ff.h File Reference

#include <typedefs.h>
#include "ffconf.h"

Include dependency graph for ff.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	FATFS
struct	FIL
struct	DIR
struct	FILINFO

Macros
#define	_FATFS   64180 /* Revision ID */
#define	LD2PD(vol)   (BYTE)(vol) /* Each logical drive is bound to the same physical drive number */
#define	LD2PT(vol)   0 /* Find first valid partition or in SFD */
#define	_T(x)   x
#define	_TEXT(x)   x
#define	f_eof(fp)   ((int)((fp)->fptr == (fp)->fsize))
#define	f_error(fp)   ((fp)->err)
#define	f_tell(fp)   ((fp)->fptr)
#define	f_size(fp)   ((fp)->fsize)
#define	f_rewind(fp)   f_lseek((fp), 0)
#define	f_rewinddir(dp)   f_readdir((dp), 0)
#define	EOF   (-1)
#define	FA_READ   0x01
#define	FA_OPEN_EXISTING   0x00
#define	FA_WRITE   0x02
#define	FA_CREATE_NEW   0x04
#define	FA_CREATE_ALWAYS   0x08
#define	FA_OPEN_ALWAYS   0x10
#define	FA__WRITTEN   0x20
#define	FA__DIRTY   0x40
#define	FS_FAT12   1
#define	FS_FAT16   2
#define	FS_FAT32   3
#define	AM_RDO   0x01 /* Read only */
#define	AM_HID   0x02 /* Hidden */
#define	AM_SYS   0x04 /* System */
#define	AM_VOL   0x08 /* Volume label */
#define	AM_LFN   0x0F /* LFN entry */
#define	AM_DIR   0x10 /* Directory */
#define	AM_ARC   0x20 /* Archive */
#define	AM_MASK   0x3F /* Mask of defined bits */
#define	CREATE_LINKMAP   0xFFFFFFFF
#define	LD_WORD(ptr)   (WORD)(((WORD)*((BYTE*)(ptr)+1)<<8)|(WORD)*(BYTE*)(ptr))
#define	LD_DWORD(ptr)   (DWORD)(((DWORD)*((BYTE*)(ptr)+3)<<24)|((DWORD)*((BYTE*)(ptr)+2)<<16)|((WORD)*((BYTE*)(ptr)+1)<<8)|*(BYTE*)(ptr))
#define	ST_WORD(ptr, val)   *(BYTE*)(ptr)=(BYTE)(val); *((BYTE*)(ptr)+1)=(BYTE)((WORD)(val)>>8)
#define	ST_DWORD(ptr, val)   *(BYTE*)(ptr)=(BYTE)(val); *((BYTE*)(ptr)+1)=(BYTE)((WORD)(val)>>8); *((BYTE*)(ptr)+2)=(BYTE)((DWORD)(val)>>16); *((BYTE*)(ptr)+3)=(BYTE)((DWORD)(val)>>24)

Typedefs
typedef char	TCHAR

Enumerations
enum	FRESULT {   FR_OK = 0 , FR_DISK_ERR , FR_INT_ERR , FR_NOT_READY ,   FR_NO_FILE , FR_NO_PATH , FR_INVALID_NAME , FR_DENIED ,   FR_EXIST , FR_INVALID_OBJECT , FR_WRITE_PROTECTED , FR_INVALID_DRIVE ,   FR_NOT_ENABLED , FR_NO_FILESYSTEM , FR_MKFS_ABORTED , FR_TIMEOUT ,   FR_LOCKED , FR_NOT_ENOUGH_CORE , FR_TOO_MANY_OPEN_FILES , FR_INVALID_PARAMETER }

Functions
FRESULT	f_open (FIL *fp, const TCHAR *path, BYTE mode)
FRESULT	f_close (FIL *fp)
FRESULT	f_read (FIL *fp, void *buff, UINT btr, UINT *br)
FRESULT	f_write (FIL *fp, const void *buff, UINT btw, UINT *bw)
FRESULT	f_forward (FIL *fp, UINT(*func)(const BYTE *, UINT), UINT btf, UINT *bf)
FRESULT	f_lseek (FIL *fp, DWORD ofs)
FRESULT	f_truncate (FIL *fp)
FRESULT	f_sync (FIL *fp)
FRESULT	f_opendir (DIR *dp, const TCHAR *path)
FRESULT	f_closedir (DIR *dp)
FRESULT	f_readdir (DIR *dp, FILINFO *fno)
FRESULT	f_findfirst (DIR *dp, FILINFO *fno, const TCHAR *path, const TCHAR *pattern)
FRESULT	f_findnext (DIR *dp, FILINFO *fno)
FRESULT	f_mkdir (const TCHAR *path)
FRESULT	f_unlink (const TCHAR *path)
FRESULT	f_rename (const TCHAR *path_old, const TCHAR *path_new)
FRESULT	f_stat (const TCHAR *path, FILINFO *fno)
FRESULT	f_chmod (const TCHAR *path, BYTE attr, BYTE mask)
FRESULT	f_utime (const TCHAR *path, const FILINFO *fno)
FRESULT	f_chdir (const TCHAR *path)
FRESULT	f_chdrive (const TCHAR *path)
FRESULT	f_getcwd (TCHAR *buff, UINT len)
FRESULT	f_getfree (const TCHAR *path, DWORD *nclst, FATFS **fatfs)
FRESULT	f_getlabel (const TCHAR *path, TCHAR *label, DWORD *vsn)
FRESULT	f_setlabel (const TCHAR *label)
FRESULT	f_mount (FATFS *fs, const TCHAR *path, BYTE opt)
FRESULT	f_mkfs (const TCHAR *path, BYTE sfd, UINT au)
FRESULT	f_fdisk (BYTE pdrv, const DWORD szt[], void *work)
int	f_putc (TCHAR c, FIL *fp)
int	f_puts (const TCHAR *str, FIL *cp)
int	f_printf (FIL *fp, const TCHAR *str,...)
TCHAR *	f_gets (TCHAR *buff, int len, FIL *fp)
DWORD	get_fattime (void)
WCHAR	ff_convert (WCHAR chr, UINT dir)
WCHAR	ff_wtoupper (WCHAR chr)

Macro Definition Documentation

_FATFS

#define _FATFS   64180 /* Revision ID */

Definition at line 20 of file ff.h.

_T

#define _T

(

x

)

x

Definition at line 68 of file ff.h.

_TEXT

#define _TEXT

(

x

)

x

Definition at line 69 of file ff.h.

AM_ARC

#define AM_ARC   0x20 /* Archive */

Definition at line 322 of file ff.h.

AM_DIR

#define AM_DIR   0x10 /* Directory */

Definition at line 321 of file ff.h.

AM_HID

#define AM_HID   0x02 /* Hidden */

Definition at line 317 of file ff.h.

AM_LFN

#define AM_LFN   0x0F /* LFN entry */

Definition at line 320 of file ff.h.

AM_MASK

#define AM_MASK   0x3F /* Mask of defined bits */

Definition at line 323 of file ff.h.

AM_RDO

#define AM_RDO   0x01 /* Read only */

Definition at line 316 of file ff.h.

AM_SYS

#define AM_SYS   0x04 /* System */

Definition at line 318 of file ff.h.

AM_VOL

#define AM_VOL   0x08 /* Volume label */

Definition at line 319 of file ff.h.

CREATE_LINKMAP

#define CREATE_LINKMAP   0xFFFFFFFF

Definition at line 327 of file ff.h.

EOF

#define EOF   (-1)

Definition at line 253 of file ff.h.

f_eof

#define f_eof

(

fp

)

((int)((fp)->fptr == (fp)->fsize))

Definition at line 245 of file ff.h.

f_error

#define f_error

(

fp

)

((fp)->err)

Definition at line 246 of file ff.h.

f_rewind

#define f_rewind

(

fp

)

f_lseek((fp), 0)

Definition at line 249 of file ff.h.

f_rewinddir

#define f_rewinddir

(

dp

)

f_readdir((dp), 0)

Definition at line 250 of file ff.h.

f_size

#define f_size

(

fp

)

((fp)->fsize)

Definition at line 248 of file ff.h.

f_tell

#define f_tell

(

fp

)

((fp)->fptr)

Definition at line 247 of file ff.h.

FA__DIRTY

#define FA__DIRTY   0x40

Definition at line 303 of file ff.h.

FA__WRITTEN

#define FA__WRITTEN   0x20

Definition at line 302 of file ff.h.

FA_CREATE_ALWAYS

#define FA_CREATE_ALWAYS   0x08

Definition at line 300 of file ff.h.

FA_CREATE_NEW

#define FA_CREATE_NEW   0x04

Definition at line 299 of file ff.h.

FA_OPEN_ALWAYS

#define FA_OPEN_ALWAYS   0x10

Definition at line 301 of file ff.h.

FA_OPEN_EXISTING

#define FA_OPEN_EXISTING   0x00

Definition at line 295 of file ff.h.

FA_READ

#define FA_READ   0x01

Definition at line 294 of file ff.h.

FA_WRITE

#define FA_WRITE   0x02

Definition at line 298 of file ff.h.

FS_FAT12

#define FS_FAT12   1

Definition at line 309 of file ff.h.

FS_FAT16

#define FS_FAT16   2

Definition at line 310 of file ff.h.

FS_FAT32

#define FS_FAT32   3

Definition at line 311 of file ff.h.

LD2PD

#define LD2PD

(

vol

)

(BYTE)(vol) /* Each logical drive is bound to the same physical drive number */

Definition at line 46 of file ff.h.

LD2PT

#define LD2PT

(

vol

)

0 /* Find first valid partition or in SFD */

Definition at line 47 of file ff.h.

LD_DWORD

#define LD_DWORD

(

ptr

)

(DWORD)(((DWORD)*((BYTE*)(ptr)+3)<<24)|((DWORD)*((BYTE*)(ptr)+2)<<16)|((WORD)*((BYTE*)(ptr)+1)<<8)|*(BYTE*)(ptr))

Definition at line 341 of file ff.h.

LD_WORD

#define LD_WORD

(

ptr

)

(WORD)(((WORD)*((BYTE*)(ptr)+1)<<8)|(WORD)*(BYTE*)(ptr))

Definition at line 340 of file ff.h.

ST_DWORD

#define ST_DWORD	(		ptr,
			val
	)		*(BYTE*)(ptr)=(BYTE)(val); *((BYTE*)(ptr)+1)=(BYTE)((WORD)(val)>>8); *((BYTE*)(ptr)+2)=(BYTE)((DWORD)(val)>>16); *((BYTE*)(ptr)+3)=(BYTE)((DWORD)(val)>>24)

Definition at line 343 of file ff.h.

ST_WORD

#define ST_WORD	(		ptr,
			val
	)		*(BYTE*)(ptr)=(BYTE)(val); *((BYTE*)(ptr)+1)=(BYTE)((WORD)(val)>>8)

Definition at line 342 of file ff.h.

Typedef Documentation

TCHAR

typedef char TCHAR

Definition at line 67 of file ff.h.

Enumeration Type Documentation

FRESULT

enum FRESULT

Enumerator
FR_OK
FR_DISK_ERR
FR_INT_ERR
FR_NOT_READY
FR_NO_FILE
FR_NO_PATH
FR_INVALID_NAME
FR_DENIED
FR_EXIST
FR_INVALID_OBJECT
FR_WRITE_PROTECTED
FR_INVALID_DRIVE
FR_NOT_ENABLED
FR_NO_FILESYSTEM
FR_MKFS_ABORTED
FR_TIMEOUT
FR_LOCKED
FR_NOT_ENOUGH_CORE
FR_TOO_MANY_OPEN_FILES
FR_INVALID_PARAMETER

