lby/mkrtos-real
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

完善驱动服务，完成简单测试

Browse Source
This commit is contained in:
zhangzheng
2023-11-12 21:33:56 +08:00
parent cb6a93217d
commit 3c1c6da99a
16 changed files with 364 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
mkrtos_user/lib/sys_svr/inc/drv_cli.h Normal file
View File

@@ -0,0 +1,10 @@
#pragma once
#include <stddef.h>
#include <u_types.h>
int dev_fs_open(const char *path, uint32_t oflags);
int dev_fs_close(int desc);
int dev_fs_read(int desc, void *buf, size_t size);
int dev_fs_write(int desc, const void *buf, size_t size);
int dev_fs_ioctl(int desc, int cmd, void *args);

12
mkrtos_user/lib/sys_svr/inc/drv_svr.h Normal file
View File

@@ -0,0 +1,12 @@
#pragma once
#include <u_types.h>
#include <stddef.h>
#include <drv_types.h>
int dev_open(const char *name, uint32_t oflags);
int dev_close(int desc);
int dev_read(int desc, void *buf, size_t size);
int dev_write(int desc, const void *buf, size_t size);
int dev_ioctl(int desc, int cmd, void *args);
void drv_init(drv_t *drv);

9
mkrtos_user/lib/sys_svr/inc/drv_types.h Normal file
View File

@@ -0,0 +1,9 @@
#pragma once
#include "u_types.h"
#include "u_rpc_svr.h"
typedef struct drv
{
rpc_svr_obj_t svr;
obj_handler_t ipc;
} drv_t;

7
mkrtos_user/lib/sys_svr/inc/rpc_prot.h
View File

@@ -24,3 +24,10 @@
#define FS_CHDIR ((uint16_t)16) //!< 进入某个目录，可在客户端实现 暂不实现*
#define FS_CWDIR ((uint16_t)17) //!< 获取当前目录，可在客户端实现 暂不实现*
#define FS_MOUNT ((uint16_t)18) //!< 挂载节点 暂不实现*
#define DRV_PROT 0x0003
#define DRV_OPEN ((uint16_t)0) //!< 打开设备
#define DRV_READ ((uint16_t)1) //!< 读取设备
#define DRV_WRITE ((uint16_t)2) //!< 写入设备
#define DRV_CLOSE ((uint16_t)3) //!< 关闭设备
#define DRV_IOCTL ((uint16_t)4) //!< 控制设备

135
mkrtos_user/lib/sys_svr/src/drv_cli.c Normal file
View File

