diff --git a/.vscode/settings.json b/.vscode/settings.json index aed666c9e..48bb73497 100755 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -129,7 +129,11 @@ "at32f435_437_crm.h": "c", "mk_char_dev.h": "c", "unistd.h": "c", - "stat.h": "c" + "stat.h": "c", + "mk_drv.h": "c", + "mk_display_drv_impl.h": "c", + "at_surf_f437_board_font.h": "c", + "infones_types.h": "c" }, "cortex-debug.showRTOS": false, "cortex-debug.variableUseNaturalFormat": false, diff --git a/armv7_8.cmake b/armv7_8.cmake index 9a3d63b48..2aa5cda78 100644 --- a/armv7_8.cmake +++ b/armv7_8.cmake @@ -1,6 +1,6 @@ message("========use armv7_8.cmake") -set(CMAKE_C_FLAGS "-mcpu=${CONFIG_ARCH} -O0 -g3 -mfloat-abi=${CONFIG_FLOAT_TYPE} -mthumb -D=MKRTOS \ +set(CMAKE_C_FLAGS "-mcpu=${CONFIG_ARCH} -O3 -g3 -mfloat-abi=${CONFIG_FLOAT_TYPE} -mthumb -D=MKRTOS \ -std=gnu11 -ffunction-sections -fdata-sections -fno-builtin -u=_printf_float \ -nostartfiles -nodefaultlibs -nostdlib -nostdinc -Xlinker \ -fno-stack-protector -Wl,--gc-sections -D__ARM_ARCH_7M__ \ diff --git a/mkrtos_configs/ATSURFF437.dts b/mkrtos_configs/ATSURFF437.dts index 1b9938fbb..1763f0db9 100644 --- a/mkrtos_configs/ATSURFF437.dts +++ b/mkrtos_configs/ATSURFF437.dts @@ -12,10 +12,18 @@ pin { compatible = "at32f43x,pin"; regs = < - 0x40020000 0x2000 /*GPIO*/ - 0x40013800 0x400 /*EXINT & SCFG*/ - 0x40013C00 0x400 /*EXINT & SCFG*/ - 0x40023800 0x400 /*CRM*/ + 0x40020000 0x2000 /*GPIO*/ + 0x40013800 0x400 /*EXINT & SCFG*/ + 0x40013C00 0x400 /*EXINT & SCFG*/ + 0x40023800 0x400 /*CRM*/ + >; + }; + disp { + compatible = "at32f43x,lcd"; + regs = < + 0xA0000000 0x1000 /*XMC_REG*/ + 0x40023800 0x400 /*CRM*/ + 0x60000000 0x100000 /*XMC_MEM*/ >; }; }; diff --git a/mkrtos_configs/STM32F205.dts b/mkrtos_configs/STM32F205.dts index 7f1568c48..1763f0db9 100644 --- a/mkrtos_configs/STM32F205.dts +++ b/mkrtos_configs/STM32F205.dts @@ -15,6 +15,15 @@ 0x40020000 0x2000 /*GPIO*/ 0x40013800 0x400 /*EXINT & SCFG*/ 0x40013C00 0x400 /*EXINT & SCFG*/ + 0x40023800 0x400 /*CRM*/ + >; + }; + disp { + compatible = "at32f43x,lcd"; + regs = < + 0xA0000000 0x1000 /*XMC_REG*/ + 0x40023800 0x400 /*CRM*/ + 0x60000000 0x100000 /*XMC_MEM*/ >; }; }; diff --git a/mkrtos_knl/knl/task.c b/mkrtos_knl/knl/task.c index 8a5c8c207..63c626e03 100755 --- a/mkrtos_knl/knl/task.c +++ b/mkrtos_knl/knl/task.c @@ -21,6 +21,7 @@ #include "spinlock.h" #include "string.h" #include "thread.h" +#include "thread_arch.h" #if IS_ENABLED(CONFIG_MMU) #include "arch.h" #endif @@ -38,6 +39,7 @@ enum task_op_code TASK_GET_PID, //!< 获取task的pid TASK_COPY_DATA, //!< 拷贝数据到task的数据区域 TASK_SET_OBJ_NAME, //!< 设置对象的名字 + TASK_COPY_DATA_TO, //!< 从当前task拷贝数据到目的task }; static bool_t task_put(kobject_t *kobj); static void task_release_stage1(kobject_t *kobj); @@ -343,6 +345,56 @@ static void task_syscall_func(kobject_t *kobj, syscall_prot_t sys_p, msg_tag_t i tag = msg_tag_init4(0, 0, 0, 0); } break; + case TASK_COPY_DATA_TO: //!< 从当前task拷贝到目的task + { + int st0, st1; + int ret = 0; + obj_handler_t dst_task_hd; + addr_t src_addr; + addr_t dst_addr; + size_t copy_len; + int suc; + + dst_task_hd = f->regs[0]; + src_addr = f->regs[1]; + dst_addr = f->regs[2]; + copy_len = f->regs[3]; + kobject_t *source_kobj = obj_space_lookup_kobj_cmp_type(&cur_task->obj_space, dst_task_hd, TASK_TYPE); + + if (!source_kobj) + { + ret = -EINVAL; + goto copy_data_to_end; + } + task_t *dst_task_obj = container_of(source_kobj, task_t, kobj); + + suc = task_lock_2(&tag_task->kobj.lock, &dst_task_obj->kobj.lock, &st0, &st1); + if (!suc) + { + tag = msg_tag_init4(0, 0, 0, -EINVAL); + break; + } + if (!is_rw_access(tag_task, (void *)src_addr, copy_len, FALSE)) + { + ret = -EPERM; + goto copy_data_to_end; + } + if (!is_rw_access(dst_task_obj, (void *)dst_addr, copy_len, FALSE)) + { + ret = -EPERM; + goto copy_data_to_end; + } + + paddr_t src_paddr = (paddr_t)task_get_currnt_paddr((vaddr_t)src_addr); + paddr_t dst_paddr = (paddr_t)task_get_currnt_paddr((vaddr_t)dst_addr); + + memcpy((void *)dst_paddr, (void *)src_paddr, copy_len); + + copy_data_to_end: + task_unlock_2(&tag_task->kobj.lock, &dst_task_obj->kobj.lock, st0, st1); + tag = msg_tag_init4(0, 0, 0, ret); + } + break; default: break; } @@ -371,7 +423,7 @@ void task_init(task_t *task, ram_limit_t *ram, int is_knl) knl_pdir_init(&task->mm_space.mem_dir, task->mm_space.mem_dir.dir, 3 /*TODO:*/); #else assert(task_vma_alloc(&task->mm_space.mem_vma, vma_addr_create(VPAGE_PROT_RO, 0, 0), - align_power_of_2(CONFIG_SYS_TEXT_SIZE), CONFIG_SYS_TEXT_ADDR, NULL) >=0 ); + align_power_of_2(CONFIG_SYS_TEXT_SIZE), CONFIG_SYS_TEXT_ADDR, NULL) >= 0); #endif } diff --git a/mkrtos_knl/knl/thread.c b/mkrtos_knl/knl/thread.c index 5b71f7c5b..e82044b75 100755 --- a/mkrtos_knl/knl/thread.c +++ b/mkrtos_knl/knl/thread.c @@ -913,7 +913,8 @@ again:; if (to->status != THREAD_SUSPEND || to->ipc_status != THREAD_RECV) { /*TODO:这里应该挂起等待*/ - if (to->ipc_status == THREAD_IPC_ABORT) { + if (to->ipc_status == THREAD_IPC_ABORT) + { ref_counter_dec_and_release(&to->ref, &to->kobj); return -ECANCELED; } @@ -1440,8 +1441,8 @@ static void thread_syscall(kobject_t *kobj, syscall_prot_t sys_p, #else if (!slist_in_list(&tag_th->sche.node)) { + tag_th->sche.prio = tge_prio; thread_ready(tag_th, TRUE); - } else { diff --git a/mkrtos_user/lib/sys/inc/u_task.h b/mkrtos_user/lib/sys/inc/u_task.h index d2f24d26d..5de37a8de 100644 --- a/mkrtos_user/lib/sys/inc/u_task.h +++ b/mkrtos_user/lib/sys/inc/u_task.h @@ -15,3 +15,4 @@ msg_tag_t task_map(obj_handler_t dst_task, obj_handler_t src_obj, obj_handler_t msg_tag_t task_unmap(obj_handler_t task_han, vpage_t vpage); msg_tag_t task_alloc_ram_base(obj_handler_t task_han, umword_t size, addr_t *alloc_addr); msg_tag_t task_copy_data(obj_handler_t task_obj, void *st_addr, umword_t size); +msg_tag_t task_copy_data_to(obj_handler_t task_obj, obj_handler_t dst_task_obj, void *st_addr, void *dst_addr, umword_t size); diff --git a/mkrtos_user/lib/sys/src/u_task.c b/mkrtos_user/lib/sys/src/u_task.c index 57778dc49..6c55b84b0 100644 --- a/mkrtos_user/lib/sys/src/u_task.c +++ b/mkrtos_user/lib/sys/src/u_task.c @@ -3,7 +3,8 @@ #include "u_prot.h" #include "u_types.h" -enum task_op_code { +enum task_op_code +{ TASK_OBJ_MAP, TASK_OBJ_UNMAP, TASK_ALLOC_RAM_BASE, @@ -12,6 +13,7 @@ enum task_op_code { TASK_GET_PID, TASK_COPY_DATA, TASK_SET_OBJ_NAME, + TASK_COPY_DATA_TO, //!< 从当前task拷贝数据到目的task }; msg_tag_t task_set_obj_name(obj_handler_t dst_task, obj_handler_t obj, const char *name) @@ -68,7 +70,8 @@ msg_tag_t task_get_pid(obj_handler_t dst_task, umword_t *pid) : : : ARCH_REG_0, ARCH_REG_1); - if (pid) { + if (pid) + { *pid = r1; } @@ -90,7 +93,8 @@ msg_tag_t task_obj_valid(obj_handler_t dst_task, obj_handler_t obj_inx, int *obj : : : ARCH_REG_0); - if (obj_type) { + if (obj_type) + { *obj_type = r1; } @@ -148,7 +152,8 @@ msg_tag_t task_alloc_ram_base(obj_handler_t task_han, umword_t size, addr_t *all : : : ARCH_REG_0, ARCH_REG_1); - if (alloc_addr) { + if (alloc_addr) + { *alloc_addr = r1; } @@ -172,3 +177,21 @@ msg_tag_t task_copy_data(obj_handler_t task_obj, void *st_addr, umword_t size) return msg_tag_init(r0); } +msg_tag_t task_copy_data_to(obj_handler_t task_obj, obj_handler_t dst_task_obj, void *st_addr, void *dst_addr, umword_t size) +{ + register volatile umword_t r0 asm(ARCH_REG_0); + + mk_syscall(syscall_prot_create(TASK_COPY_DATA_TO, TASK_PROT, task_obj).raw, + dst_task_obj, + st_addr, + dst_addr, + size, + 0, + 0); + asm __volatile__("" + : + : + : ARCH_REG_0, ARCH_REG_1); + + return msg_tag_init(r0); +} diff --git a/mkrtos_user/lib/sys_svr/inc/pm_cli.h b/mkrtos_user/lib/sys_svr/inc/pm_cli.h index 43db4ffbd..934764478 100644 --- a/mkrtos_user/lib/sys_svr/inc/pm_cli.h +++ b/mkrtos_user/lib/sys_svr/inc/pm_cli.h @@ -7,3 +7,4 @@ int pm_run_app(const char *path, int flags); int pm_kill_task(int pid, int flags); int pm_watch_pid(obj_handler_t sig_hd, pid_t pid, int flags); +int pm_copy_data(pid_t src_pid, pid_t dst_pid, addr_t src_addr, addr_t dst_addr, size_t len); diff --git a/mkrtos_user/lib/sys_svr/inc/pm_svr.h b/mkrtos_user/lib/sys_svr/inc/pm_svr.h index 0c5c00dc4..6d6560f6d 100644 --- a/mkrtos_user/lib/sys_svr/inc/pm_svr.h +++ b/mkrtos_user/lib/sys_svr/inc/pm_svr.h @@ -10,6 +10,7 @@ */ #pragma once +#include "pm_cli.h" #include "u_rpc_svr.h" #include "u_slist.h" #include "u_types.h" @@ -34,3 +35,4 @@ void pm_svr_obj_init(pm_t *pm); int pm_rpc_run_app(const char *path, int flags); int pm_rpc_kill_task(int pid, int flags); int pm_rpc_watch_pid(pm_t *pm, obj_handler_t sig_rcv_hd, pid_t pid, int flags); +int pm_rpc_copy_data(pid_t src_pid, pid_t dst_pid, umword_t src_addr, umword_t dst_addr, size_t len); diff --git a/mkrtos_user/lib/sys_svr/inc/rpc_prot.h b/mkrtos_user/lib/sys_svr/inc/rpc_prot.h index 64a66f34b..5f73f4e48 100644 --- a/mkrtos_user/lib/sys_svr/inc/rpc_prot.h +++ b/mkrtos_user/lib/sys_svr/inc/rpc_prot.h @@ -35,10 +35,11 @@ #define META_PROT 0x0004 //!< 元协议 -#define PM_PROT 0x0005 //!< 进程管理协议 -#define PM_RUN_APP ((umword_t)0) //!< 启动应用程序 -#define PM_KILL_TASK ((umword_t)1) //!< 删除进程 -#define PM_WATCH_PID ((umword_t)2) //!< watch pid +#define PM_PROT 0x0005 //!< 进程管理协议 +#define PM_RUN_APP ((umword_t)0) //!< 启动应用程序 +#define PM_KILL_TASK ((umword_t)1) //!< 删除进程 +#define PM_WATCH_PID ((umword_t)2) //!< watch pid +#define PM_COPY_DATA ((umword_t)3) //!< copy 进程数据 #define CONS_PROT 0x0006 //!< console协议 #define CONS_WRITE ((umword_t)0) //!< console删除 diff --git a/mkrtos_user/lib/sys_svr/src/pm_cli.c b/mkrtos_user/lib/sys_svr/src/pm_cli.c index f038a4476..fc3255270 100644 --- a/mkrtos_user/lib/sys_svr/src/pm_cli.c +++ b/mkrtos_user/lib/sys_svr/src/pm_cli.c @@ -27,119 +27,10 @@ int pm_run_app(const char *path, int flags) return msg_tag_get_val(tag); } -// RPC_GENERATION_CALL2(pm_t, PM_PROT, PM_KILL_TASK, kill_task, -// rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, pid, -// rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, flags) -msg_tag_t pm_t_kill_task_call(obj_handler_t hd, rpc_int_t *var0, rpc_int_t *var1) -{ - void *buf; - ipc_msg_t *msg_ipc; - thread_msg_buf_get(2, (umword_t *)(&buf), ((void *)0)); - msg_ipc = (ipc_msg_t *)buf; - int off = 0; - int off_buf = 0; - int ret = -1; - size_t op_val = ((uint16_t)1); - rpc_memcpy(msg_ipc->msg_buf, &op_val, sizeof(op_val)); - off += rpc_align(sizeof(op_val), __alignof(((uint16_t)1))); - do - { - if (1 == 1) - { - if (1 == 1 || 1 == 4) - { - int ret = rpc_cli_msg_to_buf_rpc_int_t(var0, (uint8_t *)((uint8_t *)msg_ipc->msg_buf), off); - if (ret < 0) - { - return ((msg_tag_t){.flags = (0), .msg_buf_len = (0), .map_buf_len = (0), .prot = (ret)}); - } - off = ret; - } - } - } while (0); - do - { - if (1 == 2) - { - if (1 == 1 || 1 == 4) - { - int ret = rpc_cli_msg_to_buf_rpc_int_t(var0, (uint8_t *)((uint8_t *)msg_ipc->map_buf), off_buf); - if (ret < 0) - { - return ((msg_tag_t){.flags = (0), .msg_buf_len = (0), .map_buf_len = (0), .prot = (ret)}); - } - off_buf = ret; - } - } - } while (0); - do - { - if (1 == 1) - { - if (1 == 1 || 1 == 4) - { - int ret = rpc_cli_msg_to_buf_rpc_int_t(var1, (uint8_t *)((uint8_t *)msg_ipc->msg_buf), off); - if (ret < 0) - { - return ((msg_tag_t){.flags = (0), .msg_buf_len = (0), .map_buf_len = (0), .prot = (ret)}); - } - off = ret; - } - } - } while (0); - do - { - if (1 == 2) - { - if (1 == 1 || 1 == 4) - { - int ret = rpc_cli_msg_to_buf_rpc_int_t(var1, (uint8_t *)((uint8_t *)msg_ipc->map_buf), off_buf); - if (ret < 0) - { - return ((msg_tag_t){.flags = (0), .msg_buf_len = (0), .map_buf_len = (0), .prot = (ret)}); - } - off_buf = ret; - } - } - } while (0); - msg_tag_t tag = thread_ipc_call(((msg_tag_t){.flags = (0), .msg_buf_len = ((((off) / ((sizeof(void *)))) + (((off) % ((sizeof(void *)))) ? 1 : 0))), .map_buf_len = ((((off_buf) / ((sizeof(void *)))) + (((off_buf) % ((sizeof(void *)))) ? 1 : 0))), .prot = (0x0005)}), hd, ipc_timeout_create2(0, 0)); - if (((int16_t)((tag).prot)) < 0) - { - return tag; - } - off = 0; - do - { - if (1 == 1) - { - if (1 == 2 || 1 == 4) - { - int ret = rpc_cli_buf_to_msg_rpc_int_t(var0, (uint8_t *)((uint8_t *)msg_ipc->msg_buf), off, tag.msg_buf_len * (sizeof(void *))); - if (ret < 0) - { - return ((msg_tag_t){.flags = (0), .msg_buf_len = (0), .map_buf_len = (0), .prot = (ret)}); - } - off = ret; - } - } - } while (0); - do - { - if (1 == 1) - { - if (1 == 2 || 1 == 4) - { - int ret = rpc_cli_buf_to_msg_rpc_int_t(var1, (uint8_t *)((uint8_t *)msg_ipc->msg_buf), off, tag.msg_buf_len * (sizeof(void *))); - if (ret < 0) - { - return ((msg_tag_t){.flags = (0), .msg_buf_len = (0), .map_buf_len = (0), .prot = (ret)}); - } - off = ret; - } - } - } while (0); - return tag; -} +RPC_GENERATION_CALL2(pm_t, PM_PROT, PM_KILL_TASK, kill_task, + rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, pid, + rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, flags) + int pm_kill_task(int pid, int flags) { rpc_int_t rpc_pid = { @@ -170,5 +61,33 @@ int pm_watch_pid(obj_handler_t sig_hd, pid_t pid, int flags) msg_tag_t tag = pm_t_watch_pid_call(u_get_global_env()->ns_hd, &rpc_sig_hd, &rpc_pid, &rpc_flags); + return msg_tag_get_val(tag); +} +RPC_GENERATION_CALL5(pm_t, PM_PROT, PM_COPY_DATA, copy_data, + rpc_umword_t_t, rpc_umword_t_t, RPC_DIR_IN, RPC_TYPE_DATA, src_pid, + rpc_umword_t_t, rpc_umword_t_t, RPC_DIR_IN, RPC_TYPE_DATA, dst_pid, + rpc_umword_t_t, rpc_umword_t_t, RPC_DIR_IN, RPC_TYPE_DATA, src_addr, + rpc_umword_t_t, rpc_umword_t_t, RPC_DIR_IN, RPC_TYPE_DATA, dst_addr, + rpc_umword_t_t, rpc_umword_t_t, RPC_DIR_IN, RPC_TYPE_DATA, len) +int pm_copy_data(pid_t src_pid, pid_t dst_pid, addr_t src_addr, addr_t dst_addr, size_t len) +{ + rpc_umword_t_t rpc_src_pid = { + .data = src_pid, + }; + rpc_umword_t_t rpc_dst_pid = { + .data = dst_pid, + }; + rpc_umword_t_t rpc_src_addr = { + .data = src_addr, + }; + rpc_umword_t_t rpc_dst_addr = { + .data = dst_addr, + }; + rpc_umword_t_t rpc_len = { + .data = len, + }; + msg_tag_t tag = pm_t_copy_data_call(u_get_global_env()->ns_hd, &rpc_src_pid, &rpc_dst_pid, + &rpc_src_addr, &rpc_dst_addr, &rpc_len); + return msg_tag_get_val(tag); } \ No newline at end of file diff --git a/mkrtos_user/lib/sys_svr/src/pm_svr.c b/mkrtos_user/lib/sys_svr/src/pm_svr.c index 61b317dd7..194ac0a52 100644 --- a/mkrtos_user/lib/sys_svr/src/pm_svr.c +++ b/mkrtos_user/lib/sys_svr/src/pm_svr.c @@ -62,8 +62,32 @@ RPC_GENERATION_DISPATCH3(pm_t, PM_PROT, PM_WATCH_PID, watch_pid, rpc_obj_handler_t_t, rpc_obj_handler_t_t, RPC_DIR_IN, RPC_TYPE_BUF, sig_hd, rpc_umword_t_t, rpc_umword_t_t, RPC_DIR_IN, RPC_TYPE_DATA, pid, rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, flags) +/*PM_COPY_TO_DATA*/ +RPC_GENERATION_OP5(pm_t, PM_PROT, PM_COPY_DATA, copy_data, + rpc_umword_t_t, rpc_umword_t_t, RPC_DIR_IN, RPC_TYPE_DATA, src_pid, + rpc_umword_t_t, rpc_umword_t_t, RPC_DIR_IN, RPC_TYPE_DATA, dst_pid, + rpc_umword_t_t, rpc_umword_t_t, RPC_DIR_IN, RPC_TYPE_DATA, src_addr, + rpc_umword_t_t, rpc_umword_t_t, RPC_DIR_IN, RPC_TYPE_DATA, dst_addr, + rpc_umword_t_t, rpc_umword_t_t, RPC_DIR_IN, RPC_TYPE_DATA, len) +{ + int16_t ret = 0; + + ret = pm_rpc_copy_data(src_pid->data, dst_pid->data, src_addr->data, dst_addr->data, len->data); + return ret; +} + +RPC_GENERATION_DISPATCH5(pm_t, PM_PROT, PM_COPY_DATA, copy_data, + rpc_umword_t_t, rpc_umword_t_t, RPC_DIR_IN, RPC_TYPE_DATA, src_pid, + rpc_umword_t_t, rpc_umword_t_t, RPC_DIR_IN, RPC_TYPE_DATA, dst_pid, + rpc_umword_t_t, rpc_umword_t_t, RPC_DIR_IN, RPC_TYPE_DATA, src_addr, + rpc_umword_t_t, rpc_umword_t_t, RPC_DIR_IN, RPC_TYPE_DATA, dst_addr, + rpc_umword_t_t, rpc_umword_t_t, RPC_DIR_IN, RPC_TYPE_DATA, len) /*dispatch*/ -RPC_DISPATCH3(pm_t, PM_PROT, typeof(PM_RUN_APP), PM_RUN_APP, run_app, PM_KILL_TASK, kill_task, PM_WATCH_PID, watch_pid) +RPC_DISPATCH4(pm_t, PM_PROT, typeof(PM_RUN_APP), + PM_RUN_APP, run_app, + PM_KILL_TASK, kill_task, + PM_WATCH_PID, watch_pid, + PM_COPY_DATA, copy_data) void pm_svr_obj_init(pm_t *pm) { diff --git a/mkrtos_user/lib/sys_util/inc/u_rpc.h b/mkrtos_user/lib/sys_util/inc/u_rpc.h index 1a57712d5..2df47e35f 100644 --- a/mkrtos_user/lib/sys_util/inc/u_rpc.h +++ b/mkrtos_user/lib/sys_util/inc/u_rpc.h @@ -997,4 +997,5 @@ RPC_TYPE_INIT_WITHOUT_IMPL(rpc_obj_handler_t_t) } #include "u_rpc_1.h" #include "u_rpc_2.h" -#include "u_rpc_3.h" \ No newline at end of file +#include "u_rpc_3.h" +#include "u_rpc_5.h" \ No newline at end of file diff --git a/mkrtos_user/lib/sys_util/inc/u_rpc_5.h b/mkrtos_user/lib/sys_util/inc/u_rpc_5.h new file mode 100644 index 000000000..cbdd82904 --- /dev/null +++ b/mkrtos_user/lib/sys_util/inc/u_rpc_5.h @@ -0,0 +1,125 @@ +#include "u_types.h" +#include "u_thread.h" +#include "u_err.h" +#include "u_prot.h" +#include "u_ipc.h" +#include "u_task.h" +#include +#include +#include + +#define RPC_GENERATION_CALL5(struct_type, prot, op, func_name, \ + cli_type0, svr_type0, dir0, rpc_type0, name0, \ + cli_type1, svr_type1, dir1, rpc_type1, name1, \ + cli_type2, svr_type2, dir2, rpc_type2, name2, \ + cli_type3, svr_type3, dir3, rpc_type3, name3, \ + cli_type4, svr_type4, dir4, rpc_type4, name4) \ + msg_tag_t struct_type##_##func_name##_call(obj_handler_t hd, cli_type0 *var0, cli_type1 *var1, cli_type2 *var2, cli_type3 *var3, cli_type4 *var4) \ + { \ + void *buf; \ + ipc_msg_t *msg_ipc; \ + \ + thread_msg_buf_get(-1, (umword_t *)(&buf), NULL); \ + msg_ipc = (ipc_msg_t *)buf; \ + \ + int off = 0; \ + int off_buf = 0; \ + int ret = -1; \ + umword_t op_val = op; \ + /*拷贝op*/ \ + rpc_memcpy(msg_ipc->msg_buf, &op_val, __alignof(op_val)); \ + off += rpc_align(sizeof(op_val), __alignof(op)); \ + \ + RPC_CLI_MSG_TO_BUF_IN(rpc_type0, cli_type0, var0, dir0, (uint8_t *)msg_ipc->msg_buf, off); \ + PRC_CLI_FILL_MAP_BUF(rpc_type0, cli_type0, var0, dir0, (uint8_t *)msg_ipc->map_buf, off_buf); \ + RPC_CLI_MSG_TO_BUF_IN(rpc_type1, cli_type1, var1, dir1, (uint8_t *)msg_ipc->msg_buf, off); \ + PRC_CLI_FILL_MAP_BUF(rpc_type1, cli_type1, var1, dir1, (uint8_t *)msg_ipc->map_buf, off_buf); \ + RPC_CLI_MSG_TO_BUF_IN(rpc_type2, cli_type2, var2, dir2, (uint8_t *)msg_ipc->msg_buf, off); \ + PRC_CLI_FILL_MAP_BUF(rpc_type2, cli_type2, var2, dir2, (uint8_t *)msg_ipc->map_buf, off_buf); \ + RPC_CLI_MSG_TO_BUF_IN(rpc_type3, cli_type3, var3, dir3, (uint8_t *)msg_ipc->msg_buf, off); \ + PRC_CLI_FILL_MAP_BUF(rpc_type3, cli_type3, var3, dir3, (uint8_t *)msg_ipc->map_buf, off_buf); \ + RPC_CLI_MSG_TO_BUF_IN(rpc_type4, cli_type4, var4, dir4, (uint8_t *)msg_ipc->msg_buf, off); \ + PRC_CLI_FILL_MAP_BUF(rpc_type4, cli_type4, var4, dir4, (uint8_t *)msg_ipc->map_buf, off_buf); \ + /*msg_tag_t tag = dispatch_test(msg_tag_init4(0, ROUND_UP(off, WORD_BYTES), ROUND_UP(off_buf, WORD_BYTES), 0), msg_ipc); */ \ + msg_tag_t tag = thread_ipc_call(msg_tag_init4(0, ROUND_UP(off, WORD_BYTES), ROUND_UP(off_buf, WORD_BYTES), prot), hd, \ + ipc_timeout_create2(0, 0)); \ + \ + if (msg_tag_get_val(tag) < 0) \ + { \ + return tag; \ + } /*拷贝返回的数据*/ \ + off = 0; \ + RPC_CLI_BUF_TO_MSG_OUT(rpc_type0, cli_type0, var0, dir0, (uint8_t *)msg_ipc->msg_buf, off, tag.msg_buf_len *WORD_BYTES); \ + RPC_CLI_BUF_TO_MSG_OUT(rpc_type1, cli_type1, var1, dir1, (uint8_t *)msg_ipc->msg_buf, off, tag.msg_buf_len *WORD_BYTES); \ + RPC_CLI_BUF_TO_MSG_OUT(rpc_type2, cli_type2, var2, dir2, (uint8_t *)msg_ipc->msg_buf, off, tag.msg_buf_len *WORD_BYTES); \ + RPC_CLI_BUF_TO_MSG_OUT(rpc_type3, cli_type3, var3, dir3, (uint8_t *)msg_ipc->msg_buf, off, tag.msg_buf_len *WORD_BYTES); \ + RPC_CLI_BUF_TO_MSG_OUT(rpc_type4, cli_type4, var4, dir4, (uint8_t *)msg_ipc->msg_buf, off, tag.msg_buf_len *WORD_BYTES); \ + return tag; \ + } + +#define RPC_GENERATION_DISPATCH5(struct_type, prot, op, func_name, \ + cli_type0, svr_type0, dir0, rpc_type0, name0, \ + cli_type1, svr_type1, dir1, rpc_type1, name1, \ + cli_type2, svr_type2, dir2, rpc_type2, name2, \ + cli_type3, svr_type3, dir3, rpc_type3, name3, \ + cli_type4, svr_type4, dir4, rpc_type4, name4) \ + msg_tag_t struct_type##_##func_name##_dispatch(struct_type *obj, msg_tag_t tag, ipc_msg_t *ipc_msg) \ + { \ + svr_type0 var0; \ + svr_type1 var1; \ + svr_type2 var2; \ + svr_type3 var3; \ + svr_type4 var4; \ + size_t op_val; \ + uint8_t *value = (uint8_t *)(ipc_msg->msg_buf); \ + int off = 0; \ + \ + RPC_TYPE_INIT_FUNC_CALL(svr_type0, &var0); \ + RPC_TYPE_INIT_FUNC_CALL(svr_type1, &var1); \ + RPC_TYPE_INIT_FUNC_CALL(svr_type2, &var2); \ + RPC_TYPE_INIT_FUNC_CALL(svr_type3, &var3); \ + RPC_TYPE_INIT_FUNC_CALL(svr_type4, &var4); \ + \ + /*取得op*/ \ + op_val = *((typeof(op) *)value); \ + if (op_val != op) \ + { \ + return msg_tag_init4(0, 0, 0, -EPROTO); \ + } \ + off += sizeof(typeof(op)); \ + off = rpc_align(off, __alignof(typeof(op))); \ + \ + RPC_SVR_BUF_TO_MSG_IN(rpc_type0, svr_type0, &var0, dir0, value, off, tag.msg_buf_len *WORD_BYTES); \ + RPC_SVR_BUF_TO_MSG_IN(rpc_type1, svr_type1, &var1, dir1, value, off, tag.msg_buf_len *WORD_BYTES); \ + RPC_SVR_BUF_TO_MSG_IN(rpc_type2, svr_type2, &var2, dir2, value, off, tag.msg_buf_len *WORD_BYTES); \ + RPC_SVR_BUF_TO_MSG_IN(rpc_type3, svr_type3, &var3, dir3, value, off, tag.msg_buf_len *WORD_BYTES); \ + RPC_SVR_BUF_TO_MSG_IN(rpc_type4, svr_type4, &var4, dir4, value, off, tag.msg_buf_len *WORD_BYTES); \ + \ + short ret_val = struct_type##_##func_name##_op(obj, &var0, &var1, &var2, &var3, &var4); \ + \ + if (ret_val < 0) \ + { \ + return msg_tag_init4(0, 0, 0, ret_val); \ + } \ + off = 0; \ + int off_map = 0; \ + RPC_SVR_MSG_TO_BUF_OUT(rpc_type0, svr_type0, &var0, dir0, value, off); \ + RPC_SVR_MSG_TO_BUF_OUT(rpc_type1, svr_type1, &var1, dir1, value, off); \ + RPC_SVR_MSG_TO_BUF_OUT(rpc_type2, svr_type2, &var2, dir2, value, off); \ + RPC_SVR_MSG_TO_BUF_OUT(rpc_type3, svr_type3, &var3, dir3, value, off); \ + RPC_SVR_MSG_TO_BUF_OUT(rpc_type4, svr_type4, &var4, dir4, value, off); \ + PRC_SVR_FILL_MAP_BUF(rpc_type0, svr_type0, &var0, dir0, ipc_msg->map_buf, off_map); \ + PRC_SVR_FILL_MAP_BUF(rpc_type1, svr_type1, &var1, dir1, ipc_msg->map_buf, off_map); \ + PRC_SVR_FILL_MAP_BUF(rpc_type2, svr_type2, &var2, dir2, ipc_msg->map_buf, off_map); \ + PRC_SVR_FILL_MAP_BUF(rpc_type3, svr_type3, &var3, dir3, ipc_msg->map_buf, off_map); \ + PRC_SVR_FILL_MAP_BUF(rpc_type4, svr_type4, &var4, dir4, ipc_msg->map_buf, off_map); \ + return msg_tag_init4(0, ROUND_UP(off, WORD_BYTES), ROUND_UP(off_map, WORD_BYTES), ret_val); \ + } + +#define RPC_GENERATION_OP5(struct_type, prot, op, func_name, \ + cli_type0, svr_type0, dir0, rpc_type0, name0, \ + cli_type1, svr_type1, dir1, rpc_type1, name1, \ + cli_type2, svr_type2, dir2, rpc_type2, name2, \ + cli_type3, svr_type3, dir3, rpc_type3, name3, \ + cli_type4, svr_type4, dir4, rpc_type4, name4) \ + short struct_type##_##func_name##_op(struct_type *obj, svr_type0 *name0, svr_type1 *name1, svr_type2 *name2, svr_type3 *name3, svr_type4 *name4) diff --git a/mkrtos_user/server/init/src/cons.c b/mkrtos_user/server/init/src/cons.c index fcd1ac6c5..ac8dab878 100644 --- a/mkrtos_user/server/init/src/cons.c +++ b/mkrtos_user/server/init/src/cons.c @@ -60,7 +60,7 @@ void console_init(void) cons_svr_obj_init(&cons_obj); meta_reg_svr_obj(&cons_obj.svr, CONS_PROT); u_thread_create(&cons_th, (char *)cons_stack + sizeof(cons_stack) - 8, NULL, console_read_func); - u_thread_run(cons_th, 16); + u_thread_run(cons_th, 3); ulog_write_str(LOG_PROT, "cons svr init...\n"); } /** diff --git a/mkrtos_user/server/init/src/init.c b/mkrtos_user/server/init/src/init.c index f418f8768..a59f1f649 100644 --- a/mkrtos_user/server/init/src/init.c +++ b/mkrtos_user/server/init/src/init.c @@ -39,7 +39,9 @@ int main(int argc, char *args[]) task_set_obj_name(TASK_THIS, TASK_THIS, "tk_init"); task_set_obj_name(TASK_THIS, THREAD_MAIN, "th_init"); - +// #if 1 +// thread_run(-1, 3); +// #endif ulog_write_str(LOG_PROT, "init..\n"); u_env_default_init(); env = u_get_global_env(); diff --git a/mkrtos_user/server/init/src/init.cfg b/mkrtos_user/server/init/src/init.cfg index 9bf0db3e1..7e1900c5a 100644 --- a/mkrtos_user/server/init/src/init.cfg +++ b/mkrtos_user/server/init/src/init.cfg @@ -5,5 +5,5 @@ # net cpiofs -m /bin pin -nes +# nes sh \ No newline at end of file diff --git a/mkrtos_user/server/init/src/pm.c b/mkrtos_user/server/init/src/pm.c index 14a8d4808..8e0b50ea6 100644 --- a/mkrtos_user/server/init/src/pm.c +++ b/mkrtos_user/server/init/src/pm.c @@ -17,6 +17,7 @@ #include "u_task.h" #include "u_hd_man.h" #include "u_sig.h" +#include "pm.h" #include #include #include @@ -224,3 +225,22 @@ int pm_rpc_run_app(const char *path, int flags) } } } +/** + * @brief 用于拷贝数据 + * + * @param src_pid + * @param dst_pid + * @param src_addr + * @param dst_addr + * @param len + * @return int + */ +int pm_rpc_copy_data(pid_t src_pid, pid_t dst_pid, umword_t src_addr, umword_t dst_addr, size_t len) +{ + msg_tag_t tag; + + tag = task_copy_data_to(pm_hd2pid(src_pid), pm_hd2pid(dst_pid), + (void *)src_addr, (void *)dst_addr, len); + + return msg_tag_get_val(tag); +} diff --git a/mkrtos_user/server/init/src/pm.h b/mkrtos_user/server/init/src/pm.h index 5919f4b7b..f74d21706 100644 --- a/mkrtos_user/server/init/src/pm.h +++ b/mkrtos_user/server/init/src/pm.h @@ -1,13 +1,19 @@ /** * @file pm.h * @author ATShining (1358745329@qq.com) - * @brief + * @brief * @version 0.1 * @date 2023-11-28 - * + * * @copyright Copyright (c) 2023 - * + * */ #pragma once +#include void pm_init(void); + +static inline obj_handler_t pm_hd2pid(pid_t _pid) +{ + return (obj_handler_t)_pid; +} diff --git a/mkrtos_user/server/shell/src/main.c b/mkrtos_user/server/shell/src/main.c index 868fecdd7..f149b55f8 100644 --- a/mkrtos_user/server/shell/src/main.c +++ b/mkrtos_user/server/shell/src/main.c @@ -11,6 +11,9 @@ int main(int argc, char *args[]) { task_set_obj_name(TASK_THIS, TASK_THIS, "tk_sh"); task_set_obj_name(TASK_THIS, THREAD_MAIN, "th_sh"); +#if 1 + thread_run(-1, 3); +#endif for (int i = 0; i < argc; i++) { printf("args[%d]:%s\n", i, args[i]); diff --git a/mkrtos_user/user/app/ATSURFF437/drv_test/CMakeLists.txt b/mkrtos_user/user/app/ATSURFF437/drv_test/CMakeLists.txt index b78466973..47bbeb2a9 100644 --- a/mkrtos_user/user/app/ATSURFF437/drv_test/CMakeLists.txt +++ b/mkrtos_user/user/app/ATSURFF437/drv_test/CMakeLists.txt @@ -32,6 +32,10 @@ target_include_directories( ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/sys_svr/inc ${CMAKE_CURRENT_SOURCE_DIR}/ + + ${CMAKE_SOURCE_DIR}/mkrtos_user/user/drv/lib/mk_pin + ${CMAKE_SOURCE_DIR}/mkrtos_user/user/drv/lib/mk_drv + ${CMAKE_SOURCE_DIR}/mkrtos_user/user/drv/lib/mk_display ) add_dependencies( drv_test.elf diff --git a/mkrtos_user/user/app/ATSURFF437/drv_test/main.c b/mkrtos_user/user/app/ATSURFF437/drv_test/main.c index 5aa4ed607..4bfe1b424 100644 --- a/mkrtos_user/user/app/ATSURFF437/drv_test/main.c +++ b/mkrtos_user/user/app/ATSURFF437/drv_test/main.c @@ -8,43 +8,16 @@ #include #include #include +#include "mk_pin_drv.h" +#include "mk_display_drv.h" +#include +#define PIN_TEST 0 void delay_ms(int ms) { u_sleep_ms(ms); } -typedef union mk_pin_cfg +static int_fast16_t pin_test(void) { - struct - { - uint16_t mode; - uint16_t pin; - }; - uint32_t cfg_raw; -} mk_pin_cfg_t; -enum mk_pin_mode -{ - MK_PIN_MODE_NONE = 1, - MK_PIN_MODE_OUTPUT, - MK_PIN_MODE_OUTPUT_OD, - MK_PIN_MODE_INPUT, - MK_PIN_MODE_INPUT_DOWN, - MK_PIN_MODE_INPUT_UP, - - MK_PIN_MODE_IRQ_RISING, - MK_PIN_MODE_IRQ_FALLING, - MK_PIN_MODE_IRQ_EDGE, - MK_PIN_MODE_IRQ_LOW, - MK_PIN_MODE_IRQ_HIGH, -}; -enum mk_pin_ioctl_op -{ - MK_PIN_SET_MODE, //!< 设置模式 - MK_PIN_GET_MODE, //!< 获取模式 - MK_PIN_SET_OP_PIN, //!< 设置要操作的引脚，标记读写的起始引脚 -}; -int main(int argc, char *argv[]) -{ - printf("drv test init..\n"); int fd = open("/pin", O_RDWR, 0777); int ret; @@ -54,14 +27,15 @@ int main(int argc, char *argv[]) } ioctl(fd, MK_PIN_SET_MODE, ((mk_pin_cfg_t){ - .mode = MK_PIN_MODE_OUTPUT, - .pin = 12, - }) - .cfg_raw); - ret = ioctl(fd, MK_PIN_GET_MODE, ((mk_pin_cfg_t){ - .pin = 12, - }) - .cfg_raw); + .mode = MK_PIN_MODE_OUTPUT, + .pin = 12, + .cfg = 0, + }) + .cfg_raw); + ret = ioctl(fd, MK_PIN_GET_MODE, ((mk_pin_cfg_t){ + .pin = 12, + }) + .cfg_raw); printf("ret = %d\n", ret); assert(MK_PIN_MODE_OUTPUT == ret); uint8_t val = 1; @@ -83,4 +57,57 @@ int main(int argc, char *argv[]) lseek(fd, 12, SEEK_SET); write(fd, &val, 1); } + return 0; +} +static int display_test(void) +{ + mk_display_cfg_t info; + int fd = open("/display", O_RDWR, 0777); + int ret; + + if (fd < 0) + { + return fd; + } + ioctl(fd, MK_DISPLAY_SET_WIN, &((mk_display_win_t){ + .x = 0, + .y = 0, + .w = 240, + .h = 320, + })); + ioctl(fd, MK_DISPLAY_GET_INFO, &info); + printf("display addr:0x%x\n", info.display_addr); + msg_tag_t tag; + addr_t addr; + tag = u_vmam_alloc(VMA_PROT, vma_addr_create(VPAGE_PROT_RWX, 0, 0), + 512, info.display_addr, &addr); + if (msg_tag_get_val(tag) < 0) + { + printf("periph mem alloc failed..\n"); + return -1; + } + int j = 0; + while (1) + { + for (int i = 0; i < 230; i++) + { + for (int i = 0; i < 320; i++) + { + *(volatile uint16_t *)(info.display_addr) = j++; + } + } + } + return 0; +} +int main(int argc, char *argv[]) +{ + printf("drv test init..\n"); +#if PIN_TEST + pin_test(); +#endif + display_test(); + while (1) + { + u_sleep_ms(10000000); + } } diff --git a/mkrtos_user/user/app/ATSURFF437/nes_simulator/CMakeLists.txt b/mkrtos_user/user/app/ATSURFF437/nes_simulator/CMakeLists.txt index 31f44167d..2168c37c4 100644 --- a/mkrtos_user/user/app/ATSURFF437/nes_simulator/CMakeLists.txt +++ b/mkrtos_user/user/app/ATSURFF437/nes_simulator/CMakeLists.txt @@ -56,6 +56,8 @@ target_include_directories( ${CMAKE_CURRENT_SOURCE_DIR}/infoNES ${CMAKE_CURRENT_SOURCE_DIR}/mapper ${CMAKE_CURRENT_SOURCE_DIR}/ports + ${CMAKE_SOURCE_DIR}/mkrtos_user/user/drv/lib/mk_drv + ${CMAKE_SOURCE_DIR}/mkrtos_user/user/drv/lib/mk_display ) add_dependencies( nes.elf diff --git a/mkrtos_user/user/app/ATSURFF437/nes_simulator/main.c b/mkrtos_user/user/app/ATSURFF437/nes_simulator/main.c index 936265236..bb2c68e65 100644 --- a/mkrtos_user/user/app/ATSURFF437/nes_simulator/main.c +++ b/mkrtos_user/user/app/ATSURFF437/nes_simulator/main.c @@ -1,16 +1,23 @@ #include #include -#include -#include +// #include +// #include #include #include #include +#include +#include +#include +#include #ifndef INFONES #include #else #include #endif +#include "mk_display_drv.h" +static mk_display_cfg_t info; +static int fd; void delay_ms(int ms) { u_sleep_ms(ms); @@ -24,7 +31,7 @@ void nes_lcd_color_fill(uint16_t sx, uint16_t sy, uint16_t ex, uint16_t ey, uint width = ex - sx + 1; height = ey - sy + 1; - +#if 0 lcd_windows_set(sx, sy, ex, ey); for (i = 0; i < height; i++) @@ -34,12 +41,36 @@ void nes_lcd_color_fill(uint16_t sx, uint16_t sy, uint16_t ex, uint16_t ey, uint lcd_data_16bit_write(BGR565TORGB565(color[i * width + j])); } } +#else + ioctl(fd, MK_DISPLAY_SET_WIN, &((mk_display_win_t){ + .x = sx, + .y = sy, + .w = width, + .h = height, + })); + for (int i = 0; i < width * height; i++) + { + *(volatile uint16_t *)(info.display_addr) = BGR565TORGB565(color[i]); + } +#endif } #endif + void NES_LCD_DisplayLine(int y_axes, uint16_t *Disaplyline_buffer) { - lcd_color_fill(0, y_axes, 256, y_axes, Disaplyline_buffer); + // lcd_color_fill(0, y_axes, 256, y_axes, Disaplyline_buffer); + ioctl(fd, MK_DISPLAY_SET_WIN, &((mk_display_win_t){ + .x = 0, + .y = y_axes, + .w = 256, + .h = 1, + })); + for (int i = 0; i < 256; i++) + { + *(volatile uint16_t *)(info.display_addr) = BGR565TORGB565(Disaplyline_buffer[i]); + } } +#if 0 static int drv_iomem_init(void) { addr_t addr; @@ -67,9 +98,11 @@ static int drv_iomem_init(void) } return 0; } +#endif int main(int argc, char *argv[]) { printf("lcd drv init..\n"); +#if 0 if (drv_iomem_init() < 0) { return -1; @@ -77,7 +110,26 @@ int main(int argc, char *argv[]) lcd_init(LCD_DISPLAY_VERTICAL); lcd_clear(BLACK); -#if 0 +#endif + fd = open("/display", O_RDWR, 0777); + int ret; + + if (fd < 0) + { + return fd; + } + ioctl(fd, MK_DISPLAY_GET_INFO, &info); + printf("dis_addr:0x%x\n", info.display_addr); + msg_tag_t tag; + addr_t addr; + tag = u_vmam_alloc(VMA_PROT, vma_addr_create(VPAGE_PROT_RWX, 0, 0), + 512, info.display_addr, &addr); + if (msg_tag_get_val(tag) < 0) + { + printf("periph mem alloc failed..\n"); + return -1; + } +#if 1 thread_run(-1, 3); #endif while (1) diff --git a/mkrtos_user/user/drv/ATSURFF437/CMakeLists.txt b/mkrtos_user/user/drv/ATSURFF437/CMakeLists.txt index c845757a4..71af7bc9a 100644 --- a/mkrtos_user/user/drv/ATSURFF437/CMakeLists.txt +++ b/mkrtos_user/user/drv/ATSURFF437/CMakeLists.txt @@ -1,3 +1,4 @@ cmake_minimum_required(VERSION 3.13) add_subdirectory(pin) +add_subdirectory(display) diff --git a/mkrtos_user/user/drv/ATSURFF437/display/CMakeLists.txt b/mkrtos_user/user/drv/ATSURFF437/display/CMakeLists.txt new file mode 100644 index 000000000..f80abc508 --- /dev/null +++ b/mkrtos_user/user/drv/ATSURFF437/display/CMakeLists.txt @@ -0,0 +1,86 @@ +cmake_minimum_required(VERSION 3.13) + +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DAT32F437ZMT7 -DUSE_STDPERIPH_DRIVER -DAT_SURF_F437_V1 ") +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DAT32F437ZMT7 -DUSE_STDPERIPH_DRIVER -DAT_SURF_F437_V1 ") +set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} -DAT32F437ZMT7 -DUSE_STDPERIPH_DRIVER -DAT_SURF_F437_V1 ") + +file( + GLOB deps + ${CMAKE_SOURCE_DIR}/mkrtos_bsp/AT32/AT32F435_437_Firmware_Library_V2.2.0/libraries/drivers/src/*.c + # ${CMAKE_SOURCE_DIR}/mkrtos_bsp/AT32/AT32F435_437_Firmware_Library_V2.2.0/project/at_surf_f437_board/at_surf_f437_board_lcd.c + *.c +) + + +add_executable( + display.elf + ${deps} + ${START_SRC} +) +target_link_libraries( + display.elf + PUBLIC + -Bstatic + ${LIBC_NAME} + mk_drv + mk_display + mk_char + --whole-archive + ${START_LIB} + libc_be + sys + sys_util + sys_svr + --no-whole-archive + ${GCC_LIB_PATH}/libgcc.a +) +target_include_directories( + display.elf + PUBLIC + ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/sys/inc + ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/sys_svr/inc + ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/util/inc + + ${CMAKE_SOURCE_DIR}/mkrtos_bsp/AT32/AT32F435_437_Firmware_Library_V2.2.0/libraries/drivers/inc + ${CMAKE_SOURCE_DIR}/mkrtos_bsp/AT32/AT32F435_437_Firmware_Library_V2.2.0/libraries/cmsis/cm4/device_support + ${CMAKE_SOURCE_DIR}/mkrtos_bsp/AT32/AT32F435_437_Firmware_Library_V2.2.0/libraries/cmsis/cm4/core_support + ${CMAKE_SOURCE_DIR}/mkrtos_bsp/AT32/AT32F435_437_Firmware_Library_V2.2.0/project/at_surf_f437_board/ + ${CMAKE_SOURCE_DIR}/mkrtos_bsp/AT32/AT32F435_437_Firmware_Library_V2.2.0/middlewares/i2c_application_library + ${CMAKE_CURRENT_SOURCE_DIR}/ + + + ${CMAKE_SOURCE_DIR}/mkrtos_user/user/drv/lib/mk_display + ${CMAKE_SOURCE_DIR}/mkrtos_user/user/drv/lib/mk_pin +) +add_dependencies( + display.elf + ${START_LIB} + sys + sys_util + mk_char + mk_drv + mk_display +) +set_target_properties( + display.elf PROPERTIES LINK_FLAGS + "-T ${CMAKE_CURRENT_LIST_DIR}/${ARCH_NAME}/link.lds ${CORTEX_M_LINK_FLAGS} --gc-section -no-dynamic-linker " + #--no-warn-rwx-segments +) +add_custom_target( + display_dump ALL + COMMAND + ${CMAKE_OBJDUMP} -s -S display.elf > ${CMAKE_SOURCE_DIR}/build/output/display.S + COMMAND + ${CMAKE_READELF} -a display.elf > ${CMAKE_SOURCE_DIR}/build/output/display.txt + COMMAND + ${CMAKE_OBJCOPY} -O binary -S display.elf display.bin + COMMAND + ${CMAKE_SIZE} display.elf + COMMAND + ${CMAKE_COMMAND} -E copy display.bin ${CMAKE_SOURCE_DIR}/build/output/cpio/display + COMMAND + cp display.elf ${CMAKE_SOURCE_DIR}/build/output/display.elf +) + +add_dependencies(display_dump display.elf) + \ No newline at end of file diff --git a/mkrtos_user/user/drv/ATSURFF437/display/armv7_8m/link.lds b/mkrtos_user/user/drv/ATSURFF437/display/armv7_8m/link.lds new file mode 100644 index 000000000..34fdd0c60 --- /dev/null +++ b/mkrtos_user/user/drv/ATSURFF437/display/armv7_8m/link.lds @@ -0,0 +1,124 @@ +ENTRY(_start_) + +SECTIONS +{ + .text : { + . = ALIGN(4); + __text_start__ = .; + KEEP(*(.first)) + *(.text) + *(.text.*) + + KEEP(*(.init)) + KEEP(*(.fini)) + + /* .ctors */ + *crtbegin.o(.ctors) + *crtbegin?.o(.ctors) + *(EXCLUDE_FILE(*crtend?.o *crtend.o) .ctors) + *(SORT(.ctors.*)) + *(.ctors) + + /* .dtors */ + *crtbegin.o(.dtors) + *crtbegin?.o(.dtors) + *(EXCLUDE_FILE(*crtend?.o *crtend.o) .dtors) + *(SORT(.dtors.*)) + *(.dtors) + + *(SORT(.rodata.*)) + *(.rodata) + + KEEP(*(.eh_frame*)) + + . = ALIGN(4); + __rel_start__ = .; + *(.rel.data .rel.data.* .rel.gnu.linkonce.d.*) + __rel_end__ = .; + } + .ARM.exidx : { + . = ALIGN(4); + __exdix_start = .; + *(.ARM.exidx* .gnu.linkonce.armexidx.*) + /* This is used by the startup in order to initialize the .data secion */ + __exdix_end = .; + } + + .permissions_table : { + . = ALIGN(4); + __permissions_table_start__ = .; + KEEP(*(.permissions_table)) + __permissions_table_end__ = .; + } + + + PROVIDE(__ram_size__ = __bss_end__ - __data_start__); + .data : { + . = ALIGN(4); + __data_start__ = .; + __got_start__ = .; + *(.got) + __got_end__ = .; + . = ALIGN(4); + *(.data) + *(.data.*) + + *(vtable) + *(.data*) + + . = ALIGN(4); + /* preinit data */ + PROVIDE_HIDDEN (__preinit_array_start = .); + KEEP(*(.preinit_array)) + PROVIDE_HIDDEN (__preinit_array_end = .); + + . = ALIGN(4); + /* init data */ + PROVIDE_HIDDEN (__init_array_start = .); + KEEP(*(SORT(.init_array.*))) + KEEP(*(.init_array)) + PROVIDE_HIDDEN (__init_array_end = .); + + . = ALIGN(4); + /* finit data */ + PROVIDE_HIDDEN (__fini_array_start = .); + KEEP(*(SORT(.fini_array.*))) + KEEP(*(.fini_array)) + PROVIDE_HIDDEN (__fini_array_end = .); + + . = ALIGN(4); + _shell_command_start = .; + KEEP(*(shellCommand)) + _shell_command_end = .; + + . = ALIGN(4); + /* All data end */ + __data_end__ = .; + } + + PROVIDE(__heap_size__ = __heap_end__ - __heap_start__); + PROVIDE(__stack_size__ = __stack_end__ - __stack_start__); + .bss : { + . = ALIGN(4); + /* This is used by the startup in order to initialize the .bss secion */ + __bss_start__ = .; + *(.bss) + *(COMMON) + + . = ALIGN(4); + __heap_start__ = .; + KEEP(*(.bss.heap)) + __heap_end__ = .; + + . = ALIGN(4); + __stack_start__ = .; + KEEP(*(.bss.stack)) + __stack_end__ = .; + + *(.bss.*) + /* This is used by the startup in order to initialize the .bss secion */ + . = ALIGN(4); + __bss_end__ = .; + } + _end = .; +} diff --git a/mkrtos_user/user/drv/ATSURFF437/display/at32f435_437_conf.h b/mkrtos_user/user/drv/ATSURFF437/display/at32f435_437_conf.h new file mode 100644 index 000000000..4d0bb6570 --- /dev/null +++ b/mkrtos_user/user/drv/ATSURFF437/display/at32f435_437_conf.h @@ -0,0 +1,176 @@ +/** + ************************************************************************** + * @file at32f435_437_conf.h + * @brief at32f435_437 config header file + ************************************************************************** + * Copyright notice & Disclaimer + * + * The software Board Support Package (BSP) that is made available to + * download from Artery official website is the copyrighted work of Artery. + * Artery authorizes customers to use, copy, and distribute the BSP + * software and its related documentation for the purpose of design and + * development in conjunction with Artery microcontrollers. Use of the + * software is governed by this copyright notice and the following disclaimer. + * + * THIS SOFTWARE IS PROVIDED ON "AS IS" BASIS WITHOUT WARRANTIES, + * GUARANTEES OR REPRESENTATIONS OF ANY KIND. ARTERY EXPRESSLY DISCLAIMS, + * TO THE FULLEST EXTENT PERMITTED BY LAW, ALL EXPRESS, IMPLIED OR + * STATUTORY OR OTHER WARRANTIES, GUARANTEES OR REPRESENTATIONS, + * INCLUDING BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. + * + ************************************************************************** + */ + +/* define to prevent recursive inclusion -------------------------------------*/ +#ifndef __AT32F435_437_CONF_H +#define __AT32F435_437_CONF_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/** + * @brief in the following line adjust the value of high speed external crystal (hext) + * used in your application + * + * tip: to avoid modifying this file each time you need to use different hext, you + * can define the hext value in your toolchain compiler preprocessor. + * + */ +#if !defined HEXT_VALUE +#define HEXT_VALUE ((uint32_t)8000000) /*!< value of the high speed external crystal in hz */ +#endif + +/** + * @brief in the following line adjust the high speed external crystal (hext) startup + * timeout value + */ +#define HEXT_STARTUP_TIMEOUT ((uint16_t)0x3000) /*!< time out for hext start up */ +#define HICK_VALUE ((uint32_t)8000000) /*!< value of the high speed internal clock in hz */ +#define LEXT_VALUE ((uint32_t)32768) /*!< value of the low speed external clock in hz */ + +/* module define -------------------------------------------------------------*/ +#define CRM_MODULE_ENABLED +#define TMR_MODULE_ENABLED +#define ERTC_MODULE_ENABLED +#define GPIO_MODULE_ENABLED +#define I2C_MODULE_ENABLED +#define USART_MODULE_ENABLED +#define PWC_MODULE_ENABLED +#define CAN_MODULE_ENABLED +#define ADC_MODULE_ENABLED +#define DAC_MODULE_ENABLED +#define SPI_MODULE_ENABLED +#define EDMA_MODULE_ENABLED +#define DMA_MODULE_ENABLED +#define DEBUG_MODULE_ENABLED +#define FLASH_MODULE_ENABLED +#define CRC_MODULE_ENABLED +#define WWDT_MODULE_ENABLED +#define WDT_MODULE_ENABLED +#define EXINT_MODULE_ENABLED +#define SDIO_MODULE_ENABLED +#define XMC_MODULE_ENABLED +#define USB_MODULE_ENABLED +#define ACC_MODULE_ENABLED +#define MISC_MODULE_ENABLED +#define QSPI_MODULE_ENABLED +#define DVP_MODULE_ENABLED +#define SCFG_MODULE_ENABLED +#define EMAC_MODULE_ENABLED + +/* includes ------------------------------------------------------------------*/ +#ifdef CRM_MODULE_ENABLED +#include "at32f435_437_crm.h" +#endif +#ifdef TMR_MODULE_ENABLED +#include "at32f435_437_tmr.h" +#endif +#ifdef ERTC_MODULE_ENABLED +#include "at32f435_437_ertc.h" +#endif +#ifdef GPIO_MODULE_ENABLED +#include "at32f435_437_gpio.h" +#endif +#ifdef I2C_MODULE_ENABLED +#include "at32f435_437_i2c.h" +#endif +#ifdef USART_MODULE_ENABLED +#include "at32f435_437_usart.h" +#endif +#ifdef PWC_MODULE_ENABLED +#include "at32f435_437_pwc.h" +#endif +#ifdef CAN_MODULE_ENABLED +#include "at32f435_437_can.h" +#endif +#ifdef ADC_MODULE_ENABLED +#include "at32f435_437_adc.h" +#endif +#ifdef DAC_MODULE_ENABLED +#include "at32f435_437_dac.h" +#endif +#ifdef SPI_MODULE_ENABLED +#include "at32f435_437_spi.h" +#endif +#ifdef DMA_MODULE_ENABLED +#include "at32f435_437_dma.h" +#endif +#ifdef DEBUG_MODULE_ENABLED +#include "at32f435_437_debug.h" +#endif +#ifdef FLASH_MODULE_ENABLED +#include "at32f435_437_flash.h" +#endif +#ifdef CRC_MODULE_ENABLED +#include "at32f435_437_crc.h" +#endif +#ifdef WWDT_MODULE_ENABLED +#include "at32f435_437_wwdt.h" +#endif +#ifdef WDT_MODULE_ENABLED +#include "at32f435_437_wdt.h" +#endif +#ifdef EXINT_MODULE_ENABLED +#include "at32f435_437_exint.h" +#endif +#ifdef SDIO_MODULE_ENABLED +#include "at32f435_437_sdio.h" +#endif +#ifdef XMC_MODULE_ENABLED +#include "at32f435_437_xmc.h" +#endif +#ifdef ACC_MODULE_ENABLED +#include "at32f435_437_acc.h" +#endif +#ifdef MISC_MODULE_ENABLED +#include "at32f435_437_misc.h" +#endif +#ifdef EDMA_MODULE_ENABLED +#include "at32f435_437_edma.h" +#endif +#ifdef QSPI_MODULE_ENABLED +#include "at32f435_437_qspi.h" +#endif +#ifdef SCFG_MODULE_ENABLED +#include "at32f435_437_scfg.h" +#endif +#ifdef EMAC_MODULE_ENABLED +#include "at32f435_437_emac.h" +#endif +#ifdef DVP_MODULE_ENABLED +#include "at32f435_437_dvp.h" +#endif +#ifdef USB_MODULE_ENABLED +#include "at32f435_437_usb.h" +#endif + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/mkrtos_user/user/drv/ATSURFF437/display/at_surf_f437_lcd.c b/mkrtos_user/user/drv/ATSURFF437/display/at_surf_f437_lcd.c new file mode 100644 index 000000000..6e36b7e4c --- /dev/null +++ b/mkrtos_user/user/drv/ATSURFF437/display/at_surf_f437_lcd.c @@ -0,0 +1,1045 @@ +/** + ************************************************************************** + * @file at_surf_f437_board_lcd.c + * @brief set of firmware functions to manage leds and push-button. + * initialize delay function. + ************************************************************************** + * Copyright notice & Disclaimer + * + * The software Board Support Package (BSP) that is made available to + * download from Artery official website is the copyrighted work of Artery. + * Artery authorizes customers to use, copy, and distribute the BSP + * software and its related documentation for the purpose of design and + * development in conjunction with Artery microcontrollers. Use of the + * software is governed by this copyright notice and the following disclaimer. + * + * THIS SOFTWARE IS PROVIDED ON "AS IS" BASIS WITHOUT WARRANTIES, + * GUARANTEES OR REPRESENTATIONS OF ANY KIND. ARTERY EXPRESSLY DISCLAIMS, + * TO THE FULLEST EXTENT PERMITTED BY LAW, ALL EXPRESS, IMPLIED OR + * STATUTORY OR OTHER WARRANTIES, GUARANTEES OR REPRESENTATIONS, + * INCLUDING BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT. + * + ************************************************************************** + */ + +#include "at_surf_f437_board_lcd.h" +#include "at_surf_f437_board_delay.h" +#include "at_surf_f437_board_font.h" +#include +#include +#include +#include +#include "mk_pin_drv.h" +#include "u_sleep.h" +lcd_device_type lcddev; + +#define DEV_PIN_PATH "/pin" + +static const uint8_t lcd_pins[] = { + (3 * 16) + 14 /*GPIOD 14*/, + (3 * 16) + 15 /*GPIOD 15*/, + (3 * 16) + 0 /*GPIOD 0*/, + (3 * 16) + 1 /*GPIOD 1*/, + (4 * 16) + 7 /*GPIOE 7*/, + (4 * 16) + 8 /*GPIOE 8*/, + (4 * 16) + 9 /*GPIOE 9*/, + (4 * 16) + 10 /*GPIOE 10*/, + (4 * 16) + 11 /*GPIOE 11*/, + (4 * 16) + 12 /*GPIOE 12*/, + (4 * 16) + 13 /*GPIOE 13*/, + (4 * 16) + 14 /*GPIOE 14*/, + (4 * 16) + 15 /*GPIOE 15*/, + (3 * 16) + 8 /*GPIOD 8*/, + (3 * 16) + 9 /*GPIOD 9*/, + (3 * 16) + 10 /*GPIOD 10*/, + (3 * 16) + 7 /*GPIOD 7*/, + (3 * 16) + 5 /*GPIOD 5*/, + (3 * 16) + 4 /*GPIOD 4*/, + (6 * 16) + 0 /*GPIOG 0*/, +}; +static int pin_fd; + +void delay_ms(uint16_t nms) +{ + u_sleep_ms(nms); +} +/** + * @brief configures the xmc and gpios to interface with the lcd. + * this function must be called before any write/read operation + * on the lcd. + * @param none + * @retval none + */ +static int lcd_gpio_xmc_init(void) +{ + int ret = 0; + + gpio_init_type gpio_init_struct = {0}; + xmc_norsram_init_type xmc_norsram_init_struct; + xmc_norsram_timing_init_type rw_timing_struct, w_timing_struct; + + /* enable the gpio clock */ + // crm_periph_clock_enable(LCD_D0_GPIO_CLK, TRUE); + // crm_periph_clock_enable(LCD_D1_GPIO_CLK, TRUE); + // crm_periph_clock_enable(LCD_D2_GPIO_CLK, TRUE); + // crm_periph_clock_enable(LCD_D3_GPIO_CLK, TRUE); + // crm_periph_clock_enable(LCD_D4_GPIO_CLK, TRUE); + // crm_periph_clock_enable(LCD_D5_GPIO_CLK, TRUE); + // crm_periph_clock_enable(LCD_D6_GPIO_CLK, TRUE); + // crm_periph_clock_enable(LCD_D7_GPIO_CLK, TRUE); + // crm_periph_clock_enable(LCD_D8_GPIO_CLK, TRUE); + // crm_periph_clock_enable(LCD_D9_GPIO_CLK, TRUE); + // crm_periph_clock_enable(LCD_D10_GPIO_CLK, TRUE); + // crm_periph_clock_enable(LCD_D11_GPIO_CLK, TRUE); + // crm_periph_clock_enable(LCD_D12_GPIO_CLK, TRUE); + // crm_periph_clock_enable(LCD_D13_GPIO_CLK, TRUE); + // crm_periph_clock_enable(LCD_D14_GPIO_CLK, TRUE); + // crm_periph_clock_enable(LCD_D15_GPIO_CLK, TRUE); + // crm_periph_clock_enable(LCD_NE1_GPIO_CLK, TRUE); + // crm_periph_clock_enable(LCD_NWE_GPIO_CLK, TRUE); + // crm_periph_clock_enable(LCD_NOE_GPIO_CLK, TRUE); + // crm_periph_clock_enable(LCD_A10_GPIO_CLK, TRUE); + + /* enable the xmc clock */ + crm_periph_clock_enable(CRM_XMC_PERIPH_CLOCK, TRUE); + + pin_fd = open(DEV_PIN_PATH, O_RDWR, 0777); + + if (pin_fd < 0) + { + return pin_fd; + } + + for (int i = 0; i < ARRAY_SIZE(lcd_pins); i++) + { + ret = ioctl(pin_fd, MK_PIN_SET_MODE, ((mk_pin_cfg_t){ + .mode = MK_PIN_MODE_MUX_OUTPUT, + .pin = lcd_pins[i], + .cfg = GPIO_MUX_12, + }) + .cfg_raw); + if (ret < 0) + { + return ret; + } + } + /*-- gpio configuration ------------------------------------------------------*/ + // gpio_pin_mux_config(LCD_D0_GPIO_PORT, LCD_D0_GPIO_PINS_SOURCE, LCD_D0_GPIO_MUX); + // gpio_pin_mux_config(LCD_D1_GPIO_PORT, LCD_D1_GPIO_PINS_SOURCE, LCD_D1_GPIO_MUX); + // gpio_pin_mux_config(LCD_D2_GPIO_PORT, LCD_D2_GPIO_PINS_SOURCE, LCD_D2_GPIO_MUX); + // gpio_pin_mux_config(LCD_D3_GPIO_PORT, LCD_D3_GPIO_PINS_SOURCE, LCD_D3_GPIO_MUX); + // gpio_pin_mux_config(LCD_D4_GPIO_PORT, LCD_D4_GPIO_PINS_SOURCE, LCD_D4_GPIO_MUX); + // gpio_pin_mux_config(LCD_D5_GPIO_PORT, LCD_D5_GPIO_PINS_SOURCE, LCD_D5_GPIO_MUX); + // gpio_pin_mux_config(LCD_D6_GPIO_PORT, LCD_D6_GPIO_PINS_SOURCE, LCD_D6_GPIO_MUX); + // gpio_pin_mux_config(LCD_D7_GPIO_PORT, LCD_D7_GPIO_PINS_SOURCE, LCD_D7_GPIO_MUX); + // gpio_pin_mux_config(LCD_D8_GPIO_PORT, LCD_D8_GPIO_PINS_SOURCE, LCD_D8_GPIO_MUX); + // gpio_pin_mux_config(LCD_D9_GPIO_PORT, LCD_D9_GPIO_PINS_SOURCE, LCD_D9_GPIO_MUX); + // gpio_pin_mux_config(LCD_D10_GPIO_PORT, LCD_D10_GPIO_PINS_SOURCE, LCD_D10_GPIO_MUX); + // gpio_pin_mux_config(LCD_D11_GPIO_PORT, LCD_D11_GPIO_PINS_SOURCE, LCD_D11_GPIO_MUX); + // gpio_pin_mux_config(LCD_D12_GPIO_PORT, LCD_D12_GPIO_PINS_SOURCE, LCD_D12_GPIO_MUX); + // gpio_pin_mux_config(LCD_D13_GPIO_PORT, LCD_D13_GPIO_PINS_SOURCE, LCD_D13_GPIO_MUX); + // gpio_pin_mux_config(LCD_D14_GPIO_PORT, LCD_D14_GPIO_PINS_SOURCE, LCD_D14_GPIO_MUX); + // gpio_pin_mux_config(LCD_D15_GPIO_PORT, LCD_D15_GPIO_PINS_SOURCE, LCD_D15_GPIO_MUX); + // gpio_pin_mux_config(LCD_NE1_GPIO_PORT, LCD_NE1_GPIO_PINS_SOURCE, LCD_NE1_GPIO_MUX); + // gpio_pin_mux_config(LCD_NWE_GPIO_PORT, LCD_NWE_GPIO_PINS_SOURCE, LCD_NWE_GPIO_MUX); + // gpio_pin_mux_config(LCD_NOE_GPIO_PORT, LCD_NOE_GPIO_PINS_SOURCE, LCD_NOE_GPIO_MUX); + // gpio_pin_mux_config(LCD_A10_GPIO_PORT, LCD_A10_GPIO_PINS_SOURCE, LCD_A10_GPIO_MUX); + + /* lcd data lines configuration */ + // gpio_init_struct.gpio_mode = GPIO_MODE_MUX; + // gpio_init_struct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL; + // gpio_init_struct.gpio_pull = GPIO_PULL_NONE; + // gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER; + + // gpio_init_struct.gpio_pins = LCD_D0_GPIO_PIN; + // gpio_init(LCD_D0_GPIO_PORT, &gpio_init_struct); + + // gpio_init_struct.gpio_pins = LCD_D1_GPIO_PIN; + // gpio_init(LCD_D1_GPIO_PORT, &gpio_init_struct); + + // gpio_init_struct.gpio_pins = LCD_D2_GPIO_PIN; + // gpio_init(LCD_D2_GPIO_PORT, &gpio_init_struct); + + // gpio_init_struct.gpio_pins = LCD_D3_GPIO_PIN; + // gpio_init(LCD_D3_GPIO_PORT, &gpio_init_struct); + + // gpio_init_struct.gpio_pins = LCD_D4_GPIO_PIN; + // gpio_init(LCD_D4_GPIO_PORT, &gpio_init_struct); + + // gpio_init_struct.gpio_pins = LCD_D5_GPIO_PIN; + // gpio_init(LCD_D5_GPIO_PORT, &gpio_init_struct); + + // gpio_init_struct.gpio_pins = LCD_D6_GPIO_PIN; + // gpio_init(LCD_D6_GPIO_PORT, &gpio_init_struct); + + // gpio_init_struct.gpio_pins = LCD_D7_GPIO_PIN; + // gpio_init(LCD_D7_GPIO_PORT, &gpio_init_struct); + + // gpio_init_struct.gpio_pins = LCD_D8_GPIO_PIN; + // gpio_init(LCD_D8_GPIO_PORT, &gpio_init_struct); + + // gpio_init_struct.gpio_pins = LCD_D9_GPIO_PIN; + // gpio_init(LCD_D9_GPIO_PORT, &gpio_init_struct); + + // gpio_init_struct.gpio_pins = LCD_D10_GPIO_PIN; + // gpio_init(LCD_D10_GPIO_PORT, &gpio_init_struct); + + // gpio_init_struct.gpio_pins = LCD_D11_GPIO_PIN; + // gpio_init(LCD_D11_GPIO_PORT, &gpio_init_struct); + + // gpio_init_struct.gpio_pins = LCD_D12_GPIO_PIN; + // gpio_init(LCD_D12_GPIO_PORT, &gpio_init_struct); + + // gpio_init_struct.gpio_pins = LCD_D13_GPIO_PIN; + // gpio_init(LCD_D13_GPIO_PORT, &gpio_init_struct); + + // gpio_init_struct.gpio_pins = LCD_D14_GPIO_PIN; + // gpio_init(LCD_D14_GPIO_PORT, &gpio_init_struct); + + // gpio_init_struct.gpio_pins = LCD_D15_GPIO_PIN; + // gpio_init(LCD_D15_GPIO_PORT, &gpio_init_struct); + + // gpio_init_struct.gpio_pins = LCD_NE1_GPIO_PIN; + // gpio_init(LCD_NE1_GPIO_PORT, &gpio_init_struct); + + // gpio_init_struct.gpio_pins = LCD_NWE_GPIO_PIN; + // gpio_init(LCD_NWE_GPIO_PORT, &gpio_init_struct); + + // gpio_init_struct.gpio_pins = LCD_NOE_GPIO_PIN; + // gpio_init(LCD_NOE_GPIO_PORT, &gpio_init_struct); + + // gpio_init_struct.gpio_pins = LCD_A10_GPIO_PIN; + // gpio_init(LCD_A10_GPIO_PORT, &gpio_init_struct); + + /*-- xmc configuration ------------------------------------------------------*/ + xmc_norsram_default_para_init(&xmc_norsram_init_struct); + xmc_norsram_init_struct.subbank = XMC_BANK1_NOR_SRAM1; + xmc_norsram_init_struct.data_addr_multiplex = XMC_DATA_ADDR_MUX_DISABLE; + xmc_norsram_init_struct.device = XMC_DEVICE_SRAM; + xmc_norsram_init_struct.bus_type = XMC_BUSTYPE_16_BITS; + xmc_norsram_init_struct.burst_mode_enable = XMC_BURST_MODE_DISABLE; + xmc_norsram_init_struct.asynwait_enable = XMC_ASYN_WAIT_DISABLE; + xmc_norsram_init_struct.wait_signal_lv = XMC_WAIT_SIGNAL_LEVEL_LOW; + xmc_norsram_init_struct.wrapped_mode_enable = XMC_WRAPPED_MODE_DISABLE; + xmc_norsram_init_struct.wait_signal_config = XMC_WAIT_SIGNAL_SYN_BEFORE; + xmc_norsram_init_struct.write_enable = XMC_WRITE_OPERATION_ENABLE; + xmc_norsram_init_struct.wait_signal_enable = XMC_WAIT_SIGNAL_DISABLE; + xmc_norsram_init_struct.write_timing_enable = XMC_WRITE_TIMING_ENABLE; + xmc_norsram_init_struct.write_burst_syn = XMC_WRITE_BURST_SYN_DISABLE; + xmc_nor_sram_init(&xmc_norsram_init_struct); + + /* timing configuration */ + xmc_norsram_timing_default_para_init(&rw_timing_struct, &w_timing_struct); + rw_timing_struct.subbank = XMC_BANK1_NOR_SRAM1; + rw_timing_struct.write_timing_enable = XMC_WRITE_TIMING_ENABLE; + rw_timing_struct.addr_setup_time = 0x8; + rw_timing_struct.addr_hold_time = 0x0; + rw_timing_struct.data_setup_time = 0x8; + rw_timing_struct.bus_latency_time = 0x0; + rw_timing_struct.clk_psc = 0x0; + rw_timing_struct.data_latency_time = 0x0; + rw_timing_struct.mode = XMC_ACCESS_MODE_A; + w_timing_struct.subbank = XMC_BANK1_NOR_SRAM1; + w_timing_struct.write_timing_enable = XMC_WRITE_TIMING_ENABLE; + w_timing_struct.addr_setup_time = 0x2; + w_timing_struct.addr_hold_time = 0x0; + w_timing_struct.data_setup_time = 0x2; + w_timing_struct.bus_latency_time = 0x0; + w_timing_struct.clk_psc = 0x0; + w_timing_struct.data_latency_time = 0x0; + w_timing_struct.mode = XMC_ACCESS_MODE_A; + xmc_nor_sram_timing_config(&rw_timing_struct, &w_timing_struct); + + xmc_ext_timing_config(XMC_BANK1_NOR_SRAM1, 0, 0); + /* enable xmc_bank1_nor_sram4 */ + xmc_nor_sram_enable(XMC_BANK1_NOR_SRAM1, TRUE); + + return 0; +} + +/** + * @brief lcd data read + * @param none + * @retval data + */ +uint16_t lcd_read(void) +{ + uint16_t data; + + data = *(__IO uint16_t *)XMC_LCD_DATA; + + return data; +} + +/** + * @brief write an 16-bit command to the lcd screen + * @param data:command value to be written + * @retval none + */ +void lcd_reg_write(uint16_t data) +{ + *(__IO uint16_t *)XMC_LCD_COMMAND = data; +} + +/** + * @brief write an 16-bit data to the lcd screen + * @param data:data value to be written + * @retval none + */ +void lcd_data_write(uint16_t data) +{ + *(__IO uint16_t *)XMC_LCD_DATA = data; +} + +/** + * @brief read an 16-bit value from the lcd screen + * @param none + * @retval read value + */ +uint16_t lcd_data_read(void) +{ + return lcd_read(); +} + +/** + * @brief write data into registers + * @param lcd_reg: register address + * @param lcd_regvalue: data to be written + * @retval none + */ +void lcd_command_write(uint16_t lcd_comm, uint16_t lcd_regvalue) +{ + *(__IO uint16_t *)XMC_LCD_COMMAND = lcd_comm; + *(__IO uint16_t *)XMC_LCD_DATA = lcd_regvalue; +} + +/** + * @brief read value from specially registers + * @param lcd_reg:register address + * @retval read value + */ +void lcd_command_read(uint16_t lcd_comm, uint8_t *rval, int32_t n) +{ + lcd_reg_write(lcd_comm); + + while (n--) + { + *(rval++) = lcd_data_read(); + } +} + +/** + * @brief write gram + * @param none + * @retval none + */ +void lcd_ram_prepare_write(void) +{ + lcd_reg_write(lcddev.wramcmd); +} + +/** + * @brief read gram + * @param none + * @retval none + */ +void lcd_ram_prepare_read(void) +{ + lcd_reg_write(lcddev.rramcmd); +} + +/** + * @brief write an 16-bit command to the lcd screen + * @param data:data to be written + * @retval none + */ +void lcd_data_16bit_write(uint16_t data) +{ +#if LCD_USE8BIT_MODEL + LCD->LCD_RAM = data >> 8; + LCD->LCD_RAM = data; +#else + *(__IO uint16_t *)XMC_LCD_DATA = data; +#endif +} + +/** + * @brief transform rgb format to 565 + * @param red: color red + * @param green: color green + * @param blue: color blue + * @retval none + */ +uint16_t color_to_565(uint8_t red, uint8_t green, uint8_t blue) +{ + return ((red & 0xF8) << 8) | ((green & 0xFC) << 3) | ((blue & 0xF8) >> 3); +} + +/** + * @brief read an 16-bit value from the lcd screen + * @param none + * @retval read value + */ +uint16_t lcd_data_16bit_read(void) +{ + uint16_t r, g, b; + + r = lcd_data_read(); + delay_us(1); + + r = lcd_data_read(); + delay_us(1); + + g = lcd_data_read(); + +#if LCD_USE8BIT_MODEL + delay_us(1); + b = lcd_data_read(); +#else + b = g >> 8; + g = r & 0xFF; + r = r >> 8; +#endif + + return color_to_565(r, g, b); +} + +/** + * @brief write a pixel data at a specified location + * @param x:the x coordinate of the pixel + * @param y:the y coordinate of the pixel + * @param color:the color of the pixel + * @retval none + */ +void lcd_point_draw(uint16_t x, uint16_t y, uint16_t color) +{ + lcd_cursor_set(x, y); + lcd_data_16bit_write(color); +} + +/** + * @brief draw a line at a specified location + * @param x_start:the x start coordinate of the line + * @param x_end :the x end coordinate of the line + * @param y_start:the y start coordinate of the line + * @param y_end :the x end coordinate of the line + * @param color :the color of the line + * @retval none + */ +void lcd_draw_line(uint16_t x_start, uint16_t y_start, uint16_t x_end, uint16_t y_end, uint16_t color) +{ + u16 t; + int xerr = 0, yerr = 0, delta_x, delta_y, distance; + int incx, incy, uRow, uCol; + delta_x = x_end - x_start; + delta_y = y_end - y_start; + uRow = x_start; + uCol = y_start; + if (delta_x > 0) + incx = 1; + else if (delta_x == 0) + incx = 0; + else + { + incx = -1; + delta_x = -delta_x; + } + if (delta_y > 0) + incy = 1; + else if (delta_y == 0) + incy = 0; + else + { + incy = -1; + delta_y = -delta_y; + } + if (delta_x > delta_y) + distance = delta_x; + else + distance = delta_y; + for (t = 0; t <= distance + 1; t++) + { + lcd_point_draw(uRow, uCol, color); + xerr += delta_x; + yerr += delta_y; + if (xerr > distance) + { + xerr -= distance; + uRow += incx; + } + if (yerr > distance) + { + yerr -= distance; + uCol += incy; + } + } +} + +/** + * @brief read a pixel color value at a specified location + * @param x:the x coordinate of the pixel + * @param y:the y coordinate of the pixel + * @retval the read color value + */ +uint16_t lcd_point_read(uint16_t x, uint16_t y) +{ + uint16_t color; + if (x >= lcddev.width || y >= lcddev.height) + { + return 0; + } + + lcd_cursor_set(x, y); + + lcd_ram_prepare_read(); + + color = lcd_data_16bit_read(); + + return color; +} + +/** + * @brief full screen filled lcd screen + * @param color:filled color + * @retval none + */ +void lcd_clear(uint16_t color) +{ + uint32_t i; + + // uint32_t total_point = lcddev.width * lcddev.height; + uint32_t total_point = 320 * 480; + + // lcd_windows_set(0, 0, lcddev.width - 1, lcddev.height - 1); + lcd_windows_set(0, 0, 320 - 1, 480 - 1); + + for (i = 0; i < total_point; i++) + { +#if LCD_USE8BIT_MODEL + LCD->LCD_RAM = color >> 8; + LCD->LCD_RAM = color; +#else + *(__IO uint16_t *)XMC_LCD_DATA = color; +#endif + } +} + +/** + * @brief initialization lcd screen + * @param direction: display direction + * this parameter can be one of the following values: + * - LCD_DISPLAY_VERTICAL: vertical display. + * - LCD_DISPLAY_HORIZONTAL: horizontal display. + * @retval none + */ +void lcd_init(lcd_display_type direction) +{ + lcd_gpio_xmc_init(); + LCD_RESET_HIGH(); + delay_ms(120); + LCD_RESET_LOW(); + delay_ms(120); + LCD_RESET_HIGH(); + delay_ms(120); + + /* read lcd id */ + lcd_id_read(); + + lcd_reg_write(0xF7); + lcd_data_write(0xA9); + lcd_data_write(0x51); + lcd_data_write(0x2C); + lcd_data_write(0x82); + + lcd_reg_write(0xC0); + lcd_data_write(0x11); + lcd_data_write(0x09); + + lcd_reg_write(0xC1); + lcd_data_write(0x41); + + lcd_reg_write(0xC5); + lcd_data_write(0x00); + lcd_data_write(0x0A); + lcd_data_write(0x80); + + lcd_reg_write(0xB1); + lcd_data_write(0xB0); + lcd_data_write(0x11); + + lcd_reg_write(0xB4); + lcd_data_write(0x02); + + lcd_reg_write(0xB6); + lcd_data_write(0x02); + lcd_data_write(0x22); + + lcd_reg_write(0xB7); + lcd_data_write(0xc6); + + lcd_reg_write(0xBE); + lcd_data_write(0x00); + lcd_data_write(0x04); + + lcd_reg_write(0xE9); + lcd_data_write(0x00); + + lcd_reg_write(0x36); + lcd_data_write(0x08); + + lcd_reg_write(0x3A); + lcd_data_write(0x55); + + lcd_reg_write(0xE0); + lcd_data_write(0x00); + lcd_data_write(0x07); + lcd_data_write(0x10); + lcd_data_write(0x09); + lcd_data_write(0x17); + lcd_data_write(0x0B); + lcd_data_write(0x41); + lcd_data_write(0x89); + lcd_data_write(0x4B); + lcd_data_write(0x0A); + lcd_data_write(0x0C); + lcd_data_write(0x0E); + lcd_data_write(0x18); + lcd_data_write(0x1B); + lcd_data_write(0x0F); + + lcd_reg_write(0xE1); + lcd_data_write(0x00); + lcd_data_write(0x17); + lcd_data_write(0x1A); + lcd_data_write(0x04); + lcd_data_write(0x0E); + lcd_data_write(0x06); + lcd_data_write(0x2F); + lcd_data_write(0x45); + lcd_data_write(0x43); + lcd_data_write(0x02); + lcd_data_write(0x0A); + lcd_data_write(0x09); + lcd_data_write(0x32); + lcd_data_write(0x36); + lcd_data_write(0x0F); + + lcd_reg_write(0x11); + delay_ms(120); + lcd_reg_write(0x29); + delay_ms(120); + + lcd_direction(direction); + delay_ms(120); + LCD_BL_HIGH(); + delay_ms(120); + + lcd_clear(BLACK); +} + +/** + * @brief setting lcd display window + * @param xstar:the bebinning x coordinate of the lcd display window + * @param ystar:the bebinning y coordinate of the lcd display window + * @param xend:the endning x coordinate of the lcd display window + * @param yend:the endning y coordinate of the lcd display window + * @retval none + */ +void lcd_windows_set(uint16_t xstar, uint16_t ystar, uint16_t xend, uint16_t yend) +{ + lcd_reg_write(lcddev.setxcmd); + lcd_data_write(xstar >> 8); + lcd_data_write(0x00FF & xstar); + lcd_data_write(xend >> 8); + lcd_data_write(0x00FF & xend); + + lcd_reg_write(lcddev.setycmd); + lcd_data_write(ystar >> 8); + lcd_data_write(0x00FF & ystar); + lcd_data_write(yend >> 8); + lcd_data_write(0x00FF & yend); + + lcd_ram_prepare_write(); +} + +/** + * @brief set coordinate value + * @param xpos:the x coordinate of the pixel + * @param ypos:the y coordinate of the pixel + * @retval none + */ +void lcd_cursor_set(uint16_t xpos, uint16_t ypos) +{ + lcd_windows_set(xpos, ypos, xpos, ypos); +} + +/** + * @brief setting the display direction of lcd screen + * @param direction:0-0 degree + * 1-90 degree + * 2-180 degree + * 3-270 degree + * @retval none + */ +void lcd_direction(uint8_t direction) +{ + lcddev.setxcmd = 0x2A; + lcddev.setycmd = 0x2B; + lcddev.wramcmd = 0x2C; + lcddev.rramcmd = 0x2E; + lcddev.dir = direction % 4; + + switch (lcddev.dir) + { + case LCD_DISPLAY_HORIZONTAL: + lcddev.width = LCD_H; + lcddev.height = LCD_W; + lcd_command_write(0x36, (1 << 3) | (1 << 6) | (1 << 5)); + break; + case LCD_DISPLAY_VERTICAL: + lcddev.width = LCD_W; + lcddev.height = LCD_H; + lcd_command_write(0x36, (1 << 3) | (1 << 6) | (1 << 7)); + break; + default: + break; + } +} + +/** + * @brief read id + * @param none + * @retval id value + */ +uint16_t lcd_id_read(void) +{ + uint8_t val[4] = {0}; + + lcd_command_read(0xD3, val, 4); + + return (val[2] << 8) | val[3]; +} + +/** + * @brief this function is show char to lcd + * @param x : row coordinates starting vaule + * @param y : column coordinates starting vaule + * @param num : number of char + * @param size : size of char + * @param mode : color + * @retval none + */ +void lcd_char_show(uint16_t x, uint16_t y, uint8_t num, uint8_t size, uint8_t mode) +{ + uint8_t temp, t1, t; + uint16_t y0 = y; + uint8_t csize = (size / 8 + ((size % 8) ? 1 : 0)) * (size / 2); + num = num - ' '; + + for (t = 0; t < csize; t++) + { + if (size == 12) + { + temp = asc2_1206[num][t]; + } + else if (size == 16) + { + temp = asc2_1608[num][t]; + } + else if (size == 24) + { + temp = asc2_2412[num][t]; + } + else if (size == 32) + { + temp = asc2_3216[num][t]; + } + else + { + return; + } + + for (t1 = 0; t1 < 8; t1++) + { + if (temp & 0x80) + { + lcd_point_draw(x, y, WHITE); + } + else if (mode == 0) + { + lcd_point_draw(x, y, BLACK); + } + + temp <<= 1; + y++; + + if (y >= LCD_H) + { + return; + } + + if ((y - y0) == size) + { + y = y0; + x++; + + if (x >= LCD_W) + { + return; + } + + break; + } + } + } +} + +/** + * @brief this function is show chinese to lcd + * @param x : row coordinates starting vaule + * @param y : column coordinates starting vaule + * @param gbk : chinese code + * @param size : size of char + * @param mode : color + * @retval none + */ +void lcd_font_show(uint16_t x, uint16_t y, uint8_t *gbk, uint8_t size, uint8_t mode) +{ + uint32_t temp, t1, t, flag; + uint16_t x0 = x; + uint8_t buf[72]; + + if (size == 24) + { + chinese_font_24x24_read(gbk, buf); + flag = 0x00800000; + } + else + { + return; + } + + for (t = 0; t < size; t++) + { + if (size == 24) + { + temp = (buf[t * 3 + 0] << 16) | (buf[t * 3 + 1] << 8) | buf[t * 3 + 2]; + } + + for (t1 = 0; t1 < size; t1++) + { + if (temp & flag) + { + lcd_point_draw(x, y, WHITE); + } + else if (mode == 0) + { + lcd_point_draw(x, y, BLACK); + } + + temp <<= 1; + + x++; + + if (x >= LCD_W) + { + return; + } + } + + x = x0; + y++; + + if (y >= LCD_H) + { + return; + } + } +} + +/** + * @brief this function is show string to lcd + * @param x : row coordinates starting vaule + * @param y : column coordinates starting vaule + * @param width : width of area + * @param height : height of area + * @param size : size of font + * @param p : pointer of string + * @retval none + */ +void lcd_string_show(uint16_t x, uint16_t y, uint16_t width, uint16_t height, uint8_t size, uint8_t *p) +{ + width += x; + height += y; + + while (*p) + { + if (x >= width) + { + break; + } + + if (y >= height) + { + break; + } + + if (*p < 127) + { + lcd_char_show(x, y, *p, size, BLACK); + x += size / 2; + p++; + } + else + { + lcd_font_show(x, y, p, size, BLACK); + x += size; + p += 2; + } + } +} + +/** + * @brief this function is fill in lcd with concolorous + * @param sx : row coordinates starting vaule + * @param sy : column coordinates starting vaule + * @param ex : row coordinates ending vaule + * @param ey : column coordinates ending vaule + * @param color : color for fill in lcd + * @retval none + */ +void lcd_fill(uint16_t sx, uint16_t sy, uint16_t ex, uint16_t ey, uint16_t color) +{ + uint16_t height, width; + uint16_t i, j; + + width = ex - sx + 1; + height = ey - sy + 1; + + lcd_windows_set(sx, sy, ex, ey); + + for (i = 0; i < height; i++) + { + for (j = 0; j < width; j++) + { + lcd_data_16bit_write(color); + } + } +} + +/** + * @brief this function is fill in lcd with color-pointer + * @param sx : row coordinates starting vaule + * @param sy : column coordinates starting vaule + * @param ex : row coordinates ending vaule + * @param ey : column coordinates ending vaule + * @param color : color-point for fill in lcd + * @retval none + */ +void lcd_color_fill(uint16_t sx, uint16_t sy, uint16_t ex, uint16_t ey, uint16_t *color) +{ + uint16_t height, width; + uint16_t i, j; + + width = ex - sx + 1; + height = ey - sy + 1; + + lcd_windows_set(sx, sy, ex, ey); + + for (i = 0; i < height; i++) + { + for (j = 0; j < width; j++) + { + lcd_data_16bit_write(color[i * width + j]); + } + } +} + +/** + * @brief this function is show int number to lcd + * @param x : row coordinates starting vaule + * @param y : column coordinates starting vaule + * @param width : width of string + * @param height : height of string + * @param num : number + * @retval num_bit : display number of digits + */ +void lcd_num_show(uint16_t x, uint16_t y, uint16_t width, uint16_t height, uint8_t size, int32_t num, uint8_t num_bit) +{ + uint8_t i, buf[12], start; + + buf[11] = 0; + + if (num < 0) + { + num = -num; + buf[0] = '-'; + } + else + { + buf[0] = '0'; + } + + for (i = 0; i < 10; i++) + { + buf[10 - i] = num % 10 + '0'; + num /= 10; + + if (buf[10 - i] > '0') + { + start = 10 - i; + } + } + + if (buf[0] == '-') + { + start -= 1; + + buf[start] = '-'; + } + else + { + if (start > (11 - num_bit)) + { + start = 11 - num_bit; + } + } + + lcd_string_show(x, y, width, height, size, &buf[start]); +} + +/** + * @brief this function is show float number to lcd + * @param x : row coordinates starting vaule + * @param y : column coordinates starting vaule + * @param width : width of string + * @param height : height of string + * @param num : number + * @retval num_bit : display number of digits + */ +void lcd_float_num_show(uint16_t x, uint16_t y, uint16_t width, uint16_t height, uint8_t size, float num, uint8_t num_bit) +{ + uint8_t buf[12]; + int32_t int_num; + + int_num = num; + + buf[0] = int_num + '0'; + + num = num - int_num; + + num *= 1000; + + int_num = num; + + buf[1] = '.'; + buf[2] = (int_num / 100) + '0'; + buf[3] = (int_num % 100 / 10) + '0'; + buf[4] = (int_num % 10) + '0'; + buf[5] = 0; + + buf[num_bit + 2] = 0; + + lcd_string_show(x, y, width, height, size, buf); +} diff --git a/mkrtos_user/user/drv/ATSURFF437/display/fs_rpc.c b/mkrtos_user/user/drv/ATSURFF437/display/fs_rpc.c new file mode 100644 index 000000000..c298792d9 --- /dev/null +++ b/mkrtos_user/user/drv/ATSURFF437/display/fs_rpc.c @@ -0,0 +1,345 @@ +#include "cons_cli.h" +#include "cpiofs.h" +#include "fs_svr.h" +#include "rpc_prot.h" +#include "u_env.h" +#include "u_log.h" +#include "u_rpc.h" +#include "u_rpc_svr.h" +#include "u_sys.h" +#include "mk_char_dev.h" +#include "mk_display_drv.h" +#include "fs_rpc.h" +#include +#include +#include +#include +#include +#include + +static fs_t fs; + +typedef struct file_desc +{ + pid_t pid; + mk_char_dev_iter_t iter; + void *ptr_dev; + int offset; + int open_type; +} file_desc_t; + +#define CPIO_FS_FD_NR 8 +static file_desc_t fds[CPIO_FS_FD_NR]; + +static file_desc_t *fd_alloc(int pid, void *ptr_dev, int open_type, int *fd) +{ + for (int i = 0; i < CPIO_FS_FD_NR; i++) + { + if (fds[i].ptr_dev == NULL) + { + fds[i].pid = pid; + fds[i].ptr_dev = ptr_dev; + fds[i].open_type = open_type; + if (fd) + { + *fd = i; + } + return fds + i; + } + } + return NULL; +} +static file_desc_t *fd_get(int pid, int fd) +{ + if (fd < 0 || fd >= CPIO_FS_FD_NR) + { + return NULL; + } + if (fds[fd].ptr_dev == NULL) + { + return NULL; + } + if (fds[fd].pid != pid) + { + return NULL; + } + return &fds[fd]; +} +static void fd_free(int fd) +{ + if (fd < 0 || fd >= CPIO_FS_FD_NR) + { + return; + } + if (fds[fd].ptr_dev) + { + if (fds[fd].pid == thread_get_src_pid()) + { + fds[fd].ptr_dev = NULL; + fds[fd].pid = -1; + } + } +} +void fs_svr_init(void) +{ + msg_tag_t tag; + + fs_init(&fs); + meta_reg_svr_obj(&fs.svr, FS_PROT); +} +int fs_svr_open(const char *path, int flags, int mode) +{ + int pid = thread_get_src_pid(); + msg_tag_t tag; + char *o_path; + mk_char_dev_t *char_dev; + int fd; + int ret = 0; + int is_open_dir = 0; + + printf("%s path is %s\n", __func__, path); + if (path[0] == '/' && path[1] == '\0') + { + path++; + is_open_dir = 1; + } + if (is_open_dir == 0) + { + if (path[0] == '\0') + { + char_dev = mk_char_get_first(); + } + else + { + char_dev = mk_char_find_char_dev(path); + } + if (!char_dev) + { + printf("[pin] not dev %s.\n", path); + return -ENODEV; + } + if (char_dev->ops->open) + { + ret = char_dev->ops->open(char_dev->dev); + } + if (ret < 0) + { + return ret; + } + // 找到指定文件 + file_desc_t *fdp = fd_alloc(pid, char_dev, is_open_dir, &fd); + + if (!fdp) + { + printf("[pin] not fd %s.\n", path); + if (char_dev->ops->release) + { + char_dev->ops->release(char_dev->dev); + } + return -ENOMEM; + } + } + else + { + file_desc_t *fdp = fd_alloc(pid, NULL, is_open_dir, &fd); + + if (!fdp) + { + printf("[pin] not fd %s.\n", path); + return -ENOMEM; + } + } + printf("[pin] open success %s, fd is %d.\n", path, fd); + return fd; +} + +int fs_svr_read(int fd, void *buf, size_t len) +{ + int ret; + file_desc_t *fdp = fd_get(thread_get_src_pid(), fd); + + if (!fdp) + { + return -ENOENT; + } + + return -ENOSYS; +} +int fs_svr_write(int fd, void *buf, size_t len) +{ + int ret; + file_desc_t *fdp = fd_get(thread_get_src_pid(), fd); + + if (!fdp) + { + return -ENOENT; + } + return -ENOSYS; +} +void fs_svr_close(int fd) +{ + file_desc_t *fdp = fd_get(thread_get_src_pid(), fd); + + if (!fdp) + { + // return -ENOENT; + return; + } + if (fdp->open_type == 0) + { + mk_char_dev_t *char_dev; + + char_dev = fdp->ptr_dev; + if (char_dev->ops->release) + { + char_dev->ops->release(char_dev->dev); + } + } + else + { + /*TODO:*/ + } + fd_free(fd); +} +int fs_svr_lseek(int fd, int offs, int whence) +{ + file_desc_t *file = fd_get(thread_get_src_pid(), fd); + int new_offs = 0; + + if (!file) + { + return -ENOENT; + } + if (file->open_type != 0) + { + return -EACCES; + } + return -ENOSYS; +} +int fs_svr_ftruncate(int fd, off_t off) +{ + return -ENOSYS; +} +void fs_svr_sync(int fd) +{ +} + +int fs_svr_readdir(int fd, dirent_t *dir) +{ + int pid = thread_get_src_pid(); + file_desc_t *file = fd_get(pid, fd); + int new_offs = 0; + mk_char_dev_t *char_dev; + + if (!file) + { + return -ENOENT; + } + if (file->open_type == 0) + { + return -EACCES; + } + + if (file->ptr_dev == NULL) + { + char_dev = mk_char_get_iter_first(&file->iter); + } + else + { + char_dev = mk_char_get_iter_next(&file->iter); + } + if (char_dev == NULL) + { + return -ENOENT; + } + printf("[pin] readdir %s.\n", mk_dev_get_dev_name(char_dev->dev)); + file->ptr_dev = char_dev; // TODO: ref add. + dir->d_reclen = sizeof(*dir); + strncpy(dir->d_name, mk_dev_get_dev_name(char_dev->dev), MK_DEV_NAME_LEN); + dir->d_name[MK_DEV_NAME_LEN - 1] = 0; + dir->d_type = DT_CHR; + + return sizeof(*dir); +} +int fs_svr_ioctl(int fd, int req, void *arg) +{ + file_desc_t *file = fd_get(thread_get_src_pid(), fd); + int new_offs = 0; + int ret = -EIO; + // printf("%s fd:%d req:%d arg:0x%x\n", __func__, fd, req, (umword_t)arg); + if (!file) + { + return -ENOENT; + } + if (file->open_type != 0) + { + return -EACCES; + } + mk_char_dev_t *char_dev = file->ptr_dev; + + if (char_dev->ops->ioctl) + { + ret = char_dev->ops->ioctl(char_dev->dev, req, (umword_t)arg); + } + return ret; +} +int fs_svr_mkdir(char *path) +{ + return -ENOSYS; +} +int fs_svr_unlink(const char *path) +{ + return -ENOSYS; +} +int fs_svr_renmae(char *oldname, char *newname) +{ + return -ENOSYS; +} +int fs_svr_fstat(int fd, stat_t *stat) +{ + file_desc_t *file = fd_get(thread_get_src_pid(), fd); + + if (!file) + { + return -ENOENT; + } + return -ENOSYS; +} +int fs_svr_symlink(const char *src, const char *dst) +{ + return -ENOSYS; +} +int fs_svr_fsync(int fd) +{ + return -ENOSYS; +} +int fs_svr_rmdir(char *path) +{ + return -ENOSYS; +} +int fs_svr_rename(char *old, char *new) +{ + return -ENOSYS; +} +int fs_svr_stat(const char *path, struct stat *buf) +{ + if (path == NULL || buf == NULL) + { + return -EINVAL; + } + return -ENOSYS; +} + +ssize_t fs_svr_readlink(const char *path, char *buf, size_t bufsize) +{ + return -ENOSYS; +} +int fs_svr_statfs(const char *path, struct statfs *buf) +{ + return -ENOSYS; +} + +void fs_svr_loop(void) +{ + rpc_loop(); +} \ No newline at end of file diff --git a/mkrtos_user/user/drv/ATSURFF437/display/fs_rpc.h b/mkrtos_user/user/drv/ATSURFF437/display/fs_rpc.h new file mode 100644 index 000000000..a8f63d667 --- /dev/null +++ b/mkrtos_user/user/drv/ATSURFF437/display/fs_rpc.h @@ -0,0 +1,6 @@ +#pragma once + +#define FS_DEBUG 0 + +void fs_svr_init(void); +void fs_svr_loop(void); diff --git a/mkrtos_user/user/drv/ATSURFF437/display/heap_stack.c b/mkrtos_user/user/drv/ATSURFF437/display/heap_stack.c new file mode 100644 index 000000000..0603320cc --- /dev/null +++ b/mkrtos_user/user/drv/ATSURFF437/display/heap_stack.c @@ -0,0 +1,17 @@ + +#define HEAP_SIZE (2048) +#define STACK_SIZE (1024 * 3) + +#if defined(__CC_ARM) +#define HEAP_ATTR SECTION("HEAP") __attribute__((zero_init)) +#define STACK_ATTR SECTION("STACK") __attribute__((zero_init)) +#elif defined(__GNUC__) +#define HEAP_ATTR __attribute__((__section__(".bss.heap"))) +#define STACK_ATTR __attribute__((__section__(".bss.stack"))) +#elif defined(__IAR_SYSTEMS_ICC__) +#define HEAP_ATTR +#define STACK_ATTR +#endif + +__attribute__((used)) HEAP_ATTR static char _____heap_____[HEAP_SIZE]; +__attribute__((used)) STACK_ATTR static char _____stack_____[STACK_SIZE]; diff --git a/mkrtos_user/user/drv/ATSURFF437/display/main.c b/mkrtos_user/user/drv/ATSURFF437/display/main.c new file mode 100644 index 000000000..df8a6321f --- /dev/null +++ b/mkrtos_user/user/drv/ATSURFF437/display/main.c @@ -0,0 +1,39 @@ + +#include +#include +#include +#include +#include +#include +#include +#include +#include "fs_rpc.h" +#include "ns_cli.h" +#include +#include +#include "mk_display_drv_impl.h" + +int main(int argc, char *argv[]) +{ + obj_handler_t hd; + int ret; + + printf("%s init..\n", argv[0]); +#if 1 + thread_run(-1, 3); +#endif + mk_drv_init(); + mk_dev_init(); + drv_display_init(); + dtb_parse_init(); + + ret = rpc_meta_init(THREAD_MAIN, &hd); + assert(ret >= 0); + fs_svr_init(); + // mkdir("/dev", 0777); + ns_register("/display", hd, FILE_NODE); + while (1) + { + fs_svr_loop(); + } +} diff --git a/mkrtos_user/user/drv/ATSURFF437/display/mk_display_drv_impl.c b/mkrtos_user/user/drv/ATSURFF437/display/mk_display_drv_impl.c new file mode 100644 index 000000000..6dcba7179 --- /dev/null +++ b/mkrtos_user/user/drv/ATSURFF437/display/mk_display_drv_impl.c @@ -0,0 +1,76 @@ + + +#include +#include +#include +#include +#include +#include +#include "mk_drv.h" +#include "mk_display_drv.h" +#include "mk_dtb_parse.h" +#include +#include +#include "at32f435_437_gpio.h" +#include "at32f435_437_crm.h" +#include + +static int display_get_info(mk_display_t *drv, mk_display_cfg_t *cfg) +{ + assert(drv); + assert(cfg); + + cfg->mode = MK_DISPLAY_NO_BUFFER; + cfg->display_addr = XMC_LCD_DATA; + cfg->display_cmd_addr = XMC_LCD_COMMAND; + return 0; +} +static int display_set_win(mk_display_t *drv, mk_display_win_t *dis_win) +{ + assert(drv); + assert(dis_win); + + lcd_windows_set(dis_win->x, dis_win->y, dis_win->x + dis_win->w - 1, dis_win->y + dis_win->h - 1); + return 0; +} + +static mk_display_ops_t pin_ops = { + .display_get_info = display_get_info, + .display_set_win = display_set_win, +}; +static mk_display_dev_t pin_dev = { + .ops = &pin_ops, +}; + +static int display_probe(mk_dev_t *dev) +{ + int ret; + + /* ioremap */ + ret = dev_regs_map(dev, dev->dtb); + if (ret < 0) + { + printf("display dev regs map failed.\n"); + } + lcd_init(LCD_DISPLAY_VERTICAL); + /* 注册display设备 */ + mk_display_register(dev, &pin_dev); + return 0; +} + +static mk_drv_compatible_t drv_compatilbe[] = + { + {"at32f43x,lcd"}, + {NULL}, +}; + +static mk_drv_t display_drv = + { + .compatilbe = drv_compatilbe, + .probe = display_probe, + .data = NULL, +}; +void drv_display_init(void) +{ + mk_drv_register(&display_drv); +} diff --git a/mkrtos_user/user/drv/ATSURFF437/display/mk_display_drv_impl.h b/mkrtos_user/user/drv/ATSURFF437/display/mk_display_drv_impl.h new file mode 100644 index 000000000..bfb81bdbe --- /dev/null +++ b/mkrtos_user/user/drv/ATSURFF437/display/mk_display_drv_impl.h @@ -0,0 +1,3 @@ +#pragma once + +void drv_display_init(void); diff --git a/mkrtos_user/user/drv/ATSURFF437/pin/mk_pin_drv_impl.c b/mkrtos_user/user/drv/ATSURFF437/pin/mk_pin_drv_impl.c index 5c558f8e1..a3c3faa1b 100644 --- a/mkrtos_user/user/drv/ATSURFF437/pin/mk_pin_drv_impl.c +++ b/mkrtos_user/user/drv/ATSURFF437/pin/mk_pin_drv_impl.c @@ -35,7 +35,7 @@ static gpio_type *drv_pin_get_port_data(int pin) return gpio_type_list[pin]; } -static int pin_configure(mk_pin_t *pin, int number, int mode) +static int pin_configure(mk_pin_t *pin, int number, mk_pin_mode_t cfg) { gpio_type *pin_port_data = drv_pin_get_port_data(number); uint32_t exti_line = number & 0x0f; @@ -48,7 +48,7 @@ static int pin_configure(mk_pin_t *pin, int number, int mode) printf("pin_port_data is NULL.\n"); return -EINVAL; } - printf("%s:%d number:%d mode:%d\n", __func__, __LINE__, number, mode); + printf("%s:%d number:%d mode:%d cfg:%d\n", __func__, __LINE__, number, cfg.mode, cfg.mux_cfg); gpio_default_para_init(&gpio_init_struct); exint_default_para_init(&exint_init_struct); @@ -85,7 +85,7 @@ static int pin_configure(mk_pin_t *pin, int number, int mode) { crm_periph_clock_enable(CRM_GPIOH_PERIPH_CLOCK, TRUE); } - switch (mode) + switch (cfg.mode) { case MK_PIN_MODE_NONE: { @@ -135,6 +135,24 @@ static int pin_configure(mk_pin_t *pin, int number, int mode) gpio_init_struct.gpio_pull = GPIO_PULL_UP; break; } + case MK_PIN_MODE_MUX_OUTPUT: + { + gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER; + gpio_init_struct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL; + gpio_init_struct.gpio_mode = GPIO_MODE_MUX; + gpio_init_struct.gpio_pull = GPIO_PULL_NONE; + gpio_pin_mux_config(pin_port_data, number % 16, cfg.mux_cfg); + break; + } + case MK_PIN_MODE_MUX_OUTPUT_OD: + { + gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER; + gpio_init_struct.gpio_out_type = GPIO_OUTPUT_OPEN_DRAIN; + gpio_init_struct.gpio_mode = GPIO_MODE_MUX; + gpio_init_struct.gpio_pull = GPIO_PULL_NONE; + gpio_pin_mux_config(pin_port_data, number % 16, cfg.mux_cfg); + break; + } case MK_PIN_MODE_IRQ_RISING: { gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER; @@ -168,7 +186,7 @@ static int pin_configure(mk_pin_t *pin, int number, int mode) } } - if (mode >= MK_PIN_MODE_IRQ_RISING) + if (cfg.mode >= MK_PIN_MODE_IRQ_RISING) { crm_periph_clock_enable(CRM_SCFG_PERIPH_CLOCK, TRUE); scfg_exint_line_config(number / 16, number % 16); @@ -180,7 +198,7 @@ static int pin_configure(mk_pin_t *pin, int number, int mode) // nvic_irq_enable(EXINT0_IRQn, 1, 0);TODO:这里需要在内核设置 } - pin->pins[number] = mode; + pin->pins[number] = cfg; gpio_init_struct.gpio_pins = (1 << (number % 16)); gpio_init(pin_port_data, &gpio_init_struct); return 0; @@ -209,8 +227,6 @@ static int pin_write(mk_pin_t *pin, int number, uint8_t value) return 0; } - - static mk_pin_ops_t pin_ops = { .drv_pin_configure = pin_configure, .drv_pin_read = pin_read, diff --git a/mkrtos_user/user/drv/lib/CMakeLists.txt b/mkrtos_user/user/drv/lib/CMakeLists.txt index db3d33d62..821274471 100644 --- a/mkrtos_user/user/drv/lib/CMakeLists.txt +++ b/mkrtos_user/user/drv/lib/CMakeLists.txt @@ -2,4 +2,5 @@ cmake_minimum_required(VERSION 3.13) add_subdirectory(mk_drv) add_subdirectory(mk_pin) +add_subdirectory(mk_display) add_subdirectory(mk_char) diff --git a/mkrtos_user/user/drv/lib/mk_display/CMakeLists.txt b/mkrtos_user/user/drv/lib/mk_display/CMakeLists.txt new file mode 100644 index 000000000..12b950c66 --- /dev/null +++ b/mkrtos_user/user/drv/lib/mk_display/CMakeLists.txt @@ -0,0 +1,38 @@ +cmake_minimum_required(VERSION 3.13) + + +file(GLOB_RECURSE deps *.c *.S) +add_library( + mk_display + STATIC + ${deps} +) +target_link_libraries( + mk_display + PRIVATE + fdt + sys + sys_util + sys_svr + mk_drv +) +add_dependencies( + mk_display + fdt + sys + sys_util + sys_svr + mk_drv +) +target_include_directories( + mk_display + PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR}/ + ${CMAKE_CURRENT_SOURCE_DIR}/../mk_drv + ${CMAKE_SOURCE_DIR}/mkrtos_user/user/drv/lib/mk_char + ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/sys/inc + ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/sys/inc/${ARCH_NAME} + ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/sys_svr/inc + ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/util/inc + ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/libfdt/lib/contrib +) diff --git a/mkrtos_user/user/drv/lib/mk_display/mk_display_drv.c b/mkrtos_user/user/drv/lib/mk_display/mk_display_drv.c new file mode 100644 index 000000000..3f5aad693 --- /dev/null +++ b/mkrtos_user/user/drv/lib/mk_display/mk_display_drv.c @@ -0,0 +1,146 @@ + +#include "mk_display_drv.h" +#include "u_types.h" +#include +#include +#include +#include +#include +#include +#include +/** + * @brief 写pin操作 + * + * @param pin pin设备 + * @param buf 写的buf + * @param size 写入大小˝ + * @return int 写入的个数 + */ +static int mk_display_drv_write(mk_dev_t *_dev, void *buf, size_t size) +{ + assert(buf); + assert(_dev); + + return -ENOSYS; +} +/** + * @brief 读取pin数据 + * + * @param pin + * @param buf + * @param size + * @return int + */ +static int mk_display_drv_read(mk_dev_t *_dev, void *buf, size_t size) +{ + assert(buf); + assert(_dev); + return -ENOSYS; +} + +/** + * @brief 控制pin状态 + * + * @param pin + * @param cmd + * @param args + * @return int + */ +static int mk_display_drv_ioctl(mk_dev_t *_dev, int cmd, umword_t args) +{ + assert(_dev); + pid_t src_pid = thread_get_src_pid(); + mk_display_dev_t *dis_dev = _dev->priv_data; + mk_display_ops_t *ops = dis_dev->ops; + assert(ops); + int ret; + pid_t cur_pid; + + switch (cmd) + { + case MK_DISPLAY_SET_WIN: + { + msg_tag_t tag; + mk_display_win_t dis_arg; + + tag = task_get_pid(TASK_THIS, (umword_t *)(&cur_pid)); + if (msg_tag_get_val(tag) < 0) + { + return msg_tag_get_val(tag); + } + // printf("%s:%d cmd:0x%x args:0x%x\n", __func__, __LINE__, cmd, args); + ret = mk_copy_mem_to_task(src_pid, (void *)args, + cur_pid, &dis_arg, sizeof(mk_display_win_t)); + if (ret < 0) + { + return ret; + } + if (ops->display_set_win) + { + ret = ops->display_set_win(&dis_dev->display, &dis_arg); + } + else + { + return -EIO; + } + return ret; + } + break; + case MK_DISPLAY_GET_INFO: + { + mk_display_cfg_t cfg; + mk_display_cfg_t *arg_cfg = (void *)args; + msg_tag_t tag; + + tag = task_get_pid(TASK_THIS, (umword_t *)(&cur_pid)); + if (msg_tag_get_val(tag) < 0) + { + return msg_tag_get_val(tag); + } + if (ops->display_get_info) + { + ret = ops->display_get_info(&dis_dev->display, &cfg); + } + else + { + return -EIO; + } + if (ret >= 0) + { + ret = mk_copy_mem_to_task(cur_pid, &cfg, src_pid, + arg_cfg, sizeof(mk_display_cfg_t)); + if (ret < 0) + { + return ret; + } + } + } + break; + default: + break; + } + return ret; +} +static mk_file_ops_t file_ops = { + .open = NULL, + .write = NULL, + .read = NULL, + .ioctl = mk_display_drv_ioctl, + .release = NULL, +}; + +int mk_display_register(mk_dev_t *dev, mk_display_dev_t *display_drv) +{ + int ret = 0; + assert(dev); + assert(display_drv); + + ret = mk_char_dev_register(dev, &file_ops); + if (ret < 0) + { + return ret; + } + mk_dev_set_priv_data(dev, display_drv); + + return ret; +} \ No newline at end of file diff --git a/mkrtos_user/user/drv/lib/mk_display/mk_display_drv.h b/mkrtos_user/user/drv/lib/mk_display/mk_display_drv.h new file mode 100644 index 000000000..01164e80b --- /dev/null +++ b/mkrtos_user/user/drv/lib/mk_display/mk_display_drv.h @@ -0,0 +1,51 @@ +#pragma once + +#include +#include "mk_drv.h" +#include "mk_dev.h" + +typedef struct mk_display +{ + /*None*/ +} mk_display_t; + +enum mk_display_mode +{ + MK_DISPLAY_NO_BUFFER, //!< 无buffer模式 + MK_DISPLAY_BUFFER, //!< buffer模式 +}; + +typedef struct mk_display_cfg +{ + addr_t display_addr; //!< 显示缓存的地址，物理地址 + addr_t display_cmd_addr; //!< 命令地址 + enum mk_display_mode mode; //!< 驱动显示模式 +} mk_display_cfg_t; + +typedef struct mk_display_win +{ + int x; + int y; + int w; + int h; +} mk_display_win_t; + +typedef struct mk_display_ops +{ + int (*display_get_info)(mk_display_t *drv, mk_display_cfg_t *cfg); + int (*display_set_win)(mk_display_t *drv, mk_display_win_t *dis_win); +} mk_display_ops_t; + +typedef struct mk_display_dev +{ + mk_display_t display; + mk_display_ops_t *ops; +} mk_display_dev_t; + +enum mk_display_ioctl +{ + MK_DISPLAY_GET_INFO, //!< 直接获取显示的物理缓存 + MK_DISPLAY_SET_WIN, //!< 设置显示窗口 +}; + +int mk_display_register(mk_dev_t *dev, mk_display_dev_t *pin_dev); diff --git a/mkrtos_user/user/drv/lib/mk_drv/mk_access.c b/mkrtos_user/user/drv/lib/mk_drv/mk_access.c new file mode 100644 index 000000000..be475adbe --- /dev/null +++ b/mkrtos_user/user/drv/lib/mk_drv/mk_access.c @@ -0,0 +1,9 @@ + + +#include "mk_access.h" +#include + +int mk_copy_mem_to_task(pid_t src_pid, void *src, pid_t dst_pid, void *dst, size_t len) +{ + return pm_copy_data(src_pid, dst_pid, (addr_t)src, (addr_t)dst, len); +} diff --git a/mkrtos_user/user/drv/lib/mk_drv/mk_access.h b/mkrtos_user/user/drv/lib/mk_drv/mk_access.h new file mode 100644 index 000000000..0d2426165 --- /dev/null +++ b/mkrtos_user/user/drv/lib/mk_drv/mk_access.h @@ -0,0 +1,6 @@ +#pragma once + +#include +#include + +int mk_copy_mem_to_task(pid_t src_pid, void *src, pid_t dst_pid, void *dst, size_t len); diff --git a/mkrtos_user/user/drv/lib/mk_pin/mk_pin_drv.c b/mkrtos_user/user/drv/lib/mk_pin/mk_pin_drv.c index 56e8a5c90..0d852f0dd 100644 --- a/mkrtos_user/user/drv/lib/mk_pin/mk_pin_drv.c +++ b/mkrtos_user/user/drv/lib/mk_pin/mk_pin_drv.c @@ -103,7 +103,10 @@ static int mk_pin_drv_ioctl(mk_dev_t *pin, int cmd, umword_t args) } if (ops->drv_pin_configure) { - ret = ops->drv_pin_configure(&pin_dev->pins, cfg.pin, cfg.mode); + ret = ops->drv_pin_configure(&pin_dev->pins, cfg.pin, (mk_pin_mode_t){ + .mode = cfg.mode, + .mux_cfg = cfg.cfg, + }); if (ret < 0) { return ret; @@ -123,7 +126,7 @@ static int mk_pin_drv_ioctl(mk_dev_t *pin, int cmd, umword_t args) { return -EINVAL; } - return pin_dev->pins.pins[cfg.pin]; + return pin_dev->pins.pins[cfg.pin].raw; } break; case MK_PIN_SET_OP_PIN: diff --git a/mkrtos_user/user/drv/lib/mk_pin/mk_pin_drv.h b/mkrtos_user/user/drv/lib/mk_pin/mk_pin_drv.h index e63007241..4782b1328 100644 --- a/mkrtos_user/user/drv/lib/mk_pin/mk_pin_drv.h +++ b/mkrtos_user/user/drv/lib/mk_pin/mk_pin_drv.h @@ -6,14 +6,26 @@ #define MK_PIN_MAX_NUM (16 * 8) +__ALIGN__(1) +typedef union mk_pin_mode +{ + struct + { + uint8_t mode; + uint8_t mux_cfg; + uint8_t resv0; + uint8_t resv1; + }; + uint32_t raw; +} mk_pin_mode_t; typedef struct mk_pin { - uint32_t pins[MK_PIN_MAX_NUM]; //!< 最大256引脚 + mk_pin_mode_t pins[MK_PIN_MAX_NUM]; //!< 最大256引脚 } mk_pin_t; typedef struct mk_pin_ops { - int (*drv_pin_configure)(mk_pin_t *pin, int number, int mode); + int (*drv_pin_configure)(mk_pin_t *pin, int number, mk_pin_mode_t cfg); int (*drv_pin_read)(mk_pin_t *pin, int number, uint8_t *value); int (*drv_pin_write)(mk_pin_t *pin, int number, uint8_t value); } mk_pin_ops_t; @@ -32,7 +44,7 @@ enum mk_pin_ioctl_op MK_PIN_SET_OP_PIN, //!< 设置要操作的引脚，标记读写的起始引脚 }; -enum mk_pin_mode +enum mk_pin_mode_cfg { MK_PIN_MODE_NONE = 1, MK_PIN_MODE_OUTPUT, @@ -41,17 +53,23 @@ enum mk_pin_mode MK_PIN_MODE_INPUT_DOWN, MK_PIN_MODE_INPUT_UP, + MK_PIN_MODE_MUX_OUTPUT, + MK_PIN_MODE_MUX_OUTPUT_OD, + MK_PIN_MODE_IRQ_RISING, MK_PIN_MODE_IRQ_FALLING, MK_PIN_MODE_IRQ_EDGE, MK_PIN_MODE_IRQ_LOW, MK_PIN_MODE_IRQ_HIGH, + }; +__ALIGN__(1) typedef union mk_pin_cfg { struct { - uint16_t mode; + uint8_t mode; + uint8_t cfg; uint16_t pin; }; uint32_t cfg_raw;