Definition at line 184 of file ff.h.

             {
    FR_OK = 0,              /* (0) Succeeded */
    FR_DISK_ERR,            /* (1) A hard error occurred in the low level disk I/O layer */
    FR_INT_ERR,             /* (2) Assertion failed */
    FR_NOT_READY,           /* (3) The physical drive cannot work */
    FR_NO_FILE,             /* (4) Could not find the file */
    FR_NO_PATH,             /* (5) Could not find the path */
    FR_INVALID_NAME,        /* (6) The path name format is invalid */
    FR_DENIED,              /* (7) Access denied due to prohibited access or directory full */
    FR_EXIST,               /* (8) Access denied due to prohibited access */
    FR_INVALID_OBJECT,      /* (9) The file/directory object is invalid */
    FR_WRITE_PROTECTED,     /* (10) The physical drive is write protected */
    FR_INVALID_DRIVE,       /* (11) The logical drive number is invalid */
    FR_NOT_ENABLED,         /* (12) The volume has no work area */
    FR_NO_FILESYSTEM,       /* (13) There is no valid FAT volume */
    FR_MKFS_ABORTED,        /* (14) The f_mkfs() aborted due to any parameter error */
    FR_TIMEOUT,             /* (15) Could not get a grant to access the volume within defined period */
    FR_LOCKED,              /* (16) The operation is rejected according to the file sharing policy */
    FR_NOT_ENOUGH_CORE,     /* (17) LFN working buffer could not be allocated */
    FR_TOO_MANY_OPEN_FILES, /* (18) Number of open files > _FS_LOCK */
    FR_INVALID_PARAMETER    /* (19) Given parameter is invalid */
} FRESULT;

Function Documentation

f_chdir()

FRESULT f_chdir

(

const TCHAR *

path

)

f_chdrive()

FRESULT f_chdrive

(

const TCHAR *

path

)

f_chmod()

FRESULT f_chmod	(	const TCHAR *	path,
		BYTE	attr,
		BYTE	mask
	)

Definition at line 3671 of file ff.c.

{
    FRESULT res;
    DIR dj;
    BYTE *dir;
    DEFINE_NAMEBUF;
 
 
    res = find_volume(&dj.fs, &path, 1);    /* Get logical drive number */
    if (res == FR_OK) {
        INIT_BUF(dj);
        res = follow_path(&dj, path);       /* Follow the file path */
        FREE_BUF();
        if (_FS_RPATH && res == FR_OK && (dj.fn[NSFLAG] & NS_DOT))
            res = FR_INVALID_NAME;
        if (res == FR_OK) {
            dir = dj.dir;
            if (!dir) {                     /* Is it a root directory? */
                res = FR_INVALID_NAME;
            } else {                        /* File or sub directory */
                mask &= AM_RDO|AM_HID|AM_SYS|AM_ARC;    /* Valid attribute mask */
                dir[DIR_Attr] = (attr & mask) | (dir[DIR_Attr] & (BYTE)~mask);  /* Apply attribute change */
                dj.fs->wflag = 1;
                res = sync_fs(dj.fs);
            }
        }
    }
 
    LEAVE_FF(dj.fs, res);
}

f_close()

FRESULT f_close

(

FIL *

fp

)

Definition at line 2857 of file ff.c.

{
    FRESULT res;
 
 
#if !_FS_READONLY
    res = f_sync(fp);                   /* Flush cached data */
    if (res == FR_OK)
#endif
    {
        res = validate(fp);             /* Lock volume */
        if (res == FR_OK) {
#if _FS_REENTRANT
            FATFS *fs = fp->fs;
#endif
#if _FS_LOCK
            res = dec_lock(fp->lockid); /* Decrement file open counter */
            if (res == FR_OK)
#endif
                fp->fs = 0;             /* Invalidate file object */
#if _FS_REENTRANT
            unlock_fs(fs, FR_OK);       /* Unlock volume */
#endif
        }
    }
    return res;
}

Referenced by main().

f_closedir()

FRESULT f_closedir

(

DIR *

dp

)

Definition at line 3243 of file ff.c.

{
    FRESULT res;
 
 
    res = validate(dp);
    if (res == FR_OK) {
#if _FS_REENTRANT
        FATFS *fs = dp->fs;
#endif
#if _FS_LOCK
        if (dp->lockid)             /* Decrement sub-directory open counter */
            res = dec_lock(dp->lockid);
        if (res == FR_OK)
#endif
            dp->fs = 0;             /* Invalidate directory object */
#if _FS_REENTRANT
        unlock_fs(fs, FR_OK);       /* Unlock volume */
#endif
    }
    return res;
}

f_fdisk()

FRESULT f_fdisk	(	BYTE	pdrv,
		const DWORD	szt[],
		void *	work
	)

f_findfirst()

FRESULT f_findfirst	(	DIR *	dp,
		FILINFO *	fno,
		const TCHAR *	path,
		const TCHAR *	pattern
	)

f_findnext()

FRESULT f_findnext	(	DIR *	dp,
		FILINFO *	fno
	)

f_forward()

FRESULT f_forward	(	FIL *	fp,
		UINT(*)(const BYTE *, UINT)	func,
		UINT	btf,
		UINT *	bf
	)

f_getcwd()

FRESULT f_getcwd	(	TCHAR *	buff,
		UINT	len
	)

f_getfree()

FRESULT f_getfree	(	const TCHAR *	path,
		DWORD *	nclst,
		FATFS **	fatfs
	)

Definition at line 3404 of file ff.c.

{
    FRESULT res;
    FATFS *fs;
    DWORD nfree, clst, sect, stat;
    UINT i;
    BYTE fat, *p;
 
 
    /* Get logical drive number */
    res = find_volume(fatfs, &path, 0);
    fs = *fatfs;
    if (res == FR_OK) {
        /* If free_clust is valid, return it without full cluster scan */
        if (fs->free_clust <= fs->n_fatent - 2) {
            *nclst = fs->free_clust;
        } else {
            /* Get number of free clusters */
            fat = fs->fs_type;
            nfree = 0;
            if (fat == FS_FAT12) {  /* Sector unalighed entries: Search FAT via regular routine. */
                clst = 2;
                do {
                    stat = get_fat(fs, clst);
                    if (stat == 0xFFFFFFFF) { res = FR_DISK_ERR; break; }
                    if (stat == 1) { res = FR_INT_ERR; break; }
                    if (stat == 0) nfree++;
                } while (++clst < fs->n_fatent);
            } else {                /* Sector alighed entries: Accelerate the FAT search. */
                clst = fs->n_fatent; sect = fs->fatbase;
                i = 0; p = 0;
                do {
                    if (!i) {
                        res = move_window(fs, sect++);
                        if (res != FR_OK) break;
                        p = fs->win;
                        i = SS(fs);
                    }
                    if (fat == FS_FAT16) {
                        if (LD_WORD(p) == 0) nfree++;
                        p += 2; i -= 2;
                    } else {
                        if ((LD_DWORD(p) & 0x0FFFFFFF) == 0) nfree++;
                        p += 4; i -= 4;
                    }
                } while (--clst);
            }
            fs->free_clust = nfree; /* free_clust is valid */
            fs->fsi_flag |= 1;      /* FSInfo is to be updated */
            *nclst = nfree;         /* Return the free clusters */
        }
    }
    LEAVE_FF(fs, res);
}

f_getlabel()

FRESULT f_getlabel	(	const TCHAR *	path,
		TCHAR *	label,
		DWORD *	vsn
	)

Definition at line 3839 of file ff.c.

{
    FRESULT res;
    DIR dj;
    UINT i, j;
#if _USE_LFN && _LFN_UNICODE
    WCHAR w;
#endif
 
 
    /* Get logical drive number */
    res = find_volume(&dj.fs, &path, 0);
 
    /* Get volume label */
    if (res == FR_OK && label) {
        dj.sclust = 0;                  /* Open root directory */
        res = dir_sdi(&dj, 0);
        if (res == FR_OK) {
            res = dir_read(&dj, 1);     /* Get an entry with AM_VOL */
            if (res == FR_OK) {         /* A volume label is exist */
#if _USE_LFN && _LFN_UNICODE
                i = j = 0;
                do {
                    w = (i < 11) ? dj.dir[i++] : ' ';
                    if (IsDBCS1(w) && i < 11 && IsDBCS2(dj.dir[i]))
                        w = w << 8 | dj.dir[i++];
                    label[j++] = ff_convert(w, 1);  /* OEM -> Unicode */
                } while (j < 11);
#else
                mem_cpy(label, dj.dir, 11);
#endif
                j = 11;
                do {
                    label[j] = 0;
                    if (!j) break;
                } while (label[--j] == ' ');
            }
            if (res == FR_NO_FILE) {    /* No label, return nul string */
                label[0] = 0;
                res = FR_OK;
            }
        }
    }
 
    /* Get volume serial number */
    if (res == FR_OK && vsn) {
        res = move_window(dj.fs, dj.fs->volbase);
        if (res == FR_OK) {
            i = dj.fs->fs_type == FS_FAT32 ? BS_VolID32 : BS_VolID;
            *vsn = LD_DWORD(&dj.fs->win[i]);
        }
    }
 
    LEAVE_FF(dj.fs, res);
}

f_gets()

TCHAR * f_gets	(	TCHAR *	buff,
		int	len,
		FIL *	fp
	)

f_lseek()

FRESULT f_lseek	(	FIL *	fp,
		DWORD	ofs
	)

Definition at line 3029 of file ff.c.

{
    FRESULT res;
    DWORD clst, bcs, nsect, ifptr;
#if _USE_FASTSEEK
    DWORD cl, pcl, ncl, tcl, dsc, tlen, ulen, *tbl;
#endif
 
 
    res = validate(fp);                 /* Check validity of the object */
    if (res != FR_OK) LEAVE_FF(fp->fs, res);
    if (fp->err)                        /* Check error */
        LEAVE_FF(fp->fs, (FRESULT)fp->err);
 
#if _USE_FASTSEEK
    if (fp->cltbl) {    /* Fast seek */
        if (ofs == CREATE_LINKMAP) {    /* Create CLMT */
            tbl = fp->cltbl;
            tlen = *tbl++; ulen = 2;    /* Given table size and required table size */
            cl = fp->sclust;            /* Top of the chain */
            if (cl) {
                do {
                    /* Get a fragment */
                    tcl = cl; ncl = 0; ulen += 2;   /* Top, length and used items */
                    do {
                        pcl = cl; ncl++;
                        cl = get_fat(fp->fs, cl);
                        if (cl <= 1) ABORT(fp->fs, FR_INT_ERR);
                        if (cl == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
                    } while (cl == pcl + 1);
                    if (ulen <= tlen) {     /* Store the length and top of the fragment */
                        *tbl++ = ncl; *tbl++ = tcl;
                    }
                } while (cl < fp->fs->n_fatent);    /* Repeat until end of chain */
            }
            *fp->cltbl = ulen;  /* Number of items used */
            if (ulen <= tlen)
                *tbl = 0;       /* Terminate table */
            else
                res = FR_NOT_ENOUGH_CORE;   /* Given table size is smaller than required */
 
        } else {                        /* Fast seek */
            if (ofs > fp->fsize)        /* Clip offset at the file size */
                ofs = fp->fsize;
            fp->fptr = ofs;             /* Set file pointer */
            if (ofs) {
                fp->clust = clmt_clust(fp, ofs - 1);
                dsc = clust2sect(fp->fs, fp->clust);
                if (!dsc) ABORT(fp->fs, FR_INT_ERR);
                dsc += (ofs - 1) / SS(fp->fs) & (fp->fs->csize - 1);
                if (fp->fptr % SS(fp->fs) && dsc != fp->dsect) {    /* Refill sector cache if needed */
#if !_FS_TINY
#if !_FS_READONLY
                    if (fp->flag & FA__DIRTY) {     /* Write-back dirty sector cache */
                        if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) != RES_OK)
                            ABORT(fp->fs, FR_DISK_ERR);
                        fp->flag &= ~FA__DIRTY;
                    }
#endif
                    if (disk_read(fp->fs->drv, fp->buf, dsc, 1) != RES_OK)  /* Load current sector */
                        ABORT(fp->fs, FR_DISK_ERR);
#endif
                    fp->dsect = dsc;
                }
            }
        }
    } else
