[ACPI]
[reactos.git] / reactos / drivers / bus / acpi / main.c
1 #include "precomp.h"
2
3 #include <poclass.h>
4
5 #define NDEBUG
6 #include <debug.h>
7
8 NTSTATUS
9 NTAPI
10 DriverEntry (
11 PDRIVER_OBJECT DriverObject,
12 PUNICODE_STRING RegistryPath
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
24 UNICODE_STRING ProcessorHardwareIds = {0, 0, NULL};
25 LPWSTR ProcessorIdString = NULL;
26 LPWSTR ProcessorNameString = NULL;
27
28
29 NTSTATUS
30 NTAPI
31 Bus_AddDevice(
32 PDRIVER_OBJECT DriverObject,
33 PDEVICE_OBJECT PhysicalDeviceObject
34 )
35
36 {
37 NTSTATUS status;
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");
50 status = IoCreateDevice(DriverObject,
51 sizeof(FDO_DEVICE_DATA),
52 NULL,
53 FILE_DEVICE_ACPI,
54 FILE_DEVICE_SECURE_OPEN,
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
88 deviceData->Common.DevicePowerState = PowerDeviceUnspecified;
89 deviceData->Common.SystemPowerState = PowerSystemWorking;
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
99 deviceData->NextLowerDriver = IoAttachDeviceToDeviceStack (
100 deviceObject,
101 PhysicalDeviceObject);
102
103 if (NULL == deviceData->NextLowerDriver) {
104
105 status = STATUS_NO_SUCH_DEVICE;
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
115 status = IoGetDeviceProperty (PhysicalDeviceObject,
116 DevicePropertyPhysicalDeviceObjectName,
117 0,
118 NULL,
119 &nameLength);
120
121 if (status != STATUS_BUFFER_TOO_SMALL)
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);
131 status = STATUS_INSUFFICIENT_RESOURCES;
132 goto End;
133 }
134
135 status = IoGetDeviceProperty (PhysicalDeviceObject,
136 DevicePropertyPhysicalDeviceObjectName,
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,
150 PhysicalDeviceObject,
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
179 ACPIDispatchCreateClose(
180 IN PDEVICE_OBJECT DeviceObject,
181 IN PIRP Irp)
182 {
183 Irp->IoStatus.Status = STATUS_SUCCESS;
184 Irp->IoStatus.Information = 0;
185
186 IoCompleteRequest(Irp, IO_NO_INCREMENT);
187
188 return STATUS_SUCCESS;
189 }
190
191 VOID
192 NTAPI
193 ButtonWaitThread(PVOID Context)
194 {
195 PIRP Irp = Context;
196 int result;
197 struct acpi_bus_event event;
198 ULONG ButtonEvent;
199
200 while (ACPI_SUCCESS(result = acpi_bus_receive_event(&event)) &&
201 event.type != ACPI_BUTTON_NOTIFY_STATUS);
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
221 IoCompleteRequest(Irp, IO_NO_INCREMENT);
222 }
223
224
225 NTSTATUS
226 NTAPI
227 ACPIDispatchDeviceControl(
228 IN PDEVICE_OBJECT DeviceObject,
229 IN PIRP Irp)
230 {
231 PIO_STACK_LOCATION irpStack;
232 NTSTATUS status = STATUS_NOT_SUPPORTED;
233 PCOMMON_DEVICE_DATA commonData;
234 ULONG Caps = 0;
235 HANDLE ThreadHandle;
236
237 PAGED_CODE ();
238
239 irpStack = IoGetCurrentIrpStackLocation (Irp);
240 ASSERT (IRP_MJ_DEVICE_CONTROL == irpStack->MajorFunction);
241
242 commonData = (PCOMMON_DEVICE_DATA) DeviceObject->DeviceExtension;
243
244 Irp->IoStatus.Information = 0;
245
246 if (!commonData->IsFDO)
247 {
248 switch (irpStack->Parameters.DeviceIoControl.IoControlCode)
249 {
250 case IOCTL_ACPI_EVAL_METHOD:
251 status = Bus_PDO_EvalMethod((PPDO_DEVICE_DATA)commonData,
252 Irp);
253 break;
254
255 case IOCTL_GET_SYS_BUTTON_CAPS:
256 if (irpStack->Parameters.DeviceIoControl.OutputBufferLength < sizeof(ULONG))
257 {
258 status = STATUS_BUFFER_TOO_SMALL;
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");
297 status = STATUS_INVALID_PARAMETER;
298 }
299
300 if (Caps != 0)
301 {
302 RtlCopyMemory(Irp->AssociatedIrp.SystemBuffer, &Caps, sizeof(Caps));
303 Irp->IoStatus.Information = sizeof(Caps);
304 status = STATUS_SUCCESS;
305 }
306 break;
307
308 case IOCTL_GET_SYS_BUTTON_EVENT:
309 PsCreateSystemThread(&ThreadHandle, THREAD_ALL_ACCESS, 0, 0, 0, ButtonWaitThread, Irp);
310 ZwClose(ThreadHandle);
311
312 status = STATUS_PENDING;
313 break;
314
315 default:
316 DPRINT1("Unsupported IOCTL: %x\n", irpStack->Parameters.DeviceIoControl.IoControlCode);
317 break;
318 }
319 }
320 else
321 DPRINT1("IOCTL sent to the ACPI FDO! Kill the caller!\n");
322
323 if (status != STATUS_PENDING)
324 {
325 Irp->IoStatus.Status = status;
326 IoCompleteRequest(Irp, IO_NO_INCREMENT);
327 }
328 else
329 IoMarkIrpPending(Irp);
330
331 return status;
332 }
333
334 static
335 NTSTATUS
336 AcpiRegOpenKey(IN HANDLE ParentKeyHandle,
337 IN LPCWSTR KeyName,
338 IN ACCESS_MASK DesiredAccess,
339 OUT HANDLE KeyHandle)
340 {
341 OBJECT_ATTRIBUTES ObjectAttributes;
342 UNICODE_STRING Name;
343
344 RtlInitUnicodeString(&Name, KeyName);
345
346 InitializeObjectAttributes(&ObjectAttributes,
347 &Name,
348 OBJ_CASE_INSENSITIVE,
349 ParentKeyHandle,
350 NULL);
351
352 return ZwOpenKey(KeyHandle,
353 DesiredAccess,
354 &ObjectAttributes);
355 }
356
357 static
358 NTSTATUS
359 AcpiRegQueryValue(IN HANDLE KeyHandle,
360 IN LPWSTR ValueName,
361 OUT PULONG Type OPTIONAL,
362 OUT PVOID Data OPTIONAL,
363 IN OUT PULONG DataLength OPTIONAL)
364 {
365 PKEY_VALUE_PARTIAL_INFORMATION ValueInfo;
366 UNICODE_STRING Name;
367 ULONG BufferLength = 0;
368 NTSTATUS Status;
369
370 RtlInitUnicodeString(&Name, ValueName);
371
372 if (DataLength != NULL)
373 BufferLength = *DataLength;
374
375 /* Check if the caller provided a valid buffer */
376 if ((Data != NULL) && (BufferLength != 0))
377 {
378 BufferLength += FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data);
379
380 /* Allocate memory for the value */
381 ValueInfo = ExAllocatePoolWithTag(PagedPool, BufferLength, 'MpcA');
382 if (ValueInfo == NULL)
383 return STATUS_NO_MEMORY;
384 }
385 else
386 {
387 /* Caller didn't provide a valid buffer, assume he wants the size only */
388 ValueInfo = NULL;
389 BufferLength = 0;
390 }
391
392 /* Query the value */
393 Status = ZwQueryValueKey(KeyHandle,
394 &Name,
395 KeyValuePartialInformation,
396 ValueInfo,
397 BufferLength,
398 &BufferLength);
399
400 if (DataLength != NULL)
401 *DataLength = BufferLength;
402
403 /* Check if we have the size only */
404 if (ValueInfo == NULL)
405 {
406 /* Check for unexpected status */
407 if ((Status != STATUS_BUFFER_OVERFLOW) &&
408 (Status != STATUS_BUFFER_TOO_SMALL))
409 {
410 return Status;
411 }
412
413 /* All is well */
414 Status = STATUS_SUCCESS;
415 }
416 /* Otherwise the caller wanted data back, check if we got it */
417 else if (NT_SUCCESS(Status))
418 {
419 if (Type != NULL)
420 *Type = ValueInfo->Type;
421
422 /* Copy it */
423 RtlMoveMemory(Data, ValueInfo->Data, ValueInfo->DataLength);
424
425 /* if the type is REG_SZ and data is not 0-terminated
426 * and there is enough space in the buffer NT appends a \0 */
427 if (((ValueInfo->Type == REG_SZ) ||
428 (ValueInfo->Type == REG_EXPAND_SZ) ||
429 (ValueInfo->Type == REG_MULTI_SZ)) &&
430 (ValueInfo->DataLength <= *DataLength - sizeof(WCHAR)))
431 {
432 WCHAR *ptr = (WCHAR *)((ULONG_PTR)Data + ValueInfo->DataLength);
433 if ((ptr > (WCHAR *)Data) && ptr[-1])
434 *ptr = 0;
435 }
436 }
437
438 /* Free the memory and return status */
439 if (ValueInfo != NULL)
440 {
441 ExFreePoolWithTag(ValueInfo, 'MpcA');
442 }
443
444 return Status;
445 }
446
447 static
448 NTSTATUS
449 GetProcessorInformation(VOID)
450 {
451 LPWSTR ProcessorIdentifier = NULL;
452 LPWSTR ProcessorVendorIdentifier = NULL;
453 LPWSTR HardwareIdsBuffer = NULL;
454 HANDLE ProcessorHandle = NULL;
455 ULONG Length = 0, Level1Length = 0, Level2Length = 0, Level3Length = 0;
456 SIZE_T HardwareIdsLength = 0;
457 SIZE_T VendorIdentifierLength;
458 ULONG i;
459 PWCHAR Ptr;
460 NTSTATUS Status;
461
462 DPRINT("GetProcessorInformation()\n");
463
464 /* Open the key for CPU 0 */
465 Status = AcpiRegOpenKey(NULL,
466 L"\\Registry\\Machine\\Hardware\\Description\\System\\CentralProcessor\\0",
467 KEY_READ,
468 &ProcessorHandle);
469 if (!NT_SUCCESS(Status))
470 {
471 DPRINT1("Failed to open CentralProcessor registry key: 0x%lx\n", Status);
472 goto done;
473 }
474
475 /* Query the processor identifier length */
476 Status = AcpiRegQueryValue(ProcessorHandle,
477 L"Identifier",
478 NULL,
479 NULL,
480 &Length);
481 if (!NT_SUCCESS(Status))
482 {
483 DPRINT1("Failed to query Identifier value: 0x%lx\n", Status);
484 goto done;
485 }
486
487 /* Remember the length as fallback for level 1-3 length */
488 Level1Length = Level2Length = Level3Length = Length;
489
490 /* Allocate a buffer large enough to be zero terminated */
491 Length += sizeof(UNICODE_NULL);
492 ProcessorIdentifier = ExAllocatePoolWithTag(PagedPool, Length, 'IpcA');
493 if (ProcessorIdentifier == NULL)
494 {
495 DPRINT1("Failed to allocate 0x%lx bytes\n", Length);
496 Status = STATUS_INSUFFICIENT_RESOURCES;
497 goto done;
498 }
499
500 /* Query the processor identifier string */
501 Status = AcpiRegQueryValue(ProcessorHandle,
502 L"Identifier",
503 NULL,
504 ProcessorIdentifier,
505 &Length);
506 if (!NT_SUCCESS(Status))
507 {
508 DPRINT1("Failed to query Identifier value: 0x%lx\n", Status);
509 goto done;
510 }
511
512 /* Query the processor name length */
513 Length = 0;
514 Status = AcpiRegQueryValue(ProcessorHandle,
515 L"ProcessorNameString",
516 NULL,
517 NULL,
518 &Length);
519 if (!NT_SUCCESS(Status))
520 {
521 DPRINT1("Failed to query ProcessorNameString value: 0x%lx\n", Status);
522 goto done;
523 }
524
525 /* Allocate a buffer large enough to be zero terminated */
526 Length += sizeof(UNICODE_NULL);
527 ProcessorNameString = ExAllocatePoolWithTag(PagedPool, Length, 'IpcA');
528 if (ProcessorNameString == NULL)
529 {
530 DPRINT1("Failed to allocate 0x%lx bytes\n", Length);
531 Status = STATUS_INSUFFICIENT_RESOURCES;
532 goto done;
533 }
534
535 /* Query the processor name string */
536 Status = AcpiRegQueryValue(ProcessorHandle,
537 L"ProcessorNameString",
538 NULL,
539 ProcessorNameString,
540 &Length);
541 if (!NT_SUCCESS(Status))
542 {
543 DPRINT1("Failed to query ProcessorNameString value: 0x%lx\n", Status);
544 goto done;
545 }
546
547 /* Query the vendor identifier length */
548 Length = 0;
549 Status = AcpiRegQueryValue(ProcessorHandle,
550 L"VendorIdentifier",
551 NULL,
552 NULL,
553 &Length);
554 if (!NT_SUCCESS(Status) || (Length == 0))
555 {
556 DPRINT1("Failed to query VendorIdentifier value: 0x%lx\n", Status);
557 goto done;
558 }
559
560 /* Allocate a buffer large enough to be zero terminated */
561 Length += sizeof(UNICODE_NULL);
562 ProcessorVendorIdentifier = ExAllocatePoolWithTag(PagedPool, Length, 'IpcA');
563 if (ProcessorVendorIdentifier == NULL)
564 {
565 DPRINT1("Failed to allocate 0x%lx bytes\n", Length);
566 Status = STATUS_INSUFFICIENT_RESOURCES;
567 goto done;
568 }
569
570 /* Query the vendor identifier string */
571 Status = AcpiRegQueryValue(ProcessorHandle,
572 L"VendorIdentifier",
573 NULL,
574 ProcessorVendorIdentifier,
575 &Length);
576 if (!NT_SUCCESS(Status))
577 {
578 DPRINT1("Failed to query VendorIdentifier value: 0x%lx\n", Status);
579 goto done;
580 }
581
582 /* Change spaces to underscores */
583 for (i = 0; i < wcslen(ProcessorIdentifier); i++)
584 {
585 if (ProcessorIdentifier[i] == L' ')
586 ProcessorIdentifier[i] = L'_';
587 }
588
589 Ptr = wcsstr(ProcessorIdentifier, L"Stepping");
590 if (Ptr != NULL)
591 {
592 Ptr--;
593 Level1Length = (ULONG)(Ptr - ProcessorIdentifier);
594 }
595
596 Ptr = wcsstr(ProcessorIdentifier, L"Model");
597 if (Ptr != NULL)
598 {
599 Ptr--;
600 Level2Length = (ULONG)(Ptr - ProcessorIdentifier);
601 }
602
603 Ptr = wcsstr(ProcessorIdentifier, L"Family");
604 if (Ptr != NULL)
605 {
606 Ptr--;
607 Level3Length = (ULONG)(Ptr - ProcessorIdentifier);
608 }
609
610 VendorIdentifierLength = (USHORT)wcslen(ProcessorVendorIdentifier);
611
612 /* Calculate the size of the full REG_MULTI_SZ data (see swprintf below) */
613 HardwareIdsLength = (5 + VendorIdentifierLength + 3 + Level1Length + 1 +
614 1 + VendorIdentifierLength + 3 + Level1Length + 1 +
615 5 + VendorIdentifierLength + 3 + Level2Length + 1 +
616 1 + VendorIdentifierLength + 3 + Level2Length + 1 +
617 5 + VendorIdentifierLength + 3 + Level3Length + 1 +
618 1 + VendorIdentifierLength + 3 + Level3Length + 1 +
619 1) * sizeof(WCHAR);
620
621 /* Allocate a buffer to the data */
622 HardwareIdsBuffer = ExAllocatePoolWithTag(PagedPool, HardwareIdsLength, 'IpcA');
623 if (HardwareIdsBuffer == NULL)
624 {
625 Status = STATUS_INSUFFICIENT_RESOURCES;
626 goto done;
627 }
628
629 Length = 0;
630 Length += swprintf(&HardwareIdsBuffer[Length], L"ACPI\\%s_-_%.*s", ProcessorVendorIdentifier, Level1Length, ProcessorIdentifier);
631 HardwareIdsBuffer[Length++] = UNICODE_NULL;
632
633 Length += swprintf(&HardwareIdsBuffer[Length], L"*%s_-_%.*s", ProcessorVendorIdentifier, Level1Length, ProcessorIdentifier);
634 HardwareIdsBuffer[Length++] = UNICODE_NULL;
635
636 Length += swprintf(&HardwareIdsBuffer[Length], L"ACPI\\%s_-_%.*s", ProcessorVendorIdentifier, Level2Length, ProcessorIdentifier);
637 HardwareIdsBuffer[Length++] = UNICODE_NULL;
638
639 Length += swprintf(&HardwareIdsBuffer[Length], L"*%s_-_%.*s", ProcessorVendorIdentifier, Level2Length, ProcessorIdentifier);
640 HardwareIdsBuffer[Length++] = UNICODE_NULL;
641
642 Length += swprintf(&HardwareIdsBuffer[Length], L"ACPI\\%s_-_%.*s", ProcessorVendorIdentifier, Level3Length, ProcessorIdentifier);
643 HardwareIdsBuffer[Length++] = UNICODE_NULL;
644
645 Length += swprintf(&HardwareIdsBuffer[Length], L"*%s_-_%.*s", ProcessorVendorIdentifier, Level3Length, ProcessorIdentifier);
646 HardwareIdsBuffer[Length++] = UNICODE_NULL;
647 HardwareIdsBuffer[Length++] = UNICODE_NULL;
648
649 /* Make sure we counted correctly */
650 NT_ASSERT(Length * sizeof(WCHAR) == HardwareIdsLength);
651
652 ProcessorHardwareIds.Length = (SHORT)HardwareIdsLength;
653 ProcessorHardwareIds.MaximumLength = ProcessorHardwareIds.Length;
654 ProcessorHardwareIds.Buffer = HardwareIdsBuffer;
655
656 Length = (5 + VendorIdentifierLength + 3 + Level1Length + 1) * sizeof(WCHAR);
657 ProcessorIdString = ExAllocatePoolWithTag(PagedPool, Length, 'IpcA');
658 if (ProcessorIdString != NULL)
659 {
660 Length = swprintf(ProcessorIdString, L"ACPI\\%s_-_%.*s", ProcessorVendorIdentifier, Level1Length, ProcessorIdentifier);
661 ProcessorIdString[Length++] = UNICODE_NULL;
662 DPRINT("ProcessorIdString: %S\n", ProcessorIdString);
663 }
664
665 done:
666 if (ProcessorHandle != NULL)
667 ZwClose(ProcessorHandle);
668
669 if (ProcessorIdentifier != NULL)
670 ExFreePoolWithTag(ProcessorIdentifier, 'IpcA');
671
672 if (ProcessorVendorIdentifier != NULL)
673 ExFreePoolWithTag(ProcessorVendorIdentifier, 'IpcA');
674
675 if (!NT_SUCCESS(Status))
676 {
677 if (HardwareIdsBuffer != NULL)
678 ExFreePoolWithTag(HardwareIdsBuffer, 'IpcA');
679 }
680
681 return Status;
682 }
683
684 NTSTATUS
685 NTAPI
686 DriverEntry (
687 PDRIVER_OBJECT DriverObject,
688 PUNICODE_STRING RegistryPath
689 )
690 {
691 NTSTATUS Status;
692 DPRINT("Driver Entry \n");
693
694 Status = GetProcessorInformation();
695 if (!NT_SUCCESS(Status))
696 {
697 NT_ASSERT(FALSE);
698 return Status;
699 }
700
701 //
702 // Set entry points into the driver
703 //
704 DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = ACPIDispatchDeviceControl;
705 DriverObject->MajorFunction [IRP_MJ_PNP] = Bus_PnP;
706 DriverObject->MajorFunction [IRP_MJ_POWER] = Bus_Power;
707 DriverObject->MajorFunction [IRP_MJ_CREATE] = ACPIDispatchCreateClose;
708 DriverObject->MajorFunction [IRP_MJ_CLOSE] = ACPIDispatchCreateClose;
709
710 DriverObject->DriverExtension->AddDevice = Bus_AddDevice;
711
712 return STATUS_SUCCESS;
713 }