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

appfs集成

Browse Source
This commit is contained in:
zhangzheng
2025-01-25 15:29:06 +08:00
parent 12eac3edf8
commit 5bce3adf01
65 changed files with 947 additions and 646 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
mkrtos_user/lib/letter-shell/demo/mkrtos/shell_fs_ext.c
View File

@@ -12,6 +12,7 @@
#include <sys/stat.h>
#include <errno.h>
#include "u_sys.h"
#include "unistd.h"
int ls(int argc, char *agrv[])
{
DIR *dir;
@@ -37,6 +38,19 @@ int ls(int argc, char *agrv[])
return 0;
}
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN), ls, ls, ls command);
int rm(int argc, char *agrv[])
{
int ret;
if (argc < 2)
{
return -1;
}
ret = unlink(agrv[1]);
return ret;
}
SHELL_EXPORT_CMD(SHELL_CMD_PERMISSION(0) | SHELL_CMD_TYPE(SHELL_TYPE_CMD_MAIN), rm, rm, rm command);
int cat(int argc, char *argv[])
{
if (argc != 2)
@@ -78,7 +92,7 @@ int hex(int argc, char *argv[])
return errno;
}
while ((ret = fread( &c, 1,1,fp)) == 1)
while ((ret = fread(&c, 1, 1, fp)) == 1)
{
printf("%02x ", c);
i++;

1
mkrtos_user/lib/libc_backend/inc/syscall_backend.h
View File

@@ -94,6 +94,7 @@ long be_getdents(long fd, char *buf, size_t size);
long be_mkdir(const char *path, mode_t mode);
long be_symlink(const char *src, const char *dst);
long be_stat(const char *path, void *buf);
long be_unlink(const char *path);
int be_clone(int (*func)(void *), void *stack, int flags, void *args, pid_t *ptid, void *tls, pid_t *ctid);
umword_t be_munmap(void *start, size_t len);
umword_t be_mmap(void *start,

4
mkrtos_user/lib/libc_backend/src/fs_backend.c
View File

@@ -457,6 +457,10 @@ long be_fstat(int fd, void *_buf)
}
return fs_fstat(u_fd.priv_fd, (void *)buf);
}
long be_unlink(const char *path)
{
return fs_unlink(path);
}
long sys_be_getdents(va_list ap)
{
long fd;

8
mkrtos_user/lib/mlibc/src/unistd/unlink.c
View File

@@ -1,11 +1,17 @@
#include <unistd.h>
#include <fcntl.h>
#include "syscall.h"
#ifndef NO_LITTLE_MODE
#include "syscall_backend.h"
#endif
int unlink(const char *path)
{
#ifdef SYS_unlink
#ifdef NO_LITTLE_MODE
return syscall(SYS_unlink, path);
#else
return be_unlink(path);
#endif
#else
return syscall(SYS_unlinkat, AT_FDCWD, path, 0);
#endif

1
mkrtos_user/lib/sys_svr/inc/blk_drv_cli.h
View File

@@ -6,3 +6,4 @@
int blk_drv_cli_write(obj_handler_t dm9000_obj, obj_handler_t shm_obj, int len, int inx);
int blk_drv_cli_read(obj_handler_t dm9000_obj, obj_handler_t shm_obj, int len, int inx);
int blk_drv_cli_map(obj_handler_t svr_boj, obj_handler_t *sem_obj);
int blk_drv_cli_info(obj_handler_t obj, blk_drv_info_t *info);

1
mkrtos_user/lib/sys_svr/inc/blk_drv_svr.h
View File

@@ -6,4 +6,5 @@
int blk_drv_write(obj_handler_t obj, int len, int inx);
int blk_drv_read(obj_handler_t obj, int len, int inx);
int blk_drv_map(obj_handler_t *hd);
int blk_drv_info(blk_drv_info_t *info);
void blk_drv_init(blk_drv_t *ns);

9
mkrtos_user/lib/sys_svr/inc/blk_drv_types.h
View File

@@ -2,6 +2,15 @@
#include "u_types.h"
#include "u_rpc_svr.h"
#include "u_slist.h"
#include "u_rpc.h"
typedef struct blk_drv_info
{
umword_t blk_start_addr; /*内存中的起始地址*/
size_t blk_size; /*块大小*/
size_t blk_nr; /*blk块数量*/
} blk_drv_info_t;
RPC_TYPE_DEF_ALL(blk_drv_info_t)
typedef struct blk_drv
{

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

@@ -53,3 +53,4 @@
#define BLK_DRV_WRITE ((umword_t)0) //!< 块驱动写
#define BLK_DRV_READ ((umword_t)1) //!< 块驱动读
#define BLK_DRV_MAP ((umword_t)2) //!< 块驱动对象映射
#define BLK_DRV_INFO ((umword_t)3) //!< 获取驱动信息

31
mkrtos_user/lib/sys_svr/src/blk_drv_cli.c
View File

@@ -59,7 +59,8 @@ int blk_drv_cli_map(obj_handler_t dm9000_obj, obj_handler_t *sem_obj)
obj_handler_t newfd;
newfd = handler_alloc();
if (newfd == HANDLER_INVALID) {
if (newfd == HANDLER_INVALID)
{
return -ENOENT;
}
rpc_obj_handler_t_t rpc_sem_obj = {
@@ -68,10 +69,36 @@ int blk_drv_cli_map(obj_handler_t dm9000_obj, obj_handler_t *sem_obj)
};
msg_tag_t tag = blk_drv_t_map_call(dm9000_obj, &rpc_sem_obj);
if (msg_tag_get_val(tag) < 0) {
if (msg_tag_get_val(tag) < 0)
{
handler_free(newfd);
return msg_tag_get_val(tag);
}
*sem_obj = newfd;
return msg_tag_get_val(tag);
}
RPC_GENERATION_CALL1(TRUE, blk_drv_t, BLK_DRV_PROT, BLK_DRV_INFO, info,
rpc_blk_drv_info_t_t, rpc_blk_drv_info_t_t, RPC_DIR_OUT, RPC_TYPE_DATA, info)
int blk_drv_cli_info(obj_handler_t obj, blk_drv_info_t *info)
{
assert(info);
obj_handler_t newfd;
newfd = handler_alloc();
if (newfd == HANDLER_INVALID)
{
return -ENOENT;
}
rpc_blk_drv_info_t_t rpc_info;
msg_tag_t tag = blk_drv_t_info_call(obj, &rpc_info);
if (msg_tag_get_val(tag) < 0)
{
handler_free(newfd);
return msg_tag_get_val(tag);
}
*info = rpc_info.data;
return msg_tag_get_val(tag);
}

21
mkrtos_user/lib/sys_svr/src/blk_drv_svr.c
View File

@@ -12,10 +12,9 @@
RPC_GENERATION_OP3(blk_drv_t, BLK_DRV_PROT, BLK_DRV_WRITE, write,
rpc_obj_handler_t_t, rpc_obj_handler_t_t, RPC_DIR_IN, RPC_TYPE_BUF, shm_obj,
rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, len,
rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, inx
)
rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, inx)
{
return blk_drv_write(rpc_hd_get(0), len->data, inx->data);
return blk_drv_write(vpage_create_raw(shm_obj->data).addr, len->data, inx->data);
}
RPC_GENERATION_DISPATCH3(blk_drv_t, BLK_DRV_PROT, BLK_DRV_WRITE, write,
rpc_obj_handler_t_t, rpc_obj_handler_t_t, RPC_DIR_IN, RPC_TYPE_BUF, svr_hd,
@@ -25,10 +24,9 @@ RPC_GENERATION_DISPATCH3(blk_drv_t, BLK_DRV_PROT, BLK_DRV_WRITE, write,
RPC_GENERATION_OP3(blk_drv_t, BLK_DRV_PROT, BLK_DRV_READ, read,
rpc_obj_handler_t_t, rpc_obj_handler_t_t, RPC_DIR_IN, RPC_TYPE_BUF, shm_obj,
rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, len,
rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, inx
)
rpc_int_t, rpc_int_t, RPC_DIR_IN, RPC_TYPE_DATA, inx)
{
return blk_drv_read(rpc_hd_get(0), len->data, inx->data);
return blk_drv_read(vpage_create_raw(shm_obj->data).addr, len->data, inx->data);
}
RPC_GENERATION_DISPATCH3(blk_drv_t, BLK_DRV_PROT, BLK_DRV_READ, read,
@@ -49,7 +47,16 @@ RPC_GENERATION_OP1(blk_drv_t, BLK_DRV_PROT, BLK_DRV_MAP, map,
RPC_GENERATION_DISPATCH1(blk_drv_t, BLK_DRV_PROT, BLK_DRV_MAP, map,
rpc_obj_handler_t_t, rpc_obj_handler_t_t, RPC_DIR_INOUT, RPC_TYPE_BUF, cli_hd)
RPC_DISPATCH3(blk_drv_t, BLK_DRV_PROT, typeof(BLK_DRV_READ), BLK_DRV_WRITE, write, BLK_DRV_READ, read, BLK_DRV_MAP, map)
/*info*/
RPC_GENERATION_OP1(blk_drv_t, BLK_DRV_PROT, BLK_DRV_INFO, info,
rpc_blk_drv_info_t_t, rpc_blk_drv_info_t_t, RPC_DIR_OUT, RPC_TYPE_DATA, info)
{
return blk_drv_info(&info->data);
}
RPC_GENERATION_DISPATCH1(blk_drv_t, BLK_DRV_PROT, BLK_DRV_INFO, info,
rpc_blk_drv_info_t_t, rpc_blk_drv_info_t_t, RPC_DIR_OUT, RPC_TYPE_DATA, len)
RPC_DISPATCH4(blk_drv_t, BLK_DRV_PROT, typeof(BLK_DRV_READ), BLK_DRV_WRITE, write, BLK_DRV_READ, read, BLK_DRV_MAP, map, BLK_DRV_INFO, info)
void blk_drv_init(blk_drv_t *ns)
{

2
mkrtos_user/lib/sys_svr/src/fs_cli.c
View File

@@ -354,7 +354,7 @@ RPC_GENERATION_CALL1(TRUE, fs_t, FS_PROT, FS_UNLINK, unlink,
int fs_unlink(const char *path)
{
obj_handler_t hd;
int ret = ns_query(path, &hd, 0x1);
int ret = ns_query(path, &hd, 0);
if (ret < 0)
{

1
mkrtos_user/lib/sys_util/src/u_fast_ipc.c
View File

@@ -30,6 +30,7 @@ static int fast_ipc_dat_copy(ipc_msg_t *dst_ipc, ipc_msg_t *src_ipc, msg_tag_t t
MIN(tag.msg_buf_len * WORD_BYTES, IPC_MSG_SIZE));
memcpy(dst_ipc->user, src_ipc->user,
sizeof(dst_ipc->user));
return 0;
}
static void update_map_buf(void)
{

22
mkrtos_user/server/fs/appfs/CMakeLists.txt
View File

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.13)
# set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ")
#appfs lib
file(GLOB appfs_src src/appfs.c src/appfs.h)
file(GLOB appfs_src src/appfs.c src/appfs_open.c)
add_library(
appfs_lib
STATIC
@@ -13,6 +13,14 @@ target_include_directories(
appfs_lib
PUBLIC
${CMAKE_CURRENT_SOURCE_DIR}/src
${CMAKE_SOURCE_DIR}/mkrtos_user/lib/sys/inc
${CMAKE_SOURCE_DIR}/mkrtos_user/lib/sys/inc/${ARCH_NAME}
${CMAKE_SOURCE_DIR}/mkrtos_user/user/drv/lib/mk_drv
)
add_dependencies(
appfs_lib
sys
# mk_drv
)
# appfstiny lib
@@ -26,12 +34,17 @@ target_include_directories(
appfs_tiny
PUBLIC
${CMAKE_CURRENT_SOURCE_DIR}/src
# ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/sys/inc
# ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/sys_svr/inc
# ${CMAKE_SOURCE_DIR}/mkrtos_user/lib/sys_util/inc
)
file(
GLOB deps
heap_stack.c
main.c
hw_block.c
fs_rpc.c
)
add_executable(
@@ -49,6 +62,7 @@ target_link_libraries(
sys_util
sys_svr
appfs_lib
mk_drv
${GCC_LIB_PATH}/libgcc.a
)
target_include_directories(
@@ -56,6 +70,7 @@ target_include_directories(
PUBLIC
${CMAKE_SOURCE_DIR}/mkrtos_user/lib/sys/inc
${CMAKE_SOURCE_DIR}/mkrtos_user/lib/sys_svr/inc
${CMAKE_SOURCE_DIR}/mkrtos_user/lib/sys_util/inc
${CMAKE_CURRENT_SOURCE_DIR}/src
)
@@ -65,6 +80,7 @@ add_dependencies(
sys
sys_util
appfs_lib
)
set_target_properties(
appfs.elf PROPERTIES LINK_FLAGS
@@ -89,7 +105,3 @@ add_custom_target(
add_dependencies(appfs_dump appfs.elf)
execute_process(
COMMAND cd ${CMAKE_CURRENT_SOURCE_DIR}/src/ && sh build.sh
COMMAND_ECHO STDOUT
)

405
mkrtos_user/server/fs/appfs/fs_rpc.c
View File

@@ -1,5 +1,4 @@
#include "cons_cli.h"
#include "ff.h"
#include "fs_svr.h"
#include "rpc_prot.h"
#include "u_env.h"
@@ -13,380 +12,81 @@
#include <stdio.h>
#include <string.h>
#include "kstat.h"
#include "appfs_open.h"
static fs_t fs;
static int fs_sig_call_back(pid_t pid, umword_t sig_val);
void fs_svr_init(void)
{
fs_init(&fs);
meta_reg_svr_obj(&fs.svr, FS_PROT);
#ifdef CONFIG_USING_SIG
pm_sig_func_set(fs_sig_call_back);
#endif
}
typedef struct file_desc
{
union
{
FIL fp;
FATFS_DIR dir;
};
pid_t pid;
uint8_t type; //!< 0:file 1:dir
} file_desc_t;
#define FILE_DESC_NR 8 //!< 最多同时可以打开多少个文件
static file_desc_t files[FILE_DESC_NR]; //!< 预先设置的文件描述符
static void free_fd(pid_t pid)
{
for (int i = 0; i < FILE_DESC_NR; i++)
{
if (files[i].fp.obj.fs)
{
fs_svr_close(i);
files[i].fp.obj.fs = NULL;
files[i].pid = 0;
}
}
}
static int fs_sig_call_back(pid_t pid, umword_t sig_val)
{
switch (sig_val)
{
case KILL_SIG:
free_fd(pid);
break;
}
return 0;
}
static file_desc_t *alloc_file(int *fd)
{
for (int i = 0; i < FILE_DESC_NR; i++)
{
if (files[i].fp.obj.fs == NULL)
{
*fd = i;
files[i].pid = thread_get_src_pid();
return &files[i];
}
}
return NULL;
}
static void free_file(int fd)
{
files[fd].fp.obj.fs = NULL;
}
static file_desc_t *file_get(int fd)
{
if (fd < 0 || fd >= FILE_DESC_NR)
{
return NULL;
}
if (files[fd].fp.obj.fs == NULL)
{
return NULL;
}
return files + fd;
}
static int fatfs_err_conv(FRESULT res)
{
switch (res)
{
case FR_OK:
return 0;
case FR_DISK_ERR:
return -EIO;
case FR_NO_FILE:
return -ENOENT;
case FR_NO_PATH:
return -ENOENT;
case FR_INVALID_NAME:
return -EINVAL;
case FR_DENIED:
return -EPERM;
case FR_EXIST:
return -EEXIST;
case FR_WRITE_PROTECTED:
return -EIO;
case FR_TIMEOUT:
return -ETIMEDOUT;
case FR_NOT_ENOUGH_CORE:
return -ENOMEM;
case FR_INVALID_PARAMETER:
return -EINVAL;
default:
return -1;
}
}
int fs_svr_open(const char *path, int flags, int mode)
{
// printf("open %s.\n", path);
int fd;
pid_t pid = thread_get_src_pid();
file_desc_t *file = alloc_file(&fd);
if (!file)
{
return -ENOMEM;
}
int new_mode = 0;
switch (flags & O_ACCMODE)
{
case O_RDWR:
new_mode |= FA_READ;
new_mode |= FA_WRITE;
break;
case O_RDONLY:
new_mode |= FA_READ;
break;
case O_WRONLY:
new_mode |= FA_WRITE;
break;
}
if ((flags & O_CREAT) && (flags & O_EXCL))
{
new_mode |= FA_CREATE_NEW;
}
else if ((flags & O_CREAT))
{
new_mode |= FA_OPEN_ALWAYS;
}
if (flags & O_APPEND)
{
new_mode |= FA_OPEN_APPEND;
}
FRESULT ret = f_open(&file->fp, path, new_mode);
if (ret != FR_OK)
{
if (ret == FR_NO_FILE || ret == FR_INVALID_NAME)
{
// 打开的是一个目录，则作为一个目录打开
ret = f_opendir(&file->dir, path);
if (ret != FR_OK)
{
cons_write_str("open fail..\n");
free_file(fd);
return fatfs_err_conv(ret);
}
file->type = 1;
// cons_write_str("open dir..\n");
}
}
else
{
file->type = 0;
// cons_write_str("open file..\n");
}
if (ret != FR_OK)
{
return fatfs_err_conv(ret);
}
#ifdef CONFIG_USING_SIG
int w_ret = pm_sig_watch(pid, 0 /*TODO:现在只有kill */);
if (w_ret < 0)
{
printf("pm wath pid %d err.\n", w_ret);
}
#endif
fd = appfs_open(path, flags, mode);
return fd;
}
int fs_svr_read(int fd, void *buf, size_t len)
{
UINT br;
file_desc_t *file = file_get(fd);
int ret;
if (!file)
{
return -ENOENT;
}
if (file->type != 0)
{
return -EACCES;
}
FRESULT ret = f_read(&file->fp, buf, len, &br);
ret = appfs_read(fd, buf, len);
if (ret != FR_OK)
{
return fatfs_err_conv(ret);
}
return br;
return ret;
}
int fs_svr_write(int fd, void *buf, size_t len)
{
UINT bw;
file_desc_t *file = file_get(fd);
int ret;
if (!file)
{
return -ENOENT;
}
if (file->type != 0)
{
return -EACCES;
}
FRESULT ret = f_write(&file->fp, buf, len, &bw);
if (ret != FR_OK)
{
return fatfs_err_conv(ret);
}
return bw;
ret = appfs_write(fd, buf, len);
return ret;
}
void fs_svr_close(int fd)
{
file_desc_t *file = file_get(fd);
if (!file)
{
return;
}
switch (file->type)
{
case 0:
f_close(&file->fp);
break;
case 1:
f_closedir(&file->dir);
break;
}
file->fp.obj.fs = NULL;
appfs_close(fd);
}
int fs_svr_readdir(int fd, dirent_t *dir)
{
file_desc_t *file = file_get(fd);
int ret;
if (!file)
{
return -ENOENT;
}
FILINFO info;
FRESULT ret = f_readdir(&file->dir, &info);
if (ret != FR_OK || info.fname[0] == 0)
{
return -ENOENT;
}
strncpy(dir->d_name, info.fname, sizeof(dir->d_name));
dir->d_name[sizeof(dir->d_name) - 1] = 0;
dir->d_reclen = sizeof(*dir);
dir->d_off = 0;
if (info.fattrib & AM_DIR)
{ /* Directory */
dir->d_type = DT_DIR;
}
else
{ /* File */
dir->d_type = DT_CHR;
}
return sizeof(*dir);
ret = appfs_readdir(fd, dir);
return ret;
}
int fs_svr_lseek(int fd, int offs, int whence)
{
UINT bw;
file_desc_t *file = file_get(fd);
int new_offs = 0;
int ret;
if (!file)
{
return -ENOENT;
}
if (file->type != 0)
{
return -EACCES;
}
switch (whence)
{
case SEEK_SET:
new_offs = offs;
break;
case SEEK_END:
{
new_offs = f_size(&file->fp) + offs;
}
break;
case SEEK_CUR:
{
new_offs = offs + f_tell(&file->fp);
}
break;
default:
return -EINVAL;
}
#if 0
if (new_offs > f_size(&file->fp)) {
new_offs = f_size(&file->fp);
}
#endif
if (new_offs < 0)
{
new_offs = 0;
}
FRESULT ret = f_lseek(&file->fp, new_offs);
return fatfs_err_conv(ret);
ret = appfs_lseek(fd, offs, whence);
return ret;
}
int fs_svr_ftruncate(int fd, off_t off)
{
file_desc_t *file = file_get(fd);
int ret;
if (!file)
{
return -ENOENT;
}
if (file->type != 0)
{
return -EACCES;
}
FRESULT ret = f_truncate(&file->fp);
return fatfs_err_conv(ret);
ret = appfs_truncate(fd, off);
return ret;
}
int fs_svr_fstat(int fd, void *_stat)
{
struct kstat *stat = _stat;
file_desc_t *file = file_get(fd);
int ret;
if (!file)
{
return -ENOENT;
}
memset(stat, 0, sizeof(*stat));
stat->st_size = file->type == 1 ? 0 : f_size(&file->fp);
stat->st_mode = file->type == 1 ? S_IFDIR : S_IFREG;
stat->st_blksize = 0;
return 0;
ret = appfs_stat(fd, _stat);
return ret;
}
int fs_svr_ioctl(int fd, int req, void *arg)
{
return 0; /*TODO:*/
int ret;
ret = appfs_ioctl(fd, req, (unsigned long)arg);
return ret;
}
int fs_svr_fsync(int fd)
{
file_desc_t *file = file_get(fd);
if (!file)
{
return -EBADFD;
}
if (file->type != 0)
{
return -EBADFD;
}
f_sync(&file->fp);
return 0;
}
int fs_svr_unlink(const char *path)
{
FRESULT ret = f_unlink(path);
int ret;
return fatfs_err_conv(ret);
ret = appfs_remove(path);
return ret;
}
int fs_svr_symlink(const char *existing, const char *new)
{
@@ -394,9 +94,7 @@ int fs_svr_symlink(const char *existing, const char *new)
}
int fs_svr_mkdir(char *path)
{
FRESULT ret = f_mkdir(path);
return fatfs_err_conv(ret);
return -ENOSYS;
}
int fs_svr_rmdir(char *path)
{
@@ -404,23 +102,11 @@ int fs_svr_rmdir(char *path)
}
int fs_svr_rename(char *oldname, char *newname)
{
return fatfs_err_conv(f_rename(oldname, newname));
return -ENOSYS;
}
int fs_svr_stat(const char *path, void *_buf)
{
FILINFO INFO;
FRESULT ret;
struct kstat *buf = (struct kstat *)_buf;
ret = f_stat(path, &INFO);
if (ret != FR_OK)
{
return fatfs_err_conv(ret);
}
memset(buf, 0, sizeof(*buf));
buf->st_size = INFO.fsize;
buf->st_mode = (INFO.fattrib & AM_DIR) ? S_IFDIR : S_IFREG;
return 0;
return -ENOSYS;
}
ssize_t fs_svr_readlink(const char *path, char *buf, size_t bufsize)
{
@@ -434,4 +120,31 @@ int fs_svr_statfs(const char *path, struct statfs *buf)
void fs_svr_loop(void)
{
rpc_loop();
}
}
static const fs_operations_t ops =
{
.fs_svr_open = fs_svr_open,
.fs_svr_read = fs_svr_read,
.fs_svr_write = fs_svr_write,
.fs_svr_close = fs_svr_close,
.fs_svr_readdir = fs_svr_readdir,
.fs_svr_lseek = fs_svr_lseek,
.fs_svr_ftruncate = fs_svr_ftruncate,
.fs_svr_fstat = fs_svr_fstat,
.fs_svr_ioctl = fs_svr_ioctl,
// .fs_svr_fcntl = fs_svr_fcntl,
.fs_svr_fsync = fs_svr_fsync,
.fs_svr_unlink = fs_svr_unlink,
.fs_svr_symlink = fs_svr_symlink,
.fs_svr_mkdir = fs_svr_mkdir,
.fs_svr_rmdir = fs_svr_rmdir,
.fs_svr_rename = fs_svr_rename,
.fs_svr_stat = fs_svr_stat,
.fs_svr_readlink = fs_svr_readlink,
};
void fs_svr_init(void)
{
fs_init(&fs, &ops);
meta_reg_svr_obj(&fs.svr, FS_PROT);
}

2
mkrtos_user/server/fs/appfs/heap_stack.c
View File

@@ -1,5 +1,5 @@
#define HEAP_SIZE 512
#define HEAP_SIZE (4*1024)
#define STACK_SIZE 1024 * 2
#if defined(__CC_ARM)

137
mkrtos_user/server/fs/appfs/hw_block.c Normal file
View File

@@ -0,0 +1,137 @@
#include "appfs.h"
#include "hw_block_test.h"
#include <assert.h>
#include <dirent.h>
#include <errno.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <u_hd_man.h>
#include <u_vmam.h>
#include <u_prot.h>
#include <u_task.h>
#include <u_factory.h>
#include <u_share_mem.h>
#include <u_sleep.h>
#include <blk_drv_cli.h>
#include <ns_cli.h>
#include <blk_drv_types.h>
static obj_handler_t shm_hd;
static int block_mem_addr = -1;
static int block_nr = -1;
static uint8_t *block_buf; //!< 块缓冲区
static obj_handler_t blk_drv_hd;
static blk_drv_info_t blk_info;
static int hw_erase_block(fs_info_t *fs, int block_inx)
{
int ret;
assert(fs);
assert(block_inx < fs->save.block_nr);
ret = blk_drv_cli_write(blk_drv_hd, shm_hd, 0, block_inx);
return ret;
}
static int hw_write_and_erase_block(fs_info_t *fs, int block_inx, void *buf, int size)
{
int ret;
assert(fs);
assert(buf);
assert(block_inx < fs->save.block_nr);
ret = blk_drv_cli_write(blk_drv_hd, shm_hd, size, block_inx);
return ret;
}
static int hw_read_block(fs_info_t *fs, int block_inx, void *buf, int size)
{
assert(fs);
assert(buf);
assert(block_inx < fs->save.block_nr);
int ret;
ret = blk_drv_cli_read(blk_drv_hd, shm_hd, size, block_inx);
return ret;
}
static int hw_init_fs_for_block(fs_info_t *fs)
{
fs->save.block_size = blk_info.blk_size;
fs->save.block_nr = blk_info.blk_nr;
fs->dev_fd = -1;
fs->mem_addr = (unsigned long)blk_info.blk_start_addr;
fs->buf = (uint32_t *)block_buf;
return 0;
}
static int hw_create_shm_obj(int size, obj_handler_t *shm_obj)
{
msg_tag_t tag;
obj_handler_t shm_hd;
assert(shm_obj);
shm_hd = handler_alloc();
if (shm_hd == HANDLER_INVALID)
{
printf("handler alloc fail.\n");
return -ENOMEM;
}
tag = facotry_create_share_mem(FACTORY_PROT, vpage_create_raw3(KOBJ_ALL_RIGHTS, 0, shm_hd),
SHARE_MEM_CNT_BUDDY_CNT, size);
if (msg_tag_get_prot(tag) < 0)
{
printf("facotry_create_share_mem fail.\n");
handler_free(shm_hd);
return -ENOMEM;
}
*shm_obj = shm_hd;
return 0;
}
int hw_init_block(fs_info_t *fs, const char *dev_path)
{
int ret;
msg_tag_t tag;
addr_t shm_addr;
fs->cb.hw_erase_block = hw_erase_block;
fs->cb.hw_init_fs_for_block = hw_init_fs_for_block;
fs->cb.hw_read_block = hw_read_block;
fs->cb.hw_write_and_erase_block = hw_write_and_erase_block;
again:
ret = ns_query(dev_path, &blk_drv_hd, 0x1);
if (ret < 0)
{
u_sleep_ms(50);
goto again;
}
ret = blk_drv_cli_info(blk_drv_hd, &blk_info);
if (ret < 0)
{
printf("blk info get fail.\n");
return ret;
}
ret = hw_create_shm_obj(blk_info.blk_size, &shm_hd);
if (ret < 0)
{
printf("shm obj create fail.\n");
return ret;
}
tag = share_mem_map(shm_hd, vma_addr_create(VPAGE_PROT_RW, VMA_ADDR_RESV, 0), &shm_addr, NULL);
if (msg_tag_get_prot(tag) < 0)
{
printf("shm mem map fail.\n");
handler_free_umap(shm_hd);
return -ENOMEM;
}
block_buf = (void *)shm_addr;
printf("block_buf addr:0x%x\n", block_buf);
// printf("img size is %d, block nr is %d.\n", block_mem_size, block_nr);
return 0;
}

4
mkrtos_user/server/fs/appfs/hw_block.h Normal file
View File

@@ -0,0 +1,4 @@
#pragma once
#include "appfs.h"
int hw_init_block(fs_info_t *fs, const char *dev_path);

80
mkrtos_user/server/fs/appfs/main.c
View File

@@ -1,8 +1,84 @@
#include <stdio.h>
#include "u_log.h"
#include "ns_cli.h"
#include "u_rpc_svr.h"
#include "u_prot.h"
#include "u_env.h"
#include "u_task.h"
#include "cons_cli.h"
#include "fs_rpc.h"
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <getopt.h>
#include <u_fast_ipc.h>
#include "appfs.h"
#include "hw_block.h"
#include "appfs_open.h"
#define STACK_COM_ITME_SIZE (2 * 1024)
ATTR_ALIGN(8)
uint8_t stack_coms[STACK_COM_ITME_SIZE];
uint8_t msg_buf_coms[MSG_BUG_LEN];
int main(int argv, char *argc[])
static fs_info_t fs_obj;
void fast_ipc_init(void)
{
printf("%s run.\n", argc[0]);
u_fast_ipc_init(stack_coms, msg_buf_coms, 1, STACK_COM_ITME_SIZE);
}
int main(int argc, char *argv[])
{
obj_handler_t hd;
int ret;
char *mount_path = NULL;
char *dev_path = NULL;
task_set_obj_name(TASK_THIS, TASK_THIS, "tk_appfs");
task_set_obj_name(TASK_THIS, THREAD_MAIN, "th_appfs");
for (int i = 0; i < argc; i++)
{
printf("args[%d]:%s\n", i, argv[i]);
}
fast_ipc_init();
int o;
const char *optstring = "d:m:"; // 有三个选项-abc，其中c选项后有冒号，所以后面必须有参数
while ((o = getopt(argc, argv, optstring)) != -1)
{
switch (o)
{
case 'd':
dev_path = optarg;
break;
case 'm':
printf("mount path:%s\n", optarg);
mount_path = optarg;
break;
case '?':
printf("error optopt: %c\n", optopt);
printf("error opterr: %d\n", opterr);
break;
}
}
if (dev_path == NULL || mount_path == NULL)
{
printf("dev or mout path don't setting.\n");
printf("example:appfs -m /bin -d /block\n");
return -1;
}
ret = hw_init_block(&fs_obj, dev_path);
assert(ret >= 0);
ret = appfs_init(&fs_obj);
assert(ret >= 0);
ret = appfs_open_init(&fs_obj);
assert(ret >= 0);
ret = rpc_meta_init(THREAD_MAIN, &hd);
assert(ret >= 0);
fs_svr_init();
ns_register(mount_path, hd, MOUNT_NODE);
cons_write_str("appfs mount success\n");
fs_svr_loop();
return 0;
}

5
mkrtos_user/server/fs/appfs/src/CMakeLists.txt
View File

@@ -1,7 +1,10 @@
cmake_minimum_required(VERSION 3.5.0)
project(appfs VERSION 0.1.0 LANGUAGES C)
set(CMAKE_BUILD_TYPE Debug)
add_executable(appfs appfs.c hw_block_test.c hw_block_sim.c main.c test.c open.c)
add_executable(appfs appfs.c hw_block_test.c hw_block_sim.c main.c test.c appfs_open.c)
add_compile_options(
"-Werror"
)
include(CTest)
enable_testing()

50
mkrtos_user/server/fs/appfs/src/appfs.c
View File

@@ -17,9 +17,12 @@ int appfs_init(fs_info_t *fs)
fs->cb.hw_init_fs_for_block(fs);
fs_info_t *fs_info = (fs_info_t *)fs->mem_addr;
ret = fs->cb.hw_read_block(fs, 0, fs_info, MIN(sizeof(fs_info_t), fs->save.block_size));
*fs = *fs_info;
// ret = fs->cb.hw_read_block(fs, 0, fs->buf, fs->save.block_size);
// if (ret >= 0)
// {
// memcpy(fs, fs->buf, sizeof(fs_info_t));
// }
fs->save = fs_info->save;
return ret;
}
static int mem_set_bits(uint32_t *buf, int start, int end)
@@ -54,6 +57,47 @@ static int mem_clear_bits(uint32_t *buf, int start, int end)
return 0;
}
static int appfs_get_available_block_nr(fs_info_t *info)
{
assert(info);
int ret;
int j = 0;
int block_nr = 0;
int total_nr = 0;
for (int i = info->save.blockinfo_inx; i < (info->save.blockinfo_nr + info->save.blockinfo_inx) && j < info->save.block_nr; i++, j++)
{
ret = info->cb.hw_read_block(info, i, info->buf, info->save.block_size);
if (ret < 0)
{
return ret;
}
uint32_t *buf_ptr = (uint32_t *)info->buf;
for (int a = 0; a < info->save.block_size / BYPTE_PER_PTR; a++)
{
for (int m = 0; m < BITS_PER_PTR; m++)
{
total_nr++;
if ((buf_ptr[a] & (1UL << m)))
{
block_nr++;
}
if (total_nr >= info->save.block_nr)
{
goto end;
}
}
}
}
end:
return block_nr;
}
int appfs_get_available_size(fs_info_t *info)
{
assert(info);
return appfs_get_available_block_nr(info) * info->save.block_size;
}
/**
* 设置块中的某些位为1
*/

6
mkrtos_user/server/fs/appfs/src/appfs.h
View File

@@ -75,8 +75,12 @@ int appfs_delete_file(fs_info_t *info, const char *name);
int appfs_file_resize_raw(fs_info_t *info, const dir_info_t *dir_info, int size);
int appfs_file_resize(fs_info_t *info, const char *name, int size);
int appfs_arrange_files(fs_info_t *info);
int appfs_get_available_size(fs_info_t *info);
int appfs_print_files(fs_info_t *info);
static inline int appfs_get_total_size(fs_info_t *info)
{
return info->save.block_nr * info->save.block_size;
}
static inline int appfs_get_file_size(const dir_info_t *info)
{
return info->size;

41
mkrtos_user/server/fs/appfs/src/open.c → mkrtos_user/server/fs/appfs/src/appfs_open.c
View File

@@ -1,9 +1,8 @@
#include "open.h"
#include "appfs_open.h"
#include <stdio.h>
#include <sys/types.h>
#include <errno.h>
#include <assert.h>
#include <pthread.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
@@ -224,9 +223,17 @@ int appfs_read(int fd, void *data, int len)
file->offset += ret;
return ret;
}
#ifdef MKRTOS
#include <u_prot.h>
#include <u_task.h>
#include <u_thread.h>
#include <mk_access.h>
#endif
int appfs_ioctl(int fd, unsigned long cmd, unsigned long arg)
{
#ifdef MKRTOS
pid_t src_pid = thread_get_src_pid();
#endif
appfs_file_t *file = appfs_get_file(fd);
int ret = 0;
@@ -242,9 +249,32 @@ int appfs_ioctl(int fd, unsigned long cmd, unsigned long arg)
{
case APPFS_IOCTOL_GET_ACCESS_ADDR:
{
appfs_ioctl_arg_t *fs_arg = (void *)arg;
appfs_ioctl_arg_t *fs_arg;
#ifdef MKRTOS
msg_tag_t tag;
appfs_ioctl_arg_t fs_arg_tmp;
umword_t cur_pid;
tag = task_get_pid(TASK_THIS, (umword_t *)(&cur_pid));
if (msg_tag_get_val(tag) < 0)
{
return msg_tag_get_val(tag);
}
fs_arg = &fs_arg_tmp;
#else
fs_arg = (void *)arg;
#endif
fs_arg->addr = appfs_get_file_addr(fs, dir_info_cache_list[file->dir_info_fd].info);
fs_arg->size = appfs_get_file_size(dir_info_cache_list[file->dir_info_fd].info);
#ifdef MKRTOS
ret = mk_copy_mem_to_task(cur_pid, fs_arg, src_pid,
(void*)arg, sizeof(appfs_ioctl_arg_t));
if (ret < 0)
{
return ret;
}
#endif
}
break;
default:
@@ -364,7 +394,7 @@ int appfs_stat(int fd, struct stat *st)
return -EACCES;
}
st->st_size = dir_info_cache_list[file->dir_info_fd].info->size;
st->st_mode = __S_IFREG;
st->st_mode = S_IFREG;
st->st_nlink = dir_info_cache_list[file->dir_info_fd].info->ref;
return 0;
}
@@ -421,6 +451,7 @@ int appfs_remove(const char *name)
int appfs_readdir(int fd, struct dirent *_dir)
{
int ret = -1;
// *((char*)(0)) = 0;
appfs_file_t *file = appfs_get_file(fd);
if (!file || file->used == 0)

1
mkrtos_user/server/fs/appfs/src/open.h → mkrtos_user/server/fs/appfs/src/appfs_open.h
View File

@@ -9,6 +9,7 @@ enum appfs_ioctl_cmd_op
typedef struct appfs_ioctl_arg
{
unsigned long addr;
unsigned long size;
} appfs_ioctl_arg_t;
int appfs_open(const char *name, int flags, int mode);

2
mkrtos_user/server/fs/appfs/src/build.sh
View File

@@ -1,5 +1,7 @@
#!/bin/bash
set -e -x
mkdir -p build
cmake -G Ninja -B build .
cd build && ninja

5
mkrtos_user/server/fs/appfs/src/clean.sh Executable file
View File

@@ -0,0 +1,5 @@
#!/bin/bash
set -e -x
rm -r build

43
mkrtos_user/server/fs/appfs/src/hw_block_sim.c
View File

@@ -12,12 +12,11 @@
#include <sys/types.h>
#include <unistd.h>
#define BLOCK_SIZE 512 //!< 块大小
static int block_size = -1;
static int block_mem_size = -1;
static int block_nr = -1;
static uint8_t *block; // 32MB
static uint8_t block_buf[BLOCK_SIZE]; //!< 块缓冲区
static uint8_t *block; // 32MB
static uint8_t *block_buf; //!< 块缓冲区
static int hw_erase_block(fs_info_t *fs, int block_inx)
{
@@ -45,7 +44,7 @@ static int hw_read_block(fs_info_t *fs, int block_inx, void *buf, int size)
}
static int hw_init_fs_for_block(fs_info_t *fs)
{
fs->save.block_size = BLOCK_SIZE;
fs->save.block_size = block_size;
fs->save.block_nr = block_nr;
fs->dev_fd = -1; // 模拟设备没有文件描述符
fs->mem_addr = (unsigned long)block;
@@ -117,15 +116,30 @@ int hw_offload_img_from_file(const char *name)
free(ptr_file_content);
return 0;
}
int hw_dump_to_file(const char *name)
int hw_dump_to_file(fs_info_t *fs, const char *name, int mode)
{
int ret;
unlink(name);
int fd = open(name, O_RDWR | O_CREAT, 0777);
if (fd < 0)
{
printf("%s file open faile %d.\n", name, fd);
return fd;
}
ret = write(fd, block, block_mem_size);
int write_size;
if (mode)
{
write_size = appfs_get_total_size(fs) - appfs_get_available_size(fs);
}
else
{
write_size = block_mem_size;
}
printf("write img size is %dB.\n", write_size);
ret = write(fd, block, write_size);
if (ret < 0)
{
return ret;
@@ -133,7 +147,7 @@ int hw_dump_to_file(const char *name)
close(fd);
return 0;
}
int hw_init_block_sim_test(fs_info_t *fs, int img_size)
int hw_init_block_sim_test(fs_info_t *fs, int img_size, int blk_size)
{
fs->cb.hw_erase_block = hw_erase_block;
fs->cb.hw_init_fs_for_block = hw_init_fs_for_block;
@@ -145,9 +159,16 @@ int hw_init_block_sim_test(fs_info_t *fs, int img_size)
{
return -ENOMEM;
}
block_mem_size = (img_size / BLOCK_SIZE) * BLOCK_SIZE;
block_nr = img_size / BLOCK_SIZE;
printf("img size is %d, block nr is %d.\n", block_mem_size, block_nr);
block_buf = (void *)malloc(blk_size);
if (block_buf == NULL)
{
free(block);
return -ENOMEM;
}
block_size = blk_size;
block_mem_size = (img_size / blk_size) * blk_size;
block_nr = img_size / blk_size;
printf("img size is %d, block nr is %d, block_size %d.\n", block_mem_size, block_nr, blk_size);
// 使用内存模拟一个块设备
memset(block, 0, block_mem_size);
return 0;

4
mkrtos_user/server/fs/appfs/src/hw_block_sim.h
View File

@@ -1,6 +1,6 @@
#pragma once
#include "appfs.h"
int hw_dump_to_file(const char *name);
int hw_init_block_sim_test(fs_info_t *fs, int img_size);
int hw_dump_to_file(fs_info_t *fs, const char *name, int mode);
int hw_init_block_sim_test(fs_info_t *fs, int img_size, int block_size);
int hw_read_file_all(const char *file_path, void **ret_ptr);
int hw_offload_img_from_file(const char *name);

17
mkrtos_user/server/fs/appfs/src/main.c
View File

@@ -130,11 +130,13 @@ int read_files_and_write_appfs(const char *path)
}
static char *debug_img_path;
static int gen_img_size = -1;
static int gen_img_blk_size = 4096;
static int slight_mode = 0; //! 瘦模式
static int appfs_gen_init(void)
{
int ret;
ret = hw_init_block_sim_test(&fs, gen_img_size);
ret = hw_init_block_sim_test(&fs, gen_img_size, gen_img_blk_size);
if (ret < 0)
{
return ret;
@@ -152,7 +154,7 @@ int main(int argc, char *argv[])
int ret = 0;
// appfs_test_func();
while ((opt = getopt(argc, argv, "ti:g:o:s:")) != -1)
while ((opt = getopt(argc, argv, "jti:g:o:s:b:")) != -1)
{
switch (opt)
{
@@ -160,6 +162,9 @@ int main(int argc, char *argv[])
printf("test mode.\n");
appfs_test_func();
return 0;
case 'j':
slight_mode = 1;
break;
case 'i':
printf("input img:%s\n", optarg);
debug_img_path = optarg;
@@ -176,6 +181,10 @@ int main(int argc, char *argv[])
gen_img_size = atol(optarg);
printf("img size is %d.\n", gen_img_size);
break;
case 'b':
gen_img_blk_size = atol(optarg);
printf("img blk size is %d.\n", gen_img_blk_size);
break;
default:
printf("Unknown option\n");
break;
@@ -188,7 +197,7 @@ int main(int argc, char *argv[])
}
if (gen_img_size < 0)
{
printf("output img size don't set.");
printf("output img size don't set.\n");
return -1;
}
if (output_path == NULL)
@@ -207,7 +216,7 @@ int main(int argc, char *argv[])
printf("appfs create failed\n");
return ret;
}
ret = hw_dump_to_file(output_path);
ret = hw_dump_to_file(&fs, output_path, slight_mode);
if (ret < 0)
{
printf("appfs dump failed\n");

2
mkrtos_user/server/fs/appfs/src/test.c
View File

@@ -8,7 +8,7 @@
#include <sys/fcntl.h>
#include "appfs.h"
#include "hw_block_test.h"
#include "open.h"
#include "appfs_open.h"
static fs_info_t fs;
#define APPFS_FILE_NR 128

6
mkrtos_user/server/fs/appfs/src/test.sh
View File

@@ -1,5 +1,5 @@
#!/bin/bash
./build/appfs -g test -o out.img
./build/appfs -t
set -xe
./build/appfs -g test -o out.img -s 33554432 -b 4096 -j
# ./build/appfs -t

2
mkrtos_user/server/fs/cpiofs/fs_rpc.c
View File

@@ -92,7 +92,7 @@ int fs_svr_open(const char *path, int flags, int mode)
int pid = thread_get_src_pid();
msg_tag_t tag;
char *o_path;
*((char *)0) = 0;
// *((char *)0) = 0;
if (flags & O_RDWR)
{

4
mkrtos_user/server/init/CMakeLists.txt
View File

@@ -50,8 +50,6 @@ add_custom_target(
init_dump ALL
COMMAND
${CMAKE_OBJDUMP} -s -S init.elf > ${CMAKE_SOURCE_DIR}/build/output/init.S
# COMMAND
# ${CMAKE_READELF} -a init.elf > ${CMAKE_SOURCE_DIR}/build/output/init.txt
COMMAND
${CMAKE_OBJCOPY} -O binary -S init.elf init.bin
COMMAND
@@ -59,7 +57,7 @@ add_custom_target(
COMMAND
${CMAKE_COMMAND} -E copy init.bin ${CMAKE_SOURCE_DIR}/build/output/cpio/init
COMMAND
${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_LIST_DIR}/src/init.cfg ${CMAKE_SOURCE_DIR}/build/output/cpio/
${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_LIST_DIR}/board/${CONFIG_BOARD_NAME}/init.cfg ${CMAKE_SOURCE_DIR}/build/output/cpio/
COMMAND
${CMAKE_COMMAND} -E copy init.elf ${CMAKE_SOURCE_DIR}/build/output/init.elf
)

5
mkrtos_user/server/init/src/init.cfg → mkrtos_user/server/init/board/ATSURFF437/init.cfg
View File

@@ -1,7 +1,8 @@
#一次读取一行，每行代表启动的应用程序
block /block
appfs -m /bin -d /block
# cpiofs -m /bin
# fatfs
cpiofs -m /bin
fatfs
# pin
# i2c
# pca9555

14
mkrtos_user/server/init/board/STM32F205/init.cfg Normal file
View File

@@ -0,0 +1,14 @@
#一次读取一行，每行代表启动的应用程序
block /block
appfs -m /bin -d /block
# cpiofs -m /bin
# fatfs
# pin
# i2c
# pca9555
# display
# eth
# snd
# net
# nes
sh

2
mkrtos_user/user/app/ATSURFF437/nes_simulator/CMakeLists.txt
View File

@@ -80,6 +80,8 @@ add_custom_target(
${CMAKE_COMMAND} -E copy nes.bin ${CMAKE_SOURCE_DIR}/build/output/cpio/nes
COMMAND
cp nes.elf ${CMAKE_SOURCE_DIR}/build/output/nes.elf
COMMAND
cp ${CMAKE_CURRENT_SOURCE_DIR}/nes_rom/sm.nes ${CMAKE_SOURCE_DIR}/build/output/cpio/
)
add_dependencies(nes_dump nes.elf)

169
mkrtos_user/user/app/ATSURFF437/nes_simulator/main.c
View File

@@ -12,142 +12,55 @@
#include <u_task.h>
#include <string.h>
#include "mk_display_drv.h"
mk_display_cfg_t info;
int fd;
int pin_fd;
void delay_ms(int ms)
{
u_sleep_ms(ms);
}
// #define BGR565TORGB565(a) (((a) >> 11) | ((a) & (0x3f << 5)) | (a & 0x1f) << 11)
// void nes_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;
// #if 0
// lcd_windows_set(sx, sy, ex, ey);
// for (i = 0; i < height; i++)
// {
// for (j = 0; j < width; j++)
// {
// lcd_data_16bit_write(BGR565TORGB565(color[i * width + j]));
// }
// }
// #else
// memcpy(dis_buff[dis_show_line++], color, sizeof(uint16_t) * 256);
// if (dis_show_line >= 120)
// {
// ioctl(fd, MK_DISPLAY_SET_WIN, &((mk_display_win_t){
// .x = 0,
// .y = dis_offset,
// .w = 256,
// .h = 120,
// }));
// for (int j = 0; j < 120; j++)
// {
// for (int i = 0; i < 256; i++)
// {
// *(volatile uint16_t *)(info.display_addr) = BGR565TORGB565(dis_buff[j][i]);
// }
// }
// if (dis_offset == 0)
// {
// dis_offset = 120;
// }
// else
// {
// dis_offset = 0;
// }
// dis_show_line = 0;
// }
// #endif
// }
// static uint32_t last_tick;
// static uint32_t frame_flag;
// void NES_LCD_DisplayLine(int y_axes, uint16_t *Disaplyline_buffer)
// {
// memcpy(dis_buff[dis_show_line++], Disaplyline_buffer, sizeof(uint16_t) * 256);
// if (dis_show_line >= 120)
// {
// ioctl(fd, MK_DISPLAY_SET_WIN, &((mk_display_win_t){
// .x = 0,
// .y = dis_offset,
// .w = 256,
// .h = 120,
// }));
// for (int j = 0; j < 120; j++)
// {
// for (int i = 0; i < 256; i++)
// {
// *(volatile uint16_t *)(info.display_addr) = dis_buff[j][i];
// }
// }
// if (dis_offset == 0)
// {
// frame_flag = !frame_flag;
// if (frame_flag == 0)
// {
// last_tick = sys_read_tick();
// }
// else
// {
// printf("fps:%d\n", (1000 / ((sys_read_tick() - last_tick) * (5))) * 3);
// }
// dis_offset = 120;
// }
// else
// {
// dis_offset = 0;
// }
// dis_show_line = 0;
// }
// }
#if 0
static int drv_iomem_init(void)
{
addr_t addr;
msg_tag_t tag;
tag = u_vmam_alloc(VMA_PROT, vma_addr_create(VPAGE_PROT_RWX, 0, 0),
XMC_MEM_BASE - PERIPH_BASE, PERIPH_BASE, &addr);
if (msg_tag_get_val(tag) < 0)
{
printf("periph mem alloc failed..\n");
return -1;
}
tag = u_vmam_alloc(VMA_PROT, vma_addr_create(VPAGE_PROT_RWX, 0, 0),
0x4000000, XMC_MEM_BASE, &addr);
if (msg_tag_get_val(tag) < 0)
{
printf("periph mem alloc failed..\n");
return -1;
}
tag = u_vmam_alloc(VMA_PROT, vma_addr_create(VPAGE_PROT_RWX, 0, 0),
0x10000, XMC_REG_BASE, &addr);
if (msg_tag_get_val(tag) < 0)
{
printf("periph mem alloc failed..\n");
return -1;
}
return 0;
}
#endif
#include "nes_main.h"
#include "mk_pin_drv.h"
#include "pca9555.h"
#include "joystick.h"
#include "appfs_open.h"
mk_display_cfg_t info;
int fd;
int pin_fd;
int nes_fd;
static addr_t nes_rom_addr;
static size_t new_rom_size;
void delay_ms(int ms)
{
u_sleep_ms(ms);
}
static int new_rom_get(const char *path)
{
int ret;
appfs_ioctl_arg_t appfs_arg;
extern const char nes_rom[];
extern const char nes_rom_end[];
nes_fd = open(path, O_RDONLY, 0777);
if (nes_fd < 0)
{
return nes_fd;
}
ret = ioctl(nes_fd, APPFS_IOCTOL_GET_ACCESS_ADDR, &appfs_arg);
if (ret < 0)
{
close(nes_fd);
return ret;
}
nes_rom_addr = appfs_arg.addr;
new_rom_size = appfs_arg.size;
return 0;
}
int main(int argc, char *argv[])
{
if (argc < 2)
{
printf("nes rom is NULL.\n");
return -1;
}
task_set_obj_name(TASK_THIS, TASK_THIS, "tk_nes");
task_set_obj_name(TASK_THIS, THREAD_MAIN, "th_nes");
if (new_rom_get(argv[1]) < 0)
{
printf("rom don't finded.\n");
return -1;
}
// thread_run(-1, 4);
printf("nes init..\n");
#if 0
@@ -221,6 +134,6 @@ again:
.w = 256,
.h = 240,
}));
nes_load((uint8_t *)nes_rom, (umword_t)(nes_rom_end - nes_rom));
nes_load((uint8_t *)nes_rom_addr, (umword_t)(new_rom_size));
return 0;
}

2
mkrtos_user/user/app/ATSURFF437/nes_simulator/nes.S
View File

@@ -2,7 +2,7 @@
.balign 4
.global nes_rom
nes_rom:
.incbin "/home/zhangzheng/projects/mkrtos-real/mkrtos_user/user/app/ATSURFF437/nes_simulator/nes_rom/超级马里奥兄弟3[MM之神汉化](JP)[ACT](3Mb).nes"
@ .incbin "/home/zhangzheng/projects/mkrtos-real/mkrtos_user/user/app/ATSURFF437/nes_simulator/nes_rom/超级马里奥兄弟3[MM之神汉化](JP)[ACT](3Mb).nes"
.global nes_rom_end
nes_rom_end:
.long 0

0
mkrtos_user/user/app/ATSURFF437/nes_simulator/nes_rom/超级玛丽.nes → mkrtos_user/user/app/ATSURFF437/nes_simulator/nes_rom/sm.nes
View File

BIN
mkrtos_user/user/app/ATSURFF437/nes_simulator/nes_rom/三国志英杰传 (吞食天地1) (繁体中文版)[外星科技汉化](JP)[RPG](4Mb).nes
View File

Binary file not shown.

BIN
mkrtos_user/user/app/ATSURFF437/nes_simulator/nes_rom/三目童子[Flow Wolf汉化](JP)[ACT](2Mb).nes
View File

Binary file not shown.

BIN
mkrtos_user/user/app/ATSURFF437/nes_simulator/nes_rom/双截龙3 (v1.1)[星空汉化](US)[ACT](2.5Mb).nes
View File

Binary file not shown.

BIN
mkrtos_user/user/app/ATSURFF437/nes_simulator/nes_rom/吞食天地[酷哥电子](JP)[RPG](4Mb).nes
View File

Binary file not shown.

BIN
mkrtos_user/user/app/ATSURFF437/nes_simulator/nes_rom/超级马里奥兄弟3[MM之神汉化](JP)[ACT](3Mb).nes
View File

Binary file not shown.

BIN
mkrtos_user/user/app/ATSURFF437/nes_simulator/nes_rom/魂斗罗[九班汉化](JP)[ACT](2Mb).nes
View File

Binary file not shown.

86
mkrtos_user/user/drv/ATSURFF437/block/flash.c
View File

@@ -1,50 +1,93 @@
#include "flash.h"
#include "at32f435_437_conf.h"
#include <assert.h>
#include <errno.h>
#include <stdio.h>
#include "u_sys.h"
#include "u_prot.h"
#include <u_vmam.h>
#if defined(AT32F437xM) || defined(AT32F435xM) || defined(AT32F437xD) || defined(AT32F435xD)
#define SECTOR_SIZE 4096 /* this parameter depends on the specific model of the chip */
#else
#define SECTOR_SIZE 2048 /* this parameter depends on the specific model of the chip */
#endif
static sys_info_t sys_info;
int flash_get_sector_size(void)
int flash_get_sector_size(umword_t *mem_addr, int *blk_size, int *blk_nr)
{
return SECTOR_SIZE;
assert(blk_size);
assert(mem_addr);
assert(blk_nr);
msg_tag_t tag;
tag = sys_read_info(SYS_PROT, &sys_info, 0);
if (msg_tag_get_val(tag) < 0)
{
return -ENOENT;
}
*mem_addr = sys_info.bootfs_start_addr;
*blk_size = SECTOR_SIZE;
*blk_nr = (CONFIG_SYS_TEXT_SIZE - CONFIG_BOOTSTRAP_TEXT_SIZE - CONFIG_KNL_TEXT_SIZE - CONFIG_DTBO_TEXT_SIZE) / SECTOR_SIZE;
printf("flash mem_addr:0x%x blk_size:0x%x blk_nr:0x%x\n", *mem_addr, *blk_size, *blk_nr);
return 0;
}
int flash_read_sector(uint32_t sector_inx, uint32_t *p_buffer, uint16_t num_read)
{
uint16_t i;
uint32_t read_addr;
if (num_read < SECTOR_SIZE / 4) {
if (num_read < SECTOR_SIZE / 4)
{
return -1;
}
read_addr = sector_inx * SECTOR_SIZE + FLASH_BASE;
read_addr = sector_inx * SECTOR_SIZE + sys_info.bootfs_start_addr;
for (i = 0; i < num_read; i++) {
for (i = 0; i < num_read; i++)
{
p_buffer[i] = *(uint32_t *)(read_addr);
read_addr += 4;
}
return num_read;
}
int flash_erase_sector(uint32_t sector_inx)
{
flash_status_type status = FLASH_OPERATE_DONE;
flash_unlock();
status = flash_sector_erase(sector_inx * SECTOR_SIZE + sys_info.bootfs_start_addr);
if (status != FLASH_OPERATE_DONE)
{
flash_lock();
return -1;
}
flash_lock();
return 0;
}
int flash_write_sector(uint32_t sector_inx, uint32_t *p_buffer, uint16_t num_write)
{
flash_status_type status = FLASH_OPERATE_DONE;
uint32_t write_addr = sector_inx * SECTOR_SIZE + FLASH_BASE;
uint32_t write_addr = sector_inx * SECTOR_SIZE + sys_info.bootfs_start_addr;
if (num_write < SECTOR_SIZE / 4) {
if (num_write < SECTOR_SIZE / 4)
{
return -1;
}
flash_unlock();
status = flash_sector_erase(sector_inx * SECTOR_SIZE + FLASH_BASE);
if (status != FLASH_OPERATE_DONE) {
status = flash_sector_erase(sector_inx * SECTOR_SIZE + sys_info.bootfs_start_addr);
if (status != FLASH_OPERATE_DONE)
{
flash_lock();
return -1;
}
for (int i = 0; i < num_write; i++) {
for (int i = 0; i < num_write; i++)
{
status = flash_word_program(write_addr, p_buffer[i]);
if (status != FLASH_OPERATE_DONE) {
if (status != FLASH_OPERATE_DONE)
{
flash_lock();
return -1;
}
@@ -53,3 +96,24 @@ int flash_write_sector(uint32_t sector_inx, uint32_t *p_buffer, uint16_t num_wri
flash_lock();
return num_write;
}
int flash_init(void)
{
msg_tag_t tag;
addr_t vaddr;
tag = u_vmam_alloc(VMA_PROT, vma_addr_create(VPAGE_PROT_RW, 0, 0),
0x400 /*TODO:*/, 0x40023C00, &vaddr);
if (msg_tag_get_val(tag) < 0)
{
return msg_tag_get_val(tag);
}
tag = u_vmam_alloc(VMA_PROT, vma_addr_create(VPAGE_PROT_RW, 0, 0),
32 * 1024 * 1024 /*TODO:*/, 0x8000000, &vaddr);
if (msg_tag_get_val(tag) < 0)
{
return msg_tag_get_val(tag);
}
return 0;
}

4
mkrtos_user/user/drv/ATSURFF437/block/flash.h
View File

@@ -2,6 +2,8 @@
#include <u_types.h>
int flash_get_sector_size(void);
int flash_read_sector(uint32_t sector_inx, uint32_t *p_buffer, uint16_t num_read);
int flash_write_sector(uint32_t sector_inx, uint32_t *p_buffer, uint16_t num_write);
int flash_get_sector_size(umword_t *mem_addr, int *blk_size, int *blk_nr);
int flash_erase_sector(uint32_t sector_inx);
int flash_init(void);

68
mkrtos_user/user/drv/ATSURFF437/block/main.c
View File

@@ -30,17 +30,26 @@ int blk_drv_write(obj_handler_t obj, int len, int inx)
int ret = -1;
addr_t addr = 0;
umword_t size = 0;
msg_tag_t tag = share_mem_map(obj, vma_addr_create(VPAGE_PROT_RWX, 0, 0), &addr, &size);
msg_tag_t tag;
if (msg_tag_get_val(tag) < 0) {
handler_free_umap(obj);
printf("net write error.\n");
return msg_tag_get_val(tag);
if (len == 0)
{
ret = flash_erase_sector(inx);
}
ret = flash_write_sector(inx, (void *)addr, len / 4);
handler_free_umap(obj);
if (ret < 0) {
else
{
tag = share_mem_map(obj, vma_addr_create(VPAGE_PROT_RWX, 0, 0), &addr, &size);
if (msg_tag_get_val(tag) < 0)
{
handler_free_umap(obj);
printf("net write error.\n");
return msg_tag_get_val(tag);
}
ret = flash_write_sector(inx, (void *)addr, len / 4);
handler_free_umap(obj);
}
if (ret < 0)
{
return ret;
}
return ret * 4;
@@ -50,12 +59,19 @@ int blk_drv_read(obj_handler_t obj, int len, int inx)
int ret = -1;
addr_t addr = 0;
umword_t size = 0;
msg_tag_t tag = share_mem_map(obj, vma_addr_create(VPAGE_PROT_RWX, 0, 0), &addr, &size);
uint32_t _err;
msg_tag_t tag = share_mem_map(obj, vma_addr_create(VPAGE_PROT_RWX, 0, 0), &addr, &size);
if (msg_tag_get_val(tag) < 0)
{
handler_free_umap(obj);
printf("net write error.\n");
return msg_tag_get_val(tag);
}
ret = flash_read_sector(inx, (void *)addr, len / 4);
handler_free_umap(obj);
if (ret < 0) {
if (ret < 0)
{
return ret;
}
return ret * 4;
@@ -64,22 +80,48 @@ int blk_drv_map(obj_handler_t *hd)
{
return -ENOSYS;
}
int blk_drv_info(blk_drv_info_t *info)
{
umword_t mem_addr;
int blk_size;
int blk_nr;
int ret;
ret = flash_get_sector_size(&mem_addr, &blk_size, &blk_nr);
if (ret < 0)
{
return ret;
}
info->blk_nr = blk_nr;
info->blk_size = blk_size;
info->blk_start_addr = mem_addr;
return 0;
}
int main(int argc, char *argv[])
{
obj_handler_t hd;
int ret;
if (argc < 2)
{
printf("please set dev path.\n");
printf("example:block /block");
return -1;
}
task_set_obj_name(TASK_THIS, TASK_THIS, "tk_blk");
task_set_obj_name(TASK_THIS, THREAD_MAIN, "th_blk");
printf("%s init..\n", argv[0]);
fast_ipc_init();
flash_init();
blk_drv_init(&blk_drv);
ret = rpc_meta_init(THREAD_MAIN, &hd);
assert(ret >= 0);
ns_register("/block", hd, FILE_NODE);
ns_register(argv[1], hd, FILE_NODE);
meta_reg_svr_obj(&blk_drv.svr, BLK_DRV_PROT);
while (1) {
while (1)
{
rpc_loop();
}
}

34
mkrtos_user/user/drv/ATSURFF437/display/fs_rpc.c
View File

@@ -80,13 +80,7 @@ static void fd_free(int fd)
}
}
}
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();
@@ -342,4 +336,32 @@ int fs_svr_statfs(const char *path, struct statfs *buf)
void fs_svr_loop(void)
{
rpc_loop();
}
static const fs_operations_t ops =
{
.fs_svr_open = fs_svr_open,
.fs_svr_read = fs_svr_read,
.fs_svr_write = fs_svr_write,
.fs_svr_close = fs_svr_close,
.fs_svr_readdir = fs_svr_readdir,
.fs_svr_lseek = fs_svr_lseek,
.fs_svr_ftruncate = fs_svr_ftruncate,
.fs_svr_fstat = fs_svr_fstat,
.fs_svr_ioctl = fs_svr_ioctl,
// .fs_svr_fcntl = fs_svr_fcntl,
.fs_svr_fsync = fs_svr_fsync,
.fs_svr_unlink = fs_svr_unlink,
.fs_svr_symlink = fs_svr_symlink,
.fs_svr_mkdir = fs_svr_mkdir,
.fs_svr_rmdir = fs_svr_rmdir,
.fs_svr_rename = fs_svr_rename,
.fs_svr_stat = fs_svr_stat,
.fs_svr_readlink = fs_svr_readlink,
};
void fs_svr_init(void)
{
msg_tag_t tag;
fs_init(&fs, &ops);
meta_reg_svr_obj(&fs.svr, FS_PROT);
}

4
mkrtos_user/user/drv/ATSURFF437/eth/main.c
View File

@@ -66,6 +66,10 @@ int blk_drv_map(obj_handler_t *hd)
*hd = emac_get_sema();
return 0;
}
int blk_drv_info(blk_drv_info_t *info)
{
return -ENOSYS;
}
int main(int argc, char *argv[])
{
obj_handler_t hd;

36
mkrtos_user/user/drv/ATSURFF437/i2c/fs_rpc.c
View File

@@ -80,13 +80,7 @@ static void fd_free(int fd)
}
}
}
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();
@@ -376,4 +370,32 @@ int fs_svr_statfs(const char *path, struct statfs *buf)
void fs_svr_loop(void)
{
rpc_loop();
}
}
static const fs_operations_t ops =
{
.fs_svr_open = fs_svr_open,
.fs_svr_read = fs_svr_read,
.fs_svr_write = fs_svr_write,
.fs_svr_close = fs_svr_close,
.fs_svr_readdir = fs_svr_readdir,
.fs_svr_lseek = fs_svr_lseek,
.fs_svr_ftruncate = fs_svr_ftruncate,
.fs_svr_fstat = fs_svr_fstat,
.fs_svr_ioctl = fs_svr_ioctl,
// .fs_svr_fcntl = fs_svr_fcntl,
.fs_svr_fsync = fs_svr_fsync,
.fs_svr_unlink = fs_svr_unlink,
.fs_svr_symlink = fs_svr_symlink,
.fs_svr_mkdir = fs_svr_mkdir,
.fs_svr_rmdir = fs_svr_rmdir,
.fs_svr_rename = fs_svr_rename,
.fs_svr_stat = fs_svr_stat,
.fs_svr_readlink = fs_svr_readlink,
};
void fs_svr_init(void)
{
msg_tag_t tag;
fs_init(&fs, &ops);
meta_reg_svr_obj(&fs.svr, FS_PROT);
}

34
mkrtos_user/user/drv/ATSURFF437/pca9555/fs_rpc.c
View File

@@ -80,13 +80,7 @@ static void fd_free(int fd)
}
}
}
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();
@@ -382,4 +376,32 @@ int fs_svr_statfs(const char *path, struct statfs *buf)
void fs_svr_loop(void)
{
rpc_loop();
}
static const fs_operations_t ops =
{
.fs_svr_open = fs_svr_open,
.fs_svr_read = fs_svr_read,
.fs_svr_write = fs_svr_write,
.fs_svr_close = fs_svr_close,
.fs_svr_readdir = fs_svr_readdir,
.fs_svr_lseek = fs_svr_lseek,
.fs_svr_ftruncate = fs_svr_ftruncate,
.fs_svr_fstat = fs_svr_fstat,
.fs_svr_ioctl = fs_svr_ioctl,
// .fs_svr_fcntl = fs_svr_fcntl,
.fs_svr_fsync = fs_svr_fsync,
.fs_svr_unlink = fs_svr_unlink,
.fs_svr_symlink = fs_svr_symlink,
.fs_svr_mkdir = fs_svr_mkdir,
.fs_svr_rmdir = fs_svr_rmdir,
.fs_svr_rename = fs_svr_rename,
.fs_svr_stat = fs_svr_stat,
.fs_svr_readlink = fs_svr_readlink,
};
void fs_svr_init(void)
{
msg_tag_t tag;
fs_init(&fs, &ops);
meta_reg_svr_obj(&fs.svr, FS_PROT);
}

36
mkrtos_user/user/drv/ATSURFF437/pin/fs_rpc.c
View File

@@ -83,13 +83,7 @@ static void fd_free(int fd)
}
}
}
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();
@@ -419,4 +413,32 @@ int fs_svr_statfs(const char *path, struct statfs *buf)
void fs_svr_loop(void)
{
rpc_loop();
}
}
static const fs_operations_t ops =
{
.fs_svr_open = fs_svr_open,
.fs_svr_read = fs_svr_read,
.fs_svr_write = fs_svr_write,
.fs_svr_close = fs_svr_close,
.fs_svr_readdir = fs_svr_readdir,
.fs_svr_lseek = fs_svr_lseek,
.fs_svr_ftruncate = fs_svr_ftruncate,
.fs_svr_fstat = fs_svr_fstat,
.fs_svr_ioctl = fs_svr_ioctl,
// .fs_svr_fcntl = fs_svr_fcntl,
.fs_svr_fsync = fs_svr_fsync,
.fs_svr_unlink = fs_svr_unlink,
.fs_svr_symlink = fs_svr_symlink,
.fs_svr_mkdir = fs_svr_mkdir,
.fs_svr_rmdir = fs_svr_rmdir,
.fs_svr_rename = fs_svr_rename,
.fs_svr_stat = fs_svr_stat,
.fs_svr_readlink = fs_svr_readlink,
};
void fs_svr_init(void)
{
msg_tag_t tag;
fs_init(&fs, &ops);
meta_reg_svr_obj(&fs.svr, FS_PROT);
}

6
mkrtos_user/user/drv/ATSURFF437/snd/main.c
View File

@@ -21,7 +21,7 @@
#include "mk_snd_drv_impl.h"
static blk_drv_t snd_drv; //!< 网络驱动的协议
#define STACK_COM_ITME_SIZE (1024+512)
#define STACK_COM_ITME_SIZE (1024 + 512)
ATTR_ALIGN(8)
uint8_t stack_coms[STACK_COM_ITME_SIZE];
uint8_t msg_buf_coms[MSG_BUG_LEN];
@@ -64,6 +64,10 @@ int blk_drv_map(obj_handler_t *hd)
{
return -1;
}
int blk_drv_info(blk_drv_info_t *info)
{
return -ENOSYS;
}
int main(int argc, char *argv[])
{
obj_handler_t hd;

2
mkrtos_user/user/drv/STM32F205/block/stm32f2xx_conf.h
View File

@@ -69,7 +69,7 @@
/* Uncomment the line below to expanse the "assert_param" macro in the
Standard Peripheral Library drivers code */
/* #define USE_FULL_ASSERT 1 */
#define USE_FULL_ASSERT 1
/* Exported macro ------------------------------------------------------------*/
#ifdef USE_FULL_ASSERT