ReactOS  0.4.15-dev-1392-g3014417
buspdo.c
Go to the documentation of this file.
1 #ifndef UNIT_TEST
2 #include "precomp.h"
3 
4 #include <initguid.h>
5 #include <poclass.h>
6 
7 #define NDEBUG
8 #include <debug.h>
9 
10 #ifdef ALLOC_PRAGMA
11 #pragma alloc_text (PAGE, Bus_PDO_PnP)
12 #pragma alloc_text (PAGE, Bus_PDO_QueryDeviceCaps)
13 #pragma alloc_text (PAGE, Bus_PDO_QueryDeviceId)
14 #pragma alloc_text (PAGE, Bus_PDO_QueryDeviceText)
15 #pragma alloc_text (PAGE, Bus_PDO_QueryResources)
16 #pragma alloc_text (PAGE, Bus_PDO_QueryResourceRequirements)
17 #pragma alloc_text (PAGE, Bus_PDO_QueryDeviceRelations)
18 #pragma alloc_text (PAGE, Bus_PDO_QueryBusInformation)
19 #pragma alloc_text (PAGE, Bus_GetDeviceCapabilities)
20 #endif
21 
25  PIRP Irp,
26  PIO_STACK_LOCATION IrpStack,
28  )
29 {
32  struct acpi_device *device = NULL;
33 
34  PAGED_CODE ();
35 
36  if (DeviceData->AcpiHandle)
37  acpi_bus_get_device(DeviceData->AcpiHandle, &device);
38 
39  //
40  // NB: Because we are a bus enumerator, we have no one to whom we could
41  // defer these irps. Therefore we do not pass them down but merely
42  // return them.
43  //
44 
45  switch (IrpStack->MinorFunction) {
46 
48  //
49  // Here we do what ever initialization and ``turning on'' that is
50  // required to allow others to access this device.
51  // Power up the device.
52  //
53  if (DeviceData->AcpiHandle && acpi_bus_power_manageable(DeviceData->AcpiHandle) &&
55  {
56  DPRINT1("Device %x failed to start!\n", DeviceData->AcpiHandle);
58  break;
59  }
60 
61  DeviceData->InterfaceName.Length = 0;
63 
64  if (!device)
65  {
67  &GUID_DEVICE_SYS_BUTTON,
68  NULL,
69  &DeviceData->InterfaceName);
70  }
71  else if (device->flags.hardware_id &&
72  strstr(device->pnp.hardware_id, ACPI_THERMAL_HID))
73  {
75  &GUID_DEVICE_THERMAL_ZONE,
76  NULL,
77  &DeviceData->InterfaceName);
78  }
79  else if (device->flags.hardware_id &&
80  strstr(device->pnp.hardware_id, ACPI_BUTTON_HID_LID))
81  {
83  &GUID_DEVICE_LID,
84  NULL,
85  &DeviceData->InterfaceName);
86  }
87  else if (device->flags.hardware_id &&
88  strstr(device->pnp.hardware_id, ACPI_PROCESSOR_HID))
89  {
91  &GUID_DEVICE_PROCESSOR,
92  NULL,
93  &DeviceData->InterfaceName);
94  }
95 
96  /* Failure to register an interface is not a fatal failure so don't return a failure status */
97  if (NT_SUCCESS(status) && DeviceData->InterfaceName.Length != 0)
98  IoSetDeviceInterfaceState(&DeviceData->InterfaceName, TRUE);
99 
100  state.DeviceState = PowerDeviceD0;
102  DeviceData->Common.DevicePowerState = PowerDeviceD0;
105  break;
106 
107  case IRP_MN_STOP_DEVICE:
108 
109  if (DeviceData->InterfaceName.Length != 0)
110  IoSetDeviceInterfaceState(&DeviceData->InterfaceName, FALSE);
111 
112  //
113  // Here we shut down the device and give up and unmap any resources
114  // we acquired for the device.
115  //
116  if (DeviceData->AcpiHandle && acpi_bus_power_manageable(DeviceData->AcpiHandle) &&
118  {
119  DPRINT1("Device %x failed to stop!\n", DeviceData->AcpiHandle);
121  break;
122  }
123 
124  state.DeviceState = PowerDeviceD3;
126  DeviceData->Common.DevicePowerState = PowerDeviceD3;
129  break;
130 
131 
133 
134  //
135  // No reason here why we can't stop the device.
136  // If there were a reason we should speak now, because answering success
137  // here may result in a stop device irp.
138  //
139 
142  break;
143 
145 
146  //
147  // The stop was canceled. Whatever state we set, or resources we put
148  // on hold in anticipation of the forthcoming STOP device IRP should be
149  // put back to normal. Someone, in the long list of concerned parties,
150  // has failed the stop device query.
151  //
152 
153  //
154  // First check to see whether you have received cancel-stop
155  // without first receiving a query-stop. This could happen if someone
156  // above us fails a query-stop and passes down the subsequent
157  // cancel-stop.
158  //
159 
160  if (StopPending == DeviceData->Common.DevicePnPState)
161  {
162  //
163  // We did receive a query-stop, so restore.
164  //
166  }
167  status = STATUS_SUCCESS;// We must not fail this IRP.
168  break;
169 
171  //
172  // We handle REMOVE_DEVICE just like STOP_DEVICE. This is because
173  // the device is still physically present (or at least we don't know any better)
174  // so we have to retain the PDO after stopping and removing power from it.
175  //
176  if (DeviceData->InterfaceName.Length != 0)
177  IoSetDeviceInterfaceState(&DeviceData->InterfaceName, FALSE);
178 
179  if (DeviceData->AcpiHandle && acpi_bus_power_manageable(DeviceData->AcpiHandle) &&
181  {
182  DPRINT1("Device %x failed to enter D3!\n", DeviceData->AcpiHandle);
183  state.DeviceState = PowerDeviceD3;
185  DeviceData->Common.DevicePowerState = PowerDeviceD3;
186  }
187 
190  break;
191 
195  break;
196 
198  if (RemovalPending == DeviceData->Common.DevicePnPState)
199  {
201  }
203  break;
204 
206 
207  //
208  // Return the capabilities of a device, such as whether the device
209  // can be locked or ejected..etc
210  //
211 
213 
214  break;
215 
216  case IRP_MN_QUERY_ID:
217 
218  // Query the IDs of the device
220 
221  break;
222 
224 
225  DPRINT("\tQueryDeviceRelation Type: %s\n",DbgDeviceRelationString(\
226  IrpStack->Parameters.QueryDeviceRelations.Type));
227 
229 
230  break;
231 
233 
235 
236  break;
237 
239 
241 
242  break;
243 
245 
247 
248  break;
249 
251 
253 
254  break;
255 
257 
259 
260  break;
261 
262 
264 
265  //
266  // OPTIONAL for bus drivers.
267  // The PnP Manager sends this IRP to a device
268  // stack so filter and function drivers can adjust the
269  // resources required by the device, if appropriate.
270  //
271 
272  //break;
273 
274  //case IRP_MN_QUERY_PNP_DEVICE_STATE:
275 
276  //
277  // OPTIONAL for bus drivers.
278  // The PnP Manager sends this IRP after the drivers for
279  // a device return success from the IRP_MN_START_DEVICE
280  // request. The PnP Manager also sends this IRP when a
281  // driver for the device calls IoInvalidateDeviceState.
282  //
283 
284  // break;
285 
286  //case IRP_MN_READ_CONFIG:
287  //case IRP_MN_WRITE_CONFIG:
288 
289  //
290  // Bus drivers for buses with configuration space must handle
291  // this request for their child devices. Our devices don't
292  // have a config space.
293  //
294 
295  // break;
296 
297  //case IRP_MN_SET_LOCK:
298 
299  // break;
300 
301  default:
302 
303  //
304  // For PnP requests to the PDO that we do not understand we should
305  // return the IRP WITHOUT setting the status or information fields.
306  // These fields may have already been set by a filter (eg acpi).
307  status = Irp->IoStatus.Status;
308 
309  break;
310  }
311 
312  Irp->IoStatus.Status = status;
314 
315  return status;
316 }
317 
318 NTSTATUS
321  PIRP Irp )
322 {
323 
325  PDEVICE_CAPABILITIES deviceCapabilities;
326  struct acpi_device *device = NULL;
327  ULONG i;
328 
329  PAGED_CODE ();
330 
331  if (DeviceData->AcpiHandle)
332  acpi_bus_get_device(DeviceData->AcpiHandle, &device);
333 
335 
336  //
337  // Get the packet.
338  //
339  deviceCapabilities=stack->Parameters.DeviceCapabilities.Capabilities;
340 
341  //
342  // Set the capabilities.
343  //
344 
345  if (deviceCapabilities->Version != 1 ||
346  deviceCapabilities->Size < sizeof(DEVICE_CAPABILITIES))
347  {
348  return STATUS_UNSUCCESSFUL;
349  }
350 
351  deviceCapabilities->D1Latency = 0;
352  deviceCapabilities->D2Latency = 0;
353  deviceCapabilities->D3Latency = 0;
354 
355  deviceCapabilities->DeviceState[PowerSystemWorking] = PowerDeviceD0;
356  deviceCapabilities->DeviceState[PowerSystemSleeping1] = PowerDeviceD3;
357  deviceCapabilities->DeviceState[PowerSystemSleeping2] = PowerDeviceD3;
358  deviceCapabilities->DeviceState[PowerSystemSleeping3] = PowerDeviceD3;
359 
360  for (i = 0; i < ACPI_D_STATE_COUNT && device; i++)
361  {
362  if (!device->power.states[i].flags.valid)
363  continue;
364 
365  switch (i)
366  {
367  case ACPI_STATE_D0:
368  deviceCapabilities->DeviceState[PowerSystemWorking] = PowerDeviceD0;
369  break;
370 
371  case ACPI_STATE_D1:
372  deviceCapabilities->DeviceState[PowerSystemSleeping1] = PowerDeviceD1;
373  deviceCapabilities->D1Latency = device->power.states[i].latency;
374  break;
375 
376  case ACPI_STATE_D2:
377  deviceCapabilities->DeviceState[PowerSystemSleeping2] = PowerDeviceD2;
378  deviceCapabilities->D2Latency = device->power.states[i].latency;
379  break;
380 
381  case ACPI_STATE_D3:
382  deviceCapabilities->DeviceState[PowerSystemSleeping3] = PowerDeviceD3;
383  deviceCapabilities->D3Latency = device->power.states[i].latency;
384  break;
385  }
386  }
387 
388  // We can wake the system from D1
389  deviceCapabilities->DeviceWake = PowerDeviceD1;
390 
391 
392  deviceCapabilities->DeviceD1 =
393  (deviceCapabilities->DeviceState[PowerSystemSleeping1] == PowerDeviceD1) ? TRUE : FALSE;
394  deviceCapabilities->DeviceD2 =
395  (deviceCapabilities->DeviceState[PowerSystemSleeping2] == PowerDeviceD2) ? TRUE : FALSE;
396 
397  deviceCapabilities->WakeFromD0 = FALSE;
398  deviceCapabilities->WakeFromD1 = TRUE; //Yes we can
399  deviceCapabilities->WakeFromD2 = FALSE;
400  deviceCapabilities->WakeFromD3 = FALSE;
401 
402  if (device)
403  {
404  deviceCapabilities->LockSupported = device->flags.lockable;
405  deviceCapabilities->EjectSupported = device->flags.ejectable;
406  deviceCapabilities->HardwareDisabled = !device->status.enabled && !device->status.functional;
407  deviceCapabilities->Removable = device->flags.removable;
408  deviceCapabilities->SurpriseRemovalOK = device->flags.surprise_removal_ok;
409  deviceCapabilities->UniqueID = device->flags.unique_id;
410  deviceCapabilities->NoDisplayInUI = !device->status.show_in_ui;
411  deviceCapabilities->Address = device->pnp.bus_address;
412  }
413 
414  if (!device ||
415  (device->flags.hardware_id &&
416  (strstr(device->pnp.hardware_id, ACPI_BUTTON_HID_LID) ||
417  strstr(device->pnp.hardware_id, ACPI_THERMAL_HID) ||
418  strstr(device->pnp.hardware_id, ACPI_PROCESSOR_HID))))
419  {
420  /* Allow ACPI to control the device if it is a lid button,
421  * a thermal zone, a processor, or a fixed feature button */
422  deviceCapabilities->RawDeviceOK = TRUE;
423  }
424 
425  deviceCapabilities->SilentInstall = FALSE;
426  deviceCapabilities->UINumber = (ULONG)-1;
427 
428  return STATUS_SUCCESS;
429 
430 }
431 
432 NTSTATUS
435  PIRP Irp )
436 {
438  PWCHAR buffer, src;
439  WCHAR temp[256];
440  ULONG length, i;
442  struct acpi_device *Device;
443 
444  PAGED_CODE ();
445 
447 
448  switch (stack->Parameters.QueryId.IdType) {
449 
450  case BusQueryDeviceID:
451 
452  /* This is a REG_SZ value */
453 
454  if (DeviceData->AcpiHandle)
455  {
456  acpi_bus_get_device(DeviceData->AcpiHandle, &Device);
457 
458  if (strcmp(Device->pnp.hardware_id, "Processor") == 0)
459  {
462  }
463  else
464  {
465  length = swprintf(temp,
466  L"ACPI\\%hs",
467  Device->pnp.hardware_id);
468  }
469  }
470  else
471  {
472  /* We know it's a fixed feature button because
473  * these are direct children of the ACPI root device
474  * and therefore have no handle
475  */
476  length = swprintf(temp,
477  L"ACPI\\FixedButton");
478  }
479 
480  temp[length++] = UNICODE_NULL;
481 
482  NT_ASSERT(length * sizeof(WCHAR) <= sizeof(temp));
483 
484  buffer = ExAllocatePoolWithTag(PagedPool, length * sizeof(WCHAR), 'IpcA');
485 
486  if (!buffer) {
488  break;
489  }
490 
491  RtlCopyMemory (buffer, temp, length * sizeof(WCHAR));
492  Irp->IoStatus.Information = (ULONG_PTR) buffer;
493  DPRINT("BusQueryDeviceID: %ls\n",buffer);
494  break;
495 
496  case BusQueryInstanceID:
497 
498  /* This is a REG_SZ value */
499 
500  /* See comment in BusQueryDeviceID case */
501  if(DeviceData->AcpiHandle)
502  {
503  acpi_bus_get_device(DeviceData->AcpiHandle, &Device);
504 
505  if (Device->flags.unique_id)
506  length = swprintf(temp,
507  L"%hs",
508  Device->pnp.unique_id);
509  else
510  /* FIXME: Generate unique id! */
511  length = swprintf(temp, L"%ls", L"0");
512  }
513  else
514  {
515  /* FIXME: Generate unique id! */
516  length = swprintf(temp, L"%ls", L"0");
517  }
518 
519  temp[length++] = UNICODE_NULL;
520 
521  NT_ASSERT(length * sizeof(WCHAR) <= sizeof(temp));
522 
523  buffer = ExAllocatePoolWithTag(PagedPool, length * sizeof(WCHAR), 'IpcA');
524  if (!buffer) {
526  break;
527  }
528 
529  RtlCopyMemory (buffer, temp, length * sizeof (WCHAR));
530  DPRINT("BusQueryInstanceID: %ls\n",buffer);
531  Irp->IoStatus.Information = (ULONG_PTR) buffer;
532  break;
533 
534  case BusQueryHardwareIDs:
535 
536  /* This is a REG_MULTI_SZ value */
537  length = 0;
539 
540  /* See comment in BusQueryDeviceID case */
541  if (DeviceData->AcpiHandle)
542  {
543  acpi_bus_get_device(DeviceData->AcpiHandle, &Device);
544 
545  if (!Device->flags.hardware_id)
546  {
547  /* We don't have the ID to satisfy this request */
548  break;
549  }
550 
551  DPRINT("Device name: %s\n", Device->pnp.device_name);
552  DPRINT("Hardware ID: %s\n", Device->pnp.hardware_id);
553 
554  if (strcmp(Device->pnp.hardware_id, "Processor") == 0)
555  {
558  }
559  else
560  {
561  length += swprintf(&temp[length],
562  L"ACPI\\%hs",
563  Device->pnp.hardware_id);
564  temp[length++] = UNICODE_NULL;
565 
566  length += swprintf(&temp[length],
567  L"*%hs",
568  Device->pnp.hardware_id);
569  temp[length++] = UNICODE_NULL;
570  temp[length++] = UNICODE_NULL;
571  src = temp;
572  }
573  }
574  else
575  {
576  length += swprintf(&temp[length],
577  L"ACPI\\FixedButton");
578  temp[length++] = UNICODE_NULL;
579 
580  length += swprintf(&temp[length],
581  L"*FixedButton");
582  temp[length++] = UNICODE_NULL;
583  temp[length++] = UNICODE_NULL;
584  src = temp;
585  }
586 
587  NT_ASSERT(length * sizeof(WCHAR) <= sizeof(temp));
588 
589  buffer = ExAllocatePoolWithTag(PagedPool, length * sizeof(WCHAR), 'IpcA');
590 
591  if (!buffer) {
593  break;
594  }
595 
596  RtlCopyMemory (buffer, src, length * sizeof(WCHAR));
597  Irp->IoStatus.Information = (ULONG_PTR) buffer;
598  DPRINT("BusQueryHardwareIDs: %ls\n",buffer);
600  break;
601 
603 
604  /* This is a REG_MULTI_SZ value */
605  length = 0;
607 
608  /* See comment in BusQueryDeviceID case */
609  if (DeviceData->AcpiHandle)
610  {
611  acpi_bus_get_device(DeviceData->AcpiHandle, &Device);
612 
613  if (!Device->flags.hardware_id)
614  {
615  /* We don't have the ID to satisfy this request */
616  break;
617  }
618 
619  DPRINT("Device name: %s\n", Device->pnp.device_name);
620  DPRINT("Hardware ID: %s\n", Device->pnp.hardware_id);
621 
622  if (strcmp(Device->pnp.hardware_id, "Processor") == 0)
623  {
624  length += swprintf(&temp[length],
625  L"ACPI\\%hs",
626  Device->pnp.hardware_id);
627  temp[length++] = UNICODE_NULL;
628 
629  length += swprintf(&temp[length],
630  L"*%hs",
631  Device->pnp.hardware_id);
632  temp[length++] = UNICODE_NULL;
633  temp[length++] = UNICODE_NULL;
634  }
635  else if (Device->flags.compatible_ids)
636  {
637  for (i = 0; i < Device->pnp.cid_list->Count; i++)
638  {
639  length += swprintf(&temp[length],
640  L"ACPI\\%hs",
641  Device->pnp.cid_list->Ids[i].String);
642  temp[length++] = UNICODE_NULL;
643 
644  length += swprintf(&temp[length],
645  L"*%hs",
646  Device->pnp.cid_list->Ids[i].String);
647  temp[length++] = UNICODE_NULL;
648  }
649 
650  temp[length++] = UNICODE_NULL;
651  }
652  else
653  {
654  /* No compatible IDs */
655  break;
656  }
657 
658  NT_ASSERT(length * sizeof(WCHAR) <= sizeof(temp));
659 
660  buffer = ExAllocatePoolWithTag(PagedPool, length * sizeof(WCHAR), 'IpcA');
661  if (!buffer)
662  {
664  break;
665  }
666 
667  RtlCopyMemory (buffer, temp, length * sizeof(WCHAR));
668  Irp->IoStatus.Information = (ULONG_PTR) buffer;
669  DPRINT("BusQueryCompatibleIDs: %ls\n",buffer);
671  }
672  break;
673 
674  default:
675  status = Irp->IoStatus.Status;
676  }
677  return status;
678 }
679 
680 NTSTATUS
683  PIRP Irp )
684 {
685  PWCHAR Buffer, Temp;
687  NTSTATUS status = Irp->IoStatus.Status;
688  PAGED_CODE ();
689 
691 
692  switch (stack->Parameters.QueryDeviceText.DeviceTextType) {
693 
695 
696  if (!Irp->IoStatus.Information) {
697  if (wcsstr (DeviceData->HardwareIDs, L"PNP000") != 0)
698  Temp = L"Programmable interrupt controller";
699  else if (wcsstr(DeviceData->HardwareIDs, L"PNP010") != 0)
700  Temp = L"System timer";
701  else if (wcsstr(DeviceData->HardwareIDs, L"PNP020") != 0)
702  Temp = L"DMA controller";
703  else if (wcsstr(DeviceData->HardwareIDs, L"PNP03") != 0)
704  Temp = L"Keyboard";
705  else if (wcsstr(DeviceData->HardwareIDs, L"PNP040") != 0)
706  Temp = L"Parallel port";
707  else if (wcsstr(DeviceData->HardwareIDs, L"PNP05") != 0)
708  Temp = L"Serial port";
709  else if (wcsstr(DeviceData->HardwareIDs, L"PNP06") != 0)
710  Temp = L"Disk controller";
711  else if (wcsstr(DeviceData->HardwareIDs, L"PNP07") != 0)
712  Temp = L"Disk controller";
713  else if (wcsstr(DeviceData->HardwareIDs, L"PNP09") != 0)
714  Temp = L"Display adapter";
715  else if (wcsstr(DeviceData->HardwareIDs, L"PNP0A0") != 0)
716  Temp = L"Bus controller";
717  else if (wcsstr(DeviceData->HardwareIDs, L"PNP0E0") != 0)
718  Temp = L"PCMCIA controller";
719  else if (wcsstr(DeviceData->HardwareIDs, L"PNP0F") != 0)
720  Temp = L"Mouse device";
721  else if (wcsstr(DeviceData->HardwareIDs, L"PNP8") != 0)
722  Temp = L"Network adapter";
723  else if (wcsstr(DeviceData->HardwareIDs, L"PNPA0") != 0)
724  Temp = L"SCSI controller";
725  else if (wcsstr(DeviceData->HardwareIDs, L"PNPB0") != 0)
726  Temp = L"Multimedia device";
727  else if (wcsstr(DeviceData->HardwareIDs, L"PNPC00") != 0)
728  Temp = L"Modem";
729  else if (wcsstr(DeviceData->HardwareIDs, L"PNP0C0C") != 0)
730  Temp = L"Power Button";
731  else if (wcsstr(DeviceData->HardwareIDs, L"PNP0C0E") != 0)
732  Temp = L"Sleep Button";
733  else if (wcsstr(DeviceData->HardwareIDs, L"PNP0C0D") != 0)
734  Temp = L"Lid Switch";
735  else if (wcsstr(DeviceData->HardwareIDs, L"PNP0C09") != 0)
736  Temp = L"ACPI Embedded Controller";
737  else if (wcsstr(DeviceData->HardwareIDs, L"PNP0C0B") != 0)
738  Temp = L"ACPI Fan";
739  else if (wcsstr(DeviceData->HardwareIDs, L"PNP0A03") != 0 ||
740  wcsstr(DeviceData->HardwareIDs, L"PNP0A08") != 0)
741  Temp = L"PCI Root Bridge";
742  else if (wcsstr(DeviceData->HardwareIDs, L"PNP0C0A") != 0)
743  Temp = L"ACPI Battery";
744  else if (wcsstr(DeviceData->HardwareIDs, L"PNP0C0F") != 0)
745  Temp = L"PCI Interrupt Link";
746  else if (wcsstr(DeviceData->HardwareIDs, L"ACPI_PWR") != 0)
747  Temp = L"ACPI Power Resource";
748  else if (wcsstr(DeviceData->HardwareIDs, L"Processor") != 0)
749  {
750  if (ProcessorNameString != NULL)
751  Temp = ProcessorNameString;
752  else
753  Temp = L"Processor";
754  }
755  else if (wcsstr(DeviceData->HardwareIDs, L"ThermalZone") != 0)
756  Temp = L"ACPI Thermal Zone";
757  else if (wcsstr(DeviceData->HardwareIDs, L"ACPI0002") != 0)
758  Temp = L"Smart Battery";
759  else if (wcsstr(DeviceData->HardwareIDs, L"ACPI0003") != 0)
760  Temp = L"AC Adapter";
761  /* Simply checking if AcpiHandle is NULL eliminates the need to check
762  * for the 4 different names that ACPI knows the fixed feature button as internally
763  */
764  else if (!DeviceData->AcpiHandle)
765  Temp = L"ACPI Fixed Feature Button";
766  else
767  Temp = L"Other ACPI device";
768 
769  Buffer = ExAllocatePoolWithTag(PagedPool, (wcslen(Temp) + 1) * sizeof(WCHAR), 'IpcA');
770 
771  if (!Buffer) {
773  break;
774  }
775 
776  RtlCopyMemory (Buffer, Temp, (wcslen(Temp) + 1) * sizeof(WCHAR));
777 
778  DPRINT("\tDeviceTextDescription :%ws\n", Buffer);
779 
780  Irp->IoStatus.Information = (ULONG_PTR) Buffer;
782  }
783  break;
784 
785  default:
786  break;
787  }
788 
789  return status;
790 
791 }
792 
793 NTSTATUS
796  PIRP Irp )
797 {
798  ULONG NumberOfResources = 0;
800  PCM_PARTIAL_RESOURCE_DESCRIPTOR ResourceDescriptor;
801  ACPI_STATUS AcpiStatus;
804  ULONG ResourceListSize;
805  ULONG i;
807  struct acpi_device *device;
808 
809  if (!DeviceData->AcpiHandle)
810  {
811  return Irp->IoStatus.Status;
812  }
813 
814  /* A bus number resource is not included in the list of current resources
815  * for the root PCI bus so we manually query one here and if we find it
816  * we create a resource list and add a bus number descriptor to it */
817  if (wcsstr(DeviceData->HardwareIDs, L"PNP0A03") != 0 ||
818  wcsstr(DeviceData->HardwareIDs, L"PNP0A08") != 0)
819  {
820  acpi_bus_get_device(DeviceData->AcpiHandle, &device);
821 
822  AcpiStatus = acpi_evaluate_integer(DeviceData->AcpiHandle, "_BBN", NULL, &BusNumber);
823  if (AcpiStatus != AE_OK)
824  {
825 #if 0
826  if (device->flags.unique_id)
827  {
828  /* FIXME: Try the unique ID */
829  }
830  else
831 #endif
832  {
833  BusNumber = 0;
834  DPRINT1("Failed to find a bus number\n");
835  }
836  }
837  else
838  {
839  DPRINT("Using _BBN for bus number\n");
840  }
841 
842  DPRINT("Found PCI root hub: %d\n", BusNumber);
843 
844  ResourceListSize = sizeof(CM_RESOURCE_LIST);
845  ResourceList = ExAllocatePoolWithTag(PagedPool, ResourceListSize, 'RpcA');
846  if (!ResourceList)
848 
849  ResourceList->Count = 1;
850  ResourceList->List[0].InterfaceType = Internal;
851  ResourceList->List[0].BusNumber = 0;
852  ResourceList->List[0].PartialResourceList.Version = 1;
853  ResourceList->List[0].PartialResourceList.Revision = 1;
854  ResourceList->List[0].PartialResourceList.Count = 1;
855  ResourceDescriptor = ResourceList->List[0].PartialResourceList.PartialDescriptors;
856 
857  ResourceDescriptor->Type = CmResourceTypeBusNumber;
858  ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
859  ResourceDescriptor->u.BusNumber.Start = BusNumber;
860  ResourceDescriptor->u.BusNumber.Length = 1;
861 
862  Irp->IoStatus.Information = (ULONG_PTR)ResourceList;
863  return STATUS_SUCCESS;
864  }
865 
866  /* Get current resources */
867  Buffer.Length = 0;
868  AcpiStatus = AcpiGetCurrentResources(DeviceData->AcpiHandle, &Buffer);
869  if ((!ACPI_SUCCESS(AcpiStatus) && AcpiStatus != AE_BUFFER_OVERFLOW) ||
870  Buffer.Length == 0)
871  {
872  return Irp->IoStatus.Status;
873  }
874 
875  Buffer.Pointer = ExAllocatePoolWithTag(PagedPool, Buffer.Length, 'BpcA');
876  if (!Buffer.Pointer)
878 
879  AcpiStatus = AcpiGetCurrentResources(DeviceData->AcpiHandle, &Buffer);
880  if (!ACPI_SUCCESS(AcpiStatus))
881  {
882  DPRINT1("AcpiGetCurrentResources #2 failed (0x%x)\n", AcpiStatus);
883  ASSERT(FALSE);
884  return STATUS_UNSUCCESSFUL;
885  }
886 
887  resource= Buffer.Pointer;
888  /* Count number of resources */
889  while (resource->Type != ACPI_RESOURCE_TYPE_END_TAG)
890  {
891  switch (resource->Type)
892  {
894  {
896  if (irq_data->ProducerConsumer == ACPI_PRODUCER)
897  break;
898  NumberOfResources += irq_data->InterruptCount;
899  break;
900  }
902  {
903  ACPI_RESOURCE_IRQ *irq_data = (ACPI_RESOURCE_IRQ*) &resource->Data;
904  NumberOfResources += irq_data->InterruptCount;
905  break;
906  }
908  {
909  ACPI_RESOURCE_DMA *dma_data = (ACPI_RESOURCE_DMA*) &resource->Data;
910  NumberOfResources += dma_data->ChannelCount;
911  break;
912  }
917  {
919  if (addr_res->ProducerConsumer == ACPI_PRODUCER)
920  break;
921  NumberOfResources++;
922  break;
923  }
929  {
930  NumberOfResources++;
931  break;
932  }
933  default:
934  {
935  DPRINT1("Unknown resource type: %d\n", resource->Type);
936  break;
937  }
938  }
940  }
941 
942  /* Allocate memory */
943  ResourceListSize = sizeof(CM_RESOURCE_LIST) + sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR) * (NumberOfResources - 1);
944  ResourceList = ExAllocatePoolWithTag(PagedPool, ResourceListSize, 'RpcA');
945 
946  if (!ResourceList)
947  {
948  ExFreePoolWithTag(Buffer.Pointer, 'BpcA');
950  }
951  ResourceList->Count = 1;
952  ResourceList->List[0].InterfaceType = Internal; /* FIXME */
953  ResourceList->List[0].BusNumber = 0; /* We're the only ACPI bus device in the system */
954  ResourceList->List[0].PartialResourceList.Version = 1;
955  ResourceList->List[0].PartialResourceList.Revision = 1;
956  ResourceList->List[0].PartialResourceList.Count = NumberOfResources;
957  ResourceDescriptor = ResourceList->List[0].PartialResourceList.PartialDescriptors;
958 
959  /* Fill resources list structure */
960  resource = Buffer.Pointer;
961  while (resource->Type != ACPI_RESOURCE_TYPE_END_TAG)
962  {
963  switch (resource->Type)
964  {
966  {
968  if (irq_data->ProducerConsumer == ACPI_PRODUCER)
969  break;
970  for (i = 0; i < irq_data->InterruptCount; i++)
971  {
972  ResourceDescriptor->Type = CmResourceTypeInterrupt;
973 
974  ResourceDescriptor->ShareDisposition =
976  ResourceDescriptor->Flags =
978  ResourceDescriptor->u.Interrupt.Level =
979  ResourceDescriptor->u.Interrupt.Vector = irq_data->Interrupts[i];
980  ResourceDescriptor->u.Interrupt.Affinity = (KAFFINITY)(-1);
981 
982  ResourceDescriptor++;
983  }
984  break;
985  }
987  {
988  ACPI_RESOURCE_IRQ *irq_data = (ACPI_RESOURCE_IRQ*) &resource->Data;
989  for (i = 0; i < irq_data->InterruptCount; i++)
990  {
991  ResourceDescriptor->Type = CmResourceTypeInterrupt;
992 
993  ResourceDescriptor->ShareDisposition =
995  ResourceDescriptor->Flags =
997  ResourceDescriptor->u.Interrupt.Level =
998  ResourceDescriptor->u.Interrupt.Vector = irq_data->Interrupts[i];
999  ResourceDescriptor->u.Interrupt.Affinity = (KAFFINITY)(-1);
1000 
1001  ResourceDescriptor++;
1002  }
1003  break;
1004  }
1006  {
1007  ACPI_RESOURCE_DMA *dma_data = (ACPI_RESOURCE_DMA*) &resource->Data;
1008  for (i = 0; i < dma_data->ChannelCount; i++)
1009  {
1010  ResourceDescriptor->Type = CmResourceTypeDma;
1011  ResourceDescriptor->Flags = 0;
1012  switch (dma_data->Type)
1013  {
1014  case ACPI_TYPE_A: ResourceDescriptor->Flags |= CM_RESOURCE_DMA_TYPE_A; break;
1015  case ACPI_TYPE_B: ResourceDescriptor->Flags |= CM_RESOURCE_DMA_TYPE_B; break;
1016  case ACPI_TYPE_F: ResourceDescriptor->Flags |= CM_RESOURCE_DMA_TYPE_F; break;
1017  }
1018  if (dma_data->BusMaster == ACPI_BUS_MASTER)
1019  ResourceDescriptor->Flags |= CM_RESOURCE_DMA_BUS_MASTER;
1020  switch (dma_data->Transfer)
1021  {
1022  case ACPI_TRANSFER_8: ResourceDescriptor->Flags |= CM_RESOURCE_DMA_8; break;
1023  case ACPI_TRANSFER_16: ResourceDescriptor->Flags |= CM_RESOURCE_DMA_16; break;
1024  case ACPI_TRANSFER_8_16: ResourceDescriptor->Flags |= CM_RESOURCE_DMA_8_AND_16; break;
1025  }
1026  ResourceDescriptor->u.Dma.Channel = dma_data->Channels[i];
1027 
1028  ResourceDescriptor++;
1029  }
1030  break;
1031  }
1032  case ACPI_RESOURCE_TYPE_IO:
1033  {
1034  ACPI_RESOURCE_IO *io_data = (ACPI_RESOURCE_IO*) &resource->Data;
1035  ResourceDescriptor->Type = CmResourceTypePort;
1036  ResourceDescriptor->ShareDisposition = CmResourceShareDriverExclusive;
1037  ResourceDescriptor->Flags = CM_RESOURCE_PORT_IO;
1038  if (io_data->IoDecode == ACPI_DECODE_16)
1039  ResourceDescriptor->Flags |= CM_RESOURCE_PORT_16_BIT_DECODE;
1040  else
1041  ResourceDescriptor->Flags |= CM_RESOURCE_PORT_10_BIT_DECODE;
1042  ResourceDescriptor->u.Port.Start.QuadPart = io_data->Minimum;
1043  ResourceDescriptor->u.Port.Length = io_data->AddressLength;
1044 
1045  ResourceDescriptor++;
1046  break;
1047  }
1049  {
1051  ResourceDescriptor->Type = CmResourceTypePort;
1052  ResourceDescriptor->ShareDisposition = CmResourceShareDriverExclusive;
1053  ResourceDescriptor->Flags = CM_RESOURCE_PORT_IO;
1054  ResourceDescriptor->u.Port.Start.QuadPart = io_data->Address;
1055  ResourceDescriptor->u.Port.Length = io_data->AddressLength;
1056 
1057  ResourceDescriptor++;
1058  break;
1059  }
1061  {
1062  ACPI_RESOURCE_ADDRESS16 *addr16_data = (ACPI_RESOURCE_ADDRESS16*) &resource->Data;
1063  if (addr16_data->ProducerConsumer == ACPI_PRODUCER)
1064  break;
1065  if (addr16_data->ResourceType == ACPI_BUS_NUMBER_RANGE)
1066  {
1067  ResourceDescriptor->Type = CmResourceTypeBusNumber;
1068  ResourceDescriptor->ShareDisposition = CmResourceShareShared;
1069  ResourceDescriptor->Flags = 0;
1070  ResourceDescriptor->u.BusNumber.Start = addr16_data->Address.Minimum;
1071  ResourceDescriptor->u.BusNumber.Length = addr16_data->Address.AddressLength;
1072  }
1073  else if (addr16_data->ResourceType == ACPI_IO_RANGE)
1074  {
1075  ResourceDescriptor->Type = CmResourceTypePort;
1076  ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1077  ResourceDescriptor->Flags = CM_RESOURCE_PORT_IO;
1078  if (addr16_data->Decode == ACPI_POS_DECODE)
1079  ResourceDescriptor->Flags |= CM_RESOURCE_PORT_POSITIVE_DECODE;
1080  ResourceDescriptor->u.Port.Start.QuadPart = addr16_data->Address.Minimum;
1081  ResourceDescriptor->u.Port.Length = addr16_data->Address.AddressLength;
1082  }
1083  else
1084  {
1085  ResourceDescriptor->Type = CmResourceTypeMemory;
1086  ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1087  ResourceDescriptor->Flags = 0;
1088  if (addr16_data->Info.Mem.WriteProtect == ACPI_READ_ONLY_MEMORY)
1089  ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
1090  else
1091  ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
1092  switch (addr16_data->Info.Mem.Caching)
1093  {
1094  case ACPI_CACHABLE_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_CACHEABLE; break;
1095  case ACPI_WRITE_COMBINING_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_COMBINEDWRITE; break;
1096  case ACPI_PREFETCHABLE_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_PREFETCHABLE; break;
1097  }
1098  ResourceDescriptor->u.Memory.Start.QuadPart = addr16_data->Address.Minimum;
1099  ResourceDescriptor->u.Memory.Length = addr16_data->Address.AddressLength;
1100  }
1101  ResourceDescriptor++;
1102  break;
1103  }
1105  {
1106  ACPI_RESOURCE_ADDRESS32 *addr32_data = (ACPI_RESOURCE_ADDRESS32*) &resource->Data;
1107  if (addr32_data->ProducerConsumer == ACPI_PRODUCER)
1108  break;
1109  if (addr32_data->ResourceType == ACPI_BUS_NUMBER_RANGE)
1110  {
1111  ResourceDescriptor->Type = CmResourceTypeBusNumber;
1112  ResourceDescriptor->ShareDisposition = CmResourceShareShared;
1113  ResourceDescriptor->Flags = 0;
1114  ResourceDescriptor->u.BusNumber.Start = addr32_data->Address.Minimum;
1115  ResourceDescriptor->u.BusNumber.Length = addr32_data->Address.AddressLength;
1116  }
1117  else if (addr32_data->ResourceType == ACPI_IO_RANGE)
1118  {
1119  ResourceDescriptor->Type = CmResourceTypePort;
1120  ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1121  ResourceDescriptor->Flags = CM_RESOURCE_PORT_IO;
1122  if (addr32_data->Decode == ACPI_POS_DECODE)
1123  ResourceDescriptor->Flags |= CM_RESOURCE_PORT_POSITIVE_DECODE;
1124  ResourceDescriptor->u.Port.Start.QuadPart = addr32_data->Address.Minimum;
1125  ResourceDescriptor->u.Port.Length = addr32_data->Address.AddressLength;
1126  }
1127  else
1128  {
1129  ResourceDescriptor->Type = CmResourceTypeMemory;
1130  ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1131  ResourceDescriptor->Flags = 0;
1132  if (addr32_data->Info.Mem.WriteProtect == ACPI_READ_ONLY_MEMORY)
1133  ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
1134  else
1135  ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
1136  switch (addr32_data->Info.Mem.Caching)
1137  {
1138  case ACPI_CACHABLE_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_CACHEABLE; break;
1139  case ACPI_WRITE_COMBINING_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_COMBINEDWRITE; break;
1140  case ACPI_PREFETCHABLE_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_PREFETCHABLE; break;
1141  }
1142  ResourceDescriptor->u.Memory.Start.QuadPart = addr32_data->Address.Minimum;
1143  ResourceDescriptor->u.Memory.Length = addr32_data->Address.AddressLength;
1144  }
1145  ResourceDescriptor++;
1146  break;
1147  }
1149  {
1150  ACPI_RESOURCE_ADDRESS64 *addr64_data = (ACPI_RESOURCE_ADDRESS64*) &resource->Data;
1151  if (addr64_data->ProducerConsumer == ACPI_PRODUCER)
1152  break;
1153  if (addr64_data->ResourceType == ACPI_BUS_NUMBER_RANGE)
1154  {
1155  DPRINT1("64-bit bus address is not supported!\n");
1156  ResourceDescriptor->Type = CmResourceTypeBusNumber;
1157  ResourceDescriptor->ShareDisposition = CmResourceShareShared;
1158  ResourceDescriptor->Flags = 0;
1159  ResourceDescriptor->u.BusNumber.Start = (ULONG)addr64_data->Address.Minimum;
1160  ResourceDescriptor->u.BusNumber.Length = addr64_data->Address.AddressLength;
1161  }
1162  else if (addr64_data->ResourceType == ACPI_IO_RANGE)
1163  {
1164  ResourceDescriptor->Type = CmResourceTypePort;
1165  ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1166  ResourceDescriptor->Flags = CM_RESOURCE_PORT_IO;
1167  if (addr64_data->Decode == ACPI_POS_DECODE)
1168  ResourceDescriptor->Flags |= CM_RESOURCE_PORT_POSITIVE_DECODE;
1169  ResourceDescriptor->u.Port.Start.QuadPart = addr64_data->Address.Minimum;
1170  ResourceDescriptor->u.Port.Length = addr64_data->Address.AddressLength;
1171  }
1172  else
1173  {
1174  ResourceDescriptor->Type = CmResourceTypeMemory;
1175  ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1176  ResourceDescriptor->Flags = 0;
1177  if (addr64_data->Info.Mem.WriteProtect == ACPI_READ_ONLY_MEMORY)
1178  ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
1179  else
1180  ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
1181  switch (addr64_data->Info.Mem.Caching)
1182  {
1183  case ACPI_CACHABLE_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_CACHEABLE; break;
1184  case ACPI_WRITE_COMBINING_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_COMBINEDWRITE; break;
1185  case ACPI_PREFETCHABLE_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_PREFETCHABLE; break;
1186  }
1187  ResourceDescriptor->u.Memory.Start.QuadPart = addr64_data->Address.Minimum;
1188  ResourceDescriptor->u.Memory.Length = addr64_data->Address.AddressLength;
1189  }
1190  ResourceDescriptor++;
1191  break;
1192  }
1194  {
1196  if (addr64_data->ProducerConsumer == ACPI_PRODUCER)
1197  break;
1198  if (addr64_data->ResourceType == ACPI_BUS_NUMBER_RANGE)
1199  {
1200  DPRINT1("64-bit bus address is not supported!\n");
1201  ResourceDescriptor->Type = CmResourceTypeBusNumber;
1202  ResourceDescriptor->ShareDisposition = CmResourceShareShared;
1203  ResourceDescriptor->Flags = 0;
1204  ResourceDescriptor->u.BusNumber.Start = (ULONG)addr64_data->Address.Minimum;
1205  ResourceDescriptor->u.BusNumber.Length = addr64_data->Address.AddressLength;
1206  }
1207  else if (addr64_data->ResourceType == ACPI_IO_RANGE)
1208  {
1209  ResourceDescriptor->Type = CmResourceTypePort;
1210  ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1211  ResourceDescriptor->Flags = CM_RESOURCE_PORT_IO;
1212  if (addr64_data->Decode == ACPI_POS_DECODE)
1213  ResourceDescriptor->Flags |= CM_RESOURCE_PORT_POSITIVE_DECODE;
1214  ResourceDescriptor->u.Port.Start.QuadPart = addr64_data->Address.Minimum;
1215  ResourceDescriptor->u.Port.Length = addr64_data->Address.AddressLength;
1216  }
1217  else
1218  {
1219  ResourceDescriptor->Type = CmResourceTypeMemory;
1220  ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1221  ResourceDescriptor->Flags = 0;
1222  if (addr64_data->Info.Mem.WriteProtect == ACPI_READ_ONLY_MEMORY)
1223  ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
1224  else
1225  ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
1226  switch (addr64_data->Info.Mem.Caching)
1227  {
1228  case ACPI_CACHABLE_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_CACHEABLE; break;
1229  case ACPI_WRITE_COMBINING_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_COMBINEDWRITE; break;
1230  case ACPI_PREFETCHABLE_MEMORY: ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_PREFETCHABLE; break;
1231  }
1232  ResourceDescriptor->u.Memory.Start.QuadPart = addr64_data->Address.Minimum;
1233  ResourceDescriptor->u.Memory.Length = addr64_data->Address.AddressLength;
1234  }
1235  ResourceDescriptor++;
1236  break;
1237  }
1239  {
1240  ACPI_RESOURCE_MEMORY24 *mem24_data = (ACPI_RESOURCE_MEMORY24*) &resource->Data;
1241  ResourceDescriptor->Type = CmResourceTypeMemory;
1242  ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1243  ResourceDescriptor->Flags = CM_RESOURCE_MEMORY_24;
1244  if (mem24_data->WriteProtect == ACPI_READ_ONLY_MEMORY)
1245  ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
1246  else
1247  ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
1248  ResourceDescriptor->u.Memory.Start.QuadPart = mem24_data->Minimum;
1249  ResourceDescriptor->u.Memory.Length = mem24_data->AddressLength;
1250 
1251  ResourceDescriptor++;
1252  break;
1253  }
1255  {
1256  ACPI_RESOURCE_MEMORY32 *mem32_data = (ACPI_RESOURCE_MEMORY32*) &resource->Data;
1257  ResourceDescriptor->Type = CmResourceTypeMemory;
1258  ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1259  ResourceDescriptor->Flags = 0;
1260  if (mem32_data->WriteProtect == ACPI_READ_ONLY_MEMORY)
1261  ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
1262  else
1263  ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
1264  ResourceDescriptor->u.Memory.Start.QuadPart = mem32_data->Minimum;
1265  ResourceDescriptor->u.Memory.Length = mem32_data->AddressLength;
1266 
1267  ResourceDescriptor++;
1268  break;
1269  }
1271  {
1273  ResourceDescriptor->Type = CmResourceTypeMemory;
1274  ResourceDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1275  ResourceDescriptor->Flags = 0;
1276  if (memfixed32_data->WriteProtect == ACPI_READ_ONLY_MEMORY)
1277  ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
1278  else
1279  ResourceDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
1280  ResourceDescriptor->u.Memory.Start.QuadPart = memfixed32_data->Address;
1281  ResourceDescriptor->u.Memory.Length = memfixed32_data->AddressLength;
1282 
1283  ResourceDescriptor++;
1284  break;
1285  }
1286  default:
1287  {
1288  break;
1289  }
1290  }
1292  }
1293 
1294  ExFreePoolWithTag(Buffer.Pointer, 'BpcA');
1295  Irp->IoStatus.Information = (ULONG_PTR)ResourceList;
1296  return STATUS_SUCCESS;
1297 }
1298 #endif /* UNIT_TEST */
1299 
1300 NTSTATUS
1303  PIRP Irp )
1304 {
1305  ULONG NumberOfResources = 0;
1306  ACPI_STATUS AcpiStatus;
1309  ULONG i, RequirementsListSize;
1311  PIO_RESOURCE_DESCRIPTOR RequirementDescriptor;
1312  BOOLEAN CurrentRes = FALSE;
1313  BOOLEAN SeenStartDependent;
1314 
1315  PAGED_CODE ();
1316 
1317  if (!DeviceData->AcpiHandle)
1318  {
1319  return Irp->IoStatus.Status;
1320  }
1321 
1322  /* Handle the PCI root manually */
1323  if (wcsstr(DeviceData->HardwareIDs, L"PNP0A03") != 0 ||
1324  wcsstr(DeviceData->HardwareIDs, L"PNP0A08") != 0)
1325  {
1326  return Irp->IoStatus.Status;
1327  }
1328 
1329  /* Get current resources */
1330  while (TRUE)
1331  {
1332  Buffer.Length = 0;
1333  if (CurrentRes)
1334  AcpiStatus = AcpiGetCurrentResources(DeviceData->AcpiHandle, &Buffer);
1335  else
1336  AcpiStatus = AcpiGetPossibleResources(DeviceData->AcpiHandle, &Buffer);
1337  if ((!ACPI_SUCCESS(AcpiStatus) && AcpiStatus != AE_BUFFER_OVERFLOW) ||
1338  Buffer.Length == 0)
1339  {
1340  if (!CurrentRes)
1341  CurrentRes = TRUE;
1342  else
1343  return Irp->IoStatus.Status;
1344  }
1345  else
1346  break;
1347  }
1348 
1349  Buffer.Pointer = ExAllocatePoolWithTag(PagedPool, Buffer.Length, 'BpcA');
1350  if (!Buffer.Pointer)
1352 
1353  if (CurrentRes)
1354  AcpiStatus = AcpiGetCurrentResources(DeviceData->AcpiHandle, &Buffer);
1355  else
1356  AcpiStatus = AcpiGetPossibleResources(DeviceData->AcpiHandle, &Buffer);
1357  if (!ACPI_SUCCESS(AcpiStatus))
1358  {
1359  DPRINT1("AcpiGetCurrentResources #2 failed (0x%x)\n", AcpiStatus);
1360  ASSERT(FALSE);
1361  return STATUS_UNSUCCESSFUL;
1362  }
1363 
1364  SeenStartDependent = FALSE;
1365  resource = Buffer.Pointer;
1366  /* Count number of resources */
1368  {
1370  {
1371  if (SeenStartDependent)
1372  {
1373  break;
1374  }
1375  SeenStartDependent = TRUE;
1376  }
1377  switch (resource->Type)
1378  {
1380  {
1382  if (irq_data->ProducerConsumer == ACPI_PRODUCER)
1383  break;
1384  NumberOfResources += irq_data->InterruptCount;
1385  break;
1386  }
1388  {
1389  ACPI_RESOURCE_IRQ *irq_data = (ACPI_RESOURCE_IRQ*) &resource->Data;
1390  NumberOfResources += irq_data->InterruptCount;
1391  break;
1392  }
1394  {
1395  ACPI_RESOURCE_DMA *dma_data = (ACPI_RESOURCE_DMA*) &resource->Data;
1396  NumberOfResources += dma_data->ChannelCount;
1397  break;
1398  }
1403  {
1405  if (res_addr->ProducerConsumer == ACPI_PRODUCER)
1406  break;
1407  NumberOfResources++;
1408  break;
1409  }
1414  case ACPI_RESOURCE_TYPE_IO:
1415  {
1416  NumberOfResources++;
1417  break;
1418  }
1419  default:
1420  {
1421  break;
1422  }
1423  }
1425  }
1426 
1427  RequirementsListSize = sizeof(IO_RESOURCE_REQUIREMENTS_LIST) + sizeof(IO_RESOURCE_DESCRIPTOR) * (NumberOfResources - 1);
1428  RequirementsList = ExAllocatePoolWithTag(PagedPool, RequirementsListSize, 'RpcA');
1429 
1430  if (!RequirementsList)
1431  {
1432  ExFreePoolWithTag(Buffer.Pointer, 'BpcA');
1434  }
1435  RequirementsList->ListSize = RequirementsListSize;
1436  RequirementsList->InterfaceType = Internal;
1437  RequirementsList->BusNumber = 0;
1438  RequirementsList->SlotNumber = 0; /* Not used by WDM drivers */
1439  RequirementsList->AlternativeLists = 1;
1440  RequirementsList->List[0].Version = 1;
1441  RequirementsList->List[0].Revision = 1;
1442  RequirementsList->List[0].Count = NumberOfResources;
1443  RequirementDescriptor = RequirementsList->List[0].Descriptors;
1444 
1445  /* Fill resources list structure */
1446  SeenStartDependent = FALSE;
1447  resource = Buffer.Pointer;
1449  {
1451  {
1452  if (SeenStartDependent)
1453  {
1454  break;
1455  }
1456  SeenStartDependent = TRUE;
1457  }
1458  switch (resource->Type)
1459  {
1461  {
1462  ACPI_RESOURCE_EXTENDED_IRQ *irq_data = &resource->Data.ExtendedIrq;
1463  if (irq_data->ProducerConsumer == ACPI_PRODUCER)
1464  break;
1465  for (i = 0; i < irq_data->InterruptCount; i++)
1466  {
1467  RequirementDescriptor->Option = (i == 0) ? IO_RESOURCE_PREFERRED : IO_RESOURCE_ALTERNATIVE;
1468  RequirementDescriptor->Type = CmResourceTypeInterrupt;
1471  RequirementDescriptor->u.Interrupt.MinimumVector =
1472  RequirementDescriptor->u.Interrupt.MaximumVector = irq_data->Interrupts[i];
1473 
1474  RequirementDescriptor++;
1475  }
1476  break;
1477  }
1479  {
1480  ACPI_RESOURCE_IRQ *irq_data = &resource->Data.Irq;
1481  for (i = 0; i < irq_data->InterruptCount; i++)
1482  {
1483  RequirementDescriptor->Option = (i == 0) ? IO_RESOURCE_PREFERRED : IO_RESOURCE_ALTERNATIVE;
1484  RequirementDescriptor->Type = CmResourceTypeInterrupt;
1487  RequirementDescriptor->u.Interrupt.MinimumVector =
1488  RequirementDescriptor->u.Interrupt.MaximumVector = irq_data->Interrupts[i];
1489 
1490  RequirementDescriptor++;
1491  }
1492  break;
1493  }
1495  {
1496  ACPI_RESOURCE_DMA *dma_data = &resource->Data.Dma;
1497  for (i = 0; i < dma_data->ChannelCount; i++)
1498  {
1499  RequirementDescriptor->Type = CmResourceTypeDma;
1500  RequirementDescriptor->Flags = 0;
1501  switch (dma_data->Type)
1502  {
1503  case ACPI_TYPE_A: RequirementDescriptor->Flags |= CM_RESOURCE_DMA_TYPE_A; break;
1504  case ACPI_TYPE_B: RequirementDescriptor->Flags |= CM_RESOURCE_DMA_TYPE_B; break;
1505  case ACPI_TYPE_F: RequirementDescriptor->Flags |= CM_RESOURCE_DMA_TYPE_F; break;
1506  }
1507  if (dma_data->BusMaster == ACPI_BUS_MASTER)
1508  RequirementDescriptor->Flags |= CM_RESOURCE_DMA_BUS_MASTER;
1509  switch (dma_data->Transfer)
1510  {
1511  case ACPI_TRANSFER_8: RequirementDescriptor->Flags |= CM_RESOURCE_DMA_8; break;
1512  case ACPI_TRANSFER_16: RequirementDescriptor->Flags |= CM_RESOURCE_DMA_16; break;
1513  case ACPI_TRANSFER_8_16: RequirementDescriptor->Flags |= CM_RESOURCE_DMA_8_AND_16; break;
1514  }
1515 
1516  RequirementDescriptor->Option = (i == 0) ? IO_RESOURCE_PREFERRED : IO_RESOURCE_ALTERNATIVE;
1517  RequirementDescriptor->ShareDisposition = CmResourceShareDriverExclusive;
1518  RequirementDescriptor->u.Dma.MinimumChannel =
1519  RequirementDescriptor->u.Dma.MaximumChannel = dma_data->Channels[i];
1520  RequirementDescriptor++;
1521  }
1522  break;
1523  }
1524  case ACPI_RESOURCE_TYPE_IO:
1525  {
1526  ACPI_RESOURCE_IO *io_data = &resource->Data.Io;
1527  RequirementDescriptor->Flags = CM_RESOURCE_PORT_IO;
1528  if (io_data->IoDecode == ACPI_DECODE_16)
1529  RequirementDescriptor->Flags |= CM_RESOURCE_PORT_16_BIT_DECODE;
1530  else
1531  RequirementDescriptor->Flags |= CM_RESOURCE_PORT_10_BIT_DECODE;
1532  RequirementDescriptor->u.Port.Length = io_data->AddressLength;
1533  RequirementDescriptor->Option = CurrentRes ? 0 : IO_RESOURCE_PREFERRED;
1534  RequirementDescriptor->Type = CmResourceTypePort;
1535  RequirementDescriptor->ShareDisposition = CmResourceShareDriverExclusive;
1536  RequirementDescriptor->u.Port.Alignment = io_data->Alignment;
1537  RequirementDescriptor->u.Port.MinimumAddress.QuadPart = io_data->Minimum;
1538  RequirementDescriptor->u.Port.MaximumAddress.QuadPart = io_data->Maximum + io_data->AddressLength - 1;
1539 
1540  RequirementDescriptor++;
1541  break;
1542  }
1544  {
1545  ACPI_RESOURCE_FIXED_IO *io_data = &resource->Data.FixedIo;
1546  RequirementDescriptor->Flags = CM_RESOURCE_PORT_IO;
1547  RequirementDescriptor->u.Port.Length = io_data->AddressLength;
1548  RequirementDescriptor->Option = CurrentRes ? 0 : IO_RESOURCE_PREFERRED;
1549  RequirementDescriptor->Type = CmResourceTypePort;
1550  RequirementDescriptor->ShareDisposition = CmResourceShareDriverExclusive;
1551  RequirementDescriptor->u.Port.Alignment = 1;
1552  RequirementDescriptor->u.Port.MinimumAddress.QuadPart = io_data->Address;
1553  RequirementDescriptor->u.Port.MaximumAddress.QuadPart = io_data->Address + io_data->AddressLength - 1;
1554 
1555  RequirementDescriptor++;
1556  break;
1557  }
1559  {
1560  ACPI_RESOURCE_ADDRESS16 *addr16_data = &resource->Data.Address16;
1561  if (addr16_data->ProducerConsumer == ACPI_PRODUCER)
1562  break;
1563  RequirementDescriptor->Option = CurrentRes ? 0 : IO_RESOURCE_PREFERRED;
1564  if (addr16_data->ResourceType == ACPI_BUS_NUMBER_RANGE)
1565  {
1566  RequirementDescriptor->Type = CmResourceTypeBusNumber;
1567  RequirementDescriptor->ShareDisposition = CmResourceShareShared;
1568  RequirementDescriptor->Flags = 0;
1569  RequirementDescriptor->u.BusNumber.MinBusNumber = addr16_data->Address.Minimum;
1570  RequirementDescriptor->u.BusNumber.MaxBusNumber = addr16_data->Address.Maximum + addr16_data->Address.AddressLength - 1;
1571  RequirementDescriptor->u.BusNumber.Length = addr16_data->Address.AddressLength;
1572  }
1573  else if (addr16_data->ResourceType == ACPI_IO_RANGE)
1574  {
1575  RequirementDescriptor->Type = CmResourceTypePort;
1576  RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1577  RequirementDescriptor->Flags = CM_RESOURCE_PORT_IO;
1578  if (addr16_data->Decode == ACPI_POS_DECODE)
1579  RequirementDescriptor->Flags |= CM_RESOURCE_PORT_POSITIVE_DECODE;
1580  RequirementDescriptor->u.Port.MinimumAddress.QuadPart = addr16_data->Address.Minimum;
1581  RequirementDescriptor->u.Port.MaximumAddress.QuadPart = addr16_data->Address.Maximum + addr16_data->Address.AddressLength - 1;
1582  RequirementDescriptor->u.Port.Length = addr16_data->Address.AddressLength;
1583  }
1584  else
1585  {
1586  RequirementDescriptor->Type = CmResourceTypeMemory;
1587  RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1588  RequirementDescriptor->Flags = 0;
1589  if (addr16_data->Info.Mem.WriteProtect == ACPI_READ_ONLY_MEMORY)
1590  RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
1591  else
1592  RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
1593  switch (addr16_data->Info.Mem.Caching)
1594  {
1595  case ACPI_CACHABLE_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_CACHEABLE; break;
1596  case ACPI_WRITE_COMBINING_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_COMBINEDWRITE; break;
1597  case ACPI_PREFETCHABLE_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_PREFETCHABLE; break;
1598  }
1599  RequirementDescriptor->u.Memory.MinimumAddress.QuadPart = addr16_data->Address.Minimum;
1600  RequirementDescriptor->u.Memory.MaximumAddress.QuadPart = addr16_data->Address.Maximum + addr16_data->Address.AddressLength - 1;
1601  RequirementDescriptor->u.Memory.Length = addr16_data->Address.AddressLength;
1602  }
1603  RequirementDescriptor++;
1604  break;
1605  }
1607  {
1608  ACPI_RESOURCE_ADDRESS32 *addr32_data = &resource->Data.Address32;
1609  if (addr32_data->ProducerConsumer == ACPI_PRODUCER)
1610  break;
1611  RequirementDescriptor->Option = CurrentRes ? 0 : IO_RESOURCE_PREFERRED;
1612  if (addr32_data->ResourceType == ACPI_BUS_NUMBER_RANGE)
1613  {
1614  RequirementDescriptor->Type = CmResourceTypeBusNumber;
1615  RequirementDescriptor->ShareDisposition = CmResourceShareShared;
1616  RequirementDescriptor->Flags = 0;
1617  RequirementDescriptor->u.BusNumber.MinBusNumber = addr32_data->Address.Minimum;
1618  RequirementDescriptor->u.BusNumber.MaxBusNumber = addr32_data->Address.Maximum + addr32_data->Address.AddressLength - 1;
1619  RequirementDescriptor->u.BusNumber.Length = addr32_data->Address.AddressLength;
1620  }
1621  else if (addr32_data->ResourceType == ACPI_IO_RANGE)
1622  {
1623  RequirementDescriptor->Type = CmResourceTypePort;
1624  RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1625  RequirementDescriptor->Flags = CM_RESOURCE_PORT_IO;
1626  if (addr32_data->Decode == ACPI_POS_DECODE)
1627  RequirementDescriptor->Flags |= CM_RESOURCE_PORT_POSITIVE_DECODE;
1628  RequirementDescriptor->u.Port.MinimumAddress.QuadPart = addr32_data->Address.Minimum;
1629  RequirementDescriptor->u.Port.MaximumAddress.QuadPart = addr32_data->Address.Maximum + addr32_data->Address.AddressLength - 1;
1630  RequirementDescriptor->u.Port.Length = addr32_data->Address.AddressLength;
1631  }
1632  else
1633  {
1634  RequirementDescriptor->Type = CmResourceTypeMemory;
1635  RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1636  RequirementDescriptor->Flags = 0;
1637  if (addr32_data->Info.Mem.WriteProtect == ACPI_READ_ONLY_MEMORY)
1638  RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
1639  else
1640  RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
1641  switch (addr32_data->Info.Mem.Caching)
1642  {
1643  case ACPI_CACHABLE_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_CACHEABLE; break;
1644  case ACPI_WRITE_COMBINING_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_COMBINEDWRITE; break;
1645  case ACPI_PREFETCHABLE_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_PREFETCHABLE; break;
1646  }
1647  RequirementDescriptor->u.Memory.MinimumAddress.QuadPart = addr32_data->Address.Minimum;
1648  RequirementDescriptor->u.Memory.MaximumAddress.QuadPart = addr32_data->Address.Maximum + addr32_data->Address.AddressLength - 1;
1649  RequirementDescriptor->u.Memory.Length = addr32_data->Address.AddressLength;
1650  }
1651  RequirementDescriptor++;
1652  break;
1653  }
1655  {
1656  ACPI_RESOURCE_ADDRESS64 *addr64_data = &resource->Data.Address64;
1657  if (addr64_data->ProducerConsumer == ACPI_PRODUCER)
1658  break;
1659  RequirementDescriptor->Option = CurrentRes ? 0 : IO_RESOURCE_PREFERRED;
1660  if (addr64_data->ResourceType == ACPI_BUS_NUMBER_RANGE)
1661  {
1662  DPRINT1("64-bit bus address is not supported!\n");
1663  RequirementDescriptor->Type = CmResourceTypeBusNumber;
1664  RequirementDescriptor->ShareDisposition = CmResourceShareShared;
1665  RequirementDescriptor->Flags = 0;
1666  RequirementDescriptor->u.BusNumber.MinBusNumber = (ULONG)addr64_data->Address.Minimum;
1667  RequirementDescriptor->u.BusNumber.MaxBusNumber = (ULONG)addr64_data->Address.Maximum + addr64_data->Address.AddressLength - 1;
1668  RequirementDescriptor->u.BusNumber.Length = addr64_data->Address.AddressLength;
1669  }
1670  else if (addr64_data->ResourceType == ACPI_IO_RANGE)
1671  {
1672  RequirementDescriptor->Type = CmResourceTypePort;
1673  RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1674  RequirementDescriptor->Flags = CM_RESOURCE_PORT_IO;
1675  if (addr64_data->Decode == ACPI_POS_DECODE)
1676  RequirementDescriptor->Flags |= CM_RESOURCE_PORT_POSITIVE_DECODE;
1677  RequirementDescriptor->u.Port.MinimumAddress.QuadPart = addr64_data->Address.Minimum;
1678  RequirementDescriptor->u.Port.MaximumAddress.QuadPart = addr64_data->Address.Maximum + addr64_data->Address.AddressLength - 1;
1679  RequirementDescriptor->u.Port.Length = addr64_data->Address.AddressLength;
1680  }
1681  else
1682  {
1683  RequirementDescriptor->Type = CmResourceTypeMemory;
1684  RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1685  RequirementDescriptor->Flags = 0;
1686  if (addr64_data->Info.Mem.WriteProtect == ACPI_READ_ONLY_MEMORY)
1687  RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
1688  else
1689  RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
1690  switch (addr64_data->Info.Mem.Caching)
1691  {
1692  case ACPI_CACHABLE_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_CACHEABLE; break;
1693  case ACPI_WRITE_COMBINING_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_COMBINEDWRITE; break;
1694  case ACPI_PREFETCHABLE_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_PREFETCHABLE; break;
1695  }
1696  RequirementDescriptor->u.Memory.MinimumAddress.QuadPart = addr64_data->Address.Minimum;
1697  RequirementDescriptor->u.Memory.MaximumAddress.QuadPart = addr64_data->Address.Maximum + addr64_data->Address.AddressLength - 1;
1698  RequirementDescriptor->u.Memory.Length = addr64_data->Address.AddressLength;
1699  }
1700  RequirementDescriptor++;
1701  break;
1702  }
1704  {
1705  ACPI_RESOURCE_EXTENDED_ADDRESS64 *addr64_data = &resource->Data.ExtAddress64;
1706  if (addr64_data->ProducerConsumer == ACPI_PRODUCER)
1707  break;
1708  RequirementDescriptor->Option = CurrentRes ? 0 : IO_RESOURCE_PREFERRED;
1709  if (addr64_data->ResourceType == ACPI_BUS_NUMBER_RANGE)
1710  {
1711  DPRINT1("64-bit bus address is not supported!\n");
1712  RequirementDescriptor->Type = CmResourceTypeBusNumber;
1713  RequirementDescriptor->ShareDisposition = CmResourceShareShared;
1714  RequirementDescriptor->Flags = 0;
1715  RequirementDescriptor->u.BusNumber.MinBusNumber = (ULONG)addr64_data->Address.Minimum;
1716  RequirementDescriptor->u.BusNumber.MaxBusNumber = (ULONG)addr64_data->Address.Maximum + addr64_data->Address.AddressLength - 1;
1717  RequirementDescriptor->u.BusNumber.Length = addr64_data->Address.AddressLength;
1718  }
1719  else if (addr64_data->ResourceType == ACPI_IO_RANGE)
1720  {
1721  RequirementDescriptor->Type = CmResourceTypePort;
1722  RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1723  RequirementDescriptor->Flags = CM_RESOURCE_PORT_IO;
1724  if (addr64_data->Decode == ACPI_POS_DECODE)
1725  RequirementDescriptor->Flags |= CM_RESOURCE_PORT_POSITIVE_DECODE;
1726  RequirementDescriptor->u.Port.MinimumAddress.QuadPart = addr64_data->Address.Minimum;
1727  RequirementDescriptor->u.Port.MaximumAddress.QuadPart = addr64_data->Address.Maximum + addr64_data->Address.AddressLength - 1;
1728  RequirementDescriptor->u.Port.Length = addr64_data->Address.AddressLength;
1729  }
1730  else
1731  {
1732  RequirementDescriptor->Type = CmResourceTypeMemory;
1733  RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1734  RequirementDescriptor->Flags = 0;
1735  if (addr64_data->Info.Mem.WriteProtect == ACPI_READ_ONLY_MEMORY)
1736  RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
1737  else
1738  RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
1739  switch (addr64_data->Info.Mem.Caching)
1740  {
1741  case ACPI_CACHABLE_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_CACHEABLE; break;
1742  case ACPI_WRITE_COMBINING_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_COMBINEDWRITE; break;
1743  case ACPI_PREFETCHABLE_MEMORY: RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_PREFETCHABLE; break;
1744  }
1745  RequirementDescriptor->u.Memory.MinimumAddress.QuadPart = addr64_data->Address.Minimum;
1746  RequirementDescriptor->u.Memory.MaximumAddress.QuadPart = addr64_data->Address.Maximum + addr64_data->Address.AddressLength - 1;
1747  RequirementDescriptor->u.Memory.Length = addr64_data->Address.AddressLength;
1748  }
1749  RequirementDescriptor++;
1750  break;
1751  }
1753  {
1754  ACPI_RESOURCE_MEMORY24 *mem24_data = &resource->Data.Memory24;
1755  RequirementDescriptor->Option = CurrentRes ? 0 : IO_RESOURCE_PREFERRED;
1756  RequirementDescriptor->Type = CmResourceTypeMemory;
1757  RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1758  RequirementDescriptor->Flags = CM_RESOURCE_MEMORY_24;
1759  if (mem24_data->WriteProtect == ACPI_READ_ONLY_MEMORY)
1760  RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
1761  else
1762  RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
1763  RequirementDescriptor->u.Memory.MinimumAddress.QuadPart = mem24_data->Minimum;
1764  RequirementDescriptor->u.Memory.MaximumAddress.QuadPart = mem24_data->Maximum + mem24_data->AddressLength - 1;
1765  RequirementDescriptor->u.Memory.Length = mem24_data->AddressLength;
1766 
1767  RequirementDescriptor++;
1768  break;
1769  }
1771  {
1772  ACPI_RESOURCE_MEMORY32 *mem32_data = &resource->Data.Memory32;
1773  RequirementDescriptor->Option = CurrentRes ? 0 : IO_RESOURCE_PREFERRED;
1774  RequirementDescriptor->Type = CmResourceTypeMemory;
1775  RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1776  RequirementDescriptor->Flags = 0;
1777  if (mem32_data->WriteProtect == ACPI_READ_ONLY_MEMORY)
1778  RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
1779  else
1780  RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
1781  RequirementDescriptor->u.Memory.MinimumAddress.QuadPart = mem32_data->Minimum;
1782  RequirementDescriptor->u.Memory.MaximumAddress.QuadPart = mem32_data->Maximum + mem32_data->AddressLength - 1;
1783  RequirementDescriptor->u.Memory.Length = mem32_data->AddressLength;
1784 
1785  RequirementDescriptor++;
1786  break;
1787  }
1789  {
1790  ACPI_RESOURCE_FIXED_MEMORY32 *fixedmem32_data = &resource->Data.FixedMemory32;
1791  RequirementDescriptor->Option = CurrentRes ? 0 : IO_RESOURCE_PREFERRED;
1792  RequirementDescriptor->Type = CmResourceTypeMemory;
1793  RequirementDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
1794  RequirementDescriptor->Flags = 0;
1795  if (fixedmem32_data->WriteProtect == ACPI_READ_ONLY_MEMORY)
1796  RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_ONLY;
1797  else
1798  RequirementDescriptor->Flags |= CM_RESOURCE_MEMORY_READ_WRITE;
1799  RequirementDescriptor->u.Memory.MinimumAddress.QuadPart = fixedmem32_data->Address;
1800  RequirementDescriptor->u.Memory.MaximumAddress.QuadPart = fixedmem32_data->Address + fixedmem32_data->AddressLength - 1;
1801  RequirementDescriptor->u.Memory.Length = fixedmem32_data->AddressLength;
1802 
1803  RequirementDescriptor++;
1804  break;
1805  }
1806  default:
1807  {
1808  break;
1809  }
1810  }
1812  }
1813  ExFreePoolWithTag(Buffer.Pointer, 'BpcA');
1814 
1815  Irp->IoStatus.Information = (ULONG_PTR)RequirementsList;
1816 
1817  return STATUS_SUCCESS;
1818 }
1819 
1820 #ifndef UNIT_TEST
1821 NTSTATUS
1824  PIRP Irp )
1825 /*++
1826 
1827 Routine Description:
1828 
1829  The PnP Manager sends this IRP to gather information about
1830  devices with a relationship to the specified device.
1831  Bus drivers must handle this request for TargetDeviceRelation
1832  for their child devices (child PDOs).
1833 
1834  If a driver returns relations in response to this IRP,
1835  it allocates a DEVICE_RELATIONS structure from paged
1836  memory containing a count and the appropriate number of
1837  device object pointers. The PnP Manager frees the structure
1838  when it is no longer needed. If a driver replaces a
1839  DEVICE_RELATIONS structure allocated by another driver,
1840  it must free the previous structure.
1841 
1842  A driver must reference the PDO of any device that it
1843  reports in this IRP (ObReferenceObject). The PnP Manager
1844  removes the reference when appropriate.
1845 
1846 Arguments:
1847 
1848  DeviceData - Pointer to the PDO's device extension.
1849  Irp - Pointer to the irp.
1850 
1851 Return Value:
1852 
1853  NT STATUS
1854 
1855 --*/
1856 {
1857 
1859  PDEVICE_RELATIONS deviceRelations;
1860  NTSTATUS status;
1861 
1862  PAGED_CODE ();
1863 
1865 
1866  switch (stack->Parameters.QueryDeviceRelations.Type) {
1867 
1868  case TargetDeviceRelation:
1869 
1870  deviceRelations = (PDEVICE_RELATIONS) Irp->IoStatus.Information;
1871  if (deviceRelations) {
1872  //
1873  // Only PDO can handle this request. Somebody above
1874  // is not playing by rule.
1875  //
1876  ASSERTMSG("Someone above is handling TargetDeviceRelation\n", !deviceRelations);
1877  }
1878 
1879  deviceRelations = ExAllocatePoolWithTag(PagedPool,
1880  sizeof(DEVICE_RELATIONS),
1881  'IpcA');
1882  if (!deviceRelations) {
1884  break;
1885  }
1886 
1887  //
1888  // There is only one PDO pointer in the structure
1889  // for this relation type. The PnP Manager removes
1890  // the reference to the PDO when the driver or application
1891  // un-registers for notification on the device.
1892  //
1893 
1894  deviceRelations->Count = 1;
1895  deviceRelations->Objects[0] = DeviceData->Common.Self;
1896  ObReferenceObject(DeviceData->Common.Self);
1897 
1899  Irp->IoStatus.Information = (ULONG_PTR) deviceRelations;
1900  break;
1901 
1902  case BusRelations: // Not handled by PDO
1903  case EjectionRelations: // optional for PDO
1904  case RemovalRelations: // // optional for PDO
1905  default:
1906  status = Irp->IoStatus.Status;
1907  }
1908 
1909  return status;
1910 }
1911 
1912 NTSTATUS
1915  PIRP Irp )
1916 /*++
1917 
1918 Routine Description:
1919 
1920  The PnP Manager uses this IRP to request the type and
1921  instance number of a device's parent bus. Bus drivers
1922  should handle this request for their child devices (PDOs).
1923 
1924 Arguments:
1925 
1926  DeviceData - Pointer to the PDO's device extension.
1927  Irp - Pointer to the irp.
1928 
1929 Return Value:
1930 
1931  NT STATUS
1932 
1933 --*/
1934 {
1935 
1936  PPNP_BUS_INFORMATION busInfo;
1937 
1938  PAGED_CODE ();
1939 
1940  busInfo = ExAllocatePoolWithTag(PagedPool,
1941  sizeof(PNP_BUS_INFORMATION),
1942  'IpcA');
1943 
1944  if (busInfo == NULL) {
1946  }
1947 
1948  busInfo->BusTypeGuid = GUID_ACPI_INTERFACE_STANDARD;
1949 
1950  busInfo->LegacyBusType = InternalPowerBus;
1951 
1952  busInfo->BusNumber = 0; //fixme
1953 
1954  Irp->IoStatus.Information = (ULONG_PTR)busInfo;
1955 
1956  return STATUS_SUCCESS;
1957 }
1958 
1959 
1960 NTSTATUS
1964  )
1965 {
1966  IO_STATUS_BLOCK ioStatus;
1967  KEVENT pnpEvent;
1968  NTSTATUS status;
1969  PDEVICE_OBJECT targetObject;
1970  PIO_STACK_LOCATION irpStack;
1971  PIRP pnpIrp;
1972 
1973  PAGED_CODE();
1974 
1975  //
1976  // Initialize the capabilities that we will send down
1977  //
1979  DeviceCapabilities->Size = sizeof(DEVICE_CAPABILITIES);
1980  DeviceCapabilities->Version = 1;
1981  DeviceCapabilities->Address = -1;
1982  DeviceCapabilities->UINumber = -1;
1983 
1984  //
1985  // Initialize the event
1986  //
1987  KeInitializeEvent( &pnpEvent, NotificationEvent, FALSE );
1988 
1989  targetObject = IoGetAttachedDeviceReference( DeviceObject );
1990 
1991  //
1992  // Build an Irp
1993  //
1995  IRP_MJ_PNP,
1996  targetObject,
1997  NULL,
1998  0,
1999  NULL,
2000  &pnpEvent,
2001  &ioStatus
2002  );
2003  if (pnpIrp == NULL) {
2004 
2006  goto GetDeviceCapabilitiesExit;
2007 
2008  }
2009 
2010  //
2011  // Pnp Irps all begin life as STATUS_NOT_SUPPORTED;
2012  //
2014 
2015  //
2016  // Get the top of stack
2017  //
2018  irpStack = IoGetNextIrpStackLocation( pnpIrp );
2019 
2020  //
2021  // Set the top of stack
2022  //
2023  RtlZeroMemory( irpStack, sizeof(IO_STACK_LOCATION ) );
2024  irpStack->MajorFunction = IRP_MJ_PNP;
2026  irpStack->Parameters.DeviceCapabilities.Capabilities = DeviceCapabilities;
2027 
2028  //
2029  // Call the driver
2030  //
2031  status = IoCallDriver( targetObject, pnpIrp );
2032  if (status == STATUS_PENDING) {
2033 
2034  //
2035  // Block until the irp comes back.
2036  // Important thing to note here is when you allocate
2037  // the memory for an event in the stack you must do a
2038  // KernelMode wait instead of UserMode to prevent
2039  // the stack from getting paged out.
2040  //
2041 
2043  &pnpEvent,
2044  Executive,
2045  KernelMode,
2046  FALSE,
2047  NULL
2048  );
2049  status = ioStatus.Status;
2050 
2051  }
2052 
2053 GetDeviceCapabilitiesExit:
2054  //
2055  // Done with reference
2056  //
2057  ObDereferenceObject( targetObject );
2058 
2059  //
2060  // Done
2061  //
2062  return status;
2063 
2064 }
2065 #endif /* UNIT_TEST */
#define CM_RESOURCE_DMA_16
Definition: cmtypes.h:132
struct _IO_RESOURCE_REQUIREMENTS_LIST IO_RESOURCE_REQUIREMENTS_LIST
#define IRP_MN_CANCEL_REMOVE_DEVICE
#define ACPI_WRITE_COMBINING_MEMORY
Definition: acrestyp.h:62
return STATUS_NOT_SUPPORTED
#define CM_RESOURCE_MEMORY_PREFETCHABLE
Definition: cmtypes.h:123
#define IRP_MN_QUERY_RESOURCES
#define IRP_MN_REMOVE_DEVICE
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define IRP_MN_QUERY_ID
#define ACPI_SUCCESS(a)
Definition: acexcep.h:94
#define ACPI_PRODUCER
Definition: acrestyp.h:149
#define ACPI_RESOURCE_TYPE_START_DEPENDENT
Definition: acrestyp.h:716
int acpi_bus_get_device(ACPI_HANDLE handle, struct acpi_device **device)
Definition: bus.c:108
#define IO_RESOURCE_PREFERRED
struct _CM_PARTIAL_RESOURCE_DESCRIPTOR::@385::@388 Interrupt
NTSTATUS Bus_PDO_QueryResources(PPDO_DEVICE_DATA DeviceData, PIRP Irp)
Definition: buspdo.c:794
PIRP NTAPI IoBuildSynchronousFsdRequest(IN ULONG MajorFunction, IN PDEVICE_OBJECT DeviceObject, IN PVOID Buffer, IN ULONG Length, IN PLARGE_INTEGER StartingOffset, IN PKEVENT Event, IN PIO_STATUS_BLOCK IoStatusBlock)
Definition: irp.c:1069
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
struct _IO_RESOURCE_DESCRIPTOR::@1580::@1583 Interrupt
#define ACPI_TYPE_A
Definition: acrestyp.h:116
#define TRUE
Definition: types.h:120
#define ACPI_RESOURCE_TYPE_END_DEPENDENT
Definition: acrestyp.h:717
_CONST_RETURN wchar_t *__cdecl wcsstr(_In_z_ const wchar_t *_Str, _In_z_ const wchar_t *_SubStr)
ACPI_STATUS acpi_evaluate_integer(ACPI_HANDLE handle, ACPI_STRING pathname, ACPI_OBJECT_LIST *arguments, unsigned long long *data)
Definition: utils.c:242
#define IRP_MN_FILTER_RESOURCE_REQUIREMENTS
char * strstr(char *String1, char *String2)
Definition: utclib.c:653
#define ACPI_TRANSFER_8_16
Definition: acrestyp.h:124
#define ACPI_BUS_MASTER
Definition: acrestyp.h:121
#define IRP_MN_QUERY_RESOURCE_REQUIREMENTS
PDEVICE_OBJECT Objects[1]
Definition: iotypes.h:2143
#define IRP_MJ_PNP
Definition: cdrw_usr.h:52
#define ACPI_RESOURCE_TYPE_IRQ
Definition: acrestyp.h:714
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS Bus_PDO_PnP(PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpStack, PPDO_DEVICE_DATA DeviceData)
Definition: buspdo.c:23
#define ACPI_TYPE_F
Definition: acrestyp.h:118
#define ACPI_RESOURCE_TYPE_END_TAG
Definition: acrestyp.h:721
GLuint buffer
Definition: glext.h:5915
struct _IO_RESOURCE_DESCRIPTOR::@1580::@1587 BusNumber
#define ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
Definition: acrestyp.h:728
DEVICE_CAPABILITIES
Definition: iotypes.h:948
UINT8 AddressLength
Definition: acrestyp.h:218
BOOLEAN acpi_bus_power_manageable(ACPI_HANDLE handle)
Definition: bus.c:351
static stack_node_t * stack
Definition: rpn_ieee.c:37
#define ACPI_READ_ONLY_MEMORY
Definition: acrestyp.h:57
IO_STATUS_BLOCK IoStatus
uint16_t * PWCHAR
Definition: typedefs.h:56
#define CM_RESOURCE_DMA_TYPE_F
Definition: cmtypes.h:138
struct _CM_PARTIAL_RESOURCE_DESCRIPTOR::@385::@387 Port
UINT32 ACPI_STATUS
Definition: actypes.h:460
int resource
Definition: rdpsnd_sgi.c:44
NTSTATUS Bus_PDO_QueryResourceRequirements(PPDO_DEVICE_DATA DeviceData, PIRP Irp)
Definition: buspdo.c:1301
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
#define CM_RESOURCE_DMA_TYPE_A
Definition: cmtypes.h:136
_Must_inspect_result_ _In_ WDFIORESREQLIST _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFIORESLIST * ResourceList
Definition: wdfresource.h:304
#define CM_RESOURCE_MEMORY_READ_WRITE
Definition: cmtypes.h:120
#define CmResourceTypePort
Definition: hwresource.cpp:123
#define ACPI_BUS_NUMBER_RANGE
Definition: acrestyp.h:139
FxDevice * device
struct _IO_RESOURCE_DESCRIPTOR::@1580::@1581 Port
#define ACPI_RESOURCE_TYPE_IO
Definition: acrestyp.h:718
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
union _CM_PARTIAL_RESOURCE_DESCRIPTOR::@385 u
#define ACPI_PROCESSOR_HID
Definition: acpi_drivers.h:221
#define AE_BUFFER_OVERFLOW
Definition: acexcep.h:119
#define CM_RESOURCE_MEMORY_24
Definition: cmtypes.h:125
#define FALSE
Definition: types.h:117
#define UNICODE_NULL
_In_ PIRP Irp
Definition: csq.h:116
#define IRP_MN_QUERY_REMOVE_DEVICE
Definition: devices.h:37
#define ACPI_THERMAL_HID
Definition: acpi_drivers.h:266
#define ACPI_SHARED
Definition: acrestyp.h:105
#define ASSERTMSG(msg, exp)
Definition: nt_native.h:431
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
#define CM_RESOURCE_MEMORY_READ_ONLY
Definition: cmtypes.h:121
struct _DEVICE_RELATIONS * PDEVICE_RELATIONS
struct _CM_PARTIAL_RESOURCE_DESCRIPTOR::@385::@391 Dma
unsigned char BOOLEAN
#define CM_RESOURCE_DMA_8_AND_16
Definition: cmtypes.h:134
#define CM_RESOURCE_PORT_16_BIT_DECODE
Definition: cmtypes.h:112
#define IoCompleteRequest
Definition: irp.c:1240
#define DeviceCapabilities
Definition: wingdi.h:4448
void DPRINT(...)
Definition: polytest.cpp:61
Definition: bufpool.h:45
#define ACPI_PREFETCHABLE_MEMORY
Definition: acrestyp.h:63
NTSTATUS NTAPI IoSetDeviceInterfaceState(IN PUNICODE_STRING SymbolicLinkName, IN BOOLEAN Enable)
Definition: deviface.c:1311
struct _CM_PARTIAL_RESOURCE_DESCRIPTOR::@385::@393 BusNumber
#define CM_RESOURCE_PORT_10_BIT_DECODE
Definition: cmtypes.h:110
PDEVICE_OBJECT NTAPI IoGetAttachedDeviceReference(PDEVICE_OBJECT DeviceObject)
Definition: device.c:1406
_In_opt_ PUNICODE_STRING _In_ PDRIVER_OBJECT _In_ PDEVICE_OBJECT _In_ INTERFACE_TYPE _In_ ULONG BusNumber
Definition: halfuncs.h:156
Definition: fbtusb.h:81
#define ACPI_D_STATE_COUNT
Definition: actypes.h:630
#define ACPI_TRANSFER_8
Definition: acrestyp.h:123
#define IRP_MN_QUERY_STOP_DEVICE
Definition: _stack.h:47
LPWSTR ProcessorIdString
Definition: main.c:25
struct _IO_RESOURCE_DESCRIPTOR::@1580::@1584 Dma
#define ACPI_RESOURCE_TYPE_ADDRESS32
Definition: acrestyp.h:726
#define IRP_MN_STOP_DEVICE
#define ASSERT(a)
Definition: mode.c:45
UINT8 Interrupts[1]
Definition: acrestyp.h:185
if(!(yy_init))
Definition: macro.lex.yy.c:714
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
#define RESTORE_PREVIOUS_PNP_STATE(_Data_)
Definition: fbtusb.h:115
NTSTATUS Bus_PDO_QueryDeviceId(PPDO_DEVICE_DATA DeviceData, PIRP Irp)
Definition: buspdo.c:433
#define CM_RESOURCE_PORT_POSITIVE_DECODE
Definition: cmtypes.h:113
uint64_t ULONGLONG
Definition: typedefs.h:67
NTSTATUS Bus_PDO_QueryDeviceRelations(PPDO_DEVICE_DATA DeviceData, PIRP Irp)
Definition: buspdo.c:1822
#define swprintf(buf, format,...)
Definition: sprintf.c:56
#define IRP_MN_START_DEVICE
#define ObDereferenceObject
Definition: obfuncs.h:203
UINT16 Minimum
Definition: acrestyp.h:219
ACPI_STATUS AcpiGetPossibleResources(ACPI_HANDLE DeviceHandle, ACPI_BUFFER *RetBuffer)
Definition: rsxface.c:273
bool removable
Definition: btrfs_drv.h:537
#define for
Definition: utility.h:88
NTSTATUS Bus_PDO_QueryDeviceText(PPDO_DEVICE_DATA DeviceData, PIRP Irp)
Definition: buspdo.c:681
#define ACPI_BUTTON_HID_LID
Definition: acpi_drivers.h:106
struct _IO_RESOURCE_DESCRIPTOR::@1580::@1582 Memory
#define IRP_MN_QUERY_DEVICE_TEXT
#define IRP_MN_QUERY_INTERFACE
#define CM_RESOURCE_MEMORY_COMBINEDWRITE
Definition: cmtypes.h:124
#define IO_RESOURCE_ALTERNATIVE
#define ACPI_RESOURCE_TYPE_ADDRESS64
Definition: acrestyp.h:727
#define ACPI_IO_RANGE
Definition: acrestyp.h:138
#define ACPI_STATE_D3
Definition: actypes.h:628
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define CM_RESOURCE_DMA_TYPE_B
Definition: cmtypes.h:137
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define IRP_MN_QUERY_BUS_INFORMATION
NTSTATUS Bus_PDO_QueryBusInformation(PPDO_DEVICE_DATA DeviceData, PIRP Irp)
Definition: buspdo.c:1913
#define ACPI_TRANSFER_16
Definition: acrestyp.h:125
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
LPWSTR ProcessorNameString
Definition: main.c:26
static const WCHAR L[]
Definition: oid.c:1250
#define CM_RESOURCE_DMA_8
Definition: cmtypes.h:131
#define ACPI_RESOURCE_TYPE_EXTENDED_IRQ
Definition: acrestyp.h:729
static int state
Definition: maze.c:121
#define ACPI_RESOURCE_TYPE_FIXED_MEMORY32
Definition: acrestyp.h:724
GLenum src
Definition: glext.h:6340
_Must_inspect_result_ _In_ WDFDEVICE Device
Definition: wdfchildlist.h:474
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2691
struct _CM_RESOURCE_LIST CM_RESOURCE_LIST
union _IO_RESOURCE_DESCRIPTOR::@1580 u
#define ACPI_RESOURCE_TYPE_MEMORY32
Definition: acrestyp.h:723
* PDEVICE_CAPABILITIES
Definition: iotypes.h:948
#define CM_RESOURCE_MEMORY_CACHEABLE
Definition: cmtypes.h:126
UINT8 ChannelCount
Definition: acrestyp.h:194
ACPI_ADDRESS64_ATTRIBUTE Address
Definition: acrestyp.h:419
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2789
int acpi_bus_set_power(ACPI_HANDLE handle, int state)
Definition: bus.c:249
NTSTATUS NTAPI IoRegisterDeviceInterface(IN PDEVICE_OBJECT PhysicalDeviceObject, IN CONST GUID *InterfaceClassGuid, IN PUNICODE_STRING ReferenceString OPTIONAL, OUT PUNICODE_STRING SymbolicLinkName)
Definition: deviface.c:955
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
#define ACPI_NEXT_RESOURCE(Res)
Definition: acrestyp.h:802
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
ACPI_RESOURCE_ADDRESS_COMMON ACPI_ADDRESS64_ATTRIBUTE Address
Definition: acrestyp.h:410
#define CM_RESOURCE_PORT_IO
Definition: cmtypes.h:109
static calc_node_t temp
Definition: rpn_ieee.c:38
ULONG_PTR KAFFINITY
Definition: compat.h:85
#define ACPI_RESOURCE_TYPE_DMA
Definition: acrestyp.h:715
NTSTATUS Bus_GetDeviceCapabilities(PDEVICE_OBJECT DeviceObject, PDEVICE_CAPABILITIES DeviceCapabilities)
Definition: buspdo.c:1961
UNICODE_STRING ProcessorHardwareIds
Definition: main.c:24
#define NULL
Definition: types.h:112
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
#define ACPI_TYPE_B
Definition: acrestyp.h:117
#define IRP_MN_QUERY_DEVICE_RELATIONS
#define CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE
Definition: cmtypes.h:143
#define CmResourceTypeInterrupt
Definition: hwresource.cpp:124
_In_ WDFIORESREQLIST RequirementsList
Definition: wdfresource.h:65
#define DPRINT1
Definition: precomp.h:8
UINT16 Maximum
Definition: acrestyp.h:220
#define ACPI_RESOURCE_TYPE_ADDRESS16
Definition: acrestyp.h:725
#define ACPI_RESOURCE_TYPE_MEMORY24
Definition: acrestyp.h:722
#define ACPI_DECODE_16
Definition: acrestyp.h:85
#define SET_NEW_PNP_STATE(_Data_, _state_)
Definition: fbtusb.h:111
#define ACPI_POS_DECODE
Definition: acrestyp.h:144
#define ACPI_STATE_D0
Definition: actypes.h:625
#define ObReferenceObject
Definition: obfuncs.h:204
#define CM_RESOURCE_INTERRUPT_LATCHED
Definition: cmtypes.h:144
unsigned int ULONG
Definition: retypes.h:1
#define IO_NO_INCREMENT
Definition: iotypes.h:581
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
POWER_STATE NTAPI PoSetPowerState(IN PDEVICE_OBJECT DeviceObject, IN POWER_STATE_TYPE Type, IN POWER_STATE State)
Definition: power.c:708
#define ULONG_PTR
Definition: config.h:101
ACPI_RESOURCE_ADDRESS_COMMON ACPI_ADDRESS16_ATTRIBUTE Address
Definition: acrestyp.h:394
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
NTSTATUS Bus_PDO_QueryInterface(PPDO_DEVICE_DATA DeviceData, PIRP Irp)
Definition: interface.c:94
#define CmResourceTypeBusNumber
Definition: hwresource.cpp:128
#define ACPI_STATE_D1
Definition: actypes.h:626
#define IRP_MN_CANCEL_STOP_DEVICE
#define STATUS_SUCCESS
Definition: shellext.h:65
ACPI_RESOURCE_ADDRESS_COMMON ACPI_ADDRESS32_ATTRIBUTE Address
Definition: acrestyp.h:402
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
UINT8 InterruptCount
Definition: acrestyp.h:184
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:3107
#define CmResourceTypeMemory
Definition: hwresource.cpp:125
struct _CM_PARTIAL_RESOURCE_DESCRIPTOR::@385::@390 Memory
#define ACPI_RESOURCE_TYPE_FIXED_IO
Definition: acrestyp.h:719
ACPI_STATUS AcpiGetCurrentResources(ACPI_HANDLE DeviceHandle, ACPI_BUFFER *RetBuffer)
Definition: rsxface.c:225
static SERVICE_STATUS status
Definition: service.c:31
#define AE_OK
Definition: acexcep.h:97
#define ACPI_LEVEL_SENSITIVE
Definition: acrestyp.h:93
#define CM_RESOURCE_DMA_BUS_MASTER
Definition: cmtypes.h:135
#define ACPI_CACHABLE_MEMORY
Definition: acrestyp.h:61
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
INTERFACE_TYPE LegacyBusType
Definition: cmtypes.h:365
#define ACPI_STATE_D2
Definition: actypes.h:627
NTSTATUS Bus_PDO_QueryDeviceCaps(PPDO_DEVICE_DATA DeviceData, PIRP Irp)
Definition: buspdo.c:319
PCHAR DbgDeviceRelationString(DEVICE_RELATION_TYPE Type)
#define CmResourceTypeDma
Definition: hwresource.cpp:126
#define IRP_MN_QUERY_CAPABILITIES
UINT8 Channels[1]
Definition: acrestyp.h:195
#define PAGED_CODE()
#define NT_ASSERT
Definition: rtlfuncs.h:3312
Definition: ps.c:97