On Mon, Sep 09, 2019 at 06:33:19PM -0400, Shengjiu Wang wrote:

snd_pcm_format_t is more formal than enum asrc_word_width, which has two property, width and physical width, which is more accurate than enum asrc_word_width. So it is better to use in(out)put_format instead of in(out)put_word_width.

Signed-off-by: Shengjiu Wang shengjiu.wang@nxp.com

Acked-by: Nicolin Chen nicoleotsuka@gmail.com

---

sound/soc/fsl/fsl_asrc.c | 56 +++++++++++++++++++++++++++------------- sound/soc/fsl/fsl_asrc.h | 4 +-- 2 files changed, 40 insertions(+), 20 deletions(-)

diff --git a/sound/soc/fsl/fsl_asrc.c b/sound/soc/fsl/fsl_asrc.c index cfa40ef6b1ca..4d3804a1ea55 100644 --- a/sound/soc/fsl/fsl_asrc.c +++ b/sound/soc/fsl/fsl_asrc.c @@ -265,6 +265,8 @@ static int fsl_asrc_config_pair(struct fsl_asrc_pair *pair) struct asrc_config *config = pair->config; struct fsl_asrc *asrc_priv = pair->asrc_priv; enum asrc_pair_index index = pair->index;

• enum asrc_word_width input_word_width;
• enum asrc_word_width output_word_width; u32 inrate, outrate, indiv, outdiv; u32 clk_index[2], div[2]; int in, out, channels;

@@ -283,9 +285,32 @@ static int fsl_asrc_config_pair(struct fsl_asrc_pair *pair) return -EINVAL; }