@@ -0,0 +1,135 @@
#include "u_rpc.h"
#include "u_rpc_svr.h"
#include "drv_types.h"
#include "rpc_prot.h"
#include "u_env.h"
#include "u_prot.h"
#include "u_hd_man.h"
#include <stdio.h>
#include <string.h>
#include <assert.h>
RPC_GENERATION_CALL2(drv_t, DRV_OPEN, open,
rpc_ref_array_uint32_t_uint8_t_32_t, rpc_array_uint32_t_uint8_t_32_t, RPC_DIR_IN, RPC_TYPE_DATA, name,
rpc_uint32_t_t, rpc_uint32_t_t, RPC_DIR_IN, RPC_TYPE_DATA, oflags)
RPC_GENERATION_CALL1(drv_t, DRV_CLOSE, close,
rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, desc)
RPC_GENERATION_CALL3(drv_t, DRV_READ, read,
rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, desc,
rpc_ref_array_uint32_t_uint8_t_32_t, rpc_array_uint32_t_uint8_t_32_t, RPC_DIR_OUT, RPC_TYPE_DATA, data,
rpc_uint32_t_t, rpc_uint32_t_t, RPC_DIR_IN, RPC_TYPE_DATA, size)
RPC_GENERATION_CALL3(drv_t, DRV_WRITE, write,
rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, desc,
rpc_ref_array_uint32_t_uint8_t_32_t, rpc_array_uint32_t_uint8_t_32_t, RPC_DIR_IN, RPC_TYPE_DATA, data,
rpc_uint32_t_t, rpc_uint32_t_t, RPC_DIR_IN, RPC_TYPE_DATA, size)
RPC_GENERATION_CALL3(drv_t, DRV_IOCTL, ioctl,
rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, desc,
rpc_ref_array_uint32_t_uint8_t_32_t, rpc_array_uint32_t_uint8_t_32_t, RPC_DIR_IN, RPC_TYPE_DATA, data,
rpc_uint32_t_t, rpc_uint32_t_t, RPC_DIR_IN, RPC_TYPE_DATA, size)
int dev_fs_open(const char *path, uint32_t oflags)
{
obj_handler_t hd;
int ret = ns_query(path, &hd);
if (ret < 0)
{
return ret;
}
rpc_ref_array_uint32_t_uint8_t_32_t rpc_path = {
.data = &path[ret],
.len = strlen(&path[ret]) + 1,
};
rpc_uint32_t_t rpc_flags = {
.data = oflags,
};
msg_tag_t tag = drv_t_open_call(hd, &rpc_path, &rpc_flags);
if (msg_tag_get_val(tag) < 0)
{
return msg_tag_get_val(tag);
}
return mk_sd_init2(hd, msg_tag_get_val(tag)).raw;
}
int dev_fs_close(int desc)
{
obj_handler_t hd;
int fd;
hd = mk_sd_get_hd(mk_sd_init_raw(desc));
fd = mk_sd_get_fd(mk_sd_init_raw(desc));
rpc_int_t rpc_desc = {
.data = fd,
};
msg_tag_t tag = drv_t_close_call(hd, &rpc_desc);
return msg_tag_get_val(tag);
}
int dev_fs_read(int desc, void *buf, size_t size)
{
obj_handler_t hd;
int fd;
hd = mk_sd_get_hd(mk_sd_init_raw(desc));
fd = mk_sd_get_fd(mk_sd_init_raw(desc));
rpc_int_t rpc_desc = {
.data = fd,
};
rpc_ref_array_uint32_t_uint8_t_32_t rpc_data = {
.data = buf,
.len = size,
};
rpc_size_t_t rpc_flags = {
.data = size,
};
msg_tag_t tag = drv_t_read_call(hd, &rpc_desc, &rpc_data, &rpc_flags);
return msg_tag_get_val(tag);
}
int dev_fs_write(int desc, const void *buf, size_t size)
{
obj_handler_t hd;
int fd;
hd = mk_sd_get_hd(mk_sd_init_raw(desc));
fd = mk_sd_get_fd(mk_sd_init_raw(desc));
rpc_int_t rpc_desc = {
.data = fd,
};
rpc_ref_array_uint32_t_uint8_t_32_t rpc_data = {
.data = buf,
.len = size,
};
rpc_size_t_t rpc_flags = {
.data = size,
};
msg_tag_t tag = drv_t_write_call(hd, &rpc_desc, &rpc_data, &rpc_flags);
return msg_tag_get_val(tag);
}
int dev_fs_ioctl(int desc, int cmd, void *args)
{
obj_handler_t hd;
int fd;
hd = mk_sd_get_hd(mk_sd_init_raw(desc));
fd = mk_sd_get_fd(mk_sd_init_raw(desc));
rpc_int_t rpc_desc = {
.data = fd,
};
rpc_int_t rpc_cmd = {
.data = fd,
};
rpc_umword_t_t rpc_args = {
.data = (umword_t)args,
};
msg_tag_t tag = drv_t_ioctl_call(hd, &rpc_desc, &rpc_cmd, &rpc_args);
return msg_tag_get_val(tag);
}

79
mkrtos_user/lib/sys_svr/src/drv_svr.c Normal file
View File

