windows-xp/Source/XPSP1/NT/base/busdrv/acpi/hidbatt/hidbattio.cpp

/*
 * title:      HidBattIOCT.cpp
 *
 * purpose:    Contains misc ioctl handlers for status and query info mainly
 *
 * Initial checkin for the hid to battery class driver.  This should be
 * the same for both Win 98 and NT 5.  Alpha level source. Requires
 * modified composite battery driver and modified battery class driver for
 * Windows 98 support
 *
 */


#include "hidbatt.h"


/*++

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
HidBattIoControl(
    IN PDEVICE_OBJECT   pDeviceObject,
    IN PIRP             pIrp
    )
{
    NTSTATUS            ntStatus = STATUS_NOT_SUPPORTED;
    CBatteryDevExt *    pDevExt;
    PIO_STACK_LOCATION  irpSp;
    HIDDebugBreak(HIDBATT_BREAK_ALWAYS);

    irpSp = IoGetCurrentIrpStackLocation(pIrp);
    HidBattPrint (HIDBATT_TRACE, ("HidBattIoctl = %x\n", irpSp->Parameters.DeviceIoControl.IoControlCode));

//    PrintIoctl(irpSp->Parameters.DeviceIoControl.IoControlCode);

    pDevExt = (CBatteryDevExt *) pDeviceObject->DeviceExtension;

    if (NT_SUCCESS(IoAcquireRemoveLock (&pDevExt->m_StopLock, (PVOID) HidBattTag)))
    {
        if (pDevExt->m_pBattery &&
            pDevExt->m_pBattery->m_pBatteryClass) {
            ntStatus = BatteryClassIoctl (pDevExt->m_pBattery->m_pBatteryClass, pIrp);
        }
        IoReleaseRemoveLock (&pDevExt->m_StopLock, (PVOID) HidBattTag);
    } else {
        ntStatus = STATUS_DEVICE_REMOVED;
        pIrp->IoStatus.Status = ntStatus;
        IoCompleteRequest(pIrp,IO_NO_INCREMENT);
    }

    if (ntStatus == STATUS_NOT_SUPPORTED)
    {
        HidBattCallLowerDriver(ntStatus, pDevExt->m_pLowerDeviceObject, pIrp);
    }

    return ntStatus;
}

VOID
HidBattNotifyHandler (
    IN PVOID        pContext,
    IN CUsage *        pUsage
    )
{
    HIDDebugBreak(HIDBATT_BREAK_ALWAYS);
    NTSTATUS ntStatus;
    ULONG ulCapacityLimit = BATTERY_UNKNOWN_CAPACITY;
    BOOL bResult;

    HidBattPrint (HIDBATT_TRACE, ("HidBattNotifyHandler\n"));
    // called by input routine whenever a value change is noted to
    // a notificable usage
    CBatteryDevExt * pDevExt = (CBatteryDevExt *) pContext;

    HidBattPrint (HIDBATT_DATA, ("HidBattNotifyHandler: Usage: %x\n", pUsage->m_pProperties->m_Usage));
    switch (pUsage->m_pProperties->m_Usage)
    {
        case    REMAINING_CAPACITY_ID:

          bResult = pDevExt->m_pBattery->GetSetValue(REMAINING_CAPACITY_LIMIT_INDEX,&ulCapacityLimit,FALSE);
          // Only send notification when capacity drops below notify level.
          if ((bResult) && (ulCapacityLimit != BATTERY_UNKNOWN_CAPACITY) && (pUsage->m_Value != BATTERY_UNKNOWN_CAPACITY)
              && (pUsage->m_Value > ulCapacityLimit)) {
               HidBattPrint (HIDBATT_TRACE, ("HidBattNotifyHandler:Suppressing notify\n"));
               break;
          }

        case    AC_PRESENT_ID:            // check for battery off/on line
        case    DISCHARGING_ID:
        case    CHARGING_ID:
        case    BELOW_REMAINING_CAPACITY_ID:
        case    SHUTDOWN_IMMINENT_ID:
        {
            pDevExt->m_pBattery->m_bIsCacheValid=FALSE;

            if (NT_SUCCESS (IoAcquireRemoveLock (&pDevExt->m_StopLock, (PVOID) HidBattTag))) {
                ntStatus = BatteryClassStatusNotify(
                        pDevExt->m_pBattery->m_pBatteryClass);
                IoReleaseRemoveLock (&pDevExt->m_StopLock, (PVOID) HidBattTag);
            }
            break;
        }
        default:  // nothing to notify
            break;
    }


    return;
}

NTSTATUS
HidBattQueryTag (
    IN PVOID                pContext,
    OUT PULONG              pulBatteryTag
    )
{

    HIDDebugBreak(HIDBATT_BREAK_ALWAYS);
    CBatteryDevExt * pDevExt = (CBatteryDevExt *) pContext;

    if (!NT_SUCCESS(IoAcquireRemoveLock (&pDevExt->m_StopLock, (PVOID) HidBattTag)) )
    {
        return STATUS_NO_SUCH_DEVICE;
    }

    *pulBatteryTag =     pDevExt->m_pBattery->m_Tag;

    IoReleaseRemoveLock (&pDevExt->m_StopLock, (PVOID) HidBattTag);
    return STATUS_SUCCESS;
}


NTSTATUS
HidBattSetStatusNotify (
    IN PVOID                pContext,
    IN ULONG                BatteryTag,
    IN PBATTERY_NOTIFY      pBatteryNotify
    )
{
    bool bResult;
    ULONG CentiAmpSec;
    ULONG ulValue;
    HIDDebugBreak(HIDBATT_BREAK_ALWAYS);
    HidBattPrint (HIDBATT_TRACE, ("HidBattSetStatusNotify \n"));
    CBatteryDevExt * pDevExt = (CBatteryDevExt *) pContext;
    CBattery * pBattery = pDevExt->m_pBattery;


    HidBattPrint (HIDBATT_DEBUG, ("HidBattSetStatusNotify->PowerState   = %x\n", pBatteryNotify->PowerState));    
    HidBattPrint (HIDBATT_DEBUG, ("HidBattSetStatusNotify->LowCapacity  = %x\n", pBatteryNotify->LowCapacity));    
    HidBattPrint (HIDBATT_DEBUG, ("HidBattSetStatusNotify->HighCapacity = %x\n", pBatteryNotify->HighCapacity));    

    if (!NT_SUCCESS(IoAcquireRemoveLock (&pDevExt->m_StopLock, (PVOID) HidBattTag)))
    {
        return STATUS_NO_SUCH_DEVICE;
    }

    if (pBattery->m_Tag != BatteryTag) {
        IoReleaseRemoveLock (&pDevExt->m_StopLock, (PVOID) HidBattTag);
        return STATUS_NO_SUCH_DEVICE;
    }

    if ((pBatteryNotify->HighCapacity == BATTERY_UNKNOWN_CAPACITY) ||
        (pBatteryNotify->LowCapacity == BATTERY_UNKNOWN_CAPACITY)) {
        HidBattPrint (HIDBATT_DEBUG, ("HidBattSetStatusNotify failing because of BATTERY_UNKNOWN_CAPACITY.\n"));
        IoReleaseRemoveLock (&pDevExt->m_StopLock, (PVOID) HidBattTag);
        return STATUS_NOT_SUPPORTED;
    }

    // first check for relative or absolute
    if(pBattery->m_bRelative)
    {
        ulValue = pBatteryNotify->LowCapacity; // done
    } else
    {
        // first check if setting to zero so that can skip below formula
        if(pBatteryNotify->LowCapacity == 0)
        {
            ulValue = 0;
        } else
        {
            // first must covert value to whatever is being used by this HID device.
            // currently we assume either MilliVolts consistant with battery class or
            // AmpSecs consistant with power spec
            ULONG ulUnit = pBattery->GetUnit(REMAINING_CAPACITY_INDEX);
            if(ulUnit)
            {
                short    sExponent;
                ULONG    lMilliVolts;
                long     milliWattHours,CentiWattHours,CentiWattSecs;

                sExponent = pBattery->GetExponent(REMAINING_CAPACITY_INDEX);

                // conversion from millWattHours to AmpSecs
                // formula = mWHs / 1000 / 3600 / volts ^ exponent correction
                lMilliVolts =  pBattery->m_BatteryStatus.Voltage; // stored as MilliVolts

                if (lMilliVolts == 0) {
                    HidBattPrint (HIDBATT_ERROR,
                                  ("HidBattSetStatusNotify: Error: voltage = 0, fudging with 24V.\n"));
                    lMilliVolts = 24000;
                }
                milliWattHours = pBatteryNotify->LowCapacity;
                CentiWattHours = milliWattHours /10;
                CentiWattSecs = CentiWattHours / 3600;
                CentiAmpSec = (CentiWattSecs *1000)/ lMilliVolts;
                ulValue = CorrectExponent(CentiAmpSec,-2,sExponent);
            } else
            {
                ulValue = pBatteryNotify->LowCapacity;
            }
        } // end if LowCapacity
    }  // end if relative
    // now set low
    bResult = pBattery->GetSetValue(REMAINING_CAPACITY_LIMIT_INDEX,&ulValue,TRUE);

    IoReleaseRemoveLock (&pDevExt->m_StopLock, (PVOID) HidBattTag);

    return bResult ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL;
}

NTSTATUS
HidBattDisableStatusNotify (
    IN PVOID pContext
    )
{
    HIDDebugBreak(HIDBATT_BREAK_ALWAYS);
    CBatteryDevExt * pDevExt = (CBatteryDevExt *) pContext;
    pDevExt->m_pBattery->m_pBatteryNotify = NULL;  // remove notify procedure
    return STATUS_SUCCESS;
}


/*++

Routine Description:

    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.

--*/

