ff.h File Reference

#include "ffconf.h"

Go to the source code of this file.

Data Structures
struct	FATFS
struct	FFOBJID
struct	FIL
struct	DIR
struct	FILINFO
struct	MKFS_PARM

Macros
#define	FF_DEFINED   86631 /* Revision ID */
#define	FF_INTDEF   1
#define	_T(x)   x
#define	_TEXT(x)   x
#define	f_eof(fp)   ((int)((fp)->fptr == (fp)->obj.objsize))
#define	f_error(fp)   ((fp)->err)
#define	f_tell(fp)   ((fp)->fptr)
#define	f_size(fp)   ((fp)->obj.objsize)
#define	f_rewind(fp)   f_lseek((fp), 0)
#define	f_rewinddir(dp)   f_readdir((dp), 0)
#define	f_rmdir(path)   f_unlink(path)
#define	f_unmount(path)   f_mount(0, path, 0)
#define	FA_READ   0x01
#define	FA_WRITE   0x02
#define	FA_OPEN_EXISTING   0x00
#define	FA_CREATE_NEW   0x04
#define	FA_CREATE_ALWAYS   0x08
#define	FA_OPEN_ALWAYS   0x10
#define	FA_OPEN_APPEND   0x30
#define	CREATE_LINKMAP   ((FSIZE_t)0 - 1)
#define	FM_FAT   0x01
#define	FM_FAT32   0x02
#define	FM_EXFAT   0x04
#define	FM_ANY   0x07
#define	FM_SFD   0x08
#define	FS_FAT12   1
#define	FS_FAT16   2
#define	FS_FAT32   3
#define	FS_EXFAT   4
#define	AM_RDO   0x01 /* Read only */
#define	AM_HID   0x02 /* Hidden */
#define	AM_SYS   0x04 /* System */
#define	AM_DIR   0x10 /* Directory */
#define	AM_ARC   0x20 /* Archive */

Typedefs
typedef unsigned int	UINT
typedef unsigned char	BYTE
typedef unsigned short	WORD
typedef unsigned long	DWORD
typedef WORD	WCHAR
typedef DWORD	FSIZE_t
typedef DWORD	LBA_t
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_lseek (FIL *fp, FSIZE_t 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_forward (FIL *fp, UINT(*func)(const BYTE *, UINT), UINT btf, UINT *bf)
FRESULT	f_expand (FIL *fp, FSIZE_t fsz, BYTE opt)
FRESULT	f_mount (FATFS *fs, const TCHAR *path, BYTE opt)
FRESULT	f_mkfs (const TCHAR *path, const MKFS_PARM *opt, void *work, UINT len)
FRESULT	f_fdisk (BYTE pdrv, const LBA_t ptbl[], void *work)
FRESULT	f_setcp (WORD cp)
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)
WCHAR	ff_oem2uni (WCHAR oem, WORD cp)
WCHAR	ff_uni2oem (DWORD uni, WORD cp)
DWORD	ff_wtoupper (DWORD uni)
void *	ff_memalloc (UINT msize)
void	ff_memfree (void *mblock)

Macro Definition Documentation

_T

#define _T

(

x

)

x

Definition at line 106 of file ff.h.

_TEXT

#define _TEXT

(

x

)

x

Definition at line 107 of file ff.h.

AM_ARC

#define AM_ARC   0x20 /* Archive */

Definition at line 415 of file ff.h.

AM_DIR

#define AM_DIR   0x10 /* Directory */

Definition at line 414 of file ff.h.

AM_HID

#define AM_HID   0x02 /* Hidden */

Definition at line 412 of file ff.h.

AM_RDO

#define AM_RDO   0x01 /* Read only */

Definition at line 411 of file ff.h.

AM_SYS

#define AM_SYS   0x04 /* System */

Definition at line 413 of file ff.h.

CREATE_LINKMAP

#define CREATE_LINKMAP   ((FSIZE_t)0 - 1)

Definition at line 395 of file ff.h.

f_eof

#define f_eof

(

fp

)

((int)((fp)->fptr == (fp)->obj.objsize))

Definition at line 339 of file ff.h.

f_error

#define f_error

(

fp

)

((fp)->err)

Definition at line 340 of file ff.h.

f_rewind

#define f_rewind

(

fp

)

f_lseek((fp), 0)

Definition at line 343 of file ff.h.

f_rewinddir

#define f_rewinddir

(

dp

)

f_readdir((dp), 0)

Definition at line 344 of file ff.h.

f_rmdir

#define f_rmdir

(

path

)

f_unlink(path)

Definition at line 345 of file ff.h.

f_size

#define f_size

(

fp

)

((fp)->obj.objsize)

Definition at line 342 of file ff.h.

f_tell

#define f_tell

(

fp

)

((fp)->fptr)

Definition at line 341 of file ff.h.

f_unmount

#define f_unmount

(

path

)

f_mount(0, path, 0)

Definition at line 346 of file ff.h.

FA_CREATE_ALWAYS

#define FA_CREATE_ALWAYS   0x08

Definition at line 390 of file ff.h.

FA_CREATE_NEW

#define FA_CREATE_NEW   0x04

Definition at line 389 of file ff.h.

FA_OPEN_ALWAYS

#define FA_OPEN_ALWAYS   0x10

Definition at line 391 of file ff.h.

FA_OPEN_APPEND

#define FA_OPEN_APPEND   0x30

Definition at line 392 of file ff.h.

FA_OPEN_EXISTING

#define FA_OPEN_EXISTING   0x00

Definition at line 388 of file ff.h.

FA_READ

#define FA_READ   0x01

Definition at line 386 of file ff.h.

FA_WRITE

#define FA_WRITE   0x02

Definition at line 387 of file ff.h.

FF_DEFINED

#define FF_DEFINED   86631 /* Revision ID */

Definition at line 23 of file ff.h.

FF_INTDEF

#define FF_INTDEF   1

Definition at line 57 of file ff.h.

FM_ANY

#define FM_ANY   0x07

Definition at line 401 of file ff.h.

FM_EXFAT

#define FM_EXFAT   0x04

Definition at line 400 of file ff.h.

FM_FAT

#define FM_FAT   0x01

Definition at line 398 of file ff.h.

FM_FAT32

#define FM_FAT32   0x02

Definition at line 399 of file ff.h.

FM_SFD

#define FM_SFD   0x08

Definition at line 402 of file ff.h.

FS_EXFAT

#define FS_EXFAT   4

Definition at line 408 of file ff.h.

FS_FAT12

#define FS_FAT12   1

Definition at line 405 of file ff.h.

FS_FAT16

#define FS_FAT16   2

Definition at line 406 of file ff.h.

FS_FAT32

#define FS_FAT32   3

Definition at line 407 of file ff.h.

Typedef Documentation

BYTE

typedef unsigned char BYTE

Definition at line 59 of file ff.h.

DWORD

typedef unsigned long DWORD

Definition at line 61 of file ff.h.

FSIZE_t

typedef DWORD FSIZE_t

Definition at line 82 of file ff.h.

LBA_t

typedef DWORD LBA_t

Definition at line 83 of file ff.h.

TCHAR

typedef char TCHAR

Definition at line 105 of file ff.h.

UINT

typedef unsigned int UINT

Definition at line 58 of file ff.h.

WCHAR

typedef WORD WCHAR

Definition at line 62 of file ff.h.

WORD

typedef unsigned short WORD

Definition at line 60 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 276 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 problem */
    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 > FF_FS_LOCK */
    FR_INVALID_PARAMETER    /* (19) Given parameter is invalid */
} FRESULT;

Function Documentation

f_chdir()

FRESULT f_chdir

(

const TCHAR *

path

)

Definition at line 4205 of file ff.c.

{
#if FF_STR_VOLUME_ID == 2
    UINT i;
#endif
    FRESULT res;
    DIR dj;
    FATFS *fs;
    DEF_NAMBUF
 
 
    /* Get logical drive */
    res = mount_volume(&path, &fs, 0);
    if (res == FR_OK) {
        dj.obj.fs = fs;
        INIT_NAMBUF(fs);
        res = follow_path(&dj, path);       /* Follow the path */
        if (res == FR_OK) {                 /* Follow completed */
            if (dj.fn[NSFLAG] & NS_NONAME) {    /* Is it the start directory itself? */
                fs->cdir = dj.obj.sclust;
#if FF_FS_EXFAT
                if (fs->fs_type == FS_EXFAT) {
                    fs->cdc_scl = dj.obj.c_scl;
                    fs->cdc_size = dj.obj.c_size;
                    fs->cdc_ofs = dj.obj.c_ofs;
                }
#endif
            } else {
                if (dj.obj.attr & AM_DIR) { /* It is a sub-directory */
#if FF_FS_EXFAT
                    if (fs->fs_type == FS_EXFAT) {
                        fs->cdir = ld_dword(fs->dirbuf + XDIR_FstClus);     /* Sub-directory cluster */
                        fs->cdc_scl = dj.obj.sclust;                        /* Save containing directory information */
                        fs->cdc_size = ((DWORD)dj.obj.objsize & 0xFFFFFF00) | dj.obj.stat;
                        fs->cdc_ofs = dj.blk_ofs;
                    } else
#endif
                    {
                        fs->cdir = ld_clust(fs, dj.dir);                    /* Sub-directory cluster */
                    }
                } else {
                    res = FR_NO_PATH;       /* Reached but a file */
                }
            }
        }
        FREE_NAMBUF();
        if (res == FR_NO_FILE) res = FR_NO_PATH;
#if FF_STR_VOLUME_ID == 2   /* Also current drive is changed if in Unix style volume ID */
        if (res == FR_OK) {
            for (i = FF_VOLUMES - 1; i && fs != FatFs[i]; i--) ;    /* Set current drive */
            CurrVol = (BYTE)i;
        }
#endif
    }
 
    LEAVE_FF(fs, res);
}

f_chdrive()

FRESULT f_chdrive

(

const TCHAR *

path

)

Definition at line 4188 of file ff.c.

{
    int vol;
 
 
    /* Get logical drive number */
    vol = get_ldnumber(&path);
    if (vol < 0) return FR_INVALID_DRIVE;
    CurrVol = (BYTE)vol;    /* Set it as current volume */
 
    return FR_OK;
}

f_chmod()

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

f_close()

FRESULT f_close

