ENGR00307835-3 ASoC: fsl: implement the ESAI xrun handler.

When esai xrun happened, there is possibility of channel swap. So ESAI
need to be reset.

Signed-off-by: Shengjiu Wang <b02247@freescale.com>

3 files changed, 160 insertions, 1 deletions

diff --git a/sound/soc/fsl/fsl_esai.c b/sound/soc/fsl/fsl_esai.c
index 6f6adcec7d41..762ac316fa32 100644
--- a/sound/soc/fsl/fsl_esai.c
+++ b/sound/soc/fsl/fsl_esai.c
@@ -35,6 +35,13 @@
 #define IMX_ESAI_NET            (1 << 0)
 #define IMX_ESAI_SYN            (1 << 1)
 
+static inline void write_esai_mask(u32 __iomem *addr, u32 clear, u32 set)
+{
+        u32 val = readl(addr);
+        val = (val & ~clear) | set;
+        writel(val, addr);
+}
+
 static int fsl_esai_set_dai_sysclk(struct snd_soc_dai *cpu_dai,
                                    int clk_id, unsigned int freq, int dir)
 {
@@ -308,6 +315,8 @@ static int fsl_esai_startup(struct snd_pcm_substream *substream,
         clk_enable(esai->clk);
         clk_prepare_enable(esai->dmaclk);
 
+        esai->substream[substream->stream] = substream;
+
         ESAI_DUMP();
         return 0;
 }
@@ -463,6 +472,8 @@ static void fsl_esai_shutdown(struct snd_pcm_substream *substream,
                 writel(0, esai->base + ESAI_PCRC);
         }
 
+        esai->substream[substream->stream] = NULL;
+
         clk_disable_unprepare(esai->dmaclk);
         clk_disable(esai->clk);
 }
@@ -578,6 +589,126 @@ static const struct snd_soc_component_driver fsl_esai_component = {
         .name           = "fsl-esai",
 };
 
