battdrvr.c

pxa270平台 windows mobile 5.2 wm9713 触摸屏+音频驱动

                /** pass back return values */
                __try {
                    *pdwBytesTransferred = dwStatus;
                    if(dwStatus == 0) {
                        dwErr = GetLastError();
                    } else {
                        dwErr = ERROR_SUCCESS;
                    }
                }
                __except(EXCEPTION_EXECUTE_HANDLER) {
                    DEBUGMSG(ZONE_WARN, (_T
("%s: exception writing status in IOCTL_BATTERY_GETSYSTEMPOWERSTATUSEX2\r\n"),
                        pszFname));
                }
            }
        }
        break;

    case IOCTL_BATTERY_GETSYSTEMPOWERSTATUSEX:
        /** sanity check parameters */
        if(pOutBuf != NULL && OutBufLen == sizeof(SYSTEM_POWER_STATUS_EX)
            && pInBuf != NULL && InBufLen == sizeof(BOOL)
            && pdwBytesTransferred != NULL) {
            BOOL fOk = FALSE;
            BOOL fForce;

            /** get the force parameter */
            __try {
                fForce = *((BOOL *) pInBuf);
                fOk = TRUE;
            } 
            __except(EXCEPTION_EXECUTE_HANDLER) {
                DEBUGMSG(ZONE_WARN, (_T
("%s: exception reading fForce in IOCTL_BATTERY_GETSYSTEMPOWERSTATUSEX\r\n"),
                    pszFname));
            }

            /** did we get the force parameter? */
            if(fOk) {
                DEBUGCHK(fForce == TRUE || fForce == FALSE);

                /** get the data */
                LOCKBATTERY();
                __try {
                    fOk = BatteryAPIGetSystemPowerStatusEx(
                        (PSYSTEM_POWER_STATUS_EX) pOutBuf, fForce);
                }
                __except(EXCEPTION_EXECUTE_HANDLER) {
                    DEBUGMSG(ZONE_WARN, (_T
("%s: exception reading status in  IOCTL_BATTERY_GETSYSTEMPOWERSTATUSEX\r\n"),
                        pszFname));
                    dwErr = ERROR_GEN_FAILURE;
                }
                UNLOCKBATTERY();

                /** pass back return values */
                __try {
                    if(fOk) {
                        *pdwBytesTransferred = sizeof(SYSTEM_POWER_STATUS_EX);
                        dwErr = ERROR_SUCCESS;
                    } else {
                        *pdwBytesTransferred = 0;
                        dwErr = GetLastError();
                    }
                }
                __except(EXCEPTION_EXECUTE_HANDLER) {
                    DEBUGMSG(ZONE_WARN, (_T
("%s: exception writing status in IOCTL_BATTERY_GETSYSTEMPOWERSTATUSEX\r\n"),
                        pszFname));
                }
            }
        }
        break;

    case IOCTL_BATTERY_GETLIFETIMEINFO:
        /** sanity check parameters */
        if(pOutBuf != NULL && OutBufLen == sizeof(BATTERYLIFETIMEINFO)) {
            SYSTEMTIME stLastChange = { 0 };
            DWORD cmsCpuUsage = 0, cmsPreviousCpuUsage = 0;

            DEBUGCHK(pInBuf == NULL);
            DEBUGCHK(InBufLen == 0);
            DEBUGCHK(pdwBytesTransferred != NULL);

            /** assume a good return value from this function, even though it's
                void */
            SetLastError(ERROR_SUCCESS);

            /** get the data */
            LOCKBATTERY();
            BatteryAPIGetLifeTimeInfo(&stLastChange, &cmsCpuUsage,
                &cmsPreviousCpuUsage);
            UNLOCKBATTERY();

            /** pass back return values */
            __try {
                PBATTERYLIFETIMEINFO pblti = (PBATTERYLIFETIMEINFO) pOutBuf;
                pblti->stLastChange = stLastChange;
                pblti->cmsCpuUsage = cmsCpuUsage;
                pblti->cmsPreviousCpuUsage = cmsPreviousCpuUsage;
                dwErr = GetLastError();
            }
            __except(EXCEPTION_EXECUTE_HANDLER) {
                DEBUGMSG(ZONE_WARN, 
                    (_T("%s: exception in IOCTL_BATTERY_GETLIFETIMEINFO\r\n"),
                    pszFname));
                dwErr = ERROR_INVALID_PARAMETER;
            }
        }
        break;

    case IOCTL_BATTERY_GETLEVELS:
        /** sanity check parameters */
        if(pOutBuf != NULL && OutBufLen == sizeof(LONG) &&
            pdwBytesTransferred != NULL) {
            DWORD dwLevels;

            DEBUGCHK(pInBuf == NULL);
            DEBUGCHK(InBufLen == 0);

            /** get the data */
            LOCKBATTERY();
            dwLevels = BatteryPDDGetLevels();
            UNLOCKBATTERY();

            /** pass back return values */
            __try {
                *((PLONG) pOutBuf) = (LONG) dwLevels;
                *pdwBytesTransferred = sizeof(LONG);
                dwErr = ERROR_SUCCESS;
            }
            __except(EXCEPTION_EXECUTE_HANDLER) {
                DEBUGMSG(ZONE_WARN, 
                    (_T("%s: exception in IOCTL_BATTERY_GETLEVELS\r\n"),
                    pszFname));
                dwErr = ERROR_INVALID_PARAMETER;
            }
        }
        break;

    case IOCTL_BATTERY_SUPPORTSCHANGENOTIFICATION:
        /** sanity check parameters */
        if(pOutBuf != NULL && OutBufLen == sizeof(BOOL)
            && pdwBytesTransferred != NULL) {
            BOOL fSupportsChange;

            DEBUGCHK(pInBuf == NULL);
            DEBUGCHK(InBufLen == 0);

            /** get the data */
            LOCKBATTERY();
            fSupportsChange = BatteryPDDSupportsChangeNotification();
            UNLOCKBATTERY();

            /** pass back return values */
            __try {
                *((PBOOL) pOutBuf) = fSupportsChange;
                *pdwBytesTransferred = sizeof(fSupportsChange);
                dwErr = ERROR_SUCCESS;
            }
            __except(EXCEPTION_EXECUTE_HANDLER) {
                DEBUGMSG(ZONE_WARN, (_T
("%s: exception in IOCTL_BATTERY_SUPPORTSCHANGENOTIFICATION\r\n"),
                    pszFname));
                dwErr = ERROR_INVALID_PARAMETER;
            }
        }
        break;

    case IOCTL_BATTERY_NOTIFYOFTIMECHANGE:
        /** sanity check parameters */
        if(pInBuf != NULL && InBufLen == sizeof(FILETIME) && pOutBuf != NULL 
            && OutBufLen == sizeof(BOOL)) {
            FILETIME ft;
            BOOL fForward;

            /** pass back return values */
            __try {
                ft = *((PFILETIME) pInBuf);
                fForward = *((PBOOL) pOutBuf);
                dwErr = ERROR_SUCCESS;
            }
            __except(EXCEPTION_EXECUTE_HANDLER) {
                DEBUGMSG(ZONE_WARN, (_T
                    ("%s: exception in IOCTL_BATTERY_NOTIFYOFTIMECHANGE\r\n"),
                    pszFname));
            }

            /** did we get the parameter ok? */
            if(dwErr == ERROR_SUCCESS) {
                /** assume a good status, even though the function is void */
                SetLastError(ERROR_SUCCESS);

                /** get the data */
                LOCKBATTERY();
                BatteryAPINotifyOfTimeChange(fForward, &ft);
                UNLOCKBATTERY();

                /** get the status code */
                dwErr = GetLastError();
            }
        }
        break;

    default:
        /** Pass through to the PDD if enabled.  Note that the PDD function
            returns an error code, not a boolean. */
        if(gpfnBatteryPddIOControl != NULL) {
            dwErr = gpfnBatteryPddIOControl(dwContext, Ioctl, pInBuf,
                InBufLen, pOutBuf, OutBufLen, pdwBytesTransferred);
            DEBUGMSG(ZONE_IOCTL || ZONE_WARN,
                (_T("%s: PDD IOControl(%u) returned %d\r\n"),
                pszFname, Ioctl, dwErr));
        } else {
            DEBUGMSG(ZONE_IOCTL || ZONE_WARN,
                (_T("%s: Unsupported IOCTL code %u\r\n"), pszFname, Ioctl));
            dwErr = ERROR_NOT_SUPPORTED;
        }
        break;
    }

    /** pass back appropriate response codes */
    SetLastError(dwErr);
    if(dwErr != ERROR_SUCCESS) {
        bRc = FALSE;
    } else {
        bRc = TRUE;
    }

    DEBUGMSG(ZONE_FUNCTION || (!bRc && ZONE_WARN),
        (_T("%s: returning %d, error %d\r\n"), pszFname, bRc, dwErr));
    return bRc;
}

