backlight.cpp

freescale i.mx31 BSP CE5.0全部源码

//
//  Copyright (C) 2003, Motorola Inc. All Rights Reserved
//
//------------------------------------------------------------------------------
//
//  Copyright (C) 2005, Freescale Semiconductor, Inc. All Rights Reserved
//  THIS SOURCE CODE IS CONFIDENTIAL AND PROPRIETARY AND MAY NOT
//  BE USED OR DISTRIBUTED WITHOUT THE WRITTEN PERMISSION OF
//  Freescale Semiconductor, Inc.
//
//------------------------------------------------------------------------------
//
//  File:  backlight.cpp
//
//  Implementation of Backlight Driver
//
//------------------------------------------------------------------------------

#include <windows.h>
#include <DevLoad.h>
#include <msgqueue.h>
#include <pm.h>
#include <pmimpl.h>

#include "backlight.h"


//------------------------------------------------------------------------------
// External Functions
extern void BSPBacklightInitialize();
extern void BSPBacklightRelease();
extern void BSPBacklightSetIntensity(DWORD level);

//------------------------------------------------------------------------------
// External Variables

//------------------------------------------------------------------------------
// Defines
#define dim(x)              (sizeof(x) / sizeof(x[0]))

// Queue size for Power Manager Notification MsgQ
#define QUEUE_ENTRIES   1
#define QUEUE_SIZE      (QUEUE_ENTRIES * (sizeof(POWER_BROADCAST) + MAX_PATH))

//------------------------------------------------------------------------------
// Types

//------------------------------------------------------------------------------
// Global Variables

// Backlight device name
static TCHAR szName[DEVNAME_LEN];

// Current Backlight device power state.
static CRITICAL_SECTION cs;
static CEDEVICE_POWER_STATE CurDx;

// Power Manager notification variables
static HANDLE hMsgQ;
static HANDLE hNotifications;

static bklSettings_t bklSettings;

// Event handling thread
static HANDLE ghInterruptServiceThread;

// thread wait on these handles
static HANDLE hWaitList[bklMaxWaitEvents];
static HANDLE hevDummy;

// device on AC/DC status flag
static BOOL fACOnline;

// Interrupt thread loop flag
static BOOL fEventThreadLoop;

//------------------------------------------------------------------------------
// Local Functions
static void PrintBacklightSettings(bklSettings_t *pSettings);
static void GetBacklightTimeoutSettings(bklSettings_t *pSettings);
static void GetBacklightLevelSettings(bklSettings_t *pSettings);
static DWORD CalculateTimeout(bklSettings_t *pSettings);
BOOL BKL_Deinit(DWORD dwContext);
DWORD WINAPI BKL_EventThread(LPVOID lpParameter);


