compbatt.h File Reference

#include <wdm.h>
#include <batclass.h>

Include dependency graph for compbatt.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_COMPBATT_BATTERY_DATA
struct	_COMPBATT_DEVICE_EXTENSION

Macros
#define	COMPBATT_BATTERY_INFORMATION_PRESENT   0x04
#define	COMPBATT_TAG_ASSIGNED   0x80

Typedefs
typedef struct _COMPBATT_BATTERY_DATA	COMPBATT_BATTERY_DATA
typedef struct _COMPBATT_BATTERY_DATA *	PCOMPBATT_BATTERY_DATA
typedef struct _COMPBATT_DEVICE_EXTENSION	COMPBATT_DEVICE_EXTENSION
typedef struct _COMPBATT_DEVICE_EXTENSION *	PCOMPBATT_DEVICE_EXTENSION

Functions
NTSTATUS NTAPI	CompBattAddDevice (IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT PdoDeviceObject)
NTSTATUS NTAPI	CompBattPowerDispatch (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	CompBattPnpDispatch (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
NTSTATUS NTAPI	CompBattQueryInformation (IN PCOMPBATT_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	CompBattQueryStatus (IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension, IN ULONG Tag, IN PBATTERY_STATUS BatteryStatus)
NTSTATUS NTAPI	CompBattSetStatusNotify (IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension, IN ULONG BatteryTag, IN PBATTERY_NOTIFY BatteryNotify)
NTSTATUS NTAPI	CompBattDisableStatusNotify (IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension)
NTSTATUS NTAPI	CompBattQueryTag (IN PCOMPBATT_DEVICE_EXTENSION DeviceExtension, OUT PULONG Tag)
NTSTATUS NTAPI	CompBattMonitorIrpComplete (IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PKEVENT Event)
NTSTATUS NTAPI	CompBattMonitorIrpCompleteWorker (IN PCOMPBATT_BATTERY_DATA BatteryData)
NTSTATUS NTAPI	CompBattGetDeviceObjectPointer (IN PUNICODE_STRING DeviceName, IN ACCESS_MASK DesiredAccess, OUT PFILE_OBJECT *FileObject, OUT PDEVICE_OBJECT *DeviceObject)
NTSTATUS NTAPI	BatteryIoctl (IN ULONG IoControlCode, IN PDEVICE_OBJECT DeviceObject, IN PVOID InputBuffer, IN ULONG InputBufferLength, IN PVOID OutputBuffer, IN ULONG OutputBufferLength, IN BOOLEAN InternalDeviceIoControl)

Variables
ULONG	CompBattDebug

Macro Definition Documentation

COMPBATT_BATTERY_INFORMATION_PRESENT

#define COMPBATT_BATTERY_INFORMATION_PRESENT   0x04

Definition at line 15 of file compbatt.h.

COMPBATT_TAG_ASSIGNED

#define COMPBATT_TAG_ASSIGNED   0x80

Definition at line 16 of file compbatt.h.

Typedef Documentation

COMPBATT_BATTERY_DATA

typedef struct _COMPBATT_BATTERY_DATA COMPBATT_BATTERY_DATA

COMPBATT_DEVICE_EXTENSION

typedef struct _COMPBATT_DEVICE_EXTENSION COMPBATT_DEVICE_EXTENSION

PCOMPBATT_BATTERY_DATA

typedef struct _COMPBATT_BATTERY_DATA * PCOMPBATT_BATTERY_DATA

PCOMPBATT_DEVICE_EXTENSION

typedef struct _COMPBATT_DEVICE_EXTENSION * PCOMPBATT_DEVICE_EXTENSION

Function Documentation

BatteryIoctl()

NTSTATUS NTAPI BatteryIoctl	(	IN ULONG	IoControlCode,
		IN PDEVICE_OBJECT	DeviceObject,
		IN PVOID	InputBuffer,
		IN ULONG	InputBufferLength,
		IN PVOID	OutputBuffer,
		IN ULONG	OutputBufferLength,
		IN BOOLEAN	InternalDeviceIoControl
	)

Definition at line 17 of file compmisc.c.

{
    IO_STATUS_BLOCK IoStatusBlock;
    KEVENT Event;
    NTSTATUS Status;
    PIRP Irp;
    PAGED_CODE();
    if (CompBattDebug & 0x100) DbgPrint("CompBatt: ENTERING BatteryIoctl\n");
 
    /* Initialize the event and IRP */
    KeInitializeEvent(&Event, SynchronizationEvent, 0);
    Irp = IoBuildDeviceIoControlRequest(IoControlCode,
                                        DeviceObject,
                                        InputBuffer,
                                        InputBufferLength,
                                        OutputBuffer,
                                        OutputBufferLength,
                                        InternalDeviceIoControl,
                                        &Event,
                                        &IoStatusBlock);
    if (Irp)
    {
        /* Call the class driver miniport */
        Status = IoCallDriver(DeviceObject, Irp);
        if (Status == STATUS_PENDING)
        {
            /* Wait for result */
            KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
            Status = IoStatusBlock.Status;
        }
 
        /* Print failure */
        if (!(NT_SUCCESS(Status)) && (CompBattDebug & 8))
            DbgPrint("BatteryIoctl: Irp failed - %x\n", Status);
 
        /* Done */
        if (CompBattDebug & 0x100) DbgPrint("CompBatt: EXITING BatteryIoctl\n");
    }
    else
    {
        /* Out of memory */
        if (CompBattDebug & 8) DbgPrint("BatteryIoctl: couldn't create Irp\n");
        Status = STATUS_INSUFFICIENT_RESOURCES;
    }
 
    /* Return status */
    return Status;
}

Referenced by CompBattGetBatteryGranularity(), and CompBattGetBatteryInformation().

CompBattAddDevice()

NTSTATUS NTAPI CompBattAddDevice	(	IN PDRIVER_OBJECT	DriverObject,
		IN PDEVICE_OBJECT	PdoDeviceObject
	)

Definition at line 320 of file comppnp.c.

{
    NTSTATUS Status;
    UNICODE_STRING DeviceName;
    PCOMPBATT_DEVICE_EXTENSION DeviceExtension;
    PDEVICE_OBJECT DeviceObject;
    UNICODE_STRING SymbolicLinkName;
    BATTERY_MINIPORT_INFO MiniportInfo;
    if (CompBattDebug & 2) DbgPrint("CompBatt: Got an AddDevice - %x\n", PdoDeviceObject);
 
    /* Create the device */
    RtlInitUnicodeString(&DeviceName, L"\\Device\\CompositeBattery");
    Status = IoCreateDevice(DriverObject,
                            sizeof(COMPBATT_DEVICE_EXTENSION),
                            &DeviceName,
                            FILE_DEVICE_BATTERY,
                            FILE_DEVICE_SECURE_OPEN,
                            FALSE,
                            &DeviceObject);
    if (!NT_SUCCESS(Status)) return Status;
 
    /* Setup symbolic link for Win32 access */
    RtlInitUnicodeString(&SymbolicLinkName, L"\\DosDevices\\CompositeBattery");
    IoCreateSymbolicLink(&SymbolicLinkName, &DeviceName);
 
    /* Initialize the device extension */
    DeviceExtension = DeviceObject->DeviceExtension;
    RtlZeroMemory(DeviceExtension, sizeof(COMPBATT_DEVICE_EXTENSION));
 
    /* Attach to device stack and set DO pointers */
    DeviceExtension->AttachedDevice = IoAttachDeviceToDeviceStack(DeviceObject,
                                                                  PdoDeviceObject);
    DeviceExtension->DeviceObject = DeviceObject;
    if (!DeviceExtension->AttachedDevice)
    {
        /* Fail */
        if (CompBattDebug & 8)
            DbgPrint("CompBattAddDevice: Could not attach to LowerDevice.\n");
        IoDeleteDevice(DeviceObject);
        return STATUS_UNSUCCESSFUL;
    }
 
    /* Set device object flags */
    DeviceObject->Flags |= (DO_POWER_PAGABLE | DO_BUFFERED_IO);
    DeviceObject->Flags &= ~DO_DEVICE_INITIALIZING;
 
    /* Setup the device extension */
    ExInitializeFastMutex(&DeviceExtension->Lock);
    InitializeListHead(&DeviceExtension->BatteryList);
    DeviceExtension->Flags = 0;
    DeviceExtension->NextTag = 1;
 
    /* Setup the miniport data */
    RtlZeroMemory(&MiniportInfo, sizeof(MiniportInfo));
    MiniportInfo.MajorVersion = BATTERY_CLASS_MAJOR_VERSION;
    MiniportInfo.MinorVersion = BATTERY_CLASS_MINOR_VERSION;
    MiniportInfo.Context = DeviceExtension;
    MiniportInfo.DeviceName = &DeviceName;
    MiniportInfo.QueryTag = (BCLASS_QUERY_TAG)CompBattQueryTag;
    MiniportInfo.QueryInformation = (BCLASS_QUERY_INFORMATION)CompBattQueryInformation;
    MiniportInfo.SetInformation = NULL;
    MiniportInfo.QueryStatus = (BCLASS_QUERY_STATUS)CompBattQueryStatus;
    MiniportInfo.SetStatusNotify = (BCLASS_SET_STATUS_NOTIFY)CompBattSetStatusNotify;
    MiniportInfo.DisableStatusNotify = (BCLASS_DISABLE_STATUS_NOTIFY)CompBattDisableStatusNotify;
    MiniportInfo.Pdo = NULL;
 
    /* Register with the class driver */
    Status = BatteryClassInitializeDevice(&MiniportInfo,
                                          &DeviceExtension->ClassData);
    if (!NT_SUCCESS(Status))
    {
        /* Undo everything */
        IoDetachDevice(DeviceExtension->AttachedDevice);
        IoDeleteDevice(DeviceObject);
    }
 
    /* Return status */
    return Status;
}

Referenced by DriverEntry().

CompBattDisableStatusNotify()

NTSTATUS NTAPI CompBattDisableStatusNotify

(

IN PCOMPBATT_DEVICE_EXTENSION

DeviceExtension

)

Definition at line 184 of file compbatt.c.

{
    PCOMPBATT_BATTERY_DATA BatteryData;
    PLIST_ENTRY ListHead, NextEntry;
    if (CompBattDebug & 0x100) DbgPrint("CompBatt: ENTERING DisableStatusNotify\n");
 
    /* Loop the battery list */
    ExAcquireFastMutex(&DeviceExtension->Lock);
    ListHead = &DeviceExtension->BatteryList;
    NextEntry = ListHead->Flink;
    while (NextEntry != ListHead)
    {
        /* Get the battery information and clear capacity data */
        BatteryData = CONTAINING_RECORD(NextEntry, COMPBATT_BATTERY_DATA, BatteryLink);
        BatteryData->WaitStatus.LowCapacity = 0;
        BatteryData->WaitStatus.HighCapacity = 0x7FFFFFFF;
        NextEntry = NextEntry->Flink;
    }
 
    /* Done */
    ExReleaseFastMutex(&DeviceExtension->Lock);
    if (CompBattDebug & 0x100) DbgPrint("CompBatt: EXITING DisableStatusNotify\n");
    return STATUS_SUCCESS;
}

Referenced by CompBattAddDevice().

CompBattGetDeviceObjectPointer()

NTSTATUS NTAPI CompBattGetDeviceObjectPointer	(	IN PUNICODE_STRING	DeviceName,
		IN ACCESS_MASK	DesiredAccess,
		OUT PFILE_OBJECT *	FileObject,
		OUT PDEVICE_OBJECT *	DeviceObject
	)

Definition at line 74 of file compmisc.c.

{
    NTSTATUS Status;
    OBJECT_ATTRIBUTES ObjectAttributes;
    IO_STATUS_BLOCK IoStatusBlock;
    PFILE_OBJECT LocalFileObject;
    HANDLE DeviceHandle;
    PAGED_CODE();
 
    /* Open a file object handle to the device */
    InitializeObjectAttributes(&ObjectAttributes,
                               DeviceName,
                               OBJ_KERNEL_HANDLE,
                               NULL,
                               NULL);
    Status = ZwCreateFile(&DeviceHandle,
                          DesiredAccess,
                          &ObjectAttributes,
                          &IoStatusBlock,
                          NULL,
                          0,
                          FILE_SHARE_READ | FILE_SHARE_WRITE,
                          FILE_OPEN,
                          0,
                          NULL,
                          0);
    if (NT_SUCCESS(Status))
    {
        /* Reference the file object */
        Status = ObReferenceObjectByHandle(DeviceHandle,
                                           0,
                                           *IoFileObjectType,
                                           KernelMode,
                                           (PVOID)&LocalFileObject,
                                           NULL);
        if (NT_SUCCESS(Status))
        {
            /* Return the FO and the associated DO */
            *FileObject = LocalFileObject;
            *DeviceObject = IoGetRelatedDeviceObject(LocalFileObject);
        }
 
        /* Close the handle */
        ZwClose(DeviceHandle);
    }
 
    /* Return status */
    return Status;
}

Referenced by CompBattAddNewBattery().

CompBattMonitorIrpComplete()

NTSTATUS NTAPI CompBattMonitorIrpComplete	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp,
		IN PKEVENT	Event
	)

Definition at line 70 of file compbatt.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by CompBattAddNewBattery().

CompBattMonitorIrpCompleteWorker()

NTSTATUS NTAPI CompBattMonitorIrpCompleteWorker

(

IN PCOMPBATT_BATTERY_DATA

BatteryData

)

Definition at line 80 of file compbatt.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by CompBattAddNewBattery().

CompBattPnpDispatch()

NTSTATUS NTAPI CompBattPnpDispatch	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 403 of file comppnp.c.

{
    PIO_STACK_LOCATION IoStackLocation = IoGetCurrentIrpStackLocation(Irp);
    NTSTATUS Status;
    PCOMPBATT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
    if (CompBattDebug & 1) DbgPrint("CompBatt: ENTERING PnpDispatch\n");
 
    /* Set default error */
    Status = STATUS_NOT_SUPPORTED;
 
    /* Check what kind of PnP function this is */
    switch (IoStackLocation->MinorFunction)
    {
        case IRP_MN_START_DEVICE:
 
            /* Device is starting, register for new batteries and pick up current ones */
            Status = IoRegisterPlugPlayNotification(EventCategoryDeviceInterfaceChange,
                                                    0,
                                                    (PVOID)&GUID_DEVICE_BATTERY,
                                                    DeviceObject->DriverObject,
                                                    (PDRIVER_NOTIFICATION_CALLBACK_ROUTINE)CompBattPnpEventHandler,
                                                    DeviceExtension,
                                                    &DeviceExtension->NotificationEntry);
            if (NT_SUCCESS(Status))
            {
                /* Now go get the batteries */
                if (CompBattDebug & 2)
                    DbgPrint("CompBatt: Successfully registered for PnP notification\n");
                Status = CompBattGetBatteries(DeviceExtension);
            }
            else
            {
                /* We failed */
                if (CompBattDebug & 8)
                    DbgPrint("CompBatt: Couldn't register for PnP notification - %x\n",
                             Status);
            }
             break;
        case IRP_MN_CANCEL_STOP_DEVICE:
 
            /* Explicitly say ok */
            Status = STATUS_SUCCESS;
            break;
 
        case IRP_MN_CANCEL_REMOVE_DEVICE:
 
            /* Explicitly say ok */
            Status = STATUS_SUCCESS;
            break;
 
        case IRP_MN_SURPRISE_REMOVAL:
 
            /* Explicitly say ok */
            Status = STATUS_SUCCESS;
            break;
 
        case IRP_MN_QUERY_PNP_DEVICE_STATE:
 
            /* Add this in */
            Irp->IoStatus.Information |= PNP_DEVICE_NOT_DISABLEABLE;
            Status = STATUS_SUCCESS;
            break;
 
        default:
 
            /* Not supported */
            Status = STATUS_INVALID_DEVICE_REQUEST;
            break;
    }
 
    /* Set IRP status if we have one */
    if (Status != STATUS_NOT_SUPPORTED) Irp->IoStatus.Status = Status;
 
    /* Did someone pick it up? */
    if ((NT_SUCCESS(Status)) || (Status == STATUS_NOT_SUPPORTED))
    {
        /* Still unsupported, try ACPI */
        IoSkipCurrentIrpStackLocation(Irp);
        Status = IoCallDriver(DeviceExtension->AttachedDevice, Irp);
    }
    else
    {
        /* Complete the request */
        Status = Irp->IoStatus.Status;
        IoCompleteRequest(Irp, IO_NO_INCREMENT);
    }
 
    /* Release the remove lock and return status */
    if (CompBattDebug & 1) DbgPrint("CompBatt: EXITING PnpDispatch\n");
    return Status;
}

Referenced by DriverEntry().

CompBattPowerDispatch()

NTSTATUS NTAPI CompBattPowerDispatch	(	IN PDEVICE_OBJECT	DeviceObject,
		IN PIRP	Irp
	)

Definition at line 19 of file comppnp.c.

{
    PCOMPBATT_DEVICE_EXTENSION DeviceExtension = DeviceObject->DeviceExtension;
    if (CompBattDebug & 1) DbgPrint("CompBatt: PowerDispatch received power IRP.\n");
 
    /* Start the next IRP */
    PoStartNextPowerIrp(Irp);
 
    /* Call the next driver in the stack */
    IoSkipCurrentIrpStackLocation(Irp);
    return PoCallDriver(DeviceExtension->AttachedDevice, Irp);
}

Referenced by DriverEntry().

CompBattQueryInformation()

NTSTATUS NTAPI CompBattQueryInformation	(	IN PCOMPBATT_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 482 of file compbatt.c.

{
    BATTERY_INFORMATION BatteryInfo;
    BATTERY_REPORTING_SCALE BatteryGranularity[4];
    PWCHAR BatteryName = L"Composite Battery";
    //BATTERY_MANUFACTURE_DATE Date;
    ULONG Dummy, Time;
    PVOID QueryData = NULL;
    ULONG QueryLength = 0;
    NTSTATUS Status = STATUS_SUCCESS;
    PAGED_CODE();
    if (CompBattDebug & 1)  DbgPrint("CompBatt: ENTERING QueryInformation\n");
 
    /* Check for valid/correct tag */
    if ((Tag != DeviceExtension->Tag) ||
        (!(DeviceExtension->Flags & COMPBATT_TAG_ASSIGNED)))
    {
        /* Not right, so fail */
        return STATUS_NO_SUCH_DEVICE;
    }
 
    /* Check what caller wants */
    switch (InfoLevel)
    {
        case BatteryInformation:
 
            /* Query combined battery information */
            RtlZeroMemory(&BatteryInfo, sizeof(BatteryInfo));
            Status = CompBattGetBatteryInformation(&BatteryInfo, DeviceExtension);
            if (NT_SUCCESS(Status))
            {
                /* Return the data if successful */
                QueryData = &BatteryInfo;
                QueryLength = sizeof(BatteryInfo);
            }
            break;
 
        case BatteryGranularityInformation:
 
            /* Query combined granularity information */
            RtlZeroMemory(&BatteryGranularity, sizeof(BatteryGranularity));
            Status = CompBattGetBatteryGranularity(BatteryGranularity, DeviceExtension);
            if (NT_SUCCESS(Status))
            {
                /* Return the data if successful */
                QueryLength = sizeof(BatteryGranularity);
                QueryData = &BatteryGranularity;
            }
            break;
 
        case BatteryEstimatedTime:
 
            /* Query combined time estimate information */
            RtlZeroMemory(&Time, sizeof(Time));
            Status = CompBattGetEstimatedTime(&Time, DeviceExtension);
            if (NT_SUCCESS(Status))
            {
                /* Return the data if successful */
                QueryLength = sizeof(Time);
                QueryData = &Time;
            }
            break;
 
        case BatteryManufactureName:
        case BatteryDeviceName:
 
            /* Return the static buffer */
            QueryData = BatteryName;
            QueryLength = sizeof(L"Composite Battery");
            break;
 
        case BatteryManufactureDate:
 
            /* Static data */
            //Date.Day = 26;
            //Date.Month = 06;
            //Date.Year = 1997;
            break;
 
        case BatteryTemperature:
        case BatteryUniqueID:
 
            /* Return zero */
            Dummy = 0;
            QueryData = &Dummy;
            QueryLength = sizeof(Dummy);
            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 */
    if (CompBattDebug & 1) DbgPrint("CompBatt: EXITING QueryInformation\n");
    return Status;
}

Referenced by CompBattAddDevice().

CompBattQueryStatus()

NTSTATUS NTAPI CompBattQueryStatus	(	IN PCOMPBATT_DEVICE_EXTENSION	DeviceExtension,
		IN ULONG	Tag,
		IN PBATTERY_STATUS	BatteryStatus
	)

Definition at line 221 of file compbatt.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by CompBattAddDevice().

CompBattQueryTag()

NTSTATUS NTAPI CompBattQueryTag	(	IN PCOMPBATT_DEVICE_EXTENSION	DeviceExtension,
		OUT PULONG	Tag
	)

Definition at line 149 of file compbatt.c.

{
    NTSTATUS Status;
    PAGED_CODE();
    if (CompBattDebug & 0x100) DbgPrint("CompBatt: ENTERING QueryTag\n");
 
    /* Was a tag assigned? */
    if (!(DeviceExtension->Flags & COMPBATT_TAG_ASSIGNED))
    {
        /* Assign one */
        CompBattRecalculateTag(DeviceExtension);
    }
 
    /* Do we have a tag now? */
    if ((DeviceExtension->Flags & COMPBATT_TAG_ASSIGNED) && (DeviceExtension->Tag))
    {
        /* Return the tag */
        *Tag = DeviceExtension->Tag;
        Status = STATUS_SUCCESS;
    }
    else
    {
        /* No tag */
        *Tag = 0;
        Status = STATUS_NO_SUCH_DEVICE;
    }
 
    /* Return status */
    if (CompBattDebug & 0x100) DbgPrint("CompBatt: EXITING QueryTag\n");
    return Status;
}

Referenced by CompBattAddDevice().

CompBattSetStatusNotify()

NTSTATUS NTAPI CompBattSetStatusNotify	(	IN PCOMPBATT_DEVICE_EXTENSION	DeviceExtension,
		IN ULONG	BatteryTag,
		IN PBATTERY_NOTIFY	BatteryNotify
	)

Definition at line 211 of file compbatt.c.

{
    UNIMPLEMENTED;
    return STATUS_NOT_IMPLEMENTED;
}

Referenced by CompBattAddDevice().

Variable Documentation

CompBattDebug

ULONG CompBattDebug

extern

Definition at line 17 of file compbatt.c.

Referenced by BatteryIoctl(), CompBattAddDevice(), CompBattAddNewBattery(), CompBattDisableStatusNotify(), CompBattGetBatteries(), CompBattGetBatteryGranularity(), CompBattGetBatteryInformation(), CompBattIoctl(), CompBattOpenClose(), CompBattPnpDispatch(), CompBattPnpEventHandler(), CompBattPowerDispatch(), CompBattQueryInformation(), CompBattQueryTag(), CompBattRecalculateTag(), CompBattRemoveBattery(), CompBattSystemControl(), IsBatteryAlreadyOnList(), and RemoveBatteryFromList().