ReactOS 0.4.15-dev-7942-gd23573b
cmbatt.h File Reference
#include <wdm.h>
#include <batclass.h>
#include <wmilib.h>
#include <wdmguid.h>
Include dependency graph for cmbatt.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  _ACPI_BST_DATA
 
struct  _ACPI_BIF_DATA
 
struct  _CMBATT_DEVICE_EXTENSION
 

Macros

#define IOCTL_BATTERY_QUERY_UNIQUE_ID    CTL_CODE(FILE_DEVICE_BATTERY, 0x101, METHOD_BUFFERED, FILE_READ_ACCESS)
 
#define IOCTL_BATTERY_QUERY_STA    CTL_CODE(FILE_DEVICE_BATTERY, 0x102, METHOD_BUFFERED, FILE_READ_ACCESS)
 
#define IOCTL_BATTERY_QUERY_PSR    CTL_CODE(FILE_DEVICE_BATTERY, 0x103, METHOD_BUFFERED, FILE_READ_ACCESS)
 
#define IOCTL_BATTERY_SET_TRIP_POINT    CTL_CODE(FILE_DEVICE_BATTERY, 0x104, METHOD_BUFFERED, FILE_READ_ACCESS)
 
#define IOCTL_BATTERY_QUERY_BIF    CTL_CODE(FILE_DEVICE_BATTERY, 0x105, METHOD_BUFFERED, FILE_READ_ACCESS)
 
#define IOCTL_BATTERY_QUERY_BST    CTL_CODE(FILE_DEVICE_BATTERY, 0x106, METHOD_BUFFERED, FILE_READ_ACCESS)
 
#define CMBATT_GENERIC_STATUS   0x01
 
#define CMBATT_GENERIC_INFO   0x02
 
#define CMBATT_GENERIC_WARNING   0x04
 
#define CMBATT_ACPI_WARNING   0x08
 
#define CMBATT_POWER_INFO   0x10
 
#define CMBATT_PNP_INFO   0x20
 
#define CMBATT_ACPI_ENTRY_EXIT   0x40
 
#define CMBATT_PNP_ENTRY_EXIT   0x200
 
#define CMBATT_ACPI_ASSERT   0x400
 
#define ACPI_BUS_CHECK   0x00
 
#define ACPI_DEVICE_CHECK   0x01
 
#define ACPI_STA_PRESENT   0x01
 
#define ACPI_STA_ENABLED   0x02
 
#define ACPI_STA_SHOW_UI   0x04
 
#define ACPI_STA_FUNCTIONAL   0x08
 
#define ACPI_STA_BATTERY_PRESENT   0x10
 
#define ACPI_BATT_NOTIFY_STATUS   0x80
 
#define ACPI_BATT_NOTIFY_INFO   0x81
 
#define ACPI_BATT_STAT_DISCHARG   0x0001
 
#define ACPI_BATT_STAT_CHARGING   0x0002
 
#define ACPI_BATT_STAT_CRITICAL   0x0004
 
#define CM_MAX_VALUE   0x7FFFFFFF
 
#define CM_UNKNOWN_VALUE   0xFFFFFFFF
 
#define ACPI_BATT_POWER_UNIT_WATTS   0x0
 
#define ACPI_BATT_POWER_UNIT_AMPS   0x1
 
#define CMBATT_AR_NOTIFY   0x01
 
#define CMBATT_AR_INSERT   0x02
 
#define CMBATT_AR_REMOVE   0x04
 

Typedefs

typedef enum _CMBATT_EXTENSION_TYPE CMBATT_EXTENSION_TYPE
 
typedef struct _ACPI_BST_DATA ACPI_BST_DATA
 
typedef struct _ACPI_BST_DATAPACPI_BST_DATA
 
typedef struct _ACPI_BIF_DATA ACPI_BIF_DATA
 
typedef struct _ACPI_BIF_DATAPACPI_BIF_DATA
 
typedef struct _CMBATT_DEVICE_EXTENSION CMBATT_DEVICE_EXTENSION
 