/******************************************************************************
 * Function: PowerDown                                                    *//**
 *
 *****************************************************************************/
VOID PowerDown( DWORD dwContext )
{
    /** notify the PDD */
    BatteryPDDPowerHandler(TRUE);
}

/******************************************************************************
 * Function: PowerUp                                                      *//**
 *
 *****************************************************************************/
VOID PowerUp( DWORD dwContext )
{
    /** notify the PDD */
    BatteryPDDPowerHandler(FALSE);

    /** schedule our resume thread */
    if(ghevResume != NULL) {
        CeSetPowerOnEvent(ghevResume);
    }
}

/******************************************************************************
 * Function: Open                                                         *//**
 *
 *****************************************************************************/
DWORD Open( DWORD Context, DWORD Access, DWORD ShareMode)
{

    DEBUGMSG(ZONE_FUNCTION,
        (_T("Open(%x, 0x%x, 0x%x)\r\n"),Context, Access, ShareMode));

    UNREFERENCED_PARAMETER(Access);
    UNREFERENCED_PARAMETER(ShareMode);

    /** pass back the device handle */
    return Context;     /** 0 indicates failure */
}

/******************************************************************************
 * Function: Close                                                        *//**
 *
 *****************************************************************************/
BOOL Close( DWORD Context )
{
    DEBUGMSG(ZONE_FUNCTION,(_T("Close(%x)\r\n"), Context));

    return TRUE;
}

