?? ff.c
字號:
/*--------------------------------------------------------------------------/
/ FatFs - FAT file system module R0.05 (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.
/ Aug 25, 2007 R0.05 Changed arguments of f_read(), f_write() and f_mkfs().
/ Fixed f_mkfs() on FAT32 creates incorrect FSInfo.
/ Fixed f_mkdir() on FAT32 creates incorrect directory.
/---------------------------------------------------------------------------*/
#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
/* Update FSInfo sector if needed */
if (fs->fs_type == FS_FAT32 && fs->fsi_flag)
{
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(fs->drive, fs->win, fs->fsi_sector, 1);
fs->fsi_flag = 0;
}
#endif
/* Make sure that no pending write process in the physical drive */
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;
idx = dirobj->index + 1;
if ((idx & ((S_SIZ - 1) / 32)) == 0)
{
/* Table sector changed? */
dirobj->sect++; /* Next sector */
if (!dirobj->clust)
{
/* In static table */
if (idx >= fs->n_rootdir)
{
return FALSE;
} /* Reached to end of table */
}
else
{
/* In dynamic table */
if (((idx / (S_SIZ / 32)) & (fs->sects_clust - 1)) == 0)
{
/* Cluster changed? */
clust = get_cluster(fs, dirobj->clust); /* Get next cluster */
if (clust < 2 || clust >= fs->max_clust) /* Reached to end of table */
{
return FALSE;
}
dirobj->clust = clust; /* Initialize for new cluster */
dirobj->sect = clust2sect(fs, clust);
}
}
}
dirobj->index = idx; /* Lower 4 bit of dirobj->index indicates offset in dirobj->sect */
return TRUE;
}
/*-----------------------------------------------------------------------*/
/* Get file status from directory entry */
/*-----------------------------------------------------------------------*/
#if _FS_MINIMIZE <= 1
static
void get_fileinfo(/* No return code */
FILINFO *finfo, /* Ptr to store the file information */
const BYTE *dir /* Ptr to the directory entry */)
{
BYTE n, c, a;
char *p;
p = &finfo->fname[0];
a = _USE_NTFLAG ? dir[DIR_NTres] : 0; /* NT flag */
for (n = 0; n < 8; n++)
{
/* Convert file name (body) */
c = dir[n];
if (c == ' ')
{
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -