Subversion Repositories openrisc_2011-10-31

/*

        DOSFS Embedded FAT-Compatible Filesystem

        (C) 2005 Lewin A.R.W. Edwards (sysadm@zws.com)

        You are permitted to modify and/or use this code in your own projects without

        payment of royalty, regardless of the license(s) you choose for those projects.

        You cannot re-copyright or restrict use of the code as released by Lewin Edwards.

*/

/*

  @2010, adam.edvardsson@orsoc.se

  Added local copy of the functions,

   div_t, memcmp2,strcpy2,strcmp2. The one from the string library is not comatible

*/

//#include <string.h>

//#include <stdlib.h>

//#include "or32_utils.h"

#include "dosfs.h"

#include "sdc.h"

#include "common.h"

#include "support.h"

#include "uart.h"

unsigned long int init_fat(VOLINFO * vis)

{

unsigned char sector[SECTOR_SIZE];

unsigned long int pstart, psize, i, fisz;

unsigned char pactive, ptype;

VOLINFO vi;

            //uart_init(DEFAULT_UART);

            printf("FAT INIT START\n");

memCardInit();

pstart = DFS_GetPtnStart(0, sector, 0, &pactive, &ptype, &psize);

if (pstart == 0xffffffff) {

printf("Cannot find first partition\n");

return -1;

}

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)) {

printf("Error getting volume information\n");

return -1;

}

*vis = vi;

}

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;

int i;

for (i = 0; i < count; i++) {

block_add = sector + i;

DBGA("\n readSector %u, block_addr %u \n", sector, block_add);

setup_bd_transfer(READ_OP, block_add, buffer);

if (finnish_bd_transfer() == FALSE)

return 0xff;

}

return 0;

}

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 char scr[SECTOR_SIZE];

block_add = sector;

DBGA("\n writeSector %u, block_addr2 %u \n", sector, block_add);

setup_bd_transfer(WRITE_OP, block_add, buffer);

if (finnish_bd_transfer() == FALSE) {

printf("TRANSACTION FAILED, Buffer %x \n", buffer);

                    //reset_card();  

                    // sd_wait_rsp();

                    // SD_REG(SD_SOFTWARE_RST)=1; 

                    //SD_REG(SD_SOFTWARE_RST)=0; 

DBGA("FREE BD TX/RX: 0x%x \n", SD_REG(BD_STATUS));

DBGA("TRY READ SECTOR \n");

setup_bd_transfer(READ_OP, 526571008, scr);

finnish_bd_transfer();

DBGA("PRINT test wreite to 526571008 \n");

setup_bd_transfer(WRITE_OP, 526571008, scr);

finnish_bd_transfer();

setup_bd_transfer(WRITE_OP, block_add, buffer);

if (finnish_bd_transfer() == FALSE) {

printf("TRANSACTION FAILED AGAIN!, Buffer %x \n",

                                buffer);

return 0xff;

}

}

return 0;

}

/*

        Get starting sector# of specified partition on drive #unit

        NOTE: This code ASSUMES an MBR on the disk.

        scratchsector should point to a SECTOR_SIZE scratch area

        Returns 0xffffffff for any error.

        If pactive is non-NULL, this function also returns the partition active flag.

        If pptype is non-NULL, this function also returns the partition type.

        If psize is non-NULL, this function also returns the partition size.

*/

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;

PMBR mbr = (PMBR) scratchsector;

            // DOS ptable supports maximum 4 partitions

            if (pnum > 3)

return DFS_ERRMISC;

            // Read MBR from target media

            if (DFS_ReadSector(unit, scratchsector, 0, 1)) {

return DFS_ERRMISC;

}

result = (unsigned long int)mbr->ptable[pnum].start_0 |

            (((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_3) << 24);

            //unsigned char              active;                 // 0x80 if partition active

            //unsigned char         start_h;                // starting head

            //unsigned char         start_cs_l;             // starting cylinder and sector (low 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("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)

*pactive = mbr->ptable[pnum].active;

if (pptype)

*pptype = mbr->ptable[pnum].type;

if (psize) {

*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_2) << 16) |

                    (((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);

}

return result;

}

ldiv_t ldiv(long int numer, long int denom)

{

ldiv_t result;

result.quot = numer / denom;

result.rem = numer % denom;

            /* The ANSI standard says that |QUOT| <= |NUMER / DENOM|, where

               NUMER / DENOM is to be computed in infinite precision.  In

               other words, we should always truncate the quotient towards

               zero, never -infinity.  Machine division and remainer may

               work either way when one or both of NUMER or DENOM is

               negative.  If only one is negative and QUOT has been

               truncated towards -infinity, REM will have the same sign as

               DENOM and the opposite sign of NUMER; if both are negative

               and QUOT has been truncated towards -infinity, REM will be

               positive (will have the opposite sign of NUMER).  These are

               considered `wrong'.  If both are NUM and DENOM are positive,

               RESULT will always be positive.  This all boils down to: if

               NUMER >= 0, but REM < 0, we got the wrong answer.  In that

               case, to get the right answer, add 1 to QUOT and subtract

               DENOM from REM.  */

if (numer >= 0 && result.rem < 0)

 {

++result.quot;

result.rem -= denom;

}

return result;

}

