/****************************************************************************
Copyright (C) Cambridge Silicon Radio Ltd. 2004-2007

FILE NAME
    headset_LEDmanager.c
    
DESCRIPTION
    Module responsible for managing the PIO outputs including LEDs.
    
*/


#include "headset_configmanager.h"
#include "headset_debug.h"
#include "headset_statemanager.h"
#include "headset_LEDmanager.h"
#include "headset_leds.h"
#include "headset_pio.h"
#include "headset_private.h"

#include <stddef.h>
#include <panic.h>
#include <pio.h>


#ifdef DEBUG_LM
#define LM_DEBUG(x) DEBUG(x)
#else
#define LM_DEBUG(x) 
#endif


/****************************************************************************
    LOCAL FUNCTION PROTOTYPES
*/

 /*internal method to provide a pointer to one of the malloced patterns*/
static LEDPattern_t * LMGetPattern ( LedTaskData * ptheLEDTask )  ;
    /*method to release a pattern - actually clears data held in pattern so it can be used again*/
static void LMResetPattern ( LEDPattern_t * pPattern ) ;

static bool LMIsPatternEmpty (LEDPattern_t * pPattern ) ;

static LEDPattern_t *  LMAddPattern ( LedTaskData * ptheLEDTask , LEDPattern_t * pSourcePattern , LEDPattern_t * pDestPattern ) ;

 /*methods to allocate/ initialise the space for the patterns and mappings*/
static void LEDManagerInitStatePatterns   ( LedTaskData * ptheLEDTask ) ;
static void LEDManagerInitEventPatterns   ( LedTaskData * ptheLEDTask ) ;
static void LEDManagerInitActiveLEDS      ( LedTaskData * ptheLEDTask ) ;
static void LEDManagerCreateFilterPatterns( LedTaskData * ptheLEDTask ) ;


/****************************************************************************
  FUNCTIONS
*/

/*****************************************************************************/
void LEDManagerInit ( LedTaskData * ptheLEDTask ) 
{
    uint16 lIndex = 0 ;
    uint16 lSize = 0;
    uint16 *buffer;
    uint16 pos;
        
    LM_DEBUG(("LM Init :\n")) ;
   
	/*allocate the space for all of the patterns*/
	/* Place LED Patterns and Active LEDs in 1 allocation to minimise slot usage */
	lSize = (sizeof(LEDPattern_t) * LM_MAX_NUM_PATTERNS) + (sizeof(LEDActivity_t) * HEADSET_NUM_LEDS);
	buffer = PanicUnlessMalloc(lSize);
    ptheLEDTask->gPatterns = (LEDPattern_t*)&buffer[0];
    
    pos = (sizeof(LEDPattern_t) * LM_MAX_NUM_PATTERNS);
    ptheLEDTask->gActiveLEDS = (LEDActivity_t *)&buffer[pos];
    
    for (lIndex = 0 ; lIndex < LM_MAX_NUM_PATTERNS ; lIndex ++ )
    {
            /*make sure the pattern is released and ready for use*/
        LMResetPattern ( &ptheLEDTask->gPatterns[lIndex] )  ;      
    }
    
    /*malloc the space for all of the other data*/
    lSize =   ( (sizeof(LEDPattern_t *)) * HEADSET_NUM_HFP_STATES * HEADSET_NUM_A2DP_STATES )
            + ( (sizeof(LEDPattern_t *)) * EVENTS_MAX_EVENTS   ) ; 
        
    ptheLEDTask->gStatePatterns = (LEDPattern_t * * ) PanicUnlessMalloc (lSize) ;
     
    ptheLEDTask->gEventPatterns = (LEDPattern_t * *) (ptheLEDTask->gStatePatterns + (HEADSET_NUM_HFP_STATES * HEADSET_NUM_A2DP_STATES) ) ;
    
    LM_DEBUG(("LM : p[%x][%x][%x]\n" ,  (int)ptheLEDTask->gStatePatterns ,
                                        (int)ptheLEDTask->gEventPatterns ,
                                        (int)ptheLEDTask->gActiveLEDS    
              )) ;
    /* create the patterns we want to use*/
    LEDManagerInitStatePatterns ( ptheLEDTask) ;
    
    LEDManagerInitActiveLEDS( ptheLEDTask) ;
    
    LEDManagerInitEventPatterns( ptheLEDTask ) ;
    
    ptheLEDTask->Queue.Event1 = 0 ;
    ptheLEDTask->Queue.Event2 = 0 ;
    ptheLEDTask->Queue.Event3 = 0 ;
    ptheLEDTask->Queue.Event4 = 0 ;
    
	/*the filter information*/
    LEDManagerCreateFilterPatterns( ptheLEDTask ) ;
    
    LedsInit ( ptheLEDTask ) ;

}


