chinky/rtt-f030
chinky
/
rtt-f030
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

1) elm fatfs can do mkfs without mounting first, 2) use new mkfs 3)change linebreak in dfs_uffs.c to unix

This commit is contained in:
prife 2013-01-08 20:43:52 +08:00
parent 530fc903a4 4bc0347b11
commit b3cf278502
5 changed files with 584 additions and 528 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

161
components/dfs/filesystems/elmfat/dfs_elm.c
View File

@ -75,38 +75,50 @@ static int elm_result_to_dfs(FRESULT result)
return status;
}
/* results:
* -1, no space to install fatfs driver
* >= 0, there is an space to install fatfs driver
*/
static int get_disk(rt_device_t id)
{
int index;
for (index = 0; index < _VOLUMES; index ++)
{
if (disk[index] == id)
return index;
}
return -1;
}
int dfs_elm_mount(struct dfs_filesystem *fs, unsigned long rwflag, const void *data)
{
FATFS *fat;
FRESULT result;
BYTE index;
int index;
/* handle RT-Thread device routine */
for (index = 0; index < _VOLUMES; index ++)
{
if (disk[index] == RT_NULL)
{
break;
}
}
if (index == _VOLUMES)
/* get an empty position */
index = get_disk(RT_NULL);
if (index == -1)
return -DFS_STATUS_ENOSPC;
/* get device */
/* save device */
disk[index] = fs->dev_id;
fat = (FATFS *)rt_malloc(sizeof(FATFS));
if (fat == RT_NULL)
{
disk[index] = RT_NULL;
return -1;
}
/* mount fatfs, always 0 logic driver */
result = f_mount(index, fat);
result = f_mount((BYTE)index, fat);
if (result == FR_OK)
{
char drive[8];
DIR * dir;
DIR *dir;
rt_snprintf(drive, sizeof(drive), "%d:/", index);
dir = (DIR *)rt_malloc(sizeof(DIR));
@ -116,68 +128,106 @@ int dfs_elm_mount(struct dfs_filesystem *fs, unsigned long rwflag, const void *d
/* open the root directory to test whether the fatfs is valid */
result = f_opendir(dir, drive);
if (result != FR_OK)
{
rt_free(dir);
return elm_result_to_dfs(result);
}
rt_free(dir);
goto __err;
/* mount succeed! */
fs->data = fat;
rt_free(dir);
return 0;
}
else
{
__err:
disk[index] = RT_NULL;
rt_free(fat);
return elm_result_to_dfs(result);
}
return 0;
}
int dfs_elm_unmount(struct dfs_filesystem *fs)
{
FATFS *fat;
FRESULT result;
BYTE index;
int 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);
index = get_disk(fs->dev_id);
if (index == -1) /* not found */
return -DFS_STATUS_ENOENT;
result = f_mount((BYTE)index, RT_NULL);
if (result != FR_OK)
return elm_result_to_dfs(result);
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_OK;
}
int dfs_elm_mkfs(const char *device_name)
int dfs_elm_mkfs(rt_device_t dev_id)
{
BYTE drv;
rt_device_t dev;
#define FSM_STATUS_INIT 0
#define FSM_STATUS_USE_TEMP_DRIVER 1
FATFS *fat;
int flag;
FRESULT result;
int index;
/* find device name */
for (drv = 0; drv < _VOLUMES; drv ++)
if (dev_id == RT_NULL)
return -DFS_STATUS_EINVAL;
/* if the device is already mounted, then just do mkfs to the drv,
* while if it is not mounted yet, then find an empty drive to do mkfs
*/
flag = FSM_STATUS_INIT;
index = get_disk(dev_id);
if (index == -1)
{
dev = disk[drv];
if (dev != RT_NULL && rt_strncmp(dev->parent.name, device_name, RT_NAME_MAX) == 0)
/* not found the device id */
index = get_disk(RT_NULL);
if (index == -1)
{
/* no space to store an temp driver */
rt_kprintf("sorry, there is no space to do mkfs! \n");
return -DFS_STATUS_ENOSPC;
}
else
{
fat = rt_malloc(sizeof(FATFS));
if (fat == RT_NULL)
return -DFS_STATUS_ENOMEM;
flag = FSM_STATUS_USE_TEMP_DRIVER;
disk[index] = dev_id;
/* just fill the FatFs[vol] in ff.c, or mkfs will failded!
* consider this condition: you just umount the elm fat,
* then the space in FatFs[index] is released, and now do mkfs
* on the disk, you will get a failure. so we need f_mount here,
* just fill the FatFS[index] in elm fatfs to make mkfs work.
*/
f_mount((BYTE)index, fat);
}
}
/* 1: no partition table */
/* 0: auto selection of cluster size */
result = f_mkfs(drv, 1, 0);
result = f_mkfs((BYTE)index, 1, 0);
/* check flag status, we need clear the temp driver stored in disk[] */
if (flag == FSM_STATUS_USE_TEMP_DRIVER)
{
rt_free(fat);
f_mount((BYTE)index, RT_NULL);
disk[index] = RT_NULL;
}
if (result != FR_OK)
{
rt_kprintf("format error\n");
@ -185,12 +235,6 @@ int dfs_elm_mkfs(const char *device_name)
}
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)
@ -234,7 +278,7 @@ int dfs_elm_open(struct dfs_fd *file)
#if (_VOLUMES > 1)
int vol;
extern int elm_get_vol(FATFS *fat);
extern int elm_get_vol(FATFS * fat);
/* add path for ELM FatFS driver support */
vol = elm_get_vol((FATFS *)file->fs->data);
@ -513,7 +557,7 @@ int dfs_elm_getdents(struct dfs_fd *file, struct dirent *dirp, rt_uint32_t count
break;
#if _USE_LFN
fn = *fno.lfname? fno.lfname : fno.fname;
fn = *fno.lfname ? fno.lfname : fno.fname;
#else
fn = fno.fname;
#endif
@ -552,7 +596,7 @@ int dfs_elm_unlink(struct dfs_filesystem *fs, const char *path)
#if _VOLUMES > 1
int vol;
char *drivers_fn;
extern int elm_get_vol(FATFS *fat);
extern int elm_get_vol(FATFS * fat);
/* add path for ELM FatFS driver support */
vol = elm_get_vol((FATFS *)fs->data);
@ -583,7 +627,7 @@ int dfs_elm_rename(struct dfs_filesystem *fs, const char *oldpath, const char *n
char *drivers_oldfn;
const char *drivers_newfn;
int vol;
extern int elm_get_vol(FATFS *fat);
extern int elm_get_vol(FATFS * fat);
/* add path for ELM FatFS driver support */
vol = elm_get_vol((FATFS *)fs->data);
@ -618,7 +662,7 @@ int dfs_elm_stat(struct dfs_filesystem *fs, const char *path, struct stat *st)
#if _VOLUMES > 1
int vol;
char *drivers_fn;
extern int elm_get_vol(FATFS *fat);
extern int elm_get_vol(FATFS * fat);
/* add path for ELM FatFS driver support */
vol = elm_get_vol((FATFS *)fs->data);
@ -783,7 +827,7 @@ DRESULT disk_ioctl(BYTE drv, BYTE ctrl, void *buff)
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;
}
else if (ctrl == CTRL_SYNC)
{
@ -821,6 +865,7 @@ int ff_cre_syncobj(BYTE drv, _SYNC_t *m)
int ff_del_syncobj(_SYNC_t m)
{
if (m != RT_NULL)
rt_mutex_delete(m);
return RT_TRUE;
@ -844,13 +889,13 @@ void ff_rel_grant(_SYNC_t m)
/* Memory functions */
#if _USE_LFN == 3
/* Allocate memory block */
void* ff_memalloc (UINT size)
void *ff_memalloc(UINT size)
{
return rt_malloc(size);
}
/* Free memory block */
void ff_memfree (void* mem)
void ff_memfree(void *mem)
{
rt_free(mem);
}

2
components/dfs/filesystems/jffs2/dfs_jffs2.c
View File

@ -222,7 +222,7 @@ static int dfs_jffs2_unmount(struct dfs_filesystem* fs)
return -DFS_STATUS_ENOENT;
}
static int dfs_jffs2_mkfs(const char* device_name)
static int dfs_jffs2_mkfs(rt_device_t dev_id)
{
/* just erase all blocks on this nand partition */
return -DFS_STATUS_ENOSYS;

6
components/dfs/filesystems/uffs/dfs_uffs.c
View File

@ -207,7 +207,7 @@ static int dfs_uffs_unmount(struct dfs_filesystem* fs)
return -DFS_STATUS_ENOENT;
}
static int dfs_uffs_mkfs(const char* device_name)
static int dfs_uffs_mkfs(rt_device_t dev_id)
{
rt_base_t index;
rt_uint32_t block;
@ -216,15 +216,13 @@ static int dfs_uffs_mkfs(const char* device_name)
/*1. find the device index */
for (index = 0; index < UFFS_DEVICE_MAX; index++)
{
if (rt_strncmp(nand_part[index].dev->parent.parent.name,
device_name, RT_NAME_MAX) == 0)
if (nand_part[index].dev == (struct rt_mtd_nand_device *)dev_id)
break;
}
if (index == UFFS_DEVICE_MAX)
{
/* can't find device driver */
rt_kprintf("can not find device driver: %s\n", device_name);
return -DFS_STATUS_ENOENT;
}

2
components/dfs/include/dfs_fs.h
View File

@ -35,7 +35,7 @@ struct dfs_filesystem_operation
int (*unmount) (struct dfs_filesystem *fs);
/* make a file system */
int (*mkfs) (const char *device_name);
int (*mkfs) (rt_device_t devid);
int (*statfs) (struct dfs_filesystem *fs, struct statfs *buf);
int (*open) (struct dfs_fd *fd);

15
components/dfs/src/dfs_fs.c
View File

@ -424,6 +424,19 @@ err1:
int dfs_mkfs(const char *fs_name, const char *device_name)
{
int index;
rt_device_t dev_id;
/* check device name, and it should not be NULL */
if (device_name == RT_NULL)
dev_id = RT_NULL;
else
dev_id = rt_device_find(device_name);
if (dev_id == RT_NULL)
{
rt_set_errno(-DFS_STATUS_ENODEV);
return -1;
}
/* lock file system */
dfs_lock();
@ -438,7 +451,7 @@ int dfs_mkfs(const char *fs_name, const char *device_name)
dfs_unlock();
if (ops->mkfs != RT_NULL)
return ops->mkfs(device_name);
return ops->mkfs(dev_id);
break;
}