NTSTATUS
HidBattQueryStatus (
    IN PVOID                pContext,
    IN ULONG                BatteryTag,
    OUT PBATTERY_STATUS     pBatteryStatus
    )
{
    HIDDebugBreak(HIDBATT_BREAK_ALWAYS);
    CBatteryDevExt *   pDevExt = (CBatteryDevExt *) pContext;
    NTSTATUS    ntStatus;

    HidBattPrint (HIDBATT_TRACE, ("HidBattQueryStatus - Tag (%d)\n",
                    BatteryTag));

    if (!NT_SUCCESS(IoAcquireRemoveLock (&pDevExt->m_StopLock, (PVOID) HidBattTag)) )
    {
        return STATUS_NO_SUCH_DEVICE;
    }

    if ((BatteryTag == BATTERY_TAG_INVALID) || (pDevExt->m_pBattery->m_Tag == BATTERY_TAG_INVALID)) {
        ntStatus = STATUS_NO_SUCH_DEVICE;
    } else {

        RtlZeroMemory (pBatteryStatus, sizeof(BATTERY_STATUS));
        ntStatus = pDevExt->m_pBattery->RefreshStatus();
        if (NT_SUCCESS(ntStatus)) {
            RtlCopyMemory (pBatteryStatus, &pDevExt->m_pBattery->m_BatteryStatus, sizeof(BATTERY_STATUS));
            HidBattPrint (HIDBATT_DATA, ("HidBattQueryStatus - Data (%08x)(%08x)(%08x)(%08x)\n",
                                         pBatteryStatus->PowerState,
                                         pBatteryStatus->Capacity,
                                         pBatteryStatus->Rate,
                                         pBatteryStatus->Voltage ));

        } else {
            ntStatus = STATUS_NO_SUCH_DEVICE;
            HidBattPrint (HIDBATT_DATA, ("HidBattQueryStatus - Error\n" ));
        }
    }

    IoReleaseRemoveLock (&pDevExt->m_StopLock, (PVOID) HidBattTag);

    return ntStatus;

}


