FmTxStatus FM_TX_Init(void)
{
/*FmcStatus fmcStatus = FM_TX_STATUS_SUCCESS;*/
FmTxStatus status = FM_TX_STATUS_SUCCESS;
FmcStatus fmcStatus;
FMC_FUNC_START(("FM_TX_Init"));
FMC_VERIFY_ERR((_fmTxInitState == _FM_TX_INIT_STATE_NOT_INITIALIZED), FM_TX_STATUS_NOT_DE_INITIALIZED,
("FM_TX_Init: Invalid call while FM TX Is not De-Initialized"));
/* Assume failure. If we fail before reaching the end, we will stay in this state */
_fmTxInitState = _FM_TX_INIT_STATE_INIT_FAILED;
/* Init RX & TX common module */
fmcStatus = FMCI_Init();
FMC_VERIFY_FATAL((status == FMC_STATUS_SUCCESS), fmcStatus,
("FM_TX_Init: FMCI_Init Failed (%s)", FMC_DEBUG_FmcStatusStr(fmcStatus)));
/* Init FM TX state machine */
FM_TX_SM_Init();
_fmTxInitState = _FM_TX_INIT_STATE_INITIALIZED;
FMC_LOG_INFO(("FM_TX_Init: FM TX Initialization completed Successfully"));
FMC_FUNC_END();
return status;
}
FmTxStatus FM_TX_Enable(FmTxContext *fmContext)
{
FmTxStatus status;
FmTxEnableCmd *enableCmd = NULL;
FMC_FUNC_START_AND_LOCK(("FM_TX_Enable"));
FMC_VERIFY_ERR((fmContext == FM_TX_SM_GetContext()), FMC_STATUS_INVALID_PARM, ("FM_TX_Enable: Invalid Context Ptr"));
FMC_VERIFY_ERR((FM_TX_SM_GetContextState() == FM_TX_SM_CONTEXT_STATE_DISABLED),
FM_TX_STATUS_CONTEXT_NOT_DISABLED, ("FM_TX_Enable: FM TX Context Is Not Disabled"));
FMC_VERIFY_ERR((FM_TX_SM_IsCmdPending(FM_TX_CMD_ENABLE) == FMC_FALSE), FM_TX_STATUS_IN_PROGRESS,
("FM_TX_Enable: Enabling Already In Progress"));
/* When we are disabled there must not be any pending commands in the queue */
FMC_VERIFY_FATAL((FMC_IsListEmpty(FMCI_GetCmdsQueue()) == FMC_TRUE), FMC_STATUS_INTERNAL_ERROR,
("FM_TX_Enable: Context is Disabled but there are pending command in the queue"));
/*
Direct FM task events to the TX's event handler.
This must be done here (and not in fm_tx_sm.c) since only afterwards
we will be able to send the event the event handler
*/
status = FMCI_SetEventCallback(FM_TX_SM_TaskEventCb);
FMC_VERIFY_FATAL((status == FMC_STATUS_SUCCESS), status,
("FM_TX_Enable: FMCI_SetEventCallback Failed (%s)", FMC_DEBUG_FmcStatusStr(status)));
/* Allocates the command and insert to commands queue */
status = FM_TX_SM_AllocateCmdAndAddToQueue(fmContext, FM_TX_CMD_ENABLE, (FmcBaseCmd**)&enableCmd);
FMC_VERIFY_ERR((status == FMC_STATUS_SUCCESS), status, ("FM_TX_Enable"));
status = FM_TX_STATUS_PENDING;
/* Trigger TX SM to execute the command in FM Task context */
FMCI_NotifyFmTask(FMC_OS_EVENT_GENERAL);
FMC_FUNC_END_AND_UNLOCK();
return status;
}
const char *FMC_DEBUG_FmTxStatusStr(FMC_UINT status)
{
if (status <= FMC_STATUS_LAST)
{
return FMC_DEBUG_FmcStatusStr(status);
}
switch (status)
{
case FM_TX_STATUS_RDS_NOT_ENABLED: return "STATUS_RDS_NOT_ENABLED";
case FM_TX_STATUS_TRANSMITTER_NOT_TUNED: return "STATUS_TRANSMITTER_NOT_TUNED";
case FM_TX_STATUS_TRANSMISSION_IS_NOT_ON: return "STATUS_TRANSMISSION_IS_NOT_ON";
case FM_TX_STATUS_FM_RX_ALREADY_ENABLED: return "STATUS_FM_RX_ALREADY_ENABLED";
case FM_TX_STATUS_AUTO_MODE_NOT_ON: return "STATUS_AUTO_MODE_NOT_ON";
case FM_TX_STATUS_RDS_AUTO_MODE_NOT_ON: return "STATUS_RDS_AUTO_MODE_NOT_ON";
case FM_TX_STATUS_RDS_MANUAL_MODE_NOT_ON: return "STATUS_RDS_MANUAL_MODE_NOT_ON";
case FM_TX_STATUS_CONFLICTING_RDS_CMD_IN_PROGRESS: return "STATUS_CONFLICTING_RDS_CMD_IN_PROGRESS";
case FM_TX_STATUS_AUDIO_OPERATION_UNAVAILIBLE_RESOURCES: return "FM_TX_STATUS_AUDIO_OPERATION_UNAVAILIBLE_RESOURCES";
default: return FMC_UTILS_FormatNumber("INVALID Status:%x", status, tempStr,MAX_FMC_TMP_STR_SIZE);
}
}
FmTxStatus FM_TX_Destroy(FmTxContext **fmContext)
{
FmTxStatus status = FM_TX_STATUS_SUCCESS;
FMC_FUNC_START(("FM_TX_Destroy"));
FMC_VERIFY_ERR((*fmContext == FM_TX_SM_GetContext()), FMC_STATUS_INVALID_PARM, ("FM_TX_Destroy: Invalid Context Ptr"));
FMC_VERIFY_ERR((FM_TX_SM_GetContextState() == FM_TX_SM_CONTEXT_STATE_DISABLED),
FM_TX_STATUS_CONTEXT_NOT_DISABLED, ("FM_TX_Destroy: FM TX Context must be disabled before destroyed"));
status = FM_TX_SM_Destroy(fmContext);
FMC_VERIFY_FATAL((status == FM_TX_STATUS_SUCCESS), status,
("FM_TX_Destroy: FM_TX_SM_Destroy Failed (%s)", FMC_DEBUG_FmcStatusStr(status)));
/* Make sure pointer will not stay dangling */
*fmContext = NULL;
FMC_LOG_INFO(("FM_TX_Destroy: Successfully Destroyed FM TX Context"));
FMC_FUNC_END();
return status;
}
FmTxStatus FM_TX_Create(FmcAppHandle *appHandle, const FmTxCallBack fmCallback, FmTxContext **fmContext)
{
FmTxStatus status = FM_TX_STATUS_SUCCESS;
FMC_FUNC_START(("FM_TX_Create"));
FMC_VERIFY_ERR((appHandle == NULL), FMC_STATUS_NOT_SUPPORTED, ("FM_TX_Create: appHandle Must be null currently"));
FMC_VERIFY_ERR((_fmTxInitState == _FM_TX_INIT_STATE_INITIALIZED), FM_TX_STATUS_NOT_INITIALIZED,
("FM_TX_Create: FM TX Not Initialized"));
FMC_VERIFY_FATAL((FM_TX_SM_GetContextState() == FM_TX_SM_CONTEXT_STATE_DESTROYED),
FM_TX_STATUS_CONTEXT_NOT_DESTROYED, ("FM_TX_Deinit: FM TX Context must first be destoryed"));
status = FM_TX_SM_Create(fmCallback, fmContext);
FMC_VERIFY_FATAL((status == FM_TX_STATUS_SUCCESS), status,
("FM_TX_Create: FM_TX_SM_Create Failed (%s)", FMC_DEBUG_FmcStatusStr(status)));
FMC_LOG_INFO(("FM_TX_Create: Successfully Create FM TX Context"));
FMC_FUNC_END();
return status;
}
