backlight_wince.c

WINCE下,背光驱动源码.

//
BOOL BKL_Close(DWORD context)
{
    BOOL rc = FALSE;
    BKL_DEVICE *pDevice;
    BKL_INSTANCE *pInstance = (BKL_INSTANCE*)context;

    DEBUGMSG(ZONE_FUNCTION, (L"+BKL_Close(0x%08x)\r\n", context));

    // Check if we get correct context
    if (pInstance == NULL || pInstance->cookie != BKL_INSTANCE_COOKIE) {
        DEBUGMSG (ZONE_ERROR, (L"ERROR: BKL_Read: "
            L"Incorrect context paramer\r\n"
        ));
        goto cleanUp;
    }

    // Get device context
    pDevice = pInstance->pDevice;

    // sanity check number of instances
    ASSERT(pDevice->instances > 0);

    // Decrement number of open instances
    InterlockedDecrement(&pDevice->instances);

    // Free instance structure
    LocalFree(pInstance);

    // Done...
    rc = TRUE;
    
cleanUp:
    DEBUGMSG(ZONE_FUNCTION, (L"-BKL_Close(rc = %d)\r\n", rc));
    return rc;
}

//------------------------------------------------------------------------------
//
//  Function:  BKL_IOControl
//
//  This function sends a command to a device.
//
BOOL BKL_IOControl(
    DWORD context, DWORD code, BYTE *pInBuffer, DWORD inSize, BYTE *pOutBuffer,
    DWORD outSize, DWORD *pOutSize
) {
    BOOL rc = FALSE;
    BKL_INSTANCE *pInstance = (BKL_INSTANCE*)context;
    BKL_DEVICE *pDevice;
    POWER_CAPABILITIES powerCap;
    CEDEVICE_POWER_STATE powerState;

    // Check if we get correct context
    if (pInstance == NULL || pInstance->cookie != BKL_INSTANCE_COOKIE) {
        DEBUGMSG(ZONE_ERROR, (L"ERROR: BKL_IOControl: "
            L"Incorrect context paramer\r\n"
        ));
        goto cleanUp;
    }

    // Device structure
    pDevice = pInstance->pDevice;

    switch (code) {
    // Return device specific power capabilities.
    case IOCTL_POWER_CAPABILITIES :  
        // Check input parameters
        if (pOutSize != NULL) *pOutSize = sizeof(POWER_CAPABILITIES);
        if (pOutBuffer == NULL || outSize < sizeof(POWER_CAPABILITIES)) {
            SetLastError(ERROR_INVALID_PARAMETER);
            break;
        }
        memset(&powerCap, 0, sizeof(powerCap));
        powerCap.DeviceDx = DX_MASK(D0) | DX_MASK(D3) |DX_MASK(D4);
        if (!CeSafeCopyMemory(pOutBuffer, &powerCap, sizeof(powerCap))) {
            SetLastError(ERROR_INVALID_PARAMETER);
            break;
        }
        rc = TRUE;
        break;

    // Request a change from one device power state to another.
    case IOCTL_POWER_SET:
        // Check input parameters
        if (pOutSize != NULL) *pOutSize = sizeof(CEDEVICE_POWER_STATE);
        if (
            pOutBuffer == NULL || outSize < sizeof(CEDEVICE_POWER_STATE) ||
            !CeSafeCopyMemory(&powerState, pOutBuffer, sizeof(powerState))
        ) {
            SetLastError(ERROR_INVALID_PARAMETER);
            break;
        }

        // Check for any valid power state.
        if (!VALID_DX(powerState)) {
            DEBUGMSG(ZONE_ERROR, (L"ERROR: BKL_IOControl: "
                L"Invalid power state 0x%08x\r\n", powerState
            ));
            break;
        }
        pDevice->ps = powerState;
        RefreshBKL(pDevice);
        if (!CeSafeCopyMemory(pOutBuffer, &pDevice->ps, sizeof(pDevice->ps))) {
            SetLastError(ERROR_INVALID_PARAMETER);
            break;
        }
        rc = TRUE;
        break;

    // Return the current device power state.
    case IOCTL_POWER_GET:
        // Check input parameters
        if (pOutSize != NULL) *pOutSize = sizeof(CEDEVICE_POWER_STATE);
        if (
            pOutBuffer == NULL || outSize < sizeof(CEDEVICE_POWER_STATE) ||
            !CeSafeCopyMemory(pOutBuffer, &pDevice->ps, sizeof(pDevice->ps))
        ) {
            SetLastError(ERROR_INVALID_PARAMETER);
            break;
        }
        rc = TRUE;
        break;
    case IOCTL_FORCEBKL_OFF:
    	pDevice->fForceOFF = *(BOOL *)pInBuffer;
    	RefreshBKL(pDevice);
        break;
    }

cleanUp:
    DEBUGMSG(ZONE_FUNCTION, (L"-BKL_IOControl(rc = %d)\r\n", rc));
    return rc;
}