• /* Validate output width */
• if (config->output_word_width == ASRC_WIDTH_8_BIT) {

• pair_err("does not support 8bit width output\n");
  

• switch (snd_pcm_format_width(config->input_format)) {
• case 8:

• input_word_width = ASRC_WIDTH_8_BIT;
  

• break;
  

• case 16:

• input_word_width = ASRC_WIDTH_16_BIT;
  

• break;
  

• case 24:

• input_word_width = ASRC_WIDTH_24_BIT;
  

• break;
  

• default:

• pair_err("does not support this input format, %d\n",
  

• 	 config->input_format);
  

• return -EINVAL;
  

• }
• switch (snd_pcm_format_width(config->output_format)) {
• case 16:

• output_word_width = ASRC_WIDTH_16_BIT;
  

• break;
  

• case 24:

• output_word_width = ASRC_WIDTH_24_BIT;
  

• break;
  

• default:

• pair_err("does not support this output format, %d\n",
  

• 	 config->output_format);
  

  return -EINVAL; }

@@ -383,8 +408,8 @@ static int fsl_asrc_config_pair(struct fsl_asrc_pair *pair) /* Implement word_width configurations */ regmap_update_bits(asrc_priv->regmap, REG_ASRMCR1(index), ASRMCR1i_OW16_MASK | ASRMCR1i_IWD_MASK,

• 	   ASRMCR1i_OW16(config->output_word_width) |
  

• 	   ASRMCR1i_IWD(config->input_word_width));
  

• 	   ASRMCR1i_OW16(output_word_width) |
  

• 	   ASRMCR1i_IWD(input_word_width));
  
  

  /* Enable BUFFER STALL */ regmap_update_bits(asrc_priv->regmap, REG_ASRMCR(index),

@@ -497,13 +522,13 @@ static int fsl_asrc_dai_hw_params(struct snd_pcm_substream *substream, struct snd_soc_dai *dai) { struct fsl_asrc *asrc_priv = snd_soc_dai_get_drvdata(dai);

• int width = params_width(params); struct snd_pcm_runtime *runtime = substream->runtime; struct fsl_asrc_pair *pair = runtime->private_data; unsigned int channels = params_channels(params); unsigned int rate = params_rate(params); struct asrc_config config;
• int word_width, ret;

• snd_pcm_format_t format;

• int ret;

  ret = fsl_asrc_request_pair(channels, pair); if (ret) {

@@ -513,15 +538,10 @@ static int fsl_asrc_dai_hw_params(struct snd_pcm_substream *substream,

pair->config = &config;

• if (width == 16)

• width = ASRC_WIDTH_16_BIT;
  

• else

• width = ASRC_WIDTH_24_BIT;
  

• if (asrc_priv->asrc_width == 16)

• word_width = ASRC_WIDTH_16_BIT;
  

• format = SNDRV_PCM_FORMAT_S16_LE;
  

  else

• word_width = ASRC_WIDTH_24_BIT;
  

• format = SNDRV_PCM_FORMAT_S24_LE;
  
  

  config.pair = pair->index; config.channel_num = channels;

@@ -529,13 +549,13 @@ static int fsl_asrc_dai_hw_params(struct snd_pcm_substream *substream, config.outclk = OUTCLK_ASRCK1_CLK;

if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {

• config.input_word_width   = width;
  

• config.output_word_width  = word_width;
  

• config.input_format   = params_format(params);
  

• config.output_format  = format;
  

  config.input_sample_rate = rate; config.output_sample_rate = asrc_priv->asrc_rate; } else {

• config.input_word_width   = word_width;
  

• config.output_word_width  = width;
  

• config.input_format   = format;
  

• config.output_format  = params_format(params);
  

  config.input_sample_rate = asrc_priv->asrc_rate; config.output_sample_rate = rate; }

diff --git a/sound/soc/fsl/fsl_asrc.h b/sound/soc/fsl/fsl_asrc.h index c60075112570..38af485bdd22 100644 --- a/sound/soc/fsl/fsl_asrc.h +++ b/sound/soc/fsl/fsl_asrc.h @@ -342,8 +342,8 @@ struct asrc_config { unsigned int dma_buffer_size; unsigned int input_sample_rate; unsigned int output_sample_rate;

• enum asrc_word_width input_word_width;
• enum asrc_word_width output_word_width;

• snd_pcm_format_t input_format;
• snd_pcm_format_t output_format; enum asrc_inclk inclk; enum asrc_outclk outclk;

};

2.21.0

On Mon, Sep 09, 2019 at 06:33:20PM -0400, Shengjiu Wang wrote:

The ASRC support 24bit/16bit/8bit input width, so S20_3LE format should not be supported, it is word width is 20bit.

I thought 3LE used 24-bit physical width. And the driver assigns ASRC_WIDTH_24_BIT to "width" for all non-16bit cases, so 20-bit would go for that 24-bit slot also. I don't clearly recall if I had explicitly tested S20_3LE, but I feel it should work since I put there...

Thanks Nicolin

So replace S20_3LE with S24_3LE in supported list and add S8 format in TX supported list

Signed-off-by: Shengjiu Wang shengjiu.wang@nxp.com

sound/soc/fsl/fsl_asrc.c | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/sound/soc/fsl/fsl_asrc.c b/sound/soc/fsl/fsl_asrc.c index 4d3804a1ea55..584badf956d2 100644 --- a/sound/soc/fsl/fsl_asrc.c +++ b/sound/soc/fsl/fsl_asrc.c @@ -624,7 +624,7 @@ static int fsl_asrc_dai_probe(struct snd_soc_dai *dai)

#define FSL_ASRC_FORMATS (SNDRV_PCM_FMTBIT_S24_LE | \ SNDRV_PCM_FMTBIT_S16_LE | \

• 		 SNDRV_PCM_FMTBIT_S20_3LE)
  

• 		 SNDRV_PCM_FMTBIT_S24_3LE)
  
  

static struct snd_soc_dai_driver fsl_asrc_dai = { .probe = fsl_asrc_dai_probe, @@ -635,7 +635,8 @@ static struct snd_soc_dai_driver fsl_asrc_dai = { .rate_min = 5512, .rate_max = 192000, .rates = SNDRV_PCM_RATE_KNOT,

• .formats = FSL_ASRC_FORMATS,
  

• .formats = FSL_ASRC_FORMATS |
  

• 	   SNDRV_PCM_FMTBIT_S8,
  

  }, .capture = { .stream_name = "ASRC-Capture",

-- 2.21.0

On Mon, Sep 09, 2019 at 06:33:21PM -0400, Shengjiu Wang wrote:

There is error "aplay: pcm_write:2023: write error: Input/output error" on i.MX8QM/i.MX8QXP platform for S24_3LE format.

In i.MX8QM/i.MX8QXP, the DMA is EDMA, which don't support 24bit sample, but we didn't add any constraint, that cause issues.

So we need to query the caps of dma, then update the hw parameters according to the caps.

@@ -285,8 +293,81 @@ static int fsl_asrc_dma_startup(struct snd_pcm_substream *substream)

runtime->private_data = pair;

• snd_pcm_hw_constraint_integer(substream->runtime,

• 		      SNDRV_PCM_HW_PARAM_PERIODS);
  

• ret = snd_pcm_hw_constraint_integer(substream->runtime,

• 			    SNDRV_PCM_HW_PARAM_PERIODS);
  

• if (ret < 0) {

• dev_err(dev, "failed to set pcm hw params periods\n");
  

• return ret;
  

• }
• dma_data = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
• /* Request a temp pair, which is release in the end */
• fsl_asrc_request_pair(1, pair);

Not sure if it'd be practical, but a pair request could fail. Will probably need to check return value.

And a quick feeling is that below code is mostly identical to what is in the soc-generic-dmaengine-pcm.c file. So I'm wondering if we could abstract a helper function somewhere in the ASoC core: Mark?

Thanks Nicolin

• tmp_chan = fsl_asrc_get_dma_channel(pair, dir);

• if (!tmp_chan) {

• dev_err(dev, "can't get dma channel\n");
  

• return -EINVAL;
  

• }

• ret = dma_get_slave_caps(tmp_chan, &dma_caps);

• if (ret == 0) {

• if (dma_caps.cmd_pause)
  

• 	snd_imx_hardware.info |= SNDRV_PCM_INFO_PAUSE |
  

• 				 SNDRV_PCM_INFO_RESUME;
  

• if (dma_caps.residue_granularity <=
  

• 	DMA_RESIDUE_GRANULARITY_SEGMENT)
  

• 	snd_imx_hardware.info |= SNDRV_PCM_INFO_BATCH;
  

• if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
  

• 	addr_widths = dma_caps.dst_addr_widths;
  

• else
  

• 	addr_widths = dma_caps.src_addr_widths;
  

• }

• /*

• * If SND_DMAENGINE_PCM_DAI_FLAG_PACK is set keep
  

• * hw.formats set to 0, meaning no restrictions are in place.
  

• * In this case it's the responsibility of the DAI driver to
  

• * provide the supported format information.
  

• */
  

• if (!(dma_data->flags & SND_DMAENGINE_PCM_DAI_FLAG_PACK))

• /*
  

•  * Prepare formats mask for valid/allowed sample types. If the
  

•  * dma does not have support for the given physical word size,
  

•  * it needs to be masked out so user space can not use the
  

•  * format which produces corrupted audio.
  

•  * In case the dma driver does not implement the slave_caps the
  

•  * default assumption is that it supports 1, 2 and 4 bytes
  

•  * widths.
  

•  */
  

• for (i = 0; i <= SNDRV_PCM_FORMAT_LAST; i++) {
  

• 	int bits = snd_pcm_format_physical_width(i);
  

• 	/*
  

• 	 * Enable only samples with DMA supported physical
  

• 	 * widths
  

• 	 */
  

• 	switch (bits) {
  

• 	case 8:
  

• 	case 16:
  

• 	case 24:
  

• 	case 32:
  

• 	case 64:
  

• 		if (addr_widths & (1 << (bits / 8)))
  

• 			snd_imx_hardware.formats |= (1LL << i);
  

• 		break;
  

• 	default:
  

• 		/* Unsupported types */
  

• 		break;
  

• 	}
  

• }
  

• if (tmp_chan)

• dma_release_channel(tmp_chan);
  

• fsl_asrc_release_pair(pair);

• snd_soc_set_runtime_hwparams(substream, &snd_imx_hardware);

  return 0;

-- 2.21.0