/ FatFs - Generic FAT Filesystem Module R0.15a w/patch 1 /
/-----------------------------------------------------------------------------/
/
/ Copyright (C) 2024, ChaN, all right reserved.
/
/ FatFs module is an open source software. Redistribution and use of FatFs in
/ source and binary forms, with or without modification, are permitted provided
/ that the following condition is met:
/
/ 1. Redistributions of source code must retain the above copyright notice,
/ this condition and the following disclaimer.
/
/ This software is provided by the copyright holder and contributors "AS IS"
/ and any warranties related to this software are DISCLAIMED.
/ The copyright owner or contributors be NOT LIABLE for any damages caused
/ by use of this software.
/
/----------------------------------------------------------------------------*/
#include "ff.h"
#ifndef __LITEOS_M__
#include <user_copy.h>
#endif
#include "diskio.h"
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
#include "virpartff.h"
#endif
#ifndef __LITEOS_M__
#include "fatfs.h"
#endif
Module Private Definitions
---------------------------------------------------------------------------*/
#if FF_DEFINED != 5380
#error Wrong include file (ff.h).
#endif
#define IsUpper(c) ((c) >= 'A' && (c) <= 'Z')
#define IsLower(c) ((c) >= 'a' && (c) <= 'z')
#define IsDigit(c) ((c) >= '0' && (c) <= '9')
#define IsSeparator(c) ((c) == '/' || (c) == '\\')
#define IsTerminator(c) ((UINT)(c) < (FF_USE_LFN ? ' ' : '!'))
#define IsSurrogate(c) ((c) >= 0xD800 && (c) <= 0xDFFF)
#define IsSurrogateH(c) ((c) >= 0xD800 && (c) <= 0xDBFF)
#define IsSurrogateL(c) ((c) >= 0xDC00 && (c) <= 0xDFFF)
#define FA_SEEKEND 0x20
#define FA_MODIFIED 0x40
#define FA_DIRTY 0x80
#define AM_VOL 0x08
#define AM_LFN 0x0F
#define AM_MASK 0x3F
#define NSFLAG 11
#define NS_LOSS 0x01
#define NS_LFN 0x02
#define NS_LAST 0x04
#define NS_BODY 0x08
#define NS_EXT 0x10
#define NS_DOT 0x20
#define NS_NOLFN 0x40
#define NS_NONAME 0x80
/ because the C structure is not binary compatible between different platforms */
#define BS_JmpBoot 0
#define BS_OEMName 3
#define BPB_BytsPerSec 11
#define BPB_SecPerClus 13
#define BPB_RsvdSecCnt 14
#define BPB_NumFATs 16
#define BPB_RootEntCnt 17
#define BPB_TotSec16 19
#define BPB_Media 21
#define BPB_FATSz16 22
#define BPB_SecPerTrk 24
#define BPB_NumHeads 26
#define BPB_HiddSec 28
#define BPB_TotSec32 32
#define BS_DrvNum 36
#define BS_NTres 37
#define BS_BootSig 38
#define BS_VolID 39
#define BS_VolLab 43
#define BS_FilSysType 54
#define BS_BootCode 62
#define BS_55AA 510
#define BPB_FATSz32 36
#define BPB_ExtFlags32 40
#define BPB_FSVer32 42
#define BPB_RootClus32 44
#define BPB_FSInfo32 48
#define BPB_BkBootSec32 50
#define BS_DrvNum32 64
#define BS_NTres32 65
#define BS_BootSig32 66
#define BS_VolID32 67
#define BS_VolLab32 71
#define BS_FilSysType32 82
#define BS_BootCode32 90
#define SZDIRE 32
#define DDEM 0xE5
#define RDDEM 0x05
#define LLEF 0x40
#define FSI_LeadSig 0
#define FSI_StrucSig 484
#define FSI_Free_Count 488
#define FSI_Nxt_Free 492
#define MBR_Table 446
#define SZ_PTE 16
#define PTE_Boot 0
#define PTE_StHead 1
#define PTE_StSec 2
#define PTE_StCyl 3
#define PTE_System 4
#define PTE_EdHead 5
#define PTE_EdSec 6
#define PTE_EdCyl 7
#define PTE_StLba 8
#define PTE_SizLba 12
#define GPTH_Sign 0
#define GPTH_Rev 8
#define GPTH_Size 12
#define GPTH_Bcc 16
#define GPTH_CurLba 24
#define GPTH_BakLba 32
#define GPTH_FstLba 40
#define GPTH_LstLba 48
#define GPTH_DskGuid 56
#define GPTH_PtOfs 72
#define GPTH_PtNum 80
#define GPTH_PteSize 84
#define GPTH_PtBcc 88
#define SZ_GPTE 128
#define GPTE_PtGuid 0
#define GPTE_UpGuid 16
#define GPTE_FstLba 32
#define GPTE_LstLba 40
#define GPTE_Flags 48
#define GPTE_Name 56
#define ABORT(fs, res) { fp->err = (BYTE)(res); LEAVE_FF(fs, res); }
#if FF_FS_REENTRANT
#if FF_USE_LFN == 1
#error Static LFN work area cannot be used in thread-safe configuration
#endif
#ifdef __LITEOS_M__
#define LEAVE_FF(fs, res) { unlock_fs(fs, res); return res; }
#else
#define LEAVE_FF(fs, res) { (void)fs; return res; }
#endif
#else
#define LEAVE_FF(fs, res) return res
#endif
#if (FF_MAX_SS < FF_MIN_SS) || (FF_MAX_SS != 512 && FF_MAX_SS != 1024 && FF_MAX_SS != 2048 && FF_MAX_SS != 4096) || (FF_MIN_SS != 512 && FF_MIN_SS != 1024 && FF_MIN_SS != 2048 && FF_MIN_SS != 4096)
#error Wrong sector size configuration
#endif
#if FF_FS_LOCK
#if FF_FS_READONLY
#error FF_FS_LOCK must be 0 at read-only configuration
#endif
typedef struct {
FATFS* fs;
DWORD clu;
DWORD ofs;
UINT ctr;
} FILESEM;
#endif
#define TBL_CT437 {0x80,0x9A,0x45,0x41,0x8E,0x41,0x8F,0x80,0x45,0x45,0x45,0x49,0x49,0x49,0x8E,0x8F, \
0x90,0x92,0x92,0x4F,0x99,0x4F,0x55,0x55,0x59,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
0x41,0x49,0x4F,0x55,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \
0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \
0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, \
0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
#define TBL_CT720 {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F, \
0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
0xA0,0xA1,0xA2,0xA3,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \
0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \
0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, \
0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
#define TBL_CT737 {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F, \
0x90,0x92,0x92,0x93,0x94,0x95,0x96,0x97,0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87, \
0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F,0x90,0x91,0xAA,0x92,0x93,0x94,0x95,0x96, \
0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \
0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
0x97,0xEA,0xEB,0xEC,0xE4,0xED,0xEE,0xEF,0xF5,0xF0,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, \
0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
#define TBL_CT771 {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F, \
0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F, \
0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \
0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDC,0xDE,0xDE, \
0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
0xF0,0xF0,0xF2,0xF2,0xF4,0xF4,0xF6,0xF6,0xF8,0xF8,0xFA,0xFA,0xFC,0xFC,0xFE,0xFF}
#define TBL_CT775 {0x80,0x9A,0x91,0xA0,0x8E,0x95,0x8F,0x80,0xAD,0xED,0x8A,0x8A,0xA1,0x8D,0x8E,0x8F, \
0x90,0x92,0x92,0xE2,0x99,0x95,0x96,0x97,0x97,0x99,0x9A,0x9D,0x9C,0x9D,0x9E,0x9F, \
0xA0,0xA1,0xE0,0xA3,0xA3,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \
0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \
0xB5,0xB6,0xB7,0xB8,0xBD,0xBE,0xC6,0xC7,0xA5,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
0xE0,0xE1,0xE2,0xE3,0xE5,0xE5,0xE6,0xE3,0xE8,0xE8,0xEA,0xEA,0xEE,0xED,0xEE,0xEF, \
0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
#define TBL_CT850 {0x43,0x55,0x45,0x41,0x41,0x41,0x41,0x43,0x45,0x45,0x45,0x49,0x49,0x49,0x41,0x41, \
0x45,0x92,0x92,0x4F,0x4F,0x4F,0x55,0x55,0x59,0x4F,0x55,0x4F,0x9C,0x4F,0x9E,0x9F, \
0x41,0x49,0x4F,0x55,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \
0xB0,0xB1,0xB2,0xB3,0xB4,0x41,0x41,0x41,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0x41,0x41,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \
0xD1,0xD1,0x45,0x45,0x45,0x49,0x49,0x49,0x49,0xD9,0xDA,0xDB,0xDC,0xDD,0x49,0xDF, \
0x4F,0xE1,0x4F,0x4F,0x4F,0x4F,0xE6,0xE8,0xE8,0x55,0x55,0x55,0x59,0x59,0xEE,0xEF, \
0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
#define TBL_CT852 {0x80,0x9A,0x90,0xB6,0x8E,0xDE,0x8F,0x80,0x9D,0xD3,0x8A,0x8A,0xD7,0x8D,0x8E,0x8F, \
0x90,0x91,0x91,0xE2,0x99,0x95,0x95,0x97,0x97,0x99,0x9A,0x9B,0x9B,0x9D,0x9E,0xAC, \
0xB5,0xD6,0xE0,0xE9,0xA4,0xA4,0xA6,0xA6,0xA8,0xA8,0xAA,0x8D,0xAC,0xB8,0xAE,0xAF, \
0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBD,0xBF, \
0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC6,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \
0xD1,0xD1,0xD2,0xD3,0xD2,0xD5,0xD6,0xD7,0xB7,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
0xE0,0xE1,0xE2,0xE3,0xE3,0xD5,0xE6,0xE6,0xE8,0xE9,0xE8,0xEB,0xED,0xED,0xDD,0xEF, \
0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xEB,0xFC,0xFC,0xFE,0xFF}
#define TBL_CT855 {0x81,0x81,0x83,0x83,0x85,0x85,0x87,0x87,0x89,0x89,0x8B,0x8B,0x8D,0x8D,0x8F,0x8F, \
0x91,0x91,0x93,0x93,0x95,0x95,0x97,0x97,0x99,0x99,0x9B,0x9B,0x9D,0x9D,0x9F,0x9F, \
0xA1,0xA1,0xA3,0xA3,0xA5,0xA5,0xA7,0xA7,0xA9,0xA9,0xAB,0xAB,0xAD,0xAD,0xAE,0xAF, \
0xB0,0xB1,0xB2,0xB3,0xB4,0xB6,0xB6,0xB8,0xB8,0xB9,0xBA,0xBB,0xBC,0xBE,0xBE,0xBF, \
0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC7,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \
0xD1,0xD1,0xD3,0xD3,0xD5,0xD5,0xD7,0xD7,0xDD,0xD9,0xDA,0xDB,0xDC,0xDD,0xE0,0xDF, \
0xE0,0xE2,0xE2,0xE4,0xE4,0xE6,0xE6,0xE8,0xE8,0xEA,0xEA,0xEC,0xEC,0xEE,0xEE,0xEF, \
0xF0,0xF2,0xF2,0xF4,0xF4,0xF6,0xF6,0xF8,0xF8,0xFA,0xFA,0xFC,0xFC,0xFD,0xFE,0xFF}
#define TBL_CT857 {0x80,0x9A,0x90,0xB6,0x8E,0xB7,0x8F,0x80,0xD2,0xD3,0xD4,0xD8,0xD7,0x49,0x8E,0x8F, \
0x90,0x92,0x92,0xE2,0x99,0xE3,0xEA,0xEB,0x98,0x99,0x9A,0x9D,0x9C,0x9D,0x9E,0x9E, \
0xB5,0xD6,0xE0,0xE9,0xA5,0xA5,0xA6,0xA6,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \
0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC7,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \
0xD0,0xD1,0xD2,0xD3,0xD4,0x49,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
0xE0,0xE1,0xE2,0xE3,0xE5,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xDE,0xED,0xEE,0xEF, \
0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
#define TBL_CT860 {0x80,0x9A,0x90,0x8F,0x8E,0x91,0x86,0x80,0x89,0x89,0x92,0x8B,0x8C,0x98,0x8E,0x8F, \
0x90,0x91,0x92,0x8C,0x99,0xA9,0x96,0x9D,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
0x86,0x8B,0x9F,0x96,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \
0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \
0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, \
0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
#define TBL_CT861 {0x80,0x9A,0x90,0x41,0x8E,0x41,0x8F,0x80,0x45,0x45,0x45,0x8B,0x8B,0x8D,0x8E,0x8F, \
0x90,0x92,0x92,0x4F,0x99,0x8D,0x55,0x97,0x97,0x99,0x9A,0x9D,0x9C,0x9D,0x9E,0x9F, \
0xA4,0xA5,0xA6,0xA7,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \
0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \
0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, \
0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
#define TBL_CT862 {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F, \
0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
0x41,0x49,0x4F,0x55,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \
0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \
0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, \
0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
#define TBL_CT863 {0x43,0x55,0x45,0x41,0x41,0x41,0x86,0x43,0x45,0x45,0x45,0x49,0x49,0x8D,0x41,0x8F, \
0x45,0x45,0x45,0x4F,0x45,0x49,0x55,0x55,0x98,0x4F,0x55,0x9B,0x9C,0x55,0x55,0x9F, \
0xA0,0xA1,0x4F,0x55,0xA4,0xA5,0xA6,0xA7,0x49,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \
0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \
0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, \
0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
#define TBL_CT864 {0x80,0x9A,0x45,0x41,0x8E,0x41,0x8F,0x80,0x45,0x45,0x45,0x49,0x49,0x49,0x8E,0x8F, \
0x90,0x92,0x92,0x4F,0x99,0x4F,0x55,0x55,0x59,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
0x41,0x49,0x4F,0x55,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \
0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \
0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, \
0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
#define TBL_CT865 {0x80,0x9A,0x90,0x41,0x8E,0x41,0x8F,0x80,0x45,0x45,0x45,0x49,0x49,0x49,0x8E,0x8F, \
0x90,0x92,0x92,0x4F,0x99,0x4F,0x55,0x55,0x59,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
0x41,0x49,0x4F,0x55,0xA5,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \
0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \
0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
0xE0,0xE1,0xE2,0xE3,0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xEA,0xEB,0xEC,0xED,0xEE,0xEF, \
0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,0xF6,0xF7,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
#define TBL_CT866 {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F, \
0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F, \
0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \
0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xD6,0xD7,0xD8,0xD9,0xDA,0xDB,0xDC,0xDD,0xDE,0xDF, \
0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x9B,0x9C,0x9D,0x9E,0x9F, \
0xF0,0xF0,0xF2,0xF2,0xF4,0xF4,0xF6,0xF6,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF}
#define TBL_CT869 {0x80,0x81,0x82,0x83,0x84,0x85,0x86,0x87,0x88,0x89,0x8A,0x8B,0x8C,0x8D,0x8E,0x8F, \
0x90,0x91,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9A,0x86,0x9C,0x8D,0x8F,0x90, \
0x91,0x90,0x92,0x95,0xA4,0xA5,0xA6,0xA7,0xA8,0xA9,0xAA,0xAB,0xAC,0xAD,0xAE,0xAF, \
0xB0,0xB1,0xB2,0xB3,0xB4,0xB5,0xB6,0xB7,0xB8,0xB9,0xBA,0xBB,0xBC,0xBD,0xBE,0xBF, \
0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xCA,0xCB,0xCC,0xCD,0xCE,0xCF, \
0xD0,0xD1,0xD2,0xD3,0xD4,0xD5,0xA4,0xA5,0xA6,0xD9,0xDA,0xDB,0xDC,0xA7,0xA8,0xDF, \
0xA9,0xAA,0xAC,0xAD,0xB5,0xB6,0xB7,0xB8,0xBD,0xBE,0xC6,0xC7,0xCF,0xCF,0xD0,0xEF, \
0xF0,0xF1,0xD1,0xD2,0xD3,0xF5,0xD4,0xF7,0xF8,0xF9,0xD5,0x96,0x95,0x98,0xFE,0xFF}
#define TBL_DC932 {0x81, 0x9F, 0xE0, 0xFC, 0x40, 0x7E, 0x80, 0xFC, 0x00, 0x00}
#define TBL_DC936 {0x81, 0xFE, 0x00, 0x00, 0x40, 0x7E, 0x80, 0xFE, 0x00, 0x00}
#define TBL_DC949 {0x81, 0xFE, 0x00, 0x00, 0x41, 0x5A, 0x61, 0x7A, 0x81, 0xFE}
#define TBL_DC950 {0x81, 0xFE, 0x00, 0x00, 0x40, 0x7E, 0xA1, 0xFE, 0x00, 0x00}
#define MERGE_2STR(a, b) a ## b
#define MKCVTBL(hd, cp) MERGE_2STR(hd, cp)
Module Private Work Area
---------------------------------------------------------------------------*/
/ zero/null at start-up. If not, the linker option or start-up routine is
/ not compliance with C standard. */
#if FF_VOLUMES < 1
#error Wrong FF_VOLUMES setting
#endif
static FATFS* FatFs[FF_VOLUMES];
static WORD Fsid;
UINT time_status = SYSTEM_TIME_ENABLE;
#if FF_FS_RPATH != 0 && FF_VOLUMES >= 2
static BYTE CurrVol;
#endif
#if FF_FS_LOCK != 0
static FILESEM Files[FF_FS_LOCK];
#endif
#if FF_STR_VOLUME_ID
#ifdef FF_VOLUME_STRS
static const char* const VolumeStr[FF_VOLUMES] = {FF_VOLUME_STRS};
#endif
#endif
#if FF_CODE_PAGE == 0
#define CODEPAGE CodePage
static WORD CodePage;
static const BYTE* ExCvt;
static const BYTE* DbcTbl;
static const BYTE Ct437[] = TBL_CT437;
static const BYTE Ct720[] = TBL_CT720;
static const BYTE Ct737[] = TBL_CT737;
static const BYTE Ct771[] = TBL_CT771;
static const BYTE Ct775[] = TBL_CT775;
static const BYTE Ct850[] = TBL_CT850;
static const BYTE Ct852[] = TBL_CT852;
static const BYTE Ct855[] = TBL_CT855;
static const BYTE Ct857[] = TBL_CT857;
static const BYTE Ct860[] = TBL_CT860;
static const BYTE Ct861[] = TBL_CT861;
static const BYTE Ct862[] = TBL_CT862;
static const BYTE Ct863[] = TBL_CT863;
static const BYTE Ct864[] = TBL_CT864;
static const BYTE Ct865[] = TBL_CT865;
static const BYTE Ct866[] = TBL_CT866;
static const BYTE Ct869[] = TBL_CT869;
static const BYTE Dc932[] = TBL_DC932;
static const BYTE Dc936[] = TBL_DC936;
static const BYTE Dc949[] = TBL_DC949;
static const BYTE Dc950[] = TBL_DC950;
#elif FF_CODE_PAGE < 900
#define CODEPAGE FF_CODE_PAGE
static const BYTE ExCvt[] = MKCVTBL(TBL_CT, FF_CODE_PAGE);
#else
#define CODEPAGE FF_CODE_PAGE
static const BYTE DbcTbl[] = MKCVTBL(TBL_DC, FF_CODE_PAGE);
#endif
Module Private Functions
---------------------------------------------------------------------------*/
WORD ld_word (const BYTE* ptr)
{
WORD rv;
rv = ptr[1];
rv = rv << 8 | ptr[0];
return rv;
}
DWORD ld_dword (const BYTE* ptr)
{
DWORD rv;
rv = ptr[3];
rv = rv << 8 | ptr[2];
rv = rv << 8 | ptr[1];
rv = rv << 8 | ptr[0];
return rv;
}
#if !FF_FS_READONLY
void st_word (BYTE* ptr, WORD val)
{
*ptr++ = (BYTE)val; val >>= 8;
*ptr++ = (BYTE)val;
}
void st_dword (BYTE* ptr, DWORD val)
{
*ptr++ = (BYTE)val; val >>= 8;
*ptr++ = (BYTE)val; val >>= 8;
*ptr++ = (BYTE)val; val >>= 8;
*ptr++ = (BYTE)val;
}
#endif
void mem_cpy (void* dst, const void* src, UINT cnt)
{
BYTE *d = (BYTE*)dst;
const BYTE *s = (const BYTE*)src;
if (cnt != 0) {
do {
*d++ = *s++;
} while (--cnt);
}
}
void mem_set (void* dst, int val, UINT cnt)
{
BYTE *d = (BYTE*)dst;
do {
*d++ = (BYTE)val;
} while (--cnt);
}
static int mem_cmp (const void* dst, const void* src, UINT cnt)
{
const BYTE *d = (const BYTE *)dst, *s = (const BYTE *)src;
int r = 0;
do {
r = *d++ - *s++;
} while (--cnt && r == 0);
return r;
}
static int chk_chr (const char* str, int chr)
{
while (*str && *str != chr) str++;
return *str;
}
static int dbc_1st (BYTE c)
{
#if FF_CODE_PAGE == 0
if (DbcTbl && c >= DbcTbl[0]) {
if (c <= DbcTbl[1]) return 1;
if (c >= DbcTbl[2] && c <= DbcTbl[3]) return 1;
}
#elif FF_CODE_PAGE >= 900
if (c >= DbcTbl[0]) {
if (c <= DbcTbl[1]) return 1;
if (c >= DbcTbl[2] && c <= DbcTbl[3]) return 1;
}
#else
if (c != 0) return 0;
#endif
return 0;
}
static int dbc_2nd (BYTE c)
{
#if FF_CODE_PAGE == 0
if (DbcTbl && c >= DbcTbl[4]) {
if (c <= DbcTbl[5]) return 1;
if (c >= DbcTbl[6] && c <= DbcTbl[7]) return 1;
if (c >= DbcTbl[8] && c <= DbcTbl[9]) return 1;
}
#elif FF_CODE_PAGE >= 900
if (c >= DbcTbl[4]) {
if (c <= DbcTbl[5]) return 1;
if (c >= DbcTbl[6] && c <= DbcTbl[7]) return 1;
if (c >= DbcTbl[8] && c <= DbcTbl[9]) return 1;
}
#else
if (c != 0) return 0;
#endif
return 0;
}
#if FF_USE_LFN
static DWORD tchar2uni (
const TCHAR** str
)
{
DWORD uc;
const TCHAR *p = *str;
#if FF_LFN_UNICODE == 1
WCHAR wc;
uc = *p++;
if (IsSurrogate(uc)) {
wc = *p++;
if (!IsSurrogateH(uc) || !IsSurrogateL(wc)) return 0xFFFFFFFF;
uc = uc << 16 | wc;
}
#elif FF_LFN_UNICODE == 2
BYTE b;
int nf;
uc = (BYTE)*p++;
if (uc & 0x80) {
if ((uc & 0xE0) == 0xC0) {
uc &= 0x1F; nf = 1;
} else if ((uc & 0xF0) == 0xE0) {
uc &= 0x0F; nf = 2;
} else if ((uc & 0xF8) == 0xF0) {
uc &= 0x07; nf = 3;
} else {
return 0xFFFFFFFF;
}
do {
b = (BYTE)*p++;
if ((b & 0xC0) != 0x80) return 0xFFFFFFFF;
uc = uc << 6 | (b & 0x3F);
} while (--nf != 0);
if (uc < 0x80 || IsSurrogate(uc) || uc >= 0x110000) return 0xFFFFFFFF;
if (uc >= 0x010000) uc = 0xD800DC00 | ((uc - 0x10000) << 6 & 0x3FF0000) | (uc & 0x3FF);
}
#elif FF_LFN_UNICODE == 3
uc = (TCHAR)*p++;
if (uc >= 0x110000 || IsSurrogate(uc)) return 0xFFFFFFFF;
if (uc >= 0x010000) uc = 0xD800DC00 | ((uc - 0x10000) << 6 & 0x3FF0000) | (uc & 0x3FF);
#else
BYTE b;
WCHAR wc;
wc = (BYTE)*p++;
if (dbc_1st((BYTE)wc)) {
b = (BYTE)*p++;
if (!dbc_2nd(b)) return 0xFFFFFFFF;
wc = (wc << 8) + b;
}
if (wc != 0) {
wc = ff_oem2uni(wc, CODEPAGE);
if (wc == 0) return 0xFFFFFFFF;
}
uc = wc;
#endif
*str = p;
return uc;
}
static UINT put_utf (
DWORD chr,
TCHAR* buf,
UINT szb
)
{
#if FF_LFN_UNICODE == 1
WCHAR hs, wc;
hs = (WCHAR)(chr >> 16);
wc = (WCHAR)chr;
if (hs == 0) {
if (szb < 1 || IsSurrogate(wc)) return 0;
*buf = wc;
return 1;
}
if (szb < 2 || !IsSurrogateH(hs) || !IsSurrogateL(wc)) return 0;
*buf++ = hs;
*buf++ = wc;
return 2;
#elif FF_LFN_UNICODE == 2
DWORD hc;
if (chr < 0x80) {
if (szb < 1) return 0;
*buf = (TCHAR)chr;
return 1;
}
if (chr < 0x800) {
if (szb < 2) return 0;
*buf++ = (TCHAR)(0xC0 | (chr >> 6 & 0x1F));
*buf++ = (TCHAR)(0x80 | (chr >> 0 & 0x3F));
return 2;
}
if (chr < 0x10000) {
if (szb < 3 || IsSurrogate(chr)) return 0;
*buf++ = (TCHAR)(0xE0 | (chr >> 12 & 0x0F));
*buf++ = (TCHAR)(0x80 | (chr >> 6 & 0x3F));
*buf++ = (TCHAR)(0x80 | (chr >> 0 & 0x3F));
return 3;
}
if (szb < 4) return 0;
hc = ((chr & 0xFFFF0000) - 0xD8000000) >> 6;
chr = (chr & 0xFFFF) - 0xDC00;
if (hc >= 0x100000 || chr >= 0x400) return 0;
chr = (hc | chr) + 0x10000;
*buf++ = (TCHAR)(0xF0 | (chr >> 18 & 0x07));
*buf++ = (TCHAR)(0x80 | (chr >> 12 & 0x3F));
*buf++ = (TCHAR)(0x80 | (chr >> 6 & 0x3F));
*buf++ = (TCHAR)(0x80 | (chr >> 0 & 0x3F));
return 4;
#elif FF_LFN_UNICODE == 3
DWORD hc;
if (szb < 1) return 0;
if (chr >= 0x10000) {
hc = ((chr & 0xFFFF0000) - 0xD8000000) >> 6;
chr = (chr & 0xFFFF) - 0xDC00;
if (hc >= 0x100000 || chr >= 0x400) return 0;
chr = (hc | chr) + 0x10000;
}
*buf++ = (TCHAR)chr;
return 1;
#else
WCHAR wc;
wc = ff_uni2oem(chr, CODEPAGE);
if (wc >= 0x100) {
if (szb < 2) return 0;
*buf++ = (char)(wc >> 8);
*buf++ = (TCHAR)wc;
return 2;
}
if (wc == 0 || szb < 1) return 0;
*buf++ = (TCHAR)wc;
return 1;
#endif
}
#endif
#if FF_FS_REENTRANT
int lock_fs (
FATFS* fs
)
{
return (fs && ff_req_grant(&fs->sobj)) ? 1 : 0;
}
void unlock_fs (
FATFS* fs,
FRESULT res
)
{
if (fs && res != FR_NOT_ENABLED && res != FR_INVALID_DRIVE && res != FR_TIMEOUT) {
ff_rel_grant(&fs->sobj);
}
}
#endif
#if FF_FS_LOCK
static FRESULT chk_share (
DIR* dp,
int acc
)
{
UINT i, be;
be = 0;
for (i = 0; i < FF_FS_LOCK; i++) {
if (Files[i].fs) {
if (Files[i].fs == dp->obj.fs &&
Files[i].clu == dp->obj.sclust &&
Files[i].ofs == dp->dptr) break;
} else {
be = 1;
}
}
if (i == FF_FS_LOCK) {
return (!be && acc != 2) ? FR_TOO_MANY_OPEN_FILES : FR_OK;
}
return (acc != 0 || Files[i].ctr == 0x100) ? FR_LOCKED : FR_OK;
}
static int enq_share (void)
{
UINT i;
for (i = 0; i < FF_FS_LOCK && Files[i].fs; i++) ;
return (i == FF_FS_LOCK) ? 0 : 1;
}
static UINT inc_share (
DIR* dp,
int acc
)
{
UINT i;
for (i = 0; i < FF_FS_LOCK; i++) {
if (Files[i].fs == dp->obj.fs
&& Files[i].clu == dp->obj.sclust
&& Files[i].ofs == dp->dptr) break;
}
if (i == FF_FS_LOCK) {
for (i = 0; i < FF_FS_LOCK && Files[i].fs; i++) ;
if (i == FF_FS_LOCK) return 0;
Files[i].fs = dp->obj.fs;
Files[i].clu = dp->obj.sclust;
Files[i].ofs = dp->dptr;
Files[i].ctr = 0;
}
if (acc >= 1 && Files[i].ctr) return 0;
Files[i].ctr = acc ? 0x100 : Files[i].ctr + 1;
return i + 1;
}
static FRESULT dec_share (
UINT i
)
{
UINT n;
FRESULT res;
if (--i < FF_FS_LOCK) {
n = Files[i].ctr;
if (n == 0x100) n = 0;
if (n > 0) n--;
Files[i].ctr = n;
if (n == 0) {
Files[i].fs = 0;
}
res = FR_OK;
} else {
res = FR_INT_ERR;
}
return res;
}
static void clear_share (
FATFS* fs
)
{
UINT i;
for (i = 0; i < FF_FS_LOCK; i++) {
if (Files[i].fs == fs) Files[i].fs = 0;
}
}
static
FRESULT empty_lock(FATFS* fs)
{
UINT i;
for (i = 0; i < FF_FS_LOCK; i++) {
if (Files[i].fs == fs) return FR_LOCKED;
}
return FR_OK;
}
#endif
FRESULT f_checkopenlock(int index)
{
#if FF_FS_LOCK != 0
if (FatFs[index])
return empty_lock(FatFs[index]);
#endif
return FR_OK;
}
#if !FF_FS_READONLY
FRESULT sync_window (
FATFS* fs
)
{
FRESULT res = FR_OK;
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
if (ISCHILD(fs)) fs = PARENTFS(fs);
#endif
if (fs->wflag) {
if (disk_write(fs->pdrv, fs->win, fs->winsect, 1) == RES_OK) {
fs->wflag = 0;
if (fs->winsect - fs->fatbase < fs->fsize) {
if (fs->n_fats == 2) disk_write(fs->pdrv, fs->win, fs->winsect + fs->fsize, 1);
}
} else {
res = FR_DISK_ERR;
}
}
return res;
}
#endif
FRESULT move_window (
FATFS* fs,
LBA_t sect
)
{
FRESULT res = FR_OK;
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
if (ISCHILD(fs)) fs = PARENTFS(fs);
#endif
if (sect != fs->winsect) {
#if !FF_FS_READONLY
res = sync_window(fs);
#endif
if (res == FR_OK) {
if (disk_read(fs->pdrv, fs->win, sect, 1) != RES_OK) {
sect = (LBA_t)0 - 1;
res = FR_DISK_ERR;
}
fs->winsect = sect;
}
}
return res;
}
#ifndef __LITEOS_M__
FRESULT move_window_readdir (
FATFS* fs,
LBA_t sect
)
{
FRESULT res = FR_OK;
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
if (ISCHILD(fs)) fs = PARENTFS(fs);
#endif
if (sect != fs->winsect) {
#if !FF_FS_READONLY
res = sync_window(fs);
#endif
if (res == FR_OK) {
if (disk_read_readdir(fs->pdrv, fs->win, sect, 1) != RES_OK) {
sect = 0xFFFFFFFF;
res = FR_DISK_ERR;
}
fs->winsect = sect;
}
}
return res;
}
#endif
#if !FF_FS_READONLY
FRESULT sync_fs (
FATFS* fs
)
{
FRESULT res;
res = sync_window(fs);
if (res == FR_OK) {
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
if (ISCHILD(fs)) fs = PARENTFS(fs);
#endif
if (fs->fs_type == FS_FAT32 && fs->fsi_flag == 1) {
mem_set(fs->win, 0, SS(fs));
st_word(fs->win + BS_55AA, 0xAA55);
st_dword(fs->win + FSI_LeadSig, 0x41615252);
st_dword(fs->win + FSI_StrucSig, 0x61417272);
st_dword(fs->win + FSI_Free_Count, fs->free_clst);
st_dword(fs->win + FSI_Nxt_Free, fs->last_clst);
fs->winsect = fs->volbase + 1;
disk_write(fs->pdrv, fs->win, fs->winsect, 1);
fs->fsi_flag = 0;
}
if (disk_ioctl(fs->pdrv, CTRL_SYNC, 0) != RES_OK) res = FR_DISK_ERR;
}
return res;
}
#endif
LBA_t clst2sect (
FATFS* fs,
DWORD clst
)
{
clst -= 2;
if (clst >= fs->n_fatent - 2) return 0;
return fs->database + (LBA_t)fs->csize * clst;
}
DWORD get_fat (
FFOBJID* obj,
DWORD clst
)
{
UINT wc, bc;
DWORD val;
FATFS *fs = obj->fs;
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
if (ISCHILD(fs)) fs = PARENTFS(fs);
#endif
if (clst < 2 || clst >= fs->n_fatent) {
val = 1;
} else {
val = 0xFFFFFFFF;
switch (fs->fs_type) {
case FS_FAT12 :
bc = (UINT)clst; bc += bc / 2;
if (move_window(fs, fs->fatbase + (bc / SS(fs))) != FR_OK) break;
wc = fs->win[bc++ % SS(fs)];
if (move_window(fs, fs->fatbase + (bc / SS(fs))) != FR_OK) break;
wc |= fs->win[bc % SS(fs)] << 8;
val = (clst & 1) ? (wc >> 4) : (wc & 0xFFF);
break;
case FS_FAT16 :
if (move_window(fs, fs->fatbase + (clst / (SS(fs) / 2))) != FR_OK) break;
val = ld_word(fs->win + clst * 2 % SS(fs));
break;
case FS_FAT32 :
if (move_window(fs, fs->fatbase + (clst / (SS(fs) / 4))) != FR_OK) break;
val = ld_dword(fs->win + clst * 4 % SS(fs)) & 0x0FFFFFFF;
break;
default:
val = 1;
}
}
return val;
}
#if !FF_FS_READONLY
FRESULT put_fat (
FATFS* fs,
DWORD clst,
DWORD val
)
{
UINT bc;
BYTE *p;
FRESULT res = FR_INT_ERR;
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
if (ISCHILD(fs)) fs = PARENTFS(fs);
#endif
if (clst >= 2 && clst < fs->n_fatent) {
switch (fs->fs_type) {
case FS_FAT12:
bc = (UINT)clst; bc += bc / 2;
res = move_window(fs, fs->fatbase + (bc / SS(fs)));
if (res != FR_OK) break;
p = fs->win + bc++ % SS(fs);
*p = (clst & 1) ? ((*p & 0x0F) | ((BYTE)val << 4)) : (BYTE)val;
fs->wflag = 1;
res = move_window(fs, fs->fatbase + (bc / SS(fs)));
if (res != FR_OK) break;
p = fs->win + bc % SS(fs);
*p = (clst & 1) ? (BYTE)(val >> 4) : ((*p & 0xF0) | ((BYTE)(val >> 8) & 0x0F));
fs->wflag = 1;
break;
case FS_FAT16:
res = move_window(fs, fs->fatbase + (clst / (SS(fs) / 2)));
if (res != FR_OK) break;
st_word(fs->win + clst * 2 % SS(fs), (WORD)val);
fs->wflag = 1;
break;
case FS_FAT32:
res = move_window(fs, fs->fatbase + (clst / (SS(fs) / 4)));
if (res != FR_OK) break;
val = (val & 0x0FFFFFFF) | (ld_dword(fs->win + clst * 4 % SS(fs)) & 0xF0000000);
st_dword(fs->win + clst * 4 % SS(fs), val);
fs->wflag = 1;
break;
}
}
return res;
}
#endif
#if !FF_FS_READONLY
FRESULT remove_chain (
FFOBJID* obj,
DWORD clst,
DWORD pclst
)
{
FRESULT res = FR_OK;
DWORD nxt;
FATFS *fs = obj->fs;
#if FF_USE_TRIM
DWORD scl = clst, ecl = clst;
LBA_t rt[2];
#endif
if (clst < 2 || clst >= fs->n_fatent) return FR_INT_ERR;
if (pclst) {
res = put_fat(fs, pclst, 0xFFFFFFFF);
if (res != FR_OK) return res;
}
do {
nxt = get_fat(obj, clst);
if (nxt == 0) break;
if (nxt == 1) return FR_INT_ERR;
if (nxt == 0xFFFFFFFF) return FR_DISK_ERR;
res = put_fat(fs, clst, 0);
if (res != FR_OK) return res;
#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
if (fs->free_clst < fs->n_fatent - 2) {
fs->free_clst++;
fs->fsi_flag |= 1;
}
#else
if (fs->free_clst < fs->ct_clst && ISCHILD(fs) && ISVIRPART(fs))
fs->free_clst++;
if (PARENTFS(fs)->free_clst < PARENTFS(fs)->n_fatent - 2) {
PARENTFS(fs)->free_clst++;
PARENTFS(fs)->fsi_flag |= 1;
}
#endif
#if FF_USE_TRIM
if (ecl + 1 == nxt) {
ecl = nxt;
} else {
rt[0] = clst2sect(fs, scl);
rt[1] = clst2sect(fs, ecl) + fs->csize - 1;
disk_ioctl(fs->pdrv, CTRL_TRIM, rt);
scl = ecl = nxt;
}
#endif
clst = nxt;
} while (clst < fs->n_fatent);
return FR_OK;
}
DWORD create_chain (
FFOBJID* obj,
DWORD clst
)
{
DWORD cs, ncl, scl;
FRESULT res;
FATFS *fs = obj->fs;
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
if (ISVIRPART(fs) && (fs->st_clst == 0xFFFFFFFF || fs->ct_clst == 0xFFFFFFFF)) {
return 0;
}
#endif
if (clst == 0) {
scl = fs->last_clst;
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
if (ISVIRPART(fs)) {
if (scl == 0 || scl >= fs->n_fatent)
scl = fs->st_clst - 1 ;
if (scl == 0 || scl < fs->st_clst || scl >= fs->st_clst + fs->ct_clst)
scl = fs->st_clst - 1;
} else
#endif
{
if (scl == 0 || scl >= fs->n_fatent) scl = 1;
}
} else {
cs = get_fat(obj, clst);
if (cs < 2) return 1;
if (cs == 0xFFFFFFFF) return cs;
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
if (ISVIRPART(fs)) {
if (cs < fs->st_clst + fs->ct_clst && cs >= fs->st_clst)
return cs;
if ((cs >= fs->st_clst + fs->ct_clst && cs < fs->n_fatent) || cs < fs->st_clst)
return 1;
} else
#endif
{
if (cs < fs->n_fatent) return cs;
}
scl = clst;
}
if (fs->free_clst == 0) return 0;
ncl = 0;
if (scl == clst) {
ncl = scl + 1;
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
if (ISVIRPART(fs)) {
if (ncl >= fs->st_clst + fs->ct_clst || ncl < fs->st_clst)
ncl = fs->st_clst;
} else
#endif
{
if (ncl >= fs->n_fatent) ncl = 2;
}
cs = get_fat(obj, ncl);
if (cs == 1 || cs == 0xFFFFFFFF) return cs;
if (cs != 0) {
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
if (ISVIRPART(fs)) {
cs = PARENTFS(fs)->last_clst;
if (cs >= fs->st_clst && cs < fs->st_clst + fs->ct_clst) scl = cs;
} else
#endif
{
cs = fs->last_clst;
if (cs >= 2 && cs < fs->n_fatent) scl = cs;
}
ncl = 0;
}
}
if (ncl == 0) {
ncl = scl;
for (;;) {
ncl++;
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
if (ISVIRPART(fs)) {
if (ncl >= fs->st_clst + fs->ct_clst || ncl < fs->st_clst) {
ncl = fs->st_clst;
if (ncl > scl) return 0;
}
} else
#endif
{
if (ncl >= fs->n_fatent) {
ncl = 2;
if (ncl > scl) return 0;
}
}
cs = get_fat(obj, ncl);
if (cs == 0) break;
if (cs == 1 || cs == 0xFFFFFFFF) return cs;
if (ncl == scl) return 0;
}
}
res = put_fat(fs, ncl, 0xFFFFFFFF);
if (res == FR_OK && clst != 0) {
res = put_fat(fs, clst, ncl);
}
if (res == FR_OK) {
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
if (ISVIRPART(fs)) {
fs->last_clst = ncl;
PARENTFS(fs)->last_clst = ncl;
if (fs->free_clst <= fs->ct_clst && ISCHILD(fs))
fs->free_clst--;
if (PARENTFS(fs)->free_clst <= PARENTFS(fs)->n_fatent - 2)
(PARENTFS(fs))->free_clst--;
PARENTFS(fs)->fsi_flag |= 1;
} else
#endif
{
fs->last_clst = ncl;
if (fs->free_clst <= fs->n_fatent - 2) fs->free_clst--;
fs->fsi_flag |= 1;
}
} else {
ncl = (res == FR_DISK_ERR) ? 0xFFFFFFFF : 1;
}
return ncl;
}
#endif
#if FF_USE_FASTSEEK
static DWORD clmt_clust (
FIL* fp,
FSIZE_t ofs
)
{
DWORD cl, ncl;
DWORD *tbl;
FATFS *fs = fp->obj.fs;
tbl = fp->cltbl + 1;
cl = (DWORD)(ofs / SS(fs) / fs->csize);
for (;;) {
ncl = *tbl++;
if (ncl == 0) return 0;
if (cl < ncl) break;
cl -= ncl; tbl++;
}
return cl + *tbl;
}
#endif
#if !FF_FS_READONLY
static FRESULT dir_clear (
FATFS *fs,
DWORD clst
)
{
LBA_t sect;
UINT n, szb;
BYTE *ibuf;
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
if (ISCHILD(fs)) fs = PARENTFS(fs);
#endif
if (sync_window(fs) != FR_OK) return FR_DISK_ERR;
sect = clst2sect(fs, clst);
fs->winsect = sect;
mem_set(fs->win, 0, SS(fs));
#if FF_USE_LFN == 3
for (szb = ((DWORD)fs->csize * SS(fs) >= MAX_MALLOC) ? MAX_MALLOC : fs->csize * SS(fs), ibuf = 0; szb > SS(fs) && (ibuf = ff_memalloc(szb)) == 0; szb /= 2) ;
if (szb > SS(fs)) {
mem_set(ibuf, 0, szb);
szb /= SS(fs);
for (n = 0; n < fs->csize && disk_write(fs->pdrv, ibuf, sect + n, szb) == RES_OK; n += szb) ;
ff_memfree(ibuf);
} else
#endif
{
ibuf = fs->win; szb = 1;
for (n = 0; n < fs->csize && disk_write(fs->pdrv, ibuf, sect + n, szb) == RES_OK; n += szb) ;
}
return (n == fs->csize) ? FR_OK : FR_DISK_ERR;
}
#endif
FRESULT dir_sdi (
DIR* dp,
DWORD ofs
)
{
DWORD csz, clst;
FATFS *fs = dp->obj.fs;
if (ofs >= (DWORD)MAX_DIR || ofs % SZDIRE) {
return FR_INT_ERR;
}
dp->dptr = ofs;
clst = dp->obj.sclust;
if (clst == 0 && fs->fs_type >= FS_FAT32) {
clst = (DWORD)fs->dirbase;
}
if (clst == 0) {
if (ofs / SZDIRE >= fs->n_rootdir) return FR_INT_ERR;
dp->sect = fs->dirbase;
} else {
csz = (DWORD)fs->csize * SS(fs);
while (ofs >= csz) {
clst = get_fat(&dp->obj, clst);
if (clst == 0xFFFFFFFF) return FR_DISK_ERR;
if (clst < 2 || clst >= fs->n_fatent) return FR_INT_ERR;
ofs -= csz;
}
dp->sect = clst2sect(fs, clst);
}
dp->clust = clst;
if (dp->sect == 0) return FR_INT_ERR;
dp->sect += ofs / SS(fs);
#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
dp->dir = fs->win + (ofs % SS(fs));
#else
dp->dir = PARENTFS(fs)->win + (ofs % SS(PARENTFS(fs)));
#endif
return FR_OK;
}
FRESULT dir_next (
DIR* dp,
int stretch
)
{
DWORD ofs, clst;
FATFS *fs = dp->obj.fs;
ofs = dp->dptr + SZDIRE;
if (ofs >= (DWORD)MAX_DIR) dp->sect = 0;
if (dp->sect == 0) return FR_NO_FILE;
if (ofs % SS(fs) == 0) {
dp->sect++;
if (dp->clust == 0) {
if (ofs / SZDIRE >= fs->n_rootdir) {
dp->sect = 0; return FR_NO_FILE;
}
}
else {
if ((ofs / SS(fs) & (fs->csize - 1)) == 0) {
clst = get_fat(&dp->obj, dp->clust);
if (clst <= 1) return FR_INT_ERR;
if (clst == 0xFFFFFFFF) return FR_DISK_ERR;
if (clst >= fs->n_fatent) {
#if !FF_FS_READONLY
if (!stretch) {
dp->sect = 0; return FR_NO_FILE;
}
clst = create_chain(&dp->obj, dp->clust);
if (clst == 0) return FR_NO_SPACE_LEFT;
if (clst == 1) return FR_INT_ERR;
if (clst == 0xFFFFFFFF) return FR_DISK_ERR;
if (dir_clear(fs, clst) != FR_OK) return FR_DISK_ERR;
#else
if (!stretch) dp->sect = 0;
dp->sect = 0; return FR_NO_FILE;
#endif
}
dp->clust = clst;
dp->sect = clst2sect(fs, clst);
}
}
}
dp->dptr = ofs;
#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
dp->dir = fs->win + ofs % SS(fs);
#else
dp->dir = PARENTFS(fs)->win + (ofs % SS(PARENTFS(fs)));
#endif
return FR_OK;
}
#if !FF_FS_READONLY
static FRESULT dir_alloc (
DIR* dp,
UINT n_ent
)
{
FRESULT res;
UINT n;
FATFS *fs = dp->obj.fs;
res = dir_sdi(dp, 0);
if (res == FR_OK) {
n = 0;
do {
res = move_window(fs, dp->sect);
if (res != FR_OK) break;
if (dp->dir[DIR_Name] == DDEM || dp->dir[DIR_Name] == 0) {
if (++n == n_ent) break;
} else {
n = 0;
}
res = dir_next(dp, 1);
} while (res == FR_OK);
}
if (res == FR_NO_FILE) res = FR_DENIED;
return res;
}
#endif
DWORD ld_clust (
FATFS* fs,
const BYTE* dir
)
{
DWORD cl;
cl = ld_word(dir + DIR_FstClusLO);
if (fs->fs_type == FS_FAT32) {
cl |= (DWORD)ld_word(dir + DIR_FstClusHI) << 16;
}
return cl;
}
#if !FF_FS_READONLY
void st_clust (
FATFS* fs,
BYTE* dir,
DWORD cl
)
{
st_word(dir + DIR_FstClusLO, (WORD)cl);
if (fs->fs_type == FS_FAT32) {
st_word(dir + DIR_FstClusHI, (WORD)(cl >> 16));
}
}
#endif
#if FF_USE_LFN
static int cmp_lfn (
const WCHAR* lfnbuf,
BYTE* dir
)
{
UINT i, s;
WCHAR wc, uc;
if (ld_word(dir + LDIR_FstClusLO) != 0) return 0;
i = ((dir[LDIR_Ord] & 0x3F) - 1) * 13;
for (wc = 1, s = 0; s < 13; s++) {
uc = ld_word(dir + LfnOfs[s]);
if (wc != 0) {
if (i >= FF_MAX_LFN + 1 || ff_wtoupper(uc) != ff_wtoupper(lfnbuf[i++])) {
return 0;
}
wc = uc;
} else {
if (uc != 0xFFFF) return 0;
}
}
if ((dir[LDIR_Ord] & LLEF) && wc && lfnbuf[i]) return 0;
return 1;
}
#if FF_FS_MINIMIZE <= 1 || FF_FS_RPATH >= 2 || FF_USE_LABEL
static int pick_lfn (
WCHAR* lfnbuf,
BYTE* dir
)
{
UINT i, s;
WCHAR wc, uc;
if (ld_word(dir + LDIR_FstClusLO) != 0) return 0;
i = ((dir[LDIR_Ord] & ~LLEF) - 1) * 13;
for (wc = 1, s = 0; s < 13; s++) {
uc = ld_word(dir + LfnOfs[s]);
if (wc != 0) {
if (i >= FF_MAX_LFN + 1) return 0;
lfnbuf[i++] = wc = uc;
} else {
if (uc != 0xFFFF) return 0;
}
}
if (dir[LDIR_Ord] & LLEF && wc != 0) {
if (i >= FF_MAX_LFN + 1) return 0;
lfnbuf[i] = 0;
}
return 1;
}
#endif
#if !FF_FS_READONLY
static void put_lfn (
const WCHAR* lfn,
BYTE* dir,
BYTE ord,
BYTE sum
)
{
UINT i, s;
WCHAR wc;
dir[LDIR_Chksum] = sum;
dir[LDIR_Attr] = AM_LFN;
dir[LDIR_Type] = 0;
st_word(dir + LDIR_FstClusLO, 0);
i = (ord - 1) * 13;
s = wc = 0;
do {
if (wc != 0xFFFF) wc = lfn[i++];
st_word(dir + LfnOfs[s], wc);
if (wc == 0) wc = 0xFFFF;
} while (++s < 13);
if (wc == 0xFFFF || !lfn[i]) ord |= LLEF;
dir[LDIR_Ord] = ord;
}
#endif
#endif
#if FF_USE_LFN && !FF_FS_READONLY
static void gen_numname (
BYTE* dst,
const BYTE* src,
const WCHAR* lfn,
UINT seq
)
{
BYTE ns[8], c;
UINT i, j;
WCHAR wc;
DWORD sreg;
mem_cpy(dst, src, 11);
if (seq > 5) {
sreg = seq;
while (*lfn) {
wc = *lfn++;
for (i = 0; i < 16; i++) {
sreg = (sreg << 1) + (wc & 1);
wc >>= 1;
if (sreg & 0x10000) sreg ^= 0x11021;
}
}
seq = (UINT)sreg;
}
i = 7;
do {
c = (BYTE)((seq % 16) + '0'); seq /= 16;
if (c > '9') c += 7;
ns[i--] = c;
} while (i && seq);
ns[i] = '~';
for (j = 0; j < i && dst[j] != ' '; j++) {
if (dbc_1st(dst[j])) {
if (j == i - 1) break;
j++;
}
}
do {
dst[j++] = (i < 8) ? ns[i++] : ' ';
} while (j < 8);
}
#endif
#if FF_USE_LFN
static BYTE sum_sfn (
const BYTE* dir
)
{
BYTE sum = 0;
UINT n = 11;
do {
sum = (sum >> 1) + (sum << 7) + *dir++;
} while (--n);
return sum;
}
#endif
#if FF_FS_MINIMIZE <= 1 || FF_FS_RPATH >= 2 || FF_USE_LABEL
#define DIR_READ_FILE(dp) dir_read(dp, 0)
#define DIR_READ_LABEL(dp) dir_read(dp, 1)
FRESULT dir_read (
DIR* dp,
int vol
)
{
FRESULT res = FR_NO_FILE;
FATFS *fs = dp->obj.fs;
BYTE attr, b;
#if FF_USE_LFN
BYTE ord = 0xFF, sum = 0xFF;
#endif
while (dp->sect) {
res = move_window(fs, dp->sect);
if (res != FR_OK) break;
b = dp->dir[DIR_Name];
if (b == 0) {
res = FR_NO_FILE; break;
}
dp->obj.attr = attr = dp->dir[DIR_Attr] & AM_MASK;
#if FF_USE_LFN
if (b == DDEM || b == '.' || (int)((attr & ~AM_ARC) == AM_VOL) != vol) {
ord = 0xFF;
} else {
if (attr == AM_LFN) {
if (b & LLEF) {
sum = dp->dir[LDIR_Chksum];
b &= (BYTE)~LLEF; ord = b;
dp->blk_ofs = dp->dptr;
}
ord = (b == ord && sum == dp->dir[LDIR_Chksum] && pick_lfn(fs->lfnbuf, dp->dir)) ? ord - 1 : 0xFF;
} else {
if (ord != 0 || sum != sum_sfn(dp->dir)) {
dp->blk_ofs = 0xFFFFFFFF;
}
break;
}
}
#else
if (b != DDEM && b != '.' && attr != AM_LFN && (int)((attr & ~AM_ARC) == AM_VOL) == vol) {
break;
}
#endif
res = dir_next(dp, 0);
if (res != FR_OK) break;
}
if (res != FR_OK) dp->sect = 0;
return res;
}
#endif
#ifndef __LITEOS_M__
FRESULT dir_read_massive (
DIR* dp,
int vol
)
{
FRESULT res = FR_NO_FILE;
FATFS *fs = dp->obj.fs;
BYTE attr, b;
#if FF_USE_LFN
BYTE ord = 0xFF, sum = 0xFF;
#endif
while (dp->sect) {
res = move_window_readdir(fs, dp->sect);
if (res != FR_OK) break;
b = dp->dir[DIR_Name];
if (b == 0) {
res = FR_NO_FILE; break;
}
dp->obj.attr = attr = dp->dir[DIR_Attr] & AM_MASK;
#if FF_USE_LFN
if (b == DDEM || b == '.' || (int)((attr & ~AM_ARC) == AM_VOL) != vol) {
ord = 0xFF;
} else {
if (attr == AM_LFN) {
if (b & LLEF) {
sum = dp->dir[LDIR_Chksum];
b &= (BYTE)~LLEF; ord = b;
dp->blk_ofs = dp->dptr;
}
ord = (b == ord && sum == dp->dir[LDIR_Chksum] && pick_lfn(fs->lfnbuf, dp->dir)) ? ord - 1 : 0xFF;
} else {
if (ord != 0 || sum != sum_sfn(dp->dir)) {
dp->blk_ofs = 0xFFFFFFFF;
}
break;
}
}
#else
if (b != DDEM && b != '.' && attr != AM_LFN && (int)((attr & ~AM_ARC) == AM_VOL) == vol) {
break;
}
#endif
res = dir_next(dp, 0);
if (res != FR_OK) break;
}
if (res != FR_OK) dp->sect = 0;
return res;
}
#endif
FRESULT dir_find (
DIR* dp
)
{
FRESULT res;
FATFS *fs = dp->obj.fs;
BYTE c;
#if FF_USE_LFN
BYTE a, ord, sum;
#endif
res = dir_sdi(dp, 0);
if (res != FR_OK) return res;
#if FF_USE_LFN
ord = sum = 0xFF; dp->blk_ofs = 0xFFFFFFFF;
#endif
do {
res = move_window(fs, dp->sect);
if (res != FR_OK) break;
c = dp->dir[DIR_Name];
if (c == 0) { res = FR_NO_FILE; break; }
#if FF_USE_LFN
dp->obj.attr = a = dp->dir[DIR_Attr] & AM_MASK;
if (c == DDEM || ((a & AM_VOL) && a != AM_LFN)) {
ord = 0xFF; dp->blk_ofs = 0xFFFFFFFF;
} else {
if (a == AM_LFN) {
if (!(dp->fn[NSFLAG] & NS_NOLFN)) {
if (c & LLEF) {
sum = dp->dir[LDIR_Chksum];
c &= (BYTE)~LLEF; ord = c;
dp->blk_ofs = dp->dptr;
}
ord = (c == ord && sum == dp->dir[LDIR_Chksum] && cmp_lfn(fs->lfnbuf, dp->dir)) ? ord - 1 : 0xFF;
}
} else {
if (ord == 0 && sum == sum_sfn(dp->dir)) break;
if (!(dp->fn[NSFLAG] & NS_LOSS) && !mem_cmp(dp->dir, dp->fn, 11)) break;
ord = 0xFF; dp->blk_ofs = 0xFFFFFFFF;
}
}
#else
dp->obj.attr = dp->dir[DIR_Attr] & AM_MASK;
if (!(dp->dir[DIR_Attr] & AM_VOL) && !mem_cmp(dp->dir, dp->fn, 11)) break;
#endif
res = dir_next(dp, 0);
} while (res == FR_OK);
return res;
}
DWORD dir_ofs (
DIR* dp
)
{
#if FF_USE_LFN
UINT nlen, nent;
DWORD entry;
for (nlen = 0; dp->obj.fs->lfnbuf[nlen]; nlen++) ;
nent = (dp->fn[NSFLAG] & NS_LFN) ? (nlen + 12) / 13 + 1 : 1;
entry = dp->dptr - (nent - 1) * SZDIRE;
return entry;
#else
return dp->dptr;
#endif
}
#if !FF_FS_READONLY
FRESULT dir_register (
DIR* dp
)
{
FRESULT res;
FATFS *fs = dp->obj.fs;
#if FF_USE_LFN
UINT n, len, n_ent;
BYTE sn[12], sum;
if (dp->fn[NSFLAG] & (NS_DOT | NS_NONAME)) return FR_INVALID_NAME;
for (len = 0; fs->lfnbuf[len]; len++) ;
mem_cpy(sn, dp->fn, 12);
if (sn[NSFLAG] & NS_LOSS) {
dp->fn[NSFLAG] = NS_NOLFN;
for (n = 1; n < 100; n++) {
gen_numname(dp->fn, sn, fs->lfnbuf, n);
res = dir_find(dp);
if (res != FR_OK) break;
}
if (n == 100) return FR_DENIED;
if (res != FR_NO_FILE) return res;
dp->fn[NSFLAG] = sn[NSFLAG];
}
n_ent = (sn[NSFLAG] & NS_LFN) ? (len + 12) / 13 + 1 : 1;
res = dir_alloc(dp, n_ent);
if (res == FR_OK && --n_ent) {
res = dir_sdi(dp, dp->dptr - n_ent * SZDIRE);
if (res == FR_OK) {
sum = sum_sfn(dp->fn);
do {
res = move_window(fs, dp->sect);
if (res != FR_OK) break;
put_lfn(fs->lfnbuf, dp->dir, (BYTE)n_ent, sum);
#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
fs->wflag = 1;
#else
PARENTFS(fs)->wflag = 1;
#endif
res = dir_next(dp, 0);
} while (res == FR_OK && --n_ent);
}
}
#else
res = dir_alloc(dp, 1);
#endif
if (res == FR_OK) {
res = move_window(fs, dp->sect);
if (res == FR_OK) {
mem_set(dp->dir, 0, SZDIRE);
mem_cpy(dp->dir + DIR_Name, dp->fn, 11);
#if FF_USE_LFN
dp->dir[DIR_NTres] = dp->fn[NSFLAG] & (NS_BODY | NS_EXT);
#endif
#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
fs->wflag = 1;
#else
PARENTFS(fs)->wflag = 1;
#endif
}
}
return res;
}
#endif
#if !FF_FS_READONLY && FF_FS_MINIMIZE == 0
FRESULT dir_remove (
DIR* dp
)
{
FRESULT res;
FATFS *fs = dp->obj.fs;
#if FF_USE_LFN
DWORD last = dp->dptr;
res = (dp->blk_ofs == 0xFFFFFFFF) ? FR_OK : dir_sdi(dp, dp->blk_ofs);
if (res == FR_OK) {
do {
res = move_window(fs, dp->sect);
if (res != FR_OK) break;
dp->dir[DIR_Name] = DDEM;
#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
fs->wflag = 1;
#else
PARENTFS(fs)->wflag = 1;
#endif
if (dp->dptr >= last) break;
res = dir_next(dp, 0);
} while (res == FR_OK);
if (res == FR_NO_FILE) res = FR_INT_ERR;
}
#else
res = move_window(fs, dp->sect);
if (res == FR_OK) {
dp->dir[DIR_Name] = DDEM;
#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
fs->wflag = 1;
#else
PARENTFS(fs)->wflag = 1;
#endif
}
#endif
return res;
}
#endif
#if FF_FS_MINIMIZE <= 1 || FF_FS_RPATH >= 2
void get_fileinfo (
DIR* dp,
FILINFO* fno
)
{
UINT si, di;
#if FF_USE_LFN
BYTE lcf;
WCHAR wc, hs;
FATFS *fs = dp->obj.fs;
UINT nw;
#else
TCHAR c;
#endif
fno->fname[0] = 0;
if (dp->sect == 0) return;
#if FF_USE_LFN
if (dp->blk_ofs != 0xFFFFFFFF) {
si = di = 0;
hs = 0;
while (fs->lfnbuf[si] != 0) {
wc = fs->lfnbuf[si++];
if (hs == 0 && IsSurrogate(wc)) {
hs = wc; continue;
}
nw = put_utf((DWORD)hs << 16 | wc, &fno->fname[di], FF_LFN_BUF - di);
if (nw == 0) {
di = 0; break;
}
di += nw;
hs = 0;
}
if (hs != 0) di = 0;
fno->fname[di] = 0;
}
si = di = 0;
while (si < 11) {
wc = dp->dir[si++];
if (wc == ' ') continue;
if (wc == RDDEM) wc = DDEM;
if (si == 9 && di < FF_SFN_BUF) fno->altname[di++] = '.';
#if FF_LFN_UNICODE >= 1
if (dbc_1st((BYTE)wc) && si != 8 && si != 11 && dbc_2nd(dp->dir[si])) {
wc = wc << 8 | dp->dir[si++];
}
wc = ff_oem2uni(wc, CODEPAGE);
if (wc == 0) {
di = 0; break;
}
nw = put_utf(wc, &fno->altname[di], FF_SFN_BUF - di);
if (nw == 0) {
di = 0; break;
}
di += nw;
#else
fno->altname[di++] = (TCHAR)wc;
#endif
}
fno->altname[di] = 0;
if (fno->fname[0] == 0) {
if (di == 0) {
fno->fname[di++] = '\?';
} else {
for (si = di = 0, lcf = NS_BODY; fno->altname[si]; si++, di++) {
wc = (WCHAR)fno->altname[si];
if (wc == '.') lcf = NS_EXT;
if (IsUpper(wc) && (dp->dir[DIR_NTres] & lcf)) wc += 0x20;
fno->fname[di] = (TCHAR)wc;
}
}
fno->fname[di] = 0;
if (!dp->dir[DIR_NTres]) fno->altname[0] = 0;
}
#else
si = di = 0;
while (si < 11) {
c = (TCHAR)dp->dir[si++];
if (c == ' ') continue;
if (c == RDDEM) c = DDEM;
if (si == 9) fno->fname[di++] = '.';
fno->fname[di++] = c;
}
fno->fname[di] = 0;
#endif
fno->fattrib = dp->dir[DIR_Attr] & AM_MASK;
fno->fsize = ld_dword(dp->dir + DIR_FileSize);
fno->ftime = ld_word(dp->dir + DIR_ModTime + 0);
fno->fdate = ld_word(dp->dir + DIR_ModTime + 2);
fno->sclst = ld_clust(fs, dp->dir);
}
#endif
#if FF_USE_FIND && FF_FS_MINIMIZE <= 1
#define FIND_RECURS 4
static DWORD get_achar (
const TCHAR** ptr
)
{
DWORD chr;
#if FF_USE_LFN && FF_LFN_UNICODE >= 1
chr = tchar2uni(ptr);
if (chr == 0xFFFFFFFF) chr = 0;
chr = ff_wtoupper(chr);
#else
chr = (BYTE)*(*ptr)++;
if (IsLower(chr)) chr -= 0x20;
#if FF_CODE_PAGE == 0
if (ExCvt && chr >= 0x80) chr = ExCvt[chr - 0x80];
#elif FF_CODE_PAGE < 900
if (chr >= 0x80) chr = ExCvt[chr - 0x80];
#endif
#if FF_CODE_PAGE == 0 || FF_CODE_PAGE >= 900
if (dbc_1st((BYTE)chr)) {
chr = dbc_2nd((BYTE)**ptr) ? chr << 8 | (BYTE)*(*ptr)++ : 0;
}
#endif
#endif
return chr;
}
static int pattern_match (
const TCHAR* pat,
const TCHAR* nam,
UINT skip,
UINT recur
)
{
const TCHAR *pptr;
const TCHAR *nptr;
DWORD pchr, nchr;
UINT sk;
while ((skip & 0xFF) != 0) {
if (!get_achar(&nam)) return 0;
skip--;
}
if (*pat == 0 && skip) return 1;
do {
pptr = pat; nptr = nam;
for (;;) {
if (*pptr == '\?' || *pptr == '*') {
if (recur == 0) return 0;
sk = 0;
do {
if (*pptr++ == '\?') {
sk++;
} else {
sk |= 0x100;
}
} while (*pptr == '\?' || *pptr == '*');
if (pattern_match(pptr, nptr, sk, recur - 1)) return 1;
nchr = *nptr; break;
}
pchr = get_achar(&pptr);
nchr = get_achar(&nptr);
if (pchr != nchr) break;
if (pchr == 0) return 1;
}
get_achar(&nam);
} while (skip && nchr);
return 0;
}
#endif
FRESULT create_name (
DIR* dp,
const TCHAR** path
)
{
#if FF_USE_LFN
BYTE b, cf;
WCHAR wc;
WCHAR *lfn;
const TCHAR* p;
DWORD uc;
UINT i, ni, si, di;
p = *path; lfn = dp->obj.fs->lfnbuf; di = 0;
for (;;) {
uc = tchar2uni(&p);
if (uc == 0xFFFFFFFF) return FR_INVALID_NAME;
if (uc >= 0x10000) lfn[di++] = (WCHAR)(uc >> 16);
wc = (WCHAR)uc;
if (wc < ' ' || IsSeparator(wc)) break;
if (wc < 0x80 && chk_chr("*:<>|\"\?\x7F", (int)wc)) return FR_INVALID_NAME;
if (di >= FF_MAX_LFN) return FR_INVALID_NAME;
lfn[di++] = wc;
}
if (wc < ' ') {
cf = NS_LAST;
} else {
while (IsSeparator(*p)) p++;
cf = 0;
if (IsTerminator(*p)) cf = NS_LAST;
}
*path = p;
#if FF_FS_RPATH != 0
if ((di == 1 && lfn[di - 1] == '.') ||
(di == 2 && lfn[di - 1] == '.' && lfn[di - 2] == '.')) {
lfn[di] = 0;
for (i = 0; i < 11; i++) {
dp->fn[i] = (i < di) ? '.' : ' ';
}
dp->fn[i] = cf | NS_DOT;
return FR_OK;
}
#endif
while (di) {
wc = lfn[di - 1];
if (wc != ' ' && wc != '.') break;
di--;
}
lfn[di] = 0;
if (di == 0) return FR_INVALID_NAME;
for (si = 0; lfn[si] == ' '; si++) ;
if (si > 0 || lfn[si] == '.') cf |= NS_LOSS | NS_LFN;
while (di > 0 && lfn[di - 1] != '.') di--;
mem_set(dp->fn, ' ', 11);
i = b = 0; ni = 8;
for (;;) {
wc = lfn[si++];
if (wc == 0) break;
if (wc == ' ' || (wc == '.' && si != di)) {
cf |= NS_LOSS | NS_LFN;
continue;
}
if (i >= ni || si == di) {
if (ni == 11) {
cf |= NS_LOSS | NS_LFN;
break;
}
if (si != di) cf |= NS_LOSS | NS_LFN;
if (si > di) break;
si = di; i = 8; ni = 11; b <<= 2;
continue;
}
if (wc >= 0x80) {
cf |= NS_LFN;
#if FF_CODE_PAGE == 0
if (ExCvt) {
wc = ff_uni2oem(wc, CODEPAGE);
if (wc & 0x80) wc = ExCvt[wc & 0x7F];
} else {
wc = ff_uni2oem(ff_wtoupper(wc), CODEPAGE);
}
#elif FF_CODE_PAGE < 900
wc = ff_uni2oem(wc, CODEPAGE);
if (wc & 0x80) wc = ExCvt[wc & 0x7F];
#else
wc = ff_uni2oem(ff_wtoupper(wc), CODEPAGE);
#endif
}
if (wc >= 0x100) {
if (i >= ni - 1) {
cf |= NS_LOSS | NS_LFN;
i = ni; continue;
}
dp->fn[i++] = (BYTE)(wc >> 8);
} else {
if (wc == 0 || chk_chr("+,;=[]", (int)wc)) {
wc = '_'; cf |= NS_LOSS | NS_LFN;
} else {
if (IsUpper(wc)) {
b |= 2;
}
if (IsLower(wc)) {
b |= 1; wc -= 0x20;
}
}
}
dp->fn[i++] = (BYTE)wc;
}
if (dp->fn[0] == DDEM) dp->fn[0] = RDDEM;
if (ni == 8) b <<= 2;
if ((b & 0x0C) == 0x0C || (b & 0x03) == 0x03) cf |= NS_LFN;
if (!(cf & NS_LFN)) {
if (b & 0x01) cf |= NS_EXT;
if (b & 0x04) cf |= NS_BODY;
}
dp->fn[NSFLAG] = cf;
return FR_OK;
#else
BYTE c, d;
BYTE *sfn;
UINT ni, si, i;
const char *p;
p = *path; sfn = dp->fn;
mem_set(sfn, ' ', 11);
si = i = 0; ni = 8;
#if FF_FS_RPATH != 0
if (p[si] == '.') {
for (;;) {
c = (BYTE)p[si++];
if (c != '.' || si >= 3) break;
sfn[i++] = c;
}
if (!IsSeparator(c) && c > ' ') return FR_INVALID_NAME;
*path = p + si;
sfn[NSFLAG] = (c <= ' ') ? NS_LAST | NS_DOT : NS_DOT;
return FR_OK;
}
#endif
for (;;) {
c = (BYTE)p[si++];
if (c <= ' ') break;
if (IsSeparator(c)) {
while (IsSeparator(p[si])) si++;
break;
}
if (c == '.' || i >= ni) {
if (ni == 11 || c != '.') return FR_INVALID_NAME;
i = 8; ni = 11;
continue;
}
#if FF_CODE_PAGE == 0
if (ExCvt && c >= 0x80) {
c = ExCvt[c & 0x7F];
}
#elif FF_CODE_PAGE < 900
if (c >= 0x80) {
c = ExCvt[c & 0x7F];
}
#endif
if (dbc_1st(c)) {
d = (BYTE)p[si++];
if (!dbc_2nd(d) || i >= ni - 1) return FR_INVALID_NAME;
sfn[i++] = c;
sfn[i++] = d;
} else {
if (chk_chr("*+,:;<=>[]|\"\?\x7F", (int)c)) return FR_INVALID_NAME;
if (IsLower(c)) c -= 0x20;
sfn[i++] = c;
}
}
*path = &p[si];
if (i == 0) return FR_INVALID_NAME;
if (sfn[0] == DDEM) sfn[0] = RDDEM;
sfn[NSFLAG] = (c <= ' ' || p[si] <= ' ') ? NS_LAST : 0;
return FR_OK;
#endif
}
static FRESULT follow_path (
DIR* dp,
const TCHAR* path
)
{
FRESULT res;
BYTE ns;
FATFS *fs = dp->obj.fs;
#if FF_FS_RPATH != 0
if (!IsSeparator(*path) && (FF_STR_VOLUME_ID != 2 || !IsTerminator(*path))) {
dp->obj.sclust = fs->cdir;
} else
#endif
{
while (IsSeparator(*path)) path++;
dp->obj.sclust = 0;
}
if ((UINT)*path < ' ') {
dp->fn[NSFLAG] = NS_NONAME;
res = dir_sdi(dp, 0);
} else {
for (;;) {
res = create_name(dp, &path);
if (res != FR_OK) break;
res = dir_find(dp);
ns = dp->fn[NSFLAG];
if (res != FR_OK) {
if (res == FR_NO_FILE) {
if (FF_FS_RPATH && (ns & NS_DOT)) {
if (!(ns & NS_LAST)) continue;
dp->fn[NSFLAG] = NS_NONAME;
res = FR_OK;
} else {
if (!(ns & NS_LAST)) res = FR_NO_PATH;
}
}
break;
}
if (ns & NS_LAST) break;
if (!(dp->obj.attr & AM_DIR)) {
res = FR_NO_PATH; break;
}
#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
dp->obj.sclust = ld_clust(fs, fs->win + dp->dptr % SS(fs));
#else
dp->obj.sclust = ld_clust(PARENTFS(fs), PARENTFS(fs)->win + dp->dptr % SS(PARENTFS(fs)));
#endif
}
}
return res;
}
static int get_ldnumber (
const TCHAR** path
)
{
const TCHAR *tp;
const TCHAR *tt;
TCHAR tc;
int i;
int vol = -1;
#if FF_STR_VOLUME_ID
const char *sp;
char c;
#endif
tt = tp = *path;
if (!tp) return vol;
do {
tc = *tt++;
} while (!IsTerminator(tc) && tc != ':');
if (tc == ':') {
i = *tp++ - '0';
if (IsDigit(*tp) && tp != tt) {
i = 10 * i + *tp - '0';
}
#if FF_STR_VOLUME_ID == 1
else {
i = 0;
do {
sp = VolumeStr[i]; tp = *path;
do {
c = *sp++; tc = *tp++;
if (IsLower(c)) c -= 0x20;
if (IsLower(tc)) tc -= 0x20;
} while (c && (TCHAR)c == tc);
} while ((c || tp != tt) && ++i < FF_VOLUMES);
}
#endif
if (i < FF_VOLUMES) {
vol = i;
*path = tt;
}
return vol;
}
#if FF_STR_VOLUME_ID == 2
if (*tp == '/') {
while (*(tp + 1) == '/') tp++;
i = 0;
do {
tt = tp; sp = VolumeStr[i];
do {
c = *sp++; tc = *(++tt);
if (IsLower(c)) c -= 0x20;
if (IsLower(tc)) tc -= 0x20;
} while (c && (TCHAR)c == tc);
} while ((c || (tc != '/' && !IsTerminator(tc))) && ++i < FF_VOLUMES);
if (i < FF_VOLUMES) {
vol = i;
*path = tt;
}
return vol;
}
#endif
#if FF_FS_RPATH != 0
vol = CurrVol;
#else
vol = 0;
#endif
return vol;
}
UINT check_fs (
FATFS* fs,
LBA_t sect
)
{
WORD w, sign;
BYTE b;
fs->wflag = 0; fs->winsect = (LBA_t)0 - 1;
if (move_window(fs, sect) != FR_OK) return 4;
sign = ld_word(fs->win + BS_55AA);
b = fs->win[BS_JmpBoot];
if (b == 0xEB || b == 0xE9 || b == 0xE8) {
if (sign == 0xAA55 && !mem_cmp(fs->win + BS_FilSysType32, "FAT32 ", 8)) {
return 0;
}
w = ld_word(fs->win + BPB_BytsPerSec);
if ((w & (w - 1)) == 0 && w >= FF_MIN_SS && w <= FF_MAX_SS) {
b = fs->win[BPB_SecPerClus];
if (b != 0 && (b & (b - 1)) == 0
&& (fs->win[BPB_NumFATs] == 1 || fs->win[BPB_NumFATs] == 2)
&& ld_word(fs->win + BPB_RootEntCnt) != 0
&& ld_word(fs->win + BPB_FATSz16) != 0) {
return 0;
}
}
}
return sign == 0xAA55 ? 2 : 3;
}
static UINT find_volume (
FATFS* fs,
int vol
)
{
BYTE *mbr_pt;
UINT fmt, i;
int extended_br;
int extended_pos = -1;
DWORD offset = 0;
LBA_t bsect;
bsect = 0;
fmt = check_fs(fs, 0);
if (fmt != 2 && (fmt >= 3 || LD2PT(vol) == 0)) return fmt;
if (fs->win[MBR_Table + 4] != 0xEE) {
extended_br = LD2PT(vol) - 4;
if (extended_br > 0) {
for (i = 0; i < 4; i++) {
mbr_pt = fs->win + MBR_Table + i * SZ_PTE;
if (mbr_pt[4] == 0x0F || mbr_pt[4] == 0x05) extended_pos = i;
}
mbr_pt = fs->win + MBR_Table + extended_pos * SZ_PTE;
bsect = ld_dword(&mbr_pt[8]);
do {
mem_set(fs->win, 0, SS(fs));
#ifndef __LITEOS_M__
if (disk_raw_read(LD2DI(vol), fs->win, bsect + offset, 1) != RES_OK) return FR_DISK_ERR;
#else
if (disk_read(LD2PD(vol), fs->win, bsect + offset, 1) != RES_OK) return FR_DISK_ERR;
#endif
mbr_pt = fs->win + MBR_Table;
offset = ld_dword(&mbr_pt[SZ_PTE + 8]);
} while (--extended_br);
}
i = LD2PT(vol);
if (i) {
#ifndef __LITEOS_M__
bsect = LD2PS(vol);
#else
i = LD2PT(vol);
if (i != 0) i--;
mbr_pt = fs->win + (MBR_Table + i * SZ_PTE);
bsect = mbr_pt[PTE_System] ? ld_dword(mbr_pt + PTE_StLba) : 0;
#endif
} else {
mbr_pt = fs->win + MBR_Table;
bsect = mbr_pt[4] ? ld_dword(&mbr_pt[8]) : 0;
}
}
else {
bsect = LD2PS(vol);
}
fmt = bsect ? check_fs(fs, bsect) : 2;
return fmt;
}
FRESULT mount_volume (
const TCHAR** path,
FATFS** rfs,
BYTE mode
)
{
int vol;
FATFS *fs;
DSTATUS stat;
LBA_t bsect;
DWORD tsect, sysect, fasize, nclst, szbfat;
WORD nrsv;
UINT fmt;
*rfs = 0;
vol = get_ldnumber(path);
if (vol < 0) return FR_INVALID_DRIVE;
fs = FatFs[vol];
if (!fs) return FR_NOT_ENABLED;
#if FF_FS_REENTRANT
if (!lock_fs(fs)) return FR_TIMEOUT;
#endif
*rfs = fs;
mode &= (BYTE)~FA_READ;
if (fs->fs_type != 0) {
stat = disk_status(fs->pdrv);
if (!(stat & STA_NOINIT)) {
if (!FF_FS_READONLY && mode && (stat & STA_PROTECT)) {
return FR_WRITE_PROTECTED;
}
return FR_OK;
}
}
fs->fs_type = 0;
fs->pdrv = LD2PD(vol);
stat = disk_initialize(fs->pdrv);
if (stat & STA_NOINIT) {
return FR_NOT_READY;
}
if (!FF_FS_READONLY && mode && (stat & STA_PROTECT)) {
return FR_WRITE_PROTECTED;
}
#if FF_MAX_SS != FF_MIN_SS
if (disk_ioctl(fs->pdrv, GET_SECTOR_SIZE, &SS(fs)) != RES_OK) return FR_DISK_ERR;
if (SS(fs) > FF_MAX_SS || SS(fs) < FF_MIN_SS || (SS(fs) & (SS(fs) - 1))) return FR_DISK_ERR;
#endif
if (fs->win == NULL) {
fs->win = (BYTE*) ff_memalloc(SS(fs));
if (fs->win == NULL)
return FR_NOT_ENOUGH_CORE;
}
fmt = find_volume(fs, vol);
if (fmt == 4) return FR_DISK_ERR;
if (fmt >= 2) return FR_NO_FILESYSTEM;
bsect = fs->winsect;
if (ld_word(fs->win + BPB_BytsPerSec) != SS(fs)) return FR_NO_FILESYSTEM;
fasize = ld_word(fs->win + BPB_FATSz16);
if (fasize == 0) fasize = ld_dword(fs->win + BPB_FATSz32);
fs->fsize = fasize;
fs->n_fats = fs->win[BPB_NumFATs];
if (fs->n_fats != 1 && fs->n_fats != 2) return FR_NO_FILESYSTEM;
fasize *= fs->n_fats;
fs->csize = fs->win[BPB_SecPerClus];
if (fs->csize == 0 || (fs->csize & (fs->csize - 1))) return FR_NO_FILESYSTEM;
fs->n_rootdir = ld_word(fs->win + BPB_RootEntCnt);
if (fs->n_rootdir % (SS(fs) / SZDIRE)) return FR_NO_FILESYSTEM;
tsect = ld_word(fs->win + BPB_TotSec16);
if (tsect == 0) tsect = ld_dword(fs->win + BPB_TotSec32);
nrsv = ld_word(fs->win + BPB_RsvdSecCnt);
if (nrsv == 0) return FR_NO_FILESYSTEM;
sysect = nrsv + fasize + fs->n_rootdir / (SS(fs) / SZDIRE);
if (tsect < sysect) return FR_NO_FILESYSTEM;
nclst = (tsect - sysect) / fs->csize;
if (nclst == 0) return FR_NO_FILESYSTEM;
fmt = 0;
if (nclst <= MAX_FAT32) fmt = FS_FAT32;
if (nclst <= MAX_FAT16) fmt = FS_FAT16;
if (nclst <= MAX_FAT12) fmt = FS_FAT12;
if (fmt == 0) return FR_NO_FILESYSTEM;
fs->n_fatent = nclst + 2;
fs->volbase = bsect;
fs->fatbase = bsect + nrsv;
fs->database = bsect + sysect;
if (fmt == FS_FAT32) {
if (ld_word(fs->win + BPB_FSVer32) != 0) return FR_NO_FILESYSTEM;
if (fs->n_rootdir != 0) return FR_NO_FILESYSTEM;
fs->dirbase = ld_dword(fs->win + BPB_RootClus32);
szbfat = fs->n_fatent * 4;
} else {
if (fs->n_rootdir == 0) return FR_NO_FILESYSTEM;
fs->dirbase = fs->fatbase + fasize;
szbfat = (fmt == FS_FAT16) ?
fs->n_fatent * 2 : fs->n_fatent * 3 / 2 + (fs->n_fatent & 1);
}
if (fs->fsize < (szbfat + (SS(fs) - 1)) / SS(fs)) return FR_NO_FILESYSTEM;
#if !FF_FS_READONLY
fs->last_clst = fs->free_clst = 0xFFFFFFFF;
fs->fsi_flag = 0x80;
#if (FF_FS_NOFSINFO & 3) != 3
if (fmt == FS_FAT32
&& ld_word(fs->win + BPB_FSInfo32) == 1
&& move_window(fs, bsect + 1) == FR_OK)
{
fs->fsi_flag = 0;
if (ld_word(fs->win + BS_55AA) == 0xAA55
&& ld_dword(fs->win + FSI_LeadSig) == 0x41615252
&& ld_dword(fs->win + FSI_StrucSig) == 0x61417272)
{
#if (FF_FS_NOFSINFO & 1) == 0
fs->free_clst = ld_dword(fs->win + FSI_Free_Count);
#endif
#if (FF_FS_NOFSINFO & 2) == 0
fs->last_clst = ld_dword(fs->win + FSI_Nxt_Free);
#endif
}
}
#endif
#endif
fs->fs_type = (BYTE)fmt;
fs->id = ++Fsid;
#if FF_USE_LFN == 1
fs->lfnbuf = LfnBuf;
#endif
#if FF_FS_RPATH != 0
fs->cdir = 0;
#endif
#if FF_FS_LOCK
clear_share(fs);
#endif
return FR_OK;
}
static FRESULT validate (
FFOBJID* obj,
FATFS** rfs
)
{
FRESULT res = FR_INVALID_OBJECT;
if (obj && obj->fs && obj->fs->fs_type && obj->id == obj->fs->id) {
#if FF_FS_REENTRANT
#ifdef __LITEOS_M__
if (lock_fs(obj->fs)) {
if (!(disk_status(obj->fs->pdrv) & STA_NOINIT)) {
res = FR_OK;
} else {
unlock_fs(obj->fs, FR_OK);
}
} else {
res = FR_TIMEOUT;
}
#else
res = FR_OK;
#endif
#else
if (!(disk_status(obj->fs->pdrv) & STA_NOINIT)) {
res = FR_OK;
}
#endif
}
*rfs = (res == FR_OK) ? obj->fs : 0;
return res;
}
#define FAT12_END_OF_CLUSTER 0x00000FFF
#define FAT16_END_OF_CLUSTER 0x0000FFFF
#define FAT32_END_OF_CLUSTER 0x0FFFFFFF
#define DISK_ERROR 0xFFFFFFFF
static DWORD get_end_of_cluster(
FATFS *fs
)
{
switch(fs->fs_type) {
case FS_FAT12:
return FAT12_END_OF_CLUSTER;
case FS_FAT16:
return FAT16_END_OF_CLUSTER;
case FS_FAT32:
return FAT32_END_OF_CLUSTER;
default:
return DISK_ERROR;
}
}
static
UINT get_clustinfo(FIL* fp,
DWORD* fclust
)
{
UINT count = 0;
DWORD fsclust = 0, val;
DWORD last_clust = get_end_of_cluster(fp->obj.fs);
if (fp->obj.sclust != 0) {
val = fp->obj.sclust;
do {
fsclust = val;
val = get_fat(&fp->obj, fsclust);
count++;
} while ((val != last_clust) && (val != 1));
}
*fclust = fsclust;
return count;
}
Public Functions (FatFs API)
----------------------------------------------------------------------------*/
FRESULT f_mount (
FATFS* fs,
const TCHAR* path,
BYTE opt
)
{
FATFS *cfs;
int vol;
FRESULT res;
const TCHAR *rp = path;
vol = get_ldnumber(&rp);
if (vol < 0) return FR_INVALID_DRIVE;
cfs = FatFs[vol];
if (cfs) {
#if FF_FS_LOCK
clear_share(cfs);
#endif
#if FF_FS_REENTRANT
if (!ff_del_syncobj(&cfs->sobj)) return FR_INT_ERR;
#endif
cfs->fs_type = 0;
}
if (fs) {
fs->fs_type = 0;
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
fs->vir_flag = FS_PARENT;
fs->parent_fs = fs;
fs->vir_amount = 0xFFFFFFFF;
fs->vir_avail = FS_VIRDISABLE;
#endif
#if FF_FS_REENTRANT
if (!ff_cre_syncobj((BYTE)vol, &fs->sobj)) return FR_INT_ERR;
#endif
}
FatFs[vol] = fs;
if (opt == 0) return FR_OK;
res = mount_volume(&path, &fs, 0);
LEAVE_FF(fs, res);
}
#ifndef __LITEOS_M__
FRESULT init_fatobj(FATFS *fs, BYTE fmt, QWORD start_sector)
{
DWORD fasize;
DWORD tsect;
DWORD sysect;
DWORD nclst;
DWORD szbfat;
WORD nrsv;
if (ld_word(fs->win + BPB_BytsPerSec) != SS(fs)) {
return FR_NO_FILESYSTEM;
}
fasize = ld_word(fs->win + BPB_FATSz16);
if (fasize == 0) fasize = ld_dword(fs->win + BPB_FATSz32);
fs->fsize = fasize;
fs->n_fats = fs->win[BPB_NumFATs];
if (fs->n_fats != 1 && fs->n_fats != 2) return FR_NO_FILESYSTEM;
fasize *= fs->n_fats;
fs->csize = fs->win[BPB_SecPerClus];
if (fs->csize == 0 || (fs->csize & (fs->csize - 1))) return FR_NO_FILESYSTEM;
fs->n_rootdir = ld_word(fs->win + BPB_RootEntCnt);
if (fs->n_rootdir % (SS(fs) / SZDIRE)) return FR_NO_FILESYSTEM;
tsect = ld_word(fs->win + BPB_TotSec16);
if (tsect == 0) tsect = ld_dword(fs->win + BPB_TotSec32);
nrsv = ld_word(fs->win + BPB_RsvdSecCnt);
if (nrsv == 0) return FR_NO_FILESYSTEM;
sysect = nrsv + fasize + fs->n_rootdir / (SS(fs) / SZDIRE);
if (tsect < sysect) return FR_NO_FILESYSTEM;
nclst = (tsect - sysect) / fs->csize;
if (nclst == 0) return FR_NO_FILESYSTEM;
fmt = 0;
if (nclst <= MAX_FAT32) fmt = FS_FAT32;
if (nclst <= MAX_FAT16) fmt = FS_FAT16;
if (nclst <= MAX_FAT12) fmt = FS_FAT12;
if (fmt == 0) return FR_NO_FILESYSTEM;
fs->n_fatent = nclst + FAT_RESERVED_NUM;
fs->volbase = start_sector;
fs->fatbase = start_sector + nrsv;
fs->database = start_sector + sysect;
if (fmt == FS_FAT32) {
if (ld_word(fs->win + BPB_FSVer32) != 0) return FR_NO_FILESYSTEM;
if (fs->n_rootdir != 0) return FR_NO_FILESYSTEM;
fs->dirbase = ld_dword(fs->win + BPB_RootClus32);
szbfat = fs->n_fatent * FAT32_ENTRY_SIZE;
} else {
if (fs->n_rootdir == 0) return FR_NO_FILESYSTEM;
fs->dirbase = fs->fatbase + fasize;
szbfat = (fmt == FS_FAT16) ? (fs->n_fatent * FAT16_ENTRY_SIZE) :
(fs->n_fatent * 3 / 2 + (fs->n_fatent & 1));
}
if (fs->fsize < (szbfat + (SS(fs) - 1)) / SS(fs)) {
return FR_NO_FILESYSTEM;
}
#if !FF_FS_READONLY
fs->last_clst = fs->free_clst = DISK_ERROR;
fs->fsi_flag = 0x80;
#if (FF_FS_NOFSINFO & 3) != 3
if (fmt == FS_FAT32
&& ld_word(fs->win + BPB_FSInfo32) == 1
&& move_window(fs, start_sector + 1) == FR_OK) {
fs->fsi_flag = 0;
if (ld_word(fs->win + BS_55AA) == 0xAA55
&& ld_dword(fs->win + FSI_LeadSig) == 0x41615252
&& ld_dword(fs->win + FSI_StrucSig) == 0x61417272) {
#if (FF_FS_NOFSINFO & 1) == 0
fs->free_clst = ld_dword(fs->win + FSI_Free_Count);
#endif
#if (FF_FS_NOFSINFO & 2) == 0
fs->last_clst = ld_dword(fs->win + FSI_Nxt_Free);
#endif
}
}
#endif
#endif
fs->fs_type = fmt;
fs->id = 0;
#if FF_USE_LFN == 1
fs->lfnbuf = LfnBuf;
#endif
#if FF_FS_RPATH != 0
fs->cdir = 0;
#endif
return FR_OK;
}
#endif
#ifndef __LITEOS_M__
FRESULT find_fat_partition(FATFS *fs, los_part *part, BYTE *format, QWORD *start_sector)
{
DWORD offset = 0;
QWORD bsect;
int extended_br;
int extended_pos = -1;
int i;
BYTE fmt;
BYTE *pt;
bsect = 0;
fmt = check_fs(fs, bsect);
if (fmt == VBR_BS_NOT_FAT ||
(fmt < VBR_BS_NOT_FAT && part->part_no_mbr != 0)) {
if (fs->win[MBR_Table + PTE_System] != GPT_PROTECTIVE_MBR) {
extended_br = part->part_no_mbr - MBR_PRIMARY_PART_NUM;
if (extended_br > 0) {
for (i = 0; i < MBR_PRIMARY_PART_NUM; i++) {
pt = fs->win + MBR_Table + i * SZ_PTE;
if (pt[PTE_System] == EXTENDED_PARTITION_LBA || pt[PTE_System] == EXTENDED_PARTITION_CHS) {
extended_pos = i;
}
}
pt = fs->win + MBR_Table + extended_pos * SZ_PTE;
bsect = ld_dword(&pt[PTE_StLba]);
do {
mem_set(fs->win, 0, SS(fs));
if (disk_raw_read(part->disk_id, fs->win, bsect + offset, 1) != RES_OK) {
return FR_DISK_ERR;
}
pt = fs->win + MBR_Table;
offset = ld_dword(&pt[SZ_PTE + PTE_StLba]);
} while (--extended_br);
}
i = part->part_no_mbr;
if (i) {
bsect = part->sector_start;
} else {
pt = fs->win + MBR_Table;
bsect = pt[PTE_System] ? ld_dword(&pt[PTE_StLba]) : 0;
}
} else {
bsect = part->sector_start;
}
fmt = bsect ? check_fs(fs, bsect) : VBR_BS_NOT_FAT;
}
if (fmt == VBR_DISK_ERR) {
return FR_DISK_ERR;
}
if (fmt >= VBR_BS_NOT_FAT) {
return FR_NO_FILESYSTEM;
}
*format = fmt;
*start_sector = bsect;
return FR_OK;
}
#endif
FRESULT f_open (
FIL* fp,
const TCHAR* path,
BYTE mode
)
{
FRESULT res;
DIR dj;
FATFS *fs;
#if FF_FS_REENTRANT
FATFS *fs_bak;
#endif
#if !FF_FS_READONLY
DWORD cl, bcs, clst, tm;
LBA_t sc;
#ifndef __LITEOS_M__
LBA_t dw;
#endif
FSIZE_t ofs;
#endif
DEF_NAMBUF
if (!fp) return FR_INVALID_OBJECT;
mode &= FF_FS_READONLY ? FA_READ : FA_READ | FA_WRITE | FA_CREATE_ALWAYS | FA_CREATE_NEW | FA_OPEN_ALWAYS | FA_OPEN_APPEND | FA_SEEKEND;
res = mount_volume(&path, &fs, mode);
#if FF_FS_REENTRANT
fs_bak = fs;
#endif
if (res == FR_OK) {
dj.obj.fs = fs;
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
#if FF_FS_REENTRANT
if (ISCHILD(fs)) LEAVE_FF(fs_bak,FR_INVAILD_FATFS);
#else
if (ISCHILD(fs)) LEAVE_FF(fs,FR_INVAILD_FATFS);
#endif
if (ISVIRPART(fs)) {
res = follow_virentry(&dj.obj,path);
#if FF_FS_REENTRANT
if (res == FR_INT_ERR) LEAVE_FF(fs_bak,res);
#else
if (res == FR_INT_ERR) LEAVE_FF(fs,res);
#endif
if (res == FR_OK)
fs = dj.obj.fs;
}
#endif
INIT_NAMBUF(fs);
res = follow_path(&dj, path);
#if !FF_FS_READONLY
if (res == FR_OK) {
if (dj.fn[NSFLAG] & NS_NONAME) {
res = FR_INVALID_NAME;
}
#if FF_FS_LOCK
else {
res = chk_share(&dj, (mode & ~FA_READ) ? 1 : 0);
}
#endif
}
if (mode & (FA_CREATE_ALWAYS | FA_OPEN_ALWAYS | FA_CREATE_NEW)) {
if (res != FR_OK) {
if ((res == FR_NO_FILE) && (mode & FA_OPEN_ALWAYS)) {
#if FF_FS_LOCK
res = enq_share() ? dir_register(&dj) : FR_TOO_MANY_OPEN_FILES;
#else
res = dir_register(&dj);
#endif
}
if (res == FR_OK)
mode |= FA_CREATE_ALWAYS;
}
else {
if (dj.obj.attr & (AM_RDO | AM_DIR)) {
res = FR_IS_DIR;
} else {
if (mode & FA_CREATE_NEW) res = FR_EXIST;
}
}
if (res == FR_OK && (mode & FA_CREATE_ALWAYS)) {
tm = GET_FATTIME();
if (SYSTEM_TIME_ENABLE == time_status) {
st_dword(dj.dir + DIR_CrtTime, tm);
st_dword(dj.dir + DIR_ModTime, tm);
} else if (SYSTEM_TIME_DISABLE == time_status) {
st_dword(dj.dir + DIR_CrtTime, 0);
st_dword(dj.dir + DIR_ModTime, 0);
}
dj.dir[DIR_Attr] = AM_ARC;
cl = ld_clust(fs, dj.dir);
st_clust(fs, dj.dir, 0);
st_dword(dj.dir + DIR_FileSize, 0);
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
PARENTFS(fs)->wflag = 1;
#else
fs->wflag = 1;
#endif
if (cl != 0) {
#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
sc = fs->winsect;
res = remove_chain(&dj.obj, cl, 0);
if (res == FR_OK) {
res = move_window(fs, sc);
fs->last_clst = cl - 1;
}
#else
dw = PARENTFS(fs)->winsect;
res = remove_chain(&dj.obj, cl, 0);
if (res == FR_OK) {
res = move_window(fs, dw);
if (ISVIRPART(fs) && ISCHILD(fs))
fs->last_clst = cl - 1;
PARENTFS(fs)->last_clst = cl -1;
}
#endif
}
}
}
else {
if (res == FR_OK) {
if (dj.obj.attr & AM_DIR) {
res = FR_IS_DIR;
} else {
if ((mode & FA_WRITE) && (dj.obj.attr & AM_RDO)) {
res = FR_DENIED;
}
}
}
}
if (res == FR_OK) {
if (mode & FA_CREATE_ALWAYS) mode |= FA_MODIFIED;
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
fp->dir_sect = PARENTFS(fs)->winsect;
#else
fp->dir_sect = fs->winsect;
#endif
fp->dir_ptr = dj.dir;
#if FF_FS_LOCK
fp->obj.lockid = inc_share(&dj, (mode & ~FA_READ) ? 1 : 0);
if (fp->obj.lockid == 0) res = FR_INT_ERR;
#endif
}
#else
if (res == FR_OK) {
if (dj.fn[NSFLAG] & NS_NONAME) {
res = FR_INVALID_NAME;
} else {
if (dj.obj.attr & AM_DIR) {
res = FR_NO_FILE;
}
}
}
#endif
if (res == FR_OK) {
fp->obj.sclust = ld_clust(fs, dj.dir);
fp->obj.objsize = ld_dword(dj.dir + DIR_FileSize);
#if FF_USE_FASTSEEK
fp->cltbl = 0;
#endif
fp->obj.fs = fs;
fp->obj.id = fs->id;
fp->flag = mode;
fp->err = 0;
fp->sect = 0;
fp->fptr = 0;
#if !FF_FS_READONLY
#if !FF_FS_TINY
fp->buf = (BYTE*) ff_memalloc(SS(fs));
if (fp->buf == NULL) {
res = FR_NOT_ENOUGH_CORE;
#if FF_FS_LOCK != 0
dec_share(fp->obj.lockid);
#endif
#if FF_FS_REENTRANT
LEAVE_FF(fs_bak, res);
#else
LEAVE_FF(fs, res);
#endif
}
#endif
if ((mode & FA_SEEKEND) && fp->obj.objsize > 0) {
fp->fptr = fp->obj.objsize;
bcs = (DWORD)fs->csize * SS(fs);
clst = fp->obj.sclust;
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)) {
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
}
}
}
#endif
}
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
more than two virtual partitions */
if (res == FR_OK && (mode & ~FA_READ) && ISVIRPART(fs) &&
(ISCHILD(fs) || (ISPARENT(fs) && fs->st_clst != 0xFFFFFFFF && fs->ct_clst != 0xFFFFFFFF))) {
clst = fp->obj.sclust;
cl = get_end_of_cluster(fs);
if (clst != 0) {
while (1) {
if (clst == 0xFFFFFFFF) {
res = FR_DISK_ERR;
break;
}
if (clst == cl) {
res = FR_OK;
break;
}
if (clst < 2 || clst >= fs->n_fatent) {
res = FR_INT_ERR;
break;
}
if (clst < fs->st_clst || clst >= fs->st_clst + fs->ct_clst) {
res = FR_INT_ERR;
break;
}
clst = get_fat(&fp->obj, clst);
}
}
}
#endif
#if FF_FS_LOCK
if (res != FR_OK) dec_share(fp->obj.lockid);
#endif
FREE_NAMBUF();
}
if (res != FR_OK) fp->obj.fs = 0;
#if FF_FS_REENTRANT
LEAVE_FF(fs_bak, res);
#else
LEAVE_FF(fs, res);
#endif
}
FRESULT f_read (
FIL* fp,
void* buff,
UINT btr,
UINT* br
)
{
FRESULT res;
FATFS *fs;
DWORD clst;
LBA_t sect;
FSIZE_t remain;
UINT rcnt, cc, csect;
BYTE *rbuff = (BYTE*)buff;
#ifndef __LITEOS_M__
UINT copy_ret;
#endif
*br = 0;
res = validate(&fp->obj, &fs);
if (res != FR_OK || (res = (FRESULT)fp->err) != FR_OK) LEAVE_FF(fs, res);
if (!(fp->flag & FA_READ)) LEAVE_FF(fs, FR_NO_EPERM);
remain = fp->obj.objsize - fp->fptr;
if (btr > remain) btr = (UINT)remain;
for ( ; btr > 0; btr -= rcnt, *br += rcnt, rbuff += rcnt, fp->fptr += rcnt) {
if (fp->fptr % SS(fs) == 0) {
csect = (UINT)(fp->fptr / SS(fs) & (fs->csize - 1));
if (csect == 0) {
if (fp->fptr == 0) {
clst = fp->obj.sclust;
} else {
#if FF_USE_FASTSEEK
if (fp->cltbl) {
clst = clmt_clust(fp, fp->fptr);
} else
#endif
{
clst = get_fat(&fp->obj, fp->clust);
}
}
if (clst < 2) ABORT(fs, FR_INT_ERR);
if (clst == 0xFFFFFFFF) ABORT(fs, FR_DISK_ERR);
fp->clust = clst;
}
sect = clst2sect(fs, fp->clust);
if (sect == 0) ABORT(fs, FR_INT_ERR);
sect += csect;
cc = btr / SS(fs);
if (cc > 0) {
if (csect + cc > fs->csize) {
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
#if FF_FS_TINY
if (fs->wflag && fs->winsect - sect < cc) {
#ifndef __LITEOS_M__
copy_ret = LOS_CopyFromKernel(rbuff + ((fs->winsect - sect) * SS(fs)), SS(fs), fs->win, SS(fs));
if (copy_ret != EOK) ABORT(fs, FR_INVALID_PARAMETER);
#else
mem_cpy(rbuff + ((fs->winsect - sect) * SS(fs)), fs->win, SS(fs));
#endif
}
#else
if ((fp->flag & FA_DIRTY) && fp->sect - sect < cc) {
#ifndef __LITEOS_M__
copy_ret = LOS_CopyFromKernel(rbuff + ((fp->sect - sect) * SS(fs)), SS(fs), fp->buf, SS(fs));
if (copy_ret != EOK) ABORT(fs, FR_INVALID_PARAMETER);
#else
mem_cpy(rbuff + ((fp->sect - sect) * SS(fs)), fp->buf, SS(fs));
#endif
}
#endif
#endif
rcnt = SS(fs) * cc;
continue;
}
#if !FF_FS_TINY
if (fp->sect != sect) {
#if !FF_FS_READONLY
if (fp->flag & FA_DIRTY) {
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);
}
#endif
fp->sect = sect;
}
rcnt = SS(fs) - (UINT)fp->fptr % SS(fs);
if (rcnt > btr) rcnt = btr;
#if FF_FS_TINY
if (move_window(fs, fp->sect) != FR_OK) ABORT(fs, FR_DISK_ERR);
copy_ret = LOS_CopyFromKernel(rbuff, rcnt, fs->win + fp->fptr % SS(fs), rcnt);
if (copy_ret != EOK) ABORT(fs, FR_INVALID_PARAMETER);
#else
#ifndef __LITEOS_M__
copy_ret = LOS_CopyFromKernel(rbuff, rcnt, fp->buf + fp->fptr % SS(fs), rcnt);
if (copy_ret != EOK) ABORT(fs, FR_INVALID_PARAMETER);
#else
mem_cpy(rbuff, fp->buf + fp->fptr % SS(fs), rcnt);
#endif
#endif
}
LEAVE_FF(fs, FR_OK);
}
#if !FF_FS_READONLY
FRESULT f_write (
FIL* fp,
const void* buff,
UINT btw,
UINT* bw
)
{
FRESULT res;
FATFS *fs;
DWORD clst;
LBA_t sect;
UINT wcnt, cc, csect;
const BYTE *wbuff = (const BYTE*)buff;
#ifndef __LITEOS_M__
UINT copy_ret;
#endif
*bw = 0;
res = validate(&fp->obj, &fs);
if (res != FR_OK || (res = (FRESULT)fp->err) != FR_OK) LEAVE_FF(fs, res);
if (!(fp->flag & FA_WRITE)) LEAVE_FF(fs, FR_NO_EPERM);
if ((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) {
if (fp->fptr % SS(fs) == 0) {
csect = (UINT)(fp->fptr / SS(fs)) & (fs->csize - 1);
if (csect == 0) {
if (fp->fptr == 0) {
clst = fp->obj.sclust;
if (clst == 0) {
clst = create_chain(&fp->obj, 0);
}
} else {
#if FF_USE_FASTSEEK
if (fp->cltbl) {
clst = clmt_clust(fp, fp->fptr);
} else
#endif
{
clst = create_chain(&fp->obj, fp->clust);
}
}
if (clst == 0) {
res = FR_NO_SPACE_LEFT;
break;
}
if (clst == 1) ABORT(fs, FR_INT_ERR);
if (clst == 0xFFFFFFFF) ABORT(fs, FR_DISK_ERR);
fp->clust = clst;
if (fp->obj.sclust == 0) fp->obj.sclust = clst;
}
#if FF_FS_TINY
if (fs->winsect == fp->sect && sync_window(fs) != FR_OK) ABORT(fs, FR_DISK_ERR);
#else
if (fp->flag & FA_DIRTY) {
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);
if (sect == 0) ABORT(fs, FR_INT_ERR);
sect += csect;
cc = btw / SS(fs);
if (cc > 0) {
if (csect + cc > fs->csize) {
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) {
copy_ret = LOS_CopyToKernel(fs->win, SS(fs), wbuff + ((fs->winsect - sect) * SS(fs)), SS(fs));
if (copy_ret != EOK) ABORT(fs, FR_INVALID_PARAMETER);
fs->wflag = 0;
}
#else
if (fp->sect - sect < cc) {
#ifndef __LITEOS_M__
copy_ret = LOS_CopyToKernel(fp->buf, SS(fs), wbuff + ((fp->sect - sect) * SS(fs)), SS(fs));
if (copy_ret != EOK) ABORT(fs, FR_INVALID_PARAMETER);
#else
mem_cpy(fp->buf, wbuff + ((fp->sect - sect) * SS(fs)), SS(fs));
#endif
fp->flag &= (BYTE)~FA_DIRTY;
}
#endif
#endif
wcnt = SS(fs) * cc;
continue;
}
#if FF_FS_TINY
if (fp->fptr >= fp->obj.objsize) {
if (sync_window(fs) != FR_OK) ABORT(fs, FR_DISK_ERR);
fs->winsect = sect;
}
#else
if (fp->sect != sect &&
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);
if (wcnt > btw) wcnt = btw;
#if FF_FS_TINY
if (move_window(fs, fp->sect) != FR_OK) ABORT(fs, FR_DISK_ERR);
copy_ret = LOS_CopyToKernel(fs->win + fp->fptr % SS(fs), wcnt, wbuff, wcnt);
if (copy_ret != EOK) ABORT(fs, FR_INVALID_PARAMETER);
fs->wflag = 1;
#else
#ifndef __LITEOS_M__
copy_ret = LOS_CopyToKernel(fp->buf + fp->fptr % SS(fs), wcnt, wbuff, wcnt);
if (copy_ret != EOK) ABORT(fs, FR_INVALID_PARAMETER);
#else
mem_cpy(fp->buf + fp->fptr % SS(fs), wbuff, wcnt);
#endif
fp->flag |= FA_DIRTY;
#endif
}
fp->flag |= FA_MODIFIED;
LEAVE_FF(fs, res);
}
FRESULT f_sync (
FIL* fp
)
{
FRESULT res;
FATFS *fs;
DWORD tm;
BYTE *dir;
res = validate(&fp->obj, &fs);
if (res == FR_OK) {
if (fp->flag & FA_MODIFIED) {
#if !FF_FS_TINY
if (fp->flag & FA_DIRTY) {
if (disk_write(fs->pdrv, fp->buf, fp->sect, 1) != RES_OK) LEAVE_FF(fs, FR_DISK_ERR);
fp->flag &= (BYTE)~FA_DIRTY;
}
#endif
tm = GET_FATTIME();
res = move_window(fs, fp->dir_sect);
if (res == FR_OK) {
dir = fp->dir_ptr;
dir[DIR_Attr] |= AM_ARC;
st_clust(fp->obj.fs, dir, fp->obj.sclust);
st_dword(dir + DIR_FileSize, (DWORD)fp->obj.objsize);
if (SYSTEM_TIME_ENABLE == time_status) {
st_dword(dir + DIR_ModTime, tm);
} else if (SYSTEM_TIME_DISABLE == time_status) {
st_dword(dir + DIR_ModTime, 0);
}
st_word(dir + DIR_LstAccDate, 0);
#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
fs->wflag = 1;
#else
PARENTFS(fs)->wflag = 1;
#endif
res = sync_fs(fs);
fp->flag &= (BYTE)~FA_MODIFIED;
}
}
}
LEAVE_FF(fs, res);
}
#endif
FRESULT f_close (
FIL* fp
)
{
FRESULT res;
FATFS *fs;
#if !FF_FS_READONLY
res = f_sync(fp);
if (res == FR_OK || res == FR_DISK_ERR)
#endif
{
res = validate(&fp->obj, &fs);
if (res == FR_OK) {
#if FF_FS_LOCK
res = dec_share(fp->obj.lockid);
if (res == FR_OK) fp->obj.fs = 0;
#else
fp->obj.fs = 0;
#endif
#if FF_FS_REENTRANT
unlock_fs(fs, FR_OK);
#endif
}
}
return res;
}
#if FF_FS_RPATH >= 1
FRESULT f_chdrive (
const TCHAR* path
)
{
int vol;
vol = get_ldnumber(&path);
if (vol < 0) return FR_INVALID_DRIVE;
CurrVol = (BYTE)vol;
return FR_OK;
}
FRESULT f_chdir (
const TCHAR* path
)
{
#if FF_STR_VOLUME_ID == 2
UINT i;
#endif
FRESULT res;
DIR dj;
FATFS *fs;
DEF_NAMBUF
res = mount_volume(&path, &fs, 0);
if (res == FR_OK) {
dj.obj.fs = fs;
INIT_NAMBUF(fs);
res = follow_path(&dj, path);
if (res == FR_OK) {
if (dj.fn[NSFLAG] & NS_NONAME) {
fs->cdir = dj.obj.sclust;
} else {
if (dj.obj.attr & AM_DIR) {
fs->cdir = ld_clust(fs, dj.dir);
} else {
res = FR_NO_PATH;
}
}
}
FREE_NAMBUF();
if (res == FR_NO_FILE) res = FR_NO_PATH;
#if FF_STR_VOLUME_ID == 2
if (res == FR_OK) {
for (i = FF_VOLUMES - 1; i && fs != FatFs[i]; i--) ;
CurrVol = (BYTE)i;
}
#endif
}
LEAVE_FF(fs, res);
}
#if FF_FS_RPATH >= 2
FRESULT f_getcwd (
TCHAR* buff,
UINT len
)
{
FRESULT res;
DIR dj;
FATFS *fs;
UINT i, n;
DWORD ccl;
TCHAR *tp = buff;
#if FF_VOLUMES >= 2
UINT vl;
#if FF_STR_VOLUME_ID
const char *vp;
#endif
#endif
FILINFO fno;
DEF_NAMBUF
buff[0] = 0;
res = mount_volume((const TCHAR**)&buff, &fs, 0);
if (res == FR_OK) {
dj.obj.fs = fs;
INIT_NAMBUF(fs);
i = len;
dj.obj.sclust = fs->cdir;
while ((ccl = dj.obj.sclust) != 0) {
res = dir_sdi(&dj, 1 * SZDIRE);
if (res != FR_OK) break;
res = move_window(fs, dj.sect);
if (res != FR_OK) break;
dj.obj.sclust = ld_clust(fs, dj.dir);
res = dir_sdi(&dj, 0);
if (res != FR_OK) break;
do {
res = DIR_READ_FILE(&dj);
if (res != FR_OK) break;
if (ccl == ld_clust(fs, dj.dir)) break;
res = dir_next(&dj, 0);
} while (res == FR_OK);
if (res == FR_NO_FILE) res = FR_INT_ERR;
if (res != FR_OK) break;
get_fileinfo(&dj, &fno);
for (n = 0; fno.fname[n]; n++) ;
if (i < n + 1) {
res = FR_NOT_ENOUGH_CORE; break;
}
while (n) buff[--i] = fno.fname[--n];
buff[--i] = '/';
}
if (res == FR_OK) {
if (i == len) buff[--i] = '/';
#if FF_VOLUMES >= 2
vl = 0;
#if FF_STR_VOLUME_ID >= 1
for (n = 0, vp = (const char*)VolumeStr[CurrVol]; vp[n]; n++) ;
if (i >= n + 2) {
if (FF_STR_VOLUME_ID == 2) *tp++ = (TCHAR)'/';
for (vl = 0; vl < n; *tp++ = (TCHAR)vp[vl], vl++) ;
if (FF_STR_VOLUME_ID == 1) *tp++ = (TCHAR)':';
vl++;
}
#else
if (i >= 3) {
*tp++ = (TCHAR)'0' + CurrVol;
*tp++ = (TCHAR)':';
vl = 2;
}
#endif
if (vl == 0) res = FR_NOT_ENOUGH_CORE;
#endif
if (res == FR_OK) {
do {
*tp++ = buff[i++];
} while (i < len);
}
}
FREE_NAMBUF();
}
*tp = 0;
LEAVE_FF(fs, res);
}
#endif
#endif
#if FF_FS_MINIMIZE <= 2
FRESULT f_lseek (
FIL* fp,
FSIZE_t ofs
)
{
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);
if (res == FR_OK) res = (FRESULT)fp->err;
if (res != FR_OK) LEAVE_FF(fs, res);
#if FF_USE_FASTSEEK
if (fp->cltbl) {
if (ofs == CREATE_LINKMAP) {
tbl = fp->cltbl;
tlen = *tbl++; ulen = 2;
cl = fp->obj.sclust;
if (cl != 0) {
do {
tcl = cl; ncl = 0; ulen += 2;
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) {
*tbl++ = ncl; *tbl++ = tcl;
}
} while (cl < fs->n_fatent);
}
*fp->cltbl = ulen;
if (ulen <= tlen) {
*tbl = 0;
} else {
res = FR_NOT_ENOUGH_CORE;
}
} else {
if (ofs > fp->obj.objsize) ofs = fp->obj.objsize;
fp->fptr = ofs;
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) {
#if !FF_FS_TINY
#if !FF_FS_READONLY
if (fp->flag & FA_DIRTY) {
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);
#endif
fp->sect = dsc;
}
}
}
} else
#endif
{
if (ofs > fp->obj.objsize && (FF_FS_READONLY || !(fp->flag & FA_WRITE))) {
ofs = fp->obj.objsize;
}
ifptr = fp->fptr;
fp->fptr = nsect = 0;
if (ofs > 0) {
bcs = (DWORD)fs->csize * SS(fs);
if (ifptr > 0 &&
(ofs - 1) / bcs >= (ifptr - 1) / bcs) {
fp->fptr = (ifptr - 1) & ~(FSIZE_t)(bcs - 1);
ofs -= fp->fptr;
clst = fp->clust;
} else {
clst = fp->obj.sclust;
#if !FF_FS_READONLY
if (clst == 0) {
clst = create_chain(&fp->obj, 0);
if (clst == 0) res = FR_NO_SPACE_LEFT;
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) {
ofs -= bcs; fp->fptr += bcs;
#if !FF_FS_READONLY
if (fp->flag & FA_WRITE) {
clst = create_chain(&fp->obj, clst);
if (clst == 0) {
ofs = 0;
res = FR_NO_SPACE_LEFT;
break;
}
} else
#endif
{
clst = get_fat(&fp->obj, clst);
}
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);
if (nsect == 0) ABORT(fs, FR_INT_ERR);
nsect += (DWORD)(ofs / SS(fs));
}
}
}
if (!FF_FS_READONLY && fp->fptr > fp->obj.objsize) {
fp->obj.objsize = fp->fptr;
fp->flag |= FA_MODIFIED;
}
if (fp->fptr % SS(fs) && nsect != fp->sect) {
#if !FF_FS_TINY
#if !FF_FS_READONLY
if (fp->flag & FA_DIRTY) {
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);
#endif
fp->sect = nsect;
}
}
LEAVE_FF(fs, res);
}
#if FF_FS_MINIMIZE <= 1
FRESULT f_opendir (
DIR* dp,
const TCHAR* path
)
{
FRESULT res;
FATFS *fs;
DEF_NAMBUF
if (!dp) return FR_INVALID_OBJECT;
res = mount_volume(&path, &fs, 0);
if (res == FR_OK) {
dp->obj.fs = fs;
INIT_NAMBUF(fs);
res = follow_path(dp, path);
if (res == FR_OK) {
if (!(dp->fn[NSFLAG] & NS_NONAME)) {
if (dp->obj.attr & AM_DIR) {
dp->obj.sclust = ld_clust(fs, dp->dir);
} else {
res = FR_NO_DIR;
}
}
if (res == FR_OK) {
dp->obj.id = fs->id;
res = dir_sdi(dp, 0);
#if FF_FS_LOCK
if (res == FR_OK) {
if (dp->obj.sclust != 0) {
dp->obj.lockid = inc_share(dp, 0);
if (!dp->obj.lockid) res = FR_TOO_MANY_OPEN_FILES;
} else {
dp->obj.lockid = 0;
}
}
#endif
}
}
FREE_NAMBUF();
if (res == FR_NO_FILE) res = FR_NO_PATH;
}
if (res != FR_OK) dp->obj.fs = 0;
LEAVE_FF(fs, res);
}
FRESULT f_closedir (
DIR *dp
)
{
FRESULT res;
FATFS *fs;
res = validate(&dp->obj, &fs);
if (res == FR_OK) {
#if FF_FS_LOCK
if (dp->obj.lockid) res = dec_share(dp->obj.lockid);
if (res == FR_OK) dp->obj.fs = 0;
#else
dp->obj.fs = 0;
#endif
#if FF_FS_REENTRANT
unlock_fs(fs, FR_OK);
#endif
}
return res;
}
FRESULT f_readdir (
DIR* dp,
FILINFO* fno
)
{
FRESULT res;
FATFS *fs;
DEF_NAMBUF
res = validate(&dp->obj, &fs);
if (res == FR_OK) {
if (!fno) {
res = dir_sdi(dp, 0);
} else {
INIT_NAMBUF(fs);
res = DIR_READ_FILE(dp);
if (res == FR_NO_FILE) res = FR_OK;
if (res == FR_OK) {
get_fileinfo(dp, fno);
res = dir_next(dp, 0);
if (res == FR_NO_FILE) res = FR_OK;
}
FREE_NAMBUF();
}
}
LEAVE_FF(fs, res);
}
#if FF_USE_FIND
FRESULT f_findnext (
DIR* dp,
FILINFO* fno
)
{
FRESULT res;
for (;;) {
res = f_readdir(dp, fno);
if (res != FR_OK || !fno || !fno->fname[0]) break;
if (pattern_match(dp->pat, fno->fname, 0, FIND_RECURS)) break;
#if FF_USE_LFN && FF_USE_FIND == 2
if (pattern_match(dp->pat, fno->altname, 0, FIND_RECURS)) break;
#endif
}
return res;
}
FRESULT f_findfirst (
DIR* dp,
FILINFO* fno,
const TCHAR* path,
const TCHAR* pattern
)
{
FRESULT res;
dp->pat = pattern;
res = f_opendir(dp, path);
if (res == FR_OK) {
res = f_findnext(dp, fno);
}
return res;
}
#endif
#if FF_FS_MINIMIZE == 0
FRESULT f_stat (
const TCHAR* path,
FILINFO* fno
)
{
FRESULT res;
DIR dj;
DEF_NAMBUF
res = mount_volume(&path, &dj.obj.fs, 0);
if (res == FR_OK) {
INIT_NAMBUF(dj.obj.fs);
res = follow_path(&dj, path);
if (res == FR_OK) {
if (dj.fn[NSFLAG] & NS_NONAME) {
res = FR_INVALID_NAME;
} else {
if (fno) get_fileinfo(&dj, fno);
}
}
FREE_NAMBUF();
}
LEAVE_FF(dj.obj.fs, res);
}
FRESULT fat_count_free_entries(
DWORD *nclst,
FATFS *fs
)
{
DWORD nfree, clst, stat;
LBA_t sect;
UINT i;
FFOBJID obj;
FRESULT res = FR_OK;
nfree = 0;
if (fs->fs_type == FS_FAT12) {
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 {
clst = fs->n_fatent;
sect = fs->fatbase;
i = 0;
do {
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);
}
*nclst = nfree;
fs->free_clst = nfree;
fs->fsi_flag |= 1;
return res;
}
#if !FF_FS_READONLY
FRESULT f_getfree (
const TCHAR* path,
DWORD* nclst,
FATFS** fatfs
)
{
FRESULT res;
FATFS *fs;
res = mount_volume(&path, &fs, 0);
if (res == FR_OK) {
*fatfs = fs;
if (fs->free_clst <= fs->n_fatent - 2) {
*nclst = fs->free_clst;
} else {
res = fat_count_free_entries(nclst, fs);
}
}
LEAVE_FF(fs, res);
}
FRESULT f_getclustinfo(
FIL* fp,
DWORD* fclust,
DWORD* fcount
)
{
UINT count = 0;
FATFS *fs;
FRESULT ret;
ret = validate(&fp->obj,&fs);
if (ret != FR_OK) LEAVE_FF(fs,ret);
count = get_clustinfo(fp, fclust);
if (count == 0xFFFFFFFF)
LEAVE_FF(fs,FR_DENIED);
*fcount = count;
LEAVE_FF(fs,FR_OK);
}
FRESULT f_truncate (
FIL* fp,
FSIZE_t length
)
{
FRESULT res;
FATFS *fs;
DWORD n, tcl, val, count, fclust = 0, last_clust;
res = validate(&fp->obj, &fs);
if (res != FR_OK || (res = (FRESULT)fp->err) != FR_OK) LEAVE_FF(fs, res);
if (!(fp->flag & FA_WRITE)) LEAVE_FF(fs, FR_NO_EPERM);
if (fp->fptr <= fp->obj.objsize) {
if (fp->fptr == 0 && length == 0) {
res = remove_chain(&fp->obj, fp->obj.sclust, 0);
fp->obj.sclust = 0;
} else {
n = (DWORD)fs->csize * SS(fs);
tcl = (DWORD)(length / n) + ((length & (n - 1)) ? 1 : 0);
val = fp->obj.sclust;
last_clust = get_end_of_cluster(fs);
count = 0;
do {
fclust = val;
val = get_fat(&fp->obj, fclust);
count ++;
if (count == tcl)
break;
} while ((val != last_clust) && (val != 1) && (val != 0xFFFFFFFF));
res = FR_OK;
if (val == 0xFFFFFFFF) res = FR_DISK_ERR;
if (val == 1) res = FR_INT_ERR;
if (res == FR_OK && val < fs->n_fatent) {
res = remove_chain(&fp->obj, val, fclust);
}
}
if (res == FR_OK) {
#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
fs->last_clst = fclust;
#else
if (ISVIRPART(fs) && ISCHILD(fs))
fs->last_clst = fclust;
PARENTFS(fs)->last_clst = fclust;
#endif
fp->obj.objsize = length;
if (fp->fptr > length) {
fp->fptr = length;
fp->clust = fclust;
}
}
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);
}
FRESULT f_unlink (
const TCHAR* path
)
{
FRESULT res;
FATFS *fs;
DIR dj, sdj;
DWORD dclst = 0;
#if FF_FS_REENTRANT
FATFS *fs_bak;
#endif
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
DWORD rtclst = 0;
DWORD st_bak = 0;
#endif
#ifndef __LITEOS_M__
DWORD last_clust = 1;
#endif
DEF_NAMBUF
res = mount_volume(&path, &fs, FA_WRITE);
dj.obj.fs = fs;
#if FF_FS_REENTRANT
fs_bak = fs;
#endif
if (res == FR_OK) {
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
#if FF_FS_REENTRANT
if (ISCHILD(fs)) LEAVE_FF(fs_bak,FR_INVAILD_FATFS);
#else
if (ISCHILD(fs)) LEAVE_FF(fs,FR_INVAILD_FATFS);
#endif
if (ISVIRPART(fs)) {
res = follow_virentry(&dj.obj,path);
#if FF_FS_REENTRANT
if (res == FR_INT_ERR) LEAVE_FF(fs_bak,res);
#else
if (res == FR_INT_ERR) LEAVE_FF(fs,res);
#endif
if (res == FR_OK)
fs = dj.obj.fs;
}
#endif
INIT_NAMBUF(fs);
res = follow_path(&dj, path);
if (FF_FS_RPATH && res == FR_OK && (dj.fn[NSFLAG] & NS_DOT)) {
res = FR_INVALID_NAME;
}
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
if (res == FR_OK && ISVIRPART(fs)) {
dj.atrootdir = 0;rtclst = 2;
st_bak = PARENTFS(dj.obj.fs)->winsect;
last_clust = get_end_of_cluster(fs);
for (;;) {
#if FF_FS_REENTRANT
if (rtclst == 0xFFFFFFFF) LEAVE_FF(fs_bak,FR_DISK_ERR);
#else
if (rtclst == 0xFFFFFFFF) LEAVE_FF(fs,FR_DISK_ERR);
#endif
if (rtclst == last_clust) break;
#if FF_FS_REENTRANT
if (rtclst < 2 || rtclst >= fs->n_fatent) LEAVE_FF(fs_bak,FR_INT_ERR);
if (rtclst == 0 || rtclst == 1) LEAVE_FF(fs_bak,FR_INT_ERR);
#else
if (rtclst < 2 || rtclst >= fs->n_fatent) LEAVE_FF(fs,FR_INT_ERR);
if (rtclst == 0 || rtclst == 1) LEAVE_FF(fs,FR_INT_ERR);
#endif
if (dj.clust == rtclst) {
dj.atrootdir = 1;
break;
}
rtclst = get_fat(&(dj.obj),rtclst);
}
if (dj.atrootdir == 1) {
if (ISCHILD(fs)) {
#if FF_FS_REENTRANT
LEAVE_FF(fs_bak,FR_DENIED);
#else
LEAVE_FF(fs,FR_DENIED);
#endif
}
}
res = move_window(dj.obj.fs,st_bak);
}
#endif
#if FF_FS_LOCK
if (res == FR_OK) res = chk_share(&dj, 2);
#endif
if (res == FR_OK) {
if (dj.fn[NSFLAG] & NS_NONAME) {
res = FR_INVALID_NAME;
} else {
if (dj.obj.attr & AM_RDO) {
res = FR_DENIED;
}
}
if (res == FR_OK) {
dclst = ld_clust(fs, dj.dir);
if (dj.obj.attr & AM_DIR) {
#if FF_FS_RPATH != 0
if (dclst == fs->cdir) {
res = FR_DENIED;
} else
#endif
{
sdj.obj.fs = fs;
sdj.obj.sclust = dclst;
res = dir_sdi(&sdj, 0);
if (res == FR_OK) {
res = DIR_READ_FILE(&sdj);
if (res == FR_OK) res = FR_NO_EMPTY_DIR;
if (res == FR_NO_FILE) res = FR_OK;
}
}
}
}
if (res == FR_OK) {
res = dir_remove(&dj);
if (res == FR_OK && dclst != 0) {
res = remove_chain(&dj.obj, dclst, 0);
}
if (res == FR_OK) res = sync_fs(fs);
}
}
FREE_NAMBUF();
}
#if FF_FS_REENTRANT
LEAVE_FF(fs_bak, res);
#else
LEAVE_FF(fs, res);
#endif
}
FRESULT f_mkdir (
const TCHAR* path
)
{
FRESULT res;
FATFS *fs;
DIR dj;
FFOBJID sobj;
#if FF_FS_REENTRANT
FATFS *fs_bak;
#endif
BYTE *dir;
UINT n;
DWORD dcl, pcl, tm;
QWORD dsc;
DEF_NAMBUF
res = mount_volume(&path, &fs, FA_WRITE);
dj.obj.fs = fs;
#if FF_FS_REENTRANT
fs_bak = fs;
#endif
dj.obj.sclust = 0;
if (res == FR_OK) {
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
#if FF_FS_REENTRANT
if (ISCHILD(fs)) LEAVE_FF(fs_bak,FR_INVAILD_FATFS);
#else
if (ISCHILD(fs)) LEAVE_FF(fs,FR_INVAILD_FATFS);
#endif
if (ISVIRPART(fs)) {
res = follow_virentry(&dj.obj,path);
#if FF_FS_REENTRANT
if (res == FR_INT_ERR) LEAVE_FF(fs_bak,res);
#else
if (res == FR_INT_ERR) LEAVE_FF(fs,res);
#endif
if (res == FR_OK)
fs = dj.obj.fs;
}
#endif
INIT_NAMBUF(fs);
res = follow_path(&dj, path);
if (res == FR_OK) res = FR_EXIST;
if (FF_FS_RPATH && res == FR_NO_FILE && (dj.fn[NSFLAG] & NS_DOT)) {
res = FR_INVALID_NAME;
}
if (res == FR_NO_FILE) {
sobj.fs = fs;
dcl = create_chain(&sobj, 0);
res = FR_OK;
if (dcl == 0) res = FR_NO_SPACE_LEFT;
if (dcl == 1) res = FR_INT_ERR;
if (dcl == 0xFFFFFFFF) res = FR_DISK_ERR;
if (res == FR_OK) res = sync_window(fs);
tm = GET_FATTIME();
if (res == FR_OK) {
dsc = clst2sect(fs, dcl);
#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
dir = fs->win;
#else
dir = PARENTFS(fs)->win;
#endif
mem_set(dir, 0, SS(fs));
mem_set(dir + DIR_Name, ' ', 11);
dir[DIR_Name] = '.';
dir[DIR_Attr] = AM_DIR;
if (SYSTEM_TIME_ENABLE == time_status) {
st_dword(dir + DIR_ModTime, tm);
} else if (SYSTEM_TIME_DISABLE == time_status) {
st_dword(dir + DIR_ModTime, 0);
}
st_clust(fs, dir, dcl);
mem_cpy(dir + SZDIRE, dir, SZDIRE);
dir[SZDIRE + 1] = '.'; pcl = dj.obj.sclust;
if (fs->fs_type == FS_FAT32 && pcl == fs->dirbase) pcl = 0;
st_clust(fs, dir + SZDIRE, pcl);
for (n = fs->csize; n; n--) {
#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
fs->winsect = dsc++;
fs->wflag = 1;
res = sync_window(fs);
if (res != FR_OK) break;
mem_set(dir, 0, SS(fs));
#else
PARENTFS(fs)->winsect = dsc++;
PARENTFS(fs)->wflag = 1;
res = sync_window(fs);
if (res != FR_OK) break;
mem_set(dir, 0, SS(fs));
#endif
}
}
if (res == FR_OK) {
res = dir_register(&dj);
}
if (res == FR_OK) {
dir = dj.dir;
if (SYSTEM_TIME_ENABLE == time_status) {
st_dword(dir + DIR_ModTime, tm);
}
else if (SYSTEM_TIME_DISABLE == time_status)
{
st_dword(dir + DIR_ModTime, 0);
}
st_clust(fs, dir, dcl);
dir[DIR_Attr] = AM_DIR;
#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
fs->wflag = 1;
#else
PARENTFS(fs)->wflag = 1;
#endif
if (res == FR_OK) {
res = sync_fs(fs);
}
} else {
remove_chain(&dj.obj, dcl, 0);
}
}
FREE_NAMBUF();
}
#if FF_FS_REENTRANT
LEAVE_FF(fs_bak, res);
#else
LEAVE_FF(fs, res);
#endif
}
FRESULT f_rename (
const TCHAR* path_old,
const TCHAR* path_new
)
{
FRESULT res;
FATFS *fs;
DIR djo, djn;
#if FF_FS_REENTRANT
FATFS *fs_bak;
#endif
BYTE buf[SZDIRE], *dir;
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
DWORD rtclst = 0;
DWORD st_bak = 0;
DWORD last_clust = 0;
#endif
LBA_t sect;
DEF_NAMBUF
get_ldnumber(&path_new);
res = mount_volume(&path_old, &fs, FA_WRITE);
#if FF_FS_REENTRANT
fs_bak = fs;
#endif
if (res == FR_OK) {
djo.obj.fs = fs;
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
if (ISCHILD(fs)) LEAVE_FF(fs,FR_INVAILD_FATFS);
if (ISVIRPART(fs)) {
res = follow_virentry(&djo.obj,path_old);
#if FF_FS_REENTRANT
if (res == FR_INT_ERR) LEAVE_FF(fs_bak,res);
#else
if (res == FR_INT_ERR) LEAVE_FF(fs,res);
#endif
if (res == FR_OK)
fs = djo.obj.fs;
}
#endif
INIT_NAMBUF(fs);
res = follow_path(&djo, path_old);
if (res == FR_OK && (djo.fn[NSFLAG] & (NS_DOT | NS_NONAME))) res = FR_INVALID_NAME;
#if FF_FS_LOCK
if (res == FR_OK) {
res = chk_share(&djo, 2);
}
#endif
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
if (res == FR_OK && ISVIRPART(fs)) {
djo.atrootdir = 0;rtclst = 2;
st_bak = PARENTFS(djo.obj.fs)->winsect;
last_clust = get_end_of_cluster(fs);
for (;;) {
#if FF_FS_REENTRANT
if (rtclst == 0xFFFFFFFF) LEAVE_FF(fs_bak,FR_DISK_ERR);
if (rtclst == last_clust) break;
if (rtclst < 2 || rtclst >= fs->n_fatent) LEAVE_FF(fs_bak,FR_INT_ERR);
if (rtclst == 0 || rtclst == 1) LEAVE_FF(fs_bak,FR_INT_ERR);
#else
if (rtclst == 0xFFFFFFFF) LEAVE_FF(fs,FR_DISK_ERR);
if (rtclst == last_clust) break;
if (rtclst < 2 || rtclst >= fs->n_fatent) LEAVE_FF(fs,FR_INT_ERR);
if (rtclst == 0 || rtclst == 1) LEAVE_FF(fs,FR_INT_ERR);
#endif
if (djo.clust == rtclst) {
djo.atrootdir = 1;
}
rtclst = get_fat(&(djo.obj),rtclst);
}
if (djo.atrootdir == 1) {
if (ISCHILD(fs)) {
#if FF_FS_REENTRANT
LEAVE_FF(fs_bak,FR_DENIED);
#else
LEAVE_FF(fs,FR_DENIED);
#endif
}
}
res = move_window(djo.obj.fs,st_bak);
}
#endif
if (res == FR_OK) {
mem_cpy(buf, djo.dir, SZDIRE);
mem_cpy(&djn, &djo, sizeof (DIR));
res = follow_path(&djn, path_new);
if (res == FR_OK) {
res = FR_EXIST;
}
if (res == FR_NO_FILE) {
res = dir_register(&djn);
if (res == FR_OK) {
dir = djn.dir;
mem_cpy(dir + 13, buf + 13, SZDIRE - 13);
dir[DIR_Attr] = buf[DIR_Attr];
if (!(dir[DIR_Attr] & AM_DIR)) dir[DIR_Attr] |= AM_ARC;
#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
fs->wflag = 1;
#else
PARENTFS(fs)->wflag = 1;
#endif
if ((dir[DIR_Attr] & AM_DIR) && djo.obj.sclust != djn.obj.sclust) {
sect = clst2sect(fs, ld_clust(fs, dir));
if (sect == 0) {
res = FR_INT_ERR;
} else {
#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
res = move_window(fs, sect);
dir = fs->win + SZDIRE * 1;
if (res == FR_OK && dir[1] == '.') {
st_clust(fs, dir, djn.obj.sclust);
fs->wflag = 1;
#else
res = move_window(fs, sect);
dir = PARENTFS(fs)->win + SZDIRE * 1;
if (res == FR_OK && dir[1] == '.') {
st_clust(fs, dir, djn.obj.sclust);
PARENTFS(fs)->wflag = 1;
#endif
}
}
}
}
}
if (res == FR_OK) {
res = dir_remove(&djo);
if (res == FR_OK) {
res = sync_fs(fs);
}
}
}
FREE_NAMBUF();
}
#if FF_FS_REENTRANT
LEAVE_FF(fs_bak, res);
#else
LEAVE_FF(fs, res);
#endif
}
#endif
#endif
#endif
#endif
#if FF_USE_CHMOD && !FF_FS_READONLY
FRESULT f_chmod (
const TCHAR* path,
BYTE attr,
BYTE mask
)
{
FRESULT res;
FATFS *fs;
DIR dj;
#if FF_FS_REENTRANT
FATFS *fs_bak;
#endif
DEF_NAMBUF
res = mount_volume(&path, &fs, FA_WRITE);
if (res == FR_OK) {
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
#if FF_FS_REENTRANT
if (ISCHILD(fs)) LEAVE_FF(fs_bak,FR_INVAILD_FATFS);
#else
if (ISCHILD(fs)) LEAVE_FF(fs,FR_INVAILD_FATFS);
#endif
if (ISVIRPART(fs)) {
res = follow_virentry(&dj.obj,path);
#if FF_FS_REENTRANT
if (res == FR_INT_ERR) LEAVE_FF(fs_bak,res);
#else
if (res == FR_INT_ERR) LEAVE_FF(fs,res);
#endif
if (res == FR_OK)
fs = dj.obj.fs;
}
#endif
INIT_NAMBUF(fs);
res = follow_path(&dj, path);
if (res == FR_OK && (dj.fn[NSFLAG] & (NS_DOT | NS_NONAME))) res = FR_INVALID_NAME;
if (res == FR_OK) {
mask &= AM_RDO|AM_HID|AM_SYS|AM_ARC;
dj.dir[DIR_Attr] = (attr & mask) | (dj.dir[DIR_Attr] & (BYTE)~mask);
#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
fs->wflag = 1;
#else
PARENTFS(fs)->wflag = 1;
#endif
if (res == FR_OK) {
res = sync_fs(fs);
}
}
FREE_NAMBUF();
}
#if FF_FS_REENTRANT
LEAVE_FF(fs_bak, res);
#else
LEAVE_FF(fs, res);
#endif
}
FRESULT f_utime (
const TCHAR* path,
const FILINFO* fno
)
{
FRESULT res;
FATFS *fs;
DIR dj;
DEF_NAMBUF
res = mount_volume(&path, &fs, FA_WRITE);
if (res == FR_OK) {
dj.obj.fs = fs;
INIT_NAMBUF(fs);
res = follow_path(&dj, path);
if (res == FR_OK && (dj.fn[NSFLAG] & (NS_DOT | NS_NONAME))) res = FR_INVALID_NAME;
if (res == FR_OK) {
st_dword(dj.dir + DIR_ModTime, (DWORD)fno->fdate << 16 | fno->ftime);
fs->wflag = 1;
if (res == FR_OK) {
res = sync_fs(fs);
}
}
FREE_NAMBUF();
}
LEAVE_FF(fs, res);
}
#endif
#if FF_USE_LABEL
FRESULT f_getlabel (
const TCHAR* path,
TCHAR* label,
DWORD* vsn
)
{
FRESULT res;
FATFS *fs;
DIR dj;
UINT si, di;
WCHAR wc;
res = mount_volume(&path, &fs, 0);
if (res == FR_OK && label) {
dj.obj.fs = fs; dj.obj.sclust = 0;
res = dir_sdi(&dj, 0);
if (res == FR_OK) {
res = DIR_READ_LABEL(&dj);
if (res == FR_OK) {
si = di = 0;
while (si < 11) {
wc = dj.dir[si++];
#if FF_USE_LFN && FF_LFN_UNICODE >= 1
if (dbc_1st((BYTE)wc) && si < 11) wc = wc << 8 | dj.dir[si++];
wc = ff_oem2uni(wc, CODEPAGE);
if (wc == 0) {
di = 0; break;
}
di += put_utf(wc, &label[di], 4);
#else
label[di++] = (TCHAR)wc;
#endif
}
do {
label[di] = 0;
if (di == 0) break;
} while (label[--di] == ' ');
}
}
if (res == FR_NO_FILE) {
label[0] = 0;
res = FR_OK;
}
}
if (res == FR_OK && vsn) {
res = move_window(fs, fs->volbase);
if (res == FR_OK) {
switch (fs->fs_type) {
case FS_FAT32:
di = BS_VolID32;
break;
default:
di = BS_VolID;
}
*vsn = ld_dword(fs->win + di);
}
}
LEAVE_FF(fs, res);
}
#if !FF_FS_READONLY
FRESULT set_volumn_label(FATFS *fs, const TCHAR *label)
{
FRESULT res;
DIR dj;
BYTE dirvn[22];
UINT di;
WCHAR wc;
static const char badchr[] = "\"*+,.:;<=>\?[]|\x7F";
#if FF_USE_LFN
DWORD dc;
#endif
memset(dirvn, ' ', 11);
di = 0;
while ((UINT)*label >= ' ') {
#if FF_USE_LFN
dc = tchar2uni(&label);
wc = (dc < 0x10000) ? ff_uni2oem(ff_wtoupper(dc), CODEPAGE) : 0;
#else
wc = (BYTE)*label++;
if (dbc_1st((BYTE)wc)) wc = dbc_2nd((BYTE)*label) ? wc << 8 | (BYTE)*label++ : 0;
if (IsLower(wc)) wc -= 0x20;
#if FF_CODE_PAGE == 0
if (ExCvt && wc >= 0x80) wc = ExCvt[wc - 0x80];
#elif FF_CODE_PAGE < 900
if (wc >= 0x80) wc = ExCvt[wc - 0x80];
#endif
#endif
if (wc == 0 || strchr(badchr + 0, (int)wc) || di >= (UINT)((wc >= 0x100) ? 10 : 11)) {
LEAVE_FF(fs, FR_INVALID_NAME);
}
if (wc >= 0x100) dirvn[di++] = (BYTE)(wc >> 8);
dirvn[di++] = (BYTE)wc;
}
if (dirvn[0] == DDEM) LEAVE_FF(fs, FR_INVALID_NAME);
while (di && dirvn[di - 1] == ' ') di--;
dj.obj.fs = fs; dj.obj.sclust = 0;
res = dir_sdi(&dj, 0);
if (res == FR_OK) {
res = DIR_READ_LABEL(&dj);
if (res == FR_OK) {
if (di != 0) {
mem_cpy(dj.dir, dirvn, 11);
} else {
dj.dir[DIR_Name] = DDEM;
}
fs->wflag = 1;
res = sync_fs(fs);
} else {
if (res == FR_NO_FILE) {
res = FR_OK;
if (di != 0) {
res = dir_alloc(&dj, 1);
if (res == FR_OK) {
mem_set(dj.dir, 0, SZDIRE);
dj.dir[DIR_Attr] = AM_VOL;
mem_cpy(dj.dir, dirvn, 11);
fs->wflag = 1;
res = sync_fs(fs);
}
}
}
}
}
return res;
}
FRESULT f_setlabel (
const TCHAR* label
)
{
FRESULT res;
FATFS *fs;
res = mount_volume(&label, &fs, FA_WRITE);
if (res != FR_OK) LEAVE_FF(fs, res);
res = set_volumn_label(fs, label);
LEAVE_FF(fs, res);
}
#endif
#endif
#if FF_USE_EXPAND && !FF_FS_READONLY
FRESULT f_expand (
FIL* fp,
FSIZE_t offset,
FSIZE_t fsz,
int opt
)
{
FRESULT res;
FATFS *fs;
DWORD n, clst, stcl, scl, ncl, tcl, lclst, count, fclust = 0;
DWORD clstbak = 0;
FSIZE_t exsz;
res = validate(&fp->obj, &fs);
if (res != FR_OK || (res = (FRESULT)fp->err) != FR_OK) LEAVE_FF(fs, res);
if (fsz == 0 || !(fp->flag & FA_WRITE)) LEAVE_FF(fs, FR_DENIED);
n = (DWORD)fs->csize * SS(fs);
count = 0;
if (fp->obj.sclust != 0) {
count = get_clustinfo(fp, &fclust);
}
if (offset + fsz <= n * count) LEAVE_FF(fs, FR_OK);
exsz = offset + fsz - n * count;
tcl = (DWORD)(exsz / n) + ((exsz & (n - 1)) ? 1 : 0);
stcl = fs->last_clst; lclst = 0;
#ifdef LOSCFG_FS_FAT_VIRTUAL_PARTITION
if (ISVIRPART(fs)) {
if (stcl < fs->st_clst || stcl >= fs->st_clst + fs->ct_clst) stcl = fs->st_clst;
scl = stcl; ncl = 0; clst = stcl + 1;
for (;;) {
n = get_fat(&fp->obj, clst);
if (n == 1) { res = FR_INT_ERR; break; }
if (n == 0xFFFFFFFF) { res = FR_DISK_ERR; break; }
if (n == 0) {
if (clstbak != 0) {
res = put_fat(fs, clstbak, clst);
if (res != FR_OK)
break;
} else {
scl = clst;
}
clstbak = clst;
if (++ncl == tcl) {
res = put_fat(fs, clst, 0xFFFFFFFF);
break;
}
}
if (clst == stcl) {
res = FR_DENIED;
break;
}
if (++clst >= fs->st_clst + fs->ct_clst) clst = fs->st_clst;
}
} else
#endif
{
if (stcl < 2 || stcl >= fs->n_fatent) stcl = 2;
scl = stcl; ncl = 0; clst = stcl + 1;
for (;;) {
n = get_fat(&fp->obj, clst);
if (n == 1) { res = FR_INT_ERR; break; }
if (n == 0xFFFFFFFF) { res = FR_DISK_ERR; break; }
if (n == 0) {
if (clstbak != 0) {
res = put_fat(fs, clstbak, clst);
if (res != FR_OK) break;
} else {
scl = clst;
}
clstbak = clst;
if (++ncl == tcl) {
res = put_fat(fs, clst, 0xFFFFFFFF);
break;
}
}
if (clst == stcl) {
res = FR_DENIED;
break;
}
if (++clst >= fs->n_fatent) clst = 2;
}
}
if (res == FR_OK) {
#ifndef LOSCFG_FS_FAT_VIRTUAL_PARTITION
fs->last_clst = lclst;
if (opt) {
if (fp->obj.sclust == 0) {
fp->obj.sclust = scl;
} else {
res = put_fat(fs, fclust, scl);
if (res != FR_OK) LEAVE_FF(fs, res);
}
fp->flag |= FA_MODIFIED;
if (fs->free_clst <= fs->n_fatent - 2) {
fs->free_clst -= tcl;
fs->fsi_flag |= 1;
}
}
#else
if (ISVIRPART(fs) && ISCHILD(fs))
fs->last_clst = lclst;
PARENTFS(fs)->last_clst = lclst;
if (opt) {
if (fp->obj.sclust == 0) {
fp->obj.sclust = scl;
} else {
res = put_fat(fs, fclust, scl);
if (res != FR_OK) LEAVE_FF(fs, res);
}
fp->flag |= FA_MODIFIED;
if (ISVIRPART(fs)) {
if (fs->free_clst <= fs->ct_clst && ISCHILD(fs))
fs->free_clst -= tcl;
if (PARENTFS(fs)->free_clst <= PARENTFS(fs)->n_fatent - 2) {
PARENTFS(fs)->free_clst -= tcl;
PARENTFS(fs)->fsi_flag |= 1;
}
} else {
if (fs->free_clst <= fs->n_fatent - 2) {
fs->free_clst -= tcl;
fs->fsi_flag |= 1;
}
}
}
#endif
} else {
clst = scl;
lclst = get_end_of_cluster(fs);
for (;;) {
n = get_fat(&fp->obj, clst);
if (n == 1 || n == 0) { res = FR_INT_ERR; break; }
if (n == 0xFFFFFFFF) { res = FR_DISK_ERR; break; }
res = put_fat(fs, clst, 0);
if (res != FR_OK) break;
if (n == lclst) break;
clst = n;
}
res = put_fat(fs, fclust, 0xFFFFFFFF);
}
LEAVE_FF(fs, res);
}
#endif
#if FF_USE_FORWARD
FRESULT f_forward (
FIL* fp,
UINT (*func)(const BYTE*,UINT),
UINT btf,
UINT* bf
)
{
FRESULT res;
FATFS *fs;
DWORD clst;
LBA_t sect;
FSIZE_t remain;
UINT rcnt, csect;
BYTE *dbuf;
*bf = 0;
res = validate(&fp->obj, &fs);
if (res != FR_OK || (res = (FRESULT)fp->err) != FR_OK) LEAVE_FF(fs, res);
if (!(fp->flag & FA_READ)) LEAVE_FF(fs, FR_NO_EPERM);
remain = fp->obj.objsize - fp->fptr;
if (btf > remain) btf = (UINT)remain;
for ( ; btf > 0 && (*func)(0, 0); fp->fptr += rcnt, *bf += rcnt, btf -= rcnt) {
csect = (UINT)(fp->fptr / SS(fs) & (fs->csize - 1));
if (fp->fptr % SS(fs) == 0) {
if (csect == 0) {
clst = (fp->fptr == 0) ?
fp->obj.sclust : get_fat(&fp->obj, fp->clust);
if (clst <= 1) ABORT(fs, FR_INT_ERR);
if (clst == 0xFFFFFFFF) ABORT(fs, FR_DISK_ERR);
fp->clust = clst;
}
}
sect = clst2sect(fs, fp->clust);
if (sect == 0) ABORT(fs, FR_INT_ERR);
sect += csect;
#if FF_FS_TINY
if (move_window(fs, sect) != FR_OK) ABORT(fs, FR_DISK_ERR);
dbuf = fs->win;
#else
if (fp->sect != sect) {
#if !FF_FS_READONLY
if (fp->flag & FA_DIRTY) {
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);
}
dbuf = fp->buf;
#endif
fp->sect = sect;
rcnt = SS(fs) - (UINT)fp->fptr % SS(fs);
if (rcnt > btf) rcnt = btf;
rcnt = (*func)(dbuf + ((UINT)fp->fptr % SS(fs)), rcnt);
if (rcnt == 0) ABORT(fs, FR_INT_ERR);
}
LEAVE_FF(fs, FR_OK);
}
#endif
#if !FF_FS_READONLY && FF_USE_MKFS
#define N_SEC_TRACK 63
static FRESULT create_partition (
BYTE drv,
const LBA_t plst[],
BYTE sys,
BYTE* buf
)
{
UINT i, cy;
LBA_t sz_drv;
DWORD sz_drv32, s_lba32, n_lba32;
BYTE *pte, hd, n_hd, sc, n_sc;
if (disk_ioctl(drv, GET_SECTOR_COUNT, &sz_drv) != RES_OK) return FR_DISK_ERR;
sz_drv32 = (DWORD)sz_drv;
n_sc = N_SEC_TRACK;
for (n_hd = 8; n_hd != 0 && sz_drv32 / n_hd / n_sc > 1024; n_hd *= 2) ;
if (n_hd == 0) n_hd = 255;
mem_set(buf, 0, FF_MAX_SS);
pte = buf + MBR_Table;
for (i = 0, s_lba32 = n_sc; i < 4 && s_lba32 != 0 && s_lba32 < sz_drv32; i++, s_lba32 += n_lba32) {
n_lba32 = (DWORD)plst[i];
if (n_lba32 <= 100) n_lba32 = (n_lba32 == 100) ? sz_drv32 : sz_drv32 / 100 * n_lba32;
if (s_lba32 + n_lba32 > sz_drv32 || s_lba32 + n_lba32 < s_lba32) n_lba32 = sz_drv32 - s_lba32;
if (n_lba32 == 0) break;
st_dword(pte + PTE_StLba, s_lba32);
st_dword(pte + PTE_SizLba, n_lba32);
pte[PTE_System] = sys;
cy = (UINT)(s_lba32 / n_sc / n_hd);
hd = (BYTE)(s_lba32 / n_sc % n_hd);
sc = (BYTE)(s_lba32 % n_sc + 1);
pte[PTE_StHead] = hd;
pte[PTE_StSec] = (BYTE)((cy >> 2 & 0xC0) | sc);
pte[PTE_StCyl] = (BYTE)cy;
cy = (UINT)((s_lba32 + n_lba32 - 1) / n_sc / n_hd);
hd = (BYTE)((s_lba32 + n_lba32 - 1) / n_sc % n_hd);
sc = (BYTE)((s_lba32 + n_lba32 - 1) % n_sc + 1);
pte[PTE_EdHead] = hd;
pte[PTE_EdSec] = (BYTE)((cy >> 2 & 0xC0) | sc);
pte[PTE_EdCyl] = (BYTE)cy;
pte += SZ_PTE;
}
st_word(buf + BS_55AA, 0xAA55);
if (disk_write(drv, buf, 0, 1) != RES_OK) return FR_DISK_ERR;
return FR_OK;
}
FRESULT f_mkfs (
const TCHAR* path,
const MKFS_PARM* opt,
void* work,
UINT len
)
{
static const WORD cst[] = {1, 4, 16, 64, 256, 512, 0};
static const WORD cst32[] = {1, 2, 4, 8, 16, 32, 0};
static const MKFS_PARM defopt = {FM_ANY, 0, 0, 0, 0};
BYTE fsopt, fsty, sys, pdrv, ipart;
BYTE *buf;
BYTE *pte;
#ifndef __LITEOS_M__
size_t ss;
#else
WORD ss;
#endif
DWORD sz_buf, sz_blk, n_clst, pau, nsect, n;
LBA_t sz_vol, b_vol, b_fat, b_data;
LBA_t sect, lba[2];
DWORD sz_rsv, sz_fat, sz_dir, sz_au;
UINT n_fat, n_root, i;
int vol;
DSTATUS ds;
FRESULT fr = FR_OK;
#if FF_MULTI_PARTITION
int extended_br;
int extended_pos = -1;
DWORD extended_base = 0;
DWORD extended_offset = 0;
BYTE* multi_buf = NULL;
int gpt_part = 0;
#endif
vol = get_ldnumber(&path);
if (vol < 0) return FR_INVALID_DRIVE;
if (FatFs[vol]) FatFs[vol]->fs_type = 0;
pdrv = LD2PD(vol);
ipart = LD2PT(vol);
ds = disk_initialize(pdrv);
if (ds & STA_NOINIT) return FR_NOT_READY;
if (ds & STA_PROTECT) return FR_WRITE_PROTECTED;
if (!opt) opt = &defopt;
sz_blk = opt->align;
if (sz_blk == 0) disk_ioctl(pdrv, GET_BLOCK_SIZE, &sz_blk);
if (sz_blk == 0 || sz_blk > 0x8000 || (sz_blk & (sz_blk - 1))) sz_blk = 1;
#if FF_MAX_SS != FF_MIN_SS
if (disk_ioctl(pdrv, GET_SECTOR_SIZE, &ss) != RES_OK) return FR_DISK_ERR;
if (ss > FF_MAX_SS || ss < FF_MIN_SS || (ss & (ss - 1))) return FR_DISK_ERR;
#else
ss = FF_MAX_SS;
#endif
fsopt = opt->fmt & (FM_ANY | FM_SFD);
n_fat = (opt->n_fat >= 1 && opt->n_fat <= 2) ? opt->n_fat : 1;
n_root = (opt->n_root >= 1 && opt->n_root <= 32768 && (opt->n_root % (ss / SZDIRE)) == 0) ? opt->n_root : 512;
n = opt->n_sect * ss;
sz_au = (n <= 0x1000000 && (n & (n - 1)) == 0) ? n : 0;
sz_au /= ss;
sz_buf = len / ss;
if (sz_buf == 0) return FR_NOT_ENOUGH_CORE;
buf = (BYTE*)work;
#if FF_MULTI_PARTITION
b_vol = sz_vol = 0;
if (ipart != 0) {
if (disk_read(pdrv, buf, 0, 1) != RES_OK) return FR_DISK_ERR;
if (ld_word(buf + BS_55AA) != 0xAA55) return FR_MKFS_ABORTED;
if (buf[MBR_Table + 4] != 0xEE) {
pte = buf + (MBR_Table + (ipart - 1) * SZ_PTE);
extended_br = ipart - 4;
if (extended_br > 0) {
for (i = 0; i < 4; i++) {
pte = &buf[MBR_Table + i * SZ_PTE];
if (pte[4] == 0x0F) extended_pos = i;
}
pte = &buf[MBR_Table + extended_pos * SZ_PTE];
extended_base = ld_dword(pte + 8);
#ifndef __LITEOS_M__
if (disk_raw_read(LD2DI(vol), buf, extended_base, 1) != RES_OK) return FR_DISK_ERR;
#else
if (disk_read(LD2PD(vol), buf, extended_base, 1) != RES_OK) return FR_DISK_ERR;
#endif
pte = &buf[MBR_Table];
for (; extended_br > 1; --extended_br) {
pte = &buf[MBR_Table];
extended_offset = ld_dword(pte + SZ_PTE + 8);
mem_set(buf, 0, len);
#ifndef __LITEOS_M__
if (disk_raw_read(LD2DI(vol), buf, extended_base + extended_offset, 1) != RES_OK) return FR_DISK_ERR;
#else
if (disk_read(LD2PD(vol), buf, extended_base + extended_offset, 1) != RES_OK) return FR_DISK_ERR;
#endif
}
}
if (!pte[4]) return FR_MKFS_ABORTED;
#ifdef __LITEOS_M__
b_vol = ld_dword(pte + PTE_StLba);
sz_vol = ld_dword(pte + PTE_SizLba);
#else
b_vol = LD2PS(vol);
sz_vol = LD2PC(vol);
#endif
} else {
gpt_part = 1;
b_vol = LD2PS(vol);
sz_vol = LD2PC(vol);
if (disk_read(pdrv, buf, b_vol, 1) != RES_OK) return FR_DISK_ERR;
if (ld_word(buf + BS_55AA) != 0xAA55) return FR_MKFS_ABORTED;
}
multi_buf = ff_memalloc(ss);
if (multi_buf == NULL)
return FR_NOT_ENOUGH_CORE;
mem_cpy(multi_buf, buf, ss);
if (!gpt_part)
if (!pte[4]) {fr = FR_MKFS_ABORTED; goto EXIT;}
} else
#endif
{
if (disk_ioctl(pdrv, GET_SECTOR_COUNT, &sz_vol) != RES_OK) {fr = FR_DISK_ERR; goto EXIT;}
b_vol = (fsopt & FM_SFD) ? 0 : 63; if (sz_vol < b_vol) {fr = FR_MKFS_ABORTED; goto EXIT;}
sz_vol -= b_vol;
}
if (sz_vol < 128) {fr = FR_MKFS_ABORTED; goto EXIT;}
do {
if (sz_au > 128) {fr = FR_INVALID_PARAMETER; goto EXIT;}
if (fsopt & FM_FAT32) {
if (!(fsopt & FM_FAT)) {
fsty = FS_FAT32; break;
}
}
if (!(fsopt & FM_FAT)) {fr = FR_INVALID_PARAMETER; goto EXIT;}
fsty = FS_FAT16;
} while (0);
do {
pau = sz_au;
if (fsty == FS_FAT32) {
if (pau == 0) {
n = (DWORD)sz_vol / 0x20000;
for (i = 0, pau = 1; cst32[i] && cst32[i] <= n; i++, pau <<= 1) ;
}
n_clst = (DWORD)sz_vol / pau;
sz_fat = (n_clst * 4 + 8 + ss - 1) / ss;
sz_rsv = 32;
sz_dir = 0;
if (n_clst <= MAX_FAT16 || n_clst > MAX_FAT32) {fr = FR_MKFS_ABORTED; goto EXIT;}
} else {
if (pau == 0) {
n = (DWORD)sz_vol / 0x1000;
for (i = 0, pau = 1; cst[i] && cst[i] <= n; i++, pau <<= 1) ;
}
n_clst = (DWORD)sz_vol / pau;
if (n_clst > MAX_FAT12) {
n = n_clst * 2 + 4;
} else {
fsty = FS_FAT12;
n = (n_clst * 3 + 1) / 2 + 3;
}
sz_fat = (n + ss - 1) / ss;
sz_rsv = 1;
sz_dir = (DWORD)n_root * SZDIRE / ss;
}
b_fat = b_vol + sz_rsv;
b_data = b_fat + sz_fat * n_fat + sz_dir;
n = (DWORD)(((b_data + sz_blk - 1) & ~(sz_blk - 1)) - b_data);
if (fsty == FS_FAT32) {
sz_rsv += n; b_fat += n;
} else {
if (n % n_fat) {
n--; sz_rsv++; b_fat++;
}
sz_fat += n / n_fat;
}
if (sz_vol < b_data + pau * 16 - b_vol) {
fr = FR_MKFS_ABORTED;
goto EXIT;
}
n_clst = ((DWORD)sz_vol - sz_rsv - sz_fat * n_fat - sz_dir) / pau;
if (fsty == FS_FAT32) {
if (n_clst <= MAX_FAT16) {
if (sz_au == 0 && (sz_au = pau / 2) != 0) continue;
{fr = FR_MKFS_ABORTED; goto EXIT;}
}
}
if (fsty == FS_FAT16) {
if (n_clst > MAX_FAT16) {
if (sz_au == 0 && (pau * 2) <= 64) {
sz_au = pau * 2; continue;
}
if ((fsopt & FM_FAT32)) {
fsty = FS_FAT32; continue;
}
if (sz_au == 0 && (sz_au = pau * 2) <= 128) continue;
{fr = FR_MKFS_ABORTED; goto EXIT;}
}
if (n_clst <= MAX_FAT12) {
if (sz_au == 0 && (sz_au = pau * 2) <= 128) continue;
{fr = FR_MKFS_ABORTED; goto EXIT;}
}
}
if (fsty == FS_FAT12 && n_clst > MAX_FAT12) {fr = FR_MKFS_ABORTED; goto EXIT;}
break;
} while (1);
#if FF_USE_TRIM
lba[0] = b_vol; lba[1] = b_vol + sz_vol - 1;
disk_ioctl(pdrv, CTRL_TRIM, lba);
#endif
mem_set(buf, 0, ss);
mem_cpy(buf + BS_JmpBoot, "\xEB\xFE\x90" "MSDOS5.0", 11);
st_word(buf + BPB_BytsPerSec, ss);
buf[BPB_SecPerClus] = (BYTE)pau;
st_word(buf + BPB_RsvdSecCnt, (WORD)sz_rsv);
buf[BPB_NumFATs] = (BYTE)n_fat;
st_word(buf + BPB_RootEntCnt, (WORD)((fsty == FS_FAT32) ? 0 : n_root));
if (sz_vol < 0x10000) {
st_word(buf + BPB_TotSec16, (WORD)sz_vol);
} else {
st_dword(buf + BPB_TotSec32, (DWORD)sz_vol);
}
buf[BPB_Media] = 0xF8;
st_word(buf + BPB_SecPerTrk, 63);
st_word(buf + BPB_NumHeads, 255);
st_dword(buf + BPB_HiddSec, (DWORD)b_vol);
if (fsty == FS_FAT32) {
st_dword(buf + BS_VolID32, GET_FATTIME());
st_dword(buf + BPB_FATSz32, sz_fat);
st_dword(buf + BPB_RootClus32, 2);
st_word(buf + BPB_FSInfo32, 1);
st_word(buf + BPB_BkBootSec32, 6);
buf[BS_DrvNum32] = 0x80;
buf[BS_BootSig32] = 0x29;
mem_cpy(buf + BS_VolLab32, "NO NAME " "FAT32 ", 19);
} else {
st_dword(buf + BS_VolID, GET_FATTIME());
st_word(buf + BPB_FATSz16, (WORD)sz_fat);
buf[BS_DrvNum] = 0x80;
buf[BS_BootSig] = 0x29;
mem_cpy(buf + BS_VolLab, "NO NAME " "FAT ", 19);
}
st_word(buf + BS_55AA, 0xAA55);
if (disk_write(pdrv, buf, b_vol, 1) != RES_OK) { fr = FR_DISK_ERR; goto EXIT; }
if (fsty == FS_FAT32) {
disk_write(pdrv, buf, b_vol + 6, 1);
mem_set(buf, 0, ss);
st_dword(buf + FSI_LeadSig, 0x41615252);
st_dword(buf + FSI_StrucSig, 0x61417272);
st_dword(buf + FSI_Free_Count, n_clst - 1);
st_dword(buf + FSI_Nxt_Free, 2);
st_word(buf + BS_55AA, 0xAA55);
disk_write(pdrv, buf, b_vol + 7, 1);
disk_write(pdrv, buf, b_vol + 1, 1);
}
mem_set(buf, 0, sz_buf * ss);
sect = b_fat;
for (i = 0; i < n_fat; i++) {
if (fsty == FS_FAT32) {
st_dword(buf + 0, 0xFFFFFFF8);
st_dword(buf + 4, 0xFFFFFFFF);
st_dword(buf + 8, 0x0FFFFFFF);
} else {
st_dword(buf + 0, (fsty == FS_FAT12) ? 0xFFFFF8 : 0xFFFFFFF8);
}
nsect = sz_fat;
do {
n = (nsect > sz_buf) ? sz_buf : nsect;
if (disk_write(pdrv, buf, sect, (UINT)n) != RES_OK) { fr = FR_DISK_ERR; goto EXIT; }
mem_set(buf, 0, ss);
sect += n; nsect -= n;
} while (nsect);
}
nsect = (fsty == FS_FAT32) ? pau : sz_dir;
do {
n = (nsect > sz_buf) ? sz_buf : nsect;
if (disk_write(pdrv, buf, sect, (UINT)n) != RES_OK) { fr = FR_DISK_ERR; goto EXIT; }
sect += n; nsect -= n;
} while (nsect);
if (fsty == FS_FAT32) {
sect = b_fat - 1;
mem_set(buf, 0, sz_buf * ss);
if (disk_write(pdrv, buf, sect, 1) != RES_OK) { fr = FR_DISK_ERR; goto EXIT; }
}
if (fsty == FS_FAT32) {
sys = ipart > 4 ? 0x0B : 0x0C;
} else if (sz_vol >= 0x10000) {
sys = 0x06;
} else if (fsty == FS_FAT16) {
sys = 0x04;
} else {
sys = 0x01;
}
#if FF_MULTI_PARTITION
if (ipart != 0) {
if (!gpt_part) {
if (ipart > 4) {
pte = &multi_buf[MBR_Table];
} else {
pte = &multi_buf[MBR_Table + (ipart - 1) * SZ_PTE];
}
n = (ipart > 4) ? extended_base + extended_offset : 0;
pte[4] = sys;
#ifndef __LITEOS_M__
if (disk_raw_write(LD2DI(vol), multi_buf, n, 1) != RES_OK) { fr = FR_DISK_ERR; goto EXIT; }
#else
if (disk_write(LD2PD(vol), multi_buf, n, 1) != RES_OK) { fr = FR_DISK_ERR; goto EXIT; }
#endif
} else {
b_vol = LD2PS(vol);
#ifndef __LITEOS_M__
if (disk_raw_read(LD2DI(vol), multi_buf, b_vol, 1) != RES_OK) { fr = FR_DISK_ERR; goto EXIT; }
#else
if (disk_read(LD2PD(vol), multi_buf, b_vol, 1) != RES_OK) { fr = FR_DISK_ERR; goto EXIT; }
#endif
pte = &multi_buf[MBR_Table];
pte[4] = sys;
#ifndef __LITEOS_M__
if (disk_raw_write(LD2DI(vol), multi_buf, b_vol, 1) != RES_OK) { fr = FR_DISK_ERR; goto EXIT; }
#else
if (disk_write(LD2PD(vol), multi_buf, b_vol, 1) != RES_OK) { fr = FR_DISK_ERR; goto EXIT; }
#endif
}
} else
#endif
{
if (!(fsopt & FM_SFD)) {
lba[0] = sz_vol, lba[1] = 0;
fr = create_partition(pdrv, lba, sys, buf);
if (fr != FR_OK) goto EXIT;
}
}
if (disk_ioctl(pdrv, CTRL_SYNC, 0) != RES_OK) { fr = FR_DISK_ERR; goto EXIT; }
#ifndef __LITEOS_M__
switch(fsty) {
case FS_FAT12:
PRINTK("format to FAT12, %u sectors per cluster.\n", pau);
break;
case FS_FAT16:
PRINTK("Format to FAT16, %u sectors per cluster.\n", pau);
break;
case FS_FAT32:
default:
PRINTK("Format to FAT32, %u sectors per cluster.\n", pau);
}
#endif
EXIT:
#if FF_MULTI_PARTITION
ff_memfree(multi_buf);
#endif
return fr;
}
#ifndef __LITEOS_M__
FRESULT _mkfs(los_part *partition, const MKFS_PARM* opt, BYTE *work, UINT len)
{
static const WORD cst[] = {1, 4, 16, 64, 256, 512, 0};
static const WORD cst32[] = {1, 2, 4, 8, 16, 32, 0};
static const MKFS_PARM defopt = {FM_ANY, 0, 0, 0, 0};
BYTE fsopt, fsty, sys, *buf, *pte, pdrv, ipart;
size_t ss;
DWORD sz_buf, sz_blk, n_clst, pau, nsect, n;
LBA_t sz_vol, b_vol, b_fat, b_data;
LBA_t sect, lba[2];
DWORD sz_rsv, sz_fat, sz_dir, sz_au;
UINT n_fat, n_root, i;
DSTATUS ds;
FRESULT fr = FR_OK;
#if FF_MULTI_PARTITION
int extended_br;
int extended_pos = -1;
DWORD extended_base = 0;
DWORD extended_offset = 0;
BYTE* multi_buf = NULL;
int gpt_part = 0;
#endif
pdrv = partition->part_id;
ipart = partition->part_no_mbr;
if (!opt) opt = &defopt;
ds = disk_initialize(pdrv);
if (ds & STA_NOINIT) return FR_NOT_READY;
if (ds & STA_PROTECT) return FR_WRITE_PROTECTED;
sz_blk = opt->align;
if (sz_blk == 0 && disk_ioctl(pdrv, GET_BLOCK_SIZE, &sz_blk) != RES_OK) sz_blk = 1;
if (sz_blk == 0 || sz_blk > 0x8000 || (sz_blk & (sz_blk - 1))) sz_blk = 1;
#if FF_MAX_SS != FF_MIN_SS
if (disk_ioctl(pdrv, GET_SECTOR_SIZE, &ss) != RES_OK) return FR_DISK_ERR;
if (ss > FF_MAX_SS || ss < FF_MIN_SS || (ss & (ss - 1))) return FR_DISK_ERR;
#else
ss = FF_MAX_SS;
#endif
fsopt = opt->fmt & (FM_ANY | FM_SFD);
n_fat = (opt->n_fat >= 1 && opt->n_fat <= 2) ? opt->n_fat : 1;
n_root = (opt->n_root >= 1 && opt->n_root <= 32768 && (opt->n_root % (ss / SZDIRE)) == 0) ? opt->n_root : 512;
n = opt->n_sect * ss;
sz_au = (n <= 0x1000000 && (n & (n - 1)) == 0) ? n : 0;
sz_au /= ss;
sz_buf = len / ss;
if (sz_buf == 0) return FR_NOT_ENOUGH_CORE;
buf = (BYTE *)work;
#if FF_MULTI_PARTITION
b_vol = sz_vol = 0;
if (ipart != 0) {
if (disk_read(pdrv, buf, 0, 1) != RES_OK) return FR_DISK_ERR;
if (ld_word(buf + BS_55AA) != 0xAA55) return FR_MKFS_ABORTED;
if (buf[MBR_Table + PTE_System] != GPT_PROTECTIVE_MBR) {
pte = buf + (MBR_Table + (ipart - 1) * SZ_PTE);
extended_br = ipart - MBR_PRIMARY_PART_NUM;
if (extended_br > 0) {
for (i = 0; i < MBR_PRIMARY_PART_NUM; i++) {
pte = &buf[MBR_Table + i * SZ_PTE];
if (pte[PTE_System] == EXTENDED_PARTITION_LBA) extended_pos = i;
}
pte = &buf[MBR_Table + extended_pos * SZ_PTE];
extended_base = ld_dword(pte + PTE_StLba);
if (disk_raw_read(partition->disk_id, buf, extended_base, 1) != RES_OK) {
return FR_DISK_ERR;
}
pte = &buf[MBR_Table];
for (; extended_br > 1; --extended_br) {
pte = &buf[MBR_Table];
extended_offset = ld_dword(pte + SZ_PTE + PTE_StLba);
mem_set(buf, 0, len);
if (disk_raw_read(partition->disk_id, buf, extended_base + extended_offset, 1) != RES_OK) {
return FR_DISK_ERR;
}
}
}
if (!pte[PTE_System]) return FR_MKFS_ABORTED;
} else {
gpt_part = 1;
b_vol = partition->sector_start;
if (disk_read(pdrv, buf, b_vol, 1) != RES_OK) return FR_DISK_ERR;
if (ld_word(buf + BS_55AA) != 0xAA55) return FR_MKFS_ABORTED;
}
multi_buf = ff_memalloc(ss);
if (multi_buf == NULL)
return FR_NOT_ENOUGH_CORE;
mem_cpy(multi_buf, buf, ss);
if (!gpt_part)
if (!pte[PTE_System]) {
fr = FR_MKFS_ABORTED;
goto EXIT;
}
b_vol = partition->sector_start;
sz_vol = partition->sector_count;
} else
#endif
{
if (disk_ioctl(pdrv, GET_SECTOR_COUNT, &sz_vol) != RES_OK) {fr = FR_DISK_ERR; goto EXIT;}
b_vol = (fsopt & FM_SFD) ? 0 : 63; if (sz_vol < b_vol) {fr = FR_MKFS_ABORTED; goto EXIT;}
sz_vol -= b_vol;
}
if (sz_vol < VOL_MIN_SIZE) {fr = FR_MKFS_ABORTED; goto EXIT;}
do {
if (sz_au > 128) {fr = FR_INVALID_PARAMETER; goto EXIT;}
if (fsopt & FM_FAT32) {
if (!(fsopt & FM_FAT)) {
fsty = FS_FAT32; break;
}
}
if (!(fsopt & FM_FAT)) {fr = FR_INVALID_PARAMETER; goto EXIT;}
fsty = FS_FAT16;
} while (0);
do {
pau = sz_au;
if (fsty == FS_FAT32) {
if (pau == 0) {
n = (DWORD)sz_vol / 0x20000;
for (i = 0, pau = 1; cst32[i] && cst32[i] <= n; i++, pau <<= 1);
}
n_clst = (DWORD)sz_vol / pau;
sz_fat = ((n_clst + FAT_RESERVED_NUM) * FAT32_ENTRY_SIZE + ss - 1) / ss;
sz_rsv = FAT32_RESERVED_SECTOR;
sz_dir = 0;
if (n_clst <= MAX_FAT16 || n_clst > MAX_FAT32) {fr = FR_MKFS_ABORTED; goto EXIT;}
} else {
if (pau == 0) {
n = (DWORD)sz_vol / 0x1000;
for (i = 0, pau = 1; cst[i] && cst[i] <= n; i++, pau <<= 1);
}
n_clst = (DWORD)sz_vol / pau;
if (n_clst > MAX_FAT12) {
n = (n_clst + FAT_RESERVED_NUM) * FAT16_ENTRY_SIZE;
} else {
fsty = FS_FAT12;
n = (n_clst * 3 + 1) / 2 + 3;
}
sz_fat = (n + ss - 1) / ss;
sz_rsv = FAT_RESERVED_SECTOR;
sz_dir = (DWORD)n_root * SZDIRE / ss;
}
b_fat = b_vol + sz_rsv;
b_data = b_fat + sz_fat * n_fat + sz_dir;
n = (DWORD)(((b_data + sz_blk - 1) & ~(sz_blk - 1)) - b_data);
if (fsty == FS_FAT32) {
sz_rsv += n; b_fat += n;
} else {
if (n % n_fat) {
n--; sz_rsv++; b_fat++;
}
sz_fat += n / n_fat;
}
if (sz_vol < b_data + pau * 16 - b_vol) {
fr = FR_MKFS_ABORTED;
goto EXIT;
}
n_clst = ((DWORD)sz_vol - sz_rsv - sz_fat * n_fat - sz_dir) / pau;
if (fsty == FS_FAT32) {
if (n_clst <= MAX_FAT16) {
if (sz_au == 0 && (sz_au = pau / 2) != 0) continue;
{fr = FR_MKFS_ABORTED; goto EXIT;}
}
}
if (fsty == FS_FAT16) {
if (n_clst > MAX_FAT16) {
if (sz_au == 0 && (pau * 2) <= FAT_MAX_CLUSTER_SIZE) {
sz_au = pau * 2; continue;
}
if ((fsopt & FM_FAT32)) {
fsty = FS_FAT32; continue;
}
if (sz_au == 0 && (sz_au = pau * 2) <= FAT32_MAX_CLUSTER_SIZE) continue;
{fr = FR_MKFS_ABORTED; goto EXIT;}
}
if (n_clst <= MAX_FAT12) {
if (sz_au == 0 && (sz_au = pau * 2) <= FAT32_MAX_CLUSTER_SIZE) continue;
{fr = FR_MKFS_ABORTED; goto EXIT;}
}
}
if (fsty == FS_FAT12 && n_clst > MAX_FAT12) {fr = FR_MKFS_ABORTED; goto EXIT;}
break;
} while (1);
#if FF_USE_TRIM
lba[0] = b_vol; lba[1] = b_vol + sz_vol - 1;
disk_ioctl(pdrv, CTRL_TRIM, lba);
#endif
mem_set(buf, 0, ss);
mem_cpy(buf + BS_JmpBoot, JUMP_CODE "MSDOS5.0", 11);
st_word(buf + BPB_BytsPerSec, ss);
buf[BPB_SecPerClus] = (BYTE)pau;
st_word(buf + BPB_RsvdSecCnt, (WORD)sz_rsv);
buf[BPB_NumFATs] = (BYTE)n_fat;
st_word(buf + BPB_RootEntCnt, (WORD)((fsty == FS_FAT32) ? 0 : n_root));
if (sz_vol < 0x10000) {
st_word(buf + BPB_TotSec16, (WORD)sz_vol);
} else {
st_dword(buf + BPB_TotSec32, (DWORD)sz_vol);
}
buf[BPB_Media] = 0xF8;
st_word(buf + BPB_SecPerTrk, 63);
st_word(buf + BPB_NumHeads, 255);
st_dword(buf + BPB_HiddSec, (DWORD)b_vol);
if (fsty == FS_FAT32) {
st_dword(buf + BS_VolID32, GET_FATTIME());
st_dword(buf + BPB_FATSz32, sz_fat);
st_dword(buf + BPB_RootClus32, 2);
st_word(buf + BPB_FSInfo32, 1);
st_word(buf + BPB_BkBootSec32, 6);
buf[BS_DrvNum32] = 0x80;
buf[BS_BootSig32] = 0x29;
mem_cpy(buf + BS_VolLab32, "NO NAME " "FAT32 ", 19);
} else {
st_dword(buf + BS_VolID, GET_FATTIME());
st_word(buf + BPB_FATSz16, (WORD)sz_fat);
buf[BS_DrvNum] = 0x80;
buf[BS_BootSig] = 0x29;
mem_cpy(buf + BS_VolLab, "NO NAME " "FAT ", 19);
}
st_word(buf + BS_55AA, 0xAA55);
if (disk_write(pdrv, buf, b_vol, 1) != RES_OK) { fr = FR_DISK_ERR; goto EXIT; }
if (fsty == FS_FAT32) {
disk_write(pdrv, buf, b_vol + 6, 1);
mem_set(buf, 0, ss);
st_dword(buf + FSI_LeadSig, 0x41615252);
st_dword(buf + FSI_StrucSig, 0x61417272);
st_dword(buf + FSI_Free_Count, n_clst - 1);
st_dword(buf + FSI_Nxt_Free, 2);
st_word(buf + BS_55AA, 0xAA55);
disk_write(pdrv, buf, b_vol + 7, 1);
disk_write(pdrv, buf, b_vol + 1, 1);
}
los_disk_cache_clear(pdrv);
mem_set(buf, 0, sz_buf * ss);
sect = b_fat;
for (i = 0; i < n_fat; i++) {
if (fsty == FS_FAT32) {
st_dword(buf + 0, 0xFFFFFFF8);
st_dword(buf + 4, DISK_ERROR);
st_dword(buf + 8, FAT32_END_OF_CLUSTER);
} else {
st_dword(buf + 0, (fsty == FS_FAT12) ? 0xFFFFF8 : 0xFFFFFFF8);
}
nsect = sz_fat;
do {
n = (nsect > sz_buf) ? sz_buf : nsect;
if (disk_write(pdrv, buf, sect, (UINT)n) != RES_OK) { fr = FR_DISK_ERR; goto EXIT; }
mem_set(buf, 0, ss);
sect += n;
nsect -= n;
} while (nsect);
}
nsect = (fsty == FS_FAT32) ? pau : sz_dir;
do {
n = (nsect > sz_buf) ? sz_buf : nsect;
if (disk_write(pdrv, buf, sect, (UINT)n) != RES_OK) { fr = FR_DISK_ERR; goto EXIT; }
sect += n;
nsect -= n;
} while (nsect);
if (fsty == FS_FAT32) {
sect = b_fat - 1;
mem_set(buf, 0, sz_buf * ss);
if (disk_write(pdrv, buf, sect, 1) != RES_OK) { fr = FR_DISK_ERR; goto EXIT; }
}
if (fsty == FS_FAT32) {
sys = ipart > 4 ? 0x0B : 0x0C;
} else {
if (sz_vol >= 0x10000) {
sys = FAT16B;
} else {
sys = (fsty == FS_FAT16) ? FAT16 : FAT12;
}
}
#if FF_MULTI_PARTITION
if (ipart != 0) {
if (!gpt_part) {
if (ipart > MBR_PRIMARY_PART_NUM) {
pte = &multi_buf[MBR_Table];
} else {
pte = &multi_buf[MBR_Table + (ipart - 1) * SZ_PTE];
}
n = (ipart > MBR_PRIMARY_PART_NUM) ? (extended_base + extended_offset) : 0;
pte[PTE_System] = sys;
if (disk_raw_write(partition->disk_id, multi_buf, n, 1) != RES_OK) {
fr = FR_DISK_ERR;
goto EXIT;
}
} else {
b_vol = partition->sector_start;
if (disk_raw_read(partition->disk_id, multi_buf, b_vol, 1) != RES_OK) {
fr = FR_DISK_ERR;
goto EXIT;
}
pte = &multi_buf[MBR_Table];
pte[PTE_System] = sys;
if (disk_raw_write(partition->disk_id, multi_buf, b_vol, 1) != RES_OK) {
fr = FR_DISK_ERR;
goto EXIT;
}
}
} else
#endif
{
if (!(fsopt & FM_SFD)) {
lba[0] = sz_vol, lba[1] = 0;
fr = create_partition(pdrv, lba, sys, buf);
if (fr != FR_OK) goto EXIT;
}
}
if (disk_ioctl(pdrv, CTRL_SYNC, 0) != RES_OK) { fr = FR_DISK_ERR; goto EXIT; }
switch (fsty) {
case FS_FAT12:
PRINTK("format to FAT12, %u sectors per cluster.\n", pau);
break;
case FS_FAT16:
PRINTK("Format to FAT16, %u sectors per cluster.\n", pau);
break;
case FS_FAT32:
PRINTK("Format to FAT32, %u sectors per cluster.\n", pau);
break;
default:
PRINTK("Unknown format.\n");
}
EXIT:
#if FF_MULTI_PARTITION
ff_memfree(multi_buf);
#endif
return fr;
}
#endif
#if FF_MULTI_PARTITION
FRESULT f_fdisk (
BYTE pdrv,
const DWORD szt[],
void* work
)
{
BYTE *buf = (BYTE*)work;
DSTATUS stat;
LBA_t ptbl[4] = {0};
int i = 0;;
FRESULT res;
stat = disk_initialize(pdrv);
if (stat & STA_NOINIT) return FR_NOT_READY;
if (stat & STA_PROTECT) return FR_WRITE_PROTECTED;
if (!buf) return FR_NOT_ENOUGH_CORE;
while (szt[i] != 0 && i < 4) {
ptbl[i] = szt[i];
i++;
}
res = create_partition(pdrv, ptbl, 0x07, buf);
LEAVE_MKFS(res);
}
#endif
#endif
#if FF_USE_STRFUNC
#if FF_USE_LFN && FF_LFN_UNICODE && (FF_STRF_ENCODE < 0 || FF_STRF_ENCODE > 3)
#error Wrong FF_STRF_ENCODE setting
#endif
TCHAR* f_gets (
TCHAR* buff,
int len,
FIL* fp
)
{
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
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
f_read(fp, s, 1, &rc);
if (rc != 1) break;
wc = s[0];
if (dbc_1st((BYTE)wc)) {
f_read(fp, s, 1, &rc);
if (rc != 1 || !dbc_2nd(s[0])) continue;
wc = wc << 8 | s[0];
}
dc = ff_oem2uni(wc, CODEPAGE);
if (dc == 0) continue;
#elif FF_STRF_ENCODE == 1 || FF_STRF_ENCODE == 2
f_read(fp, s, 2, &rc);
if (rc != 2) break;
dc = (FF_STRF_ENCODE == 1) ? ld_word(s) : s[0] << 8 | s[1];
if (IsSurrogateL(dc)) continue;
if (IsSurrogateH(dc)) {
f_read(fp, s, 2, &rc);
if (rc != 2) break;
wc = (FF_STRF_ENCODE == 1) ? ld_word(s) : s[0] << 8 | s[1];
if (!IsSurrogateL(wc)) continue;
dc = ((dc & 0x3FF) + 0x40) << 10 | (wc & 0x3FF);
}
#else
f_read(fp, s, 1, &rc);
if (rc != 1) break;
dc = s[0];
if (dc >= 0x80) {
ct = 0;
if ((dc & 0xE0) == 0xC0) {
dc &= 0x1F; ct = 1;
}
if ((dc & 0xF0) == 0xE0) {
dc &= 0x0F; ct = 2;
}
if ((dc & 0xF8) == 0xF0) {
dc &= 0x07; ct = 3;
}
if (ct == 0) continue;
f_read(fp, s, ct, &rc);
if (rc != ct) break;
rc = 0;
do {
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;
}
#endif
if (FF_USE_STRFUNC == 2 && dc == '\r') continue;
#if FF_LFN_UNICODE == 1 || FF_LFN_UNICODE == 3
if (FF_LFN_UNICODE == 1 && dc >= 0x10000) {
*p++ = (TCHAR)(0xD800 | ((dc >> 10) - 0x40)); nc++;
dc = 0xDC00 | (dc & 0x3FF);
}
*p++ = (TCHAR)dc; nc++;
if (dc == '\n') break;
#elif FF_LFN_UNICODE == 2
if (dc < 0x80) {
*p++ = (TCHAR)dc;
nc++;
if (dc == '\n') break;
} else if (dc < 0x800) {
*p++ = (TCHAR)(0xC0 | (dc >> 6 & 0x1F));
*p++ = (TCHAR)(0x80 | (dc >> 0 & 0x3F));
nc += 2;
} else if (dc < 0x10000) {
*p++ = (TCHAR)(0xE0 | (dc >> 12 & 0x0F));
*p++ = (TCHAR)(0x80 | (dc >> 6 & 0x3F));
*p++ = (TCHAR)(0x80 | (dc >> 0 & 0x3F));
nc += 3;
} else {
*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
len -= 1;
while (nc < len) {
f_read(fp, s, 1, &rc);
if (rc != 1) break;
dc = s[0];
if (FF_USE_STRFUNC == 2 && dc == '\r') continue;
*p++ = (TCHAR)dc; nc++;
if (dc == '\n') break;
}
#endif
*p = 0;
return nc ? buff : 0;
}
#if !FF_FS_READONLY
#include <stdarg.h>
#define SZ_PUTC_BUF 64
#define SZ_NUM_BUF 32
typedef struct {
FIL *fp;
int idx, nchr;
#if FF_USE_LFN && FF_LFN_UNICODE == 1
WCHAR hs;
#elif FF_USE_LFN && FF_LFN_UNICODE == 2
BYTE bs[4];
UINT wi, ct;
#endif
BYTE buf[SZ_PUTC_BUF];
} putbuff;
static void putc_bfd (putbuff* pb, TCHAR c)
{
UINT n;
int i, nc;
#if FF_USE_LFN && FF_LFN_UNICODE
WCHAR hs, wc;
#if FF_LFN_UNICODE == 2
DWORD dc;
const TCHAR* tp;
#endif
#endif
if (FF_USE_STRFUNC == 2 && c == '\n') {
putc_bfd(pb, '\r');
}
i = pb->idx;
if (i < 0) return;
nc = pb->nchr;
#if FF_USE_LFN && FF_LFN_UNICODE
#if FF_LFN_UNICODE == 1
if (IsSurrogateH(c)) {
pb->hs = c; return;
}
hs = pb->hs; pb->hs = 0;
if (hs != 0) {
if (!IsSurrogateL(c)) hs = 0;
} else {
if (IsSurrogateL(c)) return;
}
wc = c;
#elif FF_LFN_UNICODE == 2
for (;;) {
if (pb->ct == 0) {
pb->bs[pb->wi = 0] = (BYTE)c;
if ((BYTE)c < 0x80) break;
if (((BYTE)c & 0xE0) == 0xC0) pb->ct = 1;
if (((BYTE)c & 0xF0) == 0xE0) pb->ct = 2;
if (((BYTE)c & 0xF8) == 0xF0) pb->ct = 3;
return;
} else {
if (((BYTE)c & 0xC0) != 0x80) {
pb->ct = 0; continue;
}
pb->bs[++pb->wi] = (BYTE)c;
if (--pb->ct == 0) break;
return;
}
}
tp = (const TCHAR*)pb->bs;
dc = tchar2uni(&tp);
if (dc == 0xFFFFFFFF) return;
hs = (WCHAR)(dc >> 16);
wc = (WCHAR)dc;
#elif FF_LFN_UNICODE == 3
if (IsSurrogate(c) || c >= 0x110000) return;
if (c >= 0x10000) {
hs = (WCHAR)(0xD800 | ((c >> 10) - 0x40));
wc = 0xDC00 | (c & 0x3FF);
} else {
hs = 0;
wc = (WCHAR)c;
}
#endif
#if FF_STRF_ENCODE == 1
if (hs != 0) {
st_word(&pb->buf[i], hs);
i += 2;
nc++;
}
st_word(&pb->buf[i], wc);
i += 2;
#elif FF_STRF_ENCODE == 2
if (hs != 0) {
pb->buf[i++] = (BYTE)(hs >> 8);
pb->buf[i++] = (BYTE)hs;
nc++;
}
pb->buf[i++] = (BYTE)(wc >> 8);
pb->buf[i++] = (BYTE)wc;
#elif FF_STRF_ENCODE == 3
if (hs != 0) {
nc += 3;
hs = (hs & 0x3FF) + 0x40;
pb->buf[i++] = (BYTE)(0xF0 | hs >> 8);
pb->buf[i++] = (BYTE)(0x80 | (hs >> 2 & 0x3F));
pb->buf[i++] = (BYTE)(0x80 | (hs & 3) << 4 | (wc >> 6 & 0x0F));
pb->buf[i++] = (BYTE)(0x80 | (wc & 0x3F));
} else {
if (wc < 0x80) {
pb->buf[i++] = (BYTE)wc;
} else {
if (wc < 0x800) {
nc += 1;
pb->buf[i++] = (BYTE)(0xC0 | wc >> 6);
} else {
nc += 2;
pb->buf[i++] = (BYTE)(0xE0 | wc >> 12);
pb->buf[i++] = (BYTE)(0x80 | (wc >> 6 & 0x3F));
}
pb->buf[i++] = (BYTE)(0x80 | (wc & 0x3F));
}
}
#else
if (hs != 0) return;
wc = ff_uni2oem(wc, CODEPAGE);
if (wc == 0) return;
if (wc >= 0x100) {
pb->buf[i++] = (BYTE)(wc >> 8); nc++;
}
pb->buf[i++] = (BYTE)wc;
#endif
#else
pb->buf[i++] = (BYTE)c;
#endif
if (i >= (int)(sizeof pb->buf) - 4) {
f_write(pb->fp, pb->buf, (UINT)i, &n);
i = (n == (UINT)i) ? 0 : -1;
}
pb->idx = i;
pb->nchr = nc + 1;
}
static int putc_flush (putbuff* pb)
{
UINT nw;
if ( pb->idx >= 0
&& f_write(pb->fp, pb->buf, (UINT)pb->idx, &nw) == FR_OK
&& (UINT)pb->idx == nw) return pb->nchr;
return -1;
}
static void putc_init (putbuff* pb, FIL* fp)
{
mem_set(pb, 0, sizeof (putbuff));
pb->fp = fp;
}
int f_putc (
TCHAR c,
FIL* fp
)
{
putbuff pb;
putc_init(&pb, fp);
putc_bfd(&pb, c);
return putc_flush(&pb);
}
int f_puts (
const TCHAR* str,
FIL* fp
)
{
putbuff pb;
putc_init(&pb, fp);
while (*str) putc_bfd(&pb, *str++);
return putc_flush(&pb);
}
int f_printf (
FIL* fp,
const TCHAR* fmt,
...
)
{
va_list arp;
putbuff pb;
BYTE f, r;
UINT i, j, w;
DWORD v;
TCHAR c, d, str[32], *p;
putc_init(&pb, fp);
va_start(arp, fmt);
for (;;) {
c = *fmt++;
if (c == 0) break;
if (c != '%') {
putc_bfd(&pb, c);
continue;
}
w = f = 0;
c = *fmt++;
if (c == '0') {
f = 1; c = *fmt++;
} else {
if (c == '-') {
f = 2; c = *fmt++;
}
}
if (c == '*') {
w = va_arg(arp, int);
c = *fmt++;
} else {
while (IsDigit(c)) {
w = w * 10 + c - '0';
c = *fmt++;
}
}
if (c == 'l' || c == 'L') {
f |= 4; c = *fmt++;
}
if (c == 0) break;
d = c;
if (IsLower(d)) d -= 0x20;
switch (d) {
case 'S':
p = va_arg(arp, TCHAR*);
for (j = 0; p[j]; j++) ;
if (!(f & 2)) {
while (j++ < w) putc_bfd(&pb, ' ') ;
}
while (*p) putc_bfd(&pb, *p++) ;
while (j++ < w) putc_bfd(&pb, ' ') ;
continue;
case 'C':
putc_bfd(&pb, (TCHAR)va_arg(arp, int));
continue;
case 'B':
r = 2;
break;
case 'O':
r = 8;
break;
case 'D':
case 'U':
r = 10;
break;
case 'X':
r = 16;
break;
default:
putc_bfd(&pb, c); continue;
}
v = (f & 4) ? (DWORD)va_arg(arp, long) : ((d == 'D') ? (DWORD)(long)va_arg(arp, int) : (DWORD)va_arg(arp, unsigned int));
if (d == 'D' && (v & 0x80000000)) {
v = 0 - v;
f |= 8;
}
i = 0;
do {
d = (TCHAR)(v % r); v /= r;
if (d > 9) d += (c == 'x') ? 0x27 : 0x07;
str[i++] = d + '0';
} while (v && i < sizeof str / sizeof *str);
if (f & 8) str[i++] = '-';
j = i; d = (f & 1) ? '0' : ' ';
if (!(f & 2)) {
while (j++ < w) putc_bfd(&pb, d);
}
do {
putc_bfd(&pb, str[--i]);
} while (i);
while (j++ < w) putc_bfd(&pb, d);
}
va_end(arp);
return putc_flush(&pb);
}
#endif
#endif
int fatfs_get_vol(FATFS *fat)
{
int vol;
for (vol = 0; vol < FF_VOLUMES; vol ++) {
if (FatFs[vol] == fat)
return vol;
}
return -1;
}
void f_settimestatus(UINT status)
{
time_status = status;
}
FRESULT f_fcheckfat(DIR_FILE* dir_info)
{
FRESULT res;
FATFS *fs;
DWORD val = 0, tcl, clust_size;
res = validate(&(dir_info->f_dir.obj), &fs);
if (res == FR_OK) {
clust_size = (DWORD)fs->csize * SS(fs);
tcl = (DWORD)(dir_info->fno.fsize / clust_size) + ((dir_info->fno.fsize & (clust_size - 1)) ? 1 : 0);
if (dir_info->fno.fsize == 0) {
if (dir_info->fno.sclst != 0) {
#if !FF_FS_READONLY
res = remove_chain(&(dir_info->f_dir.obj), dir_info->fno.sclst, 0);
#else
res = FR_DENIED;
#endif
} else
res = FR_OK;
} else {
val = get_fat(&(dir_info->f_dir.obj), dir_info->fno.sclst + tcl - 1);
if (val == 0xFFFFFFFF) {
res = FR_DISK_ERR;
LEAVE_FF(fs, res);
}
if (val == 1) {
res = FR_INT_ERR;
LEAVE_FF(fs, res);
}
if (val == get_end_of_cluster(fs)) {
res = FR_OK;
LEAVE_FF(fs, res);
}
if (val < fs->n_fatent) {
#if !FF_FS_READONLY
res = remove_chain(&(dir_info->f_dir.obj), val, dir_info->fno.sclst + tcl - 1);
#else
res = FR_DENIED;
#endif
}
}
}
LEAVE_FF(fs, res);
}
#if FF_CODE_PAGE == 0
FRESULT f_setcp (
WORD cp
)
{
static const WORD validcp[22] = { 437, 720, 737, 771, 775, 850, 852, 855, 857, 860, 861, 862, 863, 864, 865, 866, 869, 932, 936, 949, 950, 0};
static const BYTE *const tables[22] = {Ct437, Ct720, Ct737, Ct771, Ct775, Ct850, Ct852, Ct855, Ct857, Ct860, Ct861, Ct862, Ct863, Ct864, Ct865, Ct866, Ct869, Dc932, Dc936, Dc949, Dc950, 0};
UINT i;
for (i = 0; validcp[i] != 0 && validcp[i] != cp; i++) ;
if (validcp[i] != cp) return FR_INVALID_PARAMETER;
CodePage = cp;
if (cp >= 900) {
ExCvt = 0;
DbcTbl = tables[i];
} else {
ExCvt = tables[i];
DbcTbl = 0;
}
return FR_OK;
}
#endif