@@ -0,0 +1,79 @@
#include "rpc_prot.h"
#include "drv_svr.h"
#include "drv_types.h"
#include "u_rpc.h"
#include "u_rpc_svr.h"
#include "u_hd_man.h"
#include <stdio.h>
/*int mr_dev_open(const char *name, uint32_t oflags);*/
RPC_GENERATION_OP2(drv_t, DRV_OPEN, open,
rpc_ref_array_uint32_t_uint8_t_32_t, rpc_array_uint32_t_uint8_t_32_t, RPC_DIR_IN, RPC_TYPE_DATA, name,
rpc_uint32_t_t, rpc_uint32_t_t, RPC_DIR_IN, RPC_TYPE_DATA, oflags)
{
name->data[name->len - 1] = 0;
return dev_open(name->data, oflags->data);
}
RPC_GENERATION_DISPATCH2(drv_t, DRV_OPEN, open,
rpc_ref_array_uint32_t_uint8_t_32_t, rpc_array_uint32_t_uint8_t_32_t, RPC_DIR_IN, RPC_TYPE_DATA, name,
rpc_uint32_t_t, rpc_uint32_t_t, RPC_DIR_IN, RPC_TYPE_DATA, oflags)
/*int mr_dev_close(int desc);*/
RPC_GENERATION_OP1(drv_t, DRV_CLOSE, close,
rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, desc)
{
return dev_close(desc->data);
}
RPC_GENERATION_DISPATCH1(drv_t, DRV_CLOSE, close,
rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, desc)
/*ssize_t mr_dev_read(int desc, void *buf, size_t size);*/
RPC_GENERATION_OP3(drv_t, DRV_READ, read,
rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, desc,
rpc_ref_array_uint32_t_uint8_t_32_t, rpc_array_uint32_t_uint8_t_32_t, RPC_DIR_OUT, RPC_TYPE_DATA, data,
rpc_uint32_t_t, rpc_uint32_t_t, RPC_DIR_IN, RPC_TYPE_DATA, size)
{
return dev_read(desc->data, data->data, size->data);
}
RPC_GENERATION_DISPATCH3(drv_t, DRV_READ, read,
rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, desc,
rpc_ref_array_uint32_t_uint8_t_32_t, rpc_array_uint32_t_uint8_t_32_t, RPC_DIR_OUT, RPC_TYPE_DATA, data,
rpc_uint32_t_t, rpc_uint32_t_t, RPC_DIR_IN, RPC_TYPE_DATA, size)
/*ssize_t mr_dev_write(int desc, const void *buf, size_t size);*/
RPC_GENERATION_OP3(drv_t, DRV_WRITE, write,
rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, desc,
rpc_ref_array_uint32_t_uint8_t_32_t, rpc_array_uint32_t_uint8_t_32_t, RPC_DIR_IN, RPC_TYPE_DATA, data,
rpc_uint32_t_t, rpc_uint32_t_t, RPC_DIR_IN, RPC_TYPE_DATA, size)
{
return dev_write(desc->data, data->data, size->data);
}
RPC_GENERATION_DISPATCH3(drv_t, DRV_WRITE, write,
rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, desc,
rpc_ref_array_uint32_t_uint8_t_32_t, rpc_array_uint32_t_uint8_t_32_t, RPC_DIR_IN, RPC_TYPE_DATA, data,
rpc_uint32_t_t, rpc_uint32_t_t, RPC_DIR_IN, RPC_TYPE_DATA, size)
/*int mr_dev_ioctl(int desc, int cmd, void *args);*/
RPC_GENERATION_OP3(drv_t, DRV_IOCTL, ioctl,
rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, desc,
rpc_ref_array_uint32_t_uint8_t_32_t, rpc_array_uint32_t_uint8_t_32_t, RPC_DIR_IN, RPC_TYPE_DATA, data,
rpc_uint32_t_t, rpc_uint32_t_t, RPC_DIR_IN, RPC_TYPE_DATA, size)
{
return dev_ioctl(desc->data, data->data, size->data);
}
RPC_GENERATION_DISPATCH3(drv_t, DRV_IOCTL, ioctl,
rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, desc,
rpc_ref_array_uint32_t_uint8_t_32_t, rpc_array_uint32_t_uint8_t_32_t, RPC_DIR_IN, RPC_TYPE_DATA, data,
rpc_uint32_t_t, rpc_uint32_t_t, RPC_DIR_IN, RPC_TYPE_DATA, size)
/*dispatch*/
RPC_DISPATCH5(drv_t, typeof(DRV_OPEN), DRV_OPEN, open, DRV_CLOSE, close, DRV_READ, read, DRV_WRITE, write, DRV_IOCTL, ioctl)
void drv_init(drv_t *drv)
{
rpc_svr_obj_init(&drv->svr, rpc_drv_t_dispatch, DRV_PROT);
}

4
mkrtos_user/lib/sys_svr/src/ns_svr.c
View File

@@ -37,11 +37,11 @@ RPC_GENERATION_OP2(ns_t, NS_QUERY_OP, query,
int ret = namespace_query((char *)(path->data), &cli_hd->data);
if (ret >= 0)
{
printf("The request service [%s] was successful.", (char *)(path->data));
printf("The request service [%s] was successful.\n", (char *)(path->data));
}
else
{
printf("Failed to request service [%s]", (char *)(path->data));
printf("Failed to request service [%s]\n", (char *)(path->data));
}
return ret;
}

3
mkrtos_user/lib/sys_util/inc/u_rpc.h
View File

