#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:

Classes
struct	_ACPI_BST_DATA

struct	_ACPI_BIF_DATA

struct	_ACPI_BIX_DATA

struct	_ACPI_BATT_STATIC_INFO

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_BIX 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	CMBATT_DISCHARGE_TIME 150000000

#define	CMBATT_CAPACITY_BOGUS 0x100000

#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	CONVERT_MAH_TO_MWH(mA, Volts) (((mA) * (Volts) + 500) / 1000)

#define	CONVERT_BATT_INFO(Capacity, DesignVoltage)

#define	ACPI_BATT_POWER_UNIT_WATTS 0x0

#define	ACPI_BATT_POWER_UNIT_AMPS 0x1

#define	ASCIIZ_MAX_LENGTH 256

#define	CMBATT_BATT_STATIC_INFO_TAG 'nItS'

#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_DATA *	PACPI_BST_DATA

typedef struct _ACPI_BIF_DATA	ACPI_BIF_DATA

typedef struct _ACPI_BIF_DATA *	PACPI_BIF_DATA

typedef struct _ACPI_BIX_DATA	ACPI_BIX_DATA

typedef struct _ACPI_BIX_DATA *	PACPI_BIX_DATA

typedef struct _ACPI_BATT_STATIC_INFO	ACPI_BATT_STATIC_INFO

typedef struct _ACPI_BATT_STATIC_INFO *	PACPI_BATT_STATIC_INFO

typedef struct _CMBATT_DEVICE_EXTENSION	CMBATT_DEVICE_EXTENSION

typedef struct _CMBATT_DEVICE_EXTENSION *	PCMBATT_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	CmBattGetBixData (_In_ PCMBATT_DEVICE_EXTENSION DeviceExtension, _Out_ PACPI_BIX_DATA BixData)
	Retrieves the eXtended static battery information from the ACPI _BIX method.

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 73 of file cmbatt.h.

◆ ACPI_BATT_NOTIFY_STATUS

#define ACPI_BATT_NOTIFY_STATUS 0x80

Definition at line 72 of file cmbatt.h.

◆ ACPI_BATT_POWER_UNIT_AMPS

#define ACPI_BATT_POWER_UNIT_AMPS 0x1

Definition at line 98 of file cmbatt.h.

◆ ACPI_BATT_POWER_UNIT_WATTS

#define ACPI_BATT_POWER_UNIT_WATTS 0x0

Definition at line 97 of file cmbatt.h.

◆ ACPI_BATT_STAT_CHARGING

#define ACPI_BATT_STAT_CHARGING 0x0002

Definition at line 76 of file cmbatt.h.

◆ ACPI_BATT_STAT_CRITICAL

#define ACPI_BATT_STAT_CRITICAL 0x0004

Definition at line 77 of file cmbatt.h.

◆ ACPI_BATT_STAT_DISCHARG

#define ACPI_BATT_STAT_DISCHARG 0x0001

Definition at line 75 of file cmbatt.h.

◆ ACPI_BUS_CHECK

#define ACPI_BUS_CHECK 0x00

Definition at line 63 of file cmbatt.h.

◆ ACPI_DEVICE_CHECK

#define ACPI_DEVICE_CHECK 0x01

Definition at line 64 of file cmbatt.h.

◆ ACPI_STA_BATTERY_PRESENT

#define ACPI_STA_BATTERY_PRESENT 0x10

Definition at line 70 of file cmbatt.h.

◆ ACPI_STA_ENABLED

#define ACPI_STA_ENABLED 0x02

Definition at line 67 of file cmbatt.h.

◆ ACPI_STA_FUNCTIONAL

#define ACPI_STA_FUNCTIONAL 0x08

Definition at line 69 of file cmbatt.h.

◆ ACPI_STA_PRESENT

#define ACPI_STA_PRESENT 0x01

Definition at line 66 of file cmbatt.h.

◆ ACPI_STA_SHOW_UI

#define ACPI_STA_SHOW_UI 0x04

Definition at line 68 of file cmbatt.h.

◆ ASCIIZ_MAX_LENGTH

#define ASCIIZ_MAX_LENGTH 256

Definition at line 100 of file cmbatt.h.

◆ CM_MAX_VALUE

#define CM_MAX_VALUE 0x7FFFFFFF

Definition at line 79 of file cmbatt.h.

◆ CM_UNKNOWN_VALUE

#define CM_UNKNOWN_VALUE 0xFFFFFFFF

Definition at line 80 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 154 of file cmbatt.h.

◆ CMBATT_AR_NOTIFY

#define CMBATT_AR_NOTIFY 0x01

Definition at line 153 of file cmbatt.h.

◆ CMBATT_AR_REMOVE

#define CMBATT_AR_REMOVE 0x04

Definition at line 155 of file cmbatt.h.

◆ CMBATT_BATT_STATIC_INFO_TAG

#define CMBATT_BATT_STATIC_INFO_TAG 'nItS'

Definition at line 151 of file cmbatt.h.

◆ CMBATT_CAPACITY_BOGUS

#define CMBATT_CAPACITY_BOGUS 0x100000

Definition at line 55 of file cmbatt.h.

◆ CMBATT_DISCHARGE_TIME

#define CMBATT_DISCHARGE_TIME 150000000

Definition at line 49 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.

◆ CONVERT_BATT_INFO

#define CONVERT_BATT_INFO	(	Capacity,
		DesignVoltage
	)

Value:

    (((Capacity) != BATTERY_UNKNOWN_CAPACITY) \
        ? CONVERT_MAH_TO_MWH((Capacity), (DesignVoltage)) \
        : BATTERY_UNKNOWN_CAPACITY)

Definition at line 84 of file cmbatt.h.

◆ CONVERT_MAH_TO_MWH

