rilpm.cpp

Windows CE 6.0 BSP for the Beagle Board.

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this sample source code is subject to the terms of the Microsoft
// license agreement under which you licensed this sample source code. If
// you did not accept the terms of the license agreement, you are not
// authorized to use this sample source code. For the terms of the license,
// please see the license agreement between you and Microsoft or, if applicable,
// see the LICENSE.RTF on your install media or the root of your tools installation.
// THE SAMPLE SOURCE CODE IS PROVIDED "AS IS", WITH NO WARRANTIES.
//
/*++


Abstract:

    Power Manager Monitor.
    Run in the background to display power state changes in debugger.

Notes:

Revision History:

--*/
#include <windows.h>
#include <ceddk.h>
#include <devload.h>
#include <Winreg.h>
#include <Pegdser.h>

//#include "precomp.h"

#include <msgqueue.h>
#include <pm.h>

#define QUEUE_ENTRIES   3
#define MAX_NAMELEN     200
#define QUEUE_SIZE      (QUEUE_ENTRIES * (sizeof(POWER_BROADCAST) + MAX_NAMELEN))


int
GetPriority(
    VOID
    )
{
    //  for CeSetThreadPriority()
    return 249;  //  249 to CeSetThreadPriority() == THREAD_PRIORITY_HIGHEST to SetThreadPriority()
}