(

FIL *

fp

)

Definition at line 4152 of file ff.c.

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

f_closedir()

FRESULT f_closedir

(

DIR *

dp

)

Definition at line 4597 of file ff.c.

{
    FRESULT res;
    FATFS *fs;
 
 
    res = validate(&dp->obj, &fs);  /* Check validity of the file object */
    if (res == FR_OK) {
#if FF_FS_LOCK != 0
        if (dp->obj.lockid) res = dec_lock(dp->obj.lockid); /* Decrement sub-directory open counter */
        if (res == FR_OK) dp->obj.fs = 0;   /* Invalidate directory object */
#else
        dp->obj.fs = 0; /* Invalidate directory object */
#endif
#if FF_FS_REENTRANT
        unlock_fs(fs, FR_OK);       /* Unlock volume */
#endif
    }
    return res;
}

f_expand()

FRESULT f_expand	(	FIL *	fp,
		FSIZE_t	fsz,
		BYTE	opt
	)

f_fdisk()

FRESULT f_fdisk	(	BYTE	pdrv,
		const LBA_t	ptbl[],
		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 4750 of file ff.c.

{
    FRESULT res;
    FATFS *fs;
    DWORD nfree, clst, stat;
    LBA_t sect;
    UINT i;
    FFOBJID obj;
 
 
    /* Get logical drive */
    res = mount_volume(&path, &fs, 0);
    if (res == FR_OK) {
        *fatfs = fs;                /* Return ptr to the fs object */
        /* If free_clst is valid, return it without full FAT scan */
        if (fs->free_clst <= fs->n_fatent - 2) {
            *nclst = fs->free_clst;
        } else {
            /* Scan FAT to obtain number of free clusters */
            nfree = 0;
            if (fs->fs_type == FS_FAT12) {  /* FAT12: Scan bit field FAT entries */
                clst = 2; obj.fs = fs;
                do {
                    stat = get_fat(&obj, 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 {
#if FF_FS_EXFAT
                if (fs->fs_type == FS_EXFAT) {  /* exFAT: Scan allocation bitmap */
                    BYTE bm;
                    UINT b;
 
                    clst = fs->n_fatent - 2;    /* Number of clusters */
                    sect = fs->bitbase;         /* Bitmap sector */
                    i = 0;                      /* Offset in the sector */
                    do {    /* Counts numbuer of bits with zero in the bitmap */
                        if (i == 0) {
                            res = move_window(fs, sect++);
                            if (res != FR_OK) break;
                        }
                        for (b = 8, bm = fs->win[i]; b && clst; b--, clst--) {
                            if (!(bm & 1)) nfree++;
                            bm >>= 1;
                        }
                        i = (i + 1) % SS(fs);
                    } while (clst);
                } else
#endif
                {   /* FAT16/32: Scan WORD/DWORD FAT entries */
                    clst = fs->n_fatent;    /* Number of entries */
                    sect = fs->fatbase;     /* Top of the FAT */
                    i = 0;                  /* Offset in the sector */
                    do {    /* Counts numbuer of entries with zero in the FAT */
                        if (i == 0) {
                            res = move_window(fs, sect++);
                            if (res != FR_OK) break;
                        }
                        if (fs->fs_type == FS_FAT16) {
                            if (ld_word(fs->win + i) == 0) nfree++;
                            i += 2;
                        } else {
                            if ((ld_dword(fs->win + i) & 0x0FFFFFFF) == 0) nfree++;
                            i += 4;
                        }
                        i %= SS(fs);
                    } while (--clst);
                }
            }
            if (res == FR_OK) {     /* Update parameters if succeeded */
                *nclst = nfree;         /* Return the free clusters */
                fs->free_clst = nfree;  /* Now free_clst is valid */
                fs->fsi_flag |= 1;      /* FAT32: FSInfo is to be updated */
            }
        }
    }
 
    LEAVE_FF(fs, res);
}

f_getlabel()

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

f_gets()

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

Definition at line 6338 of file ff.c.

{
    int nc = 0;
    TCHAR *p = buff;
    BYTE s[4];
    UINT rc;
    DWORD dc;
#if FF_USE_LFN && FF_LFN_UNICODE && FF_STRF_ENCODE <= 2
    WCHAR wc;
#endif
#if FF_USE_LFN && FF_LFN_UNICODE && FF_STRF_ENCODE == 3
    UINT ct;
#endif
 
#if FF_USE_LFN && FF_LFN_UNICODE            /* With code conversion (Unicode API) */
    /* Make a room for the character and terminator  */
    if (FF_LFN_UNICODE == 1) len -= (FF_STRF_ENCODE == 0) ? 1 : 2;
    if (FF_LFN_UNICODE == 2) len -= (FF_STRF_ENCODE == 0) ? 3 : 4;
    if (FF_LFN_UNICODE == 3) len -= 1;
    while (nc < len) {
#if FF_STRF_ENCODE == 0             /* Read a character in ANSI/OEM */
        f_read(fp, s, 1, &rc);      /* Get a code unit */
        if (rc != 1) break;         /* EOF? */
        wc = s[0];
        if (dbc_1st((BYTE)wc)) {    /* DBC 1st byte? */
            f_read(fp, s, 1, &rc);  /* Get 2nd byte */
            if (rc != 1 || !dbc_2nd(s[0])) continue;    /* Wrong code? */
            wc = wc << 8 | s[0];
        }
        dc = ff_oem2uni(wc, CODEPAGE);  /* Convert ANSI/OEM into Unicode */
        if (dc == 0) continue;      /* Conversion error? */
#elif FF_STRF_ENCODE == 1 || FF_STRF_ENCODE == 2    /* Read a character in UTF-16LE/BE */
        f_read(fp, s, 2, &rc);      /* Get a code unit */
        if (rc != 2) break;         /* EOF? */
        dc = (FF_STRF_ENCODE == 1) ? ld_word(s) : s[0] << 8 | s[1];
        if (IsSurrogateL(dc)) continue; /* Broken surrogate pair? */
        if (IsSurrogateH(dc)) {     /* High surrogate? */
            f_read(fp, s, 2, &rc);  /* Get low surrogate */
            if (rc != 2) break;     /* EOF? */
            wc = (FF_STRF_ENCODE == 1) ? ld_word(s) : s[0] << 8 | s[1];
            if (!IsSurrogateL(wc)) continue;    /* Broken surrogate pair? */
            dc = ((dc & 0x3FF) + 0x40) << 10 | (wc & 0x3FF);    /* Merge surrogate pair */
        }
#else   /* Read a character in UTF-8 */
        f_read(fp, s, 1, &rc);      /* Get a code unit */
        if (rc != 1) break;         /* EOF? */
        dc = s[0];
        if (dc >= 0x80) {           /* Multi-byte sequence? */
            ct = 0;
            if ((dc & 0xE0) == 0xC0) { dc &= 0x1F; ct = 1; }    /* 2-byte sequence? */
            if ((dc & 0xF0) == 0xE0) { dc &= 0x0F; ct = 2; }    /* 3-byte sequence? */
            if ((dc & 0xF8) == 0xF0) { dc &= 0x07; ct = 3; }    /* 4-byte sequence? */
            if (ct == 0) continue;
            f_read(fp, s, ct, &rc); /* Get trailing bytes */
            if (rc != ct) break;
            rc = 0;
            do {    /* Merge the byte sequence */
                if ((s[rc] & 0xC0) != 0x80) break;
                dc = dc << 6 | (s[rc] & 0x3F);
            } while (++rc < ct);
            if (rc != ct || dc < 0x80 || IsSurrogate(dc) || dc >= 0x110000) continue;   /* Wrong encoding? */
        }
#endif
        /* A code point is avaialble in dc to be output */
 
        if (FF_USE_STRFUNC == 2 && dc == '\r') continue;    /* Strip \r off if needed */
#if FF_LFN_UNICODE == 1 || FF_LFN_UNICODE == 3  /* Output it in UTF-16/32 encoding */
        if (FF_LFN_UNICODE == 1 && dc >= 0x10000) { /* Out of BMP at UTF-16? */
            *p++ = (TCHAR)(0xD800 | ((dc >> 10) - 0x40)); nc++; /* Make and output high surrogate */
            dc = 0xDC00 | (dc & 0x3FF);     /* Make low surrogate */
        }
        *p++ = (TCHAR)dc; nc++;
        if (dc == '\n') break;  /* End of line? */
#elif FF_LFN_UNICODE == 2       /* Output it in UTF-8 encoding */
        if (dc < 0x80) {    /* Single byte? */
            *p++ = (TCHAR)dc;
            nc++;
            if (dc == '\n') break;  /* End of line? */
        } else {
            if (dc < 0x800) {       /* 2-byte sequence? */
                *p++ = (TCHAR)(0xC0 | (dc >> 6 & 0x1F));
                *p++ = (TCHAR)(0x80 | (dc >> 0 & 0x3F));
                nc += 2;
            } else {
                if (dc < 0x10000) { /* 3-byte sequence? */
                    *p++ = (TCHAR)(0xE0 | (dc >> 12 & 0x0F));
                    *p++ = (TCHAR)(0x80 | (dc >> 6 & 0x3F));
                    *p++ = (TCHAR)(0x80 | (dc >> 0 & 0x3F));
                    nc += 3;
                } else {            /* 4-byte sequence? */
                    *p++ = (TCHAR)(0xF0 | (dc >> 18 & 0x07));
                    *p++ = (TCHAR)(0x80 | (dc >> 12 & 0x3F));
                    *p++ = (TCHAR)(0x80 | (dc >> 6 & 0x3F));
                    *p++ = (TCHAR)(0x80 | (dc >> 0 & 0x3F));
                    nc += 4;
                }
            }
        }
#endif
    }
 
#else           /* Byte-by-byte read without any conversion (ANSI/OEM API) */
    len -= 1;   /* Make a room for the terminator */
    while (nc < len) {
        f_read(fp, s, 1, &rc);  /* Get a byte */
        if (rc != 1) break;     /* EOF? */
        dc = s[0];
        if (FF_USE_STRFUNC == 2 && dc == '\r') continue;
        *p++ = (TCHAR)dc; nc++;
        if (dc == '\n') break;
    }
#endif
 
    *p = 0;     /* Terminate the string */
    return nc ? buff : 0;   /* When no data read due to EOF or error, return with error. */
}

f_lseek()

FRESULT f_lseek	(	FIL *	fp,
		FSIZE_t	ofs
	)

Definition at line 4367 of file ff.c.

{
    FRESULT res;
    FATFS *fs;
    DWORD clst, bcs;
    LBA_t nsect;
    FSIZE_t ifptr;
#if FF_USE_FASTSEEK
    DWORD cl, pcl, ncl, tcl, tlen, ulen;
    DWORD *tbl;
    LBA_t dsc;
#endif
 
    res = validate(&fp->obj, &fs);      /* Check validity of the file object */
    if (res == FR_OK) res = (FRESULT)fp->err;
#if FF_FS_EXFAT && !FF_FS_READONLY
    if (res == FR_OK && fs->fs_type == FS_EXFAT) {
        res = fill_last_frag(&fp->obj, fp->clust, 0xFFFFFFFF);  /* Fill last fragment on the FAT if needed */
    }
#endif
    if (res != FR_OK) LEAVE_FF(fs, res);
 
#if FF_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->obj.sclust;        /* Origin of the chain */
            if (cl != 0) {
                do {
                    /* Get a fragment */
                    tcl = cl; ncl = 0; ulen += 2;   /* Top, length and used items */
                    do {
                        pcl = cl; ncl++;
                        cl = get_fat(&fp->obj, cl);
                        if (cl <= 1) ABORT(fs, FR_INT_ERR);
                        if (cl == 0xFFFFFFFF) ABORT(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 < 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->obj.objsize) ofs = fp->obj.objsize;   /* Clip offset at the file size */
            fp->fptr = ofs;             /* Set file pointer */
            if (ofs > 0) {
                fp->clust = clmt_clust(fp, ofs - 1);
                dsc = clst2sect(fs, fp->clust);
                if (dsc == 0) ABORT(fs, FR_INT_ERR);
                dsc += (DWORD)((ofs - 1) / SS(fs)) & (fs->csize - 1);
                if (fp->fptr % SS(fs) && dsc != fp->sect) { /* Refill sector cache if needed */
#if !FF_FS_TINY
#if !FF_FS_READONLY
                    if (fp->flag & FA_DIRTY) {      /* Write-back dirty sector cache */
                        if (disk_write(fs->pdrv, fp->buf, fp->sect, 1) != RES_OK) ABORT(fs, FR_DISK_ERR);
                        fp->flag &= (BYTE)~FA_DIRTY;
                    }
#endif
                    if (disk_read(fs->pdrv, fp->buf, dsc, 1) != RES_OK) ABORT(fs, FR_DISK_ERR); /* Load current sector */
#endif
                    fp->sect = dsc;
                }
            }
        }
    } else
#endif
 
    /* Normal Seek */
    {
#if FF_FS_EXFAT
        if (fs->fs_type != FS_EXFAT && ofs >= 0x100000000) ofs = 0xFFFFFFFF;    /* Clip at 4 GiB - 1 if at FATxx */
#endif
        if (ofs > fp->obj.objsize && (FF_FS_READONLY || !(fp->flag & FA_WRITE))) {  /* In read-only mode, clip offset with the file size */
            ofs = fp->obj.objsize;
        }
        ifptr = fp->fptr;
        fp->fptr = nsect = 0;
        if (ofs > 0) {
            bcs = (DWORD)fs->csize * SS(fs);    /* Cluster size (byte) */
            if (ifptr > 0 &&
                (ofs - 1) / bcs >= (ifptr - 1) / bcs) { /* When seek to same or following cluster, */
                fp->fptr = (ifptr - 1) & ~(FSIZE_t)(bcs - 1);   /* start from the current cluster */
                ofs -= fp->fptr;
                clst = fp->clust;
            } else {                                    /* When seek to back cluster, */
                clst = fp->obj.sclust;                  /* start from the first cluster */
#if !FF_FS_READONLY
                if (clst == 0) {                        /* If no cluster chain, create a new chain */
                    clst = create_chain(&fp->obj, 0);
                    if (clst == 1) ABORT(fs, FR_INT_ERR);
                    if (clst == 0xFFFFFFFF) ABORT(fs, FR_DISK_ERR);
                    fp->obj.sclust = clst;
                }
#endif
                fp->clust = clst;
            }
            if (clst != 0) {
                while (ofs > bcs) {                     /* Cluster following loop */
                    ofs -= bcs; fp->fptr += bcs;
#if !FF_FS_READONLY
                    if (fp->flag & FA_WRITE) {          /* Check if in write mode or not */
                        if (FF_FS_EXFAT && fp->fptr > fp->obj.objsize) {    /* No FAT chain object needs correct objsize to generate FAT value */
                            fp->obj.objsize = fp->fptr;
                            fp->flag |= FA_MODIFIED;
                        }
                        clst = create_chain(&fp->obj, clst);    /* Follow chain with forceed stretch */
                        if (clst == 0) {                /* Clip file size in case of disk full */
                            ofs = 0; break;
                        }
                    } else
#endif
                    {
                        clst = get_fat(&fp->obj, clst); /* Follow cluster chain if not in write mode */
                    }
                    if (clst == 0xFFFFFFFF) ABORT(fs, FR_DISK_ERR);
                    if (clst <= 1 || clst >= fs->n_fatent) ABORT(fs, FR_INT_ERR);
                    fp->clust = clst;
                }
                fp->fptr += ofs;
                if (ofs % SS(fs)) {
                    nsect = clst2sect(fs, clst);    /* Current sector */
                    if (nsect == 0) ABORT(fs, FR_INT_ERR);
                    nsect += (DWORD)(ofs / SS(fs));
                }
            }
        }
        if (!FF_FS_READONLY && fp->fptr > fp->obj.objsize) {    /* Set file change flag if the file size is extended */
            fp->obj.objsize = fp->fptr;
            fp->flag |= FA_MODIFIED;
        }
        if (fp->fptr % SS(fs) && nsect != fp->sect) {   /* Fill sector cache if needed */
#if !FF_FS_TINY
#if !FF_FS_READONLY
            if (fp->flag & FA_DIRTY) {          /* Write-back dirty sector cache */
                if (disk_write(fs->pdrv, fp->buf, fp->sect, 1) != RES_OK) ABORT(fs, FR_DISK_ERR);
                fp->flag &= (BYTE)~FA_DIRTY;
            }
#endif
            if (disk_read(fs->pdrv, fp->buf, nsect, 1) != RES_OK) ABORT(fs, FR_DISK_ERR);   /* Fill sector cache */
#endif
            fp->sect = nsect;
        }
    }
 
    LEAVE_FF(fs, res);
}

f_mkdir()

FRESULT f_mkdir

(

const TCHAR *

path

)

Definition at line 4986 of file ff.c.

{
    FRESULT res;
    DIR dj;
    FFOBJID sobj;
    FATFS *fs;
    DWORD dcl, pcl, tm;
    DEF_NAMBUF
 
 
    res = mount_volume(&path, &fs, FA_WRITE);   /* Get logical drive */
    if (res == FR_OK) {
        dj.obj.fs = fs;
        INIT_NAMBUF(fs);
        res = follow_path(&dj, path);           /* Follow the file path */
        if (res == FR_OK) res = FR_EXIST;       /* Name collision? */
        if (FF_FS_RPATH && res == FR_NO_FILE && (dj.fn[NSFLAG] & NS_DOT)) { /* Invalid name? */
            res = FR_INVALID_NAME;
        }
        if (res == FR_NO_FILE) {                /* It is clear to create a new directory */
            sobj.fs = fs;                       /* New object id to create a new chain */
            dcl = create_chain(&sobj, 0);       /* Allocate a cluster for the new directory */
            res = FR_OK;
            if (dcl == 0) res = FR_DENIED;      /* No space to allocate a new cluster? */
            if (dcl == 1) res = FR_INT_ERR;     /* Any insanity? */
            if (dcl == 0xFFFFFFFF) res = FR_DISK_ERR;   /* Disk error? */
            tm = GET_FATTIME();
            if (res == FR_OK) {
                res = dir_clear(fs, dcl);       /* Clean up the new table */
                if (res == FR_OK) {
                    if (!FF_FS_EXFAT || fs->fs_type != FS_EXFAT) {  /* Create dot entries (FAT only) */
                        memset(fs->win + DIR_Name, ' ', 11);    /* Create "." entry */
                        fs->win[DIR_Name] = '.';
                        fs->win[DIR_Attr] = AM_DIR;
                        st_dword(fs->win + DIR_ModTime, tm);
                        st_clust(fs, fs->win, dcl);
                        memcpy(fs->win + SZDIRE, fs->win, SZDIRE);  /* Create ".." entry */
                        fs->win[SZDIRE + 1] = '.'; pcl = dj.obj.sclust;
                        st_clust(fs, fs->win + SZDIRE, pcl);
                        fs->wflag = 1;
                    }
                    res = dir_register(&dj);    /* Register the object to the parent directoy */
                }
            }
            if (res == FR_OK) {
#if FF_FS_EXFAT
                if (fs->fs_type == FS_EXFAT) {  /* Initialize directory entry block */
                    st_dword(fs->dirbuf + XDIR_ModTime, tm);    /* Created time */
                    st_dword(fs->dirbuf + XDIR_FstClus, dcl);   /* Table start cluster */
                    st_dword(fs->dirbuf + XDIR_FileSize, (DWORD)fs->csize * SS(fs));    /* Directory size needs to be valid */
                    st_dword(fs->dirbuf + XDIR_ValidFileSize, (DWORD)fs->csize * SS(fs));
                    fs->dirbuf[XDIR_GenFlags] = 3;              /* Initialize the object flag */
                    fs->dirbuf[XDIR_Attr] = AM_DIR;             /* Attribute */
                    res = store_xdir(&dj);
                } else
#endif
                {
                    st_dword(dj.dir + DIR_ModTime, tm); /* Created time */
                    st_clust(fs, dj.dir, dcl);          /* Table start cluster */
                    dj.dir[DIR_Attr] = AM_DIR;          /* Attribute */
                    fs->wflag = 1;
                }
                if (res == FR_OK) {
                    res = sync_fs(fs);
                }
            } else {
                remove_chain(&sobj, dcl, 0);        /* Could not register, remove the allocated cluster */
            }
        }
        FREE_NAMBUF();
    }
 
    LEAVE_FF(fs, res);
}

f_mkfs()

FRESULT f_mkfs	(	const TCHAR *	path,
		const MKFS_PARM *	opt,
		void *	work,
		UINT	len
	)

f_mount()

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

Definition at line 3605 of file ff.c.

{
    FATFS *cfs;
    int vol;
    FRESULT res;
    const TCHAR *rp = path;
 
 
    /* Get logical drive number */
    vol = get_ldnumber(&rp);
    if (vol < 0) return FR_INVALID_DRIVE;
    cfs = FatFs[vol];                   /* Pointer to fs object */
 
    if (cfs) {
#if FF_FS_LOCK != 0
        clear_lock(cfs);
#endif
#if FF_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 FF_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 (opt == 0) return FR_OK;         /* Do not mount now, it will be mounted later */
 
    res = mount_volume(&path, &fs, 0);  /* Force mounted the volume */
    LEAVE_FF(fs, res);
}

f_open()

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

Definition at line 3653 of file ff.c.

{
    FRESULT res;
    DIR dj;
    FATFS *fs;
#if !FF_FS_READONLY
    DWORD cl, bcs, clst, tm;
    LBA_t sc;
    FSIZE_t ofs;
#endif
    DEF_NAMBUF
 
 
    if (!fp) return FR_INVALID_OBJECT;
 
    /* Get logical drive number */
    mode &= FF_FS_READONLY ? FA_READ : FA_READ | FA_WRITE | FA_CREATE_ALWAYS | FA_CREATE_NEW | FA_OPEN_ALWAYS | FA_OPEN_APPEND;
    res = mount_volume(&path, &fs, mode);
    if (res == FR_OK) {
        dj.obj.fs = fs;
        INIT_NAMBUF(fs);
        res = follow_path(&dj, path);   /* Follow the file path */
#if !FF_FS_READONLY /* Read/Write configuration */
        if (res == FR_OK) {
            if (dj.fn[NSFLAG] & NS_NONAME) {    /* Origin directory itself? */
                res = FR_INVALID_NAME;
            }
#if FF_FS_LOCK != 0
            else {
                res = chk_lock(&dj, (mode & ~FA_READ) ? 1 : 0);     /* Check if the file can be used */
            }
#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 FF_FS_LOCK != 0
                    res = enq_lock() ? dir_register(&dj) : FR_TOO_MANY_OPEN_FILES;
#else
                    res = dir_register(&dj);
#endif
                }
                mode |= FA_CREATE_ALWAYS;       /* File is created */
            }
            else {                              /* Any object with the same name is already existing */
                if (dj.obj.attr & (AM_RDO | AM_DIR)) {  /* Cannot overwrite it (R/O or DIR) */
                    res = FR_DENIED;
                } else {
                    if (mode & FA_CREATE_NEW) res = FR_EXIST;   /* Cannot create as new file */
                }
            }
            if (res == FR_OK && (mode & FA_CREATE_ALWAYS)) {    /* Truncate the file if overwrite mode */
#if FF_FS_EXFAT
                if (fs->fs_type == FS_EXFAT) {
                    /* Get current allocation info */
                    fp->obj.fs = fs;
                    init_alloc_info(fs, &fp->obj);
                    /* Set directory entry block initial state */
                    memset(fs->dirbuf + 2, 0, 30);  /* Clear 85 entry except for NumSec */
                    memset(fs->dirbuf + 38, 0, 26); /* Clear C0 entry except for NumName and NameHash */
                    fs->dirbuf[XDIR_Attr] = AM_ARC;
                    st_dword(fs->dirbuf + XDIR_CrtTime, GET_FATTIME());
                    fs->dirbuf[XDIR_GenFlags] = 1;
                    res = store_xdir(&dj);
                    if (res == FR_OK && fp->obj.sclust != 0) {  /* Remove the cluster chain if exist */
                        res = remove_chain(&fp->obj, fp->obj.sclust, 0);
                        fs->last_clst = fp->obj.sclust - 1;     /* Reuse the cluster hole */
                    }
                } else
#endif
                {
                    /* Set directory entry initial state */
                    tm = GET_FATTIME();                 /* Set created time */
                    st_dword(dj.dir + DIR_CrtTime, tm);
                    st_dword(dj.dir + DIR_ModTime, tm);
                    cl = ld_clust(fs, dj.dir);          /* Get current cluster chain */
                    dj.dir[DIR_Attr] = AM_ARC;          /* Reset attribute */
                    st_clust(fs, dj.dir, 0);            /* Reset file allocation info */
                    st_dword(dj.dir + DIR_FileSize, 0);
                    fs->wflag = 1;
                    if (cl != 0) {                      /* Remove the cluster chain if exist */
                        sc = fs->winsect;
                        res = remove_chain(&dj.obj, cl, 0);
                        if (res == FR_OK) {
                            res = move_window(fs, sc);
                            fs->last_clst = cl - 1;     /* Reuse the cluster hole */
                        }
                    }
                }
            }
        }
        else {  /* Open an existing file */
            if (res == FR_OK) {                 /* Is the object exsiting? */
                if (dj.obj.attr & AM_DIR) {     /* File open against a directory */
                    res = FR_NO_FILE;
                } else {
                    if ((mode & FA_WRITE) && (dj.obj.attr & AM_RDO)) { /* Write mode open against R/O file */
                        res = FR_DENIED;
                    }
                }
            }
        }
        if (res == FR_OK) {
            if (mode & FA_CREATE_ALWAYS) mode |= FA_MODIFIED;   /* Set file change flag if created or overwritten */
            fp->dir_sect = fs->winsect;         /* Pointer to the directory entry */
            fp->dir_ptr = dj.dir;
#if FF_FS_LOCK != 0
            fp->obj.lockid = inc_lock(&dj, (mode & ~FA_READ) ? 1 : 0);  /* Lock the file for this session */
            if (fp->obj.lockid == 0) res = FR_INT_ERR;
#endif
        }
#else       /* R/O configuration */
        if (res == FR_OK) {
            if (dj.fn[NSFLAG] & NS_NONAME) {    /* Is it origin directory itself? */
                res = FR_INVALID_NAME;
            } else {
                if (dj.obj.attr & AM_DIR) {     /* Is it a directory? */
                    res = FR_NO_FILE;
                }
            }
        }
#endif
 
        if (res == FR_OK) {
#if FF_FS_EXFAT
            if (fs->fs_type == FS_EXFAT) {
                fp->obj.c_scl = dj.obj.sclust;                          /* Get containing directory info */
                fp->obj.c_size = ((DWORD)dj.obj.objsize & 0xFFFFFF00) | dj.obj.stat;
                fp->obj.c_ofs = dj.blk_ofs;
                init_alloc_info(fs, &fp->obj);
            } else
#endif
            {
                fp->obj.sclust = ld_clust(fs, dj.dir);                  /* Get object allocation info */
                fp->obj.objsize = ld_dword(dj.dir + DIR_FileSize);
            }
#if FF_USE_FASTSEEK
            fp->cltbl = 0;      /* Disable fast seek mode */
#endif
            fp->obj.fs = fs;    /* Validate the file object */
            fp->obj.id = fs->id;
            fp->flag = mode;    /* Set file access mode */
            fp->err = 0;        /* Clear error flag */
            fp->sect = 0;       /* Invalidate current data sector */
            fp->fptr = 0;       /* Set file pointer top of the file */
#if !FF_FS_READONLY
#if !FF_FS_TINY
            memset(fp->buf, 0, sizeof fp->buf); /* Clear sector buffer */
#endif
            if ((mode & FA_SEEKEND) && fp->obj.objsize > 0) {   /* Seek to end of file if FA_OPEN_APPEND is specified */
                fp->fptr = fp->obj.objsize;         /* Offset to seek */
                bcs = (DWORD)fs->csize * SS(fs);    /* Cluster size in byte */
                clst = fp->obj.sclust;              /* Follow the cluster chain */
                for (ofs = fp->obj.objsize; res == FR_OK && ofs > bcs; ofs -= bcs) {
                    clst = get_fat(&fp->obj, clst);
                    if (clst <= 1) res = FR_INT_ERR;
                    if (clst == 0xFFFFFFFF) res = FR_DISK_ERR;
                }
                fp->clust = clst;
                if (res == FR_OK && ofs % SS(fs)) { /* Fill sector buffer if not on the sector boundary */
                    sc = clst2sect(fs, clst);
                    if (sc == 0) {
                        res = FR_INT_ERR;
                    } else {
                        fp->sect = sc + (DWORD)(ofs / SS(fs));
#if !FF_FS_TINY
                        if (disk_read(fs->pdrv, fp->buf, fp->sect, 1) != RES_OK) res = FR_DISK_ERR;
#endif
                    }
                }
#if FF_FS_LOCK != 0
                if (res != FR_OK) dec_lock(fp->obj.lockid); /* Decrement file open counter if seek failed */
#endif
            }
#endif
        }
 
        FREE_NAMBUF();
    }
 
    if (res != FR_OK) fp->obj.fs = 0;   /* Invalidate file object on error */
 
    LEAVE_FF(fs, res);
}

f_opendir()

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

Definition at line 4531 of file ff.c.

{
    FRESULT res;
    FATFS *fs;
    DEF_NAMBUF
 
 
    if (!dp) return FR_INVALID_OBJECT;
 
    /* Get logical drive */
    res = mount_volume(&path, &fs, 0);
    if (res == FR_OK) {
        dp->obj.fs = fs;
        INIT_NAMBUF(fs);
        res = follow_path(dp, path);            /* Follow the path to the directory */
        if (res == FR_OK) {                     /* Follow completed */
            if (!(dp->fn[NSFLAG] & NS_NONAME)) {    /* It is not the origin directory itself */
                if (dp->obj.attr & AM_DIR) {        /* This object is a sub-directory */
#if FF_FS_EXFAT
                    if (fs->fs_type == FS_EXFAT) {
                        dp->obj.c_scl = dp->obj.sclust;                         /* Get containing directory inforamation */
                        dp->obj.c_size = ((DWORD)dp->obj.objsize & 0xFFFFFF00) | dp->obj.stat;
                        dp->obj.c_ofs = dp->blk_ofs;
                        init_alloc_info(fs, &dp->obj);  /* Get object allocation info */
                    } else
#endif
                    {
                        dp->obj.sclust = ld_clust(fs, dp->dir); /* Get object allocation info */
                    }
                } else {                        /* This object is a file */
                    res = FR_NO_PATH;
                }
            }
            if (res == FR_OK) {
                dp->obj.id = fs->id;
                res = dir_sdi(dp, 0);           /* Rewind directory */
#if FF_FS_LOCK != 0
                if (res == FR_OK) {
                    if (dp->obj.sclust != 0) {
                        dp->obj.lockid = inc_lock(dp, 0);   /* Lock the sub directory */
                        if (!dp->obj.lockid) res = FR_TOO_MANY_OPEN_FILES;
                    } else {
                        dp->obj.lockid = 0; /* Root directory need not to be locked */
                    }
                }
#endif
            }
        }
        FREE_NAMBUF();
        if (res == FR_NO_FILE) res = FR_NO_PATH;
    }
    if (res != FR_OK) dp->obj.fs = 0;       /* Invalidate the directory object if function faild */
 
    LEAVE_FF(fs, res);
}

f_printf()

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

Definition at line 6801 of file ff.c.

{
    va_list arp;
    putbuff pb;
    UINT i, j, w, f, r;
    int prec;
#if FF_PRINT_LLI && FF_INTDEF == 2
    QWORD v;
#else
    DWORD v;
#endif
    TCHAR tc, pad, *tp;
    TCHAR nul = 0;
    char d, str[SZ_NUM_BUF];
 
 
    putc_init(&pb, fp);
 
    va_start(arp, fmt);
 
    for (;;) {
        tc = *fmt++;
        if (tc == 0) break;         /* End of format string */
        if (tc != '%') {            /* Not an escape character (pass-through) */
            putc_bfd(&pb, tc);
            continue;
        }
        f = w = 0; pad = ' '; prec = -1;    /* Initialize parms */
        tc = *fmt++;
        if (tc == '0') {            /* Flag: '0' padded */
            pad = '0'; tc = *fmt++;
        } else if (tc == '-') {     /* Flag: Left aligned */
            f = 2; tc = *fmt++;
        }
        if (tc == '*') {            /* Minimum width from an argument */
            w = va_arg(arp, int);
            tc = *fmt++;
        } else {
            while (IsDigit(tc)) {   /* Minimum width */
                w = w * 10 + tc - '0';
                tc = *fmt++;
            }
        }
        if (tc == '.') {            /* Precision */
            tc = *fmt++;
            if (tc == '*') {        /* Precision from an argument */
                prec = va_arg(arp, int);
                tc = *fmt++;
            } else {
                prec = 0;
                while (IsDigit(tc)) {   /* Precision */
                    prec = prec * 10 + tc - '0';
                    tc = *fmt++;
                }
            }
        }
        if (tc == 'l') {            /* Size: long int */
            f |= 4; tc = *fmt++;
#if FF_PRINT_LLI && FF_INTDEF == 2
            if (tc == 'l') {        /* Size: long long int */
                f |= 8; tc = *fmt++;
            }
#endif
        }
        if (tc == 0) break;         /* End of format string */
        switch (tc) {               /* Atgument type is... */
        case 'b':                   /* Unsigned binary */
            r = 2; break;
        case 'o':                   /* Unsigned octal */
            r = 8; break;
        case 'd':                   /* Signed decimal */
        case 'u':                   /* Unsigned decimal */
            r = 10; break;
        case 'x':                   /* Unsigned hexdecimal (lower case) */
        case 'X':                   /* Unsigned hexdecimal (upper case) */
            r = 16; break;
        case 'c':                   /* Character */
            putc_bfd(&pb, (TCHAR)va_arg(arp, int));
            continue;
        case 's':                   /* String */
            tp = va_arg(arp, TCHAR*);   /* Get a pointer argument */
            if (!tp) tp = &nul;     /* Null ptr generates a null string */
            for (j = 0; tp[j]; j++) ;   /* j = tcslen(tp) */
            if (prec >= 0 && j > (UINT)prec) j = prec;  /* Limited length of string body */
            for ( ; !(f & 2) && j < w; j++) putc_bfd(&pb, pad); /* Left pads */
            while (*tp && prec--) putc_bfd(&pb, *tp++); /* Body */
            while (j++ < w) putc_bfd(&pb, ' ');         /* Right pads */
            continue;
#if FF_PRINT_FLOAT && FF_INTDEF == 2
        case 'f':                   /* Floating point (decimal) */
        case 'e':                   /* Floating point (e) */
        case 'E':                   /* Floating point (E) */
            ftoa(str, va_arg(arp, double), prec, tc);   /* Make a flaoting point string */
            for (j = strlen(str); !(f & 2) && j < w; j++) putc_bfd(&pb, pad);   /* Left pads */
            for (i = 0; str[i]; putc_bfd(&pb, str[i++])) ;  /* Body */
            while (j++ < w) putc_bfd(&pb, ' '); /* Right pads */
            continue;
#endif
        default:                    /* Unknown type (pass-through) */
            putc_bfd(&pb, tc); continue;
        }
 
        /* Get an integer argument and put it in numeral */
#if FF_PRINT_LLI && FF_INTDEF == 2
        if (f & 8) {    /* long long argument? */
            v = (QWORD)va_arg(arp, LONGLONG);
        } else {
            if (f & 4) {    /* long argument? */
                v = (tc == 'd') ? (QWORD)(LONGLONG)va_arg(arp, long) : (QWORD)va_arg(arp, unsigned long);
            } else {        /* int/short/char argument */
                v = (tc == 'd') ? (QWORD)(LONGLONG)va_arg(arp, int) : (QWORD)va_arg(arp, unsigned int);
            }
        }
        if (tc == 'd' && (v & 0x8000000000000000)) {    /* Negative value? */
            v = 0 - v; f |= 1;
        }
#else
        if (f & 4) {    /* long argument? */
            v = (DWORD)va_arg(arp, long);
        } else {        /* int/short/char argument */
            v = (tc == 'd') ? (DWORD)(long)va_arg(arp, int) : (DWORD)va_arg(arp, unsigned int);
        }
        if (tc == 'd' && (v & 0x80000000)) {    /* Negative value? */
            v = 0 - v; f |= 1;
        }
#endif
        i = 0;
        do {    /* Make an integer number string */
            d = (char)(v % r); v /= r;
            if (d > 9) d += (tc == 'x') ? 0x27 : 0x07;
            str[i++] = d + '0';
        } while (v && i < SZ_NUM_BUF);
        if (f & 1) str[i++] = '-';  /* Sign */
        /* Write it */
        for (j = i; !(f & 2) && j < w; j++) putc_bfd(&pb, pad); /* Left pads */
        do putc_bfd(&pb, (TCHAR)str[--i]); while (i);   /* Body */
        while (j++ < w) putc_bfd(&pb, ' ');     /* Right pads */
    }
 
    va_end(arp);
 
    return putc_flush(&pb);
}

f_putc()

int f_putc	(	TCHAR	c,
		FIL *	fp
	)

Definition at line 6640 of file ff.c.

{
    putbuff pb;
 
 
    putc_init(&pb, fp);
    putc_bfd(&pb, c);   /* Put the character */
    return putc_flush(&pb);
}

f_puts()

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

Definition at line 6660 of file ff.c.

{
    putbuff pb;
 
 
    putc_init(&pb, fp);
    while (*str) putc_bfd(&pb, *str++);     /* Put the string */
    return putc_flush(&pb);
}

f_read()

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

Definition at line 3850 of file ff.c.

{
    FRESULT res;
    FATFS *fs;
    DWORD clst;
    LBA_t sect;
    FSIZE_t remain;
    UINT rcnt, cc, csect;
    BYTE *rbuff = (BYTE*)buff;
 
 
    *br = 0;    /* Clear read byte counter */
    res = validate(&fp->obj, &fs);              /* Check validity of the file object */
    if (res != FR_OK || (res = (FRESULT)fp->err) != FR_OK) LEAVE_FF(fs, res);   /* Check validity */
    if (!(fp->flag & FA_READ)) LEAVE_FF(fs, FR_DENIED); /* Check access mode */
    remain = fp->obj.objsize - fp->fptr;
    if (btr > remain) btr = (UINT)remain;       /* Truncate btr by remaining bytes */
 
    for ( ; btr > 0; btr -= rcnt, *br += rcnt, rbuff += rcnt, fp->fptr += rcnt) {   /* Repeat until btr bytes read */
        if (fp->fptr % SS(fs) == 0) {           /* On the sector boundary? */
            csect = (UINT)(fp->fptr / SS(fs) & (fs->csize - 1));    /* Sector offset in the cluster */
            if (csect == 0) {                   /* On the cluster boundary? */
                if (fp->fptr == 0) {            /* On the top of the file? */
                    clst = fp->obj.sclust;      /* Follow cluster chain from the origin */
                } else {                        /* Middle or end of the file */
#if FF_USE_FASTSEEK
                    if (fp->cltbl) {
                        clst = clmt_clust(fp, fp->fptr);    /* Get cluster# from the CLMT */
                    } else
#endif
                    {
                        clst = get_fat(&fp->obj, fp->clust);    /* Follow cluster chain on the FAT */
                    }
                }
                if (clst < 2) ABORT(fs, FR_INT_ERR);
                if (clst == 0xFFFFFFFF) ABORT(fs, FR_DISK_ERR);
                fp->clust = clst;               /* Update current cluster */
            }
            sect = clst2sect(fs, fp->clust);    /* Get current sector */
            if (sect == 0) ABORT(fs, FR_INT_ERR);
            sect += csect;
            cc = btr / SS(fs);                  /* When remaining bytes >= sector size, */
            if (cc > 0) {                       /* Read maximum contiguous sectors directly */
                if (csect + cc > fs->csize) {   /* Clip at cluster boundary */
                    cc = fs->csize - csect;
                }
                if (disk_read(fs->pdrv, rbuff, sect, cc) != RES_OK) ABORT(fs, FR_DISK_ERR);
#if !FF_FS_READONLY && FF_FS_MINIMIZE <= 2      /* Replace one of the read sectors with cached data if it contains a dirty sector */
#if FF_FS_TINY
                if (fs->wflag && fs->winsect - sect < cc) {
                    memcpy(rbuff + ((fs->winsect - sect) * SS(fs)), fs->win, SS(fs));
                }
#else
                if ((fp->flag & FA_DIRTY) && fp->sect - sect < cc) {
                    memcpy(rbuff + ((fp->sect - sect) * SS(fs)), fp->buf, SS(fs));
                }
#endif
#endif
                rcnt = SS(fs) * cc;             /* Number of bytes transferred */
                continue;
            }
#if !FF_FS_TINY
            if (fp->sect != sect) {         /* Load data sector if not in cache */
#if !FF_FS_READONLY
                if (fp->flag & FA_DIRTY) {      /* Write-back dirty sector cache */
                    if (disk_write(fs->pdrv, fp->buf, fp->sect, 1) != RES_OK) ABORT(fs, FR_DISK_ERR);
                    fp->flag &= (BYTE)~FA_DIRTY;
                }
#endif
                if (disk_read(fs->pdrv, fp->buf, sect, 1) != RES_OK)    ABORT(fs, FR_DISK_ERR); /* Fill sector cache */
            }
#endif
            fp->sect = sect;
        }
        rcnt = SS(fs) - (UINT)fp->fptr % SS(fs);    /* Number of bytes remains in the sector */
        if (rcnt > btr) rcnt = btr;                 /* Clip it by btr if needed */
#if FF_FS_TINY
        if (move_window(fs, fp->sect) != FR_OK) ABORT(fs, FR_DISK_ERR); /* Move sector window */
        memcpy(rbuff, fs->win + fp->fptr % SS(fs), rcnt);   /* Extract partial sector */
#else
        memcpy(rbuff, fp->buf + fp->fptr % SS(fs), rcnt);   /* Extract partial sector */
#endif
    }
 
    LEAVE_FF(fs, FR_OK);
}

f_readdir()

FRESULT f_readdir	(	DIR *	dp,
		FILINFO *	fno
	)

Definition at line 4627 of file ff.c.

{
    FRESULT res;
    FATFS *fs;
    DEF_NAMBUF
 
 
    res = validate(&dp->obj, &fs);  /* Check validity of the directory object */
    if (res == FR_OK) {
        if (!fno) {
            res = dir_sdi(dp, 0);           /* Rewind the directory object */
        } else {
            INIT_NAMBUF(fs);
            res = DIR_READ_FILE(dp);        /* Read an item */
            if (res == FR_NO_FILE) res = FR_OK; /* Ignore end of directory */
            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) res = FR_OK; /* Ignore end of directory now */
            }
            FREE_NAMBUF();
        }
    }
    LEAVE_FF(fs, res);
}

f_rename()

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

Definition at line 5070 of file ff.c.

{
    FRESULT res;
    DIR djo, djn;
    FATFS *fs;
    BYTE buf[FF_FS_EXFAT ? SZDIRE * 2 : SZDIRE], *dir;
    LBA_t sect;
    DEF_NAMBUF
 
 
    get_ldnumber(&path_new);                        /* Snip the drive number of new name off */
    res = mount_volume(&path_old, &fs, FA_WRITE);   /* Get logical drive of the old object */
    if (res == FR_OK) {
        djo.obj.fs = fs;
        INIT_NAMBUF(fs);
        res = follow_path(&djo, path_old);          /* Check old object */
        if (res == FR_OK && (djo.fn[NSFLAG] & (NS_DOT | NS_NONAME))) res = FR_INVALID_NAME; /* Check validity of name */
#if FF_FS_LOCK != 0
        if (res == FR_OK) {
            res = chk_lock(&djo, 2);
        }
#endif
        if (res == FR_OK) {                 /* Object to be renamed is found */
#if FF_FS_EXFAT
            if (fs->fs_type == FS_EXFAT) {  /* At exFAT volume */
                BYTE nf, nn;
                WORD nh;
 
                memcpy(buf, fs->dirbuf, SZDIRE * 2);    /* Save 85+C0 entry of old object */
                memcpy(&djn, &djo, sizeof djo);
                res = follow_path(&djn, path_new);      /* Make sure if new object name is not in use */
                if (res == FR_OK) {                     /* Is new name already in use by any other object? */
                    res = (djn.obj.sclust == djo.obj.sclust && djn.dptr == djo.dptr) ? FR_NO_FILE : FR_EXIST;
                }
                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) {
                        nf = fs->dirbuf[XDIR_NumSec]; nn = fs->dirbuf[XDIR_NumName];
                        nh = ld_word(fs->dirbuf + XDIR_NameHash);
                        memcpy(fs->dirbuf, buf, SZDIRE * 2);    /* Restore 85+C0 entry */
                        fs->dirbuf[XDIR_NumSec] = nf; fs->dirbuf[XDIR_NumName] = nn;
                        st_word(fs->dirbuf + XDIR_NameHash, nh);
                        if (!(fs->dirbuf[XDIR_Attr] & AM_DIR)) fs->dirbuf[XDIR_Attr] |= AM_ARC; /* Set archive attribute if it is a file */
/* Start of critical section where an interruption can cause a cross-link */
                        res = store_xdir(&djn);
                    }
                }
            } else
#endif
            {   /* At FAT/FAT32 volume */
                memcpy(buf, djo.dir, SZDIRE);           /* Save directory entry of the object */
                memcpy(&djn, &djo, sizeof (DIR));       /* Duplicate the directory object */
                res = follow_path(&djn, path_new);      /* Make sure if new object name is not in use */
                if (res == FR_OK) {                     /* Is new name already in use by any other object? */
                    res = (djn.obj.sclust == djo.obj.sclust && djn.dptr == djo.dptr) ? FR_NO_FILE : FR_EXIST;
                }
                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) {
                        dir = djn.dir;                  /* Copy directory entry of the object except name */
                        memcpy(dir + 13, buf + 13, SZDIRE - 13);
                        dir[DIR_Attr] = buf[DIR_Attr];
                        if (!(dir[DIR_Attr] & AM_DIR)) dir[DIR_Attr] |= AM_ARC; /* Set archive attribute if it is a file */
                        fs->wflag = 1;
                        if ((dir[DIR_Attr] & AM_DIR) && djo.obj.sclust != djn.obj.sclust) { /* Update .. entry in the sub-directory if needed */
                            sect = clst2sect(fs, ld_clust(fs, dir));
                            if (sect == 0) {
                                res = FR_INT_ERR;
                            } else {
/* Start of critical section where an interruption can cause a cross-link */
                                res = move_window(fs, sect);
                                dir = fs->win + SZDIRE * 1; /* Ptr to .. entry */
                                if (res == FR_OK && dir[1] == '.') {
                                    st_clust(fs, dir, djn.obj.sclust);
                                    fs->wflag = 1;
                                }
                            }
                        }
                    }
                }
            }
            if (res == FR_OK) {
                res = dir_remove(&djo);     /* Remove old entry */
                if (res == FR_OK) {
                    res = sync_fs(fs);
                }
            }
/* End of the critical section */
        }
        FREE_NAMBUF();
    }
 
    LEAVE_FF(fs, res);
}

