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