ff.c

非常好用的嵌入式系统用的fat文件系统,支持fat12 fat16 fat32

/*--------------------------------------------------------------------------/
/  FatFs - FAT file system module  R0.04b                    (C)ChaN, 2007
/---------------------------------------------------------------------------/
/ The FatFs module is an experimenal project to implement FAT file system to
/ cheap microcontrollers. This is a free software and is opened for education,
/ research and development under license policy of following trems.
/
/  Copyright (C) 2007, ChaN, all right reserved.
/
/ * The FatFs module is a free software and there is no warranty.
/ * You can use, modify and/or redistribute it for personal, non-profit or
/   profit use without any restriction under your responsibility.
/ * Redistributions of source code must retain the above copyright notice.
/
/---------------------------------------------------------------------------/
/  Feb 26, 2006  R0.00  Prototype.
/  Apr 29, 2006  R0.01  First stable version.
/  Jun 01, 2006  R0.02  Added FAT12 support.
/                       Removed unbuffered mode.
/                       Fixed a problem on small (<32M) patition.
/  Jun 10, 2006  R0.02a Added a configuration option (_FS_MINIMUM).
/  Sep 22, 2006  R0.03  Added f_rename().
/                       Changed option _FS_MINIMUM to _FS_MINIMIZE.
/  Dec 11, 2006  R0.03a Improved cluster scan algolithm to write files fast.
/                       Fixed f_mkdir() creates incorrect directory on FAT32.
/  Feb 04, 2007  R0.04  Supported multiple drive system.
/                       Changed some interfaces for multiple drive system.
/                       Changed f_mountdrv() to f_mount().
/                       Added f_mkfs().
/  Apr 01, 2007  R0.04a Supported multiple partitions on a plysical drive.
/                       Added a capability of extending file size to f_lseek().
/                       Added minimization level 3.
/                       Fixed an endian sensitive code in f_mkfs().
/  May 05, 2007  R0.04b Added a configuration option _USE_NTFLAG.
/                       Added FSInfo support.
/                       Fixed DBCS name can result FR_INVALID_NAME.
/                       Fixed short seek (<= csize) collapses the file object.
/---------------------------------------------------------------------------*/

#include <string.h>
#include "ff.h"            /* FatFs declarations */
#include "diskio.h"        /* Include file for user provided disk functions */


/*--------------------------------------------------------------------------

   Module Private Functions

---------------------------------------------------------------------------*/

static
FATFS *FatFs[_DRIVES];    /* Pointer to the file system objects (logical drives) */
static
WORD fsid;                /* File system mount ID */



/*-----------------------------------------------------------------------*/
/* Change window offset                                                  */
/*-----------------------------------------------------------------------*/

static
BOOL move_window (        /* TRUE: successful, FALSE: failed */
    FATFS *fs,            /* File system object */
    DWORD sector        /* Sector number to make apperance in the fs->win[] */
)                        /* Move to zero only writes back dirty window */
{
    DWORD wsect;


    wsect = fs->winsect;
    if (wsect != sector) {    /* Changed current window */
#if !_FS_READONLY
        BYTE n;
        if (fs->winflag) {    /* Write back dirty window if needed */
            if (disk_write(fs->drive, fs->win, wsect, 1) != RES_OK)
                return FALSE;
            fs->winflag = 0;
            if (wsect < (fs->fatbase + fs->sects_fat)) {    /* In FAT area */
                for (n = fs->n_fats; n >= 2; n--) {    /* Refrect the change to FAT copy */
                    wsect += fs->sects_fat;
                    disk_write(fs->drive, fs->win, wsect, 1);
                }
            }
        }
#endif
        if (sector) {
            if (disk_read(fs->drive, fs->win, sector, 1) != RES_OK)
                return FALSE;
            fs->winsect = sector;
        }
    }
    return TRUE;
}




/*-----------------------------------------------------------------------*/
/* Clean-up cached data                                                  */
/*-----------------------------------------------------------------------*/

