c3d783d647e96e65a7e93d235cc2d4974a5e3115
[reactos.git] / hal / halx86 / legacy / halpnpdd.c
1 /*
2 * PROJECT: ReactOS HAL
3 * LICENSE: BSD - See COPYING.ARM in the top level directory
4 * FILE: hal/halx86/generic/legacy/halpnpdd.c
5 * PURPOSE: HAL Plug and Play Device Driver
6 * PROGRAMMERS: ReactOS Portable Systems Group
7 */
8
9 /* INCLUDES *******************************************************************/
10
11 #include <hal.h>
12 #define NDEBUG
13 #include <debug.h>
14
15 typedef enum _EXTENSION_TYPE
16 {
17 PdoExtensionType = 0xC0,
18 FdoExtensionType
19 } EXTENSION_TYPE;
20
21 typedef enum _PDO_TYPE
22 {
23 AcpiPdo = 0x80,
24 WdPdo
25 } PDO_TYPE;
26
27 typedef struct _FDO_EXTENSION
28 {
29 EXTENSION_TYPE ExtensionType;
30 struct _PDO_EXTENSION* ChildPdoList;
31 PDEVICE_OBJECT PhysicalDeviceObject;
32 PDEVICE_OBJECT FunctionalDeviceObject;
33 PDEVICE_OBJECT AttachedDeviceObject;
34 } FDO_EXTENSION, *PFDO_EXTENSION;
35
36 typedef struct _PDO_EXTENSION
37 {
38 EXTENSION_TYPE ExtensionType;
39 struct _PDO_EXTENSION* Next;
40 PDEVICE_OBJECT PhysicalDeviceObject;
41 PFDO_EXTENSION ParentFdoExtension;
42 PDO_TYPE PdoType;
43 PDESCRIPTION_HEADER WdTable;
44 LONG InterfaceReferenceCount;
45 } PDO_EXTENSION, *PPDO_EXTENSION;
46
47 /* GLOBALS ********************************************************************/
48
49 PDRIVER_OBJECT HalpDriverObject;
50
51 /* PRIVATE FUNCTIONS **********************************************************/
52
53 NTSTATUS
54 NTAPI
55 HalpAddDevice(IN PDRIVER_OBJECT DriverObject,
56 IN PDEVICE_OBJECT TargetDevice)
57 {
58 NTSTATUS Status;
59 PFDO_EXTENSION FdoExtension;
60 PPDO_EXTENSION PdoExtension;
61 PDEVICE_OBJECT DeviceObject, PdoDeviceObject, AttachedDevice;
62 // PDESCRIPTION_HEADER Wdrt;
63 DPRINT("HAL: PnP Driver ADD!\n");
64
65 /* Create the FDO */
66 Status = IoCreateDevice(DriverObject,
67 sizeof(FDO_EXTENSION),
68 NULL,
69 FILE_DEVICE_BUS_EXTENDER,
70 0,
71 FALSE,
72 &DeviceObject);
73 if (!NT_SUCCESS(Status))
74 {
75 /* Should not happen */
76 DbgBreakPoint();
77 return Status;
78 }
79
80 /* Setup the FDO extension */
81 FdoExtension = DeviceObject->DeviceExtension;
82 FdoExtension->ExtensionType = FdoExtensionType;
83 FdoExtension->PhysicalDeviceObject = TargetDevice;
84 FdoExtension->FunctionalDeviceObject = DeviceObject;
85 FdoExtension->ChildPdoList = NULL;
86
87 /* FDO is done initializing */
88 DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
89
90 /* Attach to the physical device object (the bus) */
91 AttachedDevice = IoAttachDeviceToDeviceStack(DeviceObject, TargetDevice);
92 if (!AttachedDevice)
93 {
94 /* Failed, undo everything */
95 IoDeleteDevice(DeviceObject);
96 return STATUS_NO_SUCH_DEVICE;
97 }
98
99 /* Save the attachment */
100 FdoExtension->AttachedDeviceObject = AttachedDevice;
101
102 /* Create the PDO */
103 Status = IoCreateDevice(DriverObject,
104 sizeof(PDO_EXTENSION),
105 NULL,
106 FILE_DEVICE_BUS_EXTENDER,
107 FILE_AUTOGENERATED_DEVICE_NAME,
108 FALSE,
109 &PdoDeviceObject);
110 if (!NT_SUCCESS(Status))
111 {
112 /* Fail */
113 DPRINT1("HAL: Could not create ACPI device object status=0x%08x\n", Status);
114 return Status;
115 }
116
117 /* Setup the PDO device extension */
118 PdoExtension = PdoDeviceObject->DeviceExtension;
119 PdoExtension->ExtensionType = PdoExtensionType;
120 PdoExtension->PhysicalDeviceObject = PdoDeviceObject;
121 PdoExtension->ParentFdoExtension = FdoExtension;
122 PdoExtension->PdoType = AcpiPdo;
123
124 /* Add the PDO to the head of the list */
125 PdoExtension->Next = FdoExtension->ChildPdoList;
126 FdoExtension->ChildPdoList = PdoExtension;
127
128 /* Initialization is finished */
129 PdoDeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
130
131 #if 0
132 /* Find the ACPI watchdog table */
133 Wdrt = HalAcpiGetTable(0, 'TRDW');
134 if (Wdrt)
135 {
136 /* FIXME: TODO */
137 DPRINT1("You have an ACPI Watchdog. That's great! You should be proud ;-)\n");
138 }
139 #endif
140
141 /* Invalidate device relations since we added a new device */
142 IoInvalidateDeviceRelations(TargetDevice, BusRelations);
143
144 /* Return status */
145 DPRINT("Device added %lx\n", Status);
146 return Status;
147 }
148
149 NTSTATUS
150 NTAPI
151 HalpQueryInterface(IN PDEVICE_OBJECT DeviceObject,
152 IN CONST GUID* InterfaceType,
153 IN USHORT Version,
154 IN PVOID InterfaceSpecificData,
155 IN ULONG InterfaceBufferSize,
156 IN PINTERFACE Interface,
157 OUT PULONG Length)
158 {
159 UNIMPLEMENTED;
160 while (TRUE);
161 return STATUS_NO_SUCH_DEVICE;
162 }
163
164 NTSTATUS
165 NTAPI
166 HalpQueryDeviceRelations(IN PDEVICE_OBJECT DeviceObject,
167 IN DEVICE_RELATION_TYPE RelationType,
168 OUT PDEVICE_RELATIONS* DeviceRelations)
169 {
170 EXTENSION_TYPE ExtensionType;
171 PPDO_EXTENSION PdoExtension;
172 PFDO_EXTENSION FdoExtension;
173 PDEVICE_RELATIONS PdoRelations, FdoRelations;
174 PDEVICE_OBJECT* ObjectEntry;
175 ULONG i = 0, PdoCount = 0;
176
177 /* Get FDO device extension and PDO count */
178 FdoExtension = DeviceObject->DeviceExtension;
179 ExtensionType = FdoExtension->ExtensionType;
180
181 /* What do they want? */
182 if (RelationType == BusRelations)
183 {
184 /* This better be an FDO */
185 if (ExtensionType == FdoExtensionType)
186 {
187 /* Count how many PDOs we have */
188 PdoExtension = FdoExtension->ChildPdoList;
189 while (PdoExtension)
190 {
191 /* Next one */
192 PdoExtension = PdoExtension->Next;
193 PdoCount++;
194 }
195
196 /* Add the PDOs that already exist in the device relations */
197 if (*DeviceRelations)
198 {
199 PdoCount += (*DeviceRelations)->Count;
200 }
201
202 /* Allocate our structure */
203 FdoRelations = ExAllocatePoolWithTag(PagedPool,
204 FIELD_OFFSET(DEVICE_RELATIONS,
205 Objects) +
206 sizeof(PDEVICE_OBJECT) * PdoCount,
207 ' laH');
208 if (!FdoRelations) return STATUS_INSUFFICIENT_RESOURCES;
209
210 /* Save our count */
211 FdoRelations->Count = PdoCount;
212
213 /* Query existing relations */
214 ObjectEntry = FdoRelations->Objects;
215 if (*DeviceRelations)
216 {
217 /* Check if there were any */
218 if ((*DeviceRelations)->Count)
219 {
220 /* Loop them all */
221 do
222 {
223 /* Copy into our structure */
224 *ObjectEntry++ = (*DeviceRelations)->Objects[i];
225 }
226 while (++i < (*DeviceRelations)->Count);
227 }
228
229 /* Free existing structure */
230 ExFreePool(*DeviceRelations);
231 }
232
233 /* Now check if we have a PDO list */
234 PdoExtension = FdoExtension->ChildPdoList;
235 if (PdoExtension)
236 {
237 /* Loop the PDOs */
238 do
239 {
240 /* Save our own PDO and reference it */
241 *ObjectEntry++ = PdoExtension->PhysicalDeviceObject;
242 ObfReferenceObject(PdoExtension->PhysicalDeviceObject);
243
244 /* Go to our next PDO */
245 PdoExtension = PdoExtension->Next;
246 }
247 while (PdoExtension);
248 }
249
250 /* Return the new structure */
251 *DeviceRelations = FdoRelations;
252 return STATUS_SUCCESS;
253 }
254 }
255 else
256 {
257 /* The only other thing we support is a target relation for the PDO */
258 if ((RelationType == TargetDeviceRelation) &&
259 (ExtensionType == PdoExtensionType))
260 {
261 /* Only one entry */
262 PdoRelations = ExAllocatePoolWithTag(PagedPool,
263 sizeof(DEVICE_RELATIONS),
264 ' laH');
265 if (!PdoRelations) return STATUS_INSUFFICIENT_RESOURCES;
266
267 /* Fill it out and reference us */
268 PdoRelations->Count = 1;
269 PdoRelations->Objects[0] = DeviceObject;
270 ObfReferenceObject(DeviceObject);
271
272 /* Return it */
273 *DeviceRelations = PdoRelations;
274 return STATUS_SUCCESS;
275 }
276 }
277
278 /* We don't support anything else */
279 return STATUS_NOT_SUPPORTED;
280 }
281
282 NTSTATUS
283 NTAPI
284 HalpQueryCapabilities(IN PDEVICE_OBJECT DeviceObject,
285 OUT PDEVICE_CAPABILITIES Capabilities)
286 {
287 //PPDO_EXTENSION PdoExtension;
288 NTSTATUS Status;
289 PAGED_CODE();
290
291 /* Get the extension and check for valid version */
292 //PdoExtension = DeviceObject->DeviceExtension;
293 ASSERT(Capabilities->Version == 1);
294 if (Capabilities->Version == 1)
295 {
296 /* Can't lock or eject us */
297 Capabilities->LockSupported = FALSE;
298 Capabilities->EjectSupported = FALSE;
299
300 /* Can't remove or dock us */
301 Capabilities->Removable = FALSE;
302 Capabilities->DockDevice = FALSE;
303
304 /* Can't access us raw */
305 Capabilities->RawDeviceOK = FALSE;
306
307 /* We have a unique ID, and don't bother the user */
308 Capabilities->UniqueID = TRUE;
309 Capabilities->SilentInstall = TRUE;
310
311 /* Fill out the adress */
312 Capabilities->Address = InterfaceTypeUndefined;
313 Capabilities->UINumber = InterfaceTypeUndefined;
314
315 /* Fill out latencies */
316 Capabilities->D1Latency = 0;
317 Capabilities->D2Latency = 0;
318 Capabilities->D3Latency = 0;
319
320 /* Fill out supported device states */
321 Capabilities->DeviceState[PowerSystemWorking] = PowerDeviceD0;
322 Capabilities->DeviceState[PowerSystemHibernate] = PowerDeviceD3;
323 Capabilities->DeviceState[PowerSystemShutdown] = PowerDeviceD3;
324 Capabilities->DeviceState[PowerSystemSleeping3] = PowerDeviceD3;
325
326 /* Done */
327 Status = STATUS_SUCCESS;
328 }
329 else
330 {
331 /* Fail */
332 Status = STATUS_NOT_SUPPORTED;
333 }
334
335 /* Return status */
336 return Status;
337 }
338
339 NTSTATUS
340 NTAPI
341 HalpQueryResources(IN PDEVICE_OBJECT DeviceObject,
342 OUT PCM_RESOURCE_LIST *Resources)
343 {
344 PPDO_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
345 NTSTATUS Status;
346 PCM_RESOURCE_LIST ResourceList;
347 // PIO_RESOURCE_REQUIREMENTS_LIST RequirementsList;
348 // PIO_RESOURCE_DESCRIPTOR Descriptor;
349 // PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDesc;
350 // ULONG i;
351 PAGED_CODE();
352
353 /* Only the ACPI PDO has requirements */
354 if (DeviceExtension->PdoType == AcpiPdo)
355 {
356 #if 0
357 /* Query ACPI requirements */
358 Status = HalpQueryAcpiResourceRequirements(&RequirementsList);
359 if (!NT_SUCCESS(Status)) return Status;
360
361 ASSERT(RequirementsList->AlternativeLists == 1);
362 #endif
363
364 /* Allocate the resourcel ist */
365 ResourceList = ExAllocatePoolWithTag(PagedPool,
366 sizeof(CM_RESOURCE_LIST),
367 ' laH');
368 if (!ResourceList )
369 {
370 /* Fail, no memory */
371 Status = STATUS_INSUFFICIENT_RESOURCES;
372 // ExFreePoolWithTag(RequirementsList, ' laH');
373 return Status;
374 }
375
376 /* Initialize it */
377 RtlZeroMemory(ResourceList, sizeof(CM_RESOURCE_LIST));
378 ResourceList->Count = 1;
379
380 /* Setup the list fields */
381 ResourceList->List[0].BusNumber = -1;
382 ResourceList->List[0].InterfaceType = PNPBus;
383 ResourceList->List[0].PartialResourceList.Version = 1;
384 ResourceList->List[0].PartialResourceList.Revision = 1;
385 ResourceList->List[0].PartialResourceList.Count = 0;
386
387 /* Setup the first descriptor */
388 //PartialDesc = ResourceList->List[0].PartialResourceList.PartialDescriptors;
389
390 /* Find the requirement descriptor for the SCI */
391 #if 0
392 for (i = 0; i < RequirementsList->List[0].Count; i++)
393 {
394 /* Get this descriptor */
395 Descriptor = &RequirementsList->List[0].Descriptors[i];
396 if (Descriptor->Type == CmResourceTypeInterrupt)
397 {
398 /* Copy requirements descriptor into resource descriptor */
399 PartialDesc->Type = CmResourceTypeInterrupt;
400 PartialDesc->ShareDisposition = Descriptor->ShareDisposition;
401 PartialDesc->Flags = Descriptor->Flags;
402 ASSERT(Descriptor->u.Interrupt.MinimumVector ==
403 Descriptor->u.Interrupt.MaximumVector);
404 PartialDesc->u.Interrupt.Vector = Descriptor->u.Interrupt.MinimumVector;
405 PartialDesc->u.Interrupt.Level = Descriptor->u.Interrupt.MinimumVector;
406 PartialDesc->u.Interrupt.Affinity = 0xFFFFFFFF;
407
408 ResourceList->List[0].PartialResourceList.Count++;
409
410 break;
411 }
412 }
413 #endif
414
415 /* Return resources and success */
416 *Resources = ResourceList;
417
418 // ExFreePoolWithTag(RequirementsList, ' laH');
419
420 return STATUS_SUCCESS;
421 }
422 else if (DeviceExtension->PdoType == WdPdo)
423 {
424 /* Watchdog doesn't */
425 return STATUS_NOT_SUPPORTED;
426 }
427 else
428 {
429 /* This shouldn't happen */
430 return STATUS_UNSUCCESSFUL;
431 }
432 }
433
434 NTSTATUS
435 NTAPI
436 HalpQueryResourceRequirements(IN PDEVICE_OBJECT DeviceObject,
437 OUT PIO_RESOURCE_REQUIREMENTS_LIST *Requirements)
438 {
439 PPDO_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
440 PAGED_CODE();
441
442 /* Only the ACPI PDO has requirements */
443 if (DeviceExtension->PdoType == AcpiPdo)
444 {
445 /* Query ACPI requirements */
446 // return HalpQueryAcpiResourceRequirements(Requirements);
447 return STATUS_SUCCESS;
448 }
449 else if (DeviceExtension->PdoType == WdPdo)
450 {
451 /* Watchdog doesn't */
452 return STATUS_NOT_SUPPORTED;
453 }
454 else
455 {
456 /* This shouldn't happen */
457 return STATUS_UNSUCCESSFUL;
458 }
459 }
460
461 NTSTATUS
462 NTAPI
463 HalpQueryIdPdo(IN PDEVICE_OBJECT DeviceObject,
464 IN BUS_QUERY_ID_TYPE IdType,
465 OUT PUSHORT *BusQueryId)
466 {
467 PPDO_EXTENSION PdoExtension;
468 PDO_TYPE PdoType;
469 PWCHAR CurrentId;
470 WCHAR Id[100];
471 NTSTATUS Status;
472 ULONG Length = 0;
473 PWCHAR Buffer;
474
475 /* Get the PDO type */
476 PdoExtension = DeviceObject->DeviceExtension;
477 PdoType = PdoExtension->PdoType;
478
479 /* What kind of ID is being requested? */
480 DPRINT("ID: %d\n", IdType);
481 switch (IdType)
482 {
483 case BusQueryDeviceID:
484 case BusQueryHardwareIDs:
485
486 /* What kind of PDO is this? */
487 if (PdoType == AcpiPdo)
488 {
489 /* ACPI ID */
490 CurrentId = L"PCI_HAL\\PNP0A03";
491 RtlCopyMemory(Id, CurrentId, (wcslen(CurrentId) * sizeof(WCHAR)) + sizeof(UNICODE_NULL));
492 Length += (wcslen(CurrentId) * sizeof(WCHAR)) + sizeof(UNICODE_NULL);
493
494 CurrentId = L"*PNP0A03";
495 RtlCopyMemory(&Id[wcslen(Id) + 1], CurrentId, (wcslen(CurrentId) * sizeof(WCHAR)) + sizeof(UNICODE_NULL));
496 Length += (wcslen(CurrentId) * sizeof(WCHAR)) + sizeof(UNICODE_NULL);
497 }
498 #if 0
499 else if (PdoType == WdPdo)
500 {
501 /* WatchDog ID */
502 CurrentId = L"ACPI_HAL\\PNP0C18";
503 RtlCopyMemory(Id, CurrentId, (wcslen(CurrentId) * sizeof(WCHAR)) + sizeof(UNICODE_NULL));
504 Length += (wcslen(CurrentId) * sizeof(WCHAR)) + sizeof(UNICODE_NULL);
505
506 CurrentId = L"*PNP0C18";
507 RtlCopyMemory(&Id[wcslen(Id) + 1], CurrentId, (wcslen(CurrentId) * sizeof(WCHAR)) + sizeof(UNICODE_NULL));
508 Length += (wcslen(CurrentId) * sizeof(WCHAR)) + sizeof(UNICODE_NULL);
509 }
510 #endif
511 else
512 {
513 /* Unknown */
514 return STATUS_NOT_SUPPORTED;
515 }
516 break;
517
518 case BusQueryInstanceID:
519
520 /* Instance ID */
521 CurrentId = L"0";
522 RtlCopyMemory(Id, CurrentId, (wcslen(CurrentId) * sizeof(WCHAR)) + sizeof(UNICODE_NULL));
523 Length += (wcslen(CurrentId) * sizeof(WCHAR)) + sizeof(UNICODE_NULL);
524 break;
525
526 case BusQueryCompatibleIDs:
527 default:
528
529 /* We don't support anything else */
530 return STATUS_NOT_SUPPORTED;
531 }
532
533 /* Allocate the buffer */
534 Buffer = ExAllocatePoolWithTag(PagedPool,
535 Length + sizeof(UNICODE_NULL),
536 ' laH');
537 if (Buffer)
538 {
539 /* Copy the string and null-terminate it */
540 RtlCopyMemory(Buffer, Id, Length);
541 Buffer[Length / sizeof(WCHAR)] = UNICODE_NULL;
542
543 /* Return string */
544 *BusQueryId = Buffer;
545 Status = STATUS_SUCCESS;
546 DPRINT("Returning: %S\n", *BusQueryId);
547 }
548 else
549 {
550 /* Fail */
551 Status = STATUS_INSUFFICIENT_RESOURCES;
552 }
553
554 /* Return status */
555 return Status;
556 }
557
558 NTSTATUS
559 NTAPI
560 HalpQueryIdFdo(IN PDEVICE_OBJECT DeviceObject,
561 IN BUS_QUERY_ID_TYPE IdType,
562 OUT PUSHORT *BusQueryId)
563 {
564 NTSTATUS Status;
565 ULONG Length;
566 PWCHAR Id;
567 PWCHAR Buffer;
568
569 /* What kind of ID is being requested? */
570 DPRINT("ID: %d\n", IdType);
571 switch (IdType)
572 {
573 case BusQueryDeviceID:
574 /* HACK */
575 Id = L"Root\\PCI_HAL";
576 break;
577
578 case BusQueryHardwareIDs:
579
580 /* This is our hardware ID */
581 Id = HalHardwareIdString;
582 break;
583
584 case BusQueryInstanceID:
585
586 /* And our instance ID */
587 Id = L"0";
588 break;
589
590 default:
591
592 /* We don't support anything else */
593 return STATUS_NOT_SUPPORTED;
594 }
595
596 /* Calculate the length */
597 Length = (wcslen(Id) * sizeof(WCHAR)) + sizeof(UNICODE_NULL);
598
599 /* Allocate the buffer */
600 Buffer = ExAllocatePoolWithTag(PagedPool,
601 Length + sizeof(UNICODE_NULL),
602 ' laH');
603 if (Buffer)
604 {
605 /* Copy the string and null-terminate it */
606 RtlCopyMemory(Buffer, Id, Length);
607 Buffer[Length / sizeof(WCHAR)] = UNICODE_NULL;
608
609 /* Return string */
610 *BusQueryId = Buffer;
611 Status = STATUS_SUCCESS;
612 DPRINT("Returning: %S\n", *BusQueryId);
613 }
614 else
615 {
616 /* Fail */
617 Status = STATUS_INSUFFICIENT_RESOURCES;
618 }
619
620 /* Return status */
621 return Status;
622 }
623
624 NTSTATUS
625 NTAPI
626 HalpDispatchPnp(IN PDEVICE_OBJECT DeviceObject,
627 IN PIRP Irp)
628 {
629 PIO_STACK_LOCATION IoStackLocation;
630 //PPDO_EXTENSION PdoExtension;
631 PFDO_EXTENSION FdoExtension;
632 NTSTATUS Status;
633 UCHAR Minor;
634
635 /* Get the device extension and stack location */
636 FdoExtension = DeviceObject->DeviceExtension;
637 IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
638 Minor = IoStackLocation->MinorFunction;
639
640 /* FDO? */
641 if (FdoExtension->ExtensionType == FdoExtensionType)
642 {
643 /* Query the IRP type */
644 switch (Minor)
645 {
646 case IRP_MN_QUERY_DEVICE_RELATIONS:
647
648 /* Call the worker */
649 DPRINT("Querying device relations for FDO\n");
650 Status = HalpQueryDeviceRelations(DeviceObject,
651 IoStackLocation->Parameters.QueryDeviceRelations.Type,
652 (PVOID)&Irp->IoStatus.Information);
653 break;
654
655 case IRP_MN_QUERY_INTERFACE:
656
657 /* Call the worker */
658 DPRINT("Querying interface for FDO\n");
659 Status = HalpQueryInterface(DeviceObject,
660 IoStackLocation->Parameters.QueryInterface.InterfaceType,
661 IoStackLocation->Parameters.QueryInterface.Size,
662 IoStackLocation->Parameters.QueryInterface.InterfaceSpecificData,
663 IoStackLocation->Parameters.QueryInterface.Version,
664 IoStackLocation->Parameters.QueryInterface.Interface,
665 (PVOID)&Irp->IoStatus.Information);
666 break;
667
668 case IRP_MN_QUERY_ID:
669
670 /* Call the worker */
671 DPRINT("Querying ID for FDO\n");
672 Status = HalpQueryIdFdo(DeviceObject,
673 IoStackLocation->Parameters.QueryId.IdType,
674 (PVOID)&Irp->IoStatus.Information);
675 break;
676
677 case IRP_MN_QUERY_CAPABILITIES:
678
679 /* Call the worker */
680 DPRINT("Querying the capabilities for the FDO\n");
681 Status = HalpQueryCapabilities(DeviceObject,
682 IoStackLocation->Parameters.DeviceCapabilities.Capabilities);
683 break;
684
685 default:
686
687 DPRINT("Other IRP: %lx\n", Minor);
688 Status = Irp->IoStatus.Status;
689 break;
690 }
691
692 /* Nowhere for the IRP to go since we also own the PDO */
693 Irp->IoStatus.Status = Status;
694 IoCompleteRequest(Irp, IO_NO_INCREMENT);
695 return Status;
696 }
697 else
698 {
699 /* This is a PDO instead */
700 ASSERT(FdoExtension->ExtensionType == PdoExtensionType);
701 //PdoExtension = (PPDO_EXTENSION)FdoExtension;
702
703 /* Query the IRP type */
704 Status = STATUS_SUCCESS;
705 switch (Minor)
706 {
707 case IRP_MN_START_DEVICE:
708
709 /* We only care about a PCI PDO */
710 DPRINT1("Start device received\n");
711 /* Complete the IRP normally */
712 break;
713
714 case IRP_MN_REMOVE_DEVICE:
715
716 /* Check if this is a PCI device */
717 DPRINT1("Remove device received\n");
718
719 /* We're done */
720 Status = STATUS_SUCCESS;
721 break;
722
723 case IRP_MN_SURPRISE_REMOVAL:
724
725 /* Inherit whatever status we had */
726 DPRINT1("Surprise removal IRP\n");
727 Status = Irp->IoStatus.Status;
728 break;
729
730 case IRP_MN_QUERY_DEVICE_RELATIONS:
731
732 /* Query the device relations */
733 DPRINT("Querying PDO relations\n");
734 Status = HalpQueryDeviceRelations(DeviceObject,
735 IoStackLocation->Parameters.QueryDeviceRelations.Type,
736 (PVOID)&Irp->IoStatus.Information);
737 break;
738
739 case IRP_MN_QUERY_INTERFACE:
740
741 /* Call the worker */
742 DPRINT("Querying interface for PDO\n");
743 Status = HalpQueryInterface(DeviceObject,
744 IoStackLocation->Parameters.QueryInterface.InterfaceType,
745 IoStackLocation->Parameters.QueryInterface.Size,
746 IoStackLocation->Parameters.QueryInterface.InterfaceSpecificData,
747 IoStackLocation->Parameters.QueryInterface.Version,
748 IoStackLocation->Parameters.QueryInterface.Interface,
749 (PVOID)&Irp->IoStatus.Information);
750 break;
751
752 case IRP_MN_QUERY_CAPABILITIES:
753
754 /* Call the worker */
755 DPRINT("Querying the capabilities for the PDO\n");
756 Status = HalpQueryCapabilities(DeviceObject,
757 IoStackLocation->Parameters.DeviceCapabilities.Capabilities);
758 break;
759
760 case IRP_MN_QUERY_RESOURCES:
761
762 /* Call the worker */
763 DPRINT("Querying the resources for the PDO\n");
764 Status = HalpQueryResources(DeviceObject, (PVOID)&Irp->IoStatus.Information);
765 break;
766
767 case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
768
769 /* Call the worker */
770 DPRINT("Querying the resource requirements for the PDO\n");
771 Status = HalpQueryResourceRequirements(DeviceObject,
772 (PVOID)&Irp->IoStatus.Information);
773 break;
774
775 case IRP_MN_QUERY_ID:
776
777 /* Call the worker */
778 DPRINT("Query the ID for the PDO\n");
779 Status = HalpQueryIdPdo(DeviceObject,
780 IoStackLocation->Parameters.QueryId.IdType,
781 (PVOID)&Irp->IoStatus.Information);
782 break;
783
784 default:
785
786 /* We don't handle anything else, so inherit the old state */
787 DPRINT("Illegal IRP: %lx\n", Minor);
788 Status = Irp->IoStatus.Status;
789 break;
790 }
791
792 /* If it's not supported, inherit the old status */
793 if (Status == STATUS_NOT_SUPPORTED) Status = Irp->IoStatus.Status;
794
795 /* Complete the IRP */
796 DPRINT("IRP completed with status: %lx\n", Status);
797 Irp->IoStatus.Status = Status;
798 IoCompleteRequest(Irp, IO_NO_INCREMENT);
799 return Status;
800 }
801 }
802
803 NTSTATUS
804 NTAPI
805 HalpDispatchWmi(IN PDEVICE_OBJECT DeviceObject,
806 IN PIRP Irp)
807 {
808 DPRINT1("HAL: PnP Driver WMI!\n");
809 while (TRUE);
810 return STATUS_SUCCESS;
811 }
812
813 NTSTATUS
814 NTAPI
815 HalpDispatchPower(IN PDEVICE_OBJECT DeviceObject,
816 IN PIRP Irp)
817 {
818 DPRINT1("HAL: PnP Driver Power!\n");
819 return STATUS_SUCCESS;
820 }
821
822 NTSTATUS
823 NTAPI
824 HalpDriverEntry(IN PDRIVER_OBJECT DriverObject,
825 IN PUNICODE_STRING RegistryPath)
826 {
827 NTSTATUS Status;
828 PDEVICE_OBJECT TargetDevice = NULL;
829
830 DPRINT("HAL: PnP Driver ENTRY!\n");
831
832 /* This is us */
833 HalpDriverObject = DriverObject;
834
835 /* Set up add device */
836 DriverObject->DriverExtension->AddDevice = HalpAddDevice;
837
838 /* Set up the callouts */
839 DriverObject->MajorFunction[IRP_MJ_PNP] = HalpDispatchPnp;
840 DriverObject->MajorFunction[IRP_MJ_POWER] = HalpDispatchPower;
841 DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = HalpDispatchWmi;
842
843 /* Create the PDO */
844 Status = IoCreateDevice(DriverObject,
845 0,
846 NULL,
847 FILE_DEVICE_CONTROLLER,
848 0,
849 FALSE,
850 &TargetDevice);
851 if (!NT_SUCCESS(Status))
852 return Status;
853
854 TargetDevice->Flags &= ~DO_DEVICE_INITIALIZING;
855
856 /* Set up the device stack */
857 Status = HalpAddDevice(DriverObject, TargetDevice);
858 if (!NT_SUCCESS(Status))
859 {
860 IoDeleteDevice(TargetDevice);
861 return Status;
862 }
863
864 /* Tell the PnP manager about us */
865 Status = IoReportDetectedDevice(DriverObject,
866 InterfaceTypeUndefined,
867 -1,
868 -1,
869 NULL,
870 NULL,
871 FALSE,
872 &TargetDevice);
873
874 /* Return to kernel */
875 return Status;
876 }
877
878 NTSTATUS
879 NTAPI
880 HaliInitPnpDriver(VOID)
881 {
882 NTSTATUS Status;
883 UNICODE_STRING DriverString;
884 PAGED_CODE();
885
886 /* Create the driver */
887 RtlInitUnicodeString(&DriverString, L"\\Driver\\PCI_HAL");
888 Status = IoCreateDriver(&DriverString, HalpDriverEntry);
889
890 /* Return status */
891 return Status;
892 }
893
894 /* EOF */