static int sun7i_pcm_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct sun7i_runtime_data *prtd = runtime->private_data;
struct snd_soc_pcm_runtime *rtd = substream->private_data;
unsigned long totbytes = params_buffer_bytes(params);
struct sun7i_dma_params *dma =
snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
if (!dma)
return 0;
if (prtd->params == NULL) {
prtd->params = dma;
/*
* requeset audio dma handle(we don't care about the channel!)
*/
prtd->dma_hdl = sw_dma_request(prtd->params->name, CHAN_DEDICATE);
if (NULL == prtd->dma_hdl) {
printk(KERN_ERR "failed to request spdif dma handle\n");
return -EINVAL;
}
}
/*
* set callback
*/
memset(&prtd->play_done_cb, 0, sizeof(prtd->play_done_cb));
prtd->play_done_cb.func = sun7i_audio_buffdone;
prtd->play_done_cb.parg = substream;
/*use the full buffer callback, maybe we should use the half buffer callback?*/
if (0 != sw_dma_ctl(prtd->dma_hdl, DMA_OP_SET_FD_CB, (void *)&(prtd->play_done_cb))) {
printk(KERN_ERR "failed to set dma buffer done!!!\n");
sw_dma_release(prtd->dma_hdl);
return -EINVAL;
}
snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
runtime->dma_bytes = totbytes;
spin_lock_irq(&prtd->lock);
prtd->dma_loaded = 0;
prtd->dma_limit = runtime->hw.periods_min;
prtd->dma_period = params_period_bytes(params);
prtd->dma_start = runtime->dma_addr;
prtd->dma_pos = prtd->dma_start;
prtd->dma_end = prtd->dma_start + totbytes;
spin_unlock_irq(&prtd->lock);
return 0;
}
static int sun4i_pcm_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params)
{
struct snd_pcm_runtime *runtime = substream->runtime;
struct sun4i_runtime_data *prtd = runtime->private_data;
struct snd_soc_pcm_runtime *rtd = substream->private_data;
unsigned long totbytes = params_buffer_bytes(params);
struct sun4i_dma_params *dma =
snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
int ret = 0;
if (!dma)
return 0;
if (prtd->params == NULL) {
prtd->params = dma;
ret = sw_dma_request(prtd->params->channel,
prtd->params->client, NULL);
if (ret < 0) {
return ret;
}
}
sw_dma_set_buffdone_fn(prtd->params->channel,
sun4i_audio_buffdone);
snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
runtime->dma_bytes = totbytes;
spin_lock_irq(&prtd->lock);
prtd->dma_loaded = 0;
prtd->dma_limit = runtime->hw.periods_min;
prtd->dma_period = params_period_bytes(params);
prtd->dma_start = runtime->dma_addr;
prtd->dma_pos = prtd->dma_start;
prtd->dma_end = prtd->dma_start + totbytes;
spin_unlock_irq(&prtd->lock);
return 0;
}
/**
* __dtc_chain_conti_mode - dma test case for DTC_CHAIN_CONTI_MOD
*
* Returns 0 if success, the err line number if failed.
*/
u32 __dtc_chain_conti_mode(void)
{
u32 uret = 0;
void *src_vaddr = NULL, *dst_vaddr = NULL;
u32 usrc_paddr = 0, udst_paddr = 0;
dm_hdl_t dma_hdl = (dm_hdl_t)NULL;
struct dma_cb_t done_cb;
struct dma_op_cb_t op_cb;
struct dma_config_t dma_config;
pr_info("%s enter\n", __func__);
/* prepare the buffer and data */
src_vaddr = dma_alloc_coherent(NULL, DTC_TOTAL_LEN, (dma_addr_t *)&usrc_paddr, GFP_KERNEL);
if(NULL == src_vaddr) {
uret = __LINE__;
goto end;
}
pr_info("%s: src_vaddr 0x%08x, usrc_paddr 0x%08x\n", __func__, (u32)src_vaddr, usrc_paddr);
dst_vaddr = dma_alloc_coherent(NULL, DTC_TOTAL_LEN, (dma_addr_t *)&udst_paddr, GFP_KERNEL);
if(NULL == dst_vaddr) {
uret = __LINE__;
goto end;
}
pr_info("%s: dst_vaddr 0x%08x, udst_paddr 0x%08x\n", __func__, (u32)dst_vaddr, udst_paddr);
get_random_bytes(src_vaddr, DTC_TOTAL_LEN);
memset(dst_vaddr, 0x54, DTC_TOTAL_LEN);
atomic_set(&g_acur_cnt, 0);
g_src_addr = usrc_paddr;
g_dst_addr = udst_paddr;
dma_hdl = sw_dma_request("m2m_dma", DMA_WORK_MODE_CHAIN);
if(NULL == dma_hdl) {
uret = __LINE__;
goto end;
}
pr_info("%s: sw_dma_request success, dma_hdl 0x%08x\n", __func__, (u32)dma_hdl);
/* set callback */
memset(&done_cb, 0, sizeof(done_cb));
memset(&op_cb, 0, sizeof(op_cb));
done_cb.func = __cb_qd_conti_mode;
done_cb.parg = NULL;
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_SET_QD_CB, (void *)&done_cb)) {
uret = __LINE__;
goto end;
}
pr_info("%s: set queuedone_cb success\n", __func__);
done_cb.func = __cb_fd_conti_mode;
done_cb.parg = NULL;
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_SET_FD_CB, (void *)&done_cb)) {
uret = __LINE__;
goto end;
}
pr_info("%s: set fulldone_cb success\n", __func__);
done_cb.func = __cb_hd_conti_mode;
done_cb.parg = NULL;
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_SET_HD_CB, (void *)&done_cb)) {
uret = __LINE__;
goto end;
}
pr_info("%s: set halfdone_cb success\n", __func__);
op_cb.func = __cb_op_conti_mode;
op_cb.parg = NULL;
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_SET_OP_CB, (void *)&op_cb)) {
uret = __LINE__;
goto end;
}
pr_info("%s: set op_cb success\n", __func__);
memset(&dma_config, 0, sizeof(dma_config));
dma_config.xfer_type = DMAXFER_D_BWORD_S_BWORD;
dma_config.address_type = DMAADDRT_D_LN_S_LN;
dma_config.para = 0;
dma_config.irq_spt = CHAN_IRQ_HD | CHAN_IRQ_FD | CHAN_IRQ_QD;
dma_config.src_addr = usrc_paddr;
dma_config.dst_addr = udst_paddr;
//dma_config.byte_cnt = DTC_ONE_LEN;
dma_config.byte_cnt = DTC_TOTAL_LEN; /* only enqueue one buf */
dma_config.bconti_mode = true;
dma_config.src_drq_type = DRQSRC_SDRAM;
dma_config.dst_drq_type = DRQDST_SDRAM;
if(0 != sw_dma_config(dma_hdl, &dma_config, ENQUE_PHASE_NORMAL)) {
uret = __LINE__;
goto end;
}
pr_info("%s: sw_dma_config success\n", __func__);
sw_dma_dump_chan(dma_hdl);
/* start dma */
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_START, NULL)) {
uret = __LINE__;
goto end;
}
/* let callback go on enqueueing... */
msleep(8000);
/* check if data ok */
if(0 == memcmp(src_vaddr, dst_vaddr, DTC_TOTAL_LEN))
pr_info("%s: data check ok!\n", __func__);
else {
pr_err("%s: data check err!\n", __func__);
uret = __LINE__; /* return err */
goto end;
}
/* stop and free dma channel */
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_STOP, NULL)) {
uret = __LINE__;
goto end;
}
pr_info("%s: sw_dma_stop success\n", __func__);
if(0 != sw_dma_release(dma_hdl)) {
uret = __LINE__;
goto end;
}
dma_hdl = (dm_hdl_t)NULL;
pr_info("%s: sw_dma_release success\n", __func__);
end:
if(0 != uret)
pr_err("%s err, line %d!\n", __func__, uret);
else
pr_info("%s, success!\n", __func__);
if((dm_hdl_t)NULL != dma_hdl) {
pr_err("%s, stop and release dma handle now!\n", __func__);
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_STOP, NULL))
pr_err("%s err, line %d!\n", __func__, __LINE__);
if(0 != sw_dma_release(dma_hdl))
pr_err("%s err, line %d!\n", __func__, __LINE__);
}
if(NULL != src_vaddr)
dma_free_coherent(NULL, DTC_TOTAL_LEN, src_vaddr, usrc_paddr);
if(NULL != dst_vaddr)
dma_free_coherent(NULL, DTC_TOTAL_LEN, dst_vaddr, udst_paddr);
pr_info("%s, end!\n", __func__);
return uret;
}
/**
* __dtc_many_enq - dma test case for DTC_1TM2M_MANY_ENQ
*
* Returns 0 if success, the err line number if failed.
*/
u32 __dtc_many_enq(void)
{
u32 uret = 0;
void *src_vaddr = NULL, *dst_vaddr = NULL;
u32 usrc_paddr = 0, udst_paddr = 0;
dm_hdl_t dma_hdl = (dm_hdl_t)NULL;
struct dma_cb_t done_cb;
struct dma_op_cb_t op_cb;
struct dma_config_t dma_config;
pr_info("%s enter\n", __func__);
src_vaddr = dma_alloc_coherent(NULL, DTC_TOTAL_LEN, (dma_addr_t *)&usrc_paddr, GFP_KERNEL);
if(NULL == src_vaddr) {
uret = __LINE__;
goto end;
}
pr_info("%s: src_vaddr 0x%08x, usrc_paddr 0x%08x\n", __func__, (u32)src_vaddr, usrc_paddr);
dst_vaddr = dma_alloc_coherent(NULL, DTC_TOTAL_LEN, (dma_addr_t *)&udst_paddr, GFP_KERNEL);
if(NULL == dst_vaddr) {
uret = __LINE__;
goto end;
}
pr_info("%s: dst_vaddr 0x%08x, udst_paddr 0x%08x\n", __func__, (u32)dst_vaddr, udst_paddr);
get_random_bytes(src_vaddr, DTC_TOTAL_LEN);
memset(dst_vaddr, 0x54, DTC_TOTAL_LEN);
atomic_set(&g_acur_cnt, 0);
g_src_addr = usrc_paddr;
g_dst_addr = udst_paddr;
dma_hdl = sw_dma_request("m2m_dma", DMA_WORK_MODE_CHAIN);
if(NULL == dma_hdl) {
uret = __LINE__;
goto end;
}
pr_info("%s: sw_dma_request success, dma_hdl 0x%08x\n", __func__, (u32)dma_hdl);
/* set callback */
memset(&done_cb, 0, sizeof(done_cb));
memset(&op_cb, 0, sizeof(op_cb));
done_cb.func = __cb_qd_many_enq;
done_cb.parg = NULL;
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_SET_QD_CB, (void *)&done_cb)) {
uret = __LINE__;
goto end;
}
pr_info("%s: set queuedone_cb success\n", __func__);
done_cb.func = __cb_fd_many_enq;
done_cb.parg = NULL;
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_SET_FD_CB, (void *)&done_cb)) {
uret = __LINE__;
goto end;
}
pr_info("%s: set fulldone_cb success\n", __func__);
done_cb.func = __cb_hd_many_enq;
done_cb.parg = NULL;
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_SET_HD_CB, (void *)&done_cb)) {
uret = __LINE__;
goto end;
}
pr_info("%s: set halfdone_cb success\n", __func__);
op_cb.func = __cb_op_many_enq;
op_cb.parg = NULL;
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_SET_OP_CB, (void *)&op_cb)) {
uret = __LINE__;
goto end;
}
pr_info("%s: set op_cb success\n", __func__);
memset(&dma_config, 0, sizeof(dma_config));
dma_config.xfer_type = DMAXFER_D_BWORD_S_BWORD;
dma_config.address_type = DMAADDRT_D_LN_S_LN;
dma_config.para = 0;
dma_config.irq_spt = CHAN_IRQ_HD | CHAN_IRQ_FD | CHAN_IRQ_QD;
dma_config.src_addr = usrc_paddr;
dma_config.dst_addr = udst_paddr;
dma_config.byte_cnt = DTC_ONE_LEN;
dma_config.bconti_mode = false;
dma_config.src_drq_type = DRQSRC_SDRAM;
dma_config.dst_drq_type = DRQDST_SDRAM;
if(0 != sw_dma_config(dma_hdl, &dma_config, ENQUE_PHASE_NORMAL)) {
uret = __LINE__;
goto end;
}
pr_info("%s: sw_dma_config success\n", __func__);
sw_dma_dump_chan(dma_hdl);
/* start dma */
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_START, NULL)) {
uret = __LINE__;
goto end;
}
/* normal enqueue and callback enqueue simutanously */
{
u32 ucur_cnt = 0, ucur_saddr = 0, ucur_daddr = 0;
u32 uloop_cnt = DTC_TOTAL_LEN / DTC_ONE_LEN;
while((ucur_cnt = atomic_add_return(1, &g_acur_cnt)) < uloop_cnt) {
pr_info("%s, line %d, ucur_cnt %d\n", __func__, __LINE__, ucur_cnt);
ucur_saddr = g_src_addr + ucur_cnt * DTC_ONE_LEN;
ucur_daddr = g_dst_addr + ucur_cnt * DTC_ONE_LEN;
if(0 != sw_dma_enqueue(dma_hdl, ucur_saddr, ucur_daddr, DTC_ONE_LEN, ENQUE_PHASE_NORMAL))
printk("%s err, line %d\n", __func__, __LINE__);
/* in order to meet cb/normal enqueue simutanously */
msleep(0);
}
}
pr_info("%s, line %d\n", __func__, __LINE__);
__waitdone_many_enq();
if(0 == memcmp(src_vaddr, dst_vaddr, DTC_TOTAL_LEN))
pr_info("%s: data check ok!\n", __func__);
else {
pr_err("%s: data check err!\n", __func__);
uret = __LINE__; /* return err */
goto end;
}
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_STOP, NULL)) {
uret = __LINE__;
goto end;
}
pr_info("%s: sw_dma_stop success\n", __func__);
if(0 != sw_dma_release(dma_hdl)) {
uret = __LINE__;
goto end;
}
dma_hdl = (dm_hdl_t)NULL;
pr_info("%s: sw_dma_release success\n", __func__);
end:
if(0 != uret)
pr_err("%s err, line %d!\n", __func__, uret);
else
pr_info("%s, success!\n", __func__);
if((dm_hdl_t)NULL != dma_hdl) {
pr_err("%s, stop and release dma handle now!\n", __func__);
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_STOP, NULL))
pr_err("%s err, line %d!\n", __func__, __LINE__);
if(0 != sw_dma_release(dma_hdl))
pr_err("%s err, line %d!\n", __func__, __LINE__);
}
if(NULL != src_vaddr)
dma_free_coherent(NULL, DTC_TOTAL_LEN, src_vaddr, usrc_paddr);
if(NULL != dst_vaddr)
dma_free_coherent(NULL, DTC_TOTAL_LEN, dst_vaddr, udst_paddr);
pr_info("%s end!\n", __func__);
return uret;
}
u32 __dtc_stopcmd(void)
{
u32 uret = 0;
u32 i = 0;
void *src_vaddr = NULL, *dst_vaddr = NULL;
u32 usrc_paddr = 0, udst_paddr = 0;
dm_hdl_t dma_hdl = (dm_hdl_t)NULL;
struct dma_cb_t done_cb;
struct dma_op_cb_t op_cb;
struct dma_config_t dma_config;
pr_info("%s enter\n", __func__);
src_vaddr = dma_alloc_coherent(NULL, DTC_TOTAL_LEN, (dma_addr_t *)&usrc_paddr, GFP_KERNEL);
if(NULL == src_vaddr) {
uret = __LINE__;
goto end;
}
pr_info("%s: src_vaddr 0x%08x, usrc_paddr 0x%08x\n", __func__, (u32)src_vaddr, usrc_paddr);
dst_vaddr = dma_alloc_coherent(NULL, DTC_TOTAL_LEN, (dma_addr_t *)&udst_paddr, GFP_KERNEL);
if(NULL == dst_vaddr) {
uret = __LINE__;
goto end;
}
pr_info("%s: dst_vaddr 0x%08x, udst_paddr 0x%08x\n", __func__, (u32)dst_vaddr, udst_paddr);
get_random_bytes(src_vaddr, DTC_TOTAL_LEN);
memset(dst_vaddr, 0x54, DTC_TOTAL_LEN);
atomic_set(&g_acur_cnt, 0);
g_src_addr = usrc_paddr;
g_dst_addr = udst_paddr;
dma_hdl = sw_dma_request("case_stp_dma", DMA_WORK_MODE_CHAIN);
//dma_hdl = sw_dma_request("case_stp_dma", DMA_WORK_MODE_SINGLE);
if(NULL == dma_hdl) {
uret = __LINE__;
goto end;
}
pr_info("%s: sw_dma_request success, dma_hdl 0x%08x\n", __func__, (u32)dma_hdl);
/* set callback */
memset(&done_cb, 0, sizeof(done_cb));
memset(&op_cb, 0, sizeof(op_cb));
done_cb.func = __cb_qd_stopcmd;
done_cb.parg = NULL;
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_SET_QD_CB, (void *)&done_cb)) {
uret = __LINE__;
goto end;
}
pr_info("%s: set queuedone_cb success\n", __func__);
done_cb.func = __cb_fd_stopcmd;
done_cb.parg = NULL;
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_SET_FD_CB, (void *)&done_cb)) {
uret = __LINE__;
goto end;
}
pr_info("%s: set fulldone_cb success\n", __func__);
done_cb.func = __cb_hd_stopcmd;
done_cb.parg = NULL;
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_SET_HD_CB, (void *)&done_cb)) {
uret = __LINE__;
goto end;
}
pr_info("%s: set halfdone_cb success\n", __func__);
op_cb.func = __cb_op_stopcmd;
op_cb.parg = NULL;
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_SET_OP_CB, (void *)&op_cb)) {
uret = __LINE__;
goto end;
}
pr_info("%s: set op_cb success\n", __func__);
memset(&dma_config, 0, sizeof(dma_config));
dma_config.src_drq_type = DRQSRC_SDRAM;
dma_config.dst_drq_type = DRQDST_SDRAM;
dma_config.bconti_mode = false; /* must be 0, otherwise irq will come again and again */
dma_config.xfer_type = DMAXFER_D_BWORD_S_BWORD;
dma_config.address_type = DMAADDRT_D_LN_S_LN; /* change with dma type */
dma_config.irq_spt = CHAN_IRQ_HD | CHAN_IRQ_FD | CHAN_IRQ_QD;
dma_config.src_addr = usrc_paddr;
dma_config.dst_addr = udst_paddr;
dma_config.byte_cnt = DTC_ONE_LEN;
dma_config.para = 0; /* to check here */
if(0 != sw_dma_config(dma_hdl, &dma_config, ENQUE_PHASE_NORMAL)) {
uret = __LINE__;
goto end;
}
pr_info("%s: sw_dma_config success\n", __func__);
atomic_set(&g_adma_done, 0);
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_START, NULL)) {
uret = __LINE__;
goto end;
}
pr_info("%s: sw_dma_start success\n", __func__);
/* callback enqueue and normal enqueue simutanously */
i = 0;
while(i++ < 100) {
u32 ucur_saddr = 0, ucur_daddr = 0;
u32 uindex = 0;
get_random_bytes(&uindex, sizeof(uindex));
uindex %= (DTC_TOTAL_LEN / DTC_ONE_LEN);
ucur_saddr = g_src_addr + uindex * DTC_ONE_LEN;
ucur_daddr = g_dst_addr + uindex * DTC_ONE_LEN;
if(0 != sw_dma_enqueue(dma_hdl, ucur_saddr, ucur_daddr, DTC_ONE_LEN, ENQUE_PHASE_NORMAL)) {
uret = __LINE__;
goto end;
}
if(0 != sw_dma_enqueue(dma_hdl, ucur_saddr, ucur_daddr, DTC_ONE_LEN, ENQUE_PHASE_NORMAL)) {
uret = __LINE__;
goto end;
}
if(0 != sw_dma_enqueue(dma_hdl, ucur_saddr, ucur_daddr, DTC_ONE_LEN, ENQUE_PHASE_NORMAL)) {
uret = __LINE__;
goto end;
}
if(0 != sw_dma_enqueue(dma_hdl, ucur_saddr, ucur_daddr, DTC_ONE_LEN, ENQUE_PHASE_NORMAL)) {
uret = __LINE__;
goto end;
}
if(0 != sw_dma_enqueue(dma_hdl, ucur_saddr, ucur_daddr, DTC_ONE_LEN, ENQUE_PHASE_NORMAL)) {
uret = __LINE__;
goto end;
}
if(0 != sw_dma_enqueue(dma_hdl, ucur_saddr, ucur_daddr, DTC_ONE_LEN, ENQUE_PHASE_NORMAL)) {
uret = __LINE__;
goto end;
}
if(0 != sw_dma_enqueue(dma_hdl, ucur_saddr, ucur_daddr, DTC_ONE_LEN, ENQUE_PHASE_NORMAL)) {
uret = __LINE__;
goto end;
}
}
#if 0
if(0 != __waitdone_stopcmd()) {
uret = __LINE__;
goto end;
}
pr_info("%s: __waitdone_stopcmd sucess\n", __func__);
#endif
sw_dma_dump_chan(dma_hdl);
/* stop and release dma channel */
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_STOP, NULL)) {
uret = __LINE__;
goto end;
}
pr_info("%s: sw_dma_stop success\n", __func__);
if(0 != sw_dma_release(dma_hdl)) {
uret = __LINE__;
goto end;
}
dma_hdl = (dm_hdl_t)NULL;
pr_info("%s: sw_dma_release success\n", __func__);
/* check if data ok */
if(0 == memcmp(src_vaddr, dst_vaddr, DTC_TOTAL_LEN))
pr_info("%s: data check ok!\n", __func__);
else {
pr_err("%s: data check err!\n", __func__);
//uret = __LINE__; /* we donnot need data ok, just test stop cmd */
}
end:
if(0 != uret)
pr_err("%s err, line %d!\n", __func__, uret);
else
pr_info("%s success!\n", __func__);
if((dm_hdl_t)NULL != dma_hdl) {
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_STOP, NULL))
pr_err("%s err, line %d!\n", __func__, __LINE__);
if(0 != sw_dma_release(dma_hdl))
pr_err("%s err, line %d!\n", __func__, __LINE__);
}
if(NULL != src_vaddr)
dma_free_coherent(NULL, DTC_TOTAL_LEN, src_vaddr, usrc_paddr);
if(NULL != dst_vaddr)
dma_free_coherent(NULL, DTC_TOTAL_LEN, dst_vaddr, udst_paddr);
return uret;
}
u32 __dtc_case_enq_aftdone(void)
{
u32 uret = 0;
u32 i = 0;
void *src_vaddr = NULL, *dst_vaddr = NULL;
u32 src_paddr = 0, dst_paddr = 0;
dm_hdl_t dma_hdl = (dm_hdl_t)NULL;
struct dma_cb_t done_cb;
struct dma_op_cb_t op_cb;
struct dma_config_t dma_config;
pr_info("%s enter\n", __func__);
/* prepare the buffer and data */
src_vaddr = dma_alloc_coherent(NULL, DTC_TOTAL_LEN, (dma_addr_t *)&src_paddr, GFP_KERNEL);
if(NULL == src_vaddr) {
uret = __LINE__;
goto end;
}
pr_info("%s: src_vaddr 0x%08x, src_paddr 0x%08x\n", __func__, (u32)src_vaddr, src_paddr);
dst_vaddr = dma_alloc_coherent(NULL, DTC_TOTAL_LEN, (dma_addr_t *)&dst_paddr, GFP_KERNEL);
if(NULL == dst_vaddr) {
uret = __LINE__;
goto end;
}
pr_info("%s: dst_vaddr 0x%08x, dst_paddr 0x%08x\n", __func__, (u32)dst_vaddr, dst_paddr);
/* init src buffer */
get_random_bytes(src_vaddr, DTC_TOTAL_LEN);
memset(dst_vaddr, 0x54, DTC_TOTAL_LEN);
/* init loop para */
atomic_set(&g_acur_cnt, 0);
g_src_addr = src_paddr;
g_dst_addr = dst_paddr;
/* request dma channel */
dma_hdl = sw_dma_request("m2m_dma", DMA_WORK_MODE_CHAIN);
if(NULL == dma_hdl) {
uret = __LINE__;
goto end;
}
pr_info("%s: sw_dma_request success, dma_hdl 0x%08x\n", __func__, (u32)dma_hdl);
/* set callback */
memset(&done_cb, 0, sizeof(done_cb));
memset(&op_cb, 0, sizeof(op_cb));
done_cb.func = __cb_qd_case_enq_aftdone;
done_cb.parg = NULL;
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_SET_QD_CB, (void *)&done_cb)) {
uret = __LINE__;
goto end;
}
pr_info("%s: set queuedone_cb success\n", __func__);
done_cb.func = __cb_fd_case_enq_aftdone;
done_cb.parg = NULL;
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_SET_FD_CB, (void *)&done_cb)) {
uret = __LINE__;
goto end;
}
pr_info("%s: set fulldone_cb success\n", __func__);
done_cb.func = __cb_hd_case_enq_aftdone;
done_cb.parg = NULL;
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_SET_HD_CB, (void *)&done_cb)) {
uret = __LINE__;
goto end;
}
pr_info("%s: set halfdone_cb success\n", __func__);
op_cb.func = __cb_op_case_enq_aftdone;
op_cb.parg = NULL;
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_SET_OP_CB, (void *)&op_cb)) {
uret = __LINE__;
goto end;
}
pr_info("%s: set op_cb success\n", __func__);
/* enqueue buffer */
memset(&dma_config, 0, sizeof(dma_config));
dma_config.src_drq_type = DRQSRC_SDRAM;
dma_config.dst_drq_type = DRQDST_SDRAM;
//dma_config.conti_mode = 1;
dma_config.bconti_mode = false; /* must be 0, otherwise irq will come again and again */
dma_config.xfer_type = DMAXFER_D_BWORD_S_BWORD;
dma_config.address_type = DMAADDRT_D_LN_S_LN; /* change with dma type */
dma_config.irq_spt = CHAN_IRQ_HD | CHAN_IRQ_FD | CHAN_IRQ_QD;
dma_config.src_addr = src_paddr;
dma_config.dst_addr = dst_paddr;
dma_config.byte_cnt = DTC_ONE_LEN;
dma_config.para = 0;
if(0 != sw_dma_config(dma_hdl, &dma_config, ENQUE_PHASE_NORMAL)) {
uret = __LINE__;
goto end;
}
pr_info("%s: sw_dma_config success\n", __func__);
sw_dma_dump_chan(dma_hdl);
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_START, NULL)) {
uret = __LINE__;
goto end;
}
pr_info("%s: sw_dma_start success\n", __func__);
if(0 != __waitdone_case_enq_aftdone()) {
uret = __LINE__;
goto end;
}
pr_info("%s: __waitdone_case_enq_aftdone sucess\n", __func__);
/* after done. app and fd_cb enqueue simutanously */
i = 0;
while(i++ < 30) {
u32 ucur_saddr = 0, ucur_daddr = 0;
pr_info("%s: i %d\n", __func__, i);
ucur_saddr = g_src_addr + 0 * DTC_ONE_LEN;
ucur_daddr = g_dst_addr + 0 * DTC_ONE_LEN;
if(0 != sw_dma_enqueue(dma_hdl, ucur_saddr, ucur_daddr, DTC_ONE_LEN, ENQUE_PHASE_NORMAL)) {
uret = __LINE__;
goto end;
}
msleep(1);
}
msleep(2000);
if(0 == memcmp(src_vaddr, dst_vaddr, DTC_TOTAL_LEN))
pr_info("%s: data check ok!\n", __func__);
else {
pr_err("%s: data check err!\n", __func__);
uret = __LINE__; /* return err */
goto end;
}
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_STOP, NULL)) {
uret = __LINE__;
goto end;
}
pr_info("%s: sw_dma_stop success\n", __func__);
if(0 != sw_dma_release(dma_hdl)) {
uret = __LINE__;
goto end;
}
dma_hdl = (dm_hdl_t)NULL;
pr_info("%s: sw_dma_release success\n", __func__);
end:
/* print err line */
if(0 != uret)
pr_err("%s err, line %d!\n", __func__, uret);
else
pr_info("%s success!\n", __func__);
if((dm_hdl_t)NULL != dma_hdl) {
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_STOP, NULL)) {
pr_err("%s err, line %d!\n", __func__, __LINE__);
}
if(0 != sw_dma_release(dma_hdl)) {
pr_err("%s err, line %d!\n", __func__, __LINE__);
}
}
if(NULL != src_vaddr)
dma_free_coherent(NULL, DTC_TOTAL_LEN, src_vaddr, src_paddr);
if(NULL != dst_vaddr)
dma_free_coherent(NULL, DTC_TOTAL_LEN, dst_vaddr, dst_paddr);
return uret;
}
/**
* __dtc_chain_mode - dma test case for chain mode
*
* Returns 0 if success, the err line number if failed.
*/
u32 __dtc_chain_mode(void)
{
u32 uret = 0;
void *src_vaddr = NULL, *dst_vaddr = NULL;
u32 src_paddr = 0, dst_paddr = 0;
dm_hdl_t dma_hdl = (dm_hdl_t)NULL;
struct dma_cb_t done_cb;
struct dma_op_cb_t op_cb;
struct dma_config_t dma_config;
pr_info("%s enter\n", __func__);
/* prepare the buffer and data */
src_vaddr = dma_alloc_coherent(NULL, DTC_TOTAL_LEN, (dma_addr_t *)&src_paddr, GFP_KERNEL);
if(NULL == src_vaddr) {
uret = __LINE__;
goto end;
}
pr_info("%s: src_vaddr 0x%08x, src_paddr 0x%08x\n", __func__, (u32)src_vaddr, src_paddr);
dst_vaddr = dma_alloc_coherent(NULL, DTC_TOTAL_LEN, (dma_addr_t *)&dst_paddr, GFP_KERNEL);
if(NULL == dst_vaddr) {
uret = __LINE__;
goto end;
}
pr_info("%s: dst_vaddr 0x%08x, dst_paddr 0x%08x\n", __func__, (u32)dst_vaddr, dst_paddr);
/* init src buffer */
get_random_bytes(src_vaddr, DTC_TOTAL_LEN);
memset(dst_vaddr, 0x54, DTC_TOTAL_LEN);
/* init loop para */
atomic_set(&g_acur_cnt, 0);
g_src_addr = src_paddr;
g_dst_addr = dst_paddr;
/* request dma channel */
dma_hdl = sw_dma_request("m2m_dma", DMA_WORK_MODE_CHAIN);
if(NULL == dma_hdl) {
uret = __LINE__;
goto end;
}
pr_info("%s: sw_dma_request success, dma_hdl 0x%08x\n", __func__, (u32)dma_hdl);
/* set queue done callback */
memset(&done_cb, 0, sizeof(done_cb));
memset(&op_cb, 0, sizeof(op_cb));
done_cb.func = __cb_qd_chain;
done_cb.parg = NULL;
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_SET_QD_CB, (void *)&done_cb)) {
uret = __LINE__;
goto end;
}
pr_info("%s: set queuedone_cb success\n", __func__);
/* set full done callback */
done_cb.func = __cb_fd_chain;
done_cb.parg = NULL;
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_SET_FD_CB, (void *)&done_cb)) {
uret = __LINE__;
goto end;
}
pr_info("%s: set fulldone_cb success\n", __func__);
/* set half done callback */
done_cb.func = __cb_hd_chain;
done_cb.parg = NULL;
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_SET_HD_CB, (void *)&done_cb)) {
uret = __LINE__;
goto end;
}
pr_info("%s: set halfdone_cb success\n", __func__);
/* set operation done callback */
op_cb.func = __cb_op_chain;
op_cb.parg = NULL;
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_SET_OP_CB, (void *)&op_cb)) {
uret = __LINE__;
goto end;
}
pr_info("%s: set op_cb success\n", __func__);
/* set config para */
memset(&dma_config, 0, sizeof(dma_config));
dma_config.xfer_type = DMAXFER_D_BWORD_S_BWORD;
dma_config.address_type = DMAADDRT_D_LN_S_LN;
dma_config.para = 0;
dma_config.irq_spt = CHAN_IRQ_HD | CHAN_IRQ_FD | CHAN_IRQ_QD;
dma_config.src_addr = src_paddr;
dma_config.dst_addr = dst_paddr;
dma_config.byte_cnt = DTC_ONE_LEN;
//dma_config.conti_mode = 1;
dma_config.bconti_mode = false;
dma_config.src_drq_type = DRQSRC_SDRAM;
dma_config.dst_drq_type = DRQDST_SDRAM;
/* enqueue buffer */
if(0 != sw_dma_config(dma_hdl, &dma_config, ENQUE_PHASE_NORMAL)) {
uret = __LINE__;
goto end;
}
pr_info("%s: sw_dma_config success\n", __func__);
/* dump chain */
sw_dma_dump_chan(dma_hdl);
/* start dma */
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_START, NULL)) {
uret = __LINE__;
goto end;
}
/* enqueue other buffer, with callback enqueue simutanously */
{
u32 ucur_cnt = 0, ucur_saddr = 0, ucur_daddr = 0;
u32 uloop_cnt = DTC_TOTAL_LEN / DTC_ONE_LEN;
while((ucur_cnt = atomic_add_return(1, &g_acur_cnt)) < uloop_cnt) {
ucur_saddr = g_src_addr + ucur_cnt * DTC_ONE_LEN;
ucur_daddr = g_dst_addr + ucur_cnt * DTC_ONE_LEN;
if(0 != sw_dma_enqueue(dma_hdl, ucur_saddr, ucur_daddr, DTC_ONE_LEN, ENQUE_PHASE_NORMAL))
printk("%s err, line %d\n", __func__, __LINE__);
}
}
pr_info("%s, line %d\n", __func__, __LINE__);
/* wait dma done */
if(0 != __waitdone_chain()) {
uret = __LINE__;
goto end;
}
pr_info("%s: __waitdone_chain sucess\n", __func__);
/*
* NOTE: must sleep here, becase when __waitdone_chain return, buffer enqueue complete, but
* data might not transfer complete, 2012-11-14
*/
msleep(1000);
/* check if data ok */
if(0 == memcmp(src_vaddr, dst_vaddr, DTC_TOTAL_LEN))
pr_info("%s: data check ok!\n", __func__);
else {
pr_err("%s: data check err!\n", __func__);
uret = __LINE__; /* return err */
goto end;
}
/* stop and release dma channel */
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_STOP, NULL)) {
uret = __LINE__;
goto end;
}
pr_info("%s: sw_dma_stop success\n", __func__);
if(0 != sw_dma_release(dma_hdl)) {
uret = __LINE__;
goto end;
}
dma_hdl = (dm_hdl_t)NULL;
pr_info("%s: sw_dma_release success\n", __func__);
end:
if(0 != uret)
pr_err("%s err, line %d!\n", __func__, uret); /* print err line */
else
pr_info("%s, success!\n", __func__);
/* stop and free dma channel, if need */
if((dm_hdl_t)NULL != dma_hdl) {
pr_err("%s, stop and release dma handle now!\n", __func__);
if(0 != sw_dma_ctl(dma_hdl, DMA_OP_STOP, NULL))
pr_err("%s err, line %d!\n", __func__, __LINE__);
if(0 != sw_dma_release(dma_hdl))
pr_err("%s err, line %d!\n", __func__, __LINE__);
}
pr_err("%s, line %d!\n", __func__, __LINE__);
/* free dma memory */
if(NULL != src_vaddr)
dma_free_coherent(NULL, DTC_TOTAL_LEN, src_vaddr, src_paddr);
if(NULL != dst_vaddr)
dma_free_coherent(NULL, DTC_TOTAL_LEN, dst_vaddr, dst_paddr);
pr_err("%s, end!\n", __func__);
return uret;
}
static int sun7i_pcm_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params)
{
/*pr_info("sun7i_i2sdma.c::func:%s(line:%d)\n",__func__,__LINE__);*/
struct snd_pcm_runtime *play_runtime = NULL, *capture_runtime = NULL;
struct sun7i_playback_runtime_data *play_prtd = NULL;
struct sun7i_capture_runtime_data *capture_prtd = NULL;
struct snd_soc_pcm_runtime *play_rtd = NULL;
struct snd_soc_pcm_runtime *capture_rtd = NULL;
struct sun7i_dma_params *play_dma = NULL;
struct sun7i_dma_params *capture_dma = NULL;
unsigned long play_totbytes = 0, capture_totbytes = 0;
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
pr_info("play:sun7i_i2sdma.c::func:%s(line:%d)\n",__func__,__LINE__);
play_runtime = substream->runtime;
play_prtd = play_runtime ->private_data;
play_rtd = substream->private_data;
play_totbytes = params_buffer_bytes(params);
play_dma = snd_soc_dai_get_dma_data(play_rtd->cpu_dai, substream);
if (!play_dma) {
return 0;
}
if (play_prtd->params == NULL) {
play_prtd->params = play_dma;
/*
* requeset audio dma handle(we don't care about the channel!)
*/
play_prtd->dma_hdl = sw_dma_request(play_prtd->params->name, CHAN_NORAML);
if (NULL == play_prtd->dma_hdl) {
printk(KERN_ERR "failed to request spdif dma handle\n");
return -EINVAL;
}
}
/*
* set callback
*/
memset(&play_prtd->play_done_cb, 0, sizeof(play_prtd->play_done_cb));
play_prtd->play_done_cb.func = sun7i_audio_play_buffdone;
play_prtd->play_done_cb.parg = substream;
/*use the full buffer callback, maybe we should use the half buffer callback?*/
if (0 != sw_dma_ctl(play_prtd->dma_hdl, DMA_OP_SET_FD_CB, (void *)&(play_prtd->play_done_cb))) {
printk(KERN_ERR "failed to set dma buffer done!!!\n");
sw_dma_release(play_prtd->dma_hdl);
return -EINVAL;
}
snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
play_runtime->dma_bytes = play_totbytes;
spin_lock_irq(&play_prtd->lock);
play_prtd->dma_loaded = 0;
play_prtd->dma_limit = play_runtime->hw.periods_min;
play_prtd->dma_period = params_period_bytes(params);
play_prtd->dma_start = play_runtime->dma_addr;
play_prtd->dma_pos = play_prtd->dma_start;
play_prtd->dma_end = play_prtd->dma_start + play_totbytes;
spin_unlock_irq(&play_prtd->lock);
} else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
pr_info("CAPTUR:sun7i_i2sdma.c::func:%s(line:%d)\n",__func__,__LINE__);
capture_runtime = substream->runtime;
capture_prtd = capture_runtime ->private_data;
capture_rtd = substream->private_data;
capture_totbytes = params_buffer_bytes(params);
capture_dma = snd_soc_dai_get_dma_data(capture_rtd->cpu_dai, substream);
if (!capture_dma) {
return 0;
}
if (capture_prtd->params == NULL) {
capture_prtd->params = capture_dma;
/*
* requeset audio dma handle(we don't care about the channel!)
*/
capture_prtd->dma_hdl = sw_dma_request(capture_prtd->params->name, CHAN_NORAML);
if (NULL == capture_prtd->dma_hdl) {
printk(KERN_ERR "failed to request spdif dma handle\n");
return -EINVAL;
}
}
/*
* set callback
*/
memset(&capture_prtd->play_done_cb, 0, sizeof(capture_prtd->play_done_cb));
capture_prtd->play_done_cb.func = sun7i_audio_capture_buffdone;
capture_prtd->play_done_cb.parg = substream;
/*use the full buffer callback, maybe we should use the half buffer callback?*/
if (0 != sw_dma_ctl(capture_prtd->dma_hdl, DMA_OP_SET_FD_CB, (void *)&(capture_prtd->play_done_cb))) {
printk(KERN_ERR "failed to set dma buffer done!!!\n");
sw_dma_release(capture_prtd->dma_hdl);
return -EINVAL;
}
snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
capture_runtime->dma_bytes = capture_totbytes;
spin_lock_irq(&capture_prtd->lock);
capture_prtd->dma_loaded = 0;
capture_prtd->dma_limit = capture_runtime->hw.periods_min;
capture_prtd->dma_period = params_period_bytes(params);
capture_prtd->dma_start = capture_runtime->dma_addr;
capture_prtd->dma_pos = capture_prtd->dma_start;
capture_prtd->dma_end = capture_prtd->dma_start + capture_totbytes;
spin_unlock_irq(&capture_prtd->lock);
} else {
return -EINVAL;
}
return 0;
}
