Commit e2f748e0 authored by Jose Abreu's avatar Jose Abreu Committed by Mark Brown
Browse files

ASoC: dwc: Add record capability in PIO mode 



Up until now PIO mode offered only playback support. With
this patch we add support for record mode. The PCM was
refactored so that we could reuse the existing infrastructure
without many changes.

We have support for 16 and 32 bits of sample size using
only 2 channels.

Tested in a x86_64 platform and in ARC AXS101 SDP platform.

Signed-off-by: default avatarJose Abreu <joabreu@synopsys.com>
Signed-off-by: default avatarMark Brown <broonie@kernel.org>
parent 6fce983f

sound/soc/dwc/designware_i2s.c

+7 −2
Original line number Diff line number Diff line
@@ -121,9 +121,14 @@ static irqreturn_t i2s_irq_handler(int irq, void *dev_id) 
			irq_valid = true;

		}



		/* Data available. Record mode not supported in PIO mode */

		if (isr[i] & ISR_RXDA)

		/*

		 * Data available. Retrieve samples from FIFO

		 * NOTE: Only two channels supported

		 */

		if ((isr[i] & ISR_RXDA) && (i == 0) && dev->use_pio) {

			dw_pcm_pop_rx(dev);

			irq_valid = true;

		}



		/* Error Handling: TX */

		if (isr[i] & ISR_TXFO) {

sound/soc/dwc/designware_pcm.c

+77 −20
Original line number Diff line number Diff line
@@ -41,10 +41,33 @@ static unsigned int dw_pcm_tx_##sample_bits(struct dw_i2s_dev *dev, \ 
	return tx_ptr; \

}



#define dw_pcm_rx_fn(sample_bits) \

static unsigned int dw_pcm_rx_##sample_bits(struct dw_i2s_dev *dev, \

		struct snd_pcm_runtime *runtime, unsigned int rx_ptr, \

		bool *period_elapsed) \

{ \

	u##sample_bits (*p)[2] = (void *)runtime->dma_area; \

	unsigned int period_pos = rx_ptr % runtime->period_size; \

	int i; \

\

	for (i = 0; i < dev->fifo_th; i++) { \

		p[rx_ptr][0] = ioread32(dev->i2s_base + LRBR_LTHR(0)); \

		p[rx_ptr][1] = ioread32(dev->i2s_base + RRBR_RTHR(0)); \

		period_pos++; \

		if (++rx_ptr >= runtime->buffer_size) \

			rx_ptr = 0; \

	} \

	*period_elapsed = period_pos >= runtime->period_size; \

	return rx_ptr; \

}



dw_pcm_tx_fn(16);

dw_pcm_tx_fn(32);

dw_pcm_rx_fn(16);

dw_pcm_rx_fn(32);



#undef dw_pcm_tx_fn

#undef dw_pcm_rx_fn