#define CONVERT_MAH_TO_MWH	(	mA,
		Volts
	)	(((mA) * (Volts) + 500) / 1000)

Definition at line 82 of file cmbatt.h.

◆ IOCTL_BATTERY_QUERY_BIF_BIX

#define IOCTL_BATTERY_QUERY_BIF_BIX 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_BATT_STATIC_INFO

typedef struct _ACPI_BATT_STATIC_INFO ACPI_BATT_STATIC_INFO

◆ ACPI_BIF_DATA

typedef struct _ACPI_BIF_DATA ACPI_BIF_DATA

◆ ACPI_BIX_DATA

typedef struct _ACPI_BIX_DATA ACPI_BIX_DATA

◆ ACPI_BST_DATA

typedef struct _ACPI_BST_DATA ACPI_BST_DATA

◆ CMBATT_DEVICE_EXTENSION

typedef struct _CMBATT_DEVICE_EXTENSION CMBATT_DEVICE_EXTENSION

◆ CMBATT_EXTENSION_TYPE

typedef enum _CMBATT_EXTENSION_TYPE CMBATT_EXTENSION_TYPE

◆ PACPI_BATT_STATIC_INFO

typedef struct _ACPI_BATT_STATIC_INFO * PACPI_BATT_STATIC_INFO

◆ PACPI_BIF_DATA

typedef struct _ACPI_BIF_DATA * PACPI_BIF_DATA

◆ PACPI_BIX_DATA

typedef struct _ACPI_BIX_DATA * PACPI_BIX_DATA

◆ PACPI_BST_DATA

typedef struct _ACPI_BST_DATA * PACPI_BST_DATA

◆ PCMBATT_DEVICE_EXTENSION

typedef struct _CMBATT_DEVICE_EXTENSION * PCMBATT_DEVICE_EXTENSION

Enumeration Type Documentation

◆ _CMBATT_EXTENSION_TYPE

enum _CMBATT_EXTENSION_TYPE

Enumerator
CmBattAcAdapter
CmBattBattery

Definition at line 57 of file cmbatt.h.

{
    CmBattAcAdapter,
    CmBattBattery
} 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 884 of file cmbatt.c.

{
    NTSTATUS Status;
    PAGED_CODE();
    if (CmBattDebug & 0xA) DbgPrint("CmBattDisableStatusNotify\n");
 
    /* Do we have a trip point */
    if (DeviceExtension->TripPointSet)
    {
        /* Is there a current value set? */
        if (DeviceExtension->TripPointValue)
        {
            /* Reset it back to 0 */
            DeviceExtension->TripPointValue = 0;
            Status = CmBattSetTripPpoint(DeviceExtension, 0);
            if (!NT_SUCCESS(Status))
            {
                /* If it failed, set unknown/invalid value */
                DeviceExtension->TripPointValue = BATTERY_UNKNOWN_CAPACITY;
                if (CmBattDebug & 8)
                    DbgPrint("CmBattDisableStatusNotify: SetTripPoint failed - %x\n", Status);
            }
        }
        else
        {
            /* No trip point set, so this is a successful no-op */
            Status = STATUS_SUCCESS;
        }
    }
    else
    {
        /* Nothing we can do */
        Status = STATUS_OBJECT_NAME_NOT_FOUND;
    }
 
    /* Return status */
    return Status;
}

Referenced by CmBattAddBattery().

◆ CmBattGetBifData()

NTSTATUS NTAPI CmBattGetBifData	(	PCMBATT_DEVICE_EXTENSION	DeviceExtension,
		PACPI_BIF_DATA	BifData
	)

Definition at line 412 of file cmexec.c.

{
    ACPI_PACKAGE_FIELD BifFields[] = {
        { "PowerUnit", FALSE, &BifData->PowerUnit },
        { "DesignCapacity", FALSE, &BifData->DesignCapacity },
        { "LastFullCapacity", FALSE, &BifData->LastFullCapacity },
        { "BatteryTechnology", FALSE, &BifData->BatteryTechnology },
        { "DesignVoltage", FALSE, &BifData->DesignVoltage },
        { "DesignCapacityWarning", FALSE, &BifData->DesignCapacityWarning },
        { "DesignCapacityLow", FALSE, &BifData->DesignCapacityLow },
        { "BatteryCapacityGranularity1", FALSE, &BifData->BatteryCapacityGranularity1 },
        { "BatteryCapacityGranularity2", FALSE, &BifData->BatteryCapacityGranularity2 },
        { "ModelNumber", TRUE, &BifData->ModelNumber },
        { "SerialNumber", TRUE, &BifData->SerialNumber },
        { "BatteryType", TRUE, &BifData->BatteryType },
        { "OemInfo", TRUE, &BifData->OemInfo },
    };
    PAGED_CODE();
 
    if (CmBattDebug & CMBATT_ACPI_ENTRY_EXIT)
        DbgPrint("CmBattGetBifData: Buffer (0x%x) Device %x Tid %x\n",
                 BifData, DeviceExtension->DeviceId, KeGetCurrentThread());
 
    /* Request the _BIF method */
    /* Note that _BIF method is deprecated since ACPI 4.0, and replaced by _BIX method.
     * However, VirtualBox 7.0 only support _BIF method.
     */
    return CmBattCallAcpiPackage("CmBattGetBifData",
                                 DeviceExtension,
                                 'FIB_',
                                 512,
                                 BifFields,
                                 RTL_NUMBER_OF(BifFields));
}

Referenced by CmBattGetBattStaticInfo(), and CmBattIoctl().

◆ CmBattGetBixData()

NTSTATUS NTAPI CmBattGetBixData	(	_In_ PCMBATT_DEVICE_EXTENSION	DeviceExtension,
		_Out_ PACPI_BIX_DATA	BixData
	)

