/**************************************************************************** * * Function Name: void void csl_caph_cfifo_fifo_init(void) * * Description: init CAPH CFIFO fifo address and size * ****************************************************************************/ static void csl_caph_cfifo_fifo_init(void) { UInt16 id, total_fifo_size = 0; CAPH_CFIFO_e chal_fifo; aTrace (LOG_AUDIO_CSL, "csl_caph_cfifo_fifo_init::\n"); for (id = CSL_CAPH_CFIFO_FIFO1; id <= CSL_CAPH_CFIFO_FIFO16; id++) { chal_fifo = csl_caph_cfifo_get_chal_fifo((CSL_CAPH_CFIFO_FIFO_e) id); chal_caph_fifo_clear_register(handle, chal_fifo); chal_caph_cfifo_set_address(handle, chal_fifo, CSL_CFIFO_table[id].address); chal_caph_cfifo_set_size(handle, chal_fifo, CSL_CFIFO_table[id].size); total_fifo_size += CSL_CFIFO_table[id].size; } audio_xassert(total_fifo_size <= CSL_CFIFO_TOTAL_SIZE, total_fifo_size); return; }
static void AUDQUE_MemCpyInterleave(UInt8 *dest, UInt8 *source, UInt8 *source2, UInt32 size, AUDIO_BITS_PER_SAMPLE_t bitPerSample) { UInt32 i = 0; #if 0 UInt32 j = 0; UInt32 step = 0; if (bitPerSample == 16) step = 2; else if (bitPerSample == 32) step = 4; else audio_xassert(0, bitPerSample); while (i < size) { for (j = 0; j < step; j++) *(dest + j) = *(source + j); } /* memcpy(dest, source, step); */ dest = dest + step; for (j = 0; j < step; j++) *(dest + j) = *(source2 + j); /* memcpy(dest, source2, step); */ source2 = source2 + step; source = source + step; dest = dest + step; i++; }
/**************************************************************************** * Function Name: CAPH_DST_STATUS_e csl_caph_switch_getDSTStatus( * CAPH_SWITCH_CHNL_e chal_chnl) * * Description: Get the status of DST fifo of one SWITCH channel * ****************************************************************************/ static CAPH_DST_STATUS_e csl_caph_switch_getDSTStatus( CAPH_SWITCH_CHNL_e chal_chnl) { u8 i = 0; for (i = 0; i < (Int8) CAPH_SWITCH_CHNL_NUM; i++) { if (dstStatusTable[i].chal_chnl == (CAPH_SWITCH_CHNL_e)chal_chnl) return (CAPH_DST_STATUS_e)dstStatusTable[i].dstStatus; } /* Should not run to here.*/ audio_xassert(0, chal_chnl); return CAPH_DST_OK; }
/**************************************************************************** * Function Name: void csl_caph_switch_setDSTStatus( * CAPH_SWITCH_CHNL_e chal_chnl, * CAPH_DST_STATUS_e dstStatus) * * Description: Update the status of DST fifo of one SWITCH channel * ****************************************************************************/ static void csl_caph_switch_setDSTStatus(CAPH_SWITCH_CHNL_e chal_chnl, CAPH_DST_STATUS_e dstStatus) { int i = 0; for (i = 0; i < (Int8) CAPH_SWITCH_CHNL_NUM; i++) { if (dstStatusTable[i].chal_chnl == (CAPH_SWITCH_CHNL_e)chal_chnl) { dstStatusTable[i].dstStatus = (CAPH_DST_STATUS_e)dstStatus; return; } } /* Should not run to here.*/ audio_xassert(0, chal_chnl); return; }
/**************************************************************************** * * Function Name:CSL_CAPH_DMA_CHNL_FIFO_STATUS_e * csl_caph_dma_get_ddrfifo_status(CSL_CAPH_DMA_CHNL_e chnl) * * Description: get the status recorded for a DMA channel * ****************************************************************************/ CSL_CAPH_DMA_CHNL_FIFO_STATUS_e csl_caph_dma_get_ddrfifo_status(CSL_CAPH_DMA_CHNL_e chnl) { switch (dmaCH_ctrl[chnl].eFifoStatus) { case CAPH_READY_NONE: return CSL_CAPH_READY_NONE; case CAPH_READY_LOW: return CSL_CAPH_READY_LOW; case CAPH_READY_HIGH: return CSL_CAPH_READY_HIGH; case CAPH_READY_HIGHLOW: return CSL_CAPH_READY_HIGHLOW; default: audio_xassert(0, dmaCH_ctrl[chnl].eFifoStatus); } return CSL_CAPH_READY_NONE; }
static Boolean AudioCopyPayload(MsgType_t msgType, void *srcDataBuf, UInt32 destBufSize, void *destDataBuf, UInt32 *outDestDataSize, Result_t *outResult) { UInt32 len; audio_xassert(srcDataBuf != NULL, 0); len = RPC_GetMsgPayloadSize(msgType); *outResult = RESULT_OK; *outDestDataSize = len; if (destDataBuf && srcDataBuf && len <= destBufSize) { memcpy(destDataBuf, srcDataBuf, len); return TRUE; } return FALSE; }
void HandleAudioEventReqCb(RPC_Msg_t *pMsg, ResultDataBufHandle_t dataBufHandle, UInt32 userContextData) { aTrace(LOG_AUDIO_DRIVER, "HandleAudioEventRspCb msg=0x%x clientID=%d ", pMsg->msgId, 0); #if defined(FUSE_COMMS_PROCESSOR) RPC_SendAckForRequest(dataBufHandle, 0); if (pMsg->msgId == MSG_AUDIO_CTRL_GENERIC_REQ) { Audio_Params_t *p = (Audio_Params_t *) pMsg->dataBuf; UInt32 val = audio_control_generic(p->param1, p->param2, p->param3, p->param4, p->param5, p->param6); SendAudioRspForRequest(pMsg, MSG_AUDIO_CTRL_GENERIC_RSP, &val); } else if (pMsg->msgId == MSG_AUDIO_CTRL_DSP_REQ) { Audio_Params_t *p = (Audio_Params_t *) pMsg->dataBuf; UInt32 val = audio_control_dsp(p->param1, p->param2, p->param3, p->param4, p->param5, p->param6); SendAudioRspForRequest(pMsg, MSG_AUDIO_CTRL_DSP_RSP, &val); } else if (pMsg->msgId == MSG_AUDIO_COMP_FILTER_REQ) { AudioCompfilter_t *p = (AudioCompfilter_t *) pMsg->dataBuf; UInt32 val = audio_cmf_filter(p); SendAudioRspForRequest(pMsg, MSG_AUDIO_COMP_FILTER_RSP, &val); } else audio_xassert(0, pMsg->msgId); #endif #if defined(CONFIG_BCM_MODEM) RPC_SYSFreeResultDataBuffer(dataBufHandle); #endif }
/**************************************************************************** * * Function Name: Result_t csl_audio_capture_configure * * Description: Configure the CAPH capture * ****************************************************************************/ Result_t csl_audio_capture_configure(AUDIO_SAMPLING_RATE_t sampleRate, AUDIO_NUM_OF_CHANNEL_t numChannels, AUDIO_BITS_PER_SAMPLE_t bitsPerSample, UInt8 *ringBuffer, UInt32 numBlocks, UInt32 blockSize, CSL_AUDCAPTURE_CB csl_audio_capture_cb, UInt32 streamID) { CSL_CAPH_Capture_Drv_t *audDrv = NULL; CSL_CAPH_HWCTRL_STREAM_REGISTER_t stream; unsigned long flags; aTrace (LOG_AUDIO_CSL, "csl_audio_capture_configure::\n"); audDrv = GetCaptureDriverByType(streamID); if (audDrv == NULL) return RESULT_ERROR; /*audDrv->ringBuffer = ringBuffer; audDrv->blockSize = blockSize; audDrv->numBlocks = numBlocks;*/ /* : make sure ringbuffer, numblocks and block size are legal for Rhea */ memset(&stream, 0, sizeof(CSL_CAPH_HWCTRL_STREAM_REGISTER_t)); stream.streamID = (CSL_CAPH_STREAM_e) audDrv->streamID; #if defined(CONFIG_MAP_VOIP) stream.src_sampleRate = AUDIO_SAMPLING_RATE_48000; #else stream.src_sampleRate = sampleRate; #endif stream.snk_sampleRate = sampleRate; /* make it same as source */ stream.chnlNum = numChannels; stream.bitPerSample = bitsPerSample; stream.pBuf = ringBuffer; stream.pBuf2 = NULL; stream.size = numBlocks * blockSize; stream.dmaCB = AUDIO_DMA_CB; if (audDrv->source == CSL_CAPH_DEV_DSP && audDrv->sink == CSL_CAPH_DEV_MEMORY) { aTrace(LOG_AUDIO_CSL, "csl_audio_capture_configure::USB call?" "reset src_sampleRate from %u to 8000.\r\n", stream.src_sampleRate); stream.src_sampleRate = AUDIO_SAMPLING_RATE_8000; } audDrv->pathID = csl_caph_hwctrl_RegisterStream(&stream); if (audDrv->pathID == 0) { audio_xassert(0, audDrv->pathID); return RESULT_ERROR; } audDrv->dmaCH = csl_caph_hwctrl_GetdmaCH(audDrv->pathID); spin_lock_irqsave(&audDrv->configLock, flags); audDrv->dmaCB = csl_audio_capture_cb; spin_unlock_irqrestore(&audDrv->configLock, flags); audDrv->ringBuffer = ringBuffer; audDrv->numBlocks = numBlocks; audDrv->blockSize = blockSize; /* assume everytime it starts, the first 2 buffers will be filled when the interrupt comes, it will start from buffer 2 */ audDrv->blockIndex = 1; return RESULT_OK; }
/**************************************************************************** * * Function Name:CSL_CAPH_SWITCH_STATUS_e csl_caph_switch_config_channel( * CSL_CAPH_SWITCH_CONFIG_t chnl_config) * * Description: configure CAPH switch channel * ****************************************************************************/ CSL_CAPH_SWITCH_STATUS_e csl_caph_switch_config_channel(CSL_CAPH_SWITCH_CONFIG_t chnl_config) { CAPH_SWITCH_CHNL_e chal_chnl = CAPH_SWITCH_CH_VOID; CAPH_DATA_FORMAT_e chal_dataFormat = CAPH_MONO_16BIT; CAPH_SWITCH_TRIGGER_e chal_trig = CAPH_VOID; CAPH_DST_STATUS_e dstStatus = CAPH_DST_OK; CSL_CAPH_SWITCH_STATUS_e status = CSL_CAPH_SWITCH_OWNER; aTrace(LOG_AUDIO_CNTLR, "csl_caph_switch_config_channel:: chnl = 0x%x, srcAddr = " "0x%lx, dstcAddr = 0x%lx, dataFmt = 0x%x, trigger = 0x%x\n", chnl_config.chnl, chnl_config.FIFO_srcAddr, chnl_config.FIFO_dstAddr, chnl_config.dataFmt, chnl_config.trigger); /* Get cHAL Channel */ chal_chnl = csl_caph_switch_get_chalchnl(chnl_config.chnl); /* Select Source for this channel */ chal_caph_switch_select_src(handle, chal_chnl, (UInt16) (chnl_config.FIFO_srcAddr)); /* Add Dst for this channel */ dstStatus = chal_caph_switch_add_dst(handle, chal_chnl, (UInt16) (chnl_config.FIFO_dstAddr)); csl_caph_switch_setDSTStatus(chal_chnl, dstStatus); /* If the DST is already being used by other channels * Do not set the switch channel anymore. */ if (dstStatus != CAPH_DST_OK) { audio_xassert(0, dstStatus); aError("%s::sw %d chal_chnl %d dst 0x%lx used by other sw, dstStatus=%d\n", __func__, chnl_config.chnl, chal_chnl, chnl_config.FIFO_dstAddr, dstStatus); csl_caph_hwctrldump(); chal_caph_switch_free_channel(handle, chal_chnl); status = CSL_CAPH_SWITCH_BORROWER; return status; } /* Set data format */ switch (chnl_config.dataFmt) { case CSL_CAPH_16BIT_MONO: chal_dataFormat = CAPH_MONO_16BIT; break; case CSL_CAPH_16BIT_STEREO: chal_dataFormat = CAPH_STEREO_16BIT; break; case CSL_CAPH_24BIT_MONO: chal_dataFormat = CAPH_MONO_24BIT; break; case CSL_CAPH_24BIT_STEREO: chal_dataFormat = CAPH_STEREO_24BIT; break; default: audio_xassert(0, chnl_config.dataFmt); } chal_caph_switch_set_datafmt(handle, chal_chnl, chal_dataFormat); /* Select the trigger */ chal_trig = chnl_config.trigger; chal_caph_switch_select_trigger(handle, chal_chnl, chal_trig); return status; }
/**************************************************************************** * Function Name: CAPH_SWITCH_CHNL_e csl_caph_switch_get_chalchnl( * CSL_CAPH_SWITCH_CHNL_e chnl) * * Description: get the CHAL SWITCH channel from CSL SWITCH channel * ****************************************************************************/ static CAPH_SWITCH_CHNL_e csl_caph_switch_get_chalchnl( CSL_CAPH_SWITCH_CHNL_e chnl) { CAPH_SWITCH_CHNL_e chal_chnl = CAPH_SWITCH_CH_VOID; switch (chnl) { case CSL_CAPH_SWITCH_NONE: chal_chnl = CAPH_SWITCH_CH_VOID; break; case CSL_CAPH_SWITCH_CH1: chal_chnl = CAPH_SWITCH_CH1; break; case CSL_CAPH_SWITCH_CH2: chal_chnl = CAPH_SWITCH_CH2; break; case CSL_CAPH_SWITCH_CH3: chal_chnl = CAPH_SWITCH_CH3; break; case CSL_CAPH_SWITCH_CH4: chal_chnl = CAPH_SWITCH_CH4; break; case CSL_CAPH_SWITCH_CH5: chal_chnl = CAPH_SWITCH_CH5; break; case CSL_CAPH_SWITCH_CH6: chal_chnl = CAPH_SWITCH_CH6; break; case CSL_CAPH_SWITCH_CH7: chal_chnl = CAPH_SWITCH_CH7; break; case CSL_CAPH_SWITCH_CH8: chal_chnl = CAPH_SWITCH_CH8; break; case CSL_CAPH_SWITCH_CH9: chal_chnl = CAPH_SWITCH_CH9; break; case CSL_CAPH_SWITCH_CH10: chal_chnl = CAPH_SWITCH_CH10; break; case CSL_CAPH_SWITCH_CH11: chal_chnl = CAPH_SWITCH_CH11; break; case CSL_CAPH_SWITCH_CH12: chal_chnl = CAPH_SWITCH_CH12; break; case CSL_CAPH_SWITCH_CH13: chal_chnl = CAPH_SWITCH_CH13; break; case CSL_CAPH_SWITCH_CH14: chal_chnl = CAPH_SWITCH_CH14; break; case CSL_CAPH_SWITCH_CH15: chal_chnl = CAPH_SWITCH_CH15; break; case CSL_CAPH_SWITCH_CH16: chal_chnl = CAPH_SWITCH_CH16; break; default: audio_xassert(0, chnl); }; return chal_chnl; }
/**************************************************************************** * Function Name: CAPH_CFIFO_e csl_caph_cfifo_get_chal_fifo( * CSL_CAPH_CFIFO_FIFO_e csl_fifo) * * Description: get the CHAL CFIFO fifo id from CSL fifo id * ****************************************************************************/ static CAPH_CFIFO_e csl_caph_cfifo_get_chal_fifo(CSL_CAPH_CFIFO_FIFO_e csl_fifo) { CAPH_CFIFO_e chal_fifo = CAPH_CFIFO_VOID; switch (csl_fifo) { case CSL_CAPH_CFIFO_NONE: chal_fifo = CAPH_CFIFO_VOID; break; case CSL_CAPH_CFIFO_FIFO1: chal_fifo = CAPH_CFIFO1; break; case CSL_CAPH_CFIFO_FIFO2: chal_fifo = CAPH_CFIFO2; break; case CSL_CAPH_CFIFO_FIFO3: chal_fifo = CAPH_CFIFO3; break; case CSL_CAPH_CFIFO_FIFO4: chal_fifo = CAPH_CFIFO4; break; case CSL_CAPH_CFIFO_FIFO5: chal_fifo = CAPH_CFIFO5; break; case CSL_CAPH_CFIFO_FIFO6: chal_fifo = CAPH_CFIFO6; break; case CSL_CAPH_CFIFO_FIFO7: chal_fifo = CAPH_CFIFO7; break; case CSL_CAPH_CFIFO_FIFO8: chal_fifo = CAPH_CFIFO8; break; case CSL_CAPH_CFIFO_FIFO9: chal_fifo = CAPH_CFIFO9; break; case CSL_CAPH_CFIFO_FIFO10: chal_fifo = CAPH_CFIFO10; break; case CSL_CAPH_CFIFO_FIFO11: chal_fifo = CAPH_CFIFO11; break; case CSL_CAPH_CFIFO_FIFO12: chal_fifo = CAPH_CFIFO12; break; case CSL_CAPH_CFIFO_FIFO13: chal_fifo = CAPH_CFIFO13; break; case CSL_CAPH_CFIFO_FIFO14: chal_fifo = CAPH_CFIFO14; break; case CSL_CAPH_CFIFO_FIFO15: chal_fifo = CAPH_CFIFO15; break; case CSL_CAPH_CFIFO_FIFO16: chal_fifo = CAPH_CFIFO16; break; default: audio_xassert(0, csl_fifo); break; }; return chal_fifo; }
/**************************************************************************** * Function Name: CSL_CAPH_DMA_CHNL_e csl_caph_dma_get_csl_chnl( * CAPH_DMA_CHANNEL_e chal_chnl) * * Description: get the CSL DMA ch from CHAL DMA ch * ****************************************************************************/ static CSL_CAPH_DMA_CHNL_e csl_caph_dma_get_csl_chnl(CAPH_DMA_CHANNEL_e chal_chnl) { CSL_CAPH_DMA_CHNL_e csl_chnl = CSL_CAPH_DMA_NONE; switch (chal_chnl) { case CAPH_DMA_CH_VOID: csl_chnl = CSL_CAPH_DMA_NONE; break; case CAPH_DMA_CH1: csl_chnl = CSL_CAPH_DMA_CH1; break; case CAPH_DMA_CH2: csl_chnl = CSL_CAPH_DMA_CH2; break; case CAPH_DMA_CH3: csl_chnl = CSL_CAPH_DMA_CH3; break; case CAPH_DMA_CH4: csl_chnl = CSL_CAPH_DMA_CH4; break; case CAPH_DMA_CH5: csl_chnl = CSL_CAPH_DMA_CH5; break; case CAPH_DMA_CH6: csl_chnl = CSL_CAPH_DMA_CH6; break; case CAPH_DMA_CH7: csl_chnl = CSL_CAPH_DMA_CH7; break; case CAPH_DMA_CH8: csl_chnl = CSL_CAPH_DMA_CH8; break; case CAPH_DMA_CH9: csl_chnl = CSL_CAPH_DMA_CH9; break; case CAPH_DMA_CH10: csl_chnl = CSL_CAPH_DMA_CH10; break; case CAPH_DMA_CH11: csl_chnl = CSL_CAPH_DMA_CH11; break; case CAPH_DMA_CH12: csl_chnl = CSL_CAPH_DMA_CH12; break; case CAPH_DMA_CH13: csl_chnl = CSL_CAPH_DMA_CH13; break; case CAPH_DMA_CH14: csl_chnl = CSL_CAPH_DMA_CH14; break; case CAPH_DMA_CH15: csl_chnl = CSL_CAPH_DMA_CH15; break; case CAPH_DMA_CH16: csl_chnl = CSL_CAPH_DMA_CH16; break; default: audio_xassert(0, chal_chnl); break; }; return csl_chnl; }
/**************************************************************************** * * Function Name: Result_t csl_audio_render_configure * * Description: Configure the CAPH render * ****************************************************************************/ Result_t csl_audio_render_configure(AUDIO_SAMPLING_RATE_t sampleRate, AUDIO_NUM_OF_CHANNEL_t numChannels, AUDIO_BITS_PER_SAMPLE_t bitsPerSample, UInt8 *ringBuffer, UInt32 numBlocks, UInt32 blockSize, CSL_AUDRENDER_CB csl_audio_render_cb, UInt32 streamID, int mixMode) { CSL_CAPH_Render_Drv_t *audDrv = NULL; CSL_CAPH_HWCTRL_STREAM_REGISTER_t stream; #ifdef DSP_FPGA_TEST AP_SharedMem_t *pSharedMem = SHAREDMEM_GetDsp_SharedMemPtr(); #endif aTrace(LOG_AUDIO_CSL, "csl_caph_render_configure:: streamID = 0x%lx, sampleRate =0x%x," "numChannels = 0x%x, numbBuffers = 0x%lx, blockSize = 0x%lx," "bitsPerSample %d, cb = %lx.\r\n", streamID, sampleRate, numChannels, numBlocks, blockSize, (int)bitsPerSample, (long unsigned int)csl_audio_render_cb); audDrv = GetRenderDriverByType(streamID); if (audDrv == NULL) return RESULT_ERROR; audDrv->dmaCB = csl_audio_render_cb; /*audDrv->numChannels = numChannels; audDrv->bitsPerSample = bitsPerSample; audDrv->sampleRate = sampleRate;*/ #ifdef DSP_FPGA_TEST if (audDrv->source == CSL_CAPH_DEV_DSP) ringBuffer = (UInt8 *) (&(((AP_SharedMem_t *) pSharedMem)-> shared_aud_out_buf_48k[0][0])); #endif /* make sure ringbuffer, numblocks and block size */ /* are legal for Rhea */ memset(&stream, 0, sizeof(CSL_CAPH_HWCTRL_STREAM_REGISTER_t)); stream.streamID = (CSL_CAPH_STREAM_e) audDrv->streamID; stream.src_sampleRate = sampleRate; /* stream.snk_sampleRate = sampleRate; */ stream.chnlNum = numChannels; stream.bitPerSample = bitsPerSample; stream.pBuf = ringBuffer; stream.pBuf2 = NULL; stream.size = numBlocks * blockSize; stream.dmaCB = AUDIO_DMA_CB; stream.mixMode = mixMode; audDrv->pathID = csl_caph_hwctrl_RegisterStream(&stream); if (audDrv->pathID == 0) { audio_xassert(0, audDrv->pathID); return RESULT_ERROR; } audDrv->dmaCH = csl_caph_hwctrl_GetdmaCH(audDrv->pathID); if (stream.size >= 0x10000 && audDrv->dmaCH > CSL_CAPH_DMA_CH2) { csl_caph_hwctrl_SetLongDma(audDrv->pathID); audDrv->dmaCH = csl_caph_hwctrl_GetdmaCH(audDrv->pathID); } audDrv->ringBuffer = ringBuffer; audDrv->numBlocks = numBlocks; audDrv->blockSize = blockSize; /* assume everytime it starts, the first 2 buffers will be filled when the interrupt comes, it will start from buffer 2 */ audDrv->readyBlockIndex = 0; audDrv->blockIndex = 1; return RESULT_OK; }