//------------------------------------------------------------------------------
//
//  FUNCTION:       BKL_Init
//
//  DESCRIPTION:
//  PARAMETERS:
//
//  RETURNS:
//
//------------------------------------------------------------------------------
UINT32 BKL_Init(UINT32 dwContext)
{
    TCHAR szEventName[MAX_PATH];
    SYSTEM_POWER_STATUS_EX status;
    MSGQUEUEOPTIONS msgOptions;
    HKEY  hDriverKey;
    DWORD dwStatus;
    DWORD dwType;
    DWORD dwSize;

    DEBUGMSG(BKL_DEBUG_MSG, (TEXT("BKL_INIT() +!\r\n")) );

    InitializeCriticalSection(&cs);

    // get our activation information
    dwStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE, (LPCTSTR)dwContext, 0, 0, &hDriverKey);
    if (dwStatus != ERROR_SUCCESS)
    {
        DEBUGMSG(BKL_ERROR_MSG, (TEXT("BKL_Init: OpenDeviceKey('%s') failed %u\r\n"), dwContext, dwStatus));
        goto InitErrCleanup;
    }

    dwSize = sizeof(szName);
    dwStatus = RegQueryValueEx(hDriverKey, DEVLOAD_DEVNAME_VALNAME, NULL, &dwType, (LPBYTE)szName, &dwSize);
    if (dwStatus != ERROR_SUCCESS || dwType != DEVLOAD_DEVNAME_VALTYPE)
    {
        DEBUGMSG(BKL_ERROR_MSG, (TEXT("BKL_Init: RegQueryValueEx('%s', '%s') failed %u\r\n"),
                 dwContext, DEVLOAD_DEVNAME_VALNAME, dwStatus));
        RegCloseKey(hDriverKey);
        goto InitErrCleanup;
    }

    DEBUGMSG(BKL_DEBUG_MSG, (TEXT("device name is '%s'\r\n"), szName));

    // Default settings:
    // enable backlight timeout, enable backlight on user activity
    bklSettings.dwACTimeout = BKL_DEFAULT_TIMEOUT;
    bklSettings.dwBattTimeout = BKL_DEFAULT_TIMEOUT;
    bklSettings.fBattTimeoutEnable = 1;
    bklSettings.fACTimeoutEnable = 1;
    bklSettings.fBattBacklightOnUser = 1;
    bklSettings.fACBacklightOnUser = 1;
    bklSettings.dwBattBacklightLevel = BKL_LEVEL_DEFAULT;
    bklSettings.dwACBacklightLevel = BKL_LEVEL_DEFAULT;

    // Get current power source
    fACOnline = FALSE;

    if (GetSystemPowerStatusEx(&status, TRUE))
    {
        if (status.ACLineStatus == 1)
        {
            fACOnline = TRUE;
        }
    }

    GetBacklightLevelSettings(&bklSettings);
    GetBacklightTimeoutSettings(&bklSettings);

    // Get handles to desired events/msgQ etc.

    // Get handle to backlight timer change Event
    hWaitList[bklControlPanelEvent] = CreateEvent(NULL, FALSE, FALSE,
                                                  L"BackLightChangeEvent" );

    if(!hWaitList[bklControlPanelEvent])
    {
        ERRORMSG(1, (TEXT("Get BackLightChangeEvent failed!!\r\n")));
        goto InitErrCleanup;
    }

    // Get handle to Power notification event
    msgOptions.dwSize = sizeof(MSGQUEUEOPTIONS);
    msgOptions.dwFlags = MSGQUEUE_ALLOW_BROKEN;
    msgOptions.dwMaxMessages = 0;
    msgOptions.cbMaxMessage = sizeof(POWER_BROADCAST) + MAX_PATH;
    msgOptions.bReadAccess = TRUE;

    // create message queue
    hMsgQ = CreateMsgQueue(NULL, &msgOptions);

    if (!hMsgQ)
    {
        ERRORMSG(1, (TEXT("Create MsgQueue fail!!\n"), GetLastError()));
        goto InitErrCleanup;
    }
    else
    {
        hNotifications = RequestPowerNotifications(hMsgQ, PBT_POWERSTATUSCHANGE);
        if(!hNotifications)
        {
            ERRORMSG(1, (TEXT("Request Power Notification fail!!\n"),
                GetLastError()));
            goto InitErrCleanup;
        }
        hWaitList[bklPowerNotificationEvent] = hMsgQ;
    }

    // Get handle to User Activity Event
    dwStatus = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                            USER_ACTIVITY_EVENT_REG_PATH,
                            0,
                            0,
                            &hDriverKey);

    if (dwStatus == ERROR_SUCCESS)
    {
        dwSize = sizeof(szEventName);
        dwStatus = RegQueryValueEx(hDriverKey,
                                   USER_ACTIVITY_EVENT_KEY,
                                   NULL,
                                   &dwType,
                                   (LPBYTE)szEventName,
                                   &dwSize);
        RegCloseKey(hDriverKey);

        if(dwStatus != ERROR_SUCCESS)
        {
            ERRORMSG(1,
                (TEXT("Get User Activity Event register setting failed!!\r\n")));
            goto InitErrCleanup;
        }
        DEBUGMSG(BKL_DEBUG_MSG,
            (TEXT("User Activity Event Name: ''%s'\r\n"), szEventName));

        hWaitList[bklUserActivityExistEvent] =
            CreateEvent(NULL, FALSE, FALSE, szEventName);
        if(!hWaitList[bklUserActivityExistEvent])
        {
            ERRORMSG(1, (TEXT("Get User Activity Event failed!!\r\n")));
            goto InitErrCleanup;
        }
    }

    // Get handle to backlight level change event
    hWaitList[bklLevelChangeEvent] = CreateEvent(NULL, FALSE, FALSE,
                                                 L"BackLightLevelChangeEvent" );
    if(!hWaitList[bklLevelChangeEvent])
    {
        ERRORMSG(1, (TEXT("Get BackLightLevelChangeEvent failed!!\r\n")));
        goto InitErrCleanup;
    }

    // Create a dummy event that will never be signaled.
    hevDummy = CreateEvent(NULL, FALSE, FALSE, NULL);
    if(!hevDummy)
    {
        ERRORMSG(1, (TEXT("Create dummy event failed!!\r\n")));
        goto InitErrCleanup;
    }

    BSPBacklightInitialize();

    // Init device power state to D0
    CurDx = D0;

    DEBUGMSG(BKL_DEBUG_MSG, (TEXT("BKL_Init: CreateThread\r\n")));
    fEventThreadLoop = TRUE;
    ghInterruptServiceThread = CreateThread(NULL,
                                            0,
                                            (LPTHREAD_START_ROUTINE)BKL_EventThread,
                                            NULL,
                                            0,
                                            NULL);
    if(ghInterruptServiceThread == NULL)
    {
        ERRORMSG(1,
            (TEXT("BKL_Init: Failed to create BLD Interrupt Service Thread\r\n")));
        goto InitErrCleanup;
    }

    DEBUGMSG(BKL_DEBUG_MSG, (TEXT("BKL_INIT() -!\r\n")) );
    return 1;

InitErrCleanup:
    if (hDriverKey)
    {
        RegCloseKey(hDriverKey);
    }

    BKL_Deinit(dwContext);

    return 0;
}


//------------------------------------------------------------------------------
//
//  FUNCTION:       BKL_Deinit
//
//  DESCRIPTION:    Deinitialize the card loader
//  PARAMETERS:
//
//  RETURNS:
//
//------------------------------------------------------------------------------
BOOL BKL_Deinit(DWORD dwContext)
{
    DWORD i;
    DEBUGMSG(BKL_DEBUG_MSG, (TEXT("+BKL_Deinit: dwContext = 0x%x\r\n"), dwContext));

    // Give the thread a chance to perform any cleanup.
    if(ghInterruptServiceThread)
    {
        fEventThreadLoop = FALSE;
        SetEvent(hWaitList[bklControlPanelEvent]);
        CloseHandle(ghInterruptServiceThread);
    }
    // Stop Power Notifications
    if(hNotifications)
        StopPowerNotifications(hNotifications);
    if(hMsgQ)
        CloseMsgQueue(hMsgQ);

    // Close wait Handles
    for(i = 0; i < dim(hWaitList); i++)
    {
        if(hWaitList[i])
            CloseHandle(hWaitList[i]);
    }
    if(hevDummy)
        CloseHandle(hevDummy);

    DeleteCriticalSection(&cs);

    BSPBacklightRelease();

    // the device manager does not check the return code
    DEBUGMSG(BKL_DEBUG_MSG, (TEXT("-BKL_Deinit\r\n"), dwContext));

    return TRUE;
}


//------------------------------------------------------------------------------
//