rbutil/ipodpatcher/fat32format.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  *
  11  * FAT32 formatting functions.  Based on:
  12  *
  13  * Fat32 formatter version 1.03
  14  * (c) Tom Thornhill 2005
  15  * This software is covered by the GPL.
  16  * By using this tool, you agree to absolve Ridgecrop of an liabilities for
  17  * lost data.
  18  * Please backup any data you value before using this tool.
  19  *
  20  *
  21  * Modified June 2007 by Dave Chapman for use in ipodpatcher
  22  *
  23  *
  24  * All files in this archive are subject to the GNU General Public License.
  25  * See the file COPYING in the source tree root for full license agreement.
  26  *
  27  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  28  * KIND, either express or implied.
  29  *
  30  ****************************************************************************/
  31
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35 #include <stdbool.h>
  36 #include <stdint.h>
  37
  38 #include "ipodio.h"
  39
  40 static inline uint16_t swap16(uint16_t value)
  41 {
  42     return (value >> 8) | (value << 8);
  43 }
  44
  45 static inline uint32_t swap32(uint32_t value)
  46 {
  47     uint32_t hi = swap16(value >> 16);
  48     uint32_t lo = swap16(value & 0xffff);
  49     return (lo << 16) | hi;
  50 }
  51
  52 /* The following functions are not the most efficient, but are
  53    self-contained and don't require needing to know endianness of CPU
  54    at compile-time.
  55 */
  56
  57 uint16_t htole16(uint16_t x)
  58 {
  59     uint16_t test = 0x1234;
  60     unsigned char* p = (unsigned char*)&test;
  61
  62     if (p[0]==0x12) {
  63         /* Big-endian */
  64         return swap16(x);
  65     } else {
  66         return x;
  67     }
  68 }
  69
  70 uint32_t htole32(uint32_t x)
  71 {
  72     uint32_t test = 0x12345678;
  73     unsigned char* p = (unsigned char*)&test;
  74
  75     if (p[0]==0x12) {
  76         /* Big-endian */
  77         return swap32(x);
  78     } else {
  79         return x;
  80     }
  81 }
  82
  83
  84 /* A large aligned buffer for disk I/O */
  85 extern unsigned char* sectorbuf;
  86
  87 /* TODO: Pass these as parameters to the various create_ functions */
  88
  89 /* can be zero for default or 1,2,4,8,16,32 or 64 */
  90 static int sectors_per_cluster = 0;
  91
  92 /* Recommended values */
  93 static uint32_t ReservedSectCount = 32;
  94 static uint32_t NumFATs = 2;
  95 static uint32_t BackupBootSect = 6;
  96 static uint32_t VolumeId=0; /* calculated before format */
  97
  98 /* Calculated later */
  99 static uint32_t FatSize=0;
 100 static uint32_t BytesPerSect=0;
 101 static uint32_t SectorsPerCluster=0;
 102 static uint32_t TotalSectors=0;
 103 static uint32_t SystemAreaSize=0;
 104 static uint32_t UserAreaSize=0;
 105 static uint8_t VolId[12] = "NO NAME    ";
 106
 107
 108 struct FAT_BOOTSECTOR32
 109 {
 110     /* Common fields. */
 111     uint8_t sJmpBoot[3];
 112     char sOEMName[8];
 113     uint16_t wBytsPerSec;
 114     uint8_t bSecPerClus;
 115     uint16_t wRsvdSecCnt;
 116     uint8_t bNumFATs;
 117     uint16_t wRootEntCnt;
 118     uint16_t wTotSec16;  /* if zero, use dTotSec32 instead */
 119     uint8_t bMedia;
 120     uint16_t wFATSz16;
 121     uint16_t wSecPerTrk;
 122     uint16_t wNumHeads;
 123     uint32_t dHiddSec;
 124     uint32_t dTotSec32;
 125
 126     /* Fat 32/16 only */
 127     uint32_t dFATSz32;
 128     uint16_t wExtFlags;
 129     uint16_t wFSVer;
 130     uint32_t dRootClus;
 131     uint16_t wFSInfo;
 132     uint16_t wBkBootSec;
 133     uint8_t Reserved[12];
 134     uint8_t bDrvNum;
 135     uint8_t Reserved1;
 136     uint8_t bBootSig;  /* == 0x29 if next three fields are ok */
 137     uint32_t dBS_VolID;
 138     uint8_t sVolLab[11];
 139     uint8_t sBS_FilSysType[8];
 140 } __attribute__((packed));
 141
 142 struct FAT_FSINFO {
 143     uint32_t dLeadSig;         // 0x41615252
 144     uint8_t sReserved1[480];   // zeros
 145     uint32_t dStrucSig;        // 0x61417272
 146     uint32_t dFree_Count;      // 0xFFFFFFFF
 147     uint32_t dNxt_Free;        // 0xFFFFFFFF
 148     uint8_t sReserved2[12];    // zeros
 149     uint32_t dTrailSig;     // 0xAA550000
 150 } __attribute__((packed));
 151
 152
 153 /* Write "count" zero sectors, starting at sector "sector" */
 154 static int zero_sectors(struct ipod_t* ipod, uint64_t sector, int count)
 155 {
 156     int n;
 157
 158     if (ipod_seek(ipod, sector * ipod->sector_size) < 0) {
 159         fprintf(stderr,"[ERR]  Seek failed\n");
 160         return -1;
 161     }
 162
 163     memset(sectorbuf, 0, 128 * ipod->sector_size);
 164
 165     /* Write 128 sectors at a time */
 166     while (count) {
 167         if (count >= 128)
 168             n = 128;
 169         else
 170             n = count;
 171
 172         if (ipod_write(ipod,sectorbuf,n * ipod->sector_size) < 0) {
 173             perror("[ERR]  Write failed in zero_sectors\n");
 174             return -1;
 175         }
 176
 177         count -= n;
 178     }
 179
 180     return 0;
 181 }
 182
 183
 184 /*
 185 28.2  CALCULATING THE VOLUME SERIAL NUMBER
 186
 187 For example, say a disk was formatted on 26 Dec 95 at 9:55 PM and 41.94
 188 seconds.  DOS takes the date and time just before it writes it to the
 189 disk.
 190
 191 Low order word is calculated:               Volume Serial Number is:
 192     Month & Day         12/26   0c1ah
 193     Sec & Hundrenths    41:94   295eh               3578:1d02
 194                                 -----
 195                                 3578h
 196
 197 High order word is calculated:
 198     Hours & Minutes     21:55   1537h
 199     Year                1995    07cbh
 200                                 -----
 201                                 1d02h
 202 */
 203 static uint32_t get_volume_id ( )
 204 {
 205     /* TODO */
 206 #if 0
 207     SYSTEMTIME s;
 208     uint32_t d;
 209     uint16_t lo,hi,tmp;
 210
 211     GetLocalTime( &s );
 212
 213     lo = s.wDay + ( s.wMonth << 8 );
 214     tmp = (s.wMilliseconds/10) + (s.wSecond << 8 );
 215     lo += tmp;
 216
 217     hi = s.wMinute + ( s.wHour << 8 );
 218     hi += s.wYear;
 219
 220     d = lo + (hi << 16);
 221     return(d);
 222 #endif
 223     return(0);
 224 }
 225
 226 /*
 227 This is the Microsoft calculation from FATGEN
 228
 229     uint32_t RootDirSectors = 0;
 230     uint32_t TmpVal1, TmpVal2, FATSz;
 231
 232     TmpVal1 = DskSize - ( ReservedSecCnt + RootDirSectors);
 233     TmpVal2 = (256 * SecPerClus) + NumFATs;
 234     TmpVal2 = TmpVal2 / 2;
 235     FATSz = (TmpVal1 + (TmpVal2 - 1)) / TmpVal2;
 236
 237     return( FatSz );
 238 */
 239
 240
 241 static uint32_t get_fat_size_sectors(uint32_t DskSize, uint32_t ReservedSecCnt,
 242                                      uint32_t SecPerClus, uint32_t NumFATs,
 243                                      uint32_t BytesPerSect)
 244 {
 245     uint64_t Numerator, Denominator;
 246     uint64_t FatElementSize = 4;
 247     uint64_t FatSz;
 248
 249     /* This is based on
 250        http://hjem.get2net.dk/rune_moeller_barnkob/filesystems/fat.html
 251        I've made the obvious changes for FAT32
 252      */
 253
 254     Numerator = FatElementSize * ( DskSize - ReservedSecCnt );
 255     Denominator = ( SecPerClus * BytesPerSect ) + ( FatElementSize * NumFATs );
 256     FatSz = Numerator / Denominator;
 257
 258     /* round up */
 259     FatSz += 1;
 260
 261     return((uint32_t)FatSz);
 262 }
 263
 264 static uint8_t get_spc(uint32_t ClusterSizeKB, uint32_t BytesPerSect)
 265 {
 266     uint32_t spc = ( ClusterSizeKB * 1024 ) / BytesPerSect;
 267     return( (uint8_t) spc );
 268 }
 269
 270 static uint8_t get_sectors_per_cluster(uint32_t DiskSizeSectors,
 271                                        uint32_t BytesPerSect)
 272 {
 273     uint8_t ret = 0x01; /* 1 sector per cluster */
 274     uint64_t DiskSizeBytes = (uint64_t)DiskSizeSectors * (uint64_t)BytesPerSect;
 275     int64_t DiskSizeMB = DiskSizeBytes / ( 1024*1024 );
 276
 277     /* 512 MB to 8,191 MB 4 KB */
 278     if ( DiskSizeMB > 512 )
 279         ret = get_spc( 4, BytesPerSect );   /* ret = 0x8; */
 280
 281     /* 8,192 MB to 16,383 MB 8 KB */
 282     if ( DiskSizeMB > 8192 )
 283         ret = get_spc( 8, BytesPerSect );   /* ret = 0x10; */
 284
 285     /* 16,384 MB to 32,767 MB 16 KB */
 286     if ( DiskSizeMB > 16384 )
 287         ret = get_spc( 16, BytesPerSect );  /* ret = 0x20; */
 288
 289     /* Larger than 32,768 MB 32 KB */
 290     if ( DiskSizeMB > 32768 )
 291         ret = get_spc( 32, BytesPerSect );  /* ret = 0x40; */
 292
 293     return( ret );
 294
 295 }
 296
 297 static void create_boot_sector(unsigned char* buf,
 298                                struct ipod_t* ipod, int partition)
 299 {
 300     struct FAT_BOOTSECTOR32* pFAT32BootSect = (struct FAT_BOOTSECTOR32*)buf;
 301
 302     /* fill out the boot sector and fs info */
 303     pFAT32BootSect->sJmpBoot[0]=0xEB;
 304     pFAT32BootSect->sJmpBoot[1]=0x5A;
 305     pFAT32BootSect->sJmpBoot[2]=0x90;
 306     strcpy( pFAT32BootSect->sOEMName, "MSWIN4.1" );
 307     pFAT32BootSect->wBytsPerSec = htole16(BytesPerSect);
 308     pFAT32BootSect->bSecPerClus = SectorsPerCluster ;
 309     pFAT32BootSect->wRsvdSecCnt = htole16(ReservedSectCount);
 310     pFAT32BootSect->bNumFATs = NumFATs;
 311     pFAT32BootSect->wRootEntCnt = htole16(0);
 312     pFAT32BootSect->wTotSec16 = htole16(0);
 313     pFAT32BootSect->bMedia = 0xF8;
 314     pFAT32BootSect->wFATSz16 = htole16(0);
 315     pFAT32BootSect->wSecPerTrk = htole16(ipod->sectors_per_track);
 316     pFAT32BootSect->wNumHeads = htole16(ipod->num_heads);
 317     pFAT32BootSect->dHiddSec = htole16(ipod->pinfo[partition].start);
 318     pFAT32BootSect->dTotSec32 = htole32(TotalSectors);
 319     pFAT32BootSect->dFATSz32 = htole32(FatSize);
 320     pFAT32BootSect->wExtFlags = htole16(0);
 321     pFAT32BootSect->wFSVer = htole16(0);
 322     pFAT32BootSect->dRootClus = htole32(2);
 323     pFAT32BootSect->wFSInfo = htole16(1);
 324     pFAT32BootSect->wBkBootSec = htole16(BackupBootSect);
 325     pFAT32BootSect->bDrvNum = 0x80;
 326     pFAT32BootSect->Reserved1 = 0;
 327     pFAT32BootSect->bBootSig = 0x29;
 328     pFAT32BootSect->dBS_VolID = htole32(VolumeId);
 329     memcpy(pFAT32BootSect->sVolLab, VolId, 11);
 330     memcpy(pFAT32BootSect->sBS_FilSysType, "FAT32   ", 8 );
 331
 332     buf[510] = 0x55;
 333     buf[511] = 0xaa;
 334 }
 335
 336 static void create_fsinfo(unsigned char* buf,
 337                           struct ipod_t* ipod, int partition)
 338 {
 339     struct FAT_FSINFO* pFAT32FsInfo = (struct FAT_FSINFO*)buf;
 340
 341     /* FSInfo sect */
 342     pFAT32FsInfo->dLeadSig = htole32(0x41615252);
 343     pFAT32FsInfo->dStrucSig = htole32(0x61417272);
 344     pFAT32FsInfo->dFree_Count = htole32((uint32_t) -1);
 345     pFAT32FsInfo->dNxt_Free = htole32((uint32_t) -1);
 346     pFAT32FsInfo->dTrailSig = htole32(0xaa550000);
 347     pFAT32FsInfo->dFree_Count = htole32((UserAreaSize/SectorsPerCluster)-1);
 348
 349     /* clusters 0-1 reserved, we used cluster 2 for the root dir */
 350     pFAT32FsInfo->dNxt_Free = htole32(3);
 351 }
 352
 353 static void create_firstfatsector(unsigned char* buf,
 354                                   struct ipod_t* ipod, int partition)
 355 {
 356     uint32_t* p = (uint32_t*)buf;  /* We know the buffer is aligned */
 357
 358     /* First FAT Sector */
 359     p[0] = htole32(0x0ffffff8);  /* Reserved cluster 1 media id in low byte */
 360     p[1] = htole32(0x0fffffff);  /* Reserved cluster 2 EOC */
 361     p[2] = htole32(0x0fffffff);  /* end of cluster chain for root dir */
 362 }
 363
 364 int format_partition(struct ipod_t* ipod, int partition)
 365 {
 366     uint32_t i;
 367     uint64_t qTotalSectors=0;
 368     uint64_t FatNeeded;
 369
 370     VolumeId = get_volume_id( );
 371
 372     /* Only support hard disks at the moment */
 373     if ( ipod->sector_size != 512 )
 374     {
 375         fprintf(stderr,"[ERR]  Only disks with 512 bytes per sector are supported.\n");
 376         return -1;
 377     }
 378     BytesPerSect = ipod->sector_size;
 379
 380     /* Checks on Disk Size */
 381     qTotalSectors = ipod->pinfo[partition].size;
 382
 383     /* low end limit - 65536 sectors */
 384     if ( qTotalSectors < 65536 )
 385     {
 386         /* I suspect that most FAT32 implementations would mount this
 387            volume just fine, but the spec says that we shouldn't do
 388            this, so we won't */
 389
 390         fprintf(stderr,"[ERR]  This drive is too small for FAT32 - there must be at least 64K clusters\n" );
 391         return -1;
 392     }
 393
 394     if ( qTotalSectors >= 0xffffffff )
 395     {
 396         /* This is a more fundamental limitation on FAT32 - the total
 397            sector count in the root dir s 32bit. With a bit of
 398            creativity, FAT32 could be extended to handle at least 2^28
 399            clusters There would need to be an extra field in the
 400            FSInfo sector, and the old sector count could be set to
 401            0xffffffff. This is non standard though, the Windows FAT
 402            driver FASTFAT.SYS won't understand this. Perhaps a future
 403            version of FAT32 and FASTFAT will handle this. */
 404
 405         fprintf(stderr,"[ERR]  This drive is too big for FAT32 - max 2TB supported\n");
 406     }
 407
 408     if ( sectors_per_cluster ) {
 409         SectorsPerCluster = sectors_per_cluster;
 410     } else {
 411         SectorsPerCluster = get_sectors_per_cluster(ipod->pinfo[partition].size,
 412                                                     BytesPerSect );
 413     }
 414
 415     TotalSectors = (uint32_t)  qTotalSectors;
 416
 417     FatSize = get_fat_size_sectors(TotalSectors, ReservedSectCount,
 418                                    SectorsPerCluster, NumFATs, BytesPerSect );
 419
 420     UserAreaSize = TotalSectors - ReservedSectCount - (NumFATs*FatSize);
 421
 422     /* First zero out ReservedSect + FatSize * NumFats + SectorsPerCluster */
 423     SystemAreaSize = (ReservedSectCount+(NumFATs*FatSize) + SectorsPerCluster);
 424
 425     /* Work out the Cluster count */
 426     FatNeeded = UserAreaSize/SectorsPerCluster;
 427
 428     /* check for a cluster count of >2^28, since the upper 4 bits of
 429        the cluster values in the FAT are reserved. */
 430     if (FatNeeded > 0x0FFFFFFF) {
 431         fprintf(stderr,"[ERR]  This drive has more than 2^28 clusters, try to specify a larger cluster size\n" );
 432         return -1;
 433     }
 434
 435     /* Sanity check, make sure the fat is big enough.
 436        Convert the cluster count into a Fat sector count, and check
 437        the fat size value we calculated earlier is OK.  */
 438
 439     FatNeeded *=4;
 440     FatNeeded += (BytesPerSect-1);
 441     FatNeeded /= BytesPerSect;
 442
 443     if ( FatNeeded > FatSize ) {
 444         fprintf(stderr,"[ERR]  Drive too big to format\n");
 445         return -1;
 446     }
 447
 448     /*
 449        Write boot sector, fats
 450        Sector 0 Boot Sector
 451        Sector 1 FSInfo
 452        Sector 2 More boot code - we write zeros here
 453        Sector 3 unused
 454        Sector 4 unused
 455        Sector 5 unused
 456        Sector 6 Backup boot sector
 457        Sector 7 Backup FSInfo sector
 458        Sector 8 Backup 'more boot code'
 459        zero'd sectors upto ReservedSectCount
 460        FAT1  ReservedSectCount to ReservedSectCount + FatSize
 461        ...
 462        FATn  ReservedSectCount to ReservedSectCount + FatSize
 463        RootDir - allocated to cluster2
 464      */
 465
 466     fprintf(stderr,"[INFO] Heads - %d, sectors/track = %d\n",ipod->num_heads,ipod->sectors_per_track);
 467     fprintf(stderr,"[INFO] Size : %lluGB %u sectors\n", ((uint64_t)ipod->pinfo[partition].size * (uint64_t)ipod->sector_size) / (1000*1000*1000), TotalSectors );
 468     fprintf(stderr,"[INFO] %d Bytes Per Sector, Cluster size %d bytes\n", BytesPerSect, SectorsPerCluster*BytesPerSect );
 469     fprintf(stderr,"[INFO] Volume ID is %x:%x\n", VolumeId>>16, VolumeId&0xffff );
 470     fprintf(stderr,"[INFO] %d Reserved Sectors, %d Sectors per FAT, %d fats\n", ReservedSectCount, FatSize, NumFATs );
 471     fprintf (stderr,"[INFO] %d Total clusters\n", UserAreaSize/SectorsPerCluster );
 472
 473     fprintf(stderr,"[INFO] Formatting partition %d:...\n",partition);
 474
 475     /* Once zero_sectors has run, any data on the drive is basically lost... */
 476     fprintf(stderr,"[INFO] Clearing out %d sectors for Reserved sectors, fats and root cluster...\n", SystemAreaSize );
 477
 478     zero_sectors(ipod, ipod->pinfo[partition].start, SystemAreaSize);
 479
 480     fprintf(stderr,"[INFO] Initialising reserved sectors and FATs...\n" );
 481
 482     /* Create the boot sector structure */
 483     create_boot_sector(sectorbuf, ipod, partition);
 484     create_fsinfo(sectorbuf + 512, ipod, partition);
 485
 486     /* Write boot sector and fsinfo at start of partition */
 487     if (ipod_seek(ipod, ipod->pinfo[partition].start * ipod->sector_size) < 0) {
 488         fprintf(stderr,"[ERR]  Seek failed\n");
 489         return -1;
 490     }
 491     if (ipod_write(ipod,sectorbuf,512 * 2) < 0) {
 492         perror("[ERR]  Write failed (first copy of bootsect/fsinfo)\n");
 493         return -1;
 494     }
 495
 496     /* Write backup copy of boot sector and fsinfo */
 497     if (ipod_seek(ipod, (ipod->pinfo[partition].start + BackupBootSect) * ipod->sector_size) < 0) {
 498         fprintf(stderr,"[ERR]  Seek failed\n");
 499         return -1;
 500     }
 501     if (ipod_write(ipod,sectorbuf,512 * 2) < 0) {
 502         perror("[ERR]  Write failed (first copy of bootsect/fsinfo)\n");
 503         return -1;
 504     }
 505
 506     /* Create the first FAT sector */
 507     create_firstfatsector(sectorbuf, ipod, partition);
 508
 509     /* Write the first fat sector in the right places */
 510     for ( i=0; i<NumFATs; i++ ) {
 511         int SectorStart = ReservedSectCount + (i * FatSize );
 512
 513         if (ipod_seek(ipod, (ipod->pinfo[partition].start + SectorStart) * ipod->sector_size) < 0) {
 514             fprintf(stderr,"[ERR]  Seek failed\n");
 515             return -1;
 516         }
 517
 518         if (ipod_write(ipod,sectorbuf,512) < 0) {
 519             perror("[ERR]  Write failed (first copy of bootsect/fsinfo)\n");
 520             return -1;
 521         }
 522     }
 523
 524     fprintf(stderr,"[INFO] Format successful\n");
 525
 526     return 0;
 527 }