//------------------------------------------------------------------------------
//
//  Function:  DllMain
//
//  Standard Windows DLL entry point.
//
BOOL __stdcall DllMain(HANDLE hDLL, DWORD reason, VOID *pReserved)
{
    switch (reason) {
    case DLL_PROCESS_ATTACH:
        DEBUGREGISTER(hDLL);
        DisableThreadLibraryCalls((HMODULE)hDLL);
        break;
    }
    return TRUE;
}

#ifndef BUILD_ULDR
void RefreshBKL(BKL_DEVICE *pDevice)
{
    CEDEVICE_POWER_STATE ps = pDevice->ps;
    BOOL TurnOn = FALSE;
    RETAILMSG(RETAILMSGZONE, (TEXT("[BKL] Function Called: RefreshBKL\r\n"))); 
    if(pDevice->fForceOFF)
    {
        ps = D4;
    }


    switch(ps)
    {
    case D0:
        RETAILMSG(RETAILMSGZONE, (TEXT("[BKL] RefreshBKL: D0\r\n"))); 
        if(pDevice->Lastps != D0)
        {
            TurnOn = TRUE;
        }
        if(pDevice->JustChanged) 
        {
            RETAILMSG(RETAILMSGZONE, (TEXT("[BKL] RefreshBKL: D0 TURN ON\r\n"))); 
            OUTREG8(&g_pPWLMAPAddress->PWL_CTRL_REG, 0x01);
            OUTREG8(&g_pPWLMAPAddress->PWL_LEVEL_REG, pDevice->dwBrightness);
            pDevice->Lastps = D0;
        }
        if(!TurnOn)
        {
            break;
        }
		if(pDevice->ACLineStatus == AC_LINE_ONLINE && pDevice->Lastps!=D4)
		{
			  if(pDevice->fACOnTap || pDevice->ACTimeout==0 )
           {
            RETAILMSG(RETAILMSGZONE, (TEXT("[BKL] RefreshBKL: D0 TURN ON\r\n"))); 
            OUTREG8(&g_pPWLMAPAddress->PWL_CTRL_REG, 0x01);
            OUTREG8(&g_pPWLMAPAddress->PWL_LEVEL_REG, pDevice->dwBrightness);
            pDevice->Lastps = D0;
           }
			  else
           {
            RETAILMSG(RETAILMSGZONE, (TEXT("[BKL] RefreshBKL: D0 KEEP DIM\r\n"))); 
            OUTREG8(&g_pPWLMAPAddress->PWL_CTRL_REG, 0x01);
            OUTREG8(&g_pPWLMAPAddress->PWL_LEVEL_REG, BACKLIGHTDIMLEVEL);
            pDevice->Lastps = D3;
           }
		}
		else if(pDevice->ACLineStatus != AC_LINE_ONLINE && pDevice->Lastps!=D4)
		{
			if(pDevice->fBattOnTap || pDevice->BatteryTimeout==0)
           {
            RETAILMSG(RETAILMSGZONE, (TEXT("[BKL] RefreshBKL: D0 TURN ON\r\n"))); 
            OUTREG8(&g_pPWLMAPAddress->PWL_CTRL_REG, 0x01);
            OUTREG8(&g_pPWLMAPAddress->PWL_LEVEL_REG, pDevice->dwBrightness);
            pDevice->Lastps = D0;
           }
			  else
           {
            RETAILMSG(RETAILMSGZONE, (TEXT("[BKL] RefreshBKL: D0 KEEP DIM\r\n"))); 
            OUTREG8(&g_pPWLMAPAddress->PWL_CTRL_REG, 0x01);
            OUTREG8(&g_pPWLMAPAddress->PWL_LEVEL_REG, BACKLIGHTDIMLEVEL);
            pDevice->Lastps = D3;
           }
		}
		else
		{
			RETAILMSG(RETAILMSGZONE, (TEXT("[BKL] RefreshBKL: D0 TURN ON\r\n"))); 
            OUTREG8(&g_pPWLMAPAddress->PWL_CTRL_REG, 0x01);
            OUTREG8(&g_pPWLMAPAddress->PWL_LEVEL_REG, pDevice->dwBrightness);
            pDevice->Lastps = D0;
		}
        break;
    case D1:
    case D2:
    case D3:
        OUTREG8(&g_pPWLMAPAddress->PWL_LEVEL_REG, BACKLIGHTDIMLEVEL);
        pDevice->Lastps = D3;
        break;
    case D4:
        RETAILMSG(RETAILMSGZONE, (TEXT("[BKL] RefreshBKL: D4\r\n"))); 
        OUTREG8(&g_pPWLMAPAddress->PWL_LEVEL_REG, 0x00);
        pDevice->Lastps = D4;
        break;
    default:
        break;
    }
    pDevice->JustChanged = FALSE;
}
#endif
#ifdef BUILD_ULDR
void RefreshBKL(BKL_DEVICE *pDevice)
{
    CEDEVICE_POWER_STATE ps = pDevice->ps;
    switch(ps)
    {
    case D0:
        RETAILMSG(RETAILMSGZONE, (TEXT("[BKL] RefreshBKL: D0 KEEP DIM\r\n"))); 
        OUTREG8(&g_pPWLMAPAddress->PWL_CTRL_REG, 0x01);
        OUTREG8(&g_pPWLMAPAddress->PWL_LEVEL_REG, pDevice->dwBrightness);
        break;
    case D1:
    case D2:
    case D3:
        OUTREG8(&g_pPWLMAPAddress->PWL_LEVEL_REG, BACKLIGHTDIMLEVEL);
        break;
    case D4:
        RETAILMSG(RETAILMSGZONE, (TEXT("[BKL] RefreshBKL: D4\r\n"))); 
        OUTREG8(&g_pPWLMAPAddress->PWL_LEVEL_REG, 0x00);
        break;
    default:
        break;
    }
}
#endif

