snled.cpp

mx27 f14v2 源代码。包括ADS板上诸多驱动的源码。

//------------------------------------------------------------------------------
//
//  Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
//  Use of this source code is subject to the terms of the Microsoft end-user
//  license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
//  If you did not accept the terms of the EULA, you are not authorized to use
//  this source code. For a copy of the EULA, please see the LICENSE.RTF on your
//  install media.
//
//------------------------------------------------------------------------------
//
//  File:  Snled.cpp
//
//  Implementation of PDD layer of Notification LED(s)
//
//------------------------------------------------------------------------------
//
// Copyright (C) 2006-2007 Freescale Semiconductor, Inc. All Rights Reserved.
// THIS SOURCE CODE, AND ITS USE AND DISTRIBUTION, IS SUBJECT TO THE TERMS
// AND CONDITIONS OF THE APPLICABLE LICENSE AGREEMENT
//
//------------------------------------------------------------------------------

#include <windows.h>
#include <nled.h>
#include <led_drvr.h>
#include <types.h>
#include <bsp.h>
#include <bsp_cfg.h>
#include <nkintr.h>
#include <Winbase.h>

//------------------------------------------------------------------------------
// Defines
#define NLED_MAX_LED    2   // Total number of notification LEDs supported

//------------------------------------------------------------------------------
// Types
struct NLedPddContext
{
    HANDLE  hNLedBlinkThreadEvent;
    HANDLE  hNLedBlinkThreadStoppedEvent;
    BOOL bLEDState;
    BOOL bLEDBlinkState;
    NLED_SETTINGS_INFO NLedSettingsInfo;
    NLED_SUPPORTS_INFO NLedSupportsInfo;
};

//------------------------------------------------------------------------------
// Local Variables
static CSP_PBC_REGS *g_pPBC;
static NLedPddContext g_NLedPddContext[NLED_MAX_LED];

//------------------------------------------------------------------------------
// Local Functions
VOID TurnOnLED(DWORD LEDNum);
VOID TurnOffLED(DWORD LEDNum);
DWORD WINAPI LEDBlinkThread(LPVOID lParam);

//-----------------------------------------------------------------------------
//
// Function: NLedDriverInitialize
//
// The NLED MDD calls this routine to initialize the underlying NLED hardware.
// This routine should return TRUE if successful.  If there's a problem
// it should return FALSE and call SetLastError() to pass back the reason
// for the failure.
//
//  Returns:
//        This routine returns TRUE if successful, or FALSE if there's a problem
//
//-----------------------------------------------------------------------------

BOOL WINAPI NLedDriverInitialize(VOID)
{
    PHYSICAL_ADDRESS phyAddr;

    DEBUGMSG(ZONE_FUNCTION, (TEXT("+NLedDriverInitialize: invoked\r\n")));

    g_pPBC = NULL;
    phyAddr.QuadPart = BSP_BASE_REG_PA_PBC_BASE;

    g_pPBC = (PCSP_PBC_REGS) MmMapIoSpace(phyAddr, sizeof(CSP_PBC_REGS), FALSE);
    if (g_pPBC == NULL)
    {
        DEBUGMSG(ZONE_ERROR, (TEXT("%s(): MmMapIoSpace failed!\r\n"), __WFUNCTION__));
        return FALSE;
    }

    // initialization NLedPddContext struct
    memset(&g_NLedPddContext, 0, NLED_MAX_LED * sizeof(NLedPddContext));

    //Setting NLED support Blink mode
    for(int i=0; i<NLED_MAX_LED; i++)
    {
        g_NLedPddContext[i].NLedSupportsInfo.LedNum = 0;
        g_NLedPddContext[i].NLedSupportsInfo.fAdjustOffTime = TRUE;
        g_NLedPddContext[i].NLedSupportsInfo.fAdjustOnTime = TRUE;
        g_NLedPddContext[i].NLedSupportsInfo.fAdjustTotalCycleTime = FALSE;
        g_NLedPddContext[i].NLedSupportsInfo.lCycleAdjust = 1000;
        g_NLedPddContext[i].NLedSupportsInfo.fMetaCycleOff = TRUE;
        g_NLedPddContext[i].NLedSupportsInfo.fMetaCycleOn = TRUE;
    }

    for(int i=0; i<NLED_MAX_LED; i++)
    {
        if((((g_NLedPddContext[i].hNLedBlinkThreadEvent = CreateEvent(NULL, FALSE, FALSE, NULL)) == NULL) ||
            (g_NLedPddContext[i].hNLedBlinkThreadStoppedEvent = CreateEvent(NULL, FALSE, FALSE, NULL)) == NULL))
        {
            CloseHandle(g_NLedPddContext[i].hNLedBlinkThreadEvent);
            CloseHandle(g_NLedPddContext[i].hNLedBlinkThreadStoppedEvent);

            while(i)
            {
                i--;
                CloseHandle(g_NLedPddContext[i].hNLedBlinkThreadEvent);
                CloseHandle(g_NLedPddContext[i].hNLedBlinkThreadStoppedEvent);
            }

            MmUnmapIoSpace(g_pPBC, sizeof(CSP_PBC_REGS));

            DEBUGMSG(ZONE_ERROR,  (TEXT("NLedDriverInitialize: CreateEvent() Failed\r\n")));
            return FALSE;
        }
    }

    for(int i=0; i<NLED_MAX_LED; i++)
        TurnOffLED(i); //Turn off all LED

    DEBUGMSG(ZONE_FUNCTION, (TEXT("-NLedDriverInitialize\r\n")));

    return TRUE;
}