typedef struct _CMBATT_DEVICE_EXTENSIONPCMBATT_DEVICE_EXTENSION
 

Enumerations

enum  _CMBATT_EXTENSION_TYPE { CmBattAcAdapter , CmBattBattery }
 

Functions

NTSTATUS NTAPI CmBattPowerDispatch (PDEVICE_OBJECT DeviceObject, PIRP Irp)
 
NTSTATUS NTAPI CmBattPnpDispatch (PDEVICE_OBJECT DeviceObject, PIRP Irp)
 
NTSTATUS NTAPI CmBattAddDevice (PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT DeviceObject)
 
NTSTATUS NTAPI CmBattSystemControl (PDEVICE_OBJECT DeviceObject, PIRP Irp)
 
NTSTATUS NTAPI CmBattGetBstData (PCMBATT_DEVICE_EXTENSION DeviceExtension, PACPI_BST_DATA BstData)
 
NTSTATUS NTAPI CmBattGetPsrData (PDEVICE_OBJECT DeviceObject, PULONG PsrData)
 
NTSTATUS NTAPI CmBattGetStaData (PDEVICE_OBJECT DeviceObject, PULONG StaData)
 
NTSTATUS NTAPI CmBattGetBifData (PCMBATT_DEVICE_EXTENSION DeviceExtension, PACPI_BIF_DATA BifData)
 
NTSTATUS NTAPI CmBattSetTripPpoint (PCMBATT_DEVICE_EXTENSION DeviceExtension, ULONG AlarmValue)
 
VOID NTAPI CmBattNotifyHandler (IN PCMBATT_DEVICE_EXTENSION DeviceExtension, IN ULONG NotifyValue)
 
NTSTATUS NTAPI CmBattWmiDeRegistration (PCMBATT_DEVICE_EXTENSION DeviceExtension)
 
NTSTATUS NTAPI CmBattWmiRegistration (PCMBATT_DEVICE_EXTENSION DeviceExtension)
 
NTSTATUS NTAPI CmBattGetUniqueId (PDEVICE_OBJECT DeviceObject, PULONG UniqueId)
 
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)
 
NTSTATUS NTAPI CmBattQueryStatus (IN PCMBATT_DEVICE_EXTENSION DeviceExtension, IN ULONG Tag, IN PBATTERY_STATUS BatteryStatus)
 
NTSTATUS NTAPI CmBattSetStatusNotify (IN PCMBATT_DEVICE_EXTENSION DeviceExtension, IN ULONG BatteryTag, IN PBATTERY_NOTIFY BatteryNotify)
 
NTSTATUS NTAPI CmBattDisableStatusNotify (IN PCMBATT_DEVICE_EXTENSION DeviceExtension)
 
NTSTATUS NTAPI CmBattQueryTag (IN PCMBATT_DEVICE_EXTENSION DeviceExtension, OUT PULONG Tag)
 

Variables

PDEVICE_OBJECT AcAdapterPdo
 
ULONG CmBattDebug
 

Macro Definition Documentation

◆ ACPI_BATT_NOTIFY_INFO

#define ACPI_BATT_NOTIFY_INFO   0x81

Definition at line 61 of file cmbatt.h.

◆ ACPI_BATT_NOTIFY_STATUS

#define ACPI_BATT_NOTIFY_STATUS   0x80

Definition at line 60 of file cmbatt.h.

◆ ACPI_BATT_POWER_UNIT_AMPS

#define ACPI_BATT_POWER_UNIT_AMPS   0x1

Definition at line 79 of file cmbatt.h.

◆ ACPI_BATT_POWER_UNIT_WATTS

#define ACPI_BATT_POWER_UNIT_WATTS   0x0

Definition at line 78 of file cmbatt.h.

◆ ACPI_BATT_STAT_CHARGING

#define ACPI_BATT_STAT_CHARGING   0x0002

Definition at line 64 of file cmbatt.h.

◆ ACPI_BATT_STAT_CRITICAL

