my version
Fork of FATFileSystem by
Revision 4:3ff2606d5713, committed 2014-08-28
- Comitter:
- mbed_official
- Date:
- Thu Aug 28 13:15:31 2014 +0100
- Parent:
- 3:e960e2b81a3c
- Commit message:
- Synchronized with git revision fee50a80ffdc8f9d9ee97be545ff36b5a986f041
Full URL: https://github.com/mbedmicro/mbed/commit/fee50a80ffdc8f9d9ee97be545ff36b5a986f041/
Changed in this revision
--- a/ChaN/diskio.cpp Mon Mar 17 14:09:00 2014 +0000 +++ b/ChaN/diskio.cpp Thu Aug 28 13:15:31 2014 +0100 @@ -14,7 +14,7 @@ DSTATUS disk_initialize ( BYTE drv /* Physical drive nmuber (0..) */ -) +) { debug_if(FFS_DBG, "disk_initialize on drv [%d]\n", drv); return (DSTATUS)FATFileSystem::_ffs[drv]->disk_initialize(); @@ -22,7 +22,7 @@ DSTATUS disk_status ( BYTE drv /* Physical drive nmuber (0..) */ -) +) { debug_if(FFS_DBG, "disk_status on drv [%d]\n", drv); return (DSTATUS)FATFileSystem::_ffs[drv]->disk_status(); @@ -36,15 +36,10 @@ ) { debug_if(FFS_DBG, "disk_read(sector %d, count %d) on drv [%d]\n", sector, count, drv); - for(DWORD s=sector; s<sector+count; s++) { - debug_if(FFS_DBG, " disk_read(sector %d)\n", s); - int res = FATFileSystem::_ffs[drv]->disk_read((uint8_t*)buff, s); - if(res) { - return RES_PARERR; - } - buff += 512; - } - return RES_OK; + if (FATFileSystem::_ffs[drv]->disk_read((uint8_t*)buff, sector, count)) + return RES_PARERR; + else + return RES_OK; } #if _READONLY == 0 @@ -56,15 +51,10 @@ ) { debug_if(FFS_DBG, "disk_write(sector %d, count %d) on drv [%d]\n", sector, count, drv); - for(DWORD s = sector; s < sector + count; s++) { - debug_if(FFS_DBG, " disk_write(sector %d)\n", s); - int res = FATFileSystem::_ffs[drv]->disk_write((uint8_t*)buff, s); - if(res) { - return RES_PARERR; - } - buff += 512; - } - return RES_OK; + if (FATFileSystem::_ffs[drv]->disk_write((uint8_t*)buff, sector, count)) + return RES_PARERR; + else + return RES_OK; } #endif /* _READONLY */
--- a/ChaN/ff.cpp Mon Mar 17 14:09:00 2014 +0000 +++ b/ChaN/ff.cpp Thu Aug 28 13:15:31 2014 +0100 @@ -527,16 +527,14 @@ /* Copy memory to memory */ static -void mem_cpy (void* dst, const void* src, UINT cnt) -{ +void mem_cpy (void* dst, const void* src, UINT cnt) { BYTE *d = (BYTE*)dst; const BYTE *s = (const BYTE*)src; #if _WORD_ACCESS == 1 while (cnt >= sizeof (int)) { *(int*)d = *(int*)s; - d += sizeof (int); - s += sizeof (int); + d += sizeof (int); s += sizeof (int); cnt -= sizeof (int); } #endif @@ -546,8 +544,7 @@ /* Fill memory */ static -void mem_set (void* dst, int val, UINT cnt) -{ +void mem_set (void* dst, int val, UINT cnt) { BYTE *d = (BYTE*)dst; while (cnt--) @@ -556,8 +553,7 @@ /* Compare memory to memory */ static -int mem_cmp (const void* dst, const void* src, UINT cnt) -{ +int mem_cmp (const void* dst, const void* src, UINT cnt) { const BYTE *d = (const BYTE *)dst, *s = (const BYTE *)src; int r = 0; @@ -567,8 +563,7 @@ /* Check if chr is contained in the string */ static -int chk_chr (const char* str, int chr) -{ +int chk_chr (const char* str, int chr) { while (*str && *str != chr) str++; return *str; } @@ -596,10 +591,10 @@ ) { if (fs && - res != FR_NOT_ENABLED && - res != FR_INVALID_DRIVE && - res != FR_INVALID_OBJECT && - res != FR_TIMEOUT) { + res != FR_NOT_ENABLED && + res != FR_INVALID_DRIVE && + res != FR_INVALID_OBJECT && + res != FR_TIMEOUT) { ff_rel_grant(fs->sobj); } } @@ -624,8 +619,8 @@ for (i = be = 0; i < _FS_LOCK; i++) { if (Files[i].fs) { /* Existing entry */ if (Files[i].fs == dj->fs && /* Check if the file matched with an open file */ - Files[i].clu == dj->sclust && - Files[i].idx == dj->index) break; + Files[i].clu == dj->sclust && + Files[i].idx == dj->index) break; } else { /* Blank entry */ be++; } @@ -659,8 +654,8 @@ for (i = 0; i < _FS_LOCK; i++) { /* Find the file */ if (Files[i].fs == dj->fs && - Files[i].clu == dj->sclust && - Files[i].idx == dj->index) break; + Files[i].clu == dj->sclust && + Files[i].idx == dj->index) break; } if (i == _FS_LOCK) { /* Not opened. Register it as new. */ @@ -836,25 +831,23 @@ return 1; switch (fs->fs_type) { - case FS_FAT12 : - bc = (UINT)clst; - bc += bc / 2; - if (move_window(fs, fs->fatbase + (bc / SS(fs)))) break; - wc = fs->win[bc % SS(fs)]; - bc++; - if (move_window(fs, fs->fatbase + (bc / SS(fs)))) break; - wc |= fs->win[bc % SS(fs)] << 8; - return (clst & 1) ? (wc >> 4) : (wc & 0xFFF); - - case FS_FAT16 : - if (move_window(fs, fs->fatbase + (clst / (SS(fs) / 2)))) break; - p = &fs->win[clst * 2 % SS(fs)]; - return LD_WORD(p); - - case FS_FAT32 : - if (move_window(fs, fs->fatbase + (clst / (SS(fs) / 4)))) break; - p = &fs->win[clst * 4 % SS(fs)]; - return LD_DWORD(p) & 0x0FFFFFFF; + case FS_FAT12 : + bc = (UINT)clst; bc += bc / 2; + if (move_window(fs, fs->fatbase + (bc / SS(fs)))) break; + wc = fs->win[bc % SS(fs)]; bc++; + if (move_window(fs, fs->fatbase + (bc / SS(fs)))) break; + wc |= fs->win[bc % SS(fs)] << 8; + return (clst & 1) ? (wc >> 4) : (wc & 0xFFF); + + case FS_FAT16 : + if (move_window(fs, fs->fatbase + (clst / (SS(fs) / 2)))) break; + p = &fs->win[clst * 2 % SS(fs)]; + return LD_WORD(p); + + case FS_FAT32 : + if (move_window(fs, fs->fatbase + (clst / (SS(fs) / 4)))) break; + p = &fs->win[clst * 4 % SS(fs)]; + return LD_DWORD(p) & 0x0FFFFFFF; } return 0xFFFFFFFF; /* An error occurred at the disk I/O layer */ @@ -884,38 +877,37 @@ } else { switch (fs->fs_type) { - case FS_FAT12 : - bc = (UINT)clst; - bc += bc / 2; - res = move_window(fs, fs->fatbase + (bc / SS(fs))); - if (res != FR_OK) break; - p = &fs->win[bc % SS(fs)]; - *p = (clst & 1) ? ((*p & 0x0F) | ((BYTE)val << 4)) : (BYTE)val; - bc++; - fs->wflag = 1; - res = move_window(fs, fs->fatbase + (bc / SS(fs))); - if (res != FR_OK) break; - p = &fs->win[bc % SS(fs)]; - *p = (clst & 1) ? (BYTE)(val >> 4) : ((*p & 0xF0) | ((BYTE)(val >> 8) & 0x0F)); - break; - - case FS_FAT16 : - res = move_window(fs, fs->fatbase + (clst / (SS(fs) / 2))); - if (res != FR_OK) break; - p = &fs->win[clst * 2 % SS(fs)]; - ST_WORD(p, (WORD)val); - break; - - case FS_FAT32 : - res = move_window(fs, fs->fatbase + (clst / (SS(fs) / 4))); - if (res != FR_OK) break; - p = &fs->win[clst * 4 % SS(fs)]; - val |= LD_DWORD(p) & 0xF0000000; - ST_DWORD(p, val); - break; - - default : - res = FR_INT_ERR; + case FS_FAT12 : + bc = (UINT)clst; bc += bc / 2; + res = move_window(fs, fs->fatbase + (bc / SS(fs))); + if (res != FR_OK) break; + p = &fs->win[bc % SS(fs)]; + *p = (clst & 1) ? ((*p & 0x0F) | ((BYTE)val << 4)) : (BYTE)val; + bc++; + fs->wflag = 1; + res = move_window(fs, fs->fatbase + (bc / SS(fs))); + if (res != FR_OK) break; + p = &fs->win[bc % SS(fs)]; + *p = (clst & 1) ? (BYTE)(val >> 4) : ((*p & 0xF0) | ((BYTE)(val >> 8) & 0x0F)); + break; + + case FS_FAT16 : + res = move_window(fs, fs->fatbase + (clst / (SS(fs) / 2))); + if (res != FR_OK) break; + p = &fs->win[clst * 2 % SS(fs)]; + ST_WORD(p, (WORD)val); + break; + + case FS_FAT32 : + res = move_window(fs, fs->fatbase + (clst / (SS(fs) / 4))); + if (res != FR_OK) break; + p = &fs->win[clst * 4 % SS(fs)]; + val |= LD_DWORD(p) & 0xF0000000; + ST_DWORD(p, val); + break; + + default : + res = FR_INT_ERR; } fs->wflag = 1; } @@ -951,14 +943,8 @@ while (clst < fs->n_fatent) { /* Not a last link? */ nxt = get_fat(fs, clst); /* Get cluster status */ if (nxt == 0) break; /* Empty cluster? */ - if (nxt == 1) { - res = FR_INT_ERR; /* Internal error? */ - break; - } - if (nxt == 0xFFFFFFFF) { - res = FR_DISK_ERR; /* Disk error? */ - break; - } + if (nxt == 1) { res = FR_INT_ERR; break; } /* Internal error? */ + if (nxt == 0xFFFFFFFF) { res = FR_DISK_ERR; break; } /* Disk error? */ res = put_fat(fs, clst, 0); /* Mark the cluster "empty" */ if (res != FR_OK) break; if (fs->free_clust != 0xFFFFFFFF) { /* Update FSInfo */ @@ -1003,7 +989,8 @@ if (clst == 0) { /* Create a new chain */ scl = fs->last_clust; /* Get suggested start point */ if (!scl || scl >= fs->n_fatent) scl = 1; - } else { /* Stretch the current chain */ + } + else { /* Stretch the current chain */ cs = get_fat(fs, clst); /* Check the cluster status */ if (cs < 2) return 1; /* It is an invalid cluster */ if (cs < fs->n_fatent) return cs; /* It is already followed by next cluster */ @@ -1064,8 +1051,7 @@ ncl = *tbl++; /* Number of cluters in the fragment */ if (!ncl) return 0; /* End of table? (error) */ if (cl < ncl) break; /* In this fragment? */ - cl -= ncl; - tbl++; /* Next fragment */ + cl -= ncl; tbl++; /* Next fragment */ } return cl + *tbl; /* Return the cluster number */ } @@ -1099,7 +1085,8 @@ if (idx >= dj->fs->n_rootdir) /* Index is out of range */ return FR_INT_ERR; dj->sect = dj->fs->dirbase + idx / (SS(dj->fs) / SZ_DIR); /* Sector# */ - } else { /* Dynamic table (sub-dirs or root-dir in FAT32) */ + } + else { /* Dynamic table (sub-dirs or root-dir in FAT32) */ ic = SS(dj->fs) / SZ_DIR * dj->fs->csize; /* Entries per cluster */ while (idx >= ic) { /* Follow cluster chain */ clst = get_fat(dj->fs, clst); /* Get next cluster */ @@ -1145,7 +1132,8 @@ if (dj->clust == 0) { /* Static table */ if (i >= dj->fs->n_rootdir) /* Report EOT when end of table */ return FR_NO_FILE; - } else { /* Dynamic table */ + } + else { /* Dynamic table */ if (((i / (SS(dj->fs) / SZ_DIR)) & (dj->fs->csize - 1)) == 0) { /* Cluster changed? */ clst = get_fat(dj->fs, dj->clust); /* Get next cluster */ if (clst <= 1) return FR_INT_ERR; @@ -1240,8 +1228,7 @@ i = ((dir[LDIR_Ord] & ~LLE) - 1) * 13; /* Get offset in the LFN buffer */ - s = 0; - wc = 1; + s = 0; wc = 1; do { uc = LD_WORD(dir+LfnOfs[s]); /* Pick an LFN character from the entry */ if (wc) { /* Last char has not been processed */ @@ -1273,8 +1260,7 @@ i = ((dir[LDIR_Ord] & 0x3F) - 1) * 13; /* Offset in the LFN buffer */ - s = 0; - wc = 1; + s = 0; wc = 1; do { uc = LD_WORD(dir+LfnOfs[s]); /* Pick an LFN character from the entry */ if (wc) { /* Last char has not been processed */ @@ -1346,8 +1332,7 @@ mem_cpy(dst, src, 11); if (seq > 5) { /* On many collisions, generate a hash number instead of sequential number */ - do seq = (seq >> 1) + (seq << 15) + (WORD)*lfn++; - while (*lfn); + do seq = (seq >> 1) + (seq << 15) + (WORD)*lfn++; while (*lfn); } /* itoa (hexdecimal) */ @@ -1388,8 +1373,7 @@ BYTE sum = 0; UINT n = 11; - do sum = (sum >> 1) + (sum << 7) + *dir++; - while (--n); + do sum = (sum >> 1) + (sum << 7) + *dir++; while (--n); return sum; } #endif @@ -1423,10 +1407,7 @@ if (res != FR_OK) break; dir = dj->dir; /* Ptr to the directory entry of current index */ c = dir[DIR_Name]; - if (c == 0) { - res = FR_NO_FILE; /* Reached to end of table */ - break; - } + if (c == 0) { res = FR_NO_FILE; break; } /* Reached to end of table */ #if _USE_LFN /* LFN configuration */ a = dir[DIR_Attr] & AM_MASK; if (c == DDE || ((a & AM_VOL) && a != AM_LFN)) { /* An entry without valid data */ @@ -1436,8 +1417,7 @@ if (dj->lfn) { if (c & LLE) { /* Is it start of LFN sequence? */ sum = dir[LDIR_Chksum]; - c &= ~LLE; - ord = c; /* LFN start order */ + c &= ~LLE; ord = c; /* LFN start order */ dj->lfn_idx = dj->index; } /* Check validity of the LFN entry and compare it with given name */ @@ -1445,8 +1425,7 @@ } } else { /* An SFN entry is found */ if (!ord && sum == sum_sfn(dir)) break; /* LFN matched? */ - ord = 0xFF; - dj->lfn_idx = 0xFFFF; /* Reset LFN sequence */ + ord = 0xFF; dj->lfn_idx = 0xFFFF; /* Reset LFN sequence */ if (!(dj->fn[NS] & NS_LOSS) && !mem_cmp(dir, dj->fn, 11)) break; /* SFN matched? */ } } @@ -1484,10 +1463,7 @@ if (res != FR_OK) break; dir = dj->dir; /* Ptr to the directory entry of current index */ c = dir[DIR_Name]; - if (c == 0) { - res = FR_NO_FILE; /* Reached to end of table */ - break; - } + if (c == 0) { res = FR_NO_FILE; break; } /* Reached to end of table */ #if _USE_LFN /* LFN configuration */ a = dir[DIR_Attr] & AM_MASK; if (c == DDE || (!_FS_RPATH && c == '.') || ((a & AM_VOL) && a != AM_LFN)) { /* An entry without valid data */ @@ -1496,8 +1472,7 @@ if (a == AM_LFN) { /* An LFN entry is found */ if (c & LLE) { /* Is it start of LFN sequence? */ sum = dir[LDIR_Chksum]; - c &= ~LLE; - ord = c; + c &= ~LLE; ord = c; dj->lfn_idx = dj->index; } /* Check LFN validity and capture it */ @@ -1541,16 +1516,14 @@ WCHAR *lfn; - fn = dj->fn; - lfn = dj->lfn; + fn = dj->fn; lfn = dj->lfn; mem_cpy(sn, fn, 12); if (_FS_RPATH && (sn[NS] & NS_DOT)) /* Cannot create dot entry */ return FR_INVALID_NAME; if (sn[NS] & NS_LOSS) { /* When LFN is out of 8.3 format, generate a numbered name */ - fn[NS] = 0; - dj->lfn = 0; /* Find only SFN */ + fn[NS] = 0; dj->lfn = 0; /* Find only SFN */ for (n = 1; n < 100; n++) { gen_numname(fn, sn, lfn, n); /* Generate a numbered name */ res = dir_find(dj); /* Check if the name collides with existing SFN */ @@ -1558,8 +1531,7 @@ } if (n == 100) return FR_DENIED; /* Abort if too many collisions */ if (res != FR_NO_FILE) return res; /* Abort if the result is other than 'not collided' */ - fn[NS] = sn[NS]; - dj->lfn = lfn; + fn[NS] = sn[NS]; dj->lfn = lfn; } if (sn[NS] & NS_LFN) { /* When LFN is to be created, reserve an SFN + LFN entries. */ @@ -1714,8 +1686,7 @@ b = (BYTE)p[si++]; /* Get 2nd byte */ if (!IsDBCS2(b)) return FR_INVALID_NAME; /* Reject invalid sequence */ - else - w = (w << 8) + b; /* Create a DBC */ + w = (w << 8) + b; /* Create a DBC */ } w = ff_convert(w, 1); /* Convert ANSI/OEM to Unicode */ if (!w) return FR_INVALID_NAME; /* Reject invalid code */ @@ -1728,7 +1699,7 @@ cf = (w < ' ') ? NS_LAST : 0; /* Set last segment flag if end of path */ #if _FS_RPATH if ((di == 1 && lfn[di-1] == '.') || /* Is this a dot entry? */ - (di == 2 && lfn[di-1] == '.' && lfn[di-2] == '.')) { + (di == 2 && lfn[di-1] == '.' && lfn[di-2] == '.')) { lfn[di] = 0; for (i = 0; i < 11; i++) dj->fn[i] = (i < di) ? '.' : ' '; @@ -1751,28 +1722,22 @@ if (si) cf |= NS_LOSS | NS_LFN; while (di && lfn[di - 1] != '.') di--; /* Find extension (di<=si: no extension) */ - b = i = 0; - ni = 8; + b = i = 0; ni = 8; for (;;) { w = lfn[si++]; /* Get an LFN char */ if (!w) break; /* Break on end of the LFN */ if (w == ' ' || (w == '.' && si != di)) { /* Remove spaces and dots */ - cf |= NS_LOSS | NS_LFN; - continue; + cf |= NS_LOSS | NS_LFN; continue; } if (i >= ni || si == di) { /* Extension or end of SFN */ if (ni == 11) { /* Long extension */ - cf |= NS_LOSS | NS_LFN; - break; + cf |= NS_LOSS | NS_LFN; break; } if (si != di) cf |= NS_LOSS | NS_LFN; /* Out of 8.3 format */ if (si > di) break; /* No extension */ - si = di; - i = 8; - ni = 11; /* Enter extension section */ - b <<= 2; - continue; + si = di; i = 8; ni = 11; /* Enter extension section */ + b <<= 2; continue; } if (w >= 0x80) { /* Non ASCII char */ @@ -1787,22 +1752,18 @@ if (_DF1S && w >= 0x100) { /* Double byte char (always false on SBCS cfg) */ if (i >= ni - 1) { - cf |= NS_LOSS | NS_LFN; - i = ni; - continue; + cf |= NS_LOSS | NS_LFN; i = ni; continue; } dj->fn[i++] = (BYTE)(w >> 8); } else { /* Single byte char */ if (!w || chk_chr("+,;=[]", w)) { /* Replace illegal chars for SFN */ - w = '_'; - cf |= NS_LOSS | NS_LFN;/* Lossy conversion */ + w = '_'; cf |= NS_LOSS | NS_LFN;/* Lossy conversion */ } else { if (IsUpper(w)) { /* ASCII large capital */ b |= 2; } else { if (IsLower(w)) { /* ASCII small capital */ - b |= 1; - w -= 0x20; + b |= 1; w -= 0x20; } } } @@ -1834,8 +1795,7 @@ for (p = *path; *p == '/' || *p == '\\'; p++) ; /* Strip duplicated separator */ sfn = dj->fn; mem_set(sfn, ' ', 11); - si = i = b = 0; - ni = 8; + si = i = b = 0; ni = 8; #if _FS_RPATH if (p[si] == '.') { /* Is this a dot entry? */ for (;;) { @@ -1854,10 +1814,8 @@ if (c <= ' ' || c == '/' || c == '\\') break; /* Break on end of segment */ if (c == '.' || i >= ni) { if (ni != 8 || c != '.') return FR_INVALID_NAME; - i = 8; - ni = 11; - b <<= 2; - continue; + i = 8; ni = 11; + b <<= 2; continue; } if (c >= 0x80) { /* Extended char? */ b |= 3; /* Eliminate NT flag */ @@ -1882,8 +1840,7 @@ b |= 2; } else { if (IsLower(c)) { /* ASCII small capital? */ - b |= 1; - c -= 0x20; + b |= 1; c -= 0x20; } } sfn[i++] = c; @@ -1973,17 +1930,11 @@ while ((w = *lfn++) != 0) { /* Get an LFN char */ #if !_LFN_UNICODE w = ff_convert(w, 0); /* Unicode -> OEM conversion */ - if (!w) { - i = 0; /* Could not convert, no LFN */ - break; - } + if (!w) { i = 0; break; } /* Could not convert, no LFN */ if (_DF1S && w >= 0x100) /* Put 1st byte if it is a DBC (always false on SBCS cfg) */ tp[i++] = (TCHAR)(w >> 8); #endif - if (i >= fno->lfsize - 1) { - i = 0; /* Buffer overflow, no LFN */ - break; - } + if (i >= fno->lfsize - 1) { i = 0; break; } /* Buffer overflow, no LFN */ tp[i++] = (TCHAR)w; } } @@ -2012,8 +1963,7 @@ #if _FS_RPATH if (*path == '/' || *path == '\\') { /* There is a heading separator */ - path++; - dj->sclust = 0; /* Strip it and start from the root dir */ + path++; dj->sclust = 0; /* Strip it and start from the root dir */ } else { /* No heading separator */ dj->sclust = dj->fs->cdir; /* Start from the current dir */ } @@ -2036,8 +1986,7 @@ if (res != FR_NO_FILE) break; /* Abort if any hard error occurred */ /* Object not found */ if (_FS_RPATH && (ns & NS_DOT)) { /* If dot entry is not exit */ - dj->sclust = 0; - dj->dir = 0; /* It is the root dir */ + dj->sclust = 0; dj->dir = 0; /* It is the root dir */ res = FR_OK; if (!(ns & NS_LAST)) continue; } else { /* Could not find the object */ @@ -2048,8 +1997,7 @@ if (ns & NS_LAST) break; /* Last segment match. Function completed. */ dir = dj->dir; /* There is next segment. Follow the sub directory */ if (!(dir[DIR_Attr] & AM_DIR)) { /* Cannot follow because it is a file */ - res = FR_NO_PATH; - break; + res = FR_NO_PATH; break; } dj->sclust = ld_clust(dj->fs, dir); } @@ -2110,8 +2058,7 @@ /* Get logical drive number from the path name */ vol = p[0] - '0'; /* Is there a drive number? */ if (vol <= 9 && p[1] == ':') { /* Found a drive number, get and strip it */ - p += 2; - *path = p; /* Return pointer to the path name */ + p += 2; *path = p; /* Return pointer to the path name */ } else { /* No drive number is given */ #if _FS_RPATH vol = CurrVol; /* Use current drive */ @@ -2215,7 +2162,7 @@ if (!fs->n_rootdir) return FR_NO_FILESYSTEM; /* (BPB_RootEntCnt must not be 0) */ fs->dirbase = fs->fatbase + fasize; /* Root directory start sector */ szbfat = (fmt == FS_FAT16) ? /* (Required FAT size) */ - fs->n_fatent * 2 : fs->n_fatent * 3 / 2 + (fs->n_fatent & 1); + fs->n_fatent * 2 : fs->n_fatent * 3 / 2 + (fs->n_fatent & 1); } if (fs->fsize < (szbfat + (SS(fs) - 1)) / SS(fs)) /* (BPB_FATSz must not be less than required) */ return FR_NO_FILESYSTEM; @@ -2230,11 +2177,11 @@ fs->fsi_flag = 0; fs->fsi_sector = bsect + LD_WORD(fs->win+BPB_FSInfo); if (disk_read(fs->drv, fs->win, fs->fsi_sector, 1) == RES_OK && - LD_WORD(fs->win+BS_55AA) == 0xAA55 && - LD_DWORD(fs->win+FSI_LeadSig) == 0x41615252 && - LD_DWORD(fs->win+FSI_StrucSig) == 0x61417272) { - fs->last_clust = LD_DWORD(fs->win+FSI_Nxt_Free); - fs->free_clust = LD_DWORD(fs->win+FSI_Free_Count); + LD_WORD(fs->win+BS_55AA) == 0xAA55 && + LD_DWORD(fs->win+FSI_LeadSig) == 0x41615252 && + LD_DWORD(fs->win+FSI_StrucSig) == 0x61417272) { + fs->last_clust = LD_DWORD(fs->win+FSI_Nxt_Free); + fs->free_clust = LD_DWORD(fs->win+FSI_Free_Count); } } #endif @@ -2382,7 +2329,8 @@ #endif mode |= FA_CREATE_ALWAYS; /* File is created */ dir = dj.dir; /* New entry */ - } else { /* Any object is already existing */ + } + else { /* Any object is already existing */ if (dir[DIR_Attr] & (AM_RDO | AM_DIR)) { /* Cannot overwrite it (R/O or DIR) */ res = FR_DENIED; } else { @@ -2407,7 +2355,8 @@ } } } - } else { /* Open an existing file */ + } + else { /* Open an existing file */ if (res == FR_OK) { /* Follow succeeded */ if (dir[DIR_Attr] & AM_DIR) { /* It is a directory */ res = FR_NO_FILE; @@ -2450,8 +2399,7 @@ #if _USE_FASTSEEK fp->cltbl = 0; /* Normal seek mode */ #endif - fp->fs = dj.fs; - fp->id = dj.fs->id; /* Validate file object */ + fp->fs = dj.fs; fp->id = dj.fs->id; /* Validate file object */ } } @@ -2490,7 +2438,7 @@ if (btr > remain) btr = (UINT)remain; /* Truncate btr by remaining bytes */ for ( ; btr; /* Repeat until all data read */ - rbuff += rcnt, fp->fptr += rcnt, *br += rcnt, btr -= rcnt) { + rbuff += rcnt, fp->fptr += rcnt, *br += rcnt, btr -= rcnt) { if ((fp->fptr % SS(fp->fs)) == 0) { /* On the sector boundary? */ csect = (BYTE)(fp->fptr / SS(fp->fs) & (fp->fs->csize - 1)); /* Sector offset in the cluster */ if (!csect) { /* On the cluster boundary? */ @@ -2578,7 +2526,7 @@ UINT wcnt, cc; const BYTE *wbuff = (const BYTE *)buff; BYTE csect; - + bool need_sync = false; *bw = 0; /* Clear write byte counter */ @@ -2591,7 +2539,7 @@ if ((DWORD)(fp->fsize + btw) < fp->fsize) btw = 0; /* File size cannot reach 4GB */ for ( ; btw; /* Repeat until all data written */ - wbuff += wcnt, fp->fptr += wcnt, *bw += wcnt, btw -= wcnt) { + wbuff += wcnt, fp->fptr += wcnt, *bw += wcnt, btw -= wcnt) { if ((fp->fptr % SS(fp->fs)) == 0) { /* On the sector boundary? */ csect = (BYTE)(fp->fptr / SS(fp->fs) & (fp->fs->csize - 1)); /* Sector offset in the cluster */ if (!csect) { /* On the cluster boundary? */ @@ -2611,6 +2559,13 @@ if (clst == 1) ABORT(fp->fs, FR_INT_ERR); if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR); fp->clust = clst; /* Update current cluster */ + +#ifdef FLUSH_ON_NEW_CLUSTER + // We do not need to flush for the first cluster + if (fp->fptr != 0) { + need_sync = true; + } +#endif } #if _FS_TINY if (fp->fs->winsect == fp->dsect && move_window(fp->fs, 0)) /* Write-back sector cache */ @@ -2643,6 +2598,9 @@ } #endif wcnt = SS(fp->fs) * cc; /* Number of bytes transferred */ +#ifdef FLUSH_ON_NEW_SECTOR + need_sync = true; +#endif continue; } #if _FS_TINY @@ -2653,8 +2611,8 @@ #else if (fp->dsect != sect) { /* Fill sector cache with file data */ if (fp->fptr < fp->fsize && - disk_read(fp->fs->drv, fp->buf, sect, 1) != RES_OK) - ABORT(fp->fs, FR_DISK_ERR); + disk_read(fp->fs->drv, fp->buf, sect, 1) != RES_OK) + ABORT(fp->fs, FR_DISK_ERR); } #endif fp->dsect = sect; @@ -2675,6 +2633,10 @@ if (fp->fptr > fp->fsize) fp->fsize = fp->fptr; /* Update file size if needed */ fp->flag |= FA__WRITTEN; /* Set file change flag */ + if (need_sync) { + f_sync (fp); + } + LEAVE_FF(fp->fs, FR_OK); } @@ -2869,8 +2831,7 @@ if (_USE_LFN && *path) tp = path; for (n = 0; tp[n]; n++) ; if (i < n + 3) { - res = FR_NOT_ENOUGH_CORE; - break; + res = FR_NOT_ENOUGH_CORE; break; } while (n) path[--i] = tp[--n]; path[--i] = '/'; @@ -2922,25 +2883,20 @@ if (ofs == CREATE_LINKMAP) { /* Create CLMT */ tbl = fp->cltbl; - tlen = *tbl++; - ulen = 2; /* Given table size and required table size */ + 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 */ + tcl = cl; ncl = 0; ulen += 2; /* Top, length and used items */ do { - pcl = cl; - ncl++; + pcl = cl; ncl++; cl = get_fat(fp->fs, cl); if (cl <= 1) ABORT(fp->fs, FR_INT_ERR); if (cl == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR); } while (cl == pcl + 1); if (ulen <= tlen) { /* Store the length and top of the fragment */ - *tbl++ = ncl; - *tbl++ = tcl; + *tbl++ = ncl; *tbl++ = tcl; } } while (cl < fp->fs->n_fatent); /* Repeat until end of chain */ } @@ -2978,22 +2934,22 @@ } else #endif - /* Normal Seek */ + /* Normal Seek */ { DWORD clst, bcs, nsect, ifptr; if (ofs > fp->fsize /* In read-only mode, clip offset with the file size */ #if !_FS_READONLY - && !(fp->flag & FA_WRITE) + && !(fp->flag & FA_WRITE) #endif - ) ofs = fp->fsize; + ) ofs = fp->fsize; ifptr = fp->fptr; fp->fptr = nsect = 0; if (ofs) { bcs = (DWORD)fp->fs->csize * SS(fp->fs); /* Cluster size (byte) */ if (ifptr > 0 && - (ofs - 1) / bcs >= (ifptr - 1) / bcs) { /* When seek to same or following cluster, */ + (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; @@ -3015,8 +2971,7 @@ if (fp->flag & FA_WRITE) { /* Check if in write mode or not */ 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; + ofs = bcs; break; } } else #endif @@ -3217,21 +3172,14 @@ clst = 2; do { stat = get_fat(fs, clst); - if (stat == 0xFFFFFFFF) { - res = FR_DISK_ERR; - break; - } - if (stat == 1) { - res = FR_INT_ERR; - break; - } + if (stat == 0xFFFFFFFF) { res = FR_DISK_ERR; break; } + if (stat == 1) { res = FR_INT_ERR; break; } if (stat == 0) n++; } while (++clst < fs->n_fatent); } else { clst = fs->n_fatent; sect = fs->fatbase; - i = 0; - p = 0; + i = 0; p = 0; do { if (!i) { res = move_window(fs, sect++); @@ -3241,12 +3189,10 @@ } if (fat == FS_FAT16) { if (LD_WORD(p) == 0) n++; - p += 2; - i -= 2; + p += 2; i -= 2; } else { if ((LD_DWORD(p) & 0x0FFFFFFF) == 0) n++; - p += 4; - i -= 4; + p += 4; i -= 4; } } while (--clst); } @@ -3355,9 +3301,9 @@ res = dir_read(&sdj); if (res == FR_OK /* Not empty dir */ #if _FS_RPATH - || dclst == dj.fs->cdir /* Current dir */ + || dclst == dj.fs->cdir /* Current dir */ #endif - ) res = FR_DENIED; + ) res = FR_DENIED; if (res == FR_NO_FILE) res = FR_OK; /* Empty */ } } @@ -3419,8 +3365,7 @@ ST_DWORD(dir+DIR_WrtTime, tim); st_clust(dir, dcl); mem_cpy(dir+SZ_DIR, dir, SZ_DIR); /* Create ".." entry */ - dir[33] = '.'; - pcl = dj.sclust; + dir[33] = '.'; pcl = dj.sclust; if (dj.fs->fs_type == FS_FAT32 && pcl == dj.fs->dirbase) pcl = 0; st_clust(dir+SZ_DIR, pcl); @@ -3571,7 +3516,7 @@ res = follow_path(&djn, path_new); if (res == FR_OK) res = FR_EXIST; /* The new object name is already existing */ if (res == FR_NO_FILE) { /* Is it a valid path and no name collision? */ - /* Start critical section that an interruption or error can cause cross-link */ +/* 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 */ @@ -3598,7 +3543,7 @@ res = sync(djo.fs); } } - /* End critical section */ +/* End critical section */ } } } @@ -3647,12 +3592,12 @@ if (btr > remain) btr = (UINT)remain; /* Truncate btr by remaining bytes */ for ( ; btr && (*func)(0, 0); /* Repeat until all data transferred or stream becomes busy */ - fp->fptr += rcnt, *bf += rcnt, btr -= rcnt) { + fp->fptr += rcnt, *bf += rcnt, btr -= rcnt) { csect = (BYTE)(fp->fptr / SS(fp->fs) & (fp->fs->csize - 1)); /* Sector offset in the cluster */ if ((fp->fptr % SS(fp->fs)) == 0) { /* On the sector boundary? */ if (!csect) { /* On the cluster boundary? */ clst = (fp->fptr == 0) ? /* On the top of the file? */ - fp->sclust : get_fat(fp->fs, fp->clust); + fp->sclust : get_fat(fp->fs, fp->clust); if (clst <= 1) ABORT(fp->fs, FR_INT_ERR); if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR); fp->clust = clst; /* Update current cluster */ @@ -3780,18 +3725,13 @@ /* Determine number of clusters and final check of validity of the FAT sub-type */ n_clst = (n_vol - n_rsv - n_fat * N_FATS - n_dir) / au; if ( (fmt == FS_FAT16 && n_clst < MIN_FAT16) - || (fmt == FS_FAT32 && n_clst < MIN_FAT32)) + || (fmt == FS_FAT32 && n_clst < MIN_FAT32)) return FR_MKFS_ABORTED; switch (fmt) { /* Determine system ID for partition table */ - case FS_FAT12: - sys = 0x01; - break; - case FS_FAT16: - sys = (n_vol < 0x10000) ? 0x04 : 0x06; - break; - default: - sys = 0x0C; + case FS_FAT12: sys = 0x01; break; + case FS_FAT16: sys = (n_vol < 0x10000) ? 0x04 : 0x06; break; + default: sys = 0x0C; } if (_MULTI_PARTITION && part) { @@ -3900,8 +3840,7 @@ { DWORD eb[2]; - eb[0] = wsect; - eb[1] = wsect + (n_clst - ((fmt == FS_FAT32) ? 1 : 0)) * au - 1; + eb[0] = wsect; eb[1] = wsect + (n_clst - ((fmt == FS_FAT32) ? 1 : 0)) * au - 1; disk_ioctl(pdrv, CTRL_ERASE_SECTOR, eb); } #endif @@ -3952,8 +3891,7 @@ /* Create partition table */ mem_set(buf, 0, _MAX_SS); - p = buf + MBR_Table; - b_cyl = 0; + p = buf + MBR_Table; b_cyl = 0; for (i = 0; i < 4; i++, p += SZ_PTE) { p_cyl = (szt[i] <= 100) ? (DWORD)tot_cyl * szt[i] / 100 : szt[i] / sz_cyl; if (!p_cyl) continue; @@ -3961,8 +3899,7 @@ sz_part = (DWORD)sz_cyl * p_cyl; if (i == 0) { /* Exclude first track of cylinder 0 */ s_hd = 1; - s_part += 63; - sz_part -= 63; + s_part += 63; sz_part -= 63; } else { s_hd = 0; } @@ -4144,12 +4081,10 @@ w = f = 0; c = *str++; if (c == '0') { /* Flag: '0' padding */ - f = 1; - c = *str++; + f = 1; c = *str++; } else { if (c == '-') { /* Flag: left justified */ - f = 2; - c = *str++; + f = 2; c = *str++; } } while (IsDigit(c)) { /* Precision */ @@ -4157,43 +4092,36 @@ c = *str++; } if (c == 'l' || c == 'L') { /* Prefix: Size is long int */ - f |= 4; - c = *str++; + f |= 4; c = *str++; } if (!c) break; d = c; if (IsLower(d)) d -= 0x20; switch (d) { /* Type is... */ - case 'S' : /* String */ - p = va_arg(arp, TCHAR*); - for (j = 0; p[j]; j++) ; - chc = 0; - if (!(f & 2)) { - while (j++ < w) chc += (cc = f_putc(' ', fil)); - } - chc += (cc = f_puts(p, fil)); + case 'S' : /* String */ + p = va_arg(arp, TCHAR*); + for (j = 0; p[j]; j++) ; + chc = 0; + if (!(f & 2)) { while (j++ < w) chc += (cc = f_putc(' ', fil)); - if (cc != EOF) cc = chc; - continue; - case 'C' : /* Character */ - cc = f_putc((TCHAR)va_arg(arp, int), fil); - continue; - case 'B' : /* Binary */ - r = 2; - break; - case 'O' : /* Octal */ - r = 8; - break; - case 'D' : /* Signed decimal */ - case 'U' : /* Unsigned decimal */ - r = 10; - break; - case 'X' : /* Hexdecimal */ - r = 16; - break; - default: /* Unknown type (pass-through) */ - cc = f_putc(c, fil); - continue; + } + chc += (cc = f_puts(p, fil)); + while (j++ < w) chc += (cc = f_putc(' ', fil)); + if (cc != EOF) cc = chc; + continue; + case 'C' : /* Character */ + cc = f_putc((TCHAR)va_arg(arp, int), fil); continue; + case 'B' : /* Binary */ + r = 2; break; + case 'O' : /* Octal */ + r = 8; break; + case 'D' : /* Signed decimal */ + case 'U' : /* Unsigned decimal */ + r = 10; break; + case 'X' : /* Hexdecimal */ + r = 16; break; + default: /* Unknown type (pass-through) */ + cc = f_putc(c, fil); continue; } /* Get an argument and put it in numeral */ @@ -4204,18 +4132,15 @@ } i = 0; do { - d = (TCHAR)(v % r); - v /= r; + d = (TCHAR)(v % r); v /= r; if (d > 9) d += (c == 'x') ? 0x27 : 0x07; s[i++] = d + '0'; } while (v && i < sizeof s / sizeof s[0]); if (f & 8) s[i++] = '-'; - j = i; - d = (f & 1) ? '0' : ' '; + j = i; d = (f & 1) ? '0' : ' '; res = 0; while (!(f & 2) && j++ < w) res += (cc = f_putc(d, fil)); - do res += (cc = f_putc(s[--i], fil)); - while(i); + do res += (cc = f_putc(s[--i], fil)); while(i); while (j++ < w) res += (cc = f_putc(' ', fil)); if (cc != EOF) cc = res; }
--- a/ChaN/ffconf.h Mon Mar 17 14:09:00 2014 +0000 +++ b/ChaN/ffconf.h Thu Aug 28 13:15:31 2014 +0100 @@ -187,5 +187,12 @@ /* To enable file lock control feature, set _FS_LOCK to 1 or greater. The value defines how many files can be opened simultaneously. */ +#define FLUSH_ON_NEW_CLUSTER 0 /* Sync the file on every new cluster */ +#define FLUSH_ON_NEW_SECTOR 1 /* Sync the file on every new sector */ +/* Only one of these two defines needs to be set to 1. If both are set to 0 + the file is only sync when closed. + Clusters are group of sectors (eg: 8 sectors). Flushing on new cluster means + it would be less often than flushing on new sector. Sectors are generally + 512 Bytes long. */ #endif /* _FFCONFIG */
--- a/FATFileHandle.cpp Mon Mar 17 14:09:00 2014 +0000 +++ b/FATFileHandle.cpp Thu Aug 28 13:15:31 2014 +0100 @@ -38,13 +38,13 @@ ssize_t FATFileHandle::write(const void* buffer, size_t length) { UINT n; FRESULT res = f_write(&_fh, buffer, length, &n); - if (res) { + if (res) { debug_if(FFS_DBG, "f_write() failed: %d", res); return -1; } return n; } - + ssize_t FATFileHandle::read(void* buffer, size_t length) { debug_if(FFS_DBG, "read(%d)\n", length); UINT n;
--- a/FATFileSystem.cpp Mon Mar 17 14:09:00 2014 +0000 +++ b/FATFileSystem.cpp Thu Aug 28 13:15:31 2014 +0100 @@ -69,7 +69,7 @@ debug_if(FFS_DBG, "open(%s) on filesystem [%s], drv [%d]\n", name, _name, _fsid); char n[64]; sprintf(n, "%d:/%s", _fsid, name); - + /* POSIX flags -> FatFS open mode */ BYTE openmode; if (flags & O_RDWR) { @@ -86,10 +86,10 @@ openmode |= FA_OPEN_ALWAYS; } } - + FIL fh; FRESULT res = f_open(&fh, n, openmode); - if (res) { + if (res) { debug_if(FFS_DBG, "f_open('w') failed: %d\n", res); return NULL; } @@ -98,16 +98,25 @@ } return new FATFileHandle(fh); } - + int FATFileSystem::remove(const char *filename) { FRESULT res = f_unlink(filename); - if (res) { + if (res) { debug_if(FFS_DBG, "f_unlink() failed: %d\n", res); return -1; } return 0; } +int FATFileSystem::rename(const char *oldname, const char *newname) { + FRESULT res = f_rename(oldname, newname); + if (res) { + debug_if(FFS_DBG, "f_rename() failed: %d\n", res); + return -1; + } + return 0; +} + int FATFileSystem::format() { FRESULT res = f_mkfs(_fsid, 0, 512); // Logical drive number, Partitioning rule, Allocation unit size (bytes per cluster) if (res) { @@ -130,3 +139,15 @@ FRESULT res = f_mkdir(name); return res == 0 ? 0 : -1; } + +int FATFileSystem::mount() { + FRESULT res = f_mount(_fsid, &_fs); + return res == 0 ? 0 : -1; +} + +int FATFileSystem::unmount() { + if (disk_sync()) + return -1; + FRESULT res = f_mount(_fsid, NULL); + return res == 0 ? 0 : -1; +}
--- a/FATFileSystem.h Mon Mar 17 14:09:00 2014 +0000 +++ b/FATFileSystem.h Thu Aug 28 13:15:31 2014 +0100 @@ -30,8 +30,8 @@ using namespace mbed; /** - * FATFileSystem based on ChaN's Fat Filesystem library v0.8 - */ + * FATFileSystem based on ChaN's Fat Filesystem library v0.8 + */ class FATFileSystem : public FileSystemLike { public: @@ -41,36 +41,51 @@ static FATFileSystem * _ffs[_VOLUMES]; // FATFileSystem objects, as parallel to FatFs drives array FATFS _fs; // Work area (file system object) for logical drive int _fsid; - + /** - * Opens a file on the filesystem - */ + * Opens a file on the filesystem + */ virtual FileHandle *open(const char* name, int flags); /** * Removes a file path */ virtual int remove(const char *filename); - + + /** + * Renames a file + */ + virtual int rename(const char *oldname, const char *newname); + /** * Formats a logical drive, FDISK artitioning rule, 512 bytes per cluster */ virtual int format(); - + /** - * Opens a directory on the filesystem - */ + * Opens a directory on the filesystem + */ virtual DirHandle *opendir(const char *name); /** * Creates a directory path */ virtual int mkdir(const char *name, mode_t mode); + + /** + * Mounts the filesystem + */ + virtual int mount(); + + /** + * Unmounts the filesystem + */ + virtual int unmount(); virtual int disk_initialize() { return 0; } virtual int disk_status() { return 0; } - virtual int disk_read(uint8_t * buffer, uint64_t sector) = 0; - virtual int disk_write(const uint8_t * buffer, uint64_t sector) = 0; + virtual int disk_read(uint8_t * buffer, uint64_t sector, uint8_t count) = 0; + virtual int disk_write(const uint8_t * buffer, uint64_t sector, uint8_t count) = 0; virtual int disk_sync() { return 0; } virtual uint64_t disk_sectors() = 0;