#endif
 
    /* Normal Seek */
    {
        if (ofs > fp->fsize                 /* In read-only mode, clip offset with the file size */
#if !_FS_READONLY
             && !(fp->flag & FA_WRITE)
#endif
            ) ofs = fp->fsize;
 
        ifptr = fp->fptr;
        fp->fptr = nsect = 0;
        if (ofs) {
            bcs = (DWORD)fp->fs->csize * SS(fp->fs);    /* Cluster size (byte) */
            if (ifptr > 0 &&
                (ofs - 1) / bcs >= (ifptr - 1) / bcs) { /* When seek to same or following cluster, */
                fp->fptr = (ifptr - 1) & ~(bcs - 1);    /* start from the current cluster */
                ofs -= fp->fptr;
                clst = fp->clust;
            } else {                                    /* When seek to back cluster, */
                clst = fp->sclust;                      /* start from the first cluster */
#if !_FS_READONLY
                if (clst == 0) {                        /* If no cluster chain, create a new chain */
                    clst = create_chain(fp->fs, 0);
                    if (clst == 1) ABORT(fp->fs, FR_INT_ERR);
                    if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
                    fp->sclust = clst;
                }
#endif
                fp->clust = clst;
            }
            if (clst != 0) {
                while (ofs > bcs) {                     /* Cluster following loop */
#if !_FS_READONLY
                    if (fp->flag & FA_WRITE) {          /* Check if in write mode or not */
                        clst = create_chain(fp->fs, clst);  /* Force stretch if in write mode */
                        if (clst == 0) {                /* When disk gets full, clip file size */
                            ofs = bcs; break;
                        }
                    } else
#endif
                        clst = get_fat(fp->fs, clst);   /* Follow cluster chain if not in write mode */
                    if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
                    if (clst <= 1 || clst >= fp->fs->n_fatent) ABORT(fp->fs, FR_INT_ERR);
                    fp->clust = clst;
                    fp->fptr += bcs;
                    ofs -= bcs;
                }
                fp->fptr += ofs;
                if (ofs % SS(fp->fs)) {
                    nsect = clust2sect(fp->fs, clst);   /* Current sector */
                    if (!nsect) ABORT(fp->fs, FR_INT_ERR);
                    nsect += ofs / SS(fp->fs);
                }
            }
        }
        if (fp->fptr % SS(fp->fs) && nsect != fp->dsect) {  /* Fill sector cache if needed */
#if !_FS_TINY
#if !_FS_READONLY
            if (fp->flag & FA__DIRTY) {         /* Write-back dirty sector cache */
                if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) != RES_OK)
                    ABORT(fp->fs, FR_DISK_ERR);
                fp->flag &= ~FA__DIRTY;
            }
#endif
            if (disk_read(fp->fs->drv, fp->buf, nsect, 1) != RES_OK)    /* Fill sector cache */
                ABORT(fp->fs, FR_DISK_ERR);
#endif
            fp->dsect = nsect;
        }
#if !_FS_READONLY
        if (fp->fptr > fp->fsize) {         /* Set file change flag if the file size is extended */
            fp->fsize = fp->fptr;
            fp->flag |= FA__WRITTEN;
        }
#endif
    }
 
    LEAVE_FF(fp->fs, res);
}

f_mkdir()

FRESULT f_mkdir

(

const TCHAR *

path

)

Definition at line 3595 of file ff.c.

{
    FRESULT res;
    DIR dj;
    BYTE *dir, n;
    DWORD dsc, dcl, pcl, tm = GET_FATTIME();
    DEFINE_NAMEBUF;
 
 
    /* Get logical drive number */
    res = find_volume(&dj.fs, &path, 1);
    if (res == FR_OK) {
        INIT_BUF(dj);
        res = follow_path(&dj, path);           /* Follow the file path */
        if (res == FR_OK) res = FR_EXIST;       /* Any object with same name is already existing */
        if (_FS_RPATH && res == FR_NO_FILE && (dj.fn[NSFLAG] & NS_DOT))
            res = FR_INVALID_NAME;
        if (res == FR_NO_FILE) {                /* Can create a new directory */
            dcl = create_chain(dj.fs, 0);       /* Allocate a cluster for the new directory table */
            res = FR_OK;
            if (dcl == 0) res = FR_DENIED;      /* No space to allocate a new cluster */
            if (dcl == 1) res = FR_INT_ERR;
            if (dcl == 0xFFFFFFFF) res = FR_DISK_ERR;
            if (res == FR_OK)                   /* Flush FAT */
                res = sync_window(dj.fs);
            if (res == FR_OK) {                 /* Initialize the new directory table */
                dsc = clust2sect(dj.fs, dcl);
                dir = dj.fs->win;
                mem_set(dir, 0, SS(dj.fs));
                mem_set(dir + DIR_Name, ' ', 11);   /* Create "." entry */
                dir[DIR_Name] = '.';
                dir[DIR_Attr] = AM_DIR;
                ST_DWORD(dir + DIR_CrtTime, tm);
                ST_DWORD(dir + DIR_WrtTime, tm);
                st_clust(dir, dcl);
                mem_cpy(dir + SZ_DIRE, dir, SZ_DIRE);   /* Create ".." entry */
                dir[SZ_DIRE + 1] = '.'; pcl = dj.sclust;
                if (dj.fs->fs_type == FS_FAT32 && pcl == dj.fs->dirbase)
                    pcl = 0;
                st_clust(dir + SZ_DIRE, pcl);
                for (n = dj.fs->csize; n; n--) {    /* Write dot entries and clear following sectors */
                    dj.fs->winsect = dsc++;
                    dj.fs->wflag = 1;
                    res = sync_window(dj.fs);
                    if (res != FR_OK) break;
                    mem_set(dir, 0, SS(dj.fs));
                }
            }
            if (res == FR_OK) res = dir_register(&dj);  /* Register the object to the directoy */
            if (res != FR_OK) {
                remove_chain(dj.fs, dcl);           /* Could not register, remove cluster chain */
            } else {
                dir = dj.dir;
                dir[DIR_Attr] = AM_DIR;             /* Attribute */
                ST_DWORD(dir + DIR_CrtTime, tm);    /* Created time */
                ST_DWORD(dir + DIR_WrtTime, tm);    /* Modified time */
                st_clust(dir, dcl);                 /* Table start cluster */
                dj.fs->wflag = 1;
                res = sync_fs(dj.fs);
            }
        }
        FREE_BUF();
    }
 
    LEAVE_FF(dj.fs, res);
}

Referenced by main().

f_mkfs()

FRESULT f_mkfs	(	const TCHAR *	path,
		BYTE	sfd,
		UINT	au
	)

Definition at line 4068 of file ff.c.

