UbixOS V2 2.0

fat_format.c
Go to the documentation of this file.
1 //-----------------------------------------------------------------------------
2 //-----------------------------------------------------------------------------
3 // FAT16/32 File IO Library
4 // V2.6
5 // Ultra-Embedded.com
6 // Copyright 2003 - 2012
7 //
8 // Email: admin@ultra-embedded.com
9 //
10 // License: GPL
11 // If you would like a version with a more permissive license for use in
12 // closed source commercial applications please contact me for details.
13 //-----------------------------------------------------------------------------
14 //
15 // This file is part of FAT File IO Library.
16 //
17 // FAT File IO Library is free software; you can redistribute it and/or modify
18 // it under the terms of the GNU General Public License as published by
19 // the Free Software Foundation; either version 2 of the License, or
20 // (at your option) any later version.
21 //
22 // FAT File IO Library is distributed in the hope that it will be useful,
23 // but WITHOUT ANY WARRANTY; without even the implied warranty of
24 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 // GNU General Public License for more details.
26 //
27 // You should have received a copy of the GNU General Public License
28 // along with FAT File IO Library; if not, write to the Free Software
29 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
30 //-----------------------------------------------------------------------------
31 //-----------------------------------------------------------------------------
32 #include <string.h>
33 #include "fat_defs.h"
34 #include "fat_access.h"
35 #include "fat_table.h"
36 #include "fat_write.h"
37 #include "fat_string.h"
38 #include "fat_misc.h"
39 #include "fat_format.h"
40
41 #if FATFS_INC_FORMAT_SUPPORT
42
43 //-----------------------------------------------------------------------------
44 // Tables
45 //-----------------------------------------------------------------------------
46 struct sec_per_clus_table
47 {
48 uint32 sectors;
49 uint8 sectors_per_cluster;
50 };
51
52 struct sec_per_clus_table _cluster_size_table16[] =
53 {
54 { 32680, 2}, // 16MB - 1K
55 { 262144, 4}, // 128MB - 2K
56 { 524288, 8}, // 256MB - 4K
57 { 1048576, 16}, // 512MB - 8K
58 { 2097152, 32}, // 1GB - 16K
59 { 4194304, 64}, // 2GB - 32K
60 { 8388608, 128},// 2GB - 64K [Warning only supported by Windows XP onwards]
61 { 0 , 0 } // Invalid
62 };
63
64 struct sec_per_clus_table _cluster_size_table32[] =
65 {
66 { 532480, 1}, // 260MB - 512b
67 { 16777216, 8}, // 8GB - 4K
68 { 33554432, 16}, // 16GB - 8K
69 { 67108864, 32}, // 32GB - 16K
70 { 0xFFFFFFFF, 64},// >32GB - 32K
71 { 0 , 0 } // Invalid
72 };
73
74 //-----------------------------------------------------------------------------
75 // fatfs_calc_cluster_size: Calculate what cluster size should be used
76 //-----------------------------------------------------------------------------
77 static uint8 fatfs_calc_cluster_size(uint32 sectors, int is_fat32)
78 {
79 int i;
80
81 if (!is_fat32)
82 {
83 for (i=0; _cluster_size_table16[i].sectors_per_cluster != 0;i++)
84 if (sectors <= _cluster_size_table16[i].sectors)
85 return _cluster_size_table16[i].sectors_per_cluster;
86 }
87 else
88 {
89 for (i=0; _cluster_size_table32[i].sectors_per_cluster != 0;i++)
90 if (sectors <= _cluster_size_table32[i].sectors)
91 return _cluster_size_table32[i].sectors_per_cluster;
92 }
93
94 return 0;
95 }
96 //-----------------------------------------------------------------------------
97 // fatfs_erase_sectors: Erase a number of sectors
98 //-----------------------------------------------------------------------------
99 static int fatfs_erase_sectors(struct fatfs *fs, uint32 lba, int count)
100 {
101 int i;
102
103 // Zero sector first
104 memset(fs->currentsector.sector, 0, FAT_SECTOR_SIZE);
105
106 for (i=0;i<count;i++)
107 if (!fs->disk_io.write_media(lba + i, fs->currentsector.sector, 1))
108 return 0;
109
110 return 1;
111 }
112 //-----------------------------------------------------------------------------
113 // fatfs_create_boot_sector: Create the boot sector
114 //-----------------------------------------------------------------------------
115 static int fatfs_create_boot_sector(struct fatfs *fs, uint32 boot_sector_lba, uint32 vol_sectors, const char *name, int is_fat32)
116 {
117 uint32 total_clusters;
118 int i;
119
120 // Zero sector initially
121 memset(fs->currentsector.sector, 0, FAT_SECTOR_SIZE);
122
123 // OEM Name & Jump Code
124 fs->currentsector.sector[0] = 0xEB;
125 fs->currentsector.sector[1] = 0x3C;
126 fs->currentsector.sector[2] = 0x90;
127 fs->currentsector.sector[3] = 0x4D;
128 fs->currentsector.sector[4] = 0x53;
129 fs->currentsector.sector[5] = 0x44;
130 fs->currentsector.sector[6] = 0x4F;
131 fs->currentsector.sector[7] = 0x53;
132 fs->currentsector.sector[8] = 0x35;
133 fs->currentsector.sector[9] = 0x2E;
134 fs->currentsector.sector[10] = 0x30;
135
136 // Bytes per sector
137 fs->currentsector.sector[11] = (FAT_SECTOR_SIZE >> 0) & 0xFF;
138 fs->currentsector.sector[12] = (FAT_SECTOR_SIZE >> 8) & 0xFF;
139
140 // Get sectors per cluster size for the disk
141 fs->sectors_per_cluster = fatfs_calc_cluster_size(vol_sectors, is_fat32);
142 if (!fs->sectors_per_cluster)
143 return 0; // Invalid disk size
144
145 // Sectors per cluster
146 fs->currentsector.sector[13] = fs->sectors_per_cluster;
147
148 // Reserved Sectors
149 if (!is_fat32)
150 fs->reserved_sectors = 8;
151 else
152 fs->reserved_sectors = 32;
153 fs->currentsector.sector[14] = (fs->reserved_sectors >> 0) & 0xFF;
154 fs->currentsector.sector[15] = (fs->reserved_sectors >> 8) & 0xFF;
155
156 // Number of FATS
157 fs->num_of_fats = 2;
158 fs->currentsector.sector[16] = fs->num_of_fats;
159
160 // Max entries in root dir (FAT16 only)
161 if (!is_fat32)
162 {
163 fs->root_entry_count = 512;
164 fs->currentsector.sector[17] = (fs->root_entry_count >> 0) & 0xFF;
165 fs->currentsector.sector[18] = (fs->root_entry_count >> 8) & 0xFF;
166 }
167 else
168 {
169 fs->root_entry_count = 0;
170 fs->currentsector.sector[17] = 0;
171 fs->currentsector.sector[18] = 0;
172 }
173
174 // [FAT16] Total sectors (use FAT32 count instead)
175 fs->currentsector.sector[19] = 0x00;
176 fs->currentsector.sector[20] = 0x00;
177
178 // Media type
179 fs->currentsector.sector[21] = 0xF8;
180
181
182 // FAT16 BS Details
183 if (!is_fat32)
184 {
185 // Count of sectors used by the FAT table (FAT16 only)
186 total_clusters = (vol_sectors / fs->sectors_per_cluster) + 1;
187 fs->fat_sectors = (total_clusters/(FAT_SECTOR_SIZE/2)) + 1;
188 fs->currentsector.sector[22] = (uint8)((fs->fat_sectors >> 0) & 0xFF);
189 fs->currentsector.sector[23] = (uint8)((fs->fat_sectors >> 8) & 0xFF);
190
191 // Sectors per track
192 fs->currentsector.sector[24] = 0x00;
193 fs->currentsector.sector[25] = 0x00;
194
195 // Heads
196 fs->currentsector.sector[26] = 0x00;
197 fs->currentsector.sector[27] = 0x00;
198
199 // Hidden sectors
200 fs->currentsector.sector[28] = 0x20;
201 fs->currentsector.sector[29] = 0x00;
202 fs->currentsector.sector[30] = 0x00;
203 fs->currentsector.sector[31] = 0x00;
204
205 // Total sectors for this volume
206 fs->currentsector.sector[32] = (uint8)((vol_sectors>>0)&0xFF);
207 fs->currentsector.sector[33] = (uint8)((vol_sectors>>8)&0xFF);
208 fs->currentsector.sector[34] = (uint8)((vol_sectors>>16)&0xFF);
209 fs->currentsector.sector[35] = (uint8)((vol_sectors>>24)&0xFF);
210
211 // Drive number
212 fs->currentsector.sector[36] = 0x00;
213
214 // Reserved
215 fs->currentsector.sector[37] = 0x00;
216
217 // Boot signature
218 fs->currentsector.sector[38] = 0x29;
219
220 // Volume ID
221 fs->currentsector.sector[39] = 0x12;
222 fs->currentsector.sector[40] = 0x34;
223 fs->currentsector.sector[41] = 0x56;
224 fs->currentsector.sector[42] = 0x78;
225
226 // Volume name
227 for (i=0;i<11;i++)
228 {
229 if (i < (int)strlen(name))
230 fs->currentsector.sector[i+43] = name[i];
231 else
232 fs->currentsector.sector[i+43] = ' ';
233 }
234
235 // File sys type
236 fs->currentsector.sector[54] = 'F';
237 fs->currentsector.sector[55] = 'A';
238 fs->currentsector.sector[56] = 'T';
239 fs->currentsector.sector[57] = '1';
240 fs->currentsector.sector[58] = '6';
241 fs->currentsector.sector[59] = ' ';
242 fs->currentsector.sector[60] = ' ';
243 fs->currentsector.sector[61] = ' ';
244
245 // Signature
246 fs->currentsector.sector[510] = 0x55;
247 fs->currentsector.sector[511] = 0xAA;
248 }
249 // FAT32 BS Details
250 else
251 {
252 // Count of sectors used by the FAT table (FAT16 only)
253 fs->currentsector.sector[22] = 0;
254 fs->currentsector.sector[23] = 0;
255
256 // Sectors per track (default)
257 fs->currentsector.sector[24] = 0x3F;
258 fs->currentsector.sector[25] = 0x00;
259
260 // Heads (default)
261 fs->currentsector.sector[26] = 0xFF;
262 fs->currentsector.sector[27] = 0x00;
263
264 // Hidden sectors
265 fs->currentsector.sector[28] = 0x00;
266 fs->currentsector.sector[29] = 0x00;
267 fs->currentsector.sector[30] = 0x00;
268 fs->currentsector.sector[31] = 0x00;
269
270 // Total sectors for this volume
271 fs->currentsector.sector[32] = (uint8)((vol_sectors>>0)&0xFF);
272 fs->currentsector.sector[33] = (uint8)((vol_sectors>>8)&0xFF);
273 fs->currentsector.sector[34] = (uint8)((vol_sectors>>16)&0xFF);
274 fs->currentsector.sector[35] = (uint8)((vol_sectors>>24)&0xFF);
275
276 total_clusters = (vol_sectors / fs->sectors_per_cluster) + 1;
277 fs->fat_sectors = (total_clusters/(FAT_SECTOR_SIZE/4)) + 1;
278
279 // BPB_FATSz32
280 fs->currentsector.sector[36] = (uint8)((fs->fat_sectors>>0)&0xFF);
281 fs->currentsector.sector[37] = (uint8)((fs->fat_sectors>>8)&0xFF);
282 fs->currentsector.sector[38] = (uint8)((fs->fat_sectors>>16)&0xFF);
283 fs->currentsector.sector[39] = (uint8)((fs->fat_sectors>>24)&0xFF);
284
285 // BPB_ExtFlags
286 fs->currentsector.sector[40] = 0;
287 fs->currentsector.sector[41] = 0;
288
289 // BPB_FSVer
290 fs->currentsector.sector[42] = 0;
291 fs->currentsector.sector[43] = 0;
292
293 // BPB_RootClus
294 fs->currentsector.sector[44] = (uint8)((fs->rootdir_first_cluster>>0)&0xFF);
295 fs->currentsector.sector[45] = (uint8)((fs->rootdir_first_cluster>>8)&0xFF);
296 fs->currentsector.sector[46] = (uint8)((fs->rootdir_first_cluster>>16)&0xFF);
297 fs->currentsector.sector[47] = (uint8)((fs->rootdir_first_cluster>>24)&0xFF);
298
299 // BPB_FSInfo
300 fs->currentsector.sector[48] = (uint8)((fs->fs_info_sector>>0)&0xFF);
301 fs->currentsector.sector[49] = (uint8)((fs->fs_info_sector>>8)&0xFF);
302
303 // BPB_BkBootSec
304 fs->currentsector.sector[50] = 6;
305 fs->currentsector.sector[51] = 0;
306
307 // Drive number
308 fs->currentsector.sector[64] = 0x00;
309
310 // Boot signature
311 fs->currentsector.sector[66] = 0x29;
312
313 // Volume ID
314 fs->currentsector.sector[67] = 0x12;
315 fs->currentsector.sector[68] = 0x34;
316 fs->currentsector.sector[69] = 0x56;
317 fs->currentsector.sector[70] = 0x78;
318
319 // Volume name
320 for (i=0;i<11;i++)
321 {
322 if (i < (int)strlen(name))
323 fs->currentsector.sector[i+71] = name[i];
324 else
325 fs->currentsector.sector[i+71] = ' ';
326 }
327
328 // File sys type
329 fs->currentsector.sector[82] = 'F';
330 fs->currentsector.sector[83] = 'A';
331 fs->currentsector.sector[84] = 'T';
332 fs->currentsector.sector[85] = '3';
333 fs->currentsector.sector[86] = '2';
334 fs->currentsector.sector[87] = ' ';
335 fs->currentsector.sector[88] = ' ';
336 fs->currentsector.sector[89] = ' ';
337
338 // Signature
339 fs->currentsector.sector[510] = 0x55;
340 fs->currentsector.sector[511] = 0xAA;
341 }
342
343 if (fs->disk_io.write_media(boot_sector_lba, fs->currentsector.sector, 1))
344 return 1;
345 else
346 return 0;
347 }
348 //-----------------------------------------------------------------------------
349 // fatfs_create_fsinfo_sector: Create the FSInfo sector (FAT32)
350 //-----------------------------------------------------------------------------
351 static int fatfs_create_fsinfo_sector(struct fatfs *fs, uint32 sector_lba)
352 {
353 // Zero sector initially
354 memset(fs->currentsector.sector, 0, FAT_SECTOR_SIZE);
355
356 // FSI_LeadSig
357 fs->currentsector.sector[0] = 0x52;
358 fs->currentsector.sector[1] = 0x52;
359 fs->currentsector.sector[2] = 0x61;
360 fs->currentsector.sector[3] = 0x41;
361
362 // FSI_StrucSig
363 fs->currentsector.sector[484] = 0x72;
364 fs->currentsector.sector[485] = 0x72;
365 fs->currentsector.sector[486] = 0x41;
366 fs->currentsector.sector[487] = 0x61;
367
368 // FSI_Free_Count
369 fs->currentsector.sector[488] = 0xFF;
370 fs->currentsector.sector[489] = 0xFF;
371 fs->currentsector.sector[490] = 0xFF;
372 fs->currentsector.sector[491] = 0xFF;
373
374 // FSI_Nxt_Free
375 fs->currentsector.sector[492] = 0xFF;
376 fs->currentsector.sector[493] = 0xFF;
377 fs->currentsector.sector[494] = 0xFF;
378 fs->currentsector.sector[495] = 0xFF;
379
380 // Signature
381 fs->currentsector.sector[510] = 0x55;
382 fs->currentsector.sector[511] = 0xAA;
383
384 if (fs->disk_io.write_media(sector_lba, fs->currentsector.sector, 1))
385 return 1;
386 else
387 return 0;
388 }
389 //-----------------------------------------------------------------------------
390 // fatfs_erase_fat: Erase FAT table using fs details in fs struct
391 //-----------------------------------------------------------------------------
392 static int fatfs_erase_fat(struct fatfs *fs, int is_fat32)
393 {
394 uint32 i;
395
396 // Zero sector initially
397 memset(fs->currentsector.sector, 0, FAT_SECTOR_SIZE);
398
399 // Initialise default allocate / reserved clusters
400 if (!is_fat32)
401 {
402 SET_16BIT_WORD(fs->currentsector.sector, 0, 0xFFF8);
403 SET_16BIT_WORD(fs->currentsector.sector, 2, 0xFFFF);
404 }
405 else
406 {
407 SET_32BIT_WORD(fs->currentsector.sector, 0, 0x0FFFFFF8);
408 SET_32BIT_WORD(fs->currentsector.sector, 4, 0xFFFFFFFF);
409 SET_32BIT_WORD(fs->currentsector.sector, 8, 0x0FFFFFFF);
410 }
411
412 if (!fs->disk_io.write_media(fs->fat_begin_lba + 0, fs->currentsector.sector, 1))
413 return 0;
414
415 // Zero remaining FAT sectors
416 memset(fs->currentsector.sector, 0, FAT_SECTOR_SIZE);
417 for (i=1;i<fs->fat_sectors*fs->num_of_fats;i++)
418 if (!fs->disk_io.write_media(fs->fat_begin_lba + i, fs->currentsector.sector, 1))
419 return 0;
420
421 return 1;
422 }
423 //-----------------------------------------------------------------------------
424 // fatfs_format_fat16: Format a FAT16 partition
425 //-----------------------------------------------------------------------------
426 int fatfs_format_fat16(struct fatfs *fs, uint32 volume_sectors, const char *name)
427 {
428 fs->currentsector.address = FAT32_INVALID_CLUSTER;
429 fs->currentsector.dirty = 0;
430
431 fs->next_free_cluster = 0; // Invalid
432
433 fatfs_fat_init(fs);
434
435 // Make sure we have read + write functions
436 if (!fs->disk_io.read_media || !fs->disk_io.write_media)
437 return FAT_INIT_MEDIA_ACCESS_ERROR;
438
439 // Volume is FAT16
440 fs->fat_type = FAT_TYPE_16;
441
442 // Not valid for FAT16
443 fs->fs_info_sector = 0;
444 fs->rootdir_first_cluster = 0;
445
446 // Sector 0: Boot sector
447 // NOTE: We don't need an MBR, it is a waste of a good sector!
448 fs->lba_begin = 0;
449 if (!fatfs_create_boot_sector(fs, fs->lba_begin, volume_sectors, name, 0))
450 return 0;
451
452 // For FAT16 (which this may be), rootdir_first_cluster is actuall rootdir_first_sector
453 fs->rootdir_first_sector = fs->reserved_sectors + (fs->num_of_fats * fs->fat_sectors);
454 fs->rootdir_sectors = ((fs->root_entry_count * 32) + (FAT_SECTOR_SIZE - 1)) / FAT_SECTOR_SIZE;
455
456 // First FAT LBA address
457 fs->fat_begin_lba = fs->lba_begin + fs->reserved_sectors;
458
459 // The address of the first data cluster on this volume
460 fs->cluster_begin_lba = fs->fat_begin_lba + (fs->num_of_fats * fs->fat_sectors);
461
462 // Initialise FAT sectors
463 if (!fatfs_erase_fat(fs, 0))
464 return 0;
465
466 // Erase Root directory
467 if (!fatfs_erase_sectors(fs, fs->lba_begin + fs->rootdir_first_sector, fs->rootdir_sectors))
468 return 0;
469
470 return 1;
471 }
472 //-----------------------------------------------------------------------------
473 // fatfs_format_fat32: Format a FAT32 partition
474 //-----------------------------------------------------------------------------
475 int fatfs_format_fat32(struct fatfs *fs, uint32 volume_sectors, const char *name)
476 {
477 fs->currentsector.address = FAT32_INVALID_CLUSTER;
478 fs->currentsector.dirty = 0;
479
480 fs->next_free_cluster = 0; // Invalid
481
482 fatfs_fat_init(fs);
483
484 // Make sure we have read + write functions
485 if (!fs->disk_io.read_media || !fs->disk_io.write_media)
486 return FAT_INIT_MEDIA_ACCESS_ERROR;
487
488 // Volume is FAT32
489 fs->fat_type = FAT_TYPE_32;
490
491 // Basic defaults for normal FAT32 partitions
492 fs->fs_info_sector = 1;
493 fs->rootdir_first_cluster = 2;
494
495 // Sector 0: Boot sector
496 // NOTE: We don't need an MBR, it is a waste of a good sector!
497 fs->lba_begin = 0;
498 if (!fatfs_create_boot_sector(fs, fs->lba_begin, volume_sectors, name, 1))
499 return 0;
500
501 // First FAT LBA address
502 fs->fat_begin_lba = fs->lba_begin + fs->reserved_sectors;
503
504 // The address of the first data cluster on this volume
505 fs->cluster_begin_lba = fs->fat_begin_lba + (fs->num_of_fats * fs->fat_sectors);
506
507 // Initialise FSInfo sector
508 if (!fatfs_create_fsinfo_sector(fs, fs->fs_info_sector))
509 return 0;
510
511 // Initialise FAT sectors
512 if (!fatfs_erase_fat(fs, 1))
513 return 0;
514
515 // Erase Root directory
516 if (!fatfs_erase_sectors(fs, fatfs_lba_of_cluster(fs, fs->rootdir_first_cluster), fs->sectors_per_cluster))
517 return 0;
518
519 return 1;
520 }
521 //-----------------------------------------------------------------------------
522 // fatfs_format: Format a partition with either FAT16 or FAT32 based on size
523 //-----------------------------------------------------------------------------
524 int fatfs_format(struct fatfs *fs, uint32 volume_sectors, const char *name)
525 {
526 // 2GB - 32K limit for safe behaviour for FAT16
527 if (volume_sectors <= 4194304)
528 return fatfs_format_fat16(fs, volume_sectors, name);
529 else
530 return fatfs_format_fat32(fs, volume_sectors, name);
531 }
532 #endif /*FATFS_INC_FORMAT_SUPPORT*/
FAT_TYPE_32
Definition: fat_access.h:54
fat_write.h
fat_access.h
FAT_INIT_MEDIA_ACCESS_ERROR
#define FAT_INIT_MEDIA_ACCESS_ERROR
Definition: fat_access.h:11
fat_table.h
uint8
unsigned char uint8
Definition: fat_types.h:15
string.h
fatfs_format_fat32
int fatfs_format_fat32(struct fatfs *fs, uint32 volume_sectors, const char *name)
Definition: fat_format.c:475
fatfs_format_fat16
int fatfs_format_fat16(struct fatfs *fs, uint32 volume_sectors, const char *name)
Definition: fat_format.c:426
strlen
int strlen(const char *str)
Definition: strlen.c:55
fat_defs.h
fs
Definition: fs.h:260
FAT_SECTOR_SIZE
#define FAT_SECTOR_SIZE
Definition: fat_opts.h:70
fat_misc.h
fatfs_lba_of_cluster
uint32 fatfs_lba_of_cluster(struct fatfs *fs, uint32 Cluster_Number)
Definition: fat_access.c:191
fat_string.h
SET_16BIT_WORD
#define SET_16BIT_WORD(buffer, location, value)
Definition: fat_misc.h:24
FAT32_INVALID_CLUSTER
#define FAT32_INVALID_CLUSTER
Definition: fat_defs.h:109
SET_32BIT_WORD
#define SET_32BIT_WORD(buffer, location, value)
Definition: fat_misc.h:19
name
const char * name
Definition: pci.c:37
_cluster_size_table16
struct sec_per_clus_table _cluster_size_table16[]
Definition: fat_format.c:52
memset
void * memset(void *dst, int c, size_t length)
fatfs_fat_init
void fatfs_fat_init(struct fatfs *fs)
Definition: fat_table.c:60
sec_per_clus_table::sectors
uint32 sectors
Definition: fat_format.c:48
uint32
unsigned long uint32
Definition: fat_types.h:23
fat_format.h
fatfs_format
int fatfs_format(struct fatfs *fs, uint32 volume_sectors, const char *name)
Definition: fat_format.c:524
FAT_TYPE_16
Definition: fat_access.h:53
sec_per_clus_table::sectors_per_cluster
uint8 sectors_per_cluster
Definition: fat_format.c:49
sec_per_clus_table
Definition: fat_format.c:46
_cluster_size_table32
struct sec_per_clus_table _cluster_size_table32[]
Definition: fat_format.c:64
fatfs
Definition: fat_access.h:57