+static bool fsl_esai_check_xrun(struct snd_pcm_substream *substream)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
+        struct fsl_esai *esai = snd_soc_dai_get_drvdata(cpu_dai);
+        u32 saisr = readl(esai->base + ESAI_SAISR);
+
+        return saisr & (ESAI_SAISR_TUE | ESAI_SAISR_ROE) ;
+}
+
+static int store_reg(struct snd_soc_dai *cpu_dai)
+{
+        struct fsl_esai *esai = snd_soc_dai_get_drvdata(cpu_dai);
+
+        esai->reg_cache[0] = readl(esai->base + ESAI_ECR);
+        esai->reg_cache[2] = readl(esai->base + ESAI_TFCR);
+        esai->reg_cache[4] = readl(esai->base + ESAI_RFCR);
+        esai->reg_cache[8] = readl(esai->base + ESAI_SAICR);
+        esai->reg_cache[9] = readl(esai->base + ESAI_TCR);
+        esai->reg_cache[10] = readl(esai->base + ESAI_TCCR);
+        esai->reg_cache[11] = readl(esai->base + ESAI_RCR);
+        esai->reg_cache[12] = readl(esai->base + ESAI_RCCR);
+        esai->reg_cache[13] = readl(esai->base + ESAI_TSMA);
+        esai->reg_cache[14] = readl(esai->base + ESAI_TSMB);
+        esai->reg_cache[15] = readl(esai->base + ESAI_RSMA);
+        esai->reg_cache[16] = readl(esai->base + ESAI_RSMB);
+        return 0;
+}
+
+static int restore_reg(struct snd_soc_dai *cpu_dai)
+{
+        struct fsl_esai *esai = snd_soc_dai_get_drvdata(cpu_dai);
+
+        writel(esai->reg_cache[0], esai->base + ESAI_ECR);
+        writel(esai->reg_cache[2] & ~ESAI_TFCR_TFEN, esai->base + ESAI_TFCR);
+        writel(esai->reg_cache[4] & ~ESAI_RFCR_RFEN, esai->base + ESAI_RFCR);
+        writel(esai->reg_cache[8], esai->base + ESAI_SAICR);
+        writel(esai->reg_cache[9] & ~ESAI_TCR_TE(12), esai->base + ESAI_TCR);
+        writel(esai->reg_cache[10], esai->base + ESAI_TCCR);
+        writel(esai->reg_cache[11] & ~ESAI_RCR_RE(8), esai->base + ESAI_RCR);
+        writel(esai->reg_cache[12], esai->base + ESAI_RCCR);
+        writel(esai->reg_cache[13], esai->base + ESAI_TSMA);
+        writel(esai->reg_cache[14], esai->base + ESAI_TSMB);
+        writel(esai->reg_cache[15], esai->base + ESAI_RSMA);
+        writel(esai->reg_cache[16], esai->base + ESAI_RSMB);
+        return 0;
+}
+
+static int stop_lock_stream(struct snd_pcm_substream *substream)
+{
+        if (substream) {
+                snd_pcm_stream_lock_irq(substream);
+                if (substream->runtime->status->state == SNDRV_PCM_STATE_RUNNING)
+                        substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_STOP);
+        }
+        return 0;
+}
+
+static int start_unlock_stream(struct snd_pcm_substream *substream)
+{
+        if (substream) {
+                if (substream->runtime->status->state == SNDRV_PCM_STATE_RUNNING)
+                        substream->ops->trigger(substream, SNDRV_PCM_TRIGGER_START);
+                snd_pcm_stream_unlock_irq(substream);
+        }
+        return 0;
+}
+
+/*
+ *Here is ESAI underrun reset step:
+ *1. Read "TUE" and got TUE=1
+ *2. stop DMA.
+ *3. stop ESAI TX section.
+ *4. Set the transmitter section individual reset "TPR=1"
+ *5. Reset the ESAI Transmit FIFO (set ESAI_TFCR[1]=1).
+ *6. Config the control registers ESAI_TCCR and ESAI_TCR.config the Transmit FIFO register.
+ *7. clear "TPR"
+ *8. read "TUE"
+ *9. Prefill ESAI TX FIFO.
+ *10.Start DMA.
+ *11 Enable the ESAI
+ */
+static void fsl_esai_reset(struct snd_pcm_substream *substream, bool stop)
+{
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
+        struct fsl_esai *esai = snd_soc_dai_get_drvdata(cpu_dai);
+        ESAI_DUMP();
+
+        if (stop) {
+                stop_lock_stream(esai->substream[0]);
+                stop_lock_stream(esai->substream[1]);
+        }
+
+        store_reg(cpu_dai);
+
+        writel(ESAI_ECR_ESAIEN | ESAI_ECR_ERST, esai->base + ESAI_ECR);
+        writel(ESAI_ECR_ESAIEN, esai->base + ESAI_ECR);
+
+        write_esai_mask(esai->base+ESAI_TCR, 0, ESAI_TCR_TPR);
+        write_esai_mask(esai->base+ESAI_RCR, 0, ESAI_RCR_RPR);
+
+        restore_reg(cpu_dai);
+
+        write_esai_mask(esai->base+ESAI_TCR, ESAI_TCR_TPR, 0);
+        write_esai_mask(esai->base+ESAI_RCR, ESAI_RCR_RPR, 0);
+
+        writel(ESAI_GPIO_ESAI, esai->base + ESAI_PRRC);
+        writel(ESAI_GPIO_ESAI, esai->base + ESAI_PCRC);
+
+        /* read "TUE" flag.*/
+        readl(esai->base + ESAI_SAISR);
+
+        if (stop) {
+                start_unlock_stream(esai->substream[1]);
+                start_unlock_stream(esai->substream[0]);
+        }
+        ESAI_DUMP();
+}
+
 static int fsl_esai_reg_init(struct fsl_esai *esai)
 {
         u32 xccr, slots = 2;
@@ -674,6 +805,11 @@ static int fsl_esai_probe(struct platform_device *pdev)
         esai->dma_params_tx.filter_data = &esai->filter_data_tx;
         esai->dma_params_rx.filter_data = &esai->filter_data_rx;
 
+        esai->dma_params_tx.check_xrun = fsl_esai_check_xrun;
+        esai->dma_params_rx.check_xrun = fsl_esai_check_xrun;
+        esai->dma_params_tx.device_reset = fsl_esai_reset;
+        esai->dma_params_rx.device_reset = fsl_esai_reset;
+
         ret = of_property_read_u32_array(pdev->dev.of_node,
                                 "fsl,esai-dma-events", dma_events, 2);
         if (ret) {
diff --git a/sound/soc/fsl/fsl_esai.h b/sound/soc/fsl/fsl_esai.h
index f0b6198a69a6..daf080641277 100644
--- a/sound/soc/fsl/fsl_esai.h
+++ b/sound/soc/fsl/fsl_esai.h
@@ -1,7 +1,7 @@
 /*
  * imx-esai.h  --  ESAI driver header file for Freescale IMX
  *
- * Copyright 2008-2013 Freescale Semiconductor, Inc. All Rights Reserved.
+ * Copyright 2008-2014 Freescale Semiconductor, Inc. All Rights Reserved.
  */
 
 /*
@@ -315,6 +315,7 @@
 #define IMX_DAI_ESAI_TX 0x04
 #define IMX_DAI_ESAI_RX 0x08
 #define IMX_DAI_ESAI_TXRX (IMX_DAI_ESAI_TX | IMX_DAI_ESAI_RX)
+#define REG_CACHE_NUM  20
 
 struct fsl_esai {
         struct clk *clk;
@@ -328,8 +329,10 @@ struct fsl_esai {
         struct snd_dmaengine_dai_dma_data dma_params_tx;
         struct imx_dma_data filter_data_tx;
         struct imx_dma_data filter_data_rx;
+        struct snd_pcm_substream *substream[2];
 
         char name[32];
+        u32 reg_cache[REG_CACHE_NUM];
 };
 
 #endif
diff --git a/sound/soc/fsl/imx-pcm-dma.c b/sound/soc/fsl/imx-pcm-dma.c
index 33752da05482..aa74383daa82 100644
--- a/sound/soc/fsl/imx-pcm-dma.c
+++ b/sound/soc/fsl/imx-pcm-dma.c
@@ -94,14 +94,34 @@ static void imx_pcm_dma_set_config_from_dai_data(
         }
 }
 
+static void imx_pcm_dma_complete(void *arg)
+{
+        struct snd_pcm_substream *substream = arg;
+        struct snd_soc_pcm_runtime *rtd = substream->private_data;
+        struct dmaengine_pcm_runtime_data *prtd = substream->runtime->private_data;
+        struct snd_dmaengine_dai_dma_data *dma_data;
+
+        prtd->pos += snd_pcm_lib_period_bytes(substream);
+        if (prtd->pos >= snd_pcm_lib_buffer_bytes(substream))
+                prtd->pos = 0;
+
+        snd_pcm_period_elapsed(substream);
+
+        dma_data = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
+        if (dma_data->check_xrun && dma_data->check_xrun(substream))
+                dma_data->device_reset(substream, 1);
+}
+
 static int imx_pcm_dma_prepare_slave_config(struct snd_pcm_substream *substream,
         struct snd_pcm_hw_params *params, struct dma_slave_config *slave_config)
 {
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct snd_dmaengine_dai_dma_data *dma_data;
+        struct dmaengine_pcm_runtime_data *prtd = substream->runtime->private_data;
         int ret;
 
         dma_data = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
+        prtd->callback = imx_pcm_dma_complete;
 
         ret = snd_hwparams_to_dma_slave_config(substream, params, slave_config);
         if (ret)