ReactOS  0.4.14-dev-98-gb0d4763
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

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

Referenced by CmBattAddBattery().

◆ CmBattGetBifData()

NTSTATUS NTAPI CmBattGetBifData ( PCMBATT_DEVICE_EXTENSION  DeviceExtension,
PACPI_BIF_DATA  BifData 
)

Definition at line 325 of file cmexec.c.

327 {
329  return STATUS_NOT_IMPLEMENTED;
330 }
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:225
#define UNIMPLEMENTED
Definition: debug.h:114

Referenced by CmBattIoctl().

◆ CmBattGetBstData()

NTSTATUS NTAPI CmBattGetBstData ( PCMBATT_DEVICE_EXTENSION  DeviceExtension,
PACPI_BST_DATA  BstData 
)

Definition at line 334 of file cmexec.c.

336 {
338  return STATUS_NOT_IMPLEMENTED;
339 }
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:225
#define UNIMPLEMENTED
Definition: debug.h:114

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 */
178  case ACPI_DEVICE_CHECK:
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;
234  DeviceObject;
235  DeviceObject = DeviceObject->NextDevice)
236  {
237  /* Is this a battery? */
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 TRUE
Definition: types.h:120
#define DbgPrint
Definition: loader.c:25
ULONG CmBattDebug
Definition: cmbatt.c:17
#define CMBATT_PNP_INFO
Definition: cmbatt.h:40
#define CMBATT_AR_INSERT
Definition: cmbatt.h:99
PVOID DeviceExtension
Definition: env_spec_w32.h:418
#define CMBATT_AR_REMOVE
Definition: cmbatt.h:100
BCLASSAPI NTSTATUS NTAPI BatteryClassStatusNotify(PVOID ClassData)
Definition: battc.c:79
#define BATTERY_UNKNOWN_CAPACITY
Definition: batclass.h:65
#define CMBATT_ACPI_WARNING
Definition: cmbatt.h:38
#define ACPI_BATT_NOTIFY_STATUS
Definition: cmbatt.h:60
#define ACPI_BATT_NOTIFY_INFO
Definition: cmbatt.h:61
#define CMBATT_AR_NOTIFY
Definition: cmbatt.h:98
#define ACPI_BUS_CHECK
Definition: cmbatt.h:51
#define InterlockedExchange
Definition: armddk.h:54
#define ACPI_DEVICE_CHECK
Definition: cmbatt.h:52
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
#define CMBATT_GENERIC_WARNING
Definition: cmbatt.h:37
#define CMBATT_ACPI_ASSERT
Definition: cmbatt.h:43
unsigned int ULONG
Definition: retypes.h:1

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 1000 of file cmbatt.c.

1007 {
1008  NTSTATUS Status;
1009  PVOID QueryData = NULL;
1010  ULONG QueryLength = 0;
1011  ULONG RemainingTime = 0;
1012  ANSI_STRING TempString;
1013  UNICODE_STRING TempString2;
1014  WCHAR InfoBuffer[256];
1015  WCHAR TempBuffer[256];
1016  UNICODE_STRING InfoString;
1017  ULONG RemainingCapacity;
1018  BATTERY_REPORTING_SCALE BatteryReportingScale[2];
1019  LONG Rate;
1020  PAGED_CODE();
1022  DbgPrint("CmBattQueryInformation - Tag (%d) Device %d, Informationlevel %d\n",
1023  Tag,
1024  FdoExtension->DeviceId,
1025  InfoLevel);
1026 
1027  /* Check ACPI Data */
1029  if (!NT_SUCCESS(Status)) return Status;
1030 
1031  /* Check what caller wants */
1032  switch (InfoLevel)
1033  {
1034  case BatteryInformation:
1035  /* Just return our static information */
1036  QueryData = &FdoExtension->BatteryInformation;
1037  QueryLength = sizeof(BATTERY_INFORMATION);
1038  break;
1039 
1041 
1042  /* Return our static information, we have two scales */
1043  BatteryReportingScale[0].Granularity = FdoExtension->BatteryCapacityGranularity1;
1044  BatteryReportingScale[0].Capacity = FdoExtension->BatteryInformation.DefaultAlert1;
1045  BatteryReportingScale[1].Granularity = FdoExtension->BatteryCapacityGranularity2;
1046  BatteryReportingScale[1].Capacity = FdoExtension->BatteryInformation.DesignedCapacity;
1047  QueryData = BatteryReportingScale;
1048  QueryLength = sizeof(BATTERY_REPORTING_SCALE) * 2;
1049  break;
1050 
1051  case BatteryEstimatedTime:
1052 
1053  /* Check if it's been more than 2 1/2 minutes since the last change */
1054  if ((KeQueryInterruptTime() - 150000000) > (FdoExtension->InterruptTime))
1055  {
1056  /* Get new battery status */
1058 
1059  /* If the caller didn't specify a rate, use our static one */
1060  Rate = AtRate;
1061  if (!Rate) Rate = FdoExtension->Rate;
1062 
1063  /* If we don't have a valid negative rate, use unknown value */
1064  if (Rate >= 0) Rate = BATTERY_UNKNOWN_RATE;
1065 
1066  /* Grab the remaining capacity */
1067  RemainingCapacity = FdoExtension->RemainingCapacity;
1068 
1069  /* See if we don't know one or the other */
1070  if ((Rate == BATTERY_UNKNOWN_RATE) ||
1071  (RemainingCapacity == BATTERY_UNKNOWN_CAPACITY))
1072  {
1073  /* If the battery is discharging, we can't give out a time */
1074  if ((FdoExtension->BstData.State & ACPI_BATT_STAT_DISCHARG) &&
1076  DbgPrint("CmBattQueryInformation: Can't calculate EstimatedTime.\n");
1077 
1078  /* Check if we don't have a rate and capacity is going down */
1079  if ((FdoExtension->Rate == BATTERY_UNKNOWN_RATE) &&
1080  (FdoExtension->BstData.State & ACPI_BATT_STAT_DISCHARG))
1081  {
1082  /* We have to fail, since we lack data */
1085  DbgPrint("---------------------- PresentRate = BATTERY_UNKNOWN_RATE\n");
1086  }
1087 
1088  /* If we don't have capacity, the rate is useless */
1089  if (RemainingCapacity == BATTERY_UNKNOWN_CAPACITY)
1090  {
1091  /* We have to fail the request */
1094  DbgPrint("---------------------- RemainingCapacity = BATTERY_UNKNOWN_CAPACITY\n");
1095  }
1096  }
1097  else
1098  {
1099  /* We have data, but is it valid? */
1100  if (RemainingCapacity > 0x123456)
1101  {
1102  /* The capacity seems bogus, so don't use it */
1104  DbgPrint("CmBattQueryInformation: Data Overflow in calculating Remaining Capacity.\n");
1105  }
1106  else
1107  {
1108  /* Compute the remaining time in seconds, based on rate */
1109  RemainingTime = (RemainingCapacity * 3600) / -Rate;
1110  }
1111  }
1112  }
1113 
1114  /* Return the remaining time */
1115  QueryData = &RemainingTime;
1116  QueryLength = sizeof(ULONG);
1117  break;
1118 
1119  case BatteryDeviceName:
1120 
1121  /* Build the model number string */
1122  RtlInitAnsiString(&TempString, FdoExtension->ModelNumber);
1123 
1124  /* Convert it to Unicode */
1125  InfoString.Buffer = InfoBuffer;
1126  InfoString.MaximumLength = sizeof(InfoBuffer);
1127  Status = RtlAnsiStringToUnicodeString(&InfoString, &TempString, 0);
1128 
1129  /* Return the unicode buffer */
1130  QueryData = InfoString.Buffer;
1131  QueryLength = InfoString.Length;
1132  break;
1133 
1134  case BatteryTemperature:
1136 
1137  /* We don't support these */
1139  break;
1140 
1142 
1143  /* Build the OEM info string */
1144  RtlInitAnsiString(&TempString, FdoExtension->OemInfo);
1145 
1146  /* Convert it to Unicode */
1147  InfoString.Buffer = InfoBuffer;
1148  InfoString.MaximumLength = sizeof(InfoBuffer);
1149  Status = RtlAnsiStringToUnicodeString(&InfoString, &TempString, 0);
1150 
1151  /* Return the unicode buffer */
1152  QueryData = InfoString.Buffer;
1153  QueryLength = InfoString.Length;
1154  break;
1155 
1156  case BatteryUniqueID:
1157 
1158  /* Build the serial number string */
1159  RtlInitAnsiString(&TempString, FdoExtension->SerialNumber);
1160 
1161  /* Convert it to Unicode */
1162  InfoString.Buffer = InfoBuffer;
1163  InfoString.MaximumLength = sizeof(InfoBuffer);
1164  RtlAnsiStringToUnicodeString(&InfoString, &TempString, 0);
1165 
1166  /* Setup a temporary string for concatenation */
1167  TempString2.Buffer = TempBuffer;
1168  TempString2.MaximumLength = sizeof(TempBuffer);
1169 
1170  /* Check if there's an OEM string */
1171  if (FdoExtension->OemInfo[0])
1172  {
1173  /* Build the OEM info string */
1174  RtlInitAnsiString(&TempString, FdoExtension->OemInfo);
1175 
1176  /* Convert it to Unicode and append it */
1177  RtlAnsiStringToUnicodeString(&TempString2, &TempString, 0);
1178  RtlAppendUnicodeStringToString(&InfoString, &TempString2);
1179  }
1180 
1181  /* Build the model number string */
1182  RtlInitAnsiString(&TempString, FdoExtension->ModelNumber);
1183 
1184  /* Convert it to Unicode and append it */
1185  RtlAnsiStringToUnicodeString(&TempString2, &TempString, 0);
1186  RtlAppendUnicodeStringToString(&InfoString, &TempString2);
1187 
1188  /* Return the final appended string */
1189  QueryData = InfoString.Buffer;
1190  QueryLength = InfoString.Length;
1191  break;
1192 
1193  default:
1194 
1195  /* Everything else is unknown */
1197  break;
1198  }
1199 
1200  /* Return the required length and check if the caller supplied enough */
1201  *ReturnedLength = QueryLength;
1202  if (BufferLength < QueryLength) Status = STATUS_BUFFER_TOO_SMALL;
1203 
1204  /* Copy the data if there's enough space and it exists */
1205  if ((NT_SUCCESS(Status)) && (QueryData)) RtlCopyMemory(Buffer, QueryData, QueryLength);
1206 
1207  /* Return function result */
1208  return Status;
1209 }
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
NTSTATUS NTAPI CmBattGetBatteryStatus(IN PCMBATT_DEVICE_EXTENSION DeviceExtension, IN ULONG Tag)
Definition: cmbatt.c:782
struct _BATTERY_INFORMATION BATTERY_INFORMATION
#define DbgPrint
Definition: loader.c:25
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
NTSTATUS NTAPI CmBattVerifyStaticInfo(PCMBATT_DEVICE_EXTENSION DeviceExtension, ULONG BatteryTag)
Definition: cmbatt.c:278
LONG NTSTATUS
Definition: precomp.h:26
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
#define ACPI_BATT_STAT_DISCHARG
Definition: cmbatt.h:63
ULONG CmBattDebug
Definition: cmbatt.c:17
#define PAGED_CODE()
Definition: video.h:57
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:64
NTSYSAPI VOID NTAPI RtlInitAnsiString(PANSI_STRING DestinationString, PCSZ SourceString)
long LONG
Definition: pedump.c:60
_In_ ULONG BufferLength
Definition: usbdlib.h:225
smooth NULL
Definition: ftsmooth.c:416
#define BATTERY_UNKNOWN_CAPACITY
Definition: batclass.h:65
Definition: bufpool.h:45
#define CMBATT_ACPI_WARNING
Definition: cmbatt.h:38
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
_In_ ULONG _In_ BATTERY_QUERY_INFORMATION_LEVEL _In_ LONG AtRate
Definition: batclass.h:183
#define BATTERY_UNKNOWN_RATE
Definition: batclass.h:82
_In_ ULONG _In_ BATTERY_QUERY_INFORMATION_LEVEL _In_ LONG _In_ ULONG _Out_ PULONG ReturnedLength
Definition: batclass.h:187
#define CMBATT_GENERIC_INFO
Definition: cmbatt.h:36
Status
Definition: gdiplustypes.h:24
#define CMBATT_GENERIC_WARNING
Definition: cmbatt.h:37
NTSYSAPI NTSTATUS NTAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING DestinationString, PANSI_STRING SourceString, BOOLEAN AllocateDestinationString)
NTSYSAPI NTSTATUS NTAPI RtlAppendUnicodeStringToString(PUNICODE_STRING Destination, PUNICODE_STRING Source)
IN ULONG IN ULONG Tag
Definition: evtlib.h:159
unsigned int ULONG
Definition: retypes.h:1
ULONGLONG NTAPI KeQueryInterruptTime(VOID)
Definition: clock.c:203

Referenced by CmBattAddBattery().

◆ CmBattQueryStatus()

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

Definition at line 1213 of file cmbatt.c.

1216 {
1217  NTSTATUS Status;
1218  PAGED_CODE();
1220  DbgPrint("CmBattQueryStatus - Tag (%d) Device %x\n", Tag, DeviceExtension->DeviceId);
1221 
1222  /* Query ACPI information */
1223  Status = CmBattGetBatteryStatus(DeviceExtension, Tag);
1224  if (NT_SUCCESS(Status))
1225  {
1226  BatteryStatus->PowerState = DeviceExtension->State;
1227  BatteryStatus->Capacity = DeviceExtension->RemainingCapacity;
1228  BatteryStatus->Voltage = DeviceExtension->PresentVoltage;
1229  BatteryStatus->Rate = DeviceExtension->Rate;
1230  }
1231 
1232  /* Return status */
1234  DbgPrint("CmBattQueryStatus: Returning [%#08lx][%#08lx][%#08lx][%#08lx]\n",
1238  BatteryStatus->Rate);
1239  return Status;
1240 }
_In_ ULONG _Out_ PBATTERY_STATUS BatteryStatus
Definition: batclass.h:198
NTSTATUS NTAPI CmBattGetBatteryStatus(IN PCMBATT_DEVICE_EXTENSION DeviceExtension, IN ULONG Tag)
Definition: cmbatt.c:782
#define DbgPrint
Definition: loader.c:25
ULONG PowerState
Definition: batclass.h:154
LONG NTSTATUS
Definition: precomp.h:26
ULONG CmBattDebug
Definition: cmbatt.c:17
#define PAGED_CODE()
Definition: video.h:57
#define CMBATT_ACPI_WARNING
Definition: cmbatt.h:38
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define CMBATT_GENERIC_INFO
Definition: cmbatt.h:36
ULONG Capacity
Definition: batclass.h:155
Status
Definition: gdiplustypes.h:24
IN ULONG IN ULONG Tag
Definition: evtlib.h:159

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 DbgPrint
Definition: loader.c:25
LONG NTSTATUS
Definition: precomp.h:26
ULONG CmBattDebug
Definition: cmbatt.c:17
#define PAGED_CODE()
Definition: video.h:57
#define BATTERY_UNKNOWN_CAPACITY
Definition: batclass.h:65
#define ACPI_STA_BATTERY_PRESENT
Definition: actypes.h:1319
#define CMBATT_ACPI_WARNING
Definition: cmbatt.h:38
NTSTATUS NTAPI CmBattGetStaData(PDEVICE_OBJECT DeviceObject, PULONG StaData)
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_NO_SUCH_DEVICE
Definition: udferr_usr.h:136
#define CMBATT_GENERIC_INFO
Definition: cmbatt.h:36
#define InterlockedExchange
Definition: armddk.h:54
Status
Definition: gdiplustypes.h:24
IN ULONG IN ULONG Tag
Definition: evtlib.h:159
unsigned int ULONG
Definition: retypes.h:1
ULONGLONG NTAPI KeQueryInterruptTime(VOID)
Definition: clock.c:203

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");
663  return STATUS_NOT_SUPPORTED;
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);
765  CmBattNotifyHandler(DeviceExtension, ACPI_BATT_NOTIFY_STATUS);
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 %x\n",
777  return Status;
778 }
ULONG RemainingCapacity
Definition: cmbatt.h:74
NTSTATUS NTAPI CmBattGetBstData(PCMBATT_DEVICE_EXTENSION DeviceExtension, PACPI_BST_DATA BstData)
Definition: cmexec.c:334
#define DbgPrint
Definition: loader.c:25
VOID NTAPI CmBattNotifyHandler(IN PCMBATT_DEVICE_EXTENSION DeviceExtension, IN ULONG NotifyValue)
Definition: cmbatt.c:142
NTSTATUS NTAPI CmBattVerifyStaticInfo(PCMBATT_DEVICE_EXTENSION DeviceExtension, ULONG BatteryTag)
Definition: cmbatt.c:278
LONG NTSTATUS
Definition: precomp.h:26
_In_ ULONG _In_ PBATTERY_NOTIFY BatteryNotify
Definition: batclass.h:215
_Out_ PULONG BatteryTag
Definition: batclass.h:173
ULONG CmBattDebug
Definition: cmbatt.c:17
#define PAGED_CODE()
Definition: video.h:57
unsigned char BOOLEAN
#define BATTERY_UNKNOWN_CAPACITY
Definition: batclass.h:65
ULONG HighCapacity
Definition: batclass.h:205
#define CMBATT_ACPI_WARNING
Definition: cmbatt.h:38
ULONG PowerState
Definition: batclass.h:203
#define BATTERY_UNKNOWN_VOLTAGE
Definition: batclass.h:79
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define ACPI_BATT_NOTIFY_STATUS
Definition: cmbatt.h:60
NTSTATUS NTAPI CmBattSetTripPpoint(PCMBATT_DEVICE_EXTENSION DeviceExtension, ULONG AlarmValue)
#define CMBATT_GENERIC_INFO
Definition: cmbatt.h:36
#define CMBATT_GENERIC_STATUS
Definition: cmbatt.h:35
Status
Definition: gdiplustypes.h:24
ULONG LowCapacity
Definition: batclass.h:204
#define STATUS_OBJECT_NAME_NOT_FOUND
Definition: udferr_usr.h:149
#define CMBATT_GENERIC_WARNING
Definition: cmbatt.h:37
#define STATUS_NOT_SUPPORTED
Definition: ntstatus.h:409
unsigned int ULONG
Definition: retypes.h:1
return STATUS_SUCCESS
Definition: btrfs.c:2966
#define ACPI_BATT_STAT_CHARGING
Definition: cmbatt.h:64
#define ACPI_BATT_POWER_UNIT_AMPS
Definition: cmbatt.h:79

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

◆ CmBattDebug