{
    static const WORD vst[] = { 1024,   512,  256,  128,   64,    32,   16,    8,    4,    2,   0};
    static const WORD cst[] = {32768, 16384, 8192, 4096, 2048, 16384, 8192, 4096, 2048, 1024, 512};
    int vol;
    BYTE fmt, md, sys, *tbl, pdrv, part;
    DWORD n_clst, vs, n, wsect;
    UINT i;
    DWORD b_vol, b_fat, b_dir, b_data;  /* LBA */
    DWORD n_vol, n_rsv, n_fat, n_dir;   /* Size */
    FATFS *fs;
    DSTATUS stat;
#if _USE_TRIM
    DWORD eb[2];
#endif
 
 
    /* Check mounted drive and clear work area */
    if (sfd > 1) return FR_INVALID_PARAMETER;
    vol = get_ldnumber(&path);
    if (vol < 0) return FR_INVALID_DRIVE;
    fs = FatFs[vol];
    if (!fs) return FR_NOT_ENABLED;
    fs->fs_type = 0;
    pdrv = LD2PD(vol);  /* Physical drive */
    part = LD2PT(vol);  /* Partition (0:auto detect, 1-4:get from partition table)*/
 
    /* Get disk statics */
    stat = disk_initialize(pdrv);
    if (stat & STA_NOINIT) return FR_NOT_READY;
    if (stat & STA_PROTECT) return FR_WRITE_PROTECTED;
#if _MAX_SS != _MIN_SS      /* Get disk sector size */
    if (disk_ioctl(pdrv, GET_SECTOR_SIZE, &SS(fs)) != RES_OK || SS(fs) > _MAX_SS || SS(fs) < _MIN_SS)
        return FR_DISK_ERR;
#endif
    if (_MULTI_PARTITION && part) {
        /* Get partition information from partition table in the MBR */
        if (disk_read(pdrv, fs->win, 0, 1) != RES_OK) return FR_DISK_ERR;
        if (LD_WORD(fs->win + BS_55AA) != 0xAA55) return FR_MKFS_ABORTED;
        tbl = &fs->win[MBR_Table + (part - 1) * SZ_PTE];
        if (!tbl[4]) return FR_MKFS_ABORTED;    /* No partition? */
        b_vol = LD_DWORD(tbl + 8);  /* Volume start sector */
        n_vol = LD_DWORD(tbl + 12); /* Volume size */
    } else {
        /* Create a partition in this function */
        if (disk_ioctl(pdrv, GET_SECTOR_COUNT, &n_vol) != RES_OK || n_vol < 128)
            return FR_DISK_ERR;
        b_vol = (sfd) ? 0 : 63;     /* Volume start sector */
        n_vol -= b_vol;             /* Volume size */
    }
 
    if (au & (au - 1)) au = 0;
    if (!au) {                      /* AU auto selection */
        vs = n_vol / (2000 / (SS(fs) / 512));
        for (i = 0; vs < vst[i]; i++) ;
        au = cst[i];
    }
    if (au >= _MIN_SS) au /= SS(fs);    /* Number of sectors per cluster */
    if (!au) au = 1;
    if (au > 128) au = 128;
 
    /* Pre-compute number of clusters and FAT sub-type */
    n_clst = n_vol / au;
    fmt = FS_FAT12;
    if (n_clst >= MIN_FAT16) fmt = FS_FAT16;
    if (n_clst >= MIN_FAT32) fmt = FS_FAT32;
 
    /* Determine offset and size of FAT structure */
    if (fmt == FS_FAT32) {
        n_fat = ((n_clst * 4) + 8 + SS(fs) - 1) / SS(fs);
        n_rsv = 32;
        n_dir = 0;
    } else {
        n_fat = (fmt == FS_FAT12) ? (n_clst * 3 + 1) / 2 + 3 : (n_clst * 2) + 4;
        n_fat = (n_fat + SS(fs) - 1) / SS(fs);
        n_rsv = 1;
        if (fmt == FS_FAT12)
            n_dir = (DWORD)N_ROOTDIR12 * SZ_DIRE / SS(fs);
        else
            n_dir = (DWORD)N_ROOTDIR16 * SZ_DIRE / SS(fs);
    }
    b_fat = b_vol + n_rsv;              /* FAT area start sector */
    b_dir = b_fat + n_fat * N_FATS;     /* Directory area start sector */
    b_data = b_dir + n_dir;             /* Data area start sector */
    if (n_vol < b_data + au - b_vol) return FR_MKFS_ABORTED;    /* Too small volume */
 
    /* Align data start sector to erase block boundary (for flash memory media) */
    if (disk_ioctl(pdrv, GET_BLOCK_SIZE, &n) != RES_OK || !n || n > 32768) n = 1;
    n = (b_data + n - 1) & ~(n - 1);    /* Next nearest erase block from current data start */
    n = (n - b_data) / N_FATS;
    if (fmt == FS_FAT32) {      /* FAT32: Move FAT offset */
        n_rsv += n;
        b_fat += n;
    } else if (fmt == FS_FAT16) {   /* FAT16: Expand FAT size */
        n_fat += n;
    } // else /* if (fmt == FS_FAT12) */ {} /* FAT12: Do nothing */
 
    /* Determine number of clusters and final check of validity of the FAT sub-type */
    n_clst = (n_vol - n_rsv - n_fat * N_FATS - n_dir) / au;
    if (   (fmt == FS_FAT16 && n_clst < MIN_FAT16)
        || (fmt == FS_FAT32 && n_clst < MIN_FAT32))
        return FR_MKFS_ABORTED;
 
    /* Determine system ID in the partition table */
    if (fmt == FS_FAT32) {
        sys = 0x0C;     /* FAT32X */
    } else {
        if (fmt == FS_FAT12 && n_vol < 0x10000) {
            sys = 0x01; /* FAT12(<65536) */
        } else {
            sys = (n_vol < 0x10000) ? 0x04 : 0x06;  /* FAT16(<65536) : FAT12/16(>=65536) */
        }
    }
 
    if (_MULTI_PARTITION && part) {
        /* Update system ID in the partition table */
        tbl = &fs->win[MBR_Table + (part - 1) * SZ_PTE];
        tbl[4] = sys;
        if (disk_write(pdrv, fs->win, 0, 1) != RES_OK)  /* Write it to teh MBR */
            return FR_DISK_ERR;
        md = 0xF8;
    } else {
        if (sfd) {  /* No partition table (SFD) */
            md = 0xF0;
        } else {    /* Create partition table (FDISK) */
            mem_set(fs->win, 0, SS(fs));
            tbl = fs->win + MBR_Table;  /* Create partition table for single partition in the drive */
            tbl[1] = 1;                     /* Partition start head */
            tbl[2] = 1;                     /* Partition start sector */
            tbl[3] = 0;                     /* Partition start cylinder */
            tbl[4] = sys;                   /* System type */
            tbl[5] = 254;                   /* Partition end head */
            n = (b_vol + n_vol) / 63 / 255;
            tbl[6] = (BYTE)(n >> 2 | 63);   /* Partition end sector */
            tbl[7] = (BYTE)n;               /* End cylinder */
            ST_DWORD(tbl + 8, 63);          /* Partition start in LBA */
            ST_DWORD(tbl + 12, n_vol);      /* Partition size in LBA */
            ST_WORD(fs->win + BS_55AA, 0xAA55); /* MBR signature */
            if (disk_write(pdrv, fs->win, 0, 1) != RES_OK)  /* Write it to the MBR */
                return FR_DISK_ERR;
            md = 0xF8;
        }
    }
 
    /* Create BPB in the VBR */
    tbl = fs->win;                          /* Clear sector */
    mem_set(tbl, 0, SS(fs));
    mem_cpy(tbl, "\xEB\xFE\x90" "MSDOS5.0", 11);/* Boot jump code, OEM name */
    i = SS(fs);                             /* Sector size */
    ST_WORD(tbl + BPB_BytsPerSec, i);
    tbl[BPB_SecPerClus] = (BYTE)au;         /* Sectors per cluster */
    ST_WORD(tbl + BPB_RsvdSecCnt, n_rsv);   /* Reserved sectors */
    tbl[BPB_NumFATs] = N_FATS;              /* Number of FATs */
    i = (fmt == FS_FAT32) ? 0 : (fmt == FS_FAT12 ? N_ROOTDIR12 : N_ROOTDIR16);  /* Number of root directory entries */
    ST_WORD(tbl + BPB_RootEntCnt, i);
    if (n_vol < 0x10000) {                  /* Number of total sectors */
        ST_WORD(tbl + BPB_TotSec16, n_vol);
    } else {
        ST_DWORD(tbl + BPB_TotSec32, n_vol);
    }
    tbl[BPB_Media] = md;                    /* Media descriptor */
    ST_DWORD(tbl + BPB_HiddSec, b_vol);     /* Hidden sectors */
    n = GET_FATTIME();                      /* Use current time as VSN */
    if (fmt == FS_FAT32) {
        ST_WORD(tbl + BPB_SecPerTrk, 63);   /* Number of sectors per track */
        ST_WORD(tbl + BPB_NumHeads, 255);   /* Number of heads */
        ST_DWORD(tbl + BS_VolID32, n);      /* VSN */
        ST_DWORD(tbl + BPB_FATSz32, n_fat); /* Number of sectors per FAT */
        ST_DWORD(tbl + BPB_RootClus, 2);    /* Root directory start cluster (2) */
        ST_WORD(tbl + BPB_FSInfo, 1);       /* FSINFO record offset (VBR + 1) */
        ST_WORD(tbl + BPB_BkBootSec, 6);    /* Backup boot record offset (VBR + 6) */
        tbl[BS_DrvNum32] = 0x80;            /* Drive number */
        tbl[BS_BootSig32] = 0x29;           /* Extended boot signature */
        mem_cpy(tbl + BS_VolLab32, "NO NAME    " "FAT32   ", 19);   /* Volume label, FAT signature */
    } else if (fmt == FS_FAT16) {
        ST_WORD(tbl + BPB_SecPerTrk, 63);   /* Number of sectors per track */
        ST_WORD(tbl + BPB_NumHeads, 255);   /* Number of heads */
        ST_DWORD(tbl + BS_VolID, n);        /* VSN */
        ST_WORD(tbl + BPB_FATSz16, n_fat);  /* Number of sectors per FAT */
        tbl[BS_DrvNum] = 0x80;              /* Drive number */
        tbl[BS_BootSig] = 0x29;             /* Extended boot signature */
        mem_cpy(tbl + BS_VolLab, "NO NAME    " "FAT16   ", 19); /* Volume label, FAT signature */
    } else /* if (fmt == FS_FAT12) */ {
        /* Assume floppy characteristics */
        ST_WORD(tbl + BPB_SecPerTrk, 0x12); /* Number of sectors per track */
        ST_WORD(tbl + BPB_NumHeads, 0x02);  /* Number of heads */
        ST_DWORD(tbl + BS_VolID, n);        /* VSN */
        ST_WORD(tbl + BPB_FATSz16, n_fat);  /* Number of sectors per FAT */
        tbl[BS_DrvNum] = 0x00;              /* Drive number */
        tbl[BS_BootSig] = 0x29;             /* Extended boot signature */
        mem_cpy(tbl + BS_VolLab, "NO NAME    " "FAT12   ", 19); /* Volume label, FAT signature */
    }
    ST_WORD(tbl + BS_55AA, 0xAA55);         /* Signature (Offset is fixed here regardless of sector size) */
    if (disk_write(pdrv, tbl, b_vol, 1) != RES_OK)  /* Write it to the VBR sector */
        return FR_DISK_ERR;
    if (fmt == FS_FAT32)                    /* Write it to the backup VBR if needed (VBR + 6) */
        disk_write(pdrv, tbl, b_vol + 6, 1);
 
    /* Initialize FAT area */
    wsect = b_fat;
    for (i = 0; i < N_FATS; i++) {      /* Initialize each FAT copy */
        mem_set(tbl, 0, SS(fs));            /* 1st sector of the FAT  */
        n = md;                             /* Media descriptor byte */
        if (fmt != FS_FAT32) {
            n |= (fmt == FS_FAT12) ? 0x00FFFF00 : 0xFFFFFF00;
            ST_DWORD(tbl + 0, n);           /* Reserve cluster #0-1 (FAT12/16) */
        } else {
            n |= 0xFFFFFF00;
            ST_DWORD(tbl + 0, n);           /* Reserve cluster #0-1 (FAT32) */
            ST_DWORD(tbl + 4, 0xFFFFFFFF);
            ST_DWORD(tbl + 8, 0x0FFFFFFF);  /* Reserve cluster #2 for root directory */
        }
        if (disk_write(pdrv, tbl, wsect++, 1) != RES_OK)
            return FR_DISK_ERR;
        mem_set(tbl, 0, SS(fs));            /* Fill following FAT entries with zero */
        for (n = 1; n < n_fat; n++) {       /* This loop may take a time on FAT32 volume due to many single sector writes */
            if (disk_write(pdrv, tbl, wsect++, 1) != RES_OK)
                return FR_DISK_ERR;
        }
    }
 
    /* Initialize root directory */
    i = (fmt == FS_FAT32) ? au : (UINT)n_dir;
    do {
        if (disk_write(pdrv, tbl, wsect++, 1) != RES_OK)
            return FR_DISK_ERR;
    } while (--i);
 
#if _USE_TRIM   /* Erase data area if needed */
    {
        eb[0] = wsect; eb[1] = wsect + (n_clst - ((fmt == FS_FAT32) ? 1 : 0)) * au - 1;
        disk_ioctl(pdrv, CTRL_TRIM, eb);
    }
#endif
 
    /* Create FSINFO if needed */
    if (fmt == FS_FAT32) {
        ST_DWORD(tbl + FSI_LeadSig, 0x41615252);
        ST_DWORD(tbl + FSI_StrucSig, 0x61417272);
        ST_DWORD(tbl + FSI_Free_Count, n_clst - 1); /* Number of free clusters */
        ST_DWORD(tbl + FSI_Nxt_Free, 2);            /* Last allocated cluster# */
        ST_WORD(tbl + BS_55AA, 0xAA55);
        disk_write(pdrv, tbl, b_vol + 1, 1);    /* Write original (VBR + 1) */
        disk_write(pdrv, tbl, b_vol + 7, 1);    /* Write backup (VBR + 7) */
    }
 
    return (disk_ioctl(pdrv, CTRL_SYNC, 0) == RES_OK) ? FR_OK : FR_DISK_ERR;
}

Referenced by main().

f_mount()

FRESULT f_mount	(	FATFS *	fs,
		const TCHAR *	path,
		BYTE	opt
	)

Definition at line 2402 of file ff.c.

{
    FATFS *cfs;
    int vol;
    FRESULT res;
    const TCHAR *rp = path;
 
 
    vol = get_ldnumber(&rp);
    if (vol < 0) return FR_INVALID_DRIVE;
    cfs = FatFs[vol];                   /* Pointer to fs object */
 
    if (cfs) {
#if _FS_LOCK
        clear_lock(cfs);
#endif
#if _FS_REENTRANT                       /* Discard sync object of the current volume */
        if (!ff_del_syncobj(cfs->sobj)) return FR_INT_ERR;
#endif
        cfs->fs_type = 0;               /* Clear old fs object */
    }
 
    if (fs) {
        fs->fs_type = 0;                /* Clear new fs object */
#if _FS_REENTRANT                       /* Create sync object for the new volume */
        if (!ff_cre_syncobj((BYTE)vol, &fs->sobj)) return FR_INT_ERR;
#endif
    }
    FatFs[vol] = fs;                    /* Register new fs object */
 
    if (!fs || opt != 1) return FR_OK;  /* Do not mount now, it will be mounted later */
 
    res = find_volume(&fs, &path, 0);   /* Force mounted the volume */
    LEAVE_FF(fs, res);
}

Referenced by need_mount().

f_open()

FRESULT f_open	(	FIL *	fp,
		const TCHAR *	path,
		BYTE	mode
	)

Definition at line 2449 of file ff.c.