#define ACPI_BATT_STAT_CRITICAL   0x0004

Definition at line 65 of file cmbatt.h.

◆ ACPI_BATT_STAT_DISCHARG

#define ACPI_BATT_STAT_DISCHARG   0x0001

Definition at line 63 of file cmbatt.h.

◆ ACPI_BUS_CHECK

#define ACPI_BUS_CHECK   0x00

Definition at line 51 of file cmbatt.h.

◆ ACPI_DEVICE_CHECK

#define ACPI_DEVICE_CHECK   0x01

Definition at line 52 of file cmbatt.h.

◆ ACPI_STA_BATTERY_PRESENT

#define ACPI_STA_BATTERY_PRESENT   0x10

Definition at line 58 of file cmbatt.h.

◆ ACPI_STA_ENABLED

#define ACPI_STA_ENABLED   0x02

Definition at line 55 of file cmbatt.h.

◆ ACPI_STA_FUNCTIONAL

#define ACPI_STA_FUNCTIONAL   0x08

Definition at line 57 of file cmbatt.h.

◆ ACPI_STA_PRESENT

#define ACPI_STA_PRESENT   0x01

Definition at line 54 of file cmbatt.h.

◆ ACPI_STA_SHOW_UI

#define ACPI_STA_SHOW_UI   0x04

Definition at line 56 of file cmbatt.h.

◆ CM_MAX_VALUE

#define CM_MAX_VALUE   0x7FFFFFFF

Definition at line 67 of file cmbatt.h.

◆ CM_UNKNOWN_VALUE

#define CM_UNKNOWN_VALUE   0xFFFFFFFF

Definition at line 68 of file cmbatt.h.

◆ CMBATT_ACPI_ASSERT

#define CMBATT_ACPI_ASSERT   0x400

Definition at line 43 of file cmbatt.h.

◆ CMBATT_ACPI_ENTRY_EXIT

#define CMBATT_ACPI_ENTRY_EXIT   0x40

Definition at line 41 of file cmbatt.h.

◆ CMBATT_ACPI_WARNING

#define CMBATT_ACPI_WARNING   0x08

Definition at line 38 of file cmbatt.h.

◆ CMBATT_AR_INSERT

#define CMBATT_AR_INSERT   0x02

Definition at line 99 of file cmbatt.h.

◆ CMBATT_AR_NOTIFY

#define CMBATT_AR_NOTIFY   0x01

Definition at line 98 of file cmbatt.h.

◆ CMBATT_AR_REMOVE

#define CMBATT_AR_REMOVE   0x04

Definition at line 100 of file cmbatt.h.

◆ CMBATT_GENERIC_INFO

#define CMBATT_GENERIC_INFO   0x02

Definition at line 36 of file cmbatt.h.

◆ CMBATT_GENERIC_STATUS

#define CMBATT_GENERIC_STATUS   0x01

Definition at line 35 of file cmbatt.h.

◆ CMBATT_GENERIC_WARNING

#define CMBATT_GENERIC_WARNING   0x04

Definition at line 37 of file cmbatt.h.

◆ CMBATT_PNP_ENTRY_EXIT

#define CMBATT_PNP_ENTRY_EXIT   0x200

Definition at line 42 of file cmbatt.h.

◆ CMBATT_PNP_INFO

#define CMBATT_PNP_INFO   0x20

Definition at line 40 of file cmbatt.h.

◆ CMBATT_POWER_INFO

#define CMBATT_POWER_INFO   0x10

Definition at line 39 of file cmbatt.h.

◆ IOCTL_BATTERY_QUERY_BIF

#define IOCTL_BATTERY_QUERY_BIF    CTL_CODE(FILE_DEVICE_BATTERY, 0x105, METHOD_BUFFERED, FILE_READ_ACCESS)

Definition at line 29 of file cmbatt.h.

◆ IOCTL_BATTERY_QUERY_BST

#define IOCTL_BATTERY_QUERY_BST    CTL_CODE(FILE_DEVICE_BATTERY, 0x106, METHOD_BUFFERED, FILE_READ_ACCESS)

Definition at line 32 of file cmbatt.h.

◆ IOCTL_BATTERY_QUERY_PSR

#define IOCTL_BATTERY_QUERY_PSR    CTL_CODE(FILE_DEVICE_BATTERY, 0x103, METHOD_BUFFERED, FILE_READ_ACCESS)

Definition at line 23 of file cmbatt.h.

◆ IOCTL_BATTERY_QUERY_STA

#define IOCTL_BATTERY_QUERY_STA    CTL_CODE(FILE_DEVICE_BATTERY, 0x102, METHOD_BUFFERED, FILE_READ_ACCESS)

Definition at line 20 of file cmbatt.h.

◆ IOCTL_BATTERY_QUERY_UNIQUE_ID

#define IOCTL_BATTERY_QUERY_UNIQUE_ID    CTL_CODE(FILE_DEVICE_BATTERY, 0x101, METHOD_BUFFERED, FILE_READ_ACCESS)

Definition at line 17 of file cmbatt.h.

◆ IOCTL_BATTERY_SET_TRIP_POINT

#define IOCTL_BATTERY_SET_TRIP_POINT    CTL_CODE(FILE_DEVICE_BATTERY, 0x104, METHOD_BUFFERED, FILE_READ_ACCESS)

Definition at line 26 of file cmbatt.h.

Typedef Documentation

◆ ACPI_BIF_DATA

◆ ACPI_BST_DATA

◆ CMBATT_DEVICE_EXTENSION

◆ CMBATT_EXTENSION_TYPE

◆ PACPI_BIF_DATA

◆ PACPI_BST_DATA

◆ PCMBATT_DEVICE_EXTENSION

Enumeration Type Documentation

◆ _CMBATT_EXTENSION_TYPE

Enumerator
CmBattAcAdapter 
CmBattBattery 

Definition at line 45 of file cmbatt.h.

46{
enum _CMBATT_EXTENSION_TYPE CMBATT_EXTENSION_TYPE
@ CmBattAcAdapter
Definition: cmbatt.h:47
@ CmBattBattery
Definition: cmbatt.h:48

Function Documentation

◆ CmBattAddDevice()

NTSTATUS NTAPI CmBattAddDevice ( PDRIVER_OBJECT  DriverObject,
PDEVICE_OBJECT  DeviceObject 
)

Referenced by DriverEntry().

◆ CmBattDisableStatusNotify()

NTSTATUS NTAPI CmBattDisableStatusNotify ( IN PCMBATT_DEVICE_EXTENSION  DeviceExtension)

Definition at line 595 of file cmbatt.c.

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}
#define PAGED_CODE()
LONG NTSTATUS
Definition: precomp.h:26
#define BATTERY_UNKNOWN_CAPACITY
Definition: batclass.h:65
ULONG CmBattDebug
Definition: cmbatt.c:17
NTSTATUS NTAPI CmBattSetTripPpoint(PCMBATT_DEVICE_EXTENSION DeviceExtension, ULONG AlarmValue)
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
Status
Definition: gdiplustypes.h:25
#define DbgPrint
Definition: hal.h:12
#define STATUS_SUCCESS
Definition: shellext.h:65
#define STATUS_OBJECT_NAME_NOT_FOUND
Definition: udferr_usr.h:149

Referenced by CmBattAddBattery().

◆ CmBattGetBifData()

NTSTATUS NTAPI CmBattGetBifData ( PCMBATT_DEVICE_EXTENSION  DeviceExtension,
PACPI_BIF_DATA  BifData 
)

Definition at line 325 of file cmexec.c.

327{
330}
#define UNIMPLEMENTED
Definition: debug.h:115
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:239

Referenced by CmBattIoctl().

◆ CmBattGetBstData()

NTSTATUS NTAPI CmBattGetBstData ( PCMBATT_DEVICE_EXTENSION  DeviceExtension,
PACPI_BST_DATA  BstData 
)

