Include dependency graph for ff.c:
Go to the source code of this file.
Macros | |
| #define | SS(fs) ((fs)->ssize) /* Variable sector size */ |
| #define | ENTER_FF(fs) |
| #define | LEAVE_FF(fs, res) return res |
| #define | ABORT(fs, res) { fp->flag |= FA__ERROR; LEAVE_FF(fs, res); } |
| #define | IsUpper(c) (((c)>='A')&&((c)<='Z')) |
| #define | IsLower(c) (((c)>='a')&&((c)<='z')) |
| #define | IsDigit(c) (((c)>='0')&&((c)<='9')) |
| #define | IsDBCS1(c) 0 |
| #define | IsDBCS2(c) 0 |
| #define | NS 11 /* Index of name status byte in fn[] */ |
| #define | NS_LOSS 0x01 /* Out of 8.3 format */ |
| #define | NS_LFN 0x02 /* Force to create LFN entry */ |
| #define | NS_LAST 0x04 /* Last segment */ |
| #define | NS_BODY 0x08 /* Lower case flag (body) */ |
| #define | NS_EXT 0x10 /* Lower case flag (ext) */ |
| #define | NS_DOT 0x20 /* Dot entry */ |
| #define | MIN_FAT16 4086 /* Minimum number of clusters for FAT16 */ |
| #define | MIN_FAT32 65526 /* Minimum number of clusters for FAT32 */ |
| #define | BS_jmpBoot 0 /* Jump instruction (3) */ |
| #define | BS_OEMName 3 /* OEM name (8) */ |
| #define | BPB_BytsPerSec 11 /* Sector size [byte] (2) */ |
| #define | BPB_SecPerClus 13 /* Cluster size [sector] (1) */ |
| #define | BPB_RsvdSecCnt 14 /* Size of reserved area [sector] (2) */ |
| #define | BPB_NumFATs 16 /* Number of FAT copies (1) */ |
| #define | BPB_RootEntCnt 17 /* Number of root dir entries for FAT12/16 (2) */ |
| #define | BPB_TotSec16 19 /* Volume size [sector] (2) */ |
| #define | BPB_Media 21 /* Media descriptor (1) */ |
| #define | BPB_FATSz16 22 /* FAT size [sector] (2) */ |
| #define | BPB_SecPerTrk 24 /* Track size [sector] (2) */ |
| #define | BPB_NumHeads 26 /* Number of heads (2) */ |
| #define | BPB_HiddSec 28 /* Number of special hidden sectors (4) */ |
| #define | BPB_TotSec32 32 /* Volume size [sector] (4) */ |
| #define | BS_DrvNum 36 /* Physical drive number (2) */ |
| #define | BS_BootSig 38 /* Extended boot signature (1) */ |
| #define | BS_VolID 39 /* Volume serial number (4) */ |
| #define | BS_VolLab 43 /* Volume label (8) */ |
| #define | BS_FilSysType 54 /* File system type (1) */ |
| #define | BPB_FATSz32 36 /* FAT size [sector] (4) */ |
| #define | BPB_ExtFlags 40 /* Extended flags (2) */ |
| #define | BPB_FSVer 42 /* File system version (2) */ |
| #define | BPB_RootClus 44 /* Root dir first cluster (4) */ |
| #define | BPB_FSInfo 48 /* Offset of FSInfo sector (2) */ |
| #define | BPB_BkBootSec 50 /* Offset of backup boot sector (2) */ |
| #define | BS_DrvNum32 64 /* Physical drive number (2) */ |
| #define | BS_BootSig32 66 /* Extended boot signature (1) */ |
| #define | BS_VolID32 67 /* Volume serial number (4) */ |
| #define | BS_VolLab32 71 /* Volume label (8) */ |
| #define | BS_FilSysType32 82 /* File system type (1) */ |
| #define | FSI_LeadSig 0 /* FSI: Leading signature (4) */ |
| #define | FSI_StrucSig 484 /* FSI: Structure signature (4) */ |
| #define | FSI_Free_Count 488 /* FSI: Number of free clusters (4) */ |
| #define | FSI_Nxt_Free 492 /* FSI: Last allocated cluster (4) */ |
| #define | MBR_Table 446 /* MBR: Partition table offset (2) */ |
| #define | SZ_PTE 16 /* MBR: Size of a partition table entry */ |
| #define | BS_55AA 510 /* Boot sector signature (2) */ |
| #define | DIR_Name 0 /* Short file name (11) */ |
| #define | DIR_Attr 11 /* Attribute (1) */ |
| #define | DIR_NTres 12 /* NT flag (1) */ |
| #define | DIR_CrtTimeTenth 13 /* Created time sub-second (1) */ |
| #define | DIR_CrtTime 14 /* Created time (2) */ |
| #define | DIR_CrtDate 16 /* Created date (2) */ |
| #define | DIR_LstAccDate 18 /* Last accessed date (2) */ |
| #define | DIR_FstClusHI 20 /* Higher 16-bit of first cluster (2) */ |
| #define | DIR_WrtTime 22 /* Modified time (2) */ |
| #define | DIR_WrtDate 24 /* Modified date (2) */ |
| #define | DIR_FstClusLO 26 /* Lower 16-bit of first cluster (2) */ |
| #define | DIR_FileSize 28 /* File size (4) */ |
| #define | LDIR_Ord 0 /* LFN entry order and LLE flag (1) */ |
| #define | LDIR_Attr 11 /* LFN attribute (1) */ |
| #define | LDIR_Type 12 /* LFN type (1) */ |
| #define | LDIR_Chksum 13 /* Sum of corresponding SFN entry */ |
| #define | LDIR_FstClusLO 26 /* Filled by zero (0) */ |
| #define | SZ_DIR 32 /* Size of a directory entry */ |
| #define | LLE 0x40 /* Last long entry flag in LDIR_Ord */ |
| #define | DDE 0xE5 /* Deleted directory entry mark in DIR_Name[0] */ |
| #define | NDDE 0x05 /* Replacement of the character collides with DDE */ |
| #define | DEF_NAMEBUF BYTE sfn[12] |
| #define | INIT_BUF(dobj) (dobj).fn = sfn |
| #define | FREE_BUF() |
Functions | |
| DWORD | clust2sect (FATFS *fs, DWORD clst) |
| DWORD | get_fat (FATFS *fs, DWORD clst) |
| FRESULT | put_fat (FATFS *fs, DWORD clst, DWORD val) |
| FRESULT | scan_files (char *path) |
| FRESULT | f_mount (BYTE vol, FATFS *fs) |
| FRESULT | f_open (FIL *fp, const TCHAR *path, BYTE mode) |
| FRESULT | f_read (FIL *fp, void *buff, UINT btr, UINT *br) |
| FRESULT | f_write (FIL *fp, const void *buff, UINT btw, UINT *bw) |
| FRESULT | f_sync (FIL *fp) |
| FRESULT | f_close (FIL *fp) |
| FRESULT | f_lseek (FIL *fp, DWORD ofs) |
| FRESULT | f_opendir (DIR *dj, const TCHAR *path) |
| FRESULT | f_readdir (DIR *dj, FILINFO *fno) |
| FRESULT | f_stat (const TCHAR *path, FILINFO *fno) |
| FRESULT | f_getfree (const TCHAR *path, DWORD *nclst, FATFS **fatfs) |
| FRESULT | f_truncate (FIL *fp) |
| FRESULT | f_unlink (const TCHAR *path) |
| FRESULT | f_mkdir (const TCHAR *path) |
| FRESULT | f_chmod (const TCHAR *path, BYTE value, BYTE mask) |
| FRESULT | f_utime (const TCHAR *path, const FILINFO *fno) |
| FRESULT | f_rename (const TCHAR *path_old, const TCHAR *path_new) |
Macro Definition Documentation
| #define BPB_BkBootSec 50 /* Offset of backup boot sector (2) */ |
| #define BPB_HiddSec 28 /* Number of special hidden sectors (4) */ |
| #define BPB_RootEntCnt 17 /* Number of root dir entries for FAT12/16 (2) */ |
| #define BPB_RsvdSecCnt 14 /* Size of reserved area [sector] (2) */ |
| #define DDE 0xE5 /* Deleted directory entry mark in DIR_Name[0] */ |
| #define DIR_FstClusHI 20 /* Higher 16-bit of first cluster (2) */ |
| #define DIR_FstClusLO 26 /* Lower 16-bit of first cluster (2) */ |
| #define FSI_Free_Count 488 /* FSI: Number of free clusters (4) */ |
| #define MIN_FAT16 4086 /* Minimum number of clusters for FAT16 */ |
| #define MIN_FAT32 65526 /* Minimum number of clusters for FAT32 */ |
| #define NDDE 0x05 /* Replacement of the character collides with DDE */ |
Function Documentation
Definition at line 3435 of file ff.c.
{
FRESULT res;
DIR dj;
BYTE *dir;
res = chk_mounted(&path, &dj.fs, 1);
if (res == FR_OK) {
INIT_BUF(dj);
res = follow_path(&dj, path); /* Follow the file path */
FREE_BUF();
res = FR_INVALID_NAME;
if (res == FR_OK) {
dir = dj.dir;
if (!dir) { /* Is it a root directory? */
res = FR_INVALID_NAME;
} else { /* File or sub directory */
res = sync(dj.fs);
}
}
}
}
Definition at line 2728 of file ff.c.
{
FRESULT res;
#if _FS_READONLY
res = validate(fp);
{
#if _FS_REENTRANT
#endif
LEAVE_FF(fs, res);
}
#else
res = f_sync(fp); /* Flush cached data */
#if _FS_LOCK
#if _FS_REENTRANT
res = validate(fp);
if (res == FR_OK) {
res = dec_lock(fp->lockid);
unlock_fs(fs, FR_OK);
}
#else
res = dec_lock(fp->lockid);
#endif
}
#endif
return res;
#endif
}
Here is the call graph for this function:
Definition at line 3177 of file ff.c.
{
FRESULT res;
FATFS *fs;
DWORD n, clst, sect, stat;
UINT i;
BYTE fat, *p;
/* Get drive number */
res = chk_mounted(&path, fatfs, 0);
fs = *fatfs;
if (res == FR_OK) {
/* If free_clust is valid, return it without full cluster scan */
*nclst = fs->free_clust;
} else {
/* Get number of free clusters */
fat = fs->fs_type;
n = 0;
if (fat == FS_FAT12) {
clst = 2;
do {
stat = get_fat(fs, clst);
if (stat == 0) n++;
} while (++clst < fs->n_fatent);
} else {
clst = fs->n_fatent;
sect = fs->fatbase;
i = 0; p = 0;
do {
if (!i) {
res = move_window(fs, sect++);
p = fs->win;
i = SS(fs);
}
if (fat == FS_FAT16) {
if (LD_WORD(p) == 0) n++;
p += 2; i -= 2;
} else {
if ((LD_DWORD(p) & 0x0FFFFFFF) == 0) n++;
p += 4; i -= 4;
}
} while (--clst);
}
fs->free_clust = n;
*nclst = n;
}
}
LEAVE_FF(fs, res);
}
Here is the call graph for this function:
Definition at line 2897 of file ff.c.
{
FRESULT res;
res = validate(fp); /* Check validity of the object */
#if _USE_FASTSEEK
DWORD cl, pcl, ncl, tcl, dsc, tlen, ulen, *tbl;
tbl = fp->cltbl;
tlen = *tbl++; ulen = 2; /* Given table size and required table size */
cl = fp->sclust; /* Top of the chain */
if (cl) {
do {
/* Get a fragment */
tcl = cl; ncl = 0; ulen += 2; /* Top, length and used items */
do {
pcl = cl; ncl++;
} while (cl == pcl + 1);
if (ulen <= tlen) { /* Store the length and top of the fragment */
*tbl++ = ncl; *tbl++ = tcl;
}
} while (cl < fp->fs->n_fatent); /* Repeat until end of chain */
}
*fp->cltbl = ulen; /* Number of items used */
if (ulen <= tlen)
*tbl = 0; /* Terminate table */
else
res = FR_NOT_ENOUGH_CORE; /* Given table size is smaller than required */
} else { /* Fast seek */
ofs = fp->fsize;
fp->fptr = ofs; /* Set file pointer */
if (ofs) {
fp->clust = clmt_clust(fp, ofs - 1);
#if !_FS_TINY
#if !_FS_READONLY
}
#endif
#endif
fp->dsect = dsc;
}
}
}
} else
#endif
/* Normal Seek */
{
DWORD clst, bcs, nsect, ifptr;
#if !_FS_READONLY
#endif
) ofs = fp->fsize;
ifptr = fp->fptr;
fp->fptr = nsect = 0;
if (ofs) {
if (ifptr > 0 &&
(ofs - 1) / bcs >= (ifptr - 1) / bcs) { /* When seek to same or following cluster, */
fp->fptr = (ifptr - 1) & ~(bcs - 1); /* start from the current cluster */
ofs -= fp->fptr;
clst = fp->clust;
} else { /* When seek to back cluster, */
clst = fp->sclust; /* start from the first cluster */
#if !_FS_READONLY
if (clst == 0) { /* If no cluster chain, create a new chain */
clst = create_chain(fp->fs, 0);
fp->sclust = clst;
}
#endif
fp->clust = clst;
}
if (clst != 0) {
while (ofs > bcs) { /* Cluster following loop */
#if !_FS_READONLY
clst = create_chain(fp->fs, clst); /* Force stretch if in write mode */
if (clst == 0) { /* When disk gets full, clip file size */
ofs = bcs; break;
}
} else
#endif
fp->clust = clst;
fp->fptr += bcs;
ofs -= bcs;
}
fp->fptr += ofs;
}
}
}
#if !_FS_TINY
#if !_FS_READONLY
}
#endif
#endif
fp->dsect = nsect;
}
#if !_FS_READONLY
fp->flag |= FA__WRITTEN;
}
#endif
}
}
Here is the call graph for this function:
Definition at line 3362 of file ff.c.
{
FRESULT res;
DIR dj;
BYTE *dir, n;
DWORD dsc, dcl, pcl, tim = get_fattime();
res = chk_mounted(&path, &dj.fs, 1);
if (res == FR_OK) {
INIT_BUF(dj);
res = follow_path(&dj, path); /* Follow the file path */
res = FR_INVALID_NAME;
dcl = create_chain(dj.fs, 0); /* Allocate a cluster for the new directory table */
res = FR_OK;
if (dcl == 1) res = FR_INT_ERR;
if (dcl == 0xFFFFFFFF) res = FR_DISK_ERR;
res = move_window(dj.fs, 0);
dsc = clust2sect(dj.fs, dcl);
dir[DIR_Name] = '.';
ST_DWORD(dir+DIR_WrtTime, tim);
st_clust(dir, dcl);
dir[33] = '.'; pcl = dj.sclust;
pcl = 0;
st_clust(dir+SZ_DIR, pcl);
res = move_window(dj.fs, 0);
}
}
if (res != FR_OK) {
remove_chain(dj.fs, dcl); /* Could not register, remove cluster chain */
} else {
dir = dj.dir;
st_clust(dir, dcl); /* Table start cluster */
res = sync(dj.fs);
}
}
FREE_BUF();
}
}
Here is the call graph for this function:
Definition at line 2288 of file ff.c.
{
FATFS *rfs;
return FR_INVALID_DRIVE;
rfs = FatFs[vol]; /* Get current fs object */
if (rfs) {
#if _FS_LOCK
clear_lock(rfs);
#endif
#if _FS_REENTRANT /* Discard sync object of the current volume */
#endif
rfs->fs_type = 0; /* Clear old fs object */
}
if (fs) {
fs->fs_type = 0; /* Clear new fs object */
#if _FS_REENTRANT /* Create sync object for the new volume */
#endif
}
FatFs[vol] = fs; /* Register new fs object */
return FR_OK;
}
Definition at line 2328 of file ff.c.
{
FRESULT res;
DIR dj;
BYTE *dir;
fp->fs = 0; /* Clear file object */
#if !_FS_READONLY
#else
mode &= FA_READ;
res = chk_mounted(&path, &dj.fs, 0);
#endif
if (res == FR_OK) {
INIT_BUF(dj);
res = follow_path(&dj, path); /* Follow the file path */
dir = dj.dir;
#if !_FS_READONLY /* R/W configuration */
if (res == FR_OK) {
if (!dir) /* Current dir itself */
res = FR_INVALID_NAME;
#if _FS_LOCK
else
res = chk_lock(&dj, (mode & ~FA_READ) ? 1 : 0);
#endif
}
/* Create or Open a file */
DWORD dw, cl;
#if _FS_LOCK
res = enq_lock() ? dir_register(&dj) : FR_TOO_MANY_OPEN_FILES;
#else
res = dir_register(&dj);
#endif
mode |= FA_CREATE_ALWAYS; /* File is created */
dir = dj.dir; /* New entry */
}
else { /* Any object is already existing */
res = FR_DENIED;
} else {
res = FR_EXIST;
}
}
dw = get_fattime(); /* Created time */
ST_DWORD(dir+DIR_CrtTime, dw);
dir[DIR_Attr] = 0; /* Reset attribute */
cl = ld_clust(dj.fs, dir); /* Get start cluster */
st_clust(dir, 0); /* cluster = 0 */
if (cl) { /* Remove the cluster chain if exist */
res = remove_chain(dj.fs, cl);
if (res == FR_OK) {
res = move_window(dj.fs, dw);
}
}
}
}
else { /* Open an existing file */
res = FR_NO_FILE;
} else {
res = FR_DENIED;
}
}
}
if (res == FR_OK) {
if (mode & FA_CREATE_ALWAYS) /* Set file change flag if created or overwritten */
mode |= FA__WRITTEN;
fp->dir_ptr = dir;
#if _FS_LOCK
fp->lockid = inc_lock(&dj, (mode & ~FA_READ) ? 1 : 0);
if (!fp->lockid) res = FR_INT_ERR;
#endif
}
#else /* R/O configuration */
dir = dj.dir;
if (!dir) { /* Current dir itself */
res = FR_INVALID_NAME;
} else {
res = FR_NO_FILE;
}
}
#endif
FREE_BUF();
if (res == FR_OK) {
fp->flag = mode; /* File access mode */
fp->fptr = 0; /* File pointer */
fp->dsect = 0;
#if _USE_FASTSEEK
fp->cltbl = 0; /* Normal seek mode */
#endif
}
}
}
Here is the call graph for this function:
Definition at line 3055 of file ff.c.
{
FRESULT res;
FATFS *fs;
res = chk_mounted(&path, &dj->fs, 0);
fs = dj->fs;
if (res == FR_OK) {
INIT_BUF(*dj);
res = follow_path(dj, path); /* Follow the path to the directory */
FREE_BUF();
} else { /* The object is not a directory */
res = FR_NO_PATH;
}
}
if (res == FR_OK) {
res = dir_sdi(dj, 0); /* Rewind dir */
}
}
} else {
dj->fs = 0;
}
LEAVE_FF(fs, res);
}
Here is the caller graph for this function:
Definition at line 2460 of file ff.c.
{
FRESULT res;
DWORD clst, sect, remain;
UINT rcnt, cc;
BYTE csect, *rbuff = buff;
*br = 0; /* Clear read byte counter */
res = validate(fp); /* Check validity */
for ( ; btr; /* Repeat until all data read */
rbuff += rcnt, fp->fptr += rcnt, *br += rcnt, btr -= rcnt) {
if (!csect) { /* On the cluster boundary? */
clst = fp->sclust; /* Follow from the origin */
} else { /* Middle or end of the file */
#if _USE_FASTSEEK
if (fp->cltbl)
clst = clmt_clust(fp, fp->fptr); /* Get cluster# from the CLMT */
else
#endif
}
fp->clust = clst; /* Update current cluster */
}
sect += csect;
if (cc) { /* Read maximum contiguous sectors directly */
#if !_FS_READONLY && _FS_MINIMIZE <= 2 /* Replace one of the read sectors with cached data if it contains a dirty sector */
#if _FS_TINY
#else
#endif
#endif
continue;
}
#if !_FS_TINY
#if !_FS_READONLY
}
#endif
}
#endif
fp->dsect = sect;
}
if (rcnt > btr) rcnt = btr;
#if _FS_TINY
#else
#endif
}
}
Here is the call graph for this function:
Definition at line 3102 of file ff.c.
{
FRESULT res;
res = validate(dj); /* Check validity of the object */
if (res == FR_OK) {
if (!fno) {
res = dir_sdi(dj, 0); /* Rewind the directory object */
} else {
INIT_BUF(*dj);
res = dir_read(dj); /* Read an directory item */
dj->sect = 0;
res = FR_OK;
}
get_fileinfo(dj, fno); /* Get the object information */
res = dir_next(dj, 0); /* Increment index for next */
if (res == FR_NO_FILE) {
dj->sect = 0;
res = FR_OK;
}
}
FREE_BUF();
}
}
}
Here is the caller graph for this function:
Definition at line 3518 of file ff.c.
{
FRESULT res;
DIR djo, djn;
BYTE buf[21], *dir;
DWORD dw;
res = chk_mounted(&path_old, &djo.fs, 1);
if (res == FR_OK) {
INIT_BUF(djo);
res = follow_path(&djo, path_old); /* Check old object */
res = FR_INVALID_NAME;
#if _FS_LOCK
if (res == FR_OK) res = chk_lock(&djo, 2);
#endif
res = FR_NO_FILE;
} else {
res = follow_path(&djn, path_new);
/* Start critical section that an interruption or error can cause cross-link */
res = dir_register(&djn); /* Register the new entry */
if (res == FR_OK) {
dir = djn.dir; /* Copy object information except for name */
mem_cpy(dir+13, buf+2, 19);
if (djo.sclust != djn.sclust && (dir[DIR_Attr] & AM_DIR)) { /* Update .. entry in the directory if needed */
if (!dw) {
res = FR_INT_ERR;
} else {
res = move_window(djo.fs, dw);
st_clust(dir, dw);
}
}
}
if (res == FR_OK) {
res = dir_remove(&djo); /* Remove old entry */
if (res == FR_OK)
res = sync(djo.fs);
}
}
/* End critical section */
}
}
}
FREE_BUF();
}
}
Here is the call graph for this function:
Definition at line 2680 of file ff.c.
{
FRESULT res;
DWORD tim;
BYTE *dir;
res = validate(fp); /* Check validity of the object */
if (res == FR_OK) {
#if !_FS_TINY /* Write-back dirty buffer */
}
#endif
/* Update the directory entry */
if (res == FR_OK) {
dir = fp->dir_ptr;
st_clust(dir, fp->sclust); /* Update start cluster */
tim = get_fattime(); /* Update updated time */
ST_DWORD(dir+DIR_WrtTime, tim);
ST_WORD(dir+DIR_LstAccDate, 0);
fp->flag &= ~FA__WRITTEN;
res = sync(fp->fs);
}
}
}
}
Here is the call graph for this function:
Here is the caller graph for this function:
Definition at line 3244 of file ff.c.
{
FRESULT res;
DWORD ncl;
res = validate(fp); /* Check validity of the object */
if (res == FR_OK) {
res = FR_INT_ERR;
} else {
res = FR_DENIED;
}
}
if (res == FR_OK) {
fp->flag |= FA__WRITTEN;
fp->sclust = 0;
} else { /* When truncate a part of the file, remove remaining clusters */
res = FR_OK;
if (ncl == 0xFFFFFFFF) res = FR_DISK_ERR;
if (ncl == 1) res = FR_INT_ERR;
if (res == FR_OK && ncl < fp->fs->n_fatent) {
}
}
}
}
}
Here is the call graph for this function:
Definition at line 3294 of file ff.c.
{
FRESULT res;
DIR dj, sdj;
BYTE *dir;
DWORD dclst;
res = chk_mounted(&path, &dj.fs, 1);
if (res == FR_OK) {
INIT_BUF(dj);
res = follow_path(&dj, path); /* Follow the file path */
res = FR_INVALID_NAME; /* Cannot remove dot entry */
#if _FS_LOCK
#endif
dir = dj.dir;
if (!dir) {
res = FR_INVALID_NAME; /* Cannot remove the start directory */
} else {
res = FR_DENIED; /* Cannot remove R/O object */
}
dclst = ld_clust(dj.fs, dir);
if (dclst < 2) {
res = FR_INT_ERR;
} else {
sdj.sclust = dclst;
res = dir_sdi(&sdj, 2); /* Exclude dot entries */
if (res == FR_OK) {
res = dir_read(&sdj);
#if _FS_RPATH
#endif
) res = FR_DENIED;
}
}
}
if (res == FR_OK) {
res = dir_remove(&dj); /* Remove the directory entry */
if (res == FR_OK) {
if (dclst) /* Remove the cluster chain if exist */
res = remove_chain(dj.fs, dclst);
}
}
}
FREE_BUF();
}
}
Definition at line 3477 of file ff.c.
{
FRESULT res;
DIR dj;
BYTE *dir;
res = chk_mounted(&path, &dj.fs, 1);
if (res == FR_OK) {
INIT_BUF(dj);
res = follow_path(&dj, path); /* Follow the file path */
FREE_BUF();
res = FR_INVALID_NAME;
if (res == FR_OK) {
dir = dj.dir;
if (!dir) { /* Root directory */
res = FR_INVALID_NAME;
} else { /* File or sub-directory */
res = sync(dj.fs);
}
}
}
}
Definition at line 2561 of file ff.c.
{
FRESULT res;
DWORD clst, sect;
UINT wcnt, cc;
const BYTE *wbuff = buff;
BYTE csect;
*bw = 0; /* Clear write byte counter */
res = validate(fp); /* Check validity */
for ( ; btw; /* Repeat until all data written */
if (!csect) { /* On the cluster boundary? */
clst = fp->sclust; /* Follow from the origin */
if (clst == 0) /* When no cluster is allocated, */
} else { /* Middle or end of the file */
#if _USE_FASTSEEK
if (fp->cltbl)
clst = clmt_clust(fp, fp->fptr); /* Get cluster# from the CLMT */
else
#endif
}
if (clst == 0) break; /* Could not allocate a new cluster (disk full) */
fp->clust = clst; /* Update current cluster */
}
#if _FS_TINY
#else
}
#endif
sect += csect;
if (cc) { /* Write maximum contiguous sectors directly */
#if _FS_TINY
if (fp->fs->winsect - sect < cc) { /* Refill sector cache if it gets invalidated by the direct write */
}
#else
}
#endif
continue;
}
#if _FS_TINY
}
#else
}
#endif
fp->dsect = sect;
}
if (wcnt > btw) wcnt = btw;
#if _FS_TINY
#else
#endif
}
}
Here is the call graph for this function:
Definition at line 820 of file ff.c.
{
UINT wc, bc;
BYTE *p;
return 1;
switch (fs->fs_type) {
case FS_FAT12 :
bc = (UINT)clst; bc += bc / 2;
return (clst & 1) ? (wc >> 4) : (wc & 0xFFF);
case FS_FAT16 :
return LD_WORD(p);
case FS_FAT32 :
return LD_DWORD(p) & 0x0FFFFFFF;
}
return 0xFFFFFFFF; /* An error occurred at the disk I/O layer */
}
Here is the caller graph for this function:
Definition at line 863 of file ff.c.
{
UINT bc;
BYTE *p;
FRESULT res;
res = FR_INT_ERR;
} else {
switch (fs->fs_type) {
case FS_FAT12 :
bc = (UINT)clst; bc += bc / 2;
bc++;
fs->wflag = 1;
break;
case FS_FAT16 :
break;
case FS_FAT32 :
val |= LD_DWORD(p) & 0xF0000000;
ST_DWORD(p, val);
break;
default :
res = FR_INT_ERR;
}
fs->wflag = 1;
}
return res;
}
Here is the caller graph for this function:
| FRESULT scan_files | ( | char * | path | ) |
Definition at line 2242 of file ff.c.
{
FRESULT res;
FILINFO fno;
DIR dir;
int i;
char *fn; /* This function is assuming non-Unicode cfg. */
#if _USE_LFN
fno.lfname = lfn;
fno.lfsize = sizeof lfn;
#endif
res = f_opendir(&dir, path); /* Open the directory */
if (res == FR_OK) {
i = strlen(path);
for (;;) {
res = f_readdir(&dir, &fno); /* Read a directory item */
#if _USE_LFN
#else
fn = fno.fname;
#endif
sprintf(&path[i], "/%s", fn);
res = scan_files(path);
path[i] = 0;
} else { /* It is a file. */
printf("%s/%s\n", path, fn);
}
}
}
return res;
}
Here is the call graph for this function:
Here is the caller graph for this function:
