[FREELDR] Remove unnecessary checks. CORE-14280
[reactos.git] / boot / freeldr / freeldr / arch / i386 / hardware.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 #include <debug.h>
25
26 DBG_DEFAULT_CHANNEL(HWDETECT);
27
28
29 #define MILLISEC (10)
30 #define PRECISION (8)
31
32 #define HZ (100)
33 #define CLOCK_TICK_RATE (1193182)
34 #define LATCH (CLOCK_TICK_RATE / HZ)
35
36 static unsigned int delay_count = 1;
37
38 /* Used for BIOS disks pre-enumeration performed when detecting the boot devices in InitializeBootDevices() */
39 extern UCHAR PcBiosDiskCount;
40
41 /* This function is slightly different in its PC and XBOX versions */
42 GET_HARDDISK_CONFIG_DATA GetHarddiskConfigurationData = NULL;
43
44 PCHAR
45 GetHarddiskIdentifier(UCHAR DriveNumber);
46
47 /* FUNCTIONS *****************************************************************/
48
49 static
50 VOID
51 __StallExecutionProcessor(ULONG Loops)
52 {
53 register volatile unsigned int i;
54 for (i = 0; i < Loops; i++);
55 }
56
57 VOID StallExecutionProcessor(ULONG Microseconds)
58 {
59 ULONGLONG LoopCount = ((ULONGLONG)delay_count * (ULONGLONG)Microseconds) / 1000ULL;
60 __StallExecutionProcessor((ULONG)LoopCount);
61 }
62
63 static
64 ULONG
65 Read8254Timer(VOID)
66 {
67 ULONG Count;
68
69 WRITE_PORT_UCHAR((PUCHAR)0x43, 0x00);
70 Count = READ_PORT_UCHAR((PUCHAR)0x40);
71 Count |= READ_PORT_UCHAR((PUCHAR)0x40) << 8;
72
73 return Count;
74 }
75
76 static
77 VOID
78 WaitFor8254Wraparound(VOID)
79 {
80 ULONG CurCount;
81 ULONG PrevCount = ~0;
82 LONG Delta;
83
84 CurCount = Read8254Timer();
85
86 do
87 {
88 PrevCount = CurCount;
89 CurCount = Read8254Timer();
90 Delta = CurCount - PrevCount;
91
92 /*
93 * This limit for delta seems arbitrary, but it isn't, it's
94 * slightly above the level of error a buggy Mercury/Neptune
95 * chipset timer can cause.
96 */
97 }
98 while (Delta < 300);
99 }
100
101 VOID
102 HalpCalibrateStallExecution(VOID)
103 {
104 ULONG i;
105 ULONG calib_bit;
106 ULONG CurCount;
107
108 /* Initialise timer interrupt with MILLISECOND ms interval */
109 WRITE_PORT_UCHAR((PUCHAR)0x43, 0x34); /* binary, mode 2, LSB/MSB, ch 0 */
110 WRITE_PORT_UCHAR((PUCHAR)0x40, LATCH & 0xff); /* LSB */
111 WRITE_PORT_UCHAR((PUCHAR)0x40, LATCH >> 8); /* MSB */
112
113 /* Stage 1: Coarse calibration */
114
115 delay_count = 1;
116
117 do
118 {
119 /* Next delay count to try */
120 delay_count <<= 1;
121
122 WaitFor8254Wraparound();
123
124 /* Do the delay */
125 __StallExecutionProcessor(delay_count);
126
127 CurCount = Read8254Timer();
128 }
129 while (CurCount > LATCH / 2);
130
131 /* Get bottom value for delay */
132 delay_count >>= 1;
133
134 /* Stage 2: Fine calibration */
135
136 /* Which bit are we going to test */
137 calib_bit = delay_count;
138
139 for (i = 0; i < PRECISION; i++)
140 {
141 /* Next bit to calibrate */
142 calib_bit >>= 1;
143
144 /* If we have done all bits, stop */
145 if (!calib_bit) break;
146
147 /* Set the bit in delay_count */
148 delay_count |= calib_bit;
149
150 WaitFor8254Wraparound();
151
152 /* Do the delay */
153 __StallExecutionProcessor(delay_count);
154
155 CurCount = Read8254Timer();
156 /* If a tick has passed, turn the calibrated bit back off */
157 if (CurCount <= LATCH / 2)
158 delay_count &= ~calib_bit;
159 }
160
161 /* We're finished: Do the finishing touches */
162
163 /* Calculate delay_count for 1ms */
164 delay_count /= (MILLISEC / 2);
165 }
166
167
168 static
169 UCHAR
170 GetFloppyCount(VOID)
171 {
172 UCHAR Data;
173
174 WRITE_PORT_UCHAR((PUCHAR)0x70, 0x10);
175 Data = READ_PORT_UCHAR((PUCHAR)0x71);
176
177 return ((Data & 0xF0) ? 1 : 0) + ((Data & 0x0F) ? 1 : 0);
178 }
179
180 static
181 UCHAR
182 GetFloppyType(UCHAR DriveNumber)
183 {
184 UCHAR Data;
185
186 WRITE_PORT_UCHAR((PUCHAR)0x70, 0x10);
187 Data = READ_PORT_UCHAR((PUCHAR)0x71);
188
189 if (DriveNumber == 0)
190 return Data >> 4;
191 else if (DriveNumber == 1)
192 return Data & 0x0F;
193
194 return 0;
195 }
196
197 static
198 PVOID
199 GetInt1eTable(VOID)
200 {
201 PUSHORT SegPtr = (PUSHORT)0x7A;
202 PUSHORT OfsPtr = (PUSHORT)0x78;
203
204 return (PVOID)((ULONG_PTR)(((ULONG)(*SegPtr)) << 4) + (ULONG)(*OfsPtr));
205 }
206
207 static
208 VOID
209 DetectBiosFloppyPeripheral(PCONFIGURATION_COMPONENT_DATA ControllerKey)
210 {
211 PCM_PARTIAL_RESOURCE_LIST PartialResourceList;
212 PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
213 PCM_FLOPPY_DEVICE_DATA FloppyData;
214 CHAR Identifier[20];
215 PCONFIGURATION_COMPONENT_DATA PeripheralKey;
216 ULONG Size;
217 UCHAR FloppyNumber;
218 UCHAR FloppyType;
219 ULONG MaxDensity[6] = {0, 360, 1200, 720, 1440, 2880};
220 PUCHAR Ptr;
221
222 for (FloppyNumber = 0; FloppyNumber < 2; FloppyNumber++)
223 {
224 FloppyType = GetFloppyType(FloppyNumber);
225
226 if ((FloppyType > 5) || (FloppyType == 0))
227 continue;
228
229 if (!DiskResetController(FloppyNumber))
230 continue;
231
232 Ptr = GetInt1eTable();
233
234 /* Set 'Identifier' value */
235 sprintf(Identifier, "FLOPPY%d", FloppyNumber + 1);
236
237 Size = sizeof(CM_PARTIAL_RESOURCE_LIST) +
238 sizeof(CM_FLOPPY_DEVICE_DATA);
239 PartialResourceList = FrLdrHeapAlloc(Size, TAG_HW_RESOURCE_LIST);
240 if (PartialResourceList == NULL)
241 {
242 ERR("Failed to allocate resource descriptor\n");
243 return;
244 }
245
246 memset(PartialResourceList, 0, Size);
247 PartialResourceList->Version = 1;
248 PartialResourceList->Revision = 1;
249 PartialResourceList->Count = 1;
250
251 PartialDescriptor = &PartialResourceList->PartialDescriptors[0];
252 PartialDescriptor->Type = CmResourceTypeDeviceSpecific;
253 PartialDescriptor->ShareDisposition = CmResourceShareUndetermined;
254 PartialDescriptor->u.DeviceSpecificData.DataSize = sizeof(CM_FLOPPY_DEVICE_DATA);
255
256 FloppyData = (PVOID)(((ULONG_PTR)PartialResourceList) + sizeof(CM_PARTIAL_RESOURCE_LIST));
257 FloppyData->Version = 2;
258 FloppyData->Revision = 0;
259 FloppyData->MaxDensity = MaxDensity[FloppyType];
260 FloppyData->MountDensity = 0;
261 RtlCopyMemory(&FloppyData->StepRateHeadUnloadTime, Ptr, 11);
262 FloppyData->MaximumTrackValue = (FloppyType == 1) ? 39 : 79;
263 FloppyData->DataTransferRate = 0;
264
265 FldrCreateComponentKey(ControllerKey,
266 PeripheralClass,
267 FloppyDiskPeripheral,
268 Input | Output,
269 FloppyNumber,
270 0xFFFFFFFF,
271 Identifier,
272 PartialResourceList,
273 Size,
274 &PeripheralKey);
275 }
276 }
277
278 static
279 PCONFIGURATION_COMPONENT_DATA
280 DetectBiosFloppyController(PCONFIGURATION_COMPONENT_DATA BusKey)
281 {
282 PCONFIGURATION_COMPONENT_DATA ControllerKey;
283 PCM_PARTIAL_RESOURCE_LIST PartialResourceList;
284 PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
285 ULONG Size;
286 ULONG FloppyCount;
287
288 FloppyCount = GetFloppyCount();
289 TRACE("Floppy count: %u\n", FloppyCount);
290
291 /* Always create a BIOS disk controller, no matter if we have floppy drives or not */
292 Size = sizeof(CM_PARTIAL_RESOURCE_LIST) +
293 2 * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
294 PartialResourceList = FrLdrHeapAlloc(Size, TAG_HW_RESOURCE_LIST);
295 if (PartialResourceList == NULL)
296 {
297 ERR("Failed to allocate resource descriptor\n");
298 return NULL;
299 }
300 memset(PartialResourceList, 0, Size);
301
302 /* Initialize resource descriptor */
303 PartialResourceList->Version = 1;
304 PartialResourceList->Revision = 1;
305 PartialResourceList->Count = 3;
306
307 /* Set IO Port */
308 PartialDescriptor = &PartialResourceList->PartialDescriptors[0];
309 PartialDescriptor->Type = CmResourceTypePort;
310 PartialDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
311 PartialDescriptor->Flags = CM_RESOURCE_PORT_IO;
312 PartialDescriptor->u.Port.Start.LowPart = 0x03F0;
313 PartialDescriptor->u.Port.Start.HighPart = 0x0;
314 PartialDescriptor->u.Port.Length = 8;
315
316 /* Set Interrupt */
317 PartialDescriptor = &PartialResourceList->PartialDescriptors[1];
318 PartialDescriptor->Type = CmResourceTypeInterrupt;
319 PartialDescriptor->ShareDisposition = CmResourceShareUndetermined;
320 PartialDescriptor->Flags = CM_RESOURCE_INTERRUPT_LATCHED;
321 PartialDescriptor->u.Interrupt.Level = 6;
322 PartialDescriptor->u.Interrupt.Vector = 6;
323 PartialDescriptor->u.Interrupt.Affinity = 0xFFFFFFFF;
324
325 /* Set DMA channel */
326 PartialDescriptor = &PartialResourceList->PartialDescriptors[2];
327 PartialDescriptor->Type = CmResourceTypeDma;
328 PartialDescriptor->ShareDisposition = CmResourceShareUndetermined;
329 PartialDescriptor->Flags = 0;
330 PartialDescriptor->u.Dma.Channel = 2;
331 PartialDescriptor->u.Dma.Port = 0;
332
333 /* Create floppy disk controller */
334 FldrCreateComponentKey(BusKey,
335 ControllerClass,
336 DiskController,
337 Output | Input,
338 0x0,
339 0xFFFFFFFF,
340 NULL,
341 PartialResourceList,
342 Size,
343 &ControllerKey);
344 TRACE("Created key: DiskController\\0\n");
345
346 if (FloppyCount)
347 DetectBiosFloppyPeripheral(ControllerKey);
348
349 return ControllerKey;
350 }
351
352 VOID
353 DetectBiosDisks(PCONFIGURATION_COMPONENT_DATA SystemKey,
354 PCONFIGURATION_COMPONENT_DATA BusKey)
355 {
356 PCONFIGURATION_COMPONENT_DATA ControllerKey, DiskKey;
357 PCM_PARTIAL_RESOURCE_LIST PartialResourceList;
358 PCM_INT13_DRIVE_PARAMETER Int13Drives;
359 GEOMETRY Geometry;
360 UCHAR DiskCount, DriveNumber;
361 USHORT i;
362 ULONG Size;
363
364 /* The pre-enumeration of the BIOS disks was already done in InitializeBootDevices() */
365 DiskCount = PcBiosDiskCount;
366
367 /* Use the floppy disk controller as our controller */
368 ControllerKey = DetectBiosFloppyController(BusKey);
369 if (!ControllerKey)
370 {
371 ERR("Failed to detect BIOS disk controller\n");
372 return;
373 }
374
375 /* Allocate resource descriptor */
376 Size = sizeof(CM_PARTIAL_RESOURCE_LIST) +
377 sizeof(CM_INT13_DRIVE_PARAMETER) * DiskCount;
378 PartialResourceList = FrLdrHeapAlloc(Size, TAG_HW_RESOURCE_LIST);
379 if (PartialResourceList == NULL)
380 {
381 ERR("Failed to allocate resource descriptor\n");
382 return;
383 }
384
385 /* Initialize resource descriptor */
386 memset(PartialResourceList, 0, Size);
387 PartialResourceList->Version = 1;
388 PartialResourceList->Revision = 1;
389 PartialResourceList->Count = 1;
390 PartialResourceList->PartialDescriptors[0].Type = CmResourceTypeDeviceSpecific;
391 PartialResourceList->PartialDescriptors[0].ShareDisposition = 0;
392 PartialResourceList->PartialDescriptors[0].Flags = 0;
393 PartialResourceList->PartialDescriptors[0].u.DeviceSpecificData.DataSize =
394 sizeof(CM_INT13_DRIVE_PARAMETER) * DiskCount;
395
396 /* Get harddisk Int13 geometry data */
397 Int13Drives = (PVOID)(((ULONG_PTR)PartialResourceList) + sizeof(CM_PARTIAL_RESOURCE_LIST));
398 for (i = 0; i < DiskCount; i++)
399 {
400 DriveNumber = 0x80 + i;
401
402 if (MachDiskGetDriveGeometry(DriveNumber, &Geometry))
403 {
404 Int13Drives[i].DriveSelect = DriveNumber;
405 Int13Drives[i].MaxCylinders = Geometry.Cylinders - 1;
406 Int13Drives[i].SectorsPerTrack = (USHORT)Geometry.Sectors;
407 Int13Drives[i].MaxHeads = (USHORT)Geometry.Heads - 1;
408 Int13Drives[i].NumberDrives = DiskCount;
409
410 TRACE("Disk %x: %u Cylinders %u Heads %u Sectors %u Bytes\n",
411 DriveNumber,
412 Geometry.Cylinders - 1,
413 Geometry.Heads - 1,
414 Geometry.Sectors,
415 Geometry.BytesPerSector);
416 }
417 }
418
419 /* Update the 'System' key's configuration data with BIOS INT13h information */
420 FldrSetConfigurationData(SystemKey, PartialResourceList, Size);
421
422 /* Create and fill subkey for each harddisk */
423 for (i = 0; i < DiskCount; i++)
424 {
425 PCHAR Identifier;
426
427 DriveNumber = 0x80 + i;
428
429 /* Get disk values */
430 PartialResourceList = GetHarddiskConfigurationData(DriveNumber, &Size);
431 Identifier = GetHarddiskIdentifier(DriveNumber);
432
433 /* Create disk key */
434 FldrCreateComponentKey(ControllerKey,
435 PeripheralClass,
436 DiskPeripheral,
437 Output | Input,
438 0x0,
439 0xFFFFFFFF,
440 Identifier,
441 PartialResourceList,
442 Size,
443 &DiskKey);
444 }
445 }
446
447 VOID
448 FrLdrCheckCpuCompatibility(VOID)
449 {
450 INT CpuInformation[4] = {-1};
451 ULONG NumberOfIds;
452
453 /* Check if the processor first supports ID 1 */
454 __cpuid(CpuInformation, 0);
455
456 NumberOfIds = CpuInformation[0];
457
458 if (NumberOfIds == 0)
459 {
460 FrLdrBugCheckWithMessage(MISSING_HARDWARE_REQUIREMENTS,
461 __FILE__,
462 __LINE__,
463 "ReactOS requires the CPUID instruction to return "
464 "more than one supported ID.\n\n");
465 }
466
467 /* NumberOfIds will be greater than 1 if the processor is new enough */
468 if (NumberOfIds == 1)
469 {
470 INT ProcessorFamily;
471
472 /* Get information */
473 __cpuid(CpuInformation, 1);
474
475 ProcessorFamily = (CpuInformation[0] >> 8) & 0xF;
476
477 /* If it's Family 4 or lower, bugcheck */
478 if (ProcessorFamily < 5)
479 {
480 FrLdrBugCheckWithMessage(MISSING_HARDWARE_REQUIREMENTS,
481 __FILE__,
482 __LINE__,
483 "Processor is too old (family %u < 5)\n"
484 "ReactOS requires a Pentium-level processor or newer.",
485 ProcessorFamily);
486 }
487 }
488 }
489
490 /* EOF */