Retrieves the eXtended static battery information from the ACPI _BIX method.

Parameters

[in]	DeviceExtension	A pointer to a Control Method (CM) battery device extension. It is used to send the ACPI method evaluation operation to the ACPI driver of which it is attached to this CM battery.
[out]	BixData	A pointer to a structure that contains the _BIX data fields, returned to caller.

Returns: Returns STATUS_SUCCESS if the operation has succeeded successfully, otherwise a failure NTSTATUS code is returned.

Definition at line 468 of file cmexec.c.

{
    ACPI_PACKAGE_FIELD BixFields[] = {
        { "Revision", FALSE, &BixData->Revision },
        { "PowerUnit", FALSE, &BixData->PowerUnit },
        { "DesignCapacity", FALSE, &BixData->DesignCapacity },
        { "LastFullCapacity", FALSE, &BixData->LastFullCapacity },
        { "BatteryTechnology", FALSE, &BixData->BatteryTechnology },
        { "DesignVoltage", FALSE, &BixData->DesignVoltage },
        { "DesignCapacityWarning", FALSE, &BixData->DesignCapacityWarning },
        { "DesignCapacityLow", FALSE, &BixData->DesignCapacityLow },
        { "CycleCount", FALSE, &BixData->CycleCount },
        { "Accuracy", FALSE, &BixData->Accuracy },
        { "MaxSampleTime", FALSE, &BixData->MaxSampleTime },
        { "MinSampleTime", FALSE, &BixData->MinSampleTime },
        { "MaxAverageInterval", FALSE, &BixData->MaxAverageInterval },
        { "MinAverageInterval", FALSE, &BixData->MinAverageInterval },
        { "BatteryCapacityGranularity1", FALSE, &BixData->BatteryCapacityGranularity1 },
        { "BatteryCapacityGranularity2", FALSE, &BixData->BatteryCapacityGranularity2 },
        { "ModelNumber", TRUE, &BixData->ModelNumber },
        { "SerialNumber", TRUE, &BixData->SerialNumber },
        { "BatteryType", TRUE, &BixData->BatteryType },
        { "OemInfo", TRUE, &BixData->OemInfo },
        { "SwapCapability", FALSE, &BixData->SwapCapability },
    };
    PAGED_CODE();
 
    if (CmBattDebug & CMBATT_ACPI_ENTRY_EXIT)
    {
        DbgPrint("CmBattGetBixData: Buffer (0x%x) Device %x Tid %x\n",
                 BixData, DeviceExtension->DeviceId, KeGetCurrentThread());
    }
 
    /* Request the ACPI driver to get the _BIX data for us */
    return CmBattCallAcpiPackage("CmBattGetBifData",
                                 DeviceExtension,
                                 'XIB_',
                                 512,
                                 BixFields,
                                 RTL_NUMBER_OF(BixFields));
}

Referenced by CmBattGetBattStaticInfo(), and CmBattIoctl().

◆ CmBattGetBstData()

NTSTATUS NTAPI CmBattGetBstData	(	PCMBATT_DEVICE_EXTENSION	DeviceExtension,
		PACPI_BST_DATA	BstData
	)

Definition at line 514 of file cmexec.c.

{
    ACPI_PACKAGE_FIELD BstFields[] = {
        { "State", FALSE, &BstData->State },
        { "PresentRate", FALSE, &BstData->PresentRate },
        { "RemainingCapacity", FALSE, &BstData->RemainingCapacity },
        { "PresentVoltage", FALSE, &BstData->PresentVoltage },
    };
    PAGED_CODE();
 
    if (CmBattDebug & CMBATT_ACPI_ENTRY_EXIT)
        DbgPrint("CmBattGetBstData: Buffer (0x%x) Device %x Tid %x\n",
                 BstData, DeviceExtension->DeviceId, KeGetCurrentThread());
 
 
    return CmBattCallAcpiPackage("CmBattGetBstData",
                                 DeviceExtension,
                                 'TSB_',
                                 512,
                                 BstFields,
                                 RTL_NUMBER_OF(BstFields));
}

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

◆ CmBattGetPsrData()

NTSTATUS NTAPI CmBattGetPsrData	(	PDEVICE_OBJECT	DeviceObject,
		PULONG	PsrData
	)

Referenced by CmBattGetBatteryStatus(), and CmBattIoctl().

◆ 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.