{
    FRESULT res;
    DIR dj;
    BYTE *dir;
    DEFINE_NAMEBUF;
#if !_FS_READONLY
    DWORD dw, cl;
#endif
 
 
    if (!fp) return FR_INVALID_OBJECT;
    fp->fs = 0;         /* Clear file object */
 
    /* Get logical drive number */
#if !_FS_READONLY
    mode &= FA_READ | FA_WRITE | FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW;
    res = find_volume(&dj.fs, &path, (BYTE)(mode & ~FA_READ));
#else
    mode &= FA_READ;
    res = find_volume(&dj.fs, &path, 0);
#endif
    if (res == FR_OK) {
        INIT_BUF(dj);
        res = follow_path(&dj, path);   /* Follow the file path */
        dir = dj.dir;
#if !_FS_READONLY   /* R/W configuration */
        if (res == FR_OK) {
            if (!dir)   /* Default directory itself */
                res = FR_INVALID_NAME;
#if _FS_LOCK
            else
                res = chk_lock(&dj, (mode & ~FA_READ) ? 1 : 0);
#endif
        }
        /* Create or Open a file */
        if (mode & (FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW)) {
            if (res != FR_OK) {                 /* No file, create new */
                if (res == FR_NO_FILE)          /* There is no file to open, create a new entry */
#if _FS_LOCK
                    res = enq_lock() ? dir_register(&dj) : FR_TOO_MANY_OPEN_FILES;
#else
                    res = dir_register(&dj);
#endif
                mode |= FA_CREATE_ALWAYS;       /* File is created */
                dir = dj.dir;                   /* New entry */
            }
            else {                              /* Any object is already existing */
                if (dir[DIR_Attr] & (AM_RDO | AM_DIR)) {    /* Cannot overwrite it (R/O or DIR) */
                    res = FR_DENIED;
                } else {
                    if (mode & FA_CREATE_NEW)   /* Cannot create as new file */
                        res = FR_EXIST;
                }
            }
            if (res == FR_OK && (mode & FA_CREATE_ALWAYS)) {    /* Truncate it if overwrite mode */
                dw = GET_FATTIME();
                ST_DWORD(dir + DIR_CrtTime, dw);/* Set created time */
                ST_DWORD(dir + DIR_WrtTime, dw);/* Set modified time */
                dir[DIR_Attr] = 0;              /* Reset attribute */
                ST_DWORD(dir + DIR_FileSize, 0);/* Reset file size */
                cl = ld_clust(dj.fs, dir);      /* Get cluster chain */
                st_clust(dir, 0);               /* Reset cluster */
                dj.fs->wflag = 1;
                if (cl) {                       /* Remove the cluster chain if exist */
                    dw = dj.fs->winsect;
                    res = remove_chain(dj.fs, cl);
                    if (res == FR_OK) {
                        dj.fs->last_clust = cl - 1; /* Reuse the cluster hole */
                        res = move_window(dj.fs, dw);
                    }
                }
            }
        }
        else {  /* Open an existing file */
            if (res == FR_OK) {                 /* Following succeeded */
                if (dir[DIR_Attr] & AM_DIR) {   /* It is a directory */
                    res = FR_NO_FILE;
                } else {
                    if ((mode & FA_WRITE) && (dir[DIR_Attr] & AM_RDO)) /* R/O violation */
                        res = FR_DENIED;
                }
            }
        }
        if (res == FR_OK) {
            if (mode & FA_CREATE_ALWAYS)        /* Set file change flag if created or overwritten */
                mode |= FA__WRITTEN;
            fp->dir_sect = dj.fs->winsect;      /* Pointer to the directory entry */
            fp->dir_ptr = dir;
#if _FS_LOCK
            fp->lockid = inc_lock(&dj, (mode & ~FA_READ) ? 1 : 0);
            if (!fp->lockid) res = FR_INT_ERR;
#endif
        }
 
#else               /* R/O configuration */
        if (res == FR_OK) {                 /* Follow succeeded */
            dir = dj.dir;
            if (!dir) {                     /* Current directory itself */
                res = FR_INVALID_NAME;
            } else {
                if (dir[DIR_Attr] & AM_DIR) /* It is a directory */
                    res = FR_NO_FILE;
            }
        }
#endif
        FREE_BUF();
 
        if (res == FR_OK) {
            fp->flag = mode;                    /* File access mode */
            fp->err = 0;                        /* Clear error flag */
            fp->sclust = ld_clust(dj.fs, dir);  /* File start cluster */
            fp->fsize = LD_DWORD(dir + DIR_FileSize);   /* File size */
            fp->fptr = 0;                       /* File pointer */
            fp->dsect = 0;
#if _USE_FASTSEEK
            fp->cltbl = 0;                      /* Normal seek mode */
#endif
            fp->fs = dj.fs;                     /* Validate file object */
            fp->id = fp->fs->id;
        }
    }
 
    LEAVE_FF(dj.fs, res);
}

Referenced by main().

f_opendir()

FRESULT f_opendir	(	DIR *	dp,
		const TCHAR *	path
	)

Definition at line 3187 of file ff.c.

{
    FRESULT res;
    FATFS* fs;
    DEFINE_NAMEBUF;
 
 
    if (!dp) return FR_INVALID_OBJECT;
 
    /* Get logical drive number */
    res = find_volume(&fs, &path, 0);
    if (res == FR_OK) {
        dp->fs = fs;
        INIT_BUF(*dp);
        res = follow_path(dp, path);            /* Follow the path to the directory */
        FREE_BUF();
        if (res == FR_OK) {                     /* Follow completed */
            if (dp->dir) {                      /* It is not the origin directory itself */
                if (dp->dir[DIR_Attr] & AM_DIR) /* The object is a sub directory */
                    dp->sclust = ld_clust(fs, dp->dir);
                else                            /* The object is a file */
                    res = FR_NO_PATH;
            }
            if (res == FR_OK) {
                dp->id = fs->id;
                res = dir_sdi(dp, 0);           /* Rewind directory */
#if _FS_LOCK
                if (res == FR_OK) {
                    if (dp->sclust) {
                        dp->lockid = inc_lock(dp, 0);   /* Lock the sub directory */
                        if (!dp->lockid)
                            res = FR_TOO_MANY_OPEN_FILES;
                    } else {
                        dp->lockid = 0; /* Root directory need not to be locked */
                    }
                }
#endif
            }
        }
        if (res == FR_NO_FILE) res = FR_NO_PATH;
    }
    if (res != FR_OK) dp->fs = 0;       /* Invalidate the directory object if function faild */
 
    LEAVE_FF(fs, res);
}

Referenced by main().

f_printf()

int f_printf	(	FIL *	fp,
		const TCHAR *	str,
			...
	)

f_putc()

int f_putc	(	TCHAR	c,
		FIL *	fp
	)

f_puts()

int f_puts	(	const TCHAR *	str,
		FIL *	cp
	)

f_read()

FRESULT f_read	(	FIL *	fp,
		void *	buff,
		UINT	btr,
		UINT *	br
	)

Definition at line 2586 of file ff.c.

{
    FRESULT res;
    DWORD clst, sect, remain;
    UINT rcnt, cc;
    BYTE csect, *rbuff = (BYTE*)buff;
 
 
    *br = 0;    /* Clear read byte counter */
 
    res = validate(fp);                         /* Check validity */
    if (res != FR_OK) LEAVE_FF(fp->fs, res);
    if (fp->err)                                /* Check error */
        LEAVE_FF(fp->fs, (FRESULT)fp->err);
    if (!(fp->flag & FA_READ))                  /* Check access mode */
        LEAVE_FF(fp->fs, FR_DENIED);
    remain = fp->fsize - fp->fptr;
    if (btr > remain) btr = (UINT)remain;       /* Truncate btr by remaining bytes */
 
    for ( ;  btr;                               /* Repeat until all data read */
        rbuff += rcnt, fp->fptr += rcnt, *br += rcnt, btr -= rcnt) {
        if ((fp->fptr % SS(fp->fs)) == 0) {     /* On the sector boundary? */
            csect = (BYTE)(fp->fptr / SS(fp->fs) & (fp->fs->csize - 1));    /* Sector offset in the cluster */
            if (!csect) {                       /* On the cluster boundary? */
                if (fp->fptr == 0) {            /* On the top of the file? */
                    clst = fp->sclust;          /* Follow from the origin */
                } else {                        /* Middle or end of the file */
#if _USE_FASTSEEK
                    if (fp->cltbl)
                        clst = clmt_clust(fp, fp->fptr);    /* Get cluster# from the CLMT */
                    else
#endif
                        clst = get_fat(fp->fs, fp->clust);  /* Follow cluster chain on the FAT */
                }
                if (clst < 2) ABORT(fp->fs, FR_INT_ERR);
                if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
                fp->clust = clst;               /* Update current cluster */
            }
            sect = clust2sect(fp->fs, fp->clust);   /* Get current sector */
            if (!sect) ABORT(fp->fs, FR_INT_ERR);
            sect += csect;
            cc = btr / SS(fp->fs);              /* When remaining bytes >= sector size, */
            if (cc) {                           /* Read maximum contiguous sectors directly */
                if (csect + cc > fp->fs->csize) /* Clip at cluster boundary */
                    cc = fp->fs->csize - csect;
                if (disk_read(fp->fs->drv, rbuff, sect, cc) != RES_OK)
                    ABORT(fp->fs, FR_DISK_ERR);
#if !_FS_READONLY && _FS_MINIMIZE <= 2          /* Replace one of the read sectors with cached data if it contains a dirty sector */
#if _FS_TINY
                if (fp->fs->wflag && fp->fs->winsect - sect < cc)
                    mem_cpy(rbuff + ((fp->fs->winsect - sect) * SS(fp->fs)), fp->fs->win, SS(fp->fs));
#else
                if ((fp->flag & FA__DIRTY) && fp->dsect - sect < cc)
                    mem_cpy(rbuff + ((fp->dsect - sect) * SS(fp->fs)), fp->buf, SS(fp->fs));
#endif
#endif
                rcnt = SS(fp->fs) * cc;         /* Number of bytes transferred */
                continue;
            }
#if !_FS_TINY
            if (fp->dsect != sect) {            /* Load data sector if not in cache */
#if !_FS_READONLY
                if (fp->flag & FA__DIRTY) {     /* Write-back dirty sector cache */
                    if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) != RES_OK)
                        ABORT(fp->fs, FR_DISK_ERR);
                    fp->flag &= ~FA__DIRTY;
                }
#endif
                if (disk_read(fp->fs->drv, fp->buf, sect, 1) != RES_OK) /* Fill sector cache */
                    ABORT(fp->fs, FR_DISK_ERR);
            }
#endif
            fp->dsect = sect;
        }
        rcnt = SS(fp->fs) - ((UINT)fp->fptr % SS(fp->fs));  /* Get partial sector data from sector buffer */
        if (rcnt > btr) rcnt = btr;
#if _FS_TINY
        if (move_window(fp->fs, fp->dsect) != FR_OK)        /* Move sector window */
            ABORT(fp->fs, FR_DISK_ERR);
        mem_cpy(rbuff, &fp->fs->win[fp->fptr % SS(fp->fs)], rcnt);  /* Pick partial sector */
#else
        mem_cpy(rbuff, &fp->buf[fp->fptr % SS(fp->fs)], rcnt);  /* Pick partial sector */
#endif
    }
 
    LEAVE_FF(fp->fs, FR_OK);
}

Referenced by main().

f_readdir()

FRESULT f_readdir	(	DIR *	dp,
		FILINFO *	fno
	)

Definition at line 3275 of file ff.c.

{
    FRESULT res;
    DEFINE_NAMEBUF;
 
 
    res = validate(dp);                     /* Check validity of the object */
    if (res == FR_OK) {
        if (!fno) {
            res = dir_sdi(dp, 0);           /* Rewind the directory object */
        } else {
            INIT_BUF(*dp);
            res = dir_read(dp, 0);          /* Read an item */
            if (res == FR_NO_FILE) {        /* Reached end of directory */
                dp->sect = 0;
                res = FR_OK;
            }
            if (res == FR_OK) {             /* A valid entry is found */
                get_fileinfo(dp, fno);      /* Get the object information */
                res = dir_next(dp, 0);      /* Increment index for next */
                if (res == FR_NO_FILE) {
                    dp->sect = 0;
                    res = FR_OK;
                }
            }
            FREE_BUF();
        }
    }
 
    LEAVE_FF(dp->fs, res);
}

Referenced by main().

f_rename()

FRESULT f_rename	(	const TCHAR *	path_old,
		const TCHAR *	path_new
	)

