ff.c

收集了单片机对SD卡读写源码

/*--------------------------------------------------------------------------/
/  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 == ' ')
		{