sdio+fatfs创建
This commit is contained in:
sc committed
commit
f762d5d7f8
2473 files changed
+1192014
No files matched your search
@@ -0,0 +1,36 @@
|
||||
menu "RT-Thread Components"
|
||||
|
||||
config RT_USING_COMPONENTS_INIT
|
||||
bool
|
||||
default n
|
||||
|
||||
config RT_USING_USER_MAIN
|
||||
bool
|
||||
default n
|
||||
|
||||
if RT_USING_USER_MAIN
|
||||
config RT_MAIN_THREAD_STACK_SIZE
|
||||
int "Set main thread stack size"
|
||||
default 2048
|
||||
config RT_MAIN_THREAD_PRIORITY
|
||||
int "Set main thread priority"
|
||||
default 4 if RT_THREAD_PRIORITY_8
|
||||
default 10 if RT_THREAD_PRIORITY_32
|
||||
default 85 if RT_THREAD_PRIORITY_256
|
||||
endif
|
||||
|
||||
config RT_USING_LEGACY
|
||||
bool "Support legacy version for compatibility"
|
||||
default n
|
||||
|
||||
source "$RTT_DIR/components/finsh/Kconfig"
|
||||
source "$RTT_DIR/components/dfs/Kconfig"
|
||||
source "$RTT_DIR/components/fal/Kconfig"
|
||||
source "$RTT_DIR/components/lwp/Kconfig"
|
||||
source "$RTT_DIR/components/drivers/Kconfig"
|
||||
source "$RTT_DIR/components/libc/Kconfig"
|
||||
source "$RTT_DIR/components/net/Kconfig"
|
||||
source "$RTT_DIR/components/utilities/Kconfig"
|
||||
source "$RTT_DIR/components/vbus/Kconfig"
|
||||
|
||||
endmenu
|
||||
@@ -0,0 +1,17 @@
|
||||
# for module compiling
|
||||
import os
|
||||
Import('remove_components')
|
||||
from building import *
|
||||
|
||||
objs = []
|
||||
cwd = GetCurrentDir()
|
||||
list = os.listdir(cwd)
|
||||
|
||||
for item in list:
|
||||
if item in remove_components:
|
||||
continue
|
||||
|
||||
if os.path.isfile(os.path.join(cwd, item, 'SConscript')):
|
||||
objs = objs + SConscript(os.path.join(item, 'SConscript'))
|
||||
|
||||
Return('objs')
|
||||
@@ -0,0 +1,160 @@
|
||||
menuconfig RT_USING_DFS
|
||||
bool "DFS: device virtual file system"
|
||||
select RT_USING_MUTEX
|
||||
default y
|
||||
help
|
||||
The device file system is a light weight virtual file system.
|
||||
|
||||
if RT_USING_DFS
|
||||
config DFS_USING_POSIX
|
||||
bool "Using posix-like functions, open/read/write/close"
|
||||
default y
|
||||
|
||||
config DFS_USING_WORKDIR
|
||||
bool "Using working directory"
|
||||
default y
|
||||
|
||||
config DFS_FILESYSTEMS_MAX
|
||||
int "The maximal number of mounted file system"
|
||||
default 4
|
||||
|
||||
config DFS_FILESYSTEM_TYPES_MAX
|
||||
int "The maximal number of file system type"
|
||||
default 4
|
||||
|
||||
config DFS_FD_MAX
|
||||
int "The maximal number of opened files"
|
||||
default 16
|
||||
|
||||
config RT_USING_DFS_MNTTABLE
|
||||
bool "Using mount table for file system"
|
||||
default n
|
||||
help
|
||||
User can use mount table for automatically mount, for example:
|
||||
const struct dfs_mount_tbl mount_table[] =
|
||||
{
|
||||
{"flash0", "/", "elm", 0, 0},
|
||||
{0}
|
||||
};
|
||||
The mount_table must be terminated with NULL.
|
||||
|
||||
config RT_USING_DFS_ELMFAT
|
||||
bool "Enable elm-chan fatfs"
|
||||
default n
|
||||
help
|
||||
FatFs is a generic FAT/exFAT file system module for small embedded systems.
|
||||
|
||||
if RT_USING_DFS_ELMFAT
|
||||
menu "elm-chan's FatFs, Generic FAT Filesystem Module"
|
||||
config RT_DFS_ELM_CODE_PAGE
|
||||
int "OEM code page"
|
||||
default 437
|
||||
|
||||
config RT_DFS_ELM_WORD_ACCESS
|
||||
bool "Using RT_DFS_ELM_WORD_ACCESS"
|
||||
default y
|
||||
|
||||
choice
|
||||
prompt "Support long file name"
|
||||
default RT_DFS_ELM_USE_LFN_3
|
||||
|
||||
config RT_DFS_ELM_USE_LFN_0
|
||||
bool "0: LFN disable"
|
||||
|
||||
config RT_DFS_ELM_USE_LFN_1
|
||||
bool "1: LFN with static LFN working buffer"
|
||||
|
||||
config RT_DFS_ELM_USE_LFN_2
|
||||
bool "2: LFN with dynamic LFN working buffer on the stack"
|
||||
|
||||
config RT_DFS_ELM_USE_LFN_3
|
||||
bool "3: LFN with dynamic LFN working buffer on the heap"
|
||||
endchoice
|
||||
|
||||
config RT_DFS_ELM_USE_LFN
|
||||
int
|
||||
default 0 if RT_DFS_ELM_USE_LFN_0
|
||||
default 1 if RT_DFS_ELM_USE_LFN_1
|
||||
default 2 if RT_DFS_ELM_USE_LFN_2
|
||||
default 3 if RT_DFS_ELM_USE_LFN_3
|
||||
|
||||
choice
|
||||
prompt "Support unicode for long file name"
|
||||
default RT_DFS_ELM_LFN_UNICODE_0
|
||||
|
||||
config RT_DFS_ELM_LFN_UNICODE_0
|
||||
bool "0: ANSI/OEM in current CP (TCHAR = char)"
|
||||
|
||||
config RT_DFS_ELM_LFN_UNICODE_1
|
||||
bool "1: Unicode in UTF-16 (TCHAR = WCHAR)"
|
||||
|
||||
config RT_DFS_ELM_LFN_UNICODE_2
|
||||
bool "2: Unicode in UTF-8 (TCHAR = char)"
|
||||
|
||||
config RT_DFS_ELM_LFN_UNICODE_3
|
||||
bool "3: Unicode in UTF-32 (TCHAR = DWORD)"
|
||||
endchoice
|
||||
|
||||
config RT_DFS_ELM_LFN_UNICODE
|
||||
int
|
||||
default 0 if RT_DFS_ELM_LFN_UNICODE_0
|
||||
default 1 if RT_DFS_ELM_LFN_UNICODE_1
|
||||
default 2 if RT_DFS_ELM_LFN_UNICODE_2
|
||||
default 3 if RT_DFS_ELM_LFN_UNICODE_3
|
||||
|
||||
config RT_DFS_ELM_MAX_LFN
|
||||
int "Maximal size of file name length"
|
||||
range 12 255
|
||||
default 255
|
||||
|
||||
config RT_DFS_ELM_DRIVES
|
||||
int "Number of volumes (logical drives) to be used."
|
||||
default 2
|
||||
|
||||
config RT_DFS_ELM_MAX_SECTOR_SIZE
|
||||
int "Maximum sector size to be handled."
|
||||
default 512
|
||||
help
|
||||
If you use some spi nor flash for fatfs, please set this the erase sector size, for example 4096.
|
||||
|
||||
config RT_DFS_ELM_USE_ERASE
|
||||
bool "Enable sector erase feature"
|
||||
default n
|
||||
|
||||
config RT_DFS_ELM_REENTRANT
|
||||
bool "Enable the reentrancy (thread safe) of the FatFs module"
|
||||
default y
|
||||
|
||||
config RT_DFS_ELM_MUTEX_TIMEOUT
|
||||
int "Timeout of thread-safe protection mutex"
|
||||
range 0 1000000
|
||||
default 3000
|
||||
depends on RT_DFS_ELM_REENTRANT
|
||||
endmenu
|
||||
endif
|
||||
|
||||
config RT_USING_DFS_DEVFS
|
||||
bool "Using devfs for device objects"
|
||||
default n
|
||||
|
||||
config RT_USING_DFS_ROMFS
|
||||
bool "Enable ReadOnly file system on flash"
|
||||
default n
|
||||
|
||||
config RT_USING_DFS_RAMFS
|
||||
bool "Enable RAM file system"
|
||||
select RT_USING_MEMHEAP
|
||||
default n
|
||||
|
||||
config RT_USING_DFS_NFS
|
||||
bool "Using NFS v3 client file system"
|
||||
depends on RT_USING_LWIP
|
||||
default n
|
||||
|
||||
if RT_USING_DFS_NFS
|
||||
config RT_NFS_HOST_EXPORT
|
||||
string "NFSv3 host export"
|
||||
default "192.168.1.5:/"
|
||||
endif
|
||||
|
||||
endif
|
||||
@@ -0,0 +1,26 @@
|
||||
from building import *
|
||||
import os
|
||||
|
||||
# The set of source files associated with this SConscript file.
|
||||
src = Split('''
|
||||
src/dfs.c
|
||||
src/dfs_file.c
|
||||
src/dfs_fs.c
|
||||
''')
|
||||
cwd = GetCurrentDir()
|
||||
CPPPATH = [cwd + "/include"]
|
||||
|
||||
if GetDepend('DFS_USING_POSIX'):
|
||||
src += ['src/dfs_posix.c']
|
||||
|
||||
group = DefineGroup('Filesystem', src, depend = ['RT_USING_DFS'], CPPPATH = CPPPATH)
|
||||
|
||||
if GetDepend('RT_USING_DFS'):
|
||||
# search in the file system implementation
|
||||
list = os.listdir(cwd)
|
||||
|
||||
for item in list:
|
||||
if os.path.isfile(os.path.join(cwd, item, 'SConscript')):
|
||||
group = group + SConscript(os.path.join(item, 'SConscript'))
|
||||
|
||||
Return('group')
|
||||
@@ -0,0 +1,4 @@
|
||||
# files format check exclude path, please follow the instructions below to modify;
|
||||
|
||||
dir_path:
|
||||
- elmfat
|
||||
@@ -0,0 +1,15 @@
|
||||
# RT-Thread building script for bridge
|
||||
|
||||
import os
|
||||
from building import *
|
||||
|
||||
cwd = GetCurrentDir()
|
||||
objs = []
|
||||
list = os.listdir(cwd)
|
||||
|
||||
for d in list:
|
||||
path = os.path.join(cwd, d)
|
||||
if os.path.isfile(os.path.join(path, 'SConscript')):
|
||||
objs = objs + SConscript(os.path.join(d, 'SConscript'))
|
||||
|
||||
Return('objs')
|
||||
@@ -0,0 +1,11 @@
|
||||
# RT-Thread building script for component
|
||||
|
||||
from building import *
|
||||
|
||||
cwd = GetCurrentDir()
|
||||
src = Glob('*.c')
|
||||
CPPPATH = [cwd]
|
||||
|
||||
group = DefineGroup('Filesystem', src, depend = ['RT_USING_DFS', 'RT_USING_DFS_DEVFS'], CPPPATH = CPPPATH)
|
||||
|
||||
Return('group')
|
||||
@@ -0,0 +1,341 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2018-02-11 Bernard Ignore O_CREAT flag in open.
|
||||
*/
|
||||
|
||||
#include <rtthread.h>
|
||||
#include <rtdevice.h>
|
||||
|
||||
#include <dfs.h>
|
||||
#include <dfs_fs.h>
|
||||
#include <dfs_file.h>
|
||||
|
||||
#include "devfs.h"
|
||||
|
||||
struct device_dirent
|
||||
{
|
||||
rt_device_t *devices;
|
||||
rt_uint16_t read_index;
|
||||
rt_uint16_t device_count;
|
||||
};
|
||||
|
||||
int dfs_device_fs_mount(struct dfs_filesystem *fs, unsigned long rwflag, const void *data)
|
||||
{
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
int dfs_device_fs_ioctl(struct dfs_fd *file, int cmd, void *args)
|
||||
{
|
||||
rt_err_t result;
|
||||
rt_device_t dev_id;
|
||||
|
||||
RT_ASSERT(file != RT_NULL);
|
||||
|
||||
/* get device handler */
|
||||
dev_id = (rt_device_t)file->data;
|
||||
RT_ASSERT(dev_id != RT_NULL);
|
||||
|
||||
/* close device handler */
|
||||
result = rt_device_control(dev_id, cmd, args);
|
||||
if (result == RT_EOK)
|
||||
return RT_EOK;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
int dfs_device_fs_read(struct dfs_fd *file, void *buf, size_t count)
|
||||
{
|
||||
int result;
|
||||
rt_device_t dev_id;
|
||||
|
||||
RT_ASSERT(file != RT_NULL);
|
||||
|
||||
/* get device handler */
|
||||
dev_id = (rt_device_t)file->data;
|
||||
RT_ASSERT(dev_id != RT_NULL);
|
||||
|
||||
/* read device data */
|
||||
result = rt_device_read(dev_id, file->pos, buf, count);
|
||||
file->pos += result;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
int dfs_device_fs_write(struct dfs_fd *file, const void *buf, size_t count)
|
||||
{
|
||||
int result;
|
||||
rt_device_t dev_id;
|
||||
|
||||
RT_ASSERT(file != RT_NULL);
|
||||
|
||||
/* get device handler */
|
||||
dev_id = (rt_device_t)file->data;
|
||||
RT_ASSERT(dev_id != RT_NULL);
|
||||
|
||||
/* read device data */
|
||||
result = rt_device_write(dev_id, file->pos, buf, count);
|
||||
file->pos += result;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
int dfs_device_fs_close(struct dfs_fd *file)
|
||||
{
|
||||
rt_err_t result;
|
||||
rt_device_t dev_id;
|
||||
|
||||
RT_ASSERT(file != RT_NULL);
|
||||
|
||||
if (file->type == FT_DIRECTORY)
|
||||
{
|
||||
struct device_dirent *root_dirent;
|
||||
|
||||
root_dirent = (struct device_dirent *)file->data;
|
||||
RT_ASSERT(root_dirent != RT_NULL);
|
||||
|
||||
/* release dirent */
|
||||
rt_free(root_dirent);
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
/* get device handler */
|
||||
dev_id = (rt_device_t)file->data;
|
||||
RT_ASSERT(dev_id != RT_NULL);
|
||||
|
||||
/* close device handler */
|
||||
result = rt_device_close(dev_id);
|
||||
if (result == RT_EOK)
|
||||
{
|
||||
file->data = RT_NULL;
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
int dfs_device_fs_open(struct dfs_fd *file)
|
||||
{
|
||||
rt_err_t result;
|
||||
rt_device_t device;
|
||||
|
||||
/* open root directory */
|
||||
if ((file->path[0] == '/') && (file->path[1] == '\0') &&
|
||||
(file->flags & O_DIRECTORY))
|
||||
{
|
||||
struct rt_object *object;
|
||||
struct rt_list_node *node;
|
||||
struct rt_object_information *information;
|
||||
struct device_dirent *root_dirent;
|
||||
rt_uint32_t count = 0;
|
||||
|
||||
/* lock scheduler */
|
||||
rt_enter_critical();
|
||||
|
||||
/* traverse device object */
|
||||
information = rt_object_get_information(RT_Object_Class_Device);
|
||||
RT_ASSERT(information != RT_NULL);
|
||||
for (node = information->object_list.next; node != &(information->object_list); node = node->next)
|
||||
{
|
||||
count ++;
|
||||
}
|
||||
rt_exit_critical();
|
||||
|
||||
root_dirent = (struct device_dirent *)rt_malloc(sizeof(struct device_dirent) +
|
||||
count * sizeof(rt_device_t));
|
||||
if (root_dirent != RT_NULL)
|
||||
{
|
||||
/* lock scheduler */
|
||||
rt_enter_critical();
|
||||
|
||||
root_dirent->devices = (rt_device_t *)(root_dirent + 1);
|
||||
root_dirent->read_index = 0;
|
||||
root_dirent->device_count = count;
|
||||
count = 0;
|
||||
/* get all device node */
|
||||
for (node = information->object_list.next; node != &(information->object_list); node = node->next)
|
||||
{
|
||||
/* avoid memory write through */
|
||||
if (count == root_dirent->device_count)
|
||||
{
|
||||
rt_kprintf("warning: There are newly added devices that are not displayed!");
|
||||
break;
|
||||
}
|
||||
object = rt_list_entry(node, struct rt_object, list);
|
||||
root_dirent->devices[count] = (rt_device_t)object;
|
||||
count ++;
|
||||
}
|
||||
rt_exit_critical();
|
||||
}
|
||||
|
||||
/* set data */
|
||||
file->data = root_dirent;
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
device = rt_device_find(&file->path[1]);
|
||||
if (device == RT_NULL)
|
||||
return -ENODEV;
|
||||
|
||||
#ifdef RT_USING_POSIX_DEVIO
|
||||
if (device->fops)
|
||||
{
|
||||
/* use device fops */
|
||||
file->fops = device->fops;
|
||||
file->data = (void *)device;
|
||||
|
||||
/* use fops */
|
||||
if (file->fops->open)
|
||||
{
|
||||
result = file->fops->open(file);
|
||||
if (result == RT_EOK || result == -RT_ENOSYS)
|
||||
{
|
||||
file->type = FT_DEVICE;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif /* RT_USING_POSIX_DEVIO */
|
||||
{
|
||||
result = rt_device_open(device, RT_DEVICE_OFLAG_RDWR);
|
||||
if (result == RT_EOK || result == -RT_ENOSYS)
|
||||
{
|
||||
file->data = device;
|
||||
file->type = FT_DEVICE;
|
||||
return RT_EOK;
|
||||
}
|
||||
}
|
||||
|
||||
file->data = RT_NULL;
|
||||
/* open device failed. */
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
int dfs_device_fs_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
|
||||
{
|
||||
/* stat root directory */
|
||||
if ((path[0] == '/') && (path[1] == '\0'))
|
||||
{
|
||||
st->st_dev = 0;
|
||||
|
||||
st->st_mode = S_IFREG | S_IRUSR | S_IRGRP | S_IROTH |
|
||||
S_IWUSR | S_IWGRP | S_IWOTH;
|
||||
st->st_mode &= ~S_IFREG;
|
||||
st->st_mode |= S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH;
|
||||
|
||||
st->st_size = 0;
|
||||
st->st_mtime = 0;
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
else
|
||||
{
|
||||
rt_device_t dev_id;
|
||||
|
||||
dev_id = rt_device_find(&path[1]);
|
||||
if (dev_id != RT_NULL)
|
||||
{
|
||||
st->st_dev = 0;
|
||||
|
||||
st->st_mode = S_IRUSR | S_IRGRP | S_IROTH |
|
||||
S_IWUSR | S_IWGRP | S_IWOTH;
|
||||
|
||||
if (dev_id->type == RT_Device_Class_Char)
|
||||
st->st_mode |= S_IFCHR;
|
||||
else if (dev_id->type == RT_Device_Class_Block)
|
||||
st->st_mode |= S_IFBLK;
|
||||
else if (dev_id->type == RT_Device_Class_Pipe)
|
||||
st->st_mode |= S_IFIFO;
|
||||
else
|
||||
st->st_mode |= S_IFREG;
|
||||
|
||||
st->st_size = 0;
|
||||
st->st_mtime = 0;
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
}
|
||||
|
||||
return -ENOENT;
|
||||
}
|
||||
|
||||
int dfs_device_fs_getdents(struct dfs_fd *file, struct dirent *dirp, uint32_t count)
|
||||
{
|
||||
rt_uint32_t index;
|
||||
rt_object_t object;
|
||||
struct dirent *d;
|
||||
struct device_dirent *root_dirent;
|
||||
|
||||
root_dirent = (struct device_dirent *)file->data;
|
||||
RT_ASSERT(root_dirent != RT_NULL);
|
||||
|
||||
/* make integer count */
|
||||
count = (count / sizeof(struct dirent));
|
||||
if (count == 0)
|
||||
return -EINVAL;
|
||||
|
||||
for (index = 0; index < count && index + root_dirent->read_index < root_dirent->device_count;
|
||||
index ++)
|
||||
{
|
||||
object = (rt_object_t)root_dirent->devices[root_dirent->read_index + index];
|
||||
|
||||
d = dirp + index;
|
||||
d->d_type = DT_REG;
|
||||
d->d_namlen = RT_NAME_MAX;
|
||||
d->d_reclen = (rt_uint16_t)sizeof(struct dirent);
|
||||
rt_strncpy(d->d_name, object->name, RT_NAME_MAX);
|
||||
}
|
||||
|
||||
root_dirent->read_index += index;
|
||||
|
||||
return index * sizeof(struct dirent);
|
||||
}
|
||||
|
||||
static int dfs_device_fs_poll(struct dfs_fd *fd, struct rt_pollreq *req)
|
||||
{
|
||||
int mask = 0;
|
||||
|
||||
return mask;
|
||||
}
|
||||
|
||||
static const struct dfs_file_ops _device_fops =
|
||||
{
|
||||
dfs_device_fs_open,
|
||||
dfs_device_fs_close,
|
||||
dfs_device_fs_ioctl,
|
||||
dfs_device_fs_read,
|
||||
dfs_device_fs_write,
|
||||
RT_NULL, /* flush */
|
||||
RT_NULL, /* lseek */
|
||||
dfs_device_fs_getdents,
|
||||
dfs_device_fs_poll,
|
||||
};
|
||||
|
||||
static const struct dfs_filesystem_ops _device_fs =
|
||||
{
|
||||
"devfs",
|
||||
DFS_FS_FLAG_DEFAULT,
|
||||
&_device_fops,
|
||||
dfs_device_fs_mount,
|
||||
RT_NULL, /*unmount*/
|
||||
RT_NULL, /*mkfs*/
|
||||
RT_NULL, /*statfs*/
|
||||
RT_NULL, /*unlink*/
|
||||
dfs_device_fs_stat,
|
||||
RT_NULL, /*rename*/
|
||||
};
|
||||
|
||||
int devfs_init(void)
|
||||
{
|
||||
/* register device file system */
|
||||
dfs_register(&_device_fs);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
|
||||
#ifndef __DEVICE_FS_H__
|
||||
#define __DEVICE_FS_H__
|
||||
|
||||
#include <rtthread.h>
|
||||
|
||||
int devfs_init(void);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,10 @@
|
||||
# files format check exclude path, please follow the instructions below to modify;
|
||||
# If you need to exclude an entire folder, add the folder path in dir_path;
|
||||
# If you need to exclude a file, add the path to the file in file_path.
|
||||
|
||||
file_path:
|
||||
- diskio.h
|
||||
- ff.c
|
||||
- ff.h
|
||||
- ffconf.h
|
||||
- ffunicode.c
|
||||
@@ -0,0 +1,359 @@
|
||||
----------------------------------------------------------------------------
|
||||
Revision history of FatFs module
|
||||
----------------------------------------------------------------------------
|
||||
|
||||
R0.00 (February 26, 2006)
|
||||
|
||||
Prototype.
|
||||
|
||||
|
||||
|
||||
R0.01 (April 29, 2006)
|
||||
|
||||
The first release.
|
||||
|
||||
|
||||
|
||||
R0.02 (June 01, 2006)
|
||||
|
||||
Added FAT12 support.
|
||||
Removed unbuffered mode.
|
||||
Fixed a problem on small (<32M) partition.
|
||||
|
||||
|
||||
|
||||
R0.02a (June 10, 2006)
|
||||
|
||||
Added a configuration option (_FS_MINIMUM).
|
||||
|
||||
|
||||
|
||||
R0.03 (September 22, 2006)
|
||||
|
||||
Added f_rename().
|
||||
Changed option _FS_MINIMUM to _FS_MINIMIZE.
|
||||
|
||||
|
||||
|
||||
R0.03a (December 11, 2006)
|
||||
|
||||
Improved cluster scan algorithm to write files fast.
|
||||
Fixed f_mkdir() creates incorrect directory on FAT32.
|
||||
|
||||
|
||||
|
||||
R0.04 (February 04, 2007)
|
||||
|
||||
Added f_mkfs().
|
||||
Supported multiple drive system.
|
||||
Changed some interfaces for multiple drive system.
|
||||
Changed f_mountdrv() to f_mount().
|
||||
|
||||
|
||||
|
||||
R0.04a (April 01, 2007)
|
||||
|
||||
Supported multiple partitions on a physical drive.
|
||||
Added a capability of extending file size to f_lseek().
|
||||
Added minimization level 3.
|
||||
Fixed an endian sensitive code in f_mkfs().
|
||||
|
||||
|
||||
|
||||
R0.04b (May 05, 2007)
|
||||
|
||||
Added a configuration option _USE_NTFLAG.
|
||||
Added FSINFO support.
|
||||
Fixed DBCS name can result FR_INVALID_NAME.
|
||||
Fixed short seek (<= csize) collapses the file object.
|
||||
|
||||
|
||||
|
||||
R0.05 (August 25, 2007)
|
||||
|
||||
Changed arguments of f_read(), f_write() and f_mkfs().
|
||||
Fixed f_mkfs() on FAT32 creates incorrect FSINFO.
|
||||
Fixed f_mkdir() on FAT32 creates incorrect directory.
|
||||
|
||||
|
||||
|
||||
R0.05a (February 03, 2008)
|
||||
|
||||
Added f_truncate() and f_utime().
|
||||
Fixed off by one error at FAT sub-type determination.
|
||||
Fixed btr in f_read() can be mistruncated.
|
||||
Fixed cached sector is not flushed when create and close without write.
|
||||
|
||||
|
||||
|
||||
R0.06 (April 01, 2008)
|
||||
|
||||
Added fputc(), fputs(), fprintf() and fgets().
|
||||
Improved performance of f_lseek() on moving to the same or following cluster.
|
||||
|
||||
|
||||
|
||||
R0.07 (April 01, 2009)
|
||||
|
||||
Merged Tiny-FatFs as a configuration option. (_FS_TINY)
|
||||
Added long file name feature. (_USE_LFN)
|
||||
Added multiple code page feature. (_CODE_PAGE)
|
||||
Added re-entrancy for multitask operation. (_FS_REENTRANT)
|
||||
Added auto cluster size selection to f_mkfs().
|
||||
Added rewind option to f_readdir().
|
||||
Changed result code of critical errors.
|
||||
Renamed string functions to avoid name collision.
|
||||
|
||||
|
||||
|
||||
R0.07a (April 14, 2009)
|
||||
|
||||
Septemberarated out OS dependent code on reentrant cfg.
|
||||
Added multiple sector size feature.
|
||||
|
||||
|
||||
|
||||
R0.07c (June 21, 2009)
|
||||
|
||||
Fixed f_unlink() can return FR_OK on error.
|
||||
Fixed wrong cache control in f_lseek().
|
||||
Added relative path feature.
|
||||
Added f_chdir() and f_chdrive().
|
||||
Added proper case conversion to extended character.
|
||||
|
||||
|
||||
|
||||
R0.07e (November 03, 2009)
|
||||
|
||||
Septemberarated out configuration options from ff.h to ffconf.h.
|
||||
Fixed f_unlink() fails to remove a sub-directory on _FS_RPATH.
|
||||
Fixed name matching error on the 13 character boundary.
|
||||
Added a configuration option, _LFN_UNICODE.
|
||||
Changed f_readdir() to return the SFN with always upper case on non-LFN cfg.
|
||||
|
||||
|
||||
|
||||
R0.08 (May 15, 2010)
|
||||
|
||||
Added a memory configuration option. (_USE_LFN = 3)
|
||||
Added file lock feature. (_FS_SHARE)
|
||||
Added fast seek feature. (_USE_FASTSEEK)
|
||||
Changed some types on the API, XCHAR->TCHAR.
|
||||
Changed .fname in the FILINFO structure on Unicode cfg.
|
||||
String functions support UTF-8 encoding files on Unicode cfg.
|
||||
|
||||
|
||||
|
||||
R0.08a (August 16, 2010)
|
||||
|
||||
Added f_getcwd(). (_FS_RPATH = 2)
|
||||
Added sector erase feature. (_USE_ERASE)
|
||||
Moved file lock semaphore table from fs object to the bss.
|
||||
Fixed f_mkfs() creates wrong FAT32 volume.
|
||||
|
||||
|
||||
|
||||
R0.08b (January 15, 2011)
|
||||
|
||||
Fast seek feature is also applied to f_read() and f_write().
|
||||
f_lseek() reports required table size on creating CLMP.
|
||||
Extended format syntax of f_printf().
|
||||
Ignores duplicated directory separators in given path name.
|
||||
|
||||
|
||||
|
||||
R0.09 (September 06, 2011)
|
||||
|
||||
f_mkfs() supports multiple partition to complete the multiple partition feature.
|
||||
Added f_fdisk().
|
||||
|
||||
|
||||
|
||||
R0.09a (August 27, 2012)
|
||||
|
||||
Changed f_open() and f_opendir() reject null object pointer to avoid crash.
|
||||
Changed option name _FS_SHARE to _FS_LOCK.
|
||||
Fixed assertion failure due to OS/2 EA on FAT12/16 volume.
|
||||
|
||||
|
||||
|
||||
R0.09b (January 24, 2013)
|
||||
|
||||
Added f_setlabel() and f_getlabel().
|
||||
|
||||
|
||||
|
||||
R0.10 (October 02, 2013)
|
||||
|
||||
Added selection of character encoding on the file. (_STRF_ENCODE)
|
||||
Added f_closedir().
|
||||
Added forced full FAT scan for f_getfree(). (_FS_NOFSINFO)
|
||||
Added forced mount feature with changes of f_mount().
|
||||
Improved behavior of volume auto detection.
|
||||
Improved write throughput of f_puts() and f_printf().
|
||||
Changed argument of f_chdrive(), f_mkfs(), disk_read() and disk_write().
|
||||
Fixed f_write() can be truncated when the file size is close to 4GB.
|
||||
Fixed f_open(), f_mkdir() and f_setlabel() can return incorrect value on error.
|
||||
|
||||
|
||||
|
||||
R0.10a (January 15, 2014)
|
||||
|
||||
Added arbitrary strings as drive number in the path name. (_STR_VOLUME_ID)
|
||||
Added a configuration option of minimum sector size. (_MIN_SS)
|
||||
2nd argument of f_rename() can have a drive number and it will be ignored.
|
||||
Fixed f_mount() with forced mount fails when drive number is >= 1. (appeared at R0.10)
|
||||
Fixed f_close() invalidates the file object without volume lock.
|
||||
Fixed f_closedir() returns but the volume lock is left acquired. (appeared at R0.10)
|
||||
Fixed creation of an entry with LFN fails on too many SFN collisions. (appeared at R0.07)
|
||||
|
||||
|
||||
|
||||
R0.10b (May 19, 2014)
|
||||
|
||||
Fixed a hard error in the disk I/O layer can collapse the directory entry.
|
||||
Fixed LFN entry is not deleted when delete/rename an object with lossy converted SFN. (appeared at R0.07)
|
||||
|
||||
|
||||
|
||||
R0.10c (November 09, 2014)
|
||||
|
||||
Added a configuration option for the platforms without RTC. (_FS_NORTC)
|
||||
Changed option name _USE_ERASE to _USE_TRIM.
|
||||
Fixed volume label created by Mac OS X cannot be retrieved with f_getlabel(). (appeared at R0.09b)
|
||||
Fixed a potential problem of FAT access that can appear on disk error.
|
||||
Fixed null pointer dereference on attempting to delete the root direcotry. (appeared at R0.08)
|
||||
|
||||
|
||||
|
||||
R0.11 (February 09, 2015)
|
||||
|
||||
Added f_findfirst(), f_findnext() and f_findclose(). (_USE_FIND)
|
||||
Fixed f_unlink() does not remove cluster chain of the file. (appeared at R0.10c)
|
||||
Fixed _FS_NORTC option does not work properly. (appeared at R0.10c)
|
||||
|
||||
|
||||
|
||||
R0.11a (September 05, 2015)
|
||||
|
||||
Fixed wrong media change can lead a deadlock at thread-safe configuration.
|
||||
Added code page 771, 860, 861, 863, 864, 865 and 869. (_CODE_PAGE)
|
||||
Removed some code pages actually not exist on the standard systems. (_CODE_PAGE)
|
||||
Fixed errors in the case conversion teble of code page 437 and 850 (ff.c).
|
||||
Fixed errors in the case conversion teble of Unicode (cc*.c).
|
||||
|
||||
|
||||
|
||||
R0.12 (April 12, 2016)
|
||||
|
||||
Added support for exFAT file system. (_FS_EXFAT)
|
||||
Added f_expand(). (_USE_EXPAND)
|
||||
Changed some members in FINFO structure and behavior of f_readdir().
|
||||
Added an option _USE_CHMOD.
|
||||
Removed an option _WORD_ACCESS.
|
||||
Fixed errors in the case conversion table of Unicode (cc*.c).
|
||||
|
||||
|
||||
|
||||
R0.12a (July 10, 2016)
|
||||
|
||||
Added support for creating exFAT volume with some changes of f_mkfs().
|
||||
Added a file open method FA_OPEN_APPEND. An f_lseek() following f_open() is no longer needed.
|
||||
f_forward() is available regardless of _FS_TINY.
|
||||
Fixed f_mkfs() creates wrong volume. (appeared at R0.12)
|
||||
Fixed wrong memory read in create_name(). (appeared at R0.12)
|
||||
Fixed compilation fails at some configurations, _USE_FASTSEEK and _USE_FORWARD.
|
||||
|
||||
|
||||
|
||||
R0.12b (September 04, 2016)
|
||||
|
||||
Made f_rename() be able to rename objects with the same name but case.
|
||||
Fixed an error in the case conversion teble of code page 866. (ff.c)
|
||||
Fixed writing data is truncated at the file offset 4GiB on the exFAT volume. (appeared at R0.12)
|
||||
Fixed creating a file in the root directory of exFAT volume can fail. (appeared at R0.12)
|
||||
Fixed f_mkfs() creating exFAT volume with too small cluster size can collapse unallocated memory. (appeared at R0.12)
|
||||
Fixed wrong object name can be returned when read directory at Unicode cfg. (appeared at R0.12)
|
||||
Fixed large file allocation/removing on the exFAT volume collapses allocation bitmap. (appeared at R0.12)
|
||||
Fixed some internal errors in f_expand() and f_lseek(). (appeared at R0.12)
|
||||
|
||||
|
||||
|
||||
R0.12c (March 04, 2017)
|
||||
|
||||
Improved write throughput at the fragmented file on the exFAT volume.
|
||||
Made memory usage for exFAT be able to be reduced as decreasing _MAX_LFN.
|
||||
Fixed successive f_getfree() can return wrong count on the FAT12/16 volume. (appeared at R0.12)
|
||||
Fixed configuration option _VOLUMES cannot be set 10. (appeared at R0.10c)
|
||||
|
||||
|
||||
|
||||
R0.13 (May 21, 2017)
|
||||
|
||||
Changed heading character of configuration keywords "_" to "FF_".
|
||||
Removed ASCII-only configuration, FF_CODE_PAGE = 1. Use FF_CODE_PAGE = 437 instead.
|
||||
Added f_setcp(), run-time code page configuration. (FF_CODE_PAGE = 0)
|
||||
Improved cluster allocation time on stretch a deep buried cluster chain.
|
||||
Improved processing time of f_mkdir() with large cluster size by using FF_USE_LFN = 3.
|
||||
Improved NoFatChain flag of the fragmented file to be set after it is truncated and got contiguous.
|
||||
Fixed archive attribute is left not set when a file on the exFAT volume is renamed. (appeared at R0.12)
|
||||
Fixed exFAT FAT entry can be collapsed when write or lseek operation to the existing file is done. (appeared at R0.12c)
|
||||
Fixed creating a file can fail when a new cluster allocation to the exFAT directory occures. (appeared at R0.12c)
|
||||
|
||||
|
||||
|
||||
R0.13a (October 14, 2017)
|
||||
|
||||
Added support for UTF-8 encoding on the API. (FF_LFN_UNICODE = 2)
|
||||
Added options for file name output buffer. (FF_LFN_BUF, FF_SFN_BUF).
|
||||
Added dynamic memory allocation option for working buffer of f_mkfs() and f_fdisk().
|
||||
Fixed f_fdisk() and f_mkfs() create the partition table with wrong CHS parameters. (appeared at R0.09)
|
||||
Fixed f_unlink() can cause lost clusters at fragmented file on the exFAT volume. (appeared at R0.12c)
|
||||
Fixed f_setlabel() rejects some valid characters for exFAT volume. (appeared at R0.12)
|
||||
|
||||
|
||||
|
||||
R0.13b (April 07, 2018)
|
||||
|
||||
Added support for UTF-32 encoding on the API. (FF_LFN_UNICODE = 3)
|
||||
Added support for Unix style volume ID. (FF_STR_VOLUME_ID = 2)
|
||||
Fixed accesing any object on the exFAT root directory beyond the cluster boundary can fail. (appeared at R0.12c)
|
||||
Fixed f_setlabel() does not reject some invalid characters. (appeared at R0.09b)
|
||||
|
||||
|
||||
|
||||
R0.13c (October 14, 2018)
|
||||
Supported stdint.h for C99 and later. (integer.h was included in ff.h)
|
||||
Fixed reading a directory gets infinite loop when the last directory entry is not empty. (appeared at R0.12)
|
||||
Fixed creating a sub-directory in the fragmented sub-directory on the exFAT volume collapses FAT chain of the parent directory. (appeared at R0.12)
|
||||
Fixed f_getcwd() cause output buffer overrun when the buffer has a valid drive number. (appeared at R0.13b)
|
||||
|
||||
|
||||
|
||||
R0.14 (October 14, 2019)
|
||||
Added support for 64-bit LBA and GUID partition table (FF_LBA64 = 1)
|
||||
Changed some API functions, f_mkfs() and f_fdisk().
|
||||
Fixed f_open() function cannot find the file with file name in length of FF_MAX_LFN characters.
|
||||
Fixed f_readdir() function cannot retrieve long file names in length of FF_MAX_LFN - 1 characters.
|
||||
Fixed f_readdir() function returns file names with wrong case conversion. (appeared at R0.12)
|
||||
Fixed f_mkfs() function can fail to create exFAT volume in the second partition. (appeared at R0.12)
|
||||
|
||||
|
||||
R0.14a (December 5, 2020)
|
||||
Limited number of recursive calls in f_findnext().
|
||||
Fixed old floppy disks formatted with MS-DOS 2.x and 3.x cannot be mounted.
|
||||
Fixed some compiler warnings.
|
||||
|
||||
|
||||
|
||||
R0.14b (April 17, 2021)
|
||||
Made FatFs uses standard library <string.h> for copy, compare and search instead of built-in string functions.
|
||||
Added support for long long integer and floating point to f_printf(). (FF_STRF_LLI and FF_STRF_FP)
|
||||
Made path name parser ignore the terminating separator to allow "dir/".
|
||||
Improved the compatibility in Unix style path name feature.
|
||||
Fixed the file gets dead-locked when f_open() failed with some conditions. (appeared at R0.12a)
|
||||
Fixed f_mkfs() can create wrong exFAT volume due to a timing dependent error. (appeared at R0.12)
|
||||
Fixed code page 855 cannot be set by f_setcp().
|
||||
Fixed some compiler warnings.
|
||||
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
FatFs Module Source Files R0.14b
|
||||
|
||||
|
||||
FILES
|
||||
|
||||
00readme.txt This file.
|
||||
00history.txt Revision history.
|
||||
ff.c FatFs module.
|
||||
ffconf.h Configuration file of FatFs module.
|
||||
ff.h Common include file for FatFs and application module.
|
||||
diskio.h Common include file for FatFs and disk I/O module.
|
||||
diskio.c An example of glue function to attach existing disk I/O module to FatFs.
|
||||
ffunicode.c Optional Unicode utility functions.
|
||||
ffsystem.c An example of optional O/S related functions.
|
||||
|
||||
|
||||
Low level disk I/O module is not included in this archive because the FatFs
|
||||
module is only a generic file system layer and it does not depend on any specific
|
||||
storage device. You need to provide a low level disk I/O module written to
|
||||
control the storage device that attached to the target system.
|
||||
|
||||
@@ -0,0 +1,11 @@
|
||||
# RT-Thread building script for component
|
||||
|
||||
from building import *
|
||||
|
||||
cwd = GetCurrentDir()
|
||||
src = Glob('*.c')
|
||||
CPPPATH = [cwd]
|
||||
|
||||
group = DefineGroup('Filesystem', src, depend = ['RT_USING_DFS', 'RT_USING_DFS_ELMFAT'], CPPPATH = CPPPATH)
|
||||
|
||||
Return('group')
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,24 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2010-02-06 Bernard Add elm_init function declaration
|
||||
*/
|
||||
|
||||
#ifndef __DFS_ELM_H__
|
||||
#define __DFS_ELM_H__
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
int elm_init(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,77 @@
|
||||
/*-----------------------------------------------------------------------/
|
||||
/ Low level disk interface modlue include file (C)ChaN, 2019 /
|
||||
/-----------------------------------------------------------------------*/
|
||||
|
||||
#ifndef _DISKIO_DEFINED
|
||||
#define _DISKIO_DEFINED
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Status of Disk Functions */
|
||||
typedef BYTE DSTATUS;
|
||||
|
||||
/* Results of Disk Functions */
|
||||
typedef enum {
|
||||
RES_OK = 0, /* 0: Successful */
|
||||
RES_ERROR, /* 1: R/W Error */
|
||||
RES_WRPRT, /* 2: Write Protected */
|
||||
RES_NOTRDY, /* 3: Not Ready */
|
||||
RES_PARERR /* 4: Invalid Parameter */
|
||||
} DRESULT;
|
||||
|
||||
|
||||
/*---------------------------------------*/
|
||||
/* Prototypes for disk control functions */
|
||||
|
||||
|
||||
DSTATUS disk_initialize (BYTE pdrv);
|
||||
DSTATUS disk_status (BYTE pdrv);
|
||||
DRESULT disk_read (BYTE pdrv, BYTE* buff, LBA_t sector, UINT count);
|
||||
DRESULT disk_write (BYTE pdrv, const BYTE* buff, LBA_t sector, UINT count);
|
||||
DRESULT disk_ioctl (BYTE pdrv, BYTE cmd, void* buff);
|
||||
|
||||
|
||||
/* Disk Status Bits (DSTATUS) */
|
||||
|
||||
#define STA_NOINIT 0x01 /* Drive not initialized */
|
||||
#define STA_NODISK 0x02 /* No medium in the drive */
|
||||
#define STA_PROTECT 0x04 /* Write protected */
|
||||
|
||||
|
||||
/* Command code for disk_ioctrl fucntion */
|
||||
|
||||
/* Generic command (Used by FatFs) */
|
||||
#define CTRL_SYNC 0 /* Complete pending write process (needed at FF_FS_READONLY == 0) */
|
||||
#define GET_SECTOR_COUNT 1 /* Get media size (needed at FF_USE_MKFS == 1) */
|
||||
#define GET_SECTOR_SIZE 2 /* Get sector size (needed at FF_MAX_SS != FF_MIN_SS) */
|
||||
#define GET_BLOCK_SIZE 3 /* Get erase block size (needed at FF_USE_MKFS == 1) */
|
||||
#define CTRL_TRIM 4 /* Inform device that the data on the block of sectors is no longer used (needed at FF_USE_TRIM == 1) */
|
||||
|
||||
/* Generic command (Not used by FatFs) */
|
||||
#define CTRL_POWER 5 /* Get/Set power status */
|
||||
#define CTRL_LOCK 6 /* Lock/Unlock media removal */
|
||||
#define CTRL_EJECT 7 /* Eject media */
|
||||
#define CTRL_FORMAT 8 /* Create physical format on the media */
|
||||
|
||||
/* MMC/SDC specific ioctl command */
|
||||
#define MMC_GET_TYPE 10 /* Get card type */
|
||||
#define MMC_GET_CSD 11 /* Get CSD */
|
||||
#define MMC_GET_CID 12 /* Get CID */
|
||||
#define MMC_GET_OCR 13 /* Get OCR */
|
||||
#define MMC_GET_SDSTAT 14 /* Get SD status */
|
||||
#define ISDIO_READ 55 /* Read data form SD iSDIO register */
|
||||
#define ISDIO_WRITE 56 /* Write data to SD iSDIO register */
|
||||
#define ISDIO_MRITE 57 /* Masked write data to SD iSDIO register */
|
||||
|
||||
/* ATA/CF specific ioctl command */
|
||||
#define ATA_GET_REV 20 /* Get F/W revision */
|
||||
#define ATA_GET_MODEL 21 /* Get model name */
|
||||
#define ATA_GET_SN 22 /* Get serial number */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,424 @@
|
||||
/*----------------------------------------------------------------------------/
|
||||
/ FatFs - Generic FAT Filesystem module R0.14b /
|
||||
/-----------------------------------------------------------------------------/
|
||||
/
|
||||
/ Copyright (C) 2021, ChaN, all right reserved.
|
||||
/
|
||||
/ FatFs module is an open source software. Redistribution and use of FatFs in
|
||||
/ source and binary forms, with or without modification, are permitted provided
|
||||
/ that the following condition is met:
|
||||
|
||||
/ 1. Redistributions of source code must retain the above copyright notice,
|
||||
/ this condition and the following disclaimer.
|
||||
/
|
||||
/ This software is provided by the copyright holder and contributors "AS IS"
|
||||
/ and any warranties related to this software are DISCLAIMED.
|
||||
/ The copyright owner or contributors be NOT LIABLE for any damages caused
|
||||
/ by use of this software.
|
||||
/
|
||||
/----------------------------------------------------------------------------*/
|
||||
|
||||
|
||||
#ifndef FF_DEFINED
|
||||
#define FF_DEFINED 86631 /* Revision ID */
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <rtthread.h>
|
||||
#include "ffconf.h" /* FatFs configuration options */
|
||||
|
||||
#if FF_DEFINED != FFCONF_DEF
|
||||
#error Wrong configuration file (ffconf.h).
|
||||
#endif
|
||||
|
||||
|
||||
/* Integer types used for FatFs API */
|
||||
|
||||
#if defined(_WIN32) /* Windows VC++ (for development only) */
|
||||
#define FF_INTDEF 2
|
||||
#include <windows.h>
|
||||
typedef unsigned __int64 QWORD;
|
||||
#include <float.h>
|
||||
#define isnan(v) _isnan(v)
|
||||
#define isinf(v) (!_finite(v))
|
||||
|
||||
#elif (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__cplusplus) /* C99 or later */
|
||||
#define FF_INTDEF 2
|
||||
#include <stdint.h>
|
||||
typedef unsigned int UINT; /* int must be 16-bit or 32-bit */
|
||||
typedef unsigned char BYTE; /* char must be 8-bit */
|
||||
typedef uint16_t WORD; /* 16-bit unsigned integer */
|
||||
typedef uint32_t DWORD; /* 32-bit unsigned integer */
|
||||
typedef uint64_t QWORD; /* 64-bit unsigned integer */
|
||||
typedef WORD WCHAR; /* UTF-16 character type */
|
||||
|
||||
#else /* Earlier than C99 */
|
||||
#define FF_INTDEF 1
|
||||
typedef unsigned int UINT; /* int must be 16-bit or 32-bit */
|
||||
typedef unsigned char BYTE; /* char must be 8-bit */
|
||||
typedef unsigned short WORD; /* 16-bit unsigned integer */
|
||||
typedef unsigned long DWORD; /* 32-bit unsigned integer */
|
||||
typedef WORD WCHAR; /* UTF-16 character type */
|
||||
#endif
|
||||
|
||||
|
||||
/* Type of file size and LBA variables */
|
||||
|
||||
#if FF_FS_EXFAT
|
||||
#if FF_INTDEF != 2
|
||||
#error exFAT feature wants C99 or later
|
||||
#endif
|
||||
typedef QWORD FSIZE_t;
|
||||
#if FF_LBA64
|
||||
typedef QWORD LBA_t;
|
||||
#else
|
||||
typedef DWORD LBA_t;
|
||||
#endif
|
||||
#else
|
||||
#if FF_LBA64
|
||||
#error exFAT needs to be enabled when enable 64-bit LBA
|
||||
#endif
|
||||
typedef DWORD FSIZE_t;
|
||||
typedef DWORD LBA_t;
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/* Type of path name strings on FatFs API (TCHAR) */
|
||||
|
||||
#if FF_USE_LFN && FF_LFN_UNICODE == 1 /* Unicode in UTF-16 encoding */
|
||||
typedef WCHAR TCHAR;
|
||||
#define _T(x) L ## x
|
||||
#define _TEXT(x) L ## x
|
||||
#elif FF_USE_LFN && FF_LFN_UNICODE == 2 /* Unicode in UTF-8 encoding */
|
||||
typedef char TCHAR;
|
||||
#define _T(x) u8 ## x
|
||||
#define _TEXT(x) u8 ## x
|
||||
#elif FF_USE_LFN && FF_LFN_UNICODE == 3 /* Unicode in UTF-32 encoding */
|
||||
typedef DWORD TCHAR;
|
||||
#define _T(x) U ## x
|
||||
#define _TEXT(x) U ## x
|
||||
#elif FF_USE_LFN && (FF_LFN_UNICODE < 0 || FF_LFN_UNICODE > 3)
|
||||
#error Wrong FF_LFN_UNICODE setting
|
||||
#else /* ANSI/OEM code in SBCS/DBCS */
|
||||
typedef char TCHAR;
|
||||
#define _T(x) x
|
||||
#define _TEXT(x) x
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/* Definitions of volume management */
|
||||
|
||||
#if FF_MULTI_PARTITION /* Multiple partition configuration */
|
||||
typedef struct {
|
||||
BYTE pd; /* Physical drive number */
|
||||
BYTE pt; /* Partition: 0:Auto detect, 1-4:Forced partition) */
|
||||
} PARTITION;
|
||||
extern PARTITION VolToPart[]; /* Volume - Partition mapping table */
|
||||
#endif
|
||||
|
||||
#if FF_STR_VOLUME_ID
|
||||
#ifndef FF_VOLUME_STRS
|
||||
extern const char* VolumeStr[FF_VOLUMES]; /* User defied volume ID */
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/* Filesystem object structure (FATFS) */
|
||||
|
||||
typedef struct {
|
||||
BYTE fs_type; /* Filesystem type (0:not mounted) */
|
||||
BYTE pdrv; /* Associated physical drive */
|
||||
BYTE n_fats; /* Number of FATs (1 or 2) */
|
||||
BYTE wflag; /* win[] flag (b0:dirty) */
|
||||
BYTE fsi_flag; /* FSINFO flags (b7:disabled, b0:dirty) */
|
||||
WORD id; /* Volume mount ID */
|
||||
WORD n_rootdir; /* Number of root directory entries (FAT12/16) */
|
||||
WORD csize; /* Cluster size [sectors] */
|
||||
#if FF_MAX_SS != FF_MIN_SS
|
||||
WORD ssize; /* Sector size (512, 1024, 2048 or 4096) */
|
||||
#endif
|
||||
#if FF_USE_LFN
|
||||
WCHAR* lfnbuf; /* LFN working buffer */
|
||||
#endif
|
||||
#if FF_FS_EXFAT
|
||||
BYTE* dirbuf; /* Directory entry block scratchpad buffer for exFAT */
|
||||
#endif
|
||||
#if FF_FS_REENTRANT
|
||||
FF_SYNC_t sobj; /* Identifier of sync object */
|
||||
#endif
|
||||
#if !FF_FS_READONLY
|
||||
DWORD last_clst; /* Last allocated cluster */
|
||||
DWORD free_clst; /* Number of free clusters */
|
||||
#endif
|
||||
#if FF_FS_RPATH
|
||||
DWORD cdir; /* Current directory start cluster (0:root) */
|
||||
#if FF_FS_EXFAT
|
||||
DWORD cdc_scl; /* Containing directory start cluster (invalid when cdir is 0) */
|
||||
DWORD cdc_size; /* b31-b8:Size of containing directory, b7-b0: Chain status */
|
||||
DWORD cdc_ofs; /* Offset in the containing directory (invalid when cdir is 0) */
|
||||
#endif
|
||||
#endif
|
||||
DWORD n_fatent; /* Number of FAT entries (number of clusters + 2) */
|
||||
DWORD fsize; /* Size of an FAT [sectors] */
|
||||
LBA_t volbase; /* Volume base sector */
|
||||
LBA_t fatbase; /* FAT base sector */
|
||||
LBA_t dirbase; /* Root directory base sector/cluster */
|
||||
LBA_t database; /* Data base sector */
|
||||
#if FF_FS_EXFAT
|
||||
LBA_t bitbase; /* Allocation bitmap base sector */
|
||||
#endif
|
||||
LBA_t winsect; /* Current sector appearing in the win[] */
|
||||
BYTE win[FF_MAX_SS]; /* Disk access window for Directory, FAT (and file data at tiny cfg) */
|
||||
} FATFS;
|
||||
|
||||
|
||||
|
||||
/* Object ID and allocation information (FFOBJID) */
|
||||
|
||||
typedef struct {
|
||||
FATFS* fs; /* Pointer to the hosting volume of this object */
|
||||
WORD id; /* Hosting volume mount ID */
|
||||
BYTE attr; /* Object attribute */
|
||||
BYTE stat; /* Object chain status (b1-0: =0:not contiguous, =2:contiguous, =3:fragmented in this session, b2:sub-directory stretched) */
|
||||
DWORD sclust; /* Object data start cluster (0:no cluster or root directory) */
|
||||
FSIZE_t objsize; /* Object size (valid when sclust != 0) */
|
||||
#if FF_FS_EXFAT
|
||||
DWORD n_cont; /* Size of first fragment - 1 (valid when stat == 3) */
|
||||
DWORD n_frag; /* Size of last fragment needs to be written to FAT (valid when not zero) */
|
||||
DWORD c_scl; /* Containing directory start cluster (valid when sclust != 0) */
|
||||
DWORD c_size; /* b31-b8:Size of containing directory, b7-b0: Chain status (valid when c_scl != 0) */
|
||||
DWORD c_ofs; /* Offset in the containing directory (valid when file object and sclust != 0) */
|
||||
#endif
|
||||
#if FF_FS_LOCK
|
||||
UINT lockid; /* File lock ID origin from 1 (index of file semaphore table Files[]) */
|
||||
#endif
|
||||
} FFOBJID;
|
||||
|
||||
|
||||
|
||||
/* File object structure (FIL) */
|
||||
|
||||
typedef struct {
|
||||
FFOBJID obj; /* Object identifier (must be the 1st member to detect invalid object pointer) */
|
||||
BYTE flag; /* File status flags */
|
||||
BYTE err; /* Abort flag (error code) */
|
||||
FSIZE_t fptr; /* File read/write pointer (Zeroed on file open) */
|
||||
DWORD clust; /* Current cluster of fpter (invalid when fptr is 0) */
|
||||
LBA_t sect; /* Sector number appearing in buf[] (0:invalid) */
|
||||
#if !FF_FS_READONLY
|
||||
LBA_t dir_sect; /* Sector number containing the directory entry (not used at exFAT) */
|
||||
BYTE* dir_ptr; /* Pointer to the directory entry in the win[] (not used at exFAT) */
|
||||
#endif
|
||||
#if FF_USE_FASTSEEK
|
||||
DWORD* cltbl; /* Pointer to the cluster link map table (nulled on open, set by application) */
|
||||
#endif
|
||||
#if !FF_FS_TINY
|
||||
BYTE buf[FF_MAX_SS]; /* File private data read/write window */
|
||||
#endif
|
||||
} FIL;
|
||||
|
||||
|
||||
|
||||
/* Directory object structure (DIR) */
|
||||
|
||||
typedef struct {
|
||||
FFOBJID obj; /* Object identifier */
|
||||
DWORD dptr; /* Current read/write offset */
|
||||
DWORD clust; /* Current cluster */
|
||||
LBA_t sect; /* Current sector (0:Read operation has terminated) */
|
||||
BYTE* dir; /* Pointer to the directory item in the win[] */
|
||||
BYTE fn[12]; /* SFN (in/out) {body[8],ext[3],status[1]} */
|
||||
#if FF_USE_LFN
|
||||
DWORD blk_ofs; /* Offset of current entry block being processed (0xFFFFFFFF:Invalid) */
|
||||
#endif
|
||||
#if FF_USE_FIND
|
||||
const TCHAR* pat; /* Pointer to the name matching pattern */
|
||||
#endif
|
||||
} DIR;
|
||||
|
||||
|
||||
|
||||
/* File information structure (FILINFO) */
|
||||
|
||||
typedef struct {
|
||||
FSIZE_t fsize; /* File size */
|
||||
WORD fdate; /* Modified date */
|
||||
WORD ftime; /* Modified time */
|
||||
BYTE fattrib; /* File attribute */
|
||||
#if FF_USE_LFN
|
||||
TCHAR altname[FF_SFN_BUF + 1];/* Altenative file name */
|
||||
TCHAR fname[FF_LFN_BUF + 1]; /* Primary file name */
|
||||
#else
|
||||
TCHAR fname[12 + 1]; /* File name */
|
||||
#endif
|
||||
} FILINFO;
|
||||
|
||||
|
||||
|
||||
/* Format parameter structure (MKFS_PARM) */
|
||||
|
||||
typedef struct {
|
||||
BYTE fmt; /* Format option (FM_FAT, FM_FAT32, FM_EXFAT and FM_SFD) */
|
||||
BYTE n_fat; /* Number of FATs */
|
||||
UINT align; /* Data area alignment (sector) */
|
||||
UINT n_root; /* Number of root directory entries */
|
||||
DWORD au_size; /* Cluster size (byte) */
|
||||
} MKFS_PARM;
|
||||
|
||||
|
||||
|
||||
/* File function return code (FRESULT) */
|
||||
|
||||
typedef enum {
|
||||
FR_OK = 0, /* (0) Succeeded */
|
||||
FR_DISK_ERR, /* (1) A hard error occurred in the low level disk I/O layer */
|
||||
FR_INT_ERR, /* (2) Assertion failed */
|
||||
FR_NOT_READY, /* (3) The physical drive cannot work */
|
||||
FR_NO_FILE, /* (4) Could not find the file */
|
||||
FR_NO_PATH, /* (5) Could not find the path */
|
||||
FR_INVALID_NAME, /* (6) The path name format is invalid */
|
||||
FR_DENIED, /* (7) Access denied due to prohibited access or directory full */
|
||||
FR_EXIST, /* (8) Access denied due to prohibited access */
|
||||
FR_INVALID_OBJECT, /* (9) The file/directory object is invalid */
|
||||
FR_WRITE_PROTECTED, /* (10) The physical drive is write protected */
|
||||
FR_INVALID_DRIVE, /* (11) The logical drive number is invalid */
|
||||
FR_NOT_ENABLED, /* (12) The volume has no work area */
|
||||
FR_NO_FILESYSTEM, /* (13) There is no valid FAT volume */
|
||||
FR_MKFS_ABORTED, /* (14) The f_mkfs() aborted due to any problem */
|
||||
FR_TIMEOUT, /* (15) Could not get a grant to access the volume within defined period */
|
||||
FR_LOCKED, /* (16) The operation is rejected according to the file sharing policy */
|
||||
FR_NOT_ENOUGH_CORE, /* (17) LFN working buffer could not be allocated */
|
||||
FR_TOO_MANY_OPEN_FILES, /* (18) Number of open files > FF_FS_LOCK */
|
||||
FR_INVALID_PARAMETER /* (19) Given parameter is invalid */
|
||||
} FRESULT;
|
||||
|
||||
|
||||
|
||||
/*--------------------------------------------------------------*/
|
||||
/* FatFs module application interface */
|
||||
|
||||
FRESULT f_open (FIL* fp, const TCHAR* path, BYTE mode); /* Open or create a file */
|
||||
FRESULT f_close (FIL* fp); /* Close an open file object */
|
||||
FRESULT f_read (FIL* fp, void* buff, UINT btr, UINT* br); /* Read data from the file */
|
||||
FRESULT f_write (FIL* fp, const void* buff, UINT btw, UINT* bw); /* Write data to the file */
|
||||
FRESULT f_lseek (FIL* fp, FSIZE_t ofs); /* Move file pointer of the file object */
|
||||
FRESULT f_truncate (FIL* fp); /* Truncate the file */
|
||||
FRESULT f_sync (FIL* fp); /* Flush cached data of the writing file */
|
||||
FRESULT f_opendir (DIR* dp, const TCHAR* path); /* Open a directory */
|
||||
FRESULT f_closedir (DIR* dp); /* Close an open directory */
|
||||
FRESULT f_readdir (DIR* dp, FILINFO* fno); /* Read a directory item */
|
||||
FRESULT f_seekdir(DIR *dj, int offset); /* Seek in directory */
|
||||
FRESULT f_findfirst (DIR* dp, FILINFO* fno, const TCHAR* path, const TCHAR* pattern); /* Find first file */
|
||||
FRESULT f_findnext (DIR* dp, FILINFO* fno); /* Find next file */
|
||||
FRESULT f_mkdir (const TCHAR* path); /* Create a sub directory */
|
||||
FRESULT f_unlink (const TCHAR* path); /* Delete an existing file or directory */
|
||||
FRESULT f_rename (const TCHAR* path_old, const TCHAR* path_new); /* Rename/Move a file or directory */
|
||||
FRESULT f_stat (const TCHAR* path, FILINFO* fno); /* Get file status */
|
||||
FRESULT f_chmod (const TCHAR* path, BYTE attr, BYTE mask); /* Change attribute of a file/dir */
|
||||
FRESULT f_utime (const TCHAR* path, const FILINFO* fno); /* Change timestamp of a file/dir */
|
||||
FRESULT f_chdir (const TCHAR* path); /* Change current directory */
|
||||
FRESULT f_chdrive (const TCHAR* path); /* Change current drive */
|
||||
FRESULT f_getcwd (TCHAR* buff, UINT len); /* Get current directory */
|
||||
FRESULT f_getfree (const TCHAR* path, DWORD* nclst, FATFS** fatfs); /* Get number of free clusters on the drive */
|
||||
FRESULT f_getlabel (const TCHAR* path, TCHAR* label, DWORD* vsn); /* Get volume label */
|
||||
FRESULT f_setlabel (const TCHAR* label); /* Set volume label */
|
||||
FRESULT f_forward (FIL* fp, UINT(*func)(const BYTE*,UINT), UINT btf, UINT* bf); /* Forward data to the stream */
|
||||
FRESULT f_expand (FIL* fp, FSIZE_t fsz, BYTE opt); /* Allocate a contiguous block to the file */
|
||||
FRESULT f_mount (FATFS* fs, const TCHAR* path, BYTE opt); /* Mount/Unmount a logical drive */
|
||||
FRESULT f_mkfs (const TCHAR* path, const MKFS_PARM* opt, void* work, UINT len); /* Create a FAT volume */
|
||||
FRESULT f_fdisk (BYTE pdrv, const LBA_t ptbl[], void* work); /* Divide a physical drive into some partitions */
|
||||
FRESULT f_setcp (WORD cp); /* Set current code page */
|
||||
int f_putc (TCHAR c, FIL* fp); /* Put a character to the file */
|
||||
int f_puts (const TCHAR* str, FIL* cp); /* Put a string to the file */
|
||||
int f_printf (FIL* fp, const TCHAR* str, ...); /* Put a formatted string to the file */
|
||||
TCHAR* f_gets (TCHAR* buff, int len, FIL* fp); /* Get a string from the file */
|
||||
|
||||
#define f_eof(fp) ((int)((fp)->fptr == (fp)->obj.objsize))
|
||||
#define f_error(fp) ((fp)->err)
|
||||
#define f_tell(fp) ((fp)->fptr)
|
||||
#define f_size(fp) ((fp)->obj.objsize)
|
||||
#define f_rewind(fp) f_lseek((fp), 0)
|
||||
#define f_rewinddir(dp) f_readdir((dp), 0)
|
||||
#define f_rmdir(path) f_unlink(path)
|
||||
#define f_unmount(path) f_mount(0, path, 0)
|
||||
|
||||
|
||||
|
||||
|
||||
/*--------------------------------------------------------------*/
|
||||
/* Additional user defined functions */
|
||||
|
||||
/* RTC function */
|
||||
#if !FF_FS_READONLY && !FF_FS_NORTC
|
||||
DWORD get_fattime (void);
|
||||
#endif
|
||||
|
||||
/* LFN support functions */
|
||||
#if FF_USE_LFN >= 1 /* Code conversion (defined in unicode.c) */
|
||||
WCHAR ff_oem2uni (WCHAR oem, WORD cp); /* OEM code to Unicode conversion */
|
||||
WCHAR ff_uni2oem (DWORD uni, WORD cp); /* Unicode to OEM code conversion */
|
||||
DWORD ff_wtoupper (DWORD uni); /* Unicode upper-case conversion */
|
||||
#endif
|
||||
#if FF_USE_LFN == 3 /* Dynamic memory allocation */
|
||||
void* ff_memalloc (UINT msize); /* Allocate memory block */
|
||||
void ff_memfree (void* mblock); /* Free memory block */
|
||||
#endif
|
||||
|
||||
/* Sync functions */
|
||||
#if FF_FS_REENTRANT
|
||||
int ff_cre_syncobj (BYTE vol, FF_SYNC_t* sobj); /* Create a sync object */
|
||||
int ff_req_grant (FF_SYNC_t sobj); /* Lock sync object */
|
||||
void ff_rel_grant (FF_SYNC_t sobj); /* Unlock sync object */
|
||||
int ff_del_syncobj (FF_SYNC_t sobj); /* Delete a sync object */
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
/*--------------------------------------------------------------*/
|
||||
/* Flags and offset address */
|
||||
|
||||
|
||||
/* File access mode and open method flags (3rd argument of f_open) */
|
||||
#define FA_READ 0x01
|
||||
#define FA_WRITE 0x02
|
||||
#define FA_OPEN_EXISTING 0x00
|
||||
#define FA_CREATE_NEW 0x04
|
||||
#define FA_CREATE_ALWAYS 0x08
|
||||
#define FA_OPEN_ALWAYS 0x10
|
||||
#define FA_OPEN_APPEND 0x30
|
||||
|
||||
/* Fast seek controls (2nd argument of f_lseek) */
|
||||
#define CREATE_LINKMAP ((FSIZE_t)0 - 1)
|
||||
|
||||
/* Format options (2nd argument of f_mkfs) */
|
||||
#define FM_FAT 0x01
|
||||
#define FM_FAT32 0x02
|
||||
#define FM_EXFAT 0x04
|
||||
#define FM_ANY 0x07
|
||||
#define FM_SFD 0x08
|
||||
|
||||
/* Filesystem type (FATFS.fs_type) */
|
||||
#define FS_FAT12 1
|
||||
#define FS_FAT16 2
|
||||
#define FS_FAT32 3
|
||||
#define FS_EXFAT 4
|
||||
|
||||
/* File attribute bits for directory entry (FILINFO.fattrib) */
|
||||
#define AM_RDO 0x01 /* Read only */
|
||||
#define AM_HID 0x02 /* Hidden */
|
||||
#define AM_SYS 0x04 /* System */
|
||||
#define AM_DIR 0x10 /* Directory */
|
||||
#define AM_ARC 0x20 /* Archive */
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* FF_DEFINED */
|
||||
@@ -0,0 +1,345 @@
|
||||
/*---------------------------------------------------------------------------/
|
||||
/ FatFs Functional Configurations
|
||||
/---------------------------------------------------------------------------*/
|
||||
|
||||
#define FFCONF_DEF 86631 /* Revision ID */
|
||||
|
||||
/*---------------------------------------------------------------------------/
|
||||
/ Function Configurations
|
||||
/---------------------------------------------------------------------------*/
|
||||
|
||||
#define FF_FS_READONLY 0
|
||||
/* This option switches read-only configuration. (0:Read/Write or 1:Read-only)
|
||||
/ Read-only configuration removes writing API functions, f_write(), f_sync(),
|
||||
/ f_unlink(), f_mkdir(), f_chmod(), f_rename(), f_truncate(), f_getfree()
|
||||
/ and optional writing functions as well. */
|
||||
|
||||
|
||||
#define FF_FS_MINIMIZE 0
|
||||
/* This option defines minimization level to remove some basic API functions.
|
||||
/
|
||||
/ 0: Basic functions are fully enabled.
|
||||
/ 1: f_stat(), f_getfree(), f_unlink(), f_mkdir(), f_truncate() and f_rename()
|
||||
/ are removed.
|
||||
/ 2: f_opendir(), f_readdir() and f_closedir() are removed in addition to 1.
|
||||
/ 3: f_lseek() function is removed in addition to 2. */
|
||||
|
||||
|
||||
#define FF_USE_FIND 0
|
||||
/* This option switches filtered directory read functions, f_findfirst() and
|
||||
/ f_findnext(). (0:Disable, 1:Enable 2:Enable with matching altname[] too) */
|
||||
|
||||
|
||||
#define FF_USE_MKFS 1
|
||||
/* This option switches f_mkfs() function. (0:Disable or 1:Enable) */
|
||||
|
||||
|
||||
#define FF_USE_FASTSEEK 1
|
||||
/* This option switches fast seek function. (0:Disable or 1:Enable) */
|
||||
|
||||
|
||||
#define FF_USE_EXPAND 0
|
||||
/* This option switches f_expand function. (0:Disable or 1:Enable) */
|
||||
|
||||
|
||||
#define FF_USE_CHMOD 0
|
||||
/* This option switches attribute manipulation functions, f_chmod() and f_utime().
|
||||
/ (0:Disable or 1:Enable) Also FF_FS_READONLY needs to be 0 to enable this option. */
|
||||
|
||||
|
||||
#define FF_USE_LABEL 0
|
||||
/* This option switches volume label functions, f_getlabel() and f_setlabel().
|
||||
/ (0:Disable or 1:Enable) */
|
||||
|
||||
|
||||
#define FF_USE_FORWARD 0
|
||||
/* This option switches f_forward() function. (0:Disable or 1:Enable) */
|
||||
|
||||
|
||||
#define FF_USE_STRFUNC 0
|
||||
#define FF_PRINT_LLI 0
|
||||
#define FF_PRINT_FLOAT 0
|
||||
#define FF_STRF_ENCODE 3
|
||||
/* FF_USE_STRFUNC switches string functions, f_gets(), f_putc(), f_puts() and
|
||||
/ f_printf().
|
||||
/
|
||||
/ 0: Disable. FF_PRINT_LLI, FF_PRINT_FLOAT and FF_STRF_ENCODE have no effect.
|
||||
/ 1: Enable without LF-CRLF conversion.
|
||||
/ 2: Enable with LF-CRLF conversion.
|
||||
/
|
||||
/ FF_PRINT_LLI = 1 makes f_printf() support long long argument and FF_PRINT_FLOAT = 1/2
|
||||
makes f_printf() support floating point argument. These features want C99 or later.
|
||||
/ When FF_LFN_UNICODE >= 1 with LFN enabled, string functions convert the character
|
||||
/ encoding in it. FF_STRF_ENCODE selects assumption of character encoding ON THE FILE
|
||||
/ to be read/written via those functions.
|
||||
/
|
||||
/ 0: ANSI/OEM in current CP
|
||||
/ 1: Unicode in UTF-16LE
|
||||
/ 2: Unicode in UTF-16BE
|
||||
/ 3: Unicode in UTF-8
|
||||
*/
|
||||
|
||||
|
||||
/*---------------------------------------------------------------------------/
|
||||
/ Locale and Namespace Configurations
|
||||
/---------------------------------------------------------------------------*/
|
||||
|
||||
#ifdef RT_DFS_ELM_CODE_PAGE
|
||||
# define FF_CODE_PAGE RT_DFS_ELM_CODE_PAGE
|
||||
#else
|
||||
# define FF_CODE_PAGE 936
|
||||
#endif
|
||||
/* This option specifies the OEM code page to be used on the target system.
|
||||
/ Incorrect code page setting can cause a file open failure.
|
||||
/
|
||||
/ 437 - U.S.
|
||||
/ 720 - Arabic
|
||||
/ 737 - Greek
|
||||
/ 771 - KBL
|
||||
/ 775 - Baltic
|
||||
/ 850 - Latin 1
|
||||
/ 852 - Latin 2
|
||||
/ 855 - Cyrillic
|
||||
/ 857 - Turkish
|
||||
/ 860 - Portuguese
|
||||
/ 861 - Icelandic
|
||||
/ 862 - Hebrew
|
||||
/ 863 - Canadian French
|
||||
/ 864 - Arabic
|
||||
/ 865 - Nordic
|
||||
/ 866 - Russian
|
||||
/ 869 - Greek 2
|
||||
/ 932 - Japanese (DBCS)
|
||||
/ 936 - Simplified Chinese (DBCS)
|
||||
/ 949 - Korean (DBCS)
|
||||
/ 950 - Traditional Chinese (DBCS)
|
||||
/ 0 - Include all code pages above and configured by f_setcp()
|
||||
*/
|
||||
|
||||
|
||||
#if RT_DFS_ELM_USE_LFN
|
||||
#define FF_USE_LFN RT_DFS_ELM_USE_LFN
|
||||
#define FF_MAX_LFN RT_DFS_ELM_MAX_LFN
|
||||
#else
|
||||
#define FF_USE_LFN 0 /* 0 to 3 */
|
||||
#define FF_MAX_LFN 255 /* Maximum LFN length to handle (12 to 255) */
|
||||
#endif
|
||||
/* The FF_USE_LFN switches the support for LFN (long file name).
|
||||
/
|
||||
/ 0: Disable LFN. FF_MAX_LFN has no effect.
|
||||
/ 1: Enable LFN with static working buffer on the BSS. Always NOT thread-safe.
|
||||
/ 2: Enable LFN with dynamic working buffer on the STACK.
|
||||
/ 3: Enable LFN with dynamic working buffer on the HEAP.
|
||||
/
|
||||
/ To enable the LFN, ffunicode.c needs to be added to the project. The LFN function
|
||||
/ requiers certain internal working buffer occupies (FF_MAX_LFN + 1) * 2 bytes and
|
||||
/ additional (FF_MAX_LFN + 44) / 15 * 32 bytes when exFAT is enabled.
|
||||
/ The FF_MAX_LFN defines size of the working buffer in UTF-16 code unit and it can
|
||||
/ be in range of 12 to 255. It is recommended to be set it 255 to fully support LFN
|
||||
/ specification.
|
||||
/ When use stack for the working buffer, take care on stack overflow. When use heap
|
||||
/ memory for the working buffer, memory management functions, ff_memalloc() and
|
||||
/ ff_memfree() exemplified in ffsystem.c, need to be added to the project. */
|
||||
|
||||
|
||||
#ifdef RT_DFS_ELM_LFN_UNICODE
|
||||
/* This option switches the character encoding on the API when LFN is enabled.
|
||||
/
|
||||
/ 0: ANSI/OEM in current CP (TCHAR = char)
|
||||
/ 1: Unicode in UTF-16 (TCHAR = WCHAR)
|
||||
/ 2: Unicode in UTF-8 (TCHAR = char)
|
||||
/ 3: Unicode in UTF-32 (TCHAR = DWORD)
|
||||
/
|
||||
/ Also behavior of string I/O functions will be affected by this option.
|
||||
/ When LFN is not enabled, this option has no effect. */
|
||||
#define FF_LFN_UNICODE RT_DFS_ELM_LFN_UNICODE /* 0:ANSI/OEM or 1:Unicode */
|
||||
#else
|
||||
#define FF_LFN_UNICODE 0 /* 0:ANSI/OEM or 1:Unicode */
|
||||
#endif
|
||||
/* This option switches the character encoding on the API when LFN is enabled.
|
||||
/
|
||||
/ 0: ANSI/OEM in current CP (TCHAR = char)
|
||||
/ 1: Unicode in UTF-16 (TCHAR = WCHAR)
|
||||
/ 2: Unicode in UTF-8 (TCHAR = char)
|
||||
/ 3: Unicode in UTF-32 (TCHAR = DWORD)
|
||||
/
|
||||
/ Also behavior of string I/O functions will be affected by this option.
|
||||
/ When LFN is not enabled, this option has no effect. */
|
||||
|
||||
|
||||
#define FF_LFN_BUF 255
|
||||
#define FF_SFN_BUF 12
|
||||
/* This set of options defines size of file name members in the FILINFO structure
|
||||
/ which is used to read out directory items. These values should be suffcient for
|
||||
/ the file names to read. The maximum possible length of the read file name depends
|
||||
/ on character encoding. When LFN is not enabled, these options have no effect. */
|
||||
|
||||
|
||||
#define FF_FS_RPATH 0
|
||||
/* This option configures support for relative path.
|
||||
/
|
||||
/ 0: Disable relative path and remove related functions.
|
||||
/ 1: Enable relative path. f_chdir() and f_chdrive() are available.
|
||||
/ 2: f_getcwd() function is available in addition to 1.
|
||||
*/
|
||||
|
||||
|
||||
/*---------------------------------------------------------------------------/
|
||||
/ Drive/Volume Configurations
|
||||
/---------------------------------------------------------------------------*/
|
||||
|
||||
#ifdef RT_DFS_ELM_DRIVES
|
||||
#define FF_VOLUMES RT_DFS_ELM_DRIVES
|
||||
#else
|
||||
#define FF_VOLUMES 1
|
||||
#endif
|
||||
/* Number of volumes (logical drives) to be used. (1-10) */
|
||||
|
||||
|
||||
#define FF_STR_VOLUME_ID 0
|
||||
#define FF_VOLUME_STRS "RAM","NAND","CF","SD","SD2","USB","USB2","USB3"
|
||||
/* FF_STR_VOLUME_ID switches support for volume ID in arbitrary strings.
|
||||
/ When FF_STR_VOLUME_ID is set to 1 or 2, arbitrary strings can be used as drive
|
||||
/ number in the path name. FF_VOLUME_STRS defines the volume ID strings for each
|
||||
/ logical drives. Number of items must not be less than FF_VOLUMES. Valid
|
||||
/ characters for the volume ID strings are A-Z, a-z and 0-9, however, they are
|
||||
/ compared in case-insensitive. If FF_STR_VOLUME_ID >= 1 and FF_VOLUME_STRS is
|
||||
/ not defined, a user defined volume string table needs to be defined as:
|
||||
/
|
||||
/ const char* VolumeStr[FF_VOLUMES] = {"ram","flash","sd","usb",...
|
||||
*/
|
||||
|
||||
|
||||
#define FF_MULTI_PARTITION 0
|
||||
/* This option switches support for multiple volumes on the physical drive.
|
||||
/ By default (0), each logical drive number is bound to the same physical drive
|
||||
/ number and only an FAT volume found on the physical drive will be mounted.
|
||||
/ When this function is enabled (1), each logical drive number can be bound to
|
||||
/ arbitrary physical drive and partition listed in the VolToPart[]. Also f_fdisk()
|
||||
/ funciton will be available. */
|
||||
|
||||
|
||||
#define FF_MIN_SS 512
|
||||
#ifdef RT_DFS_ELM_MAX_SECTOR_SIZE
|
||||
#define FF_MAX_SS RT_DFS_ELM_MAX_SECTOR_SIZE
|
||||
#else
|
||||
#define FF_MAX_SS 512 /* 512, 1024, 2048 or 4096 */
|
||||
#endif
|
||||
/* This set of options configures the range of sector size to be supported. (512,
|
||||
/ 1024, 2048 or 4096) Always set both 512 for most systems, generic memory card and
|
||||
/ harddisk, but a larger value may be required for on-board flash memory and some
|
||||
/ type of optical media. When FF_MAX_SS is larger than FF_MIN_SS, FatFs is configured
|
||||
/ for variable sector size mode and disk_ioctl() function needs to implement
|
||||
/ GET_SECTOR_SIZE command. */
|
||||
|
||||
|
||||
#define FF_LBA64 0
|
||||
/* This option switches support for 64-bit LBA. (0:Disable or 1:Enable)
|
||||
/ To enable the 64-bit LBA, also exFAT needs to be enabled. (FF_FS_EXFAT == 1) */
|
||||
|
||||
|
||||
#define FF_MIN_GPT 0x10000000
|
||||
/* Minimum number of sectors to switch GPT as partitioning format in f_mkfs and
|
||||
/ f_fdisk function. 0x100000000 max. This option has no effect when FF_LBA64 == 0. */
|
||||
|
||||
|
||||
#define FF_USE_TRIM 0
|
||||
/* This option switches support for ATA-TRIM. (0:Disable or 1:Enable)
|
||||
/ To enable Trim function, also CTRL_TRIM command should be implemented to the
|
||||
/ disk_ioctl() function. */
|
||||
|
||||
|
||||
|
||||
/*---------------------------------------------------------------------------/
|
||||
/ System Configurations
|
||||
/---------------------------------------------------------------------------*/
|
||||
|
||||
#define FF_FS_TINY 0
|
||||
/* This option switches tiny buffer configuration. (0:Normal or 1:Tiny)
|
||||
/ At the tiny configuration, size of file object (FIL) is shrinked FF_MAX_SS bytes.
|
||||
/ Instead of private sector buffer eliminated from the file object, common sector
|
||||
/ buffer in the filesystem object (FATFS) is used for the file data transfer. */
|
||||
|
||||
#ifdef RT_DFS_ELM_USE_EXFAT
|
||||
#define FF_FS_EXFAT 1
|
||||
#else
|
||||
#define FF_FS_EXFAT 0
|
||||
#endif
|
||||
/* This option switches support for exFAT filesystem. (0:Disable or 1:Enable)
|
||||
/ To enable exFAT, also LFN needs to be enabled. (FF_USE_LFN >= 1)
|
||||
/ Note that enabling exFAT discards ANSI C (C89) compatibility. */
|
||||
|
||||
|
||||
#define FF_FS_NORTC 0
|
||||
#define FF_NORTC_MON 1
|
||||
#define FF_NORTC_MDAY 1
|
||||
#define FF_NORTC_YEAR 2020
|
||||
/* The option FF_FS_NORTC switches timestamp functiton. If the system does not have
|
||||
/ any RTC function or valid timestamp is not needed, set FF_FS_NORTC = 1 to disable
|
||||
/ the timestamp function. Every object modified by FatFs will have a fixed timestamp
|
||||
/ defined by FF_NORTC_MON, FF_NORTC_MDAY and FF_NORTC_YEAR in local time.
|
||||
/ To enable timestamp function (FF_FS_NORTC = 0), get_fattime() function need to be
|
||||
/ added to the project to read current time form real-time clock. FF_NORTC_MON,
|
||||
/ FF_NORTC_MDAY and FF_NORTC_YEAR have no effect.
|
||||
/ These options have no effect in read-only configuration (FF_FS_READONLY = 1). */
|
||||
|
||||
|
||||
#define FF_FS_NOFSINFO 0
|
||||
/* If you need to know correct free space on the FAT32 volume, set bit 0 of this
|
||||
/ option, and f_getfree() function at first time after volume mount will force
|
||||
/ a full FAT scan. Bit 1 controls the use of last allocated cluster number.
|
||||
/
|
||||
/ bit0=0: Use free cluster count in the FSINFO if available.
|
||||
/ bit0=1: Do not trust free cluster count in the FSINFO.
|
||||
/ bit1=0: Use last allocated cluster number in the FSINFO if available.
|
||||
/ bit1=1: Do not trust last allocated cluster number in the FSINFO.
|
||||
*/
|
||||
|
||||
|
||||
#define FF_FS_LOCK 0
|
||||
/* The option FF_FS_LOCK switches file lock function to control duplicated file open
|
||||
/ and illegal operation to open objects. This option must be 0 when FF_FS_READONLY
|
||||
/ is 1.
|
||||
/
|
||||
/ 0: Disable file lock function. To avoid volume corruption, application program
|
||||
/ should avoid illegal open, remove and rename to the open objects.
|
||||
/ >0: Enable file lock function. The value defines how many files/sub-directories
|
||||
/ can be opened simultaneously under file lock control. Note that the file
|
||||
/ lock control is independent of re-entrancy. */
|
||||
|
||||
|
||||
/* #include <somertos.h> // O/S definitions */
|
||||
#include <rtdef.h>
|
||||
#ifdef RT_DFS_ELM_REENTRANT
|
||||
#define FF_FS_REENTRANT 1 /* 0 or 1 */
|
||||
#else
|
||||
#define FF_FS_REENTRANT 0 /* 0:Disable or 1:Enable */
|
||||
#endif
|
||||
#ifndef RT_DFS_ELM_MUTEX_TIMEOUT
|
||||
#define RT_DFS_ELM_MUTEX_TIMEOUT 3000
|
||||
#endif
|
||||
#define FF_FS_TIMEOUT RT_DFS_ELM_MUTEX_TIMEOUT
|
||||
#define FF_SYNC_t rt_mutex_t
|
||||
/* The option FF_FS_REENTRANT switches the re-entrancy (thread safe) of the FatFs
|
||||
/ module itself. Note that regardless of this option, file access to different
|
||||
/ volume is always re-entrant and volume control functions, f_mount(), f_mkfs()
|
||||
/ and f_fdisk() function, are always not re-entrant. Only file/directory access
|
||||
/ to the same volume is under control of this function.
|
||||
/
|
||||
/ 0: Disable re-entrancy. FF_FS_TIMEOUT and FF_SYNC_t have no effect.
|
||||
/ 1: Enable re-entrancy. Also user provided synchronization handlers,
|
||||
/ ff_req_grant(), ff_rel_grant(), ff_del_syncobj() and ff_cre_syncobj()
|
||||
/ function, must be added to the project. Samples are available in
|
||||
/ option/syscall.c.
|
||||
/
|
||||
/ The FF_FS_TIMEOUT defines timeout period in unit of time tick.
|
||||
/ The FF_SYNC_t defines O/S dependent sync object type. e.g. HANDLE, ID, OS_EVENT*,
|
||||
/ SemaphoreHandle_t and etc. A header file for O/S definitions needs to be
|
||||
/ included somewhere in the scope of ff.h. */
|
||||
|
||||
|
||||
|
||||
/*--- End of configuration options ---*/
|
||||
#define _FS_EXFAT 1 /* 启用 exFAT 支持 */
|
||||
#define _USE_LFN 3 /* 启用长文件名（exFAT 常用） */
|
||||
#define _CODE_PAGE 437 /* 或 936（简体中文） */
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,13 @@
|
||||
# RT-Thread building script for component
|
||||
|
||||
from building import *
|
||||
|
||||
cwd = GetCurrentDir()
|
||||
src = Glob('*.c') + Glob('rpc/*.c')
|
||||
CPPPATH = [cwd]
|
||||
|
||||
SrcRemove(src, ['rpc/auth_none.c'])
|
||||
|
||||
group = DefineGroup('Filesystem', src, depend = ['RT_USING_DFS', 'RT_USING_DFS_NFS'], CPPPATH = CPPPATH)
|
||||
|
||||
Return('group')
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,15 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
|
||||
#ifndef __NFS_H__
|
||||
#define __NFS_H__
|
||||
|
||||
int nfs_init(void);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,131 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
/*
|
||||
* Please do not edit this file.
|
||||
* It was generated using rpcgen.
|
||||
*/
|
||||
|
||||
#ifndef _MOUNT_H_RPCGEN
|
||||
#define _MOUNT_H_RPCGEN
|
||||
|
||||
#include <rpc/rpc.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* This file is copied from RFC1813
|
||||
* Copyright 1995 Sun Micrososystems (I assume)
|
||||
*/
|
||||
#define MNTPATHLEN 1024
|
||||
#define MNTNAMLEN 255
|
||||
#define FHSIZE3 64
|
||||
|
||||
typedef struct {
|
||||
unsigned int fhandle3_len;
|
||||
char *fhandle3_val;
|
||||
} fhandle3;
|
||||
|
||||
typedef char *dirpath;
|
||||
|
||||
typedef char *name;
|
||||
|
||||
typedef struct exportnode *exports;
|
||||
|
||||
typedef struct groupnode *groups;
|
||||
|
||||
typedef struct mountbody *mountlist;
|
||||
|
||||
enum mountstat3 {
|
||||
MNT3_OK = 0,
|
||||
MNT3ERR_PERM = 1,
|
||||
MNT3ERR_NOENT = 2,
|
||||
MNT3ERR_IO = 5,
|
||||
MNT3ERR_ACCES = 13,
|
||||
MNT3ERR_NOTDIR = 20,
|
||||
MNT3ERR_INVAL = 22,
|
||||
MNT3ERR_NAMETOOLONG = 63,
|
||||
MNT3ERR_NOTSUPP = 10004,
|
||||
MNT3ERR_SERVERFAULT = 10006
|
||||
};
|
||||
typedef enum mountstat3 mountstat3;
|
||||
|
||||
struct mountres3_ok {
|
||||
fhandle3 fhandle;
|
||||
struct {
|
||||
unsigned int auth_flavors_len;
|
||||
int *auth_flavors_val;
|
||||
} auth_flavors;
|
||||
};
|
||||
typedef struct mountres3_ok mountres3_ok;
|
||||
|
||||
struct mountres3 {
|
||||
mountstat3 fhs_status;
|
||||
union {
|
||||
mountres3_ok mountinfo;
|
||||
} mountres3_u;
|
||||
};
|
||||
typedef struct mountres3 mountres3;
|
||||
|
||||
struct mountbody {
|
||||
name ml_hostname;
|
||||
dirpath ml_directory;
|
||||
mountlist ml_next;
|
||||
};
|
||||
typedef struct mountbody mountbody;
|
||||
|
||||
struct groupnode {
|
||||
name gr_name;
|
||||
groups gr_next;
|
||||
};
|
||||
typedef struct groupnode groupnode;
|
||||
|
||||
struct exportnode {
|
||||
dirpath ex_dir;
|
||||
groups ex_groups;
|
||||
exports ex_next;
|
||||
};
|
||||
typedef struct exportnode exportnode;
|
||||
|
||||
#define MOUNT_PROGRAM 100005
|
||||
#define MOUNT_V3 3
|
||||
|
||||
#define MOUNTPROC3_NULL 0
|
||||
extern enum clnt_stat mountproc3_null_3(void *, CLIENT *);
|
||||
#define MOUNTPROC3_MNT 1
|
||||
extern enum clnt_stat mountproc3_mnt_3(dirpath , mountres3 *, CLIENT *);
|
||||
#define MOUNTPROC3_DUMP 2
|
||||
extern enum clnt_stat mountproc3_dump_3(mountlist *, CLIENT *);
|
||||
#define MOUNTPROC3_UMNT 3
|
||||
extern enum clnt_stat mountproc3_umnt_3(dirpath , void *, CLIENT *);
|
||||
#define MOUNTPROC3_UMNTALL 4
|
||||
extern enum clnt_stat mountproc3_umntall_3(void *, CLIENT *);
|
||||
#define MOUNTPROC3_EXPORT 5
|
||||
extern enum clnt_stat mountproc3_export_3(exports *, CLIENT *);
|
||||
|
||||
/* the xdr functions */
|
||||
|
||||
extern bool_t xdr_fhandle3(XDR *, fhandle3*);
|
||||
extern bool_t xdr_dirpath(XDR *, dirpath*);
|
||||
extern bool_t xdr_name(XDR *, name*);
|
||||
extern bool_t xdr_exports(XDR *, exports*);
|
||||
extern bool_t xdr_groups(XDR *, groups*);
|
||||
extern bool_t xdr_mountlist(XDR *, mountlist*);
|
||||
extern bool_t xdr_mountstat3(XDR *, mountstat3*);
|
||||
extern bool_t xdr_mountres3_ok(XDR *, mountres3_ok*);
|
||||
extern bool_t xdr_mountres3(XDR *, mountres3*);
|
||||
extern bool_t xdr_mountbody(XDR *, mountbody*);
|
||||
extern bool_t xdr_groupnode(XDR *, groupnode*);
|
||||
extern bool_t xdr_exportnode(XDR *, exportnode*);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* !_MOUNT_H_RPCGEN */
|
||||
@@ -0,0 +1,68 @@
|
||||
%/* This file is copied from RFC1813
|
||||
% * Copyright 1995 Sun Micrososystems (I assume)
|
||||
% */
|
||||
|
||||
const MNTPATHLEN = 1024; /* Maximum bytes in a path name */
|
||||
const MNTNAMLEN = 255; /* Maximum bytes in a name */
|
||||
const FHSIZE3 = 64; /* Maximum bytes in a V3 file handle */
|
||||
|
||||
typedef opaque fhandle3<FHSIZE3>;
|
||||
typedef string dirpath<MNTPATHLEN>;
|
||||
typedef string name<MNTNAMLEN>;
|
||||
|
||||
typedef struct exportnode *exports;
|
||||
typedef struct groupnode *groups;
|
||||
typedef struct mountbody *mountlist;
|
||||
|
||||
enum mountstat3 {
|
||||
MNT3_OK = 0, /* no error */
|
||||
MNT3ERR_PERM = 1, /* Not owner */
|
||||
MNT3ERR_NOENT = 2, /* No such file or directory */
|
||||
MNT3ERR_IO = 5, /* I/O error */
|
||||
MNT3ERR_ACCES = 13, /* Permission denied */
|
||||
MNT3ERR_NOTDIR = 20, /* Not a directory */
|
||||
MNT3ERR_INVAL = 22, /* Invalid argument */
|
||||
MNT3ERR_NAMETOOLONG = 63, /* Filename too long */
|
||||
MNT3ERR_NOTSUPP = 10004, /* Operation not supported */
|
||||
MNT3ERR_SERVERFAULT = 10006 /* A failure on the server */
|
||||
};
|
||||
|
||||
struct mountres3_ok {
|
||||
fhandle3 fhandle;
|
||||
int auth_flavors<>;
|
||||
};
|
||||
|
||||
union mountres3 switch (mountstat3 fhs_status) {
|
||||
case MNT3_OK:
|
||||
mountres3_ok mountinfo;
|
||||
default:
|
||||
void;
|
||||
};
|
||||
|
||||
struct mountbody {
|
||||
name ml_hostname;
|
||||
dirpath ml_directory;
|
||||
mountlist ml_next;
|
||||
};
|
||||
|
||||
struct groupnode {
|
||||
name gr_name;
|
||||
groups gr_next;
|
||||
};
|
||||
|
||||
struct exportnode {
|
||||
dirpath ex_dir;
|
||||
groups ex_groups;
|
||||
exports ex_next;
|
||||
};
|
||||
|
||||
program MOUNT_PROGRAM {
|
||||
version MOUNT_V3 {
|
||||
void MOUNTPROC3_NULL(void) = 0;
|
||||
mountres3 MOUNTPROC3_MNT(dirpath) = 1;
|
||||
mountlist MOUNTPROC3_DUMP(void) = 2;
|
||||
void MOUNTPROC3_UMNT(dirpath) = 3;
|
||||
void MOUNTPROC3_UMNTALL(void) = 4;
|
||||
exports MOUNTPROC3_EXPORT(void) = 5;
|
||||
} = 3;
|
||||
} = 100005;
|
||||
@@ -0,0 +1,78 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
/*
|
||||
* Please do not edit this file.
|
||||
* It was generated using rpcgen.
|
||||
*/
|
||||
|
||||
#include <string.h> /* for memset */
|
||||
#include "mount.h"
|
||||
|
||||
/* This file is copied from RFC1813
|
||||
* Copyright 1995 Sun Micrososystems (I assume)
|
||||
*/
|
||||
|
||||
typedef char* caddr_t;
|
||||
|
||||
/* Default timeout can be changed using clnt_control() */
|
||||
static struct timeval TIMEOUT = { 25, 0 };
|
||||
|
||||
enum clnt_stat
|
||||
mountproc3_null_3(void *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, MOUNTPROC3_NULL,
|
||||
(xdrproc_t) xdr_void, (caddr_t) NULL,
|
||||
(xdrproc_t) xdr_void, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
mountproc3_mnt_3(dirpath arg1, mountres3 *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, MOUNTPROC3_MNT,
|
||||
(xdrproc_t) xdr_dirpath, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_mountres3, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
mountproc3_dump_3(mountlist *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, MOUNTPROC3_DUMP,
|
||||
(xdrproc_t) xdr_void, (caddr_t) NULL,
|
||||
(xdrproc_t) xdr_mountlist, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
mountproc3_umnt_3(dirpath arg1, void *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, MOUNTPROC3_UMNT,
|
||||
(xdrproc_t) xdr_dirpath, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_void, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
mountproc3_umntall_3(void *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, MOUNTPROC3_UMNTALL,
|
||||
(xdrproc_t) xdr_void, (caddr_t) NULL,
|
||||
(xdrproc_t) xdr_void, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
mountproc3_export_3(exports *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, MOUNTPROC3_EXPORT,
|
||||
(xdrproc_t) xdr_void, (caddr_t) NULL,
|
||||
(xdrproc_t) xdr_exports, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
@@ -0,0 +1,142 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
/*
|
||||
* Please do not edit this file.
|
||||
* It was generated using rpcgen.
|
||||
*/
|
||||
|
||||
#include "mount.h"
|
||||
/* This file is copied from RFC1813
|
||||
* Copyright 1995 Sun Micrososystems (I assume)
|
||||
*/
|
||||
|
||||
bool_t
|
||||
xdr_fhandle3(register XDR *xdrs, fhandle3 *objp)
|
||||
{
|
||||
if (!xdr_bytes(xdrs, (char **)&objp->fhandle3_val, (unsigned int *) &objp->fhandle3_len, FHSIZE3))
|
||||
return (FALSE);
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
bool_t
|
||||
xdr_dirpath(register XDR *xdrs, dirpath *objp)
|
||||
{
|
||||
if (!xdr_string(xdrs, objp, MNTPATHLEN))
|
||||
return (FALSE);
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
bool_t
|
||||
xdr_name(register XDR *xdrs, name *objp)
|
||||
{
|
||||
if (!xdr_string(xdrs, objp, MNTNAMLEN))
|
||||
return (FALSE);
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
bool_t
|
||||
xdr_exports(register XDR *xdrs, exports *objp)
|
||||
{
|
||||
if (!xdr_pointer(xdrs, (char **)objp, sizeof (struct exportnode), (xdrproc_t) xdr_exportnode))
|
||||
return (FALSE);
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
bool_t
|
||||
xdr_groups(register XDR *xdrs, groups *objp)
|
||||
{
|
||||
if (!xdr_pointer(xdrs, (char **)objp, sizeof (struct groupnode), (xdrproc_t) xdr_groupnode))
|
||||
return (FALSE);
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
bool_t
|
||||
xdr_mountlist(register XDR *xdrs, mountlist *objp)
|
||||
{
|
||||
if (!xdr_pointer(xdrs, (char **)objp, sizeof (struct mountbody), (xdrproc_t) xdr_mountbody))
|
||||
return (FALSE);
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
bool_t
|
||||
xdr_mountstat3(register XDR *xdrs, mountstat3 *objp)
|
||||
{
|
||||
int enum_objp;
|
||||
|
||||
enum_objp = *objp;
|
||||
|
||||
if (!xdr_enum(xdrs, (enum_t *)&enum_objp))
|
||||
{
|
||||
*objp = (mountstat3)enum_objp;
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
bool_t
|
||||
xdr_mountres3_ok(register XDR *xdrs, mountres3_ok *objp)
|
||||
{
|
||||
if (!xdr_fhandle3(xdrs, &objp->fhandle))
|
||||
return (FALSE);
|
||||
if (!xdr_array(xdrs, (char **)&objp->auth_flavors.auth_flavors_val, (unsigned int *) &objp->auth_flavors.auth_flavors_len, ~0,
|
||||
sizeof (int), (xdrproc_t) xdr_int))
|
||||
return (FALSE);
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
bool_t
|
||||
xdr_mountres3(register XDR *xdrs, mountres3 *objp)
|
||||
{
|
||||
if (!xdr_mountstat3(xdrs, &objp->fhs_status))
|
||||
return (FALSE);
|
||||
switch (objp->fhs_status) {
|
||||
case MNT3_OK:
|
||||
if (!xdr_mountres3_ok(xdrs, &objp->mountres3_u.mountinfo))
|
||||
return (FALSE);
|
||||
break;
|
||||
default :
|
||||
return (FALSE);
|
||||
}
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
bool_t
|
||||
xdr_mountbody(register XDR *xdrs, mountbody *objp)
|
||||
{
|
||||
if (!xdr_name(xdrs, &objp->ml_hostname))
|
||||
return (FALSE);
|
||||
if (!xdr_dirpath(xdrs, &objp->ml_directory))
|
||||
return (FALSE);
|
||||
if (!xdr_mountlist(xdrs, &objp->ml_next))
|
||||
return (FALSE);
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
bool_t
|
||||
xdr_groupnode(register XDR *xdrs, groupnode *objp)
|
||||
{
|
||||
if (!xdr_name(xdrs, &objp->gr_name))
|
||||
return (FALSE);
|
||||
if (!xdr_groups(xdrs, &objp->gr_next))
|
||||
return (FALSE);
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
bool_t
|
||||
xdr_exportnode(register XDR *xdrs, exportnode *objp)
|
||||
{
|
||||
if (!xdr_dirpath(xdrs, &objp->ex_dir))
|
||||
return (FALSE);
|
||||
if (!xdr_groups(xdrs, &objp->ex_groups))
|
||||
return (FALSE);
|
||||
if (!xdr_exports(xdrs, &objp->ex_next))
|
||||
return (FALSE);
|
||||
return (TRUE);
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,774 @@
|
||||
%/* This file is copied from RFC1813
|
||||
% * Copyright 1995 Sun Micrososystems (I assume)
|
||||
% */
|
||||
|
||||
const NFS3_FHSIZE = 64;
|
||||
const NFS3_COOKIEVERFSIZE = 8;
|
||||
const NFS3_CREATEVERFSIZE = 8;
|
||||
const NFS3_WRITEVERFSIZE = 8;
|
||||
|
||||
const ACCESS3_READ = 0x0001;
|
||||
const ACCESS3_LOOKUP = 0x0002;
|
||||
const ACCESS3_MODIFY = 0x0004;
|
||||
const ACCESS3_EXTEND = 0x0008;
|
||||
const ACCESS3_DELETE = 0x0010;
|
||||
const ACCESS3_EXECUTE = 0x0020;
|
||||
|
||||
const FSF3_LINK = 0x0001;
|
||||
const FSF3_SYMLINK = 0x0002;
|
||||
const FSF3_HOMOGENEOUS = 0x0008;
|
||||
const FSF3_CANSETTIME = 0x0010;
|
||||
|
||||
typedef unsigned hyper uint64;
|
||||
typedef hyper int64;
|
||||
typedef unsigned long uint32;
|
||||
typedef long int32;
|
||||
typedef string filename3<>;
|
||||
typedef string nfspath3<>;
|
||||
typedef uint64 fileid3;
|
||||
typedef uint64 cookie3;
|
||||
typedef opaque cookieverf3[NFS3_COOKIEVERFSIZE];
|
||||
typedef opaque createverf3[NFS3_CREATEVERFSIZE];
|
||||
typedef opaque writeverf3[NFS3_WRITEVERFSIZE];
|
||||
typedef uint32 uid3;
|
||||
typedef uint32 gid3;
|
||||
typedef uint64 size3;
|
||||
typedef uint64 offset3;
|
||||
typedef uint32 mode3;
|
||||
typedef uint32 count3;
|
||||
|
||||
enum nfsstat3 {
|
||||
NFS3_OK = 0,
|
||||
NFS3ERR_PERM = 1,
|
||||
NFS3ERR_NOENT = 2,
|
||||
NFS3ERR_IO = 5,
|
||||
NFS3ERR_NXIO = 6,
|
||||
NFS3ERR_ACCES = 13,
|
||||
NFS3ERR_EXIST = 17,
|
||||
NFS3ERR_XDEV = 18,
|
||||
NFS3ERR_NODEV = 19,
|
||||
NFS3ERR_NOTDIR = 20,
|
||||
NFS3ERR_ISDIR = 21,
|
||||
NFS3ERR_INVAL = 22,
|
||||
NFS3ERR_FBIG = 27,
|
||||
NFS3ERR_NOSPC = 28,
|
||||
NFS3ERR_ROFS = 30,
|
||||
NFS3ERR_MLINK = 31,
|
||||
NFS3ERR_NAMETOOLONG = 63,
|
||||
NFS3ERR_NOTEMPTY = 66,
|
||||
NFS3ERR_DQUOT = 69,
|
||||
NFS3ERR_STALE = 70,
|
||||
NFS3ERR_REMOTE = 71,
|
||||
NFS3ERR_BADHANDLE = 10001,
|
||||
NFS3ERR_NOT_SYNC = 10002,
|
||||
NFS3ERR_BAD_COOKIE = 10003,
|
||||
NFS3ERR_NOTSUPP = 10004,
|
||||
NFS3ERR_TOOSMALL = 10005,
|
||||
NFS3ERR_SERVERFAULT = 10006,
|
||||
NFS3ERR_BADTYPE = 10007,
|
||||
NFS3ERR_JUKEBOX = 10008
|
||||
};
|
||||
|
||||
enum ftype3 {
|
||||
NFS3REG = 1,
|
||||
NFS3DIR = 2,
|
||||
NFS3BLK = 3,
|
||||
NFS3CHR = 4,
|
||||
NFS3LNK = 5,
|
||||
NFS3SOCK = 6,
|
||||
NFS3FIFO = 7
|
||||
};
|
||||
enum stable_how {
|
||||
UNSTABLE = 0,
|
||||
DATA_SYNC = 1,
|
||||
FILE_SYNC = 2
|
||||
};
|
||||
|
||||
enum createmode3 {
|
||||
UNCHECKED = 0,
|
||||
GUARDED = 1,
|
||||
EXCLUSIVE = 2
|
||||
};
|
||||
|
||||
struct specdata3 {
|
||||
uint32 specdata1;
|
||||
uint32 specdata2;
|
||||
};
|
||||
|
||||
struct nfs_fh3 {
|
||||
opaque data<NFS3_FHSIZE>;
|
||||
};
|
||||
|
||||
struct nfstime3 {
|
||||
uint32 seconds;
|
||||
uint32 nseconds;
|
||||
};
|
||||
|
||||
struct fattr3 {
|
||||
ftype3 type;
|
||||
mode3 mode;
|
||||
uint32 nlink;
|
||||
uid3 uid;
|
||||
gid3 gid;
|
||||
size3 size;
|
||||
size3 used;
|
||||
specdata3 rdev;
|
||||
uint64 fsid;
|
||||
fileid3 fileid;
|
||||
nfstime3 atime;
|
||||
nfstime3 mtime;
|
||||
nfstime3 ctime;
|
||||
};
|
||||
|
||||
union post_op_attr switch (bool attributes_follow) {
|
||||
case TRUE:
|
||||
fattr3 attributes;
|
||||
case FALSE:
|
||||
void;
|
||||
};
|
||||
|
||||
struct wcc_attr {
|
||||
size3 size;
|
||||
nfstime3 mtime;
|
||||
nfstime3 ctime;
|
||||
};
|
||||
|
||||
union pre_op_attr switch (bool attributes_follow) {
|
||||
case TRUE:
|
||||
wcc_attr attributes;
|
||||
case FALSE:
|
||||
void;
|
||||
};
|
||||
|
||||
struct wcc_data {
|
||||
pre_op_attr before;
|
||||
post_op_attr after;
|
||||
};
|
||||
|
||||
union post_op_fh3 switch (bool handle_follows) {
|
||||
case TRUE:
|
||||
nfs_fh3 handle;
|
||||
case FALSE:
|
||||
void;
|
||||
};
|
||||
|
||||
enum time_how {
|
||||
DONT_CHANGE = 0,
|
||||
SET_TO_SERVER_TIME = 1,
|
||||
SET_TO_CLIENT_TIME = 2
|
||||
};
|
||||
|
||||
union set_mode3 switch (bool set_it) {
|
||||
case TRUE:
|
||||
mode3 mode;
|
||||
default:
|
||||
void;
|
||||
};
|
||||
|
||||
union set_uid3 switch (bool set_it) {
|
||||
case TRUE:
|
||||
uid3 uid;
|
||||
default:
|
||||
void;
|
||||
};
|
||||
|
||||
union set_gid3 switch (bool set_it) {
|
||||
case TRUE:
|
||||
gid3 gid;
|
||||
default:
|
||||
void;
|
||||
};
|
||||
|
||||
union set_size3 switch (bool set_it) {
|
||||
case TRUE:
|
||||
size3 size;
|
||||
default:
|
||||
void;
|
||||
};
|
||||
|
||||
union set_atime switch (time_how set_it) {
|
||||
case SET_TO_CLIENT_TIME:
|
||||
nfstime3 atime;
|
||||
default:
|
||||
void;
|
||||
};
|
||||
|
||||
union set_mtime switch (time_how set_it) {
|
||||
case SET_TO_CLIENT_TIME:
|
||||
nfstime3 mtime;
|
||||
default:
|
||||
void;
|
||||
};
|
||||
|
||||
struct sattr3 {
|
||||
set_mode3 mode;
|
||||
set_uid3 uid;
|
||||
set_gid3 gid;
|
||||
set_size3 size;
|
||||
set_atime atime;
|
||||
set_mtime mtime;
|
||||
};
|
||||
|
||||
struct diropargs3 {
|
||||
nfs_fh3 dir;
|
||||
filename3 name;
|
||||
};
|
||||
|
||||
|
||||
struct GETATTR3args {
|
||||
nfs_fh3 object;
|
||||
};
|
||||
|
||||
struct GETATTR3resok {
|
||||
fattr3 obj_attributes;
|
||||
};
|
||||
|
||||
union GETATTR3res switch (nfsstat3 status) {
|
||||
case NFS3_OK:
|
||||
GETATTR3resok resok;
|
||||
default:
|
||||
void;
|
||||
};
|
||||
|
||||
union sattrguard3 switch (bool check) {
|
||||
case TRUE:
|
||||
nfstime3 obj_ctime;
|
||||
case FALSE:
|
||||
void;
|
||||
};
|
||||
|
||||
struct SETATTR3args {
|
||||
nfs_fh3 object;
|
||||
sattr3 new_attributes;
|
||||
sattrguard3 guard;
|
||||
};
|
||||
|
||||
struct SETATTR3resok {
|
||||
wcc_data obj_wcc;
|
||||
};
|
||||
|
||||
struct SETATTR3resfail {
|
||||
wcc_data obj_wcc;
|
||||
};
|
||||
|
||||
union SETATTR3res switch (nfsstat3 status) {
|
||||
case NFS3_OK:
|
||||
SETATTR3resok resok;
|
||||
default:
|
||||
SETATTR3resfail resfail;
|
||||
};
|
||||
|
||||
struct LOOKUP3args {
|
||||
diropargs3 what;
|
||||
};
|
||||
|
||||
struct LOOKUP3resok {
|
||||
nfs_fh3 object;
|
||||
post_op_attr obj_attributes;
|
||||
post_op_attr dir_attributes;
|
||||
};
|
||||
|
||||
struct LOOKUP3resfail {
|
||||
post_op_attr dir_attributes;
|
||||
};
|
||||
|
||||
union LOOKUP3res switch (nfsstat3 status) {
|
||||
case NFS3_OK:
|
||||
LOOKUP3resok resok;
|
||||
default:
|
||||
LOOKUP3resfail resfail;
|
||||
};
|
||||
|
||||
struct ACCESS3args {
|
||||
nfs_fh3 object;
|
||||
uint32 access;
|
||||
};
|
||||
|
||||
struct ACCESS3resok {
|
||||
post_op_attr obj_attributes;
|
||||
uint32 access;
|
||||
};
|
||||
|
||||
struct ACCESS3resfail {
|
||||
post_op_attr obj_attributes;
|
||||
};
|
||||
|
||||
union ACCESS3res switch (nfsstat3 status) {
|
||||
case NFS3_OK:
|
||||
ACCESS3resok resok;
|
||||
default:
|
||||
ACCESS3resfail resfail;
|
||||
};
|
||||
|
||||
struct READLINK3args {
|
||||
nfs_fh3 symlink;
|
||||
};
|
||||
|
||||
struct READLINK3resok {
|
||||
post_op_attr symlink_attributes;
|
||||
nfspath3 data;
|
||||
};
|
||||
|
||||
struct READLINK3resfail {
|
||||
post_op_attr symlink_attributes;
|
||||
};
|
||||
|
||||
union READLINK3res switch (nfsstat3 status) {
|
||||
case NFS3_OK:
|
||||
READLINK3resok resok;
|
||||
default:
|
||||
READLINK3resfail resfail;
|
||||
};
|
||||
|
||||
struct READ3args {
|
||||
nfs_fh3 file;
|
||||
offset3 offset;
|
||||
count3 count;
|
||||
};
|
||||
|
||||
struct READ3resok {
|
||||
post_op_attr file_attributes;
|
||||
count3 count;
|
||||
bool eof;
|
||||
opaque data<>;
|
||||
};
|
||||
|
||||
struct READ3resfail {
|
||||
post_op_attr file_attributes;
|
||||
};
|
||||
|
||||
union READ3res switch (nfsstat3 status) {
|
||||
case NFS3_OK:
|
||||
READ3resok resok;
|
||||
default:
|
||||
READ3resfail resfail;
|
||||
};
|
||||
|
||||
struct WRITE3args {
|
||||
nfs_fh3 file;
|
||||
offset3 offset;
|
||||
count3 count;
|
||||
stable_how stable;
|
||||
opaque data<>;
|
||||
};
|
||||
|
||||
struct WRITE3resok {
|
||||
wcc_data file_wcc;
|
||||
count3 count;
|
||||
stable_how committed;
|
||||
writeverf3 verf;
|
||||
};
|
||||
|
||||
struct WRITE3resfail {
|
||||
wcc_data file_wcc;
|
||||
};
|
||||
|
||||
union WRITE3res switch (nfsstat3 status) {
|
||||
case NFS3_OK:
|
||||
WRITE3resok resok;
|
||||
default:
|
||||
WRITE3resfail resfail;
|
||||
};
|
||||
|
||||
|
||||
union createhow3 switch (createmode3 mode) {
|
||||
case UNCHECKED:
|
||||
case GUARDED:
|
||||
sattr3 obj_attributes;
|
||||
case EXCLUSIVE:
|
||||
createverf3 verf;
|
||||
};
|
||||
|
||||
struct CREATE3args {
|
||||
diropargs3 where;
|
||||
createhow3 how;
|
||||
};
|
||||
|
||||
struct CREATE3resok {
|
||||
post_op_fh3 obj;
|
||||
post_op_attr obj_attributes;
|
||||
wcc_data dir_wcc;
|
||||
};
|
||||
|
||||
struct CREATE3resfail {
|
||||
wcc_data dir_wcc;
|
||||
};
|
||||
|
||||
union CREATE3res switch (nfsstat3 status) {
|
||||
case NFS3_OK:
|
||||
CREATE3resok resok;
|
||||
default:
|
||||
CREATE3resfail resfail;
|
||||
};
|
||||
|
||||
struct MKDIR3args {
|
||||
diropargs3 where;
|
||||
sattr3 attributes;
|
||||
};
|
||||
|
||||
struct MKDIR3resok {
|
||||
post_op_fh3 obj;
|
||||
post_op_attr obj_attributes;
|
||||
wcc_data dir_wcc;
|
||||
};
|
||||
|
||||
struct MKDIR3resfail {
|
||||
wcc_data dir_wcc;
|
||||
};
|
||||
|
||||
union MKDIR3res switch (nfsstat3 status) {
|
||||
case NFS3_OK:
|
||||
MKDIR3resok resok;
|
||||
default:
|
||||
MKDIR3resfail resfail;
|
||||
};
|
||||
|
||||
struct symlinkdata3 {
|
||||
sattr3 symlink_attributes;
|
||||
nfspath3 symlink_data;
|
||||
};
|
||||
|
||||
struct SYMLINK3args {
|
||||
diropargs3 where;
|
||||
symlinkdata3 symlink;
|
||||
};
|
||||
|
||||
struct SYMLINK3resok {
|
||||
post_op_fh3 obj;
|
||||
post_op_attr obj_attributes;
|
||||
wcc_data dir_wcc;
|
||||
};
|
||||
|
||||
struct SYMLINK3resfail {
|
||||
wcc_data dir_wcc;
|
||||
};
|
||||
|
||||
union SYMLINK3res switch (nfsstat3 status) {
|
||||
case NFS3_OK:
|
||||
SYMLINK3resok resok;
|
||||
default:
|
||||
SYMLINK3resfail resfail;
|
||||
};
|
||||
|
||||
struct devicedata3 {
|
||||
sattr3 dev_attributes;
|
||||
specdata3 spec;
|
||||
};
|
||||
|
||||
union mknoddata3 switch (ftype3 type) {
|
||||
case NFS3CHR:
|
||||
case NFS3BLK:
|
||||
devicedata3 device;
|
||||
case NFS3SOCK:
|
||||
case NFS3FIFO:
|
||||
sattr3 pipe_attributes;
|
||||
default:
|
||||
void;
|
||||
};
|
||||
|
||||
struct MKNOD3args {
|
||||
diropargs3 where;
|
||||
mknoddata3 what;
|
||||
};
|
||||
|
||||
struct MKNOD3resok {
|
||||
post_op_fh3 obj;
|
||||
post_op_attr obj_attributes;
|
||||
wcc_data dir_wcc;
|
||||
};
|
||||
|
||||
struct MKNOD3resfail {
|
||||
wcc_data dir_wcc;
|
||||
};
|
||||
|
||||
union MKNOD3res switch (nfsstat3 status) {
|
||||
case NFS3_OK:
|
||||
MKNOD3resok resok;
|
||||
default:
|
||||
MKNOD3resfail resfail;
|
||||
};
|
||||
|
||||
struct REMOVE3args {
|
||||
diropargs3 object;
|
||||
};
|
||||
|
||||
struct REMOVE3resok {
|
||||
wcc_data dir_wcc;
|
||||
};
|
||||
|
||||
struct REMOVE3resfail {
|
||||
wcc_data dir_wcc;
|
||||
};
|
||||
|
||||
union REMOVE3res switch (nfsstat3 status) {
|
||||
case NFS3_OK:
|
||||
REMOVE3resok resok;
|
||||
default:
|
||||
REMOVE3resfail resfail;
|
||||
};
|
||||
|
||||
struct RMDIR3args {
|
||||
diropargs3 object;
|
||||
};
|
||||
|
||||
struct RMDIR3resok {
|
||||
wcc_data dir_wcc;
|
||||
};
|
||||
|
||||
struct RMDIR3resfail {
|
||||
wcc_data dir_wcc;
|
||||
};
|
||||
|
||||
union RMDIR3res switch (nfsstat3 status) {
|
||||
case NFS3_OK:
|
||||
RMDIR3resok resok;
|
||||
default:
|
||||
RMDIR3resfail resfail;
|
||||
};
|
||||
|
||||
struct RENAME3args {
|
||||
diropargs3 from;
|
||||
diropargs3 to;
|
||||
};
|
||||
|
||||
struct RENAME3resok {
|
||||
wcc_data fromdir_wcc;
|
||||
wcc_data todir_wcc;
|
||||
};
|
||||
|
||||
struct RENAME3resfail {
|
||||
wcc_data fromdir_wcc;
|
||||
wcc_data todir_wcc;
|
||||
};
|
||||
|
||||
union RENAME3res switch (nfsstat3 status) {
|
||||
case NFS3_OK:
|
||||
RENAME3resok resok;
|
||||
default:
|
||||
RENAME3resfail resfail;
|
||||
};
|
||||
struct LINK3args {
|
||||
nfs_fh3 file;
|
||||
diropargs3 link;
|
||||
};
|
||||
|
||||
struct LINK3resok {
|
||||
post_op_attr file_attributes;
|
||||
wcc_data linkdir_wcc;
|
||||
};
|
||||
|
||||
struct LINK3resfail {
|
||||
post_op_attr file_attributes;
|
||||
wcc_data linkdir_wcc;
|
||||
};
|
||||
|
||||
union LINK3res switch (nfsstat3 status) {
|
||||
case NFS3_OK:
|
||||
LINK3resok resok;
|
||||
default:
|
||||
LINK3resfail resfail;
|
||||
};
|
||||
|
||||
struct READDIR3args {
|
||||
nfs_fh3 dir;
|
||||
cookie3 cookie;
|
||||
cookieverf3 cookieverf;
|
||||
count3 count;
|
||||
};
|
||||
|
||||
struct entry3 {
|
||||
fileid3 fileid;
|
||||
filename3 name;
|
||||
cookie3 cookie;
|
||||
entry3 *nextentry;
|
||||
};
|
||||
|
||||
struct dirlist3 {
|
||||
entry3 *entries;
|
||||
bool eof;
|
||||
};
|
||||
|
||||
struct READDIR3resok {
|
||||
post_op_attr dir_attributes;
|
||||
cookieverf3 cookieverf;
|
||||
dirlist3 reply;
|
||||
};
|
||||
|
||||
struct READDIR3resfail {
|
||||
post_op_attr dir_attributes;
|
||||
};
|
||||
|
||||
union READDIR3res switch (nfsstat3 status) {
|
||||
case NFS3_OK:
|
||||
READDIR3resok resok;
|
||||
default:
|
||||
READDIR3resfail resfail;
|
||||
};
|
||||
|
||||
struct READDIRPLUS3args {
|
||||
nfs_fh3 dir;
|
||||
cookie3 cookie;
|
||||
cookieverf3 cookieverf;
|
||||
count3 dircount;
|
||||
count3 maxcount;
|
||||
};
|
||||
|
||||
struct entryplus3 {
|
||||
fileid3 fileid;
|
||||
filename3 name;
|
||||
cookie3 cookie;
|
||||
post_op_attr name_attributes;
|
||||
post_op_fh3 name_handle;
|
||||
entryplus3 *nextentry;
|
||||
};
|
||||
|
||||
struct dirlistplus3 {
|
||||
entryplus3 *entries;
|
||||
bool eof;
|
||||
};
|
||||
|
||||
struct READDIRPLUS3resok {
|
||||
post_op_attr dir_attributes;
|
||||
cookieverf3 cookieverf;
|
||||
dirlistplus3 reply;
|
||||
};
|
||||
|
||||
struct READDIRPLUS3resfail {
|
||||
post_op_attr dir_attributes;
|
||||
};
|
||||
|
||||
union READDIRPLUS3res switch (nfsstat3 status) {
|
||||
case NFS3_OK:
|
||||
READDIRPLUS3resok resok;
|
||||
default:
|
||||
READDIRPLUS3resfail resfail;
|
||||
};
|
||||
|
||||
struct FSSTAT3args {
|
||||
nfs_fh3 fsroot;
|
||||
};
|
||||
|
||||
struct FSSTAT3resok {
|
||||
post_op_attr obj_attributes;
|
||||
size3 tbytes;
|
||||
size3 fbytes;
|
||||
size3 abytes;
|
||||
size3 tfiles;
|
||||
size3 ffiles;
|
||||
size3 afiles;
|
||||
uint32 invarsec;
|
||||
};
|
||||
|
||||
struct FSSTAT3resfail {
|
||||
post_op_attr obj_attributes;
|
||||
};
|
||||
|
||||
union FSSTAT3res switch (nfsstat3 status) {
|
||||
case NFS3_OK:
|
||||
FSSTAT3resok resok;
|
||||
default:
|
||||
FSSTAT3resfail resfail;
|
||||
};
|
||||
|
||||
struct FSINFO3args {
|
||||
nfs_fh3 fsroot;
|
||||
};
|
||||
|
||||
struct FSINFO3resok {
|
||||
post_op_attr obj_attributes;
|
||||
uint32 rtmax;
|
||||
uint32 rtpref;
|
||||
uint32 rtmult;
|
||||
uint32 wtmax;
|
||||
uint32 wtpref;
|
||||
uint32 wtmult;
|
||||
uint32 dtpref;
|
||||
size3 maxfilesize;
|
||||
nfstime3 time_delta;
|
||||
uint32 properties;
|
||||
};
|
||||
|
||||
struct FSINFO3resfail {
|
||||
post_op_attr obj_attributes;
|
||||
};
|
||||
|
||||
union FSINFO3res switch (nfsstat3 status) {
|
||||
case NFS3_OK:
|
||||
FSINFO3resok resok;
|
||||
default:
|
||||
FSINFO3resfail resfail;
|
||||
};
|
||||
|
||||
struct PATHCONF3args {
|
||||
nfs_fh3 object;
|
||||
};
|
||||
|
||||
struct PATHCONF3resok {
|
||||
post_op_attr obj_attributes;
|
||||
uint32 linkmax;
|
||||
uint32 name_max;
|
||||
bool no_trunc;
|
||||
bool chown_restricted;
|
||||
bool case_insensitive;
|
||||
bool case_preserving;
|
||||
};
|
||||
|
||||
struct PATHCONF3resfail {
|
||||
post_op_attr obj_attributes;
|
||||
};
|
||||
|
||||
union PATHCONF3res switch (nfsstat3 status) {
|
||||
case NFS3_OK:
|
||||
PATHCONF3resok resok;
|
||||
default:
|
||||
PATHCONF3resfail resfail;
|
||||
};
|
||||
|
||||
struct COMMIT3args {
|
||||
nfs_fh3 file;
|
||||
offset3 offset;
|
||||
count3 count;
|
||||
};
|
||||
|
||||
struct COMMIT3resok {
|
||||
wcc_data file_wcc;
|
||||
writeverf3 verf;
|
||||
};
|
||||
|
||||
struct COMMIT3resfail {
|
||||
wcc_data file_wcc;
|
||||
};
|
||||
|
||||
union COMMIT3res switch (nfsstat3 status) {
|
||||
case NFS3_OK:
|
||||
COMMIT3resok resok;
|
||||
default:
|
||||
COMMIT3resfail resfail;
|
||||
};
|
||||
|
||||
program NFS_PROGRAM {
|
||||
version NFS_V3 {
|
||||
void NFSPROC3_NULL(void) = 0;
|
||||
GETATTR3res NFSPROC3_GETATTR(GETATTR3args) = 1;
|
||||
SETATTR3res NFSPROC3_SETATTR(SETATTR3args) = 2;
|
||||
LOOKUP3res NFSPROC3_LOOKUP(LOOKUP3args) = 3;
|
||||
ACCESS3res NFSPROC3_ACCESS(ACCESS3args) = 4;
|
||||
READLINK3res NFSPROC3_READLINK(READLINK3args) = 5;
|
||||
READ3res NFSPROC3_READ(READ3args) = 6;
|
||||
WRITE3res NFSPROC3_WRITE(WRITE3args) = 7;
|
||||
CREATE3res NFSPROC3_CREATE(CREATE3args) = 8;
|
||||
MKDIR3res NFSPROC3_MKDIR(MKDIR3args) = 9;
|
||||
SYMLINK3res NFSPROC3_SYMLINK(SYMLINK3args) = 10;
|
||||
MKNOD3res NFSPROC3_MKNOD(MKNOD3args) = 11;
|
||||
REMOVE3res NFSPROC3_REMOVE(REMOVE3args) = 12;
|
||||
RMDIR3res NFSPROC3_RMDIR(RMDIR3args) = 13;
|
||||
RENAME3res NFSPROC3_RENAME(RENAME3args) = 14;
|
||||
LINK3res NFSPROC3_LINK(LINK3args) = 15;
|
||||
READDIR3res NFSPROC3_READDIR(READDIR3args) = 16;
|
||||
READDIRPLUS3res NFSPROC3_READDIRPLUS(READDIRPLUS3args) = 17;
|
||||
FSSTAT3res NFSPROC3_FSSTAT(FSSTAT3args) = 18;
|
||||
FSINFO3res NFSPROC3_FSINFO(FSINFO3args) = 19;
|
||||
PATHCONF3res NFSPROC3_PATHCONF(PATHCONF3args) = 20;
|
||||
COMMIT3res NFSPROC3_COMMIT(COMMIT3args) = 21;
|
||||
} = 3;
|
||||
} = 100003;
|
||||
@@ -0,0 +1,172 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
|
||||
#include <rpc/types.h>
|
||||
#include <rpc/xdr.h>
|
||||
#include <rpc/auth.h>
|
||||
|
||||
#define MAX_MARSHEL_SIZE 64
|
||||
|
||||
struct nfs_credentia
|
||||
{
|
||||
rt_uint32_t stamp;
|
||||
char *name;
|
||||
rt_uint32_t uid;
|
||||
rt_uint32_t gid;
|
||||
rt_uint32_t *auxi;
|
||||
rt_uint32_t auxi_count;
|
||||
};
|
||||
|
||||
static void authnone_verf(AUTH *);
|
||||
static bool_t authnone_validate(AUTH *, struct opaque_auth *);
|
||||
static bool_t authnone_refresh(AUTH *);
|
||||
static void authnone_destroy(AUTH *);
|
||||
static bool_t authnone_marshal(AUTH *client, XDR *xdrs);
|
||||
|
||||
static struct nfs_credentia _credentia = {
|
||||
.stamp = 0,
|
||||
.name = "rt-thread",
|
||||
.uid = 0,
|
||||
.gid = 0,
|
||||
.auxi = NULL,
|
||||
.auxi_count = 0,
|
||||
};
|
||||
|
||||
struct opaque_auth _null_auth;
|
||||
|
||||
static struct auth_ops ops =
|
||||
{
|
||||
authnone_verf,
|
||||
authnone_marshal,
|
||||
authnone_validate,
|
||||
authnone_refresh,
|
||||
authnone_destroy
|
||||
};
|
||||
|
||||
static struct authnone_private
|
||||
{
|
||||
AUTH no_client;
|
||||
char marshalled_client[MAX_MARSHEL_SIZE];
|
||||
unsigned int mcnt;
|
||||
} *authnone_private;
|
||||
|
||||
AUTH *authnone_create(void)
|
||||
{
|
||||
register struct authnone_private *ap = authnone_private;
|
||||
XDR xdr_stream;
|
||||
register XDR *xdrs;
|
||||
extern bool_t xdr_opaque_auth(XDR * xdrs, struct opaque_auth * ap);
|
||||
struct opaque_auth auth;
|
||||
rt_uint32_t *auth_buf, *auth_base;
|
||||
int buf_len = 0, str_len = 0;
|
||||
|
||||
if (_credentia.name)
|
||||
{
|
||||
str_len = strlen(_credentia.name);
|
||||
}
|
||||
if (str_len == 0)
|
||||
{
|
||||
_credentia.name = "unknown";
|
||||
str_len = strlen(_credentia.name);
|
||||
}
|
||||
buf_len = ((str_len) + (sizeof(rt_uint32_t)) - 1) & ~((sizeof(rt_uint32_t)) - 1);
|
||||
buf_len += sizeof(struct nfs_credentia);
|
||||
if (_credentia.auxi && _credentia.auxi_count)
|
||||
{
|
||||
buf_len += sizeof(rt_uint32_t) * _credentia.auxi_count;
|
||||
}
|
||||
auth_buf = auth_base = rt_malloc(buf_len);
|
||||
if (auth_buf == NULL)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
memset(auth_buf, 0, buf_len);
|
||||
*auth_buf++ = htonl(rt_tick_get());
|
||||
*auth_buf++ = htonl(str_len);
|
||||
memcpy(auth_buf, _credentia.name, str_len);
|
||||
auth_buf += (str_len + sizeof(rt_uint32_t) - 1) >> 2;
|
||||
*auth_buf++ = htonl(_credentia.uid);
|
||||
*auth_buf++ = htonl(_credentia.gid);
|
||||
if (_credentia.auxi && _credentia.auxi_count)
|
||||
{
|
||||
rt_uint32_t tmp_cnt = 0;
|
||||
*auth_buf++ = htonl(_credentia.auxi_count);
|
||||
while (tmp_cnt < _credentia.auxi_count)
|
||||
{
|
||||
*auth_buf++ = htonl(_credentia.auxi[tmp_cnt]);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
*auth_buf++ = htonl(0);
|
||||
}
|
||||
|
||||
if (ap == 0)
|
||||
{
|
||||
ap = (struct authnone_private *) rt_malloc(sizeof(*ap));
|
||||
if (ap == 0)
|
||||
{
|
||||
rt_free(auth_base);
|
||||
return NULL;
|
||||
}
|
||||
memset(ap, 0, sizeof(*ap));
|
||||
authnone_private = ap;
|
||||
}
|
||||
|
||||
if (!ap->mcnt)
|
||||
{
|
||||
memset(&auth, 0, sizeof(auth));
|
||||
auth.oa_flavor = 1;
|
||||
auth.oa_base = (char *)auth_base;
|
||||
auth.oa_length = (auth_buf - auth_base) * sizeof(rt_uint32_t);
|
||||
ap->no_client.ah_cred = auth;
|
||||
ap->no_client.ah_verf = _null_auth;
|
||||
ap->no_client.ah_ops = &ops;
|
||||
xdrs = &xdr_stream;
|
||||
xdrmem_create(xdrs, ap->marshalled_client,
|
||||
(unsigned int) MAX_MARSHEL_SIZE, XDR_ENCODE);
|
||||
(void) xdr_opaque_auth(xdrs, &ap->no_client.ah_cred);
|
||||
(void) xdr_opaque_auth(xdrs, &ap->no_client.ah_verf);
|
||||
ap->mcnt = XDR_GETPOS(xdrs);
|
||||
XDR_DESTROY(xdrs);
|
||||
}
|
||||
rt_free(auth_base);
|
||||
return (&ap->no_client);
|
||||
}
|
||||
|
||||
/*ARGSUSED*/
|
||||
static bool_t authnone_marshal(AUTH *client, XDR *xdrs)
|
||||
{
|
||||
register struct authnone_private *ap = authnone_private;
|
||||
|
||||
if (ap == 0)
|
||||
return (0);
|
||||
return ((*xdrs->x_ops->x_putbytes)(xdrs,
|
||||
ap->marshalled_client, ap->mcnt));
|
||||
}
|
||||
|
||||
static void authnone_verf(AUTH *x)
|
||||
{
|
||||
}
|
||||
|
||||
static bool_t authnone_validate(AUTH *x, struct opaque_auth *x1)
|
||||
{
|
||||
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
static bool_t authnone_refresh(AUTH *x)
|
||||
{
|
||||
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
static void authnone_destroy(AUTH *x)
|
||||
{
|
||||
}
|
||||
@@ -0,0 +1,222 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
/*
|
||||
* Please do not edit this file.
|
||||
* It was generated using rpcgen.
|
||||
*/
|
||||
|
||||
#include <string.h> /* for memset */
|
||||
#include "nfs.h"
|
||||
|
||||
/* This file is copied from RFC1813
|
||||
* Copyright 1995 Sun Micrososystems (I assume)
|
||||
*/
|
||||
|
||||
typedef char* caddr_t;
|
||||
|
||||
/* Default timeout can be changed using clnt_control() */
|
||||
static struct timeval TIMEOUT = { 25, 0 };
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_null_3(void *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_NULL,
|
||||
(xdrproc_t) xdr_void, (caddr_t) NULL,
|
||||
(xdrproc_t) xdr_void, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_getattr_3(GETATTR3args arg1, GETATTR3res *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_GETATTR,
|
||||
(xdrproc_t) xdr_GETATTR3args, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_GETATTR3res, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_setattr_3(SETATTR3args arg1, SETATTR3res *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_SETATTR,
|
||||
(xdrproc_t) xdr_SETATTR3args, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_SETATTR3res, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_lookup_3(LOOKUP3args arg1, LOOKUP3res *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_LOOKUP,
|
||||
(xdrproc_t) xdr_LOOKUP3args, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_LOOKUP3res, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_access_3(ACCESS3args arg1, ACCESS3res *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_ACCESS,
|
||||
(xdrproc_t) xdr_ACCESS3args, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_ACCESS3res, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_readlink_3(READLINK3args arg1, READLINK3res *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_READLINK,
|
||||
(xdrproc_t) xdr_READLINK3args, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_READLINK3res, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_read_3(READ3args arg1, READ3res *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_READ,
|
||||
(xdrproc_t) xdr_READ3args, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_READ3res, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_write_3(WRITE3args arg1, WRITE3res *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_WRITE,
|
||||
(xdrproc_t) xdr_WRITE3args, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_WRITE3res, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_create_3(CREATE3args arg1, CREATE3res *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_CREATE,
|
||||
(xdrproc_t) xdr_CREATE3args, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_CREATE3res, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_mkdir_3(MKDIR3args arg1, MKDIR3res *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_MKDIR,
|
||||
(xdrproc_t) xdr_MKDIR3args, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_MKDIR3res, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_symlink_3(SYMLINK3args arg1, SYMLINK3res *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_SYMLINK,
|
||||
(xdrproc_t) xdr_SYMLINK3args, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_SYMLINK3res, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_mknod_3(MKNOD3args arg1, MKNOD3res *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_MKNOD,
|
||||
(xdrproc_t) xdr_MKNOD3args, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_MKNOD3res, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_remove_3(REMOVE3args arg1, REMOVE3res *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_REMOVE,
|
||||
(xdrproc_t) xdr_REMOVE3args, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_REMOVE3res, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_rmdir_3(RMDIR3args arg1, RMDIR3res *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_RMDIR,
|
||||
(xdrproc_t) xdr_RMDIR3args, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_RMDIR3res, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_rename_3(RENAME3args arg1, RENAME3res *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_RENAME,
|
||||
(xdrproc_t) xdr_RENAME3args, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_RENAME3res, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_link_3(LINK3args arg1, LINK3res *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_LINK,
|
||||
(xdrproc_t) xdr_LINK3args, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_LINK3res, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_readdir_3(READDIR3args arg1, READDIR3res *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_READDIR,
|
||||
(xdrproc_t) xdr_READDIR3args, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_READDIR3res, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_readdirplus_3(READDIRPLUS3args arg1, READDIRPLUS3res *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_READDIRPLUS,
|
||||
(xdrproc_t) xdr_READDIRPLUS3args, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_READDIRPLUS3res, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_fsstat_3(FSSTAT3args arg1, FSSTAT3res *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_FSSTAT,
|
||||
(xdrproc_t) xdr_FSSTAT3args, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_FSSTAT3res, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_fsinfo_3(FSINFO3args arg1, FSINFO3res *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_FSINFO,
|
||||
(xdrproc_t) xdr_FSINFO3args, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_FSINFO3res, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_pathconf_3(PATHCONF3args arg1, PATHCONF3res *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_PATHCONF,
|
||||
(xdrproc_t) xdr_PATHCONF3args, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_PATHCONF3res, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
|
||||
enum clnt_stat
|
||||
nfsproc3_commit_3(COMMIT3args arg1, COMMIT3res *clnt_res, CLIENT *clnt)
|
||||
{
|
||||
return (clnt_call(clnt, NFSPROC3_COMMIT,
|
||||
(xdrproc_t) xdr_COMMIT3args, (caddr_t) &arg1,
|
||||
(xdrproc_t) xdr_COMMIT3res, (caddr_t) clnt_res,
|
||||
TIMEOUT));
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,112 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
#ifndef __AUTH_H__
|
||||
#define __AUTH_H__
|
||||
|
||||
#include <rpc/xdr.h>
|
||||
|
||||
/*
|
||||
* Status returned from authentication check
|
||||
*/
|
||||
enum auth_stat {
|
||||
AUTH_OK=0,
|
||||
/*
|
||||
* failed at remote end
|
||||
*/
|
||||
AUTH_BADCRED=1, /* bogus credentials (seal broken) */
|
||||
AUTH_REJECTEDCRED=2, /* client should begin new session */
|
||||
AUTH_BADVERF=3, /* bogus verifier (seal broken) */
|
||||
AUTH_REJECTEDVERF=4, /* verifier expired or was replayed */
|
||||
AUTH_TOOWEAK=5, /* rejected due to security reasons */
|
||||
/*
|
||||
* failed locally
|
||||
*/
|
||||
AUTH_INVALIDRESP=6, /* bogus response verifier */
|
||||
AUTH_FAILED=7 /* some unknown reason */
|
||||
};
|
||||
|
||||
union des_block {
|
||||
struct {
|
||||
uint32_t high;
|
||||
uint32_t low;
|
||||
} key;
|
||||
char c[8];
|
||||
};
|
||||
typedef union des_block des_block;
|
||||
|
||||
/*
|
||||
* Authentication info. Opaque to client.
|
||||
*/
|
||||
struct opaque_auth {
|
||||
enum_t oa_flavor; /* flavor of auth */
|
||||
char* oa_base; /* address of more auth stuff */
|
||||
unsigned int oa_length; /* not to exceed MAX_AUTH_BYTES */
|
||||
};
|
||||
|
||||
/*
|
||||
* Auth handle, interface to client side authenticators.
|
||||
*/
|
||||
typedef struct AUTH AUTH;
|
||||
struct AUTH {
|
||||
struct opaque_auth ah_cred;
|
||||
struct opaque_auth ah_verf;
|
||||
union des_block ah_key;
|
||||
struct auth_ops {
|
||||
void (*ah_nextverf) (AUTH *);
|
||||
int (*ah_marshal) (AUTH *, XDR *); /* nextverf & serialize */
|
||||
int (*ah_validate) (AUTH *, struct opaque_auth *);
|
||||
/* validate verifier */
|
||||
int (*ah_refresh) (AUTH *); /* refresh credentials */
|
||||
void (*ah_destroy) (AUTH *); /* destroy this structure */
|
||||
} *ah_ops;
|
||||
char* ah_private;
|
||||
};
|
||||
|
||||
extern struct opaque_auth _null_auth;
|
||||
|
||||
|
||||
/*
|
||||
* Authentication ops.
|
||||
* The ops and the auth handle provide the interface to the authenticators.
|
||||
*
|
||||
* AUTH *auth;
|
||||
* XDR *xdrs;
|
||||
* struct opaque_auth verf;
|
||||
*/
|
||||
#define AUTH_NEXTVERF(auth) \
|
||||
((*((auth)->ah_ops->ah_nextverf))(auth))
|
||||
#define auth_nextverf(auth) \
|
||||
((*((auth)->ah_ops->ah_nextverf))(auth))
|
||||
|
||||
#define AUTH_MARSHALL(auth, xdrs) \
|
||||
((*((auth)->ah_ops->ah_marshal))(auth, xdrs))
|
||||
#define auth_marshall(auth, xdrs) \
|
||||
((*((auth)->ah_ops->ah_marshal))(auth, xdrs))
|
||||
|
||||
#define AUTH_VALIDATE(auth, verfp) \
|
||||
((*((auth)->ah_ops->ah_validate))((auth), verfp))
|
||||
#define auth_validate(auth, verfp) \
|
||||
((*((auth)->ah_ops->ah_validate))((auth), verfp))
|
||||
|
||||
#define AUTH_REFRESH(auth) \
|
||||
((*((auth)->ah_ops->ah_refresh))(auth))
|
||||
#define auth_refresh(auth) \
|
||||
((*((auth)->ah_ops->ah_refresh))(auth))
|
||||
|
||||
#define AUTH_DESTROY(auth) \
|
||||
((*((auth)->ah_ops->ah_destroy))(auth))
|
||||
#define auth_destroy(auth) \
|
||||
((*((auth)->ah_ops->ah_destroy))(auth))
|
||||
|
||||
#define MAX_AUTH_BYTES 400
|
||||
#define MAXNETNAMELEN 255 /* maximum length of network user's name */
|
||||
|
||||
AUTH *authnone_create(void);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,135 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
/* @(#)auth_none.c 2.1 88/07/29 4.0 RPCSRC */
|
||||
/*
|
||||
* Sun RPC is a product of Sun Microsystems, Inc. and is provided for
|
||||
* unrestricted use provided that this legend is included on all tape
|
||||
* media and as a part of the software program in whole or part. Users
|
||||
* may copy or modify Sun RPC without charge, but are not authorized
|
||||
* to license or distribute it to anyone else except as part of a product or
|
||||
* program developed by the user.
|
||||
*
|
||||
* SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
|
||||
* WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
|
||||
*
|
||||
* Sun RPC is provided with no support and without any obligation on the
|
||||
* part of Sun Microsystems, Inc. to assist in its use, correction,
|
||||
* modification or enhancement.
|
||||
*
|
||||
* SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
|
||||
* INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
|
||||
* OR ANY PART THEREOF.
|
||||
*
|
||||
* In no event will Sun Microsystems, Inc. be liable for any lost revenue
|
||||
* or profits or other special, indirect and consequential damages, even if
|
||||
* Sun has been advised of the possibility of such damages.
|
||||
*
|
||||
* Sun Microsystems, Inc.
|
||||
* 2550 Garcia Avenue
|
||||
* Mountain View, California 94043
|
||||
*/
|
||||
#if !defined(lint) && defined(SCCSIDS)
|
||||
static char sccsid[] =
|
||||
|
||||
"@(#)auth_none.c 1.19 87/08/11 Copyr 1984 Sun Micro";
|
||||
#endif
|
||||
|
||||
/*
|
||||
* auth_none.c
|
||||
* Creates a client authentication handle for passing "null"
|
||||
* credentials and verifiers to remote systems.
|
||||
*
|
||||
* Copyright (C) 1984, Sun Microsystems, Inc.
|
||||
*/
|
||||
|
||||
#include <rpc/types.h>
|
||||
#include <rpc/xdr.h>
|
||||
#include <rpc/auth.h>
|
||||
#define MAX_MARSHEL_SIZE 20
|
||||
|
||||
static void authnone_verf(AUTH *);
|
||||
static bool_t authnone_validate(AUTH *, struct opaque_auth *);
|
||||
static bool_t authnone_refresh(AUTH *);
|
||||
static void authnone_destroy(AUTH *);
|
||||
static bool_t authnone_marshal(AUTH *client, XDR *xdrs);
|
||||
|
||||
struct opaque_auth _null_auth;
|
||||
|
||||
static struct auth_ops ops = {
|
||||
authnone_verf,
|
||||
authnone_marshal,
|
||||
authnone_validate,
|
||||
authnone_refresh,
|
||||
authnone_destroy
|
||||
};
|
||||
|
||||
static struct authnone_private {
|
||||
AUTH no_client;
|
||||
char marshalled_client[MAX_MARSHEL_SIZE];
|
||||
unsigned int mcnt;
|
||||
} *authnone_private;
|
||||
|
||||
AUTH *authnone_create()
|
||||
{
|
||||
register struct authnone_private *ap = authnone_private;
|
||||
XDR xdr_stream;
|
||||
register XDR *xdrs;
|
||||
extern bool_t xdr_opaque_auth(XDR *xdrs, struct opaque_auth *ap);
|
||||
|
||||
if (ap == 0) {
|
||||
ap = (struct authnone_private *) rt_malloc (sizeof(*ap));
|
||||
if (ap == 0) return NULL;
|
||||
memset(ap, 0, sizeof(*ap));
|
||||
authnone_private = ap;
|
||||
}
|
||||
if (!ap->mcnt) {
|
||||
ap->no_client.ah_cred = ap->no_client.ah_verf = _null_auth;
|
||||
ap->no_client.ah_ops = &ops;
|
||||
xdrs = &xdr_stream;
|
||||
xdrmem_create(xdrs, ap->marshalled_client,
|
||||
(unsigned int) MAX_MARSHEL_SIZE, XDR_ENCODE);
|
||||
(void) xdr_opaque_auth(xdrs, &ap->no_client.ah_cred);
|
||||
(void) xdr_opaque_auth(xdrs, &ap->no_client.ah_verf);
|
||||
ap->mcnt = XDR_GETPOS(xdrs);
|
||||
XDR_DESTROY(xdrs);
|
||||
}
|
||||
return (&ap->no_client);
|
||||
}
|
||||
|
||||
/*ARGSUSED*/
|
||||
static bool_t authnone_marshal(AUTH *client, XDR *xdrs)
|
||||
{
|
||||
register struct authnone_private *ap = authnone_private;
|
||||
|
||||
if (ap == 0)
|
||||
return (0);
|
||||
return ((*xdrs->x_ops->x_putbytes) (xdrs,
|
||||
ap->marshalled_client, ap->mcnt));
|
||||
}
|
||||
|
||||
static void authnone_verf(AUTH *x)
|
||||
{
|
||||
}
|
||||
|
||||
static bool_t authnone_validate(AUTH *x, struct opaque_auth *x1)
|
||||
{
|
||||
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
static bool_t authnone_refresh(AUTH *x)
|
||||
{
|
||||
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
static void authnone_destroy(AUTH *x)
|
||||
{
|
||||
}
|
||||
@@ -0,0 +1,330 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
/* @(#)clnt.h 2.1 88/07/29 4.0 RPCSRC; from 1.31 88/02/08 SMI*/
|
||||
/*
|
||||
* Sun RPC is a product of Sun Microsystems, Inc. and is provided for
|
||||
* unrestricted use provided that this legend is included on all tape
|
||||
* media and as a part of the software program in whole or part. Users
|
||||
* may copy or modify Sun RPC without charge, but are not authorized
|
||||
* to license or distribute it to anyone else except as part of a product or
|
||||
* program developed by the user.
|
||||
*
|
||||
* SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
|
||||
* WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
|
||||
*
|
||||
* Sun RPC is provided with no support and without any obligation on the
|
||||
* part of Sun Microsystems, Inc. to assist in its use, correction,
|
||||
* modification or enhancement.
|
||||
*
|
||||
* SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
|
||||
* INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
|
||||
* OR ANY PART THEREOF.
|
||||
*
|
||||
* In no event will Sun Microsystems, Inc. be liable for any lost revenue
|
||||
* or profits or other special, indirect and consequential damages, even if
|
||||
* Sun has been advised of the possibility of such damages.
|
||||
*
|
||||
* Sun Microsystems, Inc.
|
||||
* 2550 Garcia Avenue
|
||||
* Mountain View, California 94043
|
||||
*/
|
||||
|
||||
/*
|
||||
* clnt.h - Client side remote procedure call interface.
|
||||
*
|
||||
* Copyright (C) 1984, Sun Microsystems, Inc.
|
||||
*/
|
||||
|
||||
#ifndef _RPC_CLNT_H
|
||||
#define _RPC_CLNT_H 1
|
||||
|
||||
#include <rpc/types.h>
|
||||
#include <rpc/auth.h>
|
||||
#include <lwip/sockets.h>
|
||||
|
||||
/*
|
||||
* Rpc calls return an enum clnt_stat. This should be looked at more,
|
||||
* since each implementation is required to live with this (implementation
|
||||
* independent) list of errors.
|
||||
*/
|
||||
enum clnt_stat {
|
||||
RPC_SUCCESS=0, /* call succeeded */
|
||||
/*
|
||||
* local errors
|
||||
*/
|
||||
RPC_CANTENCODEARGS=1, /* can't encode arguments */
|
||||
RPC_CANTDECODERES=2, /* can't decode results */
|
||||
RPC_CANTSEND=3, /* failure in sending call */
|
||||
RPC_CANTRECV=4, /* failure in receiving result */
|
||||
RPC_TIMEDOUT=5, /* call timed out */
|
||||
/*
|
||||
* remote errors
|
||||
*/
|
||||
RPC_VERSMISMATCH=6, /* rpc versions not compatible */
|
||||
RPC_AUTHERROR=7, /* authentication error */
|
||||
RPC_PROGUNAVAIL=8, /* program not available */
|
||||
RPC_PROGVERSMISMATCH=9, /* program version mismatched */
|
||||
RPC_PROCUNAVAIL=10, /* procedure unavailable */
|
||||
RPC_CANTDECODEARGS=11, /* decode arguments error */
|
||||
RPC_SYSTEMERROR=12, /* generic "other problem" */
|
||||
RPC_NOBROADCAST = 21, /* Broadcasting not supported */
|
||||
/*
|
||||
* callrpc & clnt_create errors
|
||||
*/
|
||||
RPC_UNKNOWNHOST=13, /* unknown host name */
|
||||
RPC_UNKNOWNPROTO=17, /* unknown protocol */
|
||||
RPC_UNKNOWNADDR = 19, /* Remote address unknown */
|
||||
|
||||
/*
|
||||
* rpcbind errors
|
||||
*/
|
||||
RPC_RPCBFAILURE=14, /* portmapper failed in its call */
|
||||
#define RPC_PMAPFAILURE RPC_RPCBFAILURE
|
||||
RPC_PROGNOTREGISTERED=15, /* remote program is not registered */
|
||||
RPC_N2AXLATEFAILURE = 22, /* Name to addr translation failed */
|
||||
/*
|
||||
* unspecified error
|
||||
*/
|
||||
RPC_FAILED=16,
|
||||
RPC_INTR=18,
|
||||
RPC_TLIERROR=20,
|
||||
RPC_UDERROR=23,
|
||||
/*
|
||||
* asynchronous errors
|
||||
*/
|
||||
RPC_INPROGRESS = 24,
|
||||
RPC_STALERACHANDLE = 25
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* Error info.
|
||||
*/
|
||||
struct rpc_err {
|
||||
int re_status;
|
||||
union {
|
||||
int RE_errno; /* related system error */
|
||||
int RE_why; /* why the auth error occurred */
|
||||
struct {
|
||||
unsigned long low; /* lowest verion supported */
|
||||
unsigned long high; /* highest verion supported */
|
||||
} RE_vers;
|
||||
struct { /* maybe meaningful if RPC_FAILED */
|
||||
long s1;
|
||||
long s2;
|
||||
} RE_lb; /* life boot & debugging only */
|
||||
} ru;
|
||||
#define re_errno ru.RE_errno
|
||||
#define re_why ru.RE_why
|
||||
#define re_vers ru.RE_vers
|
||||
#define re_lb ru.RE_lb
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* Client rpc handle.
|
||||
* Created by individual implementations, see e.g. rpc_udp.c.
|
||||
* Client is responsible for initializing auth, see e.g. auth_none.c.
|
||||
*/
|
||||
typedef struct CLIENT CLIENT;
|
||||
struct CLIENT {
|
||||
AUTH *cl_auth; /* authenticator */
|
||||
struct clnt_ops {
|
||||
enum clnt_stat (*cl_call) (CLIENT *, unsigned long, xdrproc_t, char*, xdrproc_t,
|
||||
char*, struct timeval);
|
||||
/* call remote procedure */
|
||||
void (*cl_abort) (void); /* abort a call */
|
||||
void (*cl_geterr) (CLIENT *, struct rpc_err *);
|
||||
/* get specific error code */
|
||||
bool_t (*cl_freeres) (CLIENT *, xdrproc_t, char*);
|
||||
/* frees results */
|
||||
void (*cl_destroy) (CLIENT *); /* destroy this structure */
|
||||
bool_t (*cl_control) (CLIENT *, int, char *);
|
||||
/* the ioctl() of rpc */
|
||||
} *cl_ops;
|
||||
char* cl_private; /* private stuff */
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* client side rpc interface ops
|
||||
*
|
||||
* Parameter types are:
|
||||
*
|
||||
*/
|
||||
|
||||
/*
|
||||
* enum clnt_stat
|
||||
* CLNT_CALL(rh, proc, xargs, argsp, xres, resp, timeout)
|
||||
* CLIENT *rh;
|
||||
* unsigned long proc;
|
||||
* xdrproc_t xargs;
|
||||
* char* argsp;
|
||||
* xdrproc_t xres;
|
||||
* char* resp;
|
||||
* struct timeval timeout;
|
||||
*/
|
||||
#define CLNT_CALL(rh, proc, xargs, argsp, xres, resp, secs) \
|
||||
((*(rh)->cl_ops->cl_call)(rh, proc, xargs, argsp, xres, resp, secs))
|
||||
#define clnt_call(rh, proc, xargs, argsp, xres, resp, secs) \
|
||||
((*(rh)->cl_ops->cl_call)(rh, proc, xargs, argsp, xres, resp, secs))
|
||||
|
||||
/*
|
||||
* void
|
||||
* CLNT_ABORT(rh);
|
||||
* CLIENT *rh;
|
||||
*/
|
||||
#define CLNT_ABORT(rh) ((*(rh)->cl_ops->cl_abort)(rh))
|
||||
#define clnt_abort(rh) ((*(rh)->cl_ops->cl_abort)(rh))
|
||||
|
||||
/*
|
||||
* struct rpc_err
|
||||
* CLNT_GETERR(rh);
|
||||
* CLIENT *rh;
|
||||
*/
|
||||
#define CLNT_GETERR(rh,errp) ((*(rh)->cl_ops->cl_geterr)(rh, errp))
|
||||
#define clnt_geterr(rh,errp) ((*(rh)->cl_ops->cl_geterr)(rh, errp))
|
||||
|
||||
|
||||
/*
|
||||
* bool_t
|
||||
* CLNT_FREERES(rh, xres, resp);
|
||||
* CLIENT *rh;
|
||||
* xdrproc_t xres;
|
||||
* char* resp;
|
||||
*/
|
||||
#define CLNT_FREERES(rh,xres,resp) ((*(rh)->cl_ops->cl_freeres)(rh,xres,resp))
|
||||
#define clnt_freeres(rh,xres,resp) ((*(rh)->cl_ops->cl_freeres)(rh,xres,resp))
|
||||
|
||||
/*
|
||||
* bool_t
|
||||
* CLNT_CONTROL(cl, request, info)
|
||||
* CLIENT *cl;
|
||||
* unsigned int request;
|
||||
* char *info;
|
||||
*/
|
||||
#define CLNT_CONTROL(cl,rq,in) ((*(cl)->cl_ops->cl_control)(cl,rq,in))
|
||||
#define clnt_control(cl,rq,in) ((*(cl)->cl_ops->cl_control)(cl,rq,in))
|
||||
|
||||
/*
|
||||
* control operations that apply to all transports
|
||||
*
|
||||
* Note: options marked XXX are no-ops in this implementation of RPC.
|
||||
* The are present in TI-RPC but can't be implemented here since they
|
||||
* depend on the presence of STREAMS/TLI, which we don't have.
|
||||
*/
|
||||
#define CLSET_TIMEOUT 1 /* set timeout (timeval) */
|
||||
#define CLGET_TIMEOUT 2 /* get timeout (timeval) */
|
||||
#define CLGET_SERVER_ADDR 3 /* get server's address (sockaddr) */
|
||||
#define CLGET_FD 6 /* get connections file descriptor */
|
||||
#define CLGET_SVC_ADDR 7 /* get server's address (netbuf) XXX */
|
||||
#define CLSET_FD_CLOSE 8 /* close fd while clnt_destroy */
|
||||
#define CLSET_FD_NCLOSE 9 /* Do not close fd while clnt_destroy*/
|
||||
#define CLGET_XID 10 /* Get xid */
|
||||
#define CLSET_XID 11 /* Set xid */
|
||||
#define CLGET_VERS 12 /* Get version number */
|
||||
#define CLSET_VERS 13 /* Set version number */
|
||||
#define CLGET_PROG 14 /* Get program number */
|
||||
#define CLSET_PROG 15 /* Set program number */
|
||||
#define CLSET_SVC_ADDR 16 /* get server's address (netbuf) XXX */
|
||||
#define CLSET_PUSH_TIMOD 17 /* push timod if not already present XXX */
|
||||
#define CLSET_POP_TIMOD 18 /* pop timod XXX */
|
||||
/*
|
||||
* Connectionless only control operations
|
||||
*/
|
||||
#define CLSET_RETRY_TIMEOUT 4 /* set retry timeout (timeval) */
|
||||
#define CLGET_RETRY_TIMEOUT 5 /* get retry timeout (timeval) */
|
||||
|
||||
/*
|
||||
* void
|
||||
* CLNT_DESTROY(rh);
|
||||
* CLIENT *rh;
|
||||
*/
|
||||
#define CLNT_DESTROY(rh) ((*(rh)->cl_ops->cl_destroy)(rh))
|
||||
#define clnt_destroy(rh) ((*(rh)->cl_ops->cl_destroy)(rh))
|
||||
|
||||
|
||||
/*
|
||||
* RPCTEST is a test program which is accessible on every rpc
|
||||
* transport/port. It is used for testing, performance evaluation,
|
||||
* and network administration.
|
||||
*/
|
||||
|
||||
#define RPCTEST_PROGRAM ((unsigned long)1)
|
||||
#define RPCTEST_VERSION ((unsigned long)1)
|
||||
#define RPCTEST_NULL_PROC ((unsigned long)2)
|
||||
#define RPCTEST_NULL_BATCH_PROC ((unsigned long)3)
|
||||
|
||||
/*
|
||||
* By convention, procedure 0 takes null arguments and returns them
|
||||
*/
|
||||
|
||||
#define NULLPROC ((unsigned long)0)
|
||||
|
||||
/*
|
||||
* Below are the client handle creation routines for the various
|
||||
* implementations of client side rpc. They can return NULL if a
|
||||
* creation failure occurs.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Generic client creation routine. Supported protocols are "udp", "tcp" and
|
||||
* "unix"
|
||||
* CLIENT *
|
||||
* clnt_create(host, prog, vers, prot)
|
||||
* char *host; -- hostname
|
||||
* unsigned long prog; -- program number
|
||||
* u_ong vers; -- version number
|
||||
* char *prot; -- protocol
|
||||
*/
|
||||
extern CLIENT *clnt_create (const char *__host, const unsigned long __prog,
|
||||
const unsigned long __vers, const char *__prot)
|
||||
;
|
||||
|
||||
/*
|
||||
* UDP based rpc.
|
||||
* CLIENT *
|
||||
* clntudp_create(raddr, program, version, wait, sockp)
|
||||
* struct sockaddr_in *raddr;
|
||||
* unsigned long program;
|
||||
* unsigned long version;
|
||||
* struct timeval wait_resend;
|
||||
* int *sockp;
|
||||
*
|
||||
* Same as above, but you specify max packet sizes.
|
||||
* CLIENT *
|
||||
* clntudp_bufcreate(raddr, program, version, wait, sockp, sendsz, recvsz)
|
||||
* struct sockaddr_in *raddr;
|
||||
* unsigned long program;
|
||||
* unsigned long version;
|
||||
* struct timeval wait_resend;
|
||||
* int *sockp;
|
||||
* unsigned int sendsz;
|
||||
* unsigned int recvsz;
|
||||
*/
|
||||
extern CLIENT *clntudp_create (struct sockaddr_in *__raddr, unsigned long __program,
|
||||
unsigned long __version, struct timeval __wait_resend,
|
||||
int *__sockp);
|
||||
extern CLIENT *clntudp_bufcreate (struct sockaddr_in *__raddr,
|
||||
unsigned long __program, unsigned long __version,
|
||||
struct timeval __wait_resend, int *__sockp,
|
||||
unsigned int __sendsz, unsigned int __recvsz);
|
||||
|
||||
extern int callrpc (const char *__host, const unsigned long __prognum,
|
||||
const unsigned long __versnum, const unsigned long __procnum,
|
||||
const xdrproc_t __inproc, const char *__in,
|
||||
const xdrproc_t __outproc, char *__out);
|
||||
|
||||
#define UDPMSGSIZE 8800 /* rpc imposed limit on udp msg size */
|
||||
#define RPCSMALLMSGSIZE 400 /* a more reasonable packet size */
|
||||
|
||||
void clnt_perror(CLIENT *rpch, const char *s);
|
||||
|
||||
#endif /* rpc/clnt.h */
|
||||
@@ -0,0 +1,95 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
/* @(#)clnt_generic.c 2.2 88/08/01 4.0 RPCSRC */
|
||||
/*
|
||||
* Sun RPC is a product of Sun Microsystems, Inc. and is provided for
|
||||
* unrestricted use provided that this legend is included on all tape
|
||||
* media and as a part of the software program in whole or part. Users
|
||||
* may copy or modify Sun RPC without charge, but are not authorized
|
||||
* to license or distribute it to anyone else except as part of a product or
|
||||
* program developed by the user.
|
||||
*
|
||||
* SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
|
||||
* WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
|
||||
*
|
||||
* Sun RPC is provided with no support and without any obligation on the
|
||||
* part of Sun Microsystems, Inc. to assist in its use, correction,
|
||||
* modification or enhancement.
|
||||
*
|
||||
* SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
|
||||
* INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
|
||||
* OR ANY PART THEREOF.
|
||||
*
|
||||
* In no event will Sun Microsystems, Inc. be liable for any lost revenue
|
||||
* or profits or other special, indirect and consequential damages, even if
|
||||
* Sun has been advised of the possibility of such damages.
|
||||
*
|
||||
* Sun Microsystems, Inc.
|
||||
* 2550 Garcia Avenue
|
||||
* Mountain View, California 94043
|
||||
*/
|
||||
#if !defined(lint) && defined(SCCSIDS)
|
||||
static char sccsid[] = "@(#)clnt_generic.c 1.4 87/08/11 (C) 1987 SMI";
|
||||
#endif
|
||||
/*
|
||||
* Copyright (C) 1987, Sun Microsystems, Inc.
|
||||
*/
|
||||
#include <rpc/rpc.h>
|
||||
#include <string.h>
|
||||
|
||||
/*
|
||||
* Generic client creation: takes (hostname, program-number, protocol) and
|
||||
* returns client handle. Default options are set, which the user can
|
||||
* change using the rpc equivalent of ioctl()'s.
|
||||
*/
|
||||
CLIENT *clnt_create(const char *hostname, const unsigned long prog,
|
||||
const unsigned long vers, const char *proto)
|
||||
{
|
||||
int sock;
|
||||
struct sockaddr_in server;
|
||||
struct addrinfo hint, *res = NULL;
|
||||
struct timeval tv;
|
||||
CLIENT *client;
|
||||
int ret;
|
||||
|
||||
memset(&hint, 0, sizeof(hint));
|
||||
ret = getaddrinfo(hostname, NULL, &hint, &res);
|
||||
if (ret != 0)
|
||||
{
|
||||
rt_kprintf("getaddrinfo err: %d '%s'\n", ret, hostname);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
memcpy(&server, res->ai_addr, sizeof(struct sockaddr_in));
|
||||
freeaddrinfo(res);
|
||||
|
||||
sock = -1;
|
||||
if (strcmp(proto, "udp") == 0)
|
||||
{
|
||||
tv.tv_sec = 5;
|
||||
tv.tv_usec = 0;
|
||||
client = clntudp_create(&server, prog, vers, tv, &sock);
|
||||
if (client == NULL) return NULL;
|
||||
tv.tv_sec = 1;
|
||||
clnt_control(client, CLSET_TIMEOUT, (char *)&tv);
|
||||
}
|
||||
else
|
||||
{
|
||||
rt_kprintf("unknow protocol\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return (client);
|
||||
}
|
||||
|
||||
void clnt_perror(CLIENT *rpch, const char *s)
|
||||
{
|
||||
rt_kprintf("rpc client error:%s\n", s);
|
||||
}
|
||||
@@ -0,0 +1,404 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
/* @(#)clnt_udp.c 2.2 88/08/01 4.0 RPCSRC */
|
||||
/*
|
||||
* Sun RPC is a product of Sun Microsystems, Inc. and is provided for
|
||||
* unrestricted use provided that this legend is included on all tape
|
||||
* media and as a part of the software program in whole or part. Users
|
||||
* may copy or modify Sun RPC without charge, but are not authorized
|
||||
* to license or distribute it to anyone else except as part of a product or
|
||||
* program developed by the user.
|
||||
*
|
||||
* SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
|
||||
* WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
|
||||
*
|
||||
* Sun RPC is provided with no support and without any obligation on the
|
||||
* part of Sun Microsystems, Inc. to assist in its use, correction,
|
||||
* modification or enhancement.
|
||||
*
|
||||
* SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
|
||||
* INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
|
||||
* OR ANY PART THEREOF.
|
||||
*
|
||||
* In no event will Sun Microsystems, Inc. be liable for any lost revenue
|
||||
* or profits or other special, indirect and consequential damages, even if
|
||||
* Sun has been advised of the possibility of such damages.
|
||||
*
|
||||
* Sun Microsystems, Inc.
|
||||
* 2550 Garcia Avenue
|
||||
* Mountain View, California 94043
|
||||
*/
|
||||
#if !defined(lint) && defined(SCCSIDS)
|
||||
static char sccsid[] = "@(#)clnt_udp.c 1.39 87/08/11 Copyr 1984 Sun Micro";
|
||||
#endif
|
||||
|
||||
/*
|
||||
* clnt_udp.c, Implements a UDP/IP based, client side RPC.
|
||||
*
|
||||
* Copyright (C) 1984, Sun Microsystems, Inc.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <rpc/rpc.h>
|
||||
#include <rtthread.h>
|
||||
|
||||
/*
|
||||
* UDP bases client side rpc operations
|
||||
*/
|
||||
static enum clnt_stat clntudp_call(register CLIENT *cl, /* client handle */
|
||||
unsigned long proc, /* procedure number */
|
||||
xdrproc_t xargs, /* xdr routine for args */
|
||||
char* argsp, /* pointer to args */
|
||||
xdrproc_t xresults, /* xdr routine for results */
|
||||
char* resultsp, /* pointer to results */
|
||||
struct timeval utimeout);
|
||||
|
||||
static void clntudp_abort(void);
|
||||
static void clntudp_geterr(CLIENT *, struct rpc_err *);
|
||||
static bool_t clntudp_freeres(CLIENT *, xdrproc_t, char*);
|
||||
static bool_t clntudp_control(CLIENT *, int, char *);
|
||||
static void clntudp_destroy(CLIENT *);
|
||||
|
||||
static struct clnt_ops udp_ops =
|
||||
{
|
||||
clntudp_call,
|
||||
clntudp_abort,
|
||||
clntudp_geterr,
|
||||
clntudp_freeres,
|
||||
clntudp_destroy,
|
||||
clntudp_control
|
||||
};
|
||||
|
||||
/*
|
||||
* Private data kept per client handle
|
||||
*/
|
||||
struct cu_data
|
||||
{
|
||||
int cu_sock;
|
||||
bool_t cu_closeit;
|
||||
struct sockaddr_in cu_raddr;
|
||||
int cu_rlen;
|
||||
struct timeval cu_wait;
|
||||
struct timeval cu_total;
|
||||
struct rpc_err cu_error;
|
||||
XDR cu_outxdrs;
|
||||
unsigned int cu_xdrpos;
|
||||
unsigned int cu_sendsz;
|
||||
char *cu_outbuf;
|
||||
unsigned int cu_recvsz;
|
||||
char cu_inbuf[1];
|
||||
};
|
||||
|
||||
/*
|
||||
* Create a UDP based client handle.
|
||||
* If *sockp<0, *sockp is set to a newly created UPD socket.
|
||||
* If raddr->sin_port is 0 a binder on the remote machine
|
||||
* is consulted for the correct port number.
|
||||
* NB: It is the clients responsibility to close *sockp.
|
||||
* NB: The rpch->cl_auth is initialized to null authentication.
|
||||
* Caller may wish to set this something more useful.
|
||||
*
|
||||
* wait is the amount of time used between retransmitting a call if
|
||||
* no response has been heard; retransmition occurs until the actual
|
||||
* rpc call times out.
|
||||
*
|
||||
* sendsz and recvsz are the maximum allowable packet sizes that can be
|
||||
* sent and received.
|
||||
*/
|
||||
CLIENT *clntudp_bufcreate(struct sockaddr_in *raddr,
|
||||
unsigned long program,
|
||||
unsigned long version,
|
||||
struct timeval wait,
|
||||
int *sockp,
|
||||
unsigned int sendsz,
|
||||
unsigned int recvsz)
|
||||
{
|
||||
CLIENT *cl;
|
||||
register struct cu_data *cu = NULL;
|
||||
struct rpc_msg call_msg;
|
||||
static int xid_count = 0;
|
||||
|
||||
cl = (CLIENT *) rt_malloc (sizeof(CLIENT));
|
||||
if (cl == NULL)
|
||||
{
|
||||
rt_kprintf("clntudp_create: out of memory\n");
|
||||
goto fooy;
|
||||
}
|
||||
sendsz = ((sendsz + 3) / 4) * 4;
|
||||
recvsz = ((recvsz + 3) / 4) * 4;
|
||||
cu = (struct cu_data *) rt_malloc (sizeof(*cu) + sendsz + recvsz);
|
||||
if (cu == NULL)
|
||||
{
|
||||
rt_kprintf("clntudp_create: out of memory\n");
|
||||
goto fooy;
|
||||
}
|
||||
cu->cu_outbuf = &cu->cu_inbuf[recvsz];
|
||||
|
||||
if (raddr->sin_port == 0) {
|
||||
unsigned short port;
|
||||
extern unsigned short pmap_getport(struct sockaddr_in *address,
|
||||
unsigned long program,
|
||||
unsigned long version,
|
||||
unsigned int protocol);
|
||||
|
||||
if ((port =
|
||||
pmap_getport(raddr, program, version, IPPROTO_UDP)) == 0) {
|
||||
goto fooy;
|
||||
}
|
||||
raddr->sin_port = htons(port);
|
||||
}
|
||||
|
||||
cl->cl_ops = &udp_ops;
|
||||
cl->cl_private = (char*) cu;
|
||||
cu->cu_raddr = *raddr;
|
||||
cu->cu_rlen = sizeof(cu->cu_raddr);
|
||||
cu->cu_wait = wait;
|
||||
cu->cu_total.tv_sec = -1;
|
||||
cu->cu_total.tv_usec = -1;
|
||||
cu->cu_sendsz = sendsz;
|
||||
cu->cu_recvsz = recvsz;
|
||||
call_msg.rm_xid = ((unsigned long)rt_thread_self()) ^ ((unsigned long)rt_tick_get()) ^ (xid_count++);
|
||||
call_msg.rm_direction = CALL;
|
||||
call_msg.rm_call.cb_rpcvers = RPC_MSG_VERSION;
|
||||
call_msg.rm_call.cb_prog = program;
|
||||
call_msg.rm_call.cb_vers = version;
|
||||
xdrmem_create(&(cu->cu_outxdrs), cu->cu_outbuf, sendsz, XDR_ENCODE);
|
||||
if (!xdr_callhdr(&(cu->cu_outxdrs), &call_msg))
|
||||
{
|
||||
goto fooy;
|
||||
}
|
||||
cu->cu_xdrpos = XDR_GETPOS(&(cu->cu_outxdrs));
|
||||
if (*sockp < 0)
|
||||
{
|
||||
*sockp = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
|
||||
if (*sockp < 0)
|
||||
{
|
||||
rt_kprintf("create socket error\n");
|
||||
goto fooy;
|
||||
}
|
||||
cu->cu_closeit = TRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
cu->cu_closeit = FALSE;
|
||||
}
|
||||
cu->cu_sock = *sockp;
|
||||
cl->cl_auth = authnone_create();
|
||||
return (cl);
|
||||
|
||||
fooy:
|
||||
if (cu) rt_free(cu);
|
||||
if (cl) rt_free(cl);
|
||||
|
||||
return ((CLIENT *) NULL);
|
||||
}
|
||||
|
||||
CLIENT *clntudp_create(struct sockaddr_in *raddr,
|
||||
unsigned long program,
|
||||
unsigned long version,
|
||||
struct timeval wait,
|
||||
int *sockp)
|
||||
{
|
||||
return (clntudp_bufcreate(raddr, program, version, wait, sockp,
|
||||
UDPMSGSIZE, UDPMSGSIZE));
|
||||
}
|
||||
|
||||
static enum clnt_stat clntudp_call(CLIENT *cl, unsigned long proc,
|
||||
xdrproc_t xargs, char* argsp,
|
||||
xdrproc_t xresults, char* resultsp,
|
||||
struct timeval utimeout)
|
||||
{
|
||||
register struct cu_data *cu = (struct cu_data *) cl->cl_private;
|
||||
register XDR *xdrs;
|
||||
register int outlen;
|
||||
register int inlen;
|
||||
socklen_t fromlen;
|
||||
|
||||
struct sockaddr_in from;
|
||||
struct rpc_msg reply_msg;
|
||||
XDR reply_xdrs;
|
||||
bool_t ok;
|
||||
int nrefreshes = 2; /* number of times to refresh cred */
|
||||
|
||||
call_again:
|
||||
xdrs = &(cu->cu_outxdrs);
|
||||
xdrs->x_op = XDR_ENCODE;
|
||||
XDR_SETPOS(xdrs, cu->cu_xdrpos);
|
||||
|
||||
/*
|
||||
* the transaction is the first thing in the out buffer
|
||||
*/
|
||||
(*(unsigned long *) (cu->cu_outbuf))++;
|
||||
|
||||
if ((!XDR_PUTLONG(xdrs, (long *) &proc)) ||
|
||||
(!AUTH_MARSHALL(cl->cl_auth, xdrs)) || (!(*xargs) (xdrs, argsp)))
|
||||
{
|
||||
cu->cu_error.re_status = RPC_CANTENCODEARGS;
|
||||
return RPC_CANTENCODEARGS;
|
||||
}
|
||||
outlen = (int) XDR_GETPOS(xdrs);
|
||||
|
||||
send_again:
|
||||
if (sendto(cu->cu_sock, cu->cu_outbuf, outlen, 0,
|
||||
(struct sockaddr *) &(cu->cu_raddr), cu->cu_rlen)
|
||||
!= outlen)
|
||||
{
|
||||
cu->cu_error.re_errno = errno;
|
||||
cu->cu_error.re_status = RPC_CANTSEND;
|
||||
|
||||
return RPC_CANTSEND;
|
||||
}
|
||||
|
||||
/*
|
||||
* sub-optimal code appears here because we have
|
||||
* some clock time to spare while the packets are in flight.
|
||||
* (We assume that this is actually only executed once.)
|
||||
*/
|
||||
reply_msg.acpted_rply.ar_verf = _null_auth;
|
||||
reply_msg.acpted_rply.ar_results.where = resultsp;
|
||||
reply_msg.acpted_rply.ar_results.proc = xresults;
|
||||
|
||||
/* do recv */
|
||||
do
|
||||
{
|
||||
fromlen = sizeof(struct sockaddr);
|
||||
|
||||
inlen = recvfrom(cu->cu_sock, cu->cu_inbuf,
|
||||
(int) cu->cu_recvsz, 0,
|
||||
(struct sockaddr *) &from, &fromlen);
|
||||
}while (inlen < 0 && errno == EINTR);
|
||||
|
||||
if (inlen < 4)
|
||||
{
|
||||
rt_kprintf("recv error, len %d\n", inlen);
|
||||
cu->cu_error.re_errno = errno;
|
||||
cu->cu_error.re_status = RPC_CANTRECV;
|
||||
|
||||
return RPC_CANTRECV;
|
||||
}
|
||||
|
||||
/* see if reply transaction id matches sent id */
|
||||
if (*((uint32_t *) (cu->cu_inbuf)) != *((uint32_t *) (cu->cu_outbuf)))
|
||||
goto send_again;
|
||||
|
||||
/* we now assume we have the proper reply */
|
||||
|
||||
/*
|
||||
* now decode and validate the response
|
||||
*/
|
||||
xdrmem_create(&reply_xdrs, cu->cu_inbuf, (unsigned int) inlen, XDR_DECODE);
|
||||
ok = xdr_replymsg(&reply_xdrs, &reply_msg);
|
||||
/* XDR_DESTROY(&reply_xdrs); save a few cycles on noop destroy */
|
||||
if (ok)
|
||||
{
|
||||
_seterr_reply(&reply_msg, &(cu->cu_error));
|
||||
if (cu->cu_error.re_status == RPC_SUCCESS)
|
||||
{
|
||||
if (!AUTH_VALIDATE(cl->cl_auth,
|
||||
&reply_msg.acpted_rply.ar_verf))
|
||||
{
|
||||
cu->cu_error.re_status = RPC_AUTHERROR;
|
||||
cu->cu_error.re_why = AUTH_INVALIDRESP;
|
||||
}
|
||||
if (reply_msg.acpted_rply.ar_verf.oa_base != NULL)
|
||||
{
|
||||
extern bool_t xdr_opaque_auth(XDR *xdrs, struct opaque_auth *ap);
|
||||
|
||||
xdrs->x_op = XDR_FREE;
|
||||
(void) xdr_opaque_auth(xdrs, &(reply_msg.acpted_rply.ar_verf));
|
||||
}
|
||||
} /* end successful completion */
|
||||
else
|
||||
{
|
||||
/* maybe our credentials need to be refreshed ... */
|
||||
if (nrefreshes > 0 && AUTH_REFRESH(cl->cl_auth))
|
||||
{
|
||||
nrefreshes--;
|
||||
goto call_again;
|
||||
}
|
||||
} /* end of unsuccessful completion */
|
||||
} /* end of valid reply message */
|
||||
else
|
||||
{
|
||||
cu->cu_error.re_status = RPC_CANTDECODERES;
|
||||
}
|
||||
|
||||
return (enum clnt_stat)(cu->cu_error.re_status);
|
||||
}
|
||||
|
||||
static void clntudp_geterr(CLIENT *cl, struct rpc_err *errp)
|
||||
{
|
||||
register struct cu_data *cu = (struct cu_data *) cl->cl_private;
|
||||
|
||||
*errp = cu->cu_error;
|
||||
}
|
||||
|
||||
static bool_t clntudp_freeres(CLIENT *cl, xdrproc_t xdr_res, char* res_ptr)
|
||||
{
|
||||
register struct cu_data *cu = (struct cu_data *) cl->cl_private;
|
||||
register XDR *xdrs = &(cu->cu_outxdrs);
|
||||
|
||||
xdrs->x_op = XDR_FREE;
|
||||
return ((*xdr_res) (xdrs, res_ptr));
|
||||
}
|
||||
|
||||
static void clntudp_abort()
|
||||
{
|
||||
}
|
||||
|
||||
static bool_t clntudp_control(CLIENT *cl, int request, char *info)
|
||||
{
|
||||
register struct cu_data *cu = (struct cu_data *) cl->cl_private;
|
||||
|
||||
switch (request)
|
||||
{
|
||||
case CLSET_TIMEOUT:
|
||||
{
|
||||
int mtimeout;
|
||||
|
||||
cu->cu_total = *(struct timeval *) info;
|
||||
mtimeout = ((cu->cu_total.tv_sec * 1000) + ((cu->cu_total.tv_usec + 500)/1000));
|
||||
|
||||
/* set socket option, note: lwip only support msecond timeout */
|
||||
setsockopt(cu->cu_sock, SOL_SOCKET, SO_RCVTIMEO,
|
||||
&mtimeout, sizeof(mtimeout));
|
||||
}
|
||||
break;
|
||||
case CLGET_TIMEOUT:
|
||||
*(struct timeval *) info = cu->cu_total;
|
||||
break;
|
||||
case CLSET_RETRY_TIMEOUT:
|
||||
cu->cu_wait = *(struct timeval *) info;
|
||||
break;
|
||||
case CLGET_RETRY_TIMEOUT:
|
||||
*(struct timeval *) info = cu->cu_wait;
|
||||
break;
|
||||
case CLGET_SERVER_ADDR:
|
||||
*(struct sockaddr_in *) info = cu->cu_raddr;
|
||||
break;
|
||||
default:
|
||||
return (FALSE);
|
||||
}
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
static void clntudp_destroy(CLIENT *cl)
|
||||
{
|
||||
register struct cu_data *cu = (struct cu_data *) cl->cl_private;
|
||||
|
||||
if (cu->cu_closeit)
|
||||
{
|
||||
lwip_close(cu->cu_sock);
|
||||
}
|
||||
|
||||
XDR_DESTROY(&(cu->cu_outxdrs));
|
||||
rt_free(cu);
|
||||
rt_free(cl);
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
#include "pmap.h"
|
||||
#include "clnt.h"
|
||||
#include <rpc/rpc.h>
|
||||
|
||||
static struct timeval timeout = { 5, 0 };
|
||||
static struct timeval tottimeout = { 60, 0 };
|
||||
|
||||
|
||||
bool_t xdr_pmap(XDR *xdrs, struct pmap *regs)
|
||||
{
|
||||
if (xdr_u_long(xdrs, ®s->pm_prog) &&
|
||||
xdr_u_long(xdrs, ®s->pm_vers) &&
|
||||
xdr_u_long(xdrs, ®s->pm_prot))
|
||||
return (xdr_u_long(xdrs, ®s->pm_port));
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
/*
|
||||
* Find the mapped port for program,version.
|
||||
* Calls the pmap service remotely to do the lookup.
|
||||
* Returns 0 if no map exists.
|
||||
*/
|
||||
unsigned short pmap_getport(struct sockaddr_in *address, unsigned long program, unsigned long version, unsigned int protocol)
|
||||
{
|
||||
unsigned short port = 0;
|
||||
int socket = -1;
|
||||
register CLIENT *client = RT_NULL;
|
||||
struct pmap parms;
|
||||
|
||||
address->sin_port = htons((unsigned short)PMAPPORT);
|
||||
if (protocol == IPPROTO_UDP)
|
||||
client = clntudp_bufcreate(address, PMAPPROG, PMAPVERS, timeout,
|
||||
&socket, RPCSMALLMSGSIZE,
|
||||
RPCSMALLMSGSIZE);
|
||||
|
||||
if (client != (CLIENT *) NULL)
|
||||
{
|
||||
parms.pm_prog = program;
|
||||
parms.pm_vers = version;
|
||||
parms.pm_prot = protocol;
|
||||
parms.pm_port = 0; /* not needed or used */
|
||||
if (CLNT_CALL(client, PMAPPROC_GETPORT, (xdrproc_t)xdr_pmap, (char*)&parms,
|
||||
(xdrproc_t)xdr_u_short, (char*)&port, tottimeout) != RPC_SUCCESS)
|
||||
{
|
||||
rt_kprintf("pmap failure\n");
|
||||
}
|
||||
CLNT_DESTROY(client);
|
||||
}
|
||||
|
||||
(void) lwip_close(socket);
|
||||
address->sin_port = 0;
|
||||
|
||||
return (port);
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
#ifndef __RPC_PMAP_PROT_H__
|
||||
#define __RPC_PMAP_PROT_H__
|
||||
|
||||
#include <rpc/xdr.h>
|
||||
|
||||
/* The following procedures are supported by the protocol:
|
||||
*
|
||||
* PMAPPROC_NULL() returns ()
|
||||
* takes nothing, returns nothing
|
||||
*
|
||||
* PMAPPROC_SET(struct pmap) returns (bool_t)
|
||||
* TRUE is success, FALSE is failure. Registers the tuple
|
||||
* [prog, vers, prot, port].
|
||||
*
|
||||
* PMAPPROC_UNSET(struct pmap) returns (bool_t)
|
||||
* TRUE is success, FALSE is failure. Un-registers pair
|
||||
* [prog, vers]. prot and port are ignored.
|
||||
*
|
||||
* PMAPPROC_GETPORT(struct pmap) returns (long unsigned).
|
||||
* 0 is failure. Otherwise returns the port number where the pair
|
||||
* [prog, vers] is registered. It may lie!
|
||||
*
|
||||
* PMAPPROC_DUMP() RETURNS (struct pmaplist *)
|
||||
*
|
||||
* PMAPPROC_CALLIT(unsigned, unsigned, unsigned, string<>)
|
||||
* RETURNS (port, string<>);
|
||||
* usage: encapsulatedresults = PMAPPROC_CALLIT(prog, vers, proc, encapsulatedargs);
|
||||
* Calls the procedure on the local machine. If it is not registered,
|
||||
* this procedure is quite; ie it does not return error information!!!
|
||||
* This procedure only is supported on rpc/udp and calls via
|
||||
* rpc/udp. This routine only passes null authentication parameters.
|
||||
* This file has no interface to xdr routines for PMAPPROC_CALLIT.
|
||||
*
|
||||
* The service supports remote procedure calls on udp/ip or tcp/ip socket 111.
|
||||
*/
|
||||
|
||||
#define PMAPPORT ((unsigned short)111)
|
||||
#define PMAPPROG ((unsigned long)100000)
|
||||
#define PMAPVERS ((unsigned long)2)
|
||||
#define PMAPVERS_PROTO ((unsigned long)2)
|
||||
#define PMAPVERS_ORIG ((unsigned long)1)
|
||||
#define PMAPPROC_NULL ((unsigned long)0)
|
||||
#define PMAPPROC_SET ((unsigned long)1)
|
||||
#define PMAPPROC_UNSET ((unsigned long)2)
|
||||
#define PMAPPROC_GETPORT ((unsigned long)3)
|
||||
#define PMAPPROC_DUMP ((unsigned long)4)
|
||||
#define PMAPPROC_CALLIT ((unsigned long)5)
|
||||
|
||||
struct pmap {
|
||||
long unsigned pm_prog;
|
||||
long unsigned pm_vers;
|
||||
long unsigned pm_prot;
|
||||
long unsigned pm_port;
|
||||
};
|
||||
|
||||
extern bool_t xdr_pmap (XDR *__xdrs, struct pmap *__regs);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,62 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
/* @(#)rpc.h 2.3 88/08/10 4.0 RPCSRC; from 1.9 88/02/08 SMI */
|
||||
/*
|
||||
* Sun RPC is a product of Sun Microsystems, Inc. and is provided for
|
||||
* unrestricted use provided that this legend is included on all tape
|
||||
* media and as a part of the software program in whole or part. Users
|
||||
* may copy or modify Sun RPC without charge, but are not authorized
|
||||
* to license or distribute it to anyone else except as part of a product or
|
||||
* program developed by the user.
|
||||
*
|
||||
* SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
|
||||
* WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
|
||||
*
|
||||
* Sun RPC is provided with no support and without any obligation on the
|
||||
* part of Sun Microsystems, Inc. to assist in its use, correction,
|
||||
* modification or enhancement.
|
||||
*
|
||||
* SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
|
||||
* INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
|
||||
* OR ANY PART THEREOF.
|
||||
*
|
||||
* In no event will Sun Microsystems, Inc. be liable for any lost revenue
|
||||
* or profits or other special, indirect and consequential damages, even if
|
||||
* Sun has been advised of the possibility of such damages.
|
||||
*
|
||||
* Sun Microsystems, Inc.
|
||||
* 2550 Garcia Avenue
|
||||
* Mountain View, California 94043
|
||||
*/
|
||||
|
||||
/*
|
||||
* rpc.h, Just includes the billions of rpc header files necessary to
|
||||
* do remote procedure calling.
|
||||
*
|
||||
* Copyright (C) 1984, Sun Microsystems, Inc.
|
||||
*/
|
||||
|
||||
#ifndef _RPC_RPC_H
|
||||
#define _RPC_RPC_H 1
|
||||
|
||||
#include <rpc/types.h> /* some typedefs */
|
||||
|
||||
/* external data representation interfaces */
|
||||
#include <rpc/xdr.h> /* generic (de)serializer */
|
||||
|
||||
#include <rpc/auth.h>
|
||||
|
||||
/* Client side (mostly) remote procedure call */
|
||||
#include <rpc/clnt.h> /* generic rpc stuff */
|
||||
|
||||
/* semi-private protocol headers */
|
||||
#include <rpc/rpc_msg.h> /* protocol for rpc messages */
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,203 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
/* @(#)rpc_msg.h 2.1 88/07/29 4.0 RPCSRC */
|
||||
/*
|
||||
* Sun RPC is a product of Sun Microsystems, Inc. and is provided for
|
||||
* unrestricted use provided that this legend is included on all tape
|
||||
* media and as a part of the software program in whole or part. Users
|
||||
* may copy or modify Sun RPC without charge, but are not authorized
|
||||
* to license or distribute it to anyone else except as part of a product or
|
||||
* program developed by the user.
|
||||
*
|
||||
* SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
|
||||
* WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
|
||||
*
|
||||
* Sun RPC is provided with no support and without any obligation on the
|
||||
* part of Sun Microsystems, Inc. to assist in its use, correction,
|
||||
* modification or enhancement.
|
||||
*
|
||||
* SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
|
||||
* INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
|
||||
* OR ANY PART THEREOF.
|
||||
*
|
||||
* In no event will Sun Microsystems, Inc. be liable for any lost revenue
|
||||
* or profits or other special, indirect and consequential damages, even if
|
||||
* Sun has been advised of the possibility of such damages.
|
||||
*
|
||||
* Sun Microsystems, Inc.
|
||||
* 2550 Garcia Avenue
|
||||
* Mountain View, California 94043
|
||||
*/
|
||||
/* @(#)rpc_msg.h 1.7 86/07/16 SMI */
|
||||
|
||||
#ifndef _RPC_MSG_H
|
||||
#define _RPC_MSG_H 1
|
||||
|
||||
#include <rpc/xdr.h>
|
||||
#include <rpc/clnt.h>
|
||||
|
||||
/*
|
||||
* rpc_msg.h
|
||||
* rpc message definition
|
||||
*
|
||||
* Copyright (C) 1984, Sun Microsystems, Inc.
|
||||
*/
|
||||
|
||||
#define RPC_MSG_VERSION ((unsigned long) 2)
|
||||
#define RPC_SERVICE_PORT ((unsigned short) 2048)
|
||||
|
||||
/*
|
||||
* Bottom up definition of an rpc message.
|
||||
* NOTE: call and reply use the same overall struct but
|
||||
* different parts of unions within it.
|
||||
*/
|
||||
|
||||
enum msg_type {
|
||||
CALL=0,
|
||||
REPLY=1
|
||||
};
|
||||
|
||||
enum reply_stat {
|
||||
MSG_ACCEPTED=0,
|
||||
MSG_DENIED=1
|
||||
};
|
||||
|
||||
enum accept_stat {
|
||||
SUCCESS=0,
|
||||
PROG_UNAVAIL=1,
|
||||
PROG_MISMATCH=2,
|
||||
PROC_UNAVAIL=3,
|
||||
GARBAGE_ARGS=4,
|
||||
SYSTEM_ERR=5
|
||||
};
|
||||
|
||||
enum reject_stat {
|
||||
RPC_MISMATCH=0,
|
||||
AUTH_ERROR=1
|
||||
};
|
||||
|
||||
/*
|
||||
* Reply part of an rpc exchange
|
||||
*/
|
||||
|
||||
/*
|
||||
* Reply to an rpc request that was accepted by the server.
|
||||
* Note: there could be an error even though the request was
|
||||
* accepted.
|
||||
*/
|
||||
struct accepted_reply {
|
||||
struct opaque_auth ar_verf;
|
||||
int ar_stat;
|
||||
union {
|
||||
struct {
|
||||
unsigned long low;
|
||||
unsigned long high;
|
||||
} AR_versions;
|
||||
struct {
|
||||
char* where;
|
||||
xdrproc_t proc;
|
||||
} AR_results;
|
||||
/* and many other null cases */
|
||||
} ru;
|
||||
#define ar_results ru.AR_results
|
||||
#define ar_vers ru.AR_versions
|
||||
};
|
||||
|
||||
/*
|
||||
* Reply to an rpc request that was rejected by the server.
|
||||
*/
|
||||
struct rejected_reply {
|
||||
int rj_stat;
|
||||
union {
|
||||
struct {
|
||||
unsigned long low;
|
||||
unsigned long high;
|
||||
} RJ_versions;
|
||||
int RJ_why; /* why authentication did not work */
|
||||
} ru;
|
||||
#define rj_vers ru.RJ_versions
|
||||
#define rj_why ru.RJ_why
|
||||
};
|
||||
|
||||
/*
|
||||
* Body of a reply to an rpc request.
|
||||
*/
|
||||
struct reply_body {
|
||||
int rp_stat;
|
||||
union {
|
||||
struct accepted_reply RP_ar;
|
||||
struct rejected_reply RP_dr;
|
||||
} ru;
|
||||
#define rp_acpt ru.RP_ar
|
||||
#define rp_rjct ru.RP_dr
|
||||
};
|
||||
|
||||
/*
|
||||
* Body of an rpc request call.
|
||||
*/
|
||||
struct call_body {
|
||||
unsigned long cb_rpcvers; /* must be equal to two */
|
||||
unsigned long cb_prog;
|
||||
unsigned long cb_vers;
|
||||
unsigned long cb_proc;
|
||||
struct opaque_auth cb_cred;
|
||||
struct opaque_auth cb_verf; /* protocol specific - provided by client */
|
||||
};
|
||||
|
||||
/*
|
||||
* The rpc message
|
||||
*/
|
||||
struct rpc_msg {
|
||||
unsigned long rm_xid;
|
||||
int rm_direction;
|
||||
union {
|
||||
struct call_body RM_cmb;
|
||||
struct reply_body RM_rmb;
|
||||
} ru;
|
||||
#define rm_call ru.RM_cmb
|
||||
#define rm_reply ru.RM_rmb
|
||||
};
|
||||
#define acpted_rply ru.RM_rmb.ru.RP_ar
|
||||
#define rjcted_rply ru.RM_rmb.ru.RP_dr
|
||||
|
||||
|
||||
/*
|
||||
* XDR routine to handle a rpc message.
|
||||
* xdr_callmsg(xdrs, cmsg)
|
||||
* XDR *xdrs;
|
||||
* struct rpc_msg *cmsg;
|
||||
*/
|
||||
extern bool_t xdr_callmsg (XDR *__xdrs, struct rpc_msg *__cmsg);
|
||||
|
||||
/*
|
||||
* XDR routine to pre-serialize the static part of a rpc message.
|
||||
* xdr_callhdr(xdrs, cmsg)
|
||||
* XDR *xdrs;
|
||||
* struct rpc_msg *cmsg;
|
||||
*/
|
||||
extern bool_t xdr_callhdr (XDR *__xdrs, struct rpc_msg *__cmsg);
|
||||
|
||||
/*
|
||||
* XDR routine to handle a rpc reply.
|
||||
* xdr_replymsg(xdrs, rmsg)
|
||||
* XDR *xdrs;
|
||||
* struct rpc_msg *rmsg;
|
||||
*/
|
||||
extern bool_t xdr_replymsg (XDR *__xdrs, struct rpc_msg *__rmsg);
|
||||
|
||||
/*
|
||||
* Fills in the error part of a reply message.
|
||||
* _seterr_reply(msg, error)
|
||||
* struct rpc_msg *msg;
|
||||
* struct rpc_err *error;
|
||||
*/
|
||||
extern void _seterr_reply (struct rpc_msg *__msg, struct rpc_err *__error);
|
||||
|
||||
#endif /* rpc/rpc_msg.h */
|
||||
@@ -0,0 +1,267 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
/* @(#)rpc_prot.c 2.3 88/08/07 4.0 RPCSRC */
|
||||
/*
|
||||
* Sun RPC is a product of Sun Microsystems, Inc. and is provided for
|
||||
* unrestricted use provided that this legend is included on all tape
|
||||
* media and as a part of the software program in whole or part. Users
|
||||
* may copy or modify Sun RPC without charge, but are not authorized
|
||||
* to license or distribute it to anyone else except as part of a product or
|
||||
* program developed by the user.
|
||||
*
|
||||
* SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
|
||||
* WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
|
||||
*
|
||||
* Sun RPC is provided with no support and without any obligation on the
|
||||
* part of Sun Microsystems, Inc. to assist in its use, correction,
|
||||
* modification or enhancement.
|
||||
*
|
||||
* SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
|
||||
* INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
|
||||
* OR ANY PART THEREOF.
|
||||
*
|
||||
* In no event will Sun Microsystems, Inc. be liable for any lost revenue
|
||||
* or profits or other special, indirect and consequential damages, even if
|
||||
* Sun has been advised of the possibility of such damages.
|
||||
*
|
||||
* Sun Microsystems, Inc.
|
||||
* 2550 Garcia Avenue
|
||||
* Mountain View, California 94043
|
||||
*/
|
||||
#if !defined(lint) && defined(SCCSIDS)
|
||||
static char sccsid[] = "@(#)rpc_prot.c 1.36 87/08/11 Copyr 1984 Sun Micro";
|
||||
#endif
|
||||
|
||||
/*
|
||||
* rpc_prot.c
|
||||
*
|
||||
* Copyright (C) 1984, Sun Microsystems, Inc.
|
||||
*
|
||||
* This set of routines implements the rpc message definition,
|
||||
* its serializer and some common rpc utility routines.
|
||||
* The routines are meant for various implementations of rpc -
|
||||
* they are NOT for the rpc client or rpc service implementations!
|
||||
* Because authentication stuff is easy and is part of rpc, the opaque
|
||||
* routines are also in this program.
|
||||
*/
|
||||
|
||||
#include <rpc/rpc.h>
|
||||
|
||||
/* * * * * * * * * * * * * * XDR Authentication * * * * * * * * * * * */
|
||||
|
||||
/*
|
||||
* XDR an opaque authentication struct
|
||||
* (see auth.h)
|
||||
*/
|
||||
bool_t xdr_opaque_auth(XDR *xdrs, struct opaque_auth *ap)
|
||||
{
|
||||
|
||||
if (xdr_enum(xdrs, &(ap->oa_flavor)))
|
||||
return (xdr_bytes(xdrs, &ap->oa_base,
|
||||
&ap->oa_length, MAX_AUTH_BYTES));
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
/*
|
||||
* XDR a DES block
|
||||
*/
|
||||
bool_t xdr_des_block(XDR *xdrs, des_block *blkp)
|
||||
{
|
||||
return (xdr_opaque(xdrs, (char*) blkp, sizeof(des_block)));
|
||||
}
|
||||
|
||||
/* * * * * * * * * * * * * * XDR RPC MESSAGE * * * * * * * * * * * * * * * */
|
||||
|
||||
/*
|
||||
* XDR the MSG_ACCEPTED part of a reply message union
|
||||
*/
|
||||
static bool_t xdr_accepted_reply(XDR *xdrs, struct accepted_reply *ar)
|
||||
{
|
||||
|
||||
/* personalized union, rather than calling xdr_union */
|
||||
if (!xdr_opaque_auth(xdrs, &(ar->ar_verf)))
|
||||
return (FALSE);
|
||||
if (!xdr_enum(xdrs, (enum_t *) & (ar->ar_stat)))
|
||||
return (FALSE);
|
||||
switch (ar->ar_stat) {
|
||||
|
||||
case SUCCESS:
|
||||
return ((*(ar->ar_results.proc)) (xdrs, ar->ar_results.where));
|
||||
|
||||
case PROG_MISMATCH:
|
||||
if (!xdr_u_long(xdrs, &(ar->ar_vers.low)))
|
||||
return (FALSE);
|
||||
return (xdr_u_long(xdrs, &(ar->ar_vers.high)));
|
||||
}
|
||||
return (TRUE); /* TRUE => open ended set of problems */
|
||||
}
|
||||
|
||||
/*
|
||||
* XDR the MSG_DENIED part of a reply message union
|
||||
*/
|
||||
static bool_t xdr_rejected_reply(XDR *xdrs, struct rejected_reply *rr)
|
||||
{
|
||||
|
||||
/* personalized union, rather than calling xdr_union */
|
||||
if (!xdr_enum(xdrs, (enum_t *) & (rr->rj_stat)))
|
||||
return (FALSE);
|
||||
switch (rr->rj_stat) {
|
||||
|
||||
case RPC_MISMATCH:
|
||||
if (!xdr_u_long(xdrs, &(rr->rj_vers.low)))
|
||||
return (FALSE);
|
||||
return (xdr_u_long(xdrs, &(rr->rj_vers.high)));
|
||||
|
||||
case AUTH_ERROR:
|
||||
return (xdr_enum(xdrs, (enum_t *) & (rr->rj_why)));
|
||||
}
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
static struct xdr_discrim reply_dscrm[3] = {
|
||||
{(int) MSG_ACCEPTED, (xdrproc_t)xdr_accepted_reply},
|
||||
{(int) MSG_DENIED, (xdrproc_t)xdr_rejected_reply},
|
||||
{__dontcare__, NULL_xdrproc_t}
|
||||
};
|
||||
|
||||
/*
|
||||
* XDR a reply message
|
||||
*/
|
||||
bool_t xdr_replymsg(XDR *xdrs, struct rpc_msg *rmsg)
|
||||
{
|
||||
if (xdr_u_long(xdrs, &(rmsg->rm_xid)) &&
|
||||
xdr_enum(xdrs, (enum_t *) & (rmsg->rm_direction)) &&
|
||||
(rmsg->rm_direction == REPLY))
|
||||
return (xdr_union(xdrs, (enum_t *) & (rmsg->rm_reply.rp_stat),
|
||||
(char*) & (rmsg->rm_reply.ru), reply_dscrm,
|
||||
NULL_xdrproc_t));
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Serializes the "static part" of a call message header.
|
||||
* The fields include: rm_xid, rm_direction, rpcvers, prog, and vers.
|
||||
* The rm_xid is not really static, but the user can easily munge on the fly.
|
||||
*/
|
||||
bool_t xdr_callhdr(XDR *xdrs, struct rpc_msg *cmsg)
|
||||
{
|
||||
|
||||
cmsg->rm_direction = CALL;
|
||||
cmsg->rm_call.cb_rpcvers = RPC_MSG_VERSION;
|
||||
if (
|
||||
(xdrs->x_op == XDR_ENCODE) &&
|
||||
xdr_u_long(xdrs, &(cmsg->rm_xid)) &&
|
||||
xdr_enum(xdrs, (enum_t *) & (cmsg->rm_direction)) &&
|
||||
xdr_u_long(xdrs, &(cmsg->rm_call.cb_rpcvers)) &&
|
||||
xdr_u_long(xdrs, &(cmsg->rm_call.cb_prog)))
|
||||
return (xdr_u_long(xdrs, &(cmsg->rm_call.cb_vers)));
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
/* ************************** Client utility routine ************* */
|
||||
|
||||
static void accepted(enum accept_stat acpt_stat, struct rpc_err *error)
|
||||
{
|
||||
|
||||
switch (acpt_stat) {
|
||||
|
||||
case PROG_UNAVAIL:
|
||||
error->re_status = RPC_PROGUNAVAIL;
|
||||
return;
|
||||
|
||||
case PROG_MISMATCH:
|
||||
error->re_status = RPC_PROGVERSMISMATCH;
|
||||
return;
|
||||
|
||||
case PROC_UNAVAIL:
|
||||
error->re_status = RPC_PROCUNAVAIL;
|
||||
return;
|
||||
|
||||
case GARBAGE_ARGS:
|
||||
error->re_status = RPC_CANTDECODEARGS;
|
||||
return;
|
||||
|
||||
case SYSTEM_ERR:
|
||||
error->re_status = RPC_SYSTEMERROR;
|
||||
return;
|
||||
|
||||
case SUCCESS:
|
||||
error->re_status = RPC_SUCCESS;
|
||||
return;
|
||||
}
|
||||
/* something's wrong, but we don't know what ... */
|
||||
error->re_status = RPC_FAILED;
|
||||
error->re_lb.s1 = (long) MSG_ACCEPTED;
|
||||
error->re_lb.s2 = (long) acpt_stat;
|
||||
}
|
||||
|
||||
static void rejected(enum reject_stat rjct_stat, struct rpc_err *error)
|
||||
{
|
||||
|
||||
switch (rjct_stat) {
|
||||
|
||||
case RPC_VERSMISMATCH:
|
||||
error->re_status = RPC_VERSMISMATCH;
|
||||
return;
|
||||
|
||||
case AUTH_ERROR:
|
||||
error->re_status = RPC_AUTHERROR;
|
||||
return;
|
||||
}
|
||||
/* something's wrong, but we don't know what ... */
|
||||
error->re_status = RPC_FAILED;
|
||||
error->re_lb.s1 = (long) MSG_DENIED;
|
||||
error->re_lb.s2 = (long) rjct_stat;
|
||||
}
|
||||
|
||||
/*
|
||||
* given a reply message, fills in the error
|
||||
*/
|
||||
void _seterr_reply(struct rpc_msg *msg, struct rpc_err *error)
|
||||
{
|
||||
|
||||
/* optimized for normal, SUCCESSful case */
|
||||
switch (msg->rm_reply.rp_stat) {
|
||||
|
||||
case MSG_ACCEPTED:
|
||||
if (msg->acpted_rply.ar_stat == SUCCESS) {
|
||||
error->re_status = RPC_SUCCESS;
|
||||
return;
|
||||
};
|
||||
accepted((enum accept_stat)msg->acpted_rply.ar_stat, error);
|
||||
break;
|
||||
|
||||
case MSG_DENIED:
|
||||
rejected((enum reject_stat)msg->rjcted_rply.rj_stat, error);
|
||||
break;
|
||||
|
||||
default:
|
||||
error->re_status = RPC_FAILED;
|
||||
error->re_lb.s1 = (long) (msg->rm_reply.rp_stat);
|
||||
break;
|
||||
}
|
||||
switch (error->re_status) {
|
||||
|
||||
case RPC_VERSMISMATCH:
|
||||
error->re_vers.low = msg->rjcted_rply.rj_vers.low;
|
||||
error->re_vers.high = msg->rjcted_rply.rj_vers.high;
|
||||
break;
|
||||
|
||||
case RPC_AUTHERROR:
|
||||
error->re_why = msg->rjcted_rply.rj_why;
|
||||
break;
|
||||
|
||||
case RPC_PROGVERSMISMATCH:
|
||||
error->re_vers.low = msg->acpted_rply.ar_vers.low;
|
||||
error->re_vers.high = msg->acpted_rply.ar_vers.high;
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,79 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
/*
|
||||
* Sun RPC is a product of Sun Microsystems, Inc. and is provided for
|
||||
* unrestricted use provided that this legend is included on all tape
|
||||
* media and as a part of the software program in whole or part. Users
|
||||
* may copy or modify Sun RPC without charge, but are not authorized
|
||||
* to license or distribute it to anyone else except as part of a product or
|
||||
* program developed by the user.
|
||||
*
|
||||
* SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
|
||||
* WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
|
||||
*
|
||||
* Sun RPC is provided with no support and without any obligation on the
|
||||
* part of Sun Microsystems, Inc. to assist in its use, correction,
|
||||
* modification or enhancement.
|
||||
*
|
||||
* SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
|
||||
* INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
|
||||
* OR ANY PART THEREOF.
|
||||
*
|
||||
* In no event will Sun Microsystems, Inc. be liable for any lost revenue
|
||||
* or profits or other special, indirect and consequential damages, even if
|
||||
* Sun has been advised of the possibility of such damages.
|
||||
*
|
||||
* Sun Microsystems, Inc.
|
||||
* 2550 Garcia Avenue
|
||||
* Mountain View, California 94043
|
||||
*/
|
||||
/* fixincludes should not add extern "C" to this file */
|
||||
/*
|
||||
* Rpc additions to <sys/types.h>
|
||||
*/
|
||||
#ifndef _RPC_TYPES_H
|
||||
#define _RPC_TYPES_H 1
|
||||
|
||||
#include <rtthread.h>
|
||||
#include <lwip/netdb.h>
|
||||
#include <lwip/sockets.h>
|
||||
|
||||
#include <string.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
typedef long long int64_t;
|
||||
typedef unsigned long long uint64_t;
|
||||
|
||||
typedef int bool_t;
|
||||
typedef int enum_t;
|
||||
|
||||
/* This needs to be changed to uint32_t in the future */
|
||||
typedef unsigned long rpcprog_t;
|
||||
typedef unsigned long rpcvers_t;
|
||||
typedef unsigned long rpcproc_t;
|
||||
typedef unsigned long rpcprot_t;
|
||||
typedef unsigned long rpcport_t;
|
||||
|
||||
#define __dontcare__ -1
|
||||
|
||||
#ifndef FALSE
|
||||
# define FALSE (0)
|
||||
#endif
|
||||
|
||||
#ifndef TRUE
|
||||
# define TRUE (1)
|
||||
#endif
|
||||
|
||||
#ifndef MAXHOSTNAMELEN
|
||||
#define MAXHOSTNAMELEN 64
|
||||
#endif
|
||||
|
||||
#endif /* rpc/types.h */
|
||||
@@ -0,0 +1,774 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
/* @(#)xdr.c 2.1 88/07/29 4.0 RPCSRC */
|
||||
/*
|
||||
* Sun RPC is a product of Sun Microsystems, Inc. and is provided for
|
||||
* unrestricted use provided that this legend is included on all tape
|
||||
* media and as a part of the software program in whole or part. Users
|
||||
* may copy or modify Sun RPC without charge, but are not authorized
|
||||
* to license or distribute it to anyone else except as part of a product or
|
||||
* program developed by the user.
|
||||
*
|
||||
* SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
|
||||
* WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
|
||||
*
|
||||
* Sun RPC is provided with no support and without any obligation on the
|
||||
* part of Sun Microsystems, Inc. to assist in its use, correction,
|
||||
* modification or enhancement.
|
||||
*
|
||||
* SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
|
||||
* INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
|
||||
* OR ANY PART THEREOF.
|
||||
*
|
||||
* In no event will Sun Microsystems, Inc. be liable for any lost revenue
|
||||
* or profits or other special, indirect and consequential damages, even if
|
||||
* Sun has been advised of the possibility of such damages.
|
||||
*
|
||||
* Sun Microsystems, Inc.
|
||||
* 2550 Garcia Avenue
|
||||
* Mountain View, California 94043
|
||||
*/
|
||||
#if !defined(lint) && defined(SCCSIDS)
|
||||
static char sccsid[] = "@(#)xdr.c 1.35 87/08/12";
|
||||
#endif
|
||||
|
||||
/*
|
||||
* xdr.c, Generic XDR routines implementation.
|
||||
*
|
||||
* Copyright (C) 1986, Sun Microsystems, Inc.
|
||||
*
|
||||
* These are the "generic" xdr routines used to serialize and de-serialize
|
||||
* most common data items. See xdr.h for more info on the interface to
|
||||
* xdr.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <rpc/types.h>
|
||||
#include <rpc/xdr.h>
|
||||
#include <string.h>
|
||||
|
||||
/*
|
||||
* constants specific to the xdr "protocol"
|
||||
*/
|
||||
#define XDR_FALSE ((long) 0)
|
||||
#define XDR_TRUE ((long) 1)
|
||||
#define LASTUNSIGNED ((unsigned int) 0-1)
|
||||
|
||||
/*
|
||||
* for unit alignment
|
||||
*/
|
||||
static char xdr_zero[BYTES_PER_XDR_UNIT] = { 0, 0, 0, 0 };
|
||||
|
||||
/*
|
||||
* Free a data structure using XDR
|
||||
* Not a filter, but a convenient utility nonetheless
|
||||
*/
|
||||
void xdr_free(xdrproc_t proc, char* objp)
|
||||
{
|
||||
XDR x;
|
||||
|
||||
x.x_op = XDR_FREE;
|
||||
(*proc) (&x, objp);
|
||||
}
|
||||
|
||||
/*
|
||||
* XDR nothing
|
||||
*/
|
||||
bool_t xdr_void( /* xdrs, addr */ )
|
||||
/* XDR *xdrs; */
|
||||
/* char* addr; */
|
||||
{
|
||||
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
/*
|
||||
* XDR integers
|
||||
*/
|
||||
bool_t xdr_int(XDR* xdrs, int* ip)
|
||||
{
|
||||
if (sizeof(int) == sizeof(long)) {
|
||||
return (xdr_long(xdrs, (long *) ip));
|
||||
} else if (sizeof(int) < sizeof(long)) {
|
||||
long l;
|
||||
switch (xdrs->x_op) {
|
||||
case XDR_ENCODE:
|
||||
l = (long) *ip;
|
||||
return XDR_PUTLONG(xdrs, &l);
|
||||
case XDR_DECODE:
|
||||
if (!XDR_GETLONG(xdrs, &l))
|
||||
return FALSE;
|
||||
*ip = (int) l;
|
||||
case XDR_FREE:
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
} else {
|
||||
return (xdr_short(xdrs, (short *) ip));
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* XDR unsigned integers
|
||||
*/
|
||||
bool_t xdr_u_int(XDR* xdrs, unsigned int* up)
|
||||
{
|
||||
if (sizeof(unsigned int) == sizeof(unsigned long)) {
|
||||
return (xdr_u_long(xdrs, (unsigned long *) up));
|
||||
} else if (sizeof(unsigned int) < sizeof(unsigned long)) {
|
||||
unsigned long l;
|
||||
switch (xdrs->x_op) {
|
||||
case XDR_ENCODE:
|
||||
l = (unsigned long) *up;
|
||||
return XDR_PUTLONG(xdrs, (long*)&l);
|
||||
case XDR_DECODE:
|
||||
if (!XDR_GETLONG(xdrs, (long*)&l))
|
||||
return FALSE;
|
||||
*up = (unsigned int) l;
|
||||
case XDR_FREE:
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
} else {
|
||||
return (xdr_short(xdrs, (short *) up));
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* XDR long integers
|
||||
* same as xdr_u_long - open coded to save a proc call!
|
||||
*/
|
||||
bool_t xdr_long(XDR* xdrs, long* lp)
|
||||
{
|
||||
|
||||
if (xdrs->x_op == XDR_ENCODE
|
||||
&& (sizeof(int32_t) == sizeof(long)
|
||||
|| (int32_t) *lp == *lp))
|
||||
return (XDR_PUTLONG(xdrs, lp));
|
||||
|
||||
if (xdrs->x_op == XDR_DECODE)
|
||||
return (XDR_GETLONG(xdrs, lp));
|
||||
|
||||
if (xdrs->x_op == XDR_FREE)
|
||||
return (TRUE);
|
||||
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
/*
|
||||
* XDR unsigned long integers
|
||||
* same as xdr_long - open coded to save a proc call!
|
||||
*/
|
||||
bool_t xdr_u_long(XDR* xdrs, unsigned long* ulp)
|
||||
{
|
||||
|
||||
if (xdrs->x_op == XDR_DECODE) {
|
||||
long l;
|
||||
if (XDR_GETLONG(xdrs, &l) == FALSE)
|
||||
return FALSE;
|
||||
*ulp = (uint32_t) l;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
if (xdrs->x_op == XDR_ENCODE) {
|
||||
if (sizeof(uint32_t) != sizeof(unsigned long)
|
||||
&& (uint32_t) *ulp != *ulp)
|
||||
return FALSE;
|
||||
|
||||
return (XDR_PUTLONG(xdrs, (long *) ulp));
|
||||
}
|
||||
|
||||
if (xdrs->x_op == XDR_FREE)
|
||||
return (TRUE);
|
||||
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* XDR long long integers
|
||||
*/
|
||||
bool_t xdr_longlong_t (XDR * xdrs, long long* llp)
|
||||
{
|
||||
int32_t t1, t2;
|
||||
|
||||
switch (xdrs->x_op)
|
||||
{
|
||||
case XDR_ENCODE:
|
||||
t1 = (int32_t) ((*llp) >> 32);
|
||||
t2 = (int32_t) (*llp);
|
||||
return (XDR_PUTLONG (xdrs, &t1) && XDR_PUTLONG (xdrs, &t2));
|
||||
|
||||
case XDR_DECODE:
|
||||
if (!XDR_GETLONG (xdrs, &t1) || !XDR_GETLONG (xdrs, &t2))
|
||||
return FALSE;
|
||||
*llp = ((int64_t) t1) << 32;
|
||||
*llp |= (uint32_t) t2;
|
||||
return TRUE;
|
||||
|
||||
case XDR_FREE:
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/*
|
||||
* XDR unsigned long long integers
|
||||
*/
|
||||
bool_t xdr_u_longlong_t (XDR * xdrs, unsigned long long* ullp)
|
||||
{
|
||||
uint32_t t1, t2;
|
||||
|
||||
switch (xdrs->x_op)
|
||||
{
|
||||
case XDR_ENCODE:
|
||||
t1 = (uint32_t) ((*ullp) >> 32);
|
||||
t2 = (uint32_t) (*ullp);
|
||||
return (XDR_PUTLONG (xdrs, (int32_t *)&t1) &&
|
||||
XDR_PUTLONG (xdrs, (int32_t *)&t2));
|
||||
|
||||
case XDR_DECODE:
|
||||
if (!XDR_GETLONG (xdrs, (int32_t *)&t1) ||
|
||||
!XDR_GETLONG (xdrs, (int32_t *)&t2))
|
||||
return FALSE;
|
||||
*ullp = ((uint64_t) t1) << 32;
|
||||
*ullp |= t2;
|
||||
return TRUE;
|
||||
|
||||
case XDR_FREE:
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
/*
|
||||
* XDR short integers
|
||||
*/
|
||||
bool_t xdr_short(XDR* xdrs, short* sp)
|
||||
{
|
||||
long l;
|
||||
|
||||
switch (xdrs->x_op) {
|
||||
|
||||
case XDR_ENCODE:
|
||||
l = (long) *sp;
|
||||
return (XDR_PUTLONG(xdrs, &l));
|
||||
|
||||
case XDR_DECODE:
|
||||
if (!XDR_GETLONG(xdrs, &l)) {
|
||||
return (FALSE);
|
||||
}
|
||||
*sp = (short) l;
|
||||
return (TRUE);
|
||||
|
||||
case XDR_FREE:
|
||||
return (TRUE);
|
||||
}
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
/*
|
||||
* XDR unsigned short integers
|
||||
*/
|
||||
bool_t xdr_u_short(XDR* xdrs, unsigned short* usp)
|
||||
{
|
||||
unsigned long l;
|
||||
|
||||
switch (xdrs->x_op) {
|
||||
|
||||
case XDR_ENCODE:
|
||||
l = (unsigned long) * usp;
|
||||
return (XDR_PUTLONG(xdrs, (long*)&l));
|
||||
|
||||
case XDR_DECODE:
|
||||
if (!XDR_GETLONG(xdrs, (long*)&l)) {
|
||||
return (FALSE);
|
||||
}
|
||||
*usp = (unsigned short) l;
|
||||
return (TRUE);
|
||||
|
||||
case XDR_FREE:
|
||||
return (TRUE);
|
||||
}
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* XDR a char
|
||||
*/
|
||||
bool_t xdr_char(XDR* xdrs, char* cp)
|
||||
{
|
||||
int i;
|
||||
|
||||
i = (*cp);
|
||||
if (!xdr_int(xdrs, &i)) {
|
||||
return (FALSE);
|
||||
}
|
||||
*cp = i;
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
/*
|
||||
* XDR an unsigned char
|
||||
*/
|
||||
bool_t xdr_u_char(XDR* xdrs, unsigned char* cp)
|
||||
{
|
||||
unsigned int u;
|
||||
|
||||
u = (*cp);
|
||||
if (!xdr_u_int(xdrs, &u)) {
|
||||
return (FALSE);
|
||||
}
|
||||
*cp = u;
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
/*
|
||||
* XDR booleans
|
||||
*/
|
||||
bool_t xdr_bool(XDR *xdrs, bool_t *bp)
|
||||
{
|
||||
long lb;
|
||||
|
||||
switch (xdrs->x_op) {
|
||||
|
||||
case XDR_ENCODE:
|
||||
lb = *bp ? XDR_TRUE : XDR_FALSE;
|
||||
return (XDR_PUTLONG(xdrs, &lb));
|
||||
|
||||
case XDR_DECODE:
|
||||
if (!XDR_GETLONG(xdrs, &lb)) {
|
||||
return (FALSE);
|
||||
}
|
||||
*bp = (lb == XDR_FALSE) ? FALSE : TRUE;
|
||||
return (TRUE);
|
||||
|
||||
case XDR_FREE:
|
||||
return (TRUE);
|
||||
}
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
/*
|
||||
* XDR enumerations
|
||||
*/
|
||||
bool_t xdr_enum(XDR *xdrs, enum_t *ep)
|
||||
{
|
||||
/*
|
||||
* enums are treated as ints
|
||||
*/
|
||||
return (xdr_long(xdrs, (long *) ep));
|
||||
}
|
||||
|
||||
/*
|
||||
* XDR opaque data
|
||||
* Allows the specification of a fixed size sequence of opaque bytes.
|
||||
* cp points to the opaque object and cnt gives the byte length.
|
||||
*/
|
||||
bool_t xdr_opaque(XDR *xdrs, char* cp, unsigned int cnt)
|
||||
{
|
||||
register unsigned int rndup;
|
||||
static char crud[BYTES_PER_XDR_UNIT];
|
||||
|
||||
/*
|
||||
* if no data we are done
|
||||
*/
|
||||
if (cnt == 0)
|
||||
return (TRUE);
|
||||
|
||||
/*
|
||||
* round byte count to full xdr units
|
||||
*/
|
||||
rndup = cnt % BYTES_PER_XDR_UNIT;
|
||||
if (rndup > 0)
|
||||
rndup = BYTES_PER_XDR_UNIT - rndup;
|
||||
|
||||
if (xdrs->x_op == XDR_DECODE) {
|
||||
if (!XDR_GETBYTES(xdrs, cp, cnt)) {
|
||||
return (FALSE);
|
||||
}
|
||||
if (rndup == 0)
|
||||
return (TRUE);
|
||||
return (XDR_GETBYTES(xdrs, crud, rndup));
|
||||
}
|
||||
|
||||
if (xdrs->x_op == XDR_ENCODE) {
|
||||
if (!XDR_PUTBYTES(xdrs, cp, cnt)) {
|
||||
return (FALSE);
|
||||
}
|
||||
if (rndup == 0)
|
||||
return (TRUE);
|
||||
return (XDR_PUTBYTES(xdrs, xdr_zero, rndup));
|
||||
}
|
||||
|
||||
if (xdrs->x_op == XDR_FREE) {
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
/*
|
||||
* XDR counted bytes
|
||||
* *cpp is a pointer to the bytes, *sizep is the count.
|
||||
* If *cpp is NULL maxsize bytes are allocated
|
||||
*/
|
||||
bool_t xdr_bytes(XDR *xdrs, char** cpp, unsigned int *sizep, unsigned int maxsize)
|
||||
{
|
||||
register char *sp = *cpp; /* sp is the actual string pointer */
|
||||
register unsigned int nodesize;
|
||||
|
||||
/*
|
||||
* first deal with the length since xdr bytes are counted
|
||||
*/
|
||||
if (!xdr_u_int(xdrs, sizep)) {
|
||||
return (FALSE);
|
||||
}
|
||||
nodesize = *sizep;
|
||||
if ((nodesize > maxsize) && (xdrs->x_op != XDR_FREE)) {
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
/*
|
||||
* now deal with the actual bytes
|
||||
*/
|
||||
switch (xdrs->x_op) {
|
||||
|
||||
case XDR_DECODE:
|
||||
if (nodesize == 0) {
|
||||
return (TRUE);
|
||||
}
|
||||
if (sp == NULL) {
|
||||
*cpp = sp = (char *) rt_malloc(nodesize);
|
||||
}
|
||||
if (sp == NULL) {
|
||||
rt_kprintf("xdr_bytes: out of memory\n");
|
||||
return (FALSE);
|
||||
}
|
||||
/* fall into ... */
|
||||
|
||||
case XDR_ENCODE:
|
||||
return (xdr_opaque(xdrs, sp, nodesize));
|
||||
|
||||
case XDR_FREE:
|
||||
if (sp != NULL) {
|
||||
rt_free(sp);
|
||||
*cpp = NULL;
|
||||
}
|
||||
return (TRUE);
|
||||
}
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
/*
|
||||
* Implemented here due to commonality of the object.
|
||||
*/
|
||||
bool_t xdr_netobj(XDR *xdrs, struct netobj *np)
|
||||
{
|
||||
return (xdr_bytes(xdrs, &np->n_bytes, &np->n_len, MAX_NETOBJ_SZ));
|
||||
}
|
||||
|
||||
/*
|
||||
* XDR a descriminated union
|
||||
* Support routine for discriminated unions.
|
||||
* You create an array of xdrdiscrim structures, terminated with
|
||||
* an entry with a null procedure pointer. The routine gets
|
||||
* the discriminant value and then searches the array of xdrdiscrims
|
||||
* looking for that value. It calls the procedure given in the xdrdiscrim
|
||||
* to handle the discriminant. If there is no specific routine a default
|
||||
* routine may be called.
|
||||
* If there is no specific or default routine an error is returned.
|
||||
*/
|
||||
bool_t xdr_union(XDR* xdrs, enum_t* dscmp, char* unp, const struct xdr_discrim* choices, xdrproc_t dfault)
|
||||
{
|
||||
register enum_t dscm;
|
||||
|
||||
/*
|
||||
* we deal with the discriminator; it's an enum
|
||||
*/
|
||||
if (!xdr_enum(xdrs, dscmp)) {
|
||||
return (FALSE);
|
||||
}
|
||||
dscm = *dscmp;
|
||||
|
||||
/*
|
||||
* search choices for a value that matches the discriminator.
|
||||
* if we find one, execute the xdr routine for that value.
|
||||
*/
|
||||
for (; choices->proc != NULL_xdrproc_t; choices++) {
|
||||
if (choices->value == dscm)
|
||||
return ((*(choices->proc)) (xdrs, unp, LASTUNSIGNED));
|
||||
}
|
||||
|
||||
/*
|
||||
* no match - execute the default xdr routine if there is one
|
||||
*/
|
||||
return ((dfault == NULL_xdrproc_t) ? FALSE :
|
||||
(*dfault) (xdrs, unp, LASTUNSIGNED));
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* Non-portable xdr primitives.
|
||||
* Care should be taken when moving these routines to new architectures.
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* XDR null terminated ASCII strings
|
||||
* xdr_string deals with "C strings" - arrays of bytes that are
|
||||
* terminated by a NULL character. The parameter cpp references a
|
||||
* pointer to storage; If the pointer is null, then the necessary
|
||||
* storage is allocated. The last parameter is the max allowed length
|
||||
* of the string as specified by a protocol.
|
||||
*/
|
||||
bool_t xdr_string(XDR *xdrs, char **cpp, unsigned int maxsize)
|
||||
{
|
||||
register char *sp = *cpp; /* sp is the actual string pointer */
|
||||
unsigned int size;
|
||||
unsigned int nodesize;
|
||||
|
||||
/*
|
||||
* first deal with the length since xdr strings are counted-strings
|
||||
*/
|
||||
switch (xdrs->x_op) {
|
||||
case XDR_FREE:
|
||||
if (sp == NULL) {
|
||||
return (TRUE); /* already free */
|
||||
}
|
||||
/* fall through... */
|
||||
case XDR_ENCODE:
|
||||
size = strlen(sp);
|
||||
break;
|
||||
}
|
||||
if (!xdr_u_int(xdrs, &size)) {
|
||||
return (FALSE);
|
||||
}
|
||||
if (size > maxsize) {
|
||||
return (FALSE);
|
||||
}
|
||||
nodesize = size + 1;
|
||||
|
||||
/*
|
||||
* now deal with the actual bytes
|
||||
*/
|
||||
switch (xdrs->x_op) {
|
||||
|
||||
case XDR_DECODE:
|
||||
if (nodesize == 0) {
|
||||
return (TRUE);
|
||||
}
|
||||
if (sp == NULL)
|
||||
*cpp = sp = (char *) rt_malloc(nodesize);
|
||||
if (sp == NULL) {
|
||||
rt_kprintf("xdr_string: out of memory\n");
|
||||
return (FALSE);
|
||||
}
|
||||
sp[size] = 0;
|
||||
/* fall into ... */
|
||||
|
||||
case XDR_ENCODE:
|
||||
return (xdr_opaque(xdrs, sp, size));
|
||||
|
||||
case XDR_FREE:
|
||||
rt_free(sp);
|
||||
*cpp = NULL;
|
||||
return (TRUE);
|
||||
}
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
/*
|
||||
* Wrapper for xdr_string that can be called directly from
|
||||
* routines like clnt_call
|
||||
*/
|
||||
bool_t xdr_wrapstring(XDR *xdrs, char **cpp)
|
||||
{
|
||||
if (xdr_string(xdrs, cpp, LASTUNSIGNED)) {
|
||||
return (TRUE);
|
||||
}
|
||||
return (FALSE);
|
||||
}
|
||||
|
||||
/*
|
||||
* XDR an array of arbitrary elements
|
||||
* *addrp is a pointer to the array, *sizep is the number of elements.
|
||||
* If addrp is NULL (*sizep * elsize) bytes are allocated.
|
||||
* elsize is the size (in bytes) of each element, and elproc is the
|
||||
* xdr procedure to call to handle each element of the array.
|
||||
*/
|
||||
bool_t xdr_array(XDR *xdrs, char **addrp, unsigned int *sizep, unsigned int maxsize, unsigned int elsize, xdrproc_t elproc)
|
||||
{
|
||||
register unsigned int i;
|
||||
register char* target = *addrp;
|
||||
register unsigned int c; /* the actual element count */
|
||||
register bool_t stat = TRUE;
|
||||
register unsigned int nodesize;
|
||||
|
||||
/* like strings, arrays are really counted arrays */
|
||||
if (!xdr_u_int(xdrs, sizep)) {
|
||||
return (FALSE);
|
||||
}
|
||||
c = *sizep;
|
||||
if ((c > maxsize) && (xdrs->x_op != XDR_FREE)) {
|
||||
return (FALSE);
|
||||
}
|
||||
/* duh, look for integer overflow (fefe) */
|
||||
{
|
||||
unsigned int i;
|
||||
nodesize = 0;
|
||||
for (i=c; i; --i) {
|
||||
unsigned int tmp=nodesize+elsize;
|
||||
if (tmp<nodesize) /* overflow */
|
||||
return FALSE;
|
||||
nodesize=tmp;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* if we are deserializing, we may need to allocate an array.
|
||||
* We also save time by checking for a null array if we are freeing.
|
||||
*/
|
||||
if (target == NULL)
|
||||
switch (xdrs->x_op) {
|
||||
case XDR_DECODE:
|
||||
if (c == 0)
|
||||
return (TRUE);
|
||||
*addrp = target = rt_malloc(nodesize);
|
||||
if (target == NULL) {
|
||||
rt_kprintf("xdr_array: out of memory\n");
|
||||
return (FALSE);
|
||||
}
|
||||
memset(target, 0, nodesize);
|
||||
break;
|
||||
|
||||
case XDR_FREE:
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
/*
|
||||
* now we xdr each element of array
|
||||
*/
|
||||
for (i = 0; (i < c) && stat; i++) {
|
||||
stat = (*elproc) (xdrs, target, LASTUNSIGNED);
|
||||
target += elsize;
|
||||
}
|
||||
|
||||
/*
|
||||
* the array may need freeing
|
||||
*/
|
||||
if (xdrs->x_op == XDR_FREE) {
|
||||
rt_free(*addrp);
|
||||
*addrp = NULL;
|
||||
}
|
||||
return (stat);
|
||||
}
|
||||
|
||||
/*
|
||||
* xdr_vector():
|
||||
*
|
||||
* XDR a fixed length array. Unlike variable-length arrays,
|
||||
* the storage of fixed length arrays is static and unfreeable.
|
||||
* > basep: base of the array
|
||||
* > size: size of the array
|
||||
* > elemsize: size of each element
|
||||
* > xdr_elem: routine to XDR each element
|
||||
*/
|
||||
bool_t xdr_vector(XDR *xdrs, char *basep, unsigned int nelem, unsigned int elemsize, xdrproc_t xdr_elem)
|
||||
{
|
||||
register unsigned int i;
|
||||
register char *elptr;
|
||||
|
||||
elptr = basep;
|
||||
for (i = 0; i < nelem; i++) {
|
||||
if (!(*xdr_elem) (xdrs, elptr, LASTUNSIGNED)) {
|
||||
return (FALSE);
|
||||
}
|
||||
elptr += elemsize;
|
||||
}
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* XDR an indirect pointer
|
||||
* xdr_reference is for recursively translating a structure that is
|
||||
* referenced by a pointer inside the structure that is currently being
|
||||
* translated. pp references a pointer to storage. If *pp is null
|
||||
* the necessary storage is allocated.
|
||||
* size is the sizeof the referneced structure.
|
||||
* proc is the routine to handle the referenced structure.
|
||||
*/
|
||||
bool_t xdr_reference(XDR *xdrs, char **pp, unsigned int size, xdrproc_t proc)
|
||||
{
|
||||
register char* loc = *pp;
|
||||
register bool_t stat;
|
||||
|
||||
if (loc == NULL)
|
||||
switch (xdrs->x_op) {
|
||||
case XDR_FREE:
|
||||
return (TRUE);
|
||||
|
||||
case XDR_DECODE:
|
||||
*pp = loc = (char*) rt_malloc(size);
|
||||
if (loc == NULL) {
|
||||
rt_kprintf("xdr_reference: out of memory\n");
|
||||
return (FALSE);
|
||||
}
|
||||
memset(loc, 0, (int) size);
|
||||
break;
|
||||
}
|
||||
|
||||
stat = (*proc) (xdrs, loc, LASTUNSIGNED);
|
||||
|
||||
if (xdrs->x_op == XDR_FREE) {
|
||||
rt_free(loc);
|
||||
*pp = NULL;
|
||||
}
|
||||
return (stat);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* xdr_pointer():
|
||||
*
|
||||
* XDR a pointer to a possibly recursive data structure. This
|
||||
* differs with xdr_reference in that it can serialize/deserialiaze
|
||||
* trees correctly.
|
||||
*
|
||||
* What's sent is actually a union:
|
||||
*
|
||||
* union object_pointer switch (boolean b) {
|
||||
* case TRUE: object_data data;
|
||||
* case FALSE: void nothing;
|
||||
* }
|
||||
*
|
||||
* > objpp: Pointer to the pointer to the object.
|
||||
* > obj_size: size of the object.
|
||||
* > xdr_obj: routine to XDR an object.
|
||||
*
|
||||
*/
|
||||
bool_t xdr_pointer(XDR *xdrs, char **objpp, unsigned int obj_size, xdrproc_t xdr_obj)
|
||||
{
|
||||
|
||||
bool_t more_data;
|
||||
|
||||
more_data = (*objpp != NULL);
|
||||
if (!xdr_bool(xdrs, &more_data)) {
|
||||
return (FALSE);
|
||||
}
|
||||
if (!more_data) {
|
||||
*objpp = NULL;
|
||||
return (TRUE);
|
||||
}
|
||||
return (xdr_reference(xdrs, objpp, obj_size, xdr_obj));
|
||||
}
|
||||
@@ -0,0 +1,369 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
/*
|
||||
* Sun RPC is a product of Sun Microsystems, Inc. and is provided for
|
||||
* unrestricted use provided that this legend is included on all tape
|
||||
* media and as a part of the software program in whole or part. Users
|
||||
* may copy or modify Sun RPC without charge, but are not authorized
|
||||
* to license or distribute it to anyone else except as part of a product or
|
||||
* program developed by the user.
|
||||
*
|
||||
* SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
|
||||
* WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
|
||||
*
|
||||
* Sun RPC is provided with no support and without any obligation on the
|
||||
* part of Sun Microsystems, Inc. to assist in its use, correction,
|
||||
* modification or enhancement.
|
||||
*
|
||||
* SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
|
||||
* INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
|
||||
* OR ANY PART THEREOF.
|
||||
*
|
||||
* In no event will Sun Microsystems, Inc. be liable for any lost revenue
|
||||
* or profits or other special, indirect and consequential damages, even if
|
||||
* Sun has been advised of the possibility of such damages.
|
||||
*
|
||||
* Sun Microsystems, Inc.
|
||||
* 2550 Garcia Avenue
|
||||
* Mountain View, California 94043
|
||||
*/
|
||||
|
||||
/*
|
||||
* xdr.h, External Data Representation Serialization Routines.
|
||||
*
|
||||
* Copyright (C) 1984, Sun Microsystems, Inc.
|
||||
*/
|
||||
|
||||
#ifndef _RPC_XDR_H
|
||||
#define _RPC_XDR_H
|
||||
|
||||
#include <rpc/types.h>
|
||||
|
||||
/* We need FILE. */
|
||||
#include <stdio.h>
|
||||
|
||||
/*
|
||||
* XDR provides a conventional way for converting between C data
|
||||
* types and an external bit-string representation. Library supplied
|
||||
* routines provide for the conversion on built-in C data types. These
|
||||
* routines and utility routines defined here are used to help implement
|
||||
* a type encode/decode routine for each user-defined type.
|
||||
*
|
||||
* Each data type provides a single procedure which takes two arguments:
|
||||
*
|
||||
* bool_t
|
||||
* xdrproc(xdrs, argresp)
|
||||
* XDR *xdrs;
|
||||
* <type> *argresp;
|
||||
*
|
||||
* xdrs is an instance of a XDR handle, to which or from which the data
|
||||
* type is to be converted. argresp is a pointer to the structure to be
|
||||
* converted. The XDR handle contains an operation field which indicates
|
||||
* which of the operations (ENCODE, DECODE * or FREE) is to be performed.
|
||||
*
|
||||
* XDR_DECODE may allocate space if the pointer argresp is null. This
|
||||
* data can be freed with the XDR_FREE operation.
|
||||
*
|
||||
* We write only one procedure per data type to make it easy
|
||||
* to keep the encode and decode procedures for a data type consistent.
|
||||
* In many cases the same code performs all operations on a user defined type,
|
||||
* because all the hard work is done in the component type routines.
|
||||
* decode as a series of calls on the nested data types.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Xdr operations. XDR_ENCODE causes the type to be encoded into the
|
||||
* stream. XDR_DECODE causes the type to be extracted from the stream.
|
||||
* XDR_FREE can be used to release the space allocated by an XDR_DECODE
|
||||
* request.
|
||||
*/
|
||||
enum xdr_op {
|
||||
XDR_ENCODE = 0,
|
||||
XDR_DECODE = 1,
|
||||
XDR_FREE = 2
|
||||
};
|
||||
|
||||
/*
|
||||
* This is the number of bytes per unit of external data.
|
||||
*/
|
||||
#define BYTES_PER_XDR_UNIT (4)
|
||||
/*
|
||||
* This only works if the above is a power of 2. But it's defined to be
|
||||
* 4 by the appropriate RFCs. So it will work. And it's normally quicker
|
||||
* than the old routine.
|
||||
*/
|
||||
#define RNDUP(x) (((x) + BYTES_PER_XDR_UNIT - 1) & ~(BYTES_PER_XDR_UNIT - 1))
|
||||
|
||||
/*
|
||||
* The XDR handle.
|
||||
* Contains operation which is being applied to the stream,
|
||||
* an operations vector for the particular implementation (e.g. see xdr_mem.c),
|
||||
* and two private fields for the use of the particular implementation.
|
||||
*/
|
||||
typedef struct XDR XDR;
|
||||
struct XDR
|
||||
{
|
||||
enum xdr_op x_op; /* operation; fast additional param */
|
||||
struct xdr_ops
|
||||
{
|
||||
bool_t (*x_getlong) (XDR *__xdrs, long *__lp);
|
||||
/* get a long from underlying stream */
|
||||
bool_t (*x_putlong) (XDR *__xdrs, const long *__lp);
|
||||
/* put a long to " */
|
||||
bool_t (*x_getbytes) (XDR *__xdrs, char* __addr, unsigned int __len);
|
||||
/* get some bytes from " */
|
||||
bool_t (*x_putbytes) (XDR *__xdrs, const char *__addr, unsigned int __len);
|
||||
/* put some bytes to " */
|
||||
unsigned int (*x_getpostn) (const XDR *__xdrs);
|
||||
/* returns bytes off from beginning */
|
||||
bool_t (*x_setpostn) (XDR *__xdrs, unsigned int __pos);
|
||||
/* lets you reposition the stream */
|
||||
int32_t *(*x_inline) (XDR *__xdrs, unsigned int __len);
|
||||
/* buf quick ptr to buffered data */
|
||||
void (*x_destroy) (XDR *__xdrs);
|
||||
/* free privates of this xdr_stream */
|
||||
bool_t (*x_getint32) (XDR *__xdrs, int32_t *__ip);
|
||||
/* get a int from underlying stream */
|
||||
bool_t (*x_putint32) (XDR *__xdrs, const int32_t *__ip);
|
||||
/* put a int to " */
|
||||
}
|
||||
*x_ops;
|
||||
char* x_public; /* users' data */
|
||||
char* x_private; /* pointer to private data */
|
||||
char* x_base; /* private used for position info */
|
||||
unsigned int x_handy; /* extra private word */
|
||||
};
|
||||
|
||||
/*
|
||||
* A xdrproc_t exists for each data type which is to be encoded or decoded.
|
||||
*
|
||||
* The second argument to the xdrproc_t is a pointer to an opaque pointer.
|
||||
* The opaque pointer generally points to a structure of the data type
|
||||
* to be decoded. If this pointer is 0, then the type routines should
|
||||
* allocate dynamic storage of the appropriate size and return it.
|
||||
* bool_t (*xdrproc_t)(XDR *, char* *);
|
||||
*/
|
||||
typedef bool_t (*xdrproc_t) (XDR *, void *,...);
|
||||
|
||||
|
||||
/*
|
||||
* Operations defined on a XDR handle
|
||||
*
|
||||
* XDR *xdrs;
|
||||
* int32_t *int32p;
|
||||
* long *longp;
|
||||
* char* addr;
|
||||
* unsigned int len;
|
||||
* unsigned int pos;
|
||||
*/
|
||||
#define XDR_GETINT32(xdrs, int32p) \
|
||||
(*(xdrs)->x_ops->x_getint32)(xdrs, int32p)
|
||||
#define xdr_getint32(xdrs, int32p) \
|
||||
(*(xdrs)->x_ops->x_getint32)(xdrs, int32p)
|
||||
|
||||
#define XDR_PUTINT32(xdrs, int32p) \
|
||||
(*(xdrs)->x_ops->x_putint32)(xdrs, int32p)
|
||||
#define xdr_putint32(xdrs, int32p) \
|
||||
(*(xdrs)->x_ops->x_putint32)(xdrs, int32p)
|
||||
|
||||
#define XDR_GETLONG(xdrs, longp) \
|
||||
(*(xdrs)->x_ops->x_getlong)(xdrs, longp)
|
||||
#define xdr_getlong(xdrs, longp) \
|
||||
(*(xdrs)->x_ops->x_getlong)(xdrs, longp)
|
||||
|
||||
#define XDR_PUTLONG(xdrs, longp) \
|
||||
(*(xdrs)->x_ops->x_putlong)(xdrs, longp)
|
||||
#define xdr_putlong(xdrs, longp) \
|
||||
(*(xdrs)->x_ops->x_putlong)(xdrs, longp)
|
||||
|
||||
#define XDR_GETBYTES(xdrs, addr, len) \
|
||||
(*(xdrs)->x_ops->x_getbytes)(xdrs, addr, len)
|
||||
#define xdr_getbytes(xdrs, addr, len) \
|
||||
(*(xdrs)->x_ops->x_getbytes)(xdrs, addr, len)
|
||||
|
||||
#define XDR_PUTBYTES(xdrs, addr, len) \
|
||||
(*(xdrs)->x_ops->x_putbytes)(xdrs, addr, len)
|
||||
#define xdr_putbytes(xdrs, addr, len) \
|
||||
(*(xdrs)->x_ops->x_putbytes)(xdrs, addr, len)
|
||||
|
||||
#define XDR_GETPOS(xdrs) \
|
||||
(*(xdrs)->x_ops->x_getpostn)(xdrs)
|
||||
#define xdr_getpos(xdrs) \
|
||||
(*(xdrs)->x_ops->x_getpostn)(xdrs)
|
||||
|
||||
#define XDR_SETPOS(xdrs, pos) \
|
||||
(*(xdrs)->x_ops->x_setpostn)(xdrs, pos)
|
||||
#define xdr_setpos(xdrs, pos) \
|
||||
(*(xdrs)->x_ops->x_setpostn)(xdrs, pos)
|
||||
|
||||
#define XDR_INLINE(xdrs, len) \
|
||||
(*(xdrs)->x_ops->x_inline)(xdrs, len)
|
||||
#define xdr_inline(xdrs, len) \
|
||||
(*(xdrs)->x_ops->x_inline)(xdrs, len)
|
||||
|
||||
#define XDR_DESTROY(xdrs) \
|
||||
do { \
|
||||
if ((xdrs)->x_ops->x_destroy) \
|
||||
(*(xdrs)->x_ops->x_destroy)(xdrs); \
|
||||
} while (0)
|
||||
#define xdr_destroy(xdrs) \
|
||||
do { \
|
||||
if ((xdrs)->x_ops->x_destroy) \
|
||||
(*(xdrs)->x_ops->x_destroy)(xdrs); \
|
||||
} while (0)
|
||||
|
||||
/*
|
||||
* Support struct for discriminated unions.
|
||||
* You create an array of xdrdiscrim structures, terminated with
|
||||
* a entry with a null procedure pointer. The xdr_union routine gets
|
||||
* the discriminant value and then searches the array of structures
|
||||
* for a matching value. If a match is found the associated xdr routine
|
||||
* is called to handle that part of the union. If there is
|
||||
* no match, then a default routine may be called.
|
||||
* If there is no match and no default routine it is an error.
|
||||
*/
|
||||
#define NULL_xdrproc_t ((xdrproc_t)0)
|
||||
struct xdr_discrim
|
||||
{
|
||||
int value;
|
||||
xdrproc_t proc;
|
||||
};
|
||||
|
||||
/*
|
||||
* Inline routines for fast encode/decode of primitive data types.
|
||||
* Caveat emptor: these use single memory cycles to get the
|
||||
* data from the underlying buffer, and will fail to operate
|
||||
* properly if the data is not aligned. The standard way to use these
|
||||
* is to say:
|
||||
* if ((buf = XDR_INLINE(xdrs, count)) == NULL)
|
||||
* return (FALSE);
|
||||
* <<< macro calls >>>
|
||||
* where ``count'' is the number of bytes of data occupied
|
||||
* by the primitive data types.
|
||||
*
|
||||
* N.B. and frozen for all time: each data type here uses 4 bytes
|
||||
* of external representation.
|
||||
*/
|
||||
|
||||
#define IXDR_GET_INT32(buf) ((int32_t)ntohl((uint32_t)*(buf)++))
|
||||
#define IXDR_PUT_INT32(buf, v) (*(buf)++ = (int32_t)htonl((uint32_t)(v)))
|
||||
#define IXDR_GET_U_INT32(buf) ((uint32_t)IXDR_GET_INT32(buf))
|
||||
#define IXDR_PUT_U_INT32(buf, v) IXDR_PUT_INT32(buf, (int32_t)(v))
|
||||
|
||||
/* WARNING: The IXDR_*_LONG defines are removed by Sun for new platforms
|
||||
* and shouldn't be used any longer. Code which use this defines or longs
|
||||
* in the RPC code will not work on 64bit Solaris platforms !
|
||||
*/
|
||||
#define IXDR_GET_LONG(buf) ((long)IXDR_GET_U_INT32(buf))
|
||||
#define IXDR_PUT_LONG(buf, v) ((long)IXDR_PUT_INT32(buf, (long)(v)))
|
||||
#define IXDR_GET_U_LONG(buf) ((unsigned long)IXDR_GET_LONG(buf))
|
||||
#define IXDR_PUT_U_LONG(buf, v) IXDR_PUT_LONG(buf, (long)(v))
|
||||
|
||||
|
||||
#define IXDR_GET_BOOL(buf) ((bool_t)IXDR_GET_LONG(buf))
|
||||
#define IXDR_GET_ENUM(buf, t) ((t)IXDR_GET_LONG(buf))
|
||||
#define IXDR_GET_SHORT(buf) ((short)IXDR_GET_LONG(buf))
|
||||
#define IXDR_GET_U_SHORT(buf) ((unsigned short)IXDR_GET_LONG(buf))
|
||||
|
||||
#define IXDR_PUT_BOOL(buf, v) IXDR_PUT_LONG(buf, (long)(v))
|
||||
#define IXDR_PUT_ENUM(buf, v) IXDR_PUT_LONG(buf, (long)(v))
|
||||
#define IXDR_PUT_SHORT(buf, v) IXDR_PUT_LONG(buf, (long)(v))
|
||||
#define IXDR_PUT_U_SHORT(buf, v) IXDR_PUT_LONG(buf, (long)(v))
|
||||
|
||||
/*
|
||||
* These are the "generic" xdr routines.
|
||||
* None of these can have const applied because it's not possible to
|
||||
* know whether the call is a read or a write to the passed parameter
|
||||
* also, the XDR structure is always updated by some of these calls.
|
||||
*/
|
||||
extern bool_t xdr_void (void);
|
||||
extern bool_t xdr_short (XDR *__xdrs, short *__sp);
|
||||
extern bool_t xdr_u_short (XDR *__xdrs, unsigned short *__usp);
|
||||
extern bool_t xdr_int (XDR *__xdrs, int *__ip);
|
||||
extern bool_t xdr_u_int (XDR *__xdrs, unsigned int *__up);
|
||||
extern bool_t xdr_long (XDR *__xdrs, long *__lp);
|
||||
extern bool_t xdr_u_long (XDR *__xdrs, unsigned long *__ulp);
|
||||
extern bool_t xdr_hyper (XDR *__xdrs, int64_t *__llp);
|
||||
extern bool_t xdr_u_hyper (XDR *__xdrs, uint64_t *__ullp);
|
||||
extern bool_t xdr_longlong_t (XDR *__xdrs, int64_t *__llp);
|
||||
extern bool_t xdr_u_longlong_t (XDR *__xdrs, uint64_t *__ullp);
|
||||
extern bool_t xdr_int8_t (XDR *__xdrs, int8_t *__ip);
|
||||
extern bool_t xdr_uint8_t (XDR *__xdrs, uint8_t *__up);
|
||||
extern bool_t xdr_int16_t (XDR *__xdrs, int16_t *__ip);
|
||||
extern bool_t xdr_uint16_t (XDR *__xdrs, uint16_t *__up);
|
||||
extern bool_t xdr_int32_t (XDR *__xdrs, int32_t *__ip);
|
||||
extern bool_t xdr_uint32_t (XDR *__xdrs, uint32_t *__up);
|
||||
extern bool_t xdr_int64_t (XDR *__xdrs, int64_t *__ip);
|
||||
extern bool_t xdr_uint64_t (XDR *__xdrs, uint64_t *__up);
|
||||
extern bool_t xdr_bool (XDR *__xdrs, bool_t *__bp);
|
||||
extern bool_t xdr_enum (XDR *__xdrs, enum_t *__ep);
|
||||
extern bool_t xdr_array (XDR * _xdrs, char* *__addrp, unsigned int *__sizep,
|
||||
unsigned int __maxsize, unsigned int __elsize, xdrproc_t __elproc);
|
||||
extern bool_t xdr_bytes (XDR *xdrs, char **cpp, unsigned int *sizep,
|
||||
unsigned int maxsize);
|
||||
extern bool_t xdr_opaque (XDR *__xdrs, char* __cp, unsigned int __cnt);
|
||||
extern bool_t xdr_string (XDR *xdrs, char **cpp, unsigned int maxsize);
|
||||
extern bool_t xdr_union (XDR *__xdrs, enum_t *__dscmp, char *__unp,
|
||||
const struct xdr_discrim *__choices,
|
||||
xdrproc_t dfault);
|
||||
extern bool_t xdr_char (XDR *__xdrs, char *__cp);
|
||||
extern bool_t xdr_u_char (XDR *__xdrs, unsigned char *__cp);
|
||||
extern bool_t xdr_vector (XDR *__xdrs, char *__basep, unsigned int __nelem,
|
||||
unsigned int __elemsize, xdrproc_t __xdr_elem);
|
||||
extern bool_t xdr_float (XDR *__xdrs, float *__fp);
|
||||
extern bool_t xdr_double (XDR *__xdrs, double *__dp);
|
||||
extern bool_t xdr_reference (XDR *__xdrs, char* *__xpp, unsigned int __size,
|
||||
xdrproc_t __proc);
|
||||
extern bool_t xdr_pointer (XDR *__xdrs, char **__objpp,
|
||||
unsigned int __obj_size, xdrproc_t __xdr_obj);
|
||||
extern bool_t xdr_wrapstring (XDR *__xdrs, char **cpp);
|
||||
extern unsigned long xdr_sizeof (xdrproc_t, void *);
|
||||
|
||||
/*
|
||||
* Common opaque bytes objects used by many rpc protocols;
|
||||
* declared here due to commonality.
|
||||
*/
|
||||
#define MAX_NETOBJ_SZ 1024
|
||||
struct netobj
|
||||
{
|
||||
unsigned int n_len;
|
||||
char *n_bytes;
|
||||
};
|
||||
typedef struct netobj netobj;
|
||||
extern bool_t xdr_netobj (XDR *__xdrs, struct netobj *__np);
|
||||
|
||||
/*
|
||||
* These are the public routines for the various implementations of
|
||||
* xdr streams.
|
||||
*/
|
||||
|
||||
/* XDR using memory buffers */
|
||||
extern void xdrmem_create (XDR *__xdrs, const char* __addr,
|
||||
unsigned int __size, enum xdr_op __xop);
|
||||
|
||||
/* XDR pseudo records for tcp */
|
||||
extern void xdrrec_create (XDR *__xdrs, unsigned int __sendsize,
|
||||
unsigned int __recvsize, char* __tcp_handle,
|
||||
int (*__readit) (char *, char *, int),
|
||||
int (*__writeit) (char *, char *, int));
|
||||
|
||||
/* make end of xdr record */
|
||||
extern bool_t xdrrec_endofrecord (XDR *__xdrs, bool_t __sendnow);
|
||||
|
||||
/* move to beginning of next record */
|
||||
extern bool_t xdrrec_skiprecord (XDR *__xdrs);
|
||||
|
||||
/* true if no more input */
|
||||
extern bool_t xdrrec_eof (XDR *__xdrs);
|
||||
|
||||
/* free memory buffers for xdr */
|
||||
extern void xdr_free (xdrproc_t __proc, char *__objp);
|
||||
|
||||
#endif /* rpc/xdr.h */
|
||||
@@ -0,0 +1,172 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
/* @(#)xdr_mem.c 2.1 88/07/29 4.0 RPCSRC */
|
||||
/*
|
||||
* Sun RPC is a product of Sun Microsystems, Inc. and is provided for
|
||||
* unrestricted use provided that this legend is included on all tape
|
||||
* media and as a part of the software program in whole or part. Users
|
||||
* may copy or modify Sun RPC without charge, but are not authorized
|
||||
* to license or distribute it to anyone else except as part of a product or
|
||||
* program developed by the user.
|
||||
*
|
||||
* SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
|
||||
* WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
|
||||
* PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
|
||||
*
|
||||
* Sun RPC is provided with no support and without any obligation on the
|
||||
* part of Sun Microsystems, Inc. to assist in its use, correction,
|
||||
* modification or enhancement.
|
||||
*
|
||||
* SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
|
||||
* INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
|
||||
* OR ANY PART THEREOF.
|
||||
*
|
||||
* In no event will Sun Microsystems, Inc. be liable for any lost revenue
|
||||
* or profits or other special, indirect and consequential damages, even if
|
||||
* Sun has been advised of the possibility of such damages.
|
||||
*
|
||||
* Sun Microsystems, Inc.
|
||||
* 2550 Garcia Avenue
|
||||
* Mountain View, California 94043
|
||||
*/
|
||||
#if !defined(lint) && defined(SCCSIDS)
|
||||
static char sccsid[] = "@(#)xdr_mem.c 1.19 87/08/11 Copyr 1984 Sun Micro";
|
||||
#endif
|
||||
|
||||
/*
|
||||
* xdr_mem.h, XDR implementation using memory buffers.
|
||||
*
|
||||
* Copyright (C) 1984, Sun Microsystems, Inc.
|
||||
*
|
||||
* If you have some data to be interpreted as external data representation
|
||||
* or to be converted to external data representation in a memory buffer,
|
||||
* then this is the package for you.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <rpc/types.h>
|
||||
#include <rpc/xdr.h>
|
||||
#include <string.h>
|
||||
#include <limits.h>
|
||||
|
||||
static bool_t xdrmem_getlong (XDR *, long *);
|
||||
static bool_t xdrmem_putlong (XDR *, const long *);
|
||||
static bool_t xdrmem_getbytes (XDR *, char *, unsigned int);
|
||||
static bool_t xdrmem_putbytes (XDR *, const char *, unsigned int);
|
||||
static unsigned int xdrmem_getpos (const XDR *);
|
||||
static bool_t xdrmem_setpos (XDR *, unsigned int);
|
||||
static int32_t *xdrmem_inline (XDR *, unsigned int);
|
||||
static void xdrmem_destroy (XDR *);
|
||||
|
||||
static struct xdr_ops xdrmem_ops = {
|
||||
xdrmem_getlong,
|
||||
xdrmem_putlong,
|
||||
xdrmem_getbytes,
|
||||
xdrmem_putbytes,
|
||||
xdrmem_getpos,
|
||||
xdrmem_setpos,
|
||||
xdrmem_inline,
|
||||
xdrmem_destroy,
|
||||
NULL,
|
||||
NULL
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* The procedure xdrmem_create initializes a stream descriptor for a
|
||||
* memory buffer.
|
||||
*/
|
||||
void
|
||||
xdrmem_create (XDR *xdrs, const char* addr, unsigned int size, enum xdr_op op)
|
||||
{
|
||||
xdrs->x_op = op;
|
||||
xdrs->x_ops = &xdrmem_ops;
|
||||
xdrs->x_private = xdrs->x_base = (char*)addr;
|
||||
xdrs->x_handy = size;
|
||||
}
|
||||
|
||||
static void
|
||||
xdrmem_destroy (XDR *xdrs)
|
||||
{
|
||||
}
|
||||
|
||||
static bool_t
|
||||
xdrmem_getlong (XDR *xdrs, long *lp)
|
||||
{
|
||||
if (xdrs->x_handy < 4) return FALSE;
|
||||
xdrs->x_handy -= 4;
|
||||
|
||||
*lp = (int32_t) ntohl((*((int32_t *) (xdrs->x_private))));
|
||||
xdrs->x_private += 4;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static bool_t
|
||||
xdrmem_putlong (XDR *xdrs, const long *lp)
|
||||
{
|
||||
if (xdrs->x_handy < 4) return FALSE;
|
||||
xdrs->x_handy -= 4;
|
||||
|
||||
*(int32_t *) xdrs->x_private = htonl(*lp);
|
||||
xdrs->x_private += 4;
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
static bool_t
|
||||
xdrmem_getbytes (XDR *xdrs, char *addr, unsigned int len)
|
||||
{
|
||||
if (xdrs->x_handy < len) return FALSE;
|
||||
xdrs->x_handy -= len;
|
||||
memmove(addr, xdrs->x_private, len);
|
||||
xdrs->x_private += len;
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static bool_t
|
||||
xdrmem_putbytes (XDR *xdrs, const char *addr, unsigned int len)
|
||||
{
|
||||
if (xdrs->x_handy < len) return FALSE;
|
||||
xdrs->x_handy -= len;
|
||||
memmove(xdrs->x_private, addr, len);
|
||||
xdrs->x_private += len;
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
static unsigned int xdrmem_getpos (const XDR *xdrs)
|
||||
{
|
||||
return ((unsigned long) xdrs->x_private - (unsigned long) xdrs->x_base);
|
||||
}
|
||||
|
||||
static bool_t xdrmem_setpos(XDR *xdrs, unsigned int pos)
|
||||
{
|
||||
register char* newaddr = xdrs->x_base + pos;
|
||||
register char* lastaddr = xdrs->x_private + xdrs->x_handy;
|
||||
|
||||
if ((long) newaddr > (long) lastaddr
|
||||
|| (UINT_MAX < LONG_MAX
|
||||
&& (long) UINT_MAX < (long) lastaddr - (long) newaddr))
|
||||
return (FALSE);
|
||||
xdrs->x_private = newaddr;
|
||||
xdrs->x_handy = (long) lastaddr - (long) newaddr;
|
||||
return (TRUE);
|
||||
}
|
||||
|
||||
static int32_t *
|
||||
xdrmem_inline (XDR *xdrs, unsigned int len)
|
||||
{
|
||||
int32_t *buf = 0;
|
||||
|
||||
if (xdrs->x_handy >= len) {
|
||||
xdrs->x_handy -= len;
|
||||
buf = (int32_t *) xdrs->x_private;
|
||||
xdrs->x_private += len;
|
||||
}
|
||||
return (buf);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,9 @@
|
||||
from building import *
|
||||
|
||||
cwd = GetCurrentDir()
|
||||
src = Glob('*.c')
|
||||
CPPPATH = [cwd]
|
||||
|
||||
group = DefineGroup('Filesystem', src, depend = ['RT_USING_DFS', 'RT_USING_MEMHEAP', 'RT_USING_DFS_RAMFS'], CPPPATH = CPPPATH)
|
||||
|
||||
Return('group')
|
||||
@@ -0,0 +1,453 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2013-04-15 Bernard the first version
|
||||
* 2013-05-05 Bernard remove CRC for ramfs persistence
|
||||
* 2013-05-22 Bernard fix the no entry issue.
|
||||
*/
|
||||
|
||||
#include <rtthread.h>
|
||||
#include <dfs.h>
|
||||
#include <dfs_fs.h>
|
||||
#include <dfs_file.h>
|
||||
|
||||
#include "dfs_ramfs.h"
|
||||
|
||||
int dfs_ramfs_mount(struct dfs_filesystem *fs,
|
||||
unsigned long rwflag,
|
||||
const void *data)
|
||||
{
|
||||
struct dfs_ramfs *ramfs;
|
||||
|
||||
if (data == NULL)
|
||||
return -EIO;
|
||||
|
||||
ramfs = (struct dfs_ramfs *)data;
|
||||
fs->data = ramfs;
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
int dfs_ramfs_unmount(struct dfs_filesystem *fs)
|
||||
{
|
||||
fs->data = NULL;
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
int dfs_ramfs_statfs(struct dfs_filesystem *fs, struct statfs *buf)
|
||||
{
|
||||
struct dfs_ramfs *ramfs;
|
||||
|
||||
ramfs = (struct dfs_ramfs *)fs->data;
|
||||
RT_ASSERT(ramfs != NULL);
|
||||
RT_ASSERT(buf != NULL);
|
||||
|
||||
buf->f_bsize = 512;
|
||||
buf->f_blocks = ramfs->memheap.pool_size / 512;
|
||||
buf->f_bfree = ramfs->memheap.available_size / 512;
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
int dfs_ramfs_ioctl(struct dfs_fd *file, int cmd, void *args)
|
||||
{
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
struct ramfs_dirent *dfs_ramfs_lookup(struct dfs_ramfs *ramfs,
|
||||
const char *path,
|
||||
rt_size_t *size)
|
||||
{
|
||||
const char *subpath;
|
||||
struct ramfs_dirent *dirent;
|
||||
|
||||
subpath = path;
|
||||
while (*subpath == '/' && *subpath)
|
||||
subpath ++;
|
||||
if (! *subpath) /* is root directory */
|
||||
{
|
||||
*size = 0;
|
||||
|
||||
return &(ramfs->root);
|
||||
}
|
||||
|
||||
for (dirent = rt_list_entry(ramfs->root.list.next, struct ramfs_dirent, list);
|
||||
dirent != &(ramfs->root);
|
||||
dirent = rt_list_entry(dirent->list.next, struct ramfs_dirent, list))
|
||||
{
|
||||
if (rt_strcmp(dirent->name, subpath) == 0)
|
||||
{
|
||||
*size = dirent->size;
|
||||
|
||||
return dirent;
|
||||
}
|
||||
}
|
||||
|
||||
/* not found */
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int dfs_ramfs_read(struct dfs_fd *file, void *buf, size_t count)
|
||||
{
|
||||
rt_size_t length;
|
||||
struct ramfs_dirent *dirent;
|
||||
|
||||
dirent = (struct ramfs_dirent *)file->data;
|
||||
RT_ASSERT(dirent != NULL);
|
||||
|
||||
if (count < file->size - file->pos)
|
||||
length = count;
|
||||
else
|
||||
length = file->size - file->pos;
|
||||
|
||||
if (length > 0)
|
||||
rt_memcpy(buf, &(dirent->data[file->pos]), length);
|
||||
|
||||
/* update file current position */
|
||||
file->pos += length;
|
||||
|
||||
return length;
|
||||
}
|
||||
|
||||
int dfs_ramfs_write(struct dfs_fd *fd, const void *buf, size_t count)
|
||||
{
|
||||
struct ramfs_dirent *dirent;
|
||||
struct dfs_ramfs *ramfs;
|
||||
|
||||
dirent = (struct ramfs_dirent *)fd->data;
|
||||
RT_ASSERT(dirent != NULL);
|
||||
|
||||
ramfs = dirent->fs;
|
||||
RT_ASSERT(ramfs != NULL);
|
||||
|
||||
if (count + fd->pos > fd->size)
|
||||
{
|
||||
rt_uint8_t *ptr;
|
||||
ptr = rt_memheap_realloc(&(ramfs->memheap), dirent->data, fd->pos + count);
|
||||
if (ptr == NULL)
|
||||
{
|
||||
rt_set_errno(-ENOMEM);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* update dirent and file size */
|
||||
dirent->data = ptr;
|
||||
dirent->size = fd->pos + count;
|
||||
fd->size = dirent->size;
|
||||
}
|
||||
|
||||
if (count > 0)
|
||||
rt_memcpy(dirent->data + fd->pos, buf, count);
|
||||
|
||||
/* update file current position */
|
||||
fd->pos += count;
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
int dfs_ramfs_lseek(struct dfs_fd *file, off_t offset)
|
||||
{
|
||||
if (offset <= (off_t)file->size)
|
||||
{
|
||||
file->pos = offset;
|
||||
|
||||
return file->pos;
|
||||
}
|
||||
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
int dfs_ramfs_close(struct dfs_fd *file)
|
||||
{
|
||||
file->data = NULL;
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
int dfs_ramfs_open(struct dfs_fd *file)
|
||||
{
|
||||
rt_size_t size;
|
||||
struct dfs_ramfs *ramfs;
|
||||
struct ramfs_dirent *dirent;
|
||||
struct dfs_filesystem *fs;
|
||||
|
||||
fs = (struct dfs_filesystem *)file->data;
|
||||
|
||||
ramfs = (struct dfs_ramfs *)fs->data;
|
||||
RT_ASSERT(ramfs != NULL);
|
||||
|
||||
if (file->flags & O_DIRECTORY)
|
||||
{
|
||||
if (file->flags & O_CREAT)
|
||||
{
|
||||
return -ENOSPC;
|
||||
}
|
||||
|
||||
/* open directory */
|
||||
dirent = dfs_ramfs_lookup(ramfs, file->path, &size);
|
||||
if (dirent == NULL)
|
||||
return -ENOENT;
|
||||
if (dirent == &(ramfs->root)) /* it's root directory */
|
||||
{
|
||||
if (!(file->flags & O_DIRECTORY))
|
||||
{
|
||||
return -ENOENT;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
dirent = dfs_ramfs_lookup(ramfs, file->path, &size);
|
||||
if (dirent == &(ramfs->root)) /* it's root directory */
|
||||
{
|
||||
return -ENOENT;
|
||||
}
|
||||
|
||||
if (dirent == NULL)
|
||||
{
|
||||
if (file->flags & O_CREAT || file->flags & O_WRONLY)
|
||||
{
|
||||
char *name_ptr;
|
||||
|
||||
/* create a file entry */
|
||||
dirent = (struct ramfs_dirent *)
|
||||
rt_memheap_alloc(&(ramfs->memheap),
|
||||
sizeof(struct ramfs_dirent));
|
||||
if (dirent == NULL)
|
||||
{
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
/* remove '/' separator */
|
||||
name_ptr = file->path;
|
||||
while (*name_ptr == '/' && *name_ptr)
|
||||
name_ptr ++;
|
||||
strncpy(dirent->name, name_ptr, RAMFS_NAME_MAX);
|
||||
|
||||
rt_list_init(&(dirent->list));
|
||||
dirent->data = NULL;
|
||||
dirent->size = 0;
|
||||
dirent->fs = ramfs;
|
||||
|
||||
/* add to the root directory */
|
||||
rt_list_insert_after(&(ramfs->root.list), &(dirent->list));
|
||||
}
|
||||
else
|
||||
return -ENOENT;
|
||||
}
|
||||
|
||||
/* Creates a new file.
|
||||
* If the file is existing, it is truncated and overwritten.
|
||||
*/
|
||||
if (file->flags & O_TRUNC)
|
||||
{
|
||||
dirent->size = 0;
|
||||
if (dirent->data != NULL)
|
||||
{
|
||||
rt_memheap_free(dirent->data);
|
||||
dirent->data = NULL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
file->data = dirent;
|
||||
file->size = dirent->size;
|
||||
if (file->flags & O_APPEND)
|
||||
file->pos = file->size;
|
||||
else
|
||||
file->pos = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int dfs_ramfs_stat(struct dfs_filesystem *fs,
|
||||
const char *path,
|
||||
struct stat *st)
|
||||
{
|
||||
rt_size_t size;
|
||||
struct ramfs_dirent *dirent;
|
||||
struct dfs_ramfs *ramfs;
|
||||
|
||||
ramfs = (struct dfs_ramfs *)fs->data;
|
||||
dirent = dfs_ramfs_lookup(ramfs, path, &size);
|
||||
|
||||
if (dirent == NULL)
|
||||
return -ENOENT;
|
||||
|
||||
st->st_dev = 0;
|
||||
st->st_mode = S_IFREG | S_IRUSR | S_IRGRP | S_IROTH |
|
||||
S_IWUSR | S_IWGRP | S_IWOTH;
|
||||
|
||||
st->st_size = dirent->size;
|
||||
st->st_mtime = 0;
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
int dfs_ramfs_getdents(struct dfs_fd *file,
|
||||
struct dirent *dirp,
|
||||
uint32_t count)
|
||||
{
|
||||
rt_size_t index, end;
|
||||
struct dirent *d;
|
||||
struct ramfs_dirent *dirent;
|
||||
struct dfs_ramfs *ramfs;
|
||||
|
||||
dirent = (struct ramfs_dirent *)file->data;
|
||||
|
||||
ramfs = dirent->fs;
|
||||
RT_ASSERT(ramfs != RT_NULL);
|
||||
|
||||
if (dirent != &(ramfs->root))
|
||||
return -EINVAL;
|
||||
|
||||
/* make integer count */
|
||||
count = (count / sizeof(struct dirent));
|
||||
if (count == 0)
|
||||
return -EINVAL;
|
||||
|
||||
end = file->pos + count;
|
||||
index = 0;
|
||||
count = 0;
|
||||
for (dirent = rt_list_entry(dirent->list.next, struct ramfs_dirent, list);
|
||||
dirent != &(ramfs->root) && index < end;
|
||||
dirent = rt_list_entry(dirent->list.next, struct ramfs_dirent, list))
|
||||
{
|
||||
if (index >= (rt_size_t)file->pos)
|
||||
{
|
||||
d = dirp + count;
|
||||
d->d_type = DT_REG;
|
||||
d->d_namlen = RT_NAME_MAX;
|
||||
d->d_reclen = (rt_uint16_t)sizeof(struct dirent);
|
||||
rt_strncpy(d->d_name, dirent->name, RAMFS_NAME_MAX);
|
||||
|
||||
count += 1;
|
||||
file->pos += 1;
|
||||
}
|
||||
index += 1;
|
||||
}
|
||||
|
||||
return count * sizeof(struct dirent);
|
||||
}
|
||||
|
||||
int dfs_ramfs_unlink(struct dfs_filesystem *fs, const char *path)
|
||||
{
|
||||
rt_size_t size;
|
||||
struct dfs_ramfs *ramfs;
|
||||
struct ramfs_dirent *dirent;
|
||||
|
||||
ramfs = (struct dfs_ramfs *)fs->data;
|
||||
RT_ASSERT(ramfs != NULL);
|
||||
|
||||
dirent = dfs_ramfs_lookup(ramfs, path, &size);
|
||||
if (dirent == NULL)
|
||||
return -ENOENT;
|
||||
|
||||
rt_list_remove(&(dirent->list));
|
||||
if (dirent->data != NULL)
|
||||
rt_memheap_free(dirent->data);
|
||||
rt_memheap_free(dirent);
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
int dfs_ramfs_rename(struct dfs_filesystem *fs,
|
||||
const char *oldpath,
|
||||
const char *newpath)
|
||||
{
|
||||
struct ramfs_dirent *dirent;
|
||||
struct dfs_ramfs *ramfs;
|
||||
rt_size_t size;
|
||||
|
||||
ramfs = (struct dfs_ramfs *)fs->data;
|
||||
RT_ASSERT(ramfs != NULL);
|
||||
|
||||
dirent = dfs_ramfs_lookup(ramfs, newpath, &size);
|
||||
if (dirent != NULL)
|
||||
return -EEXIST;
|
||||
|
||||
dirent = dfs_ramfs_lookup(ramfs, oldpath, &size);
|
||||
if (dirent == NULL)
|
||||
return -ENOENT;
|
||||
|
||||
strncpy(dirent->name, newpath, RAMFS_NAME_MAX);
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static const struct dfs_file_ops _ram_fops =
|
||||
{
|
||||
dfs_ramfs_open,
|
||||
dfs_ramfs_close,
|
||||
dfs_ramfs_ioctl,
|
||||
dfs_ramfs_read,
|
||||
dfs_ramfs_write,
|
||||
NULL, /* flush */
|
||||
dfs_ramfs_lseek,
|
||||
dfs_ramfs_getdents,
|
||||
};
|
||||
|
||||
static const struct dfs_filesystem_ops _ramfs =
|
||||
{
|
||||
"ram",
|
||||
DFS_FS_FLAG_DEFAULT,
|
||||
&_ram_fops,
|
||||
|
||||
dfs_ramfs_mount,
|
||||
dfs_ramfs_unmount,
|
||||
NULL, /* mkfs */
|
||||
dfs_ramfs_statfs,
|
||||
|
||||
dfs_ramfs_unlink,
|
||||
dfs_ramfs_stat,
|
||||
dfs_ramfs_rename,
|
||||
};
|
||||
|
||||
int dfs_ramfs_init(void)
|
||||
{
|
||||
/* register ram file system */
|
||||
dfs_register(&_ramfs);
|
||||
|
||||
return 0;
|
||||
}
|
||||
INIT_COMPONENT_EXPORT(dfs_ramfs_init);
|
||||
|
||||
struct dfs_ramfs *dfs_ramfs_create(rt_uint8_t *pool, rt_size_t size)
|
||||
{
|
||||
struct dfs_ramfs *ramfs;
|
||||
rt_uint8_t *data_ptr;
|
||||
rt_err_t result;
|
||||
|
||||
size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE);
|
||||
ramfs = (struct dfs_ramfs *)pool;
|
||||
|
||||
data_ptr = (rt_uint8_t *)(ramfs + 1);
|
||||
size = size - sizeof(struct dfs_ramfs);
|
||||
size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE);
|
||||
|
||||
result = rt_memheap_init(&ramfs->memheap, "ramfs", data_ptr, size);
|
||||
if (result != RT_EOK)
|
||||
return NULL;
|
||||
/* detach this memheap object from the system */
|
||||
rt_object_detach((rt_object_t) & (ramfs->memheap));
|
||||
|
||||
/* initialize ramfs object */
|
||||
ramfs->magic = RAMFS_MAGIC;
|
||||
ramfs->memheap.parent.type = RT_Object_Class_MemHeap | RT_Object_Class_Static;
|
||||
|
||||
/* initialize root directory */
|
||||
rt_memset(&(ramfs->root), 0x00, sizeof(ramfs->root));
|
||||
rt_list_init(&(ramfs->root.list));
|
||||
ramfs->root.size = 0;
|
||||
strcpy(ramfs->root.name, ".");
|
||||
ramfs->root.fs = ramfs;
|
||||
|
||||
return ramfs;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2013-04-15 Bernard the first version
|
||||
* 2013-05-05 Bernard remove CRC for ramfs persistence
|
||||
*/
|
||||
|
||||
#ifndef __DFS_RAMFS_H__
|
||||
#define __DFS_RAMFS_H__
|
||||
|
||||
#include <rtthread.h>
|
||||
#include <rtservice.h>
|
||||
|
||||
#define RAMFS_NAME_MAX 32
|
||||
#define RAMFS_MAGIC 0x0A0A0A0A
|
||||
|
||||
struct ramfs_dirent
|
||||
{
|
||||
rt_list_t list;
|
||||
struct dfs_ramfs *fs; /* file system ref */
|
||||
|
||||
char name[RAMFS_NAME_MAX]; /* dirent name */
|
||||
rt_uint8_t *data;
|
||||
|
||||
rt_size_t size; /* file size */
|
||||
};
|
||||
|
||||
/**
|
||||
* DFS ramfs object
|
||||
*/
|
||||
struct dfs_ramfs
|
||||
{
|
||||
rt_uint32_t magic;
|
||||
|
||||
struct rt_memheap memheap;
|
||||
struct ramfs_dirent root;
|
||||
};
|
||||
|
||||
int dfs_ramfs_init(void);
|
||||
struct dfs_ramfs *dfs_ramfs_create(rt_uint8_t *pool, rt_size_t size);
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,15 @@
|
||||
# RT-Thread building script for component
|
||||
|
||||
from building import *
|
||||
|
||||
cwd = GetCurrentDir()
|
||||
src = Glob('*.c')
|
||||
CPPPATH = [cwd]
|
||||
|
||||
if GetDepend('DFS_ROMFS_ROOT'):
|
||||
# A new ROMFS root has been defined, we should remove the romfs.c
|
||||
SrcRemove(src, ['romfs.c'])
|
||||
|
||||
group = DefineGroup('Filesystem', src, depend = ['RT_USING_DFS','RT_USING_DFS_ROMFS'], CPPPATH = CPPPATH)
|
||||
|
||||
Return('group')
|
||||
@@ -0,0 +1,322 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
|
||||
#include <rtthread.h>
|
||||
#include <dfs.h>
|
||||
#include <dfs_fs.h>
|
||||
#include <dfs_file.h>
|
||||
|
||||
#include "dfs_romfs.h"
|
||||
|
||||
int dfs_romfs_mount(struct dfs_filesystem *fs, unsigned long rwflag, const void *data)
|
||||
{
|
||||
struct romfs_dirent *root_dirent;
|
||||
|
||||
if (data == NULL)
|
||||
return -EIO;
|
||||
|
||||
root_dirent = (struct romfs_dirent *)data;
|
||||
fs->data = root_dirent;
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
int dfs_romfs_unmount(struct dfs_filesystem *fs)
|
||||
{
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
int dfs_romfs_ioctl(struct dfs_fd *file, int cmd, void *args)
|
||||
{
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
rt_inline int check_dirent(struct romfs_dirent *dirent)
|
||||
{
|
||||
if ((dirent->type != ROMFS_DIRENT_FILE && dirent->type != ROMFS_DIRENT_DIR)
|
||||
|| dirent->size == ~0)
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
struct romfs_dirent *dfs_romfs_lookup(struct romfs_dirent *root_dirent, const char *path, rt_size_t *size)
|
||||
{
|
||||
rt_size_t index, found;
|
||||
const char *subpath, *subpath_end;
|
||||
struct romfs_dirent *dirent;
|
||||
rt_size_t dirent_size;
|
||||
|
||||
/* Check the root_dirent. */
|
||||
if (check_dirent(root_dirent) != 0)
|
||||
return NULL;
|
||||
|
||||
if (path[0] == '/' && path[1] == '\0')
|
||||
{
|
||||
*size = root_dirent->size;
|
||||
return root_dirent;
|
||||
}
|
||||
|
||||
/* goto root directory entries */
|
||||
dirent = (struct romfs_dirent *)root_dirent->data;
|
||||
dirent_size = root_dirent->size;
|
||||
|
||||
/* get the end position of this subpath */
|
||||
subpath_end = path;
|
||||
/* skip /// */
|
||||
while (*subpath_end && *subpath_end == '/')
|
||||
subpath_end ++;
|
||||
subpath = subpath_end;
|
||||
while ((*subpath_end != '/') && *subpath_end)
|
||||
subpath_end ++;
|
||||
|
||||
while (dirent != NULL)
|
||||
{
|
||||
found = 0;
|
||||
|
||||
/* search in folder */
|
||||
for (index = 0; index < dirent_size; index ++)
|
||||
{
|
||||
if (check_dirent(&dirent[index]) != 0)
|
||||
return NULL;
|
||||
if (rt_strlen(dirent[index].name) == (subpath_end - subpath) &&
|
||||
rt_strncmp(dirent[index].name, subpath, (subpath_end - subpath)) == 0)
|
||||
{
|
||||
dirent_size = dirent[index].size;
|
||||
|
||||
/* skip /// */
|
||||
while (*subpath_end && *subpath_end == '/')
|
||||
subpath_end ++;
|
||||
subpath = subpath_end;
|
||||
while ((*subpath_end != '/') && *subpath_end)
|
||||
subpath_end ++;
|
||||
|
||||
if (!(*subpath))
|
||||
{
|
||||
*size = dirent_size;
|
||||
return &dirent[index];
|
||||
}
|
||||
|
||||
if (dirent[index].type == ROMFS_DIRENT_DIR)
|
||||
{
|
||||
/* enter directory */
|
||||
dirent = (struct romfs_dirent *)dirent[index].data;
|
||||
found = 1;
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* return file dirent */
|
||||
if (subpath != NULL)
|
||||
break; /* not the end of path */
|
||||
|
||||
return &dirent[index];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!found)
|
||||
break; /* not found */
|
||||
}
|
||||
|
||||
/* not found */
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int dfs_romfs_read(struct dfs_fd *file, void *buf, size_t count)
|
||||
{
|
||||
rt_size_t length;
|
||||
struct romfs_dirent *dirent;
|
||||
|
||||
dirent = (struct romfs_dirent *)file->data;
|
||||
RT_ASSERT(dirent != NULL);
|
||||
|
||||
if (check_dirent(dirent) != 0)
|
||||
{
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
if (count < file->size - file->pos)
|
||||
length = count;
|
||||
else
|
||||
length = file->size - file->pos;
|
||||
|
||||
if (length > 0)
|
||||
rt_memcpy(buf, &(dirent->data[file->pos]), length);
|
||||
|
||||
/* update file current position */
|
||||
file->pos += length;
|
||||
|
||||
return length;
|
||||
}
|
||||
|
||||
int dfs_romfs_lseek(struct dfs_fd *file, off_t offset)
|
||||
{
|
||||
if (offset <= file->size)
|
||||
{
|
||||
file->pos = offset;
|
||||
return file->pos;
|
||||
}
|
||||
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
int dfs_romfs_close(struct dfs_fd *file)
|
||||
{
|
||||
file->data = NULL;
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
int dfs_romfs_open(struct dfs_fd *file)
|
||||
{
|
||||
rt_size_t size;
|
||||
struct romfs_dirent *dirent;
|
||||
struct romfs_dirent *root_dirent;
|
||||
struct dfs_filesystem *fs;
|
||||
|
||||
fs = (struct dfs_filesystem *)file->data;
|
||||
root_dirent = (struct romfs_dirent *)fs->data;
|
||||
|
||||
if (check_dirent(root_dirent) != 0)
|
||||
return -EIO;
|
||||
|
||||
if (file->flags & (O_CREAT | O_WRONLY | O_APPEND | O_TRUNC | O_RDWR))
|
||||
return -EINVAL;
|
||||
|
||||
dirent = dfs_romfs_lookup(root_dirent, file->path, &size);
|
||||
if (dirent == NULL)
|
||||
return -ENOENT;
|
||||
|
||||
/* entry is a directory file type */
|
||||
if (dirent->type == ROMFS_DIRENT_DIR)
|
||||
{
|
||||
if (!(file->flags & O_DIRECTORY))
|
||||
return -ENOENT;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* entry is a file, but open it as a directory */
|
||||
if (file->flags & O_DIRECTORY)
|
||||
return -ENOENT;
|
||||
}
|
||||
|
||||
file->data = dirent;
|
||||
file->size = size;
|
||||
file->pos = 0;
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
int dfs_romfs_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
|
||||
{
|
||||
rt_size_t size;
|
||||
struct romfs_dirent *dirent;
|
||||
struct romfs_dirent *root_dirent;
|
||||
|
||||
root_dirent = (struct romfs_dirent *)fs->data;
|
||||
dirent = dfs_romfs_lookup(root_dirent, path, &size);
|
||||
|
||||
if (dirent == NULL)
|
||||
return -ENOENT;
|
||||
|
||||
st->st_dev = 0;
|
||||
st->st_mode = S_IFREG | S_IRUSR | S_IRGRP | S_IROTH |
|
||||
S_IWUSR | S_IWGRP | S_IWOTH;
|
||||
|
||||
if (dirent->type == ROMFS_DIRENT_DIR)
|
||||
{
|
||||
st->st_mode &= ~S_IFREG;
|
||||
st->st_mode |= S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH;
|
||||
}
|
||||
|
||||
st->st_size = dirent->size;
|
||||
st->st_mtime = 0;
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
int dfs_romfs_getdents(struct dfs_fd *file, struct dirent *dirp, uint32_t count)
|
||||
{
|
||||
rt_size_t index;
|
||||
const char *name;
|
||||
struct dirent *d;
|
||||
struct romfs_dirent *dirent, *sub_dirent;
|
||||
|
||||
dirent = (struct romfs_dirent *)file->data;
|
||||
if (check_dirent(dirent) != 0)
|
||||
return -EIO;
|
||||
RT_ASSERT(dirent->type == ROMFS_DIRENT_DIR);
|
||||
|
||||
/* enter directory */
|
||||
dirent = (struct romfs_dirent *)dirent->data;
|
||||
|
||||
/* make integer count */
|
||||
count = (count / sizeof(struct dirent));
|
||||
if (count == 0)
|
||||
return -EINVAL;
|
||||
|
||||
index = 0;
|
||||
for (index = 0; index < count && file->pos < file->size; index ++)
|
||||
{
|
||||
d = dirp + index;
|
||||
|
||||
sub_dirent = &dirent[file->pos];
|
||||
name = sub_dirent->name;
|
||||
|
||||
/* fill dirent */
|
||||
if (sub_dirent->type == ROMFS_DIRENT_DIR)
|
||||
d->d_type = DT_DIR;
|
||||
else
|
||||
d->d_type = DT_REG;
|
||||
|
||||
d->d_namlen = rt_strlen(name);
|
||||
d->d_reclen = (rt_uint16_t)sizeof(struct dirent);
|
||||
rt_strncpy(d->d_name, name, DFS_PATH_MAX);
|
||||
|
||||
/* move to next position */
|
||||
++ file->pos;
|
||||
}
|
||||
|
||||
return index * sizeof(struct dirent);
|
||||
}
|
||||
|
||||
static const struct dfs_file_ops _rom_fops =
|
||||
{
|
||||
dfs_romfs_open,
|
||||
dfs_romfs_close,
|
||||
dfs_romfs_ioctl,
|
||||
dfs_romfs_read,
|
||||
NULL,
|
||||
NULL,
|
||||
dfs_romfs_lseek,
|
||||
dfs_romfs_getdents,
|
||||
};
|
||||
static const struct dfs_filesystem_ops _romfs =
|
||||
{
|
||||
"rom",
|
||||
DFS_FS_FLAG_DEFAULT,
|
||||
&_rom_fops,
|
||||
|
||||
dfs_romfs_mount,
|
||||
dfs_romfs_unmount,
|
||||
NULL,
|
||||
NULL,
|
||||
|
||||
NULL,
|
||||
dfs_romfs_stat,
|
||||
NULL,
|
||||
};
|
||||
|
||||
int dfs_romfs_init(void)
|
||||
{
|
||||
/* register rom file system */
|
||||
dfs_register(&_romfs);
|
||||
return 0;
|
||||
}
|
||||
INIT_COMPONENT_EXPORT(dfs_romfs_init);
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2019/01/13 Bernard code cleanup
|
||||
*/
|
||||
|
||||
#ifndef __DFS_ROMFS_H__
|
||||
#define __DFS_ROMFS_H__
|
||||
|
||||
#include <rtthread.h>
|
||||
|
||||
#define ROMFS_DIRENT_FILE 0x00
|
||||
#define ROMFS_DIRENT_DIR 0x01
|
||||
|
||||
struct romfs_dirent
|
||||
{
|
||||
rt_uint32_t type; /* dirent type */
|
||||
|
||||
const char *name; /* dirent name */
|
||||
const rt_uint8_t *data; /* file date ptr */
|
||||
rt_size_t size; /* file size */
|
||||
};
|
||||
|
||||
int dfs_romfs_init(void);
|
||||
extern const struct romfs_dirent romfs_root;
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,38 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
|
||||
#include <rtthread.h>
|
||||
#include <dfs_romfs.h>
|
||||
|
||||
const static unsigned char _dummy_dummy_txt[] =
|
||||
{
|
||||
0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x21, 0x0d, 0x0a,
|
||||
};
|
||||
|
||||
const static struct romfs_dirent _dummy[] =
|
||||
{
|
||||
{ROMFS_DIRENT_FILE, "dummy.txt", _dummy_dummy_txt, sizeof(_dummy_dummy_txt)},
|
||||
};
|
||||
|
||||
const static unsigned char _dummy_txt[] =
|
||||
{
|
||||
0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 0x20, 0x61, 0x20, 0x66, 0x69, 0x6c, 0x65, 0x21, 0x0d, 0x0a,
|
||||
};
|
||||
|
||||
RT_WEAK const struct romfs_dirent _root_dirent[] =
|
||||
{
|
||||
{ROMFS_DIRENT_DIR, "dummy", (rt_uint8_t *)_dummy, sizeof(_dummy) / sizeof(_dummy[0])},
|
||||
{ROMFS_DIRENT_FILE, "dummy.txt", _dummy_txt, sizeof(_dummy_txt)},
|
||||
};
|
||||
|
||||
RT_WEAK const struct romfs_dirent romfs_root =
|
||||
{
|
||||
ROMFS_DIRENT_DIR, "/", (rt_uint8_t *)_root_dirent, sizeof(_root_dirent) / sizeof(_root_dirent[0])
|
||||
};
|
||||
|
||||
@@ -0,0 +1,97 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
|
||||
#include <rtthread.h>
|
||||
#include <dfs.h>
|
||||
#include <dfs_fs.h>
|
||||
#include <dfs_file.h>
|
||||
|
||||
#include "dfs_skt_fs.h"
|
||||
|
||||
int dfs_skt_mount(struct dfs_filesystem *fs, unsigned long rwflag, const void *data)
|
||||
{
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
int dfs_skt_unmount(struct dfs_filesystem *fs)
|
||||
{
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
int dfs_skt_ioctl(struct dfs_fd *file, int cmd, void *args)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
|
||||
int dfs_skt_read(struct dfs_fd *file, void *buf, rt_size_t count)
|
||||
{
|
||||
return count;
|
||||
}
|
||||
|
||||
int dfs_skt_lseek(struct dfs_fd *file, rt_off_t offset)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
|
||||
int dfs_skt_close(struct dfs_fd *file)
|
||||
{
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
int dfs_skt_open(struct dfs_fd *file)
|
||||
{
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
int dfs_skt_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
|
||||
{
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
int dfs_skt_getdents(struct dfs_fd *file, struct dirent *dirp, rt_uint32_t count)
|
||||
{
|
||||
return count * sizeof(struct dirent);
|
||||
}
|
||||
|
||||
static const struct dfs_file_ops _skt_fops =
|
||||
{
|
||||
dfs_skt_open,
|
||||
dfs_skt_close,
|
||||
dfs_skt_ioctl,
|
||||
dfs_skt_read,
|
||||
NULL, /* write */
|
||||
NULL, /* flush */
|
||||
dfs_skt_lseek,
|
||||
dfs_skt_getdents,
|
||||
};
|
||||
|
||||
static const struct dfs_filesystem_ops _skt_fs =
|
||||
{
|
||||
"skt",
|
||||
DFS_FS_FLAG_DEFAULT,
|
||||
&_skt_fops,
|
||||
|
||||
dfs_skt_mount,
|
||||
dfs_skt_unmount,
|
||||
NULL, /* mkfs */
|
||||
NULL, /* statfs */
|
||||
|
||||
NULL, /* unlink */
|
||||
dfs_skt_stat,
|
||||
NULL, /* rename */
|
||||
};
|
||||
|
||||
int dfs_skt_init(void)
|
||||
{
|
||||
/* register rom file system */
|
||||
dfs_register(&_skt_fs);
|
||||
return 0;
|
||||
}
|
||||
INIT_COMPONENT_EXPORT(dfs_skt_init);
|
||||
|
||||
@@ -0,0 +1,17 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
|
||||
#ifndef __SKELETON_H__
|
||||
#define __SKELETON_H__
|
||||
|
||||
#include <rtthread.h>
|
||||
|
||||
int dfs_skt_init(void);
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,101 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2005-02-22 Bernard The first version.
|
||||
*/
|
||||
|
||||
#ifndef __DFS_H__
|
||||
#define __DFS_H__
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <dirent.h>
|
||||
#include <fcntl.h>
|
||||
#include <sys/stat.h>
|
||||
#include <sys/statfs.h>
|
||||
#include <sys/time.h>
|
||||
#include <rtdevice.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifndef DFS_FILESYSTEMS_MAX
|
||||
#define DFS_FILESYSTEMS_MAX 4
|
||||
#endif
|
||||
|
||||
#ifndef DFS_FD_MAX
|
||||
#define DFS_FD_MAX 16
|
||||
#endif
|
||||
|
||||
/*
|
||||
* skip stdin/stdout/stderr normally
|
||||
*/
|
||||
#ifndef DFS_FD_OFFSET
|
||||
#define DFS_FD_OFFSET 3
|
||||
#endif
|
||||
|
||||
#ifndef DFS_PATH_MAX
|
||||
#define DFS_PATH_MAX DIRENT_NAME_MAX
|
||||
#endif
|
||||
|
||||
#ifndef SECTOR_SIZE
|
||||
#define SECTOR_SIZE 512
|
||||
#endif
|
||||
|
||||
#ifndef DFS_FILESYSTEM_TYPES_MAX
|
||||
#define DFS_FILESYSTEM_TYPES_MAX 2
|
||||
#endif
|
||||
|
||||
#define DFS_FS_FLAG_DEFAULT 0x00 /* default flag */
|
||||
#define DFS_FS_FLAG_FULLPATH 0x01 /* set full path to underlaying file system */
|
||||
|
||||
/* File types */
|
||||
#define FT_REGULAR 0 /* regular file */
|
||||
#define FT_SOCKET 1 /* socket file */
|
||||
#define FT_DIRECTORY 2 /* directory */
|
||||
#define FT_USER 3 /* user defined */
|
||||
#define FT_DEVICE 4 /* device */
|
||||
|
||||
/* File flags */
|
||||
#define DFS_F_OPEN 0x01000000
|
||||
#define DFS_F_DIRECTORY 0x02000000
|
||||
#define DFS_F_EOF 0x04000000
|
||||
#define DFS_F_ERR 0x08000000
|
||||
|
||||
struct dfs_fdtable
|
||||
{
|
||||
uint32_t maxfd;
|
||||
struct dfs_fd **fds;
|
||||
};
|
||||
|
||||
/* Initialization of dfs */
|
||||
int dfs_init(void);
|
||||
|
||||
char *dfs_normalize_path(const char *directory, const char *filename);
|
||||
const char *dfs_subdir(const char *directory, const char *filename);
|
||||
|
||||
int fd_is_open(const char *pathname);
|
||||
struct dfs_fdtable *dfs_fdtable_get(void);
|
||||
|
||||
void dfs_lock(void);
|
||||
void dfs_unlock(void);
|
||||
|
||||
#ifdef DFS_USING_POSIX
|
||||
/* FD APIs */
|
||||
int fd_new(void);
|
||||
struct dfs_fd *fd_get(int fd);
|
||||
void fd_put(struct dfs_fd *fd);
|
||||
#endif /* DFS_USING_POSIX */
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,78 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2005-01-26 Bernard The first version.
|
||||
*/
|
||||
|
||||
#ifndef __DFS_FILE_H__
|
||||
#define __DFS_FILE_H__
|
||||
|
||||
#include <dfs.h>
|
||||
#include <dfs_fs.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
struct rt_pollreq;
|
||||
|
||||
struct dfs_file_ops
|
||||
{
|
||||
int (*open) (struct dfs_fd *fd);
|
||||
int (*close) (struct dfs_fd *fd);
|
||||
int (*ioctl) (struct dfs_fd *fd, int cmd, void *args);
|
||||
int (*read) (struct dfs_fd *fd, void *buf, size_t count);
|
||||
int (*write) (struct dfs_fd *fd, const void *buf, size_t count);
|
||||
int (*flush) (struct dfs_fd *fd);
|
||||
int (*lseek) (struct dfs_fd *fd, off_t offset);
|
||||
int (*getdents) (struct dfs_fd *fd, struct dirent *dirp, uint32_t count);
|
||||
|
||||
int (*poll) (struct dfs_fd *fd, struct rt_pollreq *req);
|
||||
};
|
||||
|
||||
/* file descriptor */
|
||||
#define DFS_FD_MAGIC 0xfdfd
|
||||
struct dfs_fd
|
||||
{
|
||||
uint16_t magic; /* file descriptor magic number */
|
||||
uint16_t type; /* Type (regular or socket) */
|
||||
|
||||
char *path; /* Name (below mount point) */
|
||||
int ref_count; /* Descriptor reference count */
|
||||
|
||||
struct dfs_filesystem *fs;
|
||||
const struct dfs_file_ops *fops;
|
||||
|
||||
uint32_t flags; /* Descriptor flags */
|
||||
size_t size; /* Size in bytes */
|
||||
off_t pos; /* Current file position */
|
||||
|
||||
void *data; /* Specific file system data */
|
||||
};
|
||||
|
||||
int dfs_file_open(struct dfs_fd *fd, const char *path, int flags);
|
||||
int dfs_file_close(struct dfs_fd *fd);
|
||||
int dfs_file_ioctl(struct dfs_fd *fd, int cmd, void *args);
|
||||
int dfs_file_read(struct dfs_fd *fd, void *buf, size_t len);
|
||||
int dfs_file_getdents(struct dfs_fd *fd, struct dirent *dirp, size_t nbytes);
|
||||
int dfs_file_unlink(const char *path);
|
||||
int dfs_file_write(struct dfs_fd *fd, const void *buf, size_t len);
|
||||
int dfs_file_flush(struct dfs_fd *fd);
|
||||
int dfs_file_lseek(struct dfs_fd *fd, off_t offset);
|
||||
|
||||
int dfs_file_stat(const char *path, struct stat *buf);
|
||||
int dfs_file_rename(const char *oldpath, const char *newpath);
|
||||
int dfs_file_ftruncate(struct dfs_fd *fd, off_t length);
|
||||
|
||||
/* 0x5254 is just a magic number to make these relatively unique ("RT") */
|
||||
#define RT_FIOFTRUNCATE 0x52540000U
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,102 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2005-02-22 Bernard The first version.
|
||||
*/
|
||||
|
||||
#ifndef __DFS_FS_H__
|
||||
#define __DFS_FS_H__
|
||||
|
||||
#include <dfs.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/errno.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/* Pre-declaration */
|
||||
struct dfs_filesystem;
|
||||
struct dfs_fd;
|
||||
|
||||
/* File system operations */
|
||||
struct dfs_filesystem_ops
|
||||
{
|
||||
char *name;
|
||||
uint32_t flags; /* flags for file system operations */
|
||||
|
||||
/* operations for file */
|
||||
const struct dfs_file_ops *fops;
|
||||
|
||||
/* mount and unmount file system */
|
||||
int (*mount) (struct dfs_filesystem *fs, unsigned long rwflag, const void *data);
|
||||
int (*unmount) (struct dfs_filesystem *fs);
|
||||
|
||||
/* make a file system */
|
||||
int (*mkfs) (rt_device_t devid);
|
||||
int (*statfs) (struct dfs_filesystem *fs, struct statfs *buf);
|
||||
|
||||
int (*unlink) (struct dfs_filesystem *fs, const char *pathname);
|
||||
int (*stat) (struct dfs_filesystem *fs, const char *filename, struct stat *buf);
|
||||
int (*rename) (struct dfs_filesystem *fs, const char *oldpath, const char *newpath);
|
||||
};
|
||||
|
||||
/* Mounted file system */
|
||||
struct dfs_filesystem
|
||||
{
|
||||
rt_device_t dev_id; /* Attached device */
|
||||
|
||||
char *path; /* File system mount point */
|
||||
const struct dfs_filesystem_ops *ops; /* Operations for file system type */
|
||||
|
||||
void *data; /* Specific file system data */
|
||||
};
|
||||
|
||||
/* file system partition table */
|
||||
struct dfs_partition
|
||||
{
|
||||
uint8_t type; /* file system type */
|
||||
off_t offset; /* partition start offset */
|
||||
size_t size; /* partition size */
|
||||
rt_sem_t lock;
|
||||
};
|
||||
|
||||
/* mount table */
|
||||
struct dfs_mount_tbl
|
||||
{
|
||||
const char *device_name;
|
||||
const char *path;
|
||||
const char *filesystemtype;
|
||||
unsigned long rwflag;
|
||||
const void *data;
|
||||
};
|
||||
|
||||
int dfs_register(const struct dfs_filesystem_ops *ops);
|
||||
struct dfs_filesystem *dfs_filesystem_lookup(const char *path);
|
||||
const char *dfs_filesystem_get_mounted_path(struct rt_device *device);
|
||||
|
||||
int dfs_filesystem_get_partition(struct dfs_partition *part,
|
||||
uint8_t *buf,
|
||||
uint32_t pindex);
|
||||
|
||||
int dfs_mount(const char *device_name,
|
||||
const char *path,
|
||||
const char *filesystemtype,
|
||||
unsigned long rwflag,
|
||||
const void *data);
|
||||
int dfs_unmount(const char *specialfile);
|
||||
|
||||
int dfs_mkfs(const char *fs_name, const char *device_name);
|
||||
int dfs_statfs(const char *path, struct statfs *buffer);
|
||||
int dfs_mount_device(rt_device_t dev);
|
||||
int dfs_unmount_device(rt_device_t dev);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,28 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
|
||||
#ifndef DFS_PRIVATE_H__
|
||||
#define DFS_PRIVATE_H__
|
||||
|
||||
#include <dfs.h>
|
||||
|
||||
#define DBG_TAG "DFS"
|
||||
#define DBG_LVL DBG_INFO
|
||||
#include <rtdbg.h>
|
||||
|
||||
#define NO_WORKING_DIR "system does not support working directory\n"
|
||||
|
||||
/* extern variable */
|
||||
extern const struct dfs_filesystem_ops *filesystem_operation_table[];
|
||||
extern struct dfs_filesystem filesystem_table[];
|
||||
extern const struct dfs_mount_tbl mount_table[];
|
||||
|
||||
extern char working_directory[];
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,572 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2005-02-22 Bernard The first version.
|
||||
* 2017-12-11 Bernard Use rt_free to instead of free in fd_is_open().
|
||||
* 2018-03-20 Heyuanjie dynamic allocation FD
|
||||
*/
|
||||
|
||||
#include <dfs.h>
|
||||
#include <dfs_fs.h>
|
||||
#include <dfs_file.h>
|
||||
#include "dfs_private.h"
|
||||
#ifdef RT_USING_LWP
|
||||
#include <lwp.h>
|
||||
#endif
|
||||
|
||||
#ifdef RT_USING_POSIX_STDIO
|
||||
#include <libc.h>
|
||||
#endif /* RT_USING_POSIX_STDIO */
|
||||
|
||||
/* Global variables */
|
||||
const struct dfs_filesystem_ops *filesystem_operation_table[DFS_FILESYSTEM_TYPES_MAX];
|
||||
struct dfs_filesystem filesystem_table[DFS_FILESYSTEMS_MAX];
|
||||
|
||||
/* device filesystem lock */
|
||||
static struct rt_mutex fslock;
|
||||
|
||||
#ifdef DFS_USING_WORKDIR
|
||||
char working_directory[DFS_PATH_MAX] = {"/"};
|
||||
#endif
|
||||
|
||||
static struct dfs_fdtable _fdtab;
|
||||
|
||||
/**
|
||||
* @addtogroup DFS
|
||||
*/
|
||||
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
* this function will initialize device file system.
|
||||
*/
|
||||
int dfs_init(void)
|
||||
{
|
||||
static rt_bool_t init_ok = RT_FALSE;
|
||||
|
||||
if (init_ok)
|
||||
{
|
||||
rt_kprintf("dfs already init.\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* clear filesystem operations table */
|
||||
rt_memset((void *)filesystem_operation_table, 0, sizeof(filesystem_operation_table));
|
||||
/* clear filesystem table */
|
||||
rt_memset(filesystem_table, 0, sizeof(filesystem_table));
|
||||
/* clean fd table */
|
||||
rt_memset(&_fdtab, 0, sizeof(_fdtab));
|
||||
|
||||
/* create device filesystem lock */
|
||||
rt_mutex_init(&fslock, "fslock", RT_IPC_FLAG_PRIO);
|
||||
|
||||
#ifdef DFS_USING_WORKDIR
|
||||
/* set current working directory */
|
||||
rt_memset(working_directory, 0, sizeof(working_directory));
|
||||
working_directory[0] = '/';
|
||||
#endif
|
||||
|
||||
#ifdef RT_USING_DFS_DEVFS
|
||||
{
|
||||
extern int devfs_init(void);
|
||||
|
||||
/* if enable devfs, initialize and mount it as soon as possible */
|
||||
devfs_init();
|
||||
|
||||
dfs_mount(NULL, "/dev", "devfs", 0, 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
init_ok = RT_TRUE;
|
||||
|
||||
return 0;
|
||||
}
|
||||
INIT_PREV_EXPORT(dfs_init);
|
||||
|
||||
/**
|
||||
* this function will lock device file system.
|
||||
*
|
||||
* @note please don't invoke it on ISR.
|
||||
*/
|
||||
void dfs_lock(void)
|
||||
{
|
||||
rt_err_t result = -RT_EBUSY;
|
||||
|
||||
while (result == -RT_EBUSY)
|
||||
{
|
||||
result = rt_mutex_take(&fslock, RT_WAITING_FOREVER);
|
||||
}
|
||||
|
||||
if (result != RT_EOK)
|
||||
{
|
||||
RT_ASSERT(0);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* this function will lock device file system.
|
||||
*
|
||||
* @note please don't invoke it on ISR.
|
||||
*/
|
||||
void dfs_unlock(void)
|
||||
{
|
||||
rt_mutex_release(&fslock);
|
||||
}
|
||||
|
||||
#ifdef DFS_USING_POSIX
|
||||
static int fd_alloc(struct dfs_fdtable *fdt, int startfd)
|
||||
{
|
||||
int idx;
|
||||
|
||||
/* find an empty fd entry */
|
||||
for (idx = startfd; idx < (int)fdt->maxfd; idx++)
|
||||
{
|
||||
if (fdt->fds[idx] == RT_NULL)
|
||||
break;
|
||||
if (fdt->fds[idx]->ref_count == 0)
|
||||
break;
|
||||
}
|
||||
|
||||
/* allocate a larger FD container */
|
||||
if (idx == fdt->maxfd && fdt->maxfd < DFS_FD_MAX)
|
||||
{
|
||||
int cnt, index;
|
||||
struct dfs_fd **fds;
|
||||
|
||||
/* increase the number of FD with 4 step length */
|
||||
cnt = fdt->maxfd + 4;
|
||||
cnt = cnt > DFS_FD_MAX ? DFS_FD_MAX : cnt;
|
||||
|
||||
fds = (struct dfs_fd **)rt_realloc(fdt->fds, cnt * sizeof(struct dfs_fd *));
|
||||
if (fds == NULL) goto __exit; /* return fdt->maxfd */
|
||||
|
||||
/* clean the new allocated fds */
|
||||
for (index = fdt->maxfd; index < cnt; index ++)
|
||||
{
|
||||
fds[index] = NULL;
|
||||
}
|
||||
|
||||
fdt->fds = fds;
|
||||
fdt->maxfd = cnt;
|
||||
}
|
||||
|
||||
/* allocate 'struct dfs_fd' */
|
||||
if (idx < (int)fdt->maxfd && fdt->fds[idx] == RT_NULL)
|
||||
{
|
||||
fdt->fds[idx] = (struct dfs_fd *)rt_calloc(1, sizeof(struct dfs_fd));
|
||||
if (fdt->fds[idx] == RT_NULL)
|
||||
idx = fdt->maxfd;
|
||||
}
|
||||
|
||||
__exit:
|
||||
return idx;
|
||||
}
|
||||
|
||||
/**
|
||||
* @ingroup Fd
|
||||
* This function will allocate a file descriptor.
|
||||
*
|
||||
* @return -1 on failed or the allocated file descriptor.
|
||||
*/
|
||||
int fd_new(void)
|
||||
{
|
||||
struct dfs_fd *d;
|
||||
int idx;
|
||||
struct dfs_fdtable *fdt;
|
||||
|
||||
fdt = dfs_fdtable_get();
|
||||
/* lock filesystem */
|
||||
dfs_lock();
|
||||
|
||||
/* find an empty fd entry */
|
||||
idx = fd_alloc(fdt, 0);
|
||||
|
||||
/* can't find an empty fd entry */
|
||||
if (idx == fdt->maxfd)
|
||||
{
|
||||
idx = -(1 + DFS_FD_OFFSET);
|
||||
LOG_E("DFS fd new is failed! Could not found an empty fd entry.");
|
||||
goto __result;
|
||||
}
|
||||
|
||||
d = fdt->fds[idx];
|
||||
d->ref_count = 1;
|
||||
d->magic = DFS_FD_MAGIC;
|
||||
|
||||
__result:
|
||||
dfs_unlock();
|
||||
return idx + DFS_FD_OFFSET;
|
||||
}
|
||||
|
||||
/**
|
||||
* @ingroup Fd
|
||||
*
|
||||
* This function will return a file descriptor structure according to file
|
||||
* descriptor.
|
||||
*
|
||||
* @return NULL on on this file descriptor or the file descriptor structure
|
||||
* pointer.
|
||||
*/
|
||||
struct dfs_fd *fd_get(int fd)
|
||||
{
|
||||
struct dfs_fd *d;
|
||||
struct dfs_fdtable *fdt;
|
||||
|
||||
#ifdef RT_USING_POSIX_STDIO
|
||||
if ((0 <= fd) && (fd <= 2))
|
||||
fd = libc_stdio_get_console();
|
||||
#endif /* RT_USING_POSIX_STDIO */
|
||||
|
||||
fdt = dfs_fdtable_get();
|
||||
fd = fd - DFS_FD_OFFSET;
|
||||
if (fd < 0 || fd >= (int)fdt->maxfd)
|
||||
return NULL;
|
||||
|
||||
dfs_lock();
|
||||
d = fdt->fds[fd];
|
||||
|
||||
/* check dfs_fd valid or not */
|
||||
if ((d == NULL) || (d->magic != DFS_FD_MAGIC))
|
||||
{
|
||||
dfs_unlock();
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* increase the reference count */
|
||||
d->ref_count ++;
|
||||
dfs_unlock();
|
||||
|
||||
return d;
|
||||
}
|
||||
|
||||
/**
|
||||
* @ingroup Fd
|
||||
*
|
||||
* This function will put the file descriptor.
|
||||
*/
|
||||
void fd_put(struct dfs_fd *fd)
|
||||
{
|
||||
RT_ASSERT(fd != NULL);
|
||||
|
||||
dfs_lock();
|
||||
|
||||
fd->ref_count --;
|
||||
|
||||
/* clear this fd entry */
|
||||
if (fd->ref_count == 0)
|
||||
{
|
||||
int index;
|
||||
struct dfs_fdtable *fdt;
|
||||
|
||||
fdt = dfs_fdtable_get();
|
||||
for (index = 0; index < (int)fdt->maxfd; index ++)
|
||||
{
|
||||
if (fdt->fds[index] == fd)
|
||||
{
|
||||
rt_free(fd);
|
||||
fdt->fds[index] = 0;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
dfs_unlock();
|
||||
}
|
||||
|
||||
#endif /* DFS_USING_POSIX */
|
||||
|
||||
/**
|
||||
* @ingroup Fd
|
||||
*
|
||||
* This function will return whether this file has been opend.
|
||||
*
|
||||
* @param pathname the file path name.
|
||||
*
|
||||
* @return 0 on file has been open successfully, -1 on open failed.
|
||||
*/
|
||||
int fd_is_open(const char *pathname)
|
||||
{
|
||||
char *fullpath;
|
||||
unsigned int index;
|
||||
struct dfs_filesystem *fs;
|
||||
struct dfs_fd *fd;
|
||||
struct dfs_fdtable *fdt;
|
||||
|
||||
fdt = dfs_fdtable_get();
|
||||
fullpath = dfs_normalize_path(NULL, pathname);
|
||||
if (fullpath != NULL)
|
||||
{
|
||||
char *mountpath;
|
||||
fs = dfs_filesystem_lookup(fullpath);
|
||||
if (fs == NULL)
|
||||
{
|
||||
/* can't find mounted file system */
|
||||
rt_free(fullpath);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* get file path name under mounted file system */
|
||||
if (fs->path[0] == '/' && fs->path[1] == '\0')
|
||||
mountpath = fullpath;
|
||||
else
|
||||
mountpath = fullpath + strlen(fs->path);
|
||||
|
||||
dfs_lock();
|
||||
|
||||
for (index = 0; index < fdt->maxfd; index++)
|
||||
{
|
||||
fd = fdt->fds[index];
|
||||
if (fd == NULL || fd->fops == NULL || fd->path == NULL) continue;
|
||||
|
||||
if (fd->fs == fs && strcmp(fd->path, mountpath) == 0)
|
||||
{
|
||||
/* found file in file descriptor table */
|
||||
rt_free(fullpath);
|
||||
dfs_unlock();
|
||||
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
dfs_unlock();
|
||||
|
||||
rt_free(fullpath);
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* this function will return a sub-path name under directory.
|
||||
*
|
||||
* @param directory the parent directory.
|
||||
* @param filename the filename.
|
||||
*
|
||||
* @return the subdir pointer in filename
|
||||
*/
|
||||
const char *dfs_subdir(const char *directory, const char *filename)
|
||||
{
|
||||
const char *dir;
|
||||
|
||||
if (strlen(directory) == strlen(filename)) /* it's a same path */
|
||||
return NULL;
|
||||
|
||||
dir = filename + strlen(directory);
|
||||
if ((*dir != '/') && (dir != filename))
|
||||
{
|
||||
dir --;
|
||||
}
|
||||
|
||||
return dir;
|
||||
}
|
||||
RTM_EXPORT(dfs_subdir);
|
||||
|
||||
/**
|
||||
* this function will normalize a path according to specified parent directory
|
||||
* and file name.
|
||||
*
|
||||
* @param directory the parent path
|
||||
* @param filename the file name
|
||||
*
|
||||
* @return the built full file path (absolute path)
|
||||
*/
|
||||
char *dfs_normalize_path(const char *directory, const char *filename)
|
||||
{
|
||||
char *fullpath;
|
||||
char *dst0, *dst, *src;
|
||||
|
||||
/* check parameters */
|
||||
RT_ASSERT(filename != NULL);
|
||||
|
||||
#ifdef DFS_USING_WORKDIR
|
||||
if (directory == NULL) /* shall use working directory */
|
||||
directory = &working_directory[0];
|
||||
#else
|
||||
if ((directory == NULL) && (filename[0] != '/'))
|
||||
{
|
||||
rt_kprintf(NO_WORKING_DIR);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (filename[0] != '/') /* it's a absolute path, use it directly */
|
||||
{
|
||||
fullpath = (char *)rt_malloc(strlen(directory) + strlen(filename) + 2);
|
||||
|
||||
if (fullpath == NULL)
|
||||
return NULL;
|
||||
|
||||
/* join path and file name */
|
||||
rt_snprintf(fullpath, strlen(directory) + strlen(filename) + 2,
|
||||
"%s/%s", directory, filename);
|
||||
}
|
||||
else
|
||||
{
|
||||
fullpath = rt_strdup(filename); /* copy string */
|
||||
|
||||
if (fullpath == NULL)
|
||||
return NULL;
|
||||
}
|
||||
|
||||
src = fullpath;
|
||||
dst = fullpath;
|
||||
|
||||
dst0 = dst;
|
||||
while (1)
|
||||
{
|
||||
char c = *src;
|
||||
|
||||
if (c == '.')
|
||||
{
|
||||
if (!src[1]) src ++; /* '.' and ends */
|
||||
else if (src[1] == '/')
|
||||
{
|
||||
/* './' case */
|
||||
src += 2;
|
||||
|
||||
while ((*src == '/') && (*src != '\0'))
|
||||
src ++;
|
||||
continue;
|
||||
}
|
||||
else if (src[1] == '.')
|
||||
{
|
||||
if (!src[2])
|
||||
{
|
||||
/* '..' and ends case */
|
||||
src += 2;
|
||||
goto up_one;
|
||||
}
|
||||
else if (src[2] == '/')
|
||||
{
|
||||
/* '../' case */
|
||||
src += 3;
|
||||
|
||||
while ((*src == '/') && (*src != '\0'))
|
||||
src ++;
|
||||
goto up_one;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* copy up the next '/' and erase all '/' */
|
||||
while ((c = *src++) != '\0' && c != '/')
|
||||
*dst ++ = c;
|
||||
|
||||
if (c == '/')
|
||||
{
|
||||
*dst ++ = '/';
|
||||
while (c == '/')
|
||||
c = *src++;
|
||||
|
||||
src --;
|
||||
}
|
||||
else if (!c)
|
||||
break;
|
||||
|
||||
continue;
|
||||
|
||||
up_one:
|
||||
dst --;
|
||||
if (dst < dst0)
|
||||
{
|
||||
rt_free(fullpath);
|
||||
return NULL;
|
||||
}
|
||||
while (dst0 < dst && dst[-1] != '/')
|
||||
dst --;
|
||||
}
|
||||
|
||||
*dst = '\0';
|
||||
|
||||
/* remove '/' in the end of path if exist */
|
||||
dst --;
|
||||
if ((dst != fullpath) && (*dst == '/'))
|
||||
*dst = '\0';
|
||||
|
||||
/* final check fullpath is not empty, for the special path of lwext "/.." */
|
||||
if ('\0' == fullpath[0])
|
||||
{
|
||||
fullpath[0] = '/';
|
||||
fullpath[1] = '\0';
|
||||
}
|
||||
|
||||
return fullpath;
|
||||
}
|
||||
RTM_EXPORT(dfs_normalize_path);
|
||||
|
||||
/**
|
||||
* This function will get the file descriptor table of current process.
|
||||
*/
|
||||
struct dfs_fdtable *dfs_fdtable_get(void)
|
||||
{
|
||||
struct dfs_fdtable *fdt;
|
||||
#ifdef RT_USING_LWP
|
||||
struct rt_lwp *lwp;
|
||||
|
||||
lwp = (struct rt_lwp *)rt_thread_self()->lwp;
|
||||
if (lwp)
|
||||
fdt = &lwp->fdt;
|
||||
else
|
||||
fdt = &_fdtab;
|
||||
#else
|
||||
fdt = &_fdtab;
|
||||
#endif
|
||||
|
||||
return fdt;
|
||||
}
|
||||
|
||||
#ifdef RT_USING_FINSH
|
||||
#include <finsh.h>
|
||||
int list_fd(void)
|
||||
{
|
||||
int index;
|
||||
struct dfs_fdtable *fd_table;
|
||||
|
||||
fd_table = dfs_fdtable_get();
|
||||
if (!fd_table) return -1;
|
||||
|
||||
rt_enter_critical();
|
||||
|
||||
rt_kprintf("fd type ref magic path\n");
|
||||
rt_kprintf("-- ------ --- ----- ------\n");
|
||||
for (index = 0; index < (int)fd_table->maxfd; index ++)
|
||||
{
|
||||
struct dfs_fd *fd = fd_table->fds[index];
|
||||
|
||||
if (fd && fd->fops)
|
||||
{
|
||||
rt_kprintf("%2d ", index + DFS_FD_OFFSET);
|
||||
if (fd->type == FT_DIRECTORY) rt_kprintf("%-7.7s ", "dir");
|
||||
else if (fd->type == FT_REGULAR) rt_kprintf("%-7.7s ", "file");
|
||||
else if (fd->type == FT_SOCKET) rt_kprintf("%-7.7s ", "socket");
|
||||
else if (fd->type == FT_USER) rt_kprintf("%-7.7s ", "user");
|
||||
else if (fd->type == FT_DEVICE) rt_kprintf("%-7.7s ", "device");
|
||||
else rt_kprintf("%-8.8s ", "unknown");
|
||||
rt_kprintf("%3d ", fd->ref_count);
|
||||
rt_kprintf("%04x ", fd->magic);
|
||||
if (fd->fs && fd->fs->path && rt_strlen(fd->fs->path) > 1)
|
||||
{
|
||||
rt_kprintf("%s", fd->fs->path);
|
||||
}
|
||||
if (fd->path)
|
||||
{
|
||||
rt_kprintf("%s\n", fd->path);
|
||||
}
|
||||
else
|
||||
{
|
||||
rt_kprintf("\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
rt_exit_critical();
|
||||
|
||||
return 0;
|
||||
}
|
||||
MSH_CMD_EXPORT(list_fd, list file descriptor);
|
||||
#endif
|
||||
/*@}*/
|
||||
|
||||
@@ -0,0 +1,850 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2005-02-22 Bernard The first version.
|
||||
* 2011-12-08 Bernard Merges rename patch from iamcacy.
|
||||
* 2015-05-27 Bernard Fix the fd clear issue.
|
||||
* 2019-01-24 Bernard Remove file repeatedly open check.
|
||||
*/
|
||||
|
||||
#include <dfs.h>
|
||||
#include <dfs_file.h>
|
||||
#include <dfs_private.h>
|
||||
|
||||
/**
|
||||
* @addtogroup FileApi
|
||||
*/
|
||||
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
* this function will open a file which specified by path with specified flags.
|
||||
*
|
||||
* @param fd the file descriptor pointer to return the corresponding result.
|
||||
* @param path the specified file path.
|
||||
* @param flags the flags for open operator.
|
||||
*
|
||||
* @return 0 on successful, -1 on failed.
|
||||
*/
|
||||
int dfs_file_open(struct dfs_fd *fd, const char *path, int flags)
|
||||
{
|
||||
struct dfs_filesystem *fs;
|
||||
char *fullpath;
|
||||
int result;
|
||||
|
||||
/* parameter check */
|
||||
if (fd == NULL)
|
||||
return -EINVAL;
|
||||
|
||||
/* make sure we have an absolute path */
|
||||
fullpath = dfs_normalize_path(NULL, path);
|
||||
if (fullpath == NULL)
|
||||
{
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
LOG_D("open file:%s", fullpath);
|
||||
|
||||
/* find filesystem */
|
||||
fs = dfs_filesystem_lookup(fullpath);
|
||||
if (fs == NULL)
|
||||
{
|
||||
rt_free(fullpath); /* release path */
|
||||
|
||||
return -ENOENT;
|
||||
}
|
||||
|
||||
LOG_D("open in filesystem:%s", fs->ops->name);
|
||||
fd->fs = fs; /* set file system */
|
||||
fd->fops = fs->ops->fops; /* set file ops */
|
||||
|
||||
/* initialize the fd item */
|
||||
fd->type = FT_REGULAR;
|
||||
fd->flags = flags;
|
||||
fd->size = 0;
|
||||
fd->pos = 0;
|
||||
fd->data = fs;
|
||||
|
||||
if (!(fs->ops->flags & DFS_FS_FLAG_FULLPATH))
|
||||
{
|
||||
if (dfs_subdir(fs->path, fullpath) == NULL)
|
||||
fd->path = rt_strdup("/");
|
||||
else
|
||||
fd->path = rt_strdup(dfs_subdir(fs->path, fullpath));
|
||||
rt_free(fullpath);
|
||||
LOG_D("Actual file path: %s", fd->path);
|
||||
}
|
||||
else
|
||||
{
|
||||
fd->path = fullpath;
|
||||
}
|
||||
|
||||
/* specific file system open routine */
|
||||
if (fd->fops->open == NULL)
|
||||
{
|
||||
/* clear fd */
|
||||
rt_free(fd->path);
|
||||
fd->path = NULL;
|
||||
|
||||
return -ENOSYS;
|
||||
}
|
||||
|
||||
if ((result = fd->fops->open(fd)) < 0)
|
||||
{
|
||||
/* clear fd */
|
||||
rt_free(fd->path);
|
||||
fd->path = NULL;
|
||||
|
||||
LOG_D("%s open failed", fullpath);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
fd->flags |= DFS_F_OPEN;
|
||||
if (flags & O_DIRECTORY)
|
||||
{
|
||||
fd->type = FT_DIRECTORY;
|
||||
fd->flags |= DFS_F_DIRECTORY;
|
||||
}
|
||||
|
||||
LOG_D("open successful");
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* this function will close a file descriptor.
|
||||
*
|
||||
* @param fd the file descriptor to be closed.
|
||||
*
|
||||
* @return 0 on successful, -1 on failed.
|
||||
*/
|
||||
int dfs_file_close(struct dfs_fd *fd)
|
||||
{
|
||||
int result = 0;
|
||||
|
||||
if (fd == NULL)
|
||||
return -ENXIO;
|
||||
|
||||
if (fd->fops->close != NULL)
|
||||
result = fd->fops->close(fd);
|
||||
|
||||
/* close fd error, return */
|
||||
if (result < 0)
|
||||
return result;
|
||||
|
||||
rt_free(fd->path);
|
||||
fd->path = NULL;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* this function will perform a io control on a file descriptor.
|
||||
*
|
||||
* @param fd the file descriptor.
|
||||
* @param cmd the command to send to file descriptor.
|
||||
* @param args the argument to send to file descriptor.
|
||||
*
|
||||
* @return 0 on successful, -1 on failed.
|
||||
*/
|
||||
int dfs_file_ioctl(struct dfs_fd *fd, int cmd, void *args)
|
||||
{
|
||||
if (fd == NULL)
|
||||
return -EINVAL;
|
||||
|
||||
/* regular file system fd */
|
||||
if (fd->type == FT_REGULAR)
|
||||
{
|
||||
switch (cmd)
|
||||
{
|
||||
case F_GETFL:
|
||||
return fd->flags; /* return flags */
|
||||
case F_SETFL:
|
||||
{
|
||||
int flags = (int)(rt_base_t)args;
|
||||
int mask = O_NONBLOCK | O_APPEND;
|
||||
|
||||
flags &= mask;
|
||||
fd->flags &= ~mask;
|
||||
fd->flags |= flags;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (fd->fops->ioctl != NULL)
|
||||
return fd->fops->ioctl(fd, cmd, args);
|
||||
|
||||
return -ENOSYS;
|
||||
}
|
||||
|
||||
/**
|
||||
* this function will read specified length data from a file descriptor to a
|
||||
* buffer.
|
||||
*
|
||||
* @param fd the file descriptor.
|
||||
* @param buf the buffer to save the read data.
|
||||
* @param len the length of data buffer to be read.
|
||||
*
|
||||
* @return the actual read data bytes or 0 on end of file or failed.
|
||||
*/
|
||||
int dfs_file_read(struct dfs_fd *fd, void *buf, size_t len)
|
||||
{
|
||||
int result = 0;
|
||||
|
||||
if (fd == NULL)
|
||||
return -EINVAL;
|
||||
|
||||
if (fd->fops->read == NULL)
|
||||
return -ENOSYS;
|
||||
|
||||
if ((result = fd->fops->read(fd, buf, len)) < 0)
|
||||
fd->flags |= DFS_F_EOF;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* this function will fetch directory entries from a directory descriptor.
|
||||
*
|
||||
* @param fd the directory descriptor.
|
||||
* @param dirp the dirent buffer to save result.
|
||||
* @param nbytes the available room in the buffer.
|
||||
*
|
||||
* @return the read dirent, others on failed.
|
||||
*/
|
||||
int dfs_file_getdents(struct dfs_fd *fd, struct dirent *dirp, size_t nbytes)
|
||||
{
|
||||
/* parameter check */
|
||||
if (fd == NULL || fd->type != FT_DIRECTORY)
|
||||
return -EINVAL;
|
||||
|
||||
if (fd->fops->getdents != NULL)
|
||||
return fd->fops->getdents(fd, dirp, nbytes);
|
||||
|
||||
return -ENOSYS;
|
||||
}
|
||||
|
||||
/**
|
||||
* this function will unlink (remove) a specified path file from file system.
|
||||
*
|
||||
* @param path the specified path file to be unlinked.
|
||||
*
|
||||
* @return 0 on successful, -1 on failed.
|
||||
*/
|
||||
int dfs_file_unlink(const char *path)
|
||||
{
|
||||
int result;
|
||||
char *fullpath;
|
||||
struct dfs_filesystem *fs;
|
||||
|
||||
/* Make sure we have an absolute path */
|
||||
fullpath = dfs_normalize_path(NULL, path);
|
||||
if (fullpath == NULL)
|
||||
{
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* get filesystem */
|
||||
if ((fs = dfs_filesystem_lookup(fullpath)) == NULL)
|
||||
{
|
||||
result = -ENOENT;
|
||||
goto __exit;
|
||||
}
|
||||
|
||||
/* Check whether file is already open */
|
||||
if (fd_is_open(fullpath) == 0)
|
||||
{
|
||||
result = -EBUSY;
|
||||
goto __exit;
|
||||
}
|
||||
|
||||
if (fs->ops->unlink != NULL)
|
||||
{
|
||||
if (!(fs->ops->flags & DFS_FS_FLAG_FULLPATH))
|
||||
{
|
||||
if (dfs_subdir(fs->path, fullpath) == NULL)
|
||||
result = fs->ops->unlink(fs, "/");
|
||||
else
|
||||
result = fs->ops->unlink(fs, dfs_subdir(fs->path, fullpath));
|
||||
}
|
||||
else
|
||||
result = fs->ops->unlink(fs, fullpath);
|
||||
}
|
||||
else result = -ENOSYS;
|
||||
|
||||
__exit:
|
||||
rt_free(fullpath);
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* this function will write some specified length data to file system.
|
||||
*
|
||||
* @param fd the file descriptor.
|
||||
* @param buf the data buffer to be written.
|
||||
* @param len the data buffer length
|
||||
*
|
||||
* @return the actual written data length.
|
||||
*/
|
||||
int dfs_file_write(struct dfs_fd *fd, const void *buf, size_t len)
|
||||
{
|
||||
if (fd == NULL)
|
||||
return -EINVAL;
|
||||
|
||||
if (fd->fops->write == NULL)
|
||||
return -ENOSYS;
|
||||
|
||||
return fd->fops->write(fd, buf, len);
|
||||
}
|
||||
|
||||
/**
|
||||
* this function will flush buffer on a file descriptor.
|
||||
*
|
||||
* @param fd the file descriptor.
|
||||
*
|
||||
* @return 0 on successful, -1 on failed.
|
||||
*/
|
||||
int dfs_file_flush(struct dfs_fd *fd)
|
||||
{
|
||||
if (fd == NULL)
|
||||
return -EINVAL;
|
||||
|
||||
if (fd->fops->flush == NULL)
|
||||
return -ENOSYS;
|
||||
|
||||
return fd->fops->flush(fd);
|
||||
}
|
||||
|
||||
/**
|
||||
* this function will seek the offset for specified file descriptor.
|
||||
*
|
||||
* @param fd the file descriptor.
|
||||
* @param offset the offset to be sought.
|
||||
*
|
||||
* @return the current position after seek.
|
||||
*/
|
||||
int dfs_file_lseek(struct dfs_fd *fd, off_t offset)
|
||||
{
|
||||
int result;
|
||||
|
||||
if (fd == NULL)
|
||||
return -EINVAL;
|
||||
|
||||
if (fd->fops->lseek == NULL)
|
||||
return -ENOSYS;
|
||||
|
||||
result = fd->fops->lseek(fd, offset);
|
||||
|
||||
/* update current position */
|
||||
if (result >= 0)
|
||||
fd->pos = result;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* this function will get file information.
|
||||
*
|
||||
* @param path the file path.
|
||||
* @param buf the data buffer to save stat description.
|
||||
*
|
||||
* @return 0 on successful, -1 on failed.
|
||||
*/
|
||||
int dfs_file_stat(const char *path, struct stat *buf)
|
||||
{
|
||||
int result;
|
||||
char *fullpath;
|
||||
struct dfs_filesystem *fs;
|
||||
|
||||
fullpath = dfs_normalize_path(NULL, path);
|
||||
if (fullpath == NULL)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
if ((fs = dfs_filesystem_lookup(fullpath)) == NULL)
|
||||
{
|
||||
LOG_E("can't find mounted filesystem on this path:%s", fullpath);
|
||||
rt_free(fullpath);
|
||||
|
||||
return -ENOENT;
|
||||
}
|
||||
|
||||
if ((fullpath[0] == '/' && fullpath[1] == '\0') ||
|
||||
(dfs_subdir(fs->path, fullpath) == NULL))
|
||||
{
|
||||
/* it's the root directory */
|
||||
buf->st_dev = 0;
|
||||
|
||||
buf->st_mode = S_IRUSR | S_IRGRP | S_IROTH |
|
||||
S_IWUSR | S_IWGRP | S_IWOTH;
|
||||
buf->st_mode |= S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH;
|
||||
|
||||
buf->st_size = 0;
|
||||
buf->st_mtime = 0;
|
||||
|
||||
/* release full path */
|
||||
rt_free(fullpath);
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (fs->ops->stat == NULL)
|
||||
{
|
||||
rt_free(fullpath);
|
||||
LOG_E("the filesystem didn't implement this function");
|
||||
|
||||
return -ENOSYS;
|
||||
}
|
||||
|
||||
/* get the real file path and get file stat */
|
||||
if (fs->ops->flags & DFS_FS_FLAG_FULLPATH)
|
||||
result = fs->ops->stat(fs, fullpath, buf);
|
||||
else
|
||||
result = fs->ops->stat(fs, dfs_subdir(fs->path, fullpath), buf);
|
||||
}
|
||||
|
||||
rt_free(fullpath);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* this function will rename an old path name to a new path name.
|
||||
*
|
||||
* @param oldpath the old path name.
|
||||
* @param newpath the new path name.
|
||||
*
|
||||
* @return 0 on successful, -1 on failed.
|
||||
*/
|
||||
int dfs_file_rename(const char *oldpath, const char *newpath)
|
||||
{
|
||||
int result;
|
||||
struct dfs_filesystem *oldfs, *newfs;
|
||||
char *oldfullpath, *newfullpath;
|
||||
|
||||
result = RT_EOK;
|
||||
newfullpath = NULL;
|
||||
oldfullpath = NULL;
|
||||
|
||||
oldfullpath = dfs_normalize_path(NULL, oldpath);
|
||||
if (oldfullpath == NULL)
|
||||
{
|
||||
result = -ENOENT;
|
||||
goto __exit;
|
||||
}
|
||||
|
||||
newfullpath = dfs_normalize_path(NULL, newpath);
|
||||
if (newfullpath == NULL)
|
||||
{
|
||||
result = -ENOENT;
|
||||
goto __exit;
|
||||
}
|
||||
|
||||
oldfs = dfs_filesystem_lookup(oldfullpath);
|
||||
newfs = dfs_filesystem_lookup(newfullpath);
|
||||
|
||||
if (oldfs == newfs)
|
||||
{
|
||||
if (oldfs->ops->rename == NULL)
|
||||
{
|
||||
result = -ENOSYS;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (oldfs->ops->flags & DFS_FS_FLAG_FULLPATH)
|
||||
result = oldfs->ops->rename(oldfs, oldfullpath, newfullpath);
|
||||
else
|
||||
/* use sub directory to rename in file system */
|
||||
result = oldfs->ops->rename(oldfs,
|
||||
dfs_subdir(oldfs->path, oldfullpath),
|
||||
dfs_subdir(newfs->path, newfullpath));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
result = -EXDEV;
|
||||
}
|
||||
|
||||
__exit:
|
||||
rt_free(oldfullpath);
|
||||
rt_free(newfullpath);
|
||||
|
||||
/* not at same file system, return EXDEV */
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* this function is will cause the regular file referenced by fd
|
||||
* to be truncated to a size of precisely length bytes.
|
||||
*
|
||||
* @param fd the file descriptor.
|
||||
* @param length the length to be truncated.
|
||||
*
|
||||
* @return the status of truncated.
|
||||
*/
|
||||
int dfs_file_ftruncate(struct dfs_fd *fd, off_t length)
|
||||
{
|
||||
int result;
|
||||
|
||||
/* fd is null or not a regular file system fd, or length is invalid */
|
||||
if (fd == NULL || fd->type != FT_REGULAR || length < 0)
|
||||
return -EINVAL;
|
||||
|
||||
if (fd->fops->ioctl == NULL)
|
||||
return -ENOSYS;
|
||||
|
||||
result = fd->fops->ioctl(fd, RT_FIOFTRUNCATE, (void*)&length);
|
||||
|
||||
/* update current size */
|
||||
if (result == 0)
|
||||
fd->size = length;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
#ifdef RT_USING_FINSH
|
||||
#include <finsh.h>
|
||||
|
||||
static struct dfs_fd fd;
|
||||
static struct dirent dirent;
|
||||
void ls(const char *pathname)
|
||||
{
|
||||
struct stat stat;
|
||||
int length;
|
||||
char *fullpath, *path;
|
||||
|
||||
fullpath = NULL;
|
||||
if (pathname == NULL)
|
||||
{
|
||||
#ifdef DFS_USING_WORKDIR
|
||||
/* open current working directory */
|
||||
path = rt_strdup(working_directory);
|
||||
#else
|
||||
path = rt_strdup("/");
|
||||
#endif
|
||||
if (path == NULL)
|
||||
return ; /* out of memory */
|
||||
}
|
||||
else
|
||||
{
|
||||
path = (char *)pathname;
|
||||
}
|
||||
|
||||
/* list directory */
|
||||
if (dfs_file_open(&fd, path, O_DIRECTORY) == 0)
|
||||
{
|
||||
rt_kprintf("Directory %s:\n", path);
|
||||
do
|
||||
{
|
||||
rt_memset(&dirent, 0, sizeof(struct dirent));
|
||||
length = dfs_file_getdents(&fd, &dirent, sizeof(struct dirent));
|
||||
if (length > 0)
|
||||
{
|
||||
rt_memset(&stat, 0, sizeof(struct stat));
|
||||
|
||||
/* build full path for each file */
|
||||
fullpath = dfs_normalize_path(path, dirent.d_name);
|
||||
if (fullpath == NULL)
|
||||
break;
|
||||
|
||||
if (dfs_file_stat(fullpath, &stat) == 0)
|
||||
{
|
||||
rt_kprintf("%-20s", dirent.d_name);
|
||||
if (S_ISDIR(stat.st_mode))
|
||||
{
|
||||
rt_kprintf("%-25s\n", "<DIR>");
|
||||
}
|
||||
else
|
||||
{
|
||||
rt_kprintf("%-25lu\n", (unsigned long)stat.st_size);
|
||||
}
|
||||
}
|
||||
else
|
||||
rt_kprintf("BAD file: %s\n", dirent.d_name);
|
||||
rt_free(fullpath);
|
||||
}
|
||||
}
|
||||
while (length > 0);
|
||||
|
||||
dfs_file_close(&fd);
|
||||
}
|
||||
else
|
||||
{
|
||||
rt_kprintf("No such directory\n");
|
||||
}
|
||||
if (pathname == NULL)
|
||||
rt_free(path);
|
||||
}
|
||||
FINSH_FUNCTION_EXPORT(ls, list directory contents);
|
||||
|
||||
void rm(const char *filename)
|
||||
{
|
||||
if (dfs_file_unlink(filename) < 0)
|
||||
{
|
||||
rt_kprintf("Delete %s failed\n", filename);
|
||||
}
|
||||
}
|
||||
FINSH_FUNCTION_EXPORT(rm, remove files or directories);
|
||||
|
||||
void cat(const char *filename)
|
||||
{
|
||||
uint32_t length;
|
||||
char buffer[81];
|
||||
|
||||
if (dfs_file_open(&fd, filename, O_RDONLY) < 0)
|
||||
{
|
||||
rt_kprintf("Open %s failed\n", filename);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
do
|
||||
{
|
||||
rt_memset(buffer, 0, sizeof(buffer));
|
||||
length = dfs_file_read(&fd, buffer, sizeof(buffer) - 1);
|
||||
if (length > 0)
|
||||
{
|
||||
rt_kprintf("%s", buffer);
|
||||
}
|
||||
}
|
||||
while (length > 0);
|
||||
rt_kprintf("\n");
|
||||
|
||||
dfs_file_close(&fd);
|
||||
}
|
||||
FINSH_FUNCTION_EXPORT(cat, print file);
|
||||
|
||||
#ifdef DFS_USING_POSIX
|
||||
#define BUF_SZ 4096
|
||||
static void copyfile(const char *src, const char *dst)
|
||||
{
|
||||
struct dfs_fd src_fd;
|
||||
rt_uint8_t *block_ptr;
|
||||
rt_int32_t read_bytes;
|
||||
|
||||
block_ptr = (rt_uint8_t *)rt_malloc(BUF_SZ);
|
||||
if (block_ptr == NULL)
|
||||
{
|
||||
rt_kprintf("out of memory\n");
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if (dfs_file_open(&src_fd, src, O_RDONLY) < 0)
|
||||
{
|
||||
rt_free(block_ptr);
|
||||
rt_kprintf("Read %s failed\n", src);
|
||||
|
||||
return;
|
||||
}
|
||||
if (dfs_file_open(&fd, dst, O_WRONLY | O_CREAT) < 0)
|
||||
{
|
||||
rt_free(block_ptr);
|
||||
dfs_file_close(&src_fd);
|
||||
|
||||
rt_kprintf("Write %s failed\n", dst);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
do
|
||||
{
|
||||
read_bytes = dfs_file_read(&src_fd, block_ptr, BUF_SZ);
|
||||
if (read_bytes > 0)
|
||||
{
|
||||
int length;
|
||||
|
||||
length = dfs_file_write(&fd, block_ptr, read_bytes);
|
||||
if (length != read_bytes)
|
||||
{
|
||||
/* write failed. */
|
||||
rt_kprintf("Write file data failed, errno=%d\n", length);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
while (read_bytes > 0);
|
||||
|
||||
dfs_file_close(&src_fd);
|
||||
dfs_file_close(&fd);
|
||||
rt_free(block_ptr);
|
||||
}
|
||||
|
||||
extern int mkdir(const char *path, mode_t mode);
|
||||
static void copydir(const char *src, const char *dst)
|
||||
{
|
||||
struct dirent dirent;
|
||||
struct stat stat;
|
||||
int length;
|
||||
struct dfs_fd cpfd;
|
||||
if (dfs_file_open(&cpfd, src, O_DIRECTORY) < 0)
|
||||
{
|
||||
rt_kprintf("open %s failed\n", src);
|
||||
return ;
|
||||
}
|
||||
|
||||
do
|
||||
{
|
||||
rt_memset(&dirent, 0, sizeof(struct dirent));
|
||||
|
||||
length = dfs_file_getdents(&cpfd, &dirent, sizeof(struct dirent));
|
||||
if (length > 0)
|
||||
{
|
||||
char *src_entry_full = NULL;
|
||||
char *dst_entry_full = NULL;
|
||||
|
||||
if (strcmp(dirent.d_name, "..") == 0 || strcmp(dirent.d_name, ".") == 0)
|
||||
continue;
|
||||
|
||||
/* build full path for each file */
|
||||
if ((src_entry_full = dfs_normalize_path(src, dirent.d_name)) == NULL)
|
||||
{
|
||||
rt_kprintf("out of memory!\n");
|
||||
break;
|
||||
}
|
||||
if ((dst_entry_full = dfs_normalize_path(dst, dirent.d_name)) == NULL)
|
||||
{
|
||||
rt_kprintf("out of memory!\n");
|
||||
rt_free(src_entry_full);
|
||||
break;
|
||||
}
|
||||
|
||||
rt_memset(&stat, 0, sizeof(struct stat));
|
||||
if (dfs_file_stat(src_entry_full, &stat) != 0)
|
||||
{
|
||||
rt_kprintf("open file: %s failed\n", dirent.d_name);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (S_ISDIR(stat.st_mode))
|
||||
{
|
||||
mkdir(dst_entry_full, 0);
|
||||
copydir(src_entry_full, dst_entry_full);
|
||||
}
|
||||
else
|
||||
{
|
||||
copyfile(src_entry_full, dst_entry_full);
|
||||
}
|
||||
rt_free(src_entry_full);
|
||||
rt_free(dst_entry_full);
|
||||
}
|
||||
}
|
||||
while (length > 0);
|
||||
|
||||
dfs_file_close(&cpfd);
|
||||
}
|
||||
|
||||
static const char *_get_path_lastname(const char *path)
|
||||
{
|
||||
char *ptr;
|
||||
if ((ptr = (char *)strrchr(path, '/')) == NULL)
|
||||
return path;
|
||||
|
||||
/* skip the '/' then return */
|
||||
return ++ptr;
|
||||
}
|
||||
|
||||
void copy(const char *src, const char *dst)
|
||||
{
|
||||
#define FLAG_SRC_TYPE 0x03
|
||||
#define FLAG_SRC_IS_DIR 0x01
|
||||
#define FLAG_SRC_IS_FILE 0x02
|
||||
#define FLAG_SRC_NON_EXSIT 0x00
|
||||
|
||||
#define FLAG_DST_TYPE 0x0C
|
||||
#define FLAG_DST_IS_DIR 0x04
|
||||
#define FLAG_DST_IS_FILE 0x08
|
||||
#define FLAG_DST_NON_EXSIT 0x00
|
||||
|
||||
struct stat stat;
|
||||
uint32_t flag = 0;
|
||||
|
||||
/* check the staus of src and dst */
|
||||
if (dfs_file_stat(src, &stat) < 0)
|
||||
{
|
||||
rt_kprintf("copy failed, bad %s\n", src);
|
||||
return;
|
||||
}
|
||||
if (S_ISDIR(stat.st_mode))
|
||||
flag |= FLAG_SRC_IS_DIR;
|
||||
else
|
||||
flag |= FLAG_SRC_IS_FILE;
|
||||
|
||||
if (dfs_file_stat(dst, &stat) < 0)
|
||||
{
|
||||
flag |= FLAG_DST_NON_EXSIT;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (S_ISDIR(stat.st_mode))
|
||||
flag |= FLAG_DST_IS_DIR;
|
||||
else
|
||||
flag |= FLAG_DST_IS_FILE;
|
||||
}
|
||||
|
||||
//2. check status
|
||||
if ((flag & FLAG_SRC_IS_DIR) && (flag & FLAG_DST_IS_FILE))
|
||||
{
|
||||
rt_kprintf("cp faild, cp dir to file is not permitted!\n");
|
||||
return ;
|
||||
}
|
||||
|
||||
//3. do copy
|
||||
if (flag & FLAG_SRC_IS_FILE)
|
||||
{
|
||||
if (flag & FLAG_DST_IS_DIR)
|
||||
{
|
||||
char *fdst;
|
||||
fdst = dfs_normalize_path(dst, _get_path_lastname(src));
|
||||
if (fdst == NULL)
|
||||
{
|
||||
rt_kprintf("out of memory\n");
|
||||
return;
|
||||
}
|
||||
copyfile(src, fdst);
|
||||
rt_free(fdst);
|
||||
}
|
||||
else
|
||||
{
|
||||
copyfile(src, dst);
|
||||
}
|
||||
}
|
||||
else //flag & FLAG_SRC_IS_DIR
|
||||
{
|
||||
if (flag & FLAG_DST_IS_DIR)
|
||||
{
|
||||
char *fdst;
|
||||
fdst = dfs_normalize_path(dst, _get_path_lastname(src));
|
||||
if (fdst == NULL)
|
||||
{
|
||||
rt_kprintf("out of memory\n");
|
||||
return;
|
||||
}
|
||||
mkdir(fdst, 0);
|
||||
copydir(src, fdst);
|
||||
rt_free(fdst);
|
||||
}
|
||||
else if ((flag & FLAG_DST_TYPE) == FLAG_DST_NON_EXSIT)
|
||||
{
|
||||
mkdir(dst, 0);
|
||||
copydir(src, dst);
|
||||
}
|
||||
else
|
||||
{
|
||||
copydir(src, dst);
|
||||
}
|
||||
}
|
||||
}
|
||||
FINSH_FUNCTION_EXPORT(copy, copy file or dir)
|
||||
#endif /* DFS_USING_POSIX */
|
||||
|
||||
#endif /* RT_USING_FINSH */
|
||||
/* @} */
|
||||
|
||||
@@ -0,0 +1,648 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2005-02-22 Bernard The first version.
|
||||
* 2010-06-30 Bernard Optimize for RT-Thread RTOS
|
||||
* 2011-03-12 Bernard fix the filesystem lookup issue.
|
||||
* 2017-11-30 Bernard fix the filesystem_operation_table issue.
|
||||
* 2017-12-05 Bernard fix the fs type search issue in mkfs.
|
||||
*/
|
||||
|
||||
#include <dfs_fs.h>
|
||||
#include <dfs_file.h>
|
||||
#include "dfs_private.h"
|
||||
|
||||
/**
|
||||
* @addtogroup FsApi
|
||||
*/
|
||||
/*@{*/
|
||||
|
||||
/**
|
||||
* this function will register a file system instance to device file system.
|
||||
*
|
||||
* @param ops the file system instance to be registered.
|
||||
*
|
||||
* @return 0 on successful, -1 on failed.
|
||||
*/
|
||||
int dfs_register(const struct dfs_filesystem_ops *ops)
|
||||
{
|
||||
int ret = RT_EOK;
|
||||
const struct dfs_filesystem_ops **empty = NULL;
|
||||
const struct dfs_filesystem_ops **iter;
|
||||
|
||||
/* lock filesystem */
|
||||
dfs_lock();
|
||||
/* check if this filesystem was already registered */
|
||||
for (iter = &filesystem_operation_table[0];
|
||||
iter < &filesystem_operation_table[DFS_FILESYSTEM_TYPES_MAX]; iter ++)
|
||||
{
|
||||
/* find out an empty filesystem type entry */
|
||||
if (*iter == NULL)
|
||||
(empty == NULL) ? (empty = iter) : 0;
|
||||
else if (strcmp((*iter)->name, ops->name) == 0)
|
||||
{
|
||||
rt_set_errno(-EEXIST);
|
||||
ret = -1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* save the filesystem's operations */
|
||||
if (empty == NULL)
|
||||
{
|
||||
rt_set_errno(-ENOSPC);
|
||||
LOG_E("There is no space to register this file system (%s).", ops->name);
|
||||
ret = -1;
|
||||
}
|
||||
else if (ret == RT_EOK)
|
||||
{
|
||||
*empty = ops;
|
||||
}
|
||||
|
||||
dfs_unlock();
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* this function will return the file system mounted on specified path.
|
||||
*
|
||||
* @param path the specified path string.
|
||||
*
|
||||
* @return the found file system or NULL if no file system mounted on
|
||||
* specified path
|
||||
*/
|
||||
struct dfs_filesystem *dfs_filesystem_lookup(const char *path)
|
||||
{
|
||||
struct dfs_filesystem *iter;
|
||||
struct dfs_filesystem *fs = NULL;
|
||||
uint32_t fspath, prefixlen;
|
||||
|
||||
prefixlen = 0;
|
||||
|
||||
RT_ASSERT(path);
|
||||
|
||||
/* lock filesystem */
|
||||
dfs_lock();
|
||||
|
||||
/* lookup it in the filesystem table */
|
||||
for (iter = &filesystem_table[0];
|
||||
iter < &filesystem_table[DFS_FILESYSTEMS_MAX]; iter++)
|
||||
{
|
||||
if ((iter->path == NULL) || (iter->ops == NULL))
|
||||
continue;
|
||||
|
||||
fspath = strlen(iter->path);
|
||||
if ((fspath < prefixlen)
|
||||
|| (strncmp(iter->path, path, fspath) != 0))
|
||||
continue;
|
||||
|
||||
/* check next path separator */
|
||||
if (fspath > 1 && (strlen(path) > fspath) && (path[fspath] != '/'))
|
||||
continue;
|
||||
|
||||
fs = iter;
|
||||
prefixlen = fspath;
|
||||
}
|
||||
|
||||
dfs_unlock();
|
||||
|
||||
return fs;
|
||||
}
|
||||
|
||||
/**
|
||||
* this function will return the mounted path for specified device.
|
||||
*
|
||||
* @param device the device object which is mounted.
|
||||
*
|
||||
* @return the mounted path or NULL if none device mounted.
|
||||
*/
|
||||
const char *dfs_filesystem_get_mounted_path(struct rt_device *device)
|
||||
{
|
||||
const char *path = NULL;
|
||||
struct dfs_filesystem *iter;
|
||||
|
||||
dfs_lock();
|
||||
for (iter = &filesystem_table[0];
|
||||
iter < &filesystem_table[DFS_FILESYSTEMS_MAX]; iter++)
|
||||
{
|
||||
/* find the mounted device */
|
||||
if (iter->ops == NULL) continue;
|
||||
else if (iter->dev_id == device)
|
||||
{
|
||||
path = iter->path;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* release filesystem_table lock */
|
||||
dfs_unlock();
|
||||
|
||||
return path;
|
||||
}
|
||||
|
||||
/**
|
||||
* this function will fetch the partition table on specified buffer.
|
||||
*
|
||||
* @param part the returned partition structure.
|
||||
* @param buf the buffer contains partition table.
|
||||
* @param pindex the index of partition table to fetch.
|
||||
*
|
||||
* @return RT_EOK on successful or -RT_ERROR on failed.
|
||||
*/
|
||||
int dfs_filesystem_get_partition(struct dfs_partition *part,
|
||||
uint8_t *buf,
|
||||
uint32_t pindex)
|
||||
{
|
||||
#define DPT_ADDRESS 0x1be /* device partition offset in Boot Sector */
|
||||
#define DPT_ITEM_SIZE 16 /* partition item size */
|
||||
|
||||
uint8_t *dpt;
|
||||
uint8_t type;
|
||||
|
||||
RT_ASSERT(part != NULL);
|
||||
RT_ASSERT(buf != NULL);
|
||||
|
||||
dpt = buf + DPT_ADDRESS + pindex * DPT_ITEM_SIZE;
|
||||
|
||||
/* check if it is a valid partition table */
|
||||
if ((*dpt != 0x80) && (*dpt != 0x00))
|
||||
return -EIO;
|
||||
|
||||
/* get partition type */
|
||||
type = *(dpt + 4);
|
||||
if (type == 0)
|
||||
return -EIO;
|
||||
|
||||
/* set partition information
|
||||
* size is the number of 512-Byte */
|
||||
part->type = type;
|
||||
part->offset = *(dpt + 8) | *(dpt + 9) << 8 | *(dpt + 10) << 16 | *(dpt + 11) << 24;
|
||||
part->size = *(dpt + 12) | *(dpt + 13) << 8 | *(dpt + 14) << 16 | *(dpt + 15) << 24;
|
||||
|
||||
rt_kprintf("found part[%d], begin: %d, size: ",
|
||||
pindex, part->offset * 512);
|
||||
if ((part->size >> 11) == 0)
|
||||
rt_kprintf("%d%s", part->size >> 1, "KB\n"); /* KB */
|
||||
else
|
||||
{
|
||||
unsigned int part_size;
|
||||
part_size = part->size >> 11; /* MB */
|
||||
if ((part_size >> 10) == 0)
|
||||
rt_kprintf("%d.%d%s", part_size, (part->size >> 1) & 0x3FF, "MB\n");
|
||||
else
|
||||
rt_kprintf("%d.%d%s", part_size >> 10, part_size & 0x3FF, "GB\n");
|
||||
}
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
/**
|
||||
* this function will mount a file system on a specified path.
|
||||
*
|
||||
* @param device_name the name of device which includes a file system.
|
||||
* @param path the path to mount a file system
|
||||
* @param filesystemtype the file system type
|
||||
* @param rwflag the read/write etc. flag.
|
||||
* @param data the private data(parameter) for this file system.
|
||||
*
|
||||
* @return 0 on successful or -1 on failed.
|
||||
*/
|
||||
int dfs_mount(const char *device_name,
|
||||
const char *path,
|
||||
const char *filesystemtype,
|
||||
unsigned long rwflag,
|
||||
const void *data)
|
||||
{
|
||||
const struct dfs_filesystem_ops **ops;
|
||||
struct dfs_filesystem *iter;
|
||||
struct dfs_filesystem *fs = NULL;
|
||||
char *fullpath = NULL;
|
||||
rt_device_t dev_id;
|
||||
|
||||
/* open specific device */
|
||||
if (device_name == NULL)
|
||||
{
|
||||
/* which is a non-device filesystem mount */
|
||||
dev_id = NULL;
|
||||
}
|
||||
else if ((dev_id = rt_device_find(device_name)) == NULL)
|
||||
{
|
||||
/* no this device */
|
||||
rt_set_errno(-ENODEV);
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* find out the specific filesystem */
|
||||
dfs_lock();
|
||||
|
||||
for (ops = &filesystem_operation_table[0];
|
||||
ops < &filesystem_operation_table[DFS_FILESYSTEM_TYPES_MAX]; ops++)
|
||||
if ((*ops != NULL) && (strcmp((*ops)->name, filesystemtype) == 0))
|
||||
break;
|
||||
|
||||
dfs_unlock();
|
||||
|
||||
if (ops == &filesystem_operation_table[DFS_FILESYSTEM_TYPES_MAX])
|
||||
{
|
||||
/* can't find filesystem */
|
||||
rt_set_errno(-ENODEV);
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* check if there is mount implementation */
|
||||
if ((*ops == NULL) || ((*ops)->mount == NULL))
|
||||
{
|
||||
rt_set_errno(-ENOSYS);
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* make full path for special file */
|
||||
fullpath = dfs_normalize_path(NULL, path);
|
||||
if (fullpath == NULL) /* not an abstract path */
|
||||
{
|
||||
rt_set_errno(-ENOTDIR);
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Check if the path exists or not, raw APIs call, fixme */
|
||||
if ((strcmp(fullpath, "/") != 0) && (strcmp(fullpath, "/dev") != 0))
|
||||
{
|
||||
struct dfs_fd fd;
|
||||
|
||||
if (dfs_file_open(&fd, fullpath, O_RDONLY | O_DIRECTORY) < 0)
|
||||
{
|
||||
rt_free(fullpath);
|
||||
rt_set_errno(-ENOTDIR);
|
||||
|
||||
return -1;
|
||||
}
|
||||
dfs_file_close(&fd);
|
||||
}
|
||||
|
||||
/* check whether the file system mounted or not in the filesystem table
|
||||
* if it is unmounted yet, find out an empty entry */
|
||||
dfs_lock();
|
||||
|
||||
for (iter = &filesystem_table[0];
|
||||
iter < &filesystem_table[DFS_FILESYSTEMS_MAX]; iter++)
|
||||
{
|
||||
/* check if it is an empty filesystem table entry? if it is, save fs */
|
||||
if (iter->ops == NULL)
|
||||
(fs == NULL) ? (fs = iter) : 0;
|
||||
/* check if the PATH is mounted */
|
||||
else if (strcmp(iter->path, path) == 0)
|
||||
{
|
||||
rt_set_errno(-EINVAL);
|
||||
goto err1;
|
||||
}
|
||||
}
|
||||
|
||||
if ((fs == NULL) && (iter == &filesystem_table[DFS_FILESYSTEMS_MAX]))
|
||||
{
|
||||
rt_set_errno(-ENOSPC);
|
||||
LOG_E("There is no space to mount this file system (%s).", filesystemtype);
|
||||
goto err1;
|
||||
}
|
||||
|
||||
/* register file system */
|
||||
fs->path = fullpath;
|
||||
fs->ops = *ops;
|
||||
fs->dev_id = dev_id;
|
||||
/* release filesystem_table lock */
|
||||
dfs_unlock();
|
||||
|
||||
/* open device, but do not check the status of device */
|
||||
if (dev_id != NULL)
|
||||
{
|
||||
if (rt_device_open(fs->dev_id,
|
||||
RT_DEVICE_OFLAG_RDWR) != RT_EOK)
|
||||
{
|
||||
/* The underlying device has error, clear the entry. */
|
||||
dfs_lock();
|
||||
rt_memset(fs, 0, sizeof(struct dfs_filesystem));
|
||||
|
||||
goto err1;
|
||||
}
|
||||
}
|
||||
|
||||
/* call mount of this filesystem */
|
||||
if ((*ops)->mount(fs, rwflag, data) < 0)
|
||||
{
|
||||
/* close device */
|
||||
if (dev_id != NULL)
|
||||
rt_device_close(fs->dev_id);
|
||||
|
||||
/* mount failed */
|
||||
dfs_lock();
|
||||
/* clear filesystem table entry */
|
||||
rt_memset(fs, 0, sizeof(struct dfs_filesystem));
|
||||
|
||||
goto err1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
err1:
|
||||
dfs_unlock();
|
||||
rt_free(fullpath);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* this function will unmount a file system on specified path.
|
||||
*
|
||||
* @param specialfile the specified path which mounted a file system.
|
||||
*
|
||||
* @return 0 on successful or -1 on failed.
|
||||
*/
|
||||
int dfs_unmount(const char *specialfile)
|
||||
{
|
||||
char *fullpath;
|
||||
struct dfs_filesystem *iter;
|
||||
struct dfs_filesystem *fs = NULL;
|
||||
|
||||
fullpath = dfs_normalize_path(NULL, specialfile);
|
||||
if (fullpath == NULL)
|
||||
{
|
||||
rt_set_errno(-ENOTDIR);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* lock filesystem */
|
||||
dfs_lock();
|
||||
|
||||
for (iter = &filesystem_table[0];
|
||||
iter < &filesystem_table[DFS_FILESYSTEMS_MAX]; iter++)
|
||||
{
|
||||
/* check if the PATH is mounted */
|
||||
if ((iter->path != NULL) && (strcmp(iter->path, fullpath) == 0))
|
||||
{
|
||||
fs = iter;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (fs == NULL ||
|
||||
fs->ops->unmount == NULL ||
|
||||
fs->ops->unmount(fs) < 0)
|
||||
{
|
||||
goto err1;
|
||||
}
|
||||
|
||||
/* close device, but do not check the status of device */
|
||||
if (fs->dev_id != NULL)
|
||||
rt_device_close(fs->dev_id);
|
||||
|
||||
if (fs->path != NULL)
|
||||
rt_free(fs->path);
|
||||
|
||||
/* clear this filesystem table entry */
|
||||
rt_memset(fs, 0, sizeof(struct dfs_filesystem));
|
||||
|
||||
dfs_unlock();
|
||||
rt_free(fullpath);
|
||||
|
||||
return 0;
|
||||
|
||||
err1:
|
||||
dfs_unlock();
|
||||
rt_free(fullpath);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* make a file system on the special device
|
||||
*
|
||||
* @param fs_name the file system name
|
||||
* @param device_name the special device name
|
||||
*
|
||||
* @return 0 on successful, otherwise failed.
|
||||
*/
|
||||
int dfs_mkfs(const char *fs_name, const char *device_name)
|
||||
{
|
||||
int index;
|
||||
rt_device_t dev_id = NULL;
|
||||
|
||||
/* check device name, and it should not be NULL */
|
||||
if (device_name != NULL)
|
||||
dev_id = rt_device_find(device_name);
|
||||
|
||||
if (dev_id == NULL)
|
||||
{
|
||||
rt_set_errno(-ENODEV);
|
||||
LOG_E("Device (%s) was not found", device_name);
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* lock file system */
|
||||
dfs_lock();
|
||||
/* find the file system operations */
|
||||
for (index = 0; index < DFS_FILESYSTEM_TYPES_MAX; index ++)
|
||||
{
|
||||
if (filesystem_operation_table[index] != NULL &&
|
||||
strcmp(filesystem_operation_table[index]->name, fs_name) == 0)
|
||||
break;
|
||||
}
|
||||
dfs_unlock();
|
||||
|
||||
if (index < DFS_FILESYSTEM_TYPES_MAX)
|
||||
{
|
||||
/* find file system operation */
|
||||
const struct dfs_filesystem_ops *ops = filesystem_operation_table[index];
|
||||
if (ops->mkfs == NULL)
|
||||
{
|
||||
LOG_E("The file system (%s) mkfs function was not implement", fs_name);
|
||||
rt_set_errno(-ENOSYS);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return ops->mkfs(dev_id);
|
||||
}
|
||||
|
||||
LOG_E("File system (%s) was not found.", fs_name);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* this function will return the information about a mounted file system.
|
||||
*
|
||||
* @param path the path which mounted file system.
|
||||
* @param buffer the buffer to save the returned information.
|
||||
*
|
||||
* @return 0 on successful, others on failed.
|
||||
*/
|
||||
int dfs_statfs(const char *path, struct statfs *buffer)
|
||||
{
|
||||
struct dfs_filesystem *fs;
|
||||
|
||||
fs = dfs_filesystem_lookup(path);
|
||||
if (fs != NULL)
|
||||
{
|
||||
if (fs->ops->statfs != NULL)
|
||||
return fs->ops->statfs(fs, buffer);
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
#ifdef RT_USING_DFS_MNTTABLE
|
||||
int dfs_mount_table(void)
|
||||
{
|
||||
int index = 0;
|
||||
|
||||
while (1)
|
||||
{
|
||||
if (mount_table[index].path == NULL) break;
|
||||
|
||||
if (dfs_mount(mount_table[index].device_name,
|
||||
mount_table[index].path,
|
||||
mount_table[index].filesystemtype,
|
||||
mount_table[index].rwflag,
|
||||
mount_table[index].data) != 0)
|
||||
{
|
||||
LOG_E("mount fs[%s] on %s failed.\n", mount_table[index].filesystemtype,
|
||||
mount_table[index].path);
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
index ++;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
INIT_ENV_EXPORT(dfs_mount_table);
|
||||
|
||||
int dfs_mount_device(rt_device_t dev)
|
||||
{
|
||||
int index = 0;
|
||||
|
||||
if(dev == RT_NULL) {
|
||||
rt_kprintf("the device is NULL to be mounted.\n");
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
while (1)
|
||||
{
|
||||
if (mount_table[index].path == NULL) break;
|
||||
|
||||
if(strcmp(mount_table[index].device_name, dev->parent.name) == 0) {
|
||||
if (dfs_mount(mount_table[index].device_name,
|
||||
mount_table[index].path,
|
||||
mount_table[index].filesystemtype,
|
||||
mount_table[index].rwflag,
|
||||
mount_table[index].data) != 0)
|
||||
{
|
||||
LOG_E("mount fs[%s] device[%s] to %s failed.\n", mount_table[index].filesystemtype, dev->parent.name,
|
||||
mount_table[index].path);
|
||||
return -RT_ERROR;
|
||||
} else {
|
||||
LOG_D("mount fs[%s] device[%s] to %s ok.\n", mount_table[index].filesystemtype, dev->parent.name,
|
||||
mount_table[index].path);
|
||||
return RT_EOK;
|
||||
}
|
||||
}
|
||||
|
||||
index ++;
|
||||
}
|
||||
|
||||
rt_kprintf("can't find device:%s to be mounted.\n", dev->parent.name);
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
int dfs_unmount_device(rt_device_t dev)
|
||||
{
|
||||
struct dfs_filesystem *iter;
|
||||
struct dfs_filesystem *fs = NULL;
|
||||
|
||||
/* lock filesystem */
|
||||
dfs_lock();
|
||||
|
||||
for (iter = &filesystem_table[0];
|
||||
iter < &filesystem_table[DFS_FILESYSTEMS_MAX]; iter++)
|
||||
{
|
||||
/* check if the PATH is mounted */
|
||||
if (strcmp(iter->dev_id->parent.name, dev->parent.name) == 0)
|
||||
{
|
||||
fs = iter;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (fs == NULL ||
|
||||
fs->ops->unmount == NULL ||
|
||||
fs->ops->unmount(fs) < 0)
|
||||
{
|
||||
goto err1;
|
||||
}
|
||||
|
||||
/* close device, but do not check the status of device */
|
||||
if (fs->dev_id != NULL)
|
||||
rt_device_close(fs->dev_id);
|
||||
|
||||
if (fs->path != NULL)
|
||||
rt_free(fs->path);
|
||||
|
||||
/* clear this filesystem table entry */
|
||||
rt_memset(fs, 0, sizeof(struct dfs_filesystem));
|
||||
|
||||
dfs_unlock();
|
||||
|
||||
return 0;
|
||||
|
||||
err1:
|
||||
dfs_unlock();
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef RT_USING_FINSH
|
||||
#include <finsh.h>
|
||||
void mkfs(const char *fs_name, const char *device_name)
|
||||
{
|
||||
dfs_mkfs(fs_name, device_name);
|
||||
}
|
||||
FINSH_FUNCTION_EXPORT(mkfs, make a file system);
|
||||
|
||||
int df(const char *path)
|
||||
{
|
||||
int result;
|
||||
int minor = 0;
|
||||
long long cap;
|
||||
struct statfs buffer;
|
||||
|
||||
int unit_index = 0;
|
||||
char *unit_str[] = {"KB", "MB", "GB"};
|
||||
|
||||
result = dfs_statfs(path ? path : NULL, &buffer);
|
||||
if (result != 0)
|
||||
{
|
||||
rt_kprintf("dfs_statfs failed.\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
cap = ((long long)buffer.f_bsize) * ((long long)buffer.f_bfree) / 1024LL;
|
||||
for (unit_index = 0; unit_index < 2; unit_index ++)
|
||||
{
|
||||
if (cap < 1024) break;
|
||||
|
||||
minor = (cap % 1024) * 10 / 1024; /* only one decimal point */
|
||||
cap = cap / 1024;
|
||||
}
|
||||
|
||||
rt_kprintf("disk free: %d.%d %s [ %d block, %d bytes per block ]\n",
|
||||
(unsigned long)cap, minor, unit_str[unit_index], buffer.f_bfree, buffer.f_bsize);
|
||||
return 0;
|
||||
}
|
||||
FINSH_FUNCTION_EXPORT(df, get disk free);
|
||||
#endif
|
||||
|
||||
/* @} */
|
||||
@@ -0,0 +1,953 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2009-05-27 Yi.qiu The first version
|
||||
* 2018-02-07 Bernard Change the 3rd parameter of open/fcntl/ioctl to '...'
|
||||
* 2022-01-19 Meco Man add creat()
|
||||
*/
|
||||
|
||||
#include <dfs_file.h>
|
||||
#include <dfs_private.h>
|
||||
#include <sys/errno.h>
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which will open a file and
|
||||
* return a file descriptor according specified flags.
|
||||
*
|
||||
* @param file the path name of file.
|
||||
* @param flags the file open flags.
|
||||
*
|
||||
* @return the non-negative integer on successful open, others for failed.
|
||||
*/
|
||||
int open(const char *file, int flags, ...)
|
||||
{
|
||||
int fd, result;
|
||||
struct dfs_fd *d;
|
||||
|
||||
/* allocate a fd */
|
||||
fd = fd_new();
|
||||
if (fd < 0)
|
||||
{
|
||||
rt_set_errno(-ENOMEM);
|
||||
|
||||
return -1;
|
||||
}
|
||||
d = fd_get(fd);
|
||||
|
||||
result = dfs_file_open(d, file, flags);
|
||||
if (result < 0)
|
||||
{
|
||||
/* release the ref-count of fd */
|
||||
fd_put(d);
|
||||
fd_put(d);
|
||||
|
||||
rt_set_errno(result);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* release the ref-count of fd */
|
||||
fd_put(d);
|
||||
|
||||
return fd;
|
||||
}
|
||||
RTM_EXPORT(open);
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version,
|
||||
* which will create a new file or rewrite an existing one
|
||||
*
|
||||
* @param path the path name of file.
|
||||
* @param mode the file permission bits to be used in creating the file (not used, can be 0)
|
||||
*
|
||||
* @return the non-negative integer on successful open, others for failed.
|
||||
*/
|
||||
int creat(const char *path, mode_t mode)
|
||||
{
|
||||
return open(path, O_WRONLY | O_CREAT | O_TRUNC, mode);
|
||||
}
|
||||
RTM_EXPORT(creat);
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which will close the open
|
||||
* file descriptor.
|
||||
*
|
||||
* @param fd the file descriptor.
|
||||
*
|
||||
* @return 0 on successful, -1 on failed.
|
||||
*/
|
||||
int close(int fd)
|
||||
{
|
||||
int result;
|
||||
struct dfs_fd *d;
|
||||
|
||||
d = fd_get(fd);
|
||||
if (d == NULL)
|
||||
{
|
||||
rt_set_errno(-EBADF);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
result = dfs_file_close(d);
|
||||
fd_put(d);
|
||||
|
||||
if (result < 0)
|
||||
{
|
||||
rt_set_errno(result);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
fd_put(d);
|
||||
|
||||
return 0;
|
||||
}
|
||||
RTM_EXPORT(close);
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which will read specified data
|
||||
* buffer length for an open file descriptor.
|
||||
*
|
||||
* @param fd the file descriptor.
|
||||
* @param buf the buffer to save the read data.
|
||||
* @param len the maximal length of data buffer
|
||||
*
|
||||
* @return the actual read data buffer length. If the returned value is 0, it
|
||||
* may be reach the end of file, please check errno.
|
||||
*/
|
||||
#ifdef _READ_WRITE_RETURN_TYPE
|
||||
_READ_WRITE_RETURN_TYPE read(int fd, void *buf, size_t len) /* some gcc tool chains will use different data structure */
|
||||
#else
|
||||
ssize_t read(int fd, void *buf, size_t len)
|
||||
#endif
|
||||
{
|
||||
int result;
|
||||
struct dfs_fd *d;
|
||||
|
||||
/* get the fd */
|
||||
d = fd_get(fd);
|
||||
if (d == NULL)
|
||||
{
|
||||
rt_set_errno(-EBADF);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
result = dfs_file_read(d, buf, len);
|
||||
if (result < 0)
|
||||
{
|
||||
fd_put(d);
|
||||
rt_set_errno(result);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* release the ref-count of fd */
|
||||
fd_put(d);
|
||||
|
||||
return result;
|
||||
}
|
||||
RTM_EXPORT(read);
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which will write specified data
|
||||
* buffer length for an open file descriptor.
|
||||
*
|
||||
* @param fd the file descriptor
|
||||
* @param buf the data buffer to be written.
|
||||
* @param len the data buffer length.
|
||||
*
|
||||
* @return the actual written data buffer length.
|
||||
*/
|
||||
#ifdef _READ_WRITE_RETURN_TYPE
|
||||
_READ_WRITE_RETURN_TYPE write(int fd, const void *buf, size_t len) /* some gcc tool chains will use different data structure */
|
||||
#else
|
||||
ssize_t write(int fd, const void *buf, size_t len)
|
||||
#endif
|
||||
{
|
||||
int result;
|
||||
struct dfs_fd *d;
|
||||
|
||||
/* get the fd */
|
||||
d = fd_get(fd);
|
||||
if (d == NULL)
|
||||
{
|
||||
rt_set_errno(-EBADF);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
result = dfs_file_write(d, buf, len);
|
||||
if (result < 0)
|
||||
{
|
||||
fd_put(d);
|
||||
rt_set_errno(result);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* release the ref-count of fd */
|
||||
fd_put(d);
|
||||
|
||||
return result;
|
||||
}
|
||||
RTM_EXPORT(write);
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which will seek the offset for
|
||||
* an open file descriptor.
|
||||
*
|
||||
* @param fd the file descriptor.
|
||||
* @param offset the offset to be seeked.
|
||||
* @param whence the directory of seek.
|
||||
*
|
||||
* @return the current read/write position in the file, or -1 on failed.
|
||||
*/
|
||||
off_t lseek(int fd, off_t offset, int whence)
|
||||
{
|
||||
int result;
|
||||
struct dfs_fd *d;
|
||||
|
||||
d = fd_get(fd);
|
||||
if (d == NULL)
|
||||
{
|
||||
rt_set_errno(-EBADF);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
switch (whence)
|
||||
{
|
||||
case SEEK_SET:
|
||||
break;
|
||||
|
||||
case SEEK_CUR:
|
||||
offset += d->pos;
|
||||
break;
|
||||
|
||||
case SEEK_END:
|
||||
offset += d->size;
|
||||
break;
|
||||
|
||||
default:
|
||||
fd_put(d);
|
||||
rt_set_errno(-EINVAL);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (offset < 0)
|
||||
{
|
||||
fd_put(d);
|
||||
rt_set_errno(-EINVAL);
|
||||
|
||||
return -1;
|
||||
}
|
||||
result = dfs_file_lseek(d, offset);
|
||||
if (result < 0)
|
||||
{
|
||||
fd_put(d);
|
||||
rt_set_errno(result);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* release the ref-count of fd */
|
||||
fd_put(d);
|
||||
|
||||
return offset;
|
||||
}
|
||||
RTM_EXPORT(lseek);
|
||||
|
||||
#ifndef _WIN32
|
||||
/**
|
||||
* this function is a POSIX compliant version, which will rename old file name
|
||||
* to new file name.
|
||||
*
|
||||
* @param old the old file name.
|
||||
* @param new the new file name.
|
||||
*
|
||||
* @return 0 on successful, -1 on failed.
|
||||
*
|
||||
* note: the old and new file name must be belong to a same file system.
|
||||
*/
|
||||
int rename(const char *old_file, const char *new_file)
|
||||
{
|
||||
int result;
|
||||
|
||||
result = dfs_file_rename(old_file, new_file);
|
||||
if (result < 0)
|
||||
{
|
||||
rt_set_errno(result);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
RTM_EXPORT(rename);
|
||||
#endif
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which will unlink (remove) a
|
||||
* specified path file from file system.
|
||||
*
|
||||
* @param pathname the specified path name to be unlinked.
|
||||
*
|
||||
* @return 0 on successful, -1 on failed.
|
||||
*/
|
||||
int unlink(const char *pathname)
|
||||
{
|
||||
int result;
|
||||
|
||||
result = dfs_file_unlink(pathname);
|
||||
if (result < 0)
|
||||
{
|
||||
rt_set_errno(result);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
RTM_EXPORT(unlink);
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which will get file information.
|
||||
*
|
||||
* @param file the file name
|
||||
* @param buf the data buffer to save stat description.
|
||||
*
|
||||
* @return 0 on successful, -1 on failed.
|
||||
*/
|
||||
int stat(const char *file, struct stat *buf)
|
||||
{
|
||||
int result;
|
||||
|
||||
result = dfs_file_stat(file, buf);
|
||||
if (result < 0)
|
||||
{
|
||||
rt_set_errno(result);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
RTM_EXPORT(stat);
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which will get file status.
|
||||
*
|
||||
* @param fildes the file description
|
||||
* @param buf the data buffer to save stat description.
|
||||
*
|
||||
* @return 0 on successful, -1 on failed.
|
||||
*/
|
||||
int fstat(int fildes, struct stat *buf)
|
||||
{
|
||||
struct dfs_fd *d;
|
||||
|
||||
/* get the fd */
|
||||
d = fd_get(fildes);
|
||||
if (d == NULL)
|
||||
{
|
||||
rt_set_errno(-EBADF);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* it's the root directory */
|
||||
buf->st_dev = 0;
|
||||
|
||||
buf->st_mode = S_IFREG | S_IRUSR | S_IRGRP | S_IROTH |
|
||||
S_IWUSR | S_IWGRP | S_IWOTH;
|
||||
if (d->type == FT_DIRECTORY)
|
||||
{
|
||||
buf->st_mode &= ~S_IFREG;
|
||||
buf->st_mode |= S_IFDIR | S_IXUSR | S_IXGRP | S_IXOTH;
|
||||
}
|
||||
|
||||
buf->st_size = d->size;
|
||||
buf->st_mtime = 0;
|
||||
|
||||
fd_put(d);
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
RTM_EXPORT(fstat);
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which shall request that all data
|
||||
* for the open file descriptor named by fildes is to be transferred to the storage
|
||||
* device associated with the file described by fildes.
|
||||
*
|
||||
* @param fildes the file description
|
||||
*
|
||||
* @return 0 on successful completion. Otherwise, -1 shall be returned and errno
|
||||
* set to indicate the error.
|
||||
*/
|
||||
int fsync(int fildes)
|
||||
{
|
||||
int ret;
|
||||
struct dfs_fd *d;
|
||||
|
||||
/* get the fd */
|
||||
d = fd_get(fildes);
|
||||
if (d == NULL)
|
||||
{
|
||||
rt_set_errno(-EBADF);
|
||||
return -1;
|
||||
}
|
||||
|
||||
ret = dfs_file_flush(d);
|
||||
|
||||
fd_put(d);
|
||||
return ret;
|
||||
}
|
||||
RTM_EXPORT(fsync);
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which shall perform a variety of
|
||||
* control functions on devices.
|
||||
*
|
||||
* @param fildes the file description
|
||||
* @param cmd the specified command
|
||||
* @param data represents the additional information that is needed by this
|
||||
* specific device to perform the requested function.
|
||||
*
|
||||
* @return 0 on successful completion. Otherwise, -1 shall be returned and errno
|
||||
* set to indicate the error.
|
||||
*/
|
||||
int fcntl(int fildes, int cmd, ...)
|
||||
{
|
||||
int ret = -1;
|
||||
struct dfs_fd *d;
|
||||
|
||||
/* get the fd */
|
||||
d = fd_get(fildes);
|
||||
if (d)
|
||||
{
|
||||
void *arg;
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, cmd);
|
||||
arg = va_arg(ap, void *);
|
||||
va_end(ap);
|
||||
|
||||
ret = dfs_file_ioctl(d, cmd, arg);
|
||||
fd_put(d);
|
||||
}
|
||||
else ret = -EBADF;
|
||||
|
||||
if (ret < 0)
|
||||
{
|
||||
rt_set_errno(ret);
|
||||
ret = -1;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
RTM_EXPORT(fcntl);
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which shall perform a variety of
|
||||
* control functions on devices.
|
||||
*
|
||||
* @param fildes the file description
|
||||
* @param cmd the specified command
|
||||
* @param data represents the additional information that is needed by this
|
||||
* specific device to perform the requested function.
|
||||
*
|
||||
* @return 0 on successful completion. Otherwise, -1 shall be returned and errno
|
||||
* set to indicate the error.
|
||||
*/
|
||||
int ioctl(int fildes, int cmd, ...)
|
||||
{
|
||||
void *arg;
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, cmd);
|
||||
arg = va_arg(ap, void *);
|
||||
va_end(ap);
|
||||
|
||||
/* we use fcntl for this API. */
|
||||
return fcntl(fildes, cmd, arg);
|
||||
}
|
||||
RTM_EXPORT(ioctl);
|
||||
|
||||
/**
|
||||
*
|
||||
* this function is a POSIX compliant version, which cause the regular file
|
||||
* referenced by fd to be truncated to a size of precisely length bytes.
|
||||
* @param fd the file descriptor.
|
||||
* @param length the length to be truncated.
|
||||
*
|
||||
* @return Upon successful completion, ftruncate() shall return 0;
|
||||
* otherwise, -1 shall be returned and errno set to indicate the error.
|
||||
*/
|
||||
int ftruncate(int fd, off_t length)
|
||||
{
|
||||
int result;
|
||||
struct dfs_fd *d;
|
||||
|
||||
d = fd_get(fd);
|
||||
if (d == NULL)
|
||||
{
|
||||
rt_set_errno(-EBADF);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (length < 0)
|
||||
{
|
||||
fd_put(d);
|
||||
rt_set_errno(-EINVAL);
|
||||
|
||||
return -1;
|
||||
}
|
||||
result = dfs_file_ftruncate(d, length);
|
||||
if (result < 0)
|
||||
{
|
||||
fd_put(d);
|
||||
rt_set_errno(result);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* release the ref-count of fd */
|
||||
fd_put(d);
|
||||
|
||||
return 0;
|
||||
}
|
||||
RTM_EXPORT(ftruncate);
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which will return the
|
||||
* information about a mounted file system.
|
||||
*
|
||||
* @param path the path which mounted file system.
|
||||
* @param buf the buffer to save the returned information.
|
||||
*
|
||||
* @return 0 on successful, others on failed.
|
||||
*/
|
||||
int statfs(const char *path, struct statfs *buf)
|
||||
{
|
||||
int result;
|
||||
|
||||
result = dfs_statfs(path, buf);
|
||||
if (result < 0)
|
||||
{
|
||||
rt_set_errno(result);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
RTM_EXPORT(statfs);
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which will make a directory
|
||||
*
|
||||
* @param path the directory path to be made.
|
||||
* @param mode
|
||||
*
|
||||
* @return 0 on successful, others on failed.
|
||||
*/
|
||||
int mkdir(const char *path, mode_t mode)
|
||||
{
|
||||
int fd;
|
||||
struct dfs_fd *d;
|
||||
int result;
|
||||
|
||||
fd = fd_new();
|
||||
if (fd == -1)
|
||||
{
|
||||
rt_set_errno(-ENOMEM);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
d = fd_get(fd);
|
||||
|
||||
result = dfs_file_open(d, path, O_DIRECTORY | O_CREAT);
|
||||
|
||||
if (result < 0)
|
||||
{
|
||||
fd_put(d);
|
||||
fd_put(d);
|
||||
rt_set_errno(result);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
dfs_file_close(d);
|
||||
fd_put(d);
|
||||
fd_put(d);
|
||||
|
||||
return 0;
|
||||
}
|
||||
RTM_EXPORT(mkdir);
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which will remove a directory.
|
||||
*
|
||||
* @param pathname the path name to be removed.
|
||||
*
|
||||
* @return 0 on successful, others on failed.
|
||||
*/
|
||||
int rmdir(const char *pathname)
|
||||
{
|
||||
int result;
|
||||
|
||||
result = dfs_file_unlink(pathname);
|
||||
if (result < 0)
|
||||
{
|
||||
rt_set_errno(result);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
RTM_EXPORT(rmdir);
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which will open a directory.
|
||||
*
|
||||
* @param name the path name to be open.
|
||||
*
|
||||
* @return the DIR pointer of directory, NULL on open directory failed.
|
||||
*/
|
||||
DIR *opendir(const char *name)
|
||||
{
|
||||
struct dfs_fd *d;
|
||||
int fd, result;
|
||||
DIR *t;
|
||||
|
||||
t = NULL;
|
||||
|
||||
/* allocate a fd */
|
||||
fd = fd_new();
|
||||
if (fd == -1)
|
||||
{
|
||||
rt_set_errno(-ENOMEM);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
d = fd_get(fd);
|
||||
|
||||
result = dfs_file_open(d, name, O_RDONLY | O_DIRECTORY);
|
||||
if (result >= 0)
|
||||
{
|
||||
/* open successfully */
|
||||
t = (DIR *) rt_malloc(sizeof(DIR));
|
||||
if (t == NULL)
|
||||
{
|
||||
dfs_file_close(d);
|
||||
fd_put(d);
|
||||
}
|
||||
else
|
||||
{
|
||||
rt_memset(t, 0, sizeof(DIR));
|
||||
|
||||
t->fd = fd;
|
||||
}
|
||||
fd_put(d);
|
||||
|
||||
return t;
|
||||
}
|
||||
|
||||
/* open failed */
|
||||
fd_put(d);
|
||||
fd_put(d);
|
||||
rt_set_errno(result);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
RTM_EXPORT(opendir);
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which will return a pointer
|
||||
* to a dirent structure representing the next directory entry in the
|
||||
* directory stream.
|
||||
*
|
||||
* @param d the directory stream pointer.
|
||||
*
|
||||
* @return the next directory entry, NULL on the end of directory or failed.
|
||||
*/
|
||||
struct dirent *readdir(DIR *d)
|
||||
{
|
||||
int result;
|
||||
struct dfs_fd *fd;
|
||||
|
||||
fd = fd_get(d->fd);
|
||||
if (fd == NULL)
|
||||
{
|
||||
rt_set_errno(-EBADF);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (d->num)
|
||||
{
|
||||
struct dirent *dirent_ptr;
|
||||
dirent_ptr = (struct dirent *)&d->buf[d->cur];
|
||||
d->cur += dirent_ptr->d_reclen;
|
||||
}
|
||||
|
||||
if (!d->num || d->cur >= d->num)
|
||||
{
|
||||
/* get a new entry */
|
||||
result = dfs_file_getdents(fd,
|
||||
(struct dirent *)d->buf,
|
||||
sizeof(d->buf) - 1);
|
||||
if (result <= 0)
|
||||
{
|
||||
fd_put(fd);
|
||||
rt_set_errno(result);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
d->num = result;
|
||||
d->cur = 0; /* current entry index */
|
||||
}
|
||||
|
||||
fd_put(fd);
|
||||
|
||||
return (struct dirent *)(d->buf + d->cur);
|
||||
}
|
||||
RTM_EXPORT(readdir);
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which will return current
|
||||
* location in directory stream.
|
||||
*
|
||||
* @param d the directory stream pointer.
|
||||
*
|
||||
* @return the current location in directory stream.
|
||||
*/
|
||||
long telldir(DIR *d)
|
||||
{
|
||||
struct dfs_fd *fd;
|
||||
long result;
|
||||
|
||||
fd = fd_get(d->fd);
|
||||
if (fd == NULL)
|
||||
{
|
||||
rt_set_errno(-EBADF);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
result = fd->pos - d->num + d->cur;
|
||||
fd_put(fd);
|
||||
|
||||
return result;
|
||||
}
|
||||
RTM_EXPORT(telldir);
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which will set position of
|
||||
* next directory structure in the directory stream.
|
||||
*
|
||||
* @param d the directory stream.
|
||||
* @param offset the offset in directory stream.
|
||||
*/
|
||||
void seekdir(DIR *d, off_t offset)
|
||||
{
|
||||
struct dfs_fd *fd;
|
||||
|
||||
fd = fd_get(d->fd);
|
||||
if (fd == NULL)
|
||||
{
|
||||
rt_set_errno(-EBADF);
|
||||
|
||||
return ;
|
||||
}
|
||||
|
||||
/* seek to the offset position of directory */
|
||||
if (dfs_file_lseek(fd, offset) >= 0)
|
||||
d->num = d->cur = 0;
|
||||
fd_put(fd);
|
||||
}
|
||||
RTM_EXPORT(seekdir);
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which will reset directory
|
||||
* stream.
|
||||
*
|
||||
* @param d the directory stream.
|
||||
*/
|
||||
void rewinddir(DIR *d)
|
||||
{
|
||||
struct dfs_fd *fd;
|
||||
|
||||
fd = fd_get(d->fd);
|
||||
if (fd == NULL)
|
||||
{
|
||||
rt_set_errno(-EBADF);
|
||||
|
||||
return ;
|
||||
}
|
||||
|
||||
/* seek to the beginning of directory */
|
||||
if (dfs_file_lseek(fd, 0) >= 0)
|
||||
d->num = d->cur = 0;
|
||||
fd_put(fd);
|
||||
}
|
||||
RTM_EXPORT(rewinddir);
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which will close a directory
|
||||
* stream.
|
||||
*
|
||||
* @param d the directory stream.
|
||||
*
|
||||
* @return 0 on successful, -1 on failed.
|
||||
*/
|
||||
int closedir(DIR *d)
|
||||
{
|
||||
int result;
|
||||
struct dfs_fd *fd;
|
||||
|
||||
fd = fd_get(d->fd);
|
||||
if (fd == NULL)
|
||||
{
|
||||
rt_set_errno(-EBADF);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
result = dfs_file_close(fd);
|
||||
fd_put(fd);
|
||||
|
||||
fd_put(fd);
|
||||
rt_free(d);
|
||||
|
||||
if (result < 0)
|
||||
{
|
||||
rt_set_errno(result);
|
||||
|
||||
return -1;
|
||||
}
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
RTM_EXPORT(closedir);
|
||||
|
||||
#ifdef DFS_USING_WORKDIR
|
||||
/**
|
||||
* this function is a POSIX compliant version, which will change working
|
||||
* directory.
|
||||
*
|
||||
* @param path the path name to be changed to.
|
||||
*
|
||||
* @return 0 on successful, -1 on failed.
|
||||
*/
|
||||
int chdir(const char *path)
|
||||
{
|
||||
char *fullpath;
|
||||
DIR *d;
|
||||
|
||||
if (path == NULL)
|
||||
{
|
||||
dfs_lock();
|
||||
rt_kprintf("%s\n", working_directory);
|
||||
dfs_unlock();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (strlen(path) > DFS_PATH_MAX)
|
||||
{
|
||||
rt_set_errno(-ENOTDIR);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
fullpath = dfs_normalize_path(NULL, path);
|
||||
if (fullpath == NULL)
|
||||
{
|
||||
rt_set_errno(-ENOTDIR);
|
||||
|
||||
return -1; /* build path failed */
|
||||
}
|
||||
|
||||
dfs_lock();
|
||||
d = opendir(fullpath);
|
||||
if (d == NULL)
|
||||
{
|
||||
rt_free(fullpath);
|
||||
/* this is a not exist directory */
|
||||
dfs_unlock();
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* close directory stream */
|
||||
closedir(d);
|
||||
|
||||
/* copy full path to working directory */
|
||||
strncpy(working_directory, fullpath, DFS_PATH_MAX);
|
||||
/* release normalize directory path name */
|
||||
rt_free(fullpath);
|
||||
|
||||
dfs_unlock();
|
||||
|
||||
return 0;
|
||||
}
|
||||
RTM_EXPORT(chdir);
|
||||
|
||||
#ifdef RT_USING_FINSH
|
||||
FINSH_FUNCTION_EXPORT_ALIAS(chdir, cd, change current working directory);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which shall check the file named
|
||||
* by the pathname pointed to by the path argument for accessibility according
|
||||
* to the bit pattern contained in amode.
|
||||
*
|
||||
* @param path the specified file/dir path.
|
||||
* @param amode the value is either the bitwise-inclusive OR of the access
|
||||
* permissions to be checked (R_OK, W_OK, X_OK) or the existence test (F_OK).
|
||||
*/
|
||||
int access(const char *path, int amode)
|
||||
{
|
||||
struct stat sb;
|
||||
if (stat(path, &sb) < 0)
|
||||
return -1; /* already sets errno */
|
||||
|
||||
/* ignore R_OK,W_OK,X_OK condition */
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* this function is a POSIX compliant version, which will return current
|
||||
* working directory.
|
||||
*
|
||||
* @param buf the returned current directory.
|
||||
* @param size the buffer size.
|
||||
*
|
||||
* @return the returned current directory.
|
||||
*/
|
||||
char *getcwd(char *buf, size_t size)
|
||||
{
|
||||
#ifdef DFS_USING_WORKDIR
|
||||
dfs_lock();
|
||||
strncpy(buf, working_directory, size);
|
||||
dfs_unlock();
|
||||
#else
|
||||
rt_kprintf(NO_WORKING_DIR);
|
||||
#endif
|
||||
|
||||
return buf;
|
||||
}
|
||||
RTM_EXPORT(getcwd);
|
||||
@@ -0,0 +1,865 @@
|
||||
menu "Device Drivers"
|
||||
|
||||
config RT_USING_DEVICE_IPC
|
||||
bool "Using device drivers IPC"
|
||||
default y
|
||||
|
||||
if RT_USING_DEVICE_IPC
|
||||
config RT_USING_SYSTEM_WORKQUEUE
|
||||
bool "Using system default workqueue"
|
||||
default n
|
||||
|
||||
if RT_USING_SYSTEM_WORKQUEUE
|
||||
config RT_SYSTEM_WORKQUEUE_STACKSIZE
|
||||
int "The stack size for system workqueue thread"
|
||||
default 2048
|
||||
|
||||
config RT_SYSTEM_WORKQUEUE_PRIORITY
|
||||
int "The priority level of system workqueue thread"
|
||||
default 23
|
||||
endif
|
||||
endif
|
||||
|
||||
menuconfig RT_USING_SERIAL
|
||||
bool "USING Serial device drivers"
|
||||
select RT_USING_DEVICE_IPC
|
||||
select RT_USING_DEVICE
|
||||
default y
|
||||
|
||||
if RT_USING_SERIAL
|
||||
choice
|
||||
prompt "Choice Serial version"
|
||||
default RT_USING_SERIAL_V1
|
||||
config RT_USING_SERIAL_V1
|
||||
bool "RT_USING_SERIAL_V1"
|
||||
config RT_USING_SERIAL_V2
|
||||
bool "RT_USING_SERIAL_V2"
|
||||
endchoice
|
||||
config RT_SERIAL_USING_DMA
|
||||
bool "Enable serial DMA mode"
|
||||
default y
|
||||
|
||||
config RT_SERIAL_RB_BUFSZ
|
||||
int "Set RX buffer size"
|
||||
depends on !RT_USING_SERIAL_V2
|
||||
default 64
|
||||
endif
|
||||
|
||||
config RT_USING_CAN
|
||||
bool "Using CAN device drivers"
|
||||
default n
|
||||
|
||||
if RT_USING_CAN
|
||||
config RT_CAN_USING_HDR
|
||||
bool "Enable CAN hardware filter"
|
||||
default n
|
||||
endif
|
||||
|
||||
config RT_USING_HWTIMER
|
||||
bool "Using hardware timer device drivers"
|
||||
default n
|
||||
|
||||
config RT_USING_CPUTIME
|
||||
bool "Enable CPU time for high resolution clock counter"
|
||||
default n
|
||||
help
|
||||
When enable this option, the BSP should provide a rt_clock_cputime_ops
|
||||
for CPU time by:
|
||||
const static struct rt_clock_cputime_ops _ops = {...};
|
||||
clock_cpu_setops(&_ops);
|
||||
|
||||
Then user can use high resolution clock counter with:
|
||||
|
||||
ts1 = clock_cpu_gettime();
|
||||
ts2 = clock_cpu_gettime();
|
||||
|
||||
/* and get the ms of delta tick with API: */
|
||||
ms_tick = clock_cpu_millisecond(t2 - t1);
|
||||
us_tick = clock_cpu_microsecond(t2 - t1);
|
||||
|
||||
if RT_USING_CPUTIME
|
||||
config RT_USING_CPUTIME_CORTEXM
|
||||
bool "Use DWT for CPU time"
|
||||
default y
|
||||
depends on ARCH_ARM_CORTEX_M3 || ARCH_ARM_CORTEX_M4 || ARCH_ARM_CORTEX_M7
|
||||
help
|
||||
Some Cortex-M3/4/7 MCU has Data Watchpoint and Trace Register, use
|
||||
the cycle counter in DWT for CPU time.
|
||||
endif
|
||||
|
||||
config RT_USING_I2C
|
||||
bool "Using I2C device drivers"
|
||||
default n
|
||||
|
||||
if RT_USING_I2C
|
||||
config RT_I2C_DEBUG
|
||||
bool "Use I2C debug message"
|
||||
default n
|
||||
|
||||
config RT_USING_I2C_BITOPS
|
||||
bool "Use GPIO to simulate I2C"
|
||||
default y
|
||||
|
||||
if RT_USING_I2C_BITOPS
|
||||
config RT_I2C_BITOPS_DEBUG
|
||||
bool "Use simulate I2C debug message"
|
||||
default n
|
||||
endif
|
||||
endif
|
||||
|
||||
config RT_USING_PHY
|
||||
bool "Using ethernet phy device drivers"
|
||||
default n
|
||||
|
||||
config RT_USING_PIN
|
||||
bool "Using generic GPIO device drivers"
|
||||
default y
|
||||
|
||||
config RT_USING_ADC
|
||||
bool "Using ADC device drivers"
|
||||
default n
|
||||
|
||||
config RT_USING_DAC
|
||||
bool "Using DAC device drivers"
|
||||
default n
|
||||
|
||||
config RT_USING_PWM
|
||||
bool "Using PWM device drivers"
|
||||
default n
|
||||
|
||||
config RT_USING_MTD_NOR
|
||||
bool "Using MTD Nor Flash device drivers"
|
||||
default n
|
||||
|
||||
config RT_USING_MTD_NAND
|
||||
bool "Using MTD Nand Flash device drivers"
|
||||
default n
|
||||
|
||||
if RT_USING_MTD_NAND
|
||||
config RT_MTD_NAND_DEBUG
|
||||
bool "Enable MTD Nand operations debug information"
|
||||
default n
|
||||
endif
|
||||
|
||||
config RT_USING_PM
|
||||
bool "Using Power Management device drivers"
|
||||
default n
|
||||
|
||||
if RT_USING_PM
|
||||
config PM_TICKLESS_THRESHOLD_TIME
|
||||
int "PM tickless threashold time"
|
||||
default 2
|
||||
|
||||
config PM_USING_CUSTOM_CONFIG
|
||||
bool "PM using custom pm config"
|
||||
default n
|
||||
|
||||
config PM_ENABLE_DEBUG
|
||||
bool "PM Enable Debug"
|
||||
default n
|
||||
|
||||
config PM_ENABLE_SUSPEND_SLEEP_MODE
|
||||
bool "PM Device suspend change sleep mode"
|
||||
default n
|
||||
|
||||
config PM_ENABLE_THRESHOLD_SLEEP_MODE
|
||||
bool "PM using threshold time change sleep mode"
|
||||
default n
|
||||
|
||||
if PM_ENABLE_THRESHOLD_SLEEP_MODE
|
||||
config PM_LIGHT_THRESHOLD_TIME
|
||||
int "PM light mode threashold time"
|
||||
default 5
|
||||
|
||||
config PM_DEEP_THRESHOLD_TIME
|
||||
int "PM deep mode threashold time"
|
||||
default 20
|
||||
|
||||
config PM_STANDBY_THRESHOLD_TIME
|
||||
int "PM standby mode threashold time"
|
||||
default 100
|
||||
endif
|
||||
endif
|
||||
|
||||
config RT_USING_RTC
|
||||
bool "Using RTC device drivers"
|
||||
default n
|
||||
|
||||
if RT_USING_RTC
|
||||
config RT_USING_ALARM
|
||||
bool "Using RTC alarm"
|
||||
default n
|
||||
|
||||
config RT_USING_SOFT_RTC
|
||||
bool "Using software simulation RTC device"
|
||||
default n
|
||||
endif
|
||||
|
||||
config RT_USING_SDIO
|
||||
bool "Using SD/MMC device drivers"
|
||||
default n
|
||||
|
||||
if RT_USING_SDIO
|
||||
config RT_SDIO_STACK_SIZE
|
||||
int "The stack size for sdio irq thread"
|
||||
default 512
|
||||
|
||||
config RT_SDIO_THREAD_PRIORITY
|
||||
int "The priority level value of sdio irq thread"
|
||||
default 15
|
||||
|
||||
config RT_MMCSD_STACK_SIZE
|
||||
int "The stack size for mmcsd thread"
|
||||
default 1024
|
||||
|
||||
config RT_MMCSD_THREAD_PREORITY
|
||||
int "The priority level value of mmcsd thread"
|
||||
default 22
|
||||
|
||||
config RT_MMCSD_MAX_PARTITION
|
||||
int "mmcsd max partition"
|
||||
default 16
|
||||
config RT_SDIO_DEBUG
|
||||
bool "Enable SDIO debug log output"
|
||||
default n
|
||||
endif
|
||||
|
||||
config RT_USING_SPI
|
||||
bool "Using SPI Bus/Device device drivers"
|
||||
default n
|
||||
|
||||
if RT_USING_SPI
|
||||
config RT_USING_SPI_BITOPS
|
||||
select RT_USING_PIN
|
||||
bool "Use GPIO to simulate SPI"
|
||||
default n
|
||||
|
||||
if RT_USING_SPI_BITOPS
|
||||
config RT_SPI_BITOPS_DEBUG
|
||||
bool "Use simulate SPI debug message"
|
||||
default n
|
||||
endif
|
||||
|
||||
config RT_USING_QSPI
|
||||
bool "Enable QSPI mode"
|
||||
default n
|
||||
|
||||
config RT_USING_SPI_MSD
|
||||
bool "Using SD/TF card driver with spi"
|
||||
select RT_USING_DFS
|
||||
default n
|
||||
|
||||
config RT_USING_SFUD
|
||||
bool "Using Serial Flash Universal Driver"
|
||||
default n
|
||||
help
|
||||
An using JEDEC's SFDP standard serial (SPI) flash universal driver library
|
||||
|
||||
if RT_USING_SFUD
|
||||
config RT_SFUD_USING_SFDP
|
||||
bool "Using auto probe flash JEDEC SFDP parameter"
|
||||
default y
|
||||
|
||||
config RT_SFUD_USING_FLASH_INFO_TABLE
|
||||
bool "Using defined supported flash chip information table"
|
||||
default y
|
||||
|
||||
config RT_SFUD_USING_QSPI
|
||||
bool "Using QSPI mode support"
|
||||
select RT_USING_QSPI
|
||||
default n
|
||||
|
||||
config RT_SFUD_SPI_MAX_HZ
|
||||
int "Default spi maximum speed(HZ)"
|
||||
range 0 50000000
|
||||
default 50000000
|
||||
help
|
||||
Read the JEDEC SFDP command must run at 50 MHz or less,and you also can use rt_spi_configure(); to config spi speed.
|
||||
|
||||
config RT_DEBUG_SFUD
|
||||
bool "Show more SFUD debug information"
|
||||
default n
|
||||
endif
|
||||
|
||||
config RT_USING_ENC28J60
|
||||
bool "Using ENC28J60 SPI Ethernet network interface"
|
||||
select RT_USING_LWIP
|
||||
default n
|
||||
|
||||
config RT_USING_SPI_WIFI
|
||||
bool "Using RW009/007 SPI Wi-Fi wireless interface"
|
||||
select RT_USING_LWIP
|
||||
default n
|
||||
endif
|
||||
|
||||
config RT_USING_WDT
|
||||
bool "Using Watch Dog device drivers"
|
||||
default n
|
||||
|
||||
config RT_USING_AUDIO
|
||||
bool "Using Audio device drivers"
|
||||
default n
|
||||
|
||||
if RT_USING_AUDIO
|
||||
config RT_AUDIO_REPLAY_MP_BLOCK_SIZE
|
||||
int "Replay memory pool block size"
|
||||
default 4096
|
||||
|
||||
config RT_AUDIO_REPLAY_MP_BLOCK_COUNT
|
||||
int "Replay memory pool block count"
|
||||
default 2
|
||||
|
||||
config RT_AUDIO_RECORD_PIPE_SIZE
|
||||
int "Record pipe size"
|
||||
default 2048
|
||||
endif
|
||||
|
||||
config RT_USING_SENSOR
|
||||
bool "Using Sensor device drivers"
|
||||
select RT_USING_PIN
|
||||
default n
|
||||
|
||||
if RT_USING_SENSOR
|
||||
config RT_USING_SENSOR_CMD
|
||||
bool "Using Sensor cmd"
|
||||
default y
|
||||
endif
|
||||
|
||||
config RT_USING_TOUCH
|
||||
bool "Using Touch device drivers"
|
||||
default n
|
||||
if RT_USING_TOUCH
|
||||
config RT_TOUCH_PIN_IRQ
|
||||
bool "touch irq use pin irq"
|
||||
default n
|
||||
endif
|
||||
|
||||
menuconfig RT_USING_HWCRYPTO
|
||||
bool "Using Hardware Crypto drivers"
|
||||
default n
|
||||
|
||||
if RT_USING_HWCRYPTO
|
||||
config RT_HWCRYPTO_DEFAULT_NAME
|
||||
string "Hardware crypto device name"
|
||||
default "hwcryto"
|
||||
|
||||
config RT_HWCRYPTO_IV_MAX_SIZE
|
||||
int "IV max size"
|
||||
default "16"
|
||||
|
||||
config RT_HWCRYPTO_KEYBIT_MAX_SIZE
|
||||
int "Key max bit length"
|
||||
default 256
|
||||
|
||||
config RT_HWCRYPTO_USING_GCM
|
||||
bool "Using Hardware GCM"
|
||||
default n
|
||||
|
||||
config RT_HWCRYPTO_USING_AES
|
||||
bool "Using Hardware AES"
|
||||
default n
|
||||
|
||||
if RT_HWCRYPTO_USING_AES
|
||||
config RT_HWCRYPTO_USING_AES_ECB
|
||||
bool "Using Hardware AES ECB mode"
|
||||
default y
|
||||
|
||||
config RT_HWCRYPTO_USING_AES_CBC
|
||||
bool "Using Hardware AES CBC mode"
|
||||
default n
|
||||
|
||||
config RT_HWCRYPTO_USING_AES_CFB
|
||||
bool "Using Hardware AES CFB mode"
|
||||
default n
|
||||
|
||||
config RT_HWCRYPTO_USING_AES_CTR
|
||||
bool "Using Hardware AES CTR mode"
|
||||
default n
|
||||
|
||||
config RT_HWCRYPTO_USING_AES_OFB
|
||||
bool "Using Hardware AES OFB mode"
|
||||
default n
|
||||
endif
|
||||
|
||||
config RT_HWCRYPTO_USING_DES
|
||||
bool "Using Hardware DES"
|
||||
default n
|
||||
|
||||
if RT_HWCRYPTO_USING_DES
|
||||
config RT_HWCRYPTO_USING_DES_ECB
|
||||
bool "Using Hardware DES ECB mode"
|
||||
default y
|
||||
|
||||
config RT_HWCRYPTO_USING_DES_CBC
|
||||
bool "Using Hardware DES CBC mode"
|
||||
default n
|
||||
endif
|
||||
|
||||
config RT_HWCRYPTO_USING_3DES
|
||||
bool "Using Hardware 3DES"
|
||||
default n
|
||||
|
||||
if RT_HWCRYPTO_USING_3DES
|
||||
config RT_HWCRYPTO_USING_3DES_ECB
|
||||
bool "Using Hardware 3DES ECB mode"
|
||||
default y
|
||||
|
||||
config RT_HWCRYPTO_USING_3DES_CBC
|
||||
bool "Using Hardware 3DES CBC mode"
|
||||
default n
|
||||
endif
|
||||
|
||||
config RT_HWCRYPTO_USING_RC4
|
||||
bool "Using Hardware RC4"
|
||||
default n
|
||||
|
||||
config RT_HWCRYPTO_USING_MD5
|
||||
bool "Using Hardware MD5"
|
||||
default n
|
||||
|
||||
config RT_HWCRYPTO_USING_SHA1
|
||||
bool "Using Hardware SHA1"
|
||||
default n
|
||||
|
||||
config RT_HWCRYPTO_USING_SHA2
|
||||
bool "Using Hardware SHA2"
|
||||
default n
|
||||
|
||||
if RT_HWCRYPTO_USING_SHA2
|
||||
config RT_HWCRYPTO_USING_SHA2_224
|
||||
bool "Using Hardware SHA2_224 mode"
|
||||
default n
|
||||
|
||||
config RT_HWCRYPTO_USING_SHA2_256
|
||||
bool "Using Hardware SHA2_256 mode"
|
||||
default y
|
||||
|
||||
config RT_HWCRYPTO_USING_SHA2_384
|
||||
bool "Using Hardware SHA2_384 mode"
|
||||
default n
|
||||
|
||||
config RT_HWCRYPTO_USING_SHA2_512
|
||||
bool "Using Hardware SHA2_512 mode"
|
||||
default n
|
||||
endif
|
||||
|
||||
config RT_HWCRYPTO_USING_RNG
|
||||
bool "Using Hardware RNG"
|
||||
default n
|
||||
|
||||
config RT_HWCRYPTO_USING_CRC
|
||||
bool "Using Hardware CRC"
|
||||
default n
|
||||
|
||||
if RT_HWCRYPTO_USING_CRC
|
||||
config RT_HWCRYPTO_USING_CRC_07
|
||||
bool "Using Hardware CRC-8 0x07 polynomial"
|
||||
default n
|
||||
|
||||
config RT_HWCRYPTO_USING_CRC_8005
|
||||
bool "Using Hardware CRC-16 0x8005 polynomial"
|
||||
default n
|
||||
|
||||
config RT_HWCRYPTO_USING_CRC_1021
|
||||
bool "Using Hardware CRC-16 0x1021 polynomial"
|
||||
default n
|
||||
|
||||
config RT_HWCRYPTO_USING_CRC_3D65
|
||||
bool "Using Hardware CRC-16 0x3D65 polynomial"
|
||||
default n
|
||||
|
||||
config RT_HWCRYPTO_USING_CRC_04C11DB7
|
||||
bool "Using Hardware CRC-32 0x04C11DB7 polynomial"
|
||||
default n
|
||||
endif
|
||||
|
||||
config RT_HWCRYPTO_USING_BIGNUM
|
||||
bool "Using Hardware bignum"
|
||||
default n
|
||||
|
||||
if RT_HWCRYPTO_USING_BIGNUM
|
||||
config RT_HWCRYPTO_USING_BIGNUM_EXPTMOD
|
||||
bool "Using Hardware bignum expt_mod operation"
|
||||
default y
|
||||
|
||||
config RT_HWCRYPTO_USING_BIGNUM_MULMOD
|
||||
bool "Using Hardware bignum mul_mod operation"
|
||||
default y
|
||||
|
||||
config RT_HWCRYPTO_USING_BIGNUM_MUL
|
||||
bool "Using Hardware bignum mul operation"
|
||||
default n
|
||||
|
||||
config RT_HWCRYPTO_USING_BIGNUM_ADD
|
||||
bool "Using Hardware bignum add operation"
|
||||
default n
|
||||
|
||||
config RT_HWCRYPTO_USING_BIGNUM_SUB
|
||||
bool "Using Hardware bignum sub operation"
|
||||
default n
|
||||
endif
|
||||
endif
|
||||
|
||||
config RT_USING_PULSE_ENCODER
|
||||
bool "Using PULSE ENCODER device drivers"
|
||||
default n
|
||||
|
||||
config RT_USING_INPUT_CAPTURE
|
||||
bool "Using INPUT CAPTURE device drivers"
|
||||
default n
|
||||
|
||||
if RT_USING_INPUT_CAPTURE
|
||||
config RT_INPUT_CAPTURE_RB_SIZE
|
||||
int "Set input capture ringbuffer size"
|
||||
default 100
|
||||
endif
|
||||
|
||||
menuconfig RT_USING_WIFI
|
||||
bool "Using Wi-Fi framework"
|
||||
default n
|
||||
|
||||
if RT_USING_WIFI
|
||||
config RT_WLAN_DEVICE_STA_NAME
|
||||
string "The device name for station"
|
||||
default "wlan0"
|
||||
|
||||
config RT_WLAN_DEVICE_AP_NAME
|
||||
string "The device name for ap"
|
||||
default "wlan1"
|
||||
|
||||
config RT_WLAN_SSID_MAX_LENGTH
|
||||
int "SSID maximum length"
|
||||
default 32
|
||||
|
||||
config RT_WLAN_PASSWORD_MAX_LENGTH
|
||||
int "Password maximum length"
|
||||
default 32
|
||||
|
||||
config RT_WLAN_DEV_EVENT_NUM
|
||||
int "Driver events maxcount"
|
||||
default 2
|
||||
|
||||
config RT_WLAN_MANAGE_ENABLE
|
||||
bool "Connection management Enable"
|
||||
default y
|
||||
|
||||
if RT_WLAN_MANAGE_ENABLE
|
||||
config RT_WLAN_SCAN_WAIT_MS
|
||||
int "Set scan timeout time(ms)"
|
||||
default 10000
|
||||
|
||||
config RT_WLAN_CONNECT_WAIT_MS
|
||||
int "Set connect timeout time(ms)"
|
||||
default 10000
|
||||
|
||||
config RT_WLAN_SCAN_SORT
|
||||
bool "Automatic sorting of scan results"
|
||||
default y
|
||||
|
||||
config RT_WLAN_MSH_CMD_ENABLE
|
||||
bool "MSH command Enable"
|
||||
default y
|
||||
|
||||
config RT_WLAN_AUTO_CONNECT_ENABLE
|
||||
bool "Auto connect Enable"
|
||||
select RT_WLAN_CFG_ENABLE
|
||||
select RT_WLAN_WORK_THREAD_ENABLE
|
||||
default y
|
||||
|
||||
if RT_WLAN_AUTO_CONNECT_ENABLE
|
||||
config AUTO_CONNECTION_PERIOD_MS
|
||||
int "Auto connect period(ms)"
|
||||
default 2000
|
||||
endif
|
||||
endif
|
||||
|
||||
config RT_WLAN_CFG_ENABLE
|
||||
bool "WiFi information automatically saved Enable"
|
||||
default y
|
||||
|
||||
if RT_WLAN_CFG_ENABLE
|
||||
config RT_WLAN_CFG_INFO_MAX
|
||||
int "Maximum number of WiFi information automatically saved"
|
||||
default 3
|
||||
endif
|
||||
|
||||
config RT_WLAN_PROT_ENABLE
|
||||
bool "Transport protocol manage Enable"
|
||||
default y
|
||||
|
||||
if RT_WLAN_PROT_ENABLE
|
||||
config RT_WLAN_PROT_NAME_LEN
|
||||
int "Transport protocol name length"
|
||||
default 8
|
||||
|
||||
config RT_WLAN_PROT_MAX
|
||||
int "Transport protocol maxcount"
|
||||
default 2
|
||||
|
||||
config RT_WLAN_DEFAULT_PROT
|
||||
string "Default transport protocol"
|
||||
default "lwip"
|
||||
|
||||
config RT_WLAN_PROT_LWIP_ENABLE
|
||||
bool "LWIP transport protocol Enable"
|
||||
select RT_USING_LWIP
|
||||
default y
|
||||
|
||||
if RT_WLAN_PROT_LWIP_ENABLE
|
||||
config RT_WLAN_PROT_LWIP_NAME
|
||||
string "LWIP transport protocol name"
|
||||
default "lwip"
|
||||
|
||||
config RT_WLAN_PROT_LWIP_PBUF_FORCE
|
||||
bool "Forced use of PBUF transmission"
|
||||
default n
|
||||
endif
|
||||
endif
|
||||
|
||||
config RT_WLAN_WORK_THREAD_ENABLE
|
||||
bool "WLAN work queue thread Enable"
|
||||
default y
|
||||
|
||||
if RT_WLAN_WORK_THREAD_ENABLE
|
||||
config RT_WLAN_WORKQUEUE_THREAD_NAME
|
||||
string "WLAN work queue thread name"
|
||||
default "wlan"
|
||||
|
||||
config RT_WLAN_WORKQUEUE_THREAD_SIZE
|
||||
int "WLAN work queue thread size"
|
||||
default 2048
|
||||
|
||||
config RT_WLAN_WORKQUEUE_THREAD_PRIO
|
||||
int "WLAN work queue thread priority"
|
||||
default 15
|
||||
endif
|
||||
|
||||
menuconfig RT_WLAN_DEBUG
|
||||
bool "Enable WLAN Debugging Options"
|
||||
default n
|
||||
|
||||
if RT_WLAN_DEBUG
|
||||
config RT_WLAN_CMD_DEBUG
|
||||
bool "Enable Debugging of wlan_cmd.c"
|
||||
default n
|
||||
|
||||
config RT_WLAN_MGNT_DEBUG
|
||||
bool "Enable Debugging of wlan_mgnt.c"
|
||||
default n
|
||||
|
||||
config RT_WLAN_DEV_DEBUG
|
||||
bool "Enable Debugging of wlan_dev.c"
|
||||
default n
|
||||
|
||||
config RT_WLAN_PROT_DEBUG
|
||||
bool "Enable Debugging of wlan_prot.c"
|
||||
default n
|
||||
|
||||
config RT_WLAN_CFG_DEBUG
|
||||
bool "Enable Debugging of wlan_cfg.c"
|
||||
default n
|
||||
|
||||
config RT_WLAN_LWIP_DEBUG
|
||||
bool "Enable Debugging of wlan_lwip.c"
|
||||
default n
|
||||
endif
|
||||
endif
|
||||
|
||||
menu "Using USB"
|
||||
config RT_USING_USB
|
||||
bool
|
||||
default n
|
||||
|
||||
config RT_USING_USB_HOST
|
||||
bool "Using USB host"
|
||||
default n
|
||||
select RT_USING_USB
|
||||
|
||||
if RT_USING_USB_HOST
|
||||
config RT_USBH_MSTORAGE
|
||||
bool "Enable Udisk Drivers"
|
||||
default n
|
||||
if RT_USBH_MSTORAGE
|
||||
config UDISK_MOUNTPOINT
|
||||
string "Udisk mount dir"
|
||||
default "/"
|
||||
endif
|
||||
config RT_USBH_HID
|
||||
bool "Enable HID Drivers"
|
||||
default n
|
||||
if RT_USBH_HID
|
||||
config RT_USBH_HID_MOUSE
|
||||
bool "Enable HID mouse protocol"
|
||||
default n
|
||||
endif
|
||||
endif
|
||||
config RT_USING_USB_DEVICE
|
||||
bool "Using USB device"
|
||||
default n
|
||||
select RT_USING_USB
|
||||
|
||||
if RT_USING_USB_DEVICE || RT_USING_USB_HOST
|
||||
config RT_USBD_THREAD_STACK_SZ
|
||||
int "usb thread stack size"
|
||||
default 4096
|
||||
endif
|
||||
if RT_USING_USB_DEVICE
|
||||
config USB_VENDOR_ID
|
||||
hex "USB Vendor ID"
|
||||
default 0x0FFE
|
||||
config USB_PRODUCT_ID
|
||||
hex "USB Product ID"
|
||||
default 0x0001
|
||||
|
||||
config RT_USB_DEVICE_COMPOSITE
|
||||
bool "Enable composite device"
|
||||
default n
|
||||
choice
|
||||
prompt "Device type"
|
||||
default _RT_USB_DEVICE_NONE
|
||||
depends on !RT_USB_DEVICE_COMPOSITE
|
||||
config _RT_USB_DEVICE_NONE
|
||||
bool "Using custom class by register interface"
|
||||
select RT_USB_DEVICE_NONE
|
||||
config _RT_USB_DEVICE_CDC
|
||||
bool "Enable to use device as CDC device"
|
||||
select RT_USB_DEVICE_CDC
|
||||
config _RT_USB_DEVICE_MSTORAGE
|
||||
bool "Enable to use device as Mass Storage device"
|
||||
select RT_USB_DEVICE_MSTORAGE
|
||||
config _RT_USB_DEVICE_HID
|
||||
bool "Enable to use device as HID device"
|
||||
select RT_USB_DEVICE_HID
|
||||
config _RT_USB_DEVICE_RNDIS
|
||||
bool "Enable to use device as rndis device"
|
||||
select RT_USB_DEVICE_RNDIS
|
||||
depends on RT_USING_LWIP
|
||||
config _RT_USB_DEVICE_ECM
|
||||
bool "Enable to use device as ecm device"
|
||||
select RT_USB_DEVICE_ECM
|
||||
depends on RT_USING_LWIP
|
||||
config _RT_USB_DEVICE_WINUSB
|
||||
bool "Enable to use device as winusb device"
|
||||
select RT_USB_DEVICE_WINUSB
|
||||
config _RT_USB_DEVICE_AUDIO
|
||||
bool "Enable to use device as audio device"
|
||||
select RT_USB_DEVICE_AUDIO
|
||||
endchoice
|
||||
if RT_USB_DEVICE_COMPOSITE
|
||||
config RT_USB_DEVICE_CDC
|
||||
bool "Enable to use device as CDC device"
|
||||
default n
|
||||
config RT_USB_DEVICE_NONE
|
||||
bool
|
||||
default y
|
||||
config RT_USB_DEVICE_MSTORAGE
|
||||
bool "Enable to use device as Mass Storage device"
|
||||
default n
|
||||
config RT_USB_DEVICE_HID
|
||||
bool "Enable to use device as HID device"
|
||||
default n
|
||||
config RT_USB_DEVICE_RNDIS
|
||||
bool "Enable to use device as rndis device"
|
||||
default n
|
||||
depends on RT_USING_LWIP
|
||||
config RT_USB_DEVICE_ECM
|
||||
bool "Enable to use device as ecm device"
|
||||
default n
|
||||
depends on RT_USING_LWIP
|
||||
config RT_USB_DEVICE_WINUSB
|
||||
bool "Enable to use device as winusb device"
|
||||
default n
|
||||
config RT_USB_DEVICE_AUDIO
|
||||
bool "Enable to use device as audio device"
|
||||
default n
|
||||
endif
|
||||
if RT_USB_DEVICE_CDC
|
||||
config RT_VCOM_TASK_STK_SIZE
|
||||
int "virtual com thread stack size"
|
||||
default 512
|
||||
config RT_CDC_RX_BUFSIZE
|
||||
int "virtual com rx buffer size"
|
||||
default 128
|
||||
config RT_VCOM_TX_USE_DMA
|
||||
bool "Enable to use dma for vcom tx"
|
||||
default n
|
||||
config RT_VCOM_SERNO
|
||||
string "serial number of virtual com"
|
||||
default "32021919830108"
|
||||
config RT_VCOM_SER_LEN
|
||||
int "serial number length of virtual com"
|
||||
default 14
|
||||
config RT_VCOM_TX_TIMEOUT
|
||||
int "tx timeout(ticks) of virtual com"
|
||||
default 1000
|
||||
endif
|
||||
if RT_USB_DEVICE_WINUSB
|
||||
config RT_WINUSB_GUID
|
||||
string "Guid for winusb"
|
||||
default "{6860DC3C-C05F-4807-8807-1CA861CC1D66}"
|
||||
endif
|
||||
if RT_USB_DEVICE_MSTORAGE
|
||||
config RT_USB_MSTORAGE_DISK_NAME
|
||||
string "msc class disk name"
|
||||
default "flash0"
|
||||
endif
|
||||
|
||||
if RT_USB_DEVICE_RNDIS
|
||||
config RNDIS_DELAY_LINK_UP
|
||||
bool "Delay linkup media connection"
|
||||
select RT_USING_TIMER_SOFT
|
||||
default n
|
||||
endif
|
||||
|
||||
if RT_USB_DEVICE_HID
|
||||
config RT_USB_DEVICE_HID_KEYBOARD
|
||||
bool "Use to HID device as Keyboard"
|
||||
default n
|
||||
if RT_USB_DEVICE_HID_KEYBOARD
|
||||
config RT_USB_DEVICE_HID_KEYBOARD_NUMBER
|
||||
int "Number of Keyboard(max 3)"
|
||||
default 1
|
||||
range 1 3
|
||||
endif
|
||||
config RT_USB_DEVICE_HID_MOUSE
|
||||
bool "Use to HID device as Mouse"
|
||||
default n
|
||||
config RT_USB_DEVICE_HID_GENERAL
|
||||
bool "Use to HID device as General HID device"
|
||||
default y
|
||||
if RT_USB_DEVICE_HID_GENERAL
|
||||
config RT_USB_DEVICE_HID_GENERAL_OUT_REPORT_LENGTH
|
||||
int "General HID device out report length"
|
||||
default 63
|
||||
range 0 63
|
||||
|
||||
config RT_USB_DEVICE_HID_GENERAL_IN_REPORT_LENGTH
|
||||
int "General HID device in report length"
|
||||
default 63
|
||||
range 0 63
|
||||
endif
|
||||
config RT_USB_DEVICE_HID_MEDIA
|
||||
bool "Use to HID device as media keyboard"
|
||||
default y
|
||||
endif
|
||||
if RT_USB_DEVICE_AUDIO
|
||||
config RT_USB_DEVICE_AUDIO_MIC
|
||||
bool "Use usb mic device as audio device"
|
||||
default n
|
||||
if RT_USB_DEVICE_AUDIO_MIC
|
||||
config RT_USBD_MIC_DEVICE_NAME
|
||||
string "audio mic device name"
|
||||
default "mic0"
|
||||
endif
|
||||
config RT_USB_DEVICE_AUDIO_SPEAKER
|
||||
bool "Use usb speaker device as audio device"
|
||||
default n
|
||||
if RT_USB_DEVICE_AUDIO_SPEAKER
|
||||
config RT_USBD_SPEAKER_DEVICE_NAME
|
||||
string "audio speaker device name"
|
||||
default "sound0"
|
||||
endif
|
||||
endif
|
||||
endif
|
||||
endmenu
|
||||
endmenu
|
||||
@@ -0,0 +1,14 @@
|
||||
# for module compiling
|
||||
import os
|
||||
from building import *
|
||||
|
||||
cwd = GetCurrentDir()
|
||||
objs = []
|
||||
list = os.listdir(cwd)
|
||||
|
||||
for d in list:
|
||||
path = os.path.join(cwd, d)
|
||||
if os.path.isfile(os.path.join(path, 'SConscript')):
|
||||
objs = objs + SConscript(os.path.join(d, 'SConscript'))
|
||||
|
||||
Return('objs')
|
||||
@@ -0,0 +1,9 @@
|
||||
from building import *
|
||||
|
||||
cwd = GetCurrentDir()
|
||||
src = Glob('*.c')
|
||||
CPPPATH = [cwd]
|
||||
|
||||
group = DefineGroup('DeviceDrivers', src, depend = ['RT_USING_AUDIO'], CPPPATH = CPPPATH)
|
||||
|
||||
Return('group')
|
||||
@@ -0,0 +1,612 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2017-05-09 Urey first version
|
||||
* 2019-07-09 Zero-Free improve device ops interface and data flows
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <rthw.h>
|
||||
#include <rtdevice.h>
|
||||
|
||||
#define DBG_TAG "audio"
|
||||
#define DBG_LVL DBG_INFO
|
||||
#include <rtdbg.h>
|
||||
|
||||
#ifndef MIN
|
||||
#define MIN(a, b) ((a) < (b) ? (a) : (b))
|
||||
#endif
|
||||
|
||||
enum
|
||||
{
|
||||
REPLAY_EVT_NONE = 0x00,
|
||||
REPLAY_EVT_START = 0x01,
|
||||
REPLAY_EVT_STOP = 0x02,
|
||||
};
|
||||
|
||||
static rt_err_t _audio_send_replay_frame(struct rt_audio_device *audio)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
rt_uint8_t *data;
|
||||
rt_size_t dst_size, src_size;
|
||||
rt_uint16_t position, remain_bytes = 0, index = 0;
|
||||
struct rt_audio_buf_info *buf_info;
|
||||
|
||||
RT_ASSERT(audio != RT_NULL);
|
||||
|
||||
buf_info = &audio->replay->buf_info;
|
||||
/* save current pos */
|
||||
position = audio->replay->pos;
|
||||
dst_size = buf_info->block_size;
|
||||
|
||||
/* check replay queue is empty */
|
||||
if (rt_data_queue_peek(&audio->replay->queue, (const void **)&data, &src_size) != RT_EOK)
|
||||
{
|
||||
/* ack stop event */
|
||||
if (audio->replay->event & REPLAY_EVT_STOP)
|
||||
rt_completion_done(&audio->replay->cmp);
|
||||
|
||||
/* send zero frames */
|
||||
rt_memset(&buf_info->buffer[audio->replay->pos], 0, dst_size);
|
||||
|
||||
audio->replay->pos += dst_size;
|
||||
audio->replay->pos %= buf_info->total_size;
|
||||
}
|
||||
else
|
||||
{
|
||||
rt_memset(&buf_info->buffer[audio->replay->pos], 0, dst_size);
|
||||
|
||||
/* copy data from memory pool to hardware device fifo */
|
||||
while (index < dst_size)
|
||||
{
|
||||
result = rt_data_queue_peek(&audio->replay->queue, (const void **)&data, &src_size);
|
||||
if (result != RT_EOK)
|
||||
{
|
||||
LOG_D("under run %d, remain %d", audio->replay->pos, remain_bytes);
|
||||
audio->replay->pos -= remain_bytes;
|
||||
audio->replay->pos += dst_size;
|
||||
audio->replay->pos %= buf_info->total_size;
|
||||
audio->replay->read_index = 0;
|
||||
result = -RT_EEMPTY;
|
||||
break;
|
||||
}
|
||||
|
||||
remain_bytes = MIN((dst_size - index), (src_size - audio->replay->read_index));
|
||||
rt_memcpy(&buf_info->buffer[audio->replay->pos],
|
||||
&data[audio->replay->read_index], remain_bytes);
|
||||
|
||||
index += remain_bytes;
|
||||
audio->replay->read_index += remain_bytes;
|
||||
audio->replay->pos += remain_bytes;
|
||||
audio->replay->pos %= buf_info->total_size;
|
||||
|
||||
if (audio->replay->read_index == src_size)
|
||||
{
|
||||
/* free memory */
|
||||
audio->replay->read_index = 0;
|
||||
rt_data_queue_pop(&audio->replay->queue, (const void **)&data, &src_size, RT_WAITING_NO);
|
||||
rt_mp_free(data);
|
||||
|
||||
/* notify transmitted complete. */
|
||||
if (audio->parent.tx_complete != RT_NULL)
|
||||
audio->parent.tx_complete(&audio->parent, (void *)data);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (audio->ops->transmit != RT_NULL)
|
||||
{
|
||||
if (audio->ops->transmit(audio, &buf_info->buffer[position], RT_NULL, dst_size) != dst_size)
|
||||
result = -RT_ERROR;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static rt_err_t _audio_flush_replay_frame(struct rt_audio_device *audio)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
|
||||
if (audio->replay->write_index)
|
||||
{
|
||||
result = rt_data_queue_push(&audio->replay->queue,
|
||||
(const void **)audio->replay->write_data,
|
||||
audio->replay->write_index,
|
||||
RT_WAITING_FOREVER);
|
||||
|
||||
audio->replay->write_index = 0;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static rt_err_t _aduio_replay_start(struct rt_audio_device *audio)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
|
||||
if (audio->replay->activated != RT_TRUE)
|
||||
{
|
||||
/* start playback hardware device */
|
||||
if (audio->ops->start)
|
||||
result = audio->ops->start(audio, AUDIO_STREAM_REPLAY);
|
||||
|
||||
audio->replay->activated = RT_TRUE;
|
||||
LOG_D("start audio replay device");
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static rt_err_t _aduio_replay_stop(struct rt_audio_device *audio)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
|
||||
if (audio->replay->activated == RT_TRUE)
|
||||
{
|
||||
/* flush replay remian frames */
|
||||
_audio_flush_replay_frame(audio);
|
||||
|
||||
/* notify irq(or thread) to stop the data transmission */
|
||||
audio->replay->event |= REPLAY_EVT_STOP;
|
||||
|
||||
/* waiting for the remaining data transfer to complete */
|
||||
rt_completion_init(&audio->replay->cmp);
|
||||
rt_completion_wait(&audio->replay->cmp, RT_WAITING_FOREVER);
|
||||
audio->replay->event &= ~REPLAY_EVT_STOP;
|
||||
|
||||
/* stop playback hardware device */
|
||||
if (audio->ops->stop)
|
||||
result = audio->ops->stop(audio, AUDIO_STREAM_REPLAY);
|
||||
|
||||
audio->replay->activated = RT_FALSE;
|
||||
LOG_D("stop audio replay device");
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static rt_err_t _audio_record_start(struct rt_audio_device *audio)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
|
||||
if (audio->record->activated != RT_TRUE)
|
||||
{
|
||||
/* open audio record pipe */
|
||||
rt_device_open(RT_DEVICE(&audio->record->pipe), RT_DEVICE_OFLAG_RDONLY);
|
||||
|
||||
/* start record hardware device */
|
||||
if (audio->ops->start)
|
||||
result = audio->ops->start(audio, AUDIO_STREAM_RECORD);
|
||||
|
||||
audio->record->activated = RT_TRUE;
|
||||
LOG_D("start audio record device");
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static rt_err_t _audio_record_stop(struct rt_audio_device *audio)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
|
||||
if (audio->record->activated == RT_TRUE)
|
||||
{
|
||||
/* stop record hardware device */
|
||||
if (audio->ops->stop)
|
||||
result = audio->ops->stop(audio, AUDIO_STREAM_RECORD);
|
||||
|
||||
/* close audio record pipe */
|
||||
rt_device_close(RT_DEVICE(&audio->record->pipe));
|
||||
|
||||
audio->record->activated = RT_FALSE;
|
||||
LOG_D("stop audio record device");
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static rt_err_t _audio_dev_init(struct rt_device *dev)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
struct rt_audio_device *audio;
|
||||
|
||||
RT_ASSERT(dev != RT_NULL);
|
||||
audio = (struct rt_audio_device *) dev;
|
||||
|
||||
/* initialize replay & record */
|
||||
audio->replay = RT_NULL;
|
||||
audio->record = RT_NULL;
|
||||
|
||||
/* initialize replay */
|
||||
if (dev->flag & RT_DEVICE_FLAG_WRONLY)
|
||||
{
|
||||
struct rt_audio_replay *replay = (struct rt_audio_replay *) rt_malloc(sizeof(struct rt_audio_replay));
|
||||
|
||||
if (replay == RT_NULL)
|
||||
return -RT_ENOMEM;
|
||||
rt_memset(replay, 0, sizeof(struct rt_audio_replay));
|
||||
|
||||
/* init memory pool for replay */
|
||||
replay->mp = rt_mp_create("adu_mp", RT_AUDIO_REPLAY_MP_BLOCK_COUNT, RT_AUDIO_REPLAY_MP_BLOCK_SIZE);
|
||||
if (replay->mp == RT_NULL)
|
||||
{
|
||||
rt_free(replay);
|
||||
LOG_E("create memory pool for replay failed");
|
||||
return -RT_ENOMEM;
|
||||
}
|
||||
|
||||
/* init queue for audio replay */
|
||||
rt_data_queue_init(&replay->queue, CFG_AUDIO_REPLAY_QUEUE_COUNT, 0, RT_NULL);
|
||||
|
||||
/* init mutex lock for audio replay */
|
||||
rt_mutex_init(&replay->lock, "replay", RT_IPC_FLAG_PRIO);
|
||||
|
||||
replay->activated = RT_FALSE;
|
||||
audio->replay = replay;
|
||||
}
|
||||
|
||||
/* initialize record */
|
||||
if (dev->flag & RT_DEVICE_FLAG_RDONLY)
|
||||
{
|
||||
struct rt_audio_record *record = (struct rt_audio_record *) rt_malloc(sizeof(struct rt_audio_record));
|
||||
rt_uint8_t *buffer;
|
||||
|
||||
if (record == RT_NULL)
|
||||
return -RT_ENOMEM;
|
||||
rt_memset(record, 0, sizeof(struct rt_audio_record));
|
||||
|
||||
/* init pipe for record*/
|
||||
buffer = rt_malloc(RT_AUDIO_RECORD_PIPE_SIZE);
|
||||
if (buffer == RT_NULL)
|
||||
{
|
||||
rt_free(record);
|
||||
LOG_E("malloc memory for for record pipe failed");
|
||||
return -RT_ENOMEM;
|
||||
}
|
||||
rt_audio_pipe_init(&record->pipe, "record",
|
||||
(rt_int32_t)(RT_PIPE_FLAG_FORCE_WR | RT_PIPE_FLAG_BLOCK_RD),
|
||||
buffer,
|
||||
RT_AUDIO_RECORD_PIPE_SIZE);
|
||||
|
||||
record->activated = RT_FALSE;
|
||||
audio->record = record;
|
||||
}
|
||||
|
||||
/* initialize hardware configuration */
|
||||
if (audio->ops->init)
|
||||
audio->ops->init(audio);
|
||||
|
||||
/* get replay buffer information */
|
||||
if (audio->ops->buffer_info)
|
||||
audio->ops->buffer_info(audio, &audio->replay->buf_info);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static rt_err_t _audio_dev_open(struct rt_device *dev, rt_uint16_t oflag)
|
||||
{
|
||||
struct rt_audio_device *audio;
|
||||
|
||||
RT_ASSERT(dev != RT_NULL);
|
||||
audio = (struct rt_audio_device *) dev;
|
||||
|
||||
/* check device flag with the open flag */
|
||||
if ((oflag & RT_DEVICE_OFLAG_RDONLY) && !(dev->flag & RT_DEVICE_FLAG_RDONLY))
|
||||
return -RT_EIO;
|
||||
if ((oflag & RT_DEVICE_OFLAG_WRONLY) && !(dev->flag & RT_DEVICE_FLAG_WRONLY))
|
||||
return -RT_EIO;
|
||||
|
||||
/* get open flags */
|
||||
dev->open_flag = oflag & 0xff;
|
||||
|
||||
/* initialize the Rx/Tx structure according to open flag */
|
||||
if (oflag & RT_DEVICE_OFLAG_WRONLY)
|
||||
{
|
||||
if (audio->replay->activated != RT_TRUE)
|
||||
{
|
||||
LOG_D("open audio replay device, oflag = %x\n", oflag);
|
||||
audio->replay->write_index = 0;
|
||||
audio->replay->read_index = 0;
|
||||
audio->replay->pos = 0;
|
||||
audio->replay->event = REPLAY_EVT_NONE;
|
||||
}
|
||||
dev->open_flag |= RT_DEVICE_OFLAG_WRONLY;
|
||||
}
|
||||
|
||||
if (oflag & RT_DEVICE_OFLAG_RDONLY)
|
||||
{
|
||||
/* open record pipe */
|
||||
if (audio->record->activated != RT_TRUE)
|
||||
{
|
||||
LOG_D("open audio record device ,oflag = %x\n", oflag);
|
||||
|
||||
_audio_record_start(audio);
|
||||
audio->record->activated = RT_TRUE;
|
||||
}
|
||||
dev->open_flag |= RT_DEVICE_OFLAG_RDONLY;
|
||||
}
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static rt_err_t _audio_dev_close(struct rt_device *dev)
|
||||
{
|
||||
struct rt_audio_device *audio;
|
||||
RT_ASSERT(dev != RT_NULL);
|
||||
audio = (struct rt_audio_device *) dev;
|
||||
|
||||
if (dev->open_flag & RT_DEVICE_OFLAG_WRONLY)
|
||||
{
|
||||
/* stop replay stream */
|
||||
_aduio_replay_stop(audio);
|
||||
dev->open_flag &= ~RT_DEVICE_OFLAG_WRONLY;
|
||||
}
|
||||
|
||||
if (dev->open_flag & RT_DEVICE_OFLAG_RDONLY)
|
||||
{
|
||||
/* stop record stream */
|
||||
_audio_record_stop(audio);
|
||||
dev->open_flag &= ~RT_DEVICE_OFLAG_RDONLY;
|
||||
}
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static rt_size_t _audio_dev_read(struct rt_device *dev, rt_off_t pos, void *buffer, rt_size_t size)
|
||||
{
|
||||
struct rt_audio_device *audio;
|
||||
RT_ASSERT(dev != RT_NULL);
|
||||
audio = (struct rt_audio_device *) dev;
|
||||
|
||||
if (!(dev->open_flag & RT_DEVICE_OFLAG_RDONLY) || (audio->record == RT_NULL))
|
||||
return 0;
|
||||
|
||||
return rt_device_read(RT_DEVICE(&audio->record->pipe), pos, buffer, size);
|
||||
}
|
||||
|
||||
static rt_size_t _audio_dev_write(struct rt_device *dev, rt_off_t pos, const void *buffer, rt_size_t size)
|
||||
{
|
||||
|
||||
struct rt_audio_device *audio;
|
||||
rt_uint8_t *ptr;
|
||||
rt_uint16_t block_size, remain_bytes, index = 0;
|
||||
|
||||
RT_ASSERT(dev != RT_NULL);
|
||||
audio = (struct rt_audio_device *) dev;
|
||||
|
||||
if (!(dev->open_flag & RT_DEVICE_OFLAG_WRONLY) || (audio->replay == RT_NULL))
|
||||
return 0;
|
||||
|
||||
/* push a new frame to replay data queue */
|
||||
ptr = (rt_uint8_t *)buffer;
|
||||
block_size = RT_AUDIO_REPLAY_MP_BLOCK_SIZE;
|
||||
|
||||
rt_mutex_take(&audio->replay->lock, RT_WAITING_FOREVER);
|
||||
while (index < size)
|
||||
{
|
||||
/* request buffer from replay memory pool */
|
||||
if (audio->replay->write_index % block_size == 0)
|
||||
{
|
||||
audio->replay->write_data = rt_mp_alloc(audio->replay->mp, RT_WAITING_FOREVER);
|
||||
rt_memset(audio->replay->write_data, 0, block_size);
|
||||
}
|
||||
|
||||
/* copy data to replay memory pool */
|
||||
remain_bytes = MIN((block_size - audio->replay->write_index), (size - index));
|
||||
rt_memcpy(&audio->replay->write_data[audio->replay->write_index], &ptr[index], remain_bytes);
|
||||
|
||||
index += remain_bytes;
|
||||
audio->replay->write_index += remain_bytes;
|
||||
audio->replay->write_index %= block_size;
|
||||
|
||||
if (audio->replay->write_index == 0)
|
||||
{
|
||||
rt_data_queue_push(&audio->replay->queue,
|
||||
audio->replay->write_data,
|
||||
block_size,
|
||||
RT_WAITING_FOREVER);
|
||||
}
|
||||
}
|
||||
rt_mutex_release(&audio->replay->lock);
|
||||
|
||||
/* check replay state */
|
||||
if (audio->replay->activated != RT_TRUE)
|
||||
{
|
||||
_aduio_replay_start(audio);
|
||||
audio->replay->activated = RT_TRUE;
|
||||
}
|
||||
|
||||
return index;
|
||||
}
|
||||
|
||||
static rt_err_t _audio_dev_control(struct rt_device *dev, int cmd, void *args)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
struct rt_audio_device *audio;
|
||||
RT_ASSERT(dev != RT_NULL);
|
||||
audio = (struct rt_audio_device *) dev;
|
||||
|
||||
/* dev stat...*/
|
||||
switch (cmd)
|
||||
{
|
||||
case AUDIO_CTL_GETCAPS:
|
||||
{
|
||||
struct rt_audio_caps *caps = (struct rt_audio_caps *) args;
|
||||
|
||||
LOG_D("AUDIO_CTL_GETCAPS: main_type = %d,sub_type = %d", caps->main_type, caps->sub_type);
|
||||
if (audio->ops->getcaps != RT_NULL)
|
||||
{
|
||||
result = audio->ops->getcaps(audio, caps);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case AUDIO_CTL_CONFIGURE:
|
||||
{
|
||||
struct rt_audio_caps *caps = (struct rt_audio_caps *) args;
|
||||
|
||||
LOG_D("AUDIO_CTL_CONFIGURE: main_type = %d,sub_type = %d", caps->main_type, caps->sub_type);
|
||||
if (audio->ops->configure != RT_NULL)
|
||||
{
|
||||
result = audio->ops->configure(audio, caps);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case AUDIO_CTL_START:
|
||||
{
|
||||
int stream = *(int *) args;
|
||||
|
||||
LOG_D("AUDIO_CTL_START: stream = %d", stream);
|
||||
if (stream == AUDIO_STREAM_REPLAY)
|
||||
{
|
||||
result = _aduio_replay_start(audio);
|
||||
}
|
||||
else
|
||||
{
|
||||
result = _audio_record_start(audio);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
case AUDIO_CTL_STOP:
|
||||
{
|
||||
int stream = *(int *) args;
|
||||
|
||||
LOG_D("AUDIO_CTL_STOP: stream = %d", stream);
|
||||
if (stream == AUDIO_STREAM_REPLAY)
|
||||
{
|
||||
result = _aduio_replay_stop(audio);
|
||||
}
|
||||
else
|
||||
{
|
||||
result = _audio_record_stop(audio);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
#ifdef RT_USING_DEVICE_OPS
|
||||
const static struct rt_device_ops audio_ops =
|
||||
{
|
||||
_audio_dev_init,
|
||||
_audio_dev_open,
|
||||
_audio_dev_close,
|
||||
_audio_dev_read,
|
||||
_audio_dev_write,
|
||||
_audio_dev_control
|
||||
};
|
||||
#endif
|
||||
|
||||
rt_err_t rt_audio_register(struct rt_audio_device *audio, const char *name, rt_uint32_t flag, void *data)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
struct rt_device *device;
|
||||
|
||||
RT_ASSERT(audio != RT_NULL);
|
||||
device = &(audio->parent);
|
||||
|
||||
device->type = RT_Device_Class_Sound;
|
||||
device->rx_indicate = RT_NULL;
|
||||
device->tx_complete = RT_NULL;
|
||||
|
||||
#ifdef RT_USING_DEVICE_OPS
|
||||
device->ops = &audio_ops;
|
||||
#else
|
||||
device->init = _audio_dev_init;
|
||||
device->open = _audio_dev_open;
|
||||
device->close = _audio_dev_close;
|
||||
device->read = _audio_dev_read;
|
||||
device->write = _audio_dev_write;
|
||||
device->control = _audio_dev_control;
|
||||
#endif
|
||||
device->user_data = data;
|
||||
|
||||
/* register a character device */
|
||||
result = rt_device_register(device, name, flag | RT_DEVICE_FLAG_REMOVABLE);
|
||||
|
||||
/* initialize audio device */
|
||||
if (result == RT_EOK)
|
||||
result = rt_device_init(device);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
int rt_audio_samplerate_to_speed(rt_uint32_t bitValue)
|
||||
{
|
||||
int speed = 0;
|
||||
switch (bitValue)
|
||||
{
|
||||
case AUDIO_SAMP_RATE_8K:
|
||||
speed = 8000;
|
||||
break;
|
||||
case AUDIO_SAMP_RATE_11K:
|
||||
speed = 11052;
|
||||
break;
|
||||
case AUDIO_SAMP_RATE_16K:
|
||||
speed = 16000;
|
||||
break;
|
||||
case AUDIO_SAMP_RATE_22K:
|
||||
speed = 22050;
|
||||
break;
|
||||
case AUDIO_SAMP_RATE_32K:
|
||||
speed = 32000;
|
||||
break;
|
||||
case AUDIO_SAMP_RATE_44K:
|
||||
speed = 44100;
|
||||
break;
|
||||
case AUDIO_SAMP_RATE_48K:
|
||||
speed = 48000;
|
||||
break;
|
||||
case AUDIO_SAMP_RATE_96K:
|
||||
speed = 96000;
|
||||
break;
|
||||
case AUDIO_SAMP_RATE_128K:
|
||||
speed = 128000;
|
||||
break;
|
||||
case AUDIO_SAMP_RATE_160K:
|
||||
speed = 160000;
|
||||
break;
|
||||
case AUDIO_SAMP_RATE_172K:
|
||||
speed = 176400;
|
||||
break;
|
||||
case AUDIO_SAMP_RATE_192K:
|
||||
speed = 192000;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return speed;
|
||||
}
|
||||
|
||||
void rt_audio_tx_complete(struct rt_audio_device *audio)
|
||||
{
|
||||
/* try to send next frame */
|
||||
_audio_send_replay_frame(audio);
|
||||
}
|
||||
|
||||
void rt_audio_rx_done(struct rt_audio_device *audio, rt_uint8_t *pbuf, rt_size_t len)
|
||||
{
|
||||
/* save data to record pipe */
|
||||
rt_device_write(RT_DEVICE(&audio->record->pipe), 0, pbuf, len);
|
||||
|
||||
/* invoke callback */
|
||||
if (audio->parent.rx_indicate != RT_NULL)
|
||||
audio->parent.rx_indicate(&audio->parent, len);
|
||||
}
|
||||
@@ -0,0 +1,300 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2012-09-30 Bernard first version.
|
||||
*/
|
||||
|
||||
#include <rthw.h>
|
||||
#include <rtdevice.h>
|
||||
#include "audio_pipe.h"
|
||||
|
||||
static void _rt_pipe_resume_writer(struct rt_audio_pipe *pipe)
|
||||
{
|
||||
if (!rt_list_isempty(&pipe->suspended_write_list))
|
||||
{
|
||||
rt_thread_t thread;
|
||||
|
||||
RT_ASSERT(pipe->flag & RT_PIPE_FLAG_BLOCK_WR);
|
||||
|
||||
/* get suspended thread */
|
||||
thread = rt_list_entry(pipe->suspended_write_list.next,
|
||||
struct rt_thread,
|
||||
tlist);
|
||||
|
||||
/* resume the write thread */
|
||||
rt_thread_resume(thread);
|
||||
|
||||
rt_schedule();
|
||||
}
|
||||
}
|
||||
|
||||
static rt_size_t rt_pipe_read(rt_device_t dev,
|
||||
rt_off_t pos,
|
||||
void *buffer,
|
||||
rt_size_t size)
|
||||
{
|
||||
rt_uint32_t level;
|
||||
rt_thread_t thread;
|
||||
struct rt_audio_pipe *pipe;
|
||||
rt_size_t read_nbytes;
|
||||
|
||||
pipe = (struct rt_audio_pipe *)dev;
|
||||
RT_ASSERT(pipe != RT_NULL);
|
||||
|
||||
if (!(pipe->flag & RT_PIPE_FLAG_BLOCK_RD))
|
||||
{
|
||||
level = rt_hw_interrupt_disable();
|
||||
read_nbytes = rt_ringbuffer_get(&(pipe->ringbuffer), (rt_uint8_t *)buffer, size);
|
||||
|
||||
/* if the ringbuffer is empty, there won't be any writer waiting */
|
||||
if (read_nbytes)
|
||||
_rt_pipe_resume_writer(pipe);
|
||||
|
||||
rt_hw_interrupt_enable(level);
|
||||
|
||||
return read_nbytes;
|
||||
}
|
||||
|
||||
thread = rt_thread_self();
|
||||
|
||||
/* current context checking */
|
||||
RT_DEBUG_NOT_IN_INTERRUPT;
|
||||
|
||||
do
|
||||
{
|
||||
level = rt_hw_interrupt_disable();
|
||||
read_nbytes = rt_ringbuffer_get(&(pipe->ringbuffer), (rt_uint8_t *)buffer, size);
|
||||
if (read_nbytes == 0)
|
||||
{
|
||||
rt_thread_suspend(thread);
|
||||
/* waiting on suspended read list */
|
||||
rt_list_insert_before(&(pipe->suspended_read_list),
|
||||
&(thread->tlist));
|
||||
rt_hw_interrupt_enable(level);
|
||||
|
||||
rt_schedule();
|
||||
}
|
||||
else
|
||||
{
|
||||
_rt_pipe_resume_writer(pipe);
|
||||
rt_hw_interrupt_enable(level);
|
||||
break;
|
||||
}
|
||||
}
|
||||
while (read_nbytes == 0);
|
||||
|
||||
return read_nbytes;
|
||||
}
|
||||
|
||||
static void _rt_pipe_resume_reader(struct rt_audio_pipe *pipe)
|
||||
{
|
||||
if (pipe->parent.rx_indicate)
|
||||
pipe->parent.rx_indicate(&pipe->parent,
|
||||
rt_ringbuffer_data_len(&pipe->ringbuffer));
|
||||
|
||||
if (!rt_list_isempty(&pipe->suspended_read_list))
|
||||
{
|
||||
rt_thread_t thread;
|
||||
|
||||
RT_ASSERT(pipe->flag & RT_PIPE_FLAG_BLOCK_RD);
|
||||
|
||||
/* get suspended thread */
|
||||
thread = rt_list_entry(pipe->suspended_read_list.next,
|
||||
struct rt_thread,
|
||||
tlist);
|
||||
|
||||
/* resume the read thread */
|
||||
rt_thread_resume(thread);
|
||||
|
||||
rt_schedule();
|
||||
}
|
||||
}
|
||||
|
||||
static rt_size_t rt_pipe_write(rt_device_t dev,
|
||||
rt_off_t pos,
|
||||
const void *buffer,
|
||||
rt_size_t size)
|
||||
{
|
||||
rt_uint32_t level;
|
||||
rt_thread_t thread;
|
||||
struct rt_audio_pipe *pipe;
|
||||
rt_size_t write_nbytes;
|
||||
|
||||
pipe = (struct rt_audio_pipe *)dev;
|
||||
RT_ASSERT(pipe != RT_NULL);
|
||||
|
||||
if ((pipe->flag & RT_PIPE_FLAG_FORCE_WR) ||
|
||||
!(pipe->flag & RT_PIPE_FLAG_BLOCK_WR))
|
||||
{
|
||||
level = rt_hw_interrupt_disable();
|
||||
|
||||
if (pipe->flag & RT_PIPE_FLAG_FORCE_WR)
|
||||
write_nbytes = rt_ringbuffer_put_force(&(pipe->ringbuffer),
|
||||
(const rt_uint8_t *)buffer, size);
|
||||
else
|
||||
write_nbytes = rt_ringbuffer_put(&(pipe->ringbuffer),
|
||||
(const rt_uint8_t *)buffer, size);
|
||||
|
||||
_rt_pipe_resume_reader(pipe);
|
||||
|
||||
rt_hw_interrupt_enable(level);
|
||||
|
||||
return write_nbytes;
|
||||
}
|
||||
|
||||
thread = rt_thread_self();
|
||||
|
||||
/* current context checking */
|
||||
RT_DEBUG_NOT_IN_INTERRUPT;
|
||||
|
||||
do
|
||||
{
|
||||
level = rt_hw_interrupt_disable();
|
||||
write_nbytes = rt_ringbuffer_put(&(pipe->ringbuffer), (const rt_uint8_t *)buffer, size);
|
||||
if (write_nbytes == 0)
|
||||
{
|
||||
/* pipe full, waiting on suspended write list */
|
||||
rt_thread_suspend(thread);
|
||||
/* waiting on suspended read list */
|
||||
rt_list_insert_before(&(pipe->suspended_write_list),
|
||||
&(thread->tlist));
|
||||
rt_hw_interrupt_enable(level);
|
||||
|
||||
rt_schedule();
|
||||
}
|
||||
else
|
||||
{
|
||||
_rt_pipe_resume_reader(pipe);
|
||||
rt_hw_interrupt_enable(level);
|
||||
break;
|
||||
}
|
||||
}
|
||||
while (write_nbytes == 0);
|
||||
|
||||
return write_nbytes;
|
||||
}
|
||||
|
||||
static rt_err_t rt_pipe_control(rt_device_t dev, int cmd, void *args)
|
||||
{
|
||||
struct rt_audio_pipe *pipe;
|
||||
|
||||
pipe = (struct rt_audio_pipe *)dev;
|
||||
|
||||
if (cmd == PIPE_CTRL_GET_SPACE && args)
|
||||
*(rt_size_t *)args = rt_ringbuffer_space_len(&pipe->ringbuffer);
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
#ifdef RT_USING_DEVICE_OPS
|
||||
const static struct rt_device_ops audio_pipe_ops =
|
||||
{
|
||||
RT_NULL,
|
||||
RT_NULL,
|
||||
RT_NULL,
|
||||
rt_pipe_read,
|
||||
rt_pipe_write,
|
||||
rt_pipe_control
|
||||
};
|
||||
#endif
|
||||
|
||||
/**
|
||||
* This function will initialize a pipe device and put it under control of
|
||||
* resource management.
|
||||
*
|
||||
* @param pipe the pipe device
|
||||
* @param name the name of pipe device
|
||||
* @param flag the attribute of the pipe device
|
||||
* @param buf the buffer of pipe device
|
||||
* @param size the size of pipe device buffer
|
||||
*
|
||||
* @return the operation status, RT_EOK on successful
|
||||
*/
|
||||
rt_err_t rt_audio_pipe_init(struct rt_audio_pipe *pipe,
|
||||
const char *name,
|
||||
rt_int32_t flag,
|
||||
rt_uint8_t *buf,
|
||||
rt_size_t size)
|
||||
{
|
||||
RT_ASSERT(pipe);
|
||||
RT_ASSERT(buf);
|
||||
|
||||
/* initialize suspended list */
|
||||
rt_list_init(&pipe->suspended_read_list);
|
||||
rt_list_init(&pipe->suspended_write_list);
|
||||
|
||||
/* initialize ring buffer */
|
||||
rt_ringbuffer_init(&pipe->ringbuffer, buf, size);
|
||||
|
||||
pipe->flag = flag;
|
||||
|
||||
/* create pipe */
|
||||
pipe->parent.type = RT_Device_Class_Pipe;
|
||||
#ifdef RT_USING_DEVICE_OPS
|
||||
pipe->parent.ops = &audio_pipe_ops;
|
||||
#else
|
||||
pipe->parent.init = RT_NULL;
|
||||
pipe->parent.open = RT_NULL;
|
||||
pipe->parent.close = RT_NULL;
|
||||
pipe->parent.read = rt_pipe_read;
|
||||
pipe->parent.write = rt_pipe_write;
|
||||
pipe->parent.control = rt_pipe_control;
|
||||
#endif
|
||||
|
||||
return rt_device_register(&(pipe->parent), name, RT_DEVICE_FLAG_RDWR);
|
||||
}
|
||||
|
||||
/**
|
||||
* This function will detach a pipe device from resource management
|
||||
*
|
||||
* @param pipe the pipe device
|
||||
*
|
||||
* @return the operation status, RT_EOK on successful
|
||||
*/
|
||||
rt_err_t rt_audio_pipe_detach(struct rt_audio_pipe *pipe)
|
||||
{
|
||||
return rt_device_unregister(&pipe->parent);
|
||||
}
|
||||
|
||||
#ifdef RT_USING_HEAP
|
||||
rt_err_t rt_audio_pipe_create(const char *name, rt_int32_t flag, rt_size_t size)
|
||||
{
|
||||
rt_uint8_t *rb_memptr = RT_NULL;
|
||||
struct rt_audio_pipe *pipe = RT_NULL;
|
||||
|
||||
/* get aligned size */
|
||||
size = RT_ALIGN(size, RT_ALIGN_SIZE);
|
||||
pipe = (struct rt_audio_pipe *)rt_calloc(1, sizeof(struct rt_audio_pipe));
|
||||
if (pipe == RT_NULL)
|
||||
return -RT_ENOMEM;
|
||||
|
||||
/* create ring buffer of pipe */
|
||||
rb_memptr = (rt_uint8_t *)rt_malloc(size);
|
||||
if (rb_memptr == RT_NULL)
|
||||
{
|
||||
rt_free(pipe);
|
||||
return -RT_ENOMEM;
|
||||
}
|
||||
|
||||
return rt_audio_pipe_init(pipe, name, flag, rb_memptr, size);
|
||||
}
|
||||
|
||||
void rt_audio_pipe_destroy(struct rt_audio_pipe *pipe)
|
||||
{
|
||||
if (pipe == RT_NULL)
|
||||
return;
|
||||
|
||||
/* un-register pipe device */
|
||||
rt_audio_pipe_detach(pipe);
|
||||
|
||||
/* release memory */
|
||||
rt_free(pipe->ringbuffer.buffer_ptr);
|
||||
rt_free(pipe);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
#endif /* RT_USING_HEAP */
|
||||
@@ -0,0 +1,75 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
*/
|
||||
#ifndef __AUDIO_PIPE_H__
|
||||
#define __AUDIO_PIPE_H__
|
||||
|
||||
/**
|
||||
* Pipe Device
|
||||
*/
|
||||
#include <rtdevice.h>
|
||||
|
||||
#ifndef RT_PIPE_BUFSZ
|
||||
#define PIPE_BUFSZ 512
|
||||
#else
|
||||
#define PIPE_BUFSZ RT_PIPE_BUFSZ
|
||||
#endif
|
||||
|
||||
/* portal device */
|
||||
struct rt_audio_portal_device
|
||||
{
|
||||
struct rt_device parent;
|
||||
struct rt_device *write_dev;
|
||||
struct rt_device *read_dev;
|
||||
};
|
||||
|
||||
enum rt_audio_pipe_flag
|
||||
{
|
||||
/* both read and write won't block */
|
||||
RT_PIPE_FLAG_NONBLOCK_RDWR = 0x00,
|
||||
/* read would block */
|
||||
RT_PIPE_FLAG_BLOCK_RD = 0x01,
|
||||
/* write would block */
|
||||
RT_PIPE_FLAG_BLOCK_WR = 0x02,
|
||||
/* write to this pipe will discard some data when the pipe is full.
|
||||
* When this flag is set, RT_PIPE_FLAG_BLOCK_WR will be ignored since write
|
||||
* operation will always be success. */
|
||||
RT_PIPE_FLAG_FORCE_WR = 0x04,
|
||||
};
|
||||
|
||||
struct rt_audio_pipe
|
||||
{
|
||||
struct rt_device parent;
|
||||
|
||||
/* ring buffer in pipe device */
|
||||
struct rt_ringbuffer ringbuffer;
|
||||
|
||||
rt_int32_t flag;
|
||||
|
||||
/* suspended list */
|
||||
rt_list_t suspended_read_list;
|
||||
rt_list_t suspended_write_list;
|
||||
|
||||
struct rt_audio_portal_device *write_portal;
|
||||
struct rt_audio_portal_device *read_portal;
|
||||
};
|
||||
|
||||
#define PIPE_CTRL_GET_SPACE 0x14 /**< get the remaining size of a pipe device */
|
||||
|
||||
rt_err_t rt_audio_pipe_init(struct rt_audio_pipe *pipe,
|
||||
const char *name,
|
||||
rt_int32_t flag,
|
||||
rt_uint8_t *buf,
|
||||
rt_size_t size);
|
||||
rt_err_t rt_audio_pipe_detach(struct rt_audio_pipe *pipe);
|
||||
#ifdef RT_USING_HEAP
|
||||
rt_err_t rt_audio_pipe_create(const char *name, rt_int32_t flag, rt_size_t size);
|
||||
void rt_audio_pipe_destroy(struct rt_audio_pipe *pipe);
|
||||
#endif /* RT_USING_HEAP */
|
||||
|
||||
#endif /* __AUDIO_PIPE_H__ */
|
||||
@@ -0,0 +1,8 @@
|
||||
from building import *
|
||||
|
||||
cwd = GetCurrentDir()
|
||||
src = Glob('*.c')
|
||||
CPPPATH = [cwd + '/../include']
|
||||
group = DefineGroup('DeviceDrivers', src, depend = ['RT_USING_CAN'], CPPPATH = CPPPATH)
|
||||
|
||||
Return('group')
|
||||
@@ -0,0 +1,970 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2015-05-14 aubrcool@qq.com first version
|
||||
* 2015-07-06 Bernard code cleanup and remove RT_CAN_USING_LED;
|
||||
*/
|
||||
|
||||
#include <rthw.h>
|
||||
#include <rtthread.h>
|
||||
#include <rtdevice.h>
|
||||
|
||||
#define CAN_LOCK(can) rt_mutex_take(&(can->lock), RT_WAITING_FOREVER)
|
||||
#define CAN_UNLOCK(can) rt_mutex_release(&(can->lock))
|
||||
|
||||
static rt_err_t rt_can_init(struct rt_device *dev)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
struct rt_can_device *can;
|
||||
|
||||
RT_ASSERT(dev != RT_NULL);
|
||||
can = (struct rt_can_device *)dev;
|
||||
|
||||
/* initialize rx/tx */
|
||||
can->can_rx = RT_NULL;
|
||||
can->can_tx = RT_NULL;
|
||||
#ifdef RT_CAN_USING_HDR
|
||||
can->hdr = RT_NULL;
|
||||
#endif
|
||||
|
||||
/* apply configuration */
|
||||
if (can->ops->configure)
|
||||
result = can->ops->configure(can, &can->config);
|
||||
else
|
||||
result = -RT_ENOSYS;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/*
|
||||
* can interrupt routines
|
||||
*/
|
||||
rt_inline int _can_int_rx(struct rt_can_device *can, struct rt_can_msg *data, int msgs)
|
||||
{
|
||||
int size;
|
||||
struct rt_can_rx_fifo *rx_fifo;
|
||||
RT_ASSERT(can != RT_NULL);
|
||||
size = msgs;
|
||||
|
||||
rx_fifo = (struct rt_can_rx_fifo *) can->can_rx;
|
||||
RT_ASSERT(rx_fifo != RT_NULL);
|
||||
|
||||
/* read from software FIFO */
|
||||
while (msgs)
|
||||
{
|
||||
rt_base_t level;
|
||||
#ifdef RT_CAN_USING_HDR
|
||||
rt_int8_t hdr;
|
||||
#endif /*RT_CAN_USING_HDR*/
|
||||
struct rt_can_msg_list *listmsg = RT_NULL;
|
||||
|
||||
/* disable interrupt */
|
||||
level = rt_hw_interrupt_disable();
|
||||
#ifdef RT_CAN_USING_HDR
|
||||
hdr = data->hdr;
|
||||
|
||||
if (hdr >= 0 && can->hdr && hdr < can->config.maxhdr && !rt_list_isempty(&can->hdr[hdr].list))
|
||||
{
|
||||
listmsg = rt_list_entry(can->hdr[hdr].list.next, struct rt_can_msg_list, hdrlist);
|
||||
rt_list_remove(&listmsg->list);
|
||||
rt_list_remove(&listmsg->hdrlist);
|
||||
if (can->hdr[hdr].msgs)
|
||||
{
|
||||
can->hdr[hdr].msgs--;
|
||||
}
|
||||
listmsg->owner = RT_NULL;
|
||||
}
|
||||
else if (hdr == -1)
|
||||
#endif /*RT_CAN_USING_HDR*/
|
||||
{
|
||||
if (!rt_list_isempty(&rx_fifo->uselist))
|
||||
{
|
||||
listmsg = rt_list_entry(rx_fifo->uselist.next, struct rt_can_msg_list, list);
|
||||
rt_list_remove(&listmsg->list);
|
||||
#ifdef RT_CAN_USING_HDR
|
||||
rt_list_remove(&listmsg->hdrlist);
|
||||
if (listmsg->owner != RT_NULL && listmsg->owner->msgs)
|
||||
{
|
||||
listmsg->owner->msgs--;
|
||||
}
|
||||
listmsg->owner = RT_NULL;
|
||||
#endif /*RT_CAN_USING_HDR*/
|
||||
}
|
||||
else
|
||||
{
|
||||
/* no data, enable interrupt and break out */
|
||||
rt_hw_interrupt_enable(level);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* enable interrupt */
|
||||
rt_hw_interrupt_enable(level);
|
||||
if (listmsg != RT_NULL)
|
||||
{
|
||||
rt_memcpy(data, &listmsg->data, sizeof(struct rt_can_msg));
|
||||
|
||||
level = rt_hw_interrupt_disable();
|
||||
rt_list_insert_before(&rx_fifo->freelist, &listmsg->list);
|
||||
rx_fifo->freenumbers++;
|
||||
RT_ASSERT(rx_fifo->freenumbers <= can->config.msgboxsz);
|
||||
rt_hw_interrupt_enable(level);
|
||||
|
||||
listmsg = RT_NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
break;
|
||||
}
|
||||
data ++;
|
||||
msgs -= sizeof(struct rt_can_msg);
|
||||
}
|
||||
|
||||
return (size - msgs);
|
||||
}
|
||||
|
||||
rt_inline int _can_int_tx(struct rt_can_device *can, const struct rt_can_msg *data, int msgs)
|
||||
{
|
||||
int size;
|
||||
struct rt_can_tx_fifo *tx_fifo;
|
||||
|
||||
RT_ASSERT(can != RT_NULL);
|
||||
|
||||
size = msgs;
|
||||
tx_fifo = (struct rt_can_tx_fifo *) can->can_tx;
|
||||
RT_ASSERT(tx_fifo != RT_NULL);
|
||||
|
||||
while (msgs)
|
||||
{
|
||||
rt_base_t level;
|
||||
rt_uint32_t no;
|
||||
rt_uint32_t result;
|
||||
struct rt_can_sndbxinx_list *tx_tosnd = RT_NULL;
|
||||
|
||||
rt_sem_take(&(tx_fifo->sem), RT_WAITING_FOREVER);
|
||||
level = rt_hw_interrupt_disable();
|
||||
tx_tosnd = rt_list_entry(tx_fifo->freelist.next, struct rt_can_sndbxinx_list, list);
|
||||
RT_ASSERT(tx_tosnd != RT_NULL);
|
||||
rt_list_remove(&tx_tosnd->list);
|
||||
rt_hw_interrupt_enable(level);
|
||||
|
||||
no = ((rt_uint32_t)tx_tosnd - (rt_uint32_t)tx_fifo->buffer) / sizeof(struct rt_can_sndbxinx_list);
|
||||
tx_tosnd->result = RT_CAN_SND_RESULT_WAIT;
|
||||
if (can->ops->sendmsg(can, data, no) != RT_EOK)
|
||||
{
|
||||
/* send failed. */
|
||||
level = rt_hw_interrupt_disable();
|
||||
rt_list_insert_after(&tx_fifo->freelist, &tx_tosnd->list);
|
||||
rt_hw_interrupt_enable(level);
|
||||
rt_sem_release(&(tx_fifo->sem));
|
||||
continue;
|
||||
}
|
||||
|
||||
can->status.sndchange = 1;
|
||||
rt_completion_wait(&(tx_tosnd->completion), RT_WAITING_FOREVER);
|
||||
|
||||
level = rt_hw_interrupt_disable();
|
||||
result = tx_tosnd->result;
|
||||
if (!rt_list_isempty(&tx_tosnd->list))
|
||||
{
|
||||
rt_list_remove(&tx_tosnd->list);
|
||||
}
|
||||
rt_list_insert_before(&tx_fifo->freelist, &tx_tosnd->list);
|
||||
rt_hw_interrupt_enable(level);
|
||||
rt_sem_release(&(tx_fifo->sem));
|
||||
|
||||
if (result == RT_CAN_SND_RESULT_OK)
|
||||
{
|
||||
level = rt_hw_interrupt_disable();
|
||||
can->status.sndpkg++;
|
||||
rt_hw_interrupt_enable(level);
|
||||
|
||||
data ++;
|
||||
msgs -= sizeof(struct rt_can_msg);
|
||||
if (!msgs) break;
|
||||
}
|
||||
else
|
||||
{
|
||||
level = rt_hw_interrupt_disable();
|
||||
can->status.dropedsndpkg++;
|
||||
rt_hw_interrupt_enable(level);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return (size - msgs);
|
||||
}
|
||||
|
||||
rt_inline int _can_int_tx_priv(struct rt_can_device *can, const struct rt_can_msg *data, int msgs)
|
||||
{
|
||||
int size;
|
||||
rt_base_t level;
|
||||
rt_uint32_t no, result;
|
||||
struct rt_can_tx_fifo *tx_fifo;
|
||||
|
||||
RT_ASSERT(can != RT_NULL);
|
||||
|
||||
size = msgs;
|
||||
tx_fifo = (struct rt_can_tx_fifo *) can->can_tx;
|
||||
RT_ASSERT(tx_fifo != RT_NULL);
|
||||
|
||||
while (msgs)
|
||||
{
|
||||
no = data->priv;
|
||||
if (no >= can->config.sndboxnumber)
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
level = rt_hw_interrupt_disable();
|
||||
if ((tx_fifo->buffer[no].result != RT_CAN_SND_RESULT_OK))
|
||||
{
|
||||
rt_hw_interrupt_enable(level);
|
||||
|
||||
rt_completion_wait(&(tx_fifo->buffer[no].completion), RT_WAITING_FOREVER);
|
||||
continue;
|
||||
}
|
||||
tx_fifo->buffer[no].result = RT_CAN_SND_RESULT_WAIT;
|
||||
rt_hw_interrupt_enable(level);
|
||||
|
||||
if (can->ops->sendmsg(can, data, no) != RT_EOK)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
can->status.sndchange = 1;
|
||||
rt_completion_wait(&(tx_fifo->buffer[no].completion), RT_WAITING_FOREVER);
|
||||
|
||||
result = tx_fifo->buffer[no].result;
|
||||
if (result == RT_CAN_SND_RESULT_OK)
|
||||
{
|
||||
level = rt_hw_interrupt_disable();
|
||||
can->status.sndpkg++;
|
||||
rt_hw_interrupt_enable(level);
|
||||
data ++;
|
||||
msgs -= sizeof(struct rt_can_msg);
|
||||
if (!msgs) break;
|
||||
}
|
||||
else
|
||||
{
|
||||
level = rt_hw_interrupt_disable();
|
||||
can->status.dropedsndpkg++;
|
||||
rt_hw_interrupt_enable(level);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return (size - msgs);
|
||||
}
|
||||
|
||||
static rt_err_t rt_can_open(struct rt_device *dev, rt_uint16_t oflag)
|
||||
{
|
||||
struct rt_can_device *can;
|
||||
char tmpname[16];
|
||||
RT_ASSERT(dev != RT_NULL);
|
||||
can = (struct rt_can_device *)dev;
|
||||
|
||||
CAN_LOCK(can);
|
||||
|
||||
/* get open flags */
|
||||
dev->open_flag = oflag & 0xff;
|
||||
if (can->can_rx == RT_NULL)
|
||||
{
|
||||
if (oflag & RT_DEVICE_FLAG_INT_RX)
|
||||
{
|
||||
int i = 0;
|
||||
struct rt_can_rx_fifo *rx_fifo;
|
||||
|
||||
rx_fifo = (struct rt_can_rx_fifo *) rt_malloc(sizeof(struct rt_can_rx_fifo) +
|
||||
can->config.msgboxsz * sizeof(struct rt_can_msg_list));
|
||||
RT_ASSERT(rx_fifo != RT_NULL);
|
||||
|
||||
rx_fifo->buffer = (struct rt_can_msg_list *)(rx_fifo + 1);
|
||||
rt_memset(rx_fifo->buffer, 0, can->config.msgboxsz * sizeof(struct rt_can_msg_list));
|
||||
rt_list_init(&rx_fifo->freelist);
|
||||
rt_list_init(&rx_fifo->uselist);
|
||||
rx_fifo->freenumbers = can->config.msgboxsz;
|
||||
for (i = 0; i < can->config.msgboxsz; i++)
|
||||
{
|
||||
rt_list_insert_before(&rx_fifo->freelist, &rx_fifo->buffer[i].list);
|
||||
#ifdef RT_CAN_USING_HDR
|
||||
rt_list_init(&rx_fifo->buffer[i].hdrlist);
|
||||
rx_fifo->buffer[i].owner = RT_NULL;
|
||||
#endif
|
||||
}
|
||||
can->can_rx = rx_fifo;
|
||||
|
||||
dev->open_flag |= RT_DEVICE_FLAG_INT_RX;
|
||||
/* open can rx interrupt */
|
||||
can->ops->control(can, RT_DEVICE_CTRL_SET_INT, (void *)RT_DEVICE_FLAG_INT_RX);
|
||||
}
|
||||
}
|
||||
|
||||
if (can->can_tx == RT_NULL)
|
||||
{
|
||||
if (oflag & RT_DEVICE_FLAG_INT_TX)
|
||||
{
|
||||
int i = 0;
|
||||
struct rt_can_tx_fifo *tx_fifo;
|
||||
|
||||
tx_fifo = (struct rt_can_tx_fifo *) rt_malloc(sizeof(struct rt_can_tx_fifo) +
|
||||
can->config.sndboxnumber * sizeof(struct rt_can_sndbxinx_list));
|
||||
RT_ASSERT(tx_fifo != RT_NULL);
|
||||
|
||||
tx_fifo->buffer = (struct rt_can_sndbxinx_list *)(tx_fifo + 1);
|
||||
rt_memset(tx_fifo->buffer, 0,
|
||||
can->config.sndboxnumber * sizeof(struct rt_can_sndbxinx_list));
|
||||
rt_list_init(&tx_fifo->freelist);
|
||||
for (i = 0; i < can->config.sndboxnumber; i++)
|
||||
{
|
||||
rt_list_insert_before(&tx_fifo->freelist, &tx_fifo->buffer[i].list);
|
||||
rt_completion_init(&(tx_fifo->buffer[i].completion));
|
||||
tx_fifo->buffer[i].result = RT_CAN_SND_RESULT_OK;
|
||||
}
|
||||
|
||||
rt_sprintf(tmpname, "%stl", dev->parent.name);
|
||||
rt_sem_init(&(tx_fifo->sem), tmpname, can->config.sndboxnumber, RT_IPC_FLAG_FIFO);
|
||||
can->can_tx = tx_fifo;
|
||||
|
||||
dev->open_flag |= RT_DEVICE_FLAG_INT_TX;
|
||||
/* open can tx interrupt */
|
||||
can->ops->control(can, RT_DEVICE_CTRL_SET_INT, (void *)RT_DEVICE_FLAG_INT_TX);
|
||||
}
|
||||
}
|
||||
|
||||
can->ops->control(can, RT_DEVICE_CTRL_SET_INT, (void *)RT_DEVICE_CAN_INT_ERR);
|
||||
|
||||
#ifdef RT_CAN_USING_HDR
|
||||
if (can->hdr == RT_NULL)
|
||||
{
|
||||
int i = 0;
|
||||
struct rt_can_hdr *phdr;
|
||||
|
||||
phdr = (struct rt_can_hdr *) rt_malloc(can->config.maxhdr * sizeof(struct rt_can_hdr));
|
||||
RT_ASSERT(phdr != RT_NULL);
|
||||
rt_memset(phdr, 0, can->config.maxhdr * sizeof(struct rt_can_hdr));
|
||||
for (i = 0; i < can->config.maxhdr; i++)
|
||||
{
|
||||
rt_list_init(&phdr[i].list);
|
||||
}
|
||||
|
||||
can->hdr = phdr;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (!can->timerinitflag)
|
||||
{
|
||||
can->timerinitflag = 1;
|
||||
|
||||
rt_timer_start(&can->timer);
|
||||
}
|
||||
|
||||
CAN_UNLOCK(can);
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static rt_err_t rt_can_close(struct rt_device *dev)
|
||||
{
|
||||
struct rt_can_device *can;
|
||||
|
||||
RT_ASSERT(dev != RT_NULL);
|
||||
can = (struct rt_can_device *)dev;
|
||||
|
||||
CAN_LOCK(can);
|
||||
|
||||
/* this device has more reference count */
|
||||
if (dev->ref_count > 1)
|
||||
{
|
||||
CAN_UNLOCK(can);
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
if (can->timerinitflag)
|
||||
{
|
||||
can->timerinitflag = 0;
|
||||
|
||||
rt_timer_stop(&can->timer);
|
||||
}
|
||||
|
||||
can->status_indicate.ind = RT_NULL;
|
||||
can->status_indicate.args = RT_NULL;
|
||||
|
||||
#ifdef RT_CAN_USING_HDR
|
||||
if (can->hdr != RT_NULL)
|
||||
{
|
||||
rt_free(can->hdr);
|
||||
can->hdr = RT_NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
if (dev->open_flag & RT_DEVICE_FLAG_INT_RX)
|
||||
{
|
||||
struct rt_can_rx_fifo *rx_fifo;
|
||||
|
||||
rx_fifo = (struct rt_can_rx_fifo *)can->can_rx;
|
||||
RT_ASSERT(rx_fifo != RT_NULL);
|
||||
|
||||
rt_free(rx_fifo);
|
||||
dev->open_flag &= ~RT_DEVICE_FLAG_INT_RX;
|
||||
can->can_rx = RT_NULL;
|
||||
/* clear can rx interrupt */
|
||||
can->ops->control(can, RT_DEVICE_CTRL_CLR_INT, (void *)RT_DEVICE_FLAG_INT_RX);
|
||||
}
|
||||
|
||||
if (dev->open_flag & RT_DEVICE_FLAG_INT_TX)
|
||||
{
|
||||
struct rt_can_tx_fifo *tx_fifo;
|
||||
|
||||
tx_fifo = (struct rt_can_tx_fifo *)can->can_tx;
|
||||
RT_ASSERT(tx_fifo != RT_NULL);
|
||||
|
||||
rt_sem_detach(&(tx_fifo->sem));
|
||||
rt_free(tx_fifo);
|
||||
dev->open_flag &= ~RT_DEVICE_FLAG_INT_TX;
|
||||
can->can_tx = RT_NULL;
|
||||
/* clear can tx interrupt */
|
||||
can->ops->control(can, RT_DEVICE_CTRL_CLR_INT, (void *)RT_DEVICE_FLAG_INT_TX);
|
||||
}
|
||||
|
||||
can->ops->control(can, RT_DEVICE_CTRL_CLR_INT, (void *)RT_DEVICE_CAN_INT_ERR);
|
||||
|
||||
CAN_UNLOCK(can);
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static rt_size_t rt_can_read(struct rt_device *dev,
|
||||
rt_off_t pos,
|
||||
void *buffer,
|
||||
rt_size_t size)
|
||||
{
|
||||
struct rt_can_device *can;
|
||||
|
||||
RT_ASSERT(dev != RT_NULL);
|
||||
if (size == 0) return 0;
|
||||
|
||||
can = (struct rt_can_device *)dev;
|
||||
|
||||
if ((dev->open_flag & RT_DEVICE_FLAG_INT_RX) && (dev->ref_count > 0))
|
||||
{
|
||||
return _can_int_rx(can, buffer, size);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static rt_size_t rt_can_write(struct rt_device *dev,
|
||||
rt_off_t pos,
|
||||
const void *buffer,
|
||||
rt_size_t size)
|
||||
{
|
||||
struct rt_can_device *can;
|
||||
|
||||
RT_ASSERT(dev != RT_NULL);
|
||||
if (size == 0) return 0;
|
||||
|
||||
can = (struct rt_can_device *)dev;
|
||||
|
||||
if ((dev->open_flag & RT_DEVICE_FLAG_INT_TX) && (dev->ref_count > 0))
|
||||
{
|
||||
if (can->config.privmode)
|
||||
{
|
||||
return _can_int_tx_priv(can, buffer, size);
|
||||
}
|
||||
else
|
||||
{
|
||||
return _can_int_tx(can, buffer, size);
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static rt_err_t rt_can_control(struct rt_device *dev,
|
||||
int cmd,
|
||||
void *args)
|
||||
{
|
||||
struct rt_can_device *can;
|
||||
rt_err_t res;
|
||||
|
||||
res = RT_EOK;
|
||||
RT_ASSERT(dev != RT_NULL);
|
||||
can = (struct rt_can_device *)dev;
|
||||
|
||||
switch (cmd)
|
||||
{
|
||||
case RT_DEVICE_CTRL_SUSPEND:
|
||||
/* suspend device */
|
||||
dev->flag |= RT_DEVICE_FLAG_SUSPENDED;
|
||||
break;
|
||||
|
||||
case RT_DEVICE_CTRL_RESUME:
|
||||
/* resume device */
|
||||
dev->flag &= ~RT_DEVICE_FLAG_SUSPENDED;
|
||||
break;
|
||||
|
||||
case RT_DEVICE_CTRL_CONFIG:
|
||||
/* configure device */
|
||||
res = can->ops->configure(can, (struct can_configure *)args);
|
||||
break;
|
||||
|
||||
case RT_CAN_CMD_SET_PRIV:
|
||||
/* configure device */
|
||||
if ((rt_uint32_t)args != can->config.privmode)
|
||||
{
|
||||
int i;
|
||||
rt_base_t level;
|
||||
struct rt_can_tx_fifo *tx_fifo;
|
||||
|
||||
res = can->ops->control(can, cmd, args);
|
||||
if (res != RT_EOK) return res;
|
||||
tx_fifo = (struct rt_can_tx_fifo *) can->can_tx;
|
||||
if (can->config.privmode)
|
||||
{
|
||||
for (i = 0; i < can->config.sndboxnumber; i++)
|
||||
{
|
||||
level = rt_hw_interrupt_disable();
|
||||
if(rt_list_isempty(&tx_fifo->buffer[i].list))
|
||||
{
|
||||
rt_sem_release(&(tx_fifo->sem));
|
||||
}
|
||||
else
|
||||
{
|
||||
rt_list_remove(&tx_fifo->buffer[i].list);
|
||||
}
|
||||
rt_hw_interrupt_enable(level);
|
||||
}
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
for (i = 0; i < can->config.sndboxnumber; i++)
|
||||
{
|
||||
level = rt_hw_interrupt_disable();
|
||||
if (tx_fifo->buffer[i].result == RT_CAN_SND_RESULT_OK)
|
||||
{
|
||||
rt_list_insert_before(&tx_fifo->freelist, &tx_fifo->buffer[i].list);
|
||||
}
|
||||
rt_hw_interrupt_enable(level);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
case RT_CAN_CMD_SET_STATUS_IND:
|
||||
can->status_indicate.ind = ((rt_can_status_ind_type_t)args)->ind;
|
||||
can->status_indicate.args = ((rt_can_status_ind_type_t)args)->args;
|
||||
break;
|
||||
|
||||
#ifdef RT_CAN_USING_HDR
|
||||
case RT_CAN_CMD_SET_FILTER:
|
||||
res = can->ops->control(can, cmd, args);
|
||||
if (res != RT_EOK || can->hdr == RT_NULL)
|
||||
{
|
||||
return res;
|
||||
}
|
||||
|
||||
struct rt_can_filter_config *pfilter;
|
||||
struct rt_can_filter_item *pitem;
|
||||
rt_uint32_t count;
|
||||
rt_base_t level;
|
||||
|
||||
pfilter = (struct rt_can_filter_config *)args;
|
||||
RT_ASSERT(pfilter);
|
||||
count = pfilter->count;
|
||||
pitem = pfilter->items;
|
||||
if (pfilter->actived)
|
||||
{
|
||||
while (count)
|
||||
{
|
||||
if (pitem->hdr >= can->config.maxhdr || pitem->hdr < 0)
|
||||
{
|
||||
count--;
|
||||
pitem++;
|
||||
continue;
|
||||
}
|
||||
|
||||
level = rt_hw_interrupt_disable();
|
||||
if (!can->hdr[pitem->hdr].connected)
|
||||
{
|
||||
rt_hw_interrupt_enable(level);
|
||||
rt_memcpy(&can->hdr[pitem->hdr].filter, pitem,
|
||||
sizeof(struct rt_can_filter_item));
|
||||
level = rt_hw_interrupt_disable();
|
||||
can->hdr[pitem->hdr].connected = 1;
|
||||
can->hdr[pitem->hdr].msgs = 0;
|
||||
rt_list_init(&can->hdr[pitem->hdr].list);
|
||||
}
|
||||
rt_hw_interrupt_enable(level);
|
||||
|
||||
count--;
|
||||
pitem++;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
while (count)
|
||||
{
|
||||
if (pitem->hdr >= can->config.maxhdr || pitem->hdr < 0)
|
||||
{
|
||||
count--;
|
||||
pitem++;
|
||||
continue;
|
||||
}
|
||||
level = rt_hw_interrupt_disable();
|
||||
|
||||
if (can->hdr[pitem->hdr].connected)
|
||||
{
|
||||
can->hdr[pitem->hdr].connected = 0;
|
||||
can->hdr[pitem->hdr].msgs = 0;
|
||||
if (!rt_list_isempty(&can->hdr[pitem->hdr].list))
|
||||
{
|
||||
rt_list_remove(can->hdr[pitem->hdr].list.next);
|
||||
}
|
||||
rt_hw_interrupt_enable(level);
|
||||
rt_memset(&can->hdr[pitem->hdr].filter, 0,
|
||||
sizeof(struct rt_can_filter_item));
|
||||
}
|
||||
else
|
||||
{
|
||||
rt_hw_interrupt_enable(level);
|
||||
}
|
||||
count--;
|
||||
pitem++;
|
||||
}
|
||||
}
|
||||
break;
|
||||
#endif /*RT_CAN_USING_HDR*/
|
||||
#ifdef RT_CAN_USING_BUS_HOOK
|
||||
case RT_CAN_CMD_SET_BUS_HOOK:
|
||||
can->bus_hook = (rt_can_bus_hook) args;
|
||||
break;
|
||||
#endif /*RT_CAN_USING_BUS_HOOK*/
|
||||
default :
|
||||
/* control device */
|
||||
if (can->ops->control != RT_NULL)
|
||||
{
|
||||
res = can->ops->control(can, cmd, args);
|
||||
}
|
||||
else
|
||||
{
|
||||
res = -RT_ENOSYS;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
/*
|
||||
* can timer
|
||||
*/
|
||||
static void cantimeout(void *arg)
|
||||
{
|
||||
rt_can_t can;
|
||||
|
||||
can = (rt_can_t)arg;
|
||||
RT_ASSERT(can);
|
||||
rt_device_control((rt_device_t)can, RT_CAN_CMD_GET_STATUS, (void *)&can->status);
|
||||
|
||||
if (can->status_indicate.ind != RT_NULL)
|
||||
{
|
||||
can->status_indicate.ind(can, can->status_indicate.args);
|
||||
}
|
||||
#ifdef RT_CAN_USING_BUS_HOOK
|
||||
if(can->bus_hook)
|
||||
{
|
||||
can->bus_hook(can);
|
||||
}
|
||||
#endif /*RT_CAN_USING_BUS_HOOK*/
|
||||
if (can->timerinitflag == 1)
|
||||
{
|
||||
can->timerinitflag = 0xFF;
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef RT_USING_DEVICE_OPS
|
||||
const static struct rt_device_ops can_device_ops =
|
||||
{
|
||||
rt_can_init,
|
||||
rt_can_open,
|
||||
rt_can_close,
|
||||
rt_can_read,
|
||||
rt_can_write,
|
||||
rt_can_control
|
||||
};
|
||||
#endif
|
||||
|
||||
/*
|
||||
* can register
|
||||
*/
|
||||
rt_err_t rt_hw_can_register(struct rt_can_device *can,
|
||||
const char *name,
|
||||
const struct rt_can_ops *ops,
|
||||
void *data)
|
||||
{
|
||||
struct rt_device *device;
|
||||
RT_ASSERT(can != RT_NULL);
|
||||
|
||||
device = &(can->parent);
|
||||
|
||||
device->type = RT_Device_Class_CAN;
|
||||
device->rx_indicate = RT_NULL;
|
||||
device->tx_complete = RT_NULL;
|
||||
#ifdef RT_CAN_USING_HDR
|
||||
can->hdr = RT_NULL;
|
||||
#endif
|
||||
can->can_rx = RT_NULL;
|
||||
can->can_tx = RT_NULL;
|
||||
rt_mutex_init(&(can->lock), "can", RT_IPC_FLAG_PRIO);
|
||||
#ifdef RT_CAN_USING_BUS_HOOK
|
||||
can->bus_hook = RT_NULL;
|
||||
#endif /*RT_CAN_USING_BUS_HOOK*/
|
||||
|
||||
#ifdef RT_USING_DEVICE_OPS
|
||||
device->ops = &can_device_ops;
|
||||
#else
|
||||
device->init = rt_can_init;
|
||||
device->open = rt_can_open;
|
||||
device->close = rt_can_close;
|
||||
device->read = rt_can_read;
|
||||
device->write = rt_can_write;
|
||||
device->control = rt_can_control;
|
||||
#endif
|
||||
can->ops = ops;
|
||||
|
||||
can->status_indicate.ind = RT_NULL;
|
||||
can->status_indicate.args = RT_NULL;
|
||||
rt_memset(&can->status, 0, sizeof(can->status));
|
||||
|
||||
device->user_data = data;
|
||||
|
||||
can->timerinitflag = 0;
|
||||
rt_timer_init(&can->timer,
|
||||
name,
|
||||
cantimeout,
|
||||
(void *)can,
|
||||
can->config.ticks,
|
||||
RT_TIMER_FLAG_PERIODIC);
|
||||
/* register a character device */
|
||||
return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR);
|
||||
}
|
||||
|
||||
/* ISR for can interrupt */
|
||||
void rt_hw_can_isr(struct rt_can_device *can, int event)
|
||||
{
|
||||
switch (event & 0xff)
|
||||
{
|
||||
case RT_CAN_EVENT_RXOF_IND:
|
||||
{
|
||||
rt_base_t level;
|
||||
level = rt_hw_interrupt_disable();
|
||||
can->status.dropedrcvpkg++;
|
||||
rt_hw_interrupt_enable(level);
|
||||
}
|
||||
case RT_CAN_EVENT_RX_IND:
|
||||
{
|
||||
struct rt_can_msg tmpmsg;
|
||||
struct rt_can_rx_fifo *rx_fifo;
|
||||
struct rt_can_msg_list *listmsg = RT_NULL;
|
||||
#ifdef RT_CAN_USING_HDR
|
||||
rt_int8_t hdr;
|
||||
#endif
|
||||
int ch = -1;
|
||||
rt_base_t level;
|
||||
rt_uint32_t no;
|
||||
|
||||
rx_fifo = (struct rt_can_rx_fifo *)can->can_rx;
|
||||
RT_ASSERT(rx_fifo != RT_NULL);
|
||||
/* interrupt mode receive */
|
||||
RT_ASSERT(can->parent.open_flag & RT_DEVICE_FLAG_INT_RX);
|
||||
|
||||
no = event >> 8;
|
||||
ch = can->ops->recvmsg(can, &tmpmsg, no);
|
||||
if (ch == -1) break;
|
||||
|
||||
/* disable interrupt */
|
||||
level = rt_hw_interrupt_disable();
|
||||
can->status.rcvpkg++;
|
||||
can->status.rcvchange = 1;
|
||||
if (!rt_list_isempty(&rx_fifo->freelist))
|
||||
{
|
||||
listmsg = rt_list_entry(rx_fifo->freelist.next, struct rt_can_msg_list, list);
|
||||
rt_list_remove(&listmsg->list);
|
||||
#ifdef RT_CAN_USING_HDR
|
||||
rt_list_remove(&listmsg->hdrlist);
|
||||
if (listmsg->owner != RT_NULL && listmsg->owner->msgs)
|
||||
{
|
||||
listmsg->owner->msgs--;
|
||||
}
|
||||
listmsg->owner = RT_NULL;
|
||||
#endif /*RT_CAN_USING_HDR*/
|
||||
RT_ASSERT(rx_fifo->freenumbers > 0);
|
||||
rx_fifo->freenumbers--;
|
||||
}
|
||||
else if (!rt_list_isempty(&rx_fifo->uselist))
|
||||
{
|
||||
listmsg = rt_list_entry(rx_fifo->uselist.next, struct rt_can_msg_list, list);
|
||||
can->status.dropedrcvpkg++;
|
||||
rt_list_remove(&listmsg->list);
|
||||
#ifdef RT_CAN_USING_HDR
|
||||
rt_list_remove(&listmsg->hdrlist);
|
||||
if (listmsg->owner != RT_NULL && listmsg->owner->msgs)
|
||||
{
|
||||
listmsg->owner->msgs--;
|
||||
}
|
||||
listmsg->owner = RT_NULL;
|
||||
#endif
|
||||
}
|
||||
/* enable interrupt */
|
||||
rt_hw_interrupt_enable(level);
|
||||
|
||||
if (listmsg != RT_NULL)
|
||||
{
|
||||
rt_memcpy(&listmsg->data, &tmpmsg, sizeof(struct rt_can_msg));
|
||||
level = rt_hw_interrupt_disable();
|
||||
rt_list_insert_before(&rx_fifo->uselist, &listmsg->list);
|
||||
#ifdef RT_CAN_USING_HDR
|
||||
hdr = tmpmsg.hdr;
|
||||
if (can->hdr != RT_NULL)
|
||||
{
|
||||
RT_ASSERT(hdr < can->config.maxhdr && hdr >= 0);
|
||||
if (can->hdr[hdr].connected)
|
||||
{
|
||||
rt_list_insert_before(&can->hdr[hdr].list, &listmsg->hdrlist);
|
||||
listmsg->owner = &can->hdr[hdr];
|
||||
can->hdr[hdr].msgs++;
|
||||
}
|
||||
|
||||
}
|
||||
#endif
|
||||
rt_hw_interrupt_enable(level);
|
||||
}
|
||||
|
||||
/* invoke callback */
|
||||
#ifdef RT_CAN_USING_HDR
|
||||
if (can->hdr != RT_NULL && can->hdr[hdr].connected && can->hdr[hdr].filter.ind)
|
||||
{
|
||||
rt_size_t rx_length;
|
||||
RT_ASSERT(hdr < can->config.maxhdr && hdr >= 0);
|
||||
|
||||
level = rt_hw_interrupt_disable();
|
||||
rx_length = can->hdr[hdr].msgs * sizeof(struct rt_can_msg);
|
||||
rt_hw_interrupt_enable(level);
|
||||
if (rx_length)
|
||||
{
|
||||
can->hdr[hdr].filter.ind(&can->parent, can->hdr[hdr].filter.args, hdr, rx_length);
|
||||
}
|
||||
}
|
||||
else
|
||||
#endif
|
||||
{
|
||||
if (can->parent.rx_indicate != RT_NULL)
|
||||
{
|
||||
rt_size_t rx_length;
|
||||
|
||||
level = rt_hw_interrupt_disable();
|
||||
/* get rx length */
|
||||
rx_length = rt_list_len(&rx_fifo->uselist)* sizeof(struct rt_can_msg);
|
||||
rt_hw_interrupt_enable(level);
|
||||
|
||||
if (rx_length)
|
||||
{
|
||||
can->parent.rx_indicate(&can->parent, rx_length);
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
case RT_CAN_EVENT_TX_DONE:
|
||||
case RT_CAN_EVENT_TX_FAIL:
|
||||
{
|
||||
struct rt_can_tx_fifo *tx_fifo;
|
||||
rt_uint32_t no;
|
||||
no = event >> 8;
|
||||
tx_fifo = (struct rt_can_tx_fifo *) can->can_tx;
|
||||
RT_ASSERT(tx_fifo != RT_NULL);
|
||||
|
||||
if ((event & 0xff) == RT_CAN_EVENT_TX_DONE)
|
||||
{
|
||||
tx_fifo->buffer[no].result = RT_CAN_SND_RESULT_OK;
|
||||
}
|
||||
else
|
||||
{
|
||||
tx_fifo->buffer[no].result = RT_CAN_SND_RESULT_ERR;
|
||||
}
|
||||
rt_completion_done(&(tx_fifo->buffer[no].completion));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef RT_USING_FINSH
|
||||
#include <finsh.h>
|
||||
int cmd_canstat(int argc, void **argv)
|
||||
{
|
||||
static const char *ErrCode[] =
|
||||
{
|
||||
"No Error!",
|
||||
"Warning !",
|
||||
"Passive !",
|
||||
"Bus Off !"
|
||||
};
|
||||
|
||||
if (argc >= 2)
|
||||
{
|
||||
struct rt_can_status status;
|
||||
rt_device_t candev = rt_device_find(argv[1]);
|
||||
if (!candev)
|
||||
{
|
||||
rt_kprintf(" Can't find can device %s\n", argv[1]);
|
||||
return -1;
|
||||
}
|
||||
rt_kprintf(" Finded can device: %s...", argv[1]);
|
||||
|
||||
rt_device_control(candev, RT_CAN_CMD_GET_STATUS, &status);
|
||||
rt_kprintf("\n Receive...error..count: %010ld. Send.....error....count: %010ld.",
|
||||
status.rcverrcnt, status.snderrcnt);
|
||||
rt_kprintf("\n Bit..pad..error..count: %010ld. Format...error....count: %010ld",
|
||||
status.bitpaderrcnt, status.formaterrcnt);
|
||||
rt_kprintf("\n Ack.......error..count: %010ld. Bit......error....count: %010ld.",
|
||||
status.ackerrcnt, status.biterrcnt);
|
||||
rt_kprintf("\n CRC.......error..count: %010ld. Error.code.[%010ld]: ",
|
||||
status.crcerrcnt, status.errcode);
|
||||
switch (status.errcode)
|
||||
{
|
||||
case 0:
|
||||
rt_kprintf("%s.", ErrCode[0]);
|
||||
break;
|
||||
case 1:
|
||||
rt_kprintf("%s.", ErrCode[1]);
|
||||
break;
|
||||
case 2:
|
||||
case 3:
|
||||
rt_kprintf("%s.", ErrCode[2]);
|
||||
break;
|
||||
case 4:
|
||||
case 5:
|
||||
case 6:
|
||||
case 7:
|
||||
rt_kprintf("%s.", ErrCode[3]);
|
||||
break;
|
||||
}
|
||||
rt_kprintf("\n Total.receive.packages: %010ld. Droped.receive.packages: %010ld.",
|
||||
status.rcvpkg, status.dropedrcvpkg);
|
||||
rt_kprintf("\n Total..send...packages: %010ld. Droped...send..packages: %010ld.\n",
|
||||
status.sndpkg + status.dropedsndpkg, status.dropedsndpkg);
|
||||
}
|
||||
else
|
||||
{
|
||||
rt_kprintf(" Invalid Call %s\n", argv[0]);
|
||||
rt_kprintf(" Please using %s cannamex .Here canname is driver name and x is candrive number.\n", argv[0]);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
MSH_CMD_EXPORT_ALIAS(cmd_canstat, canstat, stat can device status);
|
||||
#endif
|
||||
@@ -0,0 +1,132 @@
|
||||
说明:
|
||||
本驱动完成了can控制器硬件抽象
|
||||
一 CAN Driver 注册
|
||||
Can driver注册需要填充以下几个数据结构：
|
||||
1、struct can_configure
|
||||
{
|
||||
rt_uint32_t baud_rate;
|
||||
rt_uint32_t msgboxsz;
|
||||
rt_uint32_t sndboxnumber;
|
||||
rt_uint32_t mode :8;
|
||||
rt_uint32_t privmode :8;
|
||||
rt_uint32_t reserved :16;
|
||||
#ifdef RT_CAN_USING_LED
|
||||
const struct rt_can_led* rcvled;
|
||||
const struct rt_can_led* sndled;
|
||||
const struct rt_can_led* errled;
|
||||
#endif /*RT_CAN_USING_LED*/
|
||||
rt_uint32_t ticks;
|
||||
#ifdef RT_CAN_USING_HDR
|
||||
rt_uint32_t maxhdr;
|
||||
#endif
|
||||
};
|
||||
struct can_configure 为can驱动的基本配置信息:
|
||||
baud_rate :
|
||||
enum CANBAUD
|
||||
{
|
||||
CAN1MBaud=0, // 1 MBit/sec
|
||||
CAN800kBaud, // 800 kBit/sec
|
||||
CAN500kBaud, // 500 kBit/sec
|
||||
CAN250kBaud, // 250 kBit/sec
|
||||
CAN125kBaud, // 125 kBit/sec
|
||||
CAN100kBaud, // 100 kBit/sec
|
||||
CAN50kBaud, // 50 kBit/sec
|
||||
CAN20kBaud, // 20 kBit/sec
|
||||
CAN10kBaud // 10 kBit/sec
|
||||
};
|
||||
配置Can的波特率。
|
||||
msgboxsz : Can接收邮箱缓冲数量，本驱动在软件层开辟msgboxsz个接收邮箱。
|
||||
sndboxnumber : can 发送通道数量，该配置为Can控制器实际的发送通道数量。
|
||||
mode ：
|
||||
#define RT_CAN_MODE_NORMAL 0 正常模式
|
||||
#define RT_CAN_MODE_LISEN 1 只听模式
|
||||
#define RT_CAN_MODE_LOOPBACK 2 自发自收模式
|
||||
#define RT_CAN_MODE_LOOPBACKANLISEN 3 自发自收只听模式
|
||||
配置Can 的工作状态。
|
||||
privmode :
|
||||
#define RT_CAN_MODE_PRIV 0x01 处于优先级模式，高优先级的消息优先发送。
|
||||
#define RT_CAN_MODE_NOPRIV 0x00
|
||||
配置Can driver的优先级模式。
|
||||
#ifdef RT_CAN_USING_LED
|
||||
const struct rt_can_led* rcvled;
|
||||
const struct rt_can_led* sndled;
|
||||
const struct rt_can_led* errled;
|
||||
#endif /*RT_CAN_USING_LED*/
|
||||
配置can led信息, 当前can驱动的led使用了 pin驱动，
|
||||
开启RT_CAN_USING_LED时要确保当前系统已实现pin驱动。
|
||||
rt_uint32_t ticks : 配置Can driver timer周期。
|
||||
#ifdef RT_CAN_USING_HDR
|
||||
rt_uint32_t maxhdr;
|
||||
#endif
|
||||
如果使用硬件过滤，则开启RT_CAN_USING_HDR, maxhdr 为Can控制器过滤表的数量。
|
||||
2、struct rt_can_ops
|
||||
{
|
||||
rt_err_t (*configure)(struct rt_can_device *can, struct can_configure *cfg);
|
||||
rt_err_t (*control)(struct rt_can_device *can, int cmd, void *arg);
|
||||
int (*sendmsg)(struct rt_can_device *can, const void* buf, rt_uint32_t boxno);
|
||||
int (*recvmsg)(struct rt_can_device *can,void* buf, rt_uint32_t boxno);
|
||||
};
|
||||
struct rt_can_ops 为要实现的特定的can控制器操作。
|
||||
rt_err_t (*configure)(struct rt_can_device *can, struct can_configure *cfg);
|
||||
configure根据配置信息初始化Can控制器工作模式。
|
||||
rt_err_t (*control)(struct rt_can_device *can, int cmd, void *arg);
|
||||
control 当前接受以下cmd参数：
|
||||
#define RT_CAN_CMD_SET_FILTER 0x13
|
||||
#define RT_CAN_CMD_SET_BAUD 0x14
|
||||
#define RT_CAN_CMD_SET_MODE 0x15
|
||||
#define RT_CAN_CMD_SET_PRIV 0x16
|
||||
#define RT_CAN_CMD_GET_STATUS 0x17
|
||||
#define RT_CAN_CMD_SET_STATUS_IND 0x18
|
||||
int (*sendmsg)(struct rt_can_device *can, const void* buf, rt_uint32_t boxno);
|
||||
sendmsg向Can控制器发送数，boxno为发送通道号。
|
||||
int (*recvmsg)(struct rt_can_device *can,void* buf, rt_uint32_t boxno);
|
||||
recvmsg从Can控制器接收数据，boxno为接收通道号。
|
||||
struct rt_can_device
|
||||
{
|
||||
struct rt_device parent;
|
||||
|
||||
const struct rt_can_ops *ops;
|
||||
struct can_configure config;
|
||||
struct rt_can_status status;
|
||||
rt_uint32_t timerinitflag;
|
||||
struct rt_timer timer;
|
||||
struct rt_can_status_ind_type status_indicate;
|
||||
#ifdef RT_CAN_USING_HDR
|
||||
struct rt_can_hdr* hdr;
|
||||
#endif
|
||||
void *can_rx;
|
||||
void *can_tx;
|
||||
};
|
||||
填充完成后，便可调用rt_hw_can_register完成can驱动的注册。
|
||||
二、 CAN Driver 的添加：
|
||||
要添加一个新的Can驱动，至少要完成以下接口。
|
||||
1、struct rt_can_ops
|
||||
{
|
||||
rt_err_t (*configure)(struct rt_can_device *can, struct can_configure *cfg);
|
||||
rt_err_t (*control)(struct rt_can_device *can, int cmd, void *arg);
|
||||
int (*sendmsg)(struct rt_can_device *can, const void* buf, rt_uint32_t boxno);
|
||||
int (*recvmsg)(struct rt_can_device *can,void* buf, rt_uint32_t boxno);
|
||||
};
|
||||
2、 rt_err_t (*control)(struct rt_can_device *can, int cmd, void *arg);
|
||||
接口的
|
||||
#define RT_CAN_CMD_SET_FILTER 0x13
|
||||
#define RT_CAN_CMD_SET_BAUD 0x14
|
||||
#define RT_CAN_CMD_SET_MODE 0x15
|
||||
#define RT_CAN_CMD_SET_PRIV 0x16
|
||||
#define RT_CAN_CMD_GET_STATUS 0x17
|
||||
#define RT_CAN_CMD_SET_STATUS_IND 0x18
|
||||
若干命令。
|
||||
3、can口中断，要完接收，发送结束，以及错误中断。
|
||||
#define RT_CAN_EVENT_RX_IND 0x01 /* Rx indication */
|
||||
#define RT_CAN_EVENT_TX_DONE 0x02 /* Tx complete */
|
||||
#define RT_CAN_EVENT_TX_FAIL 0x03 /* Tx complete */
|
||||
#define RT_CAN_EVENT_RX_TIMEOUT 0x05 /* Rx timeout */
|
||||
#define RT_CAN_EVENT_RXOF_IND 0x06 /* Rx overflow */
|
||||
中断产生后，调用rt_hw_can_isr(struct rt_can_device *can, int event)
|
||||
进入相应的操作，其中接收发送中断的event，最低8位为上面的事件，16到24位为通信通道号。
|
||||
一个作为一个例子，参见bsp/stm32f10x/driver下的bxcan.c 。
|
||||
三、CAN Driver的使用：
|
||||
一个使用的例子，参数bsp/stm32f10x/applications下的canapp.c
|
||||
四、当前Can驱动，没有实现轮模式，采用中断模式，bxcan驱动工作在loopback模式下的时候不能读数据。
|
||||
|
||||
五、当前Can驱动，在stm32f105上测试，暂无问题。
|
||||
@@ -0,0 +1,14 @@
|
||||
from building import *
|
||||
|
||||
cwd = GetCurrentDir()
|
||||
CPPPATH = [cwd + '/../include']
|
||||
src = Split('''
|
||||
cputime.c
|
||||
''')
|
||||
|
||||
if GetDepend('RT_USING_CPUTIME_CORTEXM'):
|
||||
src += ['cputime_cortexm.c']
|
||||
|
||||
group = DefineGroup('DeviceDrivers', src, depend = ['RT_USING_CPUTIME'], CPPPATH = CPPPATH)
|
||||
|
||||
Return('group')
|
||||
@@ -0,0 +1,91 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2017-12-23 Bernard first version
|
||||
*/
|
||||
|
||||
#include <rtdevice.h>
|
||||
#include <rtthread.h>
|
||||
#include <sys/errno.h>
|
||||
|
||||
static const struct rt_clock_cputime_ops *_cputime_ops = RT_NULL;
|
||||
|
||||
/**
|
||||
* The clock_cpu_getres() function shall return the resolution of CPU time, the
|
||||
* number of nanosecond per tick.
|
||||
*
|
||||
* @return the number of nanosecond per tick
|
||||
*/
|
||||
float clock_cpu_getres(void)
|
||||
{
|
||||
if (_cputime_ops)
|
||||
return _cputime_ops->cputime_getres();
|
||||
|
||||
rt_set_errno(ENOSYS);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* The clock_cpu_gettime() function shall return the current value of cpu time tick.
|
||||
*
|
||||
* @return the cpu tick
|
||||
*/
|
||||
uint64_t clock_cpu_gettime(void)
|
||||
{
|
||||
if (_cputime_ops)
|
||||
return _cputime_ops->cputime_gettime();
|
||||
|
||||
rt_set_errno(ENOSYS);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* The clock_cpu_microsecond() fucntion shall return the microsecond according to
|
||||
* cpu_tick parameter.
|
||||
*
|
||||
* @param cpu_tick the cpu tick
|
||||
*
|
||||
* @return the microsecond
|
||||
*/
|
||||
uint32_t clock_cpu_microsecond(uint32_t cpu_tick)
|
||||
{
|
||||
float unit = clock_cpu_getres();
|
||||
|
||||
return (uint32_t)((cpu_tick * unit) / 1000);
|
||||
}
|
||||
|
||||
/**
|
||||
* The clock_cpu_microsecond() fucntion shall return the millisecond according to
|
||||
* cpu_tick parameter.
|
||||
*
|
||||
* @param cpu_tick the cpu tick
|
||||
*
|
||||
* @return the millisecond
|
||||
*/
|
||||
uint32_t clock_cpu_millisecond(uint32_t cpu_tick)
|
||||
{
|
||||
float unit = clock_cpu_getres();
|
||||
|
||||
return (uint32_t)((cpu_tick * unit) / (1000 * 1000));
|
||||
}
|
||||
|
||||
/**
|
||||
* The clock_cpu_seops() function shall set the ops of cpu time.
|
||||
*
|
||||
* @return always return 0.
|
||||
*/
|
||||
int clock_cpu_setops(const struct rt_clock_cputime_ops *ops)
|
||||
{
|
||||
_cputime_ops = ops;
|
||||
if (ops)
|
||||
{
|
||||
RT_ASSERT(ops->cputime_getres != RT_NULL);
|
||||
RT_ASSERT(ops->cputime_gettime != RT_NULL);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2017-12-23 Bernard first version
|
||||
*/
|
||||
|
||||
#include <rthw.h>
|
||||
#include <rtdevice.h>
|
||||
#include <rtthread.h>
|
||||
|
||||
#include <board.h>
|
||||
|
||||
/* Use Cycle counter of Data Watchpoint and Trace Register for CPU time */
|
||||
|
||||
static float cortexm_cputime_getres(void)
|
||||
{
|
||||
float ret = 1000 * 1000 * 1000;
|
||||
|
||||
ret = ret / SystemCoreClock;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static uint64_t cortexm_cputime_gettime(void)
|
||||
{
|
||||
return DWT->CYCCNT;
|
||||
}
|
||||
|
||||
const static struct rt_clock_cputime_ops _cortexm_ops =
|
||||
{
|
||||
cortexm_cputime_getres,
|
||||
cortexm_cputime_gettime
|
||||
};
|
||||
|
||||
int cortexm_cputime_init(void)
|
||||
{
|
||||
/* check support bit */
|
||||
if ((DWT->CTRL & (1UL << DWT_CTRL_NOCYCCNT_Pos)) == 0)
|
||||
{
|
||||
/* enable trace*/
|
||||
CoreDebug->DEMCR |= (1UL << CoreDebug_DEMCR_TRCENA_Pos);
|
||||
|
||||
/* whether cycle counter not enabled */
|
||||
if ((DWT->CTRL & (1UL << DWT_CTRL_CYCCNTENA_Pos)) == 0)
|
||||
{
|
||||
/* enable cycle counter */
|
||||
DWT->CTRL |= (1UL << DWT_CTRL_CYCCNTENA_Pos);
|
||||
}
|
||||
|
||||
clock_cpu_setops(&_cortexm_ops);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
INIT_BOARD_EXPORT(cortexm_cputime_init);
|
||||
@@ -0,0 +1,34 @@
|
||||
Import('RTT_ROOT')
|
||||
Import('rtconfig')
|
||||
from building import *
|
||||
|
||||
cwd = GetCurrentDir()
|
||||
CPPPATH = [cwd, str(Dir('#'))]
|
||||
|
||||
src = ['hwcrypto.c']
|
||||
|
||||
if (GetDepend(['RT_HWCRYPTO_USING_AES']) or
|
||||
GetDepend(['RT_HWCRYPTO_USING_DES']) or
|
||||
GetDepend(['RT_HWCRYPTO_USING_3DES']) or
|
||||
GetDepend(['RT_HWCRYPTO_USING_RC4'])):
|
||||
src += ['hw_symmetric.c']
|
||||
if GetDepend(['RT_HWCRYPTO_USING_GCM']):
|
||||
src += ['hw_gcm.c']
|
||||
|
||||
if (GetDepend(['RT_HWCRYPTO_USING_MD5']) or
|
||||
GetDepend(['RT_HWCRYPTO_USING_SHA1']) or
|
||||
GetDepend(['RT_HWCRYPTO_USING_SHA2'])):
|
||||
src += ['hw_hash.c']
|
||||
|
||||
if GetDepend(['RT_HWCRYPTO_USING_RNG']):
|
||||
src += ['hw_rng.c']
|
||||
|
||||
if GetDepend(['RT_HWCRYPTO_USING_CRC']):
|
||||
src += ['hw_crc.c']
|
||||
|
||||
if GetDepend(['RT_HWCRYPTO_USING_BIGNUM']):
|
||||
src += ['hw_bignum.c']
|
||||
|
||||
group = DefineGroup('DeviceDrivers', src, depend = ['RT_USING_HWCRYPTO'], CPPPATH = CPPPATH)
|
||||
|
||||
Return('group')
|
||||
@@ -0,0 +1,315 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2019-04-25 tyx the first version
|
||||
*/
|
||||
|
||||
#include <rtthread.h>
|
||||
#include <rtdevice.h>
|
||||
#include <hw_bignum.h>
|
||||
|
||||
static struct rt_hwcrypto_ctx *bignum_default;
|
||||
|
||||
rt_inline rt_err_t hwcrypto_bignum_dev_is_init(void)
|
||||
{
|
||||
struct rt_hwcrypto_device *dev;
|
||||
|
||||
if (bignum_default)
|
||||
{
|
||||
return RT_EOK;
|
||||
}
|
||||
dev = rt_hwcrypto_dev_default();
|
||||
if (dev == RT_NULL)
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
return rt_hwcrypto_bignum_default(dev);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Setting bignum default devices
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_bignum_default(struct rt_hwcrypto_device *device)
|
||||
{
|
||||
if (bignum_default)
|
||||
{
|
||||
rt_hwcrypto_ctx_destroy(bignum_default);
|
||||
bignum_default = RT_NULL;
|
||||
}
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
return RT_EOK;
|
||||
}
|
||||
bignum_default = rt_hwcrypto_ctx_create(device, HWCRYPTO_TYPE_BIGNUM, sizeof(struct hwcrypto_bignum));
|
||||
if (bignum_default == RT_NULL)
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Init bignum obj
|
||||
*
|
||||
* @param n bignum obj
|
||||
*/
|
||||
void rt_hwcrypto_bignum_init(struct hw_bignum_mpi *n)
|
||||
{
|
||||
if(n == RT_NULL)
|
||||
return;
|
||||
|
||||
n->sign = 1;
|
||||
n->total = 0;
|
||||
n->p = RT_NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief free a bignum obj
|
||||
*
|
||||
* @param Pointer to bignum obj
|
||||
*/
|
||||
void rt_hwcrypto_bignum_free(struct hw_bignum_mpi *n)
|
||||
{
|
||||
if (n)
|
||||
{
|
||||
rt_free(n->p);
|
||||
n->sign = 0;
|
||||
n->total = 0;
|
||||
n->p = RT_NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get length of bignum as an unsigned binary buffer
|
||||
*
|
||||
* @param n bignum obj
|
||||
*
|
||||
* @return binary buffer length
|
||||
*/
|
||||
int rt_hwcrypto_bignum_get_len(const struct hw_bignum_mpi *n)
|
||||
{
|
||||
int tmp_len, total;
|
||||
|
||||
if (n == RT_NULL || n->p == RT_NULL)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
tmp_len = 0;
|
||||
total = n->total;
|
||||
while ((total > 0) && (n->p[total - 1] == 0))
|
||||
{
|
||||
tmp_len++;
|
||||
total--;
|
||||
}
|
||||
return n->total - tmp_len;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Export n into unsigned binary data, big endian
|
||||
*
|
||||
* @param n bignum obj
|
||||
* @param buf Buffer for the binary number
|
||||
* @param len Length of the buffer
|
||||
*
|
||||
* @return export bin length
|
||||
*/
|
||||
int rt_hwcrypto_bignum_export_bin(struct hw_bignum_mpi *n, rt_uint8_t *buf, int len)
|
||||
{
|
||||
int cp_len, i, j;
|
||||
|
||||
if (n == RT_NULL || buf == RT_NULL)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
rt_memset(buf, 0, len);
|
||||
cp_len = n->total > len ? len : n->total;
|
||||
for(i = cp_len, j = 0; i > 0; i--, j++)
|
||||
{
|
||||
buf[i - 1] = n->p[j];
|
||||
}
|
||||
|
||||
return cp_len;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Import n from unsigned binary data, big endian
|
||||
*
|
||||
* @param n bignum obj
|
||||
* @param buf Buffer for the binary number
|
||||
* @param len Length of the buffer
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_bignum_import_bin(struct hw_bignum_mpi *n, rt_uint8_t *buf, int len)
|
||||
{
|
||||
int cp_len, i, j;
|
||||
void *temp_p;
|
||||
|
||||
if (n == RT_NULL || buf == RT_NULL)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
if (n->total < len)
|
||||
{
|
||||
temp_p = rt_malloc(len);
|
||||
if (temp_p == RT_NULL)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
rt_memset(temp_p, 0, len);
|
||||
rt_free(n->p);
|
||||
n->p = temp_p;
|
||||
n->total = len;
|
||||
}
|
||||
cp_len = n->total > len ? len : n->total;
|
||||
|
||||
for(i = cp_len, j = 0; i > 0; i--, j++)
|
||||
{
|
||||
n->p[j] = buf[i - 1];
|
||||
}
|
||||
|
||||
return cp_len;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief x = a + b
|
||||
*
|
||||
* @param a bignum obj
|
||||
* @param b bignum obj
|
||||
* @param c bignum obj
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_bignum_add(struct hw_bignum_mpi *x,
|
||||
const struct hw_bignum_mpi *a,
|
||||
const struct hw_bignum_mpi *b)
|
||||
{
|
||||
struct hwcrypto_bignum *bignum_ctx;
|
||||
|
||||
if (hwcrypto_bignum_dev_is_init() != RT_EOK)
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
bignum_ctx = (struct hwcrypto_bignum *)bignum_default;
|
||||
if (bignum_ctx->ops->add)
|
||||
{
|
||||
return bignum_ctx->ops->add(bignum_ctx, x, a, b);
|
||||
}
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief x = a - b
|
||||
*
|
||||
* @param a bignum obj
|
||||
* @param b bignum obj
|
||||
* @param c bignum obj
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_bignum_sub(struct hw_bignum_mpi *x,
|
||||
const struct hw_bignum_mpi *a,
|
||||
const struct hw_bignum_mpi *b)
|
||||
{
|
||||
struct hwcrypto_bignum *bignum_ctx;
|
||||
|
||||
if (hwcrypto_bignum_dev_is_init() != RT_EOK)
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
bignum_ctx = (struct hwcrypto_bignum *)bignum_default;
|
||||
if (bignum_ctx->ops->sub)
|
||||
{
|
||||
return bignum_ctx->ops->sub(bignum_ctx, x, a, b);
|
||||
}
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief x = a * b
|
||||
*
|
||||
* @param a bignum obj
|
||||
* @param b bignum obj
|
||||
* @param c bignum obj
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_bignum_mul(struct hw_bignum_mpi *x,
|
||||
const struct hw_bignum_mpi *a,
|
||||
const struct hw_bignum_mpi *b)
|
||||
{
|
||||
struct hwcrypto_bignum *bignum_ctx;
|
||||
|
||||
if (hwcrypto_bignum_dev_is_init() != RT_EOK)
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
bignum_ctx = (struct hwcrypto_bignum *)bignum_default;
|
||||
if (bignum_ctx->ops->mul)
|
||||
{
|
||||
return bignum_ctx->ops->mul(bignum_ctx, x, a, b);
|
||||
}
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief x = a * b (mod c)
|
||||
*
|
||||
* @param a bignum obj
|
||||
* @param b bignum obj
|
||||
* @param c bignum obj
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_bignum_mulmod(struct hw_bignum_mpi *x,
|
||||
const struct hw_bignum_mpi *a,
|
||||
const struct hw_bignum_mpi *b,
|
||||
const struct hw_bignum_mpi *c)
|
||||
{
|
||||
struct hwcrypto_bignum *bignum_ctx;
|
||||
|
||||
if (hwcrypto_bignum_dev_is_init() != RT_EOK)
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
bignum_ctx = (struct hwcrypto_bignum *)bignum_default;
|
||||
if (bignum_ctx->ops->mulmod)
|
||||
{
|
||||
return bignum_ctx->ops->mulmod(bignum_ctx, x, a, b, c);
|
||||
}
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief x = a ^ b (mod c)
|
||||
*
|
||||
* @param a bignum obj
|
||||
* @param b bignum obj
|
||||
* @param c bignum obj
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_bignum_exptmod(struct hw_bignum_mpi *x,
|
||||
const struct hw_bignum_mpi *a,
|
||||
const struct hw_bignum_mpi *b,
|
||||
const struct hw_bignum_mpi *c)
|
||||
{
|
||||
struct hwcrypto_bignum *bignum_ctx;
|
||||
|
||||
if (hwcrypto_bignum_dev_is_init() != RT_EOK)
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
bignum_ctx = (struct hwcrypto_bignum *)bignum_default;
|
||||
if (bignum_ctx->ops->exptmod)
|
||||
{
|
||||
return bignum_ctx->ops->exptmod(bignum_ctx, x, a, b, c);
|
||||
}
|
||||
return -RT_ERROR;
|
||||
}
|
||||
@@ -0,0 +1,186 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2019-04-25 tyx the first version
|
||||
*/
|
||||
|
||||
#ifndef __HW_BIGNUM_H__
|
||||
#define __HW_BIGNUM_H__
|
||||
|
||||
#include <hwcrypto.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
struct hwcrypto_bignum;
|
||||
|
||||
/* bignum obj */
|
||||
struct hw_bignum_mpi
|
||||
{
|
||||
int sign; /**< integer sign */
|
||||
rt_size_t total; /**< total of limbs */
|
||||
rt_uint8_t *p; /**< pointer to limbs */
|
||||
};
|
||||
|
||||
struct hwcrypto_bignum_ops
|
||||
{
|
||||
rt_err_t (*add)(struct hwcrypto_bignum *bignum_ctx,
|
||||
struct hw_bignum_mpi *x,
|
||||
const struct hw_bignum_mpi *a,
|
||||
const struct hw_bignum_mpi *b); /**< x = a + b */
|
||||
rt_err_t (*sub)(struct hwcrypto_bignum *bignum_ctx,
|
||||
struct hw_bignum_mpi *x,
|
||||
const struct hw_bignum_mpi *a,
|
||||
const struct hw_bignum_mpi *b); /**< x = a - b */
|
||||
rt_err_t (*mul)(struct hwcrypto_bignum *bignum_ctx,
|
||||
struct hw_bignum_mpi *x,
|
||||
const struct hw_bignum_mpi *a,
|
||||
const struct hw_bignum_mpi *b); /**< x = a * b */
|
||||
rt_err_t (*mulmod)(struct hwcrypto_bignum *bignum_ctx,
|
||||
struct hw_bignum_mpi *x,
|
||||
const struct hw_bignum_mpi *a,
|
||||
const struct hw_bignum_mpi *b,
|
||||
const struct hw_bignum_mpi *c); /**< x = a * b (mod c) */
|
||||
rt_err_t (*exptmod)(struct hwcrypto_bignum *bignum_ctx,
|
||||
struct hw_bignum_mpi *x,
|
||||
const struct hw_bignum_mpi *a,
|
||||
const struct hw_bignum_mpi *b,
|
||||
const struct hw_bignum_mpi *c); /**< x = a ^ b (mod c) */
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief bignum context. Hardware driver usage
|
||||
*/
|
||||
struct hwcrypto_bignum
|
||||
{
|
||||
struct rt_hwcrypto_ctx parent; /**< Inheritance from hardware crypto context */
|
||||
const struct hwcrypto_bignum_ops *ops; /**< !! Hardware initializes this value when creating context !! */
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Setting bignum default devices
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_bignum_default(struct rt_hwcrypto_device *device);
|
||||
|
||||
/**
|
||||
* @brief Init bignum obj
|
||||
*/
|
||||
void rt_hwcrypto_bignum_init(struct hw_bignum_mpi *n);
|
||||
|
||||
/**
|
||||
* @brief free a bignum obj
|
||||
*
|
||||
* @param Pointer to bignum obj
|
||||
*/
|
||||
void rt_hwcrypto_bignum_free(struct hw_bignum_mpi *n);
|
||||
|
||||
/**
|
||||
* @brief Get length of bignum as an unsigned binary buffer
|
||||
*
|
||||
* @param n bignum obj
|
||||
*
|
||||
* @return binary buffer Length
|
||||
*/
|
||||
int rt_hwcrypto_bignum_get_len(const struct hw_bignum_mpi *n);
|
||||
|
||||
/**
|
||||
* @brief Export n into unsigned binary data, big endian
|
||||
*
|
||||
* @param n bignum obj
|
||||
* @param buf Buffer for the binary number
|
||||
* @param len Length of the buffer
|
||||
*
|
||||
* @return export bin length
|
||||
*/
|
||||
int rt_hwcrypto_bignum_export_bin(struct hw_bignum_mpi *n, rt_uint8_t *buf, int len);
|
||||
|
||||
/**
|
||||
* @brief Import n from unsigned binary data, big endian
|
||||
*
|
||||
* @param n bignum obj
|
||||
* @param buf Buffer for the binary number
|
||||
* @param len Length of the buffer
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_bignum_import_bin(struct hw_bignum_mpi *n, rt_uint8_t *buf, int len);
|
||||
|
||||
/**
|
||||
* @brief x = a + b
|
||||
*
|
||||
* @param a bignum obj
|
||||
* @param b bignum obj
|
||||
* @param c bignum obj
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_bignum_add(struct hw_bignum_mpi *x,
|
||||
const struct hw_bignum_mpi *a,
|
||||
const struct hw_bignum_mpi *b);
|
||||
|
||||
/**
|
||||
* @brief x = a - b
|
||||
*
|
||||
* @param a bignum obj
|
||||
* @param b bignum obj
|
||||
* @param c bignum obj
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_bignum_sub(struct hw_bignum_mpi *x,
|
||||
const struct hw_bignum_mpi *a,
|
||||
const struct hw_bignum_mpi *b);
|
||||
|
||||
/**
|
||||
* @brief x = a * b
|
||||
*
|
||||
* @param a bignum obj
|
||||
* @param b bignum obj
|
||||
* @param c bignum obj
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_bignum_mul(struct hw_bignum_mpi *x,
|
||||
const struct hw_bignum_mpi *a,
|
||||
const struct hw_bignum_mpi *b);
|
||||
|
||||
/**
|
||||
* @brief x = a * b (mod c)
|
||||
*
|
||||
* @param a bignum obj
|
||||
* @param b bignum obj
|
||||
* @param c bignum obj
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_bignum_mulmod(struct hw_bignum_mpi *x,
|
||||
const struct hw_bignum_mpi *a,
|
||||
const struct hw_bignum_mpi *b,
|
||||
const struct hw_bignum_mpi *c);
|
||||
|
||||
/**
|
||||
* @brief x = a ^ b (mod c)
|
||||
*
|
||||
* @param a bignum obj
|
||||
* @param b bignum obj
|
||||
* @param c bignum obj
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_bignum_exptmod(struct hw_bignum_mpi *x,
|
||||
const struct hw_bignum_mpi *a,
|
||||
const struct hw_bignum_mpi *b,
|
||||
const struct hw_bignum_mpi *c);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,117 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2019-04-25 tyx the first version
|
||||
*/
|
||||
|
||||
#include <rtthread.h>
|
||||
#include <rtdevice.h>
|
||||
#include <hw_crc.h>
|
||||
|
||||
/**
|
||||
* @brief Creating CRC Context
|
||||
*
|
||||
* @param device Hardware crypto device
|
||||
* @param mode Setting default mode or custom mode
|
||||
*
|
||||
* @return CRC context
|
||||
*/
|
||||
struct rt_hwcrypto_ctx *rt_hwcrypto_crc_create(struct rt_hwcrypto_device *device,
|
||||
hwcrypto_crc_mode mode)
|
||||
{
|
||||
struct hwcrypto_crc *crc_ctx;
|
||||
|
||||
crc_ctx = (struct hwcrypto_crc *)rt_hwcrypto_ctx_create(device, HWCRYPTO_TYPE_CRC, sizeof(struct hwcrypto_crc));
|
||||
if (crc_ctx == RT_NULL)
|
||||
{
|
||||
return RT_NULL;
|
||||
}
|
||||
|
||||
switch (mode)
|
||||
{
|
||||
case HWCRYPTO_CRC_CRC8:
|
||||
{
|
||||
struct hwcrypto_crc_cfg temp = HWCRYPTO_CRC8_CFG;
|
||||
crc_ctx->crc_cfg = temp;
|
||||
break;
|
||||
}
|
||||
case HWCRYPTO_CRC_CRC16:
|
||||
{
|
||||
struct hwcrypto_crc_cfg temp = HWCRYPTO_CRC16_CFG;
|
||||
crc_ctx->crc_cfg = temp;
|
||||
break;
|
||||
}
|
||||
case HWCRYPTO_CRC_CRC32:
|
||||
{
|
||||
struct hwcrypto_crc_cfg temp = HWCRYPTO_CRC32_CFG;
|
||||
crc_ctx->crc_cfg = temp;
|
||||
break;
|
||||
}
|
||||
case HWCRYPTO_CRC_CCITT:
|
||||
{
|
||||
struct hwcrypto_crc_cfg temp = HWCRYPTO_CRC_CCITT_CFG;
|
||||
crc_ctx->crc_cfg = temp;
|
||||
break;
|
||||
}
|
||||
case HWCRYPTO_CRC_DNP:
|
||||
{
|
||||
struct hwcrypto_crc_cfg temp = HWCRYPTO_CRC_DNP_CFG;
|
||||
crc_ctx->crc_cfg = temp;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return &crc_ctx->parent;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Destroy CRC Context
|
||||
*
|
||||
* @param ctx CRC context
|
||||
*/
|
||||
void rt_hwcrypto_crc_destroy(struct rt_hwcrypto_ctx *ctx)
|
||||
{
|
||||
rt_hwcrypto_ctx_destroy(ctx);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Processing a packet of data
|
||||
*
|
||||
* @param ctx CRC context
|
||||
* @param input Data buffer to be Processed
|
||||
* @param length Data Buffer length
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_uint32_t rt_hwcrypto_crc_update(struct rt_hwcrypto_ctx *ctx,
|
||||
const rt_uint8_t *input,
|
||||
rt_size_t length)
|
||||
{
|
||||
struct hwcrypto_crc *crc_ctx = (struct hwcrypto_crc *)ctx;
|
||||
if (ctx && crc_ctx->ops->update)
|
||||
{
|
||||
return crc_ctx->ops->update(crc_ctx, input, length);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief CRC context configuration
|
||||
*
|
||||
* @param ctx CRC context
|
||||
* @param cfg CRC config
|
||||
*/
|
||||
void rt_hwcrypto_crc_cfg(struct rt_hwcrypto_ctx *ctx,
|
||||
struct hwcrypto_crc_cfg *cfg)
|
||||
{
|
||||
if (cfg)
|
||||
{
|
||||
((struct hwcrypto_crc *)ctx)->crc_cfg = *cfg;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,148 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2019-04-25 tyx the first version
|
||||
*/
|
||||
|
||||
#ifndef __HW_CRC_H__
|
||||
#define __HW_CRC_H__
|
||||
|
||||
#include <hwcrypto.h>
|
||||
|
||||
#define CRC_FLAG_REFIN (0x1 << 0)
|
||||
#define CRC_FLAG_REFOUT (0x1 << 1)
|
||||
|
||||
#define HWCRYPTO_CRC8_CFG \
|
||||
{ \
|
||||
.last_val = 0x00, \
|
||||
.poly = 0x07, \
|
||||
.width = 8, \
|
||||
.xorout = 0x00, \
|
||||
.flags = 0, \
|
||||
}
|
||||
|
||||
#define HWCRYPTO_CRC16_CFG \
|
||||
{ \
|
||||
.last_val = 0x0000, \
|
||||
.poly = 0x8005, \
|
||||
.width = 16, \
|
||||
.xorout = 0x0000, \
|
||||
.flags = 0, \
|
||||
}
|
||||
|
||||
#define HWCRYPTO_CRC32_CFG \
|
||||
{ \
|
||||
.last_val = 0x00000000, \
|
||||
.poly = 0x04C11DB7, \
|
||||
.width = 32, \
|
||||
.xorout = 0x00000000, \
|
||||
.flags = 0, \
|
||||
}
|
||||
|
||||
#define HWCRYPTO_CRC_CCITT_CFG \
|
||||
{ \
|
||||
.last_val = 0x0000, \
|
||||
.poly = 0x1021, \
|
||||
.width = 16, \
|
||||
.xorout = 0x0000, \
|
||||
.flags = CRC_FLAG_REFIN | CRC_FLAG_REFOUT, \
|
||||
}
|
||||
|
||||
#define HWCRYPTO_CRC_DNP_CFG \
|
||||
{ \
|
||||
.last_val = 0x0000, \
|
||||
.poly = 0x3D65, \
|
||||
.width = 16, \
|
||||
.xorout = 0xffff, \
|
||||
.flags = CRC_FLAG_REFIN | CRC_FLAG_REFOUT, \
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
struct hwcrypto_crc;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
HWCRYPTO_CRC_CUSTOM, /**< Custom CRC mode */
|
||||
HWCRYPTO_CRC_CRC8, /**< poly : 0x07 */
|
||||
HWCRYPTO_CRC_CRC16, /**< poly : 0x8005 */
|
||||
HWCRYPTO_CRC_CRC32, /**< poly : 0x04C11DB7 */
|
||||
HWCRYPTO_CRC_CCITT, /**< poly : 0x1021 */
|
||||
HWCRYPTO_CRC_DNP, /**< poly : 0x3D65 */
|
||||
} hwcrypto_crc_mode;
|
||||
|
||||
struct hwcrypto_crc_cfg
|
||||
{
|
||||
rt_uint32_t last_val; /**< Last CRC value cache */
|
||||
rt_uint32_t poly; /**< CRC polynomial */
|
||||
rt_uint16_t width; /**< CRC value width */
|
||||
rt_uint32_t xorout; /**< Result XOR Value */
|
||||
rt_uint16_t flags; /**< Input or output data reverse. CRC_FLAG_REFIN or CRC_FLAG_REFOUT */
|
||||
};
|
||||
|
||||
struct hwcrypto_crc_ops
|
||||
{
|
||||
rt_uint32_t (*update)(struct hwcrypto_crc *ctx,
|
||||
const rt_uint8_t *in, rt_size_t length); /**< Perform a CRC calculation. return CRC value */
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief CRC context. Hardware driver usage
|
||||
*/
|
||||
struct hwcrypto_crc
|
||||
{
|
||||
struct rt_hwcrypto_ctx parent; /**< Inherited from the standard device */
|
||||
struct hwcrypto_crc_cfg crc_cfg; /**< CRC configure */
|
||||
const struct hwcrypto_crc_ops *ops; /**< !! Hardware initializes this value when creating context !! */
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Creating CRC Context
|
||||
*
|
||||
* @param device Hardware crypto device
|
||||
* @param mode Setting default mode or custom mode
|
||||
*
|
||||
* @return CRC context
|
||||
*/
|
||||
struct rt_hwcrypto_ctx *rt_hwcrypto_crc_create(struct rt_hwcrypto_device *device,
|
||||
hwcrypto_crc_mode mode);
|
||||
|
||||
/**
|
||||
* @brief Destroy CRC Context
|
||||
*
|
||||
* @param ctx CRC context
|
||||
*/
|
||||
void rt_hwcrypto_crc_destroy(struct rt_hwcrypto_ctx *ctx);
|
||||
|
||||
/**
|
||||
* @brief Processing a packet of data
|
||||
*
|
||||
* @param ctx CRC context
|
||||
* @param input Data buffer to be Processed
|
||||
* @param length Data Buffer length
|
||||
*
|
||||
* @return CRC value
|
||||
*/
|
||||
rt_uint32_t rt_hwcrypto_crc_update(struct rt_hwcrypto_ctx *ctx,
|
||||
const rt_uint8_t *input, rt_size_t length);
|
||||
|
||||
/**
|
||||
* @brief CRC context configuration
|
||||
*
|
||||
* @param ctx CRC context
|
||||
* @param cfg CRC config
|
||||
*/
|
||||
void rt_hwcrypto_crc_cfg(struct rt_hwcrypto_ctx *ctx,
|
||||
struct hwcrypto_crc_cfg *cfg);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,218 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2019-05-14 tyx the first version
|
||||
*/
|
||||
|
||||
#include <rtthread.h>
|
||||
#include <rtdevice.h>
|
||||
#include <hw_gcm.h>
|
||||
|
||||
/**
|
||||
* @brief Creating GCM Context
|
||||
*
|
||||
* @param device Hardware crypto device
|
||||
* @param type Type of symmetric crypto context
|
||||
*
|
||||
* @return GCM context
|
||||
*/
|
||||
struct rt_hwcrypto_ctx *rt_hwcrypto_gcm_create(struct rt_hwcrypto_device *device,
|
||||
hwcrypto_type crypt_type)
|
||||
{
|
||||
struct rt_hwcrypto_ctx *ctx;
|
||||
|
||||
ctx = rt_hwcrypto_ctx_create(device, HWCRYPTO_TYPE_GCM, sizeof(struct hwcrypto_gcm));
|
||||
if (ctx)
|
||||
{
|
||||
((struct hwcrypto_gcm *)ctx)->crypt_type = crypt_type;
|
||||
}
|
||||
return ctx;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Destroy GCM Context
|
||||
*
|
||||
* @param ctx GCM context
|
||||
*/
|
||||
void rt_hwcrypto_gcm_destroy(struct rt_hwcrypto_ctx *ctx)
|
||||
{
|
||||
rt_hwcrypto_ctx_destroy(ctx);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief This function starts a GCM encryption or decryption operation
|
||||
*
|
||||
* @param ctx GCM context
|
||||
* @param add The buffer holding the additional data
|
||||
* @param add_len The length of the additional data
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_gcm_start(struct rt_hwcrypto_ctx *ctx, const rt_uint8_t *add,
|
||||
rt_size_t add_len)
|
||||
{
|
||||
struct hwcrypto_gcm *gcm_ctx = (struct hwcrypto_gcm *)ctx;
|
||||
|
||||
if (gcm_ctx && gcm_ctx->ops->start)
|
||||
{
|
||||
return gcm_ctx->ops->start(gcm_ctx, add, add_len);
|
||||
}
|
||||
return -RT_EINVAL;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief This function finishes the GCM operation and generates the authentication tag
|
||||
*
|
||||
* @param ctx GCM context
|
||||
* @param tag The buffer for holding the tag
|
||||
* @param tag_len The length of the tag to generate
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_gcm_finish(struct rt_hwcrypto_ctx *ctx, const rt_uint8_t *tag,
|
||||
rt_size_t tag_len)
|
||||
{
|
||||
struct hwcrypto_gcm *gcm_ctx = (struct hwcrypto_gcm *)ctx;
|
||||
|
||||
if (gcm_ctx && gcm_ctx->ops->finish)
|
||||
{
|
||||
return gcm_ctx->ops->finish(gcm_ctx, tag, tag_len);
|
||||
}
|
||||
return -RT_EINVAL;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief This function performs a symmetric encryption or decryption operation
|
||||
*
|
||||
* @param ctx GCM context
|
||||
* @param mode Operation mode. HWCRYPTO_MODE_ENCRYPT or HWCRYPTO_MODE_DECRYPT
|
||||
* @param length The length of the input data in Bytes. This must be a multiple of the block size
|
||||
* @param in The buffer holding the input data
|
||||
* @param out The buffer holding the output data
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_gcm_crypt(struct rt_hwcrypto_ctx *ctx, hwcrypto_mode mode,
|
||||
rt_size_t length, const rt_uint8_t *in, rt_uint8_t *out)
|
||||
{
|
||||
return rt_hwcrypto_symmetric_crypt(ctx, mode, length, in, out);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set Symmetric Encryption and Decryption Key
|
||||
*
|
||||
* @param ctx GCM context
|
||||
* @param key The crypto key
|
||||
* @param bitlen The crypto key bit length
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_gcm_setkey(struct rt_hwcrypto_ctx *ctx,
|
||||
const rt_uint8_t *key, rt_uint32_t bitlen)
|
||||
{
|
||||
return rt_hwcrypto_symmetric_setkey(ctx, key, bitlen);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get Symmetric Encryption and Decryption Key
|
||||
*
|
||||
* @param ctx GCM context
|
||||
* @param key The crypto key buffer
|
||||
* @param bitlen The crypto key bit length
|
||||
*
|
||||
* @return Key length of copy
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_gcm_getkey(struct rt_hwcrypto_ctx *ctx,
|
||||
rt_uint8_t *key, rt_uint32_t bitlen)
|
||||
{
|
||||
return rt_hwcrypto_symmetric_getkey(ctx, key, bitlen);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set Symmetric Encryption and Decryption initialization vector
|
||||
*
|
||||
* @param ctx GCM context
|
||||
* @param iv The crypto initialization vector
|
||||
* @param len The crypto initialization vector length
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_gcm_setiv(struct rt_hwcrypto_ctx *ctx,
|
||||
const rt_uint8_t *iv, rt_size_t len)
|
||||
{
|
||||
return rt_hwcrypto_symmetric_setiv(ctx, iv, len);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get Symmetric Encryption and Decryption initialization vector
|
||||
*
|
||||
* @param ctx GCM context
|
||||
* @param iv The crypto initialization vector buffer
|
||||
* @param len The crypto initialization vector buffer length
|
||||
*
|
||||
* @return IV length of copy
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_gcm_getiv(struct rt_hwcrypto_ctx *ctx,
|
||||
rt_uint8_t *iv, rt_size_t len)
|
||||
{
|
||||
return rt_hwcrypto_symmetric_getiv(ctx, iv, len);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set offset in initialization vector
|
||||
*
|
||||
* @param ctx GCM context
|
||||
* @param iv_off The offset in IV
|
||||
*/
|
||||
void rt_hwcrypto_gcm_set_ivoff(struct rt_hwcrypto_ctx *ctx, rt_int32_t iv_off)
|
||||
{
|
||||
rt_hwcrypto_symmetric_set_ivoff(ctx, iv_off);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get offset in initialization vector
|
||||
*
|
||||
* @param ctx GCM context
|
||||
* @param iv_off It must point to a valid memory
|
||||
*/
|
||||
void rt_hwcrypto_gcm_get_ivoff(struct rt_hwcrypto_ctx *ctx, rt_int32_t *iv_off)
|
||||
{
|
||||
rt_hwcrypto_symmetric_get_ivoff(ctx, iv_off);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief This function copy GCM context
|
||||
*
|
||||
* @param des The destination GCM context
|
||||
* @param src The GCM context to be copy
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_gcm_cpy(struct rt_hwcrypto_ctx *des,
|
||||
const struct rt_hwcrypto_ctx *src)
|
||||
{
|
||||
struct hwcrypto_gcm *gcm_des = (struct hwcrypto_gcm *)des;
|
||||
struct hwcrypto_gcm *gcm_src = (struct hwcrypto_gcm *)src;
|
||||
|
||||
if (des != RT_NULL && src != RT_NULL)
|
||||
{
|
||||
gcm_des->crypt_type = gcm_src->crypt_type;
|
||||
/* symmetric crypto context copy */
|
||||
return rt_hwcrypto_symmetric_cpy(des, src);
|
||||
}
|
||||
return -RT_EINVAL;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Reset GCM context
|
||||
*
|
||||
* @param ctx GCM context
|
||||
*/
|
||||
void rt_hwcrypto_gcm_reset(struct rt_hwcrypto_ctx *ctx)
|
||||
{
|
||||
rt_hwcrypto_symmetric_reset(ctx);
|
||||
}
|
||||
@@ -0,0 +1,182 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2019-05-14 tyx the first version
|
||||
*/
|
||||
|
||||
#ifndef __HW_GCM_H__
|
||||
#define __HW_GCM_H__
|
||||
|
||||
#include "hw_symmetric.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
struct hwcrypto_gcm;
|
||||
|
||||
struct hwcrypto_gcm_ops
|
||||
{
|
||||
rt_err_t (*start)(struct hwcrypto_gcm *gcm_ctx,
|
||||
const unsigned char *add, rt_size_t add_len); /**< Set additional data. start GCM operation */
|
||||
rt_err_t (*finish)(struct hwcrypto_gcm *gcm_ctx,
|
||||
const unsigned char *tag, rt_size_t tag_len); /**< finish GCM operation. get tag */
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief GCM context. Hardware driver usage
|
||||
*/
|
||||
struct hwcrypto_gcm
|
||||
{
|
||||
struct hwcrypto_symmetric parent; /**< Inheritance from hardware symmetric crypto context */
|
||||
hwcrypto_type crypt_type; /**< symmetric crypto type. eg: AES/DES */
|
||||
const struct hwcrypto_gcm_ops *ops; /**< !! Hardware initializes this value when creating context !! */
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Creating GCM Context
|
||||
*
|
||||
* @param device Hardware crypto device
|
||||
* @param type Type of symmetric crypto context
|
||||
*
|
||||
* @return GCM context
|
||||
*/
|
||||
struct rt_hwcrypto_ctx *rt_hwcrypto_gcm_create(struct rt_hwcrypto_device *device,
|
||||
hwcrypto_type crypt_type);
|
||||
|
||||
/**
|
||||
* @brief Destroy GCM Context
|
||||
*
|
||||
* @param ctx GCM context
|
||||
*/
|
||||
void rt_hwcrypto_gcm_destroy(struct rt_hwcrypto_ctx *ctx);
|
||||
|
||||
/**
|
||||
* @brief This function starts a GCM encryption or decryption operation
|
||||
*
|
||||
* @param ctx GCM context
|
||||
* @param add The buffer holding the additional data
|
||||
* @param add_len The length of the additional data
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_gcm_start(struct rt_hwcrypto_ctx *ctx, const rt_uint8_t *add,
|
||||
rt_size_t add_len);
|
||||
|
||||
/**
|
||||
* @brief This function finishes the GCM operation and generates the authentication tag
|
||||
*
|
||||
* @param ctx GCM context
|
||||
* @param tag The buffer for holding the tag
|
||||
* @param tag_len The length of the tag to generate
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_gcm_finish(struct rt_hwcrypto_ctx *ctx, const rt_uint8_t *tag,
|
||||
rt_size_t tag_len);
|
||||
|
||||
/**
|
||||
* @brief This function performs a symmetric encryption or decryption operation
|
||||
*
|
||||
* @param ctx GCM context
|
||||
* @param mode Operation mode. HWCRYPTO_MODE_ENCRYPT or HWCRYPTO_MODE_DECRYPT
|
||||
* @param length The length of the input data in Bytes. This must be a multiple of the block size
|
||||
* @param in The buffer holding the input data
|
||||
* @param out The buffer holding the output data
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_gcm_crypt(struct rt_hwcrypto_ctx *ctx, hwcrypto_mode mode,
|
||||
rt_size_t length, const rt_uint8_t *in, rt_uint8_t *out);
|
||||
|
||||
/**
|
||||
* @brief Set Symmetric Encryption and Decryption Key
|
||||
*
|
||||
* @param ctx GCM context
|
||||
* @param key The crypto key
|
||||
* @param bitlen The crypto key bit length
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_gcm_setkey(struct rt_hwcrypto_ctx *ctx,
|
||||
const rt_uint8_t *key, rt_uint32_t bitlen);
|
||||
|
||||
/**
|
||||
* @brief Get Symmetric Encryption and Decryption Key
|
||||
*
|
||||
* @param ctx GCM context
|
||||
* @param key The crypto key buffer
|
||||
* @param bitlen The crypto key bit length
|
||||
*
|
||||
* @return Key length of copy
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_gcm_getkey(struct rt_hwcrypto_ctx *ctx,
|
||||
rt_uint8_t *key, rt_uint32_t bitlen);
|
||||
|
||||
/**
|
||||
* @brief Set Symmetric Encryption and Decryption initialization vector
|
||||
*
|
||||
* @param ctx GCM context
|
||||
* @param iv The crypto initialization vector
|
||||
* @param len The crypto initialization vector length
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_gcm_setiv(struct rt_hwcrypto_ctx *ctx,
|
||||
const rt_uint8_t *iv, rt_size_t len);
|
||||
|
||||
/**
|
||||
* @brief Get Symmetric Encryption and Decryption initialization vector
|
||||
*
|
||||
* @param ctx GCM context
|
||||
* @param iv The crypto initialization vector buffer
|
||||
* @param len The crypto initialization vector buffer length
|
||||
*
|
||||
* @return IV length of copy
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_gcm_getiv(struct rt_hwcrypto_ctx *ctx,
|
||||
rt_uint8_t *iv, rt_size_t len);
|
||||
|
||||
/**
|
||||
* @brief Set offset in initialization vector
|
||||
*
|
||||
* @param ctx GCM context
|
||||
* @param iv_off The offset in IV
|
||||
*/
|
||||
void rt_hwcrypto_gcm_set_ivoff(struct rt_hwcrypto_ctx *ctx, rt_int32_t iv_off);
|
||||
|
||||
/**
|
||||
* @brief Get offset in initialization vector
|
||||
*
|
||||
* @param ctx GCM context
|
||||
* @param iv_off It must point to a valid memory
|
||||
*/
|
||||
void rt_hwcrypto_gcm_get_ivoff(struct rt_hwcrypto_ctx *ctx, rt_int32_t *iv_off);
|
||||
|
||||
/**
|
||||
* @brief This function copy GCM context
|
||||
*
|
||||
* @param des The destination GCM context
|
||||
* @param src The GCM context to be copy
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_gcm_cpy(struct rt_hwcrypto_ctx *des,
|
||||
const struct rt_hwcrypto_ctx *src);
|
||||
|
||||
/**
|
||||
* @brief Reset GCM context
|
||||
*
|
||||
* @param ctx GCM context
|
||||
*/
|
||||
void rt_hwcrypto_gcm_reset(struct rt_hwcrypto_ctx *ctx);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,111 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2019-04-23 tyx the first version
|
||||
*/
|
||||
|
||||
#include <rtthread.h>
|
||||
#include <rtdevice.h>
|
||||
#include <hw_hash.h>
|
||||
|
||||
/**
|
||||
* @brief Creating hash Context
|
||||
*
|
||||
* @param device Hardware crypto device
|
||||
* @param type Type of hash context
|
||||
*
|
||||
* @return Hash context
|
||||
*/
|
||||
struct rt_hwcrypto_ctx *rt_hwcrypto_hash_create(struct rt_hwcrypto_device *device, hwcrypto_type type)
|
||||
{
|
||||
struct rt_hwcrypto_ctx *ctx;
|
||||
|
||||
ctx = rt_hwcrypto_ctx_create(device, type, sizeof(struct hwcrypto_hash));
|
||||
return ctx;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Destroy hash Context
|
||||
*
|
||||
* @param ctx Hash context
|
||||
*/
|
||||
void rt_hwcrypto_hash_destroy(struct rt_hwcrypto_ctx *ctx)
|
||||
{
|
||||
rt_hwcrypto_ctx_destroy(ctx);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the final hash value
|
||||
*
|
||||
* @param ctx Hash context
|
||||
* @param output Hash value buffer
|
||||
* @param length Hash value buffer length
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_hash_finish(struct rt_hwcrypto_ctx *ctx, rt_uint8_t *output, rt_size_t length)
|
||||
{
|
||||
if (ctx && ((struct hwcrypto_hash *)ctx)->ops->finish)
|
||||
{
|
||||
return ((struct hwcrypto_hash *)ctx)->ops->finish((struct hwcrypto_hash *)ctx, output, length);
|
||||
}
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Processing a packet of data
|
||||
*
|
||||
* @param ctx Hash context
|
||||
* @param input Data buffer to be Processed
|
||||
* @param length Data Buffer length
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_hash_update(struct rt_hwcrypto_ctx *ctx, const rt_uint8_t *input, rt_size_t length)
|
||||
{
|
||||
if (ctx && ((struct hwcrypto_hash *)ctx)->ops->update)
|
||||
{
|
||||
return ((struct hwcrypto_hash *)ctx)->ops->update((struct hwcrypto_hash *)ctx, input, length);
|
||||
}
|
||||
return -RT_ERROR;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief This function copy hash context
|
||||
*
|
||||
* @param des The destination hash context
|
||||
* @param src The hash context to be copy
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_hash_cpy(struct rt_hwcrypto_ctx *des, const struct rt_hwcrypto_ctx *src)
|
||||
{
|
||||
return rt_hwcrypto_ctx_cpy(des, src);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Reset hash context
|
||||
*
|
||||
* @param ctx Hash context
|
||||
*/
|
||||
void rt_hwcrypto_hash_reset(struct rt_hwcrypto_ctx *ctx)
|
||||
{
|
||||
rt_hwcrypto_ctx_reset(ctx);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Setting hash context type
|
||||
*
|
||||
* @param ctx Hash context
|
||||
* @param type Types of settings
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_hash_set_type(struct rt_hwcrypto_ctx *ctx, hwcrypto_type type)
|
||||
{
|
||||
return rt_hwcrypto_set_type(ctx, type);
|
||||
}
|
||||
@@ -0,0 +1,110 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2019-04-23 tyx the first version
|
||||
*/
|
||||
|
||||
#ifndef __HW_HASH_H__
|
||||
#define __HW_HASH_H__
|
||||
|
||||
#include <hwcrypto.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
struct hwcrypto_hash;
|
||||
|
||||
struct hwcrypto_hash_ops
|
||||
{
|
||||
rt_err_t (*update)(struct hwcrypto_hash *hash_ctx,
|
||||
const rt_uint8_t *in, rt_size_t length); /**< Processing a packet of data */
|
||||
rt_err_t (*finish)(struct hwcrypto_hash *hash_ctx,
|
||||
rt_uint8_t *out, rt_size_t length); /**< Get the final hash value */
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief hash context. Hardware driver usage
|
||||
*/
|
||||
struct hwcrypto_hash
|
||||
{
|
||||
struct rt_hwcrypto_ctx parent; /**< Inheritance from hardware crypto context */
|
||||
const struct hwcrypto_hash_ops *ops; /**< !! Hardware initializes this value when creating context !! */
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Creating hash Context
|
||||
*
|
||||
* @param device Hardware crypto device
|
||||
* @param type Type of hash context
|
||||
*
|
||||
* @return Hash context
|
||||
*/
|
||||
struct rt_hwcrypto_ctx *rt_hwcrypto_hash_create(struct rt_hwcrypto_device *device,
|
||||
hwcrypto_type type);
|
||||
|
||||
/**
|
||||
* @brief Destroy hash Context
|
||||
*
|
||||
* @param ctx Hash context
|
||||
*/
|
||||
void rt_hwcrypto_hash_destroy(struct rt_hwcrypto_ctx *ctx);
|
||||
|
||||
/**
|
||||
* @brief Get the final hash value
|
||||
*
|
||||
* @param ctx Hash context
|
||||
* @param output Hash value buffer
|
||||
* @param length Hash value buffer length
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_hash_finish(struct rt_hwcrypto_ctx *ctx, rt_uint8_t *output, rt_size_t length);
|
||||
|
||||
/**
|
||||
* @brief Processing a packet of data
|
||||
*
|
||||
* @param ctx Hash context
|
||||
* @param input Data buffer to be Processed
|
||||
* @param length Data Buffer length
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_hash_update(struct rt_hwcrypto_ctx *ctx, const rt_uint8_t *input, rt_size_t length);
|
||||
|
||||
/**
|
||||
* @brief This function copy hash context
|
||||
*
|
||||
* @param des The destination hash context
|
||||
* @param src The hash context to be copy
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_hash_cpy(struct rt_hwcrypto_ctx *des, const struct rt_hwcrypto_ctx *src);
|
||||
|
||||
/**
|
||||
* @brief Reset hash context
|
||||
*
|
||||
* @param ctx Hash context
|
||||
*/
|
||||
void rt_hwcrypto_hash_reset(struct rt_hwcrypto_ctx *ctx);
|
||||
|
||||
/**
|
||||
* @brief Setting hash context type
|
||||
*
|
||||
* @param ctx Hash context
|
||||
* @param type Types of settings
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_hash_set_type(struct rt_hwcrypto_ctx *ctx, hwcrypto_type type);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,110 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2019-04-25 tyx the first version
|
||||
*/
|
||||
|
||||
#include <rtthread.h>
|
||||
#include <rtdevice.h>
|
||||
#include <hw_rng.h>
|
||||
|
||||
/* Used to save default RNG Context */
|
||||
static struct rt_hwcrypto_ctx *ctx_default;
|
||||
|
||||
/**
|
||||
* @brief Creating RNG Context
|
||||
*
|
||||
* @param device Hardware crypto device
|
||||
*
|
||||
* @return RNG context
|
||||
*/
|
||||
struct rt_hwcrypto_ctx *rt_hwcrypto_rng_create(struct rt_hwcrypto_device *device)
|
||||
{
|
||||
struct rt_hwcrypto_ctx *ctx;
|
||||
|
||||
ctx = rt_hwcrypto_ctx_create(device, HWCRYPTO_TYPE_RNG, sizeof(struct hwcrypto_rng));
|
||||
return ctx;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Destroy RNG Context
|
||||
*
|
||||
* @param ctx RNG context
|
||||
*/
|
||||
void rt_hwcrypto_rng_destroy(struct rt_hwcrypto_ctx *ctx)
|
||||
{
|
||||
/* Destroy the defaule RNG Context ? */
|
||||
if (ctx == ctx_default)
|
||||
{
|
||||
ctx_default = RT_NULL;
|
||||
}
|
||||
rt_hwcrypto_ctx_destroy(ctx);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Setting RNG default devices
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_rng_default(struct rt_hwcrypto_device *device)
|
||||
{
|
||||
struct rt_hwcrypto_ctx *tmp_ctx;
|
||||
|
||||
/* if device is null, destroy default RNG Context */
|
||||
if (device == RT_NULL)
|
||||
{
|
||||
if (ctx_default)
|
||||
{
|
||||
rt_hwcrypto_rng_destroy(ctx_default);
|
||||
ctx_default = RT_NULL;
|
||||
}
|
||||
return RT_EOK;
|
||||
}
|
||||
/* Try create RNG Context */
|
||||
tmp_ctx = rt_hwcrypto_rng_create(device);
|
||||
if (tmp_ctx == RT_NULL)
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
/* create RNG Context success, update default RNG Context */
|
||||
rt_hwcrypto_rng_destroy(ctx_default);
|
||||
ctx_default = tmp_ctx;
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Getting Random Numbers from RNG Context
|
||||
*
|
||||
* @param ctx RNG context
|
||||
*
|
||||
* @return Random number
|
||||
*/
|
||||
rt_uint32_t rt_hwcrypto_rng_update_ctx(struct rt_hwcrypto_ctx *ctx)
|
||||
{
|
||||
if (ctx)
|
||||
{
|
||||
return ((struct hwcrypto_rng *)ctx)->ops->update((struct hwcrypto_rng *)ctx);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Return a random number
|
||||
*
|
||||
* @return Random number
|
||||
*/
|
||||
rt_uint32_t rt_hwcrypto_rng_update(void)
|
||||
{
|
||||
/* Default device does not exist ? */
|
||||
if (ctx_default == RT_NULL)
|
||||
{
|
||||
/* try create Context from default device */
|
||||
rt_hwcrypto_rng_default(rt_hwcrypto_dev_default());
|
||||
}
|
||||
return rt_hwcrypto_rng_update_ctx(ctx_default);
|
||||
}
|
||||
@@ -0,0 +1,79 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2019-04-25 tyx the first version
|
||||
*/
|
||||
|
||||
#ifndef __HW_RNG_H__
|
||||
#define __HW_RNG_H__
|
||||
|
||||
#include <hwcrypto.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
struct hwcrypto_rng;
|
||||
|
||||
struct hwcrypto_rng_ops
|
||||
{
|
||||
rt_uint32_t (*update)(struct hwcrypto_rng *ctx); /**< Return a random number */
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief random context. Hardware driver usage
|
||||
*/
|
||||
struct hwcrypto_rng
|
||||
{
|
||||
struct rt_hwcrypto_ctx parent; /**< Inheritance from hardware crypto context */
|
||||
const struct hwcrypto_rng_ops *ops; /**< !! Hardware initializes this value when creating context !! */
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Creating RNG Context
|
||||
*
|
||||
* @param device Hardware crypto device
|
||||
*
|
||||
* @return RNG context
|
||||
*/
|
||||
struct rt_hwcrypto_ctx *rt_hwcrypto_rng_create(struct rt_hwcrypto_device *device);
|
||||
|
||||
/**
|
||||
* @brief Destroy RNG Context
|
||||
*
|
||||
* @param ctx RNG context
|
||||
*/
|
||||
void rt_hwcrypto_rng_destroy(struct rt_hwcrypto_ctx *ctx);
|
||||
|
||||
/**
|
||||
* @brief Setting RNG default devices
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_rng_default(struct rt_hwcrypto_device *device);
|
||||
|
||||
/**
|
||||
* @brief Getting Random Numbers from RNG Context
|
||||
*
|
||||
* @param ctx RNG context
|
||||
*
|
||||
* @return Random number
|
||||
*/
|
||||
rt_uint32_t rt_hwcrypto_rng_update_ctx(struct rt_hwcrypto_ctx *ctx);
|
||||
|
||||
/**
|
||||
* @brief Return a random number
|
||||
*
|
||||
* @return Random number
|
||||
*/
|
||||
rt_uint32_t rt_hwcrypto_rng_update(void);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,276 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2019-04-25 tyx the first version
|
||||
*/
|
||||
|
||||
#include <rtthread.h>
|
||||
#include <rtdevice.h>
|
||||
#include <hw_symmetric.h>
|
||||
|
||||
/**
|
||||
* @brief Creating Symmetric Encryption and Decryption Context
|
||||
*
|
||||
* @param device Hardware crypto device
|
||||
* @param type Type of symmetric crypto context
|
||||
*
|
||||
* @return Symmetric crypto context
|
||||
*/
|
||||
struct rt_hwcrypto_ctx *rt_hwcrypto_symmetric_create(struct rt_hwcrypto_device *device, hwcrypto_type type)
|
||||
{
|
||||
struct rt_hwcrypto_ctx *ctx;
|
||||
|
||||
ctx = rt_hwcrypto_ctx_create(device, type, sizeof(struct hwcrypto_symmetric));
|
||||
return ctx;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Destroy Symmetric Encryption and Decryption Context
|
||||
*
|
||||
* @param ctx Symmetric crypto context
|
||||
*/
|
||||
void rt_hwcrypto_symmetric_destroy(struct rt_hwcrypto_ctx *ctx)
|
||||
{
|
||||
rt_hwcrypto_ctx_destroy(ctx);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief This function performs a symmetric encryption or decryption operation
|
||||
*
|
||||
* @param ctx Symmetric crypto context
|
||||
* @param mode Operation mode. HWCRYPTO_MODE_ENCRYPT or HWCRYPTO_MODE_DECRYPT
|
||||
* @param length The length of the input data in Bytes. This must be a multiple of the block size
|
||||
* @param in The buffer holding the input data
|
||||
* @param out The buffer holding the output data
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_symmetric_crypt(struct rt_hwcrypto_ctx *ctx, hwcrypto_mode mode, rt_size_t length, const rt_uint8_t *in, rt_uint8_t *out)
|
||||
{
|
||||
struct hwcrypto_symmetric *symmetric_ctx;
|
||||
struct hwcrypto_symmetric_info symmetric_info;
|
||||
rt_err_t err;
|
||||
|
||||
if (ctx == RT_NULL)
|
||||
{
|
||||
return -RT_EINVAL;
|
||||
}
|
||||
symmetric_ctx = (struct hwcrypto_symmetric *)ctx;
|
||||
if (symmetric_ctx->ops->crypt == RT_NULL)
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
if (mode != HWCRYPTO_MODE_ENCRYPT && mode != HWCRYPTO_MODE_DECRYPT)
|
||||
{
|
||||
return -RT_EINVAL;
|
||||
}
|
||||
|
||||
/* Input information packaging */
|
||||
symmetric_info.mode = mode;
|
||||
symmetric_info.in = in;
|
||||
symmetric_info.out = out;
|
||||
symmetric_info.length = length;
|
||||
|
||||
/* Calling Hardware Encryption and Decryption Function */
|
||||
err = symmetric_ctx->ops->crypt(symmetric_ctx, &symmetric_info);
|
||||
|
||||
/* clean up flags */
|
||||
symmetric_ctx->flags &= ~(SYMMTRIC_MODIFY_KEY | SYMMTRIC_MODIFY_IV | SYMMTRIC_MODIFY_IVOFF);
|
||||
return err;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set Symmetric Encryption and Decryption Key
|
||||
*
|
||||
* @param ctx Symmetric crypto context
|
||||
* @param key The crypto key
|
||||
* @param bitlen The crypto key bit length
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_symmetric_setkey(struct rt_hwcrypto_ctx *ctx, const rt_uint8_t *key, rt_uint32_t bitlen)
|
||||
{
|
||||
struct hwcrypto_symmetric *symmetric_ctx;
|
||||
|
||||
if (ctx && bitlen <= RT_HWCRYPTO_KEYBIT_MAX_SIZE)
|
||||
{
|
||||
symmetric_ctx = (struct hwcrypto_symmetric *)ctx;
|
||||
rt_memcpy(symmetric_ctx->key, key, bitlen >> 3);
|
||||
/* Record key length */
|
||||
symmetric_ctx->key_bitlen = bitlen;
|
||||
/* Key change flag set up */
|
||||
symmetric_ctx->flags |= SYMMTRIC_MODIFY_KEY;
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
return -RT_EINVAL;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get Symmetric Encryption and Decryption Key
|
||||
*
|
||||
* @param ctx Symmetric crypto context
|
||||
* @param key The crypto key buffer
|
||||
* @param bitlen The crypto key bit length
|
||||
*
|
||||
* @return Key length of copy
|
||||
*/
|
||||
int rt_hwcrypto_symmetric_getkey(struct rt_hwcrypto_ctx *ctx, rt_uint8_t *key, rt_uint32_t bitlen)
|
||||
{
|
||||
struct hwcrypto_symmetric *symmetric_ctx = (struct hwcrypto_symmetric *)ctx;
|
||||
|
||||
if (ctx && bitlen >= symmetric_ctx->key_bitlen)
|
||||
{
|
||||
rt_memcpy(key, symmetric_ctx->key, symmetric_ctx->key_bitlen >> 3);
|
||||
return symmetric_ctx->key_bitlen;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set Symmetric Encryption and Decryption initialization vector
|
||||
*
|
||||
* @param ctx Symmetric crypto context
|
||||
* @param iv The crypto initialization vector
|
||||
* @param len The crypto initialization vector length
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_symmetric_setiv(struct rt_hwcrypto_ctx *ctx, const rt_uint8_t *iv, rt_size_t len)
|
||||
{
|
||||
struct hwcrypto_symmetric *symmetric_ctx;
|
||||
|
||||
if (ctx && len <= RT_HWCRYPTO_IV_MAX_SIZE)
|
||||
{
|
||||
symmetric_ctx = (struct hwcrypto_symmetric *)ctx;
|
||||
rt_memcpy(symmetric_ctx->iv, iv, len);
|
||||
symmetric_ctx->iv_len = len;
|
||||
/* IV change flag set up */
|
||||
symmetric_ctx->flags |= SYMMTRIC_MODIFY_IV;
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
return -RT_EINVAL;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get Symmetric Encryption and Decryption initialization vector
|
||||
*
|
||||
* @param ctx Symmetric crypto context
|
||||
* @param iv The crypto initialization vector buffer
|
||||
* @param len The crypto initialization vector buffer length
|
||||
*
|
||||
* @return IV length of copy
|
||||
*/
|
||||
int rt_hwcrypto_symmetric_getiv(struct rt_hwcrypto_ctx *ctx, rt_uint8_t *iv, rt_size_t len)
|
||||
{
|
||||
struct hwcrypto_symmetric *symmetric_ctx = (struct hwcrypto_symmetric *)ctx;;
|
||||
|
||||
if (ctx && len >= symmetric_ctx->iv_len)
|
||||
{
|
||||
rt_memcpy(iv, symmetric_ctx->iv, symmetric_ctx->iv_len);
|
||||
return symmetric_ctx->iv_len;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set offset in initialization vector
|
||||
*
|
||||
* @param ctx Symmetric crypto context
|
||||
* @param iv_off The offset in IV
|
||||
*/
|
||||
void rt_hwcrypto_symmetric_set_ivoff(struct rt_hwcrypto_ctx *ctx, rt_int32_t iv_off)
|
||||
{
|
||||
if (ctx)
|
||||
{
|
||||
((struct hwcrypto_symmetric *)ctx)->iv_off = iv_off;
|
||||
/* iv_off change flag set up */
|
||||
((struct hwcrypto_symmetric *)ctx)->flags |= SYMMTRIC_MODIFY_IVOFF;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get offset in initialization vector
|
||||
*
|
||||
* @param ctx Symmetric crypto context
|
||||
* @param iv_off It must point to a valid memory
|
||||
*/
|
||||
void rt_hwcrypto_symmetric_get_ivoff(struct rt_hwcrypto_ctx *ctx, rt_int32_t *iv_off)
|
||||
{
|
||||
if (ctx && iv_off)
|
||||
{
|
||||
*iv_off = ((struct hwcrypto_symmetric *)ctx)->iv_off;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief This function copy symmetric crypto context
|
||||
*
|
||||
* @param des The destination symmetric crypto context
|
||||
* @param src The symmetric crypto context to be copy
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_symmetric_cpy(struct rt_hwcrypto_ctx *des, const struct rt_hwcrypto_ctx *src)
|
||||
{
|
||||
struct hwcrypto_symmetric *symmetric_des = (struct hwcrypto_symmetric *)des;
|
||||
struct hwcrypto_symmetric *symmetric_src = (struct hwcrypto_symmetric *)src;
|
||||
|
||||
if (des != RT_NULL && src != RT_NULL)
|
||||
{
|
||||
/* Copy Symmetric Encryption and Decryption Context Information */
|
||||
symmetric_des->flags = symmetric_src->flags ;
|
||||
symmetric_des->iv_len = symmetric_src->iv_len ;
|
||||
symmetric_des->iv_off = symmetric_src->iv_off ;
|
||||
symmetric_des->key_bitlen = symmetric_src->key_bitlen;
|
||||
rt_memcpy(symmetric_des->iv, symmetric_src->iv, symmetric_src->iv_len);
|
||||
rt_memcpy(symmetric_des->key, symmetric_src->key, symmetric_src->key_bitlen >> 3);
|
||||
|
||||
/* Hardware context copy */
|
||||
return rt_hwcrypto_ctx_cpy(des, src);
|
||||
}
|
||||
return -RT_EINVAL;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Reset symmetric crypto context
|
||||
*
|
||||
* @param ctx Symmetric crypto context
|
||||
*/
|
||||
void rt_hwcrypto_symmetric_reset(struct rt_hwcrypto_ctx *ctx)
|
||||
{
|
||||
struct hwcrypto_symmetric *symmetric_ctx = (struct hwcrypto_symmetric *)ctx;
|
||||
if (ctx != RT_NULL)
|
||||
{
|
||||
/* Copy Symmetric Encryption and Decryption Context Information */
|
||||
symmetric_ctx->flags = 0x00;
|
||||
symmetric_ctx->iv_len = 0x00;
|
||||
symmetric_ctx->iv_off = 0x00;
|
||||
symmetric_ctx->key_bitlen = 0x00;
|
||||
rt_memset(symmetric_ctx->iv, 0, RT_HWCRYPTO_IV_MAX_SIZE);
|
||||
rt_memset(symmetric_ctx->key, 0, RT_HWCRYPTO_KEYBIT_MAX_SIZE >> 3);
|
||||
|
||||
/* Hardware context reset */
|
||||
rt_hwcrypto_ctx_reset(ctx);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Setting symmetric crypto context type
|
||||
*
|
||||
* @param ctx Symmetric crypto context
|
||||
* @param type Types of settings
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_symmetric_set_type(struct rt_hwcrypto_ctx *ctx, hwcrypto_type type)
|
||||
{
|
||||
return rt_hwcrypto_set_type(ctx, type);
|
||||
}
|
||||
@@ -0,0 +1,189 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2019-04-25 tyx the first version
|
||||
*/
|
||||
|
||||
#ifndef __HW_SYMMETRIC_H__
|
||||
#define __HW_SYMMETRIC_H__
|
||||
|
||||
#include <hwcrypto.h>
|
||||
|
||||
#ifndef RT_HWCRYPTO_IV_MAX_SIZE
|
||||
#define RT_HWCRYPTO_IV_MAX_SIZE (16)
|
||||
#endif
|
||||
#ifndef RT_HWCRYPTO_KEYBIT_MAX_SIZE
|
||||
#define RT_HWCRYPTO_KEYBIT_MAX_SIZE (256)
|
||||
#endif
|
||||
|
||||
#define SYMMTRIC_MODIFY_KEY (0x1 << 0)
|
||||
#define SYMMTRIC_MODIFY_IV (0x1 << 1)
|
||||
#define SYMMTRIC_MODIFY_IVOFF (0x1 << 2)
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
struct hwcrypto_symmetric;
|
||||
struct hwcrypto_symmetric_info;
|
||||
|
||||
struct hwcrypto_symmetric_ops
|
||||
{
|
||||
rt_err_t (*crypt)(struct hwcrypto_symmetric *symmetric_ctx,
|
||||
struct hwcrypto_symmetric_info *symmetric_info); /**< Hardware Symmetric Encryption and Decryption Callback */
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Hardware driver usage, including input and output information
|
||||
*/
|
||||
struct hwcrypto_symmetric_info
|
||||
{
|
||||
hwcrypto_mode mode; /**< crypto mode. HWCRYPTO_MODE_ENCRYPT or HWCRYPTO_MODE_DECRYPT */
|
||||
const rt_uint8_t *in; /**< Input data */
|
||||
rt_uint8_t *out; /**< Output data will be written */
|
||||
rt_size_t length; /**< The length of the input data in Bytes. It's a multiple of block size. */
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Symmetric crypto context. Hardware driver usage
|
||||
*/
|
||||
struct hwcrypto_symmetric
|
||||
{
|
||||
struct rt_hwcrypto_ctx parent; /**< Inheritance from hardware crypto context */
|
||||
rt_uint32_t flags; /**< key or iv or ivoff has been changed. The flag will be set up */
|
||||
rt_int32_t iv_len; /**< initialization vector effective length */
|
||||
rt_int32_t iv_off; /**< The offset in IV */
|
||||
rt_uint8_t iv[RT_HWCRYPTO_IV_MAX_SIZE]; /**< The initialization vector */
|
||||
rt_uint8_t key[RT_HWCRYPTO_KEYBIT_MAX_SIZE >> 3]; /**< The crypto key */
|
||||
rt_int32_t key_bitlen; /**< The crypto key bit length */
|
||||
const struct hwcrypto_symmetric_ops *ops; /**< !! Hardware initializes this value when creating context !! */
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Creating Symmetric Encryption and Decryption Context
|
||||
*
|
||||
* @param device Hardware crypto device
|
||||
* @param type Type of symmetric crypto context
|
||||
*
|
||||
* @return Symmetric crypto context
|
||||
*/
|
||||
struct rt_hwcrypto_ctx *rt_hwcrypto_symmetric_create(struct rt_hwcrypto_device *device,
|
||||
hwcrypto_type type);
|
||||
|
||||
/**
|
||||
* @brief Destroy Symmetric Encryption and Decryption Context
|
||||
*
|
||||
* @param ctx Symmetric crypto context
|
||||
*/
|
||||
void rt_hwcrypto_symmetric_destroy(struct rt_hwcrypto_ctx *ctx);
|
||||
|
||||
/**
|
||||
* @brief This function performs a symmetric encryption or decryption operation
|
||||
*
|
||||
* @param ctx Symmetric crypto context
|
||||
* @param mode Operation mode. HWCRYPTO_MODE_ENCRYPT or HWCRYPTO_MODE_DECRYPT
|
||||
* @param length The length of the input data in Bytes. This must be a multiple of the block size
|
||||
* @param in The buffer holding the input data
|
||||
* @param out The buffer holding the output data
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_symmetric_crypt(struct rt_hwcrypto_ctx *ctx, hwcrypto_mode mode,
|
||||
rt_size_t length, const rt_uint8_t *in, rt_uint8_t *out);
|
||||
|
||||
/**
|
||||
* @brief Set Symmetric Encryption and Decryption Key
|
||||
*
|
||||
* @param ctx Symmetric crypto context
|
||||
* @param key The crypto key
|
||||
* @param bitlen The crypto key bit length
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_symmetric_setkey(struct rt_hwcrypto_ctx *ctx, const rt_uint8_t *key, rt_uint32_t bitlen);
|
||||
|
||||
/**
|
||||
* @brief Get Symmetric Encryption and Decryption Key
|
||||
*
|
||||
* @param ctx Symmetric crypto context
|
||||
* @param key The crypto key buffer
|
||||
* @param bitlen The crypto key bit length
|
||||
*
|
||||
* @return Key length of copy
|
||||
*/
|
||||
int rt_hwcrypto_symmetric_getkey(struct rt_hwcrypto_ctx *ctx, rt_uint8_t *key, rt_uint32_t bitlen);
|
||||
|
||||
/**
|
||||
* @brief Set Symmetric Encryption and Decryption initialization vector
|
||||
*
|
||||
* @param ctx Symmetric crypto context
|
||||
* @param iv The crypto initialization vector
|
||||
* @param len The crypto initialization vector length
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_symmetric_setiv(struct rt_hwcrypto_ctx *ctx, const rt_uint8_t *iv, rt_size_t len);
|
||||
|
||||
/**
|
||||
* @brief Get Symmetric Encryption and Decryption initialization vector
|
||||
*
|
||||
* @param ctx Symmetric crypto context
|
||||
* @param iv The crypto initialization vector buffer
|
||||
* @param len The crypto initialization vector buffer length
|
||||
*
|
||||
* @return IV length of copy
|
||||
*/
|
||||
int rt_hwcrypto_symmetric_getiv(struct rt_hwcrypto_ctx *ctx, rt_uint8_t *iv, rt_size_t len);
|
||||
|
||||
/**
|
||||
* @brief Set offset in initialization vector
|
||||
*
|
||||
* @param ctx Symmetric crypto context
|
||||
* @param iv_off The offset in IV
|
||||
*/
|
||||
void rt_hwcrypto_symmetric_set_ivoff(struct rt_hwcrypto_ctx *ctx, rt_int32_t iv_off);
|
||||
|
||||
/**
|
||||
* @brief Get offset in initialization vector
|
||||
*
|
||||
* @param ctx Symmetric crypto context
|
||||
* @param iv_off It must point to a valid memory
|
||||
*/
|
||||
void rt_hwcrypto_symmetric_get_ivoff(struct rt_hwcrypto_ctx *ctx, rt_int32_t *iv_off);
|
||||
|
||||
/**
|
||||
* @brief This function copy symmetric crypto context
|
||||
*
|
||||
* @param des The destination symmetric crypto context
|
||||
* @param src The symmetric crypto context to be copy
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_symmetric_cpy(struct rt_hwcrypto_ctx *des, const struct rt_hwcrypto_ctx *src);
|
||||
|
||||
/**
|
||||
* @brief Reset symmetric crypto context
|
||||
*
|
||||
* @param ctx Symmetric crypto context
|
||||
*/
|
||||
void rt_hwcrypto_symmetric_reset(struct rt_hwcrypto_ctx *ctx);
|
||||
|
||||
/**
|
||||
* @brief Setting symmetric crypto context type
|
||||
*
|
||||
* @param ctx Symmetric crypto context
|
||||
* @param type Types of settings
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_symmetric_set_type(struct rt_hwcrypto_ctx *ctx, hwcrypto_type type);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,255 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2019-04-23 tyx the first version
|
||||
*/
|
||||
|
||||
#include <rtthread.h>
|
||||
#include <rtdevice.h>
|
||||
#include <hwcrypto.h>
|
||||
|
||||
/**
|
||||
* @brief Setting context type (Direct calls are not recommended)
|
||||
*
|
||||
* @param ctx Crypto context
|
||||
* @param type Types of settings
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_set_type(struct rt_hwcrypto_ctx *ctx, hwcrypto_type type)
|
||||
{
|
||||
if (ctx)
|
||||
{
|
||||
/* Is it the same category? */
|
||||
if ((ctx->type & HWCRYPTO_MAIN_TYPE_MASK) == (type & HWCRYPTO_MAIN_TYPE_MASK))
|
||||
{
|
||||
ctx->type = type;
|
||||
return RT_EOK;
|
||||
}
|
||||
/* Context is empty type */
|
||||
else if (ctx->type == HWCRYPTO_TYPE_NULL)
|
||||
{
|
||||
ctx->type = type;
|
||||
return RT_EOK;
|
||||
}
|
||||
else
|
||||
{
|
||||
return -RT_ERROR;
|
||||
}
|
||||
}
|
||||
return -RT_EINVAL;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Reset context type (Direct calls are not recommended)
|
||||
*
|
||||
* @param ctx Crypto context
|
||||
*
|
||||
*/
|
||||
void rt_hwcrypto_ctx_reset(struct rt_hwcrypto_ctx *ctx)
|
||||
{
|
||||
if (ctx && ctx->device->ops->reset)
|
||||
{
|
||||
ctx->device->ops->reset(ctx);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Init crypto context
|
||||
*
|
||||
* @param ctx The context to initialize
|
||||
* @param device Hardware crypto device
|
||||
* @param type Type of context
|
||||
* @param obj_size Size of context object
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_ctx_init(struct rt_hwcrypto_ctx *ctx, struct rt_hwcrypto_device *device, hwcrypto_type type)
|
||||
{
|
||||
rt_err_t err;
|
||||
|
||||
/* Setting context type */
|
||||
rt_hwcrypto_set_type(ctx, type);
|
||||
ctx->device = device;
|
||||
/* Create hardware context */
|
||||
err = ctx->device->ops->create(ctx);
|
||||
if (err != RT_EOK)
|
||||
{
|
||||
return err;
|
||||
}
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Create crypto context
|
||||
*
|
||||
* @param device Hardware crypto device
|
||||
* @param type Type of context
|
||||
* @param obj_size Size of context object
|
||||
*
|
||||
* @return Crypto context
|
||||
*/
|
||||
struct rt_hwcrypto_ctx *rt_hwcrypto_ctx_create(struct rt_hwcrypto_device *device, hwcrypto_type type, rt_uint32_t obj_size)
|
||||
{
|
||||
struct rt_hwcrypto_ctx *ctx;
|
||||
rt_err_t err;
|
||||
|
||||
/* Parameter checking */
|
||||
if (device == RT_NULL || obj_size < sizeof(struct rt_hwcrypto_ctx))
|
||||
{
|
||||
return RT_NULL;
|
||||
}
|
||||
ctx = rt_malloc(obj_size);
|
||||
if (ctx == RT_NULL)
|
||||
{
|
||||
return ctx;
|
||||
}
|
||||
rt_memset(ctx, 0, obj_size);
|
||||
/* Init context */
|
||||
err = rt_hwcrypto_ctx_init(ctx, device, type);
|
||||
if (err != RT_EOK)
|
||||
{
|
||||
rt_free(ctx);
|
||||
ctx = RT_NULL;
|
||||
}
|
||||
return ctx;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Destroy crypto context
|
||||
*
|
||||
* @param device Crypto context
|
||||
*/
|
||||
void rt_hwcrypto_ctx_destroy(struct rt_hwcrypto_ctx *ctx)
|
||||
{
|
||||
if (ctx == RT_NULL)
|
||||
{
|
||||
return;
|
||||
}
|
||||
/* Destroy hardware context */
|
||||
if (ctx->device->ops->destroy)
|
||||
{
|
||||
ctx->device->ops->destroy(ctx);
|
||||
}
|
||||
/* Free the resources */
|
||||
rt_free(ctx);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Copy crypto context
|
||||
*
|
||||
* @param des The destination context
|
||||
* @param src The context to be copy
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_ctx_cpy(struct rt_hwcrypto_ctx *des, const struct rt_hwcrypto_ctx *src)
|
||||
{
|
||||
if (des == RT_NULL || src == RT_NULL)
|
||||
{
|
||||
return -RT_EINVAL;
|
||||
}
|
||||
|
||||
/* The equipment is different or of different types and cannot be copied */
|
||||
if (des->device != src->device ||
|
||||
(des->type & HWCRYPTO_MAIN_TYPE_MASK) != (src->type & HWCRYPTO_MAIN_TYPE_MASK))
|
||||
{
|
||||
return -RT_EINVAL;
|
||||
}
|
||||
des->type = src->type;
|
||||
/* Calling Hardware Context Copy Function */
|
||||
return src->device->ops->copy(des, src);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the default hardware crypto device
|
||||
*
|
||||
* @return Hardware crypto device
|
||||
*
|
||||
*/
|
||||
struct rt_hwcrypto_device *rt_hwcrypto_dev_default(void)
|
||||
{
|
||||
static struct rt_hwcrypto_device *hwcrypto_dev;
|
||||
|
||||
/* If there is a default device, return the device */
|
||||
if (hwcrypto_dev)
|
||||
{
|
||||
return hwcrypto_dev;
|
||||
}
|
||||
/* Find by default device name */
|
||||
hwcrypto_dev = (struct rt_hwcrypto_device *)rt_device_find(RT_HWCRYPTO_DEFAULT_NAME);
|
||||
return hwcrypto_dev;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the unique ID of the device
|
||||
*
|
||||
* @param device Device object
|
||||
*
|
||||
* @return Device unique ID
|
||||
*/
|
||||
rt_uint64_t rt_hwcrypto_id(struct rt_hwcrypto_device *device)
|
||||
{
|
||||
if (device)
|
||||
{
|
||||
return device->id;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef RT_USING_DEVICE_OPS
|
||||
const static struct rt_device_ops hwcrypto_ops =
|
||||
{
|
||||
RT_NULL,
|
||||
RT_NULL,
|
||||
RT_NULL,
|
||||
RT_NULL,
|
||||
RT_NULL,
|
||||
RT_NULL
|
||||
};
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Register hardware crypto device
|
||||
*
|
||||
* @param device Hardware crypto device
|
||||
* @param name Name of device
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_register(struct rt_hwcrypto_device *device, const char *name)
|
||||
{
|
||||
rt_err_t err;
|
||||
|
||||
RT_ASSERT(device != RT_NULL);
|
||||
RT_ASSERT(name != RT_NULL);
|
||||
RT_ASSERT(device->ops != RT_NULL);
|
||||
RT_ASSERT(device->ops->create != RT_NULL);
|
||||
RT_ASSERT(device->ops->destroy != RT_NULL);
|
||||
RT_ASSERT(device->ops->copy != RT_NULL);
|
||||
RT_ASSERT(device->ops->reset != RT_NULL);
|
||||
|
||||
rt_memset(&device->parent, 0, sizeof(struct rt_device));
|
||||
#ifdef RT_USING_DEVICE_OPS
|
||||
device->parent.ops = &hwcrypto_ops;
|
||||
#else
|
||||
device->parent.init = RT_NULL;
|
||||
device->parent.open = RT_NULL;
|
||||
device->parent.close = RT_NULL;
|
||||
device->parent.read = RT_NULL;
|
||||
device->parent.write = RT_NULL;
|
||||
device->parent.control = RT_NULL;
|
||||
#endif
|
||||
|
||||
device->parent.user_data = RT_NULL;
|
||||
device->parent.type = RT_Device_Class_Miscellaneous;
|
||||
|
||||
/* Register device */
|
||||
err = rt_device_register(&device->parent, name, RT_DEVICE_FLAG_RDWR);
|
||||
|
||||
return err;
|
||||
}
|
||||
@@ -0,0 +1,193 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2019-04-23 tyx the first version
|
||||
*/
|
||||
|
||||
#ifndef __HWCRYPTO_H__
|
||||
#define __HWCRYPTO_H__
|
||||
|
||||
#include <rtthread.h>
|
||||
|
||||
#ifndef RT_HWCRYPTO_DEFAULT_NAME
|
||||
#define RT_HWCRYPTO_DEFAULT_NAME ("hwcryto")
|
||||
#endif
|
||||
|
||||
#define HWCRYPTO_MAIN_TYPE_MASK (0xffffUL << 16)
|
||||
#define HWCRYPTO_SUB_TYPE_MASK (0xffUL << 8)
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef enum
|
||||
{
|
||||
HWCRYPTO_TYPE_NULL = 0x00000000,
|
||||
|
||||
/* Main Type */
|
||||
/* symmetric Type */
|
||||
HWCRYPTO_TYPE_HEAD = __LINE__,
|
||||
HWCRYPTO_TYPE_AES = ((__LINE__ - HWCRYPTO_TYPE_HEAD) & 0xffff) << 16, /**< AES */
|
||||
HWCRYPTO_TYPE_DES = ((__LINE__ - HWCRYPTO_TYPE_HEAD) & 0xffff) << 16, /**< DES */
|
||||
HWCRYPTO_TYPE_3DES = ((__LINE__ - HWCRYPTO_TYPE_HEAD) & 0xffff) << 16, /**< 3DES */
|
||||
HWCRYPTO_TYPE_RC4 = ((__LINE__ - HWCRYPTO_TYPE_HEAD) & 0xffff) << 16, /**< RC4 */
|
||||
HWCRYPTO_TYPE_GCM = ((__LINE__ - HWCRYPTO_TYPE_HEAD) & 0xffff) << 16, /**< GCM */
|
||||
/* HASH Type */
|
||||
HWCRYPTO_TYPE_MD5 = ((__LINE__ - HWCRYPTO_TYPE_HEAD) & 0xffff) << 16, /**< MD5 */
|
||||
HWCRYPTO_TYPE_SHA1 = ((__LINE__ - HWCRYPTO_TYPE_HEAD) & 0xffff) << 16, /**< SHA1 */
|
||||
HWCRYPTO_TYPE_SHA2 = ((__LINE__ - HWCRYPTO_TYPE_HEAD) & 0xffff) << 16, /**< SHA2 */
|
||||
/* Other Type */
|
||||
HWCRYPTO_TYPE_RNG = ((__LINE__ - HWCRYPTO_TYPE_HEAD) & 0xffff) << 16, /**< RNG */
|
||||
HWCRYPTO_TYPE_CRC = ((__LINE__ - HWCRYPTO_TYPE_HEAD) & 0xffff) << 16, /**< CRC */
|
||||
HWCRYPTO_TYPE_BIGNUM = ((__LINE__ - HWCRYPTO_TYPE_HEAD) & 0xffff) << 16, /**< BIGNUM */
|
||||
|
||||
/* AES Subtype */
|
||||
HWCRYPTO_TYPE_AES_ECB = HWCRYPTO_TYPE_AES | (0x01 << 8),
|
||||
HWCRYPTO_TYPE_AES_CBC = HWCRYPTO_TYPE_AES | (0x02 << 8),
|
||||
HWCRYPTO_TYPE_AES_CFB = HWCRYPTO_TYPE_AES | (0x03 << 8),
|
||||
HWCRYPTO_TYPE_AES_CTR = HWCRYPTO_TYPE_AES | (0x04 << 8),
|
||||
HWCRYPTO_TYPE_AES_OFB = HWCRYPTO_TYPE_AES | (0x05 << 8),
|
||||
|
||||
/* DES Subtype */
|
||||
HWCRYPTO_TYPE_DES_ECB = HWCRYPTO_TYPE_DES | (0x01 << 8),
|
||||
HWCRYPTO_TYPE_DES_CBC = HWCRYPTO_TYPE_DES | (0x02 << 8),
|
||||
|
||||
/* 3DES Subtype */
|
||||
HWCRYPTO_TYPE_3DES_ECB = HWCRYPTO_TYPE_3DES | (0x01 << 8),
|
||||
HWCRYPTO_TYPE_3DES_CBC = HWCRYPTO_TYPE_3DES | (0x02 << 8),
|
||||
|
||||
/* SHA2 Subtype */
|
||||
HWCRYPTO_TYPE_SHA224 = HWCRYPTO_TYPE_SHA2 | (0x01 << 8),
|
||||
HWCRYPTO_TYPE_SHA256 = HWCRYPTO_TYPE_SHA2 | (0x02 << 8),
|
||||
HWCRYPTO_TYPE_SHA384 = HWCRYPTO_TYPE_SHA2 | (0x03 << 8),
|
||||
HWCRYPTO_TYPE_SHA512 = HWCRYPTO_TYPE_SHA2 | (0x04 << 8),
|
||||
} hwcrypto_type;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
HWCRYPTO_MODE_ENCRYPT = 0x1, /**< Encryption operations */
|
||||
HWCRYPTO_MODE_DECRYPT = 0x2, /**< Decryption operations */
|
||||
HWCRYPTO_MODE_UNKNOWN = 0x7fffffff, /**< Unknown */
|
||||
} hwcrypto_mode;
|
||||
|
||||
struct rt_hwcrypto_ctx;
|
||||
|
||||
struct rt_hwcrypto_ops
|
||||
{
|
||||
rt_err_t (*create)(struct rt_hwcrypto_ctx *ctx); /**< Creating hardware context */
|
||||
void (*destroy)(struct rt_hwcrypto_ctx *ctx); /**< Delete hardware context */
|
||||
rt_err_t (*copy)(struct rt_hwcrypto_ctx *des,
|
||||
const struct rt_hwcrypto_ctx *src); /**< Cpoy hardware context */
|
||||
void (*reset)(struct rt_hwcrypto_ctx *ctx); /**< Reset hardware context */
|
||||
};
|
||||
|
||||
struct rt_hwcrypto_device
|
||||
{
|
||||
struct rt_device parent; /**< Inherited from the standard device */
|
||||
const struct rt_hwcrypto_ops *ops; /**< Hardware crypto ops */
|
||||
rt_uint64_t id; /**< Unique id */
|
||||
void *user_data; /**< Device user data */
|
||||
};
|
||||
|
||||
struct rt_hwcrypto_ctx
|
||||
{
|
||||
struct rt_hwcrypto_device *device; /**< Binding device */
|
||||
hwcrypto_type type; /**< Encryption and decryption types */
|
||||
void *contex; /**< Hardware context */
|
||||
};
|
||||
|
||||
/**
|
||||
* @brief Setting context type (Direct calls are not recommended)
|
||||
*
|
||||
* @param ctx Crypto context
|
||||
* @param type Types of settings
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_set_type(struct rt_hwcrypto_ctx *ctx, hwcrypto_type type);
|
||||
|
||||
/**
|
||||
* @brief Reset context type (Direct calls are not recommended)
|
||||
*
|
||||
* @param ctx Crypto context
|
||||
*/
|
||||
void rt_hwcrypto_ctx_reset(struct rt_hwcrypto_ctx *ctx);
|
||||
|
||||
/**
|
||||
* @brief Init crypto context (Direct calls are not recommended)
|
||||
*
|
||||
* @param ctx The context to initialize
|
||||
* @param device Hardware crypto device
|
||||
* @param type Type of context
|
||||
* @param obj_size Size of context object
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_ctx_init(struct rt_hwcrypto_ctx *ctx,
|
||||
struct rt_hwcrypto_device *device, hwcrypto_type type);
|
||||
|
||||
/**
|
||||
* @brief Create crypto context (Direct calls are not recommended)
|
||||
*
|
||||
* @param device Hardware crypto device
|
||||
* @param type Type of context
|
||||
* @param obj_size Size of context object
|
||||
*
|
||||
* @return Crypto context
|
||||
*/
|
||||
struct rt_hwcrypto_ctx *rt_hwcrypto_ctx_create(struct rt_hwcrypto_device *device,
|
||||
hwcrypto_type type, rt_uint32_t obj_size);
|
||||
|
||||
/**
|
||||
* @brief Destroy crypto context (Direct calls are not recommended)
|
||||
*
|
||||
* @param device Crypto context
|
||||
*/
|
||||
void rt_hwcrypto_ctx_destroy(struct rt_hwcrypto_ctx *ctx);
|
||||
|
||||
/**
|
||||
* @brief Copy crypto context (Direct calls are not recommended)
|
||||
*
|
||||
* @param des The destination context
|
||||
* @param src The context to be copy
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_ctx_cpy(struct rt_hwcrypto_ctx *des, const struct rt_hwcrypto_ctx *src);
|
||||
|
||||
/**
|
||||
* @brief Register hardware crypto device
|
||||
*
|
||||
* @param device Hardware crypto device
|
||||
* @param name Name of device
|
||||
*
|
||||
* @return RT_EOK on success.
|
||||
*/
|
||||
rt_err_t rt_hwcrypto_register(struct rt_hwcrypto_device *device, const char *name);
|
||||
|
||||
/**
|
||||
* @brief Get the default hardware crypto device
|
||||
*
|
||||
* @return Hardware crypto device
|
||||
*
|
||||
*/
|
||||
struct rt_hwcrypto_device *rt_hwcrypto_dev_default(void);
|
||||
|
||||
/**
|
||||
* @brief Get the unique ID of the device
|
||||
*
|
||||
* @param device Device object
|
||||
*
|
||||
* @return Device unique ID
|
||||
*/
|
||||
rt_uint64_t rt_hwcrypto_id(struct rt_hwcrypto_device *device);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,97 @@
|
||||
# 定时器设备
|
||||
|
||||
## 功能
|
||||
|
||||
* 时间测量
|
||||
* 周期或单次执行回调函数
|
||||
|
||||
## 编译
|
||||
|
||||
1. 在rtconfig.h添加 `#define RT_USING_HWTIMER`
|
||||
|
||||
## 使用流程
|
||||
|
||||
1. 以读写方式打开设备
|
||||
2. 设置超时回调函数（如果需要）
|
||||
3. 根据需要设置定时模式（单次/周期）
|
||||
4. 设置计数频率（可选）
|
||||
5. 写入超时值，定时器随即启动
|
||||
6. 停止定时器（可选）
|
||||
7. 关闭设备（如果需要）
|
||||
|
||||
应用参考 [hwtimer_test] (/examples/test/hwtimer\_test.c)
|
||||
|
||||
## 驱动编写指南
|
||||
|
||||
### 操作接口
|
||||
|
||||
```
|
||||
struct rt_hwtimer_ops
|
||||
{
|
||||
void (*init)(struct rt_hwtimer_device *timer, rt_uint32_t state);
|
||||
rt_err_t (*start)(struct rt_hwtimer_device *timer, rt_uint32_t cnt, rt_hwtimer_mode_t mode);
|
||||
void (*stop)(struct rt_hwtimer_device *timer);
|
||||
rt_uint32_t (*count_get)(struct rt_hwtimer_device *timer);
|
||||
rt_err_t (*control)(struct rt_hwtimer_device *timer, rt_uint32_t cmd, void *args);
|
||||
};
|
||||
```
|
||||
|
||||
* init - state <1 打开设备 0 关闭设备>
|
||||
* start - cnt <超时值> - mode <单次/周期>
|
||||
* stop - <停止计数>
|
||||
* count_get - <读取计数器值>
|
||||
* control - <设置计数频率 >
|
||||
|
||||
### 定时器特征信息
|
||||
|
||||
```
|
||||
struct rt_hwtimer_info
|
||||
{
|
||||
rt_int32_t maxfreq;
|
||||
rt_int32_t minfreq;
|
||||
rt_uint32_t maxcnt;
|
||||
rt_uint8_t cntmode;
|
||||
};
|
||||
```
|
||||
|
||||
* maxfreq <设备支持的最大计数频率>
|
||||
* minfreq <设备支持的最小计数频率>
|
||||
* maxcnt <计数器最大计数值>
|
||||
* cntmode <递增计数/递减计数>
|
||||
|
||||
### 注册设备
|
||||
|
||||
```
|
||||
static rt_hwtimer_t _timer0;
|
||||
int stm32_hwtimer_init(void)
|
||||
{
|
||||
_timer0.info = &_info;
|
||||
_timer0.ops = &_ops;
|
||||
|
||||
rt_device_hwtimer_register(&_timer0, "timer0", TIM2);
|
||||
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
### 定时器中断
|
||||
|
||||
```
|
||||
void timer_irq_handler(void)
|
||||
{
|
||||
//其它操作
|
||||
|
||||
rt_device_hwtimer_isr(&_timer0);
|
||||
}
|
||||
```
|
||||
|
||||
## 注意事项
|
||||
|
||||
**可能出现定时误差**
|
||||
|
||||
误差原因：
|
||||
|
||||
假设计数器最大值0xFFFF，计数频率1Mhz，定时时间1秒又1微秒。
|
||||
|
||||
由于定时器一次最多只能计时到65535us，对于1000001us的定时要求。
|
||||
可以50000us定时20次完成，此时将会出现计算误差1us。
|
||||
@@ -0,0 +1,8 @@
|
||||
from building import *
|
||||
|
||||
cwd = GetCurrentDir()
|
||||
src = Glob('*.c')
|
||||
CPPPATH = [cwd + '/../include']
|
||||
group = DefineGroup('DeviceDrivers', src, depend = ['RT_USING_HWTIMER'], CPPPATH = CPPPATH)
|
||||
|
||||
Return('group')
|
||||
@@ -0,0 +1,366 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2015-08-31 heyuanjie87 first version
|
||||
*/
|
||||
|
||||
#include <rtthread.h>
|
||||
#include <rtdevice.h>
|
||||
#include <rthw.h>
|
||||
|
||||
rt_inline rt_uint32_t timeout_calc(rt_hwtimer_t *timer, rt_hwtimerval_t *tv)
|
||||
{
|
||||
float overflow;
|
||||
float timeout;
|
||||
rt_uint32_t counter;
|
||||
int i, index = 0;
|
||||
float tv_sec;
|
||||
float devi_min = 1;
|
||||
float devi;
|
||||
|
||||
/* changed to second */
|
||||
overflow = timer->info->maxcnt/(float)timer->freq;
|
||||
tv_sec = tv->sec + tv->usec/(float)1000000;
|
||||
|
||||
if (tv_sec < (1/(float)timer->freq))
|
||||
{
|
||||
/* little timeout */
|
||||
i = 0;
|
||||
timeout = 1/(float)timer->freq;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (i = 1; i > 0; i ++)
|
||||
{
|
||||
timeout = tv_sec/i;
|
||||
|
||||
if (timeout <= overflow)
|
||||
{
|
||||
counter = timeout*timer->freq;
|
||||
devi = tv_sec - (counter/(float)timer->freq)*i;
|
||||
/* Minimum calculation error */
|
||||
if (devi > devi_min)
|
||||
{
|
||||
i = index;
|
||||
timeout = tv_sec/i;
|
||||
break;
|
||||
}
|
||||
else if (devi == 0)
|
||||
{
|
||||
break;
|
||||
}
|
||||
else if (devi < devi_min)
|
||||
{
|
||||
devi_min = devi;
|
||||
index = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
timer->cycles = i;
|
||||
timer->reload = i;
|
||||
timer->period_sec = timeout;
|
||||
counter = timeout*timer->freq;
|
||||
|
||||
return counter;
|
||||
}
|
||||
|
||||
static rt_err_t rt_hwtimer_init(struct rt_device *dev)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
rt_hwtimer_t *timer;
|
||||
|
||||
timer = (rt_hwtimer_t *)dev;
|
||||
/* try to change to 1MHz */
|
||||
if ((1000000 <= timer->info->maxfreq) && (1000000 >= timer->info->minfreq))
|
||||
{
|
||||
timer->freq = 1000000;
|
||||
}
|
||||
else
|
||||
{
|
||||
timer->freq = timer->info->minfreq;
|
||||
}
|
||||
timer->mode = HWTIMER_MODE_ONESHOT;
|
||||
timer->cycles = 0;
|
||||
timer->overflow = 0;
|
||||
|
||||
if (timer->ops->init)
|
||||
{
|
||||
timer->ops->init(timer, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
result = -RT_ENOSYS;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static rt_err_t rt_hwtimer_open(struct rt_device *dev, rt_uint16_t oflag)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
rt_hwtimer_t *timer;
|
||||
|
||||
timer = (rt_hwtimer_t *)dev;
|
||||
if (timer->ops->control != RT_NULL)
|
||||
{
|
||||
timer->ops->control(timer, HWTIMER_CTRL_FREQ_SET, &timer->freq);
|
||||
}
|
||||
else
|
||||
{
|
||||
result = -RT_ENOSYS;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static rt_err_t rt_hwtimer_close(struct rt_device *dev)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
rt_hwtimer_t *timer;
|
||||
|
||||
timer = (rt_hwtimer_t*)dev;
|
||||
if (timer->ops->init != RT_NULL)
|
||||
{
|
||||
timer->ops->init(timer, 0);
|
||||
}
|
||||
else
|
||||
{
|
||||
result = -RT_ENOSYS;
|
||||
}
|
||||
|
||||
dev->flag &= ~RT_DEVICE_FLAG_ACTIVATED;
|
||||
dev->rx_indicate = RT_NULL;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static rt_size_t rt_hwtimer_read(struct rt_device *dev, rt_off_t pos, void *buffer, rt_size_t size)
|
||||
{
|
||||
rt_hwtimer_t *timer;
|
||||
rt_hwtimerval_t tv;
|
||||
rt_uint32_t cnt;
|
||||
rt_base_t level;
|
||||
rt_int32_t overflow;
|
||||
float t;
|
||||
|
||||
timer = (rt_hwtimer_t *)dev;
|
||||
if (timer->ops->count_get == RT_NULL)
|
||||
return 0;
|
||||
|
||||
level = rt_hw_interrupt_disable();
|
||||
cnt = timer->ops->count_get(timer);
|
||||
overflow = timer->overflow;
|
||||
rt_hw_interrupt_enable(level);
|
||||
|
||||
if (timer->info->cntmode == HWTIMER_CNTMODE_DW)
|
||||
{
|
||||
cnt = (timer->freq * timer->period_sec) - cnt;
|
||||
}
|
||||
|
||||
t = overflow * timer->period_sec + cnt/(float)timer->freq;
|
||||
tv.sec = t;
|
||||
tv.usec = (t - tv.sec) * 1000000;
|
||||
size = size > sizeof(tv)? sizeof(tv) : size;
|
||||
rt_memcpy(buffer, &tv, size);
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
static rt_size_t rt_hwtimer_write(struct rt_device *dev, rt_off_t pos, const void *buffer, rt_size_t size)
|
||||
{
|
||||
rt_uint32_t t;
|
||||
rt_hwtimer_mode_t opm = HWTIMER_MODE_PERIOD;
|
||||
rt_hwtimer_t *timer;
|
||||
|
||||
timer = (rt_hwtimer_t *)dev;
|
||||
if ((timer->ops->start == RT_NULL) || (timer->ops->stop == RT_NULL))
|
||||
return 0;
|
||||
|
||||
if (size != sizeof(rt_hwtimerval_t))
|
||||
return 0;
|
||||
|
||||
timer->ops->stop(timer);
|
||||
timer->overflow = 0;
|
||||
|
||||
t = timeout_calc(timer, (rt_hwtimerval_t*)buffer);
|
||||
if ((timer->cycles <= 1) && (timer->mode == HWTIMER_MODE_ONESHOT))
|
||||
{
|
||||
opm = HWTIMER_MODE_ONESHOT;
|
||||
}
|
||||
|
||||
if (timer->ops->start(timer, t, opm) != RT_EOK)
|
||||
size = 0;
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
static rt_err_t rt_hwtimer_control(struct rt_device *dev, int cmd, void *args)
|
||||
{
|
||||
rt_err_t result = RT_EOK;
|
||||
rt_hwtimer_t *timer;
|
||||
|
||||
timer = (rt_hwtimer_t *)dev;
|
||||
|
||||
switch (cmd)
|
||||
{
|
||||
case HWTIMER_CTRL_STOP:
|
||||
{
|
||||
if (timer->ops->stop != RT_NULL)
|
||||
{
|
||||
timer->ops->stop(timer);
|
||||
}
|
||||
else
|
||||
{
|
||||
result = -RT_ENOSYS;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case HWTIMER_CTRL_FREQ_SET:
|
||||
{
|
||||
rt_uint32_t *f;
|
||||
|
||||
if (args == RT_NULL)
|
||||
{
|
||||
result = -RT_EEMPTY;
|
||||
break;
|
||||
}
|
||||
|
||||
f = (rt_uint32_t*)args;
|
||||
if ((*f > timer->info->maxfreq) || (*f < timer->info->minfreq))
|
||||
{
|
||||
result = -RT_ERROR;
|
||||
break;
|
||||
}
|
||||
|
||||
if (timer->ops->control != RT_NULL)
|
||||
{
|
||||
result = timer->ops->control(timer, cmd, args);
|
||||
if (result == RT_EOK)
|
||||
{
|
||||
timer->freq = *f;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
result = -RT_ENOSYS;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case HWTIMER_CTRL_INFO_GET:
|
||||
{
|
||||
if (args == RT_NULL)
|
||||
{
|
||||
result = -RT_EEMPTY;
|
||||
break;
|
||||
}
|
||||
|
||||
*((struct rt_hwtimer_info*)args) = *timer->info;
|
||||
}
|
||||
break;
|
||||
case HWTIMER_CTRL_MODE_SET:
|
||||
{
|
||||
rt_hwtimer_mode_t *m;
|
||||
|
||||
if (args == RT_NULL)
|
||||
{
|
||||
result = -RT_EEMPTY;
|
||||
break;
|
||||
}
|
||||
|
||||
m = (rt_hwtimer_mode_t*)args;
|
||||
|
||||
if ((*m != HWTIMER_MODE_ONESHOT) && (*m != HWTIMER_MODE_PERIOD))
|
||||
{
|
||||
result = -RT_ERROR;
|
||||
break;
|
||||
}
|
||||
|
||||
timer->mode = *m;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
{
|
||||
result = -RT_ENOSYS;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void rt_device_hwtimer_isr(rt_hwtimer_t *timer)
|
||||
{
|
||||
RT_ASSERT(timer != RT_NULL);
|
||||
|
||||
timer->overflow ++;
|
||||
|
||||
if (timer->cycles != 0)
|
||||
{
|
||||
timer->cycles --;
|
||||
}
|
||||
|
||||
if (timer->cycles == 0)
|
||||
{
|
||||
timer->cycles = timer->reload;
|
||||
|
||||
if (timer->mode == HWTIMER_MODE_ONESHOT)
|
||||
{
|
||||
if (timer->ops->stop != RT_NULL)
|
||||
{
|
||||
timer->ops->stop(timer);
|
||||
}
|
||||
}
|
||||
|
||||
if (timer->parent.rx_indicate != RT_NULL)
|
||||
{
|
||||
timer->parent.rx_indicate(&timer->parent, sizeof(struct rt_hwtimerval));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#ifdef RT_USING_DEVICE_OPS
|
||||
const static struct rt_device_ops hwtimer_ops =
|
||||
{
|
||||
rt_hwtimer_init,
|
||||
rt_hwtimer_open,
|
||||
rt_hwtimer_close,
|
||||
rt_hwtimer_read,
|
||||
rt_hwtimer_write,
|
||||
rt_hwtimer_control
|
||||
};
|
||||
#endif
|
||||
|
||||
rt_err_t rt_device_hwtimer_register(rt_hwtimer_t *timer, const char *name, void *user_data)
|
||||
{
|
||||
struct rt_device *device;
|
||||
|
||||
RT_ASSERT(timer != RT_NULL);
|
||||
RT_ASSERT(timer->ops != RT_NULL);
|
||||
RT_ASSERT(timer->info != RT_NULL);
|
||||
|
||||
device = &(timer->parent);
|
||||
|
||||
device->type = RT_Device_Class_Timer;
|
||||
device->rx_indicate = RT_NULL;
|
||||
device->tx_complete = RT_NULL;
|
||||
|
||||
#ifdef RT_USING_DEVICE_OPS
|
||||
device->ops = &hwtimer_ops;
|
||||
#else
|
||||
device->init = rt_hwtimer_init;
|
||||
device->open = rt_hwtimer_open;
|
||||
device->close = rt_hwtimer_close;
|
||||
device->read = rt_hwtimer_read;
|
||||
device->write = rt_hwtimer_write;
|
||||
device->control = rt_hwtimer_control;
|
||||
#endif
|
||||
device->user_data = user_data;
|
||||
|
||||
return rt_device_register(device, name, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE);
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
Import('RTT_ROOT')
|
||||
from building import *
|
||||
|
||||
cwd = GetCurrentDir()
|
||||
src = Split("""
|
||||
i2c_core.c
|
||||
i2c_dev.c
|
||||
""")
|
||||
|
||||
if GetDepend('RT_USING_I2C_BITOPS'):
|
||||
src = src + ['i2c-bit-ops.c']
|
||||
|
||||
# The set of source files associated with this SConscript file.
|
||||
path = [cwd + '/../include']
|
||||
|
||||
group = DefineGroup('DeviceDrivers', src, depend = ['RT_USING_I2C'], CPPPATH = path)
|
||||
|
||||
Return('group')
|
||||
@@ -0,0 +1,453 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2012-04-25 weety first version
|
||||
*/
|
||||
|
||||
#include <rtdevice.h>
|
||||
|
||||
#define DBG_TAG "I2C"
|
||||
#ifdef RT_I2C_BITOPS_DEBUG
|
||||
#define DBG_LVL DBG_LOG
|
||||
#else
|
||||
#define DBG_LVL DBG_INFO
|
||||
#endif
|
||||
#include <rtdbg.h>
|
||||
|
||||
#define SET_SDA(ops, val) ops->set_sda(ops->data, val)
|
||||
#define SET_SCL(ops, val) ops->set_scl(ops->data, val)
|
||||
#define GET_SDA(ops) ops->get_sda(ops->data)
|
||||
#define GET_SCL(ops) ops->get_scl(ops->data)
|
||||
|
||||
rt_inline void i2c_delay(struct rt_i2c_bit_ops *ops)
|
||||
{
|
||||
ops->udelay((ops->delay_us + 1) >> 1);
|
||||
}
|
||||
|
||||
rt_inline void i2c_delay2(struct rt_i2c_bit_ops *ops)
|
||||
{
|
||||
ops->udelay(ops->delay_us);
|
||||
}
|
||||
|
||||
#define SDA_L(ops) SET_SDA(ops, 0)
|
||||
#define SDA_H(ops) SET_SDA(ops, 1)
|
||||
#define SCL_L(ops) SET_SCL(ops, 0)
|
||||
|
||||
/**
|
||||
* release scl line, and wait scl line to high.
|
||||
*/
|
||||
static rt_err_t SCL_H(struct rt_i2c_bit_ops *ops)
|
||||
{
|
||||
rt_tick_t start;
|
||||
|
||||
SET_SCL(ops, 1);
|
||||
|
||||
if (!ops->get_scl)
|
||||
goto done;
|
||||
|
||||
start = rt_tick_get();
|
||||
while (!GET_SCL(ops))
|
||||
{
|
||||
if ((rt_tick_get() - start) > ops->timeout)
|
||||
return -RT_ETIMEOUT;
|
||||
rt_thread_delay((ops->timeout + 1) >> 1);
|
||||
}
|
||||
#ifdef RT_I2C_BITOPS_DEBUG
|
||||
if (rt_tick_get() != start)
|
||||
{
|
||||
LOG_D("wait %ld tick for SCL line to go high",
|
||||
rt_tick_get() - start);
|
||||
}
|
||||
#endif
|
||||
|
||||
done:
|
||||
i2c_delay(ops);
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static void i2c_start(struct rt_i2c_bit_ops *ops)
|
||||
{
|
||||
#ifdef RT_I2C_BITOPS_DEBUG
|
||||
if (ops->get_scl && !GET_SCL(ops))
|
||||
{
|
||||
LOG_E("I2C bus error, SCL line low");
|
||||
}
|
||||
if (ops->get_sda && !GET_SDA(ops))
|
||||
{
|
||||
LOG_E("I2C bus error, SDA line low");
|
||||
}
|
||||
#endif
|
||||
SDA_L(ops);
|
||||
i2c_delay(ops);
|
||||
SCL_L(ops);
|
||||
}
|
||||
|
||||
static void i2c_restart(struct rt_i2c_bit_ops *ops)
|
||||
{
|
||||
SDA_H(ops);
|
||||
SCL_H(ops);
|
||||
i2c_delay(ops);
|
||||
SDA_L(ops);
|
||||
i2c_delay(ops);
|
||||
SCL_L(ops);
|
||||
}
|
||||
|
||||
static void i2c_stop(struct rt_i2c_bit_ops *ops)
|
||||
{
|
||||
SDA_L(ops);
|
||||
i2c_delay(ops);
|
||||
SCL_H(ops);
|
||||
i2c_delay(ops);
|
||||
SDA_H(ops);
|
||||
i2c_delay2(ops);
|
||||
}
|
||||
|
||||
rt_inline rt_bool_t i2c_waitack(struct rt_i2c_bit_ops *ops)
|
||||
{
|
||||
rt_bool_t ack;
|
||||
|
||||
SDA_H(ops);
|
||||
i2c_delay(ops);
|
||||
|
||||
if (SCL_H(ops) < 0)
|
||||
{
|
||||
LOG_W("wait ack timeout");
|
||||
|
||||
return -RT_ETIMEOUT;
|
||||
}
|
||||
|
||||
ack = !GET_SDA(ops); /* ACK : SDA pin is pulled low */
|
||||
LOG_D("%s", ack ? "ACK" : "NACK");
|
||||
|
||||
SCL_L(ops);
|
||||
|
||||
return ack;
|
||||
}
|
||||
|
||||
static rt_int32_t i2c_writeb(struct rt_i2c_bus_device *bus, rt_uint8_t data)
|
||||
{
|
||||
rt_int32_t i;
|
||||
rt_uint8_t bit;
|
||||
|
||||
struct rt_i2c_bit_ops *ops = (struct rt_i2c_bit_ops *)bus->priv;
|
||||
|
||||
for (i = 7; i >= 0; i--)
|
||||
{
|
||||
SCL_L(ops);
|
||||
bit = (data >> i) & 1;
|
||||
SET_SDA(ops, bit);
|
||||
i2c_delay(ops);
|
||||
if (SCL_H(ops) < 0)
|
||||
{
|
||||
LOG_D("i2c_writeb: 0x%02x, "
|
||||
"wait scl pin high timeout at bit %d",
|
||||
data, i);
|
||||
|
||||
return -RT_ETIMEOUT;
|
||||
}
|
||||
}
|
||||
SCL_L(ops);
|
||||
i2c_delay(ops);
|
||||
|
||||
return i2c_waitack(ops);
|
||||
}
|
||||
|
||||
static rt_int32_t i2c_readb(struct rt_i2c_bus_device *bus)
|
||||
{
|
||||
rt_uint8_t i;
|
||||
rt_uint8_t data = 0;
|
||||
struct rt_i2c_bit_ops *ops = (struct rt_i2c_bit_ops *)bus->priv;
|
||||
|
||||
SDA_H(ops);
|
||||
i2c_delay(ops);
|
||||
for (i = 0; i < 8; i++)
|
||||
{
|
||||
data <<= 1;
|
||||
|
||||
if (SCL_H(ops) < 0)
|
||||
{
|
||||
LOG_D("i2c_readb: wait scl pin high "
|
||||
"timeout at bit %d", 7 - i);
|
||||
|
||||
return -RT_ETIMEOUT;
|
||||
}
|
||||
|
||||
if (GET_SDA(ops))
|
||||
data |= 1;
|
||||
SCL_L(ops);
|
||||
i2c_delay2(ops);
|
||||
}
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
static rt_size_t i2c_send_bytes(struct rt_i2c_bus_device *bus,
|
||||
struct rt_i2c_msg *msg)
|
||||
{
|
||||
rt_int32_t ret;
|
||||
rt_size_t bytes = 0;
|
||||
const rt_uint8_t *ptr = msg->buf;
|
||||
rt_int32_t count = msg->len;
|
||||
rt_uint16_t ignore_nack = msg->flags & RT_I2C_IGNORE_NACK;
|
||||
|
||||
while (count > 0)
|
||||
{
|
||||
ret = i2c_writeb(bus, *ptr);
|
||||
|
||||
if ((ret > 0) || (ignore_nack && (ret == 0)))
|
||||
{
|
||||
count --;
|
||||
ptr ++;
|
||||
bytes ++;
|
||||
}
|
||||
else if (ret == 0)
|
||||
{
|
||||
LOG_D("send bytes: NACK.");
|
||||
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG_E("send bytes: error %d", ret);
|
||||
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
return bytes;
|
||||
}
|
||||
|
||||
static rt_err_t i2c_send_ack_or_nack(struct rt_i2c_bus_device *bus, int ack)
|
||||
{
|
||||
struct rt_i2c_bit_ops *ops = (struct rt_i2c_bit_ops *)bus->priv;
|
||||
|
||||
if (ack)
|
||||
SET_SDA(ops, 0);
|
||||
i2c_delay(ops);
|
||||
if (SCL_H(ops) < 0)
|
||||
{
|
||||
LOG_E("ACK or NACK timeout.");
|
||||
|
||||
return -RT_ETIMEOUT;
|
||||
}
|
||||
SCL_L(ops);
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static rt_size_t i2c_recv_bytes(struct rt_i2c_bus_device *bus,
|
||||
struct rt_i2c_msg *msg)
|
||||
{
|
||||
rt_int32_t val;
|
||||
rt_int32_t bytes = 0; /* actual bytes */
|
||||
rt_uint8_t *ptr = msg->buf;
|
||||
rt_int32_t count = msg->len;
|
||||
const rt_uint32_t flags = msg->flags;
|
||||
|
||||
while (count > 0)
|
||||
{
|
||||
val = i2c_readb(bus);
|
||||
if (val >= 0)
|
||||
{
|
||||
*ptr = val;
|
||||
bytes ++;
|
||||
}
|
||||
else
|
||||
{
|
||||
break;
|
||||
}
|
||||
|
||||
ptr ++;
|
||||
count --;
|
||||
|
||||
LOG_D("recieve bytes: 0x%02x, %s",
|
||||
val, (flags & RT_I2C_NO_READ_ACK) ?
|
||||
"(No ACK/NACK)" : (count ? "ACK" : "NACK"));
|
||||
|
||||
if (!(flags & RT_I2C_NO_READ_ACK))
|
||||
{
|
||||
val = i2c_send_ack_or_nack(bus, count);
|
||||
if (val < 0)
|
||||
return val;
|
||||
}
|
||||
}
|
||||
|
||||
return bytes;
|
||||
}
|
||||
|
||||
static rt_int32_t i2c_send_address(struct rt_i2c_bus_device *bus,
|
||||
rt_uint8_t addr,
|
||||
rt_int32_t retries)
|
||||
{
|
||||
struct rt_i2c_bit_ops *ops = (struct rt_i2c_bit_ops *)bus->priv;
|
||||
rt_int32_t i;
|
||||
rt_err_t ret = 0;
|
||||
|
||||
for (i = 0; i <= retries; i++)
|
||||
{
|
||||
ret = i2c_writeb(bus, addr);
|
||||
if (ret == 1 || i == retries)
|
||||
break;
|
||||
LOG_D("send stop condition");
|
||||
i2c_stop(ops);
|
||||
i2c_delay2(ops);
|
||||
LOG_D("send start condition");
|
||||
i2c_start(ops);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static rt_err_t i2c_bit_send_address(struct rt_i2c_bus_device *bus,
|
||||
struct rt_i2c_msg *msg)
|
||||
{
|
||||
rt_uint16_t flags = msg->flags;
|
||||
rt_uint16_t ignore_nack = msg->flags & RT_I2C_IGNORE_NACK;
|
||||
struct rt_i2c_bit_ops *ops = (struct rt_i2c_bit_ops *)bus->priv;
|
||||
|
||||
rt_uint8_t addr1, addr2;
|
||||
rt_int32_t retries;
|
||||
rt_err_t ret;
|
||||
|
||||
retries = ignore_nack ? 0 : bus->retries;
|
||||
|
||||
if (flags & RT_I2C_ADDR_10BIT)
|
||||
{
|
||||
addr1 = 0xf0 | ((msg->addr >> 7) & 0x06);
|
||||
addr2 = msg->addr & 0xff;
|
||||
|
||||
LOG_D("addr1: %d, addr2: %d", addr1, addr2);
|
||||
|
||||
ret = i2c_send_address(bus, addr1, retries);
|
||||
if ((ret != 1) && !ignore_nack)
|
||||
{
|
||||
LOG_W("NACK: sending first addr");
|
||||
|
||||
return -RT_EIO;
|
||||
}
|
||||
|
||||
ret = i2c_writeb(bus, addr2);
|
||||
if ((ret != 1) && !ignore_nack)
|
||||
{
|
||||
LOG_W("NACK: sending second addr");
|
||||
|
||||
return -RT_EIO;
|
||||
}
|
||||
if (flags & RT_I2C_RD)
|
||||
{
|
||||
LOG_D("send repeated start condition");
|
||||
i2c_restart(ops);
|
||||
addr1 |= 0x01;
|
||||
ret = i2c_send_address(bus, addr1, retries);
|
||||
if ((ret != 1) && !ignore_nack)
|
||||
{
|
||||
LOG_E("NACK: sending repeated addr");
|
||||
|
||||
return -RT_EIO;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
/* 7-bit addr */
|
||||
addr1 = msg->addr << 1;
|
||||
if (flags & RT_I2C_RD)
|
||||
addr1 |= 1;
|
||||
ret = i2c_send_address(bus, addr1, retries);
|
||||
if ((ret != 1) && !ignore_nack)
|
||||
return -RT_EIO;
|
||||
}
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static rt_size_t i2c_bit_xfer(struct rt_i2c_bus_device *bus,
|
||||
struct rt_i2c_msg msgs[],
|
||||
rt_uint32_t num)
|
||||
{
|
||||
struct rt_i2c_msg *msg;
|
||||
struct rt_i2c_bit_ops *ops = (struct rt_i2c_bit_ops *)bus->priv;
|
||||
rt_int32_t i, ret;
|
||||
rt_uint16_t ignore_nack;
|
||||
|
||||
if (num == 0) return 0;
|
||||
|
||||
for (i = 0; i < num; i++)
|
||||
{
|
||||
msg = &msgs[i];
|
||||
ignore_nack = msg->flags & RT_I2C_IGNORE_NACK;
|
||||
if (!(msg->flags & RT_I2C_NO_START))
|
||||
{
|
||||
if (i)
|
||||
{
|
||||
i2c_restart(ops);
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG_D("send start condition");
|
||||
i2c_start(ops);
|
||||
}
|
||||
ret = i2c_bit_send_address(bus, msg);
|
||||
if ((ret != RT_EOK) && !ignore_nack)
|
||||
{
|
||||
LOG_D("receive NACK from device addr 0x%02x msg %d",
|
||||
msgs[i].addr, i);
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
if (msg->flags & RT_I2C_RD)
|
||||
{
|
||||
ret = i2c_recv_bytes(bus, msg);
|
||||
if (ret >= 1)
|
||||
LOG_D("read %d byte%s", ret, ret == 1 ? "" : "s");
|
||||
if (ret < msg->len)
|
||||
{
|
||||
if (ret >= 0)
|
||||
ret = -RT_EIO;
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
ret = i2c_send_bytes(bus, msg);
|
||||
if (ret >= 1)
|
||||
LOG_D("write %d byte%s", ret, ret == 1 ? "" : "s");
|
||||
if (ret < msg->len)
|
||||
{
|
||||
if (ret >= 0)
|
||||
ret = -RT_ERROR;
|
||||
goto out;
|
||||
}
|
||||
}
|
||||
}
|
||||
ret = i;
|
||||
|
||||
out:
|
||||
if (!(msg->flags & RT_I2C_NO_STOP))
|
||||
{
|
||||
LOG_D("send stop condition");
|
||||
i2c_stop(ops);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static const struct rt_i2c_bus_device_ops i2c_bit_bus_ops =
|
||||
{
|
||||
i2c_bit_xfer,
|
||||
RT_NULL,
|
||||
RT_NULL
|
||||
};
|
||||
|
||||
rt_err_t rt_i2c_bit_add_bus(struct rt_i2c_bus_device *bus,
|
||||
const char *bus_name)
|
||||
{
|
||||
bus->ops = &i2c_bit_bus_ops;
|
||||
|
||||
return rt_i2c_bus_device_register(bus, bus_name);
|
||||
}
|
||||
@@ -0,0 +1,148 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2012-04-25 weety first version
|
||||
* 2021-04-20 RiceChen added support for bus control api
|
||||
*/
|
||||
|
||||
#include <rtdevice.h>
|
||||
|
||||
#define DBG_TAG "I2C"
|
||||
#ifdef RT_I2C_DEBUG
|
||||
#define DBG_LVL DBG_LOG
|
||||
#else
|
||||
#define DBG_LVL DBG_INFO
|
||||
#endif
|
||||
#include <rtdbg.h>
|
||||
|
||||
rt_err_t rt_i2c_bus_device_register(struct rt_i2c_bus_device *bus,
|
||||
const char *bus_name)
|
||||
{
|
||||
rt_err_t res = RT_EOK;
|
||||
|
||||
rt_mutex_init(&bus->lock, "i2c_bus_lock", RT_IPC_FLAG_PRIO);
|
||||
|
||||
if (bus->timeout == 0) bus->timeout = RT_TICK_PER_SECOND;
|
||||
|
||||
res = rt_i2c_bus_device_device_init(bus, bus_name);
|
||||
|
||||
LOG_I("I2C bus [%s] registered", bus_name);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
struct rt_i2c_bus_device *rt_i2c_bus_device_find(const char *bus_name)
|
||||
{
|
||||
struct rt_i2c_bus_device *bus;
|
||||
rt_device_t dev = rt_device_find(bus_name);
|
||||
if (dev == RT_NULL || dev->type != RT_Device_Class_I2CBUS)
|
||||
{
|
||||
LOG_E("I2C bus %s not exist", bus_name);
|
||||
|
||||
return RT_NULL;
|
||||
}
|
||||
|
||||
bus = (struct rt_i2c_bus_device *)dev->user_data;
|
||||
|
||||
return bus;
|
||||
}
|
||||
|
||||
rt_size_t rt_i2c_transfer(struct rt_i2c_bus_device *bus,
|
||||
struct rt_i2c_msg msgs[],
|
||||
rt_uint32_t num)
|
||||
{
|
||||
rt_size_t ret;
|
||||
|
||||
if (bus->ops->master_xfer)
|
||||
{
|
||||
#ifdef RT_I2C_DEBUG
|
||||
for (ret = 0; ret < num; ret++)
|
||||
{
|
||||
LOG_D("msgs[%d] %c, addr=0x%02x, len=%d", ret,
|
||||
(msgs[ret].flags & RT_I2C_RD) ? 'R' : 'W',
|
||||
msgs[ret].addr, msgs[ret].len);
|
||||
}
|
||||
#endif
|
||||
|
||||
rt_mutex_take(&bus->lock, RT_WAITING_FOREVER);
|
||||
ret = bus->ops->master_xfer(bus, msgs, num);
|
||||
rt_mutex_release(&bus->lock);
|
||||
|
||||
return ret;
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG_E("I2C bus operation not supported");
|
||||
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
rt_err_t rt_i2c_control(struct rt_i2c_bus_device *bus,
|
||||
rt_uint32_t cmd,
|
||||
rt_uint32_t arg)
|
||||
{
|
||||
rt_err_t ret;
|
||||
|
||||
if(bus->ops->i2c_bus_control)
|
||||
{
|
||||
ret = bus->ops->i2c_bus_control(bus, cmd, arg);
|
||||
|
||||
return ret;
|
||||
}
|
||||
else
|
||||
{
|
||||
LOG_E("I2C bus operation not supported");
|
||||
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
rt_size_t rt_i2c_master_send(struct rt_i2c_bus_device *bus,
|
||||
rt_uint16_t addr,
|
||||
rt_uint16_t flags,
|
||||
const rt_uint8_t *buf,
|
||||
rt_uint32_t count)
|
||||
{
|
||||
rt_err_t ret;
|
||||
struct rt_i2c_msg msg;
|
||||
|
||||
msg.addr = addr;
|
||||
msg.flags = flags;
|
||||
msg.len = count;
|
||||
msg.buf = (rt_uint8_t *)buf;
|
||||
|
||||
ret = rt_i2c_transfer(bus, &msg, 1);
|
||||
|
||||
return (ret > 0) ? count : ret;
|
||||
}
|
||||
|
||||
rt_size_t rt_i2c_master_recv(struct rt_i2c_bus_device *bus,
|
||||
rt_uint16_t addr,
|
||||
rt_uint16_t flags,
|
||||
rt_uint8_t *buf,
|
||||
rt_uint32_t count)
|
||||
{
|
||||
rt_err_t ret;
|
||||
struct rt_i2c_msg msg;
|
||||
RT_ASSERT(bus != RT_NULL);
|
||||
|
||||
msg.addr = addr;
|
||||
msg.flags = flags | RT_I2C_RD;
|
||||
msg.len = count;
|
||||
msg.buf = buf;
|
||||
|
||||
ret = rt_i2c_transfer(bus, &msg, 1);
|
||||
|
||||
return (ret > 0) ? count : ret;
|
||||
}
|
||||
|
||||
int rt_i2c_core_init(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
INIT_COMPONENT_EXPORT(rt_i2c_core_init);
|
||||
@@ -0,0 +1,146 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2012-04-25 weety first version
|
||||
* 2014-08-03 bernard fix some compiling warning
|
||||
* 2021-04-20 RiceChen added support for bus clock control
|
||||
*/
|
||||
|
||||
#include <rtdevice.h>
|
||||
|
||||
#define DBG_TAG "I2C"
|
||||
#ifdef RT_I2C_DEBUG
|
||||
#define DBG_LVL DBG_LOG
|
||||
#else
|
||||
#define DBG_LVL DBG_INFO
|
||||
#endif
|
||||
#include <rtdbg.h>
|
||||
|
||||
static rt_size_t i2c_bus_device_read(rt_device_t dev,
|
||||
rt_off_t pos,
|
||||
void *buffer,
|
||||
rt_size_t count)
|
||||
{
|
||||
rt_uint16_t addr;
|
||||
rt_uint16_t flags;
|
||||
struct rt_i2c_bus_device *bus = (struct rt_i2c_bus_device *)dev->user_data;
|
||||
|
||||
RT_ASSERT(bus != RT_NULL);
|
||||
RT_ASSERT(buffer != RT_NULL);
|
||||
|
||||
LOG_D("I2C bus dev [%s] reading %u bytes.", dev->parent.name, count);
|
||||
|
||||
addr = pos & 0xffff;
|
||||
flags = (pos >> 16) & 0xffff;
|
||||
|
||||
return rt_i2c_master_recv(bus, addr, flags, (rt_uint8_t *)buffer, count);
|
||||
}
|
||||
|
||||
static rt_size_t i2c_bus_device_write(rt_device_t dev,
|
||||
rt_off_t pos,
|
||||
const void *buffer,
|
||||
rt_size_t count)
|
||||
{
|
||||
rt_uint16_t addr;
|
||||
rt_uint16_t flags;
|
||||
struct rt_i2c_bus_device *bus = (struct rt_i2c_bus_device *)dev->user_data;
|
||||
|
||||
RT_ASSERT(bus != RT_NULL);
|
||||
RT_ASSERT(buffer != RT_NULL);
|
||||
|
||||
LOG_D("I2C bus dev [%s] writing %u bytes.", dev->parent.name, count);
|
||||
|
||||
addr = pos & 0xffff;
|
||||
flags = (pos >> 16) & 0xffff;
|
||||
|
||||
return rt_i2c_master_send(bus, addr, flags, (const rt_uint8_t *)buffer, count);
|
||||
}
|
||||
|
||||
static rt_err_t i2c_bus_device_control(rt_device_t dev,
|
||||
int cmd,
|
||||
void *args)
|
||||
{
|
||||
rt_err_t ret;
|
||||
struct rt_i2c_priv_data *priv_data;
|
||||
struct rt_i2c_bus_device *bus = (struct rt_i2c_bus_device *)dev->user_data;
|
||||
rt_uint32_t bus_clock;
|
||||
|
||||
RT_ASSERT(bus != RT_NULL);
|
||||
|
||||
switch (cmd)
|
||||
{
|
||||
/* set 10-bit addr mode */
|
||||
case RT_I2C_DEV_CTRL_10BIT:
|
||||
bus->flags |= RT_I2C_ADDR_10BIT;
|
||||
break;
|
||||
case RT_I2C_DEV_CTRL_TIMEOUT:
|
||||
bus->timeout = *(rt_uint32_t *)args;
|
||||
break;
|
||||
case RT_I2C_DEV_CTRL_RW:
|
||||
priv_data = (struct rt_i2c_priv_data *)args;
|
||||
ret = rt_i2c_transfer(bus, priv_data->msgs, priv_data->number);
|
||||
if (ret < 0)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
break;
|
||||
case RT_I2C_DEV_CTRL_CLK:
|
||||
bus_clock = *(rt_uint32_t *)args;
|
||||
ret = rt_i2c_control(bus, cmd, bus_clock);
|
||||
if (ret < 0)
|
||||
{
|
||||
return -RT_EIO;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
#ifdef RT_USING_DEVICE_OPS
|
||||
const static struct rt_device_ops i2c_ops =
|
||||
{
|
||||
RT_NULL,
|
||||
RT_NULL,
|
||||
RT_NULL,
|
||||
i2c_bus_device_read,
|
||||
i2c_bus_device_write,
|
||||
i2c_bus_device_control
|
||||
};
|
||||
#endif
|
||||
|
||||
rt_err_t rt_i2c_bus_device_device_init(struct rt_i2c_bus_device *bus,
|
||||
const char *name)
|
||||
{
|
||||
struct rt_device *device;
|
||||
RT_ASSERT(bus != RT_NULL);
|
||||
|
||||
device = &bus->parent;
|
||||
|
||||
device->user_data = bus;
|
||||
|
||||
/* set device type */
|
||||
device->type = RT_Device_Class_I2CBUS;
|
||||
/* initialize device interface */
|
||||
#ifdef RT_USING_DEVICE_OPS
|
||||
device->ops = &i2c_ops;
|
||||
#else
|
||||
device->init = RT_NULL;
|
||||
device->open = RT_NULL;
|
||||
device->close = RT_NULL;
|
||||
device->read = i2c_bus_device_read;
|
||||
device->write = i2c_bus_device_write;
|
||||
device->control = i2c_bus_device_control;
|
||||
#endif
|
||||
|
||||
/* register to device manager */
|
||||
rt_device_register(device, name, RT_DEVICE_FLAG_RDWR);
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
@@ -0,0 +1,42 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2018-05-07 aozima the first version
|
||||
* 2018-11-16 Ernest Chen add finsh command and update adc function
|
||||
*/
|
||||
|
||||
#ifndef __ADC_H__
|
||||
#define __ADC_H__
|
||||
#include <rtthread.h>
|
||||
|
||||
struct rt_adc_device;
|
||||
struct rt_adc_ops
|
||||
{
|
||||
rt_err_t (*enabled)(struct rt_adc_device *device, rt_uint32_t channel, rt_bool_t enabled);
|
||||
rt_err_t (*convert)(struct rt_adc_device *device, rt_uint32_t channel, rt_uint32_t *value);
|
||||
};
|
||||
|
||||
struct rt_adc_device
|
||||
{
|
||||
struct rt_device parent;
|
||||
const struct rt_adc_ops *ops;
|
||||
};
|
||||
typedef struct rt_adc_device *rt_adc_device_t;
|
||||
|
||||
typedef enum
|
||||
{
|
||||
RT_ADC_CMD_ENABLE,
|
||||
RT_ADC_CMD_DISABLE,
|
||||
} rt_adc_cmd_t;
|
||||
|
||||
rt_err_t rt_hw_adc_register(rt_adc_device_t adc,const char *name, const struct rt_adc_ops *ops, const void *user_data);
|
||||
|
||||
rt_uint32_t rt_adc_read(rt_adc_device_t dev, rt_uint32_t channel);
|
||||
rt_err_t rt_adc_enable(rt_adc_device_t dev, rt_uint32_t channel);
|
||||
rt_err_t rt_adc_disable(rt_adc_device_t dev, rt_uint32_t channel);
|
||||
|
||||
#endif /* __ADC_H__ */
|
||||
@@ -0,0 +1,80 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2012-10-27 heyuanjie87 first version.
|
||||
* 2013-05-17 aozima initial alarm event & mutex in system init.
|
||||
* 2020-10-15 zhangsz add alarm flags hour minute second.
|
||||
*/
|
||||
|
||||
#ifndef __ALARM_H__
|
||||
#define __ALARM_H__
|
||||
|
||||
#include <sys/time.h>
|
||||
#include <rtdef.h>
|
||||
|
||||
#define RT_ALARM_TM_NOW -1 /* set the alarm tm_day,tm_mon,tm_sec,etc.
|
||||
to now.we also call it "don't care" value */
|
||||
|
||||
/* alarm flags */
|
||||
#define RT_ALARM_ONESHOT 0x000 /* only alarm onece */
|
||||
#define RT_ALARM_DAILY 0x100 /* alarm everyday */
|
||||
#define RT_ALARM_WEEKLY 0x200 /* alarm weekly at Monday or Friday etc. */
|
||||
#define RT_ALARM_MONTHLY 0x400 /* alarm monthly at someday */
|
||||
#define RT_ALARM_YAERLY 0x800 /* alarm yearly at a certain date */
|
||||
#define RT_ALARM_HOUR 0x1000 /* alarm each hour at a certain min:second */
|
||||
#define RT_ALARM_MINUTE 0x2000 /* alarm each minute at a certain second */
|
||||
#define RT_ALARM_SECOND 0x4000 /* alarm each second */
|
||||
|
||||
/* alarm control cmd */
|
||||
#define RT_ALARM_CTRL_MODIFY 1 /* modify alarm time or alarm flag */
|
||||
|
||||
typedef struct rt_alarm *rt_alarm_t;
|
||||
typedef void (*rt_alarm_callback_t)(rt_alarm_t alarm, time_t timestamp);
|
||||
|
||||
/* used for low level RTC driver */
|
||||
struct rt_rtc_wkalarm
|
||||
{
|
||||
rt_bool_t enable; /* 0 = alarm disabled, 1 = alarm enabled */
|
||||
rt_int32_t tm_sec; /* alarm at tm_sec */
|
||||
rt_int32_t tm_min; /* alarm at tm_min */
|
||||
rt_int32_t tm_hour; /* alarm at tm_hour */
|
||||
};
|
||||
|
||||
struct rt_alarm
|
||||
{
|
||||
rt_list_t list;
|
||||
rt_uint32_t flag;
|
||||
rt_alarm_callback_t callback;
|
||||
struct tm wktime;
|
||||
|
||||
void *user_data;
|
||||
};
|
||||
|
||||
struct rt_alarm_setup
|
||||
{
|
||||
rt_uint32_t flag; /* alarm flag */
|
||||
struct tm wktime; /* when will the alarm wake up user */
|
||||
};
|
||||
|
||||
struct rt_alarm_container
|
||||
{
|
||||
rt_list_t head;
|
||||
struct rt_mutex mutex;
|
||||
struct rt_event event;
|
||||
struct rt_alarm *current;
|
||||
};
|
||||
|
||||
rt_alarm_t rt_alarm_create(rt_alarm_callback_t callback,
|
||||
struct rt_alarm_setup *setup);
|
||||
rt_err_t rt_alarm_control(rt_alarm_t alarm, int cmd, void *arg);
|
||||
void rt_alarm_update(rt_device_t dev, rt_uint32_t event);
|
||||
rt_err_t rt_alarm_delete(rt_alarm_t alarm);
|
||||
rt_err_t rt_alarm_start(rt_alarm_t alarm);
|
||||
rt_err_t rt_alarm_stop(rt_alarm_t alarm);
|
||||
int rt_alarm_system_init(void);
|
||||
|
||||
#endif /* __ALARM_H__ */
|
||||
@@ -0,0 +1,176 @@
|
||||
/*
|
||||
* Copyright (c) 2006-2021, RT-Thread Development Team
|
||||
*
|
||||
* SPDX-License-Identifier: Apache-2.0
|
||||
*
|
||||
* Change Logs:
|
||||
* Date Author Notes
|
||||
* 2017-05-09 Urey first version
|
||||
* 2019-07-09 Zero-Free improve device ops interface and data flows
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef __AUDIO_H__
|
||||
#define __AUDIO_H__
|
||||
|
||||
#include "audio_pipe.h"
|
||||
|
||||
/* AUDIO command */
|
||||
#define _AUDIO_CTL(a) (0x10 + a)
|
||||
|
||||
#define AUDIO_CTL_GETCAPS _AUDIO_CTL(1)
|
||||
#define AUDIO_CTL_CONFIGURE _AUDIO_CTL(2)
|
||||
#define AUDIO_CTL_START _AUDIO_CTL(3)
|
||||
#define AUDIO_CTL_STOP _AUDIO_CTL(4)
|
||||
#define AUDIO_CTL_GETBUFFERINFO _AUDIO_CTL(5)
|
||||
|
||||
/* Audio Device Types */
|
||||
#define AUDIO_TYPE_QUERY 0x00
|
||||
#define AUDIO_TYPE_INPUT 0x01
|
||||
#define AUDIO_TYPE_OUTPUT 0x02
|
||||
#define AUDIO_TYPE_MIXER 0x04
|
||||
|
||||
/* Supported Sampling Rates */
|
||||
#define AUDIO_SAMP_RATE_8K 0x0001
|
||||
#define AUDIO_SAMP_RATE_11K 0x0002
|
||||
#define AUDIO_SAMP_RATE_16K 0x0004
|
||||
#define AUDIO_SAMP_RATE_22K 0x0008
|
||||
#define AUDIO_SAMP_RATE_32K 0x0010
|
||||
#define AUDIO_SAMP_RATE_44K 0x0020
|
||||
#define AUDIO_SAMP_RATE_48K 0x0040
|
||||
#define AUDIO_SAMP_RATE_96K 0x0080
|
||||
#define AUDIO_SAMP_RATE_128K 0x0100
|
||||
#define AUDIO_SAMP_RATE_160K 0x0200
|
||||
#define AUDIO_SAMP_RATE_172K 0x0400
|
||||
#define AUDIO_SAMP_RATE_192K 0x0800
|
||||
|
||||
/* Supported Bit Rates */
|
||||
#define AUDIO_BIT_RATE_22K 0x01
|
||||
#define AUDIO_BIT_RATE_44K 0x02
|
||||
#define AUDIO_BIT_RATE_48K 0x04
|
||||
#define AUDIO_BIT_RATE_96K 0x08
|
||||
#define AUDIO_BIT_RATE_128K 0x10
|
||||
#define AUDIO_BIT_RATE_160K 0x20
|
||||
#define AUDIO_BIT_RATE_172K 0x40
|
||||
#define AUDIO_BIT_RATE_192K 0x80
|
||||
|
||||
/* Support Dsp(input/output) Units controls */
|
||||
#define AUDIO_DSP_PARAM 0 /* get/set all params */
|
||||
#define AUDIO_DSP_SAMPLERATE 1 /* samplerate */
|
||||
#define AUDIO_DSP_CHANNELS 2 /* channels */
|
||||
#define AUDIO_DSP_SAMPLEBITS 3 /* sample bits width */
|
||||
|
||||
/* Supported Mixer Units controls */
|
||||
#define AUDIO_MIXER_QUERY 0x0000
|
||||
#define AUDIO_MIXER_MUTE 0x0001
|
||||
#define AUDIO_MIXER_VOLUME 0x0002
|
||||
#define AUDIO_MIXER_BASS 0x0004
|
||||
#define AUDIO_MIXER_MID 0x0008
|
||||
#define AUDIO_MIXER_TREBLE 0x0010
|
||||
#define AUDIO_MIXER_EQUALIZER 0x0020
|
||||
#define AUDIO_MIXER_LINE 0x0040
|
||||
#define AUDIO_MIXER_DIGITAL 0x0080
|
||||
#define AUDIO_MIXER_MIC 0x0100
|
||||
#define AUDIO_MIXER_VITURAL 0x0200
|
||||
#define AUDIO_MIXER_EXTEND 0x8000 /* extend mixer command */
|
||||
|
||||
#define AUDIO_VOLUME_MAX (100)
|
||||
#define AUDIO_VOLUME_MIN (0)
|
||||
|
||||
#define CFG_AUDIO_REPLAY_QUEUE_COUNT 4
|
||||
|
||||
enum
|
||||
{
|
||||
AUDIO_STREAM_REPLAY = 0,
|
||||
AUDIO_STREAM_RECORD,
|
||||
AUDIO_STREAM_LAST = AUDIO_STREAM_RECORD,
|
||||
};
|
||||
|
||||
/* the preferred number and size of audio pipeline buffer for the audio device */
|
||||
struct rt_audio_buf_info
|
||||
{
|
||||
rt_uint8_t *buffer;
|
||||
rt_uint16_t block_size;
|
||||
rt_uint16_t block_count;
|
||||
rt_uint32_t total_size;
|
||||
};
|
||||
|
||||
struct rt_audio_device;
|
||||
struct rt_audio_caps;
|
||||
struct rt_audio_configure;
|
||||
struct rt_audio_ops
|
||||
{
|
||||
rt_err_t (*getcaps)(struct rt_audio_device *audio, struct rt_audio_caps *caps);
|
||||
rt_err_t (*configure)(struct rt_audio_device *audio, struct rt_audio_caps *caps);
|
||||
rt_err_t (*init)(struct rt_audio_device *audio);
|
||||
rt_err_t (*start)(struct rt_audio_device *audio, int stream);
|
||||
rt_err_t (*stop)(struct rt_audio_device *audio, int stream);
|
||||
rt_size_t (*transmit)(struct rt_audio_device *audio, const void *writeBuf, void *readBuf, rt_size_t size);
|
||||
/* get page size of codec or private buffer's info */
|
||||
void (*buffer_info)(struct rt_audio_device *audio, struct rt_audio_buf_info *info);
|
||||
};
|
||||
|
||||
struct rt_audio_configure
|
||||
{
|
||||
rt_uint32_t samplerate;
|
||||
rt_uint16_t channels;
|
||||
rt_uint16_t samplebits;
|
||||
};
|
||||
|
||||
struct rt_audio_caps
|
||||
{
|
||||
int main_type;
|
||||
int sub_type;
|
||||
|
||||
union
|
||||
{
|
||||
rt_uint32_t mask;
|
||||
int value;
|
||||
struct rt_audio_configure config;
|
||||
} udata;
|
||||
};
|
||||
|
||||
struct rt_audio_replay
|
||||
{
|
||||
struct rt_mempool *mp;
|
||||
struct rt_data_queue queue;
|
||||
struct rt_mutex lock;
|
||||
struct rt_completion cmp;
|
||||
struct rt_audio_buf_info buf_info;
|
||||
rt_uint8_t *write_data;
|
||||
rt_uint16_t write_index;
|
||||
rt_uint16_t read_index;
|
||||
rt_uint32_t pos;
|
||||
rt_uint8_t event;
|
||||
rt_bool_t activated;
|
||||
};
|
||||
|
||||
struct rt_audio_record
|
||||
{
|
||||
struct rt_audio_pipe pipe;
|
||||
rt_bool_t activated;
|
||||
};
|
||||
|
||||
struct rt_audio_device
|
||||
{
|
||||
struct rt_device parent;
|
||||
struct rt_audio_ops *ops;
|
||||
struct rt_audio_replay *replay;
|
||||
struct rt_audio_record *record;
|
||||
};
|
||||
|
||||
rt_err_t rt_audio_register(struct rt_audio_device *audio, const char *name, rt_uint32_t flag, void *data);
|
||||
void rt_audio_tx_complete(struct rt_audio_device *audio);
|
||||
void rt_audio_rx_done(struct rt_audio_device *audio, rt_uint8_t *pbuf, rt_size_t len);
|
||||
|
||||
/* Device Control Commands */
|
||||
#define CODEC_CMD_RESET 0
|
||||
#define CODEC_CMD_SET_VOLUME 1
|
||||
#define CODEC_CMD_GET_VOLUME 2
|
||||
#define CODEC_CMD_SAMPLERATE 3
|
||||
#define CODEC_CMD_EQ 4
|
||||
#define CODEC_CMD_3D 5
|
||||
|
||||
#define CODEC_VOLUME_MAX (63)
|
||||
|
||||
#endif /* __AUDIO_H__ */
|
||||
Loaded 100 of 2473 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user