source: svn/trunk/newcon3bcm2_21bu/magnum/portinginterface/led/7552/bled.c

/***************************************************************************
 *     Copyright (c) 2003-2011, Broadcom Corporation
 *     All Rights Reserved
 *     Confidential Property of Broadcom Corporation
 *
 *  THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
 *  AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
 *  EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
 *
 * $brcm_Workfile: bled.c $
 * $brcm_Revision: Hydra_Software_Devel/6 $
 * $brcm_Date: 1/14/11 7:57p $
 *
 * Module Description:
 *
 * Revision History:
 *
 * $brcm_Log: /magnum/portinginterface/led/7422/bled.c $
 * 
 * Hydra_Software_Devel/6   1/14/11 7:57p brianlee
 * SW7422-197: Make sure to zero out upper bits of LDK_CONTROL during
 * initialization.
 * 
 * Hydra_Software_Devel/5   6/5/06 4:28p erickson
 * PR21941: cleaned up minor warnings
 * 
 * Hydra_Software_Devel/4   5/27/04 5:15p brianlee
 * PR11238: Fixed code to work with 7038 B0.
 * 
 * Hydra_Software_Devel/3   11/4/03 6:59p brianlee
 * Get rid of enter/leave macros.
 * 
 * Hydra_Software_Devel/2   9/30/03 11:21a brianlee
 * Fixed a warning.
 * 
 * Hydra_Software_Devel/1   9/23/03 10:17a brianlee
 * Initial version.  This module includes stubs for now since 7038 A0 does
 * not contain LED module.
 * 
 ***************************************************************************/
#include "bstd.h"
#include "bled.h"
#include "bchp_ldk.h"


BDBG_MODULE(bled);

#define DEV_MAGIC_ID                    ((BERR_LED_ID<<16) | 0xFACE)

#define BLED_CHK_RETCODE( rc, func )            \
do {                                                                            \
        if( (rc = BERR_TRACE(func)) != BERR_SUCCESS ) \
        {                                                                               \
                goto done;                                                      \
        }                                                                               \
} while(0)

/* Default values */
#define LED_DEFAULT_PRESCALE_HI         0x00
#define LED_DEFAULT_PRESCALE_LO         0x55
#define LED_DEFAULT_DUTYCYCLE_OFF       0x01
#define LED_DEFAULT_DUTYCYCLE_ON        0xAA
#define LED_DEFAULT_DEBOUNCE            0x40

/*******************************************************************************
*
*       Private Module Handles
*
*******************************************************************************/

typedef struct BLED_P_Handle
{
        uint32_t                magicId;                                        /* Used to check if structure is corrupt */
        BCHP_Handle     hChip;
        BREG_Handle             hRegister;
} BLED_P_Handle;

/*******************************************************************************
*
*       Default Module Settings
*
*******************************************************************************/
static const BLED_Settings defLedSettings = 
{
        100                                                                     /* percent brightness */
};

/*******************************************************************************
*
*       Public Module Functions
*
*******************************************************************************/
BERR_Code BLED_Open(
        BLED_Handle *pLed,                                      /* [output] Returns handle */
        BCHP_Handle hChip,                                      /* Chip handle */
        BREG_Handle hRegister,                          /* Register handle */
        const BLED_Settings *pDefSettings       /* Default settings */
        )
{
        BERR_Code               retCode = BERR_SUCCESS;
        BLED_Handle     hDev;
        uint32_t                lval;

        /* Sanity check on the handles we've been given. */
        BDBG_ASSERT( hChip );
        BDBG_ASSERT( hRegister );

        /* Alloc memory from the system heap */
        hDev = (BLED_Handle) BKNI_Malloc( sizeof( BLED_P_Handle ) );
        if( hDev == NULL )
        {
                *pLed = NULL;
                retCode = BERR_TRACE(BERR_OUT_OF_SYSTEM_MEMORY);
                BDBG_ERR(("BLED_Open: BKNI_malloc() failed\n"));
                goto done;
        }

        hDev->magicId   = DEV_MAGIC_ID;
        hDev->hChip             = hChip;
        hDev->hRegister = hRegister;
        *pLed = hDev;

        /* Reset LED/Keypad core */
        lval = BREG_Read32 (hDev->hRegister, BCHP_LDK_CONTROL);
        lval |= BCHP_LDK_CONTROL_swr_MASK;
        lval &= 0x0f;                                           /* only keep lower 4 bits */
        BREG_Write32 (hDev->hRegister, BCHP_LDK_CONTROL, lval);
        
        lval &= ~BCHP_LDK_CONTROL_swr_MASK;
        lval |=  BCHP_LDK_CONTROL_ver_MASK;
        BREG_Write32 (hDev->hRegister, BCHP_LDK_CONTROL, lval);

        /* Set up LED */
        BREG_Write32 (hDev->hRegister, BCHP_LDK_PRESCHI, LED_DEFAULT_PRESCALE_HI);
        BREG_Write32 (hDev->hRegister, BCHP_LDK_PRESCLO, LED_DEFAULT_PRESCALE_LO);

        BLED_AdjustBrightness (hDev, pDefSettings->percentBrightness);

done:
        return( retCode );
}

