ReactOS  0.4.15-dev-2103-g9dff498
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 
22 NTSTATUS
23 Bus_PDO_PnP (
24  PDEVICE_OBJECT DeviceObject,
25  PIRP Irp,
26  PIO_STACK_LOCATION IrpStack,
27  PPDO_DEVICE_DATA DeviceData
28  )
29 {
30  NTSTATUS status;
31  POWER_STATE state;
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 
47  case IRP_MN_START_DEVICE:
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) &&
54  !ACPI_SUCCESS(acpi_bus_set_power(DeviceData->AcpiHandle, ACPI_STATE_D0)))
55  {
56  DPRINT1("Device %x failed to start!\n", DeviceData->AcpiHandle);
57  status = STATUS_UNSUCCESSFUL;
58  break;
59  }
60 
61  DeviceData->InterfaceName.Length = 0;
62  status = STATUS_SUCCESS;
63 
64  if (!device)
65  {
66  status = IoRegisterDeviceInterface(DeviceData->Common.Self,
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  {
74  status = IoRegisterDeviceInterface(DeviceData->Common.Self,
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  {
82  status = IoRegisterDeviceInterface(DeviceData->Common.Self,
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  {
90  status = IoRegisterDeviceInterface(DeviceData->Common.Self,
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;
101  PoSetPowerState(DeviceData->Common.Self, DevicePowerState, state);
102  DeviceData->Common.DevicePowerState = PowerDeviceD0;
103  SET_NEW_PNP_STATE(DeviceData->Common, Started);
104  status = STATUS_SUCCESS;
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) &&
117  !ACPI_SUCCESS(acpi_bus_set_power(DeviceData->AcpiHandle, ACPI_STATE_D3)))
118  {
119  DPRINT1("Device %x failed to stop!\n", DeviceData->AcpiHandle);
120  status = STATUS_UNSUCCESSFUL;
121  break;
122  }
123 
124  state.DeviceState = PowerDeviceD3;
125  PoSetPowerState(DeviceData->Common.Self, DevicePowerState, state);
126  DeviceData->Common.DevicePowerState = PowerDeviceD3;
127  SET_NEW_PNP_STATE(DeviceData->Common, Stopped);
128  status = STATUS_SUCCESS;
129  break;
130 
131 
132  case IRP_MN_QUERY_STOP_DEVICE:
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 
140  SET_NEW_PNP_STATE(DeviceData->Common, StopPending);
141  status = STATUS_SUCCESS;
142  break;
143 
144  case IRP_MN_CANCEL_STOP_DEVICE:
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  //
165  RESTORE_PREVIOUS_PNP_STATE(DeviceData->Common);
166  }
167  status = STATUS_SUCCESS;// We must not fail this IRP.
168  break;
169 
170  case IRP_MN_REMOVE_DEVICE:
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) &&
180  !ACPI_SUCCESS(acpi_bus_set_power(DeviceData->AcpiHandle, ACPI_STATE_D3)))
181  {
182  DPRINT1("Device %x failed to enter D3!\n", DeviceData->AcpiHandle);
183  state.DeviceState = PowerDeviceD3;
184  PoSetPowerState(DeviceData->Common.Self, DevicePowerState, state);
185  DeviceData->Common.DevicePowerState = PowerDeviceD3;
186  }
187 
188  SET_NEW_PNP_STATE(DeviceData->Common, Stopped);
189  status = STATUS_SUCCESS;
190  break;
191 
192  case IRP_MN_QUERY_REMOVE_DEVICE:
193  SET_NEW_PNP_STATE(DeviceData->Common, RemovalPending);
194  status = STATUS_SUCCESS;
195  break;
196 
197  case IRP_MN_CANCEL_REMOVE_DEVICE:
198  if (RemovalPending == DeviceData->Common.DevicePnPState)
199  {
200  RESTORE_PREVIOUS_PNP_STATE(DeviceData->Common);
201  }
202  status = STATUS_SUCCESS;
203  break;
204 
205  case IRP_MN_QUERY_CAPABILITIES:
206 
207  //
208  // Return the capabilities of a device, such as whether the device
209  // can be locked or ejected..etc
210  //
211 
212  status = Bus_PDO_QueryDeviceCaps(DeviceData, Irp);
213 
214  break;
215 
216  case IRP_MN_QUERY_ID:
217 
218  // Query the IDs of the device
219  status = Bus_PDO_QueryDeviceId(DeviceData, Irp);
220 
221  break;
222 
223  case IRP_MN_QUERY_DEVICE_RELATIONS:
224 
225  DPRINT("\tQueryDeviceRelation Type: %s\n",DbgDeviceRelationString(\
226  IrpStack->Parameters.QueryDeviceRelations.Type));
227 
228  status = Bus_PDO_QueryDeviceRelations(DeviceData, Irp);
229 
230  break;
231 
232  case IRP_MN_QUERY_DEVICE_TEXT:
233 
234  status = Bus_PDO_QueryDeviceText(DeviceData, Irp);
235 
236  break;
237 
238  case IRP_MN_QUERY_RESOURCES:
239 
240  status = Bus_PDO_QueryResources(DeviceData, Irp);
241 
242  break;
243 
244  case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
245 
246  status = Bus_PDO_QueryResourceRequirements(DeviceData, Irp);
247 
248  break;
249 
250  case IRP_MN_QUERY_BUS_INFORMATION:
251 
252  status = Bus_PDO_QueryBusInformation(DeviceData, Irp);
253 
254  break;
255 
256  case IRP_MN_QUERY_INTERFACE:
257 
258  status = Bus_PDO_QueryInterface(DeviceData, Irp);
259 
260  break;
261 
262 
263  case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
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;
313  IoCompleteRequest (Irp, IO_NO_INCREMENT);
314 
315  return status;
316 }
317 
318 NTSTATUS
319 Bus_PDO_QueryDeviceCaps(
320  PPDO_DEVICE_DATA DeviceData,
321  PIRP Irp )
322 {
323 
324  PIO_STACK_LOCATION stack;
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 
334  stack = IoGetCurrentIrpStackLocation (Irp);
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
433 Bus_PDO_QueryDeviceId(
434  PPDO_DEVICE_DATA DeviceData,
435  PIRP Irp )
436 {
437  PIO_STACK_LOCATION stack;
438  PWCHAR buffer, src;
439  WCHAR temp[256];
440  ULONG length, i;
441  NTSTATUS status = STATUS_SUCCESS;
442  struct acpi_device *Device;
443 
444  PAGED_CODE ();
445 
446  stack = IoGetCurrentIrpStackLocation (Irp);
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  {
460  length = wcslen(ProcessorIdString);
461  wcscpy(temp, ProcessorIdString);
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) {
487  status = STATUS_INSUFFICIENT_RESOURCES;
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) {
525  status = STATUS_INSUFFICIENT_RESOURCES;
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;
538  status = STATUS_NOT_SUPPORTED;
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  {
556  length = ProcessorHardwareIds.Length / sizeof(WCHAR);
557  src = ProcessorHardwareIds.Buffer;
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) {
592  status = STATUS_INSUFFICIENT_RESOURCES;
593  break;
594  }
595 
596  RtlCopyMemory (buffer, src, length * sizeof(WCHAR));
597  Irp->IoStatus.Information = (ULONG_PTR) buffer;
598  DPRINT("BusQueryHardwareIDs: %ls\n",buffer);
599  status = STATUS_SUCCESS;
600  break;
601 
602  case BusQueryCompatibleIDs:
603 
604  /* This is a REG_MULTI_SZ value */
605  length = 0;
606  status = STATUS_NOT_SUPPORTED;
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  {
663  status = STATUS_INSUFFICIENT_RESOURCES;
664  break;
665  }
666 
667  RtlCopyMemory (buffer, temp, length * sizeof(WCHAR));
668  Irp->IoStatus.Information = (ULONG_PTR) buffer;
669  DPRINT("BusQueryCompatibleIDs: %ls\n",buffer);
670  status = STATUS_SUCCESS;
671  }
672  break;
673 
674  default:
675  status = Irp->IoStatus.Status;
676  }
677  return status;
678 }
679 
680 NTSTATUS
681 Bus_PDO_QueryDeviceText(
682  PPDO_DEVICE_DATA DeviceData,
683  PIRP Irp )
684 {
685  PWCHAR Buffer, Temp;
686  PIO_STACK_LOCATION stack;
687  NTSTATUS status = Irp->IoStatus.Status;
688  PAGED_CODE ();
689 
690  stack = IoGetCurrentIrpStackLocation (Irp);
691 
692  switch (stack->Parameters.QueryDeviceText.DeviceTextType) {
693 
694  case DeviceTextDescription:
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) {
772  status = STATUS_INSUFFICIENT_RESOURCES;
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;
781  status = STATUS_SUCCESS;
782  }
783  break;
784 
785  default:
786  break;
787  }
788 
789  return status;
790 
791 }
792 
793 NTSTATUS
794 Bus_PDO_QueryResources(
795  PPDO_DEVICE_DATA DeviceData,
796  PIRP Irp )
797 {
798  ULONG NumberOfResources = 0;
799  PCM_RESOURCE_LIST ResourceList;
800  PCM_PARTIAL_RESOURCE_DESCRIPTOR ResourceDescriptor;
801  ACPI_STATUS AcpiStatus;
802  ACPI_BUFFER Buffer;
803  ACPI_RESOURCE* resource;
804  ULONG ResourceListSize;
805  ULONG i;
806  ULONGLONG BusNumber;
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)
847  return STATUS_INSUFFICIENT_RESOURCES;
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)
877  return STATUS_INSUFFICIENT_RESOURCES;
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  {
893  case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
894  {
895  ACPI_RESOURCE_EXTENDED_IRQ *irq_data = (ACPI_RESOURCE_EXTENDED_IRQ*) &resource->Data;
896  if (irq_data->ProducerConsumer == ACPI_PRODUCER)
897  break;
898  NumberOfResources += irq_data->InterruptCount;
899  break;
900  }
901  case ACPI_RESOURCE_TYPE_IRQ:
902  {
903  ACPI_RESOURCE_IRQ *irq_data = (ACPI_RESOURCE_IRQ*) &resource->Data;
904  NumberOfResources += irq_data->InterruptCount;
905  break;
906  }
907  case ACPI_RESOURCE_TYPE_DMA:
908  {
909  ACPI_RESOURCE_DMA *dma_data = (ACPI_RESOURCE_DMA*) &resource->Data;
910  NumberOfResources += dma_data->ChannelCount;
911  break;
912  }
913  case ACPI_RESOURCE_TYPE_ADDRESS16:
914  case ACPI_RESOURCE_TYPE_ADDRESS32:
915  case ACPI_RESOURCE_TYPE_ADDRESS64:
916  case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
917  {
918  ACPI_RESOURCE_ADDRESS *addr_res = (ACPI_RESOURCE_ADDRESS*) &resource->Data;
919  if (addr_res->ProducerConsumer == ACPI_PRODUCER)
920  break;
921  NumberOfResources++;
922  break;
923  }
924  case ACPI_RESOURCE_TYPE_MEMORY24:
925  case ACPI_RESOURCE_TYPE_MEMORY32:
926  case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
927  case ACPI_RESOURCE_TYPE_FIXED_IO:
928  case ACPI_RESOURCE_TYPE_IO:
929  {
930  NumberOfResources++;
931  break;
932  }
933  default:
934  {
935  DPRINT1("Unknown resource type: %d\n", resource->Type);
936  break;
937  }
938  }
939  resource = ACPI_NEXT_RESOURCE(resource);
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');
949  return STATUS_INSUFFICIENT_RESOURCES;
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  {
965  case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
966  {
967  ACPI_RESOURCE_EXTENDED_IRQ *irq_data = (ACPI_RESOURCE_EXTENDED_IRQ*) &resource->Data;
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 =
975  (irq_data->Shareable == ACPI_SHARED ? CmResourceShareShared : CmResourceShareDeviceExclusive);
976  ResourceDescriptor->Flags =
977  (irq_data->Triggering == ACPI_LEVEL_SENSITIVE ? CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE : CM_RESOURCE_INTERRUPT_LATCHED);
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  }
986  case ACPI_RESOURCE_TYPE_IRQ:
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 =
994  (irq_data->Shareable == ACPI_SHARED ? CmResourceShareShared : CmResourceShareDeviceExclusive);
995  ResourceDescriptor->Flags =
996  (irq_data->Triggering == ACPI_LEVEL_SENSITIVE ? CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE : CM_RESOURCE_INTERRUPT_LATCHED);
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  }
1005  case ACPI_RESOURCE_TYPE_DMA:
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  }
1048  case ACPI_RESOURCE_TYPE_FIXED_IO:
1049  {
1050  ACPI_RESOURCE_FIXED_IO *io_data = (ACPI_RESOURCE_FIXED_IO*) &resource->Data;
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  }
1060  case ACPI_RESOURCE_TYPE_ADDRESS16:
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  }
1104  case ACPI_RESOURCE_TYPE_ADDRESS32:
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  }
1148  case ACPI_RESOURCE_TYPE_ADDRESS64:
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  }
1193  case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
1194  {
1195  ACPI_RESOURCE_EXTENDED_ADDRESS64 *addr64_data = (ACPI_RESOURCE_EXTENDED_ADDRESS64*) &resource->Data;
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  }
1238  case ACPI_RESOURCE_TYPE_MEMORY24:
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  }
1254  case ACPI_RESOURCE_TYPE_MEMORY32:
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  }
1270  case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
1271  {
1272  ACPI_RESOURCE_FIXED_MEMORY32 *memfixed32_data = (ACPI_RESOURCE_FIXED_MEMORY32*) &resource->Data;
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  }
1291  resource = ACPI_NEXT_RESOURCE(resource);
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
1301 Bus_PDO_QueryResourceRequirements(
1302  PPDO_DEVICE_DATA DeviceData,
1303  PIRP Irp )
1304 {
1305  ULONG NumberOfResources = 0;
1306  ACPI_STATUS AcpiStatus;
1307  ACPI_BUFFER Buffer;
1308  ACPI_RESOURCE* resource;
1309  ULONG i, RequirementsListSize;
1310  PIO_RESOURCE_REQUIREMENTS_LIST RequirementsList;
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)
1351  return STATUS_INSUFFICIENT_RESOURCES;
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 */
1367  while (resource->Type != ACPI_RESOURCE_TYPE_END_TAG && resource->Type != ACPI_RESOURCE_TYPE_END_DEPENDENT)
1368  {
1369  if (resource->Type == ACPI_RESOURCE_TYPE_START_DEPENDENT)
1370  {
1371  if (SeenStartDependent)
1372  {
1373  break;
1374  }
1375  SeenStartDependent = TRUE;
1376  }
1377  switch (resource->Type)
1378  {
1379  case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
1380  {
1381  ACPI_RESOURCE_EXTENDED_IRQ *irq_data = (ACPI_RESOURCE_EXTENDED_IRQ*) &resource->Data;
1382  if (irq_data->ProducerConsumer == ACPI_PRODUCER)
1383  break;
1384  NumberOfResources += irq_data->InterruptCount;
1385  break;
1386  }
1387  case ACPI_RESOURCE_TYPE_IRQ:
1388  {
1389  ACPI_RESOURCE_IRQ *irq_data = (ACPI_RESOURCE_IRQ*) &resource->Data;
1390  NumberOfResources += irq_data->InterruptCount;
1391  break;
1392  }
1393  case ACPI_RESOURCE_TYPE_DMA:
1394  {
1395  ACPI_RESOURCE_DMA *dma_data = (ACPI_RESOURCE_DMA*) &resource->Data;
1396  NumberOfResources += dma_data->ChannelCount;
1397  break;
1398  }
1399  case ACPI_RESOURCE_TYPE_ADDRESS16:
1400  case ACPI_RESOURCE_TYPE_ADDRESS32:
1401  case ACPI_RESOURCE_TYPE_ADDRESS64:
1402  case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
1403  {
1404  ACPI_RESOURCE_ADDRESS *res_addr = (ACPI_RESOURCE_ADDRESS*) &resource->Data;
1405  if (res_addr->ProducerConsumer == ACPI_PRODUCER)
1406  break;
1407  NumberOfResources++;
1408  break;
1409  }
1410  case ACPI_RESOURCE_TYPE_MEMORY24:
1411  case ACPI_RESOURCE_TYPE_MEMORY32:
1412  case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
1413  case ACPI_RESOURCE_TYPE_FIXED_IO:
1414  case ACPI_RESOURCE_TYPE_IO:
1415  {
1416  NumberOfResources++;
1417  break;
1418  }
1419  default:
1420  {
1421  break;
1422  }
1423  }
1424  resource = ACPI_NEXT_RESOURCE(resource);
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');
1433  return STATUS_INSUFFICIENT_RESOURCES;
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;
1448  while (resource->Type != ACPI_RESOURCE_TYPE_END_TAG && resource->Type != ACPI_RESOURCE_TYPE_END_DEPENDENT)
1449  {
1450  if (resource->Type == ACPI_RESOURCE_TYPE_START_DEPENDENT)
1451  {
1452  if (SeenStartDependent)
1453  {
1454  break;
1455  }
1456  SeenStartDependent = TRUE;
1457  }
1458  switch (resource->Type)
1459  {
1460  case ACPI_RESOURCE_TYPE_EXTENDED_IRQ:
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;
1469  RequirementDescriptor->ShareDisposition = (irq_data->Shareable == ACPI_SHARED ? CmResourceShareShared : CmResourceShareDeviceExclusive);
1470  RequirementDescriptor->Flags =(irq_data->Triggering == ACPI_LEVEL_SENSITIVE ? CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE : CM_RESOURCE_INTERRUPT_LATCHED);
1471  RequirementDescriptor->u.Interrupt.MinimumVector =
1472  RequirementDescriptor->u.Interrupt.MaximumVector = irq_data->Interrupts[i];
1473 
1474  RequirementDescriptor++;
1475  }
1476  break;
1477  }
1478  case ACPI_RESOURCE_TYPE_IRQ:
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;
1485  RequirementDescriptor->ShareDisposition = (irq_data->Shareable == ACPI_SHARED ? CmResourceShareShared : CmResourceShareDeviceExclusive);
1486  RequirementDescriptor->Flags =(irq_data->Triggering == ACPI_LEVEL_SENSITIVE ? CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE : CM_RESOURCE_INTERRUPT_LATCHED);
1487  RequirementDescriptor->u.Interrupt.MinimumVector =
1488  RequirementDescriptor->u.Interrupt.MaximumVector = irq_data->Interrupts[i];
1489 
1490  RequirementDescriptor++;
1491  }
1492  break;
1493  }
1494  case ACPI_RESOURCE_TYPE_DMA:
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  }
1543  case ACPI_RESOURCE_TYPE_FIXED_IO:
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  }
1558  case ACPI_RESOURCE_TYPE_ADDRESS16:
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  }
1606  case ACPI_RESOURCE_TYPE_ADDRESS32:
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  }
1654  case ACPI_RESOURCE_TYPE_ADDRESS64:
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  }
1703  case ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64:
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  }
1752  case ACPI_RESOURCE_TYPE_MEMORY24:
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  }
1770  case ACPI_RESOURCE_TYPE_MEMORY32:
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  }
1788  case ACPI_RESOURCE_TYPE_FIXED_MEMORY32:
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  }
1811  resource = ACPI_NEXT_RESOURCE(resource);
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
1822 Bus_PDO_QueryDeviceRelations(
1823  PPDO_DEVICE_DATA DeviceData,
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 
1858  PIO_STACK_LOCATION stack;
1859  PDEVICE_RELATIONS deviceRelations;
1860  NTSTATUS status;
1861 
1862  PAGED_CODE ();
1863 
1864  stack = IoGetCurrentIrpStackLocation (Irp);
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) {
1883  status = STATUS_INSUFFICIENT_RESOURCES;
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 
1898  status = STATUS_SUCCESS;
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
1913 Bus_PDO_QueryBusInformation(
1914  PPDO_DEVICE_DATA DeviceData,
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) {
1945  return STATUS_INSUFFICIENT_RESOURCES;
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
1961 Bus_GetDeviceCapabilities(
1962  PDEVICE_OBJECT DeviceObject,
1963  PDEVICE_CAPABILITIES DeviceCapabilities
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  //
1978  RtlZeroMemory( DeviceCapabilities, sizeof(DEVICE_CAPABILITIES) );
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  //
1994  pnpIrp = IoBuildSynchronousFsdRequest(
1995  IRP_MJ_PNP,
1996  targetObject,
1997  NULL,
1998  0,
1999  NULL,
2000  &pnpEvent,
2001  &ioStatus
2002  );
2003  if (pnpIrp == NULL) {
2004 
2005  status = STATUS_INSUFFICIENT_RESOURCES;
2006  goto GetDeviceCapabilitiesExit;
2007 
2008  }
2009 
2010  //
2011  // Pnp Irps all begin life as STATUS_NOT_SUPPORTED;
2012  //
2013  pnpIrp->IoStatus.Status = STATUS_NOT_SUPPORTED;
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;
2025  irpStack->MinorFunction = IRP_MN_QUERY_CAPABILITIES;
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 
2042  KeWaitForSingleObject(
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 */
acpi_resource_memory32::WriteProtect
UINT8 WriteProtect
Definition: acrestyp.h:285
CM_RESOURCE_DMA_16
#define CM_RESOURCE_DMA_16
Definition: cmtypes.h:132
IO_RESOURCE_REQUIREMENTS_LIST
struct _IO_RESOURCE_REQUIREMENTS_LIST IO_RESOURCE_REQUIREMENTS_LIST
_IO_RESOURCE_DESCRIPTOR::Flags
USHORT Flags
Definition: Bus_PDO_QueryResourceRequirements.c:25
IRP_MN_CANCEL_REMOVE_DEVICE
#define IRP_MN_CANCEL_REMOVE_DEVICE
ACPI_WRITE_COMBINING_MEMORY
#define ACPI_WRITE_COMBINING_MEMORY
Definition: acrestyp.h:62
acpi_resource_extended_irq::InterruptCount
UINT8 InterruptCount
Definition: acrestyp.h:431
acpi_resource_extended_irq::ProducerConsumer
UINT8 ProducerConsumer
Definition: acrestyp.h:426
acpi_address32_attribute::Maximum
UINT32 Maximum
Definition: acrestyp.h:369
STATUS_NOT_SUPPORTED
return STATUS_NOT_SUPPORTED
Definition: fxdriverapi.cpp:376
_IO_RESOURCE_DESCRIPTOR::Option
UCHAR Option
Definition: Bus_PDO_QueryResourceRequirements.c:21
CM_RESOURCE_MEMORY_PREFETCHABLE
#define CM_RESOURCE_MEMORY_PREFETCHABLE
Definition: cmtypes.h:123
IRP_MN_QUERY_RESOURCES
#define IRP_MN_QUERY_RESOURCES
acpi_buffer
Definition: actypes.h:1042
IRP_MN_REMOVE_DEVICE
#define IRP_MN_REMOVE_DEVICE
STATUS_INSUFFICIENT_RESOURCES
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
IRP_MN_QUERY_ID
#define IRP_MN_QUERY_ID
acpi_resource_fixed_memory32::Address
UINT32 Address
Definition: acrestyp.h:296
ACPI_SUCCESS
#define ACPI_SUCCESS(a)
Definition: acexcep.h:94
ACPI_PRODUCER
#define ACPI_PRODUCER
Definition: acrestyp.h:149
acpi_resource_irq
Definition: acrestyp.h:177
ACPI_RESOURCE_TYPE_START_DEPENDENT
#define ACPI_RESOURCE_TYPE_START_DEPENDENT
Definition: acrestyp.h:716
acpi_resource_address16
Definition: acrestyp.h:391
acpi_bus_get_device
int acpi_bus_get_device(ACPI_HANDLE handle, struct acpi_device **device)
Definition: bus.c:108
IO_RESOURCE_PREFERRED
#define IO_RESOURCE_PREFERRED
Definition: Bus_PDO_QueryResourceRequirements.c:16
Bus_PDO_QueryResources
NTSTATUS Bus_PDO_QueryResources(PPDO_DEVICE_DATA DeviceData, PIRP Irp)
Definition: buspdo.c:794
IoBuildSynchronousFsdRequest
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
acpi_address64_attribute::Minimum
UINT64 Minimum
Definition: acrestyp.h:378
Buffer
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
ACPI_TYPE_A
#define ACPI_TYPE_A
Definition: acrestyp.h:116
_CM_PARTIAL_RESOURCE_DESCRIPTOR::Memory
struct _CM_PARTIAL_RESOURCE_DESCRIPTOR::@375::@380 Memory
acpi_resource_extended_irq::Triggering
UINT8 Triggering
Definition: acrestyp.h:427
TRUE
#define TRUE
Definition: types.h:120
ACPI_RESOURCE_TYPE_END_DEPENDENT
#define ACPI_RESOURCE_TYPE_END_DEPENDENT
Definition: acrestyp.h:717
wcsstr
_CONST_RETURN wchar_t *__cdecl wcsstr(_In_z_ const wchar_t *_Str, _In_z_ const wchar_t *_SubStr)
acpi_evaluate_integer
ACPI_STATUS acpi_evaluate_integer(ACPI_HANDLE handle, ACPI_STRING pathname, ACPI_OBJECT_LIST *arguments, unsigned long long *data)
Definition: utils.c:242
IRP_MN_FILTER_RESOURCE_REQUIREMENTS
#define IRP_MN_FILTER_RESOURCE_REQUIREMENTS
strstr
char * strstr(char *String1, char *String2)
Definition: utclib.c:653
ACPI_TRANSFER_8_16
#define ACPI_TRANSFER_8_16
Definition: acrestyp.h:124
ACPI_BUS_MASTER
#define ACPI_BUS_MASTER
Definition: acrestyp.h:121
IRP_MN_QUERY_RESOURCE_REQUIREMENTS
#define IRP_MN_QUERY_RESOURCE_REQUIREMENTS
_DEVICE_RELATIONS::Objects
PDEVICE_OBJECT Objects[1]
Definition: iotypes.h:2160
_IO_RESOURCE_DESCRIPTOR::BusNumber
struct _IO_RESOURCE_DESCRIPTOR::@1569::@1576 BusNumber
IRP_MJ_PNP
#define IRP_MJ_PNP
Definition: cdrw_usr.h:52
_POWER_STATE
Definition: ntpoapi.h:56
ACPI_RESOURCE_TYPE_IRQ
#define ACPI_RESOURCE_TYPE_IRQ
Definition: acrestyp.h:714
acpi_resource_extended_address64
Definition: acrestyp.h:415
NTSTATUS
LONG NTSTATUS
Definition: precomp.h:26
_UNICODE_STRING::Length
USHORT Length
Definition: env_spec_w32.h:369
acpi_resource_extended_irq::Interrupts
UINT32 Interrupts[1]
Definition: acrestyp.h:433
Bus_PDO_PnP
NTSTATUS Bus_PDO_PnP(PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpStack, PPDO_DEVICE_DATA DeviceData)
Definition: buspdo.c:23
_DEVICE_RELATIONS::Count
ULONG Count
Definition: iotypes.h:2159
_IO_STATUS_BLOCK::Status
ULONG Status
Definition: env_spec_w32.h:871
_CM_PARTIAL_RESOURCE_DESCRIPTOR::BusNumber
struct _CM_PARTIAL_RESOURCE_DESCRIPTOR::@375::@383 BusNumber
ACPI_TYPE_F
#define ACPI_TYPE_F
Definition: acrestyp.h:118
_IO_STACK_LOCATION
Definition: iotypes.h:3106
ACPI_RESOURCE_TYPE_END_TAG
#define ACPI_RESOURCE_TYPE_END_TAG
Definition: acrestyp.h:721
_PNP_BUS_INFORMATION::BusTypeGuid
GUID BusTypeGuid
Definition: cmtypes.h:364
buffer
GLuint buffer
Definition: glext.h:5915
ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
#define ACPI_RESOURCE_TYPE_EXTENDED_ADDRESS64
Definition: acrestyp.h:728
DEVICE_CAPABILITIES
DEVICE_CAPABILITIES
Definition: iotypes.h:965
acpi_resource_io::AddressLength
UINT8 AddressLength
Definition: acrestyp.h:218
acpi_bus_power_manageable
BOOLEAN acpi_bus_power_manageable(ACPI_HANDLE handle)
Definition: bus.c:351
stack
static stack_node_t * stack
Definition: rpn_ieee.c:37
acpi_address32_attribute::AddressLength
UINT32 AddressLength
Definition: acrestyp.h:371
ACPI_READ_ONLY_MEMORY
#define ACPI_READ_ONLY_MEMORY
Definition: acrestyp.h:57
_IRP::IoStatus
IO_STATUS_BLOCK IoStatus
Definition: Bus_PDO_QueryResourceRequirements.c:94
PWCHAR
uint16_t * PWCHAR
Definition: typedefs.h:56
swprintf
#define swprintf
Definition: precomp.h:40
CM_RESOURCE_DMA_TYPE_F
#define CM_RESOURCE_DMA_TYPE_F
Definition: cmtypes.h:138
acpi_resource_memory32::Maximum
UINT32 Maximum
Definition: acrestyp.h:287
ACPI_STATUS
UINT32 ACPI_STATUS
Definition: actypes.h:460
resource
int resource
Definition: rdpsnd_sgi.c:44
acpi_resource_dma::Type
UINT8 Type
Definition: acrestyp.h:191
acpi_resource_memory24
Definition: acrestyp.h:273
Bus_PDO_QueryResourceRequirements
NTSTATUS Bus_PDO_QueryResourceRequirements(PPDO_DEVICE_DATA DeviceData, PIRP Irp)
Definition: buspdo.c:1301
KeWaitForSingleObject
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
_IO_RESOURCE_DESCRIPTOR::Memory
struct _IO_RESOURCE_DESCRIPTOR::@1569::@1571 Memory
CM_RESOURCE_DMA_TYPE_A
#define CM_RESOURCE_DMA_TYPE_A
Definition: cmtypes.h:136
ResourceList
_Must_inspect_result_ _In_ WDFIORESREQLIST _In_opt_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFIORESLIST * ResourceList
Definition: wdfresource.h:304
CM_RESOURCE_MEMORY_READ_WRITE
#define CM_RESOURCE_MEMORY_READ_WRITE
Definition: cmtypes.h:120
CmResourceTypePort
#define CmResourceTypePort
Definition: hwresource.cpp:123
_CM_PARTIAL_RESOURCE_DESCRIPTOR::Dma
struct _CM_PARTIAL_RESOURCE_DESCRIPTOR::@375::@381 Dma
ACPI_BUS_NUMBER_RANGE
#define ACPI_BUS_NUMBER_RANGE
Definition: acrestyp.h:139
acpi_resource_dma::Transfer
UINT8 Transfer
Definition: acrestyp.h:193
_CM_PARTIAL_RESOURCE_DESCRIPTOR::ShareDisposition
UCHAR ShareDisposition
Definition: hwresource.cpp:29
device
FxDevice * device
Definition: fxchildlistapi.cpp:664
_CM_PARTIAL_RESOURCE_DESCRIPTOR::Interrupt
struct _CM_PARTIAL_RESOURCE_DESCRIPTOR::@375::@378 Interrupt
ACPI_RESOURCE_TYPE_IO
#define ACPI_RESOURCE_TYPE_IO
Definition: acrestyp.h:718
DeviceObject
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_PNP_BUS_INFORMATION
Definition: cmtypes.h:363
ACPI_PROCESSOR_HID
#define ACPI_PROCESSOR_HID
Definition: acpi_drivers.h:221
AE_BUFFER_OVERFLOW
#define AE_BUFFER_OVERFLOW
Definition: acexcep.h:119
acpi_resource
Definition: acrestyp.h:783
CM_RESOURCE_MEMORY_24
#define CM_RESOURCE_MEMORY_24
Definition: cmtypes.h:125
FALSE
#define FALSE
Definition: types.h:117
UNICODE_NULL
#define UNICODE_NULL
Irp
_In_ PIRP Irp
Definition: csq.h:116
IRP_MN_QUERY_REMOVE_DEVICE
#define IRP_MN_QUERY_REMOVE_DEVICE
device
Definition: devices.h:37
_CM_PARTIAL_RESOURCE_DESCRIPTOR::u
union _CM_PARTIAL_RESOURCE_DESCRIPTOR::@375 u
ACPI_THERMAL_HID
#define ACPI_THERMAL_HID
Definition: acpi_drivers.h:266
ACPI_SHARED
#define ACPI_SHARED
Definition: acrestyp.h:105
acpi_resource_irq::Triggering
UINT8 Triggering
Definition: acrestyp.h:180
_UNICODE_STRING::Buffer
PWSTR Buffer
Definition: env_spec_w32.h:371
ASSERTMSG
#define ASSERTMSG(msg, exp)
Definition: nt_native.h:431
acpi_resource_fixed_memory32
Definition: acrestyp.h:293
_IO_RESOURCE_DESCRIPTOR
Definition: Bus_PDO_QueryResourceRequirements.c:20
length
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
acpi_resource_fixed_io::Address
UINT16 Address
Definition: acrestyp.h:226
CM_RESOURCE_MEMORY_READ_ONLY
#define CM_RESOURCE_MEMORY_READ_ONLY
Definition: cmtypes.h:121
PDEVICE_RELATIONS
struct _DEVICE_RELATIONS * PDEVICE_RELATIONS
BOOLEAN
unsigned char BOOLEAN
Definition: ProcessorBind.h:185
CM_RESOURCE_DMA_8_AND_16
#define CM_RESOURCE_DMA_8_AND_16
Definition: cmtypes.h:134
acpi_resource_dma::BusMaster
UINT8 BusMaster
Definition: acrestyp.h:192
CM_RESOURCE_PORT_16_BIT_DECODE
#define CM_RESOURCE_PORT_16_BIT_DECODE
Definition: cmtypes.h:112
IoCompleteRequest
#define IoCompleteRequest
Definition: irp.c:1240
DeviceCapabilities
#define DeviceCapabilities
Definition: wingdi.h:4448
Buffer
Definition: bufpool.h:45
acpi_resource_extended_irq
Definition: acrestyp.h:424
ACPI_PREFETCHABLE_MEMORY
#define ACPI_PREFETCHABLE_MEMORY
Definition: acrestyp.h:63
IoSetDeviceInterfaceState
NTSTATUS NTAPI IoSetDeviceInterfaceState(IN PUNICODE_STRING SymbolicLinkName, IN BOOLEAN Enable)
Definition: deviface.c:1311
_DEVICE_OBJECT
Definition: env_spec_w32.h:413
CM_RESOURCE_PORT_10_BIT_DECODE
#define CM_RESOURCE_PORT_10_BIT_DECODE
Definition: cmtypes.h:110
_IO_RESOURCE_REQUIREMENTS_LIST
Definition: Bus_PDO_QueryResourceRequirements.c:78
IoGetAttachedDeviceReference
PDEVICE_OBJECT NTAPI IoGetAttachedDeviceReference(PDEVICE_OBJECT DeviceObject)
Definition: device.c:1406
BusNumber
_In_opt_ PUNICODE_STRING _In_ PDRIVER_OBJECT _In_ PDEVICE_OBJECT _In_ INTERFACE_TYPE _In_ ULONG BusNumber
Definition: halfuncs.h:156
Stopped
Definition: fbtusb.h:81
ACPI_D_STATE_COUNT
#define ACPI_D_STATE_COUNT
Definition: actypes.h:630
ACPI_TRANSFER_8
#define ACPI_TRANSFER_8
Definition: acrestyp.h:123
_IO_STACK_LOCATION::MajorFunction
UCHAR MajorFunction
Definition: iotypes.h:3107
acpi_resource_io::Alignment
UINT8 Alignment
Definition: acrestyp.h:217
IRP_MN_QUERY_STOP_DEVICE
#define IRP_MN_QUERY_STOP_DEVICE
stack
Definition: _stack.h:47
_CM_PARTIAL_RESOURCE_DESCRIPTOR::Flags
USHORT Flags
Definition: hwresource.cpp:30
ProcessorIdString
LPWSTR ProcessorIdString
Definition: main.c:25
ACPI_RESOURCE_TYPE_ADDRESS32
#define ACPI_RESOURCE_TYPE_ADDRESS32
Definition: acrestyp.h:726
IRP_MN_STOP_DEVICE
#define IRP_MN_STOP_DEVICE
ASSERT
#define ASSERT(a)
Definition: mode.c:45
acpi_resource_irq::Interrupts
UINT8 Interrupts[1]
Definition: acrestyp.h:185
if
if(!(yy_init))
Definition: macro.lex.yy.c:714
_DEVICE_RELATIONS
Definition: iotypes.h:2158
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
NT_SUCCESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
STATUS_PENDING
#define STATUS_PENDING
Definition: ntstatus.h:82
acpi_resource_fixed_memory32::AddressLength
UINT32 AddressLength
Definition: acrestyp.h:297
acpi_resource_address64
Definition: acrestyp.h:407
RESTORE_PREVIOUS_PNP_STATE
#define RESTORE_PREVIOUS_PNP_STATE(_Data_)
Definition: fbtusb.h:115
Bus_PDO_QueryDeviceId
NTSTATUS Bus_PDO_QueryDeviceId(PPDO_DEVICE_DATA DeviceData, PIRP Irp)
Definition: buspdo.c:433
CM_RESOURCE_PORT_POSITIVE_DECODE
#define CM_RESOURCE_PORT_POSITIVE_DECODE
Definition: cmtypes.h:113
ULONGLONG
uint64_t ULONGLONG
Definition: typedefs.h:67
Bus_PDO_QueryDeviceRelations
NTSTATUS Bus_PDO_QueryDeviceRelations(PPDO_DEVICE_DATA DeviceData, PIRP Irp)
Definition: buspdo.c:1822
IRP_MN_START_DEVICE
#define IRP_MN_START_DEVICE
ObDereferenceObject
#define ObDereferenceObject
Definition: obfuncs.h:203
_CM_PARTIAL_RESOURCE_DESCRIPTOR::Port
struct _CM_PARTIAL_RESOURCE_DESCRIPTOR::@375::@377 Port
acpi_resource_io::Minimum
UINT16 Minimum
Definition: acrestyp.h:219
AcpiGetPossibleResources
ACPI_STATUS AcpiGetPossibleResources(ACPI_HANDLE DeviceHandle, ACPI_BUFFER *RetBuffer)
Definition: rsxface.c:273
acpi_address16_attribute::AddressLength
UINT16 AddressLength
Definition: acrestyp.h:361
device::removable
bool removable
Definition: btrfs_drv.h:537
for
#define for
Definition: utility.h:88
Bus_PDO_QueryDeviceText
NTSTATUS Bus_PDO_QueryDeviceText(PPDO_DEVICE_DATA DeviceData, PIRP Irp)
Definition: buspdo.c:681
ACPI_BUTTON_HID_LID
#define ACPI_BUTTON_HID_LID
Definition: acpi_drivers.h:106
IRP_MN_QUERY_DEVICE_TEXT
#define IRP_MN_QUERY_DEVICE_TEXT
acpi_resource_address
Definition: acrestyp.h:385
IRP_MN_QUERY_INTERFACE
#define IRP_MN_QUERY_INTERFACE
CM_RESOURCE_MEMORY_COMBINEDWRITE
#define CM_RESOURCE_MEMORY_COMBINEDWRITE
Definition: cmtypes.h:124
acpi_resource_fixed_io
Definition: acrestyp.h:224
_CM_PARTIAL_RESOURCE_DESCRIPTOR::Type
UCHAR Type
Definition: hwresource.cpp:28
_IO_RESOURCE_DESCRIPTOR::u
union _IO_RESOURCE_DESCRIPTOR::@1569 u
IO_RESOURCE_ALTERNATIVE
#define IO_RESOURCE_ALTERNATIVE
Definition: Bus_PDO_QueryResourceRequirements.c:18
ACPI_RESOURCE_TYPE_ADDRESS64
#define ACPI_RESOURCE_TYPE_ADDRESS64
Definition: acrestyp.h:727
acpi_resource_io
Definition: acrestyp.h:214
ACPI_IO_RANGE
#define ACPI_IO_RANGE
Definition: acrestyp.h:138
ACPI_STATE_D3
#define ACPI_STATE_D3
Definition: actypes.h:628
STATUS_UNSUCCESSFUL
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
CM_RESOURCE_DMA_TYPE_B
#define CM_RESOURCE_DMA_TYPE_B
Definition: cmtypes.h:137
ExAllocatePoolWithTag
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
_PDO_DEVICE_DATA
Definition: acpisys.h:36
_IO_RESOURCE_DESCRIPTOR::Type
UCHAR Type
Definition: Bus_PDO_QueryResourceRequirements.c:22
IRP_MN_QUERY_BUS_INFORMATION
#define IRP_MN_QUERY_BUS_INFORMATION
Bus_PDO_QueryBusInformation
NTSTATUS Bus_PDO_QueryBusInformation(PPDO_DEVICE_DATA DeviceData, PIRP Irp)
Definition: buspdo.c:1913
ACPI_TRANSFER_16
#define ACPI_TRANSFER_16
Definition: acrestyp.h:125
acpi_resource_memory32::Minimum
UINT32 Minimum
Definition: acrestyp.h:286
_PNP_BUS_INFORMATION::BusNumber
ULONG BusNumber
Definition: cmtypes.h:366
wcscpy
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
ProcessorNameString
LPWSTR ProcessorNameString
Definition: main.c:26
L
static const WCHAR L[]
Definition: oid.c:1250
CM_RESOURCE_DMA_8
#define CM_RESOURCE_DMA_8
Definition: cmtypes.h:131
acpi_address32_attribute::Minimum
UINT32 Minimum
Definition: acrestyp.h:368
acpi_resource_memory24::Maximum
UINT16 Maximum
Definition: acrestyp.h:277
acpi_resource_memory32
Definition: acrestyp.h:283
ACPI_RESOURCE_TYPE_EXTENDED_IRQ
#define ACPI_RESOURCE_TYPE_EXTENDED_IRQ
Definition: acrestyp.h:729
state
static int state
Definition: maze.c:121
ACPI_RESOURCE_TYPE_FIXED_MEMORY32
#define ACPI_RESOURCE_TYPE_FIXED_MEMORY32
Definition: acrestyp.h:724
acpi_address64_attribute::Maximum
UINT64 Maximum
Definition: acrestyp.h:379
acpi_resource_extended_irq::Shareable
UINT8 Shareable
Definition: acrestyp.h:429
src
GLenum src
Definition: glext.h:6340
Device
_Must_inspect_result_ _In_ WDFDEVICE Device
Definition: wdfchildlist.h:474
IoGetNextIrpStackLocation
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetNextIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2691
_IO_RESOURCE_DESCRIPTOR::Interrupt
struct _IO_RESOURCE_DESCRIPTOR::@1569::@1572 Interrupt
CM_RESOURCE_LIST
struct _CM_RESOURCE_LIST CM_RESOURCE_LIST
ACPI_RESOURCE_TYPE_MEMORY32
#define ACPI_RESOURCE_TYPE_MEMORY32
Definition: acrestyp.h:723
acpi_resource_dma
Definition: acrestyp.h:189
PDEVICE_CAPABILITIES
* PDEVICE_CAPABILITIES
Definition: iotypes.h:965
CM_RESOURCE_MEMORY_CACHEABLE
#define CM_RESOURCE_MEMORY_CACHEABLE
Definition: cmtypes.h:126
_IRP
Definition: Bus_PDO_QueryResourceRequirements.c:92
acpi_resource_dma::ChannelCount
UINT8 ChannelCount
Definition: acrestyp.h:194
acpi_resource_extended_address64::Address
ACPI_ADDRESS64_ATTRIBUTE Address
Definition: acrestyp.h:419
acpi_resource_memory24::Minimum
UINT16 Minimum
Definition: acrestyp.h:276
acpi_address16_attribute::Minimum
UINT16 Minimum
Definition: acrestyp.h:358
_IO_STATUS_BLOCK
Definition: env_spec_w32.h:870
IoGetCurrentIrpStackLocation
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2789
acpi_bus_set_power
int acpi_bus_set_power(ACPI_HANDLE handle, int state)
Definition: bus.c:249
acpi_address16_attribute::Maximum
UINT16 Maximum
Definition: acrestyp.h:359
IoRegisterDeviceInterface
NTSTATUS NTAPI IoRegisterDeviceInterface(IN PDEVICE_OBJECT PhysicalDeviceObject, IN CONST GUID *InterfaceClassGuid, IN PUNICODE_STRING ReferenceString OPTIONAL, OUT PUNICODE_STRING SymbolicLinkName)
Definition: deviface.c:955
KeInitializeEvent
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
ACPI_NEXT_RESOURCE
#define ACPI_NEXT_RESOURCE(Res)
Definition: acrestyp.h:802
i
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_address64::Address
ACPI_RESOURCE_ADDRESS_COMMON ACPI_ADDRESS64_ATTRIBUTE Address
Definition: acrestyp.h:410
CM_RESOURCE_PORT_IO
#define CM_RESOURCE_PORT_IO
Definition: cmtypes.h:109
temp
static calc_node_t temp
Definition: rpn_ieee.c:38
KAFFINITY
ULONG_PTR KAFFINITY
Definition: compat.h:85
acpi_resource_io::IoDecode
UINT8 IoDecode
Definition: acrestyp.h:216
ACPI_RESOURCE_TYPE_DMA
#define ACPI_RESOURCE_TYPE_DMA
Definition: acrestyp.h:715
acpi_resource_address32
Definition: acrestyp.h:399
Bus_GetDeviceCapabilities
NTSTATUS Bus_GetDeviceCapabilities(PDEVICE_OBJECT DeviceObject, PDEVICE_CAPABILITIES DeviceCapabilities)
Definition: buspdo.c:1961
ProcessorHardwareIds
UNICODE_STRING ProcessorHardwareIds
Definition: main.c:24
_IO_RESOURCE_DESCRIPTOR::Port
struct _IO_RESOURCE_DESCRIPTOR::@1569::@1570 Port
_IO_STACK_LOCATION::MinorFunction
UCHAR MinorFunction
Definition: iotypes.h:3108
NULL
#define NULL
Definition: types.h:112
IoCallDriver
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
ACPI_TYPE_B
#define ACPI_TYPE_B
Definition: acrestyp.h:117
IRP_MN_QUERY_DEVICE_RELATIONS
#define IRP_MN_QUERY_DEVICE_RELATIONS
CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE
#define CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE
Definition: cmtypes.h:143
CmResourceTypeInterrupt
#define CmResourceTypeInterrupt
Definition: hwresource.cpp:124
_KEVENT
Definition: ketypes.h:799
acpi_resource_memory24::WriteProtect
UINT8 WriteProtect
Definition: acrestyp.h:275
acpi_resource_fixed_memory32::WriteProtect
UINT8 WriteProtect
Definition: acrestyp.h:295
RequirementsList
_In_ WDFIORESREQLIST RequirementsList
Definition: wdfresource.h:65
DPRINT1
#define DPRINT1
Definition: precomp.h:8
acpi_resource_io::Maximum
UINT16 Maximum
Definition: acrestyp.h:220
_IO_RESOURCE_DESCRIPTOR::Dma
struct _IO_RESOURCE_DESCRIPTOR::@1569::@1573 Dma
acpi_device
Definition: acpi_bus.h:268
ACPI_RESOURCE_TYPE_ADDRESS16
#define ACPI_RESOURCE_TYPE_ADDRESS16
Definition: acrestyp.h:725
ACPI_RESOURCE_TYPE_MEMORY24
#define ACPI_RESOURCE_TYPE_MEMORY24
Definition: acrestyp.h:722
acpi_resource_irq::Shareable
UINT8 Shareable
Definition: acrestyp.h:182
ACPI_DECODE_16
#define ACPI_DECODE_16
Definition: acrestyp.h:85
SET_NEW_PNP_STATE
#define SET_NEW_PNP_STATE(_Data_, _state_)
Definition: fbtusb.h:111
ACPI_POS_DECODE
#define ACPI_POS_DECODE
Definition: acrestyp.h:144
ACPI_STATE_D0
#define ACPI_STATE_D0
Definition: actypes.h:625
ObReferenceObject
#define ObReferenceObject
Definition: obfuncs.h:204
_CM_PARTIAL_RESOURCE_DESCRIPTOR
Definition: hwresource.cpp:27
CM_RESOURCE_INTERRUPT_LATCHED
#define CM_RESOURCE_INTERRUPT_LATCHED
Definition: cmtypes.h:144
ULONG
unsigned int ULONG
Definition: retypes.h:1
IO_NO_INCREMENT
#define IO_NO_INCREMENT
Definition: iotypes.h:598
strcmp
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
acpi_resource_memory32::AddressLength
UINT32 AddressLength
Definition: acrestyp.h:289
RtlZeroMemory
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:262
PoSetPowerState
POWER_STATE NTAPI PoSetPowerState(IN PDEVICE_OBJECT DeviceObject, IN POWER_STATE_TYPE Type, IN POWER_STATE State)
Definition: power.c:708
acpi_resource_fixed_io::AddressLength
UINT8 AddressLength
Definition: acrestyp.h:227
ULONG_PTR
#define ULONG_PTR
Definition: config.h:101
acpi_resource_address16::Address
ACPI_RESOURCE_ADDRESS_COMMON ACPI_ADDRESS16_ATTRIBUTE Address
Definition: acrestyp.h:394
RtlCopyMemory
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
Bus_PDO_QueryInterface
NTSTATUS Bus_PDO_QueryInterface(PPDO_DEVICE_DATA DeviceData, PIRP Irp)
Definition: interface.c:94
CmResourceTypeBusNumber
#define CmResourceTypeBusNumber
Definition: hwresource.cpp:128
ACPI_STATE_D1
#define ACPI_STATE_D1
Definition: actypes.h:626
IRP_MN_CANCEL_STOP_DEVICE
#define IRP_MN_CANCEL_STOP_DEVICE
STATUS_SUCCESS
#define STATUS_SUCCESS
Definition: shellext.h:65
acpi_resource_address32::Address
ACPI_RESOURCE_ADDRESS_COMMON ACPI_ADDRESS32_ATTRIBUTE Address
Definition: acrestyp.h:402
ExFreePoolWithTag
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
acpi_resource_irq::InterruptCount
UINT8 InterruptCount
Definition: acrestyp.h:184
DPRINT
#define DPRINT
Definition: sndvol32.h:71
_IO_STACK_LOCATION::Parameters
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:3124
CmResourceTypeMemory
#define CmResourceTypeMemory
Definition: hwresource.cpp:125
_IO_RESOURCE_DESCRIPTOR::ShareDisposition
UCHAR ShareDisposition
Definition: Bus_PDO_QueryResourceRequirements.c:23
_CM_RESOURCE_LIST
Definition: hwresource.cpp:163
ACPI_RESOURCE_TYPE_FIXED_IO
#define ACPI_RESOURCE_TYPE_FIXED_IO
Definition: acrestyp.h:719
AcpiGetCurrentResources
ACPI_STATUS AcpiGetCurrentResources(ACPI_HANDLE DeviceHandle, ACPI_BUFFER *RetBuffer)
Definition: rsxface.c:225
status
static SERVICE_STATUS status
Definition: service.c:31
acpi_address64_attribute::AddressLength
UINT64 AddressLength
Definition: acrestyp.h:381
AE_OK
#define AE_OK
Definition: acexcep.h:97
ACPI_LEVEL_SENSITIVE
#define ACPI_LEVEL_SENSITIVE
Definition: acrestyp.h:93
CM_RESOURCE_DMA_BUS_MASTER
#define CM_RESOURCE_DMA_BUS_MASTER
Definition: cmtypes.h:135
ACPI_CACHABLE_MEMORY
#define ACPI_CACHABLE_MEMORY
Definition: acrestyp.h:61
wcslen
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
_PNP_BUS_INFORMATION::LegacyBusType
INTERFACE_TYPE LegacyBusType
Definition: cmtypes.h:365
ACPI_STATE_D2
#define ACPI_STATE_D2
Definition: actypes.h:627
acpi_resource_memory24::AddressLength
UINT16 AddressLength
Definition: acrestyp.h:279
Bus_PDO_QueryDeviceCaps
NTSTATUS Bus_PDO_QueryDeviceCaps(PPDO_DEVICE_DATA DeviceData, PIRP Irp)
Definition: buspdo.c:319
DbgDeviceRelationString
PCHAR DbgDeviceRelationString(DEVICE_RELATION_TYPE Type)
CmResourceTypeDma
#define CmResourceTypeDma
Definition: hwresource.cpp:126
IRP_MN_QUERY_CAPABILITIES
#define IRP_MN_QUERY_CAPABILITIES
acpi_resource_dma::Channels
UINT8 Channels[1]
Definition: acrestyp.h:195
PAGED_CODE
#define PAGED_CODE()
Definition: Bus_PDO_QueryResourceRequirements.c:89
NT_ASSERT
#define NT_ASSERT
Definition: rtlfuncs.h:3312
status
Definition: ps.c:97