{
    ULONG ArFlag;
    PCMBATT_DEVICE_EXTENSION FdoExtension;
    PDEVICE_OBJECT DeviceObject;
 
    if (CmBattDebug & (CMBATT_ACPI_ASSERT | CMBATT_PNP_INFO))
        DbgPrint("CmBattNotifyHandler: CmBatt 0x%08x Type %d Number %d Notify Value: %x\n",
                 DeviceExtension,
                 DeviceExtension->FdoType,
                 DeviceExtension->DeviceId,
                 NotifyValue);
 
    /* Check what kind of notification was received */
    switch (NotifyValue)
    {
        /* ACPI Specification says is sends a "Bus Check" when power source changes */
        case ACPI_BUS_CHECK:
 
            /* We treat it as possible physical change */
            DeviceExtension->ArFlag |= (CMBATT_AR_NOTIFY | CMBATT_AR_INSERT);
            if ((DeviceExtension->Tag) &&
                (CmBattDebug & (CMBATT_ACPI_WARNING | CMBATT_GENERIC_WARNING)))
                DbgPrint("CmBattNotifyHandler: Received battery #%x insertion, but tag was not invalid.\n",
                         DeviceExtension->DeviceId);
            break;
 
        /* Status of the battery has changed */
        case ACPI_BATT_NOTIFY_STATUS:
 
            /* All we'll do is notify the class driver */
            DeviceExtension->ArFlag |= CMBATT_AR_NOTIFY;
            break;
 
        /* Information on the battery has changed, such as physical presence */
        case ACPI_DEVICE_CHECK:
        case ACPI_BATT_NOTIFY_INFO:
 
            /* Reset all state and let the class driver re-evaluate it all */
            DeviceExtension->ArFlag |= (CMBATT_AR_NOTIFY |
                                        CMBATT_AR_INSERT |
                                        CMBATT_AR_REMOVE);
            break;
 
        default:
 
            if (CmBattDebug & CMBATT_PNP_INFO)
                DbgPrint("CmBattNotifyHandler: Unknown Notify Value: %x\n", NotifyValue);
    }
 
    /* Check if we're supposed to delay the notification till later */
    if (DeviceExtension->DelayNotification)
    {
        /* We'll handle this when we get a status query later on */
        if (CmBattDebug & CMBATT_PNP_INFO)
            DbgPrint("CmBattNotifyHandler: Notification delayed: ARs = %01x\n",
                      DeviceExtension->ArFlag);
        return;
    }
 
    /* We're going to handle this now */
    if (CmBattDebug & CMBATT_PNP_INFO)
        DbgPrint("CmBattNotifyHandler: Performing ARs: %01x\n", DeviceExtension->ArFlag);
 
    /* Check if this is a battery or AC adapter notification */
    if (DeviceExtension->FdoType == CmBattBattery)
    {
        /* Reset the current trip point */
        DeviceExtension->TripPointValue = BATTERY_UNKNOWN_CAPACITY;
 
        /* Check what ARs have to be done */
        ArFlag = DeviceExtension->ArFlag;
 
        /* New battery inserted, reset lock value */
        if (ArFlag & CMBATT_AR_INSERT) InterlockedExchange(&DeviceExtension->ArLockValue, 0);
 
        /* Check if the battery may have been removed */
        if (ArFlag & CMBATT_AR_REMOVE) DeviceExtension->Tag = 0;
 
        /* Check if there's been any sort of change to the battery */
        if (ArFlag & CMBATT_AR_NOTIFY)
        {
            /* We'll probably end up re-evaluating _BIF and _BST */
            DeviceExtension->NotifySent = TRUE;
            BatteryClassStatusNotify(DeviceExtension->ClassData);
        }
    }
    else if (DeviceExtension->ArFlag & CMBATT_AR_NOTIFY)
    {
        /* The only known notification is AC/DC change. Loop device objects. */
        for (DeviceObject = DeviceExtension->FdoDeviceObject->DriverObject->DeviceObject;
             DeviceObject;
             DeviceObject = DeviceObject->NextDevice)
        {
            /* Is this a battery? */
            FdoExtension = DeviceObject->DeviceExtension;
            if (FdoExtension->FdoType == CmBattBattery)
            {
                /* Send a notification to the class driver */
                FdoExtension->NotifySent = TRUE;
                BatteryClassStatusNotify(FdoExtension->ClassData);
            }
        }
    }
 
    /* ARs have been processed */
    DeviceExtension->ArFlag = 0;
}

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