/*****************************************************************************/
void LEDManagerAddLEDStatePattern ( LedTaskData * ptheLEDTask , headsetHfpState pState, headsetA2dpState pA2dpState , LEDPattern_t* pPattern )
{  
    uint16 led_state =  pState + (HEADSET_NUM_HFP_STATES * pA2dpState);
    ptheLEDTask->gStatePatterns [ led_state ] = LMAddPattern ( ptheLEDTask , pPattern ,  ptheLEDTask->gStatePatterns [ led_state ] )  ;
    LM_DEBUG(("LM: AddState[%x][%x][%x]\n" , pState , pA2dpState ,(int) ptheLEDTask->gStatePatterns [ led_state ] )) ;
}


/*****************************************************************************/
void LEDManagerAddLEDFilter  (  LedTaskData * ptheLEDTask , LEDFilter_t* pLedFilter ) 
{
    if ( ptheLEDTask->gLMNumFiltersUsed < LM_NUM_FILTER_EVENTS )
    {
        /*then add the filter pattern*/
       ptheLEDTask->gEventFilters [ ptheLEDTask->gLMNumFiltersUsed ] = *pLedFilter ;
  
       LM_DEBUG(("LM :  AF[%x][%d][%d][%d][%d] [%d][%d] [%d][%d]\n", pLedFilter->Event ,pLedFilter->IsFilterActive , 
                                                   pLedFilter->Speed, pLedFilter->SpeedAction, pLedFilter->Colour ,
                                                   pLedFilter->OverideLEDActive , pLedFilter->OverideLED , 
                                                   pLedFilter->FollowerLEDActive , pLedFilter->FollowerLEDDelay
                                                   )) ;
     /*inc the filters*/
        ptheLEDTask->gLMNumFiltersUsed ++ ;
    }
}


/*****************************************************************************/
void LEDManagerAddLEDEventPattern ( LedTaskData * ptheLEDTask , headsetEvents_t pEvent , LEDPattern_t* pPattern )
{
    uint16 lIndex = pEvent - EVENTS_EVENT_BASE ;

    ptheLEDTask->gEventPatterns [ lIndex ] = LMAddPattern ( ptheLEDTask , pPattern , ptheLEDTask->gEventPatterns [ lIndex ]  ) ;   
    
    LM_DEBUG(("LM: AddEvent[%x] [%x]\n" , pEvent ,(int)ptheLEDTask->gEventPatterns [ lIndex ])) ;    

}


/*****************************************************************************/
void LEDManagerSetPowerPin ( hsTaskData * pApp ,  PowerPin_t pEnable ) 
{
    LM_DEBUG(("LM : Power [%c]\n", (pEnable ? 'T':'F') )) ;
    PioSetPowerPin ( pApp , pEnable) ;
}


/*****************************************************************************/
void LEDManagerSetMicBias ( hsTaskData * pApp , bool pEnable  ) 
{
    /*uint16 lMicPio = configManagerGetMicBiasPio() ;*/
    
#ifdef USES_LDO  
    /*set or unset the  LDO*/
    /*PioSetInternalLDO ( pEnable ) ;*/
#else  
    /*update the pin as requested*/
    /*PioSetPio(  lMicPio , pEnable) ;*/
#endif  
     
        /* turn on and off dedicated pin and set current and voltage */
    if ( pEnable)
    {
        /* set current and voltage to magic values*/
        PioSetMicBiasHwEnabled (1);
        PioSetMicBiasHwCurrent(11);   
        PioSetMicBiasHwVoltage(7);
    }
    else
    {
        PioSetMicBiasHwEnabled (0);
    }
	
    LM_DEBUG(("LM: Mic e[%c]\n" , (pEnable ? 'T':'F' ))) ;
}


/*****************************************************************************/
void LedManagerSetPIO ( uint16 pPIO , bool pOnOrOff  ) 
{
    PioSetPio ( pPIO , pOnOrOff  ) ; 
}


