ReactOS 0.4.15-dev-8235-gcd88a97
cmbatt.c
Go to the documentation of this file.
1/*
2 * PROJECT: ReactOS ACPI-Compliant Control Method Battery
3 * LICENSE: BSD - See COPYING.ARM in the top level directory
4 * FILE: boot/drivers/bus/acpi/cmbatt/cmbatt.c
5 * PURPOSE: Main Initialization Code and IRP Handling
6 * PROGRAMMERS: ReactOS Portable Systems Group
7 */
8
9/* INCLUDES *******************************************************************/
10
11#include "cmbatt.h"
12
13#include <debug.h>
14
15/* GLOBALS ********************************************************************/
16
25
26/* FUNCTIONS ******************************************************************/
27
28VOID
33{
34 BOOLEAN Cancelled;
36 if (CmBattDebug & 0x10)
37 DbgPrint("CmBattPowerCallBack: action: %d, value: %d \n", Action, Value);
38
39 /* Check if a transition is going to happen */
41 {
42 /* We have just re-entered S0: call the wake DPC in 10 seconds */
43 if (Value == 1)
44 {
45 if (CmBattDebug & 0x10)
46 DbgPrint("CmBattPowerCallBack: Calling CmBattWakeDpc after 10 seconds.\n");
48 if (CmBattDebug & 0x10)
49 DbgPrint("CmBattPowerCallBack: timerCanceled = %d.\n", Cancelled);
50 }
51 else if (Value == 0)
52 {
53 /* We are exiting the S0 state: loop all devices to set the delay flag */
54 if (CmBattDebug & 0x10)
55 DbgPrint("CmBattPowerCallBack: Delaying Notifications\n");
56 for (DeviceObject = DeviceExtension->DeviceObject;
58 DeviceObject = DeviceObject->NextDevice)
59 {
60 /* Set the delay flag */
61 DeviceExtension = DeviceObject->DeviceExtension;
62 DeviceExtension->DelayNotification = TRUE;
63 }
64 }
65 else if (CmBattDebug & 0x10)
66 {
67 /* Unknown value */
68 DbgPrint("CmBattPowerCallBack: unknown argument2 = %08x\n", Value);
69 }
70 }
71}
72
73VOID
79{
80 PDEVICE_OBJECT CurrentObject;
81 BOOLEAN AcNotify = FALSE;
82 PCMBATT_DEVICE_EXTENSION DeviceExtension;
83 ULONG ArFlag;
84 if (CmBattDebug & 2) DbgPrint("CmBattWakeDpc: Entered.\n");
85
86 /* Loop all device objects */
87 for (CurrentObject = FdoExtension->DeviceObject;
88 CurrentObject;
89 CurrentObject = CurrentObject->NextDevice)
90 {
91 /* Turn delay flag off, we're back in S0 */
92 DeviceExtension = CurrentObject->DeviceExtension;
93 DeviceExtension->DelayNotification = 0;
94
95 /* Check if this is an AC adapter */
96 if (DeviceExtension->FdoType == CmBattAcAdapter)
97 {
98 /* Was there a pending notify? */
99 if (DeviceExtension->ArFlag & CMBATT_AR_NOTIFY)
100 {
101 /* We'll send a notify on the next pass */
102 AcNotify = TRUE;
103 DeviceExtension->ArFlag = 0;
104 if (CmBattDebug & 0x20)
105 DbgPrint("CmBattWakeDpc: AC adapter notified\n");
106 }
107 }
108 }
109
110 /* Loop the device objects again */
111 for (CurrentObject = FdoExtension->DeviceObject;
112 CurrentObject;
113 CurrentObject = CurrentObject->NextDevice)
114 {
115 /* Check if this is a battery */
116 DeviceExtension = CurrentObject->DeviceExtension;
117 if (DeviceExtension->FdoType == CmBattBattery)
118 {
119 /* Check what ARs are pending */
120 ArFlag = DeviceExtension->ArFlag;
121 if (CmBattDebug & 0x20)
122 DbgPrint("CmBattWakeDpc: Performing delayed ARs: %01x\n", ArFlag);
123
124 /* Insert notification, clear the lock value */
125 if (ArFlag & CMBATT_AR_INSERT) InterlockedExchange(&DeviceExtension->ArLockValue, 0);
126
127 /* Removal, clear the battery tag */
128 if (ArFlag & CMBATT_AR_REMOVE) DeviceExtension->Tag = 0;
129
130 /* Notification (or AC/DC adapter change from first pass above) */
131 if ((ArFlag & CMBATT_AR_NOTIFY) || (AcNotify))
132 {
133 /* Notify the class driver */
134 BatteryClassStatusNotify(DeviceExtension->ClassData);
135 }
136 }
137 }
138}
139
140VOID
141NTAPI
143 IN ULONG NotifyValue)
144{
145 ULONG ArFlag;
148
150 DbgPrint("CmBattNotifyHandler: CmBatt 0x%08x Type %d Number %d Notify Value: %x\n",
151 DeviceExtension,
152 DeviceExtension->FdoType,
153 DeviceExtension->DeviceId,
154 NotifyValue);
155
156 /* Check what kind of notification was received */
157 switch (NotifyValue)
158 {
159 /* ACPI Specification says is sends a "Bus Check" when power source changes */
160 case ACPI_BUS_CHECK:
161
162 /* We treat it as possible physical change */
163 DeviceExtension->ArFlag |= (CMBATT_AR_NOTIFY | CMBATT_AR_INSERT);
164 if ((DeviceExtension->Tag) &&
166 DbgPrint("CmBattNotifyHandler: Received battery #%x insertion, but tag was not invalid.\n",
167 DeviceExtension->DeviceId);
168 break;
169
170 /* Status of the battery has changed */
172
173 /* All we'll do is notify the class driver */
174 DeviceExtension->ArFlag |= CMBATT_AR_NOTIFY;
175 break;
176
177 /* Information on the battery has changed, such as physical presence */
180
181 /* Reset all state and let the class driver re-evaluate it all */
182 DeviceExtension->ArFlag |= (CMBATT_AR_NOTIFY |
185 break;
186
187 default:
188
190 DbgPrint("CmBattNotifyHandler: Unknown Notify Value: %x\n", NotifyValue);
191 }
192
193 /* Check if we're supposed to delay the notification till later */
194 if (DeviceExtension->DelayNotification)
195 {
196 /* We'll handle this when we get a status query later on */
198 DbgPrint("CmBattNotifyHandler: Notification delayed: ARs = %01x\n",
199 DeviceExtension->ArFlag);
200 return;
201 }
202
203 /* We're going to handle this now */
205 DbgPrint("CmBattNotifyHandler: Performing ARs: %01x\n", DeviceExtension->ArFlag);
206
207 /* Check if this is a battery or AC adapter notification */
208 if (DeviceExtension->FdoType == CmBattBattery)
209 {
210 /* Reset the current trip point */
211 DeviceExtension->TripPointValue = BATTERY_UNKNOWN_CAPACITY;
212
213 /* Check what ARs have to be done */
214 ArFlag = DeviceExtension->ArFlag;
215
216 /* New battery inserted, reset lock value */
217 if (ArFlag & CMBATT_AR_INSERT) InterlockedExchange(&DeviceExtension->ArLockValue, 0);
218
219 /* Check if the battery may have been removed */
220 if (ArFlag & CMBATT_AR_REMOVE) DeviceExtension->Tag = 0;
221
222 /* Check if there's been any sort of change to the battery */
223 if (ArFlag & CMBATT_AR_NOTIFY)
224 {
225 /* We'll probably end up re-evaluating _BIF and _BST */
226 DeviceExtension->NotifySent = TRUE;
227 BatteryClassStatusNotify(DeviceExtension->ClassData);
228 }
229 }
230 else if (DeviceExtension->ArFlag & CMBATT_AR_NOTIFY)
231 {
232 /* The only known notification is AC/DC change. Loop device objects. */
233 for (DeviceObject = DeviceExtension->FdoDeviceObject->DriverObject->DeviceObject;
235 DeviceObject = DeviceObject->NextDevice)
236 {
237 /* Is this a battery? */
238 FdoExtension = DeviceObject->DeviceExtension;
239 if (FdoExtension->FdoType == CmBattBattery)
240 {
241 /* Send a notification to the class driver */
242 FdoExtension->NotifySent = TRUE;
244 }
245 }
246 }
247
248 /* ARs have been processed */
249 DeviceExtension->ArFlag = 0;
250}
251
252VOID
253NTAPI
255{
256 if (CmBattDebug & CMBATT_GENERIC_INFO) DPRINT("CmBattUnload: \n");
257
258 /* Check if we have a registered power callback */
260 {
261 /* Get rid of it */
264 }
265
266 /* Free the registry buffer if it exists */
268
269 /* Make sure we don't still have references to the DO */
270 if ((DriverObject->DeviceObject) && (CmBattDebug & CMBATT_GENERIC_WARNING))
271 {
272 DbgPrint("Unload called before all devices removed.\n");
273 }
274}
275
277NTAPI
280{
283}
284
286NTAPI
288 IN PIRP Irp)
289{
291 PIO_STACK_LOCATION IoStackLocation;
292 UCHAR Major;
293 ULONG Count;
294 PCMBATT_DEVICE_EXTENSION DeviceExtension;
295 PAGED_CODE();
296 if (CmBattDebug & CMBATT_GENERIC_INFO) DPRINT("CmBattOpenClose\n");
297
298 /* Grab the device extension and lock it */
299 DeviceExtension = DeviceObject->DeviceExtension;
300 ExAcquireFastMutex(&DeviceExtension->FastMutex);
301
302 /* Check if someone is trying to open a device that doesn't exist yet */
303 Count = DeviceExtension->HandleCount;
304 if (Count == 0xFFFFFFFF)
305 {
306 /* Fail the request */
309 {
310 DbgPrint("CmBattOpenClose: Failed (UID = %x)(device being removed).\n",
311 DeviceExtension->Tag);
312 }
313 goto Complete;
314 }
315
316 /* Check if this is an open or close */
317 IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
318 Major = IoStackLocation->MajorFunction;
319 if (Major == IRP_MJ_CREATE)
320 {
321 /* Increment the open count */
322 DeviceExtension->HandleCount = Count + 1;
324 {
325 DbgPrint("CmBattOpenClose: Open (DeviceNumber = %x)(count = %x).\n",
326 DeviceExtension->DeviceId, Count + 1);
327 }
328 }
329 else if (Major == IRP_MJ_CLOSE)
330 {
331 /* Decrement the open count */
332 DeviceExtension->HandleCount = Count - 1;
334 {
335 DbgPrint("CmBattOpenClose: Close (DeviceNumber = %x)(count = %x).\n",
336 DeviceExtension->DeviceId, Count + 1);
337 }
338 }
339
341 /* Release lock and complete request */
342 ExReleaseFastMutex(&DeviceExtension->FastMutex);
343 Irp->IoStatus.Status = Status;
345 return Status;
346}
347
349NTAPI
351 IN PIRP Irp)
352{
353 PCMBATT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
355 PIO_STACK_LOCATION IoStackLocation;
357 PAGED_CODE();
358 if (CmBattDebug & 2) DbgPrint("CmBattIoctl\n");
359
360 /* Acquire the remove lock */
361 Status = IoAcquireRemoveLock(&DeviceExtension->RemoveLock, Irp);
362 if (!NT_SUCCESS(Status))
363 {
364 /* It's too late, fail */
365 Irp->IoStatus.Status = STATUS_DEVICE_REMOVED;
368 }
369
370 /* There's nothing to do for an AC adapter */
371 if (DeviceExtension->FdoType == CmBattAcAdapter)
372 {
373 /* Pass it down, and release the remove lock */
375 Status = IoCallDriver(DeviceExtension->AttachedDevice, Irp);
376 IoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
377 return Status;
378 }
379
380 /* Send to class driver */
381 Status = BatteryClassIoctl(DeviceExtension->ClassData, Irp);
383 {
384 /* Read IOCTL information from IRP stack */
385 IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
386 IoControlCode = IoStackLocation->Parameters.DeviceIoControl.IoControlCode;
387 OutputBufferLength = IoStackLocation->Parameters.DeviceIoControl.OutputBufferLength;
388 InputBufferLength = IoStackLocation->Parameters.DeviceIoControl.InputBufferLength;
389 if (CmBattDebug & 4)
390 DbgPrint("CmBattIoctl: Received Direct Access IOCTL %x\n", IoControlCode);
391
392 /* Handle internal IOCTLs */
393 switch (IoControlCode)
394 {
396
397 /* Data is 4 bytes long */
398 if (OutputBufferLength == sizeof(ULONG))
399 {
400 /* Query it */
401 Status = CmBattGetUniqueId(DeviceExtension->PdoDeviceObject,
402 Irp->AssociatedIrp.SystemBuffer);
403 if (NT_SUCCESS(Status)) Irp->IoStatus.Information = sizeof(ULONG);
404 }
405 else
406 {
407 /* Buffer size invalid */
409 }
410 break;
411
413
414 /* Data is 4 bytes long */
415 if (OutputBufferLength == sizeof(ULONG))
416 {
417 /* Query it */
418 Status = CmBattGetStaData(DeviceExtension->PdoDeviceObject,
419 Irp->AssociatedIrp.SystemBuffer);
420 if (NT_SUCCESS(Status)) Irp->IoStatus.Information = sizeof(ULONG);
421 }
422 else
423 {
424 /* Buffer size invalid */
426 }
427 break;
428
430
431 /* Data is 4 bytes long */
432 if (OutputBufferLength == sizeof(ULONG))
433 {
434 /* Do we have an AC adapter? */
435 if (AcAdapterPdo)
436 {
437 /* Query it */
439 Irp->AssociatedIrp.SystemBuffer);
440 if (NT_SUCCESS(Status)) Irp->IoStatus.Information = sizeof(ULONG);
441 }
442 else
443 {
444 /* No adapter, just a battery, so fail */
446 }
447 }
448 else
449 {
450 /* Buffer size invalid */
452 }
453 break;
454
456
457 /* Data is 4 bytes long */
458 if (InputBufferLength == sizeof(ULONG))
459 {
460 /* Query it */
461 Status = CmBattSetTripPpoint(DeviceExtension,
462 *(PULONG)Irp->AssociatedIrp.SystemBuffer);
463 Irp->IoStatus.Information = 0;
464 }
465 else
466 {
467 /* Buffer size invalid */
469 }
470 break;
471
473
474 /* Data is 1060 bytes long */
475 if (OutputBufferLength == sizeof(ACPI_BIF_DATA))
476 {
477 /* Query it */
478 Status = CmBattGetBifData(DeviceExtension,
479 Irp->AssociatedIrp.SystemBuffer);
480 if (NT_SUCCESS(Status)) Irp->IoStatus.Information = sizeof(ACPI_BIF_DATA);
481 }
482 else
483 {
484 /* Buffer size invalid */
486 }
487 break;
488
490
491 /* Data is 16 bytes long */
492 if (OutputBufferLength == sizeof(ACPI_BST_DATA))
493 {
494 /* Query it */
495 Status = CmBattGetBstData(DeviceExtension,
496 Irp->AssociatedIrp.SystemBuffer);
497 if (NT_SUCCESS(Status)) Irp->IoStatus.Information = sizeof(ACPI_BST_DATA);
498 }
499 else
500 {
501 /* Buffer size invalid */
503 }
504 break;
505
506 default:
507
508 /* Unknown, let us pass it on to ACPI */
509 if (CmBattDebug & 0xC)
510 DbgPrint("CmBattIoctl: Unknown IOCTL %x\n", IoControlCode);
511 break;
512 }
513
514 /* Did someone pick it up? */
516 {
517 /* Complete the request */
518 Irp->IoStatus.Status = Status;
520 }
521 else
522 {
523 /* Still unsupported, try ACPI */
525 Status = IoCallDriver(DeviceExtension->AttachedDevice, Irp);
526 }
527 }
528
529 /* Release the remove lock and return status */
530 IoReleaseRemoveLock(&DeviceExtension->RemoveLock, Irp);
531 return Status;
532}
533
535NTAPI
537 OUT PULONG Tag)
538{
539 PDEVICE_OBJECT PdoDevice;
540 ULONG StaData;
541 ULONG NewTag;
543 PAGED_CODE();
545 DbgPrint("CmBattQueryTag - Tag (%d), Battery %x, Device %d\n",
546 *Tag, DeviceExtension, DeviceExtension->DeviceId);
547
548 /* Get PDO and clear notification flag */
549 PdoDevice = DeviceExtension->PdoDeviceObject;
550 DeviceExtension->NotifySent = 0;
551
552 /* Get _STA from PDO (we need the machine status, not the battery status) */
553 Status = CmBattGetStaData(PdoDevice, &StaData);
554 if (NT_SUCCESS(Status))
555 {
556 /* Is a battery present? */
557 if (StaData & ACPI_STA_BATTERY_PRESENT)
558 {
559 /* Do we not have a tag yet? */
560 if (!DeviceExtension->Tag)
561 {
562 /* Set the new tag value, reset tags if we reached the maximum */
563 NewTag = DeviceExtension->TagData;
564 if (DeviceExtension->TagData++ == 0xFFFFFFFF) NewTag = 1;
565 DeviceExtension->Tag = NewTag;
567 DbgPrint("CmBattQueryTag - New Tag: (%d)\n", DeviceExtension->Tag);
568
569 /* Reset trip point data */
570 DeviceExtension->TripPointOld = 0;
571 DeviceExtension->TripPointValue = BATTERY_UNKNOWN_CAPACITY;
572
573 /* Clear AR lock and set new interrupt time */
574 InterlockedExchange(&DeviceExtension->ArLockValue, 0);
575 DeviceExtension->InterruptTime = KeQueryInterruptTime();
576 }
577 }
578 else
579 {
580 /* No battery, so no tag */
581 DeviceExtension->Tag = 0;
583 }
584 }
585
586 /* Return the tag and status result */
587 *Tag = DeviceExtension->Tag;
589 DbgPrint("CmBattQueryTag: Returning Tag: 0x%x, status 0x%x\n", *Tag, Status);
590 return Status;
591}
592
594NTAPI
596{
598 PAGED_CODE();
599 if (CmBattDebug & 0xA) DbgPrint("CmBattDisableStatusNotify\n");
600
601 /* Do we have a trip point */
602 if (DeviceExtension->TripPointSet)
603 {
604 /* Is there a current value set? */
605 if (DeviceExtension->TripPointValue)
606 {
607 /* Reset it back to 0 */
608 DeviceExtension->TripPointValue = 0;
609 Status = CmBattSetTripPpoint(DeviceExtension, 0);
610 if (!NT_SUCCESS(Status))
611 {
612 /* If it failed, set unknown/invalid value */
613 DeviceExtension->TripPointValue = BATTERY_UNKNOWN_CAPACITY;
614 if (CmBattDebug & 8)
615 DbgPrint("CmBattDisableStatusNotify: SetTripPoint failed - %x\n", Status);
616 }
617 }
618 else
619 {
620 /* No trip point set, so this is a successful no-op */
622 }
623 }
624 else
625 {
626 /* Nothing we can do */
628 }
629
630 /* Return status */
631 return Status;
632}
633
635NTAPI
639{
641 ACPI_BST_DATA BstData;
642 ULONG Capacity, NewTripPoint, TripPoint, DesignVoltage;
643 BOOLEAN Charging;
644 PAGED_CODE();
646 DbgPrint("CmBattSetStatusNotify: Tag (%d) Target(0x%x)\n",
648
649 /* Update any ACPI evaluations */
650 Status = CmBattVerifyStaticInfo(DeviceExtension, BatteryTag);
651 if (!NT_SUCCESS(Status)) return Status;
652
653 /* Trip point not supported, fail */
654 if (!DeviceExtension->TripPointSet) return STATUS_OBJECT_NAME_NOT_FOUND;
655
656 /* Are both capacities known? */
659 {
660 /* We can't set trip points without these */
662 DbgPrint("CmBattSetStatusNotify: Failing request because of BATTERY_UNKNOWN_CAPACITY.\n");
664 }
665
666 /* Is the battery charging? */
667 Charging = DeviceExtension->BstData.State & ACPI_BATT_STAT_CHARGING;
668 if (Charging)
669 {
670 /* Then the trip point is when we hit the cap */
671 Capacity = BatteryNotify->HighCapacity;
672 NewTripPoint = BatteryNotify->HighCapacity;
673 }
674 else
675 {
676 /* Otherwise it's when we discharge to the bottom */
677 Capacity = BatteryNotify->LowCapacity;
678 NewTripPoint = BatteryNotify->LowCapacity;
679 }
680
681 /* Do we have data in Amps or Watts? */
682 if (DeviceExtension->BifData.PowerUnit == ACPI_BATT_POWER_UNIT_AMPS)
683 {
684 /* We need the voltage to do the conversion */
685 DesignVoltage = DeviceExtension->BifData.DesignVoltage;
686 if ((DesignVoltage != BATTERY_UNKNOWN_VOLTAGE) && (DesignVoltage))
687 {
688 /* Convert from mAh into Ah */
689 TripPoint = 1000 * NewTripPoint;
690 if (Charging)
691 {
692 /* Scale the high trip point */
693 NewTripPoint = (TripPoint + 500) / DesignVoltage + ((TripPoint + 500) % DesignVoltage != 0);
694 }
695 else
696 {
697 /* Scale the low trip point */
698 NewTripPoint = (TripPoint - 500) / DesignVoltage - ((TripPoint - 500) % DesignVoltage == 0);
699 }
700 }
701 else
702 {
703 /* Without knowing the voltage, Amps are not enough data on consumption */
706 DbgPrint("CmBattSetStatusNotify: Can't calculate BTP, DesignVoltage = 0x%08x\n",
707 DesignVoltage);
708 }
709 }
710 else if (Charging)
711 {
712 /* Make it trip just one past the charge cap */
713 ++NewTripPoint;
714 }
715 else if (NewTripPoint > 0)
716 {
717 /* Make it trip just one below the drain cap */
718 --NewTripPoint;
719 }
720
721 /* Do we actually have a new trip point? */
722 if (NewTripPoint == DeviceExtension->TripPointValue)
723 {
724 /* No, so there is no work to be done */
726 DbgPrint("CmBattSetStatusNotify: Keeping original setting: %X\n", DeviceExtension->TripPointValue);
727 return STATUS_SUCCESS;
728 }
729
730 /* Set the trip point with ACPI and check for success */
731 DeviceExtension->TripPointValue = NewTripPoint;
732 Status = CmBattSetTripPpoint(DeviceExtension, NewTripPoint);
733 if (!(NewTripPoint) && (Capacity)) Status = STATUS_NOT_SUPPORTED;
734 if (!NT_SUCCESS(Status))
735 {
736 /* We failed to set the trip point, or there wasn't one settable */
737 DeviceExtension->TripPointValue = BATTERY_UNKNOWN_CAPACITY;
739 DbgPrint("CmBattSetStatusNotify: SetTripPoint failed - %x\n", Status);
740 return Status;
741 }
742
743 /* Read the new BST data to see the latest state */
744 Status = CmBattGetBstData(DeviceExtension, &BstData);
745 if (!NT_SUCCESS(Status))
746 {
747 /* We'll return failure to the caller */
749 DbgPrint("CmBattSetStatusNotify: GetBstData - %x\n", Status);
750 }
751 else if ((Charging) && (BstData.RemainingCapacity >= NewTripPoint))
752 {
753 /* We are charging and our capacity is past the trip point, so trip now */
755 DbgPrint("CmBattSetStatusNotify: Trip point already crossed (1): TP = %08x, remaining capacity = %08x\n",
756 NewTripPoint, BstData.RemainingCapacity);
758 }
759 else if ((BstData.RemainingCapacity) && (Capacity))
760 {
761 /* We are discharging, and our capacity is below the trip point, trip now */
763 DbgPrint("CmBattSetStatusNotify: Trip point already crossed (1): TP = %08x, remaining capacity = %08x\n",
764 NewTripPoint, BstData.RemainingCapacity);
766 }
767
768 /* All should've went well if we got here, unless BST failed... return! */
770 DbgPrint("CmBattSetStatusNotify: Want %X CurrentCap %X\n",
771 Capacity, DeviceExtension->RemainingCapacity);
773 DbgPrint("CmBattSetStatusNotify: Set to: [%#08lx][%#08lx][%#08lx] Status %lx\n",
777 Status);
778 return Status;
779}
780
782NTAPI
784 IN ULONG Tag)
785{
786 ULONG PsrData = 0;
788 ULONG BstState;
789 ULONG DesignVoltage, PresentRate, RemainingCapacity;
790 PAGED_CODE();
792 DbgPrint("CmBattGetBatteryStatus - CmBatt (%08x) Tag (%d)\n", DeviceExtension, Tag);
793
794 /* Validate ACPI data */
795 Status = CmBattVerifyStaticInfo(DeviceExtension, Tag);
796 if (!NT_SUCCESS(Status)) return Status;
797
798 /* Check for delayed status notifications */
799 if (DeviceExtension->DelayNotification)
800 {
801 /* Process them now and don't do any other work */
803 return Status;
804 }
805
806 /* Get _BST from ACPI */
807 Status = CmBattGetBstData(DeviceExtension, &DeviceExtension->BstData);
808 if (!NT_SUCCESS(Status))
809 {
810 /* Fail */
811 InterlockedExchange(&DeviceExtension->ArLockValue, 0);
812 return Status;
813 }
814
815 /* Clear current BST information */
816 DeviceExtension->State = 0;
817 DeviceExtension->RemainingCapacity = 0;
818 DeviceExtension->PresentVoltage = 0;
819 DeviceExtension->Rate = 0;
820
821 /* Get battery state */
822 BstState = DeviceExtension->BstData.State;
823
824 /* Is the battery both charging and discharging? */
825 if ((BstState & ACPI_BATT_STAT_DISCHARG) && (BstState & ACPI_BATT_STAT_CHARGING) &&
827 DbgPrint("************************ ACPI BIOS BUG ********************\n* "
828 "CmBattGetBatteryStatus: Invalid state: _BST method returned 0x%08x for Battery State.\n"
829 "* One battery cannot be charging and discharging at the same time.\n",
830 BstState);
831
832 /* Is the battery discharging? */
833 if (BstState & ACPI_BATT_STAT_DISCHARG)
834 {
835 /* Set power state and check if it just started discharging now */
836 DeviceExtension->State |= BATTERY_DISCHARGING;
837 if (!(DeviceExtension->State & ACPI_BATT_STAT_DISCHARG))
838 {
839 /* Remember the time when the state changed */
840 DeviceExtension->InterruptTime = KeQueryInterruptTime();
841 }
842 }
843 else if (BstState & ACPI_BATT_STAT_CHARGING)
844 {
845 /* Battery is charging, update power state */
846 DeviceExtension->State |= (BATTERY_CHARGING | BATTERY_POWER_ON_LINE);
847 }
848
849 /* Is the battery in a critical state? */
850 if (BstState & ACPI_BATT_STAT_CRITICAL) DeviceExtension->State |= BATTERY_CRITICAL;
851
852 /* Read the voltage data */
853 DeviceExtension->PresentVoltage = DeviceExtension->BstData.PresentVoltage;
854
855 /* Check if we have an A/C adapter */
856 if (AcAdapterPdo)
857 {
858 /* Query information on it */
860 }
861 else
862 {
863 /* Otherwise, check if the battery is charging */
864 if (BstState & ACPI_BATT_STAT_CHARGING)
865 {
866 /* Then we'll assume there's a charger */
867 PsrData = 1;
868 }
869 else
870 {
871 /* Assume no charger */
872 PsrData = 0;
873 }
874 }
875
876 /* Is there a charger? */
877 if (PsrData)
878 {
879 /* Set the power state flag to reflect this */
880 DeviceExtension->State |= BATTERY_POWER_ON_LINE;
882 DbgPrint("CmBattGetBatteryStatus: AC adapter is connected\n");
883 }
885 {
886 DbgPrint("CmBattGetBatteryStatus: AC adapter is NOT connected\n");
887 }
888
889 /* Get some data we'll need */
890 DesignVoltage = DeviceExtension->BifData.DesignVoltage;
891 PresentRate = DeviceExtension->BstData.PresentRate;
892 RemainingCapacity = DeviceExtension->BstData.RemainingCapacity;
893
894 /* Check if we have battery data in Watts instead of Amps */
895 if (DeviceExtension->BifData.PowerUnit == ACPI_BATT_POWER_UNIT_WATTS)
896 {
897 /* Get the data from the BST */
898 DeviceExtension->RemainingCapacity = RemainingCapacity;
899 DeviceExtension->Rate = PresentRate;
900
901 /* Check if the rate is invalid */
902 if (PresentRate > CM_MAX_VALUE)
903 {
904 /* Set an unknown rate and don't touch the old value */
905 DeviceExtension->Rate = BATTERY_UNKNOWN_RATE;
906 if ((PresentRate != CM_UNKNOWN_VALUE) && (CmBattDebug & CMBATT_ACPI_WARNING))
907 {
908 DbgPrint("CmBattGetBatteryStatus - Rate is greater than CM_MAX_VALUE\n");
909 DbgPrint("---------------------- PresentRate = 0x%08x\n", PresentRate);
910 }
911 }
912 }
913 else if ((DesignVoltage != CM_UNKNOWN_VALUE) && (DesignVoltage))
914 {
915 /* We have voltage data, what about capacity? */
916 if (RemainingCapacity == CM_UNKNOWN_VALUE)
917 {
918 /* Unable to calculate it */
919 DeviceExtension->RemainingCapacity = BATTERY_UNKNOWN_CAPACITY;
921 {
922 DbgPrint("CmBattGetBatteryStatus - Can't calculate RemainingCapacity \n");
923 DbgPrint("---------------------- RemainingCapacity = CM_UNKNOWN_VALUE\n");
924 }
925 }
926 else
927 {
928 /* Compute the capacity with the information we have */
929 DeviceExtension->RemainingCapacity = (DesignVoltage * RemainingCapacity + 500) / 1000;
930 }
931
932 /* Check if we have a rate */
933 if (PresentRate != CM_UNKNOWN_VALUE)
934 {
935 /* Make sure the rate isn't too large */
936 if (PresentRate > (-500 / DesignVoltage))
937 {
938 /* It is, so set unknown state */
939 DeviceExtension->Rate = BATTERY_UNKNOWN_RATE;
941 {
942 DbgPrint("CmBattGetBatteryStatus - Can't calculate Rate \n");
943 DbgPrint("---------------------- Overflow: PresentRate = 0x%08x\n", PresentRate);
944 }
945 }
946
947 /* Compute the rate */
948 DeviceExtension->Rate = (PresentRate * DesignVoltage + 500) / 1000;
949 }
950 else
951 {
952 /* We don't have a rate, so set unknown value */
953 DeviceExtension->Rate = BATTERY_UNKNOWN_RATE;
955 {
956 DbgPrint("CmBattGetBatteryStatus - Can't calculate Rate \n");
957 DbgPrint("---------------------- Present Rate = CM_UNKNOWN_VALUE\n");
958 }
959 }
960 }
961 else
962 {
963 /* We have no rate, and no capacity, set unknown values */
964 DeviceExtension->Rate = BATTERY_UNKNOWN_RATE;
965 DeviceExtension->RemainingCapacity = BATTERY_UNKNOWN_CAPACITY;
967 {
968 DbgPrint("CmBattGetBatteryStatus - Can't calculate RemainingCapacity and Rate \n");
969 DbgPrint("---------------------- DesignVoltage = 0x%08x\n", DesignVoltage);
970 }
971 }
972
973 /* Check if we have an unknown rate */
974 if (DeviceExtension->Rate == BATTERY_UNKNOWN_RATE)
975 {
976 /* The battery is discharging but we don't know by how much... this is bad! */
977 if ((BstState & ACPI_BATT_STAT_DISCHARG) &&
979 DbgPrint("CmBattGetBatteryStatus: battery rate is unknown when battery is not charging!\n");
980 }
981 else if (DeviceExtension->State & BATTERY_DISCHARGING)
982 {
983 /* The battery is discharging, so treat the rate as a negative rate */
984 DeviceExtension->Rate = -(LONG)DeviceExtension->Rate;
985 }
986 else if (!(DeviceExtension->State & BATTERY_CHARGING) && (DeviceExtension->Rate))
987 {
988 /* We are not charging, not discharging, but have a rate? Ignore it! */
990 DbgPrint("CmBattGetBatteryStatus: battery is not charging or discharging, but rate = %x\n",
991 DeviceExtension->Rate);
992 DeviceExtension->Rate = 0;
993 }
994
995 /* Done */
996 return STATUS_SUCCESS;
997}
998
1000NTAPI
1002 IN ULONG Tag,
1005 IN PVOID Buffer,
1008{
1010 PVOID QueryData = NULL;
1011 ULONG QueryLength = 0;
1012 ULONG RemainingTime = 0;
1013 ANSI_STRING TempString;
1014 UNICODE_STRING TempString2;
1015 WCHAR InfoBuffer[256];
1016 WCHAR TempBuffer[256];
1017 UNICODE_STRING InfoString;
1018 ULONG RemainingCapacity;
1019 BATTERY_REPORTING_SCALE BatteryReportingScale[2];
1020 LONG Rate;
1021 PAGED_CODE();
1023 DbgPrint("CmBattQueryInformation - Tag (%d) Device %d, Informationlevel %d\n",
1024 Tag,
1025 FdoExtension->DeviceId,
1026 InfoLevel);
1027
1028 /* Check ACPI Data */
1030 if (!NT_SUCCESS(Status)) return Status;
1031
1032 /* Check what caller wants */
1033 switch (InfoLevel)
1034 {
1035 case BatteryInformation:
1036 /* Just return our static information */
1037 QueryData = &FdoExtension->BatteryInformation;
1038 QueryLength = sizeof(BATTERY_INFORMATION);
1039 break;
1040
1042
1043 /* Return our static information, we have two scales */
1044 BatteryReportingScale[0].Granularity = FdoExtension->BatteryCapacityGranularity1;
1045 BatteryReportingScale[0].Capacity = FdoExtension->BatteryInformation.DefaultAlert1;
1046 BatteryReportingScale[1].Granularity = FdoExtension->BatteryCapacityGranularity2;
1047 BatteryReportingScale[1].Capacity = FdoExtension->BatteryInformation.DesignedCapacity;
1048 QueryData = BatteryReportingScale;
1049 QueryLength = sizeof(BATTERY_REPORTING_SCALE) * 2;
1050 break;
1051
1053
1054 /* Check if it's been more than 2 1/2 minutes since the last change */
1055 if ((KeQueryInterruptTime() - 150000000) > (FdoExtension->InterruptTime))
1056 {
1057 /* Get new battery status */
1059
1060 /* If the caller didn't specify a rate, use our static one */
1061 Rate = AtRate;
1062 if (!Rate) Rate = FdoExtension->Rate;
1063
1064 /* If we don't have a valid negative rate, use unknown value */
1065 if (Rate >= 0) Rate = BATTERY_UNKNOWN_RATE;
1066
1067 /* Grab the remaining capacity */
1068 RemainingCapacity = FdoExtension->RemainingCapacity;
1069
1070 /* See if we don't know one or the other */
1071 if ((Rate == BATTERY_UNKNOWN_RATE) ||
1072 (RemainingCapacity == BATTERY_UNKNOWN_CAPACITY))
1073 {
1074 /* If the battery is discharging, we can't give out a time */
1075 if ((FdoExtension->BstData.State & ACPI_BATT_STAT_DISCHARG) &&
1077 DbgPrint("CmBattQueryInformation: Can't calculate EstimatedTime.\n");
1078
1079 /* Check if we don't have a rate and capacity is going down */
1080 if ((FdoExtension->Rate == BATTERY_UNKNOWN_RATE) &&
1081 (FdoExtension->BstData.State & ACPI_BATT_STAT_DISCHARG))
1082 {
1083 /* We have to fail, since we lack data */
1086 DbgPrint("---------------------- PresentRate = BATTERY_UNKNOWN_RATE\n");
1087 }
1088
1089 /* If we don't have capacity, the rate is useless */
1090 if (RemainingCapacity == BATTERY_UNKNOWN_CAPACITY)
1091 {
1092 /* We have to fail the request */
1095 DbgPrint("---------------------- RemainingCapacity = BATTERY_UNKNOWN_CAPACITY\n");
1096 }
1097 }
1098 else
1099 {
1100 /* We have data, but is it valid? */
1101 if (RemainingCapacity > 0x123456)
1102 {
1103 /* The capacity seems bogus, so don't use it */
1105 DbgPrint("CmBattQueryInformation: Data Overflow in calculating Remaining Capacity.\n");
1106 }
1107 else
1108 {
1109 /* Compute the remaining time in seconds, based on rate */
1110 RemainingTime = (RemainingCapacity * 3600) / -Rate;
1111 }
1112 }
1113 }
1114
1115 /* Return the remaining time */
1116 QueryData = &RemainingTime;
1117 QueryLength = sizeof(ULONG);
1118 break;
1119
1120 case BatteryDeviceName:
1121
1122 /* Build the model number string */
1123 RtlInitAnsiString(&TempString, FdoExtension->ModelNumber);
1124
1125 /* Convert it to Unicode */
1126 InfoString.Buffer = InfoBuffer;
1127 InfoString.MaximumLength = sizeof(InfoBuffer);
1128 Status = RtlAnsiStringToUnicodeString(&InfoString, &TempString, 0);
1129
1130 /* Return the unicode buffer */
1131 QueryData = InfoString.Buffer;
1132 QueryLength = InfoString.Length;
1133 break;
1134
1135 case BatteryTemperature:
1137
1138 /* We don't support these */
1140 break;
1141
1143
1144 /* Build the OEM info string */
1145 RtlInitAnsiString(&TempString, FdoExtension->OemInfo);
1146
1147 /* Convert it to Unicode */
1148 InfoString.Buffer = InfoBuffer;
1149 InfoString.MaximumLength = sizeof(InfoBuffer);
1150 Status = RtlAnsiStringToUnicodeString(&InfoString, &TempString, 0);
1151
1152 /* Return the unicode buffer */
1153 QueryData = InfoString.Buffer;
1154 QueryLength = InfoString.Length;
1155 break;
1156
1157 case BatteryUniqueID:
1158
1159 /* Build the serial number string */
1160 RtlInitAnsiString(&TempString, FdoExtension->SerialNumber);
1161
1162 /* Convert it to Unicode */
1163 InfoString.Buffer = InfoBuffer;
1164 InfoString.MaximumLength = sizeof(InfoBuffer);
1165 RtlAnsiStringToUnicodeString(&InfoString, &TempString, 0);
1166
1167 /* Setup a temporary string for concatenation */
1168 TempString2.Buffer = TempBuffer;
1169 TempString2.MaximumLength = sizeof(TempBuffer);
1170
1171 /* Check if there's an OEM string */
1172 if (FdoExtension->OemInfo[0])
1173 {
1174 /* Build the OEM info string */
1175 RtlInitAnsiString(&TempString, FdoExtension->OemInfo);
1176
1177 /* Convert it to Unicode and append it */
1178 RtlAnsiStringToUnicodeString(&TempString2, &TempString, 0);
1179 RtlAppendUnicodeStringToString(&InfoString, &TempString2);
1180 }
1181
1182 /* Build the model number string */
1183 RtlInitAnsiString(&TempString, FdoExtension->ModelNumber);
1184
1185 /* Convert it to Unicode and append it */
1186 RtlAnsiStringToUnicodeString(&TempString2, &TempString, 0);
1187 RtlAppendUnicodeStringToString(&InfoString, &TempString2);
1188
1189 /* Return the final appended string */
1190 QueryData = InfoString.Buffer;
1191 QueryLength = InfoString.Length;
1192 break;
1193
1194 default:
1195
1196 /* Everything else is unknown */
1198 break;
1199 }
1200
1201 /* Return the required length and check if the caller supplied enough */
1202 *ReturnedLength = QueryLength;
1203 if (BufferLength < QueryLength) Status = STATUS_BUFFER_TOO_SMALL;
1204
1205 /* Copy the data if there's enough space and it exists */
1206 if ((NT_SUCCESS(Status)) && (QueryData)) RtlCopyMemory(Buffer, QueryData, QueryLength);
1207
1208 /* Return function result */
1209 return Status;
1210}
1211
1213NTAPI
1215 IN ULONG Tag,
1217{
1219 PAGED_CODE();
1221 DbgPrint("CmBattQueryStatus - Tag (%d) Device %x\n", Tag, DeviceExtension->DeviceId);
1222
1223 /* Query ACPI information */
1224 Status = CmBattGetBatteryStatus(DeviceExtension, Tag);
1225 if (NT_SUCCESS(Status))
1226 {
1227 BatteryStatus->PowerState = DeviceExtension->State;
1228 BatteryStatus->Capacity = DeviceExtension->RemainingCapacity;
1229 BatteryStatus->Voltage = DeviceExtension->PresentVoltage;
1230 BatteryStatus->Rate = DeviceExtension->Rate;
1231 }
1232
1233 /* Return status */
1235 DbgPrint("CmBattQueryStatus: Returning [%#08lx][%#08lx][%#08lx][%#08lx]\n",
1240 return Status;
1241}
1242
1244NTAPI
1247{
1251 UNICODE_STRING CallbackName;
1252
1253 /* Allocate registry path */
1258 'MtaB');
1260 {
1261 /* Fail if we're out of memory this early */
1263 DbgPrint("CmBatt: Couldn't allocate pool for registry path.");
1265 }
1266
1267 /* Buffer allocated, copy the string */
1270 DbgPrint("CmBatt DriverEntry - Obj (%08x) Path \"%wZ\"\n",
1272 RegistryPath);
1273
1274 /* Setup the major dispatchers */
1275 DriverObject->MajorFunction[IRP_MJ_CREATE] = CmBattOpenClose;
1276 DriverObject->MajorFunction[IRP_MJ_CLOSE] = CmBattOpenClose;
1279 DriverObject->MajorFunction[IRP_MJ_PNP] = CmBattPnpDispatch;
1281
1282 /* And the unload routine */
1283 DriverObject->DriverUnload = CmBattUnload;
1284
1285 /* And the add device routine */
1286 DriverExtension = DriverObject->DriverExtension;
1287 DriverExtension->AddDevice = CmBattAddDevice;
1288
1289 /* Create a power callback */
1290 RtlInitUnicodeString(&CallbackName, L"\\Callback\\PowerState");
1292 &CallbackName,
1294 NULL,
1295 NULL);
1297 if (!NT_SUCCESS(Status))
1298 {
1299 /* No callback, fail */
1302 DbgPrint("CmBattRegisterPowerCallBack: failed status=0x%08x\n", Status);
1303 }
1304 else
1305 {
1306 /* Register the power callback now */
1309 DriverObject);
1311 {
1312 /* Last thing: setup our DPC and timer for battery wake */
1315 }
1316 else
1317 {
1320 DbgPrint("CmBattRegisterPowerCallBack: ExRegisterCallback failed.\n");
1321 }
1322
1323 /* All good */
1325 }
1326
1327 /* Return failure or success */
1328 return Status;
1329}
1330
1331/* EOF */
static PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
#define PAGED_CODE()
unsigned char BOOLEAN
#define ACPI_STA_BATTERY_PRESENT
Definition: actypes.h:1344
#define InterlockedExchange
Definition: armddk.h:54
LONG NTSTATUS
Definition: precomp.h:26
_In_ ULONG _In_ BATTERY_QUERY_INFORMATION_LEVEL _In_ LONG _In_ ULONG _Out_ PULONG ReturnedLength
Definition: batclass.h:188
#define BATTERY_CRITICAL
Definition: batclass.h:76
_In_ ULONG _In_ PBATTERY_NOTIFY BatteryNotify
Definition: batclass.h:216
#define BATTERY_UNKNOWN_CAPACITY
Definition: batclass.h:65
_Out_ PULONG BatteryTag
Definition: batclass.h:173
_In_ ULONG _Out_ PBATTERY_STATUS BatteryStatus
Definition: batclass.h:199
#define BATTERY_UNKNOWN_VOLTAGE
Definition: batclass.h:79
_In_ ULONG _In_ BATTERY_QUERY_INFORMATION_LEVEL _In_ LONG AtRate
Definition: batclass.h:185
#define BATTERY_POWER_ON_LINE
Definition: batclass.h:73
#define BATTERY_DISCHARGING
Definition: batclass.h:74
struct _BATTERY_INFORMATION BATTERY_INFORMATION
@ BatteryInformation
Definition: batclass.h:97
@ BatteryManufactureName
Definition: batclass.h:103
@ BatteryGranularityInformation
Definition: batclass.h:98
@ BatteryUniqueID
Definition: batclass.h:104
@ BatteryEstimatedTime
Definition: batclass.h:100
@ BatteryDeviceName
Definition: batclass.h:101
@ BatteryTemperature
Definition: batclass.h:99
@ BatteryManufactureDate
Definition: batclass.h:102
#define BATTERY_CHARGING
Definition: batclass.h:75
#define BATTERY_UNKNOWN_RATE
Definition: batclass.h:82
enum _BATTERY_QUERY_INFORMATION_LEVEL BATTERY_QUERY_INFORMATION_LEVEL
BCLASSAPI NTSTATUS NTAPI BatteryClassStatusNotify(PVOID ClassData)
Definition: battc.c:79
BCLASSAPI NTSTATUS NTAPI BatteryClassIoctl(PVOID ClassData, PIRP Irp)
Definition: battc.c:189
#define UNIMPLEMENTED
Definition: debug.h:118
#define IRP_MJ_PNP
Definition: cdrw_usr.h:52
Definition: bufpool.h:45
PDEVICE_OBJECT AcAdapterPdo
Definition: cmbatt.c:23
KDPC CmBattWakeDpcObject
Definition: cmbatt.c:22
NTSTATUS NTAPI CmBattGetBatteryStatus(IN PCMBATT_DEVICE_EXTENSION DeviceExtension, IN ULONG Tag)
Definition: cmbatt.c:783
VOID NTAPI CmBattUnload(IN PDRIVER_OBJECT DriverObject)
Definition: cmbatt.c:254
KTIMER CmBattWakeDpcTimerObject
Definition: cmbatt.c:21
NTSTATUS NTAPI CmBattOpenClose(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: cmbatt.c:287
NTSTATUS NTAPI CmBattIoctl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: cmbatt.c:350
PCALLBACK_OBJECT CmBattPowerCallBackObject
Definition: cmbatt.c:18
ULONG CmBattDebug
Definition: cmbatt.c:17
PVOID CmBattPowerCallBackRegistration
Definition: cmbatt.c:19
NTSTATUS NTAPI CmBattDisableStatusNotify(IN PCMBATT_DEVICE_EXTENSION DeviceExtension)
Definition: cmbatt.c:595
LARGE_INTEGER CmBattWakeDpcDelay
Definition: cmbatt.c:24
VOID NTAPI CmBattWakeDpc(IN PKDPC Dpc, IN PCMBATT_DEVICE_EXTENSION FdoExtension, IN PVOID SystemArgument1, IN PVOID SystemArgument2)
Definition: cmbatt.c:75
NTSTATUS NTAPI CmBattQueryStatus(IN PCMBATT_DEVICE_EXTENSION DeviceExtension, IN ULONG Tag, IN PBATTERY_STATUS BatteryStatus)
Definition: cmbatt.c:1214
NTSTATUS NTAPI CmBattQueryInformation(IN PCMBATT_DEVICE_EXTENSION FdoExtension, IN ULONG Tag, IN BATTERY_QUERY_INFORMATION_LEVEL InfoLevel, IN OPTIONAL LONG AtRate, IN PVOID Buffer, IN ULONG BufferLength, OUT PULONG ReturnedLength)
Definition: cmbatt.c:1001
VOID NTAPI CmBattNotifyHandler(IN PCMBATT_DEVICE_EXTENSION DeviceExtension, IN ULONG NotifyValue)
Definition: cmbatt.c:142
UNICODE_STRING GlobalRegistryPath
Definition: cmbatt.c:20
NTSTATUS NTAPI CmBattVerifyStaticInfo(PCMBATT_DEVICE_EXTENSION DeviceExtension, ULONG BatteryTag)
Definition: cmbatt.c:278
VOID NTAPI CmBattPowerCallBack(IN PCMBATT_DEVICE_EXTENSION DeviceExtension, IN ULONG Action, IN ULONG Value)
Definition: cmbatt.c:30
NTSTATUS NTAPI CmBattQueryTag(IN PCMBATT_DEVICE_EXTENSION DeviceExtension, OUT PULONG Tag)
Definition: cmbatt.c:536
NTSTATUS NTAPI CmBattSetStatusNotify(IN PCMBATT_DEVICE_EXTENSION DeviceExtension, IN ULONG BatteryTag, IN PBATTERY_NOTIFY BatteryNotify)
Definition: cmbatt.c:636
#define CM_UNKNOWN_VALUE
Definition: cmbatt.h:68
NTSTATUS NTAPI CmBattSetTripPpoint(PCMBATT_DEVICE_EXTENSION DeviceExtension, ULONG AlarmValue)
#define ACPI_BUS_CHECK
Definition: cmbatt.h:51
#define CMBATT_GENERIC_INFO
Definition: cmbatt.h:36
#define CMBATT_ACPI_WARNING
Definition: cmbatt.h:38
#define CMBATT_GENERIC_STATUS
Definition: cmbatt.h:35
NTSTATUS NTAPI CmBattGetStaData(PDEVICE_OBJECT DeviceObject, PULONG StaData)
NTSTATUS NTAPI CmBattGetPsrData(PDEVICE_OBJECT DeviceObject, PULONG PsrData)
#define CM_MAX_VALUE
Definition: cmbatt.h:67
#define CMBATT_ACPI_ASSERT
Definition: cmbatt.h:43
#define ACPI_BATT_NOTIFY_INFO
Definition: cmbatt.h:61
#define CMBATT_AR_INSERT
Definition: cmbatt.h:99
#define IOCTL_BATTERY_QUERY_STA
Definition: cmbatt.h:20
#define CMBATT_AR_REMOVE
Definition: cmbatt.h:100
struct _ACPI_BIF_DATA ACPI_BIF_DATA
#define ACPI_BATT_POWER_UNIT_WATTS
Definition: cmbatt.h:78
#define IOCTL_BATTERY_QUERY_BST
Definition: cmbatt.h:32
NTSTATUS NTAPI CmBattGetUniqueId(PDEVICE_OBJECT DeviceObject, PULONG UniqueId)
#define ACPI_BATT_STAT_CRITICAL
Definition: cmbatt.h:65
#define IOCTL_BATTERY_SET_TRIP_POINT
Definition: cmbatt.h:26
#define ACPI_DEVICE_CHECK
Definition: cmbatt.h:52
NTSTATUS NTAPI CmBattPowerDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
#define CMBATT_GENERIC_WARNING
Definition: cmbatt.h:37
NTSTATUS NTAPI CmBattGetBifData(PCMBATT_DEVICE_EXTENSION DeviceExtension, PACPI_BIF_DATA BifData)
Definition: cmexec.c:325
#define ACPI_BATT_STAT_DISCHARG
Definition: cmbatt.h:63
NTSTATUS NTAPI CmBattGetBstData(PCMBATT_DEVICE_EXTENSION DeviceExtension, PACPI_BST_DATA BstData)
Definition: cmexec.c:334
#define CMBATT_PNP_INFO
Definition: cmbatt.h:40
#define IOCTL_BATTERY_QUERY_PSR
Definition: cmbatt.h:23
#define CMBATT_AR_NOTIFY
Definition: cmbatt.h:98
#define IOCTL_BATTERY_QUERY_UNIQUE_ID
Definition: cmbatt.h:17
NTSTATUS NTAPI CmBattPnpDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
struct _ACPI_BST_DATA ACPI_BST_DATA
#define ACPI_BATT_STAT_CHARGING
Definition: cmbatt.h:64
#define IOCTL_BATTERY_QUERY_BIF
Definition: cmbatt.h:29
#define ACPI_BATT_NOTIFY_STATUS
Definition: cmbatt.h:60
NTSTATUS NTAPI CmBattAddDevice(PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT DeviceObject)
NTSTATUS NTAPI CmBattSystemControl(PDEVICE_OBJECT DeviceObject, PIRP Irp)
#define ACPI_BATT_POWER_UNIT_AMPS
Definition: cmbatt.h:79
@ CmBattAcAdapter
Definition: cmbatt.h:47
@ CmBattBattery
Definition: cmbatt.h:48
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:36
_In_ PIRP Irp
Definition: csq.h:116
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
VOID NTAPI KeInitializeDpc(IN PKDPC Dpc, IN PKDEFERRED_ROUTINE DeferredRoutine, IN PVOID DeferredContext)
Definition: dpc.c:712
DRIVER_INITIALIZE DriverEntry
Definition: condrv.c:21
@ FdoExtension
Definition: precomp.h:48
#define ExAllocatePoolWithTag(hernya, size, tag)
Definition: env_spec_w32.h:350
#define ExFreePool(addr)
Definition: env_spec_w32.h:352
#define PagedPool
Definition: env_spec_w32.h:308
pRequest Complete(RequestStatus)
Status
Definition: gdiplustypes.h:25
VOID FASTCALL ExAcquireFastMutex(IN PFAST_MUTEX FastMutex)
Definition: fmutex.c:23
VOID FASTCALL ExReleaseFastMutex(IN PFAST_MUTEX FastMutex)
Definition: fmutex.c:31
#define DbgPrint
Definition: hal.h:12
#define OBJ_KERNEL_HANDLE
Definition: winternl.h:231
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
int Count
Definition: noreturn.cpp:7
NTSYSAPI VOID NTAPI RtlCopyUnicodeString(PUNICODE_STRING DestinationString, PUNICODE_STRING SourceString)
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
#define UNICODE_NULL
#define IoSkipCurrentIrpStackLocation(Irp)
Definition: ntifs_ex.h:421
VOID NTAPI ExUnregisterCallback(IN PVOID CallbackRegistrationHandle)
Definition: callback.c:636
PVOID NTAPI ExRegisterCallback(IN PCALLBACK_OBJECT CallbackObject, IN PCALLBACK_FUNCTION CallbackFunction, IN PVOID CallbackContext)
Definition: callback.c:556
NTSTATUS NTAPI ExCreateCallback(OUT PCALLBACK_OBJECT *CallbackObject, IN POBJECT_ATTRIBUTES ObjectAttributes, IN BOOLEAN Create, IN BOOLEAN AllowMultipleCallbacks)
Definition: callback.c:361
#define IoCompleteRequest
Definition: irp.c:1240
#define IoCallDriver
Definition: irp.c:1225
#define STATUS_INVALID_BUFFER_SIZE
Definition: ntstatus.h:650
#define STATUS_NOT_SUPPORTED
Definition: ntstatus.h:423
#define STATUS_DEVICE_REMOVED
Definition: ntstatus.h:809
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:239
#define L(x)
Definition: ntvdm.h:50
PPCI_DRIVER_EXTENSION DriverExtension
Definition: pci.c:31
long LONG
Definition: pedump.c:60
#define IRP_MJ_CLOSE
Definition: rdpdr.c:45
#define IRP_MJ_DEVICE_CONTROL
Definition: rdpdr.c:52
#define IRP_MJ_CREATE
Definition: rdpdr.c:44
#define KeQueryInterruptTime()
Definition: ke.h:37
#define STATUS_SUCCESS
Definition: shellext.h:65
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
#define DPRINT
Definition: sndvol32.h:73
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68
ULONG RemainingCapacity
Definition: cmbatt.h:74
ULONG LowCapacity
Definition: batclass.h:204
ULONG HighCapacity
Definition: batclass.h:205
ULONG PowerState
Definition: batclass.h:203
ULONG PowerState
Definition: batclass.h:154
ULONG Capacity
Definition: batclass.h:155
CMBATT_EXTENSION_TYPE FdoType
Definition: cmbatt.h:104
PDEVICE_OBJECT PdoDeviceObject
Definition: cmbatt.h:107
BOOLEAN DelayNotification
Definition: cmbatt.h:119
PDEVICE_OBJECT AttachedDevice
Definition: cmbatt.h:108
IO_REMOVE_LOCK RemoveLock
Definition: cmbatt.h:115
FAST_MUTEX FastMutex
Definition: cmbatt.h:109
PVOID DeviceExtension
Definition: env_spec_w32.h:418
union _IO_STACK_LOCATION::@1573 Parameters
struct _IO_STACK_LOCATION::@1573::@1574 DeviceIoControl
Definition: ketypes.h:699
USHORT MaximumLength
Definition: env_spec_w32.h:370
BOOLEAN NTAPI KeSetTimer(IN OUT PKTIMER Timer, IN LARGE_INTEGER DueTime, IN PKDPC Dpc OPTIONAL)
Definition: timerobj.c:281
VOID NTAPI KeInitializeTimer(OUT PKTIMER Timer)
Definition: timerobj.c:233
uint32_t * PULONG
Definition: typedefs.h:59
#define NTAPI
Definition: typedefs.h:36
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define IN
Definition: typedefs.h:39
uint32_t ULONG
Definition: typedefs.h:59
#define OUT
Definition: typedefs.h:40
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define STATUS_NO_SUCH_DEVICE
Definition: udferr_usr.h:136
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define STATUS_OBJECT_NAME_NOT_FOUND
Definition: udferr_usr.h:149
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055
_Must_inspect_result_ _In_ WDFDEVICE _In_ BOOLEAN _In_opt_ PVOID Tag
Definition: wdfdevice.h:4065
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ ULONG BufferLength
Definition: wdfdevice.h:3771
_Must_inspect_result_ _In_ PWDF_DPC_CONFIG _In_ PWDF_OBJECT_ATTRIBUTES _Out_ WDFDPC * Dpc
Definition: wdfdpc.h:112
_Must_inspect_result_ _In_ PDRIVER_OBJECT _In_ PCUNICODE_STRING RegistryPath
Definition: wdfdriver.h:215
_Must_inspect_result_ _In_ PDRIVER_OBJECT DriverObject
Definition: wdfdriver.h:213
_In_ WDFREQUEST _In_ size_t _In_ size_t _In_ ULONG IoControlCode
Definition: wdfio.h:325
_In_ WDFREQUEST _In_ size_t OutputBufferLength
Definition: wdfio.h:320
_In_ WDFREQUEST _In_ size_t _In_ size_t InputBufferLength
Definition: wdfio.h:322
_In_ WDFIOTARGET _In_ _Strict_type_match_ WDF_IO_TARGET_SENT_IO_ACTION Action
Definition: wdfiotarget.h:510
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:413
#define IoAcquireRemoveLock(RemoveLock, Tag)
#define IoReleaseRemoveLock(_RemoveLock, _Tag)
Definition: iofuncs.h:2764
#define IO_NO_INCREMENT
Definition: iotypes.h:598
#define IRP_MJ_SYSTEM_CONTROL
#define IRP_MJ_POWER
_In_opt_ PVOID _In_opt_ PVOID SystemArgument1
Definition: ketypes.h:688
_In_opt_ PVOID _In_opt_ PVOID _In_opt_ PVOID SystemArgument2
Definition: ketypes.h:689
#define ObDereferenceObject
Definition: obfuncs.h:203
#define PO_CB_SYSTEM_STATE_LOCK
unsigned char UCHAR
Definition: xmlstorage.h:181
__wchar_t WCHAR
Definition: xmlstorage.h:180