{
    NTSTATUS Status;
    PVOID QueryData = NULL;
    ULONG QueryLength = 0;
    ULONG RemainingTime = 0;
    ANSI_STRING TempString;
    UNICODE_STRING TempString2;
    WCHAR InfoBuffer[256];
    WCHAR TempBuffer[256];
    UNICODE_STRING InfoString;
    ULONG RemainingCapacity;
    BATTERY_REPORTING_SCALE BatteryReportingScale[2];
    LONG Rate;
    PAGED_CODE();
    if (CmBattDebug & (CMBATT_ACPI_WARNING | CMBATT_GENERIC_INFO))
        DbgPrint("CmBattQueryInformation - Tag (%d) Device %d, Informationlevel %d\n",
                 Tag,
                 FdoExtension->DeviceId,
                 InfoLevel);
 
    /* Check ACPI Data */
    Status = CmBattVerifyStaticInfo(FdoExtension, Tag);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Check what caller wants */
    switch (InfoLevel)
    {
        case BatteryInformation:
            /* Just return our static information */
            QueryData = &FdoExtension->BatteryInformation;
            QueryLength = sizeof(BATTERY_INFORMATION);
            break;
 
        case BatteryGranularityInformation:
 
            /* Return our static information, we have two scales */
            BatteryReportingScale[0].Granularity = FdoExtension->BatteryCapacityGranularity1;
            BatteryReportingScale[0].Capacity = FdoExtension->BatteryInformation.DefaultAlert1;
            BatteryReportingScale[1].Granularity = FdoExtension->BatteryCapacityGranularity2;
            BatteryReportingScale[1].Capacity = FdoExtension->BatteryInformation.DesignedCapacity;
            QueryData = BatteryReportingScale;
            QueryLength = sizeof(BATTERY_REPORTING_SCALE) * 2;
            break;
 
        case BatteryEstimatedTime:
 
            /* Check if it's been more than 15 seconds since the last change */
            if (KeQueryInterruptTime() > (FdoExtension->InterruptTime + CMBATT_DISCHARGE_TIME))
            {
                /* Get new battery status */
                CmBattGetBatteryStatus(FdoExtension, FdoExtension->Tag);
 
                /* If the caller didn't specify a rate, use our static one */
                Rate = AtRate;
                if (!Rate) Rate = FdoExtension->Rate;
 
                /* If we don't have a valid negative rate, use unknown value */
                if (Rate >= 0) Rate = BATTERY_UNKNOWN_RATE;
 
                /* Grab the remaining capacity */
                RemainingCapacity = FdoExtension->RemainingCapacity;
 
                /* Default time to unknown if we fail the request later */
                RemainingTime = BATTERY_UNKNOWN_TIME;
 
                /* See if we don't know one or the other */
                if ((Rate == BATTERY_UNKNOWN_RATE) ||
                    (RemainingCapacity == BATTERY_UNKNOWN_CAPACITY))
                {
                    /* If the battery is discharging, we can't give out a time */
                    if ((FdoExtension->BstData.State & ACPI_BATT_STAT_DISCHARG) &&
                        (CmBattDebug & CMBATT_GENERIC_WARNING))
                            DbgPrint("CmBattQueryInformation: Can't calculate EstimatedTime.\n");
 
                    /* Check if we don't have a rate and capacity is going down */
                    if ((FdoExtension->Rate == BATTERY_UNKNOWN_RATE) &&
                        (FdoExtension->BstData.State & ACPI_BATT_STAT_DISCHARG))
                    {
                        /* We have to fail, since we lack data */
                        Status = STATUS_INVALID_DEVICE_REQUEST;
                        if (CmBattDebug & CMBATT_GENERIC_WARNING)
                            DbgPrint("----------------------   PresentRate = BATTERY_UNKNOWN_RATE\n");
                    }
 
                    /* If we don't have capacity, the rate is useless */
                    if (RemainingCapacity == BATTERY_UNKNOWN_CAPACITY)
                    {
                        /* We have to fail the request */
                        Status = STATUS_INVALID_DEVICE_REQUEST;
                        if (CmBattDebug & CMBATT_GENERIC_WARNING)
                            DbgPrint("----------------------   RemainingCapacity = BATTERY_UNKNOWN_CAPACITY\n");
                    }
                }
                else
                {
                    /* We have data, but is it valid? */
                    if (RemainingCapacity > CMBATT_CAPACITY_BOGUS)
                    {
                        /* The capacity seems bogus, so don't use it */
                        if (CmBattDebug & CMBATT_ACPI_WARNING)
                            DbgPrint("CmBattQueryInformation: Data Overflow in calculating Remaining Capacity.\n");
                    }
                    else
                    {
                        /* Compute the remaining time in seconds, based on rate */
                        RemainingTime = (RemainingCapacity * 3600) / -Rate;
                    }
                }
            }
            else
            {
                RemainingTime = BATTERY_UNKNOWN_TIME;
            }
 
            /* Return the remaining time */
            QueryData = &RemainingTime;
            QueryLength = sizeof(ULONG);
            break;
 
        case BatteryDeviceName:
 
            /* Build the model number string */
            if (FdoExtension->BattInfo.ExtendedData)
            {
                RtlInitAnsiString(&TempString, FdoExtension->BattInfo.BixData.ModelNumber);
            }
            else
            {
                RtlInitAnsiString(&TempString, FdoExtension->BattInfo.BifData.ModelNumber);
            }
 
            /* Convert it to Unicode */
            InfoString.Buffer = InfoBuffer;
            InfoString.MaximumLength = sizeof(InfoBuffer);
            Status = RtlAnsiStringToUnicodeString(&InfoString, &TempString, 0);
 
            /* Return the unicode buffer */
            QueryData = InfoString.Buffer;
            QueryLength = InfoString.Length;
            break;
 
        case BatteryTemperature:
        case BatteryManufactureDate:
 
            /* We don't support these */
            Status = STATUS_INVALID_DEVICE_REQUEST;
            break;
 
        case BatteryManufactureName:
 
            /* Build the OEM info string */
            if (FdoExtension->BattInfo.ExtendedData)
            {
                RtlInitAnsiString(&TempString, FdoExtension->BattInfo.BixData.OemInfo);
            }
            else
            {
                RtlInitAnsiString(&TempString, FdoExtension->BattInfo.BifData.OemInfo);
            }
 
            /* Convert it to Unicode */
            InfoString.Buffer = InfoBuffer;
            InfoString.MaximumLength = sizeof(InfoBuffer);
            Status = RtlAnsiStringToUnicodeString(&InfoString, &TempString, 0);
 
            /* Return the unicode buffer */
            QueryData = InfoString.Buffer;
            QueryLength = InfoString.Length;
            break;
 
        case BatteryUniqueID:
 
            /* Build the serial number string */
            if (FdoExtension->BattInfo.ExtendedData)
            {
                RtlInitAnsiString(&TempString, FdoExtension->BattInfo.BixData.SerialNumber);
            }
            else
            {
                RtlInitAnsiString(&TempString, FdoExtension->BattInfo.BifData.SerialNumber);
            }
 
            /* Convert it to Unicode */
            InfoString.Buffer = InfoBuffer;
            InfoString.MaximumLength = sizeof(InfoBuffer);
            RtlAnsiStringToUnicodeString(&InfoString, &TempString, 0);
 
            /* Setup a temporary string for concatenation */
            TempString2.Buffer = TempBuffer;
            TempString2.MaximumLength = sizeof(TempBuffer);
 
            /* Check if there's an OEM string */
            if ((FdoExtension->BattInfo.ExtendedData && FdoExtension->BattInfo.BixData.OemInfo[0]) ||
                FdoExtension->BattInfo.BifData.OemInfo[0])
            {
                /* Build the OEM info string */
                if (FdoExtension->BattInfo.ExtendedData)
                {
                    RtlInitAnsiString(&TempString, FdoExtension->BattInfo.BixData.OemInfo);
                }
                else
                {
                    RtlInitAnsiString(&TempString, FdoExtension->BattInfo.BifData.OemInfo);
                }
 
                /* Convert it to Unicode and append it */
                RtlAnsiStringToUnicodeString(&TempString2, &TempString, 0);
                RtlAppendUnicodeStringToString(&InfoString, &TempString2);
            }
 
            /* Build the model number string */
            if (FdoExtension->BattInfo.ExtendedData)
            {
                RtlInitAnsiString(&TempString, FdoExtension->BattInfo.BixData.ModelNumber);
            }
            else
            {
                RtlInitAnsiString(&TempString, FdoExtension->BattInfo.BifData.ModelNumber);
            }
 
            /* Convert it to Unicode and append it */
            RtlAnsiStringToUnicodeString(&TempString2, &TempString, 0);
            RtlAppendUnicodeStringToString(&InfoString, &TempString2);
 
            /* Return the final appended string */
            QueryData = InfoString.Buffer;
            QueryLength = InfoString.Length;
            break;
 
        default:
 
            /* Everything else is unknown */
            Status = STATUS_INVALID_PARAMETER;
            break;
    }
 
    /* Return the required length and check if the caller supplied enough */
    *ReturnedLength = QueryLength;
    if (BufferLength < QueryLength) Status = STATUS_BUFFER_TOO_SMALL;
 
    /* Copy the data if there's enough space and it exists */
    if ((NT_SUCCESS(Status)) && (QueryData)) RtlCopyMemory(Buffer, QueryData, QueryLength);
 
    /* Return function result */
    return Status;
}

