ff.c

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

	{
		return FR_RW_ERROR;
	}	/* Remove the cluster chain */

	return sync(fs);
}




/*-----------------------------------------------------------------------*/
/* Create a Directory   												 */
/*-----------------------------------------------------------------------*/
DWORD get_fattime(void)
{
	return(0);
}
FRESULT f_mkdir(const char *path		/* Pointer to the directory path */)
{
	BYTE *dir, *fw, n;
	char fn[8 + 3 + 1];
	DWORD sect, dsect, dclust, pclust, tim;
	FRESULT res;
	DIR dirobj;
	FATFS *fs;


	res = auto_mount(&path, &fs, 1);
	if (res != FR_OK)
	{
		return res;
	}
	dirobj.fs = fs;

	res = trace_path(&dirobj, fn, path, &dir);	/* Trace the file path */
	if (res == FR_OK)
	{
		return FR_EXIST;
	}			/* Any file or directory is already existing */
	if (res != FR_NO_FILE)
	{
		return res;
	}

	res = reserve_direntry(&dirobj, &dir); 		/* Reserve a directory entry */
	if (res != FR_OK)
	{
		return res;
	}
	sect = fs->winsect;
	dclust = create_chain(fs, 0);				/* Allocate a cluster for new directory table */
	if (dclust == 1)
	{
		return FR_RW_ERROR;
	}
	dsect = clust2sect(fs, dclust);
	if (!dsect)
	{
		return FR_DENIED;
	}
	if (!move_window(fs, dsect))
	{
		return FR_RW_ERROR;
	}

	fw = fs->win;
	memset(fw, 0, S_SIZ);						/* Clear the new directory table */
	for (n = 1; n < fs->sects_clust; n++)
	{
		if (disk_write(fs->drive, fw, ++dsect, 1) != RES_OK)
		{
			return FR_RW_ERROR;
		}
	}
	memset(&fw[DIR_Name], ' ', 8 + 3);			/* Create "." entry */
	fw[DIR_Name] = '.';
	fw[DIR_Attr] = AM_DIR;
	tim = get_fattime();
	ST_DWORD(&fw[DIR_WrtTime], tim);
	memcpy(&fw[32], &fw[0], 32); fw[33] = '.';	/* Create ".." entry */
	ST_WORD(&fw[DIR_FstClusLO], dclust);
	ST_WORD(&fw[DIR_FstClusHI], dclust >> 16);
	pclust = dirobj.sclust;
	if (fs->fs_type == FS_FAT32 && pclust == fs->dirbase)
	{
		pclust = 0;
	}
	ST_WORD(&fw[32 + DIR_FstClusLO], pclust);
	ST_WORD(&fw[32 + DIR_FstClusHI], pclust >> 16);
	fs->winflag = 1;

	if (!move_window(fs, sect))
	{
		return FR_RW_ERROR;
	}
	memset(&dir[0], 0, 32);						/* Initialize the new entry */
	memcpy(&dir[DIR_Name], fn, 8 + 3);			/* Name */
	dir[DIR_NTres] = fn[11];
	dir[DIR_Attr] = AM_DIR;						/* Attribute */
	ST_DWORD(&dir[DIR_WrtTime], tim);			/* Crated time */
	ST_WORD(&dir[DIR_FstClusLO], dclust);		/* Table start cluster */
	ST_WORD(&dir[DIR_FstClusHI], dclust >> 16);

	return sync(fs);
}




/*-----------------------------------------------------------------------*/
/* Change File Attribute												 */
/*-----------------------------------------------------------------------*/

FRESULT f_chmod(const char *path, /* Pointer to the file path */
	BYTE value, /* Attribute bits */
	BYTE mask			/* Attribute mask to change */)
{
	FRESULT res;
	BYTE *dir;
	DIR dirobj;
	char fn[8 + 3 + 1];
	FATFS *fs;


	res = auto_mount(&path, &fs, 1);
	if (res == FR_OK)
	{
		dirobj.fs = fs;
		res = trace_path(&dirobj, fn, path, &dir);	/* Trace the file path */
		if (res == FR_OK)
		{
			/* Trace completed */
			if (dir == NULL)
			{
				res = FR_INVALID_NAME;
			}
			else
			{
				mask &= AM_RDO | AM_HID | AM_SYS | AM_ARC;	/* Valid attribute mask */
				dir[DIR_Attr] = (value & mask) |
								(dir[DIR_Attr] & (BYTE) ~mask);	/* Apply attribute change */
				res = sync(fs);
			}
		}
	}
	return res;
}




