diff options
author | Dominik Riebeling <Dominik.Riebeling@gmail.com> | 2021-12-15 21:04:28 +0100 |
---|---|---|
committer | Dominik Riebeling <Dominik.Riebeling@gmail.com> | 2021-12-24 18:05:53 +0100 |
commit | c876d3bbefe0dc00c27ca0c12d29da5874946962 (patch) | |
tree | 69f468a185a369b01998314bc3ecc19b70f4fcaa /utils/ipodpatcher/fat32format.c | |
parent | 6c6f0757d7a902feb293be165d1490c42bc8e7ad (diff) | |
download | rockbox-c876d3bbefe0dc00c27ca0c12d29da5874946962.tar.gz rockbox-c876d3bbefe0dc00c27ca0c12d29da5874946962.zip |
rbutil: Merge rbutil with utils folder.
rbutil uses several components from the utils folder, and can be
considered part of utils too. Having it in a separate folder is an
arbitrary split that doesn't help anymore these days, so merge them.
This also allows other utils to easily use libtools.make without the
need to navigate to a different folder.
Change-Id: I3fc2f4de19e3e776553efb5dea5f779dfec0dc21
Diffstat (limited to 'utils/ipodpatcher/fat32format.c')
-rw-r--r-- | utils/ipodpatcher/fat32format.c | 530 |
1 files changed, 530 insertions, 0 deletions
diff --git a/utils/ipodpatcher/fat32format.c b/utils/ipodpatcher/fat32format.c new file mode 100644 index 0000000000..7ee8021cbf --- /dev/null +++ b/utils/ipodpatcher/fat32format.c | |||
@@ -0,0 +1,530 @@ | |||
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 | } | ||