/*****************************************************************************/
void LEDManagerIndicateEvent ( LedTaskData * pLEDTask , MessageId pEvent ) 
{
    uint16 lEventIndex = pEvent - EVENTS_EVENT_BASE ;

    /*only indicate if LEDs are enabled*/
    if ((pLEDTask->gLEDSEnabled ) ||
        LedsEventCanOverideDisable( pLEDTask , pEvent ) ||
        LedActiveFiltersCanOverideDisable( pLEDTask ))
    {
    
        LM_DEBUG(("LM : IE[%x]\n",pEvent )) ;
            /*if there is an event configured*/
        if ( pLEDTask->gEventPatterns [lEventIndex] != NULL )
        {
                /*only update if wer are not currently indicating an event*/
            if ( ! pLEDTask->gCurrentlyIndicatingEvent )
            {
                LedsIndicateEvent ( pLEDTask , pEvent ) ;  
            }    
            else
            {
            
                /*hsTaskData * lApp = (hsTaskData *) getAppTask() ;*/

                if (1)/*lApp->features.QueueLEDEvents )*/
                {
             
                        /*try and add it to the queue*/
                    LM_DEBUG(("LM: Queue LED Event [%x]\n" , pEvent )) ;
                
                    if ( pLEDTask->Queue.Event1 == 0)
                    {
                        pLEDTask->Queue.Event1 = ( pEvent - EVENTS_EVENT_BASE) ;
                    }
                    else if ( pLEDTask->Queue.Event2 == 0)
                    {
                        pLEDTask->Queue.Event2 = ( pEvent - EVENTS_EVENT_BASE) ;
                    }
                    else if ( pLEDTask->Queue.Event3 == 0)
                    {
                        pLEDTask->Queue.Event3 = ( pEvent - EVENTS_EVENT_BASE) ;
                    }
                    else if ( pLEDTask->Queue.Event4 == 0)
                    {
                        pLEDTask->Queue.Event4 = ( pEvent - EVENTS_EVENT_BASE) ;
                    }    
                    else
                    {
                        LM_DEBUG(("LM: Err Queue Full!!\n")) ;
                    }
                }    
            }
        }
        else
        {
            LM_DEBUG(("LM: NoEvPatCfg\n")) ;
        }  
        }
    else
    {
        LM_DEBUG(("LM : No IE[%x] disabled\n",pEvent )) ;
    }
    
    /*indicate a filter if there is one present*/
    LedsCheckForFilter ( pLEDTask , pEvent ) ;
}


/*****************************************************************************/
void LEDManagerIndicateState ( LedTaskData * pLEDTask , headsetHfpState pState , headsetA2dpState pA2dpState )  
{   
    uint16 led_state = pState + (HEADSET_NUM_HFP_STATES * pA2dpState);
    
    /* only indicate if LEDs are enabled*/
    if ((pLEDTask->gLEDSEnabled ) ||
        LedsStateCanOverideDisable( pLEDTask , pState , pA2dpState ) ||
        LedActiveFiltersCanOverideDisable( pLEDTask ))
    {
            /*if there is no pattern associated with the sate then do nothing*/
        if ( pLEDTask->gStatePatterns[ led_state ] == NULL )
        {
            LM_DEBUG(("LM: NoStCfg[%x][%x]\n",pState, pA2dpState)) ;
            LedsIndicateNoState ( pLEDTask ) ;
        }
        else
        {
            LM_DEBUG(("LM : IS[%x][%x]\n", pState, pA2dpState)) ;
            LedsIndicateState ( pLEDTask , pState, pA2dpState );
        } 
    }
    else
    {
        LM_DEBUG(("LM : DIS NoStCfg[%x]\n", pState)) ;
        LedsIndicateNoState ( pLEDTask );
    }
}


/*****************************************************************************/
void LedManagerDisableLEDS ( LedTaskData * pTask )
{
    LM_DEBUG(("LM Disable LEDS\n")) ;

    /*turn off all current LED Indications if not overidden by state or filter */
    if (!LedsStateCanOverideDisable(pTask , stateManagerGetHfpState(), stateManagerGetA2dpState()) && !LedActiveFiltersCanOverideDisable(pTask))
    {
        LedsIndicateNoState ( pTask ) ;
    }    
    
    pTask->gLEDSEnabled = FALSE ;
}


/*****************************************************************************/
void LedManagerEnableLEDS ( LedTaskData * pTask )
{
    LM_DEBUG(("LM Enable LEDS\n")) ;
    
    pTask->gLEDSEnabled = TRUE ;
         
    LEDManagerIndicateState ( pTask , stateManagerGetHfpState () , stateManagerGetA2dpState () ) ;    
}


/*****************************************************************************/
void LedManagerToggleLEDS ( LedTaskData * pTask ) 
{
    if ( pTask->gLEDSEnabled )
    {
        LedManagerDisableLEDS ( pTask ) ;        
    }
    else