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