f_setcp()

FRESULT f_setcp

(

WORD

cp

)

f_setlabel()

FRESULT f_setlabel

(

const TCHAR *

label

)

f_stat()

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

Definition at line 4715 of file ff.c.

{
    FRESULT res;
    DIR dj;
    DEF_NAMBUF
 
 
    /* Get logical drive */
    res = mount_volume(&path, &dj.obj.fs, 0);
    if (res == FR_OK) {
        INIT_NAMBUF(dj.obj.fs);
        res = follow_path(&dj, path);   /* Follow the file path */
        if (res == FR_OK) {             /* Follow completed */
            if (dj.fn[NSFLAG] & NS_NONAME) {    /* It is origin directory */
                res = FR_INVALID_NAME;
            } else {                            /* Found an object */
                if (fno) get_fileinfo(&dj, fno);
            }
        }
        FREE_NAMBUF();
    }
 
    LEAVE_FF(dj.obj.fs, res);
}

f_sync()

FRESULT f_sync

(

FIL *

fp

)

Definition at line 4071 of file ff.c.

{
    FRESULT res;
    FATFS *fs;
    DWORD tm;
    BYTE *dir;
 
 
    res = validate(&fp->obj, &fs);  /* Check validity of the file object */
    if (res == FR_OK) {
        if (fp->flag & FA_MODIFIED) {   /* Is there any change to the file? */
#if !FF_FS_TINY
            if (fp->flag & FA_DIRTY) {  /* Write-back cached data if needed */
                if (disk_write(fs->pdrv, fp->buf, fp->sect, 1) != RES_OK) LEAVE_FF(fs, FR_DISK_ERR);
                fp->flag &= (BYTE)~FA_DIRTY;
            }
#endif
            /* Update the directory entry */
            tm = GET_FATTIME();             /* Modified time */
#if FF_FS_EXFAT
            if (fs->fs_type == FS_EXFAT) {
                res = fill_first_frag(&fp->obj);    /* Fill first fragment on the FAT if needed */
                if (res == FR_OK) {
                    res = fill_last_frag(&fp->obj, fp->clust, 0xFFFFFFFF);  /* Fill last fragment on the FAT if needed */
                }
                if (res == FR_OK) {
                    DIR dj;
                    DEF_NAMBUF
 
                    INIT_NAMBUF(fs);
                    res = load_obj_xdir(&dj, &fp->obj); /* Load directory entry block */
                    if (res == FR_OK) {
                        fs->dirbuf[XDIR_Attr] |= AM_ARC;                /* Set archive attribute to indicate that the file has been changed */
                        fs->dirbuf[XDIR_GenFlags] = fp->obj.stat | 1;   /* Update file allocation information */
                        st_dword(fs->dirbuf + XDIR_FstClus, fp->obj.sclust);        /* Update start cluster */
                        st_qword(fs->dirbuf + XDIR_FileSize, fp->obj.objsize);      /* Update file size */
                        st_qword(fs->dirbuf + XDIR_ValidFileSize, fp->obj.objsize); /* (FatFs does not support Valid File Size feature) */
                        st_dword(fs->dirbuf + XDIR_ModTime, tm);        /* Update modified time */
                        fs->dirbuf[XDIR_ModTime10] = 0;
                        st_dword(fs->dirbuf + XDIR_AccTime, 0);
                        res = store_xdir(&dj);  /* Restore it to the directory */
                        if (res == FR_OK) {
                            res = sync_fs(fs);
                            fp->flag &= (BYTE)~FA_MODIFIED;
                        }
                    }
                    FREE_NAMBUF();
                }
            } else
#endif
            {
                res = move_window(fs, fp->dir_sect);
                if (res == FR_OK) {
                    dir = fp->dir_ptr;
                    dir[DIR_Attr] |= AM_ARC;                        /* Set archive attribute to indicate that the file has been changed */
                    st_clust(fp->obj.fs, dir, fp->obj.sclust);      /* Update file allocation information  */
                    st_dword(dir + DIR_FileSize, (DWORD)fp->obj.objsize);   /* Update file size */
                    st_dword(dir + DIR_ModTime, tm);                /* Update modified time */
                    st_word(dir + DIR_LstAccDate, 0);
                    fs->wflag = 1;
                    res = sync_fs(fs);                  /* Restore it to the directory */
                    fp->flag &= (BYTE)~FA_MODIFIED;
                }
            }
        }
    }
 
    LEAVE_FF(fs, res);
}

