Plugson/src/Lib/fat_io_lib/fat_format.c

   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*/