ReactOS  0.4.14-dev-49-gfb4591c
main.c
Go to the documentation of this file.
1 #include "precomp.h"
2 
3 #include <poclass.h>
4 
5 #define NDEBUG
6 #include <debug.h>
7 
9 NTAPI
13  );
14 
15 #ifdef ALLOC_PRAGMA
16 #pragma alloc_text (INIT, DriverEntry)
17 #pragma alloc_text (PAGE, Bus_AddDevice)
18 
19 #endif
20 
21 extern struct acpi_device *sleep_button;
22 extern struct acpi_device *power_button;
23 
27 
28 
30 NTAPI
34  )
35 
36 {
38  PDEVICE_OBJECT deviceObject = NULL;
39  PFDO_DEVICE_DATA deviceData = NULL;
40 #ifndef NDEBUG
41  PWCHAR deviceName = NULL;
42  ULONG nameLength;
43 #endif
44 
45  PAGED_CODE ();
46 
47  DPRINT("Add Device: 0x%p\n", PhysicalDeviceObject);
48 
49  DPRINT("#################### Bus_CreateClose Creating FDO Device ####################\n");
51  sizeof(FDO_DEVICE_DATA),
52  NULL,
55  TRUE,
56  &deviceObject);
57  if (!NT_SUCCESS(status))
58  {
59  DPRINT1("IoCreateDevice() failed with status 0x%X\n", status);
60  goto End;
61  }
62 
63  deviceData = (PFDO_DEVICE_DATA) deviceObject->DeviceExtension;
64  RtlZeroMemory (deviceData, sizeof (FDO_DEVICE_DATA));
65 
66  //
67  // Set the initial state of the FDO
68  //
69 
70  INITIALIZE_PNP_STATE(deviceData->Common);
71 
72  deviceData->Common.IsFDO = TRUE;
73 
74  deviceData->Common.Self = deviceObject;
75 
76  ExInitializeFastMutex (&deviceData->Mutex);
77 
78  InitializeListHead (&deviceData->ListOfPDOs);
79 
80  // Set the PDO for use with PlugPlay functions
81 
82  deviceData->UnderlyingPDO = PhysicalDeviceObject;
83 
84  //
85  // Set the initial powerstate of the FDO
86  //
87 
90 
91  deviceObject->Flags |= DO_POWER_PAGABLE;
92 
93  //
94  // Attach our FDO to the device stack.
95  // The return value of IoAttachDeviceToDeviceStack is the top of the
96  // attachment chain. This is where all the IRPs should be routed.
97  //
98 
100  deviceObject,
102 
103  if (NULL == deviceData->NextLowerDriver) {
104 
106  goto End;
107  }
108 
109 
110 #ifndef NDEBUG
111  //
112  // We will demonstrate here the step to retrieve the name of the PDO
113  //
114 
117  0,
118  NULL,
119  &nameLength);
120 
122  {
123  DPRINT1("AddDevice:IoGDP failed (0x%x)\n", status);
124  goto End;
125  }
126 
127  deviceName = ExAllocatePoolWithTag(NonPagedPool, nameLength, 'MpcA');
128 
129  if (NULL == deviceName) {
130  DPRINT1("AddDevice: no memory to alloc for deviceName(0x%x)\n", nameLength);
132  goto End;
133  }
134 
137  nameLength,
138  deviceName,
139  &nameLength);
140 
141  if (!NT_SUCCESS (status)) {
142 
143  DPRINT1("AddDevice:IoGDP(2) failed (0x%x)", status);
144  goto End;
145  }
146 
147  DPRINT("AddDevice: %p to %p->%p (%ws) \n",
148  deviceObject,
149  deviceData->NextLowerDriver,
151  deviceName);
152 
153 #endif
154 
155  //
156  // We are done with initializing, so let's indicate that and return.
157  // This should be the final step in the AddDevice process.
158  //
159  deviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
160 
161 End:
162 #ifndef NDEBUG
163  if (deviceName){
164  ExFreePoolWithTag(deviceName, 'MpcA');
165  }
166 #endif
167  if (!NT_SUCCESS(status) && deviceObject){
168  if (deviceData && deviceData->NextLowerDriver){
169  IoDetachDevice (deviceData->NextLowerDriver);
170  }
171  IoDeleteDevice (deviceObject);
172  }
173  return status;
174 
175 }
176 
177 NTSTATUS
178 NTAPI
181  IN PIRP Irp)
182 {
183  Irp->IoStatus.Status = STATUS_SUCCESS;
184  Irp->IoStatus.Information = 0;
185 
187 
188  return STATUS_SUCCESS;
189 }
190 
191 VOID
192 NTAPI
194 {
195  PIRP Irp = Context;
196  int result;
197  struct acpi_bus_event event;
198  ULONG ButtonEvent;
199 
202 
203  if (!ACPI_SUCCESS(result))
204  {
205  Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
206  }
207  else
208  {
209  if (strstr(event.bus_id, "PWRF"))
210  ButtonEvent = SYS_BUTTON_POWER;
211  else if (strstr(event.bus_id, "SLPF"))
212  ButtonEvent = SYS_BUTTON_SLEEP;
213  else
214  ButtonEvent = 0;
215 
216  RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, &ButtonEvent, sizeof(ButtonEvent));
217  Irp->IoStatus.Status = STATUS_SUCCESS;
218  Irp->IoStatus.Information = sizeof(ULONG);
219  }
220 
222 }
223 
224 
225 NTSTATUS
226 NTAPI
229  IN PIRP Irp)
230 {
231  PIO_STACK_LOCATION irpStack;
233  PCOMMON_DEVICE_DATA commonData;
234  ULONG Caps = 0;
235  HANDLE ThreadHandle;
236 
237  PAGED_CODE ();
238 
239  irpStack = IoGetCurrentIrpStackLocation (Irp);
241 
243 
244  Irp->IoStatus.Information = 0;
245 
246  if (!commonData->IsFDO)
247  {
248  switch (irpStack->Parameters.DeviceIoControl.IoControlCode)
249  {
252  Irp);
253  break;
254 
256  if (irpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG))
257  {
259  break;
260  }
261 
262  if (wcsstr(((PPDO_DEVICE_DATA)commonData)->HardwareIDs, L"PNP0C0D"))
263  {
264  DPRINT1("Lid button reported to power manager\n");
265  Caps |= SYS_BUTTON_LID;
266  }
267  else if (((PPDO_DEVICE_DATA)commonData)->AcpiHandle == NULL)
268  {
269  /* We have to return both at the same time because since we
270  * have a NULL handle we are the fixed feature DO and we will
271  * only be called once (not once per device)
272  */
273  if (power_button)
274  {
275  DPRINT("Fixed power button reported to power manager\n");
276  Caps |= SYS_BUTTON_POWER;
277  }
278  if (sleep_button)
279  {
280  DPRINT("Fixed sleep button reported to power manager\n");
281  Caps |= SYS_BUTTON_SLEEP;
282  }
283  }
284  else if (wcsstr(((PPDO_DEVICE_DATA)commonData)->HardwareIDs, L"PNP0C0C"))
285  {
286  DPRINT("Control method power button reported to power manager\n");
287  Caps |= SYS_BUTTON_POWER;
288  }
289  else if (wcsstr(((PPDO_DEVICE_DATA)commonData)->HardwareIDs, L"PNP0C0E"))
290  {
291  DPRINT("Control method sleep reported to power manager\n");
292  Caps |= SYS_BUTTON_SLEEP;
293  }
294  else
295  {
296  DPRINT1("IOCTL_GET_SYS_BUTTON_CAPS sent to a non-button device\n");
298  }
299 
300  if (Caps != 0)
301  {
302  RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, &Caps, sizeof(Caps));
303  Irp->IoStatus.Information = sizeof(Caps);
305  }
306  break;
307 
309  PsCreateSystemThread(&ThreadHandle, THREAD_ALL_ACCESS, 0, 0, 0, ButtonWaitThread, Irp);
310  ZwClose(ThreadHandle);
311 
313  break;
314 
316  DPRINT("IOCTL_BATTERY_QUERY_TAG is not supported!\n");
317  break;
318 
319  default:
320  DPRINT1("Unsupported IOCTL: %x\n", irpStack->Parameters.DeviceIoControl.IoControlCode);
321  break;
322  }
323  }
324  else
325  DPRINT1("IOCTL sent to the ACPI FDO! Kill the caller!\n");
326 
327  if (status != STATUS_PENDING)
328  {
329  Irp->IoStatus.Status = status;
331  }
332  else
334 
335  return status;
336 }
337 
338 static
339 NTSTATUS
340 AcpiRegOpenKey(IN HANDLE ParentKeyHandle,
344 {
347 
349 
351  &Name,
353  ParentKeyHandle,
354  NULL);
355 
356  return ZwOpenKey(KeyHandle,
359 }
360 
361 static
362 NTSTATUS
368 {
371  ULONG BufferLength = 0;
373 
375 
376  if (DataLength != NULL)
378 
379  /* Check if the caller provided a valid buffer */
380  if ((Data != NULL) && (BufferLength != 0))
381  {
383 
384  /* Allocate memory for the value */
385  ValueInfo = ExAllocatePoolWithTag(PagedPool, BufferLength, 'MpcA');
386  if (ValueInfo == NULL)
387  return STATUS_NO_MEMORY;
388  }
389  else
390  {
391  /* Caller didn't provide a valid buffer, assume he wants the size only */
392  ValueInfo = NULL;
393  BufferLength = 0;
394  }
395 
396  /* Query the value */
397  Status = ZwQueryValueKey(KeyHandle,
398  &Name,
400  ValueInfo,
401  BufferLength,
402  &BufferLength);
403 
404  if (DataLength != NULL)
406 
407  /* Check if we have the size only */
408  if (ValueInfo == NULL)
409  {
410  /* Check for unexpected status */
411  if ((Status != STATUS_BUFFER_OVERFLOW) &&
413  {
414  return Status;
415  }
416 
417  /* All is well */
419  }
420  /* Otherwise the caller wanted data back, check if we got it */
421  else if (NT_SUCCESS(Status))
422  {
423  if (Type != NULL)
424  *Type = ValueInfo->Type;
425 
426  /* Copy it */
427  RtlMoveMemory(Data, ValueInfo->Data, ValueInfo->DataLength);
428 
429  /* if the type is REG_SZ and data is not 0-terminated
430  * and there is enough space in the buffer NT appends a \0 */
431  if (((ValueInfo->Type == REG_SZ) ||
432  (ValueInfo->Type == REG_EXPAND_SZ) ||
433  (ValueInfo->Type == REG_MULTI_SZ)) &&
434  (ValueInfo->DataLength <= *DataLength - sizeof(WCHAR)))
435  {
436  WCHAR *ptr = (WCHAR *)((ULONG_PTR)Data + ValueInfo->DataLength);
437  if ((ptr > (WCHAR *)Data) && ptr[-1])
438  *ptr = 0;
439  }
440  }
441 
442  /* Free the memory and return status */
443  if (ValueInfo != NULL)
444  {
445  ExFreePoolWithTag(ValueInfo, 'MpcA');
446  }
447 
448  return Status;
449 }
450 
451 static
452 NTSTATUS
454 {
455  LPWSTR ProcessorIdentifier = NULL;
456  LPWSTR ProcessorVendorIdentifier = NULL;
457  LPWSTR HardwareIdsBuffer = NULL;
458  HANDLE ProcessorHandle = NULL;
459  ULONG Length = 0, Level1Length = 0, Level2Length = 0, Level3Length = 0;
460  SIZE_T HardwareIdsLength = 0;
461  SIZE_T VendorIdentifierLength;
462  ULONG i;
463  PWCHAR Ptr;
465 
466  DPRINT("GetProcessorInformation()\n");
467 
468  /* Open the key for CPU 0 */
470  L"\\Registry\\Machine\\Hardware\\Description\\System\\CentralProcessor\\0",
471  KEY_READ,
472  &ProcessorHandle);
473  if (!NT_SUCCESS(Status))
474  {
475  DPRINT1("Failed to open CentralProcessor registry key: 0x%lx\n", Status);
476  goto done;
477  }
478 
479  /* Query the processor identifier length */
480  Status = AcpiRegQueryValue(ProcessorHandle,
481  L"Identifier",
482  NULL,
483  NULL,
484  &Length);
485  if (!NT_SUCCESS(Status))
486  {
487  DPRINT1("Failed to query Identifier value: 0x%lx\n", Status);
488  goto done;
489  }
490 
491  /* Remember the length as fallback for level 1-3 length */
492  Level1Length = Level2Length = Level3Length = Length;
493 
494  /* Allocate a buffer large enough to be zero terminated */
495  Length += sizeof(UNICODE_NULL);
496  ProcessorIdentifier = ExAllocatePoolWithTag(PagedPool, Length, 'IpcA');
497  if (ProcessorIdentifier == NULL)
498  {
499  DPRINT1("Failed to allocate 0x%lx bytes\n", Length);
501  goto done;
502  }
503 
504  /* Query the processor identifier string */
505  Status = AcpiRegQueryValue(ProcessorHandle,
506  L"Identifier",
507  NULL,
508  ProcessorIdentifier,
509  &Length);
510  if (!NT_SUCCESS(Status))
511  {
512  DPRINT1("Failed to query Identifier value: 0x%lx\n", Status);
513  goto done;
514  }
515 
516  /* Query the processor name length */
517  Length = 0;
518  Status = AcpiRegQueryValue(ProcessorHandle,
519  L"ProcessorNameString",
520  NULL,
521  NULL,
522  &Length);
523  if (!NT_SUCCESS(Status))
524  {
525  DPRINT1("Failed to query ProcessorNameString value: 0x%lx\n", Status);
526  goto done;
527  }
528 
529  /* Allocate a buffer large enough to be zero terminated */
530  Length += sizeof(UNICODE_NULL);
532  if (ProcessorNameString == NULL)
533  {
534  DPRINT1("Failed to allocate 0x%lx bytes\n", Length);
536  goto done;
537  }
538 
539  /* Query the processor name string */
540  Status = AcpiRegQueryValue(ProcessorHandle,
541  L"ProcessorNameString",
542  NULL,
544  &Length);
545  if (!NT_SUCCESS(Status))
546  {
547  DPRINT1("Failed to query ProcessorNameString value: 0x%lx\n", Status);
548  goto done;
549  }
550 
551  /* Query the vendor identifier length */
552  Length = 0;
553  Status = AcpiRegQueryValue(ProcessorHandle,
554  L"VendorIdentifier",
555  NULL,
556  NULL,
557  &Length);
558  if (!NT_SUCCESS(Status) || (Length == 0))
559  {
560  DPRINT1("Failed to query VendorIdentifier value: 0x%lx\n", Status);
561  goto done;
562  }
563 
564  /* Allocate a buffer large enough to be zero terminated */
565  Length += sizeof(UNICODE_NULL);
566  ProcessorVendorIdentifier = ExAllocatePoolWithTag(PagedPool, Length, 'IpcA');
567  if (ProcessorVendorIdentifier == NULL)
568  {
569  DPRINT1("Failed to allocate 0x%lx bytes\n", Length);
571  goto done;
572  }
573 
574  /* Query the vendor identifier string */
575  Status = AcpiRegQueryValue(ProcessorHandle,
576  L"VendorIdentifier",
577  NULL,
578  ProcessorVendorIdentifier,
579  &Length);
580  if (!NT_SUCCESS(Status))
581  {
582  DPRINT1("Failed to query VendorIdentifier value: 0x%lx\n", Status);
583  goto done;
584  }
585 
586  /* Change spaces to underscores */
587  for (i = 0; i < wcslen(ProcessorIdentifier); i++)
588  {
589  if (ProcessorIdentifier[i] == L' ')
590  ProcessorIdentifier[i] = L'_';
591  }
592 
593  Ptr = wcsstr(ProcessorIdentifier, L"Stepping");
594  if (Ptr != NULL)
595  {
596  Ptr--;
597  Level1Length = (ULONG)(Ptr - ProcessorIdentifier);
598  }
599 
600  Ptr = wcsstr(ProcessorIdentifier, L"Model");
601  if (Ptr != NULL)
602  {
603  Ptr--;
604  Level2Length = (ULONG)(Ptr - ProcessorIdentifier);
605  }
606 
607  Ptr = wcsstr(ProcessorIdentifier, L"Family");
608  if (Ptr != NULL)
609  {
610  Ptr--;
611  Level3Length = (ULONG)(Ptr - ProcessorIdentifier);
612  }
613 
614  VendorIdentifierLength = (USHORT)wcslen(ProcessorVendorIdentifier);
615 
616  /* Calculate the size of the full REG_MULTI_SZ data (see swprintf below) */
617  HardwareIdsLength = (5 + VendorIdentifierLength + 3 + Level1Length + 1 +
618  1 + VendorIdentifierLength + 3 + Level1Length + 1 +
619  5 + VendorIdentifierLength + 3 + Level2Length + 1 +
620  1 + VendorIdentifierLength + 3 + Level2Length + 1 +
621  5 + VendorIdentifierLength + 3 + Level3Length + 1 +
622  1 + VendorIdentifierLength + 3 + Level3Length + 1 +
623  1) * sizeof(WCHAR);
624 
625  /* Allocate a buffer to the data */
626  HardwareIdsBuffer = ExAllocatePoolWithTag(PagedPool, HardwareIdsLength, 'IpcA');
627  if (HardwareIdsBuffer == NULL)
628  {
630  goto done;
631  }
632 
633  Length = 0;
634  Length += swprintf(&HardwareIdsBuffer[Length], L"ACPI\\%s_-_%.*s", ProcessorVendorIdentifier, Level1Length, ProcessorIdentifier);
635  HardwareIdsBuffer[Length++] = UNICODE_NULL;
636 
637  Length += swprintf(&HardwareIdsBuffer[Length], L"*%s_-_%.*s", ProcessorVendorIdentifier, Level1Length, ProcessorIdentifier);
638  HardwareIdsBuffer[Length++] = UNICODE_NULL;
639 
640  Length += swprintf(&HardwareIdsBuffer[Length], L"ACPI\\%s_-_%.*s", ProcessorVendorIdentifier, Level2Length, ProcessorIdentifier);
641  HardwareIdsBuffer[Length++] = UNICODE_NULL;
642 
643  Length += swprintf(&HardwareIdsBuffer[Length], L"*%s_-_%.*s", ProcessorVendorIdentifier, Level2Length, ProcessorIdentifier);
644  HardwareIdsBuffer[Length++] = UNICODE_NULL;
645 
646  Length += swprintf(&HardwareIdsBuffer[Length], L"ACPI\\%s_-_%.*s", ProcessorVendorIdentifier, Level3Length, ProcessorIdentifier);
647  HardwareIdsBuffer[Length++] = UNICODE_NULL;
648 
649  Length += swprintf(&HardwareIdsBuffer[Length], L"*%s_-_%.*s", ProcessorVendorIdentifier, Level3Length, ProcessorIdentifier);
650  HardwareIdsBuffer[Length++] = UNICODE_NULL;
651  HardwareIdsBuffer[Length++] = UNICODE_NULL;
652 
653  /* Make sure we counted correctly */
654  NT_ASSERT(Length * sizeof(WCHAR) == HardwareIdsLength);
655 
656  ProcessorHardwareIds.Length = (SHORT)HardwareIdsLength;
658  ProcessorHardwareIds.Buffer = HardwareIdsBuffer;
659 
660  Length = (5 + VendorIdentifierLength + 3 + Level1Length + 1) * sizeof(WCHAR);
662  if (ProcessorIdString != NULL)
663  {
664  Length = swprintf(ProcessorIdString, L"ACPI\\%s_-_%.*s", ProcessorVendorIdentifier, Level1Length, ProcessorIdentifier);
666  DPRINT("ProcessorIdString: %S\n", ProcessorIdString);
667  }
668 
669 done:
670  if (ProcessorHandle != NULL)
671  ZwClose(ProcessorHandle);
672 
673  if (ProcessorIdentifier != NULL)
674  ExFreePoolWithTag(ProcessorIdentifier, 'IpcA');
675 
676  if (ProcessorVendorIdentifier != NULL)
677  ExFreePoolWithTag(ProcessorVendorIdentifier, 'IpcA');
678 
679  if (!NT_SUCCESS(Status))
680  {
681  if (HardwareIdsBuffer != NULL)
682  ExFreePoolWithTag(HardwareIdsBuffer, 'IpcA');
683  }
684 
685  return Status;
686 }
687 
688 NTSTATUS
689 NTAPI
693  )
694 {
696  DPRINT("Driver Entry \n");
697 
699  if (!NT_SUCCESS(Status))
700  {
701  NT_ASSERT(FALSE);
702  return Status;
703  }
704 
705  //
706  // Set entry points into the driver
707  //
713 
715 
716  return STATUS_SUCCESS;
717 }
NTSTATUS NTAPI ACPIDispatchDeviceControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: main.c:227
#define DO_DEVICE_INITIALIZING
Definition: env_spec_w32.h:399
#define IOCTL_GET_SYS_BUTTON_CAPS
Definition: poclass.h:57
#define DO_POWER_PAGABLE
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING KeyName
Definition: ndis.h:4711
#define IN
Definition: typedefs.h:38
DEVICE_POWER_STATE DevicePowerState
Definition: acpisys.h:33
#define THREAD_ALL_ACCESS
Definition: nt_native.h:1339
static NTSTATUS AcpiRegQueryValue(IN HANDLE KeyHandle, IN LPWSTR ValueName, OUT PULONG Type OPTIONAL, OUT PVOID Data OPTIONAL, IN OUT PULONG DataLength OPTIONAL)
Definition: main.c:363
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
#define IRP_MJ_CREATE
Definition: rdpdr.c:44
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define ACPI_SUCCESS(a)
Definition: acexcep.h:94
UNICODE_STRING ProcessorHardwareIds
Definition: main.c:24
Type
Definition: Type.h:6
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING _Out_ PNDIS_HANDLE KeyHandle
Definition: ndis.h:4711
USHORT MaximumLength
Definition: env_spec_w32.h:370
_In_ PIRP Irp
Definition: csq.h:116
#define KEY_READ
Definition: nt_native.h:1023
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define SYS_BUTTON_SLEEP
Definition: poclass.h:82
_CONST_RETURN wchar_t *__cdecl wcsstr(_In_z_ const wchar_t *_Str, _In_z_ const wchar_t *_SubStr)
NTSYSAPI NTSTATUS NTAPI ZwClose(_In_ HANDLE Handle)
char * strstr(char *String1, char *String2)
Definition: utclib.c:653
#define IRP_MJ_PNP
Definition: cdrw_usr.h:52
_Must_inspect_result_ _In_ PFSRTL_PER_STREAM_CONTEXT Ptr
Definition: fsrtlfuncs.h:898
LONG NTSTATUS
Definition: precomp.h:26
VOID NTAPI IoDetachDevice(IN PDEVICE_OBJECT TargetDevice)
Definition: device.c:1296
NTSTATUS NTAPI Bus_Power(PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: power.c:8
uint16_t * PWCHAR
Definition: typedefs.h:54
NTSTATUS NTAPI Bus_PDO_EvalMethod(PPDO_DEVICE_DATA DeviceData, PIRP Irp)
Definition: eval.c:85
PDEVICE_OBJECT PhysicalDeviceObject
Definition: btrfs_drv.h:1114
struct acpi_device * power_button
Definition: button.c:55
PDEVICE_OBJECT UnderlyingPDO
Definition: acpisys.h:59
LPWSTR ProcessorIdString
Definition: main.c:25
#define PAGED_CODE()
Definition: video.h:57
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:263
static NTSTATUS GetProcessorInformation(VOID)
Definition: main.c:453
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:64
PDEVICE_OBJECT Self
Definition: acpisys.h:28
uint32_t ULONG_PTR
Definition: typedefs.h:63
#define SYS_BUTTON_LID
Definition: poclass.h:83
_In_ PUNICODE_STRING ValueName
Definition: cmfuncs.h:264
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
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
#define UNICODE_NULL
struct _COMMON_DEVICE_DATA * PCOMMON_DEVICE_DATA
_In_ ULONG BufferLength
Definition: usbdlib.h:225
SYSTEM_POWER_STATE SystemPowerState
Definition: acpisys.h:32
short SHORT
Definition: pedump.c:59
#define REG_MULTI_SZ
Definition: nt_native.h:1501
FAST_MUTEX Mutex
Definition: acpisys.h:72
PDEVICE_OBJECT NTAPI IoAttachDeviceToDeviceStack(IN PDEVICE_OBJECT SourceDevice, IN PDEVICE_OBJECT TargetDevice)
Definition: device.c:966
PDRIVER_EXTENSION DriverExtension
Definition: iotypes.h:2174
static PVOID ptr
Definition: dispmode.c:27
struct NameRec_ * Name
Definition: cdprocs.h:464
PVOID DeviceExtension
Definition: env_spec_w32.h:418
LPWSTR ProcessorNameString
Definition: main.c:26
smooth NULL
Definition: ftsmooth.c:416
static PDRIVER_OBJECT DriverObject
Definition: template.c:42
#define IoCompleteRequest
Definition: irp.c:1240
NTSTATUS NTAPI IoGetDeviceProperty(IN PDEVICE_OBJECT DeviceObject, IN DEVICE_REGISTRY_PROPERTY DeviceProperty, IN ULONG BufferLength, OUT PVOID PropertyBuffer, OUT PULONG ResultLength)
Definition: pnpmgr.c:4228
void DPRINT(...)
Definition: polytest.cpp:61
#define ACPI_BUTTON_NOTIFY_STATUS
Definition: acpi_drivers.h:87
#define IOCTL_GET_SYS_BUTTON_EVENT
Definition: poclass.h:60
LIST_ENTRY ListOfPDOs
Definition: acpisys.h:66
static NTSTATUS AcpiRegOpenKey(IN HANDLE ParentKeyHandle, IN LPCWSTR KeyName, IN ACCESS_MASK DesiredAccess, OUT HANDLE KeyHandle)
Definition: main.c:340
if(!(yy_init))
Definition: macro.lex.yy.c:714
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
static PSecPkgInfoA *static SEC_CHAR ULONG
Definition: main.c:37
#define STATUS_PENDING
Definition: ntstatus.h:82
#define STATUS_NO_SUCH_DEVICE
Definition: udferr_usr.h:136
FORCEINLINE VOID ExInitializeFastMutex(_Out_ PFAST_MUTEX FastMutex)
Definition: exfuncs.h:274
#define swprintf(buf, format,...)
Definition: sprintf.c:56
NTSTATUS NTAPI Bus_AddDevice(PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT PhysicalDeviceObject)
Definition: main.c:31
#define IOCTL_BATTERY_QUERY_TAG
Definition: batclass.h:84
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
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_MJ_POWER
#define IRP_MJ_CLOSE
Definition: rdpdr.c:45
static const WCHAR L[]
Definition: oid.c:1250
COMMON_DEVICE_DATA Common
Definition: acpisys.h:58
#define SYS_BUTTON_POWER
Definition: poclass.h:81
struct _cl_event * event
Definition: glext.h:7739
#define IOCTL_ACPI_EVAL_METHOD
Definition: acpiioct.h:178
Status
Definition: gdiplustypes.h:24
struct _FDO_DEVICE_DATA * PFDO_DEVICE_DATA
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
ULONG_PTR SIZE_T
Definition: typedefs.h:78
__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
PDRIVER_ADD_DEVICE AddDevice
Definition: iotypes.h:2112
struct acpi_device * sleep_button
Definition: button.c:56
VOID NTAPI ButtonWaitThread(PVOID Context)
Definition: main.c:193
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:61
unsigned short USHORT
Definition: pedump.c:61
NTSTATUS NTAPI DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
Definition: main.c:690
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define REG_EXPAND_SZ
Definition: nt_native.h:1494
_In_ PIO_STACK_LOCATION _Inout_ PFILE_OBJECT _Inout_ PVCB _Outptr_result_maybenull_ PDCB _In_ PDCB _In_ PDIRENT _In_ ULONG _In_ ULONG _In_ PUNICODE_STRING _In_ PACCESS_MASK DesiredAccess
Definition: create.c:4157
#define STATUS_NO_MEMORY
Definition: ntstatus.h:246
NTSTATUS NTAPI PsCreateSystemThread(OUT PHANDLE ThreadHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, IN HANDLE ProcessHandle, IN PCLIENT_ID ClientId, IN PKSTART_ROUTINE StartRoutine, IN PVOID StartContext)
Definition: thread.c:602
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:254
unsigned int * PULONG
Definition: retypes.h:1
NTSTATUS NTAPI Bus_PnP(PDEVICE_OBJECT DeviceObject, PIRP Irp)
Definition: pnp.c:25
#define DPRINT1
Definition: precomp.h:8
#define INITIALIZE_PNP_STATE(_Data_)
Definition: fbtusb.h:107
PDEVICE_OBJECT NextLowerDriver
Definition: acpisys.h:63
int acpi_bus_receive_event(struct acpi_bus_event *event)
Definition: bus.c:513
#define OUT
Definition: typedefs.h:39
PDRIVER_DISPATCH MajorFunction[IRP_MJ_MAXIMUM_FUNCTION+1]
Definition: iotypes.h:2181
#define FILE_DEVICE_ACPI
Definition: winioctl.h:155
struct tagContext Context
Definition: acpixf.h:1024
#define STATUS_NOT_SUPPORTED
Definition: ntstatus.h:409
unsigned int ULONG
Definition: retypes.h:1
#define IO_NO_INCREMENT
Definition: iotypes.h:566
NTSTATUS NTAPI IoCreateDevice(IN PDRIVER_OBJECT DriverObject, IN ULONG DeviceExtensionSize, IN PUNICODE_STRING DeviceName, IN DEVICE_TYPE DeviceType, IN ULONG DeviceCharacteristics, IN BOOLEAN Exclusive, OUT PDEVICE_OBJECT *DeviceObject)
Definition: device.c:1031
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
_In_ PUNICODE_STRING RegistryPath
Definition: wmip.h:27
NTSTATUS NTAPI ACPIDispatchCreateClose(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: main.c:179
#define FILE_DEVICE_SECURE_OPEN
Definition: cdrw_usr.h:46
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1099
WCHAR * LPWSTR
Definition: xmlstorage.h:184
_Must_inspect_result_ _Out_writes_to_ DataLength PHIDP_DATA _Inout_ PULONG DataLength
Definition: hidpi.h:333
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:2772
return STATUS_SUCCESS
Definition: btrfs.c:2966
IoMarkIrpPending(Irp)
GLuint64EXT * result
Definition: glext.h:11304
static SERVICE_STATUS status
Definition: service.c:31
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
ULONG ACCESS_MASK
Definition: nt_native.h:40
#define IRP_MJ_DEVICE_CONTROL
Definition: rdpdr.c:52
#define NT_ASSERT
Definition: rtlfuncs.h:3312
#define REG_SZ
Definition: layer.c:22
Definition: ps.c:97
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68