/******************************************************************************
 * Function: Read                                                         *//**
 *
 *****************************************************************************/
DWORD Read( DWORD dwContext, LPVOID pBuf, DWORD Len )
{
    UNREFERENCED_PARAMETER(dwContext);
    UNREFERENCED_PARAMETER(pBuf);
    UNREFERENCED_PARAMETER(Len);

    DEBUGMSG(ZONE_ERROR | ZONE_FUNCTION,(_T("Read\r\n")));
    SetLastError(ERROR_INVALID_FUNCTION);
    return  0;
}

/******************************************************************************
 * Function: Write                                                        *//**
 *
 *****************************************************************************/
DWORD Write( DWORD dwContext, LPVOID pBuf, DWORD Len )
{
    UNREFERENCED_PARAMETER(dwContext);
    UNREFERENCED_PARAMETER(pBuf);
    UNREFERENCED_PARAMETER(Len);

    DEBUGMSG(ZONE_ERROR | ZONE_FUNCTION,(_T("Read\r\n")));
    SetLastError(ERROR_INVALID_FUNCTION);
    return  0;
}

/******************************************************************************
 * Function: Seek                                                         *//**
 *
 *****************************************************************************/
ULONG Seek( PVOID Context, LONG Position, DWORD Type )
{
    UNREFERENCED_PARAMETER(Context);
    UNREFERENCED_PARAMETER(Position);
    UNREFERENCED_PARAMETER(Type);

    return (DWORD)-1;
}

/******************************************************************************
 * Function: DllMain                                                      *//**
 *
 *****************************************************************************/
BOOL WINAPI DllMain( HINSTANCE hDllHandle, DWORD  dwReason, LPVOID lpreserved )
{
    BOOL bRc = TRUE;

    UNREFERENCED_PARAMETER(hDllHandle);
    UNREFERENCED_PARAMETER(lpreserved);

    switch (dwReason) {
    case DLL_PROCESS_ATTACH: 
        {
            DEBUGREGISTER(hDllHandle);
            DEBUGMSG(ZONE_INIT,(_T
("*** DLL_PROCESS_ATTACH  - Current Process: 0x%x, ID: 0x%x ***\r\n"),
                GetCurrentProcess(), GetCurrentProcessId()));
            DisableThreadLibraryCalls((HMODULE) hDllHandle);
        }
        break;

    case DLL_PROCESS_DETACH: 
        {
            DEBUGMSG(ZONE_INIT,(_T
("*** DLL_PROCESS_DETACH  - Current Process: 0x%x, ID: 0x%x ***\r\n"),
                GetCurrentProcess(), GetCurrentProcessId()));
        } 
        break;

    default:
        break;
    }

    return bRc;
}