Definition at line 334 of file cmexec.c.

336{
339}

Referenced by CmBattGetBatteryStatus(), CmBattIoctl(), and CmBattSetStatusNotify().

◆ CmBattGetPsrData()

NTSTATUS NTAPI CmBattGetPsrData ( PDEVICE_OBJECT  DeviceObject,
PULONG  PsrData 
)

◆ CmBattGetStaData()

NTSTATUS NTAPI CmBattGetStaData ( PDEVICE_OBJECT  DeviceObject,
PULONG  StaData 
)

Referenced by CmBattIoctl(), and CmBattQueryTag().

◆ CmBattGetUniqueId()

NTSTATUS NTAPI CmBattGetUniqueId ( PDEVICE_OBJECT  DeviceObject,
PULONG  UniqueId 
)

Referenced by CmBattCreateFdo(), and CmBattIoctl().

◆ CmBattNotifyHandler()

VOID NTAPI CmBattNotifyHandler ( IN PCMBATT_DEVICE_EXTENSION  DeviceExtension,
IN ULONG  NotifyValue 
)

Definition at line 142 of file cmbatt.c.

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}
#define InterlockedExchange
Definition: armddk.h:54
BCLASSAPI NTSTATUS NTAPI BatteryClassStatusNotify(PVOID ClassData)
Definition: battc.c:79
#define ACPI_BUS_CHECK
Definition: cmbatt.h:51
#define CMBATT_ACPI_WARNING
Definition: cmbatt.h:38
#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 CMBATT_AR_REMOVE
Definition: cmbatt.h:100
#define ACPI_DEVICE_CHECK
Definition: cmbatt.h:52
#define CMBATT_GENERIC_WARNING
Definition: cmbatt.h:37
#define CMBATT_PNP_INFO
Definition: cmbatt.h:40
#define CMBATT_AR_NOTIFY
Definition: cmbatt.h:98
#define ACPI_BATT_NOTIFY_STATUS
Definition: cmbatt.h:60
#define TRUE
Definition: types.h:120
@ FdoExtension
Definition: precomp.h:48
uint32_t ULONG
Definition: typedefs.h:59
_In_ PDEVICE_OBJECT DeviceObject
Definition: wdfdevice.h:2055

Referenced by CmBattAddAcAdapter(), CmBattAddBattery(), CmBattGetBatteryStatus(), CmBattRemoveDevice(), and CmBattSetStatusNotify().

◆ CmBattPnpDispatch()

NTSTATUS NTAPI CmBattPnpDispatch ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp 
)

Referenced by DriverEntry().

◆ CmBattPowerDispatch()

NTSTATUS NTAPI CmBattPowerDispatch ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp 
)

Referenced by DriverEntry().

◆ CmBattQueryInformation()

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 at line 1001 of file cmbatt.c.

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}
_In_ ULONG _In_ BATTERY_QUERY_INFORMATION_LEVEL _In_ LONG _In_ ULONG _Out_ PULONG ReturnedLength
Definition: batclass.h:188
_In_ ULONG _In_ BATTERY_QUERY_INFORMATION_LEVEL _In_ LONG AtRate
Definition: batclass.h:185
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_UNKNOWN_RATE
Definition: batclass.h:82
Definition: bufpool.h:45
NTSTATUS NTAPI CmBattGetBatteryStatus(IN PCMBATT_DEVICE_EXTENSION DeviceExtension, IN ULONG Tag)
Definition: cmbatt.c:783
NTSTATUS NTAPI CmBattVerifyStaticInfo(PCMBATT_DEVICE_EXTENSION DeviceExtension, ULONG BatteryTag)
Definition: cmbatt.c:278
#define CMBATT_GENERIC_INFO
Definition: cmbatt.h:36
#define ACPI_BATT_STAT_DISCHARG
Definition: cmbatt.h:63
#define NULL
Definition: types.h:112
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 RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
long LONG
Definition: pedump.c:60
#define KeQueryInterruptTime()
Definition: ke.h:37
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define RtlCopyMemory(Destination, Source, Length)
Definition: typedefs.h:263
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
_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
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by CmBattAddBattery().