BERR_Code BLED_Close(
        BLED_Handle hDev                                        /* Device handle */
        )
{
        BERR_Code retCode = BERR_SUCCESS;


        BDBG_ASSERT( hDev );
        BDBG_ASSERT( hDev->magicId == DEV_MAGIC_ID );

        BKNI_Free( (void *) hDev );

        return( retCode );
}

BERR_Code BLED_GetDefaultSettings(
        BLED_Settings *pDefSettings,            /* [output] Returns default setting */
        BCHP_Handle hChip                                       /* Chip handle */
)
{
        BERR_Code retCode = BERR_SUCCESS;

        BSTD_UNUSED(hChip);

        *pDefSettings = defLedSettings;

        return( retCode );
}

BERR_Code BLED_Write ( 
        BLED_Handle             hLed,                   /* Device handle */
        uint8_t                         digit,                  /* digit to write to */
        uint8_t                         value                   /* value to write */
)
{
        uint32_t        offset;
        
        switch (digit)
        {
                case 1:
                        offset = BCHP_LDK_DIGIT1;
                        break;

                case 2:
                        offset = BCHP_LDK_DIGIT2;
                        break;
                        
                case 3:
                        offset = BCHP_LDK_DIGIT3;
                        break;

                case 4:
                        offset = BCHP_LDK_DIGIT4;
                        break;
                        
                default:
                        return BERR_INVALID_PARAMETER;
        }
        
        BREG_Write32 (hLed->hRegister, offset, (uint32_t)value);

        return BERR_SUCCESS;
}

BERR_Code BLED_AdjustBrightness ( 
        BLED_Handle             hLed,                           /* Device handle */
        uint8_t                         percentBrightness       /* percent of brightness */
)
{
        uint8_t                         ucDutyCycleOn;
        uint8_t                         ucDutyCycleOff;
        uint32_t                        dutyCycleClks;
        uint32_t                        valueOn;

        dutyCycleClks   = LED_DEFAULT_DUTYCYCLE_ON + LED_DEFAULT_DUTYCYCLE_OFF;

        valueOn                 = dutyCycleClks * percentBrightness / 100;
        ucDutyCycleOn   = (uint8_t)valueOn;
        ucDutyCycleOff  = dutyCycleClks - ucDutyCycleOn;

        BREG_Write32 (hLed->hRegister, BCHP_LDK_DUTYOFF, (uint32_t)ucDutyCycleOff);
        BREG_Write32 (hLed->hRegister, BCHP_LDK_DUTYON,  (uint32_t)ucDutyCycleOn);

        return BERR_SUCCESS;
}

BERR_Code BLED_SetDiscreteLED ( 
        BLED_Handle             hLed,                   /* Device handle */
        bool                            on,                             /* turn on or off */
        uint8_t                         ledStatusBit    /* bit to turn on or off */
)
{
        uint32_t                        lval;

        if (ledStatusBit > 7)
                return BERR_INVALID_PARAMETER;
                
        lval = BREG_Read32 (hLed->hRegister, BCHP_LDK_STATUS);
        if (on)
                lval &= ~(1 << ledStatusBit);
        else
                lval |= (1 << ledStatusBit);

        BREG_Write32 (hLed->hRegister, BCHP_LDK_STATUS, lval);

        return BERR_SUCCESS;
}