ReactOS  0.4.14-dev-114-gc8cbd56
pnp.c
Go to the documentation of this file.
1 #include "precomp.h"
2 
3 #define NDEBUG
4 #include <debug.h>
5 
8  struct acpi_device *Device,
9  PFDO_DEVICE_DATA FdoData
10  );
11 
12 #ifdef ALLOC_PRAGMA
13 #pragma alloc_text (PAGE, Bus_PnP)
14 #pragma alloc_text (PAGE, Bus_PlugInDevice)
15 #pragma alloc_text (PAGE, Bus_InitializePdo)
16 #pragma alloc_text (PAGE, Bus_DestroyPdo)
17 #pragma alloc_text (PAGE, Bus_FDO_PnP)
18 #pragma alloc_text (PAGE, Bus_StartFdo)
19 #pragma alloc_text (PAGE, Bus_SendIrpSynchronously)
20 #endif
21 
22 
24 NTAPI
27  PIRP Irp
28  )
29 {
30  PIO_STACK_LOCATION irpStack;
32  PCOMMON_DEVICE_DATA commonData;
33 
34  PAGED_CODE ();
35 
36  irpStack = IoGetCurrentIrpStackLocation (Irp);
37  ASSERT (IRP_MJ_PNP == irpStack->MajorFunction);
38 
40 
41 
42  if (commonData->IsFDO) {
43  DPRINT("FDO %s IRP:0x%p\n",
45  Irp);
46  //
47  // Request is for the bus FDO
48  //
51  Irp,
52  irpStack,
53  (PFDO_DEVICE_DATA) commonData);
54  } else {
55  DPRINT("PDO %s IRP: 0x%p\n",
57  Irp);
58  //
59  // Request is for the child PDO.
60  //
63  Irp,
64  irpStack,
65  (PPDO_DEVICE_DATA) commonData);
66  }
67 
68  return status;
69 }
70 
74  PIRP Irp,
75  PIO_STACK_LOCATION IrpStack,
77  )
78 {
80  ULONG length, prevcount, numPdosPresent;
82  PPDO_DEVICE_DATA pdoData;
83  PDEVICE_RELATIONS relations, oldRelations;
84 
85  PAGED_CODE ();
86 
87  switch (IrpStack->MinorFunction) {
88 
90 
92 
93 
94  //
95  // We must now complete the IRP, since we stopped it in the
96  // completion routine with MORE_PROCESSING_REQUIRED.
97  //
98 
99  Irp->IoStatus.Status = status;
101 
102  return status;
103 
105 
106  //
107  // The PnP manager is trying to stop the device
108  // for resource rebalancing.
109  //
111  Irp->IoStatus.Status = STATUS_SUCCESS;
112  break;
113 
115 
116  //
117  // The PnP Manager sends this IRP, at some point after an
118  // IRP_MN_QUERY_STOP_DEVICE, to inform the drivers for a
119  // device that the device will not be stopped for
120  // resource reconfiguration.
121  //
122  //
123  // First check to see whether you have received cancel-stop
124  // without first receiving a query-stop. This could happen if
125  // someone above us fails a query-stop and passes down the subsequent
126  // cancel-stop.
127  //
128 
129  if (StopPending == DeviceData->Common.DevicePnPState)
130  {
131  //
132  // We did receive a query-stop, so restore.
133  //
135  ASSERT(DeviceData->Common.DevicePnPState == Started);
136  }
137  Irp->IoStatus.Status = STATUS_SUCCESS; // We must not fail the IRP.
138  break;
139 
141 
142  DPRINT("\tQueryDeviceRelation Type: %s\n",
144  IrpStack->Parameters.QueryDeviceRelations.Type));
145 
146  if (BusRelations != IrpStack->Parameters.QueryDeviceRelations.Type) {
147  //
148  // We don't support any other Device Relations
149  //
150  break;
151  }
152 
153 
154  ExAcquireFastMutex (&DeviceData->Mutex);
155 
156  oldRelations = (PDEVICE_RELATIONS) Irp->IoStatus.Information;
157  if (oldRelations) {
158  prevcount = oldRelations->Count;
159  if (!DeviceData->NumPDOs) {
160  //
161  // There is a device relations struct already present and we have
162  // nothing to add to it, so just call IoSkip and IoCall
163  //
164  ExReleaseFastMutex (&DeviceData->Mutex);
165  break;
166  }
167  }
168  else {
169  prevcount = 0;
170  }
171 
172  //
173  // Calculate the number of PDOs actually present on the bus
174  //
175  numPdosPresent = 0;
176  for (entry = DeviceData->ListOfPDOs.Flink;
177  entry != &DeviceData->ListOfPDOs;
178  entry = entry->Flink) {
180  numPdosPresent++;
181  }
182 
183  //
184  // Need to allocate a new relations structure and add our
185  // PDOs to it.
186  //
187 
188  length = sizeof(DEVICE_RELATIONS) +
189  (((numPdosPresent + prevcount) - 1) * sizeof (PDEVICE_OBJECT));
190 
191  relations = ExAllocatePoolWithTag(PagedPool, length, 'IpcA');
192 
193  if (NULL == relations) {
194  //
195  // Fail the IRP
196  //
197  ExReleaseFastMutex (&DeviceData->Mutex);
198  Irp->IoStatus.Status = status = STATUS_INSUFFICIENT_RESOURCES;
200  return status;
201 
202  }
203 
204  //
205  // Copy in the device objects so far
206  //
207  if (prevcount) {
208  RtlCopyMemory (relations->Objects, oldRelations->Objects,
209  prevcount * sizeof (PDEVICE_OBJECT));
210  }
211 
212  relations->Count = prevcount + numPdosPresent;
213 
214  //
215  // For each PDO present on this bus add a pointer to the device relations
216  // buffer, being sure to take out a reference to that object.
217  // The Plug & Play system will dereference the object when it is done
218  // with it and free the device relations buffer.
219  //
220 
221  for (entry = DeviceData->ListOfPDOs.Flink;
222  entry != &DeviceData->ListOfPDOs;
223  entry = entry->Flink) {
224 
226  relations->Objects[prevcount] = pdoData->Common.Self;
227  ObReferenceObject (pdoData->Common.Self);
228  prevcount++;
229  }
230 
231  DPRINT("\t#PDOs present = %d\n\t#PDOs reported = %d\n",
232  DeviceData->NumPDOs, relations->Count);
233 
234  //
235  // Replace the relations structure in the IRP with the new
236  // one.
237  //
238  if (oldRelations) {
239  ExFreePoolWithTag(oldRelations, 0);
240  }
241  Irp->IoStatus.Information = (ULONG_PTR) relations;
242 
243  ExReleaseFastMutex (&DeviceData->Mutex);
244 
245  //
246  // Set up and pass the IRP further down the stack
247  //
248  Irp->IoStatus.Status = STATUS_SUCCESS;
249  break;
250 
251  default:
252 
253  //
254  // In the default case we merely call the next driver.
255  // We must not modify Irp->IoStatus.Status or complete the IRP.
256  //
257 
258  break;
259  }
260 
262  status = IoCallDriver (DeviceData->NextLowerDriver, Irp);
263  return STATUS_SUCCESS;
264 }
265 
266 NTSTATUS
268  PFDO_DEVICE_DATA FdoData,
269  PIRP Irp )
270 {
272  POWER_STATE powerState;
273  ACPI_STATUS AcpiStatus;
274 
275  PAGED_CODE ();
276 
278  powerState.DeviceState = PowerDeviceD0;
279  PoSetPowerState ( FdoData->Common.Self, DevicePowerState, powerState );
280 
281  SET_NEW_PNP_STATE(FdoData->Common, Started);
282 
283  AcpiStatus = AcpiInitializeSubsystem();
284  if(ACPI_FAILURE(AcpiStatus)){
285  DPRINT1("Unable to AcpiInitializeSubsystem\n");
286  return STATUS_UNSUCCESSFUL;
287  }
288 
289  AcpiStatus = AcpiInitializeTables(NULL, 16, 0);
290  if (ACPI_FAILURE(AcpiStatus)){
291  DPRINT1("Unable to AcpiInitializeTables\n");
292  return STATUS_UNSUCCESSFUL;
293  }
294 
295  AcpiStatus = AcpiLoadTables();
296  if(ACPI_FAILURE(AcpiStatus)){
297  DPRINT1("Unable to AcpiLoadTables\n");
298  AcpiTerminate();
299  return STATUS_UNSUCCESSFUL;
300  }
301 
303  if (!NT_SUCCESS(status))
304  {
305  DPRINT1("Unable to create ACPI tables in registry\n");
306  }
307 
308  DPRINT("Acpi subsystem init\n");
309  /* Initialize ACPI bus manager */
310  AcpiStatus = acpi_init();
311  if (!ACPI_SUCCESS(AcpiStatus)) {
312  DPRINT1("acpi_init() failed with status 0x%X\n", AcpiStatus);
313  AcpiTerminate();
314  return STATUS_UNSUCCESSFUL;
315  }
316  status = ACPIEnumerateDevices(FdoData);
317 
318  return status;
319 }
320 
321 NTSTATUS
324  PIRP Irp
325  )
326 {
327  KEVENT event;
329 
330  PAGED_CODE();
331 
333 
335 
338  &event,
339  TRUE,
340  TRUE,
341  TRUE
342  );
343 
345 
346  //
347  // Wait for lower drivers to be done with the Irp.
348  // Important thing to note here is when you allocate
349  // the memory for an event in the stack you must do a
350  // KernelMode wait instead of UserMode to prevent
351  // the stack from getting paged out.
352  //
353 
354  if (status == STATUS_PENDING) {
356  Executive,
357  KernelMode,
358  FALSE,
359  NULL
360  );
361  status = Irp->IoStatus.Status;
362  }
363 
364  return status;
365 }
366 
367 NTSTATUS
368 NTAPI
371  PIRP Irp,
372  PVOID Context
373  )
374 {
376 
377  //
378  // If the lower driver didn't return STATUS_PENDING, we don't need to
379  // set the event because we won't be waiting on it.
380  // This optimization avoids grabbing the dispatcher lock and improves perf.
381  //
382  if (Irp->PendingReturned != FALSE) {
383 
385  }
386  return STATUS_MORE_PROCESSING_REQUIRED; // Keep this IRP
387 }
388 
389 NTSTATUS
392  PPDO_DEVICE_DATA PdoData
393  )
394 {
395  PAGED_CODE ();
396 
397  //
398  // BusEnum does not queue any irps at this time so we have nothing to do.
399  //
400 
401  //
402  // Free any resources.
403  //
404 
405  if (PdoData->HardwareIDs) {
406  ExFreePoolWithTag(PdoData->HardwareIDs, 'DpcA');
407  PdoData->HardwareIDs = NULL;
408  }
409 
410  DPRINT("\tDeleting PDO: 0x%p\n", Device);
412  return STATUS_SUCCESS;
413 }
414 
415 
416 VOID
419  PFDO_DEVICE_DATA FdoData
420  )
421 {
422  PPDO_DEVICE_DATA pdoData;
423  int acpistate;
424  DEVICE_POWER_STATE ntState;
425 
426  PAGED_CODE ();
427 
428  pdoData = (PPDO_DEVICE_DATA) Pdo->DeviceExtension;
429 
430  DPRINT("pdo 0x%p, extension 0x%p\n", Pdo, pdoData);
431 
432  if (pdoData->AcpiHandle)
433  acpi_bus_get_power(pdoData->AcpiHandle, &acpistate);
434  else
435  acpistate = ACPI_STATE_D0;
436 
437  switch(acpistate)
438  {
439  case ACPI_STATE_D0:
440  ntState = PowerDeviceD0;
441  break;
442  case ACPI_STATE_D1:
443  ntState = PowerDeviceD1;
444  break;
445  case ACPI_STATE_D2:
446  ntState = PowerDeviceD2;
447  break;
448  case ACPI_STATE_D3:
449  ntState = PowerDeviceD3;
450  break;
451  default:
452  DPRINT1("Unknown power state (%d) returned by acpi\n",acpistate);
453  ntState = PowerDeviceUnspecified;
454  break;
455  }
456 
457  //
458  // Initialize the rest
459  //
460  pdoData->Common.IsFDO = FALSE;
461  pdoData->Common.Self = Pdo;
462 
463  pdoData->ParentFdo = FdoData->Common.Self;
464 
465 
466  INITIALIZE_PNP_STATE(pdoData->Common);
467 
468  pdoData->Common.DevicePowerState = ntState;
469  pdoData->Common.SystemPowerState = FdoData->Common.SystemPowerState;
470 
471  ExAcquireFastMutex (&FdoData->Mutex);
472  InsertTailList(&FdoData->ListOfPDOs, &pdoData->Link);
473  FdoData->NumPDOs++;
474  ExReleaseFastMutex (&FdoData->Mutex);
475 
476  // This should be the last step in initialization.
478 
479 }
480 
481 #if DBG
482 
483 PCHAR
486 )
487 {
488  switch (MinorFunction)
489  {
490  case IRP_MN_START_DEVICE:
491  return "IRP_MN_START_DEVICE";
493  return "IRP_MN_QUERY_REMOVE_DEVICE";
495  return "IRP_MN_REMOVE_DEVICE";
497  return "IRP_MN_CANCEL_REMOVE_DEVICE";
498  case IRP_MN_STOP_DEVICE:
499  return "IRP_MN_STOP_DEVICE";
501  return "IRP_MN_QUERY_STOP_DEVICE";
503  return "IRP_MN_CANCEL_STOP_DEVICE";
505  return "IRP_MN_QUERY_DEVICE_RELATIONS";
507  return "IRP_MN_QUERY_INTERFACE";
509  return "IRP_MN_QUERY_CAPABILITIES";
511  return "IRP_MN_QUERY_RESOURCES";
513  return "IRP_MN_QUERY_RESOURCE_REQUIREMENTS";
515  return "IRP_MN_QUERY_DEVICE_TEXT";
517  return "IRP_MN_FILTER_RESOURCE_REQUIREMENTS";
518  case IRP_MN_READ_CONFIG:
519  return "IRP_MN_READ_CONFIG";
520  case IRP_MN_WRITE_CONFIG:
521  return "IRP_MN_WRITE_CONFIG";
522  case IRP_MN_EJECT:
523  return "IRP_MN_EJECT";
524  case IRP_MN_SET_LOCK:
525  return "IRP_MN_SET_LOCK";
526  case IRP_MN_QUERY_ID:
527  return "IRP_MN_QUERY_ID";
529  return "IRP_MN_QUERY_PNP_DEVICE_STATE";
531  return "IRP_MN_QUERY_BUS_INFORMATION";
533  return "IRP_MN_DEVICE_USAGE_NOTIFICATION";
535  return "IRP_MN_SURPRISE_REMOVAL";
537  return "IRP_MN_QUERY_LEGACY_BUS_INFORMATION";
538  default:
539  return "unknown_pnp_irp";
540  }
541 }
542 
543 PCHAR
546  )
547 {
548  switch (Type)
549  {
550  case BusRelations:
551  return "BusRelations";
552  case EjectionRelations:
553  return "EjectionRelations";
554  case RemovalRelations:
555  return "RemovalRelations";
557  return "TargetDeviceRelation";
558  default:
559  return "UnKnown Relation";
560  }
561 }
562 
563 PCHAR
566  )
567 {
568  switch (Type)
569  {
570  case BusQueryDeviceID:
571  return "BusQueryDeviceID";
572  case BusQueryHardwareIDs:
573  return "BusQueryHardwareIDs";
575  return "BusQueryCompatibleIDs";
576  case BusQueryInstanceID:
577  return "BusQueryInstanceID";
579  return "BusQueryDeviceSerialNumber";
580  default:
581  return "UnKnown ID";
582  }
583 }
584 
585 #endif
586 
587 
#define DO_DEVICE_INITIALIZING
Definition: env_spec_w32.h:399
signed char * PCHAR
Definition: retypes.h:7
#define IRP_MN_CANCEL_REMOVE_DEVICE
DEVICE_POWER_STATE DevicePowerState
Definition: acpisys.h:33
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
enum _BUS_QUERY_ID_TYPE BUS_QUERY_ID_TYPE
#define IRP_MN_QUERY_RESOURCES
#define IRP_MN_REMOVE_DEVICE
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define IRP_MN_QUERY_ID
#define ACPI_SUCCESS(a)
Definition: acexcep.h:94
_In_ PDEVICE_OBJECT Pdo
Definition: classpnp.h:301
Type
Definition: Type.h:6
_In_ PIRP _In_ PDEVICE_OBJECT Device
Definition: fatprocs.h:2020
NTSTATUS NTAPI Bus_PnP(PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: pnp.c:25
ActualNumberDriverObjects * sizeof(PDRIVER_OBJECT)) PDRIVER_OBJECT *DriverObjectList
#define STATUS_MORE_PROCESSING_REQUIRED
Definition: shellext.h:63
_In_ PIRP Irp
Definition: csq.h:116
#define UNREFERENCED_PARAMETER(P)
Definition: ntbasedef.h:323
struct _DEVICE_OBJECT * PDEVICE_OBJECT
#define IRP_MN_FILTER_RESOURCE_REQUIREMENTS
#define IRP_MN_QUERY_RESOURCE_REQUIREMENTS
#define IRP_MN_WRITE_CONFIG
PDEVICE_OBJECT Objects[1]
Definition: iotypes.h:2055
#define IRP_MJ_PNP
Definition: cdrw_usr.h:52
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS Bus_PDO_PnP(PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpStack, PPDO_DEVICE_DATA DeviceData)
Definition: buspdo.c:22
#define IRP_MN_QUERY_LEGACY_BUS_INFORMATION
Definition: iotypes.h:4071
#define IRP_MN_EJECT
#define InsertTailList(ListHead, Entry)
UINT32 ACPI_STATUS
Definition: actypes.h:460
NTSTATUS Bus_SendIrpSynchronously(PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: pnp.c:322
LONG NTAPI KeSetEvent(IN PKEVENT Event, IN KPRIORITY Increment, IN BOOLEAN Wait)
Definition: eventobj.c:159
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
ACPI_STATUS ACPI_INIT_FUNCTION AcpiInitializeSubsystem(void)
Definition: utxfinit.c:76
VOID FASTCALL ExReleaseFastMutex(IN PFAST_MUTEX FastMutex)
Definition: fmutex.c:31
static int Link(const char **args)
Definition: vfdcmd.c:2414
#define PAGED_CODE()
Definition: video.h:57
#define IoSetCompletionRoutine(_Irp, _CompletionRoutine, _Context, _InvokeOnSuccess, _InvokeOnError, _InvokeOnCancel)
Definition: irp.cpp:515
PDEVICE_OBJECT Self
Definition: acpisys.h:28
FORCEINLINE VOID IoCopyCurrentIrpStackLocationToNext(_Inout_ PIRP Irp)
Definition: iofuncs.h:2820
NTSTATUS ACPIEnumerateDevices(PFDO_DEVICE_DATA DeviceExtension)
Definition: acpienum.c:146
#define ACPI_FAILURE(a)
Definition: acexcep.h:95
NTSTATUS Bus_DestroyPdo(PDEVICE_OBJECT Device, PPDO_DEVICE_DATA PdoData)
Definition: pnp.c:390
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
ACPI_STATUS ACPI_INIT_FUNCTION AcpiLoadTables(void)
Definition: tbxfload.c:69
#define IRP_MN_QUERY_REMOVE_DEVICE
struct _COMMON_DEVICE_DATA * PCOMMON_DEVICE_DATA
SYSTEM_POWER_STATE SystemPowerState
Definition: acpisys.h:32
FAST_MUTEX Mutex
Definition: acpisys.h:72
PWCHAR HardwareIDs
Definition: acpisys.h:44
struct _DEVICE_RELATIONS * PDEVICE_RELATIONS
PVOID DeviceExtension
Definition: env_spec_w32.h:418
smooth NULL
Definition: ftsmooth.c:416
#define IoCompleteRequest
Definition: irp.c:1240
void DPRINT(...)
Definition: polytest.cpp:61
NTSTATUS Bus_PlugInDevice(struct acpi_device *Device, PFDO_DEVICE_DATA FdoData)
Definition: acpienum.c:22
ACPI_STATUS ACPI_INIT_FUNCTION AcpiTerminate(void)
Definition: utxface.c:67
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
#define IRP_MN_READ_CONFIG
enum _DEVICE_RELATION_TYPE DEVICE_RELATION_TYPE
#define IRP_MN_QUERY_STOP_DEVICE
LIST_ENTRY ListOfPDOs
Definition: acpisys.h:66
NTSTATUS NTAPI Bus_CompletionRoutine(PDEVICE_OBJECT DeviceObject, PIRP Irp, PVOID Context)
Definition: pnp.c:369
enum _DEVICE_POWER_STATE DEVICE_POWER_STATE
struct _PDO_DEVICE_DATA * PPDO_DEVICE_DATA
#define IRP_MN_SURPRISE_REMOVAL
Definition: ntifs_ex.h:408
#define IRP_MN_STOP_DEVICE
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
#define RESTORE_PREVIOUS_PNP_STATE(_Data_)
Definition: fbtusb.h:115
GLenum GLuint GLenum GLsizei length
Definition: glext.h:5579
ACPI_STATUS ACPI_INIT_FUNCTION AcpiInitializeTables(ACPI_TABLE_DESC *InitialTableArray, UINT32 InitialTableCount, BOOLEAN AllowResize)
Definition: tbxface.c:107
#define IRP_MN_START_DEVICE
DEVICE_POWER_STATE DeviceState
Definition: ntpoapi.h:58
int acpi_bus_get_power(ACPI_HANDLE handle, int *state)
Definition: bus.c:198
#define IRP_MN_QUERY_DEVICE_TEXT
#define IRP_MN_QUERY_INTERFACE
#define ACPI_STATE_D3
Definition: actypes.h:627
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define IRP_MN_QUERY_BUS_INFORMATION
unsigned char UCHAR
Definition: xmlstorage.h:181
VOID Bus_InitializePdo(PDEVICE_OBJECT Pdo, PFDO_DEVICE_DATA FdoData)
Definition: pnp.c:417
COMMON_DEVICE_DATA Common
Definition: acpisys.h:58
uint32_t entry
Definition: isohybrid.c:63
Definition: typedefs.h:117
struct _cl_event * event
Definition: glext.h:7739
_In_ UCHAR MinorFunction
Definition: pofuncs.h:42
NTSTATUS acpi_create_volatile_registry_tables(void)
Definition: utils.c:522
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
PCHAR NTAPI PnPMinorFunctionString(UCHAR MinorFunction)
Definition: fbtpnp.c:1831
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2745
VOID NTAPI IoDeleteDevice(IN PDEVICE_OBJECT DeviceObject)
Definition: device.c:1251
PDEVICE_OBJECT ParentFdo
Definition: acpisys.h:41
struct _DEVICE_RELATIONS DEVICE_RELATIONS
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
VOID FASTCALL ExAcquireFastMutex(IN PFAST_MUTEX FastMutex)
Definition: fmutex.c:23
ULONG NumPDOs
Definition: acpisys.h:69
ACPI_HANDLE AcpiHandle
Definition: acpisys.h:39
PCHAR DbgDeviceIDString(BUS_QUERY_ID_TYPE Type)
NTSTATUS NTAPI IoCallDriver(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1218
NTSTATUS Bus_StartFdo(PFDO_DEVICE_DATA FdoData, PIRP Irp)
Definition: pnp.c:267
#define IRP_MN_QUERY_DEVICE_RELATIONS
#define IoSkipCurrentIrpStackLocation(Irp)
Definition: ntifs_ex.h:421
#define DPRINT1
Definition: precomp.h:8
#define INITIALIZE_PNP_STATE(_Data_)
Definition: fbtusb.h:107
#define SET_NEW_PNP_STATE(_Data_, _state_)
Definition: fbtusb.h:111
NTSTATUS Bus_FDO_PnP(PDEVICE_OBJECT DeviceObject, PIRP Irp, PIO_STACK_LOCATION IrpStack, PFDO_DEVICE_DATA DeviceData)
Definition: pnp.c:72
#define ACPI_STATE_D0
Definition: actypes.h:624
#define ObReferenceObject
Definition: obfuncs.h:204
#define IRP_MN_SET_LOCK
unsigned int ULONG
Definition: retypes.h:1
#define IO_NO_INCREMENT
Definition: iotypes.h:566
POWER_STATE NTAPI PoSetPowerState(IN PDEVICE_OBJECT DeviceObject, IN POWER_STATE_TYPE Type, IN POWER_STATE State)
Definition: power.c:597
#define ULONG_PTR
Definition: config.h:101
#define ACPI_STATE_D1
Definition: actypes.h:625
#define IRP_MN_CANCEL_STOP_DEVICE
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
#define IRP_MN_DEVICE_USAGE_NOTIFICATION
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:2772
return STATUS_SUCCESS
Definition: btrfs.c:2966
static SERVICE_STATUS status
Definition: service.c:31
LIST_ENTRY Link
Definition: acpisys.h:46
int acpi_init(void)
Definition: bus.c:1754
#define ACPI_STATE_D2
Definition: actypes.h:626
#define IRP_MN_QUERY_PNP_DEVICE_STATE
PCHAR DbgDeviceRelationString(DEVICE_RELATION_TYPE Type)
COMMON_DEVICE_DATA Common
Definition: acpisys.h:38
#define IRP_MN_QUERY_CAPABILITIES
Definition: ps.c:97