//-----------------------------------------------------------------------------
//
// Function: NLedDriverDeInitialize
//
// The NLED MDD calls this routine to deinitialize the underlying NLED
// hardware as the NLED driver is unloaded.  It should return TRUE if
// successful.  If there's a problem this routine should return FALSE
// and call SetLastError() to pass back the reason for the failure.
//
//  Returns:
//        This routine returns TRUE if successful, or FALSE if there's a problem
//
//-----------------------------------------------------------------------------
BOOL WINAPI NLedDriverDeInitialize(VOID)
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("+NLedDriverDeInitialize: invoked\r\n")));

    for(int i=0; i<NLED_MAX_LED; i++) // Stop all threads
        SetEvent(g_NLedPddContext[i].hNLedBlinkThreadEvent);

    for(int i=0; i<NLED_MAX_LED; i++) // Wait for all threads to stop
        if(g_NLedPddContext[i].bLEDBlinkState)
            WaitForSingleObject(g_NLedPddContext[i].hNLedBlinkThreadStoppedEvent, INFINITE);

    MmUnmapIoSpace(g_pPBC, sizeof(CSP_PBC_REGS));

    for(int i=0; i<NLED_MAX_LED; i++)
    {
        CloseHandle(g_NLedPddContext[i].hNLedBlinkThreadStoppedEvent);
        CloseHandle(g_NLedPddContext[i].hNLedBlinkThreadEvent);
    }

    DEBUGMSG(ZONE_FUNCTION, (TEXT("-NLedDriverDeInitialize\r\n")));

    return TRUE;
}

//-----------------------------------------------------------------------------
//
// Function: NLedDriverGetDeviceInfo
//
// This routine retrieves information about the NLED device(s) that
// this driver supports.  The nInfoId parameter indicates what specific
// information is being queried and pOutput is a buffer to be filled in.
// The size of pOutput depends on the type of data being requested.  This
// routine returns TRUE if successful, or FALSE if there's a problem -- in
// which case it also calls SetLastError() to pass back more complete
// error information.  The NLED MDD invokes this routine when an application
// calls NLedGetDeviceInfo().
//
// Parameters:
//      InputParm
//          [in] INT     nInfoId
//
//      OutputParm
//          [out] PVOID   pOutput
//
// Returns:
//      This routine returns TRUE if successful, or FALSE if there's a problem
//
//-----------------------------------------------------------------------------
BOOL WINAPI NLedDriverGetDeviceInfo(
                       INT     nInfoId,
                       PVOID   pOutput
                       )
{
    DEBUGMSG(ZONE_FUNCTION, (TEXT("+NLedDriverGetDeviceInfo\r\n")));

    BOOL fOk = TRUE;
    SETFNAME(_T("NLedDriverGetDeviceInfo"));

    if(nInfoId == NLED_COUNT_INFO_ID)
    {
        struct NLED_COUNT_INFO *p = (struct NLED_COUNT_INFO*)pOutput;
        p->cLeds = NLED_MAX_LED;
    }
    else if (nInfoId == NLED_SUPPORTS_INFO_ID)
    {
        struct NLED_SUPPORTS_INFO *p = (struct NLED_SUPPORTS_INFO*)pOutput;

        if(p->LedNum >= NLED_MAX_LED)
        {
            fOk = FALSE;
        }
        else
        {
            p->fAdjustOffTime           = g_NLedPddContext[p->LedNum].NLedSupportsInfo.fAdjustOffTime;
            p->fAdjustOnTime            = g_NLedPddContext[p->LedNum].NLedSupportsInfo.fAdjustOnTime;
            p->lCycleAdjust             = g_NLedPddContext[p->LedNum].NLedSupportsInfo.lCycleAdjust;
            p->fMetaCycleOff            = g_NLedPddContext[p->LedNum].NLedSupportsInfo.fMetaCycleOff;
            p->fMetaCycleOn             = g_NLedPddContext[p->LedNum].NLedSupportsInfo.fMetaCycleOn;
            p->fAdjustTotalCycleTime    = g_NLedPddContext[p->LedNum].NLedSupportsInfo.fAdjustTotalCycleTime;
        }
    }
    else if (nInfoId == NLED_SETTINGS_INFO_ID)
    {
        struct NLED_SETTINGS_INFO *p = (struct NLED_SETTINGS_INFO*)pOutput;

        if(p->LedNum >= NLED_MAX_LED)
        {
            fOk = FALSE;
        }
        else
        {
            p->MetaCycleOff         = g_NLedPddContext[p->LedNum].NLedSettingsInfo.MetaCycleOff;
            p->MetaCycleOn          = g_NLedPddContext[p->LedNum].NLedSettingsInfo.MetaCycleOn;
            p->OffOnBlink           = g_NLedPddContext[p->LedNum].NLedSettingsInfo.OffOnBlink;
            p->OffTime              = g_NLedPddContext[p->LedNum].NLedSettingsInfo.OffTime;
            p->OnTime               = g_NLedPddContext[p->LedNum].NLedSettingsInfo.OnTime;
            p->TotalCycleTime       = g_NLedPddContext[p->LedNum].NLedSettingsInfo.TotalCycleTime;
        }
    }
    else
    {
        fOk = FALSE;
        SetLastError(ERROR_INVALID_PARAMETER);
    }

    DEBUGMSG(ZONE_FUNCTION, (TEXT("-NLedDriverGetDeviceInfo\r\n")));

    return (fOk);
}


//-----------------------------------------------------------------------------
//
// Function: NLedDriverSetDevice
//
// This routine changes the configuration of an LED.  The nInfoId parameter
// indicates what kind of configuration information is being changed.
// Currently only the NLED_SETTINGS_INFO_ID value is supported.  The pInput