static const struct snd_pcm_hardware dw_pcm_hardware = {

	.info = SNDRV_PCM_INFO_INTERLEAVED |
@@ -68,27 +91,51 @@ static const struct snd_pcm_hardware dw_pcm_hardware = { 
	.fifo_size = 16,

};



void dw_pcm_push_tx(struct dw_i2s_dev *dev)

static void dw_pcm_transfer(struct dw_i2s_dev *dev, bool push)

{

	struct snd_pcm_substream *tx_substream;

	bool tx_active, period_elapsed;

	struct snd_pcm_substream *substream;

	bool active, period_elapsed;



	rcu_read_lock();

	tx_substream = rcu_dereference(dev->tx_substream);

	tx_active = tx_substream && snd_pcm_running(tx_substream);

	if (tx_active) {

		unsigned int tx_ptr = READ_ONCE(dev->tx_ptr);

		unsigned int new_tx_ptr = dev->tx_fn(dev, tx_substream->runtime,

				tx_ptr, &period_elapsed);

		cmpxchg(&dev->tx_ptr, tx_ptr, new_tx_ptr);

	if (push)

		substream = rcu_dereference(dev->tx_substream);

	else

		substream = rcu_dereference(dev->rx_substream);

	active = substream && snd_pcm_running(substream);

	if (active) {

		unsigned int ptr;

		unsigned int new_ptr;



		if (push) {

			ptr = READ_ONCE(dev->tx_ptr);

			new_ptr = dev->tx_fn(dev, substream->runtime, ptr,

					&period_elapsed);

			cmpxchg(&dev->tx_ptr, ptr, new_ptr);

		} else {

			ptr = READ_ONCE(dev->rx_ptr);

			new_ptr = dev->rx_fn(dev, substream->runtime, ptr,

					&period_elapsed);

			cmpxchg(&dev->rx_ptr, ptr, new_ptr);

		}



		if (period_elapsed)

			snd_pcm_period_elapsed(tx_substream);

			snd_pcm_period_elapsed(substream);

	}

	rcu_read_unlock();

}



void dw_pcm_push_tx(struct dw_i2s_dev *dev)

{

	dw_pcm_transfer(dev, true);

}

EXPORT_SYMBOL_GPL(dw_pcm_push_tx);



void dw_pcm_pop_rx(struct dw_i2s_dev *dev)

{

	dw_pcm_transfer(dev, false);

}

EXPORT_SYMBOL_GPL(dw_pcm_pop_rx);



static int dw_pcm_open(struct snd_pcm_substream *substream)

{

	struct snd_pcm_runtime *runtime = substream->runtime;
@@ -126,20 +173,17 @@ static int dw_pcm_hw_params(struct snd_pcm_substream *substream, 
	switch (params_format(hw_params)) {

	case SNDRV_PCM_FORMAT_S16_LE:

		dev->tx_fn = dw_pcm_tx_16;

		dev->rx_fn = dw_pcm_rx_16;

		break;

	case SNDRV_PCM_FORMAT_S32_LE:

		dev->tx_fn = dw_pcm_tx_32;

		dev->rx_fn = dw_pcm_rx_32;

		break;

	default:

		dev_err(dev->dev, "invalid format\n");

		return -EINVAL;

	}



	if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK) {

		dev_err(dev->dev, "only playback is available\n");

		return -EINVAL;

	}



	ret = snd_pcm_lib_malloc_pages(substream,

			params_buffer_bytes(hw_params));

	if (ret < 0)
@@ -163,13 +207,21 @@ static int dw_pcm_trigger(struct snd_pcm_substream *substream, int cmd) 
	case SNDRV_PCM_TRIGGER_START:

	case SNDRV_PCM_TRIGGER_RESUME:

	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:

		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {

			WRITE_ONCE(dev->tx_ptr, 0);

			rcu_assign_pointer(dev->tx_substream, substream);

		} else {

			WRITE_ONCE(dev->rx_ptr, 0);

			rcu_assign_pointer(dev->rx_substream, substream);

		}

		break;

	case SNDRV_PCM_TRIGGER_STOP:

	case SNDRV_PCM_TRIGGER_SUSPEND:

	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:

		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)

			rcu_assign_pointer(dev->tx_substream, NULL);

		else

			rcu_assign_pointer(dev->rx_substream, NULL);

		break;

	default:

		ret = -EINVAL;
@@ -183,7 +235,12 @@ static snd_pcm_uframes_t dw_pcm_pointer(struct snd_pcm_substream *substream) 
{

	struct snd_pcm_runtime *runtime = substream->runtime;

	struct dw_i2s_dev *dev = runtime->private_data;

	snd_pcm_uframes_t pos = READ_ONCE(dev->tx_ptr);

	snd_pcm_uframes_t pos;



	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)

		pos = READ_ONCE(dev->tx_ptr);

	else

		pos = READ_ONCE(dev->rx_ptr);



	return pos < runtime->buffer_size ? pos : 0;

}

sound/soc/dwc/local.h

+8 −1
Original line number Diff line number Diff line
@@ -105,20 +105,27 @@ struct dw_i2s_dev { 
	struct i2s_clk_config_data config;

	int (*i2s_clk_cfg)(struct i2s_clk_config_data *config);



	/* data related to PIO transfers (TX) */

	/* data related to PIO transfers */

	bool use_pio;

	struct snd_pcm_substream __rcu *tx_substream;

	struct snd_pcm_substream __rcu *rx_substream;

	unsigned int (*tx_fn)(struct dw_i2s_dev *dev,

			struct snd_pcm_runtime *runtime, unsigned int tx_ptr,

			bool *period_elapsed);

	unsigned int (*rx_fn)(struct dw_i2s_dev *dev,

			struct snd_pcm_runtime *runtime, unsigned int rx_ptr,

			bool *period_elapsed);

	unsigned int tx_ptr;

	unsigned int rx_ptr;

};



#if IS_ENABLED(CONFIG_SND_DESIGNWARE_PCM)

void dw_pcm_push_tx(struct dw_i2s_dev *dev);

void dw_pcm_pop_rx(struct dw_i2s_dev *dev);

int dw_pcm_register(struct platform_device *pdev);

#else

void dw_pcm_push_tx(struct dw_i2s_dev *dev) { }

void dw_pcm_pop_rx(struct dw_i2s_dev *dev) { }

int dw_pcm_register(struct platform_device *pdev)

{

	return -EINVAL;

CRA Git | Maintained and supported by SUSTech CRA and CCSE