Mercurial > ~darius > hgwebdir.cgi > stm32temp

comparison fatfs/ff.h @ 49:ace431a0d0f5

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add SDIO code poached from STM. Use FatFS to read from SD card. LFN doesn't work reliably so it's disabled for now.
author Daniel O'Connor <darius@dons.net.au>
date Wed, 03 Apr 2013 23:34:20 +1030
parents
children
comparison
equal deleted inserted replaced
48:2f336d212c74 49:ace431a0d0f5
1 /*---------------------------------------------------------------------------/
2 / FatFs - FAT file system module include file R0.09b (C)ChaN, 2013
3 /----------------------------------------------------------------------------/
4 / FatFs module is a generic FAT file system module for small embedded systems.
5 / This is a free software that opened for education, research and commercial
6 / developments under license policy of following terms.
7 /
8 / Copyright (C) 2013, ChaN, all right reserved.
9 /
10 / * The FatFs module is a free software and there is NO WARRANTY.
11 / * No restriction on use. You can use, modify and redistribute it for
12 / personal, non-profit or commercial product UNDER YOUR RESPONSIBILITY.
13 / * Redistributions of source code must retain the above copyright notice.
14 /
15 /----------------------------------------------------------------------------*/
16
17 #ifndef _FATFS
18 #define _FATFS 82786 /* Revision ID */
19
20 #ifdef __cplusplus
21 extern "C" {
22 #endif
23
24 #include "integer.h" /* Basic integer types */
25 #include "ffconf.h" /* FatFs configuration options */
26
27 #if _FATFS != _FFCONF
28 #error Wrong configuration file (ffconf.h).
29 #endif
30
31
32
33 /* Definitions of volume management */
34
35 #if _MULTI_PARTITION /* Multiple partition configuration */
36 typedef struct {
37 BYTE pd; /* Physical drive number */
38 BYTE pt; /* Partition: 0:Auto detect, 1-4:Forced partition) */
39 } PARTITION;
40 extern PARTITION VolToPart[]; /* Volume - Partition resolution table */
41 #define LD2PD(vol) (VolToPart[vol].pd) /* Get physical drive number */
42 #define LD2PT(vol) (VolToPart[vol].pt) /* Get partition index */
43
44 #else /* Single partition configuration */
45 #define LD2PD(vol) (BYTE)(vol) /* Each logical drive is bound to the same physical drive number */
46 #define LD2PT(vol) 0 /* Always mounts the 1st partition or in SFD */
47
48 #endif
49
50
51
52 /* Type of path name strings on FatFs API */
53
54 #if _LFN_UNICODE /* Unicode string */
55 #if !_USE_LFN
56 #error _LFN_UNICODE must be 0 in non-LFN cfg.
57 #endif
58 #ifndef _INC_TCHAR
59 typedef WCHAR TCHAR;
60 #define _T(x) L ## x
61 #define _TEXT(x) L ## x
62 #endif
63
64 #else /* ANSI/OEM string */
65 #ifndef _INC_TCHAR
66 typedef char TCHAR;
67 #define _T(x) x
68 #define _TEXT(x) x
69 #endif
70
71 #endif
72
73
74
75 /* File system object structure (FATFS) */
76
77 typedef struct {
78 BYTE fs_type; /* FAT sub-type (0:Not mounted) */
79 BYTE drv; /* Physical drive number */
80 BYTE csize; /* Sectors per cluster (1,2,4...128) */
81 BYTE n_fats; /* Number of FAT copies (1,2) */
82 BYTE wflag; /* win[] dirty flag (1:must be written back) */
83 BYTE fsi_flag; /* fsinfo dirty flag (1:must be written back) */
84 WORD id; /* File system mount ID */
85 WORD n_rootdir; /* Number of root directory entries (FAT12/16) */
86 #if _MAX_SS != 512
87 WORD ssize; /* Bytes per sector (512, 1024, 2048 or 4096) */
88 #endif
89 #if _FS_REENTRANT
90 _SYNC_t sobj; /* Identifier of sync object */
91 #endif
92 #if !_FS_READONLY
93 DWORD last_clust; /* Last allocated cluster */
94 DWORD free_clust; /* Number of free clusters */
95 DWORD fsi_sector; /* fsinfo sector (FAT32) */
96 #endif
97 #if _FS_RPATH
98 DWORD cdir; /* Current directory start cluster (0:root) */
99 #endif
100 DWORD n_fatent; /* Number of FAT entries (= number of clusters + 2) */
101 DWORD fsize; /* Sectors per FAT */
102 DWORD volbase; /* Volume start sector */
103 DWORD fatbase; /* FAT start sector */
104 DWORD dirbase; /* Root directory start sector (FAT32:Cluster#) */
105 DWORD database; /* Data start sector */
106 DWORD winsect; /* Current sector appearing in the win[] */
107 BYTE win[_MAX_SS]; /* Disk access window for Directory, FAT (and Data on tiny cfg) */
108 } FATFS;
109
110
111
112 /* File object structure (FIL) */
113
114 typedef struct {
115 FATFS* fs; /* Pointer to the related file system object (**do not change order**) */
116 WORD id; /* Owner file system mount ID (**do not change order**) */
117 BYTE flag; /* File status flags */
118 BYTE pad1;
119 DWORD fptr; /* File read/write pointer (0ed on file open) */
120 DWORD fsize; /* File size */
121 DWORD sclust; /* File data start cluster (0:no data cluster, always 0 when fsize is 0) */
122 DWORD clust; /* Current cluster of fpter */
123 DWORD dsect; /* Current data sector of fpter */
124 #if !_FS_READONLY
125 DWORD dir_sect; /* Sector containing the directory entry */
126 BYTE* dir_ptr; /* Pointer to the directory entry in the window */
127 #endif
128 #if _USE_FASTSEEK
129 DWORD* cltbl; /* Pointer to the cluster link map table (null on file open) */
130 #endif
131 #if _FS_LOCK
132 UINT lockid; /* File lock ID (index of file semaphore table Files[]) */
133 #endif
134 #if !_FS_TINY
135 BYTE buf[_MAX_SS]; /* File data read/write buffer */
136 #endif
137 } FIL;
138
139
140
141 /* Directory object structure (DIR) */
142
143 typedef struct {
144 FATFS* fs; /* Pointer to the owner file system object (**do not change order**) */
145 WORD id; /* Owner file system mount ID (**do not change order**) */
146 WORD index; /* Current read/write index number */
147 DWORD sclust; /* Table start cluster (0:Root dir) */
148 DWORD clust; /* Current cluster */
149 DWORD sect; /* Current sector */
150 BYTE* dir; /* Pointer to the current SFN entry in the win[] */
151 BYTE* fn; /* Pointer to the SFN (in/out) {file[8],ext[3],status[1]} */
152 #if _USE_LFN
153 WCHAR* lfn; /* Pointer to the LFN working buffer */
154 WORD lfn_idx; /* Last matched LFN index number (0xFFFF:No LFN) */
155 #endif
156 } DIR;
157
158
159
160 /* File status structure (FILINFO) */
161
162 typedef struct {
163 DWORD fsize; /* File size */
164 WORD fdate; /* Last modified date */
165 WORD ftime; /* Last modified time */
166 BYTE fattrib; /* Attribute */
167 TCHAR fname[13]; /* Short file name (8.3 format) */
168 #if _USE_LFN
169 TCHAR* lfname; /* Pointer to the LFN buffer */
170 UINT lfsize; /* Size of LFN buffer in TCHAR */
171 #endif
172 } FILINFO;
173
174
175
176 /* File function return code (FRESULT) */
177
178 typedef enum {
179 FR_OK = 0, /* (0) Succeeded */
180 FR_DISK_ERR, /* (1) A hard error occurred in the low level disk I/O layer */
181 FR_INT_ERR, /* (2) Assertion failed */
182 FR_NOT_READY, /* (3) The physical drive cannot work */
183 FR_NO_FILE, /* (4) Could not find the file */
184 FR_NO_PATH, /* (5) Could not find the path */
185 FR_INVALID_NAME, /* (6) The path name format is invalid */
186 FR_DENIED, /* (7) Access denied due to prohibited access or directory full */
187 FR_EXIST, /* (8) Access denied due to prohibited access */
188 FR_INVALID_OBJECT, /* (9) The file/directory object is invalid */
189 FR_WRITE_PROTECTED, /* (10) The physical drive is write protected */
190 FR_INVALID_DRIVE, /* (11) The logical drive number is invalid */
191 FR_NOT_ENABLED, /* (12) The volume has no work area */
192 FR_NO_FILESYSTEM, /* (13) There is no valid FAT volume */
193 FR_MKFS_ABORTED, /* (14) The f_mkfs() aborted due to any parameter error */
194 FR_TIMEOUT, /* (15) Could not get a grant to access the volume within defined period */
195 FR_LOCKED, /* (16) The operation is rejected according to the file sharing policy */
196 FR_NOT_ENOUGH_CORE, /* (17) LFN working buffer could not be allocated */
197 FR_TOO_MANY_OPEN_FILES, /* (18) Number of open files > _FS_SHARE */
198 FR_INVALID_PARAMETER /* (19) Given parameter is invalid */
199 } FRESULT;
200
201
202
203 /*--------------------------------------------------------------*/
204 /* FatFs module application interface */
205
206 FRESULT f_mount (BYTE vol, FATFS* fs); /* Mount/Unmount a logical drive */
207 FRESULT f_open (FIL* fp, const TCHAR* path, BYTE mode); /* Open or create a file */
208 FRESULT f_read (FIL* fp, void* buff, UINT btr, UINT* br); /* Read data from a file */
209 FRESULT f_lseek (FIL* fp, DWORD ofs); /* Move file pointer of a file object */
210 FRESULT f_close (FIL* fp); /* Close an open file object */
211 FRESULT f_opendir (DIR* dj, const TCHAR* path); /* Open an existing directory */
212 FRESULT f_readdir (DIR* dj, FILINFO* fno); /* Read a directory item */
213 FRESULT f_stat (const TCHAR* path, FILINFO* fno); /* Get file status */
214 FRESULT f_write (FIL* fp, const void* buff, UINT btw, UINT* bw); /* Write data to a file */
215 FRESULT f_getfree (const TCHAR* path, DWORD* nclst, FATFS** fatfs); /* Get number of free clusters on the drive */
216 FRESULT f_truncate (FIL* fp); /* Truncate file */
217 FRESULT f_sync (FIL* fp); /* Flush cached data of a writing file */
218 FRESULT f_unlink (const TCHAR* path); /* Delete an existing file or directory */
219 FRESULT f_mkdir (const TCHAR* path); /* Create a new directory */
220 FRESULT f_chmod (const TCHAR* path, BYTE value, BYTE mask); /* Change attribute of the file/dir */
221 FRESULT f_utime (const TCHAR* path, const FILINFO* fno); /* Change times-tamp of the file/dir */
222 FRESULT f_rename (const TCHAR* path_old, const TCHAR* path_new); /* Rename/Move a file or directory */
223 FRESULT f_chdrive (BYTE drv); /* Change current drive */
224 FRESULT f_chdir (const TCHAR* path); /* Change current directory */
225 FRESULT f_getcwd (TCHAR* buff, UINT len); /* Get current directory */
226 FRESULT f_getlabel (const TCHAR* path, TCHAR* label, DWORD* sn); /* Get volume label */
227 FRESULT f_setlabel (const TCHAR* label); /* Set volume label */
228 FRESULT f_forward (FIL* fp, UINT(*func)(const BYTE*,UINT), UINT btf, UINT* bf); /* Forward data to the stream */
229 FRESULT f_mkfs (BYTE vol, BYTE sfd, UINT au); /* Create a file system on the drive */
230 FRESULT f_fdisk (BYTE pdrv, const DWORD szt[], void* work); /* Divide a physical drive into some partitions */
231 int f_putc (TCHAR c, FIL* fp); /* Put a character to the file */
232 int f_puts (const TCHAR* str, FIL* cp); /* Put a string to the file */
233 int f_printf (FIL* fp, const TCHAR* str, ...); /* Put a formatted string to the file */
234 TCHAR* f_gets (TCHAR* buff, int len, FIL* fp); /* Get a string from the file */
235
236 #define f_eof(fp) (((fp)->fptr == (fp)->fsize) ? 1 : 0)
237 #define f_error(fp) (((fp)->flag & FA__ERROR) ? 1 : 0)
238 #define f_tell(fp) ((fp)->fptr)
239 #define f_size(fp) ((fp)->fsize)
240
241 #ifndef EOF
242 #define EOF (-1)
243 #endif
244
245
246
247
248 /*--------------------------------------------------------------*/
249 /* Additional user defined functions */
250
251 /* RTC function */
252 #if !_FS_READONLY
253 DWORD get_fattime (void);
254 #endif
255
256 /* Unicode support functions */
257 #if _USE_LFN /* Unicode - OEM code conversion */
258 WCHAR ff_convert (WCHAR chr, UINT dir); /* OEM-Unicode bidirectional conversion */
259 WCHAR ff_wtoupper (WCHAR chr); /* Unicode upper-case conversion */
260 #if _USE_LFN == 3 /* Memory functions */
261 void* ff_memalloc (UINT msize); /* Allocate memory block */
262 void ff_memfree (void* mblock); /* Free memory block */
263 #endif
264 #endif
265
266 /* Sync functions */
267 #if _FS_REENTRANT
268 int ff_cre_syncobj (BYTE vol, _SYNC_t* sobj); /* Create a sync object */
269 int ff_req_grant (_SYNC_t sobj); /* Lock sync object */
270 void ff_rel_grant (_SYNC_t sobj); /* Unlock sync object */
271 int ff_del_syncobj (_SYNC_t sobj); /* Delete a sync object */
272 #endif
273
274
275
276
277 /*--------------------------------------------------------------*/
278 /* Flags and offset address */
279
280
281 /* File access control and file status flags (FIL.flag) */
282
283 #define FA_READ 0x01
284 #define FA_OPEN_EXISTING 0x00
285 #define FA__ERROR 0x80
286
287 #if !_FS_READONLY
288 #define FA_WRITE 0x02
289 #define FA_CREATE_NEW 0x04
290 #define FA_CREATE_ALWAYS 0x08
291 #define FA_OPEN_ALWAYS 0x10
292 #define FA__WRITTEN 0x20
293 #define FA__DIRTY 0x40
294 #endif
295
296
297 /* FAT sub type (FATFS.fs_type) */
298
299 #define FS_FAT12 1
300 #define FS_FAT16 2
301 #define FS_FAT32 3
302
303
304 /* File attribute bits for directory entry */
305
306 #define AM_RDO 0x01 /* Read only */
307 #define AM_HID 0x02 /* Hidden */
308 #define AM_SYS 0x04 /* System */
309 #define AM_VOL 0x08 /* Volume label */
310 #define AM_LFN 0x0F /* LFN entry */
311 #define AM_DIR 0x10 /* Directory */
312 #define AM_ARC 0x20 /* Archive */
313 #define AM_MASK 0x3F /* Mask of defined bits */
314
315
316 /* Fast seek feature */
317 #define CREATE_LINKMAP 0xFFFFFFFF
318
319
320
321 /*--------------------------------*/
322 /* Multi-byte word access macros */
323
324 #if _WORD_ACCESS == 1 /* Enable word access to the FAT structure */
325 #define LD_WORD(ptr) (WORD)(*(WORD*)(BYTE*)(ptr))
326 #define LD_DWORD(ptr) (DWORD)(*(DWORD*)(BYTE*)(ptr))
327 #define ST_WORD(ptr,val) *(WORD*)(BYTE*)(ptr)=(WORD)(val)
328 #define ST_DWORD(ptr,val) *(DWORD*)(BYTE*)(ptr)=(DWORD)(val)
329 #else /* Use byte-by-byte access to the FAT structure */
330 #define LD_WORD(ptr) (WORD)(((WORD)*((BYTE*)(ptr)+1)<<8)|(WORD)*(BYTE*)(ptr))
331 #define LD_DWORD(ptr) (DWORD)(((DWORD)*((BYTE*)(ptr)+3)<<24)|((DWORD)*((BYTE*)(ptr)+2)<<16)|((WORD)*((BYTE*)(ptr)+1)<<8)|*(BYTE*)(ptr))
332 #define ST_WORD(ptr,val) *(BYTE*)(ptr)=(BYTE)(val); *((BYTE*)(ptr)+1)=(BYTE)((WORD)(val)>>8)
333 #define ST_DWORD(ptr,val) *(BYTE*)(ptr)=(BYTE)(val); *((BYTE*)(ptr)+1)=(BYTE)((WORD)(val)>>8); *((BYTE*)(ptr)+2)=(BYTE)((DWORD)(val)>>16); *((BYTE*)(ptr)+3)=(BYTE)((DWORD)(val)>>24)
334 #endif
335
336 #ifdef __cplusplus
337 }
338 #endif
339
340 #endif /* _FATFS */