Referenced by CmBattAddBattery().

◆ CmBattQueryStatus()

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

Definition at line 1573 of file cmbatt.c.

{
    NTSTATUS Status;
    PAGED_CODE();
    if (CmBattDebug & (CMBATT_ACPI_WARNING | CMBATT_GENERIC_INFO))
        DbgPrint("CmBattQueryStatus - Tag (%d) Device %x\n", Tag, DeviceExtension->DeviceId);
 
    /* Query ACPI information */
    Status = CmBattGetBatteryStatus(DeviceExtension, Tag);
    if (NT_SUCCESS(Status))
    {
        BatteryStatus->PowerState = DeviceExtension->State;
        BatteryStatus->Capacity = DeviceExtension->RemainingCapacity;
        BatteryStatus->Voltage = DeviceExtension->PresentVoltage;
        BatteryStatus->Rate = DeviceExtension->Rate;
    }
 
    /* Return status */
    if (CmBattDebug & (CMBATT_GENERIC_INFO))
        DbgPrint("CmBattQueryStatus: Returning [%#08lx][%#08lx][%#08lx][%#08lx]\n",
                 BatteryStatus->PowerState,
                 BatteryStatus->Capacity,
                 BatteryStatus->Voltage,
                 BatteryStatus->Rate);
    return Status;
}

Referenced by CmBattAddBattery().

◆ CmBattQueryTag()

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

Definition at line 826 of file cmbatt.c.

{
    PDEVICE_OBJECT PdoDevice;
    ULONG StaData;
    NTSTATUS Status;
    PAGED_CODE();
    if (CmBattDebug & (CMBATT_ACPI_WARNING | CMBATT_GENERIC_INFO))
      DbgPrint("CmBattQueryTag - Tag (%d), Battery %x, Device %d\n",
                *Tag, DeviceExtension, DeviceExtension->DeviceId);
 
    /* Get PDO and clear notification flag */
    PdoDevice = DeviceExtension->PdoDeviceObject;
    DeviceExtension->NotifySent = 0;
 
    /* Get _STA from PDO (we need the machine status, not the battery status) */
    Status = CmBattGetStaData(PdoDevice, &StaData);
    if (NT_SUCCESS(Status))
    {
        /* Is a battery present? */
        if (StaData & ACPI_STA_BATTERY_PRESENT)
        {
            /* Do we not have a tag yet? */
            if (DeviceExtension->Tag == BATTERY_TAG_INVALID)
            {
                /* Set the new tag value, reset tags if we reached the maximum */
                if (++DeviceExtension->TagData == BATTERY_TAG_INVALID)
                    DeviceExtension->TagData = 1;
                DeviceExtension->Tag = DeviceExtension->TagData;
                if (CmBattDebug & CMBATT_GENERIC_INFO)
                    DbgPrint("CmBattQueryTag - New Tag: (%d)\n", DeviceExtension->Tag);
 
                /* Reset trip point data */
                DeviceExtension->TripPointOld = 0;
                DeviceExtension->TripPointValue = BATTERY_UNKNOWN_CAPACITY;
 
                /* Clear AR lock and set new interrupt time */
                InterlockedExchange(&DeviceExtension->ArLockValue, 0);
                DeviceExtension->InterruptTime = KeQueryInterruptTime();
            }
        }
        else
        {
            /* No battery, so no tag */
            DeviceExtension->Tag = BATTERY_TAG_INVALID;
            Status = STATUS_NO_SUCH_DEVICE;
        }
    }
 
    /* Return the tag and status result */
    *Tag = DeviceExtension->Tag;
    if (CmBattDebug & CMBATT_ACPI_WARNING)
      DbgPrint("CmBattQueryTag: Returning Tag: 0x%x, status 0x%x\n", *Tag, Status);
    return Status;
}

Referenced by CmBattAddBattery().

◆ CmBattSetStatusNotify()

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

Definition at line 925 of file cmbatt.c.