/*-----------------------------------------------------------------------*/
/* Rename File/Directory												 */
/*-----------------------------------------------------------------------*/

FRESULT f_rename(const char *path_old, /* Pointer to the old name */
	const char *path_new	/* Pointer to the new name */)
{
	FRESULT res;
	DWORD sect_old;
	BYTE *dir_old, *dir_new, direntry[32 - 11];
	DIR dirobj;
	char fn[8 + 3 + 1];
	FATFS *fs;


	res = auto_mount(&path_old, &fs, 1);
	if (res != FR_OK)
	{
		return res;
	}
	dirobj.fs = fs;

	res = trace_path(&dirobj, fn, path_old, &dir_old);	/* Check old object */
	if (res != FR_OK)
	{
		return res;
	}			/* The old object is not found */
	if (!dir_old)
	{
		return FR_NO_FILE;
	}
	sect_old = fs->winsect;					/* Save the object information */
	memcpy(direntry, &dir_old[DIR_Attr], 32 - 11);

	res = trace_path(&dirobj, fn, path_new, &dir_new);	/* Check new object */
	if (res == FR_OK)
	{
		return FR_EXIST;
	}			/* The new object name is already existing */
	if (res != FR_NO_FILE)
	{
		return res;
	}			/* Is there no old name? */
	res = reserve_direntry(&dirobj, &dir_new); 	/* Reserve a directory entry */
	if (res != FR_OK)
	{
		return res;
	}

	memcpy(&dir_new[DIR_Attr], direntry, 32 - 11);	/* Create new entry */
	memcpy(&dir_new[DIR_Name], fn, 8 + 3);
	dir_new[DIR_NTres] = fn[11];
	fs->winflag = 1;

	if (!move_window(fs, sect_old))
	{
		return FR_RW_ERROR;
	}	/* Remove old entry */
	dir_old[DIR_Name] = 0xE5;

	return sync(fs);
}



#if _USE_MKFS
/*-----------------------------------------------------------------------*/
/* Create File System on the Drive  									 */
/*-----------------------------------------------------------------------*/

#define N_ROOTDIR	512			/* Multiple of 32 and <= 2048 */
#define N_FATS		1			/* 1 or 2 */
#define MAX_SECTOR	64000000UL	/* Maximum partition size */
#define MIN_SECTOR	2000UL		/* Minimum partition size */


FRESULT f_mkfs(BYTE drv, /* Logical drive number */
	BYTE partition, /* Partitioning rule 0:FDISK, 1:SFD */
	WORD allocsize		/* Allocation unit size [bytes] */)
{
	BYTE fmt, m, *tbl;
	DWORD b_part, b_fat, b_dir, b_data;		/* Area offset (LBA) */
	DWORD n_part, n_rsv, n_fat, n_dir;		/* Area size */
	DWORD n_clust, n;
	FATFS *fs;
	DSTATUS stat;


	/* Check validity of the parameters */
	if (drv >= _DRIVES)
	{
		return FR_INVALID_DRIVE;
	}
	if (partition >= 2)
	{
		return FR_MKFS_ABORTED;
	}
	for (n = 512; n <= 32768U && n != allocsize; n <<= 1)
		;
	if (n != allocsize)
	{
		return FR_MKFS_ABORTED;
	}

	/* Check mounted drive and clear work area */
	fs = FatFs[drv];
	if (!fs)
	{
		return FR_NOT_ENABLED;
	}
	memset(fs, 0, sizeof(FATFS));
	drv = LD2PD(drv);

	/* Get disk statics */
	stat = disk_initialize(drv);
	if (stat & STA_NOINIT)
	{
		return FR_NOT_READY;
	}
	if (stat & STA_PROTECT)
	{
		return FR_WRITE_PROTECTED;
	}
	if (disk_ioctl(drv, GET_SECTOR_COUNT, &n_part) != RES_OK ||
		n_part < MIN_SECTOR)
	{
		return FR_MKFS_ABORTED;
	}
	if (n_part > MAX_SECTOR)
	{
		n_part = MAX_SECTOR;
	}
	b_part = (!partition) ? 63 : 0;		/* Boot sector */
	n_part -= b_part;
#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 ||
		S_SIZ > allocsize)
	{
		return FR_MKFS_ABORTED;
	}
