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