{
    NTSTATUS Status;
    ACPI_BST_DATA BstData;
    ULONG PowerUnit, Capacity, NewTripPoint, TripPoint, DesignVoltage;
    BOOLEAN Charging;
    PAGED_CODE();
    if (CmBattDebug & (CMBATT_ACPI_WARNING | CMBATT_GENERIC_INFO))
        DbgPrint("CmBattSetStatusNotify: Tag (%d) Target(0x%x)\n",
                 BatteryTag, BatteryNotify->LowCapacity);
 
    /* Update any ACPI evaluations */
    Status = CmBattVerifyStaticInfo(DeviceExtension, BatteryTag);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Trip point not supported, fail */
    if (!DeviceExtension->TripPointSet) return STATUS_OBJECT_NAME_NOT_FOUND;
 
    /* Are both capacities known? */
    if ((BatteryNotify->HighCapacity == BATTERY_UNKNOWN_CAPACITY) ||
        (BatteryNotify->LowCapacity == BATTERY_UNKNOWN_CAPACITY))
    {
        /* We can't set trip points without these */
        if (CmBattDebug & CMBATT_GENERIC_WARNING)
            DbgPrint("CmBattSetStatusNotify: Failing request because of BATTERY_UNKNOWN_CAPACITY.\n");
        return STATUS_NOT_SUPPORTED;
    }
 
    /* Is the battery charging? */
    Charging = DeviceExtension->BstData.State & ACPI_BATT_STAT_CHARGING;
    if (Charging)
    {
        /* Then the trip point is when we hit the cap */
        Capacity = BatteryNotify->HighCapacity;
        NewTripPoint = BatteryNotify->HighCapacity;
    }
    else
    {
        /* Otherwise it's when we discharge to the bottom */
        Capacity = BatteryNotify->LowCapacity;
        NewTripPoint = BatteryNotify->LowCapacity;
    }
 
    /* Is this machine supporting _BIX or _BIF? */
    if (DeviceExtension->BattInfo.ExtendedData)
    {
        PowerUnit = DeviceExtension->BattInfo.BixData.PowerUnit;
        DesignVoltage = DeviceExtension->BattInfo.BixData.DesignVoltage;
    }
    else
    {
        PowerUnit = DeviceExtension->BattInfo.BifData.PowerUnit;
        DesignVoltage = DeviceExtension->BattInfo.BifData.DesignVoltage;
    }
 
    /* Do we have data in Amps or Watts? */
    if (PowerUnit == ACPI_BATT_POWER_UNIT_AMPS)
    {
        /* We need the voltage to do the conversion */
        if ((DesignVoltage != BATTERY_UNKNOWN_VOLTAGE) && (DesignVoltage))
        {
            /* Convert from mAh into Ah */
            TripPoint = 1000 * NewTripPoint;
            if (Charging)
            {
                /* Scale the high trip point */
                NewTripPoint = (TripPoint + 500) / DesignVoltage + ((TripPoint + 500) % DesignVoltage != 0);
            }
            else
            {
                /* Scale the low trip point */
                NewTripPoint = (TripPoint - 500) / DesignVoltage - ((TripPoint - 500) % DesignVoltage == 0);
            }
        }
        else
        {
            /* Without knowing the voltage, Amps are not enough data on consumption */
            Status = STATUS_NOT_SUPPORTED;
            if (CmBattDebug & CMBATT_ACPI_WARNING)
                DbgPrint("CmBattSetStatusNotify: Can't calculate BTP, DesignVoltage = 0x%08x\n",
                        DesignVoltage);
        }
    }
    else if (Charging)
    {
        /* Make it trip just one past the charge cap */
        ++NewTripPoint;
    }
    else if (NewTripPoint > 0)
    {
        /* Make it trip just one below the drain cap */
        --NewTripPoint;
    }
 
    /* Do we actually have a new trip point? */
    if (NewTripPoint == DeviceExtension->TripPointValue)
    {
        /* No, so there is no work to be done */
        if (CmBattDebug & CMBATT_GENERIC_STATUS)
            DbgPrint("CmBattSetStatusNotify: Keeping original setting: %X\n", DeviceExtension->TripPointValue);
        return STATUS_SUCCESS;
    }
 
    /* Set the trip point with ACPI and check for success */
    DeviceExtension->TripPointValue = NewTripPoint;
    Status = CmBattSetTripPpoint(DeviceExtension, NewTripPoint);
    if (!(NewTripPoint) && (Capacity)) Status = STATUS_NOT_SUPPORTED;
    if (!NT_SUCCESS(Status))
    {
        /* We failed to set the trip point, or there wasn't one settable */
        DeviceExtension->TripPointValue = BATTERY_UNKNOWN_CAPACITY;
        if (CmBattDebug & (CMBATT_GENERIC_WARNING | CMBATT_ACPI_WARNING))
            DbgPrint("CmBattSetStatusNotify: SetTripPoint failed - %x\n", Status);
        return Status;
    }
 
    /* Read the new BST data to see the latest state */
    Status = CmBattGetBstData(DeviceExtension, &BstData);
    if (!NT_SUCCESS(Status))
    {
        /* We'll return failure to the caller */
        if (CmBattDebug & (CMBATT_GENERIC_WARNING | CMBATT_ACPI_WARNING))
            DbgPrint("CmBattSetStatusNotify: GetBstData - %x\n", Status);
    }
    else if ((Charging) && (BstData.RemainingCapacity >= NewTripPoint))
    {
        /* We are charging and our capacity is past the trip point, so trip now */
        if (CmBattDebug & CMBATT_GENERIC_WARNING)
            DbgPrint("CmBattSetStatusNotify: Trip point already crossed (1): TP = %08x, remaining capacity = %08x\n",
                     NewTripPoint, BstData.RemainingCapacity);
        CmBattNotifyHandler(DeviceExtension, ACPI_BATT_NOTIFY_STATUS);
    }
    else if ((BstData.RemainingCapacity) && (Capacity))
    {
        /* We are discharging, and our capacity is below the trip point, trip now */
        if (CmBattDebug & CMBATT_GENERIC_WARNING)
            DbgPrint("CmBattSetStatusNotify: Trip point already crossed (1): TP = %08x, remaining capacity = %08x\n",
                     NewTripPoint, BstData.RemainingCapacity);
        CmBattNotifyHandler(DeviceExtension, ACPI_BATT_NOTIFY_STATUS);
    }
 
    /* All should've went well if we got here, unless BST failed... return! */
    if (CmBattDebug & CMBATT_GENERIC_STATUS)
          DbgPrint("CmBattSetStatusNotify: Want %X CurrentCap %X\n",
                    Capacity, DeviceExtension->RemainingCapacity);
    if (CmBattDebug & CMBATT_ACPI_WARNING)
          DbgPrint("CmBattSetStatusNotify: Set to: [%#08lx][%#08lx][%#08lx] Status %lx\n",
                    BatteryNotify->PowerState,
                    BatteryNotify->LowCapacity,
                    BatteryNotify->HighCapacity,
                    Status);
    return Status;
}