div_t div(int numer, int denom)

{

div_t result;

result.quot = numer / denom;

result.rem = numer % denom;

            /* The ANSI standard says that |QUOT| <= |NUMER / DENOM|, where

               NUMER / DENOM is to be computed in infinite precision.  In

               other words, we should always truncate the quotient towards

               zero, never -infinity.  Machine division and remainer may

               work either way when one or both of NUMER or DENOM is

               negative.  If only one is negative and QUOT has been

               truncated towards -infinity, REM will have the same sign as

               DENOM and the opposite sign of NUMER; if both are negative

               and QUOT has been truncated towards -infinity, REM will be

               positive (will have the opposite sign of NUMER).  These are

               considered `wrong'.  If both are NUM and DENOM are positive,

               RESULT will always be positive.  This all boils down to: if

               NUMER >= 0, but REM < 0, we got the wrong answer.  In that

               case, to get the right answer, add 1 to QUOT and subtract

               DENOM from REM.  */

if (numer >= 0 && result.rem < 0)

 {

++result.quot;

result.rem -= denom;

}

return result;

}

/*

        Retrieve volume info from BPB and store it in a VOLINFO structure

        You must provide the unit and starting sector of the filesystem, and

        a pointer to a sector buffer for scratch

        Attempts to read BPB and glean information about the FS from that.

        Returns 0 OK, nonzero for any error.

*/

unsigned long int DFS_GetVolInfo(unsigned char unit,

                                 unsigned char *scratchsector,

                                 unsigned long int startsector,

                                 PVOLINFO volinfo)

{

PLBR lbr = (PLBR) scratchsector;

volinfo->unit = unit;

volinfo->startsector = startsector;

if (DFS_ReadSector(unit, scratchsector, startsector, 1))

return DFS_ERRMISC;

// tag: OEMID, refer dosfs.h

//      strncpy(volinfo->oemid, lbr->oemid, 8);

//      volinfo->oemid[8] = 0;

volinfo->secperclus = lbr->bpb.secperclus;

volinfo->reservedsecs = (unsigned short)lbr->bpb.reserved_l |

            (((unsigned short)lbr->bpb.reserved_h) << 8);

volinfo->numsecs = (unsigned short)lbr->bpb.sectors_s_l |

            (((unsigned short)lbr->bpb.sectors_s_h) << 8);

if (!volinfo->numsecs)

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_2) << 16) |

                    (((unsigned long int)lbr->bpb.sectors_l_3) << 24);

            // If secperfat is 0, we must be in a FAT32 volume; get secperfat

            // from the FAT32 EBPB. The volume label and system ID string are also

            // in different locations for FAT12/16 vs FAT32.

            volinfo->secperfat = (unsigned short)lbr->bpb.secperfat_l |

            (((unsigned short)lbr->bpb.secperfat_h) << 8);

if (!volinfo->secperfat) {

volinfo->secperfat =

                    (unsigned long int)lbr->ebpb.ebpb32.

                    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);

volinfo->label[11] = 0;

// tag: OEMID, refer dosfs.h

//              memcpy(volinfo->system, lbr->ebpb.ebpb32.system, 8);

//              volinfo->system[8] = 0; 

        }

        else {

memcpy(volinfo->label, lbr->ebpb.ebpb.label, 11);

volinfo->label[11] = 0;

// tag: OEMID, refer dosfs.h

//              memcpy(volinfo->system, lbr->ebpb.ebpb.system, 8);

//              volinfo->system[8] = 0; 

        }

            // note: if rootentries is 0, we must be in a FAT32 volume.

            volinfo->rootentries = (unsigned short)lbr->bpb.rootentries_l |

            (((unsigned short)lbr->bpb.rootentries_h) << 8);

            // after extracting raw info we perform some useful precalculations

            volinfo->fat1 = startsector + volinfo->reservedsecs;

            // The calculation below is designed to round up the root directory size for FAT12/16

            // and to simply ignore the root directory for FAT32, since it's a normal, expandable

            // file in that situation.

            if (volinfo->rootentries) {

volinfo->rootdir = volinfo->fat1 + (volinfo->secperfat * 2);

volinfo->dataarea =

                    volinfo->rootdir +

                    (((volinfo->rootentries * 32) +

                      (SECTOR_SIZE - 1)) / SECTOR_SIZE);

}

        else {

volinfo->dataarea = volinfo->fat1 + (volinfo->secperfat * 2);

volinfo->rootdir =

                    (unsigned long int)lbr->ebpb.ebpb32.

                    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.

            volinfo->numclusters =

            (volinfo->numsecs - volinfo->dataarea) / volinfo->secperclus;

if (volinfo->numclusters < 4085)

volinfo->filesystem = FAT12;

        else if (volinfo->numclusters < 65525)

volinfo->filesystem = FAT16;

        else

volinfo->filesystem = FAT32;

return DFS_OK;

}

