You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
569 lines
14 KiB
569 lines
14 KiB
/*++
|
|
|
|
Copyright (c) 1990 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
ApmBatt.c
|
|
|
|
Abstract:
|
|
|
|
Control Method Battery Miniport Driver - Wacked to work on APM.
|
|
|
|
Author:
|
|
|
|
Bryan Willman
|
|
Ron Mosgrove (Intel)
|
|
|
|
Environment:
|
|
|
|
Kernel mode
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "ApmBattp.h"
|
|
#include "ntddk.h"
|
|
#include "ntapm.h"
|
|
|
|
|
|
ULONG ApmBattDebug = APMBATT_ERROR;
|
|
//ULONG ApmBattDebug = -1;
|
|
|
|
//
|
|
// Prototypes
|
|
//
|
|
|
|
NTSTATUS
|
|
DriverEntry(
|
|
IN PDRIVER_OBJECT DriverObject,
|
|
IN PUNICODE_STRING RegistryPath
|
|
);
|
|
|
|
NTSTATUS
|
|
ApmBattOpenClose(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
);
|
|
|
|
NTSTATUS
|
|
ApmBattIoctl(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
);
|
|
|
|
|
|
//
|
|
// Globals. Globals are a little odd in a device driver,
|
|
// but this is an odd driver
|
|
//
|
|
|
|
//
|
|
// Vector used to call NtApm.sys (our PDO) and ask about
|
|
// current battery status
|
|
//
|
|
ULONG (*NtApmGetBatteryLevel)() = NULL;
|
|
|
|
//
|
|
// APM event notifications and SET_POWER ops will cause
|
|
// this value to be incremented.
|
|
//
|
|
ULONG TagValue = 1;
|
|
|
|
//
|
|
// If somebody tries to claim there is more than 1 APM driver battery
|
|
// in the system, somebody somewhere is very confused. So keep track
|
|
// and forbig this.
|
|
//
|
|
ULONG DeviceCount = 0;
|
|
|
|
//
|
|
//
|
|
//
|
|
|
|
#ifdef ALLOC_PRAGMA
|
|
#pragma alloc_text(INIT,DriverEntry)
|
|
#pragma alloc_text(PAGE,ApmBattQueryTag)
|
|
#pragma alloc_text(PAGE,ApmBattQueryInformation)
|
|
#pragma alloc_text(PAGE,ApmBattQueryStatus)
|
|
#pragma alloc_text(PAGE,ApmBattSetStatusNotify)
|
|
#pragma alloc_text(PAGE,ApmBattDisableStatusNotify)
|
|
#pragma alloc_text(PAGE,ApmBattOpenClose)
|
|
#pragma alloc_text(PAGE,ApmBattIoctl)
|
|
#endif
|
|
|
|
|
|
|
|
NTSTATUS
|
|
DriverEntry(
|
|
IN PDRIVER_OBJECT DriverObject,
|
|
IN PUNICODE_STRING RegistryPath
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine initializes the ACPI Embedded Controller Driver
|
|
|
|
Arguments:
|
|
|
|
DriverObject - Pointer to driver object created by system.
|
|
|
|
RegistryPath - Pointer to the Unicode name of the registry path
|
|
for this driver.
|
|
|
|
Return Value:
|
|
|
|
The function value is the final status from the initialization operation.
|
|
|
|
--*/
|
|
{
|
|
ApmBattPrint (APMBATT_TRACE, ("ApmBatt DriverEntry - Obj (%08x) Path (%08x)\n",
|
|
DriverObject, RegistryPath));
|
|
//
|
|
// Set up the device driver entry points.
|
|
//
|
|
DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = ApmBattIoctl;
|
|
DriverObject->MajorFunction[IRP_MJ_CREATE] = ApmBattOpenClose;
|
|
DriverObject->MajorFunction[IRP_MJ_CLOSE] = ApmBattOpenClose;
|
|
|
|
DriverObject->MajorFunction[IRP_MJ_POWER] = ApmBattPowerDispatch;
|
|
DriverObject->MajorFunction[IRP_MJ_PNP] = ApmBattPnpDispatch;
|
|
DriverObject->DriverExtension->AddDevice = ApmBattAddDevice;
|
|
|
|
return STATUS_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
NTSTATUS
|
|
ApmBattOpenClose(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This is the routine called as a result of a Open or Close on the device
|
|
|
|
Arguments:
|
|
|
|
|
|
DeviceObject - Battery for request
|
|
Irp - IO request
|
|
|
|
Return Value:
|
|
|
|
STATUS_SUCCESS - no way to fail this puppy
|
|
|
|
--*/
|
|
{
|
|
PAGED_CODE();
|
|
|
|
ApmBattPrint (APMBATT_TRACE, ("ApmBattOpenClose\n"));
|
|
|
|
//
|
|
// Complete the request and return status.
|
|
//
|
|
|
|
Irp->IoStatus.Status = STATUS_SUCCESS;
|
|
Irp->IoStatus.Information = 0;
|
|
IoCompleteRequest(Irp, IO_NO_INCREMENT);
|
|
return(STATUS_SUCCESS);
|
|
}
|
|
|
|
|
|
|
|
NTSTATUS
|
|
ApmBattIoctl(
|
|
IN PDEVICE_OBJECT DeviceObject,
|
|
IN PIRP Irp
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
IOCTL handler. As this is an exclusive battery device, send the
|
|
Irp to the battery class driver to handle battery IOCTLs.
|
|
|
|
Arguments:
|
|
|
|
DeviceObject - Battery for request
|
|
Irp - IO request
|
|
|
|
Return Value:
|
|
|
|
Status of request
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status;
|
|
PCM_BATT ApmBatt;
|
|
|
|
|
|
PAGED_CODE();
|
|
|
|
ApmBattPrint (APMBATT_TRACE, ("ApmBattIoctl\n"));
|
|
|
|
ApmBatt = (PCM_BATT) DeviceObject->DeviceExtension;
|
|
Status = BatteryClassIoctl (ApmBatt->Class, Irp);
|
|
|
|
if (Status == STATUS_NOT_SUPPORTED) {
|
|
//
|
|
// Not for the battery, complete it
|
|
//
|
|
|
|
Irp->IoStatus.Status = Status;
|
|
IoCompleteRequest (Irp, IO_NO_INCREMENT);
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
NTSTATUS
|
|
ApmBattQueryTag (
|
|
IN PVOID Context,
|
|
OUT PULONG TagPtr
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
BATTERY CLASS ENTRY
|
|
|
|
Called by the class driver to retrieve the batteries current tag value
|
|
|
|
The battery class driver will serialize all requests it issues to
|
|
the miniport for a given battery.
|
|
|
|
Arguments:
|
|
|
|
Context - Miniport context value for battery
|
|
TagPtr - Pointer to return current tag
|
|
|
|
Return Value:
|
|
|
|
Success if there is a battery currently installed, else no such device.
|
|
|
|
--*/
|
|
{
|
|
ULONG BatteryLevel;
|
|
UNREFERENCED_PARAMETER(Context);
|
|
PAGED_CODE();
|
|
ApmBattPrint ((APMBATT_TRACE | APMBATT_MINI),
|
|
("ApmBattQueryTag - TagValue = %08x\n", TagValue));
|
|
//
|
|
// The code that catches APM event notification, and the code
|
|
// that handles Power IRPs, will both increment the tag.
|
|
// We simply report that.
|
|
//
|
|
|
|
*TagPtr = TagValue;
|
|
|
|
//
|
|
// Call ntapm, it will return a DWORD with the relevent data in it,
|
|
// crack this DWORD, and fill this stuff in.
|
|
//
|
|
if (NtApmGetBatteryLevel) {
|
|
BatteryLevel = NtApmGetBatteryLevel();
|
|
if ((BatteryLevel & NTAPM_NO_BATT) || (BatteryLevel & NTAPM_NO_SYS_BATT)) {
|
|
return STATUS_NO_SUCH_DEVICE;
|
|
} else {
|
|
return STATUS_SUCCESS;
|
|
}
|
|
} else {
|
|
//
|
|
// if we cannot get battery status, it's likely we don't have
|
|
// a battery, so say we don't have one.
|
|
//
|
|
return STATUS_NO_SUCH_DEVICE;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
NTSTATUS
|
|
ApmBattQueryInformation (
|
|
IN PVOID Context,
|
|
IN ULONG BatteryTag,
|
|
IN BATTERY_QUERY_INFORMATION_LEVEL Level,
|
|
IN ULONG AtRate OPTIONAL,
|
|
OUT PVOID Buffer,
|
|
IN ULONG BufferLength,
|
|
OUT PULONG ReturnedLength
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
BATTERY CLASS ENTRY
|
|
|
|
Called by the class driver to retrieve battery information
|
|
|
|
The battery class driver will serialize all requests it issues to
|
|
the miniport for a given battery.
|
|
|
|
We return invalid parameter when we can't handle a request for a
|
|
specific level of information. This is defined in the battery class spec.
|
|
|
|
Arguments:
|
|
|
|
Context - Miniport context value for battery
|
|
BatteryTag - Tag of current battery
|
|
Level - type of information required
|
|
AtRate - Used only when Level==BatteryEstimatedTime
|
|
Buffer - Location for the information
|
|
BufferLength - Length in bytes of the buffer
|
|
ReturnedLength - Length in bytes of the returned data
|
|
|
|
Return Value:
|
|
|
|
Success if there is a battery currently installed, else no such device.
|
|
|
|
--*/
|
|
{
|
|
NTSTATUS Status;
|
|
PVOID ReturnBuffer;
|
|
ULONG ReturnBufferLength;
|
|
ULONG CapabilityVector = (BATTERY_SYSTEM_BATTERY | BATTERY_CAPACITY_RELATIVE);
|
|
BATTERY_INFORMATION bi;
|
|
|
|
|
|
PAGED_CODE();
|
|
|
|
ApmBattPrint ((APMBATT_TRACE | APMBATT_MINI),
|
|
("ApmBattQueryInformation Level=%08xl\n", Level));
|
|
|
|
//
|
|
// We cannot tell (reliably/safely) if there is a battery
|
|
// present or not, so always return what the query code tells us
|
|
//
|
|
|
|
ReturnBuffer = NULL;
|
|
ReturnBufferLength = 0;
|
|
Status = STATUS_SUCCESS;
|
|
|
|
//
|
|
// Get the info requested
|
|
//
|
|
|
|
switch (Level) {
|
|
case BatteryInformation:
|
|
ApmBattPrint((APMBATT_TRACE|APMBATT_MINI), ("Batteryinformation\n"));
|
|
RtlZeroMemory(&bi, sizeof(bi));
|
|
bi.Capabilities = CapabilityVector;
|
|
bi.Technology = BATTERY_SECONDARY_CHARGABLE;
|
|
bi.DesignedCapacity = 100;
|
|
bi.FullChargedCapacity = UNKNOWN_CAPACITY;
|
|
ReturnBuffer = (PVOID) &bi;
|
|
ReturnBufferLength = sizeof(bi);
|
|
break;
|
|
|
|
case BatteryEstimatedTime:
|
|
case BatteryTemperature:
|
|
case BatteryGranularityInformation:
|
|
case BatteryDeviceName:
|
|
case BatteryManufactureDate:
|
|
case BatteryManufactureName:
|
|
case BatteryUniqueID:
|
|
Status = STATUS_INVALID_DEVICE_REQUEST;
|
|
break;
|
|
|
|
default:
|
|
Status = STATUS_INVALID_PARAMETER;
|
|
break;
|
|
}
|
|
|
|
//
|
|
// Done, return buffer if needed
|
|
//
|
|
*ReturnedLength = ReturnBufferLength;
|
|
if (BufferLength < ReturnBufferLength) {
|
|
Status = STATUS_BUFFER_TOO_SMALL;
|
|
}
|
|
|
|
if (NT_SUCCESS(Status) && ReturnBuffer) {
|
|
RtlZeroMemory (Buffer, BufferLength); // Clear entire user buffer
|
|
RtlCopyMemory (Buffer, ReturnBuffer, ReturnBufferLength); // Copy what's needed
|
|
}
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
NTSTATUS
|
|
ApmBattQueryStatus (
|
|
IN PVOID Context,
|
|
IN ULONG BatteryTag,
|
|
OUT PBATTERY_STATUS BatteryStatus
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
BATTERY CLASS ENTRY
|
|
|
|
Called by the class driver to retrieve the batteries current status
|
|
|
|
The battery class driver will serialize all requests it issues to
|
|
the miniport for a given battery.
|
|
|
|
Arguments:
|
|
|
|
Context - Miniport context value for battery
|
|
BatteryTag - Tag of current battery
|
|
BatteryStatus - Pointer to structure to return the current battery status
|
|
|
|
Return Value:
|
|
|
|
Success if there is a battery currently installed, else no such device.
|
|
|
|
--*/
|
|
{
|
|
ULONG BatteryLevel;
|
|
|
|
PAGED_CODE();
|
|
|
|
ApmBattPrint ((APMBATT_TRACE | APMBATT_MINI), ("ApmBattQueryStatus\n"));
|
|
|
|
//
|
|
// Call ntapm, it will return a DWORD with the relevent data in it,
|
|
// crack this DWORD, and fill this stuff in.
|
|
//
|
|
if (NtApmGetBatteryLevel) {
|
|
BatteryLevel = NtApmGetBatteryLevel();
|
|
BatteryStatus->PowerState = ((BatteryLevel & NTAPM_BATTERY_STATE) >> NTAPM_BATTERY_STATE_SHIFT);
|
|
BatteryStatus->Capacity = BatteryLevel & NTAPM_POWER_PERCENT;
|
|
BatteryStatus->Voltage = UNKNOWN_VOLTAGE;
|
|
BatteryStatus->Current = UNKNOWN_RATE;
|
|
|
|
ApmBattPrint((APMBATT_MINI), ("ApmBattQueryStatus: BatteryLevel = %08lx\n", BatteryLevel));
|
|
|
|
return STATUS_SUCCESS;
|
|
|
|
} else {
|
|
ApmBattPrint((APMBATT_ERROR), ("ApmBattQueryStatus: failure NtApmGetBatteryLevel == NULL\n"));
|
|
//
|
|
// return some "safe" values to keep from looping forever
|
|
//
|
|
BatteryStatus->PowerState = 0;
|
|
BatteryStatus->Capacity = 1;
|
|
BatteryStatus->Voltage = UNKNOWN_VOLTAGE;
|
|
BatteryStatus->Current = UNKNOWN_RATE;
|
|
return STATUS_UNSUCCESSFUL;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
NTSTATUS
|
|
ApmBattSetStatusNotify (
|
|
IN PVOID Context,
|
|
IN ULONG BatteryTag,
|
|
IN PBATTERY_NOTIFY Notify
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
BATTERY CLASS ENTRY
|
|
|
|
Called by the class driver to set the batteries current notification
|
|
setting. When the battery trips the notification, one call to
|
|
BatteryClassStatusNotify is issued. If an error is returned, the
|
|
class driver will poll the battery status - primarily for capacity
|
|
changes. Which is to say the miniport should still issue BatteryClass-
|
|
StatusNotify whenever the power state changes.
|
|
|
|
The class driver will always set the notification level it needs
|
|
after each call to BatteryClassStatusNotify.
|
|
|
|
The battery class driver will serialize all requests it issues to
|
|
the miniport for a given battery.
|
|
|
|
Arguments:
|
|
|
|
Context - Miniport context value for battery
|
|
BatteryTag - Tag of current battery
|
|
BatteryNotify - The notification setting
|
|
|
|
Return Value:
|
|
|
|
Status
|
|
|
|
--*/
|
|
{
|
|
//
|
|
// need to fill this in
|
|
//
|
|
ApmBattPrint (APMBATT_TRACE, ("ApmBattSetStatusNotify\n"));
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
|
|
|
|
NTSTATUS
|
|
ApmBattDisableStatusNotify (
|
|
IN PVOID Context
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
BATTERY CLASS ENTRY
|
|
|
|
Called by the class driver to disable the notification setting
|
|
for the battery supplied by Context. Note, to disable a setting
|
|
does not require the battery tag. Any notification is to be
|
|
masked off until a subsequent call to ApmBattSetStatusNotify.
|
|
|
|
The battery class driver will serialize all requests it issues to
|
|
the miniport for a given battery.
|
|
|
|
Arguments:
|
|
|
|
Context - Miniport context value for battery
|
|
|
|
Return Value:
|
|
|
|
Status
|
|
|
|
--*/
|
|
{
|
|
//
|
|
// need to fill this in
|
|
//
|
|
ApmBattPrint (APMBATT_TRACE, ("ApmBattDisableStatusNotify\n"));
|
|
return STATUS_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
VOID
|
|
ApmBattPowerNotifyHandler (
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
NTAPM CALLBACK
|
|
|
|
This routine fields power device notifications from the APM driver.
|
|
|
|
Arguments:
|
|
|
|
|
|
Return Value:
|
|
|
|
None
|
|
|
|
--*/
|
|
{
|
|
ApmBattPrint (APMBATT_TRACE, ("ApmBattPowerNotifyHandler\n"));
|
|
// DbgBreakPoint();
|
|
TagValue++;
|
|
BatteryClassStatusNotify(ApmGlobalClass);
|
|
}
|
|
|