OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [bootloaders/] [orpmon/] [common/] [dosfs.c] - Diff between revs 389 and 406

Go to most recent revision | Show entire file | Details | Blame | View Log

Rev 389 Rev 406
Line 26... Line 26...
#include "support.h"
#include "support.h"
#include "uart.h"
#include "uart.h"
 
 
 
 
 
 
unsigned long int init_fat(VOLINFO *vis){
unsigned long int init_fat(VOLINFO * vis)
 
{
 
 
 
 
 
 
 
 
    unsigned char sector[SECTOR_SIZE];
    unsigned char sector[SECTOR_SIZE];
 
 
    unsigned long int pstart,psize, i,fisz;
    unsigned long int pstart,psize, i,fisz;
 
 
    unsigned char pactive, ptype;
    unsigned char pactive, ptype;
 
 
    VOLINFO vi;
    VOLINFO vi;
 
 
 
 
 
 
    //uart_init(DEFAULT_UART);
    //uart_init(DEFAULT_UART);
    printf("FAT INIT START\n");
    printf("FAT INIT START\n");
 
 
    memCardInit();
    memCardInit();
 
 
 
 
 
 
        pstart = DFS_GetPtnStart(0, sector, 0, &pactive, &ptype, &psize);
        pstart = DFS_GetPtnStart(0, sector, 0, &pactive, &ptype, &psize);
 
 
        if (pstart == 0xffffffff) {
        if (pstart == 0xffffffff) {
 
 
                printf("Cannot find first partition\n");
                printf("Cannot find first partition\n");
 
 
                return -1;
                return -1;
 
 
        }
        }
 
 
        printf("Partition 0 start sector 0x%-08.8lX active %-02.2hX type %-02.2hX size %-08.8lX\n", pstart, pactive, ptype, psize);
 
 
printf
 
            ("Partition 0 start sector 0x%-08.8lX active %-02.2hX type %-02.2hX size %-08.8lX\n",
 
             pstart, pactive, ptype, psize);
 
 
 
 
        if (DFS_GetVolInfo(0, sector, pstart, &vi)) {
        if (DFS_GetVolInfo(0, sector, pstart, &vi)) {
 
 
                printf("Error getting volume information\n");
                printf("Error getting volume information\n");
 
 
                return -1;
                return -1;
 
 
        }
        }
 
 
 
 
 
 
 
 
 
 
        *vis=vi;
        *vis=vi;
 
 
 
 
 
 
 
 
}
}
 
 
 
 
unsigned long int DFS_ReadSector(unsigned char unit, unsigned char *buffer, unsigned long int sector, unsigned long int  count)
 
 
 
 
unsigned long int DFS_ReadSector(unsigned char unit, unsigned char *buffer,
 
                                    unsigned long int sector,
 
                                    unsigned long int count)
{
{
 
 
 
 
    unsigned long int block_add = 0;
    unsigned long int block_add = 0;
 
 
        int i ;
        int i ;
 
 
 
 
 
 
 
 
    for (i=0; i<count; i++){
    for (i=0; i<count; i++){
 
 
        block_add=sector+i;
        block_add=sector+i;
 
 
        DBGA("\n readSector %u, block_addr %u \n",sector,block_add);
        DBGA("\n readSector %u, block_addr %u \n",sector,block_add);
 
 
        setup_bd_transfer(READ_OP, block_add , buffer);
        setup_bd_transfer(READ_OP, block_add , buffer);
 
 
        if (finnish_bd_transfer() == FALSE)
        if (finnish_bd_transfer() == FALSE)
 
 
            return 0xff;
            return 0xff;
 
 
 
 
    }
    }
 
 
 
 
    return 0;
    return 0;
 
 
 
 
}
}
 
 
 
 
unsigned long int DFS_WriteSector(unsigned char unit, unsigned char *buffer, unsigned long int sector, unsigned long int  count)
 
 
 
 
unsigned long int DFS_WriteSector(unsigned char unit, unsigned char *buffer,
 
                                     unsigned long int sector,
 
                                     unsigned long int count)
{
{
 
 
 
 
 
 
    unsigned long int block_add = 0;
    unsigned long int block_add = 0;
 
 
    unsigned char scr[SECTOR_SIZE];
    unsigned char scr[SECTOR_SIZE];
 
 
 
 
            block_add=sector;
            block_add=sector;
 
 
            DBGA("\n writeSector %u, block_addr2 %u \n",sector,block_add);
            DBGA("\n writeSector %u, block_addr2 %u \n",sector,block_add);
 
 
            setup_bd_transfer(WRITE_OP, block_add , buffer);
            setup_bd_transfer(WRITE_OP, block_add , buffer);
 
 
 
 
            if (finnish_bd_transfer() == FALSE){
            if (finnish_bd_transfer() == FALSE){
 
 
                printf("TRANSACTION FAILED, Buffer %x \n", buffer);
                printf("TRANSACTION FAILED, Buffer %x \n", buffer);
 
 
 
 
                //reset_card();  
                //reset_card();  
               // sd_wait_rsp();
               // sd_wait_rsp();
               // SD_REG(SD_SOFTWARE_RST)=1; 
               // SD_REG(SD_SOFTWARE_RST)=1; 
 
 
                //SD_REG(SD_SOFTWARE_RST)=0; 
                //SD_REG(SD_SOFTWARE_RST)=0; 
 
 
 
 
                DBGA("FREE BD TX/RX: 0x%x \n", SD_REG(BD_STATUS) );
                DBGA("FREE BD TX/RX: 0x%x \n", SD_REG(BD_STATUS) );
 
 
 
 
 
 
                DBGA("TRY READ SECTOR \n");
                DBGA("TRY READ SECTOR \n");
 
 
                setup_bd_transfer(READ_OP, 526571008 , scr);
                setup_bd_transfer(READ_OP, 526571008 , scr);
 
 
                finnish_bd_transfer();
                finnish_bd_transfer();
 
 
               DBGA("PRINT test wreite to 526571008 \n");
               DBGA("PRINT test wreite to 526571008 \n");
 
 
               setup_bd_transfer(WRITE_OP, 526571008 , scr);
               setup_bd_transfer(WRITE_OP, 526571008 , scr);
 
 
              finnish_bd_transfer();
              finnish_bd_transfer();
 
 
 
 
                setup_bd_transfer(WRITE_OP, block_add , buffer);
                setup_bd_transfer(WRITE_OP, block_add , buffer);
 
 
                if (finnish_bd_transfer() == FALSE){
                if (finnish_bd_transfer() == FALSE){
                   printf("TRANSACTION FAILED AGAIN!, Buffer %x \n", buffer);
 
 
printf("TRANSACTION FAILED AGAIN!, Buffer %x \n",
 
                                buffer);
 
 
                      return 0xff;
                      return 0xff;
 
 
                }
                }
 
 
 
 
            }
            }
 
 
 
 
 
 
    return 0;
    return 0;
 
 
 
 
}
}
 
 
 
 
 
 
/*
/*
        Get starting sector# of specified partition on drive #unit
        Get starting sector# of specified partition on drive #unit
        NOTE: This code ASSUMES an MBR on the disk.
        NOTE: This code ASSUMES an MBR on the disk.
        scratchsector should point to a SECTOR_SIZE scratch area
        scratchsector should point to a SECTOR_SIZE scratch area
        Returns 0xffffffff for any error.
        Returns 0xffffffff for any error.
Line 141... Line 206...
        If pptype is non-NULL, this function also returns the partition type.
        If pptype is non-NULL, this function also returns the partition type.
        If psize is non-NULL, this function also returns the partition size.
        If psize is non-NULL, this function also returns the partition size.
*/
*/
 
 
 
 
unsigned long int DFS_GetPtnStart(unsigned char unit, unsigned char *scratchsector, unsigned char pnum, unsigned char *pactive, unsigned char *pptype, unsigned long int *psize)
unsigned long int DFS_GetPtnStart(unsigned char unit,
 
                                    unsigned char *scratchsector,
 
                                    unsigned char pnum, unsigned char *pactive,
 
                                    unsigned char *pptype,
 
                                    unsigned long int *psize)
{
{
 
 
        unsigned long int result;
        unsigned long int result;
 
 
        PMBR mbr = (PMBR) scratchsector;
        PMBR mbr = (PMBR) scratchsector;
 
 
 
 
        // DOS ptable supports maximum 4 partitions
        // DOS ptable supports maximum 4 partitions
        if (pnum > 3)
        if (pnum > 3)
 
 
                return DFS_ERRMISC;
                return DFS_ERRMISC;
 
 
 
 
        // Read MBR from target media
        // Read MBR from target media
        if (DFS_ReadSector(unit,scratchsector,0,1)) {
        if (DFS_ReadSector(unit,scratchsector,0,1)) {
 
 
                return DFS_ERRMISC;
                return DFS_ERRMISC;
 
 
        }
        }
 
 
 
 
        result = (unsigned long int) mbr->ptable[pnum].start_0 |
        result = (unsigned long int) mbr->ptable[pnum].start_0 |
          (((unsigned long int) mbr->ptable[pnum].start_1) << 8) |
          (((unsigned long int) mbr->ptable[pnum].start_1) << 8) |
          (((unsigned long int) mbr->ptable[pnum].start_2) << 16) |
          (((unsigned long int) mbr->ptable[pnum].start_2) << 16) |
          (((unsigned long int) mbr->ptable[pnum].start_3) << 24);
          (((unsigned long int) mbr->ptable[pnum].start_3) << 24);
 
 
 
 
 
 
   //unsigned char              active;                 // 0x80 if partition active
   //unsigned char              active;                 // 0x80 if partition active
        //unsigned char         start_h;                // starting head
        //unsigned char         start_h;                // starting head
        //unsigned char         start_cs_l;             // starting cylinder and sector (low byte)
        //unsigned char         start_cs_l;             // starting cylinder and sector (low byte)
        //unsigned char         start_cs_h;             // starting cylinder and sector (high byte)
        //unsigned char         start_cs_h;             // starting cylinder and sector (high byte)
 
 
    printf("active 0:%x 1:%x 2:%x 3:%x \n",  mbr->ptable[pnum].active, mbr->ptable[pnum].start_h, mbr->ptable[pnum].start_cs_l,mbr->ptable[pnum].start_cs_h);
printf("active 0:%x 1:%x 2:%x 3:%x \n", mbr->ptable[pnum].active,
 
                    mbr->ptable[pnum].start_h, mbr->ptable[pnum].start_cs_l,
 
                    mbr->ptable[pnum].start_cs_h);
 
 
 
 
 
printf("start 0:%x 1:%x 2:%x 3:%x \n", mbr->ptable[pnum].start_0,
 
                 mbr->ptable[pnum].start_1, mbr->ptable[pnum].start_2,
 
                 mbr->ptable[pnum].start_3);
 
 
    printf("start 0:%x 1:%x 2:%x 3:%x \n", mbr->ptable[pnum].start_0, mbr->ptable[pnum].start_1,mbr->ptable[pnum].start_2,mbr->ptable[pnum].start_3);
 
        if (pactive)
        if (pactive)
 
 
                *pactive = mbr->ptable[pnum].active;
                *pactive = mbr->ptable[pnum].active;
 
 
 
 
        if (pptype)
        if (pptype)
 
 
                *pptype = mbr->ptable[pnum].type;
                *pptype = mbr->ptable[pnum].type;
 
 
 
 
        if (psize){
        if (psize){
 
 
                *psize = (unsigned long int) mbr->ptable[pnum].size_0 |
                *psize = (unsigned long int) mbr->ptable[pnum].size_0 |
                  (((unsigned long int) mbr->ptable[pnum].size_1) << 8) |
                  (((unsigned long int) mbr->ptable[pnum].size_1) << 8) |
                  (((unsigned long int) mbr->ptable[pnum].size_2) << 16) |
                  (((unsigned long int) mbr->ptable[pnum].size_2) << 16) |
                  (((unsigned long int) mbr->ptable[pnum].size_3) << 24);
                  (((unsigned long int) mbr->ptable[pnum].size_3) << 24);
          printf("size 0:%x 1:%x 2:%x 3:%x \n", mbr->ptable[pnum].size_0, mbr->ptable[pnum].size_1,mbr->ptable[pnum].size_2,mbr->ptable[pnum].size_3);
 
 
printf("size 0:%x 1:%x 2:%x 3:%x \n", mbr->ptable[pnum].size_0,
 
                        mbr->ptable[pnum].size_1, mbr->ptable[pnum].size_2,
 
                        mbr->ptable[pnum].size_3);
 
 
          }
          }
 
 
 
 
        return result;
        return result;
 
 
}
}
 
 
 
 
 
 
 
 
 
 
 ldiv_t ldiv (long int numer, long int denom)
 ldiv_t ldiv (long int numer, long int denom)
{
{
 
 
   ldiv_t result;
   ldiv_t result;
 
 
 
 
  result.quot = numer / denom;
  result.quot = numer / denom;
 
 
  result.rem = numer % denom;
  result.rem = numer % denom;
 
 
 
 
  /* The ANSI standard says that |QUOT| <= |NUMER / DENOM|, where
  /* The ANSI standard says that |QUOT| <= |NUMER / DENOM|, where
     NUMER / DENOM is to be computed in infinite precision.  In
     NUMER / DENOM is to be computed in infinite precision.  In
     other words, we should always truncate the quotient towards
     other words, we should always truncate the quotient towards
     zero, never -infinity.  Machine division and remainer may
     zero, never -infinity.  Machine division and remainer may
     work either way when one or both of NUMER or DENOM is
     work either way when one or both of NUMER or DENOM is
Line 212... Line 313...
     NUMER >= 0, but REM < 0, we got the wrong answer.  In that
     NUMER >= 0, but REM < 0, we got the wrong answer.  In that
     case, to get the right answer, add 1 to QUOT and subtract
     case, to get the right answer, add 1 to QUOT and subtract
     DENOM from REM.  */
     DENOM from REM.  */
 
 
  if (numer >= 0 && result.rem < 0)
  if (numer >= 0 && result.rem < 0)
 
 
    {
    {
 
 
      ++result.quot;
      ++result.quot;
 
 
      result.rem -= denom;
      result.rem -= denom;
 
 
    }
    }
 
 
 
 
  return result;
  return result;
 
 
}
}
 
 
 
 
 
 
 div_t div ( int numer,  int denom)
 div_t div ( int numer,  int denom)
{
{
 
 
    div_t result;
    div_t result;
 
 
 
 
  result.quot = numer / denom;
  result.quot = numer / denom;
 
 
  result.rem = numer % denom;
  result.rem = numer % denom;
 
 
 
 
  /* The ANSI standard says that |QUOT| <= |NUMER / DENOM|, where
  /* The ANSI standard says that |QUOT| <= |NUMER / DENOM|, where
     NUMER / DENOM is to be computed in infinite precision.  In
     NUMER / DENOM is to be computed in infinite precision.  In
     other words, we should always truncate the quotient towards
     other words, we should always truncate the quotient towards
     zero, never -infinity.  Machine division and remainer may
     zero, never -infinity.  Machine division and remainer may
     work either way when one or both of NUMER or DENOM is
     work either way when one or both of NUMER or DENOM is
Line 244... Line 357...
     NUMER >= 0, but REM < 0, we got the wrong answer.  In that
     NUMER >= 0, but REM < 0, we got the wrong answer.  In that
     case, to get the right answer, add 1 to QUOT and subtract
     case, to get the right answer, add 1 to QUOT and subtract
     DENOM from REM.  */
     DENOM from REM.  */
 
 
  if (numer >= 0 && result.rem < 0)
  if (numer >= 0 && result.rem < 0)
 
 
    {
    {
 
 
      ++result.quot;
      ++result.quot;
 
 
      result.rem -= denom;
      result.rem -= denom;
 
 
    }
    }
 
 
 
 
  return result;
  return result;
 
 
}
}
 
 
 
 
/*
/*
        Retrieve volume info from BPB and store it in a VOLINFO structure
        Retrieve volume info from BPB and store it in a VOLINFO structure
        You must provide the unit and starting sector of the filesystem, and
        You must provide the unit and starting sector of the filesystem, and
        a pointer to a sector buffer for scratch
        a pointer to a sector buffer for scratch
        Attempts to read BPB and glean information about the FS from that.
        Attempts to read BPB and glean information about the FS from that.
        Returns 0 OK, nonzero for any error.
        Returns 0 OK, nonzero for any error.
*/
*/
unsigned long int DFS_GetVolInfo(unsigned char unit, unsigned char *scratchsector, unsigned long int startsector, PVOLINFO volinfo)
unsigned long int DFS_GetVolInfo(unsigned char unit,
 
                                 unsigned char *scratchsector,
 
                                 unsigned long int startsector,
 
                                 PVOLINFO volinfo)
{
{
 
 
        PLBR lbr = (PLBR) scratchsector;
        PLBR lbr = (PLBR) scratchsector;
 
 
        volinfo->unit = unit;
        volinfo->unit = unit;
 
 
        volinfo->startsector = startsector;
        volinfo->startsector = startsector;
 
 
 
 
        if(DFS_ReadSector(unit,scratchsector,startsector,1))
        if(DFS_ReadSector(unit,scratchsector,startsector,1))
 
 
                return DFS_ERRMISC;
                return DFS_ERRMISC;
 
 
 
 
// tag: OEMID, refer dosfs.h
// tag: OEMID, refer dosfs.h
//      strncpy(volinfo->oemid, lbr->oemid, 8);
//      strncpy(volinfo->oemid, lbr->oemid, 8);
//      volinfo->oemid[8] = 0;
//      volinfo->oemid[8] = 0;
 
 
        volinfo->secperclus = lbr->bpb.secperclus;
        volinfo->secperclus = lbr->bpb.secperclus;
 
 
        volinfo->reservedsecs = (unsigned short) lbr->bpb.reserved_l |
        volinfo->reservedsecs = (unsigned short) lbr->bpb.reserved_l |
                  (((unsigned short) lbr->bpb.reserved_h) << 8);
                  (((unsigned short) lbr->bpb.reserved_h) << 8);
 
 
 
 
        volinfo->numsecs =  (unsigned short) lbr->bpb.sectors_s_l |
        volinfo->numsecs =  (unsigned short) lbr->bpb.sectors_s_l |
                  (((unsigned short) lbr->bpb.sectors_s_h) << 8);
                  (((unsigned short) lbr->bpb.sectors_s_h) << 8);
 
 
 
 
        if (!volinfo->numsecs)
        if (!volinfo->numsecs)
 
 
                volinfo->numsecs = (unsigned long int) lbr->bpb.sectors_l_0 |
                volinfo->numsecs = (unsigned long int) lbr->bpb.sectors_l_0 |
                  (((unsigned long int) lbr->bpb.sectors_l_1) << 8) |
                  (((unsigned long int) lbr->bpb.sectors_l_1) << 8) |
                  (((unsigned long int) lbr->bpb.sectors_l_2) << 16) |
                  (((unsigned long int) lbr->bpb.sectors_l_2) << 16) |
                  (((unsigned long int) lbr->bpb.sectors_l_3) << 24);
                  (((unsigned long int) lbr->bpb.sectors_l_3) << 24);
 
 
 
 
        // If secperfat is 0, we must be in a FAT32 volume; get secperfat
        // 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
        // from the FAT32 EBPB. The volume label and system ID string are also
        // in different locations for FAT12/16 vs FAT32.
        // in different locations for FAT12/16 vs FAT32.
        volinfo->secperfat =  (unsigned short) lbr->bpb.secperfat_l |
        volinfo->secperfat =  (unsigned short) lbr->bpb.secperfat_l |
                  (((unsigned short) lbr->bpb.secperfat_h) << 8);
                  (((unsigned short) lbr->bpb.secperfat_h) << 8);
 
 
        if (!volinfo->secperfat) {
        if (!volinfo->secperfat) {
                volinfo->secperfat = (unsigned long int) lbr->ebpb.ebpb32.fatsize_0 |
 
                  (((unsigned long int) lbr->ebpb.ebpb32.fatsize_1) << 8) |
volinfo->secperfat =
                  (((unsigned long int) lbr->ebpb.ebpb32.fatsize_2) << 16) |
                    (unsigned long int)lbr->ebpb.ebpb32.
                  (((unsigned long int) lbr->ebpb.ebpb32.fatsize_3) << 24);
                    fatsize_0 |
 
 
 
(((unsigned long int)lbr->ebpb.ebpb32.
 
                       fatsize_1) << 8) |
 
(((unsigned long int)lbr->ebpb.
 
                                             ebpb32.
 
                                             fatsize_2) << 16) |
 
(((unsigned
 
                                                                     long int)
 
                                                                    lbr->ebpb.
 
                                                                    ebpb32.
 
                                                                    fatsize_3)
 
                                                                   << 24);
 
 
 
 
                memcpy(volinfo->label, lbr->ebpb.ebpb32.label, 11);
                memcpy(volinfo->label, lbr->ebpb.ebpb32.label, 11);
 
 
                volinfo->label[11] = 0;
                volinfo->label[11] = 0;
 
 
 
 
// tag: OEMID, refer dosfs.h
// tag: OEMID, refer dosfs.h
//              memcpy(volinfo->system, lbr->ebpb.ebpb32.system, 8);
//              memcpy(volinfo->system, lbr->ebpb.ebpb32.system, 8);
//              volinfo->system[8] = 0; 
//              volinfo->system[8] = 0; 
        }
        }
 
 
        else {
        else {
 
 
                memcpy(volinfo->label, lbr->ebpb.ebpb.label, 11);
                memcpy(volinfo->label, lbr->ebpb.ebpb.label, 11);
 
 
                volinfo->label[11] = 0;
                volinfo->label[11] = 0;
 
 
 
 
// tag: OEMID, refer dosfs.h
// tag: OEMID, refer dosfs.h
//              memcpy(volinfo->system, lbr->ebpb.ebpb.system, 8);
//              memcpy(volinfo->system, lbr->ebpb.ebpb.system, 8);
//              volinfo->system[8] = 0; 
//              volinfo->system[8] = 0; 
        }
        }
 
 
 
 
        // note: if rootentries is 0, we must be in a FAT32 volume.
        // note: if rootentries is 0, we must be in a FAT32 volume.
        volinfo->rootentries =  (unsigned short) lbr->bpb.rootentries_l |
        volinfo->rootentries =  (unsigned short) lbr->bpb.rootentries_l |
                  (((unsigned short) lbr->bpb.rootentries_h) << 8);
                  (((unsigned short) lbr->bpb.rootentries_h) << 8);
 
 
 
 
        // after extracting raw info we perform some useful precalculations
        // after extracting raw info we perform some useful precalculations
        volinfo->fat1 = startsector + volinfo->reservedsecs;
        volinfo->fat1 = startsector + volinfo->reservedsecs;
 
 
 
 
        // The calculation below is designed to round up the root directory size for FAT12/16
        // 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
        // and to simply ignore the root directory for FAT32, since it's a normal, expandable
        // file in that situation.
        // file in that situation.
        if (volinfo->rootentries) {
        if (volinfo->rootentries) {
 
 
                volinfo->rootdir = volinfo->fat1 + (volinfo->secperfat * 2);
                volinfo->rootdir = volinfo->fat1 + (volinfo->secperfat * 2);
                volinfo->dataarea = volinfo->rootdir + (((volinfo->rootentries * 32) + (SECTOR_SIZE - 1)) / SECTOR_SIZE);
 
 
volinfo->dataarea =
 
                    volinfo->rootdir +
 
                    (((volinfo->rootentries * 32) +
 
                      (SECTOR_SIZE - 1)) / SECTOR_SIZE);
 
 
        }
        }
 
 
        else {
        else {
 
 
                volinfo->dataarea = volinfo->fat1 + (volinfo->secperfat * 2);
                volinfo->dataarea = volinfo->fat1 + (volinfo->secperfat * 2);
                volinfo->rootdir = (unsigned long int) lbr->ebpb.ebpb32.root_0 |
 
                  (((unsigned long int) lbr->ebpb.ebpb32.root_1) << 8) |
volinfo->rootdir =
                  (((unsigned long int) lbr->ebpb.ebpb32.root_2) << 16) |
                    (unsigned long int)lbr->ebpb.ebpb32.
                  (((unsigned long int) lbr->ebpb.ebpb32.root_3) << 24);
                    root_0 |
 
(((unsigned long int)lbr->ebpb.ebpb32.root_1) <<
 
                               8) |
 
(((unsigned long int)lbr->ebpb.ebpb32.
 
                                       root_2) << 16) |
 
(((unsigned long int)
 
                                                           lbr->ebpb.ebpb32.
 
                                                           root_3) << 24);
 
 
        }
        }
 
 
        // Calculate number of clusters in data area and infer FAT type from this information.
        // Calculate number of clusters in data area and infer FAT type from this information.
        volinfo->numclusters = (volinfo->numsecs - volinfo->dataarea) / volinfo->secperclus;
            volinfo->numclusters =
 
            (volinfo->numsecs - volinfo->dataarea) / volinfo->secperclus;
 
 
        if (volinfo->numclusters < 4085)
        if (volinfo->numclusters < 4085)
 
 
                volinfo->filesystem = FAT12;
                volinfo->filesystem = FAT12;
 
 
        else if (volinfo->numclusters < 65525)
        else if (volinfo->numclusters < 65525)
 
 
                volinfo->filesystem = FAT16;
                volinfo->filesystem = FAT16;
 
 
        else
        else
 
 
                volinfo->filesystem = FAT32;
                volinfo->filesystem = FAT32;
 
 
 
 
        return DFS_OK;
        return DFS_OK;
 
 
}
}
 
 
 
 
 
 
/*
/*
        Fetch FAT entry for specified cluster number
        Fetch FAT entry for specified cluster number
        You must provide a scratch buffer for one sector (SECTOR_SIZE) and a populated VOLINFO
        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
        Returns a FAT32 BAD_CLUSTER value for any error, otherwise the contents of the desired
        FAT entry.
        FAT entry.
        scratchcache should point to a UINT32. This variable caches the physical sector number
        scratchcache should point to a UINT32. This variable caches the physical sector number
        last read into the scratch buffer for performance enhancement reasons.
        last read into the scratch buffer for performance enhancement reasons.
*/
*/
unsigned long int DFS_GetFAT(PVOLINFO volinfo, unsigned char *scratch, unsigned long int *scratchcache, unsigned long int cluster)
unsigned long int DFS_GetFAT(PVOLINFO volinfo, unsigned char *scratch,
 
                             unsigned long int *scratchcache,
 
                             unsigned long int cluster)
{
{
 
 
        unsigned long int offset, sector, result;
        unsigned long int offset, sector, result;
 
 
 
 
        if (volinfo->filesystem == FAT12) {
        if (volinfo->filesystem == FAT12) {
 
 
                offset = cluster + (cluster / 2);
                offset = cluster + (cluster / 2);
 
 
        }
        }
 
 
        else if (volinfo->filesystem == FAT16) {
        else if (volinfo->filesystem == FAT16) {
 
 
                offset = cluster * 2;
                offset = cluster * 2;
 
 
        }
        }
 
 
        else if (volinfo->filesystem == FAT32) {
        else if (volinfo->filesystem == FAT32) {
 
 
                offset = cluster * 4;
                offset = cluster * 4;
 
 
        }
        }
 
 
        else
        else
 
 
                return 0x0ffffff7;      // FAT32 bad cluster    
                return 0x0ffffff7;      // FAT32 bad cluster    
 
 
        // at this point, offset is the BYTE offset of the desired sector from the start
        // 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.
        // of the FAT. Calculate the physical sector containing this FAT entry.
        sector = ldiv(offset, SECTOR_SIZE).quot + volinfo->fat1;
        sector = ldiv(offset, SECTOR_SIZE).quot + volinfo->fat1;
 
 
 
 
        // If this is not the same sector we last read, then read it into RAM
        // If this is not the same sector we last read, then read it into RAM
        if (sector != *scratchcache) {
        if (sector != *scratchcache) {
 
 
                if(DFS_ReadSector(volinfo->unit, scratch, sector, 1)) {
                if(DFS_ReadSector(volinfo->unit, scratch, sector, 1)) {
 
 
                        // avoid anyone assuming that this cache value is still valid, which
                        // avoid anyone assuming that this cache value is still valid, which
                        // might cause disk corruption
                        // might cause disk corruption
                        *scratchcache = 0;
                        *scratchcache = 0;
 
 
                        return 0x0ffffff7;      // FAT32 bad cluster    
                        return 0x0ffffff7;      // FAT32 bad cluster    
                }
                }
 
 
                *scratchcache = sector;
                *scratchcache = sector;
 
 
        }
        }
 
 
 
 
        // At this point, we "merely" need to extract the relevant entry.
        // 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
        // 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
        // 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.
        // FAT sectors, but that luxury is (by design intent) unavailable to DOSFS.
        offset = ldiv(offset, SECTOR_SIZE).rem;
        offset = ldiv(offset, SECTOR_SIZE).rem;
 
 
 
 
        if (volinfo->filesystem == FAT12) {
        if (volinfo->filesystem == FAT12) {
 
 
                // Special case for sector boundary - Store last byte of current sector.
                // 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
                // Then read in the next sector and put the first byte of that sector into
                // the high byte of result.
                // the high byte of result.
                if (offset == SECTOR_SIZE - 1) {
                if (offset == SECTOR_SIZE - 1) {
 
 
                        result = (unsigned long int) scratch[offset];
                        result = (unsigned long int) scratch[offset];
 
 
                        sector++;
                        sector++;
 
 
                        if(DFS_ReadSector(volinfo->unit, scratch, sector, 1)) {
                        if(DFS_ReadSector(volinfo->unit, scratch, sector, 1)) {
 
 
                                // avoid anyone assuming that this cache value is still valid, which
                                // avoid anyone assuming that this cache value is still valid, which
                                // might cause disk corruption
                                // might cause disk corruption
                                *scratchcache = 0;
                                *scratchcache = 0;
 
 
                                return 0x0ffffff7;      // FAT32 bad cluster    
                                return 0x0ffffff7;      // FAT32 bad cluster    
                        }
                        }
 
 
                        *scratchcache = sector;
                        *scratchcache = sector;
 
 
                        // Thanks to Claudio Leonel for pointing out this missing line.
                        // Thanks to Claudio Leonel for pointing out this missing line.
                        result |= ((unsigned long int) scratch[0]) << 8;
                        result |= ((unsigned long int) scratch[0]) << 8;
 
 
                }
                }
 
 
                else {
                else {
 
 
                        result = (unsigned long int) scratch[offset] |
                        result = (unsigned long int) scratch[offset] |
                          ((unsigned long int) scratch[offset+1]) << 8;
                          ((unsigned long int) scratch[offset+1]) << 8;
 
 
                }
                }
                if (cluster & 1)
                if (cluster & 1)
 
 
                        result = result >> 4;
                        result = result >> 4;
 
 
                else
                else
 
 
                        result = result & 0xfff;
                        result = result & 0xfff;
 
 
        }
        }
 
 
        else if (volinfo->filesystem == FAT16) {
        else if (volinfo->filesystem == FAT16) {
 
 
                result = (unsigned long int) scratch[offset] |
                result = (unsigned long int) scratch[offset] |
                  ((unsigned long int) scratch[offset+1]) << 8;
                  ((unsigned long int) scratch[offset+1]) << 8;
 
 
        }
        }
 
 
        else if (volinfo->filesystem == FAT32) {
        else if (volinfo->filesystem == FAT32) {
 
 
                result = ((unsigned long int) scratch[offset] |
                result = ((unsigned long int) scratch[offset] |
                  ((unsigned long int) scratch[offset+1]) << 8 |
                  ((unsigned long int) scratch[offset+1]) << 8 |
                  ((unsigned long int) scratch[offset+2]) << 16 |
                  ((unsigned long int) scratch[offset+2]) << 16 |
                  ((unsigned long int) scratch[offset+3]) << 24) & 0x0fffffff;
                           ((unsigned long int)scratch[offset + 3]) << 24) &
 
                    0x0fffffff;
 
 
        }
        }
 
 
        else
        else
 
 
                result = 0x0ffffff7;    // FAT32 bad cluster    
                result = 0x0ffffff7;    // FAT32 bad cluster    
        return result;
        return result;
 
 
}
}
 
 
 
 
 
 
 
 
/*
/*
        Set FAT entry for specified cluster number
        Set FAT entry for specified cluster number
        You must provide a scratch buffer for one sector (SECTOR_SIZE) and a populated VOLINFO
        You must provide a scratch buffer for one sector (SECTOR_SIZE) and a populated VOLINFO
        Returns DFS_ERRMISC for any error, otherwise DFS_OK
        Returns DFS_ERRMISC for any error, otherwise DFS_OK
        scratchcache should point to a UINT32. This variable caches the physical sector number
        scratchcache should point to a UINT32. This variable caches the physical sector number
Line 448... Line 683...
 
 
        If you are operating DOSFS over flash, you are strongly advised to implement a writeback
        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
        cache in your physical I/O driver. This will speed up your code significantly and will
        also conserve power and flash write life.
        also conserve power and flash write life.
*/
*/
unsigned long int DFS_SetFAT(PVOLINFO volinfo, unsigned char *scratch, unsigned long int *scratchcache, unsigned long int cluster, unsigned long int new_contents)
unsigned long int DFS_SetFAT(PVOLINFO volinfo, unsigned char *scratch,
 
                             unsigned long int *scratchcache,
 
                             unsigned long int cluster,
 
                             unsigned long int new_contents)
{
{
 
 
        unsigned long int offset, sector, result;
        unsigned long int offset, sector, result;
 
 
        if (volinfo->filesystem == FAT12) {
        if (volinfo->filesystem == FAT12) {
 
 
                offset = cluster + (cluster / 2);
                offset = cluster + (cluster / 2);
 
 
                new_contents &=0xfff;
                new_contents &=0xfff;
 
 
        }
        }
 
 
        else if (volinfo->filesystem == FAT16) {
        else if (volinfo->filesystem == FAT16) {
 
 
                offset = cluster * 2;
                offset = cluster * 2;
 
 
                new_contents &=0xffff;
                new_contents &=0xffff;
 
 
        }
        }
 
 
        else if (volinfo->filesystem == FAT32) {
        else if (volinfo->filesystem == FAT32) {
 
 
                offset = cluster * 4;
                offset = cluster * 4;
 
 
                new_contents &=0x0fffffff;      // FAT32 is really "FAT28"
                new_contents &=0x0fffffff;      // FAT32 is really "FAT28"
        }
        }
 
 
        else
        else
 
 
                return DFS_ERRMISC;
                return DFS_ERRMISC;
 
 
 
 
        // at this point, offset is the BYTE offset of the desired sector from the start
        // 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.
        // of the FAT. Calculate the physical sector containing this FAT entry.
        sector = ldiv(offset, SECTOR_SIZE).quot + volinfo->fat1;
        sector = ldiv(offset, SECTOR_SIZE).quot + volinfo->fat1;
 
 
 
 
        // If this is not the same sector we last read, then read it into RAM
        // If this is not the same sector we last read, then read it into RAM
        if (sector != *scratchcache) {
        if (sector != *scratchcache) {
 
 
                if(DFS_ReadSector(volinfo->unit, scratch, sector, 1)) {
                if(DFS_ReadSector(volinfo->unit, scratch, sector, 1)) {
 
 
                        // avoid anyone assuming that this cache value is still valid, which
                        // avoid anyone assuming that this cache value is still valid, which
                        // might cause disk corruption
                        // might cause disk corruption
                        *scratchcache = 0;
                        *scratchcache = 0;
 
 
                        return DFS_ERRMISC;
                        return DFS_ERRMISC;
 
 
                }
                }
 
 
                *scratchcache = sector;
                *scratchcache = sector;
 
 
        }
        }
 
 
 
 
        // At this point, we "merely" need to extract the relevant entry.
        // 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
        // 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
        // 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.
        // FAT sectors, but that luxury is (by design intent) unavailable to DOSFS.
        offset = ldiv(offset, SECTOR_SIZE).rem;
        offset = ldiv(offset, SECTOR_SIZE).rem;
 
 
 
 
        if (volinfo->filesystem == FAT12) {
        if (volinfo->filesystem == FAT12) {
 
 
 
 
                // If this is an odd cluster, pre-shift the desired new contents 4 bits to
                // If this is an odd cluster, pre-shift the desired new contents 4 bits to
                // make the calculations below simpler
                // make the calculations below simpler
                if (cluster & 1)
                if (cluster & 1)
 
 
                        new_contents = new_contents << 4;
                        new_contents = new_contents << 4;
 
 
 
 
                // Special case for sector boundary
                // Special case for sector boundary
                if (offset == SECTOR_SIZE - 1) {
                if (offset == SECTOR_SIZE - 1) {
 
 
 
 
                        // Odd cluster: High 12 bits being set
                        // Odd cluster: High 12 bits being set
                        if (cluster & 1) {
                        if (cluster & 1) {
                                scratch[offset] = (scratch[offset] & 0x0f) | new_contents & 0xf0;
 
 
scratch[offset] =
 
                                    (scratch[offset] & 0x0f) | new_contents &
 
                                    0xf0;
 
 
                        }
                        }
 
 
                        // Even cluster: Low 12 bits being set
                        // Even cluster: Low 12 bits being set
                        else {
                        else {
 
 
                                scratch[offset] = new_contents & 0xff;
                                scratch[offset] = new_contents & 0xff;
 
 
                        }
                        }
                        result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1);
 
 
result =
 
                            DFS_WriteSector(volinfo->unit, scratch,
 
                                            *scratchcache, 1);
 
 
                        // mirror the FAT into copy 2
                        // mirror the FAT into copy 2
                        if (DFS_OK == result)
                        if (DFS_OK == result)
                                result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1);
 
 
result =
 
                                    DFS_WriteSector(volinfo->unit, scratch,
 
                                                    (*scratchcache) +
 
                                                    volinfo->secperfat, 1);
 
 
 
 
                        // If we wrote that sector OK, then read in the subsequent sector
                        // If we wrote that sector OK, then read in the subsequent sector
                        // and poke the first byte with the remainder of this FAT entry.
                        // and poke the first byte with the remainder of this FAT entry.
                        if (DFS_OK == result) {
                        if (DFS_OK == result) {
 
 
                                *scratchcache++;
                                *scratchcache++;
                                result = DFS_ReadSector(volinfo->unit, scratch, *scratchcache, 1);
 
 
result =
 
                                    DFS_ReadSector(volinfo->unit, scratch,
 
                                                   *scratchcache, 1);
 
 
                                if (DFS_OK == result) {
                                if (DFS_OK == result) {
 
 
                                        // Odd cluster: High 12 bits being set
                                        // Odd cluster: High 12 bits being set
                                        if (cluster & 1) {
                                        if (cluster & 1) {
                                                scratch[0] = new_contents & 0xff00;
 
 
scratch[0] =
 
                                                    new_contents & 0xff00;
 
 
                                        }
                                        }
 
 
                                        // Even cluster: Low 12 bits being set
                                        // Even cluster: Low 12 bits being set
                                        else {
                                        else {
                                                scratch[0] = (scratch[0] & 0xf0) | new_contents & 0x0f;
 
 
scratch[0] =
 
                                                    (scratch[0] & 0xf0) |
 
                                                    new_contents & 0x0f;
 
 
                                        }
                                        }
                                        result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1);
 
 
result =
 
                                            DFS_WriteSector(volinfo->unit,
 
                                                            scratch,
 
                                                            *scratchcache, 1);
 
 
                                        // mirror the FAT into copy 2
                                        // mirror the FAT into copy 2
                                        if (DFS_OK == result)
                                        if (DFS_OK == result)
                                                result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1);
 
 
result =
 
                                                    DFS_WriteSector(volinfo->
 
                                                                    unit,
 
                                                                    scratch,
 
                                                                    (*scratchcache)
 
                                                                    +
 
                                                                    volinfo->
 
                                                                    secperfat,
 
                                                                    1);
 
 
                                }
                                }
 
 
                                else {
                                else {
 
 
                                        // avoid anyone assuming that this cache value is still valid, which
                                        // avoid anyone assuming that this cache value is still valid, which
                                        // might cause disk corruption
                                        // might cause disk corruption
                                        *scratchcache = 0;
                                        *scratchcache = 0;
 
 
                                }
                                }
 
 
                        }
                        }
 
 
                } // if (offset == SECTOR_SIZE - 1)
                } // if (offset == SECTOR_SIZE - 1)
 
 
                // Not a sector boundary. But we still have to worry about if it's an odd
                // Not a sector boundary. But we still have to worry about if it's an odd
                // or even cluster number.
                // or even cluster number.
                else {
                else {
 
 
                        // Odd cluster: High 12 bits being set
                        // Odd cluster: High 12 bits being set
                        if (cluster & 1) {
                        if (cluster & 1) {
                                scratch[offset] = (scratch[offset] & 0x0f) | new_contents & 0xf0;
 
 
scratch[offset] =
 
                                    (scratch[offset] & 0x0f) | new_contents &
 
                                    0xf0;
 
 
                                scratch[offset+1] = new_contents & 0xff00;
                                scratch[offset+1] = new_contents & 0xff00;
 
 
                        }
                        }
 
 
                        // Even cluster: Low 12 bits being set
                        // Even cluster: Low 12 bits being set
                        else {
                        else {
 
 
                                scratch[offset] = new_contents & 0xff;
                                scratch[offset] = new_contents & 0xff;
                                scratch[offset+1] = (scratch[offset+1] & 0xf0) | new_contents & 0x0f;
 
 
scratch[offset + 1] =
 
                                    (scratch[offset + 1] & 0xf0) | new_contents
 
                                    & 0x0f;
 
 
                        }
                        }
                        result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1);
 
 
result =
 
                            DFS_WriteSector(volinfo->unit, scratch,
 
                                            *scratchcache, 1);
 
 
                        // mirror the FAT into copy 2
                        // mirror the FAT into copy 2
                        if (DFS_OK == result)
                        if (DFS_OK == result)
                                result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1);
 
 