#if !_FS_READONLY
static
FRESULT sync (            /* FR_OK: successful, FR_RW_ERROR: failed */
    FATFS *fs            /* File system object */
)
{
    fs->winflag = 1;
    if (!move_window(fs, 0)) return FR_RW_ERROR;
#if _USE_FSINFO
    if (fs->fs_type == FS_FAT32 && fs->fsi_flag) {        /* Update FSInfo sector if needed */
        fs->winsect = 0;
        memset(fs->win, 0, 512);
        ST_WORD(&fs->win[BS_55AA], 0xAA55);
        ST_DWORD(&fs->win[FSI_LeadSig], 0x41615252);
        ST_DWORD(&fs->win[FSI_StrucSig], 0x61417272);
        ST_DWORD(&fs->win[FSI_Free_Count], fs->free_clust);
        ST_DWORD(&fs->win[FSI_Nxt_Free], fs->last_clust);
        disk_write(0, fs->win, fs->fsi_sector, 1);
        fs->fsi_flag = 0;
    }
#endif
    if (disk_ioctl(fs->drive, CTRL_SYNC, NULL) != RES_OK) return FR_RW_ERROR;
    return FR_OK;
}
#endif




/*-----------------------------------------------------------------------*/
/* Get a cluster status                                                  */
/*-----------------------------------------------------------------------*/

static
DWORD get_cluster (        /* 0,>=2: successful, 1: failed */
    FATFS *fs,            /* File system object */
    DWORD clust            /* Cluster# to get the link information */
)
{
    WORD wc, bc;
    DWORD fatsect;


    if (clust >= 2 && clust < fs->max_clust) {        /* Valid cluster# */
        fatsect = fs->fatbase;
        switch (fs->fs_type) {
        case FS_FAT12 :
            bc = (WORD)clust * 3 / 2;
            if (!move_window(fs, fatsect + (bc / S_SIZ))) break;
            wc = fs->win[bc & (S_SIZ - 1)]; bc++;
            if (!move_window(fs, fatsect + (bc / S_SIZ))) break;
            wc |= (WORD)fs->win[bc & (S_SIZ - 1)] << 8;
            return (clust & 1) ? (wc >> 4) : (wc & 0xFFF);

        case FS_FAT16 :
            if (!move_window(fs, fatsect + (clust / (S_SIZ / 2)))) break;
            return LD_WORD(&fs->win[((WORD)clust * 2) & (S_SIZ - 1)]);

        case FS_FAT32 :
            if (!move_window(fs, fatsect + (clust / (S_SIZ / 4)))) break;
            return LD_DWORD(&fs->win[((WORD)clust * 4) & (S_SIZ - 1)]) & 0x0FFFFFFF;
        }
    }

    return 1;    /* There is no cluster information, or an error occured */
}




/*-----------------------------------------------------------------------*/
/* Change a cluster status                                               */
/*-----------------------------------------------------------------------*/

#if !_FS_READONLY
static
BOOL put_cluster (        /* TRUE: successful, FALSE: failed */
    FATFS *fs,            /* File system object */
    DWORD clust,        /* Cluster# to change */
    DWORD val            /* New value to mark the cluster */
)
{
    WORD bc;
    BYTE *p;
    DWORD fatsect;


    fatsect = fs->fatbase;
    switch (fs->fs_type) {
    case FS_FAT12 :
        bc = (WORD)clust * 3 / 2;
        if (!move_window(fs, fatsect + (bc / S_SIZ))) return FALSE;
        p = &fs->win[bc & (S_SIZ - 1)];
        *p = (clust & 1) ? ((*p & 0x0F) | ((BYTE)val << 4)) : (BYTE)val;
        bc++;
        fs->winflag = 1;
        if (!move_window(fs, fatsect + (bc / S_SIZ))) return FALSE;
        p = &fs->win[bc & (S_SIZ - 1)];
        *p = (clust & 1) ? (BYTE)(val >> 4) : ((*p & 0xF0) | ((BYTE)(val >> 8) & 0x0F));
        break;

    case FS_FAT16 :
        if (!move_window(fs, fatsect + (clust / (S_SIZ / 2)))) return FALSE;
        ST_WORD(&fs->win[((WORD)clust * 2) & (S_SIZ - 1)], (WORD)val);
        break;

    case FS_FAT32 :
        if (!move_window(fs, fatsect + (clust / (S_SIZ / 4)))) return FALSE;
        ST_DWORD(&fs->win[((WORD)clust * 4) & (S_SIZ - 1)], val);
        break;

    default :
        return FALSE;
    }
    fs->winflag = 1;
    return TRUE;
}
#endif /* !_FS_READONLY */




