/****************************************************************************
NAME
configManagerLEDS
DESCRIPTION
Read the system LED configuration from persistent store and configure
the LEDS
RETURNS
void
*/
static void configManagerLEDS( void )
{
/* 1. LED state configuration */
/* Providing there are states to configure */
if((theSink.theLEDTask->gStatePatternsAllocated > 0) && (theSink.theLEDTask->gStatePatternsAllocated < SINK_NUM_STATES))
{
ConfigRetrieve(theSink.config_id , PSKEY_LED_STATES, &theSink.theLEDTask->gStatePatterns, theSink.theLEDTask->gStatePatternsAllocated * sizeof(LEDPattern_t));
}
/* 2. LED event configuration */
/* Providing there are events to configure */
if((theSink.theLEDTask->gEventPatternsAllocated > 0) && (theSink.theLEDTask->gEventPatternsAllocated < EVENTS_MAX_EVENTS))
{
ConfigRetrieve(theSink.config_id , PSKEY_LED_EVENTS, &theSink.theLEDTask->gEventPatterns, theSink.theLEDTask->gEventPatternsAllocated * sizeof(LEDPattern_t));
}
/* 3. LED event filter configuration */
/* Providing there are states to configure */
if((theSink.theLEDTask->gLMNumFiltersUsed > 0) && (theSink.theLEDTask->gLMNumFiltersUsed < LM_NUM_FILTER_EVENTS))
{
/* read from ps straight into filter config structure */
ConfigRetrieve(theSink.config_id , PSKEY_LED_FILTERS, &theSink.theLEDTask->gEventFilters, theSink.theLEDTask->gLMNumFiltersUsed * sizeof(LEDFilter_t));
}
/*tri colour behaviour*/
ConfigRetrieve(theSink.config_id , PSKEY_TRI_COL_LEDS, &theSink.theLEDTask->gTriColLeds, sizeof(uint16)) ;
DEBUG(("CONF: TRICOL [%x][%x][%x]\n" , theSink.theLEDTask->gTriColLeds.TriCol_a ,
theSink.theLEDTask->gTriColLeds.TriCol_b ,
theSink.theLEDTask->gTriColLeds.TriCol_c )) ;
}
/****************************************************************************
NAME
configManagerTimeouts
DESCRIPTION
Read and configure the automatic switch off time if the range allows
Also now handles the power on timeout
RETURNS
void
*/
static void configManagerConfiguration ( uint16 pConfigID )
{
ConfigRetrieve(pConfigID , PSKEY_PIO_BLOCK, theHeadset.PIO, sizeof(PIO_block_t));
ConfigRetrieve(pConfigID , PSKEY_INPUT_PIO_BLOCK, &theHeadset.conf->input_PIO, sizeof(input_pio_config_type));
ConfigRetrieve(pConfigID , PSKEY_TIMEOUTS, (void*)&theHeadset.conf->timeouts, sizeof(Timeouts_t) ) ;
ConfigRetrieve(pConfigID , PSKEY_RSSI_PAIRING, (void*)&theHeadset.conf->rssi, sizeof(rssi_pairing_t) ) ;
ConfigRetrieve(pConfigID , PSKEY_FILTER, (void*)&theHeadset.conf->filter, sizeof(filter_t) ) ;
}
void configManagerReadFmData(void)
{
/* determine size of data required by fm library */
int lSize = (sizeof(fm_rx_data_t) + FMRX_MAX_BUFFER_SIZE);
/*allocate the memory*/
theSink.conf2->sink_fm_data.fm_plugin_data = mallocPanic( lSize );
/* initialise structure */
memset(theSink.conf2->sink_fm_data.fm_plugin_data, 0, lSize);
/* get the FM config from pskey */
ConfigRetrieve(theSink.config_id, PSKEY_FM_CONFIG, &theSink.conf2->sink_fm_data.fm_plugin_data->config, sizeof(fm_rx_config));
/* get the FM stored freq from pskey */
ConfigRetrieve(theSink.config_id, PSKEY_FM_FREQUENCY_STORE, &theSink.conf2->sink_fm_data.fmStoredFreq, sizeof(fm_stored_freq));
}
/****************************************************************************
NAME
sinkDialStoredNumber
DESCRIPTION
Dials a number stored in CONFIG_PHONE_NUMBER
If HFP and connected - issues command
If HFP and not connected - connects and issues if not in call
If HSP sends button press
RETURNS
void
*/
void sinkDialStoredNumber ( void )
{
uint16 ret_len;
Sink sink;
uint16 phone_number_key[SIZE_CONFIG_PHONE_NUMBER];
CM_DEBUG(("sinkDialStoredNumber\n")) ;
if ((ret_len = ConfigRetrieve(CONFIG_PHONE_NUMBER, phone_number_key, SIZE_CONFIG_PHONE_NUMBER )))
{
if((HfpLinkGetSlcSink(hfp_primary_link, &sink)) && SinkIsValid(sink))
{
/* Send the dial request now */
CM_DEBUG(("CM:Dial Stored Number (Connected) len=%x\n",ret_len)) ;
HfpDialNumberRequest(hfp_primary_link, ret_len, (uint8 *)&phone_number_key[0]);
}
else
{
/* Not connected, connect and queue the dial request */
#ifdef ENABLE_AVRCP
sinkAvrcpCheckManualConnectReset(NULL);
#endif
MessageSend ( &theSink.task , EventUsrEstablishSLC , 0 ) ;
sinkQueueEvent( EventUsrDialStoredNumber ) ;
}
}
else
{
/*The PSKEY could not be read*/
MessageSend(&theSink.task, EventUsrUpdateStoredNumber, 0);
}
}
static void configManagerVoicePromptsInit( uint16 no_vp , uint16 no_tts_languages )
{
#ifdef CSR_VOICE_PROMPTS
/* check the number of events configured and the supported tts languages */
if(no_vp)
{
/* Read in the PSKEY that tells us where the prompt header is */
if(ConfigRetrieve(theSink.config_id , PSKEY_VOICE_PROMPTS, &theSink.conf4->vp_init_params, sizeof(vp_config_type)))
{
#ifdef TEXT_TO_SPEECH_LANGUAGESELECTION
theSink.no_tts_languages = no_tts_languages;
#ifdef ENABLE_SQIFVP
/* Initilaise as no partitions currently mounted */
theSink.rundata->partitions_mounted = 0;
configManagerSqifPartitionsInit( );
#endif
#endif
/* Pass configuration to the voice prompts plugin */
TTSConfigureVoicePrompts(no_vp);
}
}
#endif /* CSR_VOICE_PROMPTS */
}
/****************************************************************************
NAME
configManagerUserDefinedTones
DESCRIPTION
Attempt to read the user configured tones, if data exists it will be in the following format:
uint16 offset in array to user tone 1,
uint16 offset in array to user tone ....,
uint16 offset in array to user tone 8,
uint16[] user tone data
To play a particular tone it can be access via gVariableTones, e.g. to access tone 1
theSink.audioData.gConfigTones->gVariableTones[0] + (uint16)*theSink.audioData.gConfigTones->gVariableTones[0]
or to access tone 2
theSink.audioData.gConfigTones->gVariableTones[0] + (uint16)*theSink.audioData.gConfigTones->gVariableTones[1]
and so on
RETURNS
void
*/
static void configManagerUserDefinedTones( uint16 KeyLength )
{
/* if the keyLength is zero there are no user tones so don't malloc any memory */
if(KeyLength)
{
/* malloc only enough memory to hold the configured tone data */
uint16 * configTone = mallocPanic(KeyLength * sizeof(uint16));
/* retrieve pskey data up to predetermined max size */
uint16 size_ps_key = ConfigRetrieve( theSink.config_id, PSKEY_CONFIG_TONES , configTone , KeyLength );
CONF_DEBUG(("Co : Configurable Tones Malloc size [%x]\n", KeyLength )) ;
/* is there any configurable tone data, if present update pointer to tone data */
if (size_ps_key)
{
/* the data is in the form of 8 x uint16 audio note start offsets followed by the
up to 8 lots of tone data */
theSink.conf1->gConfigTones.gVariableTones = (ringtone_note*)&configTone[0];
}
/* no user configured tone data is available, so free previous malloc as not in use */
else
{
/* no need to waste memory */
freePanic(configTone);
}
}
/* no tone data available, ensure data pointer is null */
else
{
theSink.conf1->gConfigTones.gVariableTones = NULL;
}
}
/****************************************************************************
NAME
configManagerButtonPatterns
DESCRIPTION
Read and configure any buttonpattern matches that exist
RETURNS
*/
static void configManagerButtonPatterns( void )
{
/* Allocate enough memory to hold event configuration */
button_pattern_config_type* config = (button_pattern_config_type*) mallocPanic(BM_NUM_BUTTON_MATCH_PATTERNS * sizeof(button_pattern_config_type));
CONF_DEBUG(("Co: No Button Patterns - %d\n", BM_NUM_BUTTON_MATCH_PATTERNS));
/* Now read in event configuration */
if(config)
{
if(ConfigRetrieve(theSink.config_id , PSKEY_BUTTON_PATTERN_CONFIG, config, BM_NUM_BUTTON_MATCH_PATTERNS * sizeof(button_pattern_config_type)))
{
uint16 n;
/* Now we have the event configuration, map required events to system events */
for(n = 0; n < BM_NUM_BUTTON_MATCH_PATTERNS ; n++)
{
CONF_DEBUG(("Co : AddPattern Ev[%x]\n", config[n].event )) ;
/* Map PIO button event to system events in specified states */
buttonManagerAddPatternMapping ( theSink.theButtonsTask , config[n].event , config[n].pattern, n ) ;
}
}
else
{
CONF_DEBUG(("Co: !EvLen\n")) ;
}
freePanic(config) ;
}
}
/****************************************************************************
NAME
configManagerHFP_SupportedFeatures
DESCRIPTION
Gets the HFP Supported features set from PS
RETURNS
void
*/
void configManagerHFP_SupportedFeatures( void )
{
uint16 lConfigID = get_config_id ( PSKEY_CONFIGURATION_ID ) ;
ConfigRetrieve( lConfigID , PSKEY_ADDITIONAL_HFP_SUPPORTED_FEATURES , &theHeadset.HFP_supp_features , sizeof( HFP_features_type ) ) ;
if ( ! theHeadset.HFP_supp_features.HFP_Version )
{
/*then set the defaults*/
theHeadset.HFP_supp_features.HFP_Version = headset_hfp_version_1_0 ;
theHeadset.HFP_supp_features.supportedSyncPacketTypes = (sync_hv1 | sync_hv2 | sync_hv3) ;
}
else
{
/*make sure the mask we have read in is within range*/
uint16 lAllPktTypes = ( sync_hv1 | sync_hv2 | sync_hv3 |
sync_ev3 | sync_ev4 | sync_ev5 |
sync_2ev3 | sync_3ev3 | sync_2ev5 | sync_3ev5 ) ;
uint16 lPSPktTypes = theHeadset.HFP_supp_features.supportedSyncPacketTypes ;
CONF_DEBUG(("CONF: Feat[%x]&[%x] = [%x]\n" , lAllPktTypes , lPSPktTypes , (lAllPktTypes & lPSPktTypes) )) ;
theHeadset.HFP_supp_features.supportedSyncPacketTypes = (lAllPktTypes & lPSPktTypes) ;
}
}
/*************************************************************************
NAME
ConfigManagerSetupSsr
DESCRIPTION
This function attempts to retreive SSR parameters from the PS, setting
them to zero if none are found
RETURNS
*/
static void configManagerSetupSsr( void )
{
CONF_DEBUG(("CO: SSR\n")) ;
/* Get the SSR params from the PS/Config */
ConfigRetrieve(theSink.config_id , PSKEY_SSR_PARAMS, &theSink.conf2->ssr_data, sizeof(subrate_t));
}
/****************************************************************************
NAME
configManagerButtonDurations
DESCRIPTION
Read the button configuration from persistent store and configure
the button durations
RETURNS
void
*/
static void configManagerButtonDurations( void )
{
if(ConfigRetrieve(theSink.config_id , PSKEY_BUTTON_CONFIG, &theSink.conf1->buttons_duration, sizeof(button_config_type)))
{
/*buttonmanager keeps buttons block*/
buttonManagerConfigDurations ( theSink.theButtonsTask , &theSink.conf1->buttons_duration );
}
}
/****************************************************************************
NAME
configManagerButtonDurations
DESCRIPTION
Read the button configuration from persistent store and configure
the button durations
RETURNS
void
*/
static void configManagerButtonDurations( uint16 pConfigID )
{
if(ConfigRetrieve(pConfigID , PSKEY_BUTTON_CONFIG, theHeadset.buttons_duration, sizeof(button_config_type)))
{
/*buttonmanager keeps buttons block*/
buttonManagerConfigDurations ( theHeadset.theButtonsTask , theHeadset.buttons_duration );
}
}
/****************************************************************************
NAME
configManagerPower
DESCRIPTION
Read the Power Manager configuration
RETURNS
void
*/
static void configManagerPower( uint16 pConfigID )
{
/* 1. Read in the battery monitoring configuration */
ConfigRetrieve(pConfigID , PSKEY_BATTERY_CONFIG, (void*)&((theHeadset.conf->power).battery_config), sizeof(power_config_type) ) ;
/* 2. Setup the power manager */
powerManagerConfig(&theHeadset.conf->power);
}
static void configManagerButtons( void )
{
/* Allocate enough memory to hold event configuration */
event_config_type* configA = (event_config_type*) mallocPanic(BM_EVENTS_PER_PS_BLOCK * sizeof(event_config_type));
event_config_type* configB = (event_config_type*) mallocPanic(BM_EVENTS_PER_PS_BLOCK * sizeof(event_config_type));
event_config_type* configC = (event_config_type*) mallocPanic(BM_EVENTS_PER_PS_BLOCK * sizeof(event_config_type));
uint16 n;
uint8 i = 0;
ConfigRetrieve(theSink.config_id , PSKEY_EVENTS_A, configA, BM_EVENTS_PER_PS_BLOCK * sizeof(event_config_type)) ;
ConfigRetrieve(theSink.config_id , PSKEY_EVENTS_B, configB, BM_EVENTS_PER_PS_BLOCK * sizeof(event_config_type)) ;
ConfigRetrieve(theSink.config_id , PSKEY_EVENTS_C, configC, BM_EVENTS_PER_PS_BLOCK * sizeof(event_config_type)) ;
/* Now we have the event configuration, map required events to system events */
for(n = 0; n < BM_EVENTS_PER_PS_BLOCK; n++)
{
CONF_DEBUG(("Co : AddMap indexes [%u,%u] Ev[%x][%x][%x]\n", n, i, configA[n].event , configB[n].event, configC[n].event )) ;
/* check to see if a valid pio mask is present, this includes the upper 2 bits of the state
info as these are being used for bc5 as vreg enable and charger detect */
if ( (configA[n].pio_mask)||(configA[n].state_mask & 0xC000))
buttonManagerAddMapping ( &configA[n], i++ );
if ( (configB[n].pio_mask)||(configB[n].state_mask & 0xC000))
buttonManagerAddMapping ( &configB[n], i++ );
if ( (configC[n].pio_mask)||(configC[n].state_mask & 0xC000))
buttonManagerAddMapping ( &configC[n], i++ );
}
freePanic(configA) ;
freePanic(configB) ;
freePanic(configC) ;
/* perform an initial pio check to see if any pio changes need processing following the completion
of the configuration ps key reading */
BMCheckButtonsAfterReadingConfig();
}
static void configManagerRadio( uint16 pConfigID )
{
if(!ConfigRetrieve(pConfigID , PSKEY_RADIO_CONFIG, theHeadset.radio, sizeof(radio_config_type)))
{
/* Assume HCI defaults */
theHeadset.radio->page_scan_interval = HCI_PAGESCAN_INTERVAL_DEFAULT;
theHeadset.radio->page_scan_window = HCI_PAGESCAN_WINDOW_DEFAULT;
theHeadset.radio->inquiry_scan_interval = HCI_INQUIRYSCAN_INTERVAL_DEFAULT;
theHeadset.radio->inquiry_scan_interval = HCI_INQUIRYSCAN_WINDOW_DEFAULT;
}
}
static void configManagerRadio( void )
{
if(!ConfigRetrieve(theSink.config_id , PSKEY_RADIO_CONFIG, &theSink.conf2->radio, sizeof(radio_config_type)))
{
/* Assume HCI defaults */
theSink.conf2->radio.page_scan_interval = HCI_PAGESCAN_INTERVAL_DEFAULT;
theSink.conf2->radio.page_scan_window = HCI_PAGESCAN_WINDOW_DEFAULT;
theSink.conf2->radio.inquiry_scan_interval = HCI_INQUIRYSCAN_INTERVAL_DEFAULT;
theSink.conf2->radio.inquiry_scan_window = HCI_INQUIRYSCAN_WINDOW_DEFAULT;
}
}
/*************************************************************************
NAME
ConfigManagerSetupSsr
DESCRIPTION
This function attempts to retreive SSR parameters from the PS, setting
them to zero if none are found
RETURNS
*/
static void configManagerSetupSsr( uint16 pConfigID )
{
CONF_DEBUG(("CO: SSR\n")) ;
/* Get the SSR params from the PS/Config if there */
if(!ConfigRetrieve(pConfigID , PSKEY_SSR_PARAMS, theHeadset.ssr_data, sizeof(subrate_t)))
{
CONF_DEBUG(("CO: SSR Defaults\n")) ;
/* If we failed to read in params then set the pointer to NULL */
theHeadset.ssr_data = NULL;
}
}
/****************************************************************************
NAME
configManagerEventTone
DESCRIPTION
Configure an event tone only if one is defined
RETURNS
void
*/
static void configManagerEventTones( uint16 no_tones )
{
/* First read the number of events configured */
if(no_tones)
{
/* Now read in tones configuration */
if(ConfigRetrieve(theSink.config_id , PSKEY_TONES, &theSink.conf2->gEventTones, no_tones * sizeof(tone_config_type)))
{
/*set the last tone (empty) - used by the play tone routine to identify the last tone*/
theSink.conf2->gEventTones[no_tones].tone = TONE_NOT_DEFINED ;
}
}
}
/****************************************************************************
NAME
configManagerPower
DESCRIPTION
Read the Power Manager configuration
RETURNS
void
*/
static void configManagerPower( void )
{
sink_power_config power;
/* Read in the battery monitoring configuration */
ConfigRetrieve(theSink.config_id , PSKEY_BATTERY_CONFIG, (void*)&power, sizeof(sink_power_config) ) ;
/* Store power settings */
theSink.conf1->power = power.settings;
/* Setup the power manager */
powerManagerConfig(&power.config);
}
/****************************************************************************
NAME
configManagerEventTTSPhrases
DESCRIPTION
Configure an event tts phrase only if one is defined
RETURNS
void
*/
static void configManagerEventTTSPhrases( uint16 no_tts )
{
#ifdef TEXT_TO_SPEECH_PHRASES
/* check the number of events configured */
if(no_tts)
{
/* Now read in TTS configuration */
ConfigRetrieve(theSink.config_id , PSKEY_TTS, &theSink.conf4->gEventTTSPhrases, no_tts * sizeof(tts_config_type));
/* Terminate the list */
theSink.conf4->gEventTTSPhrases[no_tts].tts_id = TTS_NOT_DEFINED;
}
#endif
}
/****************************************************************************
NAME
configManagerFeatureBlock
DESCRIPTION
Read the system feature block and configure system accordingly
RETURNS
void
*/
static void configManagerFeatureBlock( uint16 pConfigID )
{
uint8 i;
/* Read the feature block from persistent store */
ConfigRetrieve(pConfigID , PSKEY_FEATURE_BLOCK, &theHeadset.features, sizeof(feature_config_type)) ;
/*Set the default volume level*/
for(i=0;i<MAX_PROFILES;i++)
{
theHeadset.profile_data[i].audio.gSMVolumeLevel = theHeadset.features.DefaultVolume ;
}
}
/****************************************************************************
NAME
configManagerKeyLengths
DESCRIPTION
Read the lengths of ps keys for tts, tone and led configuration
RETURNS
void
*/
static void configManagerKeyLengths( lengths_config_type * pLengths )
{
ConfigRetrieve(theSink.config_id , PSKEY_LENGTHS, pLengths, sizeof(lengths_config_type));
DEBUG(("CONF: LENGTHS [%x][%x][%x][%x][%x][%x]\n" , pLengths->no_tts,
pLengths->no_tts_languages,
pLengths->no_led_filter,
pLengths->no_led_states,
pLengths->no_led_events,
pLengths->no_tones )) ;
/* Set led lengths straight away */
theSink.theLEDTask->gStatePatternsAllocated = pLengths->no_led_states;
theSink.theLEDTask->gEventPatternsAllocated = pLengths->no_led_events;
theSink.theLEDTask->gLMNumFiltersUsed = pLengths->no_led_filter;
theSink.rundata->defrag = pLengths->defrag;
}
/****************************************************************************
NAME
configManagerKeyLengths
DESCRIPTION
Read the lengths of ps keys for tts, tone and led configuration
RETURNS
void
*/
static void configManagerKeyLengths(uint16 configID, lengths_config_type * pLengths )
{
ConfigRetrieve(configID , PSKEY_LENGTHS, pLengths, sizeof(lengths_config_type));
DEBUG(("CONF: LENGTHS [%x][%x][%x][%x][%x][%x]\n" , pLengths->no_tts,
pLengths->no_tts_languages,
pLengths->no_led_filter,
pLengths->no_led_states,
pLengths->no_led_events,
pLengths->no_tones )) ;
#ifdef ROM_LEDS
/* Set led lengths straight away */
theHeadset.theLEDTask->gStatePatternsAllocated = pLengths->no_led_states;
theHeadset.theLEDTask->gEventPatternsAllocated = pLengths->no_led_events;
theHeadset.theLEDTask->gLMNumFiltersUsed = pLengths->no_led_filter;
#endif
}
/****************************************************************************
NAME
configManagerButtonPatterns
DESCRIPTION
Read and configure any buttonpattern matches that exist
RETURNS
*/
static void configManagerButtonPatterns( uint16 pConfigID )
{
/* Allocate enough memory to hold event configuration */
button_pattern_config_type* config = (button_pattern_config_type*) mallocPanic(BM_NUM_BUTTON_MATCH_PATTERNS * sizeof(button_pattern_config_type));
CONF_DEBUG(("Co: No Button Patterns - %d\n", BM_NUM_BUTTON_MATCH_PATTERNS));
/* Now read in event configuration */
if(config)
{
if(ConfigRetrieve(pConfigID , PSKEY_BUTTON_PATTERN_CONFIG, config, BM_NUM_BUTTON_MATCH_PATTERNS * sizeof(button_pattern_config_type)))
{
uint16 n;
/* Now we have the event configuration, map required events to system events */
for(n = 0; n < BM_NUM_BUTTON_MATCH_PATTERNS ; n++)
{
CONF_DEBUG(("Co : AddPattern Ev[%x]\n", config[n].event )) ;
#ifdef BHC612
if(n == 0)
{
config[0].event = 0x6000;
config[0].pattern[0] = 2;/*Vol - */
config[0].pattern[1] = 4;/*Talk*/
config[0].pattern[2] = 1;/*Vol +*/
config[0].pattern[3] = 6;/*Vol - & Talk*/
config[0].pattern[4] = 5;/*Vol + & Talk*/
config[0].pattern[5] = 2;/*Vol -*/
}
#endif
/* Map PIO button event to system events in specified states */
buttonManagerAddPatternMapping ( theHeadset.theButtonsTask , config[n].event , config[n].pattern, n ) ;
}
}
else
{
CONF_DEBUG(("Co: !EvLen\n")) ;
}
free (config) ;
}
}
/****************************************************************************
NAME
configManagerPioMap
DESCRIPTION
Read PIO config and map in configured PIOs.
RETURNS
void
*/
void configManagerPioMap(void)
{
pio_config_type* pio;
/* Allocate memory for Button data, volume mapping */
theSink.conf1 = mallocPanic( sizeof(config_block1_t) );
memset(theSink.conf1, 0, sizeof (config_block1_t));
CONF_DEBUG(("INIT: Malloc size 1: [%d]\n",sizeof(config_block1_t)));
/* Retrieve config */
pio = &theSink.conf1->PIOIO;
ConfigRetrieve(theSink.config_id , PSKEY_PIO_BLOCK, pio, sizeof(pio_config_type));
/* Make sure all references to mic parameters point to the right place */
theSink.cvc_params.digital = &pio->digital;
/* Map in any required pins */
CONF_DEBUG(("INIT: Map PIO 0x%lX\n", pio->pio_map));
PioSetMapPins32(pio->pio_map,pio->pio_map);
}
/****************************************************************************
NAME
configManagerReadSessionData
*/
static void configManagerReadSessionData( void )
{
session_data_type lTemp ;
/*read in the volume orientation*/
ConfigRetrieve( theSink.config_id , PSKEY_VOLUME_ORIENTATION , &lTemp , sizeof( session_data_type ) ) ;
theSink.VolumeOrientationIsInverted = lTemp.vol_orientation ;
/* if the feature bit to reset led disable state after a reboot is set then enable the leds
otherwise get the led enable state from ps */
if(!theSink.features.ResetLEDEnableStateAfterReset)
{
theSink.theLEDTask->gLEDSEnabled = lTemp.led_disable ;
}
else
{
theSink.theLEDTask->gLEDSEnabled = TRUE;
}
theSink.tts_language = lTemp.tts_language;
theSink.tts_enabled = lTemp.tts_enable;
theSink.iir_enabled = lTemp.iir_enable;
theSink.lbipmEnable = lTemp.lbipm_enable;
theSink.ssr_enabled = lTemp.ssr_enabled;
theSink.a2dp_link_data->a2dp_audio_mode_params.music_mode_processing = lTemp.eq;
configManagerEnableMultipoint(lTemp.multipoint_enable);
theSink.a2dp_link_data->a2dp_audio_mode_params.music_mode_processing = (A2DP_MUSIC_PROCESSING_FULL_SET_EQ_BANK0 + (lTemp.audio_enhancements & A2DP_MUSIC_CONFIG_USER_EQ_SELECT));
theSink.a2dp_link_data->a2dp_audio_mode_params.music_mode_enhancements = (lTemp.audio_enhancements & ~A2DP_MUSIC_CONFIG_USER_EQ_SELECT);
#ifdef ENABLE_FM
theSink.conf2->sink_fm_data.fmRxTunedFreq = lTemp.fm_frequency;
#endif
CONF_DEBUG(("CONF : Rd Vol Inverted [%c], LED Disable [%c], Multipoint Enable [%c], IIR Enable [%c], LBIPM Enable [%c] EQ[%x]\n", theSink.VolumeOrientationIsInverted ? 'T':'F' ,
lTemp.led_disable ? 'T':'F' ,
theSink.MultipointEnable ? 'T':'F',
theSink.iir_enabled ? 'T':'F',
theSink.lbipmEnable ? 'T':'F',
theSink.a2dp_link_data->a2dp_audio_mode_params.music_mode_processing)) ;
}
void sinkGattHidRcConfigRemote(uint16 rc_lookup_sie)
{
#ifdef DEBUG_GATT_HID_RC
uint16 i;
#endif
if(!rc_lookup_sie)
{
/* No RC lookup table exists, there's nothing the RC task can do without the lookup table, return */
return;
}
/* Allocate enough memory to extract the configured BLE HID lookup table (can be of max size 16 entries) */
GATT_HID_RC.rc_lookup_size = rc_lookup_sie;
GATT_HID_RC_DEBUG(("GattHIDRc: RC Config: Malloc size for RC Config: [%d]\n", ((sizeof(gattHidRcConfig_t) - sizeof(gattHidRcLookupTable_t)) + (GATT_HID_RC.rc_lookup_size * sizeof(gattHidRcLookupTable_t))) ));
GATT_HID_RC.config = mallocPanic( ((sizeof(gattHidRcConfig_t) - sizeof(gattHidRcLookupTable_t)) + (GATT_HID_RC.rc_lookup_size * sizeof(gattHidRcLookupTable_t))) );
/* If there is enough memory available for a look up table, then get it */
if (GATT_HID_RC.config)
{
ConfigRetrieve(CONFIG_BLE_REMOTE_CONTROL, GATT_HID_RC.config, ((sizeof(gattHidRcConfig_t) - sizeof(gattHidRcLookupTable_t)) + (GATT_HID_RC.rc_lookup_size * sizeof(gattHidRcLookupTable_t))) );
#ifdef DEBUG_GATT_HID_RC
/* Print the lookup table in a readable format for debugging purposes */
GATT_HID_RC_DEBUG(("GattHIDRc: RC Config : Max RC[%d], Lookup Size[%d]:\n", GATT_HID_RC.config->max_remotes, GATT_HID_RC.rc_lookup_size));
for (i=0; i<GATT_HID_RC.rc_lookup_size; i++)
{
GATT_HID_RC_DEBUG(("GattHIDRc: RC Config: [0x%x]->[0x%03x]\n", GATT_HID_RC.config->lookup_table[i].input_id, GATT_HID_RC.config->lookup_table[i].hid_code));
}
#endif
}
else
{
/* Set look up size as zero, without config memory and data , RC task can not work */
GATT_HID_RC.rc_lookup_size = 0;
GATT_HID_RC_DEBUG(("GattHIDRc: Memory for RC config is not available \n"));
}
}
/****************************************************************************
NAME
configManagerEventTone
DESCRIPTION
Configure an event tts phrase only if one is defined
RETURNS
void
*/
static void configManagerEventTTSPhrases( uint16 pConfigID , uint16 no_tts )
{
#ifdef TEXT_TO_SPEECH_PHRASES
/* cheack the number of events configured and the supported tts languages */
if(no_tts)
{
tts_config_type * config;
/* Allocate enough memory to hold event configuration */
config = (tts_config_type *) mallocPanic((no_tts + 1) * sizeof(tts_config_type));
if (config)
{
/* Now read in tones configuration */
if(ConfigRetrieve(pConfigID , PSKEY_TTS, config, no_tts * sizeof(tts_config_type)))
{
theHeadset.audioData.gEventTTSPhrases = (HeadsetTts_t*)config;
theHeadset.audioData.gEventTTSPhrases[no_tts].tts_id = TTS_NOT_DEFINED;
}
}
}
#endif
}
static void configManagerVoicePromptsInit( uint16 pConfigID , uint16 no_vp , uint16 no_tts_languages )
{
#ifdef CSR_VOICE_PROMPTS
/* cheack the number of events configured and the supported tts languages */
if(no_vp)
{
vp_config_type * config = NULL;
uint16 size_vp_config = sizeof(vp_config_type);
/* Allocate enough memory to hold event configuration */
config = (vp_config_type *) mallocPanic(size_vp_config);
if (config)
{
/* Read in the PSKEY that tells us where the prompt header is */
if(ConfigRetrieve(pConfigID , PSKEY_VOICE_PROMPTS, config, size_vp_config))
{
TTSConfigureVoicePrompts(no_vp, config, no_tts_languages);
}
}
}
#endif /* CSR_VOICE_PROMPTS */
}
/****************************************************************************
NAME
configManagerHFP_Init
DESCRIPTION
Gets the HFP initialisation parameters from PS
RETURNS
void
*/
void configManagerHFP_Init( hfp_init_params * hfp_params )
{
ConfigRetrieve( theSink.config_id , PSKEY_HFP_INIT , hfp_params , sizeof( hfp_init_params ) ) ;
}
/****************************************************************************
NAME
configManagerHFP_SupportedFeatures
DESCRIPTION
Gets the HFP Supported features set from PS
RETURNS
void
*/
void configManagerHFP_SupportedFeatures( void )
{
ConfigRetrieve( theSink.config_id , PSKEY_ADDITIONAL_HFP_SUPPORTED_FEATURES , &theSink.HFP_supp_features , sizeof( HFP_features_type ) ) ;
}
