ENGR00309073-2 ASoC: fsl: Add new p2p struct for code ligibility

improve code ligibility.

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

2 files changed, 55 insertions, 43 deletions

diff --git a/sound/soc/fsl/fsl_asrc.c b/sound/soc/fsl/fsl_asrc.c
index 8d68f5a7468e..2d801cd66c1a 100644
--- a/sound/soc/fsl/fsl_asrc.c
+++ b/sound/soc/fsl/fsl_asrc.c
@@ -49,12 +49,12 @@ static int asrc_p2p_request_channel(struct snd_pcm_substream *substream)
         struct snd_dmaengine_dai_dma_data *dma_params_fe = NULL;
         struct imx_dma_data *fe_filter_data = NULL;
         struct imx_dma_data *be_filter_data = NULL;
-
+        struct fsl_asrc_p2p_params *p2p_params = &asrc_p2p->p2p_params[substream->stream];
+        enum asrc_pair_index asrc_index = p2p_params->asrc_index;
         struct dma_slave_config slave_config;
         dma_cap_mask_t mask;
-        struct dma_chan *chan;
-        int ret;
         struct snd_soc_dpcm *dpcm;
+        int ret;
 
         /* find the be for this fe stream */
         list_for_each_entry(dpcm, &rtd->dpcm[substream->stream].be_clients, list_be) {
@@ -80,6 +80,10 @@ static int asrc_p2p_request_channel(struct snd_pcm_substream *substream)
 
         fe_filter_data = dma_params_fe->filter_data;
         be_filter_data = dma_params_be->filter_data;
+        if (!fe_filter_data || !be_filter_data) {
+                dev_err(rtd->card->dev, "can't get be or fe filter data\n");
+                return -EINVAL;
+        }
 
         if (asrc_p2p->p2p_width == 16)
                 buswidth = DMA_SLAVE_BUSWIDTH_2_BYTES;
@@ -87,48 +91,43 @@ static int asrc_p2p_request_channel(struct snd_pcm_substream *substream)
                 buswidth = DMA_SLAVE_BUSWIDTH_4_BYTES;
 
         /* reconfig memory to FIFO dma request */
-        dma_params_fe->addr = asrc_p2p->asrc_ops.asrc_p2p_per_addr(
-                                                asrc_p2p->asrc_index, 1);
-        fe_filter_data->dma_request0 = asrc_p2p->dmarx[asrc_p2p->asrc_index];
+        dma_params_fe->addr = asrc_p2p->asrc_ops.asrc_p2p_per_addr(asrc_index, 1);
         dma_params_fe->maxburst = dma_params_be->maxburst;
+        fe_filter_data->dma_request0 = asrc_p2p->dmarx[asrc_index];
 
         dma_cap_zero(mask);
         dma_cap_set(DMA_SLAVE, mask);
         dma_cap_set(DMA_CYCLIC, mask);
 
         /* config p2p dma channel */
-        asrc_p2p->asrc_p2p_dma_data.peripheral_type = IMX_DMATYPE_ASRC;
-        asrc_p2p->asrc_p2p_dma_data.priority        = DMA_PRIO_HIGH;
-        asrc_p2p->asrc_p2p_dma_data.dma_request1    = asrc_p2p->dmatx[asrc_p2p->asrc_index];
+        p2p_params->dma_data.peripheral_type = IMX_DMATYPE_ASRC;
+        p2p_params->dma_data.priority        = DMA_PRIO_HIGH;
+        p2p_params->dma_data.dma_request1    = asrc_p2p->dmatx[asrc_index];
         /* need to get target device's dma dma_addr, burstsize */
-        asrc_p2p->asrc_p2p_dma_data.dma_request0    = be_filter_data->dma_request0;
+        p2p_params->dma_data.dma_request0    = be_filter_data->dma_request0;
 
         /* Request channel */
-        asrc_p2p->asrc_p2p_dma_chan =
-                dma_request_channel(mask, filter, &asrc_p2p->asrc_p2p_dma_data);
-
-        if (!asrc_p2p->asrc_p2p_dma_chan) {
+        p2p_params->dma_chan = dma_request_channel(mask, filter, &p2p_params->dma_data);
+        if (!p2p_params->dma_chan) {
                 dev_err(rtd->card->dev, "can not request dma channel\n");
                 goto error;
         }
-        chan = asrc_p2p->asrc_p2p_dma_chan;
 
         /*
          * Buswidth is not used in the sdma for p2p. Here we set the maxburst fix to
          * twice of dma_params's burstsize.
          */
         slave_config.direction      = DMA_DEV_TO_DEV;
-        slave_config.src_addr       = asrc_p2p->asrc_ops.asrc_p2p_per_addr(asrc_p2p->asrc_index, 0);
+        slave_config.src_addr       = asrc_p2p->asrc_ops.asrc_p2p_per_addr(asrc_index, 0);
         slave_config.src_addr_width = buswidth;
         slave_config.src_maxburst   = dma_params_be->maxburst * 2;
         slave_config.dst_addr       = dma_params_be->addr;
         slave_config.dst_addr_width = buswidth;
         slave_config.dst_maxburst   = dma_params_be->maxburst * 2;
         slave_config.dma_request0   = be_filter_data->dma_request0;
-        slave_config.dma_request1   = asrc_p2p->dmatx[asrc_p2p->asrc_index];
+        slave_config.dma_request1   = asrc_p2p->dmatx[asrc_index];
 
-        ret = dmaengine_slave_config(asrc_p2p->asrc_p2p_dma_chan,
-                                                        &slave_config);
+        ret = dmaengine_slave_config(p2p_params->dma_chan, &slave_config);
         if (ret) {
                 dev_err(rtd->card->dev, "can not config dma channel\n");
                 goto error;
@@ -136,9 +135,9 @@ static int asrc_p2p_request_channel(struct snd_pcm_substream *substream)
 
         return 0;
 error:
-        if (asrc_p2p->asrc_p2p_dma_chan) {
-                dma_release_channel(asrc_p2p->asrc_p2p_dma_chan);
-                asrc_p2p->asrc_p2p_dma_chan = NULL;
+        if (p2p_params->dma_chan) {
+                dma_release_channel(p2p_params->dma_chan);
+                p2p_params->dma_chan = NULL;
         }
 
         return -EINVAL;
@@ -150,6 +149,7 @@ static int config_asrc(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_asrc_p2p *asrc_p2p   = snd_soc_dai_get_drvdata(cpu_dai);
+        struct fsl_asrc_p2p_params *p2p_params = &asrc_p2p->p2p_params[substream->stream];
         unsigned int rate    = params_rate(params);
         unsigned int channel = params_channels(params);
         struct asrc_config config = {0};
@@ -161,7 +161,7 @@ static int config_asrc(struct snd_pcm_substream *substream,
                 return -EINVAL;
         }
 
-        ret = asrc_p2p->asrc_ops.asrc_p2p_req_pair(channel, &asrc_p2p->asrc_index);
+        ret = asrc_p2p->asrc_ops.asrc_p2p_req_pair(channel, &p2p_params->asrc_index);
         if (ret < 0) {
                 dev_err(cpu_dai->dev, "Fail to request asrc pair\n");
                 return -EINVAL;
@@ -201,12 +201,11 @@ static int config_asrc(struct snd_pcm_substream *substream,
 
         config.input_word_width   = word_width;
         config.output_word_width  = p2p_word_width;
-        config.pair               = asrc_p2p->asrc_index;
+        config.pair               = p2p_params->asrc_index;
         config.channel_num        = channel;
         config.input_sample_rate  = rate;
         config.output_sample_rate = asrc_p2p->p2p_rate;
         config.inclk              = INCLK_NONE;
-
         switch (asrc_p2p->per_dev) {
         case SSI1:
                 config.outclk    = OUTCLK_SSI1_TX;
@@ -251,18 +250,21 @@ static int fsl_asrc_p2p_hw_free(struct snd_pcm_substream *substream,
                               struct snd_soc_dai *cpu_dai)
 {
         struct fsl_asrc_p2p *asrc_p2p = snd_soc_dai_get_drvdata(cpu_dai);
+        struct fsl_asrc_p2p_params *p2p_params = &asrc_p2p->p2p_params[substream->stream];
+        struct dma_chan *chan = p2p_params->dma_chan;
+        enum asrc_pair_index asrc_index = p2p_params->asrc_index;
 
-        if (asrc_p2p->asrc_p2p_dma_chan) {
+        if (chan) {
                 /* Release p2p dma resource */
-                dma_release_channel(asrc_p2p->asrc_p2p_dma_chan);
-                asrc_p2p->asrc_p2p_dma_chan = NULL;
+                dma_release_channel(chan);
+                p2p_params->dma_chan = NULL;
         }
 
-        if (asrc_p2p->asrc_index != -1) {
-                asrc_p2p->asrc_ops.asrc_p2p_release_pair(asrc_p2p->asrc_index);
-                asrc_p2p->asrc_ops.asrc_p2p_finish_conv(asrc_p2p->asrc_index);
+        if (asrc_index != -1) {
+                asrc_p2p->asrc_ops.asrc_p2p_release_pair(asrc_index);
+                asrc_p2p->asrc_ops.asrc_p2p_finish_conv(asrc_index);
+                p2p_params->asrc_index = -1;
         }
-        asrc_p2p->asrc_index = -1;
 
         return 0;
 }
@@ -270,8 +272,9 @@ static int fsl_asrc_p2p_hw_free(struct snd_pcm_substream *substream,
 static int fsl_asrc_dma_prepare_and_submit(struct snd_pcm_substream *substream,
                                         struct fsl_asrc_p2p *asrc_p2p)
 {
-        struct dma_async_tx_descriptor *desc = asrc_p2p->asrc_p2p_desc;
-        struct dma_chan *chan = asrc_p2p->asrc_p2p_dma_chan;
+        struct fsl_asrc_p2p_params *p2p_params = &asrc_p2p->p2p_params[substream->stream];
+        struct dma_chan *chan = p2p_params->dma_chan;
+        struct dma_async_tx_descriptor *desc = p2p_params->desc;
         struct snd_soc_pcm_runtime *rtd = substream->private_data;
         struct device *dev = rtd->platform->dev;
 
@@ -290,6 +293,9 @@ static int fsl_asrc_p2p_trigger(struct snd_pcm_substream *substream, int cmd,
                             struct snd_soc_dai *cpu_dai)
 {
         struct fsl_asrc_p2p *asrc_p2p = snd_soc_dai_get_drvdata(cpu_dai);
+        struct fsl_asrc_p2p_params *p2p_params = &asrc_p2p->p2p_params[substream->stream];
+        struct dma_chan *chan = p2p_params->dma_chan;
+        enum asrc_pair_index asrc_index = p2p_params->asrc_index;
         int ret;
 
         switch (cmd) {
@@ -299,8 +305,8 @@ static int fsl_asrc_p2p_trigger(struct snd_pcm_substream *substream, int cmd,
                 ret = fsl_asrc_dma_prepare_and_submit(substream, asrc_p2p);
                 if (ret)
                         return ret;
-                dma_async_issue_pending(asrc_p2p->asrc_p2p_dma_chan);
-                asrc_p2p->asrc_ops.asrc_p2p_start_conv(asrc_p2p->asrc_index);
+                dma_async_issue_pending(chan);
+                asrc_p2p->asrc_ops.asrc_p2p_start_conv(asrc_index);
 
                 /* Output enough data to content the DMA burstsize of BE */
                 mdelay(1);
@@ -308,8 +314,8 @@ static int fsl_asrc_p2p_trigger(struct snd_pcm_substream *substream, int cmd,
         case SNDRV_PCM_TRIGGER_SUSPEND:
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
         case SNDRV_PCM_TRIGGER_STOP:
-                dmaengine_terminate_all(asrc_p2p->asrc_p2p_dma_chan);
-                asrc_p2p->asrc_ops.asrc_p2p_stop_conv(asrc_p2p->asrc_index);
+                dmaengine_terminate_all(chan);
+                asrc_p2p->asrc_ops.asrc_p2p_stop_conv(asrc_index);
                 break;
         default:
                 return -EINVAL;
@@ -491,7 +497,8 @@ static int fsl_asrc_p2p_probe(struct platform_device *pdev)
         asrc_p2p->asrc_ops.asrc_p2p_release_pair    = asrc_release_pair;
         asrc_p2p->asrc_ops.asrc_p2p_finish_conv     = asrc_finish_conv;
 
-        asrc_p2p->asrc_index = -1;
+        asrc_p2p->p2p_params[0].asrc_index = -1;
+        asrc_p2p->p2p_params[1].asrc_index = -1;
 
         iprop_rate = of_get_property(np, "fsl,p2p-rate", NULL);
         if (iprop_rate)
diff --git a/sound/soc/fsl/fsl_asrc.h b/sound/soc/fsl/fsl_asrc.h
index 857f7f0f93a7..fc518f12c553 100644
--- a/sound/soc/fsl/fsl_asrc.h
+++ b/sound/soc/fsl/fsl_asrc.h
@@ -22,10 +22,16 @@ enum peripheral_device_type {
         ESAI,
 };
 
+struct fsl_asrc_p2p_params {
+        enum asrc_pair_index asrc_index;
+        struct dma_async_tx_descriptor  *desc;
+        struct dma_chan                 *dma_chan;
+        struct imx_dma_data              dma_data;
+};
+
 struct fsl_asrc_p2p {
         int p2p_rate;
         int p2p_width;
-        enum asrc_pair_index asrc_index;
         enum peripheral_device_type per_dev;
         struct asrc_p2p_ops asrc_ops;
 
@@ -35,9 +41,8 @@ struct fsl_asrc_p2p {
         struct imx_dma_data filter_data_rx;
         struct snd_pcm_substream *substream[2];
 
-        struct dma_async_tx_descriptor  *asrc_p2p_desc;
-        struct dma_chan                 *asrc_p2p_dma_chan;
-        struct imx_dma_data              asrc_p2p_dma_data;
+        /* playback and record p2p params */
+        struct fsl_asrc_p2p_params p2p_params[2];
         struct platform_device *soc_platform_pdev;
 
         int dmarx[3];