#ifndef BUILD_ULDR
void BrightCallback(HREGNOTIFY hNotify, DWORD dwUserData, const PBYTE pData, const UINT cbData)
{
    BKL_DEVICE *pDevice = (BKL_DEVICE *)dwUserData;
    if(pData == 0)
    {
        return;
    }
    if(hNotify == pDevice->hACLineStatus)
    {
        pDevice->JustChanged = TRUE;
        pDevice->ACLineStatus = (*(DWORD*)pData);
    }
    else if(hNotify == pDevice->hBrightNotify)
    {
        pDevice->JustChanged = TRUE;
        pDevice->dwBrightness = (*(DWORD*)pData);
        RETAILMSG(RETAILMSGZONE, (TEXT("[BKL] Brightness level changed to 0x%x \r\n"),pDevice->dwBrightness)); 
    }
    else if(hNotify == pDevice->hBattOnTapNotify)
    {
        RETAILMSG(RETAILMSGZONE, (TEXT("[BKL] BattOnTap changed to 0x%x \r\n"),*(DWORD *)pData));
        pDevice->fBattOnTap = *(BOOL *)pData;
    }
    else if(hNotify == pDevice->hACOnTapNotify)
    {
        RETAILMSG(RETAILMSGZONE, (TEXT("[BKL] ACOnTap changed to 0x%x \r\n"),*(DWORD *)pData));
        pDevice->fACOnTap = *(BOOL *)pData;
    }
	else if(hNotify == pDevice->hBatteryTimeoutNotify)
    {
        RETAILMSG(RETAILMSGZONE, (TEXT("[BKL] BatteryTimeoutNotify changed to 0x%x \r\n"),*(DWORD *)pData));
		pDevice->BatteryTimeout= (*(DWORD*)pData);
    }
    else if(hNotify == pDevice->hACTimeoutNotify)
    {
        RETAILMSG(RETAILMSGZONE, (TEXT("[BKL] ACTimeoutNotify changed to 0x%x \r\n"),*(DWORD *)pData));
		pDevice->ACTimeout= (*(DWORD*)pData);
    }
    RefreshBKL(pDevice);
}

void CheckBacklightTimeout()
{
    DWORD val = 0;
    
    if(S_OK == RegistryGetDWORD(HKEY_CURRENT_USER, BACKLIGHT_SET_PATH,
                                BACKLIGHT_SET_BACKKEY, &val))
    {
        RegistrySetDWORD(HKEY_CURRENT_USER, BACKLIGHT_SET_PATH,
                         BACKLIGHT_SET_KEY, val);
    }
}
#endif