ff.c

S64和VS1003的MP3播放实现的源代码/

		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 & 15) * 32];		/* Pointer to the directory entry */
			if (*dptr == 0)									/* Has it reached to end of dir? */
				return !ds ? FR_NO_FILE : FR_NO_PATH;
			if (    (*dptr != 0xE5)							/* Matched? */
				&& !(*(dptr+11) & AM_VOL)
				&& !memcmp(dptr, 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+11) & AM_DIR)) return FR_NO_PATH;		/* Cannot trace because it is a file */
		clust = ((DWORD)LD_WORD(dptr+20) << 16) | LD_WORD(dptr+26); /* Get cluster# of the directory */
		dirobj->clust = dirobj->sclust = clust;				/* Restart scanning at the new directory */
		dirobj->sect = clust2sect(fs, clust);
		dirobj->index = 0;
	}
}




/*-----------------------------------------------------------------------*/
/* Reserve a Directory Entry                                             */
/*-----------------------------------------------------------------------*/

#if _FS_READONLY == 0
static
BYTE* reserve_direntry (	/* !=NULL: successful, NULL: failed */
	DIR *dirobj				/* Target directory to create new entry */
)
{
	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 NULL;
		dptr = &fs->win[(dirobj->index & 15) * 32];		/* Pointer to the directory entry */
		c = *dptr;
		if (c == 0 || c == 0xE5) return dptr;			/* Found an empty entry! */
	} 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 NULL;
	if (!move_window(fs, 0)) return 0;

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




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

static
BYTE check_fs (		/* 0:Not a boot record, 1:Valid boot record but not a FAT, 2:FAT boot record */
	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 0;
	if (LD_WORD(&fs->win[510]) != 0xAA55)					/* Check record signature */
		return 0;

	if (!memcmp(&fs->win[54], "FAT", 3))					/* Check FAT signature */
		return 2;
	if (!memcmp(&fs->win[82], "FAT32", 5) && !(fs->win[40] & 0x80))
		return 2;

	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 wrinting fuctions */
)
{
	BYTE drv, fmt;
	DSTATUS stat;
	DWORD basesect, 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';		/* 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, select drive 0 in 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 */

	/* Chekck 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 == 0
			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 _FS_READONLY == 0
	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, basesect = 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 */
		if (fs->win[0x1C2]) {						/* Is the 1st partition existing? */
			basesect = LD_DWORD(&fs->win[0x1C6]);	/* Partition offset in LBA */
			fmt = check_fs(fs, basesect);			/* Check the partition */
		}
	}
	if (fmt != 2 || fs->win[12] != 2)			/* No valid FAT patition is found */
		return FR_NO_FILESYSTEM;

	/* Initialize the file system object */
	fatsize = LD_WORD(&fs->win[22]);					/* Number of sectors per FAT */
	if (!fatsize) fatsize = LD_DWORD(&fs->win[36]);
	fs->sects_fat = fatsize;
	fs->n_fats = fs->win[16];							/* Number of FAT copies */
	fatsize *= fs->n_fats;		/* Number of sectors in FAT area */
	fs->fatbase = basesect += LD_WORD(&fs->win[14]);	/* FAT start sector (lba) */
	basesect += fatsize;		/* Next sector of FAT area (lba) */
	fs->sects_clust = fs->win[13];						/* Number of sectors per cluster */
	fs->n_rootdir = LD_WORD(&fs->win[17]);				/* Nmuber of root directory entries */
	totalsect = LD_WORD(&fs->win[19]);					/* Number of sectors on the file system */
	if (!totalsect) totalsect = LD_DWORD(&fs->win[32]);
	fs->max_clust = maxclust = (totalsect				/* Last cluster# + 1 */
		- LD_WORD(&fs->win[14]) - fatsize - fs->n_rootdir / 16
		) / fs->sects_clust + 2;
	fmt = FS_FAT12;										/* Determins the FAT type */
	if (maxclust >= 0xFF7) fmt = FS_FAT16;
	if (maxclust >= 0xFFF7) fmt = FS_FAT32;
	if (fmt == FS_FAT32)
		fs->dirbase = LD_DWORD(&fs->win[44]);			/* Root directory start cluster */
	else
		fs->dirbase = basesect;							/* Root directory start sector (lba) */
	fs->database = basesect + fs->n_rootdir / 16;		/* Data start sector (lba) */

	fs->fs_type = fmt;									/* FAT type */
	fs->id = ++fsid;									/* File system mount ID */

	return FR_OK;
}




/*-----------------------------------------------------------------------*/
/* Check if the file/dir object is valid or not                          */
/*-----------------------------------------------------------------------*/

static
FRESULT validate (		/* FR_OK(0): The object is valid, !=0: Not valid */
	const FATFS *fs,	/* Pointer to the file system object */
	WORD id				/* id member of the target object to be checked */
)
{
	if (!fs || (WORD)~fs->id != id)
		return FR_INVALID_OBJECT;
	if (disk_status(fs->drive) & STA_NOINIT)
		return FR_NOT_READY;

	return FR_OK;
}




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

   Public Functions

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