/*

        Fetch FAT entry for specified cluster number

        You must provide a scratch buffer for one sector (SECTOR_SIZE) and a populated VOLINFO

        Returns a FAT32 BAD_CLUSTER value for any error, otherwise the contents of the desired

        FAT entry.

        scratchcache should point to a UINT32. This variable caches the physical sector number

        last read into the scratch buffer for performance enhancement reasons.

*/

unsigned long int DFS_GetFAT(PVOLINFO volinfo, unsigned char *scratch,

                             unsigned long int *scratchcache,

                             unsigned long int cluster)

{

unsigned long int offset, sector, result;

if (volinfo->filesystem == FAT12) {

offset = cluster + (cluster / 2);

}

        else if (volinfo->filesystem == FAT16) {

offset = cluster * 2;

}

        else if (volinfo->filesystem == FAT32) {

offset = cluster * 4;

}

        else

return 0x0ffffff7;      // FAT32 bad cluster    

            // at this point, offset is the BYTE offset of the desired sector from the start

            // of the FAT. Calculate the physical sector containing this FAT entry.

            sector = ldiv(offset, SECTOR_SIZE).quot + volinfo->fat1;

            // If this is not the same sector we last read, then read it into RAM

            if (sector != *scratchcache) {

if (DFS_ReadSector(volinfo->unit, scratch, sector, 1)) {

                            // avoid anyone assuming that this cache value is still valid, which

                            // might cause disk corruption

                            *scratchcache = 0;

return 0x0ffffff7;      // FAT32 bad cluster    

                }

*scratchcache = sector;

}

            // At this point, we "merely" need to extract the relevant entry.

            // This is easy for FAT16 and FAT32, but a royal PITA for FAT12 as a single entry

            // may span a sector boundary. The normal way around this is always to read two

            // FAT sectors, but that luxury is (by design intent) unavailable to DOSFS.

            offset = ldiv(offset, SECTOR_SIZE).rem;

if (volinfo->filesystem == FAT12) {

                    // Special case for sector boundary - Store last byte of current sector.

                    // Then read in the next sector and put the first byte of that sector into

                    // the high byte of result.

                    if (offset == SECTOR_SIZE - 1) {

result = (unsigned long int)scratch[offset];

sector++;

if (DFS_ReadSector(volinfo->unit, scratch, sector, 1)) {

                                    // avoid anyone assuming that this cache value is still valid, which

                                    // might cause disk corruption

                                    *scratchcache = 0;

return 0x0ffffff7;      // FAT32 bad cluster    

                        }

*scratchcache = sector;

                            // Thanks to Claudio Leonel for pointing out this missing line.

                            result |= ((unsigned long int)scratch[0]) << 8;

}

                else {

result = (unsigned long int)scratch[offset] |

                            ((unsigned long int)scratch[offset + 1]) << 8;

}

if (cluster & 1)

result = result >> 4;

                else

result = result & 0xfff;

}

        else if (volinfo->filesystem == FAT16) {

result = (unsigned long int)scratch[offset] |

                    ((unsigned long int)scratch[offset + 1]) << 8;

}

        else if (volinfo->filesystem == FAT32) {

result = ((unsigned long int)scratch[offset] |

                           ((unsigned long int)scratch[offset + 1]) << 8 |

                           ((unsigned long int)scratch[offset + 2]) << 16 |

                           ((unsigned long int)scratch[offset + 3]) << 24) &

                    0x0fffffff;

}

        else

result = 0x0ffffff7;    // FAT32 bad cluster    

        return result;

}

/*

        Set FAT entry for specified cluster number

        You must provide a scratch buffer for one sector (SECTOR_SIZE) and a populated VOLINFO

        Returns DFS_ERRMISC for any error, otherwise DFS_OK

        scratchcache should point to a UINT32. This variable caches the physical sector number

        last read into the scratch buffer for performance enhancement reasons.

        NOTE: This code is HIGHLY WRITE-INEFFICIENT, particularly for flash media. Considerable

        performance gains can be realized by caching the sector. However this is difficult to

        achieve on FAT12 without requiring 2 sector buffers of scratch space, and it is a design

        requirement of this code to operate on a single 512-byte scratch.

        If you are operating DOSFS over flash, you are strongly advised to implement a writeback

        cache in your physical I/O driver. This will speed up your code significantly and will

        also conserve power and flash write life.

*/

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;

if (volinfo->filesystem == FAT12) {

offset = cluster + (cluster / 2);

new_contents &= 0xfff;

}

        else if (volinfo->filesystem == FAT16) {

offset = cluster * 2;

new_contents &= 0xffff;

}

        else if (volinfo->filesystem == FAT32) {