#endif
	allocsize /= S_SIZ;		/* Number of sectors per cluster */

	/* Pre-compute number of clusters and FAT type */
	n_clust = n_part / allocsize;
	fmt = FS_FAT12;
	if (n_clust >= 0xFF7)
	{
		fmt = FS_FAT16;
	}
	if (n_clust >= 0xFFF7)
	{
		fmt = FS_FAT32;
	}

	/* Determine offset and size of FAT structure */
	switch (fmt)
	{
		case FS_FAT12:
			n_fat = ((n_clust * 3 + 1) / 2 + 3 + S_SIZ - 1) / S_SIZ;
			n_rsv = 1 + partition;
			n_dir = N_ROOTDIR * 32 / S_SIZ;
			break;
		case FS_FAT16:
			n_fat = ((n_clust * 2) + 4 + S_SIZ - 1) / S_SIZ;
			n_rsv = 1 + partition;
			n_dir = N_ROOTDIR * 32 / S_SIZ;
			break;
		default:
			n_fat = ((n_clust * 4) + 8 + S_SIZ - 1) / S_SIZ;
			n_rsv = 33 - partition;
			n_dir = 0;
	}
	b_fat = b_part + n_rsv;			/* FATs start sector */
	b_dir = b_fat + n_fat * N_FATS;	/* Directory start sector */
	b_data = b_dir + n_dir;			/* Data start sector */

	/* Align data start sector to erase block boundary (for flash memory media) */
	if (disk_ioctl(drv, GET_BLOCK_SIZE, &n) != RES_OK)
	{
		return FR_MKFS_ABORTED;
	}
	n = (b_data + n - 1) & ~(n - 1);
	n_fat += (n - b_data) / N_FATS;
	/* b_dir and b_data are no longer used below */

	/* Determine number of cluster and final check of validity of the FAT type */
	n_clust = (n_part - n_rsv - n_fat * N_FATS - n_dir) / allocsize;
	if ((fmt == FS_FAT16 && n_clust < 0xFF7) ||
		(fmt == FS_FAT32 && n_clust < 0xFFF7))
	{
		return FR_MKFS_ABORTED;
	}

	/* Create partition table if needed */
	if (!partition)
	{
		DWORD n_disk = b_part + n_part;

		tbl = &fs->win[MBR_Table];
		ST_DWORD(&tbl[0], 0x00010180);	/* Partition start in CHS */
		if (n_disk < 63UL * 255 * 1024)
		{
			/* Partition end in CHS */
			n_disk = n_disk / 63 / 255;
			tbl[7] = (BYTE) n_disk;
			tbl[6] = (BYTE) ((n_disk >> 2) | 63);
		}
		else
		{
			ST_WORD(&tbl[6], 0xFFFF);
		}
		tbl[5] = 254;
		if (fmt != FS_FAT32)			/* System ID */
		{
			tbl[4] = (n_part < 0x10000) ? 0x04 : 0x06;
		}
		else
		{
			tbl[4] = 0x0c;
		}
		ST_DWORD(&tbl[8], 63);			/* Partition start in LBA */
		ST_DWORD(&tbl[12], n_part);		/* Partition size in LBA */
		ST_WORD(&tbl[64], 0xAA55);		/* Signature */
		if (disk_write(drv, fs->win, 0, 1) != RES_OK)
		{
			return FR_RW_ERROR;
		}
	}

	/* Create boot record */
	tbl = fs->win;								/* Clear buffer */
	memset(tbl, 0, S_SIZ);
	ST_DWORD(&tbl[BS_jmpBoot], 0x90FEEB);		/* Boot code (jmp $, nop) */
	ST_WORD(&tbl[BPB_BytsPerSec], S_SIZ);		/* Sector size */
	tbl[BPB_SecPerClus] = (BYTE) allocsize;		/* Sectors per cluster */
	ST_WORD(&tbl[BPB_RsvdSecCnt], n_rsv);		/* Reserved sectors */
	tbl[BPB_NumFATs] = N_FATS;					/* Number of FATs */
	ST_WORD(&tbl[BPB_RootEntCnt], S_SIZ / 32 * n_dir); /* Number of rootdir entries */
	if (n_part < 0x10000)
	{
		/* Number of total sectors */
		ST_WORD(&tbl[BPB_TotSec16], n_part);
	}
	else
	{
		ST_DWORD(&tbl[BPB_TotSec32], n_part);
	}
	tbl[BPB_Media] = 0xF8;						/* Media descripter */
	ST_WORD(&tbl[BPB_SecPerTrk], 63);			/* Number of sectors per track */
	ST_WORD(&tbl[BPB_NumHeads], 255);			/* Number of heads */
	ST_DWORD(&tbl[BPB_HiddSec], b_part);		/* Hidden sectors */
	if (fmt != FS_FAT32)
	{
		ST_WORD(&tbl[BPB_FATSz16], n_fat);		/* Number of secters per FAT */
		tbl[BS_DrvNum] = 0x80;					/* Drive number */
		tbl[BS_BootSig] = 0x29;					/* Extended boot signature */
		memcpy(&tbl[BS_VolLab], "NO NAME    FAT     ", 19);	/* Volume lavel, FAT signature */
	}
	else
	{
		ST_DWORD(&tbl[BPB_FATSz32], n_fat);		/* Number of secters per FAT */
		ST_DWORD(&tbl[BPB_RootClus], 2);		/* Root directory cluster (2) */
		ST_WORD(&tbl[BPB_FSInfo], 1);			/* FSInfo record (bs+1) */
		ST_WORD(&tbl[BPB_BkBootSec], 6);		/* Backup boot record (bs+6) */
		tbl[BS_DrvNum32] = 0x80;				/* Drive number */
		tbl[BS_BootSig32] = 0x29;				/* Extended boot signature */
		memcpy(&tbl[BS_VolLab32], "NO NAME    FAT32   ", 19);	/* Volume lavel, FAT signature */
	}
	ST_WORD(&tbl[BS_55AA], 0xAA55);			/* Signature */
	if (disk_write(drv, tbl, b_part + 0, 1) != RES_OK)
	{
		return FR_RW_ERROR;
	}
	if (fmt == FS_FAT32)
	{
		disk_write(drv, tbl, b_part + 6, 1);
	}

	/* Initialize FAT area */
	for (m = 0; m < N_FATS; m++)
	{
		memset(tbl, 0, S_SIZ);		/* 1st sector of the FAT  */
		if (fmt != FS_FAT32)
		{
			n = (fmt == FS_FAT12) ? 0x00FFFFF8 : 0xFFFFFFF8;
			ST_DWORD(&tbl[0], n);			/* Reserve cluster #0-1 (FAT12/16) */
		}
		else
		{
			ST_DWORD(&tbl[0], 0xFFFFFFF8);	/* Reserve cluster #0-1 (FAT32) */
			ST_DWORD(&tbl[4], 0xFFFFFFFF);
			ST_DWORD(&tbl[8], 0x0FFFFFFF);	/* Reserve cluster #2 for root dir */
		}
		if (disk_write(drv, tbl, b_fat++, 1) != RES_OK)
		{
			return FR_RW_ERROR;
		}
		memset(tbl, 0, S_SIZ);		/* Following FAT entries are filled by zero */
		for (n = 1; n < n_fat; n++)
		{
			if (disk_write(drv, tbl, b_fat++, 1) != RES_OK)
			{
				return FR_RW_ERROR;
			}
		}
	}

	/* Initialize Root directory */
	m = (BYTE) ((fmt == FS_FAT32) ? allocsize : n_dir);
	do
	{
		if (disk_write(drv, tbl, b_fat++, 1) != RES_OK)
		{
			return FR_RW_ERROR;
		}
	}
	while (--m);

	/* Create FSInfo record if needed */
	if (fmt == FS_FAT32)
	{
		ST_WORD(&tbl[BS_55AA], 0xAA55);
		ST_DWORD(&tbl[FSI_LeadSig], 0x41615252);
		ST_DWORD(&tbl[FSI_StrucSig], 0x61417272);
		ST_DWORD(&tbl[FSI_Free_Count], n_clust - 1);
		ST_DWORD(&tbl[FSI_Nxt_Free], 0xFFFFFFFF);
		disk_write(drv, tbl, b_part + 1, 1);
		disk_write(drv, tbl, b_part + 7, 1);
	}

	return (disk_ioctl(drv, CTRL_SYNC, NULL) == RES_OK) ? FR_OK : FR_RW_ERROR;
}

#endif /* _USE_MKFS */
#endif /* !_FS_READONLY */
#endif /* _FS_MINIMIZE == 0 */
#endif /* _FS_MINIMIZE <= 1 */
#endif /* _FS_MINIMIZE <= 2 */