f_truncate()

FRESULT f_truncate

(

FIL *

fp

)

Definition at line 4842 of file ff.c.

{
    FRESULT res;
    FATFS *fs;
    DWORD ncl;
 
 
    res = validate(&fp->obj, &fs);  /* Check validity of the file object */
    if (res != FR_OK || (res = (FRESULT)fp->err) != FR_OK) LEAVE_FF(fs, res);
    if (!(fp->flag & FA_WRITE)) LEAVE_FF(fs, FR_DENIED);    /* Check access mode */
 
    if (fp->fptr < fp->obj.objsize) {   /* Process when fptr is not on the eof */
        if (fp->fptr == 0) {    /* When set file size to zero, remove entire cluster chain */
            res = remove_chain(&fp->obj, fp->obj.sclust, 0);
            fp->obj.sclust = 0;
        } else {                /* When truncate a part of the file, remove remaining clusters */
            ncl = get_fat(&fp->obj, fp->clust);
            res = FR_OK;
            if (ncl == 0xFFFFFFFF) res = FR_DISK_ERR;
            if (ncl == 1) res = FR_INT_ERR;
            if (res == FR_OK && ncl < fs->n_fatent) {
                res = remove_chain(&fp->obj, ncl, fp->clust);
            }
        }
        fp->obj.objsize = fp->fptr; /* Set file size to current read/write point */
        fp->flag |= FA_MODIFIED;
#if !FF_FS_TINY
        if (res == FR_OK && (fp->flag & FA_DIRTY)) {
            if (disk_write(fs->pdrv, fp->buf, fp->sect, 1) != RES_OK) {
                res = FR_DISK_ERR;
            } else {
                fp->flag &= (BYTE)~FA_DIRTY;
            }
        }
#endif
        if (res != FR_OK) ABORT(fs, res);
    }
 
    LEAVE_FF(fs, res);
}

