1541cb32ddc348cb68a2b20ca99be9e4bf70c7ef
[reactos.git] / reactos / boot / freeldr / freeldr / arch / i386 / hwdisk.c
1 /*
2 * FreeLoader
3 *
4 * Copyright (C) 2003, 2004 Eric Kohl
5 * Copyright (C) 2009 Hervé Poussineau
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 */
21
22 #include <freeldr.h>
23
24 #define NDEBUG
25 #include <debug.h>
26
27 DBG_DEFAULT_CHANNEL(HWDETECT);
28
29 /*
30 * This is the common code for harddisk for both the PC and the XBOX.
31 */
32
33 typedef struct tagDISKCONTEXT
34 {
35 UCHAR DriveNumber;
36 ULONG SectorSize;
37 ULONGLONG SectorOffset;
38 ULONGLONG SectorCount;
39 ULONGLONG SectorNumber;
40 } DISKCONTEXT;
41
42 extern ULONG reactos_disk_count;
43 extern ARC_DISK_SIGNATURE_EX reactos_arc_disk_info[];
44
45 static CHAR Hex[] = "0123456789abcdef";
46
47 UCHAR PcBiosDiskCount = 0;
48 static CHAR PcDiskIdentifier[32][20];
49
50 PVOID DiskReadBuffer;
51 SIZE_T DiskReadBufferSize;
52
53
54 /* FUNCTIONS *****************************************************************/
55
56 static ARC_STATUS
57 DiskClose(ULONG FileId)
58 {
59 DISKCONTEXT* Context = FsGetDeviceSpecific(FileId);
60
61 FrLdrTempFree(Context, TAG_HW_DISK_CONTEXT);
62 return ESUCCESS;
63 }
64
65 static ARC_STATUS
66 DiskGetFileInformation(ULONG FileId, FILEINFORMATION* Information)
67 {
68 DISKCONTEXT* Context = FsGetDeviceSpecific(FileId);
69
70 RtlZeroMemory(Information, sizeof(FILEINFORMATION));
71 Information->EndingAddress.QuadPart = (Context->SectorOffset + Context->SectorCount) * Context->SectorSize;
72 Information->CurrentAddress.QuadPart = (Context->SectorOffset + Context->SectorNumber) * Context->SectorSize;
73
74 return ESUCCESS;
75 }
76
77 static ARC_STATUS
78 DiskOpen(CHAR* Path, OPENMODE OpenMode, ULONG* FileId)
79 {
80 DISKCONTEXT* Context;
81 UCHAR DriveNumber;
82 ULONG DrivePartition, SectorSize;
83 ULONGLONG SectorOffset = 0;
84 ULONGLONG SectorCount = 0;
85 PARTITION_TABLE_ENTRY PartitionTableEntry;
86 CHAR FileName[1];
87
88 if (!DissectArcPath(Path, FileName, &DriveNumber, &DrivePartition))
89 return EINVAL;
90
91 if (DrivePartition == 0xff)
92 {
93 /* This is a CD-ROM device */
94 SectorSize = 2048;
95 }
96 else
97 {
98 /*
99 * This is either a floppy disk device (DrivePartition == 0) or
100 * a hard disk device (DrivePartition != 0 && DrivePartition != 0xFF)
101 * but it doesn't matter which one because they both have 512 bytes
102 * per sector.
103 */
104 SectorSize = 512;
105 }
106
107 if (DrivePartition != 0xff && DrivePartition != 0)
108 {
109 if (!DiskGetPartitionEntry(DriveNumber, DrivePartition, &PartitionTableEntry))
110 return EINVAL;
111
112 SectorOffset = PartitionTableEntry.SectorCountBeforePartition;
113 SectorCount = PartitionTableEntry.PartitionSectorCount;
114 }
115 #if 0 // FIXME: Investigate
116 else
117 {
118 SectorCount = 0; /* FIXME */
119 }
120 #endif
121
122 Context = FrLdrTempAlloc(sizeof(DISKCONTEXT), TAG_HW_DISK_CONTEXT);
123 if (!Context)
124 return ENOMEM;
125
126 Context->DriveNumber = DriveNumber;
127 Context->SectorSize = SectorSize;
128 Context->SectorOffset = SectorOffset;
129 Context->SectorCount = SectorCount;
130 Context->SectorNumber = 0;
131 FsSetDeviceSpecific(*FileId, Context);
132
133 return ESUCCESS;
134 }
135
136 static ARC_STATUS
137 DiskRead(ULONG FileId, VOID* Buffer, ULONG N, ULONG* Count)
138 {
139 DISKCONTEXT* Context = FsGetDeviceSpecific(FileId);
140 UCHAR* Ptr = (UCHAR*)Buffer;
141 ULONG Length, TotalSectors, MaxSectors, ReadSectors;
142 BOOLEAN ret;
143 ULONGLONG SectorOffset;
144
145 TotalSectors = (N + Context->SectorSize - 1) / Context->SectorSize;
146 MaxSectors = DiskReadBufferSize / Context->SectorSize;
147 SectorOffset = Context->SectorNumber + Context->SectorOffset;
148
149 ret = TRUE;
150
151 while (TotalSectors)
152 {
153 ReadSectors = TotalSectors;
154 if (ReadSectors > MaxSectors)
155 ReadSectors = MaxSectors;
156
157 ret = MachDiskReadLogicalSectors(Context->DriveNumber,
158 SectorOffset,
159 ReadSectors,
160 DiskReadBuffer);
161 if (!ret)
162 break;
163
164 Length = ReadSectors * Context->SectorSize;
165 if (Length > N)
166 Length = N;
167
168 RtlCopyMemory(Ptr, DiskReadBuffer, Length);
169
170 Ptr += Length;
171 N -= Length;
172 SectorOffset += ReadSectors;
173 TotalSectors -= ReadSectors;
174 }
175
176 *Count = (ULONG)(Ptr - (UCHAR*)Buffer);
177
178 return (!ret) ? EIO : ESUCCESS;
179 }
180
181 static ARC_STATUS
182 DiskSeek(ULONG FileId, LARGE_INTEGER* Position, SEEKMODE SeekMode)
183 {
184 DISKCONTEXT* Context = FsGetDeviceSpecific(FileId);
185
186 if (SeekMode != SeekAbsolute)
187 return EINVAL;
188 if (Position->LowPart & (Context->SectorSize - 1))
189 return EINVAL;
190
191 Context->SectorNumber = (ULONG)(Position->QuadPart / Context->SectorSize);
192 return ESUCCESS;
193 }
194
195 static const DEVVTBL DiskVtbl =
196 {
197 DiskClose,
198 DiskGetFileInformation,
199 DiskOpen,
200 DiskRead,
201 DiskSeek,
202 };
203
204
205 PCHAR
206 GetHarddiskIdentifier(UCHAR DriveNumber)
207 {
208 return PcDiskIdentifier[DriveNumber - 0x80];
209 }
210
211 static VOID
212 GetHarddiskInformation(UCHAR DriveNumber)
213 {
214 PMASTER_BOOT_RECORD Mbr;
215 PULONG Buffer;
216 ULONG i;
217 ULONG Checksum;
218 ULONG Signature;
219 CHAR ArcName[MAX_PATH];
220 PARTITION_TABLE_ENTRY PartitionTableEntry;
221 PCHAR Identifier = PcDiskIdentifier[DriveNumber - 0x80];
222
223 /* Read the MBR */
224 if (!MachDiskReadLogicalSectors(DriveNumber, 0ULL, 1, DiskReadBuffer))
225 {
226 ERR("Reading MBR failed\n");
227 return;
228 }
229
230 Buffer = (ULONG*)DiskReadBuffer;
231 Mbr = (PMASTER_BOOT_RECORD)DiskReadBuffer;
232
233 Signature = Mbr->Signature;
234 TRACE("Signature: %x\n", Signature);
235
236 /* Calculate the MBR checksum */
237 Checksum = 0;
238 for (i = 0; i < 512 / sizeof(ULONG); i++)
239 {
240 Checksum += Buffer[i];
241 }
242 Checksum = ~Checksum + 1;
243 TRACE("Checksum: %x\n", Checksum);
244
245 /* Fill out the ARC disk block */
246 reactos_arc_disk_info[reactos_disk_count].DiskSignature.Signature = Signature;
247 reactos_arc_disk_info[reactos_disk_count].DiskSignature.CheckSum = Checksum;
248 sprintf(ArcName, "multi(0)disk(0)rdisk(%lu)", reactos_disk_count);
249 strcpy(reactos_arc_disk_info[reactos_disk_count].ArcName, ArcName);
250 reactos_arc_disk_info[reactos_disk_count].DiskSignature.ArcName =
251 reactos_arc_disk_info[reactos_disk_count].ArcName;
252 reactos_disk_count++;
253
254 sprintf(ArcName, "multi(0)disk(0)rdisk(%u)partition(0)", DriveNumber - 0x80);
255 FsRegisterDevice(ArcName, &DiskVtbl);
256
257 /* Add partitions */
258 i = 1;
259 DiskReportError(FALSE);
260 while (DiskGetPartitionEntry(DriveNumber, i, &PartitionTableEntry))
261 {
262 if (PartitionTableEntry.SystemIndicator != PARTITION_ENTRY_UNUSED)
263 {
264 sprintf(ArcName, "multi(0)disk(0)rdisk(%u)partition(%lu)", DriveNumber - 0x80, i);
265 FsRegisterDevice(ArcName, &DiskVtbl);
266 }
267 i++;
268 }
269 DiskReportError(TRUE);
270
271 /* Convert checksum and signature to identifier string */
272 Identifier[0] = Hex[(Checksum >> 28) & 0x0F];
273 Identifier[1] = Hex[(Checksum >> 24) & 0x0F];
274 Identifier[2] = Hex[(Checksum >> 20) & 0x0F];
275 Identifier[3] = Hex[(Checksum >> 16) & 0x0F];
276 Identifier[4] = Hex[(Checksum >> 12) & 0x0F];
277 Identifier[5] = Hex[(Checksum >> 8) & 0x0F];
278 Identifier[6] = Hex[(Checksum >> 4) & 0x0F];
279 Identifier[7] = Hex[Checksum & 0x0F];
280 Identifier[8] = '-';
281 Identifier[9] = Hex[(Signature >> 28) & 0x0F];
282 Identifier[10] = Hex[(Signature >> 24) & 0x0F];
283 Identifier[11] = Hex[(Signature >> 20) & 0x0F];
284 Identifier[12] = Hex[(Signature >> 16) & 0x0F];
285 Identifier[13] = Hex[(Signature >> 12) & 0x0F];
286 Identifier[14] = Hex[(Signature >> 8) & 0x0F];
287 Identifier[15] = Hex[(Signature >> 4) & 0x0F];
288 Identifier[16] = Hex[Signature & 0x0F];
289 Identifier[17] = '-';
290 Identifier[18] = 'A'; // FIXME: Not always 'A' ...
291 Identifier[19] = 0;
292 TRACE("Identifier: %s\n", Identifier);
293 }
294
295 BOOLEAN
296 PcInitializeBootDevices(VOID)
297 {
298 UCHAR DiskCount, DriveNumber;
299 ULONG i;
300 BOOLEAN Changed;
301 BOOLEAN BootDriveReported = FALSE;
302 CHAR BootPath[MAX_PATH];
303
304 /* Count the number of visible drives */
305 DiskReportError(FALSE);
306 DiskCount = 0;
307 DriveNumber = 0x80;
308
309 /*
310 * There are some really broken BIOSes out there. There are even BIOSes
311 * that happily report success when you ask them to read from non-existent
312 * harddisks. So, we set the buffer to known contents first, then try to
313 * read. If the BIOS reports success but the buffer contents haven't
314 * changed then we fail anyway.
315 */
316 memset(DiskReadBuffer, 0xcd, DiskReadBufferSize);
317 while (MachDiskReadLogicalSectors(DriveNumber, 0ULL, 1, DiskReadBuffer))
318 {
319 Changed = FALSE;
320 for (i = 0; !Changed && i < DiskReadBufferSize; i++)
321 {
322 Changed = ((PUCHAR)DiskReadBuffer)[i] != 0xcd;
323 }
324 if (!Changed)
325 {
326 TRACE("BIOS reports success for disk %d but data didn't change\n",
327 (int)DiskCount);
328 break;
329 }
330
331 /* Cache the BIOS hard disk information for later use */
332 GetHarddiskInformation(DriveNumber);
333
334 /* Check if we have seen the boot drive */
335 if (FrldrBootDrive == DriveNumber)
336 BootDriveReported = TRUE;
337
338 DiskCount++;
339 DriveNumber++;
340 memset(DiskReadBuffer, 0xcd, DiskReadBufferSize);
341 }
342 DiskReportError(TRUE);
343 TRACE("BIOS reports %d harddisk%s\n",
344 (int)DiskCount, (DiskCount == 1) ? "" : "s");
345
346 /* Get the drive we're booting from */
347 MachDiskGetBootPath(BootPath, sizeof(BootPath));
348
349 /* Add it, if it's a floppy or cdrom */
350 if ((FrldrBootDrive >= 0x80 && !BootDriveReported) ||
351 DiskIsDriveRemovable(FrldrBootDrive))
352 {
353 /* TODO: Check if it's really a CDROM drive */
354
355 PMASTER_BOOT_RECORD Mbr;
356 PULONG Buffer;
357 ULONG Checksum = 0;
358 ULONG Signature;
359
360 /* Read the MBR */
361 if (!MachDiskReadLogicalSectors(FrldrBootDrive, 16ULL, 1, DiskReadBuffer))
362 {
363 ERR("Reading MBR failed\n");
364 return FALSE;
365 }
366
367 Buffer = (ULONG*)DiskReadBuffer;
368 Mbr = (PMASTER_BOOT_RECORD)DiskReadBuffer;
369
370 Signature = Mbr->Signature;
371 TRACE("Signature: %x\n", Signature);
372
373 /* Calculate the MBR checksum */
374 for (i = 0; i < 2048 / sizeof(ULONG); i++) Checksum += Buffer[i];
375 Checksum = ~Checksum + 1;
376 TRACE("Checksum: %x\n", Checksum);
377
378 /* Fill out the ARC disk block */
379 reactos_arc_disk_info[reactos_disk_count].DiskSignature.Signature = Signature;
380 reactos_arc_disk_info[reactos_disk_count].DiskSignature.CheckSum = Checksum;
381 strcpy(reactos_arc_disk_info[reactos_disk_count].ArcName, BootPath);
382 reactos_arc_disk_info[reactos_disk_count].DiskSignature.ArcName =
383 reactos_arc_disk_info[reactos_disk_count].ArcName;
384 reactos_disk_count++;
385
386 FsRegisterDevice(BootPath, &DiskVtbl);
387 DiskCount++;
388 }
389
390 PcBiosDiskCount = DiskCount;
391 TRACE("BIOS reports %d harddisk%s\n",
392 (int)DiskCount, (DiskCount == 1) ? "": "s");
393
394 return (DiskCount != 0);
395 }