result =
 
                                    DFS_WriteSector(volinfo->unit, scratch,
 
                                                    (*scratchcache) +
 
                                                    volinfo->secperfat, 1);
 
 
                }
                }
 
 
        }
        }
 
 
        else if (volinfo->filesystem == FAT16) {
        else if (volinfo->filesystem == FAT16) {
 
 
                scratch[offset] = (new_contents & 0xff);
                scratch[offset] = (new_contents & 0xff);
 
 
                scratch[offset+1] = (new_contents & 0xff00) >> 8;
                scratch[offset+1] = (new_contents & 0xff00) >> 8;
                result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1);
 
 
result =
 
                    DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1);
 
 
                // mirror the FAT into copy 2
                // mirror the FAT into copy 2
                if (DFS_OK == result)
                if (DFS_OK == result)
                        result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1);
 
 
result =
 
                            DFS_WriteSector(volinfo->unit, scratch,
 
                                            (*scratchcache) +
 
                                            volinfo->secperfat, 1);
 
 
        }
        }
 
 
        else if (volinfo->filesystem == FAT32) {
        else if (volinfo->filesystem == FAT32) {
 
 
                scratch[offset] = (new_contents & 0xff);
                scratch[offset] = (new_contents & 0xff);
 
 
                scratch[offset+1] = (new_contents & 0xff00) >> 8;
                scratch[offset+1] = (new_contents & 0xff00) >> 8;
 
 
                scratch[offset+2] = (new_contents & 0xff0000) >> 16;
                scratch[offset+2] = (new_contents & 0xff0000) >> 16;
                scratch[offset+3] = (scratch[offset+3] & 0xf0) | ((new_contents & 0x0f000000) >> 24);
 
 
scratch[offset + 3] =
 
                    (scratch[offset + 3] & 0xf0) | ((new_contents & 0x0f000000)
 
                                                    >> 24);
 
 
                // Note well from the above: Per Microsoft's guidelines we preserve the upper
                // 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
                // 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.
                // for; in every example I've encountered they are always zero.
                result = DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1);
                    result =
 
                    DFS_WriteSector(volinfo->unit, scratch, *scratchcache, 1);
 
 
                // mirror the FAT into copy 2
                // mirror the FAT into copy 2
                if (DFS_OK == result)
                if (DFS_OK == result)
                        result = DFS_WriteSector(volinfo->unit, scratch, (*scratchcache)+volinfo->secperfat, 1);
 
 
result =
 
                            DFS_WriteSector(volinfo->unit, scratch,
 
                                            (*scratchcache) +
 
                                            volinfo->secperfat, 1);
 
 
        }
        }
 
 
        else
        else
 
 
                result = DFS_ERRMISC;
                result = DFS_ERRMISC;
 
 
 
 
        return result;
        return result;
 
 
}
}
 
 
 
 
 
 
/*
/*
        Convert a filename element from canonical (8.3) to directory entry (11) form
        Convert a filename element from canonical (8.3) to directory entry (11) form
        src must point to the first non-separator character.
        src must point to the first non-separator character.
        dest must point to a 12-byte buffer.
        dest must point to a 12-byte buffer.
*/
*/
unsigned char *DFS_CanonicalToDir(unsigned char *dest, unsigned char *src)
unsigned char *DFS_CanonicalToDir(unsigned char *dest, unsigned char *src)
{
{
 
 
        unsigned char *destptr = dest;
        unsigned char *destptr = dest;
 
 
 
 
        memset(dest, ' ', 11);
        memset(dest, ' ', 11);
 
 
        dest[11] = 0;
        dest[11] = 0;
 
 
 
 
        while (*src && (*src != DIR_SEPARATOR) && (destptr - dest < 11)) {
        while (*src && (*src != DIR_SEPARATOR) && (destptr - dest < 11)) {
 
 
                if (*src >= 'a' && *src <='z') {
                if (*src >= 'a' && *src <='z') {
 
 
                        *destptr++ = (*src - 'a') + 'A';
                        *destptr++ = (*src - 'a') + 'A';
 
 
                        src++;
                        src++;
 
 
                }
                }
 
 
                else if (*src == '.') {
                else if (*src == '.') {
 
 
                        src++;
                        src++;
 
 
                        destptr = dest + 8;
                        destptr = dest + 8;
 
 
                }
                }
 
 
                else {
                else {
 
 
                        *destptr++ = *src++;
                        *destptr++ = *src++;
 
 
                }
                }
 
 
        }
        }
 
 
 
 
        return dest;
        return dest;
 
 
}
}
 
 
 
 
 
 
/*
/*
        Find the first unused FAT entry
        Find the first unused FAT entry
        You must provide a scratch buffer for one sector (SECTOR_SIZE) and a populated VOLINFO
        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
        Returns a FAT32 BAD_CLUSTER value for any error, otherwise the contents of the desired
        FAT entry.
        FAT entry.
        Returns FAT32 bad_sector (0x0ffffff7) if there is no free cluster available
        Returns FAT32 bad_sector (0x0ffffff7) if there is no free cluster available
*/
*/
unsigned long int DFS_GetFreeFAT(PVOLINFO volinfo, unsigned char *scratch)
unsigned long int DFS_GetFreeFAT(PVOLINFO volinfo, unsigned char *scratch)
{
{
 
 
        unsigned long int i, result = 0xffffffff, scratchcache = 0;
        unsigned long int i, result = 0xffffffff, scratchcache = 0;
 
 
 
 
        // Search starts at cluster 2, which is the first usable cluster
        // Search starts at cluster 2, which is the first usable cluster
        // NOTE: This search can't terminate at a bad cluster, because there might
        // NOTE: This search can't terminate at a bad cluster, because there might
        // legitimately be bad clusters on the disk.
        // legitimately be bad clusters on the disk.
        for (i=2; i < volinfo->numclusters; i++) {
        for (i=2; i < volinfo->numclusters; i++) {
 
 
                result = DFS_GetFAT(volinfo, scratch, &scratchcache, i);
                result = DFS_GetFAT(volinfo, scratch, &scratchcache, i);
 
 
                if (!result) {
                if (!result) {
 
 
                        return i;
                        return i;
 
 
                }
                }
 
 
        }
        }
 
 
        return 0x0ffffff7;              // Can't find a free cluster
        return 0x0ffffff7;              // Can't find a free cluster
}
}
 
 
 
 
 
 
 
 
/*
/*
        Open a directory for enumeration by DFS_GetNextDirEnt
        Open a directory for enumeration by DFS_GetNextDirEnt
        You must supply a populated VOLINFO (see DFS_GetVolInfo)
        You must supply a populated VOLINFO (see DFS_GetVolInfo)
        The empty string or a string containing only the directory separator are
        The empty string or a string containing only the directory separator are
        considered to be the root directory.
        considered to be the root directory.
        Returns 0 OK, nonzero for any error.
        Returns 0 OK, nonzero for any error.
*/
*/
unsigned long int DFS_OpenDir(PVOLINFO volinfo, unsigned char *dirname, PDIRINFO dirinfo)
unsigned long int DFS_OpenDir(PVOLINFO volinfo, unsigned char *dirname,
 
                              PDIRINFO dirinfo)
{
{
 
 
        // Default behavior is a regular search for existing entries
        // Default behavior is a regular search for existing entries
        dirinfo->flags = 0;
        dirinfo->flags = 0;
 
 
        if (!strlen((char *) dirname) || (strlen((char *) dirname) == 1 && dirname[0] == DIR_SEPARATOR)) {
 
 
if (!strlen((char *)dirname)
 
              || (strlen((char *)dirname) == 1
 
                  && dirname[0] == DIR_SEPARATOR)) {
 
 
                if (volinfo->filesystem == FAT32) {
                if (volinfo->filesystem == FAT32) {
 
 
                        dirinfo->currentcluster = volinfo->rootdir;
                        dirinfo->currentcluster = volinfo->rootdir;
 
 
                        dirinfo->currentsector = 0;
                        dirinfo->currentsector = 0;
 
 
                        dirinfo->currententry = 0;
                        dirinfo->currententry = 0;
 
 
 
 
                        // read first sector of directory
                        // read first sector of directory
                        return DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->dataarea + ((volinfo->rootdir - 2) * volinfo->secperclus), 1);
                            return DFS_ReadSector(volinfo->unit,
 
                                                  dirinfo->scratch,
 
                                                  volinfo->dataarea +
 
                                                  ((volinfo->rootdir -
 
                                                    2) * volinfo->secperclus),
 
                                                  1);
 
 
                }
                }
 
 
                else {
                else {
 
 
                        dirinfo->currentcluster = 0;
                        dirinfo->currentcluster = 0;
 
 
                        dirinfo->currentsector = 0;
                        dirinfo->currentsector = 0;
 
 
                        dirinfo->currententry = 0;
                        dirinfo->currententry = 0;
 
 
 
 
                        // read first sector of directory
                        // read first sector of directory
                        return DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->rootdir, 1);
                            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.
        // 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.
        // We do this by devious means, using our own companion function DFS_GetNext.
        else {
        else {
 
 
                unsigned char tmpfn[12];
                unsigned char tmpfn[12];
 
 
                unsigned char *ptr = dirname;
                unsigned char *ptr = dirname;
 
 
                unsigned long int result;
                unsigned long int result;
 
 
                DIRENT de;
                DIRENT de;
 
 
 
 
                if (volinfo->filesystem == FAT32) {
                if (volinfo->filesystem == FAT32) {
 
 
                        dirinfo->currentcluster = volinfo->rootdir;
                        dirinfo->currentcluster = volinfo->rootdir;
 
 
                        dirinfo->currentsector = 0;
                        dirinfo->currentsector = 0;
 
 
                        dirinfo->currententry = 0;
                        dirinfo->currententry = 0;
 
 
 
 
                        // read first sector of directory
                        // read first sector of directory
                        if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->dataarea + ((volinfo->rootdir - 2) * volinfo->secperclus), 1))
                            if (DFS_ReadSector
 
                                (volinfo->unit, dirinfo->scratch,
 
                                 volinfo->dataarea +
 
                                 ((volinfo->rootdir - 2) * volinfo->secperclus),
 
                                 1))
 
 
                                return DFS_ERRMISC;
                                return DFS_ERRMISC;
 
 
                }
                }
 
 
                else {
                else {
 
 
                        dirinfo->currentcluster = 0;
                        dirinfo->currentcluster = 0;
 
 
                        dirinfo->currentsector = 0;
                        dirinfo->currentsector = 0;
 
 
                        dirinfo->currententry = 0;
                        dirinfo->currententry = 0;
 
 
 
 
                        // read first sector of directory
                        // read first sector of directory
                        if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->rootdir, 1))
                            if (DFS_ReadSector
 
                                (volinfo->unit, dirinfo->scratch,
 
                                 volinfo->rootdir, 1))
 
 
                                return DFS_ERRMISC;
                                return DFS_ERRMISC;
 
 
                }
                }
 
 
 
 
                // skip leading path separators
                // skip leading path separators
                while (*ptr == DIR_SEPARATOR && *ptr)
                while (*ptr == DIR_SEPARATOR && *ptr)
 
 
                        ptr++;
                        ptr++;
 
 
 
 
                // Scan the path from left to right, finding the start cluster of each entry
                // 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.
                // Observe that this code is inelegant, but obviates the need for recursion.
                while (*ptr) {
                while (*ptr) {
 
 
                        DFS_CanonicalToDir(tmpfn, ptr);
                        DFS_CanonicalToDir(tmpfn, ptr);
 
 
 
 
                        de.name[0] = 0;
                        de.name[0] = 0;
 
 
 
 
                        do {
                        do {
 
 
                                result = DFS_GetNext(volinfo, dirinfo, &de);
                                result = DFS_GetNext(volinfo, dirinfo, &de);
 
 
                        } while (!result && memcmp2(de.name, tmpfn, 11));
                        } while (!result && memcmp2(de.name, tmpfn, 11));
 
 
                        if (!memcmp2(de.name, tmpfn, 11) && ((de.attr & ATTR_DIRECTORY) == ATTR_DIRECTORY)) {
 
 
if (!memcmp2(de.name, tmpfn, 11)
 
                              && ((de.attr & ATTR_DIRECTORY) ==
 
                                  ATTR_DIRECTORY)) {
 
 
                                if (volinfo->filesystem == FAT32) {
                                if (volinfo->filesystem == FAT32) {
                                        dirinfo->currentcluster = (unsigned long int) de.startclus_l_l |
 
                                          ((unsigned long int) de.startclus_l_h) << 8 |
dirinfo->currentcluster =
                                          ((unsigned long int) de.startclus_h_l) << 16 |
                                            (unsigned long int)de.
                                          ((unsigned long int) de.startclus_h_h) << 24;
                                            startclus_l_l |
 
 
 
((unsigned long int)de.
 
                                              startclus_l_h) << 8 |
 
((unsigned
 
                                                                       long int)
 
                                                                      de.
 
                                                                      startclus_h_l)
 
                                            << 16 |
 
((unsigned long int)de.
 
                                                      startclus_h_h) << 24;
 
 
                                }
                                }
 
 
                                else {
                                else {
                                        dirinfo->currentcluster = (unsigned long int) de.startclus_l_l |
 
                                          ((unsigned long int) de.startclus_l_h) << 8;
dirinfo->currentcluster =
 
                                            (unsigned long int)de.
 
                                            startclus_l_l |
 
 
 
((unsigned long int)de.
 
                                              startclus_l_h) << 8;
 
 
                                }
                                }
                                dirinfo->currentsector = 0;
                                dirinfo->currentsector = 0;
 
 
                                dirinfo->currententry = 0;
                                dirinfo->currententry = 0;
 
 
                                if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->dataarea + ((dirinfo->currentcluster - 2) * volinfo->secperclus), 1))
 
 
if (DFS_ReadSector
 
                                      (volinfo->unit, dirinfo->scratch,
 
                                       volinfo->dataarea +
 
                                       ((dirinfo->currentcluster -
 
                                         2) * volinfo->secperclus), 1))
 
 
                                        return DFS_ERRMISC;
                                        return DFS_ERRMISC;
 
 
                        }
                        }
                        else if (!memcmp2(de.name, tmpfn, 11) && !(de.attr & ATTR_DIRECTORY))
 
 
                        else if (!memcmp2(de.name, tmpfn, 11)
 
                                 && !(de.attr & ATTR_DIRECTORY))
 
 
                                return DFS_NOTFOUND;
                                return DFS_NOTFOUND;
 
 
 
 
                        // seek to next item in list
                        // seek to next item in list
                        while (*ptr != DIR_SEPARATOR && *ptr)
                        while (*ptr != DIR_SEPARATOR && *ptr)
 
 
                                ptr++;
                                ptr++;
 
 
                        if (*ptr == DIR_SEPARATOR)
                        if (*ptr == DIR_SEPARATOR)
 
 
                                ptr++;
                                ptr++;
 
 
                }
                }
 
 
 
 
                if (!dirinfo->currentcluster)
                if (!dirinfo->currentcluster)
 
 
                        return DFS_NOTFOUND;
                        return DFS_NOTFOUND;
 
 
        }
        }
 
 
        return DFS_OK;
        return DFS_OK;
 
 
}
}
 
 
 
 
 
 
/*
/*
        Get next entry in opened directory structure. Copies fields into the dirent
        Get next entry in opened directory structure. Copies fields into the dirent
        structure, updates dirinfo. Note that it is the _caller's_ responsibility to
        structure, updates dirinfo. Note that it is the _caller's_ responsibility to
        handle the '.' and '..' entries.
        handle the '.' and '..' entries.
        A deleted file will be returned as a NULL entry (first char of filename=0)
        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
        by this code. Filenames beginning with 0x05 will be translated to 0xE5
        automatically. Long file name entries will be returned as NULL.
        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,
        returns DFS_EOF if there are no more entries, DFS_OK if this entry is valid,
        or DFS_ERRMISC for a media error
        or DFS_ERRMISC for a media error
*/
*/
unsigned long int DFS_GetNext(PVOLINFO volinfo, PDIRINFO dirinfo, PDIRENT dirent)
unsigned long int DFS_GetNext(PVOLINFO volinfo, PDIRINFO dirinfo,
 
                              PDIRENT dirent)
{
{
 
 
        unsigned long int tempint;      // required by DFS_GetFAT
        unsigned long int tempint;      // required by DFS_GetFAT
 
 
        // Do we need to read the next sector of the directory?
        // Do we need to read the next sector of the directory?
        if (dirinfo->currententry >= SECTOR_SIZE / sizeof(DIRENT)) {
        if (dirinfo->currententry >= SECTOR_SIZE / sizeof(DIRENT)) {
 
 
                dirinfo->currententry = 0;
                dirinfo->currententry = 0;
 
 
                dirinfo->currentsector++;
                dirinfo->currentsector++;
 
 
 
 
                // Root directory; special case handling 
                // Root directory; special case handling 
                // Note that currentcluster will only ever be zero if both:
                // Note that currentcluster will only ever be zero if both:
                // (a) this is the root directory, and
                // (a) this is the root directory, and
                // (b) we are on a FAT12/16 volume, where the root dir can't be expanded
                // (b) we are on a FAT12/16 volume, where the root dir can't be expanded
                if (dirinfo->currentcluster == 0) {
                if (dirinfo->currentcluster == 0) {
 
 
                        // Trying to read past end of root directory?
                        // Trying to read past end of root directory?
                        if (dirinfo->currentsector * (SECTOR_SIZE / sizeof(DIRENT)) >= volinfo->rootentries)
                            if (dirinfo->currentsector *
 
                                (SECTOR_SIZE / sizeof(DIRENT)) >=
 
                                volinfo->rootentries)
 
 
                                return DFS_EOF;
                                return DFS_EOF;
 
 
 
 
                        // Otherwise try to read the next sector
                        // Otherwise try to read the next sector
                        if (DFS_ReadSector(volinfo->unit, dirinfo->scratch, volinfo->rootdir + dirinfo->currentsector, 1))
                            if (DFS_ReadSector
 
                                (volinfo->unit, dirinfo->scratch,
 
                                 volinfo->rootdir + dirinfo->currentsector, 1))
 
 
                                return DFS_ERRMISC;
                                return DFS_ERRMISC;
 
 
                }
                }
 
 
 
 
                // Normal handling
                // Normal handling
                else {
                else {
 
 
                        if (dirinfo->currentsector >= volinfo->secperclus) {
                        if (dirinfo->currentsector >= volinfo->secperclus) {
 
 
                                dirinfo->currentsector = 0;
                                dirinfo->currentsector = 0;
                                if ((dirinfo->currentcluster >= 0xff7 &&  volinfo->filesystem == FAT12) ||
 
                                  (dirinfo->currentcluster >= 0xfff7 &&  volinfo->filesystem == FAT16) ||
if ((dirinfo->currentcluster >= 0xff7
                                  (dirinfo->currentcluster >= 0x0ffffff7 &&  volinfo->filesystem == FAT32)) {
                                      && 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
                                        // We are at the end of the directory chain. If this is a normal
                                        // find operation, we should indicate that there is nothing more
                                        // find operation, we should indicate that there is nothing more
                                        // to see.
                                        // to see.
                                        if (!(dirinfo->flags & DFS_DI_BLANKENT))
                                            if (!
 
                                                (dirinfo->
 
                                                 flags & DFS_DI_BLANKENT))
 
 
                                                return DFS_EOF;
                                                return DFS_EOF;
 
 
 
 
                                        // On the other hand, if this is a "find free entry" search,
                                        // On the other hand, if this is a "find free entry" search,
                                        // we need to tell the caller to allocate a new cluster
                                        // we need to tell the caller to allocate a new cluster
                                        else
                                        else
 
 
                                                return DFS_ALLOCNEW;
                                                return DFS_ALLOCNEW;
 
 
                                }
                                }
                                dirinfo->currentcluster = DFS_GetFAT(volinfo, dirinfo->scratch, &tempint, dirinfo->currentcluster);
 
 
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))
 
 
if (DFS_ReadSector
 
                             (volinfo->unit, dirinfo->scratch,
 
                              volinfo->dataarea +
 
                              ((dirinfo->currentcluster -
 
                                2) * volinfo->secperclus) +
 
                              dirinfo->currentsector, 1))
 
 
                                return DFS_ERRMISC;
                                return DFS_ERRMISC;
 
 
                }
                }
 
 
        }
        }
 
 
        memcpy(dirent, &(((PDIRENT) dirinfo->scratch)[dirinfo->currententry]), sizeof(DIRENT));
 
 
memcpy(dirent, &(((PDIRENT) dirinfo->scratch)[dirinfo->currententry]),
 
                 sizeof(DIRENT));
 
 
 
 
        if (dirent->name[0] == 0) {               // no more files in this directory
        if (dirent->name[0] == 0) {               // no more files in this directory
                // If this is a "find blank" then we can reuse this name.
                // If this is a "find blank" then we can reuse this name.
                if (dirinfo->flags & DFS_DI_BLANKENT)
                if (dirinfo->flags & DFS_DI_BLANKENT)
 
 
                        return DFS_OK;
                        return DFS_OK;
 
 
                else
                else
 
 
                        return DFS_EOF;
                        return DFS_EOF;
 
 
        }
        }
 
 
 
 
        if (dirent->name[0] == 0xe5)     // handle deleted file entries
        if (dirent->name[0] == 0xe5)     // handle deleted file entries
                dirent->name[0] = 0;
                dirent->name[0] = 0;
 
 
        else if ((dirent->attr & ATTR_LONG_NAME) == ATTR_LONG_NAME)
        else if ((dirent->attr & ATTR_LONG_NAME) == ATTR_LONG_NAME)
 
 
                dirent->name[0] = 0;
                dirent->name[0] = 0;
 
 
        else if (dirent->name[0] == 0x05)        // handle kanji filenames beginning with 0xE5
        else if (dirent->name[0] == 0x05)        // handle kanji filenames beginning with 0xE5
                dirent->name[0] = 0xe5;
                dirent->name[0] = 0xe5;
 
 
 
 
        dirinfo->currententry++;
        dirinfo->currententry++;
 
 
 
 
        return DFS_OK;
        return DFS_OK;
 
 
}
}
 
 
 
 
 
 
/*
/*
        INTERNAL
        INTERNAL
        Find a free directory entry in the directory specified by path
        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
        This function MAY cause a disk write if it is necessary to extend the directory
        size.
        size.
        Note - di.scratch must be preinitialized to point to a sector scratch buffer
        Note - di.scratch must be preinitialized to point to a sector scratch buffer
        de is a scratch structure
        de is a scratch structure
        Returns DFS_ERRMISC if a new entry could not be located or created
        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
        de is updated with the same return information you would expect from DFS_GetNext
*/
*/
unsigned long int DFS_GetFreeDirEnt(PVOLINFO volinfo, unsigned char *path, PDIRINFO di, PDIRENT de)
unsigned long int DFS_GetFreeDirEnt(PVOLINFO volinfo, unsigned char *path,
 
                                    PDIRINFO di, PDIRENT de)
{
{
 
 
        unsigned long int tempclus,i;
        unsigned long int tempclus,i;
 
 
 
 
        if (DFS_OpenDir(volinfo, path, di))
        if (DFS_OpenDir(volinfo, path, di))
 
 
                return DFS_NOTFOUND;
                return DFS_NOTFOUND;
 
 
 
 
        // Set "search for empty" flag so DFS_GetNext knows what we're doing
        // Set "search for empty" flag so DFS_GetNext knows what we're doing
        di->flags |= DFS_DI_BLANKENT;
        di->flags |= DFS_DI_BLANKENT;
 
 
 
 
        // We seek through the directory looking for an empty entry
        // We seek through the directory looking for an empty entry
        // Note we are reusing tempclus as a temporary result holder.
        // Note we are reusing tempclus as a temporary result holder.
        tempclus = 0;
        tempclus = 0;
 
 
        do {
        do {
 
 
                tempclus = DFS_GetNext(volinfo, di, de);
                tempclus = DFS_GetNext(volinfo, di, de);
 
 
 
 
                // Empty entry found
                // Empty entry found
                if (tempclus == DFS_OK && (!de->name[0])) {
                if (tempclus == DFS_OK && (!de->name[0])) {
 
 
                        return DFS_OK;
                        return DFS_OK;
 
 
                }
                }
 
 
 
 
                // End of root directory reached
                // End of root directory reached
                else if (tempclus == DFS_EOF)
                else if (tempclus == DFS_EOF)
 
 
                        return DFS_ERRMISC;
                        return DFS_ERRMISC;
 
 
 
 
                else if (tempclus == DFS_ALLOCNEW) {
                else if (tempclus == DFS_ALLOCNEW) {
 
 
                        tempclus = DFS_GetFreeFAT(volinfo, di->scratch);
                        tempclus = DFS_GetFreeFAT(volinfo, di->scratch);
 
 
                        if (tempclus == 0x0ffffff7)
                        if (tempclus == 0x0ffffff7)
 
 
                                return DFS_ERRMISC;
                                return DFS_ERRMISC;
 
 
 
 
                        // write out zeroed sectors to the new cluster
                        // write out zeroed sectors to the new cluster
                        memset(di->scratch, 0, SECTOR_SIZE);
                        memset(di->scratch, 0, SECTOR_SIZE);
 
 
                        for (i=0;i<volinfo->secperclus;i++) {
                        for (i=0;i<volinfo->secperclus;i++) {
                                if (DFS_WriteSector(volinfo->unit, di->scratch, volinfo->dataarea + ((tempclus - 2) * volinfo->secperclus) + i, 1))
 
 
if (DFS_WriteSector
 
                                     (volinfo->unit, di->scratch,
 
                                      volinfo->dataarea +
 
                                      ((tempclus - 2) * volinfo->secperclus) +
 
                                      i, 1))
 
 
                                        return DFS_ERRMISC;
                                        return DFS_ERRMISC;
 
 
                        }
                        }
 
 
                        // Point old end cluster to newly allocated cluster
                        // Point old end cluster to newly allocated cluster
                        i = 0;
                        i = 0;
                        DFS_SetFAT(volinfo, di->scratch, &i, di->currentcluster, tempclus);
 
 
DFS_SetFAT(volinfo, di->scratch, &i,
 
                                    di->currentcluster, tempclus);
 
 
 
 
                        // Update DIRINFO so caller knows where to place the new file                   
                        // Update DIRINFO so caller knows where to place the new file                   
                        di->currentcluster = tempclus;
                        di->currentcluster = tempclus;
 
 
                        di->currentsector = 0;
                        di->currentsector = 0;
 
 
                        di->currententry = 1;   // since the code coming after this expects to subtract 1
                        di->currententry = 1;   // since the code coming after this expects to subtract 1
 
 
                        // Mark newly allocated cluster as end of chain                 
                        // Mark newly allocated cluster as end of chain                 
                        switch(volinfo->filesystem) {
                        switch(volinfo->filesystem) {
                                case FAT12:             tempclus = 0xff8;       break;
 
                                case FAT16:             tempclus = 0xfff8;      break;
case FAT12:
                                case FAT32:             tempclus = 0x0ffffff8;  break;
                                tempclus = 0xff8;
                                default:                return DFS_ERRMISC;
                                break;
 
 
 
case FAT16:
 
                                tempclus = 0xfff8;
 
                                break;
 
 
 
case FAT32:
 
                                tempclus = 0x0ffffff8;
 
                                break;
 
 
 
default:
 
                                return DFS_ERRMISC;
 
 
                        }
                        }
                        DFS_SetFAT(volinfo, di->scratch, &i, di->currentcluster, tempclus);
 
 
DFS_SetFAT(volinfo, di->scratch, &i,
 
                                    di->currentcluster, tempclus);
 
 
                }
                }
 
 
        } while (!tempclus);
        } while (!tempclus);
 
 
 
 
        // We shouldn't get here
        // We shouldn't get here
        return DFS_ERRMISC;
        return DFS_ERRMISC;
 
 
}
}
 
 
 
 
 
 
/*
/*
        Open a file for reading or writing. You supply populated VOLINFO, a path to the file,
        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
        mode (DFS_READ or DFS_WRITE) and an empty fileinfo structure. You also need to
        provide a pointer to a sector-sized scratch buffer.
        provide a pointer to a sector-sized scratch buffer.
        Returns various DFS_* error states. If the result is DFS_OK, fileinfo can be used
        Returns various DFS_* error states. If the result is DFS_OK, fileinfo can be used
        to access the file from this point on.
        to access the file from this point on.
*/
*/
unsigned long int DFS_OpenFile(PVOLINFO volinfo, unsigned char *path, unsigned char mode, unsigned char *scratch, PFILEINFO fileinfo)
unsigned long int DFS_OpenFile(PVOLINFO volinfo, unsigned char *path,
 
                               unsigned char mode, unsigned char *scratch,
 
                               PFILEINFO fileinfo)
{
{
 
 
        unsigned char tmppath[MAX_PATH];
        unsigned char tmppath[MAX_PATH];
 
 
        unsigned char filename[12];
        unsigned char filename[12];
 
 
        unsigned char *p;
        unsigned char *p;
 
 
        DIRINFO di;
        DIRINFO di;
 
 
        DIRENT de;
        DIRENT de;
 
 
 
 
        // larwe 2006-09-16 +1 zero out file structure
        // larwe 2006-09-16 +1 zero out file structure
        memset(fileinfo, 0, sizeof(FILEINFO));
        memset(fileinfo, 0, sizeof(FILEINFO));
 
 
 
 
        // save access mode
        // save access mode
        fileinfo->mode = mode;
        fileinfo->mode = mode;
 
 
 
 
        // Get a local copy of the path. If it's longer than MAX_PATH, abort.
        // Get a local copy of the path. If it's longer than MAX_PATH, abort.
        strcpy2((char *) tmppath, (char *) path);
        strcpy2((char *) tmppath, (char *) path);
 
 
        tmppath[MAX_PATH - 1] = 0;
        tmppath[MAX_PATH - 1] = 0;
 
 
        if (strcmp2((char *) path,(char *) tmppath)) {
        if (strcmp2((char *) path,(char *) tmppath)) {
 
 
                return DFS_PATHLEN;
                return DFS_PATHLEN;
 
 
        }
        }
 
 
 
 
 
 
        // strip leading path separators
        // strip leading path separators
        while (tmppath[0] == DIR_SEPARATOR)
        while (tmppath[0] == DIR_SEPARATOR)
 
 
                strcpy2((char *) tmppath, (char *) tmppath + 1);
                strcpy2((char *) tmppath, (char *) tmppath + 1);
 
 
 
 
        // Parse filename off the end of the supplied path
        // Parse filename off the end of the supplied path
        p = tmppath;
        p = tmppath;
 
 
        while (*(p++));
        while (*(p++));
 
 
 
 
        p--;
        p--;
 
 
        while (p > tmppath && *p != DIR_SEPARATOR) // larwe 9/16/06 ">=" to ">" bugfix
        while (p > tmppath && *p != DIR_SEPARATOR) // larwe 9/16/06 ">=" to ">" bugfix
                p--;
                p--;
 
 
        if (*p == DIR_SEPARATOR)
        if (*p == DIR_SEPARATOR)
 
 
                p++;
                p++;
 
 
 
 
        DFS_CanonicalToDir(filename, p);
        DFS_CanonicalToDir(filename, p);
 
 
 
 
        if (p > tmppath)
        if (p > tmppath)
 
 
                p--;
                p--;
 
 
        if (*p == DIR_SEPARATOR || p == tmppath) // larwe 9/16/06 +"|| p == tmppath" bugfix
        if (*p == DIR_SEPARATOR || p == tmppath) // larwe 9/16/06 +"|| p == tmppath" bugfix
                *p = 0;
                *p = 0;
 
 
 
 
        // At this point, if our path was MYDIR/MYDIR2/FILE.EXT, filename = "FILE    EXT" and
        // At this point, if our path was MYDIR/MYDIR2/FILE.EXT, filename = "FILE    EXT" and
        // tmppath = "MYDIR/MYDIR2".
        // tmppath = "MYDIR/MYDIR2".
        di.scratch = scratch;
        di.scratch = scratch;
 
 
        if (DFS_OpenDir(volinfo, tmppath, &di))
        if (DFS_OpenDir(volinfo, tmppath, &di))
 
 
                return DFS_NOTFOUND;
                return DFS_NOTFOUND;
 
 
 
 
        while (!DFS_GetNext(volinfo, &di, &de)) {
        while (!DFS_GetNext(volinfo, &di, &de)) {
 
 
 
 
                if (!memcmp2(de.name, filename, 11)) {
                if (!memcmp2(de.name, filename, 11)) {
 
 
                        // You can't use this function call to open a directory.
                        // You can't use this function call to open a directory.
                        if (de.attr & ATTR_DIRECTORY)
                        if (de.attr & ATTR_DIRECTORY)
 
 
                                return DFS_NOTFOUND;
                                return DFS_NOTFOUND;
 
 
                        printf("get enxt \n");
                        printf("get enxt \n");
 
 
                        fileinfo->volinfo = volinfo;
                        fileinfo->volinfo = volinfo;
 
 
                        fileinfo->pointer = 0;
                        fileinfo->pointer = 0;
 
 
                        // The reason we store this extra info about the file is so that we can
                        // 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
                        // speedily update the file size, modification date, etc. on a file that is
                        // opened for writing.
                        // opened for writing.
                        if (di.currentcluster == 0)
                        if (di.currentcluster == 0)
                                fileinfo->dirsector = volinfo->rootdir + di.currentsector;
 
 
fileinfo->dirsector =
 
                                    volinfo->rootdir + di.currentsector;
 
 
                        else
                        else
                                fileinfo->dirsector = volinfo->dataarea + ((di.currentcluster - 2) * volinfo->secperclus) + di.currentsector;
 
 
fileinfo->dirsector =
 
                                    volinfo->dataarea +
 
                                    ((di.currentcluster -
 
                                      2) * volinfo->secperclus) +
 
                                    di.currentsector;
 
 
                        fileinfo->diroffset = di.currententry - 1;
                        fileinfo->diroffset = di.currententry - 1;
 
 
                        if (volinfo->filesystem == FAT32) {
                        if (volinfo->filesystem == FAT32) {
                                fileinfo->cluster = (unsigned long int) de.startclus_l_l |
 
                                  ((unsigned long int) de.startclus_l_h) << 8 |
fileinfo->cluster =
                                  ((unsigned long int) de.startclus_h_l) << 16 |
                                    (unsigned long int)de.
                                  ((unsigned long int) de.startclus_h_h) << 24;
                                    startclus_l_l |
 
((unsigned long int)de.
 
                                                      startclus_l_h) << 8 |
 
 
 
((unsigned long int)de.
 
                                      startclus_h_l) << 16 |
 
((unsigned long
 
                                                                int)de.
 
                                                               startclus_h_h) <<
 
                                    24;
 
 
                        }
                        }
 
 
                        else {
                        else {
                                fileinfo->cluster = (unsigned long int) de.startclus_l_l |
 
                                  ((unsigned long int) de.startclus_l_h) << 8;
fileinfo->cluster =
 
                                    (unsigned long int)de.
 
                                    startclus_l_l |
 
((unsigned long int)de.
 
                                                      startclus_l_h) << 8;
 
 
                        }
                        }
                        fileinfo->firstcluster = fileinfo->cluster;
                        fileinfo->firstcluster = fileinfo->cluster;
                        fileinfo->filelen = (unsigned long int) de.filesize_0 |
 
                          ((unsigned long int) de.filesize_1) << 8 |
fileinfo->filelen =
                          ((unsigned long int) de.filesize_2) << 16 |
                            (unsigned long int)de.
 
                            filesize_0 |
 
((unsigned long int)de.
 
                                           filesize_1) << 8 |
 
((unsigned long
 
                                                                 int)de.
 
                                                                filesize_2) <<
 
                            16 |
                          ((unsigned long int) de.filesize_3) << 24;
                          ((unsigned long int) de.filesize_3) << 24;
 
 
 
 
                        return DFS_OK;
                        return DFS_OK;
 
 
                }
                }
 
 
        }
        }
 
 
 
 
        // At this point, we KNOW the file does not exist. If the file was opened
        // At this point, we KNOW the file does not exist. If the file was opened
        // with write access, we can create it.
        // with write access, we can create it.
        if (mode & DFS_WRITE) {
        if (mode & DFS_WRITE) {
 
 
                unsigned long int cluster, temp;
                unsigned long int cluster, temp;
 
 
 
 
                // Locate or create a directory entry for this file
                // Locate or create a directory entry for this file
                if (DFS_OK != DFS_GetFreeDirEnt(volinfo, tmppath, &di, &de))
                if (DFS_OK != DFS_GetFreeDirEnt(volinfo, tmppath, &di, &de))
 
 
                        return DFS_ERRMISC;
                        return DFS_ERRMISC;
 
 
 
 
                // put sane values in the directory entry
                // put sane values in the directory entry
                memset(&de, 0, sizeof(de));
                memset(&de, 0, sizeof(de));
 
 
                memcpy(de.name, filename, 11);
                memcpy(de.name, filename, 11);
 
 
                de.crttime_l = 0x20;    // 01:01:00am, Jan 1, 2006.
                de.crttime_l = 0x20;    // 01:01:00am, Jan 1, 2006.
                de.crttime_h = 0x08;
                de.crttime_h = 0x08;
 
 
                de.crtdate_l = 0x11;
                de.crtdate_l = 0x11;
 
 
                de.crtdate_h = 0x34;
                de.crtdate_h = 0x34;
 
 
                de.lstaccdate_l = 0x11;
                de.lstaccdate_l = 0x11;
 
 
                de.lstaccdate_h = 0x34;
                de.lstaccdate_h = 0x34;
 
 
                de.wrttime_l = 0x20;
                de.wrttime_l = 0x20;
 
 
                de.wrttime_h = 0x08;
                de.wrttime_h = 0x08;
 
 
                de.wrtdate_l = 0x11;
                de.wrtdate_l = 0x11;
 
 
                de.wrtdate_h = 0x34;
                de.wrtdate_h = 0x34;
 
 
 
 
                // allocate a starting cluster for the directory entry
                // allocate a starting cluster for the directory entry
                cluster = DFS_GetFreeFAT(volinfo, scratch);
                cluster = DFS_GetFreeFAT(volinfo, scratch);
 
 
 
 
                de.startclus_l_l = cluster & 0xff;
                de.startclus_l_l = cluster & 0xff;
 
 
                de.startclus_l_h = (cluster & 0xff00) >> 8;
                de.startclus_l_h = (cluster & 0xff00) >> 8;
 
 
                de.startclus_h_l = (cluster & 0xff0000) >> 16;
                de.startclus_h_l = (cluster & 0xff0000) >> 16;
 
 
                de.startclus_h_h = (cluster & 0xff000000) >> 24;
                de.startclus_h_h = (cluster & 0xff000000) >> 24;
 
 
 
 
                // update FILEINFO for our caller's sake
                // update FILEINFO for our caller's sake
                fileinfo->volinfo = volinfo;
                fileinfo->volinfo = volinfo;
 
 
                fileinfo->pointer = 0;
                fileinfo->pointer = 0;
 
 
                // The reason we store this extra info about the file is so that we can
                // 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
                // speedily update the file size, modification date, etc. on a file that is
                // opened for writing.
                // opened for writing.
                if (di.currentcluster == 0)
                if (di.currentcluster == 0)
                        fileinfo->dirsector = volinfo->rootdir + di.currentsector;
 
 
fileinfo->dirsector =
 
                            volinfo->rootdir + di.currentsector;
 
 
                else
                else
                        fileinfo->dirsector = volinfo->dataarea + ((di.currentcluster - 2) * volinfo->secperclus) + di.currentsector;
 
 
fileinfo->dirsector =
 
                            volinfo->dataarea +
 
                            ((di.currentcluster - 2) * volinfo->secperclus) +
 
                            di.currentsector;
 
 
                fileinfo->diroffset = di.currententry - 1;
                fileinfo->diroffset = di.currententry - 1;
 
 
                fileinfo->cluster = cluster;
                fileinfo->cluster = cluster;
 
 
                fileinfo->firstcluster = cluster;
                fileinfo->firstcluster = cluster;
 
 
                fileinfo->filelen = 0;
                fileinfo->filelen = 0;
 
 
 
 
                // write the directory entry
                // write the directory entry
                // note that we no longer have the sector containing the directory entry,
                // note that we no longer have the sector containing the directory entry,
                // tragically, so we have to re-read it
                // tragically, so we have to re-read it
                if (DFS_ReadSector(volinfo->unit, scratch, fileinfo->dirsector, 1))
                    if (DFS_ReadSector
 
                        (volinfo->unit, scratch, fileinfo->dirsector, 1))
 
 
                        return DFS_ERRMISC;
                        return DFS_ERRMISC;
                memcpy(&(((PDIRENT) scratch)[di.currententry-1]), &de, sizeof(DIRENT));
 
                if (DFS_WriteSector(volinfo->unit, scratch, fileinfo->dirsector, 1))
memcpy(&(((PDIRENT) scratch)[di.currententry - 1]), &de,
 
                        sizeof(DIRENT));
 
 
 
if (DFS_WriteSector
 
                     (volinfo->unit, scratch, fileinfo->dirsector, 1))
 
 
                        return DFS_ERRMISC;
                        return DFS_ERRMISC;
 
 
 
 
                // Mark newly allocated cluster as end of chain                 
                // Mark newly allocated cluster as end of chain                 
                switch(volinfo->filesystem) {
                switch(volinfo->filesystem) {
                        case FAT12:             cluster = 0xff8;        break;
 
                        case FAT16:             cluster = 0xfff8;       break;
case FAT12:
                        case FAT32:             cluster = 0x0ffffff8;   break;
                        cluster = 0xff8;
                        default:                return DFS_ERRMISC;
                        break;
 
 
 
case FAT16:
 
                        cluster = 0xfff8;
 
                        break;
 
 
 
case FAT32:
 
                        cluster = 0x0ffffff8;
 
                        break;
 
 
 
default:
 
                        return DFS_ERRMISC;
 
 
                }
                }
 
 
                temp = 0;
                temp = 0;
                DFS_SetFAT(volinfo, scratch, &temp, fileinfo->cluster, cluster);
 
 
DFS_SetFAT(volinfo, scratch, &temp, fileinfo->cluster,
 
                            cluster);
 
 
 
 
                return DFS_OK;
                return DFS_OK;
 
 
        }
        }
 
 
 
 
        return DFS_NOTFOUND;
        return DFS_NOTFOUND;
 
 
}
}
 
 
 
 
 
 
/*
/*
        Read an open file
        Read an open file
        You must supply a prepopulated FILEINFO as provided by DFS_OpenFile, and a
        You must supply a prepopulated FILEINFO as provided by DFS_OpenFile, and a
        pointer to a SECTOR_SIZE scratch buffer.
        pointer to a SECTOR_SIZE scratch buffer.
        Note that returning DFS_EOF is not an error condition. This function updates the
        Note that returning DFS_EOF is not an error condition. This function updates the
        successcount field with the number of bytes actually read.
        successcount field with the number of bytes actually read.
*/
*/
unsigned long int DFS_ReadFile(PFILEINFO fileinfo, unsigned char *scratch, unsigned char *buffer, unsigned long int *successcount, unsigned long int len)
unsigned long int DFS_ReadFile(PFILEINFO fileinfo, unsigned char *scratch,
 
                               unsigned char *buffer,
 
                               unsigned long int *successcount,
 
                               unsigned long int len)
{
{
 
 
        unsigned long int remain;
        unsigned long int remain;
 
 
        unsigned long int result = DFS_OK;
        unsigned long int result = DFS_OK;
 
 
        unsigned long int sector;
        unsigned long int sector;
 
 
        unsigned long int bytesread;
        unsigned long int bytesread;
 
 
 
 
        // Don't try to read past EOF
        // Don't try to read past EOF
        if (len > fileinfo->filelen - fileinfo->pointer)
        if (len > fileinfo->filelen - fileinfo->pointer)
 
 
                len = fileinfo->filelen - fileinfo->pointer;
                len = fileinfo->filelen - fileinfo->pointer;
 
 
 
 
        remain = len;
        remain = len;
 
 
        *successcount = 0;
        *successcount = 0;
 
 
 
 
        while (remain && result == DFS_OK) {
        while (remain && result == DFS_OK) {
 
 
                // This is a bit complicated. The sector we want to read is addressed at a cluster
                // 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
                // granularity by the fileinfo->cluster member. The file pointer tells us how many
                // extra sectors to add to that number.
                // extra sectors to add to that number.
                sector = fileinfo->volinfo->dataarea +
                sector = fileinfo->volinfo->dataarea +
                  ((fileinfo->cluster - 2) * fileinfo->volinfo->secperclus) +
                  ((fileinfo->cluster - 2) * fileinfo->volinfo->secperclus) +
                  div(div(fileinfo->pointer,fileinfo->volinfo->secperclus * SECTOR_SIZE).rem, SECTOR_SIZE).quot;
 
 
div(div
 
                         (fileinfo->pointer,
 
                          fileinfo->volinfo->secperclus * SECTOR_SIZE).rem,
 
                         SECTOR_SIZE).quot;
 
 
 
 
                // Case 1 - File pointer is not on a sector boundary
                // Case 1 - File pointer is not on a sector boundary
                if (div(fileinfo->pointer, SECTOR_SIZE).rem) {
                if (div(fileinfo->pointer, SECTOR_SIZE).rem) {
 
 
 
 
            unsigned short tempreadsize;
            unsigned short tempreadsize;
 
 
 
 
 
 
                        // We always have to go through scratch in this case
                        // We always have to go through scratch in this case
                        result = DFS_ReadSector(fileinfo->volinfo->unit, scratch, sector, 1);
                            result =
 
                            DFS_ReadSector(fileinfo->volinfo->unit, scratch,
 
                                           sector, 1);
 
 
 
 
                        // This is the number of bytes that we actually care about in the sector
                        // This is the number of bytes that we actually care about in the sector
                        // just read.
                        // just read.
 
 
                        tempreadsize = SECTOR_SIZE - (div(fileinfo->pointer, SECTOR_SIZE).rem);
tempreadsize =
 
                            SECTOR_SIZE -
 
                            (div(fileinfo->pointer, SECTOR_SIZE).rem);
 
 
 
 
 
 
            // Case 1A - We want the entire remainder of the sector. After this
            // 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
                        // 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.
                        // boundary, which allows us to go through the optimal path 2A below.
                        if (remain >= tempreadsize) {
                        if (remain >= tempreadsize) {
                                memcpy(buffer, scratch + (SECTOR_SIZE - tempreadsize), tempreadsize);
 
 
memcpy(buffer,
 
                                        scratch + (SECTOR_SIZE - tempreadsize),
 
                                        tempreadsize);
 
 
                                bytesread = tempreadsize;
                                bytesread = tempreadsize;
 
 
                                buffer += tempreadsize;
                                buffer += tempreadsize;
 
 
                                fileinfo->pointer += tempreadsize;
                                fileinfo->pointer += tempreadsize;
 
 
                                remain -= tempreadsize;
                                remain -= tempreadsize;
 
 
                        }
                        }
 
 
                        // Case 1B - This read concludes the file read operation
                        // Case 1B - This read concludes the file read operation
                        else {
                        else {
                                memcpy(buffer, scratch + (SECTOR_SIZE - tempreadsize), remain);
 
 
memcpy(buffer,
 
                                        scratch + (SECTOR_SIZE - tempreadsize),
 
                                        remain);
 
 
 
 
                                buffer += remain;
                                buffer += remain;
 
 
                                fileinfo->pointer += remain;
                                fileinfo->pointer += remain;
 
 
                                bytesread = remain;
                                bytesread = remain;
 
 
                                remain = 0;
                                remain = 0;
 
 
                        }
                        }
 
 
                }
                }
 
 
                // Case 2 - File pointer is on sector boundary
                // Case 2 - File pointer is on sector boundary
                else {
                else {
 
 
 
 
                        // Case 2A - We have at least one more full sector to read and don't have
                        // 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
                        // 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
                        // 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
                        // 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
                        // 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
                        // 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).
                        // [large] read requests would be able to go a cluster at a time).
                        if (remain >= SECTOR_SIZE) {
                        if (remain >= SECTOR_SIZE) {
 
 
                                result = DFS_ReadSector(fileinfo->volinfo->unit, buffer, sector, 1);
 
 
result =
 
                                    DFS_ReadSector(fileinfo->volinfo->unit,
 
                                                   buffer, sector, 1);
 
 
 
 
                remain -= SECTOR_SIZE;
                remain -= SECTOR_SIZE;
 
 
 
 
                                buffer += SECTOR_SIZE;
                                buffer += SECTOR_SIZE;
 
 
 
 
                                fileinfo->pointer += SECTOR_SIZE;
                                fileinfo->pointer += SECTOR_SIZE;
 
 
 
 
                                bytesread = SECTOR_SIZE;
                                bytesread = SECTOR_SIZE;
 
 
 
 
                        }
                        }
 
 
                        // Case 2B - We are only reading a partial sector
                        // Case 2B - We are only reading a partial sector
                        else {
                        else {
 
 
                                result = DFS_ReadSector(fileinfo->volinfo->unit, scratch, sector, 1);
 
 
result =
 
                                    DFS_ReadSector(fileinfo->volinfo->unit,
 
                                                   scratch, sector, 1);
 
 
                                memcpy(buffer, scratch, remain);
                                memcpy(buffer, scratch, remain);
 
 
                                buffer += remain;
                                buffer += remain;
 
 
                                fileinfo->pointer += remain;
                                fileinfo->pointer += remain;
 
 
                                bytesread = remain;
                                bytesread = remain;
 
 
                                remain = 0;
                                remain = 0;
 
 
                        }
                        }
 
 
                }
                }
 
 
 
 
                *successcount += bytesread;
                *successcount += bytesread;
 
 
 
 
 
 
                // check to see if we stepped over a cluster boundary
                // check to see if we stepped over a cluster boundary
                if (div(fileinfo->pointer - bytesread, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot !=
                    if (div
                  div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot) {
                        (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
                        // An act of minor evil - we use bytesread as a scratch integer, knowing that
                        // its value is not used after updating *successcount above
                        // its value is not used after updating *successcount above
 
 
            bytesread = 0;
            bytesread = 0;
 
 
            if (((fileinfo->volinfo->filesystem == FAT12) && (fileinfo->cluster >= 0xff8)) ||
 
                          ((fileinfo->volinfo->filesystem == FAT16) && (fileinfo->cluster >= 0xfff8)) ||
if (((fileinfo->volinfo->filesystem == FAT12)
                          ((fileinfo->volinfo->filesystem == FAT32) && (fileinfo->cluster >= 0x0ffffff8)))
                               && (fileinfo->cluster >= 0xff8))
 
                              ||
 
((fileinfo->volinfo->filesystem == FAT16)
 
                                   && (fileinfo->cluster >= 0xfff8))
 
                              ||
 
((fileinfo->volinfo->filesystem == FAT32)
 
                                   && (fileinfo->cluster >= 0x0ffffff8)))
 
 
                                result = DFS_EOF;
                                result = DFS_EOF;
 
 
                        else
                        else
                                fileinfo->cluster = DFS_GetFAT(fileinfo->volinfo, scratch, &bytesread, fileinfo->cluster);
 
 
fileinfo->cluster =
 
                                    DFS_GetFAT(fileinfo->volinfo, scratch,
 
                                               &bytesread, fileinfo->cluster);
 
 
                }
                }
 
 
        }
        }
 
 
 
 
 
 
        return result;
        return result;
 
 
}
}
 
 
 
 
 
 
/*
/*
        Seek file pointer to a given position
        Seek file pointer to a given position
        This function does not return status - refer to the fileinfo->pointer value
        This function does not return status - refer to the fileinfo->pointer value
        to see where the pointer wound up.
        to see where the pointer wound up.
        Requires a SECTOR_SIZE scratch buffer
        Requires a SECTOR_SIZE scratch buffer
*/
*/
void DFS_Seek(PFILEINFO fileinfo, unsigned long int offset, unsigned char *scratch)
void DFS_Seek(PFILEINFO fileinfo, unsigned long int offset,
 
              unsigned char *scratch)
{
{
 
 
        unsigned long int tempint;
        unsigned long int tempint;
 
 
 
 
        // larwe 9/16/06 bugfix split case 0a/0b and changed fallthrough handling
        // larwe 9/16/06 bugfix split case 0a/0b and changed fallthrough handling
        // Case 0a - Return immediately for degenerate case
        // Case 0a - Return immediately for degenerate case
        if (offset == fileinfo->pointer) {
        if (offset == fileinfo->pointer) {
 
 
                return;
                return;
 
 
        }
        }
 
 
 
 
        // Case 0b - Don't allow the user to seek past the end of the file
        // Case 0b - Don't allow the user to seek past the end of the file
        if (offset > fileinfo->filelen) {
        if (offset > fileinfo->filelen) {
 
 
                offset = fileinfo->filelen;
                offset = fileinfo->filelen;
 
 
                // NOTE NO RETURN HERE!
                // NOTE NO RETURN HERE!
        }
        }
 
 
 
 
        // Case 1 - Simple rewind to start
        // Case 1 - Simple rewind to start
        // Note _intentional_ fallthrough from Case 0b above
        // Note _intentional_ fallthrough from Case 0b above
        if (offset == 0) {
        if (offset == 0) {
 
 
                fileinfo->cluster = fileinfo->firstcluster;
                fileinfo->cluster = fileinfo->firstcluster;
 
 
                fileinfo->pointer = 0;
                fileinfo->pointer = 0;
 
 
                return;         // larwe 9/16/06 +1 bugfix
                return;         // larwe 9/16/06 +1 bugfix
        }
        }
 
 
        // Case 2 - Seeking backwards. Need to reset and seek forwards
        // Case 2 - Seeking backwards. Need to reset and seek forwards
        else if (offset < fileinfo->pointer) {
        else if (offset < fileinfo->pointer) {
 
 
                fileinfo->cluster = fileinfo->firstcluster;
                fileinfo->cluster = fileinfo->firstcluster;
 
 
                fileinfo->pointer = 0;
                fileinfo->pointer = 0;
 
 
                // NOTE NO RETURN HERE!
                // NOTE NO RETURN HERE!
        }
        }
 
 
 
 
        // Case 3 - Seeking forwards
        // Case 3 - Seeking forwards
        // Note _intentional_ fallthrough from Case 2 above
        // Note _intentional_ fallthrough from Case 2 above
 
 
        // Case 3a - Seek size does not cross cluster boundary - 
        // Case 3a - Seek size does not cross cluster boundary - 
        // very simple case
        // very simple case
        // larwe 9/16/06 changed .rem to .quot in both div calls, bugfix
        // larwe 9/16/06 changed .rem to .quot in both div calls, bugfix
        if (div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot ==
            if (div
          div(fileinfo->pointer + offset, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot) {
                (fileinfo->pointer,
 
                 fileinfo->volinfo->secperclus * SECTOR_SIZE).quot ==
 
 
 
div(fileinfo->pointer + offset,
 
                     fileinfo->volinfo->secperclus * SECTOR_SIZE).quot) {
 
 
                fileinfo->pointer = offset;
                fileinfo->pointer = offset;
 
 
        }
        }
 
 
        // Case 3b - Seeking across cluster boundary(ies)
        // Case 3b - Seeking across cluster boundary(ies)
        else {
        else {
 
 
                // round file pointer down to cluster boundary
                // round file pointer down to cluster boundary
                fileinfo->pointer = div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot *
                    fileinfo->pointer =
 
                    div(fileinfo->pointer,
 
                        fileinfo->volinfo->secperclus * SECTOR_SIZE).quot *
 
 
                  fileinfo->volinfo->secperclus * SECTOR_SIZE;
                  fileinfo->volinfo->secperclus * SECTOR_SIZE;
 
 
 
 
                // seek by clusters
                // seek by clusters
                // larwe 9/30/06 bugfix changed .rem to .quot in both div calls
                // larwe 9/30/06 bugfix changed .rem to .quot in both div calls
                while (div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot !=
                    while (div
                  div(fileinfo->pointer + offset, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot) {
                           (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);
 
 
                        fileinfo->cluster = DFS_GetFAT(fileinfo->volinfo, scratch, &tempint, fileinfo->cluster);
 
                        // Abort if there was an error
                        // Abort if there was an error
                        if (fileinfo->cluster == 0x0ffffff7) {
                        if (fileinfo->cluster == 0x0ffffff7) {
 
 
                                fileinfo->pointer = 0;
                                fileinfo->pointer = 0;
 
 
                                fileinfo->cluster = fileinfo->firstcluster;
                                fileinfo->cluster = fileinfo->firstcluster;
 
 
                                return;
                                return;
 
 
                        }
                        }
                        fileinfo->pointer += SECTOR_SIZE * fileinfo->volinfo->secperclus;
 
 
fileinfo->pointer +=
 
                            SECTOR_SIZE * fileinfo->volinfo->secperclus;
 
 
                }
                }
 
 
 
 
                // since we know the cluster is right, we have no more work to do
                // since we know the cluster is right, we have no more work to do
                fileinfo->pointer = offset;
                fileinfo->pointer = offset;
 
 
        }
        }
 
 
}
}
 
 
 
 
 
 
/*
/*
        Delete a file
        Delete a file
        scratch must point to a sector-sized buffer
        scratch must point to a sector-sized buffer
*/
*/
unsigned long int DFS_UnlinkFile(PVOLINFO volinfo, unsigned char *path, unsigned char *scratch)
unsigned long int DFS_UnlinkFile(PVOLINFO volinfo, unsigned char *path,
 
                                 unsigned char *scratch)
{
{
 
 
        PDIRENT de = (PDIRENT) scratch;
        PDIRENT de = (PDIRENT) scratch;
 
 
        FILEINFO fi;
        FILEINFO fi;
 
 
        unsigned long int cache = 0;
        unsigned long int cache = 0;
 
 
        unsigned long int tempclus;
        unsigned long int tempclus;
 
 
 
 
        // DFS_OpenFile gives us all the information we need to delete it
        // DFS_OpenFile gives us all the information we need to delete it
        if (DFS_OK != DFS_OpenFile(volinfo, path, DFS_READ, scratch, &fi))
        if (DFS_OK != DFS_OpenFile(volinfo, path, DFS_READ, scratch, &fi))
 
 
                return DFS_NOTFOUND;
                return DFS_NOTFOUND;
 
 
 
 
        // First, read the directory sector and delete that entry
        // First, read the directory sector and delete that entry
        if (DFS_ReadSector(volinfo->unit, scratch, fi.dirsector, 1))
        if (DFS_ReadSector(volinfo->unit, scratch, fi.dirsector, 1))
 
 
                return DFS_ERRMISC;
                return DFS_ERRMISC;
 
 
        ((PDIRENT) scratch)[fi.diroffset].name[0] = 0xe5;
        ((PDIRENT) scratch)[fi.diroffset].name[0] = 0xe5;
 
 
        if (DFS_WriteSector(volinfo->unit, scratch, fi.dirsector, 1))
        if (DFS_WriteSector(volinfo->unit, scratch, fi.dirsector, 1))
 
 
                return DFS_ERRMISC;
                return DFS_ERRMISC;
 
 
 
 
        // Now follow the cluster chain to free the file space
        // Now follow the cluster chain to free the file space
        while (!((volinfo->filesystem == FAT12 && fi.firstcluster >= 0x0ff7) ||
            while (!
          (volinfo->filesystem == FAT16 && fi.firstcluster >= 0xfff7) ||
                   ((volinfo->filesystem == FAT12 && fi.firstcluster >= 0x0ff7)
          (volinfo->filesystem == FAT32 && fi.firstcluster >= 0x0ffffff7))) {
                    ||
 
(volinfo->filesystem == FAT16
 
                         && fi.firstcluster >= 0xfff7)
 
                    ||
 
(volinfo->filesystem == FAT32
 
                         && fi.firstcluster >= 0x0ffffff7))) {
 
 
                tempclus = fi.firstcluster;
                tempclus = fi.firstcluster;
 
 
                fi.firstcluster = DFS_GetFAT(volinfo, scratch, &cache, fi.firstcluster);
 
 
fi.firstcluster =
 
                    DFS_GetFAT(volinfo, scratch, &cache, fi.firstcluster);
 
 
                DFS_SetFAT(volinfo, scratch, &cache, tempclus, 0);
                DFS_SetFAT(volinfo, scratch, &cache, tempclus, 0);
 
 
 
 
        }
        }
 
 
        return DFS_OK;
        return DFS_OK;
 
 
}
}
 
 
 
 
 
 
 
 
/*
/*
        Write an open file
        Write an open file
        You must supply a prepopulated FILEINFO as provided by DFS_OpenFile, and a
        You must supply a prepopulated FILEINFO as provided by DFS_OpenFile, and a
        pointer to a SECTOR_SIZE scratch buffer.
        pointer to a SECTOR_SIZE scratch buffer.
        This function updates the successcount field with the number of bytes actually written.
        This function updates the successcount field with the number of bytes actually written.
*/
*/
unsigned long int DFS_WriteFile(PFILEINFO fileinfo, unsigned char *scratch, unsigned char *buffer, unsigned long int *successcount, unsigned long int len)
unsigned long int DFS_WriteFile(PFILEINFO fileinfo, unsigned char *scratch,
 
                                unsigned char *buffer,
 
                                unsigned long int *successcount,
 
                                unsigned long int len)
{
{
 
 
        unsigned long int remain;
        unsigned long int remain;
 
 
        unsigned long int result = DFS_OK;
        unsigned long int result = DFS_OK;
 
 
        unsigned long int sector;
        unsigned long int sector;
 
 
        unsigned long int byteswritten;
        unsigned long int byteswritten;
 
 
 
 
        // Don't allow writes to a file that's open as readonly
        // Don't allow writes to a file that's open as readonly
        if (!(fileinfo->mode & DFS_WRITE))
        if (!(fileinfo->mode & DFS_WRITE))
 
 
                return DFS_ERRMISC;
                return DFS_ERRMISC;
 
 
 
 
        remain = len;
        remain = len;
 
 
        *successcount = 0;
        *successcount = 0;
 
 
 
 
        while (remain && result == DFS_OK) {
        while (remain && result == DFS_OK) {
 
 
                // This is a bit complicated. The sector we want to read is addressed at a cluster
                // 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
                // granularity by the fileinfo->cluster member. The file pointer tells us how many
                // extra sectors to add to that number.
                // extra sectors to add to that number.
                sector = fileinfo->volinfo->dataarea +
                sector = fileinfo->volinfo->dataarea +
                  ((fileinfo->cluster - 2) * fileinfo->volinfo->secperclus) +
                  ((fileinfo->cluster - 2) * fileinfo->volinfo->secperclus) +
                  div(div(fileinfo->pointer,fileinfo->volinfo->secperclus * SECTOR_SIZE).rem, SECTOR_SIZE).quot;
 
 
div(div
 
                         (fileinfo->pointer,
 
                          fileinfo->volinfo->secperclus * SECTOR_SIZE).rem,
 
                         SECTOR_SIZE).quot;
 
 
 
 
                // Case 1 - File pointer is not on a sector boundary
                // Case 1 - File pointer is not on a sector boundary
                if (div(fileinfo->pointer, SECTOR_SIZE).rem) {
                if (div(fileinfo->pointer, SECTOR_SIZE).rem) {
 
 
                        unsigned short tempsize;
                        unsigned short tempsize;
 
 
            printf("CASE 1 \n");
            printf("CASE 1 \n");
 
 
                        // We always have to go through scratch in this case
                        // We always have to go through scratch in this case
                        result = DFS_ReadSector(fileinfo->volinfo->unit, scratch, sector, 1);
                            result =
 
                            DFS_ReadSector(fileinfo->volinfo->unit, scratch,
 
                                           sector, 1);
 
 
 
 
                        // This is the number of bytes that we don't want to molest in the
                        // This is the number of bytes that we don't want to molest in the
                        // scratch sector just read.
                        // scratch sector just read.
                        tempsize = div(fileinfo->pointer, SECTOR_SIZE).rem;
                        tempsize = div(fileinfo->pointer, SECTOR_SIZE).rem;
 
 
 
 
                        // Case 1A - We are writing the entire remainder of the sector. After
                        // 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
                        // this point, all passes through the read loop will be aligned on a
                        // sector boundary, which allows us to go through the optimal path
                        // sector boundary, which allows us to go through the optimal path
                        // 2A below.
                        // 2A below.
                        if (remain >= SECTOR_SIZE - tempsize) {
                        if (remain >= SECTOR_SIZE - tempsize) {
                                memcpy(scratch + tempsize, buffer, SECTOR_SIZE - tempsize);
 
 
memcpy(scratch + tempsize, buffer,
 
                                        SECTOR_SIZE - tempsize);
 
 
                                if (!result)
                                if (!result)
                                        result = DFS_WriteSector(fileinfo->volinfo->unit, scratch, sector, 1);
 
 
result =
 
                                            DFS_WriteSector(fileinfo->volinfo->
 
                                                            unit, scratch,
 
                                                            sector, 1);
 
 
 
 
                                byteswritten = SECTOR_SIZE - tempsize;
                                byteswritten = SECTOR_SIZE - tempsize;
 
 
                                buffer += SECTOR_SIZE - tempsize;
                                buffer += SECTOR_SIZE - tempsize;
 
 
                                fileinfo->pointer += SECTOR_SIZE - tempsize;
                                fileinfo->pointer += SECTOR_SIZE - tempsize;
 
 
                                if (fileinfo->filelen < fileinfo->pointer) {
                                if (fileinfo->filelen < fileinfo->pointer) {
 
 
                                        fileinfo->filelen = fileinfo->pointer;
                                        fileinfo->filelen = fileinfo->pointer;
 
 
                                }
                                }
 
 
                                remain -= SECTOR_SIZE - tempsize;
                                remain -= SECTOR_SIZE - tempsize;
 
 
                        }
                        }
 
 
                        // Case 1B - This concludes the file write operation
                        // Case 1B - This concludes the file write operation
                        else {
                        else {
 
 
                  printf("CASE 1B \n");
                  printf("CASE 1B \n");
 
 
                                memcpy(scratch + tempsize, buffer, remain);
                                memcpy(scratch + tempsize, buffer, remain);
 
 
                                if (!result)
                                if (!result)
                                        result = DFS_WriteSector(fileinfo->volinfo->unit, scratch, sector, 1);
 
 
result =
 
                                            DFS_WriteSector(fileinfo->volinfo->
 
                                                            unit, scratch,
 
                                                            sector, 1);
 
 
 
 
                                buffer += remain;
                                buffer += remain;
 
 
                                fileinfo->pointer += remain;
                                fileinfo->pointer += remain;
 
 
                                if (fileinfo->filelen < fileinfo->pointer) {
                                if (fileinfo->filelen < fileinfo->pointer) {
 
 
                                        fileinfo->filelen = fileinfo->pointer;
                                        fileinfo->filelen = fileinfo->pointer;
 
 
                                }
                                }
 
 
                                byteswritten = remain;
                                byteswritten = remain;
 
 
                                remain = 0;
                                remain = 0;
 
 
                        }
                        }
 
 
                } // case 1
                } // case 1
                // Case 2 - File pointer is on sector boundary
                // Case 2 - File pointer is on sector boundary
                else {
                else {
 
 
              printf("CASE 2 \n");
              printf("CASE 2 \n");
 
 
                        // Case 2A - We have at least one more full sector to write and don't have
                        // 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
                        // 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
                        // write multiple sectors at a time, if you were thus inclined. Refer to
                        // similar notes in DFS_ReadFile.
                        // similar notes in DFS_ReadFile.
                        if (remain >= SECTOR_SIZE) {
                        if (remain >= SECTOR_SIZE) {
                                result = DFS_WriteSector(fileinfo->volinfo->unit, buffer, sector, 1);
 
 
result =
 
                                    DFS_WriteSector(fileinfo->volinfo->unit,
 
                                                    buffer, sector, 1);
 
 
                                remain -= SECTOR_SIZE;
                                remain -= SECTOR_SIZE;
 
 
                                buffer += SECTOR_SIZE;
                                buffer += SECTOR_SIZE;
 
 
                                fileinfo->pointer += SECTOR_SIZE;
                                fileinfo->pointer += SECTOR_SIZE;
 
 
                                if (fileinfo->filelen < fileinfo->pointer) {
                                if (fileinfo->filelen < fileinfo->pointer) {
 
 
                                        fileinfo->filelen = fileinfo->pointer;
                                        fileinfo->filelen = fileinfo->pointer;
 
 
                                }
                                }
 
 
                                byteswritten = SECTOR_SIZE;
                                byteswritten = SECTOR_SIZE;
 
 
                        }
                        }
 
 
                        // Case 2B - We are only writing a partial sector and potentially need to
                        // Case 2B - We are only writing a partial sector and potentially need to
                        // go through the scratch buffer.
                        // go through the scratch buffer.
                        else {
                        else {
 
 
                   printf("CASE 2B \n");
                   printf("CASE 2B \n");
 
 
                                // If the current file pointer is not yet at or beyond the file
                                // 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
                                // length, we are writing somewhere in the middle of the file and
                                // need to load the original sector to do a read-modify-write.
                                // need to load the original sector to do a read-modify-write.
                                if (fileinfo->pointer < fileinfo->filelen) {
                                if (fileinfo->pointer < fileinfo->filelen) {
                                        result = DFS_ReadSector(fileinfo->volinfo->unit, scratch, sector, 1);
 
 
result =
 
                                            DFS_ReadSector(fileinfo->volinfo->
 
                                                           unit, scratch,
 
                                                           sector, 1);
 
 
                                        if (!result) {
                                        if (!result) {
                                                memcpy(scratch, buffer, remain);
 
                                                result = DFS_WriteSector(fileinfo->volinfo->unit, scratch, sector, 1);
memcpy(scratch, buffer,
 
                                                        remain);
 
 
 
result =
 
                                                    DFS_WriteSector(fileinfo->
 
                                                                    volinfo->
 
                                                                    unit,
 
                                                                    scratch,
 
                                                                    sector, 1);
 
 
                                        }
                                        }
 
 
                                }
                                }
 
 
                                else {
                                else {
                                        result = DFS_WriteSector(fileinfo->volinfo->unit, buffer, sector, 1);
 
 
result =
 
                                            DFS_WriteSector(fileinfo->volinfo->
 
                                                            unit, buffer,
 
                                                            sector, 1);
 
 
                                }
                                }
 
 
 
 
                                buffer += remain;
                                buffer += remain;
 
 
                                fileinfo->pointer += remain;
                                fileinfo->pointer += remain;
 
 
                                if (fileinfo->filelen < fileinfo->pointer) {
                                if (fileinfo->filelen < fileinfo->pointer) {
 
 
                                        fileinfo->filelen = fileinfo->pointer;
                                        fileinfo->filelen = fileinfo->pointer;
 
 
                                }
                                }
 
 
                                byteswritten = remain;
                                byteswritten = remain;
 
 
                                remain = 0;
                                remain = 0;
 
 
                        }
                        }
 
 
                }
                }
 
 
 
 
                *successcount += byteswritten;
                *successcount += byteswritten;
 
 
        printf("Writen byte %d \n", *successcount );
        printf("Writen byte %d \n", *successcount );
 
 
                // check to see if we stepped over a cluster boundary
                // check to see if we stepped over a cluster boundary
                if (div(fileinfo->pointer - byteswritten, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot !=
                    if (div
                  div(fileinfo->pointer, fileinfo->volinfo->secperclus * SECTOR_SIZE).quot) {
                        (fileinfo->pointer - byteswritten,
 
                         fileinfo->volinfo->secperclus * SECTOR_SIZE).quot !=
 
 
 
div(fileinfo->pointer,
 
                             fileinfo->volinfo->secperclus *
 
                             SECTOR_SIZE).quot) {
 
 
                        unsigned long int lastcluster;
                        unsigned long int lastcluster;
 
 
 
 
                        // We've transgressed into another cluster. If we were already at EOF,
                        // We've transgressed into another cluster. If we were already at EOF,
                        // we need to allocate a new cluster.
                        // we need to allocate a new cluster.
                        // An act of minor evil - we use byteswritten as a scratch integer, knowing
                        // An act of minor evil - we use byteswritten as a scratch integer, knowing
                        // that its value is not used after updating *successcount above
                        // that its value is not used after updating *successcount above
                        byteswritten = 0;
                        byteswritten = 0;
 
 
 
 
                        lastcluster = fileinfo->cluster;
                        lastcluster = fileinfo->cluster;
                        fileinfo->cluster = DFS_GetFAT(fileinfo->volinfo, scratch, &byteswritten, fileinfo->cluster);
 
 
fileinfo->cluster =
 
                            DFS_GetFAT(fileinfo->volinfo, scratch,
 
                                       &byteswritten, fileinfo->cluster);
 
 
 
 
                        // Allocate a new cluster?
                        // Allocate a new cluster?
                        if (((fileinfo->volinfo->filesystem == FAT12) && (fileinfo->cluster >= 0xff8)) ||
                            if (((fileinfo->volinfo->filesystem == FAT12)
                          ((fileinfo->volinfo->filesystem == FAT16) && (fileinfo->cluster >= 0xfff8)) ||
                                 && (fileinfo->cluster >= 0xff8))
                          ((fileinfo->volinfo->filesystem == FAT32) && (fileinfo->cluster >= 0x0ffffff8))) {
                                ||
 
((fileinfo->volinfo->filesystem == FAT16)
 
                                     && (fileinfo->cluster >= 0xfff8))
 
                                ||
 
((fileinfo->volinfo->filesystem == FAT32)
 
                                     && (fileinfo->cluster >= 0x0ffffff8))) {
 
 
                                unsigned long int tempclus;
                                unsigned long int tempclus;
 
 
                                tempclus = DFS_GetFreeFAT(fileinfo->volinfo, scratch);
 
 
tempclus =
 
                                    DFS_GetFreeFAT(fileinfo->volinfo, scratch);
 
 
                                byteswritten = 0; // invalidate cache
                                byteswritten = 0; // invalidate cache
                                if (tempclus == 0x0ffffff7)
                                if (tempclus == 0x0ffffff7)
 
 
                                        return DFS_ERRMISC;
                                        return DFS_ERRMISC;
 
 
 
 
                                // Link new cluster onto file
                                // Link new cluster onto file
                                DFS_SetFAT(fileinfo->volinfo, scratch, &byteswritten, lastcluster, tempclus);
                                    DFS_SetFAT(fileinfo->volinfo, scratch,
 
                                               &byteswritten, lastcluster,
 
                                               tempclus);
 
 
                                fileinfo->cluster = tempclus;
                                fileinfo->cluster = tempclus;
 
 
 
 
                                // Mark newly allocated cluster as end of chain                 
                                // Mark newly allocated cluster as end of chain                 
                                switch(fileinfo->volinfo->filesystem) {
                                switch(fileinfo->volinfo->filesystem) {
                                        case FAT12:             tempclus = 0xff8;       break;
 
                                        case FAT16:             tempclus = 0xfff8;      break;
case FAT12:
                                        case FAT32:             tempclus = 0x0ffffff8;  break;
                                        tempclus = 0xff8;
                                        default:                return DFS_ERRMISC;
                                        break;
 
 
 
case FAT16:
 
                                        tempclus = 0xfff8;
 
                                        break;
 
 
 
case FAT32:
 
                                        tempclus = 0x0ffffff8;
 
                                        break;
 
 
 
default:
 
                                        return DFS_ERRMISC;
 
 
                                }
                                }
                                DFS_SetFAT(fileinfo->volinfo, scratch, &byteswritten, fileinfo->cluster, tempclus);
 
 
DFS_SetFAT(fileinfo->volinfo, scratch,
 
                                            &byteswritten, fileinfo->cluster,
 
                                            tempclus);
 
 
 
 
                                result = DFS_OK;
                                result = DFS_OK;
 
 
                        }
                        }
 
 
                        // No else clause is required.
                        // No else clause is required.
                }
                }
 
 
        }
        }
 
 
 
 
        // Update directory entry
        // Update directory entry
                if (DFS_ReadSector(fileinfo->volinfo->unit, scratch, fileinfo->dirsector, 1))
            if (DFS_ReadSector
 
                (fileinfo->volinfo->unit, scratch, fileinfo->dirsector, 1))
 
 
                        return DFS_ERRMISC;
                        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_0 =
                ((PDIRENT) scratch)[fileinfo->diroffset].filesize_2 = (fileinfo->filelen & 0xff0000) >> 16;
            fileinfo->filelen & 0xff;
                ((PDIRENT) scratch)[fileinfo->diroffset].filesize_3 = (fileinfo->filelen & 0xff000000) >> 24;
 
                if (DFS_WriteSector(fileinfo->volinfo->unit, scratch, fileinfo->dirsector, 1))
((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 DFS_ERRMISC;
 
 
        return result;
        return result;
 
 
}
}
 
 
 
 
 
 
int memcmp2(const void* s1, const void* s2,size_t n)
int memcmp2(const void* s1, const void* s2,size_t n)
{
{
 
 
    const unsigned char *p1 = s1, *p2 = s2;
    const unsigned char *p1 = s1, *p2 = s2;
 
 
    while(n--)
    while(n--)
 
 
        if( *p1 != *p2 )
        if( *p1 != *p2 )
 
 
            return *p1 - *p2;
            return *p1 - *p2;
 
 
        else
        else
            *p1++,*p2++;
 
 
*p1++, *p2++;
 
 
    return 0;
    return 0;
 
 
}
}
 
 
 
 
 
 
char *strcpy2(char *dest,  char* src)
char *strcpy2(char *dest,  char* src)
{
{
 
 
    char *ret = dest;
    char *ret = dest;
 
 
    while (*dest++ = *src++)
    while (*dest++ = *src++)
 
 
        ;
        ;
 
 
    return ret;
    return ret;
 
 
}
}
 
 
 
 
 
 
int strcmp2(const char* s1, const char* s2)
int strcmp2(const char* s1, const char* s2)
{
{
    while(*s1 && (*s1==*s2))
 
 
while (*s1 && (*s1 == *s2))
 
 
        s1++,s2++;
        s1++,s2++;
    return *(const unsigned char*)s1-*(const unsigned char*)s2;
 
 
return *(const unsigned char *)s1 - *(const unsigned char *)s2;
 
 
}
}
 
 
 No newline at end of file
 No newline at end of file

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.