/***************************************************************************
 *     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;
}