f_unlink()

FRESULT f_unlink

(

const TCHAR *

path

)

Definition at line 4892 of file ff.c.

{
    FRESULT res;
    DIR dj, sdj;
    DWORD dclst = 0;
    FATFS *fs;
#if FF_FS_EXFAT
    FFOBJID obj;
#endif
    DEF_NAMBUF
 
 
    /* Get logical drive */
    res = mount_volume(&path, &fs, FA_WRITE);
    if (res == FR_OK) {
        dj.obj.fs = fs;
        INIT_NAMBUF(fs);
        res = follow_path(&dj, path);       /* Follow the file path */
        if (FF_FS_RPATH && res == FR_OK && (dj.fn[NSFLAG] & NS_DOT)) {
            res = FR_INVALID_NAME;          /* Cannot remove dot entry */
        }
#if FF_FS_LOCK != 0
        if (res == FR_OK) res = chk_lock(&dj, 2);   /* Check if it is an open object */
#endif
        if (res == FR_OK) {                 /* The object is accessible */
            if (dj.fn[NSFLAG] & NS_NONAME) {
                res = FR_INVALID_NAME;      /* Cannot remove the origin directory */
            } else {
                if (dj.obj.attr & AM_RDO) {
                    res = FR_DENIED;        /* Cannot remove R/O object */
                }
            }
            if (res == FR_OK) {
#if FF_FS_EXFAT
                obj.fs = fs;
                if (fs->fs_type == FS_EXFAT) {
                    init_alloc_info(fs, &obj);
                    dclst = obj.sclust;
                } else
#endif
                {
                    dclst = ld_clust(fs, dj.dir);
                }
                if (dj.obj.attr & AM_DIR) {         /* Is it a sub-directory? */
#if FF_FS_RPATH != 0
                    if (dclst == fs->cdir) {        /* Is it the current directory? */
                        res = FR_DENIED;
                    } else
#endif
                    {
                        sdj.obj.fs = fs;            /* Open the sub-directory */
                        sdj.obj.sclust = dclst;
#if FF_FS_EXFAT
                        if (fs->fs_type == FS_EXFAT) {
                            sdj.obj.objsize = obj.objsize;
                            sdj.obj.stat = obj.stat;
                        }
#endif
                        res = dir_sdi(&sdj, 0);
                        if (res == FR_OK) {
                            res = DIR_READ_FILE(&sdj);          /* Test if the directory is empty */
                            if (res == FR_OK) res = FR_DENIED;  /* Not empty? */
                            if (res == FR_NO_FILE) res = FR_OK; /* Empty? */
                        }
                    }
                }
            }
            if (res == FR_OK) {
                res = dir_remove(&dj);          /* Remove the directory entry */
                if (res == FR_OK && dclst != 0) {   /* Remove the cluster chain if exist */
#if FF_FS_EXFAT
                    res = remove_chain(&obj, dclst, 0);
#else
                    res = remove_chain(&dj.obj, dclst, 0);
#endif
                }
                if (res == FR_OK) res = sync_fs(fs);
            }
        }
        FREE_NAMBUF();
    }
 
    LEAVE_FF(fs, res);
}

