From 696ee75469e4e21afa570f8471c81ebd291f243a Mon Sep 17 00:00:00 2001 From: Ben Gras Date: Mon, 20 Jun 2016 14:36:21 +0200 Subject: FAT fs changes: FAT code and larger ROM size . add fatfs umon cli to it. unmodified from the umon 1.19 distribution, apache-licensed. . also add dosfs from the umon 1.19 distribution, which is similarly liberally licensed. . increase available 'ROM' size to 128kB minus 1kB secure + 18kB reserved (numbers from uboot wiki). . no unaligned access - needed to access fields in on-disk structs without gcc generating unaligned access instructions (causes data abort exceptions) . turn on shellvars for BBB as they are needed to connect FATFS to the SD i/o functions --- main/common/dosfs.c | 1326 ++++++++++++++++++++++++++++++++++++++++ main/common/dosfs.h | 393 ++++++++++++ main/common/fatfs.c | 696 +++++++++++++++++++++ ports/beagleboneblack/Makefile | 6 +- ports/beagleboneblack/config.h | 3 +- 5 files changed, 2420 insertions(+), 4 deletions(-) create mode 100644 main/common/dosfs.c create mode 100644 main/common/dosfs.h create mode 100644 main/common/fatfs.c diff --git a/main/common/dosfs.c b/main/common/dosfs.c new file mode 100644 index 0000000..e49fb73 --- /dev/null +++ b/main/common/dosfs.c @@ -0,0 +1,1326 @@ +/* + DOSFS Embedded FAT-Compatible Filesystem + (C) 2005 Lewin A.R.W. Edwards (sysadm@zws.com) + + You are permitted to modify and/or use this code in your own projects without + payment of royalty, regardless of the license(s) you choose for those projects. + + You cannot re-copyright or restrict use of the code as released by Lewin Edwards. + + Modifications: Aug 2006 (esutter/ghenderson) + Initial integration into uMon source tree. + Eliminated a few precedence warnings by adding parenthesis. + Eliminated one "variable unused" warning. + Modifications: Sept 2006 (ghenderson) + Added DFS_DirToCanonical. + All structures in dosfs.h have been defined with the + __attribute__ ((__packed__)). + Added macros in dosfs.h to help in formating time, + date, and filesize. + Modifications: Sept 25, 2006 (esutter) + Updated to dosfs-1.02 (dated Sept 16, 2006). + Modifications: Oct 2, 2006 (esutter) + Updated to dosfs-1.03 (dated Sept 30, 2006). + Incorporate fix from Graham Henderson (see USE_GMHFIX) +*/ +#include "config.h" + +#if INCLUDE_FATFS +#include "genlib.h" +#include "dosfs.h" + +#define memcpy(a,b,c) memcpy((char *)a, (char *)b,(int)c) +#define memset(a,b,c) memset((char *)a, (char)b,(int)c) +#define memcmp(a,b,c) memcmp((char *)a, (char *)b,(int)c) + +/* + Get starting sector# of specified partition on drive #unit + NOTE: This code ASSUMES an MBR on the disk. + scratchsector should point to a SECTOR_SIZE scratch area + Returns 0xffffffff for any error. + If pactive is non-NULL, this function also returns the partition active flag. + If pptype is non-NULL, this function also returns the partition type. + If psize is non-NULL, this function also returns the partition size. +*/ +uint32_t DFS_GetPtnStart(uint8_t unit, uint8_t *scratchsector, uint8_t pnum, uint8_t *pactive, uint8_t *pptype, uint32_t *psize) +{ + uint32_t result; + PMBR mbr = (PMBR) scratchsector; + + // DOS ptable supports maximum 4 partitions + if (pnum > 3) + return DFS_ERRMISC; + + // Read MBR from target media + if (DFS_ReadSector(unit,scratchsector,0,1)) { + return DFS_ERRMISC; + } + + result = (uint32_t) mbr->ptable[pnum].start_0 | + (((uint32_t) mbr->ptable[pnum].start_1) << 8) | + (((uint32_t) mbr->ptable[pnum].start_2) << 16) | + (((uint32_t) mbr->ptable[pnum].start_3) << 24); + + if (pactive) + *pactive = mbr->ptable[pnum].active; + + if (pptype) + *pptype = mbr->ptable[pnum].type; + + if (psize) + *psize = (uint32_t) mbr->ptable[pnum].size_0 | + (((uint32_t) mbr->ptable[pnum].size_1) << 8) | + (((uint32_t) mbr->ptable[pnum].size_2) << 16) | + (((uint32_t) mbr->ptable[pnum].size_3) << 24); + + return result; +} + + +/* + Retrieve volume info from BPB and store it in a VOLINFO structure + You must provide the unit and starting sector of the filesystem, and + a pointer to a sector buffer for scratch + Attempts to read BPB and glean information about the FS from that. + Returns 0 OK, nonzero for any error. +*/ +uint32_t DFS_GetVolInfo(uint8_t unit, uint8_t *scratchsector, uint32_t startsector, PVOLINFO volinfo) +{ + PLBR lbr = (PLBR) scratchsector; + volinfo->unit = unit; + volinfo->startsector = startsector; + + if(DFS_ReadSector(unit,scratchsector,startsector,1)) + return DFS_ERRMISC; + +// tag: OEMID, refer dosfs.h +// strncpy(volinfo->oemid, lbr->oemid, 8); +// volinfo->oemid[8] = 0; + + volinfo->secperclus = lbr->bpb.secperclus; + volinfo->reservedsecs = (uint16_t) lbr->bpb.reserved_l | + (((uint16_t) lbr->bpb.reserved_h) << 8); + + volinfo->numsecs = (uint16_t) lbr->bpb.sectors_s_l | + (((uint16_t) lbr->bpb.sectors_s_h) << 8); + + if (!volinfo->numsecs) + volinfo->numsecs = (uint32_t) lbr->bpb.sectors_l_0 | + (((uint32_t) lbr->bpb.sectors_l_1) << 8) | + (((uint32_t) lbr->bpb.sectors_l_2) << 16) | + (((uint32_t) lbr->bpb.sectors_l_3) << 24); + + // If secperfat is 0, we must be in a FAT32 volume; get secperfat + // from the FAT32 EBPB. The volume label and system ID string are also + // in different locations for FAT12/16 vs FAT32. + volinfo->secperfat = (uint16_t) lbr->bpb.secperfat_l | + (((uint16_t) lbr->bpb.secperfat_h) << 8); + if (!volinfo->secperfat) { + volinfo->secperfat = (uint32_t) lbr->ebpb.ebpb32.fatsize_0 | + (((uint32_t) lbr->ebpb.ebpb32.fatsize_1) << 8) | + (((uint32_t) lbr->ebpb.ebpb32.fatsize_2) << 16) | + (((uint32_t) lbr->ebpb.ebpb32.fatsize_3) << 24); + + memcpy(volinfo->label, lbr->ebpb.ebpb32.label, 11); + volinfo->label[11] = 0; + +// tag: OEMID, refer dosfs.h +// memcpy(volinfo->system, lbr->ebpb.ebpb32.system, 8); +// volinfo->system[8] = 0; + } + else { + memcpy(volinfo->label, lbr->ebpb.ebpb.label, 11); + volinfo->label[11] = 0; + +// tag: OEMID, refer dosfs.h +// memcpy(volinfo->system, lbr->ebpb.ebpb.system, 8); +// volinfo->system[8] = 0; + } + + // note: if rootentries is 0, we must be in a FAT32 volume. + volinfo->rootentries = (uint16_t) lbr->bpb.rootentries_l | + (((uint16_t) lbr->bpb.rootentries_h) << 8); + + // after extracting raw info we perform some useful precalculations + volinfo->fat1 = startsector + volinfo->reservedsecs; + + // The calculation below is designed to round up the root directory size for FAT12/16 + // and to simply ignore the root directory for FAT32, since it's a normal, expandable + // file in that situation. + if (volinfo->rootentries) { + volinfo->rootdir = volinfo->fat1 + (volinfo->secperfat * 2); + volinfo->dataarea = volinfo->rootdir + (((volinfo->rootentries * 32) + (SECTOR_SIZE - 1)) / SECTOR_SIZE); + } + else { + volinfo->dataarea = volinfo->fat1 + (volinfo->secperfat * 2); + volinfo->rootdir = (uint32_t) lbr->ebpb.ebpb32.root_0 | + (((uint32_t) lbr->ebpb.ebpb32.root_1) << 8) | + (((uint32_t) lbr->ebpb.ebpb32.root_2) << 16) | + (((uint32_t) lbr->ebpb.ebpb32.root_3) << 24); + } + + // Calculate number of clusters in data area and infer FAT type from this information. + volinfo->numclusters = (volinfo->numsecs - volinfo->dataarea) / volinfo->secperclus; + if (volinfo->numclusters < 4085) + volinfo->filesystem = FAT12; + else if (volinfo->numclusters < 65525) + volinfo->filesystem = FAT16; + else + volinfo->filesystem = FAT32; + + return DFS_OK; +} + +/* + Fetch FAT entry for specified cluster number + You must provide a scratch buffer for one sector (SECTOR_SIZE) and a populated VOLINFO + Returns a FAT32 BAD_CLUSTER value for any error, otherwise the contents of the desired + FAT entry. + scratchcache should point to a UINT32. This variable caches the physical sector number + last read into the scratch buffer for performance enhancement reasons. +*/ +uint32_t DFS_GetFAT(PVOLINFO volinfo, uint8_t *scratch, uint32_t *scratchcache, uint32_t cluster) +{ + uint32_t offset, sector, result; + + if (volinfo->filesystem == FAT12) { + offset = cluster + (cluster / 2); + } + else if (volinfo->filesystem == FAT16) { + offset = cluster * 2; + } + else if (volinfo->filesystem == FAT32) { + offset = cluster * 4; + } + else + return 0x0ffffff7; // FAT32 bad cluster + + // at this point, offset is the BYTE offset of the desired sector from the start + // of the FAT. Calculate the physical sector containing this FAT entry. + sector = ldiv(offset, SECTOR_SIZE).quot + volinfo->fat1; + + // If this is not the same sector we last read, then read it into RAM + if (sector != *scratchcache) { + if(DFS_ReadSector(volinfo->unit, scratch, sector, 1)) { + // avoid anyone assuming that this cache value is still valid, which + // might cause disk corruption + *scratchcache = 0; + return 0x0ffffff7; // FAT32 bad cluster + } + *scratchcache = sector; + } + + // At this point, we "merely" need to extract the relevant entry. + // This is easy for FAT16 and FAT32, but a royal PITA for FAT12 as a single entry + // may span a sector boundary. The normal way around this is always to read two + // FAT sectors, but that luxury is (by design intent) unavailable to DOSFS. + offset = ldiv(offset, SECTOR_SIZE).rem; + + if (volinfo->filesystem == FAT12) { + // Special case for sector boundary - Store last byte of current sector. + // Then read in the next sector and put the first byte of that sector into + // the high byte of result. + if (offset == SECTOR_SIZE - 1) { + result = (uint32_t) scratch[offset]; + sector++; + if(DFS_ReadSector(volinfo->unit, scratch, sector, 1)) { + // avoid anyone assuming that this cache value is still valid, which + // might cause disk corruption + *scratchcache = 0; + return 0x0ffffff7; // FAT32 bad cluster + } + *scratchcache = sector; + // Thanks to Claudio Leonel for pointing out this missing line. + result |= ((uint32_t) scratch[0]) << 8; + } + else { + result = (uint32_t) scratch[offset] | + ((uint32_t) scratch[offset+1]) << 8; + } + if (cluster & 1) + result = result >> 4; + else + result = result & 0xfff; + } + else if (volinfo->filesystem == FAT16) { + result = (uint32_t) scratch[offset] | + ((uint32_t) scratch[offset+1]) << 8; + } + else if (volinfo->filesystem == FAT32) { + result = ((uint32_t) scratch[offset] | + ((uint32_t) scratch[offset+1]) << 8 | + ((uint32_t) scratch[offset+2]) << 16 | + ((uint32_t) scratch[offset+3]) << 24) & 0x0fffffff; + } + else + result = 0x0ffffff7; // FAT32 bad cluster + return result; +} + + +/* + Set FAT entry for specified cluster number + You must provide a scratch buffer for one sector (SECTOR_SIZE) and a populated VOLINFO + Returns DFS_ERRMISC for any error, otherwise DFS_OK + scratchcache should point to a UINT32. This variable caches the physical sector number + last read into the scratch buffer for performance enhancement reasons. + + NOTE: This code is HIGHLY WRITE-INEFFICIENT, particularly for flash media. Considerable + performance gains can be realized by caching the sector. However this is difficult to + achieve on FAT12 without requiring 2 sector buffers of scratch space, and it is a design + requirement of this code to operate on a single 512-byte scratch. + + If you are operating DOSFS over flash, you are strongly advised to implement a writeback + cache in your physical I/O driver. This will speed up your code significantly and will + also conserve power and flash write life. +*/ +uint32_t DFS_SetFAT(PVOLINFO volinfo, uint8_t *scratch, uint32_t *scratchcache, uint32_t cluster, uint32_t new_contents) +{ + uint32_t offset, sector, result; + if (volinfo->filesystem == FAT12) { + offset = cluster + (cluster / 2); + new_contents &=0xfff; + } + else if (volinfo->filesystem == FAT16) { + offset = cluster * 2; + new_contents &=0xffff; + } + else if (volinfo->filesystem == FAT32) { + offset = cluster * 4; + new_contents &=0x0fffffff; // FAT32 is really "FAT28" + } + else + return DFS_ERRMISC; + + // at this point, offset is the BYTE offset of the desired sector from the start + // of the FAT. Calculate the physical sector containing this FAT entry. + sector = ldiv(offset, SECTOR_SIZE).quot + volinfo->fat1; + + // If this is not the same sector we last read, then read it into RAM + if (sector != *scratchcache) { + if(DFS_ReadSector(volinfo->unit, scratch, sector, 1)) { + // avoid anyone assuming that this cache value is still valid, which + // might cause disk corruption + *scratchcache = 0; + return DFS_ERRMISC; + } + *scratchcache = sector; + } + + // At this point, we "merely" need to extract the relevant entry. + // This is easy for FAT16 and FAT32, but a royal PITA for FAT12 as a single entry + // may span a sector boundary. The normal way around this is always to read two + // FAT sectors, but that luxury is (by design intent) unavailable to DOSFS. + offset = ldiv(offset, SECTOR_SIZE).rem; + + if (volinfo->filesystem == FAT12) { + + // If this is an odd cluster, pre-shift the desired new contents 4 bits to + // make the calculations below simpler + if (cluster & 1) + new_contents = new_contents << 4; + + // Special case for sector boundary + if (offset == SECTOR_SIZE - 1) { + + // Odd cluster: High 12 bits being set + if (cluster & 1) { + scratch[offset] = (scratch[offset] & 0x0f) | (new_contents & 0xf0); + } + // Even cluster: Low 12 bits being set + else { + scratch[offset] = new_contents & 0xff; + } + result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1); + // mirror the FAT into copy 2 + if (DFS_OK == result) + result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1); + + // If we wrote that sector OK, then read in the subsequent sector + // and poke the first byte with the remainder of this FAT entry. + if (DFS_OK == result) { +#if 0 + /* ELSNOTE: + * Original line here is illegal (IMHO). Didn't notice this + * till I used a version of GCC that warned me about it. + * I changed this to eliminate the warning, and *hopefully* + * generate the correct code. Have not been able to test this. + */ + *scratchcache++; +#else + (*scratchcache)++; +#endif + result = DFS_ReadSector(volinfo->unit, scratch, *scratchcache, 1); + if (DFS_OK == result) { + // Odd cluster: High 12 bits being set + if (cluster & 1) { + scratch[0] = new_contents & 0xff00; + } + // Even cluster: Low 12 bits being set + else { + scratch[0] = (scratch[0] & 0xf0) | (new_contents & 0x0f); + } + result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1); + // mirror the FAT into copy 2 + if (DFS_OK == result) + result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1); + } + else { + // avoid anyone assuming that this cache value is still valid, which + // might cause disk corruption + *scratchcache = 0; + } + } + } // if (offset == SECTOR_SIZE - 1) + + // Not a sector boundary. But we still have to worry about if it's an odd + // or even cluster number. + else { + // Odd cluster: High 12 bits being set + if (cluster & 1) { + scratch[offset] = (scratch[offset] & 0x0f) | (new_contents & 0xf0); + scratch[offset+1] = new_contents & 0xff00; + } + // Even cluster: Low 12 bits being set + else { + scratch[offset] = new_contents & 0xff; + scratch[offset+1] = (scratch[offset+1] & 0xf0) | (new_contents & 0x0f); + } + result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1); + // mirror the FAT into copy 2 + if (DFS_OK == result) + result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1); + } + } + else if (volinfo->filesystem == FAT16) { + scratch[offset] = (new_contents & 0xff); + scratch[offset+1] = (new_contents & 0xff00) >> 8; + result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1); + // mirror the FAT into copy 2 + if (DFS_OK == result) + result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1); + } + else if (volinfo->filesystem == FAT32) { + scratch[offset] = (new_contents & 0xff); + scratch[offset+1] = (new_contents & 0xff00) >> 8; + scratch[offset+2] = (new_contents & 0xff0000) >> 16; + scratch[offset+3] = (scratch[offset+3] & 0xf0) | ((new_contents & 0x0f000000) >> 24); + // Note well from the above: Per Microsoft's guidelines we preserve the upper + // 4 bits of the FAT32 cluster value. It's unclear what these bits will be used + // for; in every example I've encountered they are always zero. + result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1); + // mirror the FAT into copy 2 + if (DFS_OK == result) + result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1); + } + else + result = DFS_ERRMISC; + + return result; +} + +/* + Convert a filename element from canonical (8.3) to directory entry (11) form + src must point to the first non-separator character. + dest must point to a 12-byte buffer. +*/ +uint8_t *DFS_CanonicalToDir(uint8_t *dest, uint8_t *src) +{ + uint8_t *destptr = dest; + + memset(dest, ' ', 11); + dest[11] = 0; + + while (*src && (*src != DIR_SEPARATOR) && (destptr - dest < 11)) { + if (*src >= 'a' && *src <='z') { + *destptr++ = (*src - 'a') + 'A'; + src++; + } + else if (*src == '.') { + src++; + destptr = dest + 8; + } + else { + *destptr++ = *src++; + } + } + + return dest; +} + +/* + Find the first unused FAT entry + You must provide a scratch buffer for one sector (SECTOR_SIZE) and a populated VOLINFO + Returns a FAT32 BAD_CLUSTER value for any error, otherwise the contents of the desired + FAT entry. + Returns FAT32 bad_sector (0x0ffffff7) if there is no free cluster available +*/ +uint32_t DFS_GetFreeFAT(PVOLINFO volinfo, uint8_t *scratch) +{ + uint32_t i, result = 0xffffffff, scratchcache = 0; + + // Search starts at cluster 2, which is the first usable cluster + // NOTE: This search can't terminate at a bad cluster, because there might + // legitimately be bad clusters on the disk. + for (i=2; i < volinfo->numclusters; i++) { + result = DFS_GetFAT(volinfo, scratch, &scratchcache, i); + if (!result) { + return i; + } + } + return 0x0ffffff7; // Can't find a free cluster +} + + +/* + Open a directory for enumeration by DFS_GetNextDirEnt + You must supply a populated VOLINFO (see DFS_GetVolInfo) + The empty string or a string containing only the directory separator are + considered to be the root directory. + Returns 0 OK, nonzero for any error. +*/ +uint32_t DFS_OpenDir(PVOLINFO volinfo, uint8_t *dirname, PDIRINFO dirinfo) +{ + // Default behavior is a regular search for existing entries + dirinfo->flags = 0; + + if (!strlen((char *) dirname) || (strlen((char *) dirname) == 1 && dirname[0] == DIR_SEPARATOR)) { + if (volinfo->filesystem == FAT32) { + dirinfo->currentcluster = volinfo->rootdir; + dirinfo->currentsector = 0; + dirinfo->currententry = 0; + + // read first sector of directory + return DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->dataarea + ((volinfo->rootdir - 2) * volinfo->secperclus), 1); + } + else { + dirinfo->currentcluster = 0; + dirinfo->currentsector = 0; + dirinfo->currententry = 0; + + // read first sector of directory + return DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->rootdir, 1); + } + } + + // This is not the root directory. We need to find the start of this subdirectory. + // We do this by devious means, using our own companion function DFS_GetNext. + else { + uint8_t tmpfn[12]; + uint8_t *ptr = dirname; + uint32_t result; + DIRENT de; + + if (volinfo->filesystem == FAT32) { + dirinfo->currentcluster = volinfo->rootdir; + dirinfo->currentsector = 0; + dirinfo->currententry = 0; + + // read first sector of directory + if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->dataarea + ((volinfo->rootdir - 2) * volinfo->secperclus), 1)) + return DFS_ERRMISC; + } + else { + dirinfo->currentcluster = 0; + dirinfo->currentsector = 0; + dirinfo->currententry = 0; + + // read first sector of directory + if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->rootdir, 1)) + return DFS_ERRMISC; + } + + // skip leading path separators + while (*ptr == DIR_SEPARATOR && *ptr) + ptr++; + + // Scan the path from left to right, finding the start cluster of each entry + // Observe that this code is inelegant, but obviates the need for recursion. + while (*ptr) { + DFS_CanonicalToDir(tmpfn, ptr); + + de.name[0] = 0; + + do { + result = DFS_GetNext(volinfo, dirinfo, &de); + } while (!result && memcmp(de.name, tmpfn, 11)); + + if (!memcmp(de.name, tmpfn, 11) && ((de.attr & ATTR_DIRECTORY) == ATTR_DIRECTORY)) { + if (volinfo->filesystem == FAT32) { + dirinfo->currentcluster = (uint32_t) de.startclus_l_l | + ((uint32_t) de.startclus_l_h) << 8 | + ((uint32_t) de.startclus_h_l) << 16 | + ((uint32_t) de.startclus_h_h) << 24; + } + else { + dirinfo->currentcluster = (uint32_t) de.startclus_l_l | + ((uint32_t) de.startclus_l_h) << 8; + } + dirinfo->currentsector = 0; + dirinfo->currententry = 0; + + if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->dataarea + ((dirinfo->currentcluster - 2) * volinfo->secperclus), 1)) + return DFS_ERRMISC; + } + else if (!memcmp(de.name, tmpfn, 11) && !(de.attr & ATTR_DIRECTORY)) + return DFS_NOTFOUND; + + // seek to next item in list + while (*ptr != DIR_SEPARATOR && *ptr) + ptr++; + if (*ptr == DIR_SEPARATOR) + ptr++; + } + + if (!dirinfo->currentcluster) + return DFS_NOTFOUND; + } + return DFS_OK; +} + +/* + Get next entry in opened directory structure. Copies fields into the dirent + structure, updates dirinfo. Note that it is the _caller's_ responsibility to + handle the '.' and '..' entries. + A deleted file will be returned as a NULL entry (first char of filename=0) + by this code. Filenames beginning with 0x05 will be translated to 0xE5 + automatically. Long file name entries will be returned as NULL. + returns DFS_EOF if there are no more entries, DFS_OK if this entry is valid, + or DFS_ERRMISC for a media error +*/ +uint32_t DFS_GetNext(PVOLINFO volinfo, PDIRINFO dirinfo, PDIRENT dirent) +{ + uint32_t tempint; // required by DFS_GetFAT + + // Do we need to read the next sector of the directory? + if (dirinfo->currententry >= SECTOR_SIZE / sizeof(DIRENT)) { + dirinfo->currententry = 0; + dirinfo->currentsector++; + + // Root directory; special case handling + // Note that currentcluster will only ever be zero if both: + // (a) this is the root directory, and + // (b) we are on a FAT12/16 volume, where the root dir can't be expanded + if (dirinfo->currentcluster == 0) { + // Trying to read past end of root directory? + if (dirinfo->currentsector * (SECTOR_SIZE / sizeof(DIRENT)) >= volinfo->rootentries) + return DFS_EOF; + + // Otherwise try to read the next sector + if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->rootdir + dirinfo->currentsector, 1)) + return DFS_ERRMISC; + } + + // Normal handling + else { + if (dirinfo->currentsector >= volinfo->secperclus) { + dirinfo->currentsector = 0; + if ((dirinfo->currentcluster >= 0xff7 && volinfo->filesystem == FAT12) || + (dirinfo->currentcluster >= 0xfff7 && volinfo->filesystem == FAT16) || + (dirinfo->currentcluster >= 0x0ffffff7 && volinfo->filesystem == FAT32)) { + + // We are at the end of the directory chain. If this is a normal + // find operation, we should indicate that there is nothing more + // to see. + if (!(dirinfo->flags & DFS_DI_BLANKENT)) + return DFS_EOF; + + // On the other hand, if this is a "find free entry" search, + // we need to tell the caller to allocate a new cluster + else + return DFS_ALLOCNEW; + } + dirinfo->currentcluster = DFS_GetFAT(volinfo, dirinfo->scratch, &tempint, dirinfo->currentcluster); + } + if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->dataarea + ((dirinfo->currentcluster - 2) * volinfo->secperclus) + dirinfo->currentsector, 1)) + return DFS_ERRMISC; + } + } + + memcpy(dirent, &(((PDIRENT) dirinfo->scratch)[dirinfo->currententry]), sizeof(DIRENT)); + + if (dirent->name[0] == 0) { // no more files in this directory + // If this is a "find blank" then we can reuse this name. + if (dirinfo->flags & DFS_DI_BLANKENT) + return DFS_OK; + else + return DFS_EOF; + } + + if (dirent->name[0] == 0xe5) // handle deleted file entries + dirent->name[0] = 0; + else if ((dirent->attr & ATTR_LONG_NAME) == ATTR_LONG_NAME) + dirent->name[0] = 0; + else if (dirent->name[0] == 0x05) // handle kanji filenames beginning with 0xE5 + dirent->name[0] = 0xe5; + + dirinfo->currententry++; + + return DFS_OK; +} + +/* + INTERNAL + Find a free directory entry in the directory specified by path + This function MAY cause a disk write if it is necessary to extend the directory + size. + Note - di.scratch must be preinitialized to point to a sector scratch buffer + de is a scratch structure + Returns DFS_ERRMISC if a new entry could not be located or created + de is updated with the same return information you would expect from DFS_GetNext +*/ +uint32_t DFS_GetFreeDirEnt(PVOLINFO volinfo, uint8_t *path, PDIRINFO di, PDIRENT de) +{ + uint32_t tempclus,i; + + if (DFS_OpenDir(volinfo, path, di)) + return DFS_NOTFOUND; + + // Set "search for empty" flag so DFS_GetNext knows what we're doing + di->flags |= DFS_DI_BLANKENT; + + // We seek through the directory looking for an empty entry + // Note we are reusing tempclus as a temporary result holder. + tempclus = 0; + do { + tempclus = DFS_GetNext(volinfo, di, de); + + // Empty entry found + if (tempclus == DFS_OK && (!de->name[0])) { + return DFS_OK; + } + + // End of root directory reached + else if (tempclus == DFS_EOF) + return DFS_ERRMISC; + + else if (tempclus == DFS_ALLOCNEW) { + tempclus = DFS_GetFreeFAT(volinfo, di->scratch); + if (tempclus == 0x0ffffff7) + return DFS_ERRMISC; + + // write out zeroed sectors to the new cluster + memset(di->scratch, 0, SECTOR_SIZE); + for (i=0;isecperclus;i++) { + if (DFS_WriteSector(volinfo->unit, di->scratch, volinfo->dataarea + ((tempclus - 2) * volinfo->secperclus) + i, 1)) + return DFS_ERRMISC; + } + // Point old end cluster to newly allocated cluster + i = 0; + DFS_SetFAT(volinfo, di->scratch, &i, di->currentcluster, tempclus); + + // Update DIRINFO so caller knows where to place the new file + di->currentcluster = tempclus; + di->currentsector = 0; + di->currententry = 1; // since the code coming after this expects to subtract 1 + + // Mark newly allocated cluster as end of chain + switch(volinfo->filesystem) { + case FAT12: tempclus = 0xff8; break; + case FAT16: tempclus = 0xfff8; break; + case FAT32: tempclus = 0x0ffffff8; break; + default: return DFS_ERRMISC; + } + DFS_SetFAT(volinfo, di->scratch, &i, di->currentcluster, tempclus); + } + } while (!tempclus); + + // We shouldn't get here + return DFS_ERRMISC; +} + +/* + Open a file for reading or writing. You supply populated VOLINFO, a path to the file, + mode (DFS_READ or DFS_WRITE) and an empty fileinfo structure. You also need to + provide a pointer to a sector-sized scratch buffer. + Returns various DFS_* error states. If the result is DFS_OK, fileinfo can be used + to access the file from this point on. +*/ +uint32_t DFS_OpenFile(PVOLINFO volinfo, uint8_t *path, uint8_t mode, uint8_t *scratch, PFILEINFO fileinfo) +{ + uint8_t tmppath[MAX_PATH]; + uint8_t filename[12]; + uint8_t *p; + DIRINFO di; + DIRENT de; + + // larwe 2006-09-16 +1 zero out file structure + memset(fileinfo, 0, sizeof(FILEINFO)); + + // save access mode + fileinfo->mode = mode; + + // Get a local copy of the path. If it's longer than MAX_PATH, abort. + strncpy((char *) tmppath, (char *) path, MAX_PATH); + tmppath[MAX_PATH - 1] = 0; + if (strcmp((char *) path,(char *) tmppath)) { + return DFS_PATHLEN; + } + + // strip leading path separators + while (tmppath[0] == DIR_SEPARATOR) + strcpy((char *) tmppath, (char *) tmppath + 1); + + // Parse filename off the end of the supplied path + p = tmppath; + while (*(p++)); + + p--; + while (p > tmppath && *p != DIR_SEPARATOR) // larwe 9/16/06 ">=" to ">" bugfix + p--; + if (*p == DIR_SEPARATOR) + p++; + + DFS_CanonicalToDir(filename, p); + + if (p > tmppath) + p--; + if (*p == DIR_SEPARATOR || p == tmppath) // larwe 9/16/06 +"|| p == tmppath" bugfix + *p = 0; + + // At this point, if our path was MYDIR/MYDIR2/FILE.EXT, filename = "FILE EXT" and + // tmppath = "MYDIR/MYDIR2". + di.scratch = scratch; + if (DFS_OpenDir(volinfo, tmppath, &di)) + return DFS_NOTFOUND; + + while (!DFS_GetNext(volinfo, &di, &de)) { + if (!memcmp(de.name, filename, 11)) { + // You can't use this function call to open a directory. + if (de.attr & ATTR_DIRECTORY) + return DFS_NOTFOUND; + + fileinfo->volinfo = volinfo; + fileinfo->pointer = 0; + // The reason we store this extra info about the file is so that we can + // speedily update the file size, modification date, etc. on a file that is + // opened for writing. + if (di.currentcluster == 0) + fileinfo->dirsector = volinfo->rootdir + di.currentsector; + else + fileinfo->dirsector = volinfo->dataarea + ((di.currentcluster - 2) * volinfo->secperclus) + di.currentsector; + fileinfo->diroffset = di.currententry - 1; + if (volinfo->filesystem == FAT32) { + fileinfo->cluster = (uint32_t) de.startclus_l_l | + ((uint32_t) de.startclus_l_h) << 8 | + ((uint32_t) de.startclus_h_l) << 16 | + ((uint32_t) de.startclus_h_h) << 24; + } + else { + fileinfo->cluster = (uint32_t) de.startclus_l_l | + ((uint32_t) de.startclus_l_h) << 8; + } + fileinfo->firstcluster = fileinfo->cluster; + fileinfo->filelen = (uint32_t) de.filesize_0 | + ((uint32_t) de.filesize_1) << 8 | + ((uint32_t) de.filesize_2) << 16 | + ((uint32_t) de.filesize_3) << 24; + + return DFS_OK; + } + } + + // At this point, we KNOW the file does not exist. If the file was opened + // with write access, we can create it. + if (mode & DFS_WRITE) { + uint32_t cluster, temp; + + // Locate or create a directory entry for this file + if (DFS_OK != DFS_GetFreeDirEnt(volinfo, tmppath, &di, &de)) + return DFS_ERRMISC; + + // put sane values in the directory entry + memset(&de, 0, sizeof(de)); + memcpy(de.name, filename, 11); + de.crttime_l = 0x20; // 01:01:00am, Jan 1, 2006. + de.crttime_h = 0x08; + de.crtdate_l = 0x11; + de.crtdate_h = 0x34; + de.lstaccdate_l = 0x11; + de.lstaccdate_h = 0x34; + de.wrttime_l = 0x20; + de.wrttime_h = 0x08; + de.wrtdate_l = 0x11; + de.wrtdate_h = 0x34; + + // allocate a starting cluster for the directory entry + cluster = DFS_GetFreeFAT(volinfo, scratch); + + de.startclus_l_l = cluster & 0xff; + de.startclus_l_h = (cluster & 0xff00) >> 8; + de.startclus_h_l = (cluster & 0xff0000) >> 16; + de.startclus_h_h = (cluster & 0xff000000) >> 24; + + // update FILEINFO for our caller's sake + fileinfo->volinfo = volinfo; + fileinfo->pointer = 0; + // The reason we store this extra info about the file is so that we can + // speedily update the file size, modification date, etc. on a file that is + // opened for writing. + if (di.currentcluster == 0) + fileinfo->dirsector = volinfo->rootdir + di.currentsector; + else + fileinfo->dirsector = volinfo->dataarea + ((di.currentcluster - 2) * volinfo->secperclus) + di.currentsector; +#ifdef USE_GMHFIX + fileinfo->diroffset = di.currententry; +#else + fileinfo->diroffset = di.currententry - 1; +#endif + fileinfo->cluster = cluster; + fileinfo->firstcluster = cluster; + fileinfo->filelen = 0; + + // write the directory entry + // note that we no longer have the sector containing the directory entry, + // tragically, so we have to re-read it + if (DFS_ReadSector(volinfo->unit, scratch, fileinfo->dirsector, 1)) + return DFS_ERRMISC; +#ifdef USE_GMHFIX + memcpy(&(((PDIRENT) scratch)[di.currententry]), &de, sizeof(DIRENT)); +#else + memcpy(&(((PDIRENT) scratch)[di.currententry-1]), &de, sizeof(DIRENT)); +#endif + if (DFS_WriteSector(volinfo->unit, scratch, fileinfo->dirsector, 1)) + return DFS_ERRMISC; + + // Mark newly allocated cluster as end of chain + switch(volinfo->filesystem) { + case FAT12: cluster = 0xff8; break; + case FAT16: cluster = 0xfff8; break; + case FAT32: cluster = 0x0ffffff8; break; + default: return DFS_ERRMISC; + } + temp = 0; + DFS_SetFAT(volinfo, scratch, &temp, fileinfo->cluster, cluster); + + return DFS_OK; + } + + return DFS_NOTFOUND; +} + +/* + Read an open file + You must supply a prepopulated FILEINFO as provided by DFS_OpenFile, and a + pointer to a SECTOR_SIZE scratch buffer. + Note that returning DFS_EOF is not an error condition. This function updates the + successcount field with the number of bytes actually read. +*/ +uint32_t DFS_ReadFile(PFILEINFO fileinfo, uint8_t *scratch, uint8_t *buffer, uint32_t *successcount, uint32_t len) +{ + uint32_t remain; + uint32_t result = DFS_OK; + uint32_t sector; + uint32_t bytesread; + + // Don't try to read past EOF + if (len > fileinfo->filelen - fileinfo->pointer) + len = fileinfo->filelen - fileinfo->pointer; + + remain = len; + *successcount = 0; + + while (remain && result == DFS_OK) { + // This is a bit complicated. The sector we want to read is addressed at a cluster + // granularity by the fileinfo->cluster member. The file pointer tells us how many + // extra sectors to add to that number. + sector = fileinfo->volinfo->dataarea + + ((fileinfo->cluster - 2) * fileinfo->volinfo->secperclus) + + div(div(fileinfo->pointer,fileinfo->volinfo->secperclus * SECTOR_SIZE).rem, SECTOR_SIZE).quot; + + // Case 1 - File pointer is not on a sector boundary + if (div(fileinfo->pointer, SECTOR_SIZE).rem) { + uint16_t tempreadsize; + + // We always have to go through scratch in this case + result = DFS_ReadSector(fileinfo->volinfo->unit, scratch, sector, 1); + + // This is the number of bytes that we actually care about in the sector + // just read. + tempreadsize = SECTOR_SIZE - (div(fileinfo->pointer, SECTOR_SIZE).rem); + + // Case 1A - We want the entire remainder of the sector. After this + // point, all passes through the read loop will be aligned on a sector + // boundary, which allows us to go through the optimal path 2A below. + if (remain >= tempreadsize) { + memcpy(buffer, scratch + (SECTOR_SIZE - tempreadsize), tempreadsize); + bytesread = tempreadsize; + buffer += tempreadsize; + fileinfo->pointer += tempreadsize; + remain -= tempreadsize; + } + // Case 1B - This read concludes the file read operation + else { + memcpy(buffer, scratch + (SECTOR_SIZE - tempreadsize), remain); + + buffer += remain; + fileinfo->pointer += remain; + bytesread = remain; + remain = 0; + } + } + // Case 2 - File pointer is on sector boundary + else { + // Case 2A - We have at least one more full sector to read and don't have + // to go through the scratch buffer. You could insert optimizations here to + // read multiple sectors at a time, if you were thus inclined (note that + // the maximum multi-read you could perform is a single cluster, so it would + // be advantageous to have code similar to case 1A above that would round the + // pointer to a cluster boundary the first pass through, so all subsequent + // [large] read requests would be able to go a cluster at a time). + if (remain >= SECTOR_SIZE) { + result = DFS_ReadSector(fileinfo->volinfo->unit, buffer, sector, 1); + remain -= SECTOR_SIZE; + buffer += SECTOR_SIZE; + fileinfo->pointer += SECTOR_SIZE; + bytesread = SECTOR_SIZE; + } + // Case 2B - We are only reading a partial sector + else { + result = DFS_ReadSector(fileinfo->volinfo->unit, scratch, sector, 1); + memcpy(buffer, scratch, remain); + buffer += remain; + fileinfo->pointer += remain; + bytesread = remain; + remain = 0; + } + } + + *successcount += bytesread; + + // check to see if we stepped over a cluster boundary + if (div(fileinfo->pointer - bytesread, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot != + div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot) { + // An act of minor evil - we use bytesread as a scratch integer, knowing that + // its value is not used after updating *successcount above + bytesread = 0; + if (((fileinfo->volinfo->filesystem == FAT12) && (fileinfo->cluster >= 0xff8)) || + ((fileinfo->volinfo->filesystem == FAT16) && (fileinfo->cluster >= 0xfff8)) || + ((fileinfo->volinfo->filesystem == FAT32) && (fileinfo->cluster >= 0x0ffffff8))) + result = DFS_EOF; + else + fileinfo->cluster = DFS_GetFAT(fileinfo->volinfo, scratch, &bytesread, fileinfo->cluster); + } + } + + return result; +} + +/* + Seek file pointer to a given position + This function does not return status - refer to the fileinfo->pointer value + to see where the pointer wound up. + Requires a SECTOR_SIZE scratch buffer +*/ +void DFS_Seek(PFILEINFO fileinfo, uint32_t offset, uint8_t *scratch) +{ + uint32_t tempint; + + // larwe 9/16/06 bugfix split case 0a/0b and changed fallthrough handling + // Case 0a - Return immediately for degenerate case + if (offset == fileinfo->pointer) { + return; + } + + // Case 0b - Don't allow the user to seek past the end of the file + if (offset > fileinfo->filelen) { + offset = fileinfo->filelen; + // NOTE NO RETURN HERE! + } + + // Case 1 - Simple rewind to start + // Note _intentional_ fallthrough from Case 0b above + if (offset == 0) { + fileinfo->cluster = fileinfo->firstcluster; + fileinfo->pointer = 0; + return; // larwe 9/16/06 +1 bugfix + } + // Case 2 - Seeking backwards. Need to reset and seek forwards + else if (offset < fileinfo->pointer) { + fileinfo->cluster = fileinfo->firstcluster; + fileinfo->pointer = 0; + // NOTE NO RETURN HERE! + } + + // Case 3 - Seeking forwards + // Note _intentional_ fallthrough from Case 2 above + + // Case 3a - Seek size does not cross cluster boundary - + // very simple case + // larwe 9/16/06 changed .rem to .quot in both div calls, bugfix + if (div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot == + div(fileinfo->pointer + offset, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot) { + fileinfo->pointer = offset; + } + // Case 3b - Seeking across cluster boundary(ies) + else { + // round file pointer down to cluster boundary + fileinfo->pointer = div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot * + fileinfo->volinfo->secperclus * SECTOR_SIZE; + + // seek by clusters + // larwe 9/30/06 bugfix changed .rem to .quot in both div calls + while (div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot != + div(fileinfo->pointer + offset, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot) { + + fileinfo->cluster = DFS_GetFAT(fileinfo->volinfo, scratch, &tempint, fileinfo->cluster); + // Abort if there was an error + if (fileinfo->cluster == 0x0ffffff7) { + fileinfo->pointer = 0; + fileinfo->cluster = fileinfo->firstcluster; + return; + } + fileinfo->pointer += SECTOR_SIZE * fileinfo->volinfo->secperclus; + } + + // since we know the cluster is right, we have no more work to do + fileinfo->pointer = offset; + } +} + +/* + Delete a file + scratch must point to a sector-sized buffer +*/ +uint32_t DFS_UnlinkFile(PVOLINFO volinfo, uint8_t *path, uint8_t *scratch) +{ + FILEINFO fi; + uint32_t cache = 0; + uint32_t tempclus; + + // DFS_OpenFile gives us all the information we need to delete it + if (DFS_OK != DFS_OpenFile(volinfo, path, DFS_READ, scratch, &fi)) + return DFS_NOTFOUND; + + // First, read the directory sector and delete that entry + if (DFS_ReadSector(volinfo->unit, scratch, fi.dirsector, 1)) + return DFS_ERRMISC; + ((PDIRENT) scratch)[fi.diroffset].name[0] = 0xe5; + if (DFS_WriteSector(volinfo->unit, scratch, fi.dirsector, 1)) + return DFS_ERRMISC; + + // Now follow the cluster chain to free the file space + while (!((volinfo->filesystem == FAT12 && fi.firstcluster >= 0x0ff7) || + (volinfo->filesystem == FAT16 && fi.firstcluster >= 0xfff7) || + (volinfo->filesystem == FAT32 && fi.firstcluster >= 0x0ffffff7))) { + tempclus = fi.firstcluster; + + fi.firstcluster = DFS_GetFAT(volinfo, scratch, &cache, fi.firstcluster); + DFS_SetFAT(volinfo, scratch, &cache, tempclus, 0); + + } + return DFS_OK; +} + + +/* + Write an open file + You must supply a prepopulated FILEINFO as provided by DFS_OpenFile, and a + pointer to a SECTOR_SIZE scratch buffer. + This function updates the successcount field with the number of bytes actually written. +*/ +uint32_t DFS_WriteFile(PFILEINFO fileinfo, uint8_t *scratch, uint8_t *buffer, uint32_t *successcount, uint32_t len) +{ + uint32_t remain; + uint32_t result = DFS_OK; + uint32_t sector; + uint32_t byteswritten; + + // Don't allow writes to a file that's open as readonly + if (!(fileinfo->mode & DFS_WRITE)) + return DFS_ERRMISC; + + remain = len; + *successcount = 0; + + while (remain && result == DFS_OK) { + // This is a bit complicated. The sector we want to read is addressed at a cluster + // granularity by the fileinfo->cluster member. The file pointer tells us how many + // extra sectors to add to that number. + sector = fileinfo->volinfo->dataarea + + ((fileinfo->cluster - 2) * fileinfo->volinfo->secperclus) + + div(div(fileinfo->pointer,fileinfo->volinfo->secperclus * SECTOR_SIZE).rem, SECTOR_SIZE).quot; + + // Case 1 - File pointer is not on a sector boundary + if (div(fileinfo->pointer, SECTOR_SIZE).rem) { + uint16_t tempsize; + + // We always have to go through scratch in this case + result = DFS_ReadSector(fileinfo->volinfo->unit, scratch, sector, 1); + + // This is the number of bytes that we don't want to molest in the + // scratch sector just read. + tempsize = div(fileinfo->pointer, SECTOR_SIZE).rem; + + // Case 1A - We are writing the entire remainder of the sector. After + // this point, all passes through the read loop will be aligned on a + // sector boundary, which allows us to go through the optimal path + // 2A below. + if (remain >= SECTOR_SIZE - tempsize) { + memcpy(scratch + tempsize, buffer, SECTOR_SIZE - tempsize); + if (!result) + result = DFS_WriteSector(fileinfo->volinfo->unit, scratch, sector, 1); + + byteswritten = SECTOR_SIZE - tempsize; + buffer += SECTOR_SIZE - tempsize; + fileinfo->pointer += SECTOR_SIZE - tempsize; + if (fileinfo->filelen < fileinfo->pointer) { + fileinfo->filelen = fileinfo->pointer; + } + remain -= SECTOR_SIZE - tempsize; + } + // Case 1B - This concludes the file write operation + else { + memcpy(scratch + tempsize, buffer, remain); + if (!result) + result = DFS_WriteSector(fileinfo->volinfo->unit, scratch, sector, 1); + + buffer += remain; + fileinfo->pointer += remain; + if (fileinfo->filelen < fileinfo->pointer) { + fileinfo->filelen = fileinfo->pointer; + } + byteswritten = remain; + remain = 0; + } + } // case 1 + // Case 2 - File pointer is on sector boundary + else { + // Case 2A - We have at least one more full sector to write and don't have + // to go through the scratch buffer. You could insert optimizations here to + // write multiple sectors at a time, if you were thus inclined. Refer to + // similar notes in DFS_ReadFile. + if (remain >= SECTOR_SIZE) { + result = DFS_WriteSector(fileinfo->volinfo->unit, buffer, sector, 1); + remain -= SECTOR_SIZE; + buffer += SECTOR_SIZE; + fileinfo->pointer += SECTOR_SIZE; + if (fileinfo->filelen < fileinfo->pointer) { + fileinfo->filelen = fileinfo->pointer; + } + byteswritten = SECTOR_SIZE; + } + // Case 2B - We are only writing a partial sector and potentially need to + // go through the scratch buffer. + else { + // If the current file pointer is not yet at or beyond the file + // length, we are writing somewhere in the middle of the file and + // need to load the original sector to do a read-modify-write. + if (fileinfo->pointer < fileinfo->filelen) { + result = DFS_ReadSector(fileinfo->volinfo->unit, scratch, sector, 1); + if (!result) { + memcpy(scratch, buffer, remain); + result = DFS_WriteSector(fileinfo->volinfo->unit, scratch, sector, 1); + } + } + else { + result = DFS_WriteSector(fileinfo->volinfo->unit, buffer, sector, 1); + } + + buffer += remain; + fileinfo->pointer += remain; + if (fileinfo->filelen < fileinfo->pointer) { + fileinfo->filelen = fileinfo->pointer; + } + byteswritten = remain; + remain = 0; + } + } + + *successcount += byteswritten; + + // check to see if we stepped over a cluster boundary + if (div(fileinfo->pointer - byteswritten, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot != + div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot) { + uint32_t lastcluster; + + // We've transgressed into another cluster. If we were already at EOF, + // we need to allocate a new cluster. + // An act of minor evil - we use byteswritten as a scratch integer, knowing + // that its value is not used after updating *successcount above + byteswritten = 0; + + lastcluster = fileinfo->cluster; + fileinfo->cluster = DFS_GetFAT(fileinfo->volinfo, scratch, &byteswritten, fileinfo->cluster); + + // Allocate a new cluster? + if (((fileinfo->volinfo->filesystem == FAT12) && (fileinfo->cluster >= 0xff8)) || + ((fileinfo->volinfo->filesystem == FAT16) && (fileinfo->cluster >= 0xfff8)) || + ((fileinfo->volinfo->filesystem == FAT32) && (fileinfo->cluster >= 0x0ffffff8))) { + uint32_t tempclus; + + tempclus = DFS_GetFreeFAT(fileinfo->volinfo, scratch); + byteswritten = 0; // invalidate cache + if (tempclus == 0x0ffffff7) + return DFS_ERRMISC; + + // Link new cluster onto file + DFS_SetFAT(fileinfo->volinfo, scratch, &byteswritten, lastcluster, tempclus); + fileinfo->cluster = tempclus; + + // Mark newly allocated cluster as end of chain + switch(fileinfo->volinfo->filesystem) { + case FAT12: tempclus = 0xff8; break; + case FAT16: tempclus = 0xfff8; break; + case FAT32: tempclus = 0x0ffffff8; break; + default: return DFS_ERRMISC; + } + DFS_SetFAT(fileinfo->volinfo, scratch, &byteswritten, fileinfo->cluster, tempclus); + + result = DFS_OK; + } + // No else clause is required. + } + } + + // Update directory entry + if (DFS_ReadSector(fileinfo->volinfo->unit, scratch, fileinfo->dirsector, 1)) + return DFS_ERRMISC; + ((PDIRENT) scratch)[fileinfo->diroffset].filesize_0 = fileinfo->filelen & 0xff; + ((PDIRENT) scratch)[fileinfo->diroffset].filesize_1 = (fileinfo->filelen & 0xff00) >> 8; + ((PDIRENT) scratch)[fileinfo->diroffset].filesize_2 = (fileinfo->filelen & 0xff0000) >> 16; + ((PDIRENT) scratch)[fileinfo->diroffset].filesize_3 = (fileinfo->filelen & 0xff000000) >> 24; + if (DFS_WriteSector(fileinfo->volinfo->unit, scratch, fileinfo->dirsector, 1)) + return DFS_ERRMISC; + return result; +} + +/************************************************************************* + * + * The remainder of this file has been added as a result of the dosfs + * distribution being used in MicroMonitor. + * This is not part of the original dosfs.c as distributed by Lewin Edwards. + * + ************************************************************************* + */ + +/* + * Convert a filename element from directory entry (11) to canonical (8.3) form + * dest must point to the first non-separator character. + * sec must point to a 12-byte buffer. + */ +uint8_t *DFS_DirToCanonical(uint8_t *dest, uint8_t *src) +{ + uint8_t *srcptr = src; + + // copy filename until spaces + while(( srcptr - src) <= 11) + { + if (*srcptr == 0) break; + + // name.ext seperator + if(( srcptr - src) == 8) *dest++ = '.'; + if( *srcptr != ' ') *dest++ = *srcptr; + + srcptr++; + } + + // null terminate and rewind one char + *dest-- = 0; + + // if name has no extension - kill the seperator + if( *dest == '.') *dest = 0; + + return dest; +} +#endif diff --git a/main/common/dosfs.h b/main/common/dosfs.h new file mode 100644 index 0000000..1deb16b --- /dev/null +++ b/main/common/dosfs.h @@ -0,0 +1,393 @@ +/* + DOSFS Embedded FAT-Compatible Filesystem + (C) 2005 Lewin A.R.W. Edwards (sysadm@zws.com) +*/ + +#ifndef _DOSFS_H +#define _DOSFS_H + +#include + +//#define USE_GMHFIX // Defined to pull in dosfs fixes from Graham Henderson + + +//=================================================================== +// User-supplied functions +uint32_t DFS_ReadSector(uint8_t unit, uint8_t *buffer, uint32_t sector, uint32_t count); +uint32_t DFS_WriteSector(uint8_t unit, uint8_t *buffer, uint32_t sector, uint32_t count); + + +//=================================================================== +// Configurable items +#define MAX_PATH 64 // Maximum path length (increasing this will + // GREATLY increase stack requirements!) +#define DIR_SEPARATOR '/' // character separating directory components + +// End of configurable items +//=================================================================== + +//=================================================================== +// 32-bit error codes +#define DFS_OK 0 // no error +#define DFS_EOF 1 // end of file (not an error) +#define DFS_WRITEPROT 2 // volume is write protected +#define DFS_NOTFOUND 3 // path or file not found +#define DFS_PATHLEN 4 // path too long +#define DFS_ALLOCNEW 5 // must allocate new directory cluster +#define DFS_ERRMISC 0xffffffff // generic error + +//=================================================================== +// File access modes +#define DFS_READ 1 // read-only +#define DFS_WRITE 2 // write-only + +//=================================================================== +// Miscellaneous constants +#define SECTOR_SIZE 512 // sector size in bytes + +//=================================================================== +// Internal subformat identifiers +#define FAT12 0 +#define FAT16 1 +#define FAT32 2 + +//=================================================================== +// DOS attribute bits +#define ATTR_READ_ONLY 0x01 +#define ATTR_HIDDEN 0x02 +#define ATTR_SYSTEM 0x04 +#define ATTR_VOLUME_ID 0x08 +#define ATTR_DIRECTORY 0x10 +#define ATTR_ARCHIVE 0x20 +#define ATTR_LONG_NAME (ATTR_READ_ONLY | ATTR_HIDDEN | ATTR_SYSTEM | ATTR_VOLUME_ID) + + +/* + Directory entry structure + note: if name[0] == 0xe5, this is a free dir entry + if name[0] == 0x00, this is a free entry and all subsequent entries are free + if name[0] == 0x05, the first character of the name is 0xe5 [a kanji nicety] + + Date format: bit 0-4 = day of month (1-31) + bit 5-8 = month, 1=Jan..12=Dec + bit 9-15 = count of years since 1980 (0-127) + Time format: bit 0-4 = 2-second count, (0-29) + bit 5-10 = minutes (0-59) + bit 11-15= hours (0-23) +*/ + +// some macros to aid in formatting file date, times. and file sizes +#define CREATE_DAY( _x_) ((_x_.crtdate_l) & 0x1f) +#define CREATE_MON( _x_) (((_x_.crtdate_l >> 5) & 0x07) | ((_x_.crtdate_h & 1) << 3)) +#define CREATE_YEAR( _x_) ((_x_.crtdate_h >> 1) + 1980) + +#define CREATE_SEC( _x_) (((_x_.crttime_l) & 0x1f) * 2) +#define CREATE_MIN( _x_) (((_x_.crttime_l >> 5) & 0x07) | ((_x_.crttime_h & 0x07) << 3)) +#define CREATE_HR( _x_) ((_x_.crttime_h >> 3)) + +#define FILESIZE(_x_) (int)( ( _x_.filesize_3 << 24)| ( _x_.filesize_2 << 16) | ( _x_.filesize_1 << 8) | _x_.filesize_0) + + +typedef struct __attribute__ ((__packed__)) _tagDIRENT { + uint8_t name[11]; // filename + uint8_t attr; // attributes (see ATTR_* constant definitions) + uint8_t reserved; // reserved, must be 0 + uint8_t crttimetenth; // create time, 10ths of a second (0-199 are valid) + uint8_t crttime_l; // creation time low byte + uint8_t crttime_h; // creation time high byte + uint8_t crtdate_l; // creation date low byte + uint8_t crtdate_h; // creation date high byte + uint8_t lstaccdate_l; // last access date low byte + uint8_t lstaccdate_h; // last access date high byte + uint8_t startclus_h_l; // high word of first cluster, low byte (FAT32) + uint8_t startclus_h_h; // high word of first cluster, high byte (FAT32) + uint8_t wrttime_l; // last write time low byte + uint8_t wrttime_h; // last write time high byte + uint8_t wrtdate_l; // last write date low byte + uint8_t wrtdate_h; // last write date high byte + uint8_t startclus_l_l; // low word of first cluster, low byte + uint8_t startclus_l_h; // low word of first cluster, high byte + uint8_t filesize_0; // file size, low byte + uint8_t filesize_1; // + uint8_t filesize_2; // + uint8_t filesize_3; // file size, high byte +} DIRENT, *PDIRENT; + +/* + Partition table entry structure +*/ +typedef struct __attribute__ ((__packed__)) _tagPTINFO { + uint8_t active; // 0x80 if partition active + uint8_t start_h; // starting head + uint8_t start_cs_l; // starting cylinder and sector (low byte) + uint8_t start_cs_h; // starting cylinder and sector (high byte) + uint8_t type; // type ID byte + uint8_t end_h; // ending head + uint8_t end_cs_l; // ending cylinder and sector (low byte) + uint8_t end_cs_h; // ending cylinder and sector (high byte) + uint8_t start_0; // starting sector# (low byte) + uint8_t start_1; // + uint8_t start_2; // + uint8_t start_3; // starting sector# (high byte) + uint8_t size_0; // size of partition (low byte) + uint8_t size_1; // + uint8_t size_2; // + uint8_t size_3; // size of partition (high byte) +} PTINFO, *PPTINFO; + +/* + Master Boot Record structure +*/ +typedef struct __attribute__ ((__packed__)) _tagMBR { + uint8_t bootcode[0x1be]; // boot sector + PTINFO ptable[4]; // four partition table structures + uint8_t sig_55; // 0x55 signature byte + uint8_t sig_aa; // 0xaa signature byte +} MBR, *PMBR; + +/* + BIOS Parameter Block structure (FAT12/16) +*/ +typedef struct __attribute__ ((__packed__)) _tagBPB { + uint8_t bytepersec_l; // bytes per sector low byte (0x00) + uint8_t bytepersec_h; // bytes per sector high byte (0x02) + uint8_t secperclus; // sectors per cluster (1,2,4,8,16,32,64,128 are valid) + uint8_t reserved_l; // reserved sectors low byte + uint8_t reserved_h; // reserved sectors high byte + uint8_t numfats; // number of FAT copies (2) + uint8_t rootentries_l; // number of root dir entries low byte (0x00 normally) + uint8_t rootentries_h; // number of root dir entries high byte (0x02 normally) + uint8_t sectors_s_l; // small num sectors low byte + uint8_t sectors_s_h; // small num sectors high byte + uint8_t mediatype; // media descriptor byte + uint8_t secperfat_l; // sectors per FAT low byte + uint8_t secperfat_h; // sectors per FAT high byte + uint8_t secpertrk_l; // sectors per track low byte + uint8_t secpertrk_h; // sectors per track high byte + uint8_t heads_l; // heads low byte + uint8_t heads_h; // heads high byte + uint8_t hidden_0; // hidden sectors low byte + uint8_t hidden_1; // (note - this is the number of MEDIA sectors before + uint8_t hidden_2; // first sector of VOLUME - we rely on the MBR instead) + uint8_t hidden_3; // hidden sectors high byte + uint8_t sectors_l_0; // large num sectors low byte + uint8_t sectors_l_1; // + uint8_t sectors_l_2; // + uint8_t sectors_l_3; // large num sectors high byte +} BPB, *PBPB; + +/* + Extended BIOS Parameter Block structure (FAT12/16) +*/ +typedef struct __attribute__ ((__packed__)) _tagEBPB { + uint8_t unit; // int 13h drive# + uint8_t head; // archaic, used by Windows NT-class OSes for flags + uint8_t signature; // 0x28 or 0x29 + uint8_t serial_0; // serial# + uint8_t serial_1; // serial# + uint8_t serial_2; // serial# + uint8_t serial_3; // serial# + uint8_t label[11]; // volume label + uint8_t system[8]; // filesystem ID +} EBPB, *PEBPB; + +/* + Extended BIOS Parameter Block structure (FAT32) +*/ +typedef struct __attribute__ ((__packed__)) _tagEBPB32 { + uint8_t fatsize_0; // big FAT size in sectors low byte + uint8_t fatsize_1; // + uint8_t fatsize_2; // + uint8_t fatsize_3; // big FAT size in sectors high byte + uint8_t extflags_l; // extended flags low byte + uint8_t extflags_h; // extended flags high byte + uint8_t fsver_l; // filesystem version (0x00) low byte + uint8_t fsver_h; // filesystem version (0x00) high byte + uint8_t root_0; // cluster of root dir, low byte + uint8_t root_1; // + uint8_t root_2; // + uint8_t root_3; // cluster of root dir, high byte + uint8_t fsinfo_l; // sector pointer to FSINFO within reserved area, low byte (2) + uint8_t fsinfo_h; // sector pointer to FSINFO within reserved area, high byte (0) + uint8_t bkboot_l; // sector pointer to backup boot sector within reserved area, low byte (6) + uint8_t bkboot_h; // sector pointer to backup boot sector within reserved area, high byte (0) + uint8_t reserved[12]; // reserved, should be 0 + + uint8_t unit; // int 13h drive# + uint8_t head; // archaic, used by Windows NT-class OSes for flags + uint8_t signature; // 0x28 or 0x29 + uint8_t serial_0; // serial# + uint8_t serial_1; // serial# + uint8_t serial_2; // serial# + uint8_t serial_3; // serial# + uint8_t label[11]; // volume label + uint8_t system[8]; // filesystem ID +} EBPB32, *PEBPB32; + +/* + Logical Boot Record structure (volume boot sector) +*/ +typedef struct __attribute__ ((__packed__)) _tagLBR { + uint8_t jump[3]; // JMP instruction + uint8_t oemid[8]; // OEM ID, space-padded + BPB bpb; // BIOS Parameter Block + union { + EBPB ebpb; // FAT12/16 Extended BIOS Parameter Block + EBPB32 ebpb32; // FAT32 Extended BIOS Parameter Block + } ebpb; + uint8_t code[420]; // boot sector code + uint8_t sig_55; // 0x55 signature byte + uint8_t sig_aa; // 0xaa signature byte +} LBR, *PLBR; + +/* + Volume information structure (Internal to DOSFS) +*/ +typedef struct __attribute__ ((__packed__)) _tagVOLINFO { + uint8_t unit; // unit on which this volume resides + uint8_t filesystem; // formatted filesystem + +// These two fields aren't very useful, so support for them has been commented out to +// save memory. (Note that the "system" tag is not actually used by DOS to determine +// filesystem type - that decision is made entirely on the basis of how many clusters +// the drive contains. DOSFS works the same way). +// See tag: OEMID in dosfs.c +// uint8_t oemid[9]; // OEM ID ASCIIZ +// uint8_t system[9]; // system ID ASCIIZ + uint8_t label[12]; // volume label ASCIIZ + uint32_t startsector; // starting sector of filesystem + uint8_t secperclus; // sectors per cluster + uint16_t reservedsecs; // reserved sectors + uint32_t numsecs; // number of sectors in volume + uint32_t secperfat; // sectors per FAT + uint16_t rootentries; // number of root dir entries + + uint32_t numclusters; // number of clusters on drive + + // The fields below are PHYSICAL SECTOR NUMBERS. + uint32_t fat1; // starting sector# of FAT copy 1 + uint32_t rootdir; // starting sector# of root directory (FAT12/FAT16) or cluster (FAT32) + uint32_t dataarea; // starting sector# of data area (cluster #2) +} VOLINFO, *PVOLINFO; + +/* + Flags in DIRINFO.flags +*/ +#define DFS_DI_BLANKENT 0x01 // Searching for blank entry + +/* + Directory search structure (Internal to DOSFS) +*/ +typedef struct __attribute__ ((__packed__)) _tagDIRINFO { + uint32_t currentcluster; // current cluster in dir + uint8_t currentsector; // current sector in cluster + uint8_t currententry; // current dir entry in sector + uint8_t *scratch; // ptr to user-supplied scratch buffer (one sector) + uint8_t flags; // internal DOSFS flags +} DIRINFO, *PDIRINFO; + +/* + File handle structure (Internal to DOSFS) +*/ +typedef struct __attribute__ ((__packed__)) _tagFILEINFO { + PVOLINFO volinfo; // VOLINFO used to open this file + uint32_t dirsector; // physical sector containing dir entry of this file + uint8_t diroffset; // # of this entry within the dir sector + uint8_t mode; // mode in which this file was opened + uint32_t firstcluster; // first cluster of file + uint32_t filelen; // byte length of file + + uint32_t cluster; // current cluster + uint32_t pointer; // current (BYTE) pointer +} FILEINFO, *PFILEINFO; + +/* + Get starting sector# of specified partition on drive #unit + NOTE: This code ASSUMES an MBR on the disk. + scratchsector should point to a SECTOR_SIZE scratch area + Returns 0xffffffff for any error. + If pactive is non-NULL, this function also returns the partition active flag. + If pptype is non-NULL, this function also returns the partition type. + If psize is non-NULL, this function also returns the partition size. +*/ +uint32_t DFS_GetPtnStart(uint8_t unit, uint8_t *scratchsector, uint8_t pnum, uint8_t *pactive, uint8_t *pptype, uint32_t *psize); + +/* + Retrieve volume info from BPB and store it in a VOLINFO structure + You must provide the unit and starting sector of the filesystem, and + a pointer to a sector buffer for scratch + Attempts to read BPB and glean information about the FS from that. + Returns 0 OK, nonzero for any error. +*/ +uint32_t DFS_GetVolInfo(uint8_t unit, uint8_t *scratchsector, uint32_t startsector, PVOLINFO volinfo); + +/* + Open a directory for enumeration by DFS_GetNextDirEnt + You must supply a populated VOLINFO (see DFS_GetVolInfo) + The empty string or a string containing only the directory separator are + considered to be the root directory. + Returns 0 OK, nonzero for any error. +*/ +uint32_t DFS_OpenDir(PVOLINFO volinfo, uint8_t *dirname, PDIRINFO dirinfo); + +/* + Get next entry in opened directory structure. Copies fields into the dirent + structure, updates dirinfo. Note that it is the _caller's_ responsibility to + handle the '.' and '..' entries. + A deleted file will be returned as a NULL entry (first char of filename=0) + by this code. Filenames beginning with 0x05 will be translated to 0xE5 + automatically. Long file name entries will be returned as NULL. + returns DFS_EOF if there are no more entries, DFS_OK if this entry is valid, + or DFS_ERRMISC for a media error +*/ +uint32_t DFS_GetNext(PVOLINFO volinfo, PDIRINFO dirinfo, PDIRENT dirent); + +/* + Open a file for reading or writing. You supply populated VOLINFO, a path to the file, + mode (DFS_READ or DFS_WRITE) and an empty fileinfo structure. You also need to + provide a pointer to a sector-sized scratch buffer. + Returns various DFS_* error states. If the result is DFS_OK, fileinfo can be used + to access the file from this point on. +*/ +uint32_t DFS_OpenFile(PVOLINFO volinfo, uint8_t *path, uint8_t mode, uint8_t *scratch, PFILEINFO fileinfo); + +/* + Read an open file + You must supply a prepopulated FILEINFO as provided by DFS_OpenFile, and a + pointer to a SECTOR_SIZE scratch buffer. + Note that returning DFS_EOF is not an error condition. This function updates the + successcount field with the number of bytes actually read. +*/ +uint32_t DFS_ReadFile(PFILEINFO fileinfo, uint8_t *scratch, uint8_t *buffer, uint32_t *successcount, uint32_t len); + +/* + Write an open file + You must supply a prepopulated FILEINFO as provided by DFS_OpenFile, and a + pointer to a SECTOR_SIZE scratch buffer. + This function updates the successcount field with the number of bytes actually written. +*/ +uint32_t DFS_WriteFile(PFILEINFO fileinfo, uint8_t *scratch, uint8_t *buffer, uint32_t *successcount, uint32_t len); + +/* + Seek file pointer to a given position + This function does not return status - refer to the fileinfo->pointer value + to see where the pointer wound up. + Requires a SECTOR_SIZE scratch buffer +*/ +void DFS_Seek(PFILEINFO fileinfo, uint32_t offset, uint8_t *scratch); + +/* + Delete a file + scratch must point to a sector-sized buffer +*/ +uint32_t DFS_UnlinkFile(PVOLINFO volinfo, uint8_t *path, uint8_t *scratch); + +uint32_t DFS_GetFAT(PVOLINFO volinfo, uint8_t *scratch, uint32_t *scratchcache, uint32_t cluster); +uint8_t *DFS_DirToCanonical(uint8_t *dest, uint8_t *src); + +// If we are building a host-emulation version, include host support +#ifdef HOSTVER +#include "hostemu.h" +#endif + +#endif // _DOSFS_H diff --git a/main/common/fatfs.c b/main/common/fatfs.c new file mode 100644 index 0000000..34c6275 --- /dev/null +++ b/main/common/fatfs.c @@ -0,0 +1,696 @@ +/* vi: set ts=4: */ +/* fatfs.c: + * This is a front end (i.e. the CLI portion) of the dosfs.c source code. + * The dosfs.c file is code from Lewin Edwards. The website I got this + * from originally was: http://www.zws.com/products/dosfs/index.html . + * + * The dosfs.c dosfs.h files in uMon common (i.e. here) are taken directly + * from that website, with minimal modification (so as to remain compatible + * with any DOSFS updates). Much of this fatfs code is also shamelessly + * cut-and-pasted from Lewin's source file main.c (part of the dosfs + * tarball) used to demonstrate the dosfs interface. + * + * Discussion on uMon's philosophy of file-systems other than TFS... + * The intent under the scope of uMon for support of file systems other than + * TFS is to support two commands: a file-system-specific command and an + * interface-specific command. The goal is that members of the two different + * command sets can be mixed and matched as needed in a particular design. + * For example, if we have commands for compact flash (CF), SPI and I2C + * interfaces the "fatfs" command could use anyone of them to retrieve files + * from that interface (assuming of course, that the interface has an FAT + * FS on the other side). + * + * The way this works is simple, the only thing the fatfs command needs is + * a set of interface-specific functions: readblock and writeblock. As + * long as the CF/SPI/I2C commands support this, and also support the + * ability to share those interface functions through the CLI, it simply + * becomes a matter of assigning the function pointers in a startup script + * when uMon boots up (probably in monrc). + * + * That being said, here's the model... + * + * File-system-specific Command: + * Each command will support the ability to establish its read and write + * pointers through the command line. The -r and -w options do this in + * the fatfs command, and it would be nice if other similar commands could + * follow the same model. The command should support (at minimum) the + * ability to list the files in the FS (ls), query for the presence of a + * specific file within the FS (qry), copy a file from the FS to TFS or + * ram (get), and also dump the content of an ASCII file from the FS to the + * console (cat). If the command supports modification of the FS, then, + * it should also support the ability remove (rm) and copy from ram or TFS + * to the FS (put). The command also supports default shell variables that + * may contain the read write functions. + * + * Interface-specific Command: + * Each command will support the potential of multiple interfaces of the + * same type. The command must be able to initialize (with optional + * verbosity) said interface and populate a defined set of shell variables + * with the address of the read and write functions applicable to that + * interface. Ideally the interface command should also support the ability + * to do raw reads (FS to memory) and writes (memory to FS) on the interface. + * + * With the above model we then have the ability to connect the "FS" command + * with any "Interface" command; so as file system support in uMon grows, + * it immediately becomes useful on a variety of interfaces, as long as + * they adhere to the above simple model. As of this writing the "cf" and + * "fatfs" commands comply to this model and can be used as a template for + * developing new commands that fit into this category. + * + * Here is an example of their usage: + * + * uMON> cf init FATFS # Initialize the compact flash interface and + * # laod FATFS_RD and FATFS_WR with the read and + * # write function pointers. + * uMON> fatfs cat file1 # Using the FATFS_RD and FATFS_WR shell variables + * # previously set up, dump the content of the file + * # named 'file1'. + * + * General notice: + * This code is part of a boot-monitor package developed as a generic base + * platform for embedded system designs. As such, it is likely to be + * distributed to various projects beyond the control of the original + * author. Please notify the author of any enhancements made or bugs found + * so that all may benefit from the changes. In addition, notification back + * to the author will allow the new user to pick up changes that may have + * been made by other users after this version of the code was distributed. + * + * Note1: the majority of this code was edited with 4-space tabs. + * Note2: as more and more contributions are accepted, the term "author" + * is becoming a mis-representation of credit. + * + * Original author: Ed Sutter esutter@lucent.com + * Contributor(s): Graham Henderson + */ + +#include "config.h" +#if INCLUDE_FATFS +#include "stddefs.h" +#include "genlib.h" +#include "cli.h" +#include "tfs.h" +#include "tfsprivate.h" +#include "dosfs.h" + +static int (*fatfsRead)(int interface, char *buf, int blknum, int count); +static int (*fatfsWrite)(int interface, char *buf, int blknum, int count); + +static char fatfs_initialized; +static char *fatfs_tmp_space; +static VOLINFO vi __attribute__((aligned (32))); +static uint8_t sector[SECTOR_SIZE] __attribute__ ((aligned (32))); +static uint8_t sector2[SECTOR_SIZE] __attribute__ ((aligned (32))); + +/* Support skipping LFN dir entries... + */ +#define ATTR_LONG_NAME \ + (ATTR_READ_ONLY | ATTR_HIDDEN | ATTR_SYSTEM | ATTR_VOLUME_ID) + +#define FATFS_FNAME_STR "FATFSFNAME" +#define FATFS_FTOT_STR "FATFSFTOT" +#define FATFS_FSIZE_STR "FATFSFSIZE" + +/* fatfsInit(): + * Start up the fs by reading in volume information. + * This function will return if already initialized, unless force + * is nonzero. + */ +static int +fatfsInit(int force, int verbose) +{ + uint8_t pactive, ptype; + uint32_t pstart, psize; + + if ((fatfs_initialized == 1) && (force == 0)) + return(0); + + /* Obtain pointer to first partition on first (only) unit. + */ + pstart = DFS_GetPtnStart(0, sector, 0, &pactive, &ptype, &psize); + if (pstart == 0xffffffff) { + printf("Cannot find first partition\n"); + return(-1); + } + + if (verbose) { + printf("Partition 0...\n"); + printf(" Start sector 0x%08lx\n",pstart); + printf(" Active %d\n",pactive); + printf(" Type 0x%x\n",ptype); + printf(" Size 0x%lx\n",psize); + } + + if (DFS_GetVolInfo(0, sector, pstart, &vi)) { + printf("Error getting volume information\n"); + return(-1); + } + + if (verbose) { + printf("Volume label '%-11s'\n", vi.label); + printf(" %d sector(s) per cluster\n",vi.secperclus); + printf(" %d reserved sector(s)\n",vi.reservedsecs); + printf(" %d total volume sector(s)\n", vi.numsecs); + printf(" %d sectors per FAT\n",vi.secperfat); + printf(" first FAT at sector #%d\n",vi.fat1); + printf(" root dir at #%d\n",vi.rootdir); + + printf("For.. FAT32 rootdir is CLUSTER #,\n"); + printf(" FAT12/16 rootdir is a SECTOR #.\n"); + printf("%d root dir entries, data area commences at sector #%d.\n", + vi.rootentries,vi.dataarea); + printf("%d clusters (%d bytes) in data area, filesystem IDd as ", + vi.numclusters, vi.numclusters * vi.secperclus * SECTOR_SIZE); + + if (vi.filesystem == FAT12) + printf("FAT12.\n"); + else if (vi.filesystem == FAT16) + printf("FAT16.\n"); + else if (vi.filesystem == FAT32) + printf("FAT32.\n"); + else + printf("[unknown]\n"); + } + fatfs_initialized = 1; + return(0); +} + +/* fatfsCat(): + * Dump the content of the specified fatfs file to the console. + * This function assumes the data is ASCII. + */ +static int +fatfsCat(char *filepath) +{ + uint32_t i, j; + FILEINFO fi; + uint8_t *p; + + if (DFS_OpenFile(&vi, (uint8_t *)filepath, DFS_READ, sector, &fi)) { + printf("error opening '%s'\n",filepath); + return(-1); + } + p = (uint8_t *)fatfs_tmp_space; + DFS_ReadFile(&fi, sector, p, &i, fi.filelen); + for(j=0;j 0) { + if (len >= SECTOR_SIZE) + size = SECTOR_SIZE; + else + size = len; + + rc = DFS_WriteFile(&fi, sector2, (uint8_t *)p, &successcount, size); + if ((rc != DFS_OK) || (successcount != size)) { + printf("error writing '%s'\n",fatfspath); + return(-1); + } + p += size; + len -= size; + } + return(0); +} + +/* fatfsRm(): + * Remove the specified file from the FATFS. + * If the path is a directory, then don't remove anything. + */ +static int +fatfsRm(char *fatfspath) +{ + DIRINFO di; + + di.scratch = sector; + if (DFS_OpenDir(&vi, (uint8_t *)fatfspath, &di) == 0) { + printf("can't remove directory '%s'\n",fatfspath); + return(-1); + } + if (DFS_UnlinkFile(&vi, (uint8_t *)fatfspath, sector)) { + printf("error unlinking file %s\n",fatfspath); + return(-1); + } + return(0); +} + +/* fatfsLs(): + * The incoming string is assumed to be some directory name. + * If NULL, then it is assumed to be the CF's top-most level. + */ +static int +fatfsLs(char *dirname) +{ + int ftot; + DIRENT de; + DIRINFO di; + char *dir; + + if (dirname) + dir = dirname; + else + dir = ""; + + di.scratch = sector; + if (DFS_OpenDir(&vi, (uint8_t *)dir, &di)) { + printf("Can't open dir: <%s>\n",dirname); + return(CMD_FAILURE); + } + + ftot = 0; + while (!DFS_GetNext(&vi, &di, &de)) { + char tmp[32]; + + if (de.name[0] && ((de.attr & ATTR_LONG_NAME) != ATTR_LONG_NAME)) { + if ((de.attr & ATTR_VOLUME_ID) > 0) { + de.name[8] = 0; + printf("Volume: %s\n",de.name); + continue; + } + ftot++; + + printf("%02d/%02d/%4d %02d:%02d ", + CREATE_MON(de), CREATE_DAY(de), CREATE_YEAR(de), + CREATE_HR(de), CREATE_MIN(de)); + + if ((de.attr & ATTR_DIRECTORY) > 0) { + // truncate the extension + de.name[8] = 0; + + printf(" %-8s",de.name); + } + else { + DFS_DirToCanonical((uint8_t *)tmp,de.name); + printf(" %8d %-12s",FILESIZE(de), tmp); + } + + printf(" %c%c%c%c%c\n", + (( de.attr & ATTR_VOLUME_ID) ? 'V' : ' '), + (( de.attr & ATTR_READ_ONLY) ? 'R' : ' '), + (( de.attr & ATTR_ARCHIVE ) ? 'A' : ' '), + (( de.attr & ATTR_SYSTEM ) ? 'S' : ' '), + (( de.attr & ATTR_HIDDEN ) ? 'H' : ' ')); + } + } + shell_sprintf(FATFS_FTOT_STR,"%d",ftot); + return(0); +} + +static int +fatfsQry(char *fatfspath, int verbose) +{ + DIRENT de; + DIRINFO di; + char *lastslash, *fname, *dir, pathcopy[80], matchname[80]; + int flen, flen1, fsize, pathlen, match, ftot; + + if (!fatfspath) + return(-1); + + /* Prior to each 'ls', clear the content of the name and + * size shell variables... + */ + setenv(FATFS_FNAME_STR,0); + setenv(FATFS_FSIZE_STR,0); + setenv(FATFS_FTOT_STR,0); + + pathlen = strlen(fatfspath); + if (pathlen > sizeof(pathcopy)) { + printf("path too big\n"); + return(-1); + } + strcpy(pathcopy, fatfspath); + lastslash = strrchr(pathcopy,DIR_SEPARATOR); + + if (lastslash == 0) { + dir = ""; + fname = pathcopy; + } + else { + *lastslash = 0; + dir = pathcopy; + fname = lastslash+1; + } + + flen = strlen(fname); + if (verbose > 1) + printf("Qry opening dir <%s>, fname <%s>...\n",dir,fname); + + di.scratch = sector; + if (DFS_OpenDir(&vi, (uint8_t *)dir, &di)) { + printf("error opening subdirectory\n"); + return(CMD_FAILURE); + } + + match = fsize = ftot = flen1 = 0; + while (!DFS_GetNext(&vi, &di, &de)) { + int i; + char dosname[16]; + + memset(dosname,0,sizeof(dosname)); + if (de.name[0] && ((de.attr & ATTR_LONG_NAME) != ATTR_LONG_NAME)) { + if ((de.attr & ATTR_VOLUME_ID) || (de.attr & ATTR_DIRECTORY)) { + for(i=0;i<8;i++) { + if (de.name[i] != ' ') { + dosname[i] = de.name[i]; + } + else { + dosname[i] = 0; + break; + } + } + dosname[8] = 0; + } + else + DFS_DirToCanonical((uint8_t *)dosname,de.name); + + flen1 = strlen(dosname); + + if ((fname[0] == '*') && (fname[flen-1] == '*')) { + fname[flen-1] = 0; + if (strstr(dosname,fname+1)) + match = 1; + fname[flen-1] = '*'; + } + else if (fname[0] == '*') { + if (!strcmp(dosname+(flen1-flen+1),fname+1)) + match = 1; + } + else if (fname[flen-1] == '*') { + fname[flen-1] = 0; + if (!strncmp(dosname,fname,flen-1)) + match = 1; + fname[flen-1] = '*'; + } + else if (!strcmp(dosname,fname)) { + match = 1; + } + if (match) { + strcpy(matchname,dosname); + fsize = FILESIZE(de); + ftot++; + match = 0; + if (verbose) + printf(" %s (%d)\n",dosname,fsize); + } + } + } + shell_sprintf(FATFS_FTOT_STR,"%d",ftot); + if (ftot) { + shell_sprintf(FATFS_FSIZE_STR,"%d",fsize); + setenv(FATFS_FNAME_STR,matchname); + } + return(0); +} + + +char *FatfsHelp[] = { + "Fat 12|16|32 File System Support", + "[r:s:w:v] {operation} [args]...", +#if INCLUDE_VERBOSEHELP + "", + "Options:", + " -r {addr} set read-block func ptr (default: FATFS_RD)", + " -s {addr} base of ram scratch space used by fatfs", + " (default is APPRAMBASE)", + " -w {addr} set write-block func ptr (default: FATFS_WR)", + " -v additive verbosity", + "", + "Operations:", + " cat {fname}", + " get {fat_file} {tfs_file | addr}", + " (get from fatfs)", + " init initialize internal structures", + " put {tfs_file | addr,size} {fat_file}", + " (put to fatfs)", + " ls [dir] list files within specified directory (or top)", + " qry {fltr} qry for file or directory presence", + " - fltr format: sss, *sss, sss*, *sss* ('sss' is any string)", + " - loads " FATFS_FNAME_STR " & " FATFS_FSIZE_STR " based on most recent match", + " - loads " FATFS_FTOT_STR " with number of files listed", + " rm {fname}", +#endif + 0 +}; + +/* FatfsCmd(): + * This command provides a front end (command line interface) to the + * dosfs.c code. The intent is that this be a template for other + * "fs-ish" commands within uMon (refer to discussion at the top of this + * file). + */ +int +FatfsCmd(int argc, char *argv[]) +{ + uint32_t i, j; + int opt, verbose; + char *cmd, *env, *arg1, *arg2, *arg3; + + /* Establish default read/write functions to access underlying + * storage media. These defaults can be overridden by the + * command line options -r & -w below. + */ + if ((env = getenv("FATFS_RD")) != 0) + fatfsRead = (int(*)(int,char*,int,int))strtol(env,0,0); + + if ((env = getenv("FATFS_WR")) != 0) + fatfsWrite = (int(*)(int,char*,int,int))strtol(env,0,0); + + verbose = 0; + fatfs_tmp_space = (char *)0xffffffff; + while ((opt=getopt(argc,argv,"r:s:vw:")) != -1) { + switch(opt) { + case 'r': + fatfsRead = (int(*)(int,char*,int,int))strtoul(optarg,0,0); + break; + case 's': + fatfs_tmp_space = (char *)strtoul(optarg,0,0); + break; + case 'w': + fatfsWrite = (int(*)(int,char*,int,int))strtoul(optarg,0,0); + break; + case 'v': + verbose++; + break; + default: + return(CMD_PARAM_ERROR); + } + } + + if ((fatfsRead == 0) || (fatfsWrite == 0)) { + printf("FATFS access pointers not initialized\n"); + return(CMD_FAILURE); + } + + if (argc < optind + 1) + return(CMD_PARAM_ERROR); + + if (fatfs_tmp_space == (char *)0xffffffff) + fatfs_tmp_space = (char *)getAppRamStart(); + + cmd = argv[optind]; + arg1 = argv[optind+1]; + arg2 = argv[optind+2]; + arg3 = argv[optind+3]; + + if (strcmp(cmd,"init") == 0) { + if (fatfsInit(1,verbose) < 0) + return(CMD_FAILURE); + } + else if (strcmp(cmd,"cat") == 0) { + if (argc != optind + 2) + return(CMD_PARAM_ERROR); + + if (fatfsInit(0,0) < 0) + return(CMD_FAILURE); + + for(i=optind+1;i not found\n",cmd); + return(CMD_FAILURE); + } + + return(CMD_SUCCESS); +} + +/* Hookup between DOSFS and this command... + * The dosfs.c code requires that the user provide two functions + * (DFS_ReadSector() and DFS_WriteSector()) to hook it up to an + * external interface. These two functions are configured by + * the fatfs command to point to whatever driver is to be established + * as the FATFS physical interface. For more information refer to the + * discussion at the top of this file. + */ +uint32_t +DFS_ReadSector(uint8_t unit, uint8_t *data, uint32_t sec,uint32_t count) +{ + return((uint32_t)fatfsRead((int)unit, (char *)data, sec, count)); +} + +uint32_t +DFS_WriteSector(uint8_t unit, uint8_t *data, uint32_t sec,uint32_t count) +{ + return((uint32_t)fatfsWrite((int)unit, (char *)data, sec, count)); +} + +#endif diff --git a/ports/beagleboneblack/Makefile b/ports/beagleboneblack/Makefile index e0676b1..11956db 100644 --- a/ports/beagleboneblack/Makefile +++ b/ports/beagleboneblack/Makefile @@ -39,7 +39,7 @@ endif LIBABIDIR = -L $(ABIDIR) COMMON_AFLAGS = -c -D PLATFORM_$(PLATFORM)=1 -D ASSEMBLY_ONLY -CUSTOM_CFLAGS = -mcpu=cortex-a8 -O2 -isystem $(ABIDIR)/include -Wno-char-subscripts +CUSTOM_CFLAGS = -mcpu=cortex-a8 -O2 -isystem $(ABIDIR)/include -Wno-char-subscripts -mno-unaligned-access ############################################################################### @@ -48,7 +48,7 @@ CUSTOM_CFLAGS = -mcpu=cortex-a8 -O2 -isystem $(ABIDIR)/include -Wno-char-subscri # The following variables are used to establish the system's memory map. # BOOTROMBASE=0x402F0400 -BOOTROMLEN=0x010000 +BOOTROMLEN=0x01b000 BOOTRAMBASE=0x80000000 BOOTRAMLEN=0x010000 RAMTSTROMBASE=0x80100000 @@ -75,7 +75,7 @@ COMCSRC = arp.c cast.c cache.c chario.c cmdtbl.c \ reg_cache.c sbrk.c sd.c \ start.c struct.c symtbl.c syslog.c tcpstuff.c tfs.c tfsapi.c \ tfsclean1.c tfscli.c tfsloader.c tfslog.c tftp.c timestuff.c \ - tsi.c xmodem.c + tsi.c xmodem.c dosfs.c fatfs.c CPUCSRC = except_arm.c misc_arm.c strace_arm.c IODEVSRC = uart16550.c FLASHSRC = diff --git a/ports/beagleboneblack/config.h b/ports/beagleboneblack/config.h index 2592fdf..b0136c3 100644 --- a/ports/beagleboneblack/config.h +++ b/ports/beagleboneblack/config.h @@ -176,7 +176,7 @@ #define INCLUDE_PROFILER 0 #define INCLUDE_BBC 0 #define INCLUDE_STOREMAC 0 -#define INCLUDE_SHELLVARS 0 +#define INCLUDE_SHELLVARS 1 #define INCLUDE_MALLOC 0 #define INCLUDE_PORTCMD 0 #define INCLUDE_SYSLOG 0 @@ -191,6 +191,7 @@ #define INCLUDE_SD 1 #define INCLUDE_DNS 0 #define INCLUDE_BLINKLED 1 +#define INCLUDE_FATFS 1 #define TARGET_BLINKLED target_blinkled /* Inclusion of this next file will make sure that all of the above -- cgit v1.2.3