DWORD RIL_PmProc (LPVOID *lpV)
{
    HANDLE hMsgQ = NULL;
    HANDLE hNotifications = NULL;
    DWORD dwErr, dwFlags = 0, dwCount = 0;
    DWORD dwPri = CeGetThreadPriority(GetCurrentThread());
    
    MSGQUEUEOPTIONS msgOptions = {0};   

    UCHAR buf[QUEUE_SIZE];
    unsigned long iBytesInQueue;
    
    // create a message queue for Power Manager notifications
    //
    msgOptions.dwSize = sizeof(MSGQUEUEOPTIONS);
    msgOptions.dwFlags = 0;
    msgOptions.dwMaxMessages = QUEUE_ENTRIES;
    msgOptions.cbMaxMessage = sizeof(POWER_BROADCAST) + MAX_NAMELEN;
    msgOptions.bReadAccess = TRUE;

    hMsgQ = CreateMsgQueue(NULL, &msgOptions);
    if (!hMsgQ) {
        dwErr = GetLastError();
        RETAILMSG(1, (TEXT("PMMON!CreateMessageQueue ERROR:%d\n"), dwErr));
        goto _Exit;
    }

    // request Power notifications
    //
    hNotifications = RequestPowerNotifications(hMsgQ,
                                               POWER_NOTIFY_ALL); // Flags
    if (!hNotifications) {
        dwErr = GetLastError();
        RETAILMSG(1, (TEXT("PMMON!RequestPowerNotifications ERROR:%d\n"), dwErr));
        goto _Exit;
    }

    dwPri = GetPriority();
    if ( !CeSetThreadPriority(GetCurrentThread(), dwPri)) {
        dwErr = GetLastError();
        RETAILMSG(1, (TEXT("PMAPI!CeSetThreadPriority ERROR:%d\n"), dwErr));
        goto _Exit;
    }

    while (1) 
    {
        iBytesInQueue = 0;
        memset(&buf, 0, QUEUE_SIZE);

        // Block on our message queue.
        // This thread runs when the power manager writes a notification into the queue.
        if ( !ReadMsgQueue(hMsgQ,
                           &buf,
                           QUEUE_SIZE,
                           &iBytesInQueue,
                           INFINITE,    // Timeout
                           &dwFlags))
        {
            dwErr = GetLastError();
            RETAILMSG(1, (TEXT("PMMON!ReadMsgQueue: ERROR:%d\n"), dwErr));
            ASSERT(0);
        } else if(iBytesInQueue >= sizeof(POWER_BROADCAST)) {
            //
            // process power notifications
            //
            PPOWER_BROADCAST pB = (PPOWER_BROADCAST)&buf;
            
            RETAILMSG(1, (TEXT("PMMON!*** Power Notification @ Tick:%u, Count:%d, Pri:%d***\n"), 
                GetTickCount(), dwCount++, dwPri));
            switch (pB->Message) 
            {
            case PBT_TRANSITION:
                RETAILMSG(1, (TEXT("PMMON!\tPBT_TRANSITION to system power state: '%s'\n"), pB->SystemPowerState));
                switch (POWER_STATE(pB->Flags)) {
                case POWER_STATE_ON:
                    NKDbgPrintfW(TEXT("RilDrv: PMMON!\tPOWER_STATE_ON\r\n"));
                    break;
                case POWER_STATE_OFF:
                    NKDbgPrintfW(TEXT("RilDrv: PMMON!\tPOWER_STATE_OFF\r\n"));
                    break;
                case POWER_STATE_CRITICAL:
                    NKDbgPrintfW(TEXT("RilDrv: PMMON!\tPOWER_STATE_CRITICAL\r\n"));
                    break;
                case POWER_STATE_BOOT:
                    NKDbgPrintfW(TEXT("RilDrv: PMMON!\tPOWER_STATE_BOOT\r\n"));
                    break;
                case POWER_STATE_IDLE:
                    NKDbgPrintfW(TEXT("RilDrv: PMMON!\tPOWER_STATE_IDLE\r\n"));
                    break;
                case POWER_STATE_SUSPEND:
                    {
                        NKDbgPrintfW(TEXT("RilDrv: PMMON!\tPOWER_STATE_SUSPEND\r\n"));
#ifdef OEM1_DRIVER
#ifdef BSP_POCKETPC
                        //NKDbgPrintfW(TEXT("RilDrv: RILDrv_EnablePowerSavings called...\r\n"));
                        RILDrv_EnablePowerSavings(0);
                        //NKDbgPrintfW(TEXT("RilDrv: RILDrv_EnablePowerSavings done.\r\n"));
#endif // BSP_POCKETPC
#endif // OEM1_DRIVER
                    }
                    break;
                case POWER_STATE_RESET:
                    NKDbgPrintfW(TEXT("RilDrv: PMMON!\tPOWER_STATE_RESET\r\n"));
                    break;
                case 0:
                    break;
                default:
                    NKDbgPrintfW(TEXT("RilDrv: PMMON!\tUnknown Power State Flags:0x%x\r\n"),pB->Flags);
                    ASSERT(0);
                    break;
                }
                break;
                
                case PBT_RESUME:
                    NKDbgPrintfW(TEXT("RilDrv: PMMON!\tPBT_RESUME\r\n"));
#ifdef OEM1_DRIVER
#ifdef BSP_POCKETPC
                    //NKDbgPrintfW(TEXT("RilDrv: RILDrv_DisablePowerSavings called...\r\n"));
                    RILDrv_DisablePowerSavings(0);
                    //NKDbgPrintfW(TEXT("RilDrv: RILDrv_DisablePowerSavings done.\r\n"));
#endif // BSP_POCKETPC
#endif // OEM1_DRIVER
                    break;
                    
                case PBT_POWERSTATUSCHANGE:
                    NKDbgPrintfW(TEXT("RilDrv: PMMON!\tPBT_POWERSTATUSCHANGE\r\n"));
                    break;
                    
                case PBT_POWERINFOCHANGE:
                    {
                        NKDbgPrintfW(TEXT("RilDrv: PMMON!\tPBT_POWERINFOCHANGE\r\n"));

                        PPOWER_BROADCAST_POWER_INFO ppbpi = (PPOWER_BROADCAST_POWER_INFO) pB->SystemPowerState;

                        RETAILMSG(1, (TEXT("PMMON!\tPBT_POWERINFOCHANGE\n")));
                        RETAILMSG(1, (TEXT("PMMON!\t\tAC line status %u, battery flag %u, backup flag %u, %d levels\n"),
                            ppbpi->bACLineStatus, ppbpi->bBatteryFlag, ppbpi->bBackupBatteryFlag, ppbpi->dwNumLevels));
                        RETAILMSG(1, (TEXT("PMMON!\t\tbattery life %d, backup life %d\n"),
                            ppbpi->bBatteryLifePercent, ppbpi->bBackupBatteryLifePercent));
                        RETAILMSG(1, (TEXT("PMMON!\t\tlifetime 0x%08x, full lifetime 0x%08x\n"),
                            ppbpi->dwBatteryLifeTime, ppbpi->dwBatteryFullLifeTime));
                        RETAILMSG(1, (TEXT("PMMON!\t\tbackup lifetime 0x%08x, backup full lifetime 0x%08x\n"),
                            ppbpi->dwBackupBatteryLifeTime, ppbpi->dwBackupBatteryFullLifeTime));
                    }
                    break;
                    
                default:
                    NKDbgPrintfW(TEXT("RilDrv: PMMON!\tUnknown Message:%d\n"), pB->Message);
                    ASSERT(0);
                    break;
            }

            RETAILMSG(1, (TEXT("PMMON!\tMessage: 0x%x\n"), pB->Message));
            RETAILMSG(1, (TEXT("PMMON!\tFlags: 0x%x\n"), pB->Flags));
            RETAILMSG(1, (TEXT("PMMON!\tdwLen: %d\n"), pB->Length));
            
            RETAILMSG(1, (TEXT("PMMON!***********************\n")));
        } else {
            RETAILMSG(1, (TEXT("PMMON!\tReceived short message: %d bytes\n"), iBytesInQueue));
            ASSERT(0);
        }
    }

_Exit:
    if (hMsgQ)
        CloseMsgQueue(hMsgQ);

    if (hNotifications && !StopPowerNotifications(hNotifications)) {
        RETAILMSG(1, (TEXT("PMMON!StopNotifications ERROR:%d\n"), GetLastError()));
        ASSERT(0);
    }

    ExitThread(ERROR_SUCCESS);  
    return ERROR_SUCCESS;
}

// EOF