f_utime()

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

f_write()

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

Definition at line 3950 of file ff.c.

{
    FRESULT res;
    FATFS *fs;
    DWORD clst;
    LBA_t sect;
    UINT wcnt, cc, csect;
    const BYTE *wbuff = (const BYTE*)buff;
 
 
    *bw = 0;    /* Clear write byte counter */
    res = validate(&fp->obj, &fs);          /* Check validity of the file object */
    if (res != FR_OK || (res = (FRESULT)fp->err) != FR_OK) LEAVE_FF(fs, res);   /* Check validity */
    if (!(fp->flag & FA_WRITE)) LEAVE_FF(fs, FR_DENIED);    /* Check access mode */
 
    /* Check fptr wrap-around (file size cannot reach 4 GiB at FAT volume) */
    if ((!FF_FS_EXFAT || fs->fs_type != FS_EXFAT) && (DWORD)(fp->fptr + btw) < (DWORD)fp->fptr) {
        btw = (UINT)(0xFFFFFFFF - (DWORD)fp->fptr);
    }
 
    for ( ; btw > 0; btw -= wcnt, *bw += wcnt, wbuff += wcnt, fp->fptr += wcnt, fp->obj.objsize = (fp->fptr > fp->obj.objsize) ? fp->fptr : fp->obj.objsize) {  /* Repeat until all data written */
        if (fp->fptr % SS(fs) == 0) {       /* On the sector boundary? */
            csect = (UINT)(fp->fptr / SS(fs)) & (fs->csize - 1);    /* Sector offset in the cluster */
            if (csect == 0) {               /* On the cluster boundary? */
                if (fp->fptr == 0) {        /* On the top of the file? */
                    clst = fp->obj.sclust;  /* Follow from the origin */
                    if (clst == 0) {        /* If no cluster is allocated, */
                        clst = create_chain(&fp->obj, 0);   /* create a new cluster chain */
                    }
                } else {                    /* On the middle or end of the file */
#if FF_USE_FASTSEEK
                    if (fp->cltbl) {
                        clst = clmt_clust(fp, fp->fptr);    /* Get cluster# from the CLMT */
                    } else
#endif
                    {
                        clst = create_chain(&fp->obj, 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(fs, FR_INT_ERR);
                if (clst == 0xFFFFFFFF) ABORT(fs, FR_DISK_ERR);
                fp->clust = clst;           /* Update current cluster */
                if (fp->obj.sclust == 0) fp->obj.sclust = clst; /* Set start cluster if the first write */
            }
#if FF_FS_TINY
            if (fs->winsect == fp->sect && sync_window(fs) != FR_OK) ABORT(fs, FR_DISK_ERR);    /* Write-back sector cache */
#else
            if (fp->flag & FA_DIRTY) {      /* Write-back sector cache */
                if (disk_write(fs->pdrv, fp->buf, fp->sect, 1) != RES_OK) ABORT(fs, FR_DISK_ERR);
                fp->flag &= (BYTE)~FA_DIRTY;
            }
#endif
            sect = clst2sect(fs, fp->clust);    /* Get current sector */
            if (sect == 0) ABORT(fs, FR_INT_ERR);
            sect += csect;
            cc = btw / SS(fs);              /* When remaining bytes >= sector size, */
            if (cc > 0) {                   /* Write maximum contiguous sectors directly */
                if (csect + cc > fs->csize) {   /* Clip at cluster boundary */
                    cc = fs->csize - csect;
                }
                if (disk_write(fs->pdrv, wbuff, sect, cc) != RES_OK) ABORT(fs, FR_DISK_ERR);
#if FF_FS_MINIMIZE <= 2
#if FF_FS_TINY
                if (fs->winsect - sect < cc) {  /* Refill sector cache if it gets invalidated by the direct write */
                    memcpy(fs->win, wbuff + ((fs->winsect - sect) * SS(fs)), SS(fs));
                    fs->wflag = 0;
                }
#else
                if (fp->sect - sect < cc) { /* Refill sector cache if it gets invalidated by the direct write */
                    memcpy(fp->buf, wbuff + ((fp->sect - sect) * SS(fs)), SS(fs));
                    fp->flag &= (BYTE)~FA_DIRTY;
                }
#endif
#endif
                wcnt = SS(fs) * cc;     /* Number of bytes transferred */
                continue;
            }
#if FF_FS_TINY
            if (fp->fptr >= fp->obj.objsize) {  /* Avoid silly cache filling on the growing edge */
                if (sync_window(fs) != FR_OK) ABORT(fs, FR_DISK_ERR);
                fs->winsect = sect;
            }
#else
            if (fp->sect != sect &&         /* Fill sector cache with file data */
                fp->fptr < fp->obj.objsize &&
                disk_read(fs->pdrv, fp->buf, sect, 1) != RES_OK) {
                    ABORT(fs, FR_DISK_ERR);
            }
#endif
            fp->sect = sect;
        }
        wcnt = SS(fs) - (UINT)fp->fptr % SS(fs);    /* Number of bytes remains in the sector */
        if (wcnt > btw) wcnt = btw;                 /* Clip it by btw if needed */
#if FF_FS_TINY
        if (move_window(fs, fp->sect) != FR_OK) ABORT(fs, FR_DISK_ERR); /* Move sector window */
        memcpy(fs->win + fp->fptr % SS(fs), wbuff, wcnt);   /* Fit data to the sector */
        fs->wflag = 1;
#else
        memcpy(fp->buf + fp->fptr % SS(fs), wbuff, wcnt);   /* Fit data to the sector */
        fp->flag |= FA_DIRTY;
#endif
    }
 
    fp->flag |= FA_MODIFIED;                /* Set file change flag */
 
    LEAVE_FF(fs, FR_OK);
}

ff_memalloc()

void * ff_memalloc

(

UINT

msize

)

Definition at line 16 of file ffsystem.c.

{
    return malloc(msize);   /* Allocate a new memory block with POSIX API */
}

ff_memfree()

void ff_memfree

(

void *

mblock

)

Definition at line 28 of file ffsystem.c.

{
    free(mblock);   /* Free the memory block with POSIX API */
}

ff_oem2uni()

WCHAR ff_oem2uni	(	WCHAR	oem,
		WORD	cp
	)

Definition at line 15244 of file ffunicode.c.

{
    WCHAR c = 0;
    const WCHAR *p = CVTBL(uc, FF_CODE_PAGE);
 
 
    if (oem < 0x80) {   /* ASCII? */
        c = oem;
 
    } else {            /* Extended char */
        if (cp == FF_CODE_PAGE) {   /* Is it a valid code page? */
            if (oem < 0x100) c = p[oem - 0x80];
        }
    }
 
    return c;
}

ff_uni2oem()

WCHAR ff_uni2oem	(	DWORD	uni,
		WORD	cp
	)

Definition at line 15222 of file ffunicode.c.

{
    WCHAR c = 0;
    const WCHAR *p = CVTBL(uc, FF_CODE_PAGE);
 
 
    if (uni < 0x80) {   /* ASCII? */
        c = (WCHAR)uni;
 
    } else {            /* Non-ASCII */
        if (uni < 0x10000 && cp == FF_CODE_PAGE) {  /* Is it in BMP and valid code page? */
            for (c = 0; c < 0x80 && uni != p[c]; c++) ;
            c = (c + 0x80) & 0xFF;
        }
    }
 
    return c;
}

ff_wtoupper()

DWORD ff_wtoupper

(

DWORD

uni

)

Definition at line 15464 of file ffunicode.c.

{
    const WORD *p;
    WORD uc, bc, nc, cmd;
    static const WORD cvt1[] = {    /* Compressed up conversion table for U+0000 - U+0FFF */
        /* Basic Latin */
        0x0061,0x031A,
        /* Latin-1 Supplement */
        0x00E0,0x0317,
        0x00F8,0x0307,
        0x00FF,0x0001,0x0178,
        /* Latin Extended-A */
        0x0100,0x0130,
        0x0132,0x0106,
        0x0139,0x0110,
        0x014A,0x012E,
        0x0179,0x0106,
        /* Latin Extended-B */
        0x0180,0x004D,0x0243,0x0181,0x0182,0x0182,0x0184,0x0184,0x0186,0x0187,0x0187,0x0189,0x018A,0x018B,0x018B,0x018D,0x018E,0x018F,0x0190,0x0191,0x0191,0x0193,0x0194,0x01F6,0x0196,0x0197,0x0198,0x0198,0x023D,0x019B,0x019C,0x019D,0x0220,0x019F,0x01A0,0x01A0,0x01A2,0x01A2,0x01A4,0x01A4,0x01A6,0x01A7,0x01A7,0x01A9,0x01AA,0x01AB,0x01AC,0x01AC,0x01AE,0x01AF,0x01AF,0x01B1,0x01B2,0x01B3,0x01B3,0x01B5,0x01B5,0x01B7,0x01B8,0x01B8,0x01BA,0x01BB,0x01BC,0x01BC,0x01BE,0x01F7,0x01C0,0x01C1,0x01C2,0x01C3,0x01C4,0x01C5,0x01C4,0x01C7,0x01C8,0x01C7,0x01CA,0x01CB,0x01CA,
        0x01CD,0x0110,
        0x01DD,0x0001,0x018E,
        0x01DE,0x0112,
        0x01F3,0x0003,0x01F1,0x01F4,0x01F4,
        0x01F8,0x0128,
        0x0222,0x0112,
        0x023A,0x0009,0x2C65,0x023B,0x023B,0x023D,0x2C66,0x023F,0x0240,0x0241,0x0241,
        0x0246,0x010A,
        /* IPA Extensions */
        0x0253,0x0040,0x0181,0x0186,0x0255,0x0189,0x018A,0x0258,0x018F,0x025A,0x0190,0x025C,0x025D,0x025E,0x025F,0x0193,0x0261,0x0262,0x0194,0x0264,0x0265,0x0266,0x0267,0x0197,0x0196,0x026A,0x2C62,0x026C,0x026D,0x026E,0x019C,0x0270,0x0271,0x019D,0x0273,0x0274,0x019F,0x0276,0x0277,0x0278,0x0279,0x027A,0x027B,0x027C,0x2C64,0x027E,0x027F,0x01A6,0x0281,0x0282,0x01A9,0x0284,0x0285,0x0286,0x0287,0x01AE,0x0244,0x01B1,0x01B2,0x0245,0x028D,0x028E,0x028F,0x0290,0x0291,0x01B7,
        /* Greek, Coptic */
        0x037B,0x0003,0x03FD,0x03FE,0x03FF,
        0x03AC,0x0004,0x0386,0x0388,0x0389,0x038A,
        0x03B1,0x0311,
        0x03C2,0x0002,0x03A3,0x03A3,
        0x03C4,0x0308,
        0x03CC,0x0003,0x038C,0x038E,0x038F,
        0x03D8,0x0118,
        0x03F2,0x000A,0x03F9,0x03F3,0x03F4,0x03F5,0x03F6,0x03F7,0x03F7,0x03F9,0x03FA,0x03FA,
        /* Cyrillic */
        0x0430,0x0320,
        0x0450,0x0710,
        0x0460,0x0122,
        0x048A,0x0136,
        0x04C1,0x010E,
        0x04CF,0x0001,0x04C0,
        0x04D0,0x0144,
        /* Armenian */
        0x0561,0x0426,
 
        0x0000  /* EOT */
    };
    static const WORD cvt2[] = {    /* Compressed up conversion table for U+1000 - U+FFFF */
        /* Phonetic Extensions */
        0x1D7D,0x0001,0x2C63,
        /* Latin Extended Additional */
        0x1E00,0x0196,
        0x1EA0,0x015A,
        /* Greek Extended */
        0x1F00,0x0608,
        0x1F10,0x0606,
        0x1F20,0x0608,
        0x1F30,0x0608,
        0x1F40,0x0606,
        0x1F51,0x0007,0x1F59,0x1F52,0x1F5B,0x1F54,0x1F5D,0x1F56,0x1F5F,
        0x1F60,0x0608,
        0x1F70,0x000E,0x1FBA,0x1FBB,0x1FC8,0x1FC9,0x1FCA,0x1FCB,0x1FDA,0x1FDB,0x1FF8,0x1FF9,0x1FEA,0x1FEB,0x1FFA,0x1FFB,
        0x1F80,0x0608,
        0x1F90,0x0608,
        0x1FA0,0x0608,
        0x1FB0,0x0004,0x1FB8,0x1FB9,0x1FB2,0x1FBC,
        0x1FCC,0x0001,0x1FC3,
        0x1FD0,0x0602,
        0x1FE0,0x0602,
        0x1FE5,0x0001,0x1FEC,
        0x1FF3,0x0001,0x1FFC,
        /* Letterlike Symbols */
        0x214E,0x0001,0x2132,
        /* Number forms */
        0x2170,0x0210,
        0x2184,0x0001,0x2183,
        /* Enclosed Alphanumerics */
        0x24D0,0x051A,
        0x2C30,0x042F,
        /* Latin Extended-C */
        0x2C60,0x0102,
        0x2C67,0x0106, 0x2C75,0x0102,
        /* Coptic */
        0x2C80,0x0164,
        /* Georgian Supplement */
        0x2D00,0x0826,
        /* Full-width */
        0xFF41,0x031A,
 
        0x0000  /* EOT */
    };
 
 
    if (uni < 0x10000) {    /* Is it in BMP? */
        uc = (WORD)uni;
        p = uc < 0x1000 ? cvt1 : cvt2;
        for (;;) {
            bc = *p++;                              /* Get the block base */
            if (bc == 0 || uc < bc) break;          /* Not matched? */
            nc = *p++; cmd = nc >> 8; nc &= 0xFF;   /* Get processing command and block size */
            if (uc < bc + nc) { /* In the block? */
                switch (cmd) {
                case 0: uc = p[uc - bc]; break;     /* Table conversion */
                case 1: uc -= (uc - bc) & 1; break; /* Case pairs */
                case 2: uc -= 16; break;            /* Shift -16 */
                case 3: uc -= 32; break;            /* Shift -32 */
                case 4: uc -= 48; break;            /* Shift -48 */
                case 5: uc -= 26; break;            /* Shift -26 */
                case 6: uc += 8; break;             /* Shift +8 */
                case 7: uc -= 80; break;            /* Shift -80 */
                case 8: uc -= 0x1C60; break;        /* Shift -0x1C60 */
                }
                break;
            }
            if (cmd == 0) p += nc;  /* Skip table if needed */
        }
        uni = uc;
    }
 
    return uni;
}