/*===========================================================================
FUNCTION RFLL1X_DISABLE_RX
DESCRIPTION
Disbles a receiver chain. Performs all the necessary activities to minimize
current drawn by the RF chain which has been disabled.
DEPENDENCIES
rfm_init() must have already been called.
rfm_enter_mode() must have already been called.
RETURN VALUE
None.
SIDE EFFECTS
None
===========================================================================*/
void rfll1x_disable_rx
(
rfll_device_desc_type *dev_desc /*lint -e818 Device descriptor
could be declared as const */
)
{
rf_path_state_type tstate;
int dummy_data=1;
/* Disable task switching */
TASKLOCK();
tstate = rf_path_state;
/* Put the path into sleep */
switch (rf_path_state) {
case RF_R0_ONLY_ST:
if( dev_desc->device == RFCOM_TRANSCEIVER_0)
{
/* Disable Primary VCO */
rfc_disable_primary_chain_vco();
rfll1x_sleep(dev_desc, &dummy_data, NULL);
rfll1x_stay_asleep(dev_desc);
tstate = RF_DISABLED_ST;
}
break;
case RF_R1_ONLY_ST:
if( dev_desc->device == RFCOM_RECEIVER_1)
{
/* Disable Secondary VCO */
rfc_disable_secondary_chain_vco();
rfll1x_sleep(dev_desc, &dummy_data, NULL);
rfll1x_stay_asleep(dev_desc);
tstate = RF_DISABLED_ST;
}
break;
case RF_DUAL_ST:
if(dev_desc->device == RFCOM_TRANSCEIVER_0)
{
/* Disable Primary VCO */
rfc_disable_primary_chain_vco();
/* Check if FTM active before this transition */
rfll1x_sleep(dev_desc, &dummy_data, NULL);
rfll1x_stay_asleep(dev_desc);
tstate = RF_R1_ONLY_ST;
}
else if (dev_desc->device == RFCOM_RECEIVER_1)
{
/* Disable Secondary VCO */
rfc_disable_secondary_chain_vco();
rfll1x_sleep(dev_desc, &dummy_data, NULL);
rfll1x_stay_asleep(dev_desc);
tstate = RF_R0_ONLY_ST;
}
break;
case RF_DIVERSITY_ST:
if(dev_desc->device == RFCOM_TRANSCEIVER_0)
{
/* Disable Diversity */
(void) rf_disable_diversity(RFCOM_RECEIVER_DIV);
/* Disable both chains */
rfll1x_sleep(dev_desc, &dummy_data, NULL);
rfll1x_stay_asleep(dev_desc);
rf_sleep_cdma1x(RFCOM_RECEIVER_1);
rf_set_stay_asleep(RFCOM_RECEIVER_1, FALSE );
/* Set Mux to select VCO 1 for Chain 1 */
rfc_select_secondary_vco();
/* Enable secondary chain */
rfc_enable_secondary_chain_vco();
rf_enable_digital_rx_pwr( RFCOM_RECEIVER_1 );
tstate = RF_R1_ONLY_ST;
}
else if (dev_desc->device == RFCOM_RECEIVER_1)
{
/* Set Mux back to select VCO 1 for Chain 1 */
rfc_select_secondary_vco();
/* Disable Secondary VCO */
rfc_disable_secondary_chain_vco();
/* disable diversity chain & sleep chain 1 */
(void) rf_disable_diversity( RFCOM_RECEIVER_DIV );
rfll1x_sleep(dev_desc, &dummy_data, NULL);
rfll1x_stay_asleep(dev_desc);
tstate = RF_R0_ONLY_ST;
}
break;
default:
MSG(MSG_SSID_RF, MSG_LEGACY_ERROR,
"rfll1x_disable_rx, Invalid Device for curr state");
MSG_2(MSG_SSID_RF, MSG_LEGACY_ERROR,
"Device ID: %d, Current State: %d", dev_desc->device, rf_path_state);
break;
}
rf_path_state = tstate;
/* Enable task switching */
TASKFREE();
} /* rfll1x_disable_rx() */
/*===========================================================================
FUNCTION RFLL1X_SLEEP
DESCRIPTION
This function completes transition of RF hardware to sleep state by
turning off the Rx and Tx LDOs.
DEPENDENCIES
rfll1x_sleep() must have already been called.
RETURN VALUE
None
SIDE EFFECTS
None
===========================================================================*/
uint32 rfll1x_sleep //TODO_7600
(
rfll_device_desc_type *dev_desc, /*lint -e818 Device descriptor
could be declared as const */
const void *user_data_ptr, /* Pointer to user data passed into
callback */
rfcom_cb_handler_type cb_handler /* Call back handler or NULL */
)
{
rf_chain_state_type *rf_chain_0 = &rf_chain_status[rfcom_to_path[RFCOM_TRANSCEIVER_0]];
rf_chain_state_type *rf_chain_1 = &rf_chain_status[rfcom_to_path[RFCOM_RECEIVER_1]];
rf_chain_state_type *dev_chain = &rf_chain_status[ rfcom_to_path[dev_desc->device]];
if (user_data_ptr==NULL)
{
// TODO_7600: CDMA 1X flag parameter (FALSE do nothing)
return 0;
}
/* Put RF to sleep */
if( dev_desc->device == RFCOM_RECEIVER_DIV || dev_desc->device == RFCOM_RECEIVER_DUAL)
{
if(rf_chain_0->rf_state == RF_STATE_CDMA_RX)
rf_sleep_cdma1x(RFCOM_TRANSCEIVER_0);
else
MSG_1( MSG_SSID_RF, MSG_LEGACY_ERROR,
"rfll1x_sleep, RF Primary Chain in invalid state: %d",
rf_chain_0->rf_state );
if(rf_chain_1->rf_state == RF_STATE_CDMA_RX ||
#ifndef RF_HAS_BYPASS_RF_STATE_GPS_CHECK
rf_chain_1->rf_state == RF_STATE_GPS ||
#endif
rf_chain_1->rf_state == RF_STATE_DIVERSITY)
rf_sleep_cdma1x(RFCOM_RECEIVER_1);
else
MSG_1( MSG_SSID_RF, MSG_LEGACY_ERROR,
"rfll1x_sleep, RF Secondary Chain in invalid state: %d",
rf_chain_1->rf_state);
}
else if(dev_desc->device == RFCOM_TRANSCEIVER_0)
{
if(dev_chain->rf_state == RF_STATE_CDMA_RXTX)
{
rf_tx_shutdown();
rf_sleep_cdma1x(dev_desc->device);
}
else if(dev_chain->rf_state == RF_STATE_CDMA_RX)
{
rf_sleep_cdma1x(dev_desc->device);
}
else
MSG_2( MSG_SSID_RF, MSG_LEGACY_ERROR,
"rfll1x_sleep, RF Chain:%d in invalid state: %d",
dev_desc->device,dev_chain->rf_state);
}
else
{
if(dev_chain->rf_state == RF_STATE_CDMA_RX)
rf_sleep_cdma1x(dev_desc->device);
else
MSG_2( MSG_SSID_RF, MSG_LEGACY_ERROR,
"rfll1x_sleep, RF Chain:%d in invalid state: %d",
dev_desc->device,dev_chain->rf_state);
}
return 0;
} /* rfll1x_stay_asleep() */
uint32 rfll1x_enable_rx
(
rfll_device_desc_type *dev_desc, /*lint -e818 Device descriptor
could be declared as const */
const void *user_data_ptr, /*lint -esym(715, user_data_ptr), not used */
rfcom_cb_handler_type cb_handler /* Call back handler or NULL */
)
{
rf_path_state_type tstate;
rf_chain_state_type *rf_chain_1;
/* Disable task switching */
TASKLOCK();
#if defined ( RF_HAS_MDSP_TX_AGC ) && !defined ( RF_HAS_QSC60X5 ) && !defined ( RF_HAS_QSC11X0 )
rf_cdma_mdsp_init_tx_agc_settings();
#endif
#ifdef RF_HAS_HDR
#error code not present
#endif /* RF_HAS_HDR */
tstate = rf_path_state;
rf_chain_1 = &rf_chain_status[rfcom_to_path[RFCOM_RECEIVER_1]];
switch (rf_path_state) {
case RF_DISABLED_ST:
if(dev_desc->device == RFCOM_TRANSCEIVER_0)
{
/* Enable primary VCO */
rfc_enable_primary_chain_vco();
rf_enable_digital_rx_pwr( dev_desc->device );
tstate = RF_R0_ONLY_ST;
}
else if (dev_desc->device == RFCOM_RECEIVER_1)
{
/* Set Mux to select VCO 1 for Chain 1 */
rfc_select_secondary_vco();
/* Enable secondary VCO */
rfc_enable_secondary_chain_vco();
rf_enable_digital_rx_pwr( dev_desc->device );
tstate = RF_R1_ONLY_ST;
}
break;
case RF_R0_ONLY_ST:
if(dev_desc->device == RFCOM_RECEIVER_1)
{
/* Set Mux to select VCO 1 for Chain 1 */
rfc_select_secondary_vco();
/* Enable VCO 1 for initial state */
rfc_enable_secondary_chain_vco();
rf_enable_digital_rx_pwr( dev_desc->device );
tstate = RF_DUAL_ST;
}
else if (dev_desc->device == RFCOM_RECEIVER_DIV)
{
/* Select VCO 0 for Chain 1 */
rfc_select_primary_vco();
/* Disable VCO 1 */
rfc_disable_secondary_chain_vco();
/* This requires tuning Rx1 to path 0 synthesizer */
rf_enable_digital_rx_pwr( RFCOM_RECEIVER_DIV);
(void) rf_enable_diversity(RFCOM_RECEIVER_DIV);
tstate = RF_DIVERSITY_ST;
}
else if(dev_desc->device == RFCOM_TRANSCEIVER_0 && ftm_mode == FTM_MODE)
{
rf_enable_digital_rx_pwr( dev_desc->device );
}
break;
case RF_R1_ONLY_ST:
if(dev_desc->device == RFCOM_TRANSCEIVER_0)
{
/* Enable Primary VCO */
rfc_enable_primary_chain_vco();
/* Check if FTM mode is active?? */
rf_enable_digital_rx_pwr( dev_desc->device );
tstate = RF_DUAL_ST;
}
else if(dev_desc->device == RFCOM_RECEIVER_DIV)
{
/* Set Mux to select VCO 0 for Chain 1 */
rfc_select_primary_vco();
/* Enable Primary VCO */
rfc_enable_primary_chain_vco();
/* Disable VCO 1 */
rfc_disable_secondary_chain_vco();
/* Tune the primary chain to where secondary chain was */
(void) rf_init_digital_band_chan(
RFCOM_TRANSCEIVER_0,
rf_chain_1->rf_curr_cdma_band,
rf_chain_1->rf_chan );
rf_complete_warmup();
/* Setup secondary in Diversity*/
(void) rf_enable_diversity(RFCOM_RECEIVER_DIV);
tstate = RF_DIVERSITY_ST;
}
break;
case RF_DUAL_ST:
if(dev_desc->device == RFCOM_RECEIVER_DIV)
{
/* Set Mux to select VCO 0 for Chain 1 */
rfc_select_primary_vco();
/* Disable VCO 1 */
rfc_disable_secondary_chain_vco();
(void) rf_enable_diversity(RFCOM_RECEIVER_DIV);
tstate = RF_DIVERSITY_ST;
}
break;
case RF_DIVERSITY_ST:
if(dev_desc->device == RFCOM_RECEIVER_1)
{
/* Set Mux to select VCO 1 for Chain 1 */
rfc_select_secondary_vco();
/* Enable VCO 1 */
rfc_enable_secondary_chain_vco();
/* Disable Diversity */
(void) rf_disable_diversity(RFCOM_RECEIVER_DIV);
tstate = RF_DUAL_ST;
}
break;
default:
MSG( MSG_SSID_RF, MSG_LEGACY_ERROR,
"rfll1x_enable_rx, Invalid Device for curr state");
MSG_2( MSG_SSID_RF, MSG_LEGACY_ERROR,
"Device ID: %d, Current State: %d", dev_desc->device, rf_path_state);
break;
}
rf_path_state = tstate;
/* Enable task switching */
TASKFREE();
/* the return value is the required delay for complete path enable */
return (uint32) RF_ENABLE_RX_PWR_WAIT;
} /* rfll1x_enable_rx() */
/**
* This function does the logging for algo tuning variables
*
* @param[in] log_buffer Ptr to the buffer to be logged.
* @param[in] log_size logging size in bytes
* @param[in] client_handle_ptr client handle pointer
*
*/
ADSPResult algo_data_log_now(algo_data_logging_t *algo_data_logging_ptr,
int8_t *log_buffer,
uint32_t log_size,
uint32_t client_handle)
{
uint32_t log_buf_size;
uint32_t log_size_used = 0;
int8_t *log_buf_ptr = NULL;
algo_log_client_info_t *algo_log_client_info_ptr = NULL;
if(NULL == (algo_log_client_info_ptr = algo_find_client_info(algo_data_logging_ptr, client_handle)))
{
MSG_1(MSG_SSID_QDSP6, DBG_ERROR_PRIO, "Algo Log: algo client is not found 0x%lx", client_handle);
return ADSP_EFAILED;
}
/* Validate the log size */
if(log_size != algo_log_client_info_ptr->log_size)
{
MSG_2(MSG_SSID_QDSP6, DBG_ERROR_PRIO,
"Algo Log: log size registered %ld is different from log size %ld being logged",
algo_log_client_info_ptr->log_size, log_size);
return ADSP_EFAILED;
}
if(NULL != algo_log_client_info_ptr->log_buf_ptr)
{
log_buf_size = algo_log_client_info_ptr->log_buf_size;
log_size_used = algo_log_client_info_ptr->log_size_used;
log_buf_ptr = algo_log_client_info_ptr->log_buf_ptr;
if((log_size_used + log_size) <= log_buf_size)
{
//dest buffer will have the free space of (log_buf_size-log_size_used)
memscpy(log_buf_ptr + (log_size_used), (log_buf_size - log_size_used), log_buffer,
log_size);
/* Update used log buffer size */
algo_log_client_info_ptr->log_size_used += log_size;
/* If all the log buffer size has been used, do commit the log buffer. */
if(algo_log_client_info_ptr->log_size_used >= (log_buf_size))
{
algo_log_commit_buf(algo_log_client_info_ptr);
}
}
else
{
algo_log_commit_buf(algo_log_client_info_ptr);
//dest buffer will have the free space of (log_buf_size-log_size_used)
/* algo_log_client_info_ptr->log_size_used is reset to 0 inside commit func */
memscpy(log_buf_ptr, log_buf_size, log_buffer, log_size);
/* Update used log buffer size */
algo_log_client_info_ptr->log_size_used += log_size;
}
}
return ADSP_EOK;
}
