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_DATA *	PACPI_BST_DATA
typedef struct _ACPI_BIF_DATA	ACPI_BIF_DATA
typedef struct _ACPI_BIF_DATA *	PACPI_BIF_DATA
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	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

typedef struct _ACPI_BIF_DATA ACPI_BIF_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_BIF_DATA

typedef struct _ACPI_BIF_DATA * PACPI_BIF_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 45 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 595 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 325 of file cmexec.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by CmBattIoctl().

CmBattGetBstData()

NTSTATUS NTAPI CmBattGetBstData	(	PCMBATT_DEVICE_EXTENSION	DeviceExtension,
		PACPI_BST_DATA	BstData
	)

Definition at line 334 of file cmexec.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

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 1000 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 2 1/2 minutes since the last change */
            if ((KeQueryInterruptTime() - 150000000) > (FdoExtension->InterruptTime))
            {
                /* 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;
                
                /* 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 > 0x123456)
                    {
                        /* 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;
                    }
                }
            }
            
            /* Return the remaining time */
            QueryData = &RemainingTime;
            QueryLength = sizeof(ULONG);
            break;
            
        case BatteryDeviceName:
        
            /* Build the model number string */
            RtlInitAnsiString(&TempString, FdoExtension->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 */
            RtlInitAnsiString(&TempString, FdoExtension->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 */
            RtlInitAnsiString(&TempString, FdoExtension->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->OemInfo[0])
            {
                /* Build the OEM info string */
                RtlInitAnsiString(&TempString, FdoExtension->OemInfo);
              
                /* Convert it to Unicode and append it */
                RtlAnsiStringToUnicodeString(&TempString2, &TempString, 0);
                RtlAppendUnicodeStringToString(&InfoString, &TempString2);
            }
            
            /* Build the model number string */
            RtlInitAnsiString(&TempString, FdoExtension->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 1213 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 536 of file cmbatt.c.

{
    PDEVICE_OBJECT PdoDevice;
    ULONG StaData;
    ULONG NewTag;
    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)
            {
                /* Set the new tag value, reset tags if we reached the maximum */
                NewTag = DeviceExtension->TagData;
                if (DeviceExtension->TagData++ == 0xFFFFFFFF) NewTag = 1;
                DeviceExtension->Tag = NewTag;
                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 = 0;
            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 636 of file cmbatt.c.

{
    NTSTATUS Status;
    ACPI_BST_DATA BstData;
    ULONG 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;
    }

    /* Do we have data in Amps or Watts? */
    if (DeviceExtension->BifData.PowerUnit == ACPI_BATT_POWER_UNIT_AMPS)
    {
        /* We need the voltage to do the conversion */
        DesignVoltage = DeviceExtension->BifData.DesignVoltage;
        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 %x\n",
                    BatteryNotify->PowerState,
                    BatteryNotify->LowCapacity,
                    BatteryNotify->HighCapacity);
    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

Definition at line 23 of file cmbatt.c.

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

CmBattDebug

ULONG CmBattDebug

Definition at line 17 of file cmbatt.c.

Referenced by CmBattAddAcAdapter(), CmBattAddBattery(), CmBattAddDevice(), CmBattCreateFdo(), CmBattDestroyFdo(), CmBattDisableStatusNotify(), CmBattGetAcpiInterfaces(), CmBattGetBatteryStatus(), CmBattGetPsrData(), CmBattGetStaData(), CmBattGetUniqueId(), CmBattIoCompletion(), CmBattIoctl(), CmBattNotifyHandler(), CmBattOpenClose(), CmBattPnpDispatch(), CmBattPowerCallBack(), CmBattPowerDispatch(), CmBattQueryInformation(), CmBattQueryStatus(), CmBattQueryTag(), CmBattRemoveDevice(), CmBattSendDownStreamIrp(), CmBattSetStatusNotify(), CmBattSetTripPpoint(), CmBattSystemControl(), CmBattUnload(), CmBattWaitWakeLoop(), CmBattWakeDpc(), DriverEntry(), GetDwordElement(), and GetStringElement().