Definition at line 3713 of file ff.c.

{
    FRESULT res;
    DIR djo, djn;
    BYTE buf[21], *dir;
    DWORD dw;
    DEFINE_NAMEBUF;
 
 
    /* Get logical drive number of the source object */
    res = find_volume(&djo.fs, &path_old, 1);
    if (res == FR_OK) {
        djn.fs = djo.fs;
        INIT_BUF(djo);
        res = follow_path(&djo, path_old);      /* Check old object */
        if (_FS_RPATH && res == FR_OK && (djo.fn[NSFLAG] & NS_DOT))
            res = FR_INVALID_NAME;
#if _FS_LOCK
        if (res == FR_OK) res = chk_lock(&djo, 2);
#endif
        if (res == FR_OK) {                     /* Old object is found */
            if (!djo.dir) {                     /* Is root dir? */
                res = FR_NO_FILE;
            } else {
                mem_cpy(buf, djo.dir + DIR_Attr, 21);   /* Save information about object except name */
                mem_cpy(&djn, &djo, sizeof (DIR));      /* Duplicate the directory object */
                if (get_ldnumber(&path_new) >= 0)       /* Snip drive number off and ignore it */
                    res = follow_path(&djn, path_new);  /* and make sure if new object name is not conflicting */
                else
                    res = FR_INVALID_DRIVE;
                if (res == FR_OK) res = FR_EXIST;       /* The new object name is already existing */
                if (res == FR_NO_FILE) {                /* It is a valid path and no name collision */
                    res = dir_register(&djn);           /* Register the new entry */
                    if (res == FR_OK) {
/* Start of critical section where any interruption can cause a cross-link */
                        dir = djn.dir;                  /* Copy information about object except name */
                        mem_cpy(dir + 13, buf + 2, 19);
                        dir[DIR_Attr] = buf[0] | AM_ARC;
                        djo.fs->wflag = 1;
                        if ((dir[DIR_Attr] & AM_DIR) && djo.sclust != djn.sclust) { /* Update .. entry in the sub-directory if needed */
                            dw = clust2sect(djo.fs, ld_clust(djo.fs, dir));
                            if (!dw) {
                                res = FR_INT_ERR;
                            } else {
                                res = move_window(djo.fs, dw);
                                dir = djo.fs->win + SZ_DIRE * 1;    /* Ptr to .. entry */
                                if (res == FR_OK && dir[1] == '.') {
                                    st_clust(dir, djn.sclust);
                                    djo.fs->wflag = 1;
                                }
                            }
                        }
                        if (res == FR_OK) {
                            res = dir_remove(&djo);     /* Remove old entry */
                            if (res == FR_OK)
                                res = sync_fs(djo.fs);
                        }
/* End of critical section */
                    }
                }
            }
        }
        FREE_BUF();
    }
 
    LEAVE_FF(djo.fs, res);
}

Referenced by main().

f_setlabel()

FRESULT f_setlabel

(

const TCHAR *

label

)

Definition at line 3906 of file ff.c.

{
    FRESULT res;
    DIR dj;
    BYTE vn[11];
    UINT i, j, sl;
    WCHAR w;
    DWORD tm;
 
 
    /* Get logical drive number */
    res = find_volume(&dj.fs, &label, 1);
    if (res) LEAVE_FF(dj.fs, res);
 
    /* Create a volume label in directory form */
    vn[0] = 0;
    for (sl = 0; label[sl]; sl++) ;             /* Get name length */
    for ( ; sl && label[sl - 1] == ' '; sl--) ; /* Remove trailing spaces */
    if (sl) {   /* Create volume label in directory form */
        i = j = 0;
        do {
#if _USE_LFN && _LFN_UNICODE
            w = ff_convert(ff_wtoupper(label[i++]), 0);
#else
            w = (BYTE)label[i++];
            if (IsDBCS1(w))
                w = (j < 10 && i < sl && IsDBCS2(label[i])) ? w << 8 | (BYTE)label[i++] : 0;
#if _USE_LFN
            w = ff_convert(ff_wtoupper(ff_convert(w, 1)), 0);
#else
            if (IsLower(w)) w -= 0x20;          /* To upper ASCII characters */
#ifdef _EXCVT
            if (w >= 0x80) w = ExCvt[w - 0x80]; /* To upper extended characters (SBCS cfg) */
#else
            if (!_DF1S && w >= 0x80) w = 0;     /* Reject extended characters (ASCII cfg) */
#endif
#endif
#endif
            if (!w || chk_chr("\"*+,.:;<=>\?[]|\x7F", w) || j >= (UINT)((w >= 0x100) ? 10 : 11)) /* Reject invalid characters for volume label */
                LEAVE_FF(dj.fs, FR_INVALID_NAME);
            if (w >= 0x100) vn[j++] = (BYTE)(w >> 8);
            vn[j++] = (BYTE)w;
        } while (i < sl);
        while (j < 11) vn[j++] = ' ';   /* Fill remaining name field */
        if (vn[0] == DDEM) LEAVE_FF(dj.fs, FR_INVALID_NAME);    /* Reject illegal name (heading DDEM) */
    }
 
    /* Set volume label */
    dj.sclust = 0;                  /* Open root directory */
    res = dir_sdi(&dj, 0);
    if (res == FR_OK) {
        res = dir_read(&dj, 1);     /* Get an entry with AM_VOL */
        if (res == FR_OK) {         /* A volume label is found */
            if (vn[0]) {
                mem_cpy(dj.dir, vn, 11);    /* Change the volume label name */
                tm = GET_FATTIME();
                ST_DWORD(dj.dir + DIR_CrtTime, tm);
                ST_DWORD(dj.dir + DIR_WrtTime, tm);
            } else {
                dj.dir[0] = DDEM;           /* Remove the volume label */
            }
            dj.fs->wflag = 1;
            res = sync_fs(dj.fs);
        } else {                    /* No volume label is found or error */
            if (res == FR_NO_FILE) {
                res = FR_OK;
                if (vn[0]) {                /* Create volume label as new */
                    res = dir_alloc(&dj, 1);    /* Allocate an entry for volume label */
                    if (res == FR_OK) {
                        mem_set(dj.dir, 0, SZ_DIRE);    /* Set volume label */
                        mem_cpy(dj.dir, vn, 11);
                        dj.dir[DIR_Attr] = AM_VOL;
                        tm = GET_FATTIME();
                        ST_DWORD(dj.dir + DIR_CrtTime, tm);
                        ST_DWORD(dj.dir + DIR_WrtTime, tm);
                        dj.fs->wflag = 1;
                        res = sync_fs(dj.fs);
                    }
                }
            }
        }
    }
 
    LEAVE_FF(dj.fs, res);
}

Referenced by main().

f_stat()

FRESULT f_stat	(	const TCHAR *	path,
		FILINFO *	fno
	)

Definition at line 3369 of file ff.c.

{
    FRESULT res;
    DIR dj;
    DEFINE_NAMEBUF;
 
 
    /* Get logical drive number */
    res = find_volume(&dj.fs, &path, 0);
    if (res == FR_OK) {
        INIT_BUF(dj);
        res = follow_path(&dj, path);   /* Follow the file path */
        if (res == FR_OK) {             /* Follow completed */
            if (dj.dir) {       /* Found an object */
                if (fno) get_fileinfo(&dj, fno);
            } else {            /* It is root directory */
                res = FR_INVALID_NAME;
            }
        }
        FREE_BUF();
    }
 
    LEAVE_FF(dj.fs, res);
}

f_sync()

FRESULT f_sync

(

FIL *

fp

)

Definition at line 2809 of file ff.c.

{
    FRESULT res;
    DWORD tm;
    BYTE *dir;
 
 
    res = validate(fp);                 /* Check validity of the object */
    if (res == FR_OK) {
        if (fp->flag & FA__WRITTEN) {   /* Is there any change to the file? */
#if !_FS_TINY
            if (fp->flag & FA__DIRTY) { /* Write-back cached data if needed */
                if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) != RES_OK)
                    LEAVE_FF(fp->fs, FR_DISK_ERR);
                fp->flag &= ~FA__DIRTY;
            }
#endif
            /* Update the directory entry */
            res = move_window(fp->fs, fp->dir_sect);
            if (res == FR_OK) {
                dir = fp->dir_ptr;
                dir[DIR_Attr] |= AM_ARC;                    /* Set archive bit */
                ST_DWORD(dir + DIR_FileSize, fp->fsize);    /* Update file size */
                st_clust(dir, fp->sclust);                  /* Update start cluster */
                tm = GET_FATTIME();                         /* Update modified time */
                ST_DWORD(dir + DIR_WrtTime, tm);
                ST_WORD(dir + DIR_LstAccDate, 0);
                fp->flag &= ~FA__WRITTEN;
                fp->fs->wflag = 1;
                res = sync_fs(fp->fs);
            }
        }
    }
 
    LEAVE_FF(fp->fs, res);
}

Referenced by f_close().

f_truncate()

FRESULT f_truncate

(

FIL *

fp

)

Definition at line 3470 of file ff.c.

{
    FRESULT res;
    DWORD ncl;
 
 
    res = validate(fp);                     /* Check validity of the object */
    if (res == FR_OK) {
        if (fp->err) {                      /* Check error */
            res = (FRESULT)fp->err;
        } else {
            if (!(fp->flag & FA_WRITE))     /* Check access mode */
                res = FR_DENIED;
        }
    }
    if (res == FR_OK) {
        if (fp->fsize > fp->fptr) {
            fp->fsize = fp->fptr;   /* Set file size to current R/W point */
            fp->flag |= FA__WRITTEN;
            if (fp->fptr == 0) {    /* When set file size to zero, remove entire cluster chain */
                res = remove_chain(fp->fs, fp->sclust);
                fp->sclust = 0;
            } else {                /* When truncate a part of the file, remove remaining clusters */
                ncl = get_fat(fp->fs, fp->clust);
                res = FR_OK;
                if (ncl == 0xFFFFFFFF) res = FR_DISK_ERR;
                if (ncl == 1) res = FR_INT_ERR;
                if (res == FR_OK && ncl < fp->fs->n_fatent) {
                    res = put_fat(fp->fs, fp->clust, 0x0FFFFFFF);
                    if (res == FR_OK) res = remove_chain(fp->fs, ncl);
                }
            }
#if !_FS_TINY
            if (res == FR_OK && (fp->flag & FA__DIRTY)) {
                if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) != RES_OK)
                    res = FR_DISK_ERR;
                else
                    fp->flag &= ~FA__DIRTY;
            }
#endif
        }
        if (res != FR_OK) fp->err = (FRESULT)res;
    }
 
    LEAVE_FF(fp->fs, res);
}

f_unlink()

FRESULT f_unlink

(

const TCHAR *

path

)

Definition at line 3526 of file ff.c.

