2dee988b3476554111bfeba4f95c5cda607c2a24
[reactos.git] / ntoskrnl / po / power.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: ntoskrnl/po/power.c
5 * PURPOSE: Power Manager
6 * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
7 * Hervé Poussineau (hpoussin@reactos.com)
8 */
9
10 /* INCLUDES ******************************************************************/
11
12 #include <ntoskrnl.h>
13 #define NDEBUG
14 #include <debug.h>
15
16 /* GLOBALS *******************************************************************/
17
18 typedef struct _POWER_STATE_TRAVERSE_CONTEXT
19 {
20 SYSTEM_POWER_STATE SystemPowerState;
21 POWER_ACTION PowerAction;
22 PDEVICE_OBJECT PowerDevice;
23 } POWER_STATE_TRAVERSE_CONTEXT, *PPOWER_STATE_TRAVERSE_CONTEXT;
24
25 PDEVICE_NODE PopSystemPowerDeviceNode = NULL;
26 BOOLEAN PopAcpiPresent = FALSE;
27 POP_POWER_ACTION PopAction;
28 WORK_QUEUE_ITEM PopShutdownWorkItem;
29
30 /* PRIVATE FUNCTIONS *********************************************************/
31
32 static
33 NTSTATUS
34 NTAPI
35 PopRequestPowerIrpCompletion(IN PDEVICE_OBJECT DeviceObject,
36 IN PIRP Irp,
37 IN PVOID Context)
38 {
39 PIO_STACK_LOCATION Stack;
40 PREQUEST_POWER_COMPLETE CompletionRoutine;
41 POWER_STATE PowerState;
42
43 Stack = IoGetCurrentIrpStackLocation(Irp);
44 CompletionRoutine = Context;
45
46 PowerState.DeviceState = (ULONG_PTR)Stack->Parameters.Others.Argument3;
47 CompletionRoutine(Stack->Parameters.Others.Argument1,
48 (UCHAR)(ULONG_PTR)Stack->Parameters.Others.Argument2,
49 PowerState,
50 Stack->Parameters.Others.Argument4,
51 &Irp->IoStatus);
52
53 IoSkipCurrentIrpStackLocation(Irp);
54 IoFreeIrp(Irp);
55 ObDereferenceObject(DeviceObject);
56
57 return STATUS_MORE_PROCESSING_REQUIRED;
58 }
59
60 VOID
61 NTAPI
62 PopCleanupPowerState(IN PPOWER_STATE PowerState)
63 {
64 //UNIMPLEMENTED;
65 }
66
67 NTSTATUS
68 PopSendQuerySystemPowerState(PDEVICE_OBJECT DeviceObject, SYSTEM_POWER_STATE SystemState, POWER_ACTION PowerAction)
69 {
70 KEVENT Event;
71 IO_STATUS_BLOCK IoStatusBlock;
72 PIO_STACK_LOCATION IrpSp;
73 PIRP Irp;
74 NTSTATUS Status;
75
76 KeInitializeEvent(&Event,
77 NotificationEvent,
78 FALSE);
79
80 Irp = IoBuildSynchronousFsdRequest(IRP_MJ_POWER,
81 DeviceObject,
82 NULL,
83 0,
84 NULL,
85 &Event,
86 &IoStatusBlock);
87 if (!Irp) return STATUS_INSUFFICIENT_RESOURCES;
88
89 IrpSp = IoGetNextIrpStackLocation(Irp);
90 IrpSp->MinorFunction = IRP_MN_QUERY_POWER;
91 IrpSp->Parameters.Power.Type = SystemPowerState;
92 IrpSp->Parameters.Power.State.SystemState = SystemState;
93 IrpSp->Parameters.Power.ShutdownType = PowerAction;
94
95 Status = PoCallDriver(DeviceObject, Irp);
96 if (Status == STATUS_PENDING)
97 {
98 KeWaitForSingleObject(&Event,
99 Executive,
100 KernelMode,
101 FALSE,
102 NULL);
103 Status = IoStatusBlock.Status;
104 }
105
106 return Status;
107 }
108
109 NTSTATUS
110 PopSendSetSystemPowerState(PDEVICE_OBJECT DeviceObject, SYSTEM_POWER_STATE SystemState, POWER_ACTION PowerAction)
111 {
112 KEVENT Event;
113 IO_STATUS_BLOCK IoStatusBlock;
114 PIO_STACK_LOCATION IrpSp;
115 PIRP Irp;
116 NTSTATUS Status;
117
118 KeInitializeEvent(&Event,
119 NotificationEvent,
120 FALSE);
121
122 Irp = IoBuildSynchronousFsdRequest(IRP_MJ_POWER,
123 DeviceObject,
124 NULL,
125 0,
126 NULL,
127 &Event,
128 &IoStatusBlock);
129 if (!Irp) return STATUS_INSUFFICIENT_RESOURCES;
130
131 IrpSp = IoGetNextIrpStackLocation(Irp);
132 IrpSp->MinorFunction = IRP_MN_SET_POWER;
133 IrpSp->Parameters.Power.Type = SystemPowerState;
134 IrpSp->Parameters.Power.State.SystemState = SystemState;
135 IrpSp->Parameters.Power.ShutdownType = PowerAction;
136
137 Status = PoCallDriver(DeviceObject, Irp);
138 if (Status == STATUS_PENDING)
139 {
140 KeWaitForSingleObject(&Event,
141 Executive,
142 KernelMode,
143 FALSE,
144 NULL);
145 Status = IoStatusBlock.Status;
146 }
147
148 return Status;
149 }
150
151 NTSTATUS
152 PopQuerySystemPowerStateTraverse(PDEVICE_NODE DeviceNode,
153 PVOID Context)
154 {
155 PPOWER_STATE_TRAVERSE_CONTEXT PowerStateContext = Context;
156 PDEVICE_OBJECT TopDeviceObject;
157 NTSTATUS Status;
158
159 DPRINT("PopQuerySystemPowerStateTraverse(%p, %p)\n", DeviceNode, Context);
160
161 if (DeviceNode == IopRootDeviceNode)
162 return STATUS_SUCCESS;
163
164 if (DeviceNode->Flags & DNF_LEGACY_DRIVER)
165 return STATUS_SUCCESS;
166
167 TopDeviceObject = IoGetAttachedDeviceReference(DeviceNode->PhysicalDeviceObject);
168
169 Status = PopSendQuerySystemPowerState(TopDeviceObject,
170 PowerStateContext->SystemPowerState,
171 PowerStateContext->PowerAction);
172 if (!NT_SUCCESS(Status))
173 {
174 DPRINT1("Device '%wZ' failed IRP_MN_QUERY_POWER\n", &DeviceNode->InstancePath);
175 }
176 ObDereferenceObject(TopDeviceObject);
177
178 #if 0
179 return Status;
180 #else
181 return STATUS_SUCCESS;
182 #endif
183 }
184
185 NTSTATUS
186 PopSetSystemPowerStateTraverse(PDEVICE_NODE DeviceNode,
187 PVOID Context)
188 {
189 PPOWER_STATE_TRAVERSE_CONTEXT PowerStateContext = Context;
190 PDEVICE_OBJECT TopDeviceObject;
191 NTSTATUS Status;
192
193 DPRINT("PopSetSystemPowerStateTraverse(%p, %p)\n", DeviceNode, Context);
194
195 if (DeviceNode == IopRootDeviceNode)
196 return STATUS_SUCCESS;
197
198 if (DeviceNode->PhysicalDeviceObject == PowerStateContext->PowerDevice)
199 return STATUS_SUCCESS;
200
201 if (DeviceNode->Flags & DNF_LEGACY_DRIVER)
202 return STATUS_SUCCESS;
203
204 TopDeviceObject = IoGetAttachedDeviceReference(DeviceNode->PhysicalDeviceObject);
205 if (TopDeviceObject == PowerStateContext->PowerDevice)
206 {
207 ObDereferenceObject(TopDeviceObject);
208 return STATUS_SUCCESS;
209 }
210
211 Status = PopSendSetSystemPowerState(TopDeviceObject,
212 PowerStateContext->SystemPowerState,
213 PowerStateContext->PowerAction);
214 if (!NT_SUCCESS(Status))
215 {
216 DPRINT1("Device '%wZ' failed IRP_MN_SET_POWER\n", &DeviceNode->InstancePath);
217 }
218
219 ObDereferenceObject(TopDeviceObject);
220
221 #if 0
222 return Status;
223 #else
224 return STATUS_SUCCESS;
225 #endif
226 }
227
228 NTSTATUS
229 NTAPI
230 PopSetSystemPowerState(SYSTEM_POWER_STATE PowerState, POWER_ACTION PowerAction)
231 {
232 PDEVICE_OBJECT DeviceObject;
233 PDEVICE_OBJECT Fdo;
234 NTSTATUS Status;
235 DEVICETREE_TRAVERSE_CONTEXT Context;
236 POWER_STATE_TRAVERSE_CONTEXT PowerContext;
237
238 Status = IopGetSystemPowerDeviceObject(&DeviceObject);
239 if (!NT_SUCCESS(Status))
240 {
241 DPRINT1("No system power driver available\n");
242 Fdo = NULL;
243 }
244 else
245 {
246 Fdo = IoGetAttachedDeviceReference(DeviceObject);
247 if (Fdo == DeviceObject)
248 {
249 DPRINT("An FDO was not attached\n");
250 return STATUS_UNSUCCESSFUL;
251 }
252 }
253
254 /* Set up context */
255 PowerContext.PowerAction = PowerAction;
256 PowerContext.SystemPowerState = PowerState;
257 PowerContext.PowerDevice = Fdo;
258
259 /* Query for system power change */
260 IopInitDeviceTreeTraverseContext(&Context,
261 IopRootDeviceNode,
262 PopQuerySystemPowerStateTraverse,
263 &PowerContext);
264
265 Status = IopTraverseDeviceTree(&Context);
266 if (!NT_SUCCESS(Status))
267 {
268 DPRINT1("Query system power state failed; changing state anyway\n");
269 }
270
271 /* Set system power change */
272 IopInitDeviceTreeTraverseContext(&Context,
273 IopRootDeviceNode,
274 PopSetSystemPowerStateTraverse,
275 &PowerContext);
276
277 IopTraverseDeviceTree(&Context);
278
279 if (!PopAcpiPresent) return STATUS_NOT_IMPLEMENTED;
280
281 if (Fdo != NULL)
282 {
283 if (PowerAction != PowerActionShutdownReset)
284 PopSendSetSystemPowerState(Fdo, PowerState, PowerAction);
285
286 ObDereferenceObject(Fdo);
287 }
288
289 return Status;
290 }
291
292 BOOLEAN
293 NTAPI
294 INIT_FUNCTION
295 PoInitSystem(IN ULONG BootPhase)
296 {
297 PVOID NotificationEntry;
298 PCHAR CommandLine;
299 BOOLEAN ForceAcpiDisable = FALSE;
300
301 /* Check if this is phase 1 init */
302 if (BootPhase == 1)
303 {
304 /* Register power button notification */
305 IoRegisterPlugPlayNotification(EventCategoryDeviceInterfaceChange,
306 PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES,
307 (PVOID)&GUID_DEVICE_SYS_BUTTON,
308 IopRootDeviceNode->
309 PhysicalDeviceObject->DriverObject,
310 PopAddRemoveSysCapsCallback,
311 NULL,
312 &NotificationEntry);
313
314 /* Register lid notification */
315 IoRegisterPlugPlayNotification(EventCategoryDeviceInterfaceChange,
316 PNPNOTIFY_DEVICE_INTERFACE_INCLUDE_EXISTING_INTERFACES,
317 (PVOID)&GUID_DEVICE_LID,
318 IopRootDeviceNode->
319 PhysicalDeviceObject->DriverObject,
320 PopAddRemoveSysCapsCallback,
321 NULL,
322 &NotificationEntry);
323 return TRUE;
324 }
325
326 /* Get the Command Line */
327 CommandLine = KeLoaderBlock->LoadOptions;
328
329 /* Upcase it */
330 _strupr(CommandLine);
331
332 /* Check for ACPI disable */
333 if (strstr(CommandLine, "NOACPI")) ForceAcpiDisable = TRUE;
334
335 if (ForceAcpiDisable)
336 {
337 /* Set the ACPI State to False if it's been forced that way */
338 PopAcpiPresent = FALSE;
339 }
340 else
341 {
342 /* Otherwise check if the LoaderBlock has a ACPI Table */
343 PopAcpiPresent = KeLoaderBlock->Extension->AcpiTable != NULL ? TRUE : FALSE;
344 }
345
346
347 /* Initialize volume support */
348 InitializeListHead(&PopVolumeDevices);
349 KeInitializeGuardedMutex(&PopVolumeLock);
350
351 /* Initialize support for dope */
352 KeInitializeSpinLock(&PopDopeGlobalLock);
353
354 /* Initialize support for shutdown waits and work-items */
355 PopInitShutdownList();
356
357 return TRUE;
358 }
359
360 VOID
361 NTAPI
362 PopPerfIdle(PPROCESSOR_POWER_STATE PowerState)
363 {
364 DPRINT1("PerfIdle function: %p\n", PowerState);
365 }
366
367 VOID
368 NTAPI
369 PopPerfIdleDpc(IN PKDPC Dpc,
370 IN PVOID DeferredContext,
371 IN PVOID SystemArgument1,
372 IN PVOID SystemArgument2)
373 {
374 /* Call the Perf Idle function */
375 PopPerfIdle(&((PKPRCB)DeferredContext)->PowerState);
376 }
377
378 VOID
379 FASTCALL
380 PopIdle0(IN PPROCESSOR_POWER_STATE PowerState)
381 {
382 /* FIXME: Extremly naive implementation */
383 HalProcessorIdle();
384 }
385
386 VOID
387 NTAPI
388 INIT_FUNCTION
389 PoInitializePrcb(IN PKPRCB Prcb)
390 {
391 /* Initialize the Power State */
392 RtlZeroMemory(&Prcb->PowerState, sizeof(Prcb->PowerState));
393 Prcb->PowerState.Idle0KernelTimeLimit = 0xFFFFFFFF;
394 Prcb->PowerState.CurrentThrottle = 100;
395 Prcb->PowerState.CurrentThrottleIndex = 0;
396 Prcb->PowerState.IdleFunction = PopIdle0;
397
398 /* Initialize the Perf DPC and Timer */
399 KeInitializeDpc(&Prcb->PowerState.PerfDpc, PopPerfIdleDpc, Prcb);
400 KeSetTargetProcessorDpc(&Prcb->PowerState.PerfDpc, Prcb->Number);
401 KeInitializeTimerEx(&Prcb->PowerState.PerfTimer, SynchronizationTimer);
402 }
403
404 /* PUBLIC FUNCTIONS **********************************************************/
405
406 /*
407 * @unimplemented
408 */
409 NTSTATUS
410 NTAPI
411 PoCancelDeviceNotify(IN PVOID NotifyBlock)
412 {
413 UNIMPLEMENTED;
414 return STATUS_NOT_IMPLEMENTED;
415 }
416
417 /*
418 * @unimplemented
419 */
420 NTSTATUS
421 NTAPI
422 PoRegisterDeviceNotify(OUT PVOID Unknown0,
423 IN ULONG Unknown1,
424 IN ULONG Unknown2,
425 IN ULONG Unknown3,
426 IN PVOID Unknown4,
427 IN PVOID Unknown5)
428 {
429 UNIMPLEMENTED;
430 return STATUS_NOT_IMPLEMENTED;
431 }
432
433 /*
434 * @unimplemented
435 */
436 VOID
437 NTAPI
438 PoShutdownBugCheck(IN BOOLEAN LogError,
439 IN ULONG BugCheckCode,
440 IN ULONG_PTR BugCheckParameter1,
441 IN ULONG_PTR BugCheckParameter2,
442 IN ULONG_PTR BugCheckParameter3,
443 IN ULONG_PTR BugCheckParameter4)
444 {
445 DPRINT1("PoShutdownBugCheck called\n");
446
447 /* FIXME: Log error if requested */
448 /* FIXME: Initiate a shutdown */
449
450 /* Bugcheck the system */
451 KeBugCheckEx(BugCheckCode,
452 BugCheckParameter1,
453 BugCheckParameter2,
454 BugCheckParameter3,
455 BugCheckParameter4);
456 }
457
458 /*
459 * @unimplemented
460 */
461 VOID
462 NTAPI
463 PoSetHiberRange(IN PVOID HiberContext,
464 IN ULONG Flags,
465 IN OUT PVOID StartPage,
466 IN ULONG Length,
467 IN ULONG PageTag)
468 {
469 UNIMPLEMENTED;
470 return;
471 }
472
473 /*
474 * @implemented
475 */
476 NTSTATUS
477 NTAPI
478 PoCallDriver(IN PDEVICE_OBJECT DeviceObject,
479 IN OUT PIRP Irp)
480 {
481 NTSTATUS Status;
482
483 /* Forward to Io -- FIXME! */
484 Status = IoCallDriver(DeviceObject, Irp);
485
486 /* Return status */
487 return Status;
488 }
489
490 /*
491 * @unimplemented
492 */
493 PULONG
494 NTAPI
495 PoRegisterDeviceForIdleDetection(IN PDEVICE_OBJECT DeviceObject,
496 IN ULONG ConservationIdleTime,
497 IN ULONG PerformanceIdleTime,
498 IN DEVICE_POWER_STATE State)
499 {
500 UNIMPLEMENTED;
501 return NULL;
502 }
503
504 /*
505 * @unimplemented
506 */
507 PVOID
508 NTAPI
509 PoRegisterSystemState(IN PVOID StateHandle,
510 IN EXECUTION_STATE Flags)
511 {
512 UNIMPLEMENTED;
513 return NULL;
514 }
515
516 /*
517 * @implemented
518 */
519 NTSTATUS
520 NTAPI
521 PoRequestPowerIrp(IN PDEVICE_OBJECT DeviceObject,
522 IN UCHAR MinorFunction,
523 IN POWER_STATE PowerState,
524 IN PREQUEST_POWER_COMPLETE CompletionFunction,
525 IN PVOID Context,
526 OUT PIRP *pIrp OPTIONAL)
527 {
528 PDEVICE_OBJECT TopDeviceObject;
529 PIO_STACK_LOCATION Stack;
530 PIRP Irp;
531
532 if (MinorFunction != IRP_MN_QUERY_POWER
533 && MinorFunction != IRP_MN_SET_POWER
534 && MinorFunction != IRP_MN_WAIT_WAKE)
535 return STATUS_INVALID_PARAMETER_2;
536
537 /* Always call the top of the device stack */
538 TopDeviceObject = IoGetAttachedDeviceReference(DeviceObject);
539
540 Irp = IoAllocateIrp(TopDeviceObject->StackSize + 2, FALSE);
541 if (!Irp)
542 {
543 ObDereferenceObject(TopDeviceObject);
544 return STATUS_INSUFFICIENT_RESOURCES;
545 }
546
547 Irp->IoStatus.Status = STATUS_NOT_SUPPORTED;
548 Irp->IoStatus.Information = 0;
549
550 IoSetNextIrpStackLocation(Irp);
551
552 Stack = IoGetNextIrpStackLocation(Irp);
553 Stack->Parameters.Others.Argument1 = DeviceObject;
554 Stack->Parameters.Others.Argument2 = (PVOID)(ULONG_PTR)MinorFunction;
555 Stack->Parameters.Others.Argument3 = (PVOID)(ULONG_PTR)PowerState.DeviceState;
556 Stack->Parameters.Others.Argument4 = Context;
557 Stack->DeviceObject = TopDeviceObject;
558 IoSetNextIrpStackLocation(Irp);
559
560 Stack = IoGetNextIrpStackLocation(Irp);
561 Stack->MajorFunction = IRP_MJ_POWER;
562 Stack->MinorFunction = MinorFunction;
563 if (MinorFunction == IRP_MN_WAIT_WAKE)
564 {
565 Stack->Parameters.WaitWake.PowerState = PowerState.SystemState;
566 }
567 else
568 {
569 Stack->Parameters.Power.Type = DevicePowerState;
570 Stack->Parameters.Power.State = PowerState;
571 }
572
573 if (pIrp != NULL)
574 *pIrp = Irp;
575
576 IoSetCompletionRoutine(Irp, PopRequestPowerIrpCompletion, CompletionFunction, TRUE, TRUE, TRUE);
577 PoCallDriver(TopDeviceObject, Irp);
578
579 /* Always return STATUS_PENDING. The completion routine
580 * will call CompletionFunction and complete the Irp.
581 */
582 return STATUS_PENDING;
583 }
584
585 /*
586 * @unimplemented
587 */
588 POWER_STATE
589 NTAPI
590 PoSetPowerState(IN PDEVICE_OBJECT DeviceObject,
591 IN POWER_STATE_TYPE Type,
592 IN POWER_STATE State)
593 {
594 POWER_STATE ps;
595
596 ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
597
598 ps.SystemState = PowerSystemWorking; // Fully on
599 ps.DeviceState = PowerDeviceD0; // Fully on
600
601 return ps;
602 }
603
604 /*
605 * @unimplemented
606 */
607 VOID
608 NTAPI
609 PoSetSystemState(IN EXECUTION_STATE Flags)
610 {
611 UNIMPLEMENTED;
612 }
613
614 /*
615 * @unimplemented
616 */
617 VOID
618 NTAPI
619 PoStartNextPowerIrp(IN PIRP Irp)
620 {
621 UNIMPLEMENTED;
622 }
623
624 /*
625 * @unimplemented
626 */
627 VOID
628 NTAPI
629 PoUnregisterSystemState(IN PVOID StateHandle)
630 {
631 UNIMPLEMENTED;
632 }
633
634 /*
635 * @unimplemented
636 */
637 NTSTATUS
638 NTAPI
639 NtInitiatePowerAction(IN POWER_ACTION SystemAction,
640 IN SYSTEM_POWER_STATE MinSystemState,
641 IN ULONG Flags,
642 IN BOOLEAN Asynchronous)
643 {
644 UNIMPLEMENTED;
645 return STATUS_NOT_IMPLEMENTED;
646 }
647
648 /*
649 * @unimplemented
650 */
651 NTSTATUS
652 NTAPI
653 NtPowerInformation(IN POWER_INFORMATION_LEVEL PowerInformationLevel,
654 IN PVOID InputBuffer OPTIONAL,
655 IN ULONG InputBufferLength,
656 OUT PVOID OutputBuffer OPTIONAL,
657 IN ULONG OutputBufferLength)
658 {
659 NTSTATUS Status;
660 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
661
662 PAGED_CODE();
663
664 DPRINT("NtPowerInformation(PowerInformationLevel 0x%x, InputBuffer 0x%p, "
665 "InputBufferLength 0x%x, OutputBuffer 0x%p, OutputBufferLength 0x%x)\n",
666 PowerInformationLevel,
667 InputBuffer, InputBufferLength,
668 OutputBuffer, OutputBufferLength);
669
670 if (PreviousMode != KernelMode)
671 {
672 _SEH2_TRY
673 {
674 ProbeForRead(InputBuffer, InputBufferLength, 1);
675 ProbeForWrite(OutputBuffer, OutputBufferLength, sizeof(ULONG));
676 }
677 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
678 {
679 _SEH2_YIELD(return _SEH2_GetExceptionCode());
680 }
681 _SEH2_END;
682 }
683
684 switch (PowerInformationLevel)
685 {
686 case SystemBatteryState:
687 {
688 PSYSTEM_BATTERY_STATE BatteryState = (PSYSTEM_BATTERY_STATE)OutputBuffer;
689
690 if (InputBuffer != NULL)
691 return STATUS_INVALID_PARAMETER;
692 if (OutputBufferLength < sizeof(SYSTEM_BATTERY_STATE))
693 return STATUS_BUFFER_TOO_SMALL;
694
695 _SEH2_TRY
696 {
697 /* Just zero the struct (and thus set BatteryState->BatteryPresent = FALSE) */
698 RtlZeroMemory(BatteryState, sizeof(SYSTEM_BATTERY_STATE));
699 BatteryState->EstimatedTime = MAXULONG;
700
701 Status = STATUS_SUCCESS;
702 }
703 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
704 {
705 Status = _SEH2_GetExceptionCode();
706 }
707 _SEH2_END;
708
709 break;
710 }
711
712 case SystemPowerCapabilities:
713 {
714 PSYSTEM_POWER_CAPABILITIES PowerCapabilities = (PSYSTEM_POWER_CAPABILITIES)OutputBuffer;
715
716 if (InputBuffer != NULL)
717 return STATUS_INVALID_PARAMETER;
718 if (OutputBufferLength < sizeof(SYSTEM_POWER_CAPABILITIES))
719 return STATUS_BUFFER_TOO_SMALL;
720
721 _SEH2_TRY
722 {
723 /* Just zero the struct (and thus set PowerCapabilities->SystemBatteriesPresent = FALSE) */
724 RtlZeroMemory(PowerCapabilities, sizeof(SYSTEM_POWER_CAPABILITIES));
725 //PowerCapabilities->SystemBatteriesPresent = 0;
726
727 Status = STATUS_SUCCESS;
728 }
729 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
730 {
731 Status = _SEH2_GetExceptionCode();
732 }
733 _SEH2_END;
734
735 break;
736 }
737
738 case ProcessorInformation:
739 {
740 PPROCESSOR_POWER_INFORMATION PowerInformation = (PPROCESSOR_POWER_INFORMATION)OutputBuffer;
741
742 if (InputBuffer != NULL)
743 return STATUS_INVALID_PARAMETER;
744 if (OutputBufferLength < sizeof(PROCESSOR_POWER_INFORMATION))
745 return STATUS_BUFFER_TOO_SMALL;
746
747 _SEH2_TRY
748 {
749 PowerInformation->Number = 0;
750 PowerInformation->MaxMhz = 1000;
751 PowerInformation->CurrentMhz = 1000;
752 PowerInformation->MhzLimit = 1000;
753 PowerInformation->MaxIdleState = 0;
754 PowerInformation->CurrentIdleState = 0;
755
756 Status = STATUS_SUCCESS;
757 }
758 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
759 {
760 Status = _SEH2_GetExceptionCode();
761 }
762 _SEH2_END;
763
764 break;
765 }
766
767 default:
768 Status = STATUS_NOT_IMPLEMENTED;
769 DPRINT1("PowerInformationLevel 0x%x is UNIMPLEMENTED! Have a nice day.\n",
770 PowerInformationLevel);
771 break;
772 }
773
774 return Status;
775 }
776
777 NTSTATUS
778 NTAPI
779 NtGetDevicePowerState(IN HANDLE Device,
780 IN PDEVICE_POWER_STATE PowerState)
781 {
782 UNIMPLEMENTED;
783 return STATUS_NOT_IMPLEMENTED;
784 }
785
786 BOOLEAN
787 NTAPI
788 NtIsSystemResumeAutomatic(VOID)
789 {
790 UNIMPLEMENTED;
791 return FALSE;
792 }
793
794 NTSTATUS
795 NTAPI
796 NtRequestWakeupLatency(IN LATENCY_TIME Latency)
797 {
798 UNIMPLEMENTED;
799 return STATUS_NOT_IMPLEMENTED;
800 }
801
802 NTSTATUS
803 NTAPI
804 NtSetThreadExecutionState(IN EXECUTION_STATE esFlags,
805 OUT EXECUTION_STATE *PreviousFlags)
806 {
807 PKTHREAD Thread = KeGetCurrentThread();
808 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
809 EXECUTION_STATE PreviousState;
810 PAGED_CODE();
811
812 /* Validate flags */
813 if (esFlags & ~(ES_CONTINUOUS | ES_USER_PRESENT))
814 {
815 /* Fail the request */
816 return STATUS_INVALID_PARAMETER;
817 }
818
819 /* Check for user parameters */
820 if (PreviousMode != KernelMode)
821 {
822 /* Protect the probes */
823 _SEH2_TRY
824 {
825 /* Check if the pointer is valid */
826 ProbeForWriteUlong(PreviousFlags);
827 }
828 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
829 {
830 /* It isn't -- fail */
831 _SEH2_YIELD(return _SEH2_GetExceptionCode());
832 }
833 _SEH2_END;
834 }
835
836 /* Save the previous state, always masking in the continous flag */
837 PreviousState = Thread->PowerState | ES_CONTINUOUS;
838
839 /* Check if we need to update the power state */
840 if (esFlags & ES_CONTINUOUS) Thread->PowerState = (UCHAR)esFlags;
841
842 /* Protect the write back to user mode */
843 _SEH2_TRY
844 {
845 /* Return the previous flags */
846 *PreviousFlags = PreviousState;
847 }
848 _SEH2_EXCEPT(ExSystemExceptionFilter())
849 {
850 /* Something's wrong, fail */
851 _SEH2_YIELD(return _SEH2_GetExceptionCode());
852 }
853 _SEH2_END;
854
855 /* All is good */
856 return STATUS_SUCCESS;
857 }
858
859 NTSTATUS
860 NTAPI
861 NtSetSystemPowerState(IN POWER_ACTION SystemAction,
862 IN SYSTEM_POWER_STATE MinSystemState,
863 IN ULONG Flags)
864 {
865 KPROCESSOR_MODE PreviousMode = KeGetPreviousMode();
866 POP_POWER_ACTION Action = {0};
867 NTSTATUS Status;
868 ULONG Dummy;
869
870 /* Check for invalid parameter combinations */
871 if ((MinSystemState >= PowerSystemMaximum) ||
872 (MinSystemState <= PowerSystemUnspecified) ||
873 (SystemAction > PowerActionWarmEject) ||
874 (SystemAction < PowerActionReserved) ||
875 (Flags & ~(POWER_ACTION_QUERY_ALLOWED |
876 POWER_ACTION_UI_ALLOWED |
877 POWER_ACTION_OVERRIDE_APPS |
878 POWER_ACTION_LIGHTEST_FIRST |
879 POWER_ACTION_LOCK_CONSOLE |
880 POWER_ACTION_DISABLE_WAKES |
881 POWER_ACTION_CRITICAL)))
882 {
883 DPRINT1("NtSetSystemPowerState: Bad parameters!\n");
884 DPRINT1(" SystemAction: 0x%x\n", SystemAction);
885 DPRINT1(" MinSystemState: 0x%x\n", MinSystemState);
886 DPRINT1(" Flags: 0x%x\n", Flags);
887 return STATUS_INVALID_PARAMETER;
888 }
889
890 /* Check for user caller */
891 if (PreviousMode != KernelMode)
892 {
893 /* Check for shutdown permission */
894 if (!SeSinglePrivilegeCheck(SeShutdownPrivilege, PreviousMode))
895 {
896 /* Not granted */
897 DPRINT1("ERROR: Privilege not held for shutdown\n");
898 return STATUS_PRIVILEGE_NOT_HELD;
899 }
900
901 /* Do it as a kernel-mode caller for consistency with system state */
902 return ZwSetSystemPowerState(SystemAction, MinSystemState, Flags);
903 }
904
905 /* Read policy settings (partial shutdown vs. full shutdown) */
906 if (SystemAction == PowerActionShutdown) PopReadShutdownPolicy();
907
908 /* Disable lazy flushing of registry */
909 DPRINT("Stopping lazy flush\n");
910 CmSetLazyFlushState(FALSE);
911
912 /* Setup the power action */
913 Action.Action = SystemAction;
914 Action.Flags = Flags;
915
916 /* Notify callbacks */
917 DPRINT("Notifying callbacks\n");
918 ExNotifyCallback(PowerStateCallback, (PVOID)3, NULL);
919
920 /* Swap in any worker thread stacks */
921 DPRINT("Swapping worker threads\n");
922 ExSwapinWorkerThreads(FALSE);
923
924 /* Make our action global */
925 PopAction = Action;
926
927 /* Start power loop */
928 Status = STATUS_CANCELLED;
929 while (TRUE)
930 {
931 /* Break out if there's nothing to do */
932 if (Action.Action == PowerActionNone) break;
933
934 /* Check for first-pass or restart */
935 if (Status == STATUS_CANCELLED)
936 {
937 /* Check for shutdown action */
938 if ((PopAction.Action == PowerActionShutdown) ||
939 (PopAction.Action == PowerActionShutdownReset) ||
940 (PopAction.Action == PowerActionShutdownOff))
941 {
942 /* Set the action */
943 PopAction.Shutdown = TRUE;
944 }
945
946 /* Now we are good to go */
947 Status = STATUS_SUCCESS;
948 }
949
950 /* Check if we're still in an invalid status */
951 if (!NT_SUCCESS(Status)) break;
952
953 #ifndef NEWCC
954 /* Flush dirty cache pages */
955 /* XXX: Is that still mandatory? As now we'll wait on lazy writer to complete? */
956 CcRosFlushDirtyPages(-1, &Dummy, FALSE, FALSE); //HACK: We really should wait here!
957 #else
958 Dummy = 0;
959 #endif
960
961 /* Flush all volumes and the registry */
962 DPRINT("Flushing volumes, cache flushed %lu pages\n", Dummy);
963 PopFlushVolumes(PopAction.Shutdown);
964
965 /* Set IRP for drivers */
966 PopAction.IrpMinor = IRP_MN_SET_POWER;
967 if (PopAction.Shutdown)
968 {
969 DPRINT("Queueing shutdown thread\n");
970 /* Check if we are running in the system context */
971 if (PsGetCurrentProcess() != PsInitialSystemProcess)
972 {
973 /* We're not, so use a worker thread for shutdown */
974 ExInitializeWorkItem(&PopShutdownWorkItem,
975 &PopGracefulShutdown,
976 NULL);
977
978 ExQueueWorkItem(&PopShutdownWorkItem, CriticalWorkQueue);
979
980 /* Spend us -- when we wake up, the system is good to go down */
981 KeSuspendThread(KeGetCurrentThread());
982 Status = STATUS_SYSTEM_SHUTDOWN;
983 goto Exit;
984
985 }
986 else
987 {
988 /* Do the shutdown inline */
989 PopGracefulShutdown(NULL);
990 }
991 }
992
993 /* You should not have made it this far */
994 // ASSERTMSG("System is still up and running?!", FALSE);
995 DPRINT1("System is still up and running, you may not have chosen a yet supported power option: %u\n", PopAction.Action);
996 break;
997 }
998
999 Exit:
1000 /* We're done, return */
1001 return Status;
1002 }