770 lines
15 KiB
C
770 lines
15 KiB
C
#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_def.h>
|
|
|
|
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;
|
|
buf->f_bsize = 512;
|
|
|
|
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;
|
|
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, *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 = rt_malloc(256);
|
|
if (drivers_newfn == RT_NULL)
|
|
{
|
|
rt_free(drivers_oldfn);
|
|
return -DFS_STATUS_ENOMEM;
|
|
}
|
|
|
|
rt_snprintf(drivers_oldfn, 256, "%d:%s", vol, oldpath);
|
|
rt_snprintf(drivers_newfn, 256, "%d:%s", vol, newpath);
|
|
#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);
|
|
rt_free(drivers_newfn);
|
|
#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;
|
|
st->st_blksize = 512;
|
|
}
|
|
|
|
#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)
|
|
{
|
|
/* register fatfs file system */
|
|
dfs_register(&dfs_elm);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* RT-Thread Device Interface for ELM FatFs
|
|
*/
|
|
#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;
|
|
}
|
|
|
|
rt_time_t get_fattime()
|
|
{
|
|
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
|