{
    FRESULT res;
    DIR dj, sdj;
    BYTE *dir;
    DWORD dclst = 0;
    DEFINE_NAMEBUF;
 
 
    /* Get logical drive number */
    res = find_volume(&dj.fs, &path, 1);
    if (res == FR_OK) {
        INIT_BUF(dj);
        res = follow_path(&dj, path);       /* Follow the file path */
        if (_FS_RPATH && res == FR_OK && (dj.fn[NSFLAG] & NS_DOT))
            res = FR_INVALID_NAME;          /* Cannot remove dot entry */
#if _FS_LOCK
        if (res == FR_OK) res = chk_lock(&dj, 2);   /* Cannot remove open object */
#endif
        if (res == FR_OK) {                 /* The object is accessible */
            dir = dj.dir;
            if (!dir) {
                res = FR_INVALID_NAME;      /* Cannot remove the origin directory */
            } else {
                if (dir[DIR_Attr] & AM_RDO)
                    res = FR_DENIED;        /* Cannot remove R/O object */
            }
            if (res == FR_OK) {
                dclst = ld_clust(dj.fs, dir);
                if (dclst && (dir[DIR_Attr] & AM_DIR)) {    /* Is it a sub-directory ? */
#if _FS_RPATH
                    if (dclst == dj.fs->cdir) {             /* Is it the current directory? */
                        res = FR_DENIED;
                    } else
#endif
                    {
                        mem_cpy(&sdj, &dj, sizeof (DIR));   /* Open the sub-directory */
                        sdj.sclust = dclst;
                        res = dir_sdi(&sdj, 2);
                        if (res == FR_OK) {
                            res = dir_read(&sdj, 0);            /* Read an item (excluding dot entries) */
                            if (res == FR_OK) res = FR_DENIED;  /* Not empty? (cannot remove) */
                            if (res == FR_NO_FILE) res = FR_OK; /* Empty? (can remove) */
                        }
                    }
                }
            }
            if (res == FR_OK) {
                res = dir_remove(&dj);      /* Remove the directory entry */
                if (res == FR_OK && dclst)  /* Remove the cluster chain if exist */
                    res = remove_chain(dj.fs, dclst);
                if (res == FR_OK) res = sync_fs(dj.fs);
            }
        }
        FREE_BUF();
    }
 
    LEAVE_FF(dj.fs, res);
}

Referenced by main().

f_utime()

FRESULT f_utime	(	const TCHAR *	path,
		const FILINFO *	fno
	)

Definition at line 3791 of file ff.c.

{
    FRESULT res;
    DIR dj;
    BYTE *dir;
    DEFINE_NAMEBUF;
 
 
    /* Get logical drive number */
    res = find_volume(&dj.fs, &path, 1);
    if (res == FR_OK) {
        INIT_BUF(dj);
        res = follow_path(&dj, path);   /* Follow the file path */
        FREE_BUF();
        if (_FS_RPATH && res == FR_OK && (dj.fn[NSFLAG] & NS_DOT))
            res = FR_INVALID_NAME;
        if (res == FR_OK) {
            dir = dj.dir;
            if (!dir) {                 /* Root directory */
                res = FR_INVALID_NAME;
            } else {                    /* File or sub-directory */
                ST_WORD(dir + DIR_WrtTime, fno->ftime);
                ST_WORD(dir + DIR_WrtDate, fno->fdate);
                dj.fs->wflag = 1;
                res = sync_fs(dj.fs);
            }
        }
    }
 
    LEAVE_FF(dj.fs, res);
}

f_write()

FRESULT f_write	(	FIL *	fp,
		const void *	buff,
		UINT	btw,
		UINT *	bw
	)

Definition at line 2687 of file ff.c.

{
    FRESULT res;
    DWORD clst, sect;
    UINT wcnt, cc;
    const BYTE *wbuff = (const BYTE*)buff;
    BYTE csect;
 
 
    *bw = 0;    /* Clear write byte counter */
 
    res = validate(fp);                     /* Check validity */
    if (res != FR_OK) LEAVE_FF(fp->fs, res);
    if (fp->err)                            /* Check error */
        LEAVE_FF(fp->fs, (FRESULT)fp->err);
    if (!(fp->flag & FA_WRITE))             /* Check access mode */
        LEAVE_FF(fp->fs, FR_DENIED);
    if (fp->fptr + btw < fp->fptr) btw = 0; /* File size cannot reach 4GB */
 
    for ( ;  btw;                           /* Repeat until all data written */
        wbuff += wcnt, fp->fptr += wcnt, *bw += wcnt, btw -= wcnt) {
        if ((fp->fptr % SS(fp->fs)) == 0) { /* On the sector boundary? */
            csect = (BYTE)(fp->fptr / SS(fp->fs) & (fp->fs->csize - 1));    /* Sector offset in the cluster */
            if (!csect) {                   /* On the cluster boundary? */
                if (fp->fptr == 0) {        /* On the top of the file? */
                    clst = fp->sclust;      /* Follow from the origin */
                    if (clst == 0)          /* When no cluster is allocated, */
                        clst = create_chain(fp->fs, 0); /* Create a new cluster chain */
                } else {                    /* Middle or end of the file */
#if _USE_FASTSEEK
                    if (fp->cltbl)
                        clst = clmt_clust(fp, fp->fptr);    /* Get cluster# from the CLMT */
                    else
#endif
                        clst = create_chain(fp->fs, fp->clust); /* Follow or stretch cluster chain on the FAT */
                }
                if (clst == 0) break;       /* Could not allocate a new cluster (disk full) */
                if (clst == 1) ABORT(fp->fs, FR_INT_ERR);
                if (clst == 0xFFFFFFFF) ABORT(fp->fs, FR_DISK_ERR);
                fp->clust = clst;           /* Update current cluster */
                if (fp->sclust == 0) fp->sclust = clst; /* Set start cluster if the first write */
            }
#if _FS_TINY
            if (fp->fs->winsect == fp->dsect && sync_window(fp->fs))    /* Write-back sector cache */
                ABORT(fp->fs, FR_DISK_ERR);
#else
            if (fp->flag & FA__DIRTY) {     /* Write-back sector cache */
                if (disk_write(fp->fs->drv, fp->buf, fp->dsect, 1) != RES_OK)
                    ABORT(fp->fs, FR_DISK_ERR);
                fp->flag &= ~FA__DIRTY;
            }
#endif
            sect = clust2sect(fp->fs, fp->clust);   /* Get current sector */
            if (!sect) ABORT(fp->fs, FR_INT_ERR);
            sect += csect;
            cc = btw / SS(fp->fs);          /* When remaining bytes >= sector size, */
            if (cc) {                       /* Write maximum contiguous sectors directly */
                if (csect + cc > fp->fs->csize) /* Clip at cluster boundary */
                    cc = fp->fs->csize - csect;
                if (disk_write(fp->fs->drv, wbuff, sect, cc) != RES_OK)
                    ABORT(fp->fs, FR_DISK_ERR);
#if _FS_MINIMIZE <= 2
#if _FS_TINY
                if (fp->fs->winsect - sect < cc) {  /* Refill sector cache if it gets invalidated by the direct write */
                    mem_cpy(fp->fs->win, wbuff + ((fp->fs->winsect - sect) * SS(fp->fs)), SS(fp->fs));
                    fp->fs->wflag = 0;
                }
#else
                if (fp->dsect - sect < cc) { /* Refill sector cache if it gets invalidated by the direct write */
                    mem_cpy(fp->buf, wbuff + ((fp->dsect - sect) * SS(fp->fs)), SS(fp->fs));
                    fp->flag &= ~FA__DIRTY;
                }
#endif
#endif
                wcnt = SS(fp->fs) * cc;     /* Number of bytes transferred */
                continue;
            }
#if _FS_TINY
            if (fp->fptr >= fp->fsize) {    /* Avoid silly cache filling at growing edge */
                if (sync_window(fp->fs)) ABORT(fp->fs, FR_DISK_ERR);
                fp->fs->winsect = sect;
            }
#else
            if (fp->dsect != sect) {        /* Fill sector cache with file data */
                if (fp->fptr < fp->fsize &&
                    disk_read(fp->fs->drv, fp->buf, sect, 1) != RES_OK)
                        ABORT(fp->fs, FR_DISK_ERR);
            }
#endif
            fp->dsect = sect;
        }
        wcnt = SS(fp->fs) - ((UINT)fp->fptr % SS(fp->fs));/* Put partial sector into file I/O buffer */
        if (wcnt > btw) wcnt = btw;
#if _FS_TINY
        if (move_window(fp->fs, fp->dsect) != FR_OK)    /* Move sector window */
            ABORT(fp->fs, FR_DISK_ERR);
        mem_cpy(&fp->fs->win[fp->fptr % SS(fp->fs)], wbuff, wcnt);  /* Fit partial sector */
        fp->fs->wflag = 1;
#else
        mem_cpy(&fp->buf[fp->fptr % SS(fp->fs)], wbuff, wcnt);  /* Fit partial sector */
        fp->flag |= FA__DIRTY;
#endif
    }
 
    if (fp->fptr > fp->fsize) fp->fsize = fp->fptr; /* Update file size if needed */
    fp->flag |= FA__WRITTEN;                        /* Set file change flag */
 
    LEAVE_FF(fp->fs, FR_OK);
}

Referenced by main().

ff_convert()

WCHAR ff_convert	(	WCHAR	chr,
		UINT	dir
	)

Definition at line 275 of file ccsbcs.c.

{
    WCHAR c;
 
 
    if (chr < 0x80) {   /* ASCII */
        c = chr;
 
    } else {
        if (dir) {      /* OEM code to Unicode */
            c = (chr >= 0x100) ? 0 : Tbl[chr - 0x80];
 
        } else {        /* Unicode to OEM code */
            for (c = 0; c < 0x80; c++) {
                if (chr == Tbl[c]) break;
            }
            c = (c + 0x80) & 0xFF;
        }
    }
 
    return c;
}

Referenced by create_name(), f_getlabel(), f_setlabel(), and get_fileinfo().

ff_wtoupper()

WCHAR ff_wtoupper

(

WCHAR

chr

)

Definition at line 304 of file ccsbcs.c.

