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