@@ -179,6 +179,9 @@ static inline void rpc_memcpy(void *dst, void *src, size_t size)
RPC_CLI_TYPE_TRAN_TO_SVR_TYPE(rpc_##type##_t, rpc_##type##_t)
RPC_TYPE_DEF_ALL(int) //!< 定义所有的
RPC_TYPE_DEF_ALL(uint32_t) //!< 定义所有的
RPC_TYPE_DEF_ALL(size_t) //!< 定义所有的
RPC_TYPE_DEF_ALL(umword_t) //!< 定义所有的
RPC_TYPE_DEF_ALL(dirent_t) //!< 目录类型
RPC_TYPE_DEF_ALL(stat_t)

4
mkrtos_user/server/drv/mr_drv/inc/drv_rpc.h Normal file
View File

@@ -0,0 +1,4 @@
#pragma once
#include <u_types.h>
void drv_svr_init(obj_handler_t ipc);
void drv_svr_loop(void);

45
mkrtos_user/server/drv/mr_drv/src/drv_rpc.c Normal file
View File

@@ -0,0 +1,45 @@
#include <drv_svr.h>
#include <mr_api.h>
#include <drv_types.h>
#include "drv_rpc.h"
static drv_t drv;
void drv_svr_init(obj_handler_t ipc)
{
drv_init(&drv);
drv.ipc = ipc;
}
int dev_open(const char *name, uint32_t oflags)
{
printf("%s:%d\n", __func__, __LINE__);
return mr_dev_open(name[0] == '/' ? name + 1 : name, oflags);
}
int dev_close(int desc)
{
printf("%s:%d\n", __func__, __LINE__);
return mr_dev_close(desc);
}
int dev_read(int desc, void *buf, size_t size)
{
printf("%s:%d\n", __func__, __LINE__);
return mr_dev_read(desc, buf, size);
}
int dev_write(int desc, const void *buf, size_t size)
{
printf("%s:%d\n", __func__, __LINE__);
return mr_dev_write(desc, buf, size);
}
int dev_ioctl(int desc, int cmd, void *args)
{
printf("%s:%d\n", __func__, __LINE__);
return mr_dev_ioctl(desc, cmd, args);
}
void drv_svr_loop(void)
{
rpc_loop(drv.ipc, &drv.svr);
}

21
mkrtos_user/server/drv/mr_drv/src/main.c
View File

@@ -1,9 +1,24 @@
#include "drv_rpc.h"
#include <u_types.h>
#include <u_prot.h>
#include <assert.h>
#include <ns_cli.h>
#include <stdio.h>
#include <u_factory.h>
#include <u_rpc_svr.h>
#include <mr_api.h>
int main(int argc, char *args[])
{
obj_handler_t ipc_hd;
int ret;
printf("mr drv init...\n");
ret = rpc_creaite_bind_ipc(THREAD_MAIN, NULL, &ipc_hd);
assert(ret >= 0);
ns_register("/dev", ipc_hd);
printf("mr drv start success...\n");
mr_auto_init();
drv_svr_init(ipc_hd);
drv_svr_loop();
return 0;
}

21
mkrtos_user/server/hello/src/main.c
View File

@@ -2,12 +2,33 @@
// #include <stdio.h>
#include "u_log.h"
#include "u_env.h"
#include "u_sleep.h"
#include "drv_cli.h"
#include <mr_api.h>
#include <assert.h>
void drv_test(void)
{
char data[10] = "mkrtos..\n";
int fd = dev_fs_open("/dev/uart1", MR_OFLAG_RDWR);
assert(fd > 0);
int ret = dev_fs_read(fd, data, sizeof(data));
assert(ret >= 0);
printf("%s:%d data:%s.\n", __func__, __LINE__, data);
ret = dev_fs_write(fd, data, sizeof(data));
assert(ret >= 0);
dev_fs_close(fd);
}
int main(int argc, char *args[])
{
u_sleep_init();
u_sleep_ms(100);
// printf("Hello world.\n");
ulog_write_str(u_get_global_env()->log_hd, "hello is runing...\n");
drv_test();
ulog_write_str(u_get_global_env()->log_hd, "Hello world.\n");
return 0;
}

17
mkrtos_user/server/init/src/main.c
View File

@@ -44,24 +44,29 @@ int main(int argc, char *args[])
env.ns_hd = ipc_hd;
namespace_init(ipc_hd);
u_sleep_init();
ret = app_load("mr_drv", &env);
if (ret < 0)
{
printf("%s load fail, 0x%x\n", "mr_drv", ret);
}
ret = app_load("hello", &env);
if (ret < 0)
{
printf("%s load fail, 0x%x\n", "hello", ret);
}
// ret = app_load("app", &env);
// if (ret < 0)
// {
// printf("app load fail, 0x%x\n", ret);
// // ulog_write_str(LOG_PROT, "app load fail.\n");
// }
ret = app_load("mr_drv", &env);
if (ret < 0)
{
printf("app load fail, 0x%x\n", ret);
}
// ret = app_load("fatfs", &env);
// if (ret < 0)
// {
// printf("app load fail, 0x%x\n", ret);
// }
// u_sleep_ms(500);
// u_sleep_ms(500);
namespace_pre_alloc_map_fd();
namespace_loop();