/*-----------------------------------------------------------------------*/
/* Mount/Unmount a Locical Drive                                         */
/*-----------------------------------------------------------------------*/

FRESULT f_mount (
	BYTE drv,		/* Logical drive number to be mounted/unmounted */
	FATFS *fs		/* Pointer to new file system object (NULL for unmount)*/
)
{
	FATFS *fsobj;


	if (drv >= _DRIVES) return FR_INVALID_DRIVE;
	fsobj = FatFs[drv];
	FatFs[drv] = fs;
	if (fsobj) memset(fsobj, 0, sizeof(FATFS));
	if (fs) memset(fs, 0, sizeof(FATFS));

	return FR_OK;
}




/*-----------------------------------------------------------------------*/
/* Open or Create a File                                                 */
/*-----------------------------------------------------------------------*/

FRESULT f_open (
	FIL *fp,			/* Pointer to the blank file object */
	const char *path,	/* Pointer to the file name */
	BYTE mode			/* Access mode and file open mode flags */
)
{
	FRESULT res;
	BYTE *dir;
	DIR dirobj;
	char fn[8+3+1];
	FATFS *fs;


#if _FS_READONLY == 0
	res = auto_mount(&path, &fs, mode & (FA_WRITE|FA_CREATE_ALWAYS|FA_OPEN_ALWAYS));
#else
	res = auto_mount(&path, &fs, 0);
#endif
	if (res != FR_OK) return res;

	/* Trace the file path */
	dirobj.fs = fs;
	res = trace_path(&dirobj, fn, path, &dir);

#if _FS_READONLY == 0
	/* Create or Open a File */
	if (mode & (FA_CREATE_ALWAYS|FA_OPEN_ALWAYS)) {
		DWORD ps, rs;
		if (res != FR_OK) {		/* No file, create new */
			mode |= FA_CREATE_ALWAYS;
			if (res != FR_NO_FILE) return res;
			dir = reserve_direntry(&dirobj);	/* Reserve a directory entry */
			if (dir == NULL) return FR_DENIED;
			memset(dir, 0, 32);		/* Initialize the new entry */
			memcpy(dir, fn, 8+3);
			*(dir+12) = fn[11];
		} else {				/* Any object is already existing */
			if (dir == NULL || (*(dir+11) & (AM_RDO|AM_DIR)))	/* Could not overwrite (R/O or DIR) */
				return FR_DENIED;
			if (mode & FA_CREATE_ALWAYS) {	/* Resize it to zero */
				rs = ((DWORD)LD_WORD(dir+20) << 16) | LD_WORD(dir+26);
				ST_WORD(dir+20, 0); ST_WORD(dir+26, 0);	/* cluster = 0 */
				ST_DWORD(dir+28, 0);					/* size = 0 */
				fs->winflag = 1;
				ps = fs->winsect;						/* Remove the cluster chain */
				if (!remove_chain(fs, rs) || !move_window(fs, ps))
					return FR_RW_ERROR;
			}
		}
		if (mode & FA_CREATE_ALWAYS) {
			*(dir+11) = AM_ARC;
			ps = get_fattime();
			ST_DWORD(dir+14, ps);	/* Created time */
			ST_DWORD(dir+22, ps);	/* Updated time */
			fs->winflag = 1;
		}
	}
	/* Open a File */
	else {
#endif /* _FS_READONLY */
		if (res != FR_OK) return res;		/* Trace failed */
		if (dir == NULL || (*(dir+11) & AM_DIR))	/* It is a directory */
			return FR_NO_FILE;
#if _FS_READONLY == 0
		if ((mode & FA_WRITE) && (*(dir+11) & AM_RDO)) /* R/O violation */
			return FR_DENIED;
	}
#endif

#if _FS_READONLY == 0
	fp->flag = mode & (FA_WRITE|FA_READ);
	fp->dir_sect = fs->winsect;			/* Pointer to the directory entry */
	fp->dir_ptr = dir;
#else
	fp->flag = mode & FA_READ;
#endif
	fp->org_clust =	((DWORD)LD_WORD(dir+20) << 16) | LD_WORD(dir+26);	/* File start cluster */
	fp->fsize = LD_DWORD(dir+28);		/* File size */
	fp->fptr = 0;						/* File ptr */
	fp->sect_clust = 1;					/* Sector counter */
	fp->fs = fs; fp->id = ~fs->id;		/* Owner file system object of the file */
	return FR_OK;
}




/*-----------------------------------------------------------------------*/
/* Read File                                                             */
/*-----------------------------------------------------------------------*/

FRESULT f_read (
	FIL *fp, 		/* Pointer to the file object */
	void *buff,		/* Pointer to data buffer */
	WORD btr,		/* Number of bytes to read */
	WORD *br		/* Pointer to number of bytes read */
)
{
	DWORD clust, sect, ln;
	WORD rcnt;
	BYTE cc, *rbuff = buff;
	FRESULT res;
	FATFS *fs = fp->fs;


	*br = 0;
	res = validate(fs, fp->id);