{
    static const WCHAR lower[] = {  /* Lower case characters to be converted */
    /* Latin Supplement */          0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF,
    /* Latin Extended-A */          0x101,0x103,0x105,0x107,0x109,0x10B,0x10D,0x10F,0x111,0x113,0x115,0x117,0x119,0x11B,0x11D,0x11F,0x121,0x123,0x125,0x127,0x129,0x12B,0x12D,0x12F,0x131,0x133,0x135,0x137,0x13A,0x13C,0x13E,0x140,0x142,0x144,0x146,0x148,0x14B,0x14D,0x14F,0x151,0x153,0x155,0x157,0x159,0x15B,0x15D,0x15F,0x161,0x163,0x165,0x167,0x169,0x16B,0x16D,0x16F,0x171,0x173,0x175,0x177,0x17A,0x17C,0x17E,
    /* Latin Extended-B */          0x183,0x185,0x188,0x18C,0x192,0x199,0x1A1,0x1A3,0x1A8,0x1AD,0x1B0,0x1B4,0x1B6,0x1B9,0x1BD,0x1C6,0x1C9,0x1CC,0x1CE,0x1D0,0x1D2,0x1D4,0x1D6,0x1D8,0x1DA,0x1DC,0x1DD,0x1DF,0x1E1,0x1E3,0x1E5,0x1E7,0x1E9,0x1EB,0x1ED,0x1EF,0x1F3,0x1F5,0x1FB,0x1FD,0x1FF,0x201,0x203,0x205,0x207,0x209,0x20B,0x20D,0x20F,0x211,0x213,0x215,0x217,
    /* Greek, Coptic */             0x3B1,0x3B2,0x3B3,0x3B4,0x3B5,0x3B6,0x3B7,0x3B8,0x3B9,0x3BA,0x3BB,0x3BC,0x3BD,0x3BE,0x3BF,0x3C0,0x3C1,0x3C3,0x3C4,0x3C5,0x3C6,0x3C7,0x3C8,0x3C9,0x3CA,0x3CB,0x3CC,0x3CD,0x3CE,0x3E3,0x3E5,0x3E7,0x3E9,0x3EB,
    /* Cyrillic */                  0x430,0x431,0x432,0x433,0x434,0x435,0x436,0x437,0x438,0x439,0x43A,0x43B,0x43C,0x43D,0x43E,0x43F,0x440,0x441,0x442,0x443,0x444,0x445,0x446,0x447,0x448,0x449,0x44A,0x44B,0x44C,0x44D,0x44E,0x44F,0x452,0x453,0x454,0x455,0x456,0x457,0x458,0x459,0x45A,0x45B,0x45C,0x45E,0x45F,0x461,0x463,0x465,0x467,0x469,0x46B,0x46D,0x46F,0x471,0x473,0x475,0x477,0x479,0x47B,0x47D,0x47F,0x481,0x491,0x493,0x495,0x497,0x499,0x49B,0x49D,0x49F,0x4A1,0x4A3,0x4A5,0x4A7,0x4A9,0x4AB,0x4AD,0x4AF,0x4B1,0x4B3,0x4B5,0x4B7,0x4B9,0x4BB,0x4BD,0x4BF,0x4C2,0x4C4,0x4C8,0x4D1,0x4D3,0x4D5,0x4D7,0x4D9,0x4DB,0x4DD,0x4DF,0x4E1,0x4E3,0x4E5,0x4E7,0x4E9,0x4EB,0x4ED,0x4EF,0x4F1,0x4F3,0x4F5,0x4F9,
    /* Armenian */                  0x561,0x562,0x563,0x564,0x565,0x566,0x567,0x568,0x569,0x56A,0x56B,0x56C,0x56D,0x56E,0x56F,0x570,0x571,0x572,0x573,0x574,0x575,0x576,0x577,0x578,0x579,0x57A,0x57B,0x57C,0x57D,0x57E,0x57F,0x580,0x581,0x582,0x583,0x584,0x585,0x586,
    /* Latin Extended Additional */ 0x1E01,0x1E03,0x1E05,0x1E07,0x1E09,0x1E0B,0x1E0D,0x1E0F,0x1E11,0x1E13,0x1E15,0x1E17,0x1E19,0x1E1B,0x1E1D,0x1E1F,0x1E21,0x1E23,0x1E25,0x1E27,0x1E29,0x1E2B,0x1E2D,0x1E2F,0x1E31,0x1E33,0x1E35,0x1E37,0x1E39,0x1E3B,0x1E3D,0x1E3F,0x1E41,0x1E43,0x1E45,0x1E47,0x1E49,0x1E4B,0x1E4D,0x1E4F,0x1E51,0x1E53,0x1E55,0x1E57,0x1E59,0x1E5B,0x1E5D,0x1E5F,0x1E61,0x1E63,0x1E65,0x1E67,0x1E69,0x1E6B,0x1E6D,0x1E6F,0x1E71,0x1E73,0x1E75,0x1E77,0x1E79,0x1E7B,0x1E7D,0x1E7F,0x1E81,0x1E83,0x1E85,0x1E87,0x1E89,0x1E8B,0x1E8D,0x1E8F,0x1E91,0x1E93,0x1E95,0x1E97,0x1E99,0x1E9B,0x1E9D,0x1E9F,0x1EA1,0x1EA3,0x1EA5,0x1EA7,0x1EA9,0x1EAB,0x1EAD,0x1EAF,0x1EB1,0x1EB3,0x1EB5,0x1EB7,0x1EB9,0x1EBB,0x1EBD,0x1EBF,0x1EC1,0x1EC3,0x1EC5,0x1EC7,0x1EC9,0x1ECB,0x1ECD,0x1ECF,0x1ED1,0x1ED3,0x1ED5,0x1ED7,0x1ED9,0x1EDB,0x1EDD,0x1EDF,0x1EE1,0x1EE3,0x1EE5,0x1EE7,0x1EE9,0x1EEB,0x1EED,0x1EEF,0x1EF1,0x1EF3,0x1EF5,0x1EF7,0x1EF9,
    /* Number forms */              0x2170,0x2171,0x2172,0x2173,0x2174,0x2175,0x2176,0x2177,0x2178,0x2179,0x217A,0x217B,0x217C,0x217D,0x217E,0x217F,
    /* Full-width */                0xFF41,0xFF42,0xFF43,0xFF44,0xFF45,0xFF46,0xFF47,0xFF48,0xFF49,0xFF4A,0xFF4B,0xFF4C,0xFF4D,0xFF4E,0xFF4F,0xFF50,0xFF51,0xFF52,0xFF53,0xFF54,0xFF55,0xFF56,0xFF57,0xFF58,0xFF59,0xFF5A
    };
    static const WCHAR upper[] = {  /* Upper case characters correspond to lower[] */
                                    0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF,0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0x178,
                                    0x100,0x102,0x104,0x106,0x108,0x10A,0x10C,0x10E,0x110,0x112,0x114,0x116,0x118,0x11A,0x11C,0x11E,0x120,0x122,0x124,0x126,0x128,0x12A,0x12C,0x12E,0x130,0x132,0x134,0x136,0x139,0x13B,0x13D,0x13F,0x141,0x143,0x145,0x147,0x14A,0x14C,0x14E,0x150,0x152,0x154,0x156,0x158,0x15A,0x15C,0x15E,0x160,0x162,0x164,0x166,0x168,0x16A,0x16C,0x16E,0x170,0x172,0x174,0x176,0x179,0x17B,0x17D,
                                    0x182,0x184,0x187,0x18B,0x191,0x198,0x1A0,0x1A2,0x1A7,0x1AC,0x1AF,0x1B3,0x1B5,0x1B8,0x1BC,0x1C4,0x1C7,0x1CA,0x1CD,0x1CF,0x1D1,0x1D3,0x1D5,0x1D7,0x1D9,0x1DB,0x18E,0x1DE,0x1E0,0x1E2,0x1E4,0x1E6,0x1E8,0x1EA,0x1EC,0x1EE,0x1F1,0x1F4,0x1FA,0x1FC,0x1FE,0x200,0x202,0x204,0x206,0x208,0x20A,0x20C,0x20E,0x210,0x212,0x214,0x216,
                                    0x391,0x392,0x393,0x394,0x395,0x396,0x397,0x398,0x399,0x39A,0x39B,0x39C,0x39D,0x39E,0x39F,0x3A0,0x3A1,0x3A3,0x3A4,0x3A5,0x3A6,0x3A7,0x3A8,0x3A9,0x3AA,0x3AB,0x38C,0x38E,0x38F,0x3E2,0x3E4,0x3E6,0x3E8,0x3EA,
                                    0x410,0x411,0x412,0x413,0x414,0x415,0x416,0x417,0x418,0x419,0x41A,0x41B,0x41C,0x41D,0x41E,0x41F,0x420,0x421,0x422,0x423,0x424,0x425,0x426,0x427,0x428,0x429,0x42A,0x42B,0x42C,0x42D,0x42E,0x42F,0x402,0x403,0x404,0x405,0x406,0x407,0x408,0x409,0x40A,0x40B,0x40C,0x40E,0x40F,0x460,0x462,0x464,0x466,0x468,0x46A,0x46C,0x46E,0x470,0x472,0x474,0x476,0x478,0x47A,0x47C,0x47E,0x480,0x490,0x492,0x494,0x496,0x498,0x49A,0x49C,0x49E,0x4A0,0x4A2,0x4A4,0x4A6,0x4A8,0x4AA,0x4AC,0x4AE,0x4B0,0x4B2,0x4B4,0x4B6,0x4B8,0x4BA,0x4BC,0x4BE,0x4C1,0x4C3,0x5C7,0x4D0,0x4D2,0x4D4,0x4D6,0x4D8,0x4DA,0x4DC,0x4DE,0x4E0,0x4E2,0x4E4,0x4E6,0x4E8,0x4EA,0x4EC,0x4EE,0x4F0,0x4F2,0x4F4,0x4F8,
                                    0x531,0x532,0x533,0x534,0x535,0x536,0x537,0x538,0x539,0x53A,0x53B,0x53C,0x53D,0x53E,0x53F,0x540,0x541,0x542,0x543,0x544,0x545,0x546,0x547,0x548,0x549,0x54A,0x54B,0x54C,0x54D,0x54E,0x54F,0x550,0x551,0x552,0x553,0x554,0x555,0x556,
                                    0x1E00,0x1E02,0x1E04,0x1E06,0x1E08,0x1E0A,0x1E0C,0x1E0E,0x1E10,0x1E12,0x1E14,0x1E16,0x1E18,0x1E1A,0x1E1C,0x1E1E,0x1E20,0x1E22,0x1E24,0x1E26,0x1E28,0x1E2A,0x1E2C,0x1E2E,0x1E30,0x1E32,0x1E34,0x1E36,0x1E38,0x1E3A,0x1E3C,0x1E3E,0x1E40,0x1E42,0x1E44,0x1E46,0x1E48,0x1E4A,0x1E4C,0x1E4E,0x1E50,0x1E52,0x1E54,0x1E56,0x1E58,0x1E5A,0x1E5C,0x1E5E,0x1E60,0x1E62,0x1E64,0x1E66,0x1E68,0x1E6A,0x1E6C,0x1E6E,0x1E70,0x1E72,0x1E74,0x1E76,0x1E78,0x1E7A,0x1E7C,0x1E7E,0x1E80,0x1E82,0x1E84,0x1E86,0x1E88,0x1E8A,0x1E8C,0x1E8E,0x1E90,0x1E92,0x1E94,0x1E96,0x1E98,0x1E9A,0x1E9C,0x1E9E,0x1EA0,0x1EA2,0x1EA4,0x1EA6,0x1EA8,0x1EAA,0x1EAC,0x1EAE,0x1EB0,0x1EB2,0x1EB4,0x1EB6,0x1EB8,0x1EBA,0x1EBC,0x1EBE,0x1EC0,0x1EC2,0x1EC4,0x1EC6,0x1EC8,0x1ECA,0x1ECC,0x1ECE,0x1ED0,0x1ED2,0x1ED4,0x1ED6,0x1ED8,0x1EDA,0x1EDC,0x1EDE,0x1EE0,0x1EE2,0x1EE4,0x1EE6,0x1EE8,0x1EEA,0x1EEC,0x1EEE,0x1EF0,0x1EF2,0x1EF4,0x1EF6,0x1EF8,
                                    0x2160,0x2161,0x2162,0x2163,0x2164,0x2165,0x2166,0x2167,0x2168,0x2169,0x216A,0x216B,0x216C,0x216D,0x216E,0x216F,
                                    0xFF21,0xFF22,0xFF23,0xFF24,0xFF25,0xFF26,0xFF27,0xFF28,0xFF29,0xFF2A,0xFF2B,0xFF2C,0xFF2D,0xFF2E,0xFF2F,0xFF30,0xFF31,0xFF32,0xFF33,0xFF34,0xFF35,0xFF36,0xFF37,0xFF38,0xFF39,0xFF3A
    };
    UINT i, n, hi, li;
 
 
    if (chr < 0x80) {   /* ASCII characters (acceleration) */
        if (chr >= 0x61 && chr <= 0x7A) chr -= 0x20;
 
    } else {            /* Non ASCII characters (table search) */
        n = 12; li = 0; hi = sizeof lower / sizeof lower[0];
        do {
            i = li + (hi - li) / 2;
            if (chr == lower[i]) break;
            if (chr > lower[i]) li = i; else hi = i;
        } while (--n);
        if (n) chr = upper[i];
    }
 
    return chr;
}

Referenced by cmp_lfn(), create_name(), and f_setlabel().

get_fattime()

DWORD get_fattime

(

void

)

Definition at line 20 of file fatten.c.

{
    /* 31-25: Year(0-127 org.1980), 24-21: Month(1-12), 20-16: Day(1-31) */
    /* 15-11: Hour(0-23), 10-5: Minute(0-59), 4-0: Second(0-29 *2) */
 
    time_t rawtime;
    struct tm * timeinfo;
 
    time(&rawtime);
    timeinfo = localtime(&rawtime);
 
    {
    union FatTime {
        struct {
            DWORD Second : 5; // div 2
            DWORD Minute : 6;
            DWORD Hour   : 5;
            DWORD Day    : 5;
            DWORD Month  : 4;
            DWORD Year   : 7; // year-1980
        };
        DWORD whole;
    } myTime = {
        {
            timeinfo->tm_sec / 2,
            timeinfo->tm_min,
            timeinfo->tm_hour,
            timeinfo->tm_mday,
            timeinfo->tm_mon  +  1,
            timeinfo->tm_year - 80,
        }
    };
 
    return myTime.whole;
    }
}