ff.c

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

			break;
		}
		if (c == 0x05)
		{
			c = 0xE5;
		}
		if (a & 0x08 && c >= 'A' && c <= 'Z')
		{
			c += 0x20;
		}
		*p++ = c;
	}
	if (dir[8] != ' ')
	{
		/* Convert file name (extension) */
		*p++ = '.';
		for (n = 8; n < 11; n++)
		{
			c = dir[n];
			if (c == ' ')
			{
				break;
			}
			if (a & 0x10 && c >= 'A' && c <= 'Z')
			{
				c += 0x20;
			}
			*p++ = c;
		}
	}
	*p = '\0';

	finfo->fattrib = dir[DIR_Attr];					/* Attribute */
	finfo->fsize = LD_DWORD(&dir[DIR_FileSize]);	/* Size */
	finfo->fdate = LD_WORD(&dir[DIR_WrtDate]);		/* Date */
	finfo->ftime = LD_WORD(&dir[DIR_WrtTime]);		/* Time */
}
#endif /* _FS_MINIMIZE <= 1 */




/*-----------------------------------------------------------------------*/
/* Pick a paragraph and create the name in format of directory entry	 */
/*-----------------------------------------------------------------------*/

static
char make_dirfile(/* 1: error - detected an invalid format, '\0'or'/': next character */
	const char **path, /* Pointer to the file path pointer */
	char *dirname			/* Pointer to directory name buffer {Name(8), Ext(3), NT flag(1)} */)
{
	BYTE n, t, c, a, b;


	memset(dirname, ' ', 8 + 3);	/* Fill buffer with spaces */
	a = 0; b = 0x18;	/* NT flag */
	n = 0; t = 8;
	for (; ;)
	{
		c = *(*path)++;
		if (c == '\0' || c == '/')
		{
			/* Reached to end of str or directory separator */
			if (n == 0)
			{
				break;
			}
			dirname[11] = _USE_NTFLAG ? (a & b) : 0;
			return c;
		}
		if (c <= ' ' || c == 0x7F)
		{
			break;
		}		/* Reject invisible chars */
		if (c == '.')
		{
			if (!(a & 1) && n >= 1 && n <= 8)
			{
				/* Enter extension part */
				n = 8; t = 11; continue;
			}
			break;
		}
		if (_USE_SJIS &&
			((c >= 0x81 && c <= 0x9F) || 	/* Accept S-JIS code */
			(c >= 0xE0 && c <= 0xFC)))
		{
			if (n == 0 && c == 0xE5)		/* Change heading \xE5 to \x05 */
			{
				c = 0x05;
			}
			a ^= 1; goto md_l2;
		}
		if (c == '"')
		{
			break;
		}				/* Reject " */
		if (c <= ')')
		{
			goto md_l1;
		}			/* Accept ! # $ % & ' ( ) */
		if (c <= ',')
		{
			break;
		}				/* Reject * + , */
		if (c <= '9')
		{
			goto md_l1;
		}			/* Accept - 0-9 */
		if (c <= '?')
		{
			break;
		}				/* Reject : ; < = > ? */
		if (!(a & 1))
		{
			/* These checks are not applied to S-JIS 2nd byte */
			if (c == '|')
			{
				break;
			}			/* Reject | */
			if (c >= '[' && c <= ']')
			{
				break;
			}/* Reject [ \ ] */
			if (_USE_NTFLAG && c >= 'A' && c <= 'Z')
			{
				(t == 8) ? (b &= ~0x08) : (b &= ~0x10);
			}
			if (c >= 'a' && c <= 'z')
			{
				/* Convert to upper case */
				c -= 0x20;
				if (_USE_NTFLAG)
				{
					(t == 8) ? (a |= 0x08) : (a |= 0x10);
				}
			}
		}
		md_l1 : a &= ~1;
		md_l2:
		if (n >= t)
		{
			break;
		}
		dirname[n++] = c;
	}
	return 1;
}




