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