/*++

Routine Description:

    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          - Optional Parameter
    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
HidBattQueryInformation (
    IN PVOID                            Context,
    IN ULONG                            BatteryTag,
    IN BATTERY_QUERY_INFORMATION_LEVEL  Level,
    IN LONG                             AtRate OPTIONAL,
    OUT PVOID                           Buffer,
    IN  ULONG                           BufferLength,
    OUT PULONG                          ReturnedLength
    )
{

    CBatteryDevExt * pDevExt = (CBatteryDevExt *) Context;
    ULONG               ulResult;
    NTSTATUS            ntStatus;
    PVOID               pReturnBuffer;
    ULONG               ulReturnBufferLength;
    WCHAR               scratchBuffer[MAX_BATTERY_STRING_SIZE];
    WCHAR               buffer2[MAX_BATTERY_STRING_SIZE];
    UNICODE_STRING      tmpUnicodeString;
    UNICODE_STRING      unicodeString;
    ANSI_STRING         ansiString;
    bool                bResult;
    BATTERY_REMAINING_SCALE     ScalePtr[2];
    ULONG                ulReturn,ulNewValue;
    ULONG                ulEstTimeStub = 5;

    HIDDebugBreak(HIDBATT_BREAK_ALWAYS);

    HidBattPrint (HIDBATT_TRACE, ("HidBattQueryInformation - Tag (%d)\n",
                    BatteryTag));


    if (!NT_SUCCESS(IoAcquireRemoveLock (&pDevExt->m_StopLock, (PVOID) HidBattTag)) )
    {
        return STATUS_NO_SUCH_DEVICE;
    }

    //
    // If caller has the wrong ID give an error
    //

    if (BatteryTag == BATTERY_TAG_INVALID ||
        pDevExt->m_pBattery->m_Tag == BATTERY_TAG_INVALID ||
        BatteryTag != pDevExt->m_pBattery->m_Tag)
    {
        IoReleaseRemoveLock (&pDevExt->m_StopLock, (PVOID) HidBattTag);
        return STATUS_NO_SUCH_DEVICE;
    }

    ulResult = 0;
    pReturnBuffer = NULL;
    ulReturnBufferLength = 0;
    ntStatus = STATUS_SUCCESS;
    CUString cUniqueID;
    SHORT    sExponent;
    char * pTemp;
    //
    // Get the info requested
    //

    switch (Level) {
        case BatteryInformation:
            //
            //  This data structure is populated by CmBattVerifyStaticInfo
            //
            HidBattPrint (HIDBATT_TRACE, ("HidBattQueryInformation - Battery Info\n"));
            pReturnBuffer = (PVOID) &pDevExt->m_pBattery->m_BatteryInfo;
            ulReturnBufferLength = sizeof (pDevExt->m_pBattery->m_BatteryInfo);
            break;

        case BatteryGranularityInformation:
            //
            //  Get the granularity from the static info structure
            //  This data structure is populated by CmBattVerifyStaticInfo
            //
            {
                HidBattPrint (HIDBATT_TRACE, ("HidBattQueryInformation - Granularity\n"));
                bResult = pDevExt->m_pBattery->GetSetValue(GRANULARITY1_INDEX, &ulReturn,FALSE);
                if(!pDevExt->m_pBattery->m_bRelative)
                {
                    // convert from amps to watts
                    sExponent = pDevExt->m_pBattery->GetExponent(GRANULARITY1_INDEX);
                    ulNewValue = CorrectExponent(ulReturn,sExponent,-2);
                    ulReturn= CentiAmpSecsToMilliWattHours(ulNewValue,pDevExt->m_pBattery->m_BatteryStatus.Voltage);
                }

                ScalePtr[0].Granularity = bResult ? ulReturn : 0;
                bResult = pDevExt->m_pBattery->GetSetValue(GRANULARITY2_INDEX, &ulReturn,FALSE);
                if(!pDevExt->m_pBattery->m_bRelative)
                {
                    // convert from amps to watts
                    sExponent = pDevExt->m_pBattery->GetExponent(GRANULARITY2_INDEX);
                    ulNewValue = CorrectExponent(ulReturn,sExponent,-2);
                    ulReturn= CentiAmpSecsToMilliWattHours(ulNewValue,pDevExt->m_pBattery->m_BatteryStatus.Voltage);
                }
                ScalePtr[1].Granularity = bResult ? ulReturn : 0;
                bResult = pDevExt->m_pBattery->GetSetValue(WARNING_CAPACITY_LIMIT_INDEX, &ulReturn,FALSE);
                if(!pDevExt->m_pBattery->m_bRelative)
                {
                    // convert from amps to watts
                    sExponent = pDevExt->m_pBattery->GetExponent(WARNING_CAPACITY_LIMIT_INDEX);
                    ulNewValue = CorrectExponent(ulReturn,sExponent,-2);
                    ulReturn= CentiAmpSecsToMilliWattHours(ulNewValue,pDevExt->m_pBattery->m_BatteryStatus.Voltage);
                }
                ScalePtr[0].Capacity = bResult ? ulReturn : 0;
                bResult = pDevExt->m_pBattery->GetSetValue(DESIGN_CAPACITY_INDEX, &ulReturn,FALSE);
                if(!pDevExt->m_pBattery->m_bRelative)
                {
                    // convert from amps to watts
                    sExponent = pDevExt->m_pBattery->GetExponent(DESIGN_CAPACITY_INDEX);
                    ulNewValue = CorrectExponent(ulReturn,sExponent,-2);
                    ulReturn= CentiAmpSecsToMilliWattHours(ulNewValue,pDevExt->m_pBattery->m_BatteryStatus.Voltage);
                }
                ScalePtr[1].Capacity = bResult ? ulReturn : 0;

                pReturnBuffer        = ScalePtr;
                ulReturnBufferLength  = 2 * sizeof (BATTERY_REMAINING_SCALE);
            }
            break;

        case BatteryTemperature:
            HidBattPrint (HIDBATT_TRACE, ("HidBattQueryInformation - Temperature\n"));
            ntStatus = STATUS_INVALID_DEVICE_REQUEST;
            break;

        case BatteryEstimatedTime:
            HidBattPrint (HIDBATT_TRACE, ("HidBattQueryInformation - Estimated time\n"));
            bResult = pDevExt->m_pBattery->GetSetValue(RUNTIME_TO_EMPTY_INDEX, &ulReturn,FALSE);

            if(!bResult)
            {
                ntStatus = STATUS_INVALID_DEVICE_REQUEST;
            } else
            {
                SHORT exponent;

                exponent = pDevExt->m_pBattery->GetExponent(RUNTIME_TO_EMPTY_INDEX);
                ulReturn = CorrectExponent (ulReturn, exponent, 0);

                pReturnBuffer = &ulReturn;
                ulReturnBufferLength = sizeof (ULONG);
            }
            break;

        case BatteryDeviceName:
            //
            // Model Number must be returned as a wide string
            //
            HidBattPrint (HIDBATT_TRACE, ("HidBattQueryInformation - Device Name\n"));
            if(pDevExt->m_pBattery->m_pProduct)
            {
                pReturnBuffer = pDevExt->m_pBattery->m_pProduct->m_String.Buffer;
                ulReturnBufferLength = pDevExt->m_pBattery->m_pProduct->m_String.Length;
            }
            break;

        case BatteryManufactureDate:
            HidBattPrint (HIDBATT_TRACE, ("HidBattQueryInformation - Mfr Date\n"));
            if(!pDevExt->m_pBattery->m_ManufactureDate.Day)
            {
                ntStatus = STATUS_INVALID_DEVICE_REQUEST;
                break;
            }
            pReturnBuffer = &pDevExt->m_pBattery->m_ManufactureDate;
            ulReturnBufferLength = sizeof(pDevExt->m_pBattery->m_ManufactureDate);
            break;

        case BatteryManufactureName:
            //
            // Oem Info must be returned as wide string
            //
            HidBattPrint (HIDBATT_TRACE, ("HidBattQueryInformation - Mfr Name\n"));
            if(pDevExt->m_pBattery->m_pManufacturer)
            {
                pReturnBuffer = pDevExt->m_pBattery->m_pManufacturer->m_String.Buffer;
                ulReturnBufferLength = pDevExt->m_pBattery->m_pManufacturer->m_String.Length;
            }

            break;

        case BatteryUniqueID:
            //
            //  Concatenate the serial #, manufacturer name, and Product           //



             // start off with serial number
            HidBattPrint (HIDBATT_TRACE, ("HidBattQueryInformation - Unique ID\n"));
            if(pDevExt->m_pBattery->m_pSerialNumber) {
                HidBattPrint (HIDBATT_TRACE, ("HidBattQueryInformation - Serial = %s\n", pDevExt->m_pBattery->m_pSerialNumber));

                cUniqueID.Append(pDevExt->m_pBattery->m_pSerialNumber);
            } else {
                HidBattPrint (HIDBATT_TRACE, ("HidBattQueryInformation - Serial = NULL\n"));
                CUString * pSTemp = new (NonPagedPool, HidBattTag) CUString(L"1000");
                if (pSTemp) {
                  cUniqueID.Append(pSTemp);
                  delete pSTemp;
                }
            }
            if(pDevExt->m_pBattery->m_pManufacturer)
                cUniqueID.Append(pDevExt->m_pBattery->m_pManufacturer); // add mfr name
            else
            {
                CUString * pSTemp = new (NonPagedPool, HidBattTag) CUString(L"Mfr");
                if (pSTemp) {
                  cUniqueID.Append(pSTemp);
                  delete pSTemp;
                }
            }
            if(pDevExt->m_pBattery->m_pProduct)
                cUniqueID.Append(pDevExt->m_pBattery->m_pProduct); // add Product
            else
            {
                CUString * pSTemp = new (NonPagedPool, HidBattTag) CUString(L"Prod");
                if (pSTemp) {
                  cUniqueID.Append(pSTemp);
                  delete pSTemp;
                }
            }
            pReturnBuffer = cUniqueID.m_String.Buffer;
            ulReturnBufferLength = cUniqueID.m_String.Length;
            break;
        default:
            HidBattPrint (HIDBATT_TRACE, ("HidBattQueryInformation - Default\n"));
            ntStatus = STATUS_INVALID_PARAMETER;
            break;
    }

    //
    // Done, return buffer if needed
    //

    *ReturnedLength = ulReturnBufferLength;
    if (BufferLength < ulReturnBufferLength) {
        ntStatus = STATUS_BUFFER_TOO_SMALL;
    }

    if (NT_SUCCESS(ntStatus) && pReturnBuffer) {
        RtlCopyMemory (Buffer, pReturnBuffer, ulReturnBufferLength);   // Copy what's needed
    }


    HidBattPrint (HIDBATT_TRACE, ("HidBattQueryInformation - Status = %08x  Buffer = %08x\n", ntStatus, *(PULONG)Buffer));

    IoReleaseRemoveLock (&pDevExt->m_StopLock, (PVOID) HidBattTag);

    return ntStatus;
}



NTSTATUS
HidBattIoCompletion(
    IN PDEVICE_OBJECT       pDeviceObject,
    IN PIRP                 pIrp,
    IN PVOID                pdoIoCompletedEvent
    )
{
    HidBattPrint (HIDBATT_TRACE, ("HidBattIoCompletion\n"));
    KeSetEvent((KEVENT *) pdoIoCompletedEvent,0, FALSE);
    return STATUS_MORE_PROCESSING_REQUIRED;

}