/*-----------------------------------------------------------------------*/
/* Trace a file path													 */
/*-----------------------------------------------------------------------*/

static
FRESULT trace_path(/* FR_OK(0): successful, !=0: error code */
	DIR *dirobj, /* Pointer to directory object to return last directory */
	char *fn, /* Pointer to last segment name to return {file(8),ext(3),attr(1)} */
	const char *path, /* Full-path string to trace a file or directory */
	BYTE **dir			/* Directory pointer in Win[] to retutn */)
{
	DWORD clust;
	char ds;
	BYTE *dptr = NULL;
	FATFS *fs = dirobj->fs;	/* Get logical drive from the given DIR structure */


	/* Initialize directory object */
	clust = fs->dirbase;
	if (fs->fs_type == FS_FAT32)
	{
		dirobj->clust = dirobj->sclust = clust;
		dirobj->sect = clust2sect(fs, clust);
	}
	else
	{
		dirobj->clust = dirobj->sclust = 0;
		dirobj->sect = clust;
	}
	dirobj->index = 0;

	if (*path == '\0')
	{
		/* Null path means the root directory */
		*dir = NULL; return FR_OK;
	}

	for (; ;)
	{
		ds = make_dirfile(&path, fn);			/* Get a paragraph into fn[] */
		if (ds == 1)
		{
			return FR_INVALID_NAME;
		}
		for (; ;)
		{
			if (!move_window(fs, dirobj->sect))
			{
				return FR_RW_ERROR;
			}
			dptr = &fs->win[(dirobj->index & ((S_SIZ - 1) / 32)) * 32];	/* Pointer to the directory entry */
			if (dptr[DIR_Name] == 0)						/* Has it reached to end of dir? */
			{
				return !ds ? FR_NO_FILE : FR_NO_PATH;
			}
			if (dptr[DIR_Name] !=
				0xE5						/* Matched? */ &&
				!(dptr[DIR_Attr] & AM_VOL) &&
				!memcmp(&dptr[DIR_Name],
						fn,
						8 +
						3))
			{
				break;
			}
			if (!next_dir_entry(dirobj))					/* Next directory pointer */
			{
				return !ds ? FR_NO_FILE : FR_NO_PATH;
			}
		}
		if (!ds)
		{
			*dir = dptr; return FR_OK;
		}				/* Matched with end of path */
		if (!(dptr[DIR_Attr] & AM_DIR))
		{
			return FR_NO_PATH;
		}	/* Cannot trace because it is a file */
		clust = ((DWORD) LD_WORD(&dptr[DIR_FstClusHI]) << 16) |
				LD_WORD(&dptr[DIR_FstClusLO]); /* Get cluster# of the directory */
		dirobj->clust = dirobj->sclust = clust;				/* Restart scanning at the new directory */
		dirobj->sect = clust2sect(fs, clust);
		dirobj->index = 2;
	}
}




/*-----------------------------------------------------------------------*/
/* Reserve a directory entry											 */
/*-----------------------------------------------------------------------*/