Referenced by CmBattAddBattery().

◆ CmBattSetTripPpoint()

NTSTATUS NTAPI CmBattSetTripPpoint	(	PCMBATT_DEVICE_EXTENSION	DeviceExtension,
		ULONG	AlarmValue
	)

Referenced by CmBattAddBattery(), CmBattDisableStatusNotify(), CmBattIoctl(), and CmBattSetStatusNotify().

◆ CmBattSystemControl()

NTSTATUS NTAPI CmBattSystemControl	(	PDEVICE_OBJECT	DeviceObject,
		PIRP	Irp
	)

Referenced by DriverEntry().

◆ CmBattWmiDeRegistration()

NTSTATUS NTAPI CmBattWmiDeRegistration ( PCMBATT_DEVICE_EXTENSION DeviceExtension )

Referenced by CmBattAddBattery(), and CmBattRemoveDevice().

◆ CmBattWmiRegistration()

NTSTATUS NTAPI CmBattWmiRegistration ( PCMBATT_DEVICE_EXTENSION DeviceExtension )

Referenced by CmBattAddAcAdapter(), and CmBattAddBattery().

Variable Documentation

◆ AcAdapterPdo

PDEVICE_OBJECT AcAdapterPdo

extern

Definition at line 23 of file cmbatt.c.

Referenced by CmBattAddAcAdapter(), CmBattGetBatteryStatus(), CmBattIoctl(), and CmBattRemoveDevice().

◆ CmBattDebug

ULONG CmBattDebug

extern

Classes

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ ACPI_BATT_NOTIFY_INFO

◆ ACPI_BATT_NOTIFY_STATUS

◆ ACPI_BATT_POWER_UNIT_AMPS

◆ ACPI_BATT_POWER_UNIT_WATTS

◆ ACPI_BATT_STAT_CHARGING

◆ ACPI_BATT_STAT_CRITICAL

◆ ACPI_BATT_STAT_DISCHARG

◆ ACPI_BUS_CHECK

◆ ACPI_DEVICE_CHECK

◆ ACPI_STA_BATTERY_PRESENT

◆ ACPI_STA_ENABLED

◆ ACPI_STA_FUNCTIONAL

◆ ACPI_STA_PRESENT

◆ ACPI_STA_SHOW_UI

◆ ASCIIZ_MAX_LENGTH

◆ CM_MAX_VALUE

◆ CM_UNKNOWN_VALUE

◆ CMBATT_ACPI_ASSERT

◆ CMBATT_ACPI_ENTRY_EXIT

◆ CMBATT_ACPI_WARNING

◆ CMBATT_AR_INSERT

◆ CMBATT_AR_NOTIFY

◆ CMBATT_AR_REMOVE

◆ CMBATT_BATT_STATIC_INFO_TAG

◆ CMBATT_CAPACITY_BOGUS

◆ CMBATT_DISCHARGE_TIME

◆ CMBATT_GENERIC_INFO

◆ CMBATT_GENERIC_STATUS

◆ CMBATT_GENERIC_WARNING

◆ CMBATT_PNP_ENTRY_EXIT

◆ CMBATT_PNP_INFO

◆ CMBATT_POWER_INFO

◆ CONVERT_BATT_INFO

◆ CONVERT_MAH_TO_MWH

◆ IOCTL_BATTERY_QUERY_BIF_BIX

◆ IOCTL_BATTERY_QUERY_BST

◆ IOCTL_BATTERY_QUERY_PSR

◆ IOCTL_BATTERY_QUERY_STA

◆ IOCTL_BATTERY_QUERY_UNIQUE_ID

◆ IOCTL_BATTERY_SET_TRIP_POINT

Typedef Documentation

◆ ACPI_BATT_STATIC_INFO

◆ ACPI_BIF_DATA

◆ ACPI_BIX_DATA

◆ ACPI_BST_DATA

◆ CMBATT_DEVICE_EXTENSION

◆ CMBATT_EXTENSION_TYPE

◆ PACPI_BATT_STATIC_INFO

◆ PACPI_BIF_DATA

◆ PACPI_BIX_DATA

◆ PACPI_BST_DATA

◆ PCMBATT_DEVICE_EXTENSION

Enumeration Type Documentation

◆ _CMBATT_EXTENSION_TYPE

Function Documentation

◆ CmBattAddDevice()

◆ CmBattDisableStatusNotify()

◆ CmBattGetBifData()

◆ CmBattGetBixData()

◆ CmBattGetBstData()

◆ CmBattGetPsrData()

◆ CmBattGetStaData()

◆ CmBattGetUniqueId()

◆ CmBattNotifyHandler()

◆ CmBattPnpDispatch()

◆ CmBattPowerDispatch()

◆ CmBattQueryInformation()

◆ CmBattQueryStatus()

◆ CmBattQueryTag()

◆ CmBattSetStatusNotify()

◆ CmBattSetTripPpoint()

◆ CmBattSystemControl()

◆ CmBattWmiDeRegistration()