◆ CmBattQueryStatus()

NTSTATUS NTAPI CmBattQueryStatus ( IN PCMBATT_DEVICE_EXTENSION  DeviceExtension,
IN ULONG  Tag,
IN PBATTERY_STATUS  BatteryStatus 
)

Definition at line 1214 of file cmbatt.c.

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}
_In_ ULONG _Out_ PBATTERY_STATUS BatteryStatus
Definition: batclass.h:199
ULONG PowerState
Definition: batclass.h:154
ULONG Capacity
Definition: batclass.h:155

Referenced by CmBattAddBattery().

◆ CmBattQueryTag()

NTSTATUS NTAPI CmBattQueryTag ( IN PCMBATT_DEVICE_EXTENSION  DeviceExtension,
OUT PULONG  Tag 
)

Definition at line 536 of file cmbatt.c.

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}
#define ACPI_STA_BATTERY_PRESENT
Definition: actypes.h:1344
NTSTATUS NTAPI CmBattGetStaData(PDEVICE_OBJECT DeviceObject, PULONG StaData)
#define STATUS_NO_SUCH_DEVICE
Definition: udferr_usr.h:136

Referenced by CmBattAddBattery().

◆ CmBattSetStatusNotify()

NTSTATUS NTAPI CmBattSetStatusNotify ( IN PCMBATT_DEVICE_EXTENSION  DeviceExtension,
IN ULONG  BatteryTag,
IN PBATTERY_NOTIFY  BatteryNotify 
)

Definition at line 636 of file cmbatt.c.

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}
unsigned char BOOLEAN
_In_ ULONG _In_ PBATTERY_NOTIFY BatteryNotify
Definition: batclass.h:216
_Out_ PULONG BatteryTag
Definition: batclass.h:173
#define BATTERY_UNKNOWN_VOLTAGE
Definition: batclass.h:79
VOID NTAPI CmBattNotifyHandler(IN PCMBATT_DEVICE_EXTENSION DeviceExtension, IN ULONG NotifyValue)
Definition: cmbatt.c:142
#define CMBATT_GENERIC_STATUS
Definition: cmbatt.h:35
NTSTATUS NTAPI CmBattGetBstData(PCMBATT_DEVICE_EXTENSION DeviceExtension, PACPI_BST_DATA BstData)
Definition: cmexec.c:334
#define ACPI_BATT_STAT_CHARGING
Definition: cmbatt.h:64
#define ACPI_BATT_POWER_UNIT_AMPS
Definition: cmbatt.h:79
#define STATUS_NOT_SUPPORTED
Definition: ntstatus.h:423
ULONG RemainingCapacity
Definition: cmbatt.h:74
ULONG LowCapacity
Definition: batclass.h:204
ULONG HighCapacity
Definition: batclass.h:205
ULONG PowerState
Definition: batclass.h:203

Referenced by CmBattAddBattery().

◆ CmBattSetTripPpoint()

NTSTATUS NTAPI CmBattSetTripPpoint ( PCMBATT_DEVICE_EXTENSION  DeviceExtension,
ULONG  AlarmValue 
)

◆ CmBattSystemControl()

NTSTATUS NTAPI CmBattSystemControl ( PDEVICE_OBJECT  DeviceObject,
PIRP  Irp 
)

Referenced by DriverEntry().

◆ CmBattWmiDeRegistration()

NTSTATUS NTAPI CmBattWmiDeRegistration ( PCMBATT_DEVICE_EXTENSION  DeviceExtension)

◆ CmBattWmiRegistration()

NTSTATUS NTAPI CmBattWmiRegistration ( PCMBATT_DEVICE_EXTENSION  DeviceExtension)

Variable Documentation

◆ AcAdapterPdo

PDEVICE_OBJECT AcAdapterPdo
extern

◆ CmBattDebug