/*-----------------------------------------------------------------------*/
/* Remove a cluster chain                                                */
/*-----------------------------------------------------------------------*/

#if !_FS_READONLY
static
BOOL remove_chain (        /* TRUE: successful, FALSE: failed */
    FATFS *fs,            /* File system object */
    DWORD clust            /* Cluster# to remove chain from */
)
{
    DWORD nxt;


    while (clust >= 2 && clust < fs->max_clust) {
        nxt = get_cluster(fs, clust);
        if (nxt == 1) return FALSE;
        if (!put_cluster(fs, clust, 0)) return FALSE;
        if (fs->free_clust != 0xFFFFFFFF) {
            fs->free_clust++;
#if _USE_FSINFO
            fs->fsi_flag = 1;
#endif
        }
        clust = nxt;
    }
    return TRUE;
}
#endif




/*-----------------------------------------------------------------------*/
/* Stretch or create a cluster chain                                     */
/*-----------------------------------------------------------------------*/

#if !_FS_READONLY
static
DWORD create_chain (    /* 0: no free cluster, 1: error, >=2: new cluster number */
    FATFS *fs,            /* File system object */
    DWORD clust            /* Cluster# to stretch, 0 means create new */
)
{
    DWORD cstat, ncl, scl, mcl = fs->max_clust;


    if (clust == 0) {        /* Create new chain */
        scl = fs->last_clust;            /* Get suggested start point */
        if (scl == 0 || scl >= mcl) scl = 1;
    }
    else {                    /* Stretch existing chain */
        cstat = get_cluster(fs, clust);    /* Check the cluster status */
        if (cstat < 2) return 1;        /* It is an invalid cluster */
        if (cstat < mcl) return cstat;    /* It is already followed by next cluster */
        scl = clust;
    }

    ncl = scl;                /* Start cluster */
    for (;;) {
        ncl++;                            /* Next cluster */
        if (ncl >= mcl) {                /* Wrap around */
            ncl = 2;
            if (ncl > scl) return 0;    /* No free custer */
        }
        cstat = get_cluster(fs, ncl);    /* Get the cluster status */
        if (cstat == 0) break;            /* Found a free cluster */
        if (cstat == 1) return 1;        /* Any error occured */
        if (ncl == scl) return 0;        /* No free custer */
    }

    if (!put_cluster(fs, ncl, 0x0FFFFFFF)) return 1;        /* Mark the new cluster "in use" */
    if (clust && !put_cluster(fs, clust, ncl)) return 1;    /* Link it to previous one if needed */

    fs->last_clust = ncl;                /* Update fsinfo */
    if (fs->free_clust != 0xFFFFFFFF) {
        fs->free_clust--;
#if _USE_FSINFO
        fs->fsi_flag = 1;
#endif
    }

    return ncl;        /* Return new cluster number */
}
#endif /* !_FS_READONLY */




/*-----------------------------------------------------------------------*/
/* Get sector# from cluster#                                             */
/*-----------------------------------------------------------------------*/

static
DWORD clust2sect (    /* !=0: sector number, 0: failed - invalid cluster# */
    FATFS *fs,        /* File system object */
    DWORD clust        /* Cluster# to be converted */
)
{
    clust -= 2;
    if (clust >= (fs->max_clust - 2)) return 0;        /* Invalid cluster# */
    return clust * fs->sects_clust + fs->database;
}




/*-----------------------------------------------------------------------*/
/* Move directory pointer to next                                        */
/*-----------------------------------------------------------------------*/

static
BOOL next_dir_entry (    /* TRUE: successful, FALSE: could not move next */
    DIR *dirobj            /* Pointer to directory object */
)
{
    DWORD clust;
    WORD idx;
    FATFS *fs = dirobj->fs;