Skip to content

R
rt-thread

lfmiao0 / rt-thread
与 Fork 源项目一致

Fork自 RT-Thread / rt-thread

通知 1
Star 0
Fork 0
R
rt-thread

体验新版 GitCode，发现更多精彩内容 >>

提交 f9ad7f1b 编写于 作者: mysterywolf's avatar mysterywolf
浏览文件
操作

remove efm32 files

上级 92204470
隐藏空白更改
内联 并排
Showing with 0 addition and 1431 deletion
bsp/efm32/copy_this_file_dfs_elm.c 已删除 100644 → 0
浏览文件 @ 92204470
/*
* File : dfs_elm.c
* This file is part of Device File System in RT-Thread RTOS
* COPYRIGHT (C) 2008-2011, RT-Thread Development Team
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE.
*
* Change Logs:
* Date Author Notes
* 2008-02-22 QiuYi The first version.
* 2011-10-08 Bernard fixed the block size in statfs.
* 2011-11-23 Bernard fixed the rename issue.
*/
#include <rtthread.h>
#include "ffconf.h"
#include "ff.h"
/* ELM FatFs provide a DIR struct */
#define HAVE_DIR_STRUCTURE
#include <dfs_fs.h>
#include <dfs.h>
#ifdef DFS_ELMFAT_INTERFACE_EFM
#include "diskio.h"
/* Disk status */
static volatile DSTATUS diskStat[_VOLUMES];
#endif
static rt_device_t disk[_VOLUMES] = {0};
static int elm_result_to_dfs(FRESULT result)
{
int status = DFS_STATUS_OK;
switch (result)
{
case FR_OK:
break;
case FR_NO_FILE:
case FR_NO_PATH:
case FR_NO_FILESYSTEM:
status = -DFS_STATUS_ENOENT;
break;
case FR_INVALID_NAME:
status = -DFS_STATUS_EINVAL;
break;
case FR_EXIST:
case FR_INVALID_OBJECT:
status = -DFS_STATUS_EEXIST;
break;
case FR_DISK_ERR:
case FR_NOT_READY:
case FR_INT_ERR:
status = -DFS_STATUS_EIO;
break;
case FR_WRITE_PROTECTED:
case FR_DENIED:
status = -DFS_STATUS_EROFS;
break;
case FR_MKFS_ABORTED:
status = -DFS_STATUS_EINVAL;
break;
default:
status = -1;
break;
}
return status;
}
int dfs_elm_mount(struct dfs_filesystem *fs, unsigned long rwflag, const void *data)
{
FATFS *fat;
FRESULT result;
rt_uint32_t index;
/* handle RT-Thread device routine */
for (index = 0; index < _VOLUMES; index ++)
{
if (disk[index] == RT_NULL)
{
break;
}
}
if (index == _VOLUMES)
return -DFS_STATUS_ENOSPC;
/* get device */
disk[index] = fs->dev_id;
fat = (FATFS *)rt_malloc(sizeof(FATFS));
if (fat == RT_NULL)
{
return -1;
}
/* mount fatfs, always 0 logic driver */
result = f_mount(index, fat);
if (result == FR_OK)
fs->data = fat;
else
{
rt_free(fat);
return elm_result_to_dfs(result);
}
return 0;
}
int dfs_elm_unmount(struct dfs_filesystem *fs)
{
FATFS *fat;
FRESULT result;
rt_uint32_t index;
fat = (FATFS *)fs->data;
RT_ASSERT(fat != RT_NULL);
/* find the device index and then umount it */
for (index = 0; index < _VOLUMES; index ++)
{
if (disk[index] == fs->dev_id)
{
result = f_mount(index, RT_NULL);
if (result == FR_OK)
{
fs->data = RT_NULL;
disk[index] = RT_NULL;
rt_free(fat);
return DFS_STATUS_OK;
}
}
}
return -DFS_STATUS_ENOENT;
}
int dfs_elm_mkfs(const char *device_name)
{
BYTE drv;
rt_device_t dev;
FRESULT result;
/* find device name */
for (drv = 0; drv < _VOLUMES; drv ++)
{
dev = disk[drv];
if (rt_strncmp(dev->parent.name, device_name, RT_NAME_MAX) == 0)
{
/* 1: no partition table */
/* 0: auto selection of cluster size */
result = f_mkfs(drv, 1, 0);
if (result != FR_OK)
{
rt_kprintf("format error\n");
return elm_result_to_dfs(result);
}
return DFS_STATUS_OK;
}
}
/* can't find device driver */
rt_kprintf("can not find device driver: %s\n", device_name);
return -DFS_STATUS_EIO;
}
int dfs_elm_statfs(struct dfs_filesystem *fs, struct statfs *buf)
{
FATFS *f;
FRESULT res;
char driver[4];
DWORD fre_clust, fre_sect, tot_sect;
RT_ASSERT(fs != RT_NULL);
RT_ASSERT(buf != RT_NULL);
f = (FATFS *)fs->data;
rt_snprintf(driver, sizeof(driver), "%d:", f->drv);
res = f_getfree(driver, &fre_clust, &f);
if (res)
return elm_result_to_dfs(res);
/* Get total sectors and free sectors */
tot_sect = (f->n_fatent - 2) * f->csize;
fre_sect = fre_clust * f->csize;
buf->f_bfree = fre_sect;
buf->f_blocks = tot_sect;
#if _MAX_SS != 512
buf->f_bsize = f->ssize;
#else
buf->f_bsize = 512;
#endif
return 0;
}
int dfs_elm_open(struct dfs_fd *file)
{
FIL *fd;
BYTE mode;
FRESULT result;
char *drivers_fn;
#if (_VOLUMES > 1)
int vol;
extern int elm_get_vol(FATFS *fat);
/* add path for ELM FatFS driver support */
vol = elm_get_vol((FATFS *)file->fs->data);
if (vol < 0)
return -DFS_STATUS_ENOENT;
drivers_fn = rt_malloc(256);
if (drivers_fn == RT_NULL)
return -DFS_STATUS_ENOMEM;
rt_snprintf(drivers_fn, 256, "%d:%s", vol, file->path);
#else
drivers_fn = file->path;
#endif
if (file->flags & DFS_O_DIRECTORY)
{
DIR *dir;
if (file->flags & DFS_O_CREAT)
{
result = f_mkdir(drivers_fn);
if (result != FR_OK)
{
#if _VOLUMES > 1
rt_free(drivers_fn);
#endif
return elm_result_to_dfs(result);
}
}
/* open directory */
dir = (DIR *)rt_malloc(sizeof(DIR));
if (dir == RT_NULL)
{
#if _VOLUMES > 1
rt_free(drivers_fn);
#endif
return -DFS_STATUS_ENOMEM;
}
result = f_opendir(dir, drivers_fn);
#if _VOLUMES > 1
rt_free(drivers_fn);
#endif
if (result != FR_OK)
{
rt_free(dir);
return elm_result_to_dfs(result);
}
file->data = dir;
return DFS_STATUS_OK;
}
else
{
mode = FA_READ;
if (file->flags & DFS_O_WRONLY)
mode |= FA_WRITE;
if ((file->flags & DFS_O_ACCMODE) & DFS_O_RDWR)
mode |= FA_WRITE;
/* Opens the file, if it is existing. If not, a new file is created. */
if (file->flags & DFS_O_CREAT)
mode |= FA_OPEN_ALWAYS;
/* Creates a new file. If the file is existing, it is truncated and overwritten. */
if (file->flags & DFS_O_TRUNC)
mode |= FA_CREATE_ALWAYS;
/* Creates a new file. The function fails if the file is already existing. */
if (file->flags & DFS_O_EXCL)
mode |= FA_CREATE_NEW;
/* allocate a fd */
fd = (FIL *)rt_malloc(sizeof(FIL));
if (fd == RT_NULL)
{
return -DFS_STATUS_ENOMEM;
}
result = f_open(fd, drivers_fn, mode);
#if _VOLUMES > 1
rt_free(drivers_fn);
#endif
if (result == FR_OK)
{
file->pos = fd->fptr;
file->size = fd->fsize;
file->data = fd;
if (file->flags & DFS_O_APPEND)
{
file->pos = f_lseek(fd, fd->fsize);
}
}
else
{
/* open failed, return */
rt_free(fd);
return elm_result_to_dfs(result);
}
}
return DFS_STATUS_OK;
}
int dfs_elm_close(struct dfs_fd *file)
{
FRESULT result;
result = FR_OK;
if (file->type == FT_DIRECTORY)
{
DIR *dir;
dir = (DIR *)(file->data);
RT_ASSERT(dir != RT_NULL);
/* release memory */
rt_free(dir);
}
else if (file->type == FT_REGULAR)
{
FIL *fd;
fd = (FIL *)(file->data);
RT_ASSERT(fd != RT_NULL);
result = f_close(fd);
if (result == FR_OK)
{
/* release memory */
rt_free(fd);
}
}
return elm_result_to_dfs(result);
}
int dfs_elm_ioctl(struct dfs_fd *file, int cmd, void *args)
{
return -DFS_STATUS_ENOSYS;
}
int dfs_elm_read(struct dfs_fd *file, void *buf, rt_size_t len)
{
FIL *fd;
FRESULT result;
UINT byte_read;
if (file->type == FT_DIRECTORY)
{
return -DFS_STATUS_EISDIR;
}
fd = (FIL *)(file->data);
RT_ASSERT(fd != RT_NULL);
result = f_read(fd, buf, len, &byte_read);
/* update position */
file->pos = fd->fptr;
if (result == FR_OK)
return byte_read;
return elm_result_to_dfs(result);
}
int dfs_elm_write(struct dfs_fd *file, const void *buf, rt_size_t len)
{
FIL *fd;
FRESULT result;
UINT byte_write;
if (file->type == FT_DIRECTORY)
{
return -DFS_STATUS_EISDIR;
}
fd = (FIL *)(file->data);
RT_ASSERT(fd != RT_NULL);
result = f_write(fd, buf, len, &byte_write);
/* update position and file size */
file->pos = fd->fptr;
file->size = fd->fsize;
if (result == FR_OK)
return byte_write;
return elm_result_to_dfs(result);
}
int dfs_elm_flush(struct dfs_fd *file)
{
FIL *fd;
FRESULT result;
fd = (FIL *)(file->data);
RT_ASSERT(fd != RT_NULL);
result = f_sync(fd);
return elm_result_to_dfs(result);
}
int dfs_elm_lseek(struct dfs_fd *file, rt_off_t offset)
{
FRESULT result = FR_OK;
if (file->type == FT_REGULAR)
{
FIL *fd;
/* regular file type */
fd = (FIL *)(file->data);
RT_ASSERT(fd != RT_NULL);
result = f_lseek(fd, offset);
if (result == FR_OK)
{
/* return current position */
return fd->fptr;
}
}
else if (file->type == FT_DIRECTORY)
{
/* which is a directory */
DIR *dir;
dir = (DIR *)(file->data);
RT_ASSERT(dir != RT_NULL);
result = f_seekdir(dir, offset / sizeof(struct dirent));
if (result == FR_OK)
{
/* update file position */
file->pos = offset;
return file->pos;
}
}
return elm_result_to_dfs(result);
}
int dfs_elm_getdents(struct dfs_fd *file, struct dirent *dirp, rt_uint32_t count)
{
DIR *dir;
FILINFO fno;
FRESULT result;
rt_uint32_t index;
struct dirent *d;
dir = (DIR *)(file->data);
RT_ASSERT(dir != RT_NULL);
/* make integer count */
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
if (count == 0)
return -DFS_STATUS_EINVAL;
#if _USE_LFN
/* allocate long file name */
fno.lfname = rt_malloc(256);
fno.lfsize = 256;
#endif
index = 0;
while (1)
{
char *fn;
d = dirp + index;
result = f_readdir(dir, &fno);
if (result != FR_OK || fno.fname[0] == 0)
break;
#if _USE_LFN
fn = *fno.lfname? fno.lfname : fno.fname;
#else
fn = fno.fname;
#endif
d->d_type = DFS_DT_UNKNOWN;
if (fno.fattrib & AM_DIR)
d->d_type = DFS_DT_DIR;
else
d->d_type = DFS_DT_REG;
d->d_namlen = rt_strlen(fn);
d->d_reclen = (rt_uint16_t)sizeof(struct dirent);
rt_strncpy(d->d_name, fn, rt_strlen(fn) + 1);
index ++;
if (index * sizeof(struct dirent) >= count)
break;
}
#if _USE_LFN
rt_free(fno.lfname);
#endif
if (index == 0)
return elm_result_to_dfs(result);
file->pos += index * sizeof(struct dirent);
return index * sizeof(struct dirent);
}
int dfs_elm_unlink(struct dfs_filesystem *fs, const char *path)
{
FRESULT result;
#if _VOLUMES > 1
int vol;
char *drivers_fn;
extern int elm_get_vol(FATFS *fat);
/* add path for ELM FatFS driver support */
vol = elm_get_vol((FATFS *)fs->data);
if (vol < 0)
return -DFS_STATUS_ENOENT;
drivers_fn = rt_malloc(256);
if (drivers_fn == RT_NULL)
return -DFS_STATUS_ENOMEM;
rt_snprintf(drivers_fn, 256, "%d:%s", vol, path);
#else
const char *drivers_fn;
drivers_fn = path;
#endif
result = f_unlink(drivers_fn);
#if _VOLUMES > 1
rt_free(drivers_fn);
#endif
return elm_result_to_dfs(result);
}
int dfs_elm_rename(struct dfs_filesystem *fs, const char *oldpath, const char *newpath)
{
FRESULT result;
#if _VOLUMES > 1
char *drivers_oldfn;
const char *drivers_newfn;
int vol;
extern int elm_get_vol(FATFS *fat);
/* add path for ELM FatFS driver support */
vol = elm_get_vol((FATFS *)fs->data);
if (vol < 0)
return -DFS_STATUS_ENOENT;
drivers_oldfn = rt_malloc(256);
if (drivers_oldfn == RT_NULL)
return -DFS_STATUS_ENOMEM;
drivers_newfn = newpath;
rt_snprintf(drivers_oldfn, 256, "%d:%s", vol, oldpath);
#else
const char *drivers_oldfn, *drivers_newfn;
drivers_oldfn = oldpath;
drivers_newfn = newpath;
#endif
result = f_rename(drivers_oldfn, drivers_newfn);
#if _VOLUMES > 1
rt_free(drivers_oldfn);
#endif
return elm_result_to_dfs(result);
}
int dfs_elm_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
{
FILINFO file_info;
FRESULT result;
#if _VOLUMES > 1
int vol;
char *drivers_fn;
extern int elm_get_vol(FATFS *fat);
/* add path for ELM FatFS driver support */
vol = elm_get_vol((FATFS *)fs->data);
if (vol < 0)
return -DFS_STATUS_ENOENT;
drivers_fn = rt_malloc(256);
if (drivers_fn == RT_NULL)
return -DFS_STATUS_ENOMEM;
rt_snprintf(drivers_fn, 256, "%d:%s", vol, path);
#else
const char *drivers_fn;
drivers_fn = path;
#endif
#if _USE_LFN
/* allocate long file name */
file_info.lfname = rt_malloc(256);
file_info.lfsize = 256;
#endif
result = f_stat(drivers_fn, &file_info);
#if _VOLUMES > 1
rt_free(drivers_fn);
#endif
if (result == FR_OK)
{
/* convert to dfs stat structure */
st->st_dev = 0;
st->st_mode = DFS_S_IFREG | DFS_S_IRUSR | DFS_S_IRGRP | DFS_S_IROTH |
DFS_S_IWUSR | DFS_S_IWGRP | DFS_S_IWOTH;
if (file_info.fattrib & AM_DIR)
{
st->st_mode &= ~DFS_S_IFREG;
st->st_mode |= DFS_S_IFDIR | DFS_S_IXUSR | DFS_S_IXGRP | DFS_S_IXOTH;
}
if (file_info.fattrib & AM_RDO)
st->st_mode &= ~(DFS_S_IWUSR | DFS_S_IWGRP | DFS_S_IWOTH);
st->st_size = file_info.fsize;
st->st_mtime = file_info.ftime;
}
#if _USE_LFN
rt_free(file_info.lfname);
#endif
return elm_result_to_dfs(result);
}
static const struct dfs_filesystem_operation dfs_elm =
{
"elm",
dfs_elm_mount,
dfs_elm_unmount,
dfs_elm_mkfs,
dfs_elm_statfs,
dfs_elm_open,
dfs_elm_close,
dfs_elm_ioctl,
dfs_elm_read,
dfs_elm_write,
dfs_elm_flush,
dfs_elm_lseek,
dfs_elm_getdents,
dfs_elm_unlink,
dfs_elm_stat,
dfs_elm_rename,
};
int elm_init(void)
{
#ifdef DFS_ELMFAT_INTERFACE_EFM
int i;
for (i = 0; i < _VOLUMES; i++)
{
diskStat[i] = STA_NOINIT;
}
#endif
/* register fatfs file system */
dfs_register(&dfs_elm);
return 0;
}
/*
* RT-Thread Device Interface for ELM FatFs
*/
#ifdef DFS_ELMFAT_INTERFACE_EFM
/*-----------------------------------------------------------------------*/
/* Initialize Disk Drive */
/*-----------------------------------------------------------------------*/
DSTATUS disk_initialize (
BYTE drv /* Physical drive nmuber */
)
{
rt_device_t device = disk[drv];
if (!device)
{
return RES_ERROR;
}
if (diskStat[drv] & STA_NODISK)
{
/* No card in the socket */
return diskStat[drv];
}
/* Initialize hardware: the actual operation is performed in dfs_mount() */
diskStat[drv] &= ~STA_NOINIT;
return diskStat[drv];
}
/*-----------------------------------------------------------------------*/
/* Get Disk Status */
/*-----------------------------------------------------------------------*/
DSTATUS disk_status (
BYTE drv /* Physical drive nmuber */
)
{
return diskStat[drv];
}
/*-----------------------------------------------------------------------*/
/* Read Sector(s) */
/*-----------------------------------------------------------------------*/
DRESULT disk_read (
BYTE drv, /* Physical drive nmuber */
BYTE *buff, /* Pointer to the data buffer to store read data */
DWORD sector, /* Start sector number (LBA) */
BYTE count /* Sector count (1..255) */
)
{
rt_device_t device = disk[drv];
if (!device)
{
return RES_ERROR;
}
if (!count)
{
return RES_PARERR;
}
if (diskStat[drv] & STA_NOINIT)
{
return RES_NOTRDY;
}
if (rt_device_read(device, sector, buff, count) != count)
{
return RES_ERROR;
}
else
{
return RES_OK;
}
}
/*-----------------------------------------------------------------------*/
/* Write Sector(s) */
/*-----------------------------------------------------------------------*/
#if _READONLY == 0
DRESULT disk_write (
BYTE drv, /* Physical drive nmuber */
const BYTE *buff, /* Pointer to the data to be written */
DWORD sector, /* Start sector number (LBA) */
BYTE count /* Sector count (1..255) */
)
{
rt_device_t device = disk[drv];
if (!device)
{
return RES_ERROR;
}
if (!count)
{
return RES_PARERR;
}
if (diskStat[drv] & STA_NOINIT)
{
return RES_NOTRDY;
}
if (diskStat[drv] & STA_PROTECT)
{
return RES_WRPRT;
}
if (rt_device_write(device, sector, buff, count) != count)
{
return RES_ERROR;
}
else
{
return RES_OK;
}
}
#endif /* _READONLY */
/*-----------------------------------------------------------------------*/
/* Miscellaneous Functions */
/*-----------------------------------------------------------------------*/
DRESULT disk_ioctl (
BYTE drv, /* Physical drive nmuber */
BYTE ctrl, /* Control code */
void *buff /* Buffer to send/receive data block */
)
{
rt_device_t device = disk[drv];
if (!device)
{
return RES_ERROR;
}
if (diskStat[drv] & STA_NOINIT)
{
return RES_NOTRDY;
}
if (rt_device_control(device, ctrl, buff) != RT_EOK)
{
return RES_ERROR;
}
else
{
return RES_OK;
}
}
#else
#include "diskio.h"
/* Inidialize a Drive */
DSTATUS disk_initialize(BYTE drv)
{
return 0;
}
/* Return Disk Status */
DSTATUS disk_status(BYTE drv)
{
return 0;
}
/* Read Sector(s) */
DRESULT disk_read(BYTE drv, BYTE *buff, DWORD sector, BYTE count)
{
rt_size_t result;
rt_device_t device = disk[drv];
result = rt_device_read(device, sector, buff, count);
if (result == count)
{
return RES_OK;
}
return RES_ERROR;
}
/* Write Sector(s) */
DRESULT disk_write(BYTE drv, const BYTE *buff, DWORD sector, BYTE count)
{
rt_size_t result;
rt_device_t device = disk[drv];
result = rt_device_write(device, sector, buff, count);
if (result == count)
{
return RES_OK;
}
return RES_ERROR;
}
/* Miscellaneous Functions */
DRESULT disk_ioctl(BYTE drv, BYTE ctrl, void *buff)
{
rt_device_t device = disk[drv];
if (device == RT_NULL)
return RES_ERROR;
if (ctrl == GET_SECTOR_COUNT)
{
struct rt_device_blk_geometry geometry;
rt_memset(&geometry, 0, sizeof(geometry));
rt_device_control(device, RT_DEVICE_CTRL_BLK_GETGEOME, &geometry);
*(DWORD *)buff = geometry.sector_count;
if (geometry.sector_count == 0)
return RES_ERROR;
}
else if (ctrl == GET_SECTOR_SIZE)
{
struct rt_device_blk_geometry geometry;
rt_memset(&geometry, 0, sizeof(geometry));
rt_device_control(device, RT_DEVICE_CTRL_BLK_GETGEOME, &geometry);
*(WORD *)buff = geometry.bytes_per_sector;
}
else if (ctrl == GET_BLOCK_SIZE) /* Get erase block size in unit of sectors (DWORD) */
{
struct rt_device_blk_geometry geometry;
rt_memset(&geometry, 0, sizeof(geometry));
rt_device_control(device, RT_DEVICE_CTRL_BLK_GETGEOME, &geometry);
*(DWORD *)buff = geometry.block_size/geometry.bytes_per_sector;
}
return RES_OK;
}
#endif
rt_time_t get_fattime(void)
{
return 0;
}
#if _FS_REENTRANT
int ff_cre_syncobj(BYTE drv, _SYNC_t *m)
{
char name[8];
rt_mutex_t mutex;
rt_snprintf(name, sizeof(name), "fat%d", drv);
mutex = rt_mutex_create(name, RT_IPC_FLAG_FIFO);
if (mutex != RT_NULL)
{
*m = mutex;
return RT_TRUE;
}
return RT_FALSE;
}
int ff_del_syncobj(_SYNC_t m)
{
rt_mutex_delete(m);
return RT_TRUE;
}
int ff_req_grant(_SYNC_t m)
{
if (rt_mutex_take(m, _FS_TIMEOUT) == RT_EOK)
return RT_TRUE;
return RT_FALSE;
}
void ff_rel_grant(_SYNC_t m)
{
rt_mutex_release(m);
}
#endif
bsp/efm32/copy_this_file_shell.c 已删除 100644 → 0
浏览文件 @ 92204470
/*
* File : shell.c
* This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006, RT-Thread Development Team
*
* The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE
*
* Change Logs:
* Date Author Notes
* 2006-04-30 Bernard the first verion for FinSH
* 2006-05-08 Bernard change finsh thread stack to 2048
* 2006-06-03 Bernard add support for skyeye
* 2006-09-24 Bernard remove the code related with hardware
* 2010-01-18 Bernard fix down then up key bug.
* 2010-03-19 Bernard fix backspace issue and fix device read in shell.
* 2010-04-01 Bernard add prompt output when start and remove the empty history
* 2011-02-23 Bernard fix variable section end issue of finsh shell
* initialization when use GNU GCC compiler.
*/
#include <rtthread.h>
#include <rthw.h>
#include "finsh.h"
#include "shell.h"
/* finsh thread */
static struct rt_thread finsh_thread;
ALIGN(RT_ALIGN_SIZE)
static char finsh_thread_stack[FINSH_THREAD_STACK_SIZE];
struct finsh_shell* shell;
#if defined(RT_USING_DFS) && defined(DFS_USING_WORKDIR)
#include <dfs_posix.h>
const char* finsh_get_prompt(void)
{
#define _PROMPT "finsh "
static char finsh_prompt[RT_CONSOLEBUF_SIZE + 1] = {_PROMPT};
/* get current working directory */
getcwd(&finsh_prompt[6], RT_CONSOLEBUF_SIZE - 8);
strcat(finsh_prompt, ">");
return finsh_prompt;
}
#endif
static rt_err_t finsh_rx_ind(rt_device_t dev, rt_size_t size)
{
RT_ASSERT(shell != RT_NULL);
/* release semaphore to let finsh thread rx data */
rt_sem_release(&shell->rx_sem);
return RT_EOK;
}
/**
* @ingroup finsh
*
* This function sets the input device of finsh shell.
*
* @param device_name the name of new input device.
*/
void finsh_set_device(const char* device_name)
{
rt_device_t dev = RT_NULL;
RT_ASSERT(shell != RT_NULL);
dev = rt_device_find(device_name);
if (dev != RT_NULL && rt_device_open(dev, RT_DEVICE_OFLAG_RDWR) == RT_EOK)
{
if (shell->device != RT_NULL)
{
/* close old finsh device */
rt_device_close(shell->device);
}
shell->device = dev;
rt_device_set_rx_indicate(dev, finsh_rx_ind);
}
else
{
rt_kprintf("finsh: can not find device:%s\n", device_name);
}
}
/**
* @ingroup finsh
*
* This function returns current finsh shell input device.
*
* @return the finsh shell input device name is returned.
*/
const char* finsh_get_device()
{
RT_ASSERT(shell != RT_NULL);
return shell->device->parent.name;
}
/**
* @ingroup finsh
*
* This function set the echo mode of finsh shell.
*
* FINSH_OPTION_ECHO=0x01 is echo mode, other values are none-echo mode.
*
* @param echo the echo mode
*/
void finsh_set_echo(rt_uint32_t echo)
{
RT_ASSERT(shell != RT_NULL);
shell->echo_mode = echo;
}
/**
* @ingroup finsh
*
* This function gets the echo mode of finsh shell.
*
* @return the echo mode
*/
rt_uint32_t finsh_get_echo()
{
RT_ASSERT(shell != RT_NULL);
return shell->echo_mode;
}
void finsh_auto_complete(char* prefix)
{
extern void list_prefix(char* prefix);
rt_kprintf("\n");
list_prefix(prefix);
rt_kprintf("%s%s", FINSH_PROMPT, prefix);
}
void finsh_run_line(struct finsh_parser* parser, const char *line)
{
const char* err_str;
rt_kprintf("\n");
finsh_parser_run(parser, (unsigned char*)line);
/* compile node root */
if (finsh_errno() == 0)
{
finsh_compiler_run(parser->root);
}
else
{
err_str = finsh_error_string(finsh_errno());
rt_kprintf("%s\n", err_str);
}
/* run virtual machine */
if (finsh_errno() == 0)
{
char ch;
finsh_vm_run();
ch = (unsigned char)finsh_stack_bottom();
if (ch > 0x20 && ch < 0x7e)
{
rt_kprintf("\t'%c', %d, 0x%08x\n",
(unsigned char)finsh_stack_bottom(),
(unsigned int)finsh_stack_bottom(),
(unsigned int)finsh_stack_bottom());
}
else
{
rt_kprintf("\t%d, 0x%08x\n",
(unsigned int)finsh_stack_bottom(),
(unsigned int)finsh_stack_bottom());
}
}
finsh_flush(parser);
}
#ifdef FINSH_USING_HISTORY
rt_bool_t finsh_handle_history(struct finsh_shell* shell, char ch)
{
/*
* handle up and down key
* up key : 0x1b 0x5b 0x41
* down key: 0x1b 0x5b 0x42
*/
if (ch == 0x1b)
{
shell->stat = WAIT_SPEC_KEY;
return RT_TRUE;
}
if ((shell->stat == WAIT_SPEC_KEY))
{
if (ch == 0x5b)
{
shell->stat = WAIT_FUNC_KEY;
return RT_TRUE;
}
shell->stat = WAIT_NORMAL;
return RT_FALSE;
}
if (shell->stat == WAIT_FUNC_KEY)
{
shell->stat = WAIT_NORMAL;
if (ch == 0x41) /* up key */
{
/* prev history */
if (shell->current_history > 0)shell->current_history --;
else
{
shell->current_history = 0;
return RT_TRUE;
}
/* copy the history command */
memcpy(shell->line, &shell->cmd_history[shell->current_history][0],
FINSH_CMD_SIZE);
shell->line_position = strlen(shell->line);
shell->use_history = 1;
}
else if (ch == 0x42) /* down key */
{
/* next history */
if (shell->current_history < shell->history_count - 1)
shell->current_history ++;
else
{
/* set to the end of history */
if (shell->history_count != 0)
{
shell->current_history = shell->history_count - 1;
}
else return RT_TRUE;
}
memcpy(shell->line, &shell->cmd_history[shell->current_history][0],
FINSH_CMD_SIZE);
shell->line_position = strlen(shell->line);
shell->use_history = 1;
}
if (shell->use_history)
{
rt_kprintf("\033[2K\r");
rt_kprintf("%s%s", FINSH_PROMPT, shell->line);
return RT_TRUE;;
}
}
return RT_FALSE;
}
void finsh_push_history(struct finsh_shell* shell)
{
if ((shell->use_history == 0) && (shell->line_position != 0))
{
/* push history */
if (shell->history_count >= FINSH_HISTORY_LINES)
{
/* move history */
int index;
for (index = 0; index < FINSH_HISTORY_LINES - 1; index ++)
{
memcpy(&shell->cmd_history[index][0],
&shell->cmd_history[index + 1][0], FINSH_CMD_SIZE);
}
memset(&shell->cmd_history[index][0], 0, FINSH_CMD_SIZE);
memcpy(&shell->cmd_history[index][0], shell->line, shell->line_position);
/* it's the maximum history */
shell->history_count = FINSH_HISTORY_LINES;
}
else
{
memset(&shell->cmd_history[shell->history_count][0], 0, FINSH_CMD_SIZE);
memcpy(&shell->cmd_history[shell->history_count][0], shell->line, shell->line_position);
/* increase count and set current history position */
shell->history_count ++;
}
}
shell->current_history = shell->history_count;
}
#endif
#ifndef RT_USING_HEAP
struct finsh_shell _shell;
#endif
void finsh_thread_entry(void* parameter)
{
char ch;
/* test: for efm32 low power mode */
emu_all_disable();
/* normal is echo mode */
shell->echo_mode = 1;
finsh_init(&shell->parser);
rt_kprintf(FINSH_PROMPT);
while (1)
{
/* test: for efm32 low power mode */
emu_em2_enable();
/* wait receive */
if (rt_sem_take(&shell->rx_sem, RT_WAITING_FOREVER) != RT_EOK) continue;
/* test: for efm32 low power mode */
emu_em2_disable();
/* read one character from device */
while (rt_device_read(shell->device, 0, &ch, 1) == 1)
{
/* handle history key */
#ifdef FINSH_USING_HISTORY
if (finsh_handle_history(shell, ch) == RT_TRUE) continue;
#endif
/* handle CR key */
if (ch == '\r')
{
char next;
if (rt_device_read(shell->device, 0, &next, 1) == 1)
ch = next;
else ch = '\r';
}
/* handle tab key */
else if (ch == '\t')
{
/* auto complete */
finsh_auto_complete(&shell->line[0]);
/* re-calculate position */
shell->line_position = strlen(shell->line);
continue;
}
/* handle backspace key */
else if (ch == 0x7f || ch == 0x08)
{
if (shell->line_position != 0)
{
rt_kprintf("%c %c", ch, ch);
}
if (shell->line_position <= 0) shell->line_position = 0;
else shell->line_position --;
shell->line[shell->line_position] = 0;
continue;
}
/* handle end of line, break */
if (ch == '\r' || ch == '\n')
{
/* change to ';' and break */
shell->line[shell->line_position] = ';';
#ifdef FINSH_USING_HISTORY
finsh_push_history(shell);
#endif
if (shell->line_position != 0) finsh_run_line(&shell->parser, shell->line);
else rt_kprintf("\n");
rt_kprintf(FINSH_PROMPT);
memset(shell->line, 0, sizeof(shell->line));
shell->line_position = 0;
break;
}
/* it's a large line, discard it */
if (shell->line_position >= FINSH_CMD_SIZE) shell->line_position = 0;
/* normal character */
shell->line[shell->line_position] = ch; ch = 0;
if (shell->echo_mode) rt_kprintf("%c", shell->line[shell->line_position]);
shell->line_position ++;
shell->use_history = 0; /* it's a new command */
} /* end of device read */
}
}
void finsh_system_function_init(const void* begin, const void* end)
{
_syscall_table_begin = (struct finsh_syscall*) begin;
_syscall_table_end = (struct finsh_syscall*) end;
}
void finsh_system_var_init(const void* begin, const void* end)
{
_sysvar_table_begin = (struct finsh_sysvar*) begin;
_sysvar_table_end = (struct finsh_sysvar*) end;
}
#if defined(__ICCARM__) /* for IAR compiler */
#ifdef FINSH_USING_SYMTAB
#pragma section="FSymTab"
#pragma section="VSymTab"
#endif
#endif
/*
* @ingroup finsh
*
* This function will initialize finsh shell
*/
int finsh_system_init(void)
{
rt_err_t result;
#ifdef FINSH_USING_SYMTAB
#ifdef __CC_ARM /* ARM C Compiler */
extern const int FSymTab$$Base;
extern const int FSymTab$$Limit;
extern const int VSymTab$$Base;
extern const int VSymTab$$Limit;
finsh_system_function_init(&FSymTab$$Base, &FSymTab$$Limit);
finsh_system_var_init(&VSymTab$$Base, &VSymTab$$Limit);
#elif defined (__ICCARM__) /* for IAR Compiler */
finsh_system_function_init(__section_begin("FSymTab"),
__section_end("FSymTab"));
finsh_system_var_init(__section_begin("VSymTab"),
__section_end("VSymTab"));
#elif defined (__GNUC__) /* GNU GCC Compiler */
extern const int __fsymtab_start;
extern const int __fsymtab_end;
extern const int __vsymtab_start;
extern const int __vsymtab_end;
finsh_system_function_init(&__fsymtab_start, &__fsymtab_end);
finsh_system_var_init(&__vsymtab_start, &__vsymtab_end);
#endif
#endif
/* create or set shell structure */
#ifdef RT_USING_HEAP
shell = (struct finsh_shell*)rt_malloc(sizeof(struct finsh_shell));
#else
shell = &_shell;
#endif
if (shell == RT_NULL)
{
rt_kprintf("no memory for shell\n");
return;
}
memset(shell, 0, sizeof(struct finsh_shell));
rt_sem_init(&(shell->rx_sem), "shrx", 0, 0);
result = rt_thread_init(&finsh_thread,
"tshell",
finsh_thread_entry, RT_NULL,
&finsh_thread_stack[0], sizeof(finsh_thread_stack),
FINSH_THREAD_PRIORITY, 10);
if (result == RT_EOK)
rt_thread_startup(&finsh_thread);
}
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或