diff options
Diffstat (limited to 'bsp/efm32/copy_this_file_dfs_elm.c')
| -rw-r--r-- | bsp/efm32/copy_this_file_dfs_elm.c | 1170 |
1 files changed, 585 insertions, 585 deletions
diff --git a/bsp/efm32/copy_this_file_dfs_elm.c b/bsp/efm32/copy_this_file_dfs_elm.c index a6adbce114..8d36dd7c88 100644 --- a/bsp/efm32/copy_this_file_dfs_elm.c +++ b/bsp/efm32/copy_this_file_dfs_elm.c @@ -9,7 +9,7 @@ * 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" @@ -30,658 +30,658 @@ static rt_device_t disk[_VOLUMES] = {0}; static int elm_result_to_dfs(FRESULT result) { - int status = DFS_STATUS_OK; + int status = DFS_STATUS_OK; - switch (result) - { - case FR_OK: - break; + 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_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_INVALID_NAME: + status = -DFS_STATUS_EINVAL; + break; - case FR_EXIST: - case FR_INVALID_OBJECT: - status = -DFS_STATUS_EEXIST; - 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_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_WRITE_PROTECTED: + case FR_DENIED: + status = -DFS_STATUS_EROFS; + break; - case FR_MKFS_ABORTED: - status = -DFS_STATUS_EINVAL; - break; + case FR_MKFS_ABORTED: + status = -DFS_STATUS_EINVAL; + break; - default: - status = -1; - break; - } + default: + status = -1; + break; + } - return status; + return status; } int dfs_elm_mount(struct dfs_filesystem *fs, unsigned long rwflag, const void *data) { - FATFS *fat; - FRESULT result; - rt_uint32_t index; + 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; + /* 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; + /* get device */ + disk[index] = fs->dev_id; - fat = (FATFS *)rt_malloc(sizeof(FATFS)); - if (fat == RT_NULL) - { - return -1; - } + 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); - } + /* 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; + return 0; } int dfs_elm_unmount(struct dfs_filesystem *fs) { - FATFS *fat; - FRESULT result; - rt_uint32_t index; + FATFS *fat; + FRESULT result; + rt_uint32_t index; - fat = (FATFS *)fs->data; + fat = (FATFS *)fs->data; - RT_ASSERT(fat != RT_NULL); + 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); + /* 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; - } - } - } + if (result == FR_OK) + { + fs->data = RT_NULL; + disk[index] = RT_NULL; + rt_free(fat); + return DFS_STATUS_OK; + } + } + } - return -DFS_STATUS_ENOENT; + return -DFS_STATUS_ENOENT; } int dfs_elm_mkfs(const char *device_name) { - BYTE drv; - rt_device_t dev; - FRESULT result; + 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); - } + /* 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; - } - } + return DFS_STATUS_OK; + } + } - /* can't find device driver */ - rt_kprintf("can not find device driver: %s\n", device_name); - return -DFS_STATUS_EIO; + /* 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; + FATFS *f; + FRESULT res; + char driver[4]; + DWORD fre_clust, fre_sect, tot_sect; - RT_ASSERT(fs != RT_NULL); - RT_ASSERT(buf != RT_NULL); + RT_ASSERT(fs != RT_NULL); + RT_ASSERT(buf != RT_NULL); - f = (FATFS *)fs->data; + 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); + 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; + /* 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; + buf->f_bfree = fre_sect; + buf->f_blocks = tot_sect; #if _MAX_SS != 512 - buf->f_bsize = f->ssize; + buf->f_bsize = f->ssize; #else buf->f_bsize = 512; #endif - return 0; + return 0; } int dfs_elm_open(struct dfs_fd *file) { - FIL *fd; - BYTE mode; - FRESULT result; - char *drivers_fn; + FIL *fd; + BYTE mode; + FRESULT result; + char *drivers_fn; #if (_VOLUMES > 1) - int vol; - extern int elm_get_vol(FATFS *fat); + 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; + /* 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); + rt_snprintf(drivers_fn, 256, "%d:%s", vol, file->path); #else - drivers_fn = file->path; + drivers_fn = file->path; #endif - if (file->flags & DFS_O_DIRECTORY) - { - DIR *dir; + if (file->flags & DFS_O_DIRECTORY) + { + DIR *dir; - if (file->flags & DFS_O_CREAT) - { - result = f_mkdir(drivers_fn); - if (result != FR_OK) - { + if (file->flags & DFS_O_CREAT) + { + result = f_mkdir(drivers_fn); + if (result != FR_OK) + { #if _VOLUMES > 1 - rt_free(drivers_fn); + rt_free(drivers_fn); #endif - return elm_result_to_dfs(result); - } - } + return elm_result_to_dfs(result); + } + } - /* open directory */ - dir = (DIR *)rt_malloc(sizeof(DIR)); - if (dir == RT_NULL) - { + /* open directory */ + dir = (DIR *)rt_malloc(sizeof(DIR)); + if (dir == RT_NULL) + { #if _VOLUMES > 1 - rt_free(drivers_fn); + rt_free(drivers_fn); #endif - return -DFS_STATUS_ENOMEM; - } + return -DFS_STATUS_ENOMEM; + } - result = f_opendir(dir, drivers_fn); + result = f_opendir(dir, drivers_fn); #if _VOLUMES > 1 - rt_free(drivers_fn); + rt_free(drivers_fn); #endif - if (result != FR_OK) - { - rt_free(dir); - return elm_result_to_dfs(result); - } + if (result != FR_OK) + { + rt_free(dir); + return elm_result_to_dfs(result); + } - file->data = dir; - return DFS_STATUS_OK; - } - else - { - mode = FA_READ; + 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; + 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; - } + /* allocate a fd */ + fd = (FIL *)rt_malloc(sizeof(FIL)); + if (fd == RT_NULL) + { + return -DFS_STATUS_ENOMEM; + } - result = f_open(fd, drivers_fn, mode); + result = f_open(fd, drivers_fn, mode); #if _VOLUMES > 1 - rt_free(drivers_fn); + rt_free(drivers_fn); #endif - if (result == FR_OK) - { - file->pos = fd->fptr; - file->size = fd->fsize; - file->data = fd; + 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); - } - } + 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; + return DFS_STATUS_OK; } int dfs_elm_close(struct dfs_fd *file) { - FRESULT result; + FRESULT result; - result = FR_OK; - if (file->type == FT_DIRECTORY) - { - DIR *dir; + result = FR_OK; + if (file->type == FT_DIRECTORY) + { + DIR *dir; - dir = (DIR *)(file->data); - RT_ASSERT(dir != RT_NULL); + 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); + /* 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); - } - } + result = f_close(fd); + if (result == FR_OK) + { + /* release memory */ + rt_free(fd); + } + } - return elm_result_to_dfs(result); + return elm_result_to_dfs(result); } -int dfs_elm_ioctl(struct dfs_fd *file, int cmd, void *args) +int dfs_elm_ioctl(struct dfs_fd *file, int cmd, void *args) { - return -DFS_STATUS_ENOSYS; + 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; + FIL *fd; + FRESULT result; + UINT byte_read; - if (file->type == FT_DIRECTORY) - { - return -DFS_STATUS_EISDIR; - } + if (file->type == FT_DIRECTORY) + { + return -DFS_STATUS_EISDIR; + } - fd = (FIL *)(file->data); - RT_ASSERT(fd != RT_NULL); + 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; + 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); + 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; + FIL *fd; + FRESULT result; + UINT byte_write; - if (file->type == FT_DIRECTORY) - { - return -DFS_STATUS_EISDIR; - } + if (file->type == FT_DIRECTORY) + { + return -DFS_STATUS_EISDIR; + } - fd = (FIL *)(file->data); - RT_ASSERT(fd != RT_NULL); + 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; + 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); + return elm_result_to_dfs(result); } int dfs_elm_flush(struct dfs_fd *file) { - FIL *fd; - FRESULT result; + FIL *fd; + FRESULT result; - fd = (FIL *)(file->data); - RT_ASSERT(fd != RT_NULL); + fd = (FIL *)(file->data); + RT_ASSERT(fd != RT_NULL); - result = f_sync(fd); - return elm_result_to_dfs(result); + 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; + 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; + /* regular file type */ + fd = (FIL *)(file->data); + RT_ASSERT(fd != RT_NULL); - dir = (DIR *)(file->data); - RT_ASSERT(dir != 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; - result = f_seekdir(dir, offset / sizeof(struct dirent)); - if (result == FR_OK) - { - /* update file position */ - file->pos = offset; - return file->pos; - } - } + dir = (DIR *)(file->data); + RT_ASSERT(dir != RT_NULL); - return elm_result_to_dfs(result); + 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; + FILINFO fno; + FRESULT result; + rt_uint32_t index; + struct dirent *d; - dir = (DIR *)(file->data); - RT_ASSERT(dir != RT_NULL); + 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; + /* 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; + /* allocate long file name */ + fno.lfname = rt_malloc(256); + fno.lfsize = 256; #endif - index = 0; - while (1) - { - char *fn; + index = 0; + while (1) + { + char *fn; - d = dirp + index; + d = dirp + index; - result = f_readdir(dir, &fno); - if (result != FR_OK || fno.fname[0] == 0) - break; + result = f_readdir(dir, &fno); + if (result != FR_OK || fno.fname[0] == 0) + break; #if _USE_LFN - fn = *fno.lfname? fno.lfname : fno.fname; + fn = *fno.lfname? fno.lfname : fno.fname; #else - fn = fno.fname; + 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_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); + 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; - } + index ++; + if (index * sizeof(struct dirent) >= count) + break; + } #if _USE_LFN - rt_free(fno.lfname); + rt_free(fno.lfname); #endif - if (index == 0) - return elm_result_to_dfs(result); + if (index == 0) + return elm_result_to_dfs(result); - file->pos += index * sizeof(struct dirent); + file->pos += index * sizeof(struct dirent); - return index * sizeof(struct dirent); + return index * sizeof(struct dirent); } int dfs_elm_unlink(struct dfs_filesystem *fs, const char *path) { - FRESULT result; + FRESULT result; #if _VOLUMES > 1 - int vol; - char *drivers_fn; - extern int elm_get_vol(FATFS *fat); + 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; + /* 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); + rt_snprintf(drivers_fn, 256, "%d:%s", vol, path); #else - const char *drivers_fn; - drivers_fn = path; + const char *drivers_fn; + drivers_fn = path; #endif - result = f_unlink(drivers_fn); + result = f_unlink(drivers_fn); #if _VOLUMES > 1 - rt_free(drivers_fn); + rt_free(drivers_fn); #endif - return elm_result_to_dfs(result); + return elm_result_to_dfs(result); } int dfs_elm_rename(struct dfs_filesystem *fs, const char *oldpath, const char *newpath) { - FRESULT result; + FRESULT result; #if _VOLUMES > 1 - char *drivers_oldfn; - const char *drivers_newfn; - int vol; - extern int elm_get_vol(FATFS *fat); + 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; + /* 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; + 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); + rt_snprintf(drivers_oldfn, 256, "%d:%s", vol, oldpath); #else - const char *drivers_oldfn, *drivers_newfn; + const char *drivers_oldfn, *drivers_newfn; - drivers_oldfn = oldpath; - drivers_newfn = newpath; + drivers_oldfn = oldpath; + drivers_newfn = newpath; #endif - result = f_rename(drivers_oldfn, drivers_newfn); + result = f_rename(drivers_oldfn, drivers_newfn); #if _VOLUMES > 1 - rt_free(drivers_oldfn); + rt_free(drivers_oldfn); #endif - return elm_result_to_dfs(result); + 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; + FILINFO file_info; + FRESULT result; #if _VOLUMES > 1 - int vol; - char *drivers_fn; - extern int elm_get_vol(FATFS *fat); + 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; + /* 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); + rt_snprintf(drivers_fn, 256, "%d:%s", vol, path); #else - const char *drivers_fn; - drivers_fn = path; + 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; + /* allocate long file name */ + file_info.lfname = rt_malloc(256); + file_info.lfsize = 256; #endif - result = f_stat(drivers_fn, &file_info); + result = f_stat(drivers_fn, &file_info); #if _VOLUMES > 1 - rt_free(drivers_fn); + rt_free(drivers_fn); #endif - if (result == FR_OK) - { - /* convert to dfs stat structure */ - st->st_dev = 0; + 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_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; - } + st->st_size = file_info.fsize; + st->st_mtime = file_info.ftime; + } #if _USE_LFN - rt_free(file_info.lfname); + rt_free(file_info.lfname); #endif - return elm_result_to_dfs(result); + 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, + "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, + 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; + int i; - for (i = 0; i < _VOLUMES; i++) - { - diskStat[i] = STA_NOINIT; - } + for (i = 0; i < _VOLUMES; i++) + { + diskStat[i] = STA_NOINIT; + } #endif /* register fatfs file system */ dfs_register(&dfs_elm); - return 0; + return 0; } /* @@ -692,70 +692,70 @@ int elm_init(void) /* Initialize Disk Drive */ /*-----------------------------------------------------------------------*/ DSTATUS disk_initialize ( - BYTE drv /* Physical drive nmuber */ - ) + BYTE drv /* Physical drive nmuber */ + ) { - rt_device_t device = disk[drv]; + rt_device_t device = disk[drv]; - if (!device) - { - return RES_ERROR; - } - if (diskStat[drv] & STA_NODISK) - { - /* No card in the socket */ - return diskStat[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; + /* Initialize hardware: the actual operation is performed in dfs_mount() */ + diskStat[drv] &= ~STA_NOINIT; - return diskStat[drv]; + return diskStat[drv]; } /*-----------------------------------------------------------------------*/ /* Get Disk Status */ /*-----------------------------------------------------------------------*/ DSTATUS disk_status ( - BYTE drv /* Physical drive nmuber */ - ) + BYTE drv /* Physical drive nmuber */ + ) { - return diskStat[drv]; + 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) */ - ) + 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]; + 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 (!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; - } + if (rt_device_read(device, sector, buff, count) != count) + { + return RES_ERROR; + } + else + { + return RES_OK; + } } /*-----------------------------------------------------------------------*/ @@ -763,39 +763,39 @@ DRESULT disk_read ( /*-----------------------------------------------------------------------*/ #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) */ - ) + 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]; + 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 (!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; - } + if (rt_device_write(device, sector, buff, count) != count) + { + return RES_ERROR; + } + else + { + return RES_OK; + } } #endif /* _READONLY */ @@ -803,30 +803,30 @@ DRESULT disk_write ( /* Miscellaneous Functions */ /*-----------------------------------------------------------------------*/ DRESULT disk_ioctl ( - BYTE drv, /* Physical drive nmuber */ - BYTE ctrl, /* Control code */ - void *buff /* Buffer to send/receive data block */ + BYTE drv, /* Physical drive nmuber */ + BYTE ctrl, /* Control code */ + void *buff /* Buffer to send/receive data block */ ) { - rt_device_t device = disk[drv]; + rt_device_t device = disk[drv]; - if (!device) - { - return RES_ERROR; - } - if (diskStat[drv] & STA_NOINIT) - { - return RES_NOTRDY; - } + 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; - } + if (rt_device_control(device, ctrl, buff) != RT_EOK) + { + return RES_ERROR; + } + else + { + return RES_OK; + } } #else #include "diskio.h" @@ -834,90 +834,90 @@ DRESULT disk_ioctl ( /* Inidialize a Drive */ DSTATUS disk_initialize(BYTE drv) { - return 0; + return 0; } /* Return Disk Status */ DSTATUS disk_status(BYTE drv) { - return 0; + 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]; + rt_size_t result; + rt_device_t device = disk[drv]; - result = rt_device_read(device, sector, buff, count); - if (result == count) - { - return RES_OK; - } + result = rt_device_read(device, sector, buff, count); + if (result == count) + { + return RES_OK; + } - return RES_ERROR; + 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]; + rt_size_t result; + rt_device_t device = disk[drv]; - result = rt_device_write(device, sector, buff, count); - if (result == count) - { - return RES_OK; - } + result = rt_device_write(device, sector, buff, count); + if (result == count) + { + return RES_OK; + } - return RES_ERROR; + return RES_ERROR; } /* Miscellaneous Functions */ DRESULT disk_ioctl(BYTE drv, BYTE ctrl, void *buff) { - rt_device_t device = disk[drv]; + rt_device_t device = disk[drv]; - if (device == RT_NULL) - return RES_ERROR; + if (device == RT_NULL) + return RES_ERROR; - if (ctrl == GET_SECTOR_COUNT) - { - struct rt_device_blk_geometry geometry; + 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); + 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; + *(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); + 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; + *(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); + 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; - } + *(DWORD *)buff = geometry.block_size/geometry.bytes_per_sector; + } - return RES_OK; + return RES_OK; } #endif rt_time_t get_fattime(void) { - return 0; + return 0; } #if _FS_REENTRANT @@ -947,14 +947,14 @@ int ff_del_syncobj(_SYNC_t m) int ff_req_grant(_SYNC_t m) { if (rt_mutex_take(m, _FS_TIMEOUT) == RT_EOK) - return RT_TRUE; + return RT_TRUE; return RT_FALSE; } void ff_rel_grant(_SYNC_t m) { - rt_mutex_release(m); + rt_mutex_release(m); } #endif |