Re: [PATCH 4/5] ASoC: atmel_ssc_dai/atmel-pcm: adapt to dmaengineusage
From: Koul, Vinod
Date: Wed Jun 29 2011 - 21:33:18 EST
On Wed, 2011-06-29 at 20:00 +0200, Nicolas Ferre wrote:
> Change xfer_size name to apply to PDC and DMA aswell.
> Specify overrun bit in interrupt mask.
> Add dmaengine specific routines and replace PDC ones in
> pcm_ops if appropriate.
> Uses cyclic DMA API for queuing samples.
>
> Signed-off-by: Nicolas Ferre <nicolas.ferre@xxxxxxxxx>
> Signed-off-by: Uwe Kleine-KÃnig <u.kleine-koenig@xxxxxxxxxxxxxx>
> ---
> sound/soc/atmel/atmel-pcm.c | 382 +++++++++++++++++++++++++++++++++++---
> sound/soc/atmel/atmel-pcm.h | 4 +-
> sound/soc/atmel/atmel_ssc_dai.c | 33 ++--
> 3 files changed, 373 insertions(+), 46 deletions(-)
>
> diff --git a/sound/soc/atmel/atmel-pcm.c b/sound/soc/atmel/atmel-pcm.c
> index 51dde4e..fee6696 100644
> --- a/sound/soc/atmel/atmel-pcm.c
> +++ b/sound/soc/atmel/atmel-pcm.c
> @@ -37,6 +37,7 @@
> #include <linux/slab.h>
> #include <linux/dma-mapping.h>
> #include <linux/atmel_pdc.h>
> +#include <linux/dmaengine.h>
> #include <linux/atmel-ssc.h>
>
> #include <sound/core.h>
> @@ -44,6 +45,8 @@
> #include <sound/pcm_params.h>
> #include <sound/soc.h>
>
> +#include <mach/at_hdmac.h>
> +
> #include "atmel-pcm.h"
>
>
> @@ -53,7 +56,7 @@
> /* TODO: These values were taken from the AT91 platform driver, check
> * them against real values for AT32
> */
> -static const struct snd_pcm_hardware atmel_pcm_hardware = {
> +static const struct snd_pcm_hardware atmel_pcm_pdc_hardware = {
> .info = SNDRV_PCM_INFO_MMAP |
> SNDRV_PCM_INFO_MMAP_VALID |
> SNDRV_PCM_INFO_INTERLEAVED |
> @@ -66,6 +69,22 @@ static const struct snd_pcm_hardware atmel_pcm_hardware = {
> .buffer_bytes_max = 32 * 1024,
> };
>
> +static const struct snd_pcm_hardware atmel_pcm_dma_hardware = {
> + .info = SNDRV_PCM_INFO_MMAP |
> + SNDRV_PCM_INFO_MMAP_VALID |
> + SNDRV_PCM_INFO_INTERLEAVED |
> + SNDRV_PCM_INFO_RESUME |
> + SNDRV_PCM_INFO_PAUSE,
> + .formats = SNDRV_PCM_FMTBIT_S16_LE,
> + .period_bytes_min = 256, /* not too low to absorb DMA programming overhead */
> + .period_bytes_max = 2 * 0xffff, /* if 2 bytes format */
> + .periods_min = 8,
> + .periods_max = 1024, /* no limit */
> + .buffer_bytes_max = 64 * 1024, /* 64KiB */
> +};
> +
> +static const struct snd_pcm_hardware *atmel_pcm_hardware;
> +
>
> /*--------------------------------------------------------------------------*\
> * Data types
> @@ -77,12 +96,19 @@ struct atmel_runtime_data {
> size_t period_size;
>
> dma_addr_t period_ptr; /* physical address of next period */
> + int periods; /* period index of period_ptr */
>
> /* PDC register save */
> u32 pdc_xpr_save;
> u32 pdc_xcr_save;
> u32 pdc_xnpr_save;
> u32 pdc_xncr_save;
> +
> + /* dmaengine data */
> + struct at_dma_slave atslave;
> + struct dma_async_tx_descriptor *desc;
> + dma_cookie_t cookie;
> + struct dma_chan *dma_chan;
> };
>
>
> @@ -94,7 +120,7 @@ static int atmel_pcm_preallocate_dma_buffer(struct snd_pcm *pcm,
> {
> struct snd_pcm_substream *substream = pcm->streams[stream].substream;
> struct snd_dma_buffer *buf = &substream->dma_buffer;
> - size_t size = atmel_pcm_hardware.buffer_bytes_max;
> + size_t size = atmel_pcm_hardware->buffer_bytes_max;
>
> buf->dev.type = SNDRV_DMA_TYPE_DEV;
> buf->dev.dev = pcm->card->dev;
> @@ -116,7 +142,7 @@ static int atmel_pcm_preallocate_dma_buffer(struct snd_pcm *pcm,
> /*--------------------------------------------------------------------------*\
> * ISR
> \*--------------------------------------------------------------------------*/
> -static void atmel_pcm_dma_irq(u32 ssc_sr,
> +static void atmel_pcm_pdc_irq(u32 ssc_sr,
> struct snd_pcm_substream *substream)
> {
> struct atmel_runtime_data *prtd = substream->runtime->private_data;
> @@ -142,7 +168,7 @@ static void atmel_pcm_dma_irq(u32 ssc_sr,
> ssc_writex(params->ssc->regs, params->pdc->xpr,
> prtd->period_ptr);
> ssc_writex(params->ssc->regs, params->pdc->xcr,
> - prtd->period_size / params->pdc_xfer_size);
> + prtd->period_size / params->data_xfer_size);
> ssc_writex(params->ssc->regs, ATMEL_PDC_PTCR,
> params->mask->pdc_enable);
> }
> @@ -156,12 +182,163 @@ static void atmel_pcm_dma_irq(u32 ssc_sr,
> ssc_writex(params->ssc->regs, params->pdc->xnpr,
> prtd->period_ptr);
> ssc_writex(params->ssc->regs, params->pdc->xncr,
> - prtd->period_size / params->pdc_xfer_size);
> + prtd->period_size / params->data_xfer_size);
> }
>
> snd_pcm_period_elapsed(substream);
> }
>
> +/**
> + * atmel_pcm_dma_irq: SSC interrupt handler for DMAENGINE enabled SSC
> + *
> + * We use DMAENGINE to send/receive data to/from SSC so this ISR is only to
> + * check if any overrun occured.
> + */
> +static void atmel_pcm_dma_irq(u32 ssc_sr,
> + struct snd_pcm_substream *substream)
> +{
> + struct atmel_runtime_data *prtd = substream->runtime->private_data;
> + struct atmel_pcm_dma_params *params = prtd->params;
> +
> + if (ssc_sr & params->mask->ssc_error) {
> + if (snd_pcm_running(substream))
> + pr_warning("atmel-pcm: buffer %s on %s"
> + " (SSC_SR=%#x)\n",
> + substream->stream == SNDRV_PCM_STREAM_PLAYBACK
> + ? "underrun" : "overrun",
> + params->name, ssc_sr);
> +
> + /* stop RX and capture stream: will be enabled again at restart */
> + ssc_writex(params->ssc->regs, SSC_CR, params->mask->ssc_disable);
> + snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
> +
> + /* now drain RHR and read status to remove xrun condition */
> + ssc_readx(params->ssc->regs, SSC_RHR);
> + ssc_readx(params->ssc->regs, SSC_SR);
> + }
> +}
> +
> +/*--------------------------------------------------------------------------*\
> + * DMAENGINE operations
> +\*--------------------------------------------------------------------------*/
> +static bool filter(struct dma_chan *chan, void *slave)
> +{
> + struct at_dma_slave *sl = slave;
> +
> + if (sl->dma_dev == chan->device->dev) {
> + chan->private = sl;
Nope you dont want to do that, pls use dmaengine_slave_config() API for
setting this
> + return true;
> + } else {
> + return false;
> + }
> +}
> +
> +static int atmel_pcm_dma_alloc(struct snd_pcm_substream *substream,
> + struct snd_pcm_hw_params *params)
> +{
> + struct snd_pcm_runtime *runtime = substream->runtime;
> + struct atmel_runtime_data *prtd = runtime->private_data;
> + struct ssc_device *ssc = prtd->params->ssc;
> + struct at_dma_slave *sdata = NULL;
> +
> + if (ssc->pdev)
> + sdata = ssc->pdev->dev.platform_data;
> +
> + if (sdata && sdata->dma_dev) {
> + dma_cap_mask_t mask;
> +
> + /* setup DMA addresses */
> + sdata->rx_reg = (dma_addr_t)ssc->phybase + SSC_RHR;
> + sdata->tx_reg = (dma_addr_t)ssc->phybase + SSC_THR;
> +
> + /* Try to grab a DMA channel */
> + dma_cap_zero(mask);
> + dma_cap_set(DMA_CYCLIC, mask);
> + prtd->dma_chan = dma_request_channel(mask, filter, sdata);
> + }
> + if (!prtd->dma_chan) {
> + pr_err("atmel-pcm: "
> + "DMA channel not available, unable to use SSC-audio\n");
> + return -EBUSY;
> + }
> +
> + return 0;
> +}
> +
> +static void audio_dma_irq(void *data)
> +{
> + struct snd_pcm_substream *substream = (struct snd_pcm_substream *)data;
> + struct snd_pcm_runtime *runtime = substream->runtime;
> + struct atmel_runtime_data *prtd = runtime->private_data;
> +
> + prtd->period_ptr += prtd->period_size;
> + if (prtd->period_ptr >= prtd->dma_buffer_end)
> + prtd->period_ptr = prtd->dma_buffer;
> +
> + snd_pcm_period_elapsed(substream);
> +}
> +
> +static void atmel_pcm_dma_slave_config(struct snd_pcm_substream *substream)
> +{
> + struct snd_pcm_runtime *runtime = substream->runtime;
> + struct atmel_runtime_data *prtd = runtime->private_data;
> + struct dma_chan *chan = prtd->dma_chan;
> + struct dma_slave_config slave_config;
> + enum dma_slave_buswidth buswidth;
> +
> + switch (prtd->params->data_xfer_size) {
> + case 1:
> + buswidth = DMA_SLAVE_BUSWIDTH_1_BYTE;
> + break;
> + case 2:
> + buswidth = DMA_SLAVE_BUSWIDTH_2_BYTES;
> + break;
> + case 4:
> + buswidth = DMA_SLAVE_BUSWIDTH_4_BYTES;
> + break;
> + default:
> + return;
> + }
> +
> + if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
> + slave_config.direction = DMA_TO_DEVICE;
> + slave_config.dst_addr_width = buswidth;
> + } else {
> + slave_config.direction = DMA_FROM_DEVICE;
> + slave_config.src_addr_width = buswidth;
> + }
> +
> + dmaengine_slave_config(chan, &slave_config);
okay, you seem to be doing right thing, then why are you setting the
chan->slave pointer??
> +}
> +
> +static int atmel_pcm_dma_prep(struct snd_pcm_substream *substream)
> +{
> + struct snd_pcm_runtime *runtime = substream->runtime;
> + struct atmel_runtime_data *prtd = runtime->private_data;
> + struct dma_chan *chan = prtd->dma_chan;
> +
> + if (prtd->desc)
> + /* already been there: redo the prep job */
> + dmaengine_terminate_all(chan);
> +
> + /* setup dma configuration */
> + atmel_pcm_dma_slave_config(substream);
Nope, this is channel config. As long as you retain the channel you
shouldn't be required to set this again.
> +
> + prtd->desc = chan->device->device_prep_dma_cyclic(chan, prtd->dma_buffer,
> + prtd->period_size * prtd->periods,
> + prtd->period_size,
> + substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
> + DMA_TO_DEVICE : DMA_FROM_DEVICE);
> + if (!prtd->desc) {
> + dev_err(&chan->dev->device, "cannot prepare slave dma\n");
> + return -EINVAL;
> + }
> +
> + prtd->desc->callback = audio_dma_irq;
> + prtd->desc->callback_param = substream;
> +
> + return 0;
> +}
>
> /*--------------------------------------------------------------------------*\
> * PCM operations
> @@ -172,6 +349,7 @@ static int atmel_pcm_hw_params(struct snd_pcm_substream *substream,
> struct snd_pcm_runtime *runtime = substream->runtime;
> struct atmel_runtime_data *prtd = runtime->private_data;
> struct snd_soc_pcm_runtime *rtd = substream->private_data;
> + int ret;
>
> /* this may get called several times by oss emulation
> * with different params */
> @@ -180,15 +358,35 @@ static int atmel_pcm_hw_params(struct snd_pcm_substream *substream,
> runtime->dma_bytes = params_buffer_bytes(params);
>
> prtd->params = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
> - prtd->params->dma_intr_handler = atmel_pcm_dma_irq;
>
> prtd->dma_buffer = runtime->dma_addr;
> prtd->dma_buffer_end = runtime->dma_addr + runtime->dma_bytes;
> prtd->period_size = params_period_bytes(params);
> + prtd->periods = params_periods(params);
> +
> + if (ssc_use_dmaengine()) {
> + if (prtd->dma_chan == NULL) {
> + ret = atmel_pcm_dma_alloc(substream, params);
> + if (ret)
> + return ret;
> + }
> + ret = atmel_pcm_dma_prep(substream);
> + if (ret) {
> + dma_release_channel(prtd->dma_chan);
> + prtd->dma_chan = NULL;
> + return ret;
> + }
> +
> + prtd->params->dma_intr_handler = atmel_pcm_dma_irq;
> + } else {
> + prtd->params->dma_intr_handler = atmel_pcm_pdc_irq;
> + }
>
> pr_debug("atmel-pcm: "
> - "hw_params: DMA for %s initialized "
> + "hw_params: %s%s for %s initialized "
> "(dma_bytes=%u, period_size=%u)\n",
> + prtd->dma_chan ? "DMA " : "PDC",
> + prtd->dma_chan ? dma_chan_name(prtd->dma_chan): "",
> prtd->params->name,
> runtime->dma_bytes,
> prtd->period_size);
> @@ -201,15 +399,30 @@ static int atmel_pcm_hw_free(struct snd_pcm_substream *substream)
> struct atmel_pcm_dma_params *params = prtd->params;
>
> if (params != NULL) {
> - ssc_writex(params->ssc->regs, SSC_PDC_PTCR,
> - params->mask->pdc_disable);
> + if (ssc_use_dmaengine()) {
> + struct dma_chan *chan = prtd->dma_chan;
> +
> + if (chan) {
> + dmaengine_terminate_all(chan);
> + prtd->cookie = 0;
> + prtd->desc = NULL;
> + dma_release_channel(chan);
> + prtd->dma_chan = NULL;
> + }
> + } else {
> + ssc_writex(params->ssc->regs, SSC_PDC_PTCR,
> + params->mask->pdc_disable);
> + }
> prtd->params->dma_intr_handler = NULL;
> }
>
> return 0;
> }
>
> -static int atmel_pcm_prepare(struct snd_pcm_substream *substream)
> +/*--------------------------------------------------------------------------*\
> + * PCM callbacks using PDC
> +\*--------------------------------------------------------------------------*/
> +static int atmel_pcm_pdc_prepare(struct snd_pcm_substream *substream)
> {
> struct atmel_runtime_data *prtd = substream->runtime->private_data;
> struct atmel_pcm_dma_params *params = prtd->params;
> @@ -221,7 +434,7 @@ static int atmel_pcm_prepare(struct snd_pcm_substream *substream)
> return 0;
> }
>
> -static int atmel_pcm_trigger(struct snd_pcm_substream *substream,
> +static int atmel_pcm_pdc_trigger(struct snd_pcm_substream *substream,
> int cmd)
> {
> struct snd_pcm_runtime *rtd = substream->runtime;
> @@ -240,13 +453,13 @@ static int atmel_pcm_trigger(struct snd_pcm_substream *substream,
> ssc_writex(params->ssc->regs, params->pdc->xpr,
> prtd->period_ptr);
> ssc_writex(params->ssc->regs, params->pdc->xcr,
> - prtd->period_size / params->pdc_xfer_size);
> + prtd->period_size / params->data_xfer_size);
>
> prtd->period_ptr += prtd->period_size;
> ssc_writex(params->ssc->regs, params->pdc->xnpr,
> prtd->period_ptr);
> ssc_writex(params->ssc->regs, params->pdc->xncr,
> - prtd->period_size / params->pdc_xfer_size);
> + prtd->period_size / params->data_xfer_size);
>
> pr_debug("atmel-pcm: trigger: "
> "period_ptr=%lx, xpr=%u, "
> @@ -264,7 +477,7 @@ static int atmel_pcm_trigger(struct snd_pcm_substream *substream,
>
> pr_debug("sr=%u imr=%u\n",
> ssc_readx(params->ssc->regs, SSC_SR),
> - ssc_readx(params->ssc->regs, SSC_IER));
> + ssc_readx(params->ssc->regs, SSC_IMR));
> break; /* SNDRV_PCM_TRIGGER_START */
>
> case SNDRV_PCM_TRIGGER_STOP:
> @@ -287,7 +500,7 @@ static int atmel_pcm_trigger(struct snd_pcm_substream *substream,
> return ret;
> }
>
> -static snd_pcm_uframes_t atmel_pcm_pointer(
> +static snd_pcm_uframes_t atmel_pcm_pdc_pointer(
> struct snd_pcm_substream *substream)
> {
> struct snd_pcm_runtime *runtime = substream->runtime;
> @@ -305,13 +518,107 @@ static snd_pcm_uframes_t atmel_pcm_pointer(
> return x;
> }
>
> +/*--------------------------------------------------------------------------*\
> + * PCM callbacks using DMAENGINE
> +\*--------------------------------------------------------------------------*/
> +static int atmel_pcm_dma_prepare(struct snd_pcm_substream *substream)
> +{
> + struct atmel_runtime_data *prtd = substream->runtime->private_data;
> + struct atmel_pcm_dma_params *params = prtd->params;
> +
> + ssc_writex(params->ssc->regs, SSC_IDR, params->mask->ssc_error);
> + return 0;
> +}
> +
> +static int atmel_pcm_dma_trigger(struct snd_pcm_substream *substream,
> + int cmd)
> +{
> + struct snd_pcm_runtime *rtd = substream->runtime;
> + struct atmel_runtime_data *prtd = rtd->private_data;
> + struct atmel_pcm_dma_params *params = prtd->params;
> + dma_cookie_t cookie;
> + int ret = 0;
> +
> + pr_debug("atmel-pcm: trigger %d: buffer_size = %ld,"
> + " dma_area = %p, dma_bytes = %u\n",
> + cmd, rtd->buffer_size, rtd->dma_area, rtd->dma_bytes);
> +
> + switch (cmd) {
> + case SNDRV_PCM_TRIGGER_START:
> +
> + if (prtd->cookie < DMA_MIN_COOKIE) {
> + cookie = dmaengine_submit(prtd->desc);
submit and issue_pending as well...
> + if (dma_submit_error(cookie)) {
> + ret = -EINVAL;
> + break;
> + }
> + prtd->cookie = cookie;
> + prtd->period_ptr = prtd->dma_buffer;
> + }
> +
> +
> + pr_debug("atmel-pcm: trigger: start sr=0x%08x imr=0x%08u\n",
> + ssc_readx(params->ssc->regs, SSC_SR),
> + ssc_readx(params->ssc->regs, SSC_IMR));
> +
> + /* fallback */
> + case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
> + case SNDRV_PCM_TRIGGER_RESUME:
> + dmaengine_resume(prtd->dma_chan);
> +
> + /* It not already done or comming from xrun state */
> + ssc_readx(params->ssc->regs, SSC_SR);
> + ssc_writex(params->ssc->regs, SSC_IER, params->mask->ssc_error);
> + ssc_writex(params->ssc->regs, SSC_CR, params->mask->ssc_enable);
> +
> + break;
> + case SNDRV_PCM_TRIGGER_STOP:
> + pr_debug("atmel-pcm: trigger: stop cmd = %d\n", cmd);
> +
> + ssc_writex(params->ssc->regs, SSC_IDR, params->mask->ssc_error);
> +
> + /* fallback */
> + case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
> + case SNDRV_PCM_TRIGGER_SUSPEND:
> + dmaengine_pause(prtd->dma_chan);
> + break;
> + default:
> + ret = -EINVAL;
> + }
> +
> + return ret;
> +}
> +
> +static snd_pcm_uframes_t atmel_pcm_dma_pointer(
> + struct snd_pcm_substream *substream)
> +{
> + struct snd_pcm_runtime *runtime = substream->runtime;
> + struct atmel_runtime_data *prtd = runtime->private_data;
> + snd_pcm_uframes_t x;
> +
> + dev_vdbg(substream->pcm->card->dev, "%s: 0x%08x %ld\n",
> + __func__, prtd->period_ptr,
> + bytes_to_frames(runtime, prtd->period_ptr - prtd->dma_buffer));
> +
> + x = bytes_to_frames(runtime, prtd->period_ptr - prtd->dma_buffer);
> +
> + if (x >= runtime->buffer_size)
> + x = 0;
> +
> + return x;
> +}
> +
> +
> +/*--------------------------------------------------------------------------*\
> + * PCM open/close/mmap
> +\*--------------------------------------------------------------------------*/
> static int atmel_pcm_open(struct snd_pcm_substream *substream)
> {
> struct snd_pcm_runtime *runtime = substream->runtime;
> struct atmel_runtime_data *prtd;
> int ret = 0;
>
> - snd_soc_set_runtime_hwparams(substream, &atmel_pcm_hardware);
> + snd_soc_set_runtime_hwparams(substream, atmel_pcm_hardware);
>
> /* ensure that buffer size is a multiple of period size */
> ret = snd_pcm_hw_constraint_integer(runtime,
> @@ -352,9 +659,9 @@ static struct snd_pcm_ops atmel_pcm_ops = {
> .ioctl = snd_pcm_lib_ioctl,
> .hw_params = atmel_pcm_hw_params,
> .hw_free = atmel_pcm_hw_free,
> - .prepare = atmel_pcm_prepare,
> - .trigger = atmel_pcm_trigger,
> - .pointer = atmel_pcm_pointer,
> + .prepare = atmel_pcm_pdc_prepare,
> + .trigger = atmel_pcm_pdc_trigger,
> + .pointer = atmel_pcm_pdc_pointer,
> .mmap = atmel_pcm_mmap,
> };
>
> @@ -426,14 +733,16 @@ static int atmel_pcm_suspend(struct snd_soc_dai *dai)
> prtd = runtime->private_data;
> params = prtd->params;
>
> - /* disable the PDC and save the PDC registers */
> + if (!ssc_use_dmaengine()) {
> + /* disable the PDC and save the PDC registers */
>
> - ssc_writel(params->ssc->regs, PDC_PTCR, params->mask->pdc_disable);
> + ssc_writel(params->ssc->regs, PDC_PTCR, params->mask->pdc_disable);
>
> - prtd->pdc_xpr_save = ssc_readx(params->ssc->regs, params->pdc->xpr);
> - prtd->pdc_xcr_save = ssc_readx(params->ssc->regs, params->pdc->xcr);
> - prtd->pdc_xnpr_save = ssc_readx(params->ssc->regs, params->pdc->xnpr);
> - prtd->pdc_xncr_save = ssc_readx(params->ssc->regs, params->pdc->xncr);
> + prtd->pdc_xpr_save = ssc_readx(params->ssc->regs, params->pdc->xpr);
> + prtd->pdc_xcr_save = ssc_readx(params->ssc->regs, params->pdc->xcr);
> + prtd->pdc_xnpr_save = ssc_readx(params->ssc->regs, params->pdc->xnpr);
> + prtd->pdc_xncr_save = ssc_readx(params->ssc->regs, params->pdc->xncr);
> + }
>
> return 0;
> }
> @@ -450,13 +759,15 @@ static int atmel_pcm_resume(struct snd_soc_dai *dai)
> prtd = runtime->private_data;
> params = prtd->params;
>
> - /* restore the PDC registers and enable the PDC */
> - ssc_writex(params->ssc->regs, params->pdc->xpr, prtd->pdc_xpr_save);
> - ssc_writex(params->ssc->regs, params->pdc->xcr, prtd->pdc_xcr_save);
> - ssc_writex(params->ssc->regs, params->pdc->xnpr, prtd->pdc_xnpr_save);
> - ssc_writex(params->ssc->regs, params->pdc->xncr, prtd->pdc_xncr_save);
> + if (!ssc_use_dmaengine()) {
> + /* restore the PDC registers and enable the PDC */
> + ssc_writex(params->ssc->regs, params->pdc->xpr, prtd->pdc_xpr_save);
> + ssc_writex(params->ssc->regs, params->pdc->xcr, prtd->pdc_xcr_save);
> + ssc_writex(params->ssc->regs, params->pdc->xnpr, prtd->pdc_xnpr_save);
> + ssc_writex(params->ssc->regs, params->pdc->xncr, prtd->pdc_xncr_save);
>
> - ssc_writel(params->ssc->regs, PDC_PTCR, params->mask->pdc_enable);
> + ssc_writel(params->ssc->regs, PDC_PTCR, params->mask->pdc_enable);
> + }
> return 0;
> }
> #else
> @@ -495,6 +806,15 @@ static struct platform_driver atmel_pcm_driver = {
>
> static int __init snd_atmel_pcm_init(void)
> {
> + if (ssc_use_dmaengine()) {
> + atmel_pcm_ops.prepare = atmel_pcm_dma_prepare;
> + atmel_pcm_ops.trigger = atmel_pcm_dma_trigger;
> + atmel_pcm_ops.pointer = atmel_pcm_dma_pointer;
> +
> + atmel_pcm_hardware = &atmel_pcm_dma_hardware;
> + } else {
> + atmel_pcm_hardware = &atmel_pcm_pdc_hardware;
> + }
> return platform_driver_register(&atmel_pcm_driver);
> }
> module_init(snd_atmel_pcm_init);
> diff --git a/sound/soc/atmel/atmel-pcm.h b/sound/soc/atmel/atmel-pcm.h
> index 5e0a95e..b007376 100644
> --- a/sound/soc/atmel/atmel-pcm.h
> +++ b/sound/soc/atmel/atmel-pcm.h
> @@ -50,6 +50,7 @@ struct atmel_pdc_regs {
> struct atmel_ssc_mask {
> u32 ssc_enable; /* SSC recv/trans enable */
> u32 ssc_disable; /* SSC recv/trans disable */
> + u32 ssc_error; /* SSC error conditions */
> u32 ssc_endx; /* SSC ENDTX or ENDRX */
> u32 ssc_endbuf; /* SSC TXBUFE or RXBUFF */
> u32 pdc_enable; /* PDC recv/trans enable */
> @@ -66,7 +67,8 @@ struct atmel_ssc_mask {
> */
> struct atmel_pcm_dma_params {
> char *name; /* stream identifier */
> - int pdc_xfer_size; /* PDC counter increment in bytes */
> + int data_xfer_size; /* PDC counter increment in bytes,
> + DMA data transfer size in bytes */
> struct ssc_device *ssc; /* SSC device for stream */
> struct atmel_pdc_regs *pdc; /* PDC receive or transmit registers */
> struct atmel_ssc_mask *mask; /* SSC & PDC status bits */
> diff --git a/sound/soc/atmel/atmel_ssc_dai.c b/sound/soc/atmel/atmel_ssc_dai.c
> index a7a7bbc..9412fc3 100644
> --- a/sound/soc/atmel/atmel_ssc_dai.c
> +++ b/sound/soc/atmel/atmel_ssc_dai.c
> @@ -48,7 +48,8 @@
> #include "atmel_ssc_dai.h"
>
>
> -#if defined(CONFIG_ARCH_AT91SAM9260) || defined(CONFIG_ARCH_AT91SAM9G20)
> +#if defined(CONFIG_ARCH_AT91SAM9260) || defined(CONFIG_ARCH_AT91SAM9G20) \
> + || defined(CONFIG_ARCH_AT91SAM9X5)
> #define NUM_SSC_DEVICES 1
> #else
> #define NUM_SSC_DEVICES 3
> @@ -86,6 +87,7 @@ static struct atmel_ssc_mask ssc_tx_mask = {
> static struct atmel_ssc_mask ssc_rx_mask = {
> .ssc_enable = SSC_BIT(CR_RXEN),
> .ssc_disable = SSC_BIT(CR_RXDIS),
> + .ssc_error = SSC_BIT(SR_OVRUN),
> .ssc_endx = SSC_BIT(SR_ENDRX),
> .ssc_endbuf = SSC_BIT(SR_RXBUFF),
> .pdc_enable = ATMEL_PDC_RXTEN,
> @@ -183,7 +185,8 @@ static irqreturn_t atmel_ssc_interrupt(int irq, void *dev_id)
> if ((dma_params != NULL) &&
> (dma_params->dma_intr_handler != NULL)) {
> ssc_substream_mask = (dma_params->mask->ssc_endx |
> - dma_params->mask->ssc_endbuf);
> + dma_params->mask->ssc_endbuf |
> + dma_params->mask->ssc_error);
> if (ssc_sr & ssc_substream_mask) {
> dma_params->dma_intr_handler(ssc_sr,
> dma_params->
> @@ -376,19 +379,19 @@ static int atmel_ssc_hw_params(struct snd_pcm_substream *substream,
> switch (params_format(params)) {
> case SNDRV_PCM_FORMAT_S8:
> bits = 8;
> - dma_params->pdc_xfer_size = 1;
> + dma_params->data_xfer_size = 1;
> break;
> case SNDRV_PCM_FORMAT_S16_LE:
> bits = 16;
> - dma_params->pdc_xfer_size = 2;
> + dma_params->data_xfer_size = 2;
> break;
> case SNDRV_PCM_FORMAT_S24_LE:
> bits = 24;
> - dma_params->pdc_xfer_size = 4;
> + dma_params->data_xfer_size = 4;
> break;
> case SNDRV_PCM_FORMAT_S32_LE:
> bits = 32;
> - dma_params->pdc_xfer_size = 4;
> + dma_params->data_xfer_size = 4;
> break;
> default:
> printk(KERN_WARNING "atmel_ssc_dai: unsupported PCM format");
> @@ -561,15 +564,17 @@ static int atmel_ssc_hw_params(struct snd_pcm_substream *substream,
> /* Reset the SSC and its PDC registers */
> ssc_writel(ssc_p->ssc->regs, CR, SSC_BIT(CR_SWRST));
>
> - ssc_writel(ssc_p->ssc->regs, PDC_RPR, 0);
> - ssc_writel(ssc_p->ssc->regs, PDC_RCR, 0);
> - ssc_writel(ssc_p->ssc->regs, PDC_RNPR, 0);
> - ssc_writel(ssc_p->ssc->regs, PDC_RNCR, 0);
> + if (!ssc_use_dmaengine()) {
> + ssc_writel(ssc_p->ssc->regs, PDC_RPR, 0);
> + ssc_writel(ssc_p->ssc->regs, PDC_RCR, 0);
> + ssc_writel(ssc_p->ssc->regs, PDC_RNPR, 0);
> + ssc_writel(ssc_p->ssc->regs, PDC_RNCR, 0);
>
> - ssc_writel(ssc_p->ssc->regs, PDC_TPR, 0);
> - ssc_writel(ssc_p->ssc->regs, PDC_TCR, 0);
> - ssc_writel(ssc_p->ssc->regs, PDC_TNPR, 0);
> - ssc_writel(ssc_p->ssc->regs, PDC_TNCR, 0);
> + ssc_writel(ssc_p->ssc->regs, PDC_TPR, 0);
> + ssc_writel(ssc_p->ssc->regs, PDC_TCR, 0);
> + ssc_writel(ssc_p->ssc->regs, PDC_TNPR, 0);
> + ssc_writel(ssc_p->ssc->regs, PDC_TNCR, 0);
> + }
>
> ret = request_irq(ssc_p->ssc->irq, atmel_ssc_interrupt, 0,
> ssc_p->name, ssc_p);
--
~Vinod
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/