#if !_FS_READONLY
static
FRESULT reserve_direntry(/* FR_OK: successful, FR_DENIED: no free entry, FR_RW_ERROR: a disk error occured */
	DIR *dirobj, /* Target directory to create new entry */
	BYTE **dir				/* Pointer to pointer to created entry to retutn */)
{
	DWORD clust, sector;
	BYTE c, n, *dptr;
	FATFS *fs = dirobj->fs;


	/* Re-initialize directory object */
	clust = dirobj->sclust;
	if (clust)
	{
		/* Dyanmic directory table */
		dirobj->clust = clust;
		dirobj->sect = clust2sect(fs, clust);
	}
	else
	{
		/* Static directory table */
		dirobj->sect = fs->dirbase;
	}
	dirobj->index = 0;

	do
	{
		if (!move_window(fs, dirobj->sect))
		{
			return FR_RW_ERROR;
		}
		dptr = &fs->win[(dirobj->index & ((S_SIZ - 1) / 32)) * 32];	/* Pointer to the directory entry */
		c = dptr[DIR_Name];
		if (c == 0 || c == 0xE5)
		{
			/* Found an empty entry! */
			*dir = dptr; return FR_OK;
		}
	}
	while (next_dir_entry(dirobj));				/* Next directory pointer */
	/* Reached to end of the directory table */

	/* Abort when static table or could not stretch dynamic table */
	if (!clust || !(clust = create_chain(fs, dirobj->clust)))
	{
		return FR_DENIED;
	}
	if (clust == 1 || !move_window(fs, 0))
	{
		return FR_RW_ERROR;
	}

	fs->winsect = sector = clust2sect(fs, clust);		/* Cleanup the expanded table */
	memset(fs->win, 0, S_SIZ);
	for (n = fs->sects_clust; n; n--)
	{
		if (disk_write(fs->drive, fs->win, sector, 1) != RES_OK)
		{
			return FR_RW_ERROR;
		}
		sector++;
	}
	fs->winflag = 1;
	*dir = fs->win;
	return FR_OK;
}
#endif /* !_FS_READONLY */




/*-----------------------------------------------------------------------*/
/* Load boot record and check if it is a FAT boot record				 */
/*-----------------------------------------------------------------------*/

static
BYTE check_fs(/* 0:The FAT boot record, 1:Valid boot record but not an FAT, 2:Not a boot record or error */
	FATFS *fs, /* File system object */
	DWORD sect		/* Sector# (lba) to check if it is a FAT boot record or not */)
{
	if (disk_read(fs->drive, fs->win, sect, 1) != RES_OK)	/* Load boot record */
	{
		return 2;
	}
	if (LD_WORD(&fs->win[BS_55AA]) != 0xAA55)				/* Check record signature (always placed at offset 510 even if the sector size is >512) */
	{
		return 2;
	}

	if (!memcmp(&fs->win[BS_FilSysType], "FAT", 3))			/* Check FAT signature */
	{
		return 0;
	}
	if (!memcmp(&fs->win[BS_FilSysType32], "FAT32", 5) &&
		!(fs->win[BPB_ExtFlags] & 0x80))
	{
		return 0;
	}

	return 1;
}




/*-----------------------------------------------------------------------*/
/* Make sure that the file system is valid  							 */
/*-----------------------------------------------------------------------*/

static
FRESULT auto_mount(/* FR_OK(0): successful, !=0: any error occured */
	const char **path, /* Pointer to pointer to the path name (drive number) */
	FATFS **rfs, /* Pointer to pointer to the found file system object */
	BYTE chk_wp				/* !=0: Check media write protection for write access */)
{
	BYTE drv, fmt, *tbl;
	DSTATUS stat;
	DWORD bootsect, fatsize, totalsect, maxclust;
	const char *p = *path;
	FATFS *fs;


	/* Get drive number from the path name */
	while (*p == ' ')
	{
		p++;
	}		/* Strip leading spaces */
	drv = p[0] - '0';			/* Is there a drive number? */
	if (drv <= 9 && p[1] == ':')
	{
		p += 2;
	}			/* Found a drive number, get and strip it */
	else
	{
		drv = 0;
	}		/* No drive number is given, use drive number 0 as default */
	if (*p == '/')
	{
		p++;
	}	/* Strip heading slash */
	*path = p;			/* Return pointer to the path name */

	/* Check if the drive number is valid or not */
	if (drv >= _DRIVES)
	{
		return FR_INVALID_DRIVE;
	}	/* Is the drive number valid? */
	if (!(fs = FatFs[drv]))
	{
		return FR_NOT_ENABLED;
	}	/* Is the file system object registered? */
	*rfs = fs;			/* Returen pointer to the corresponding file system object */

	/* Check if the logical drive has been mounted or not */
	if (fs->fs_type)
	{
		stat = disk_status(fs->drive);
		if (!(stat & STA_NOINIT))
		{
			/* If the physical drive is kept initialized */
#if !_FS_READONLY
			if (chk_wp && (stat & STA_PROTECT))	/* Check write protection if needed */
			{
				return FR_WRITE_PROTECTED;
			}
#endif
			return FR_OK;						/* The file system object is valid */
		}
	}

	/* The logical drive has not been mounted, following code attempts to mount the logical drive */

	memset(fs, 0, sizeof(FATFS));		/* Clean-up the file system object */
	fs->drive = LD2PD(drv);				/* Bind the logical drive and a physical drive */
	stat = disk_initialize(fs->drive);	/* Initialize low level disk I/O layer */
	if (stat & STA_NOINIT)				/* Check if the drive is ready */
	{
		return FR_NOT_READY;
	}
#if S_MAX_SIZ > 512						/* Check disk sector size */
	if (disk_ioctl(drv, GET_SECTOR_SIZE, &S_SIZ) != RES_OK ||
		S_SIZ > S_MAX_SIZ)
	{
		return FR_NO_FILESYSTEM;
	}
#endif
#if !_FS_READONLY
	if (chk_wp && (stat & STA_PROTECT))	/* Check write protection if needed */
	{
		return FR_WRITE_PROTECTED;
	}
#endif
	/* Search FAT partition on the drive */
	fmt = check_fs(fs, bootsect = 0);	/* Check sector 0 as an SFD format */
	if (fmt == 1)
	{
		/* Not a FAT boot record, it may be patitioned */
		/* Check a partition listed in top of the partition table */
		tbl = &fs->win[MBR_Table + LD2PT(drv) * 16];	/* Partition table */
		if (tbl[4])
		{
			/* Is the partition existing? */
			bootsect = LD_DWORD(&tbl[8]);			/* Partition offset in LBA */
			fmt = check_fs(fs, bootsect);			/* Check the partition */
		}
	}
	if (fmt || LD_WORD(&fs->win[BPB_BytsPerSec]) != S_SIZ)	/* No valid FAT patition is found */
	{
		return FR_NO_FILESYSTEM;
	}

	/* Initialize the file system object */
	fatsize = LD_WORD(&fs->win[BPB_FATSz16]);			/* Number of sectors per FAT */
	if (!fatsize)
	{
		fatsize = LD_DWORD(&fs->win[BPB_FATSz32]);
	}
	fs->sects_fat = fatsize;
	fs->n_fats = fs->win[BPB_NumFATs];					/* Number of FAT copies */
	fatsize *= fs->n_fats;								/* (Number of sectors in FAT area) */
	fs->fatbase = bootsect + LD_WORD(&fs->win[BPB_RsvdSecCnt]); /* FAT start sector (lba) */
	fs->sects_clust = fs->win[BPB_SecPerClus];			/* Number of sectors per cluster */
	fs->n_rootdir = LD_WORD(&fs->win[BPB_RootEntCnt]);	/* Nmuber of root directory entries */
	totalsect = LD_WORD(&fs->win[BPB_TotSec16]);		/* Number of sectors on the file system */
	if (!totalsect)
	{
		totalsect = LD_DWORD(&fs->win[BPB_TotSec32]);
	}
	fs->max_clust = maxclust = (totalsect				/* Last cluster# + 1 */ -
								LD_WORD(&fs->win[BPB_RsvdSecCnt]) -
								fatsize -
								fs->n_rootdir /
								(S_SIZ / 32)) /
					fs->sects_clust +
					2;

	fmt = FS_FAT12;										/* Determine the FAT sub type */
	if (maxclust > 0xFF7)
	{
		fmt = FS_FAT16;
	}
	if (maxclust > 0xFFF7)
	{
		fmt = FS_FAT32;
	}
	fs->fs_type = fmt;

	if (fmt == FS_FAT32)
	{
		fs->dirbase = LD_DWORD(&fs->win[BPB_RootClus]);