[mirror_ubuntu-focal-kernel.git] / sound / soc / kirkwood / kirkwood-dma.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * kirkwood-dma.c
 *
 * (c) 2010 Arnaud Patard <apatard@mandriva.com>
 * (c) 2010 Arnaud Patard <arnaud.patard@rtp-net.org>
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/io.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/dma-mapping.h>
#include <linux/mbus.h>
#include <sound/soc.h>
#include "kirkwood.h"

static struct kirkwood_dma_data *kirkwood_priv(struct snd_pcm_substream *subs)
{
	struct snd_soc_pcm_runtime *soc_runtime = subs->private_data;
	return snd_soc_dai_get_drvdata(soc_runtime->cpu_dai);
}

static const struct snd_pcm_hardware kirkwood_dma_snd_hw = {
	.info = SNDRV_PCM_INFO_INTERLEAVED |
		SNDRV_PCM_INFO_MMAP |
		SNDRV_PCM_INFO_MMAP_VALID |
		SNDRV_PCM_INFO_BLOCK_TRANSFER |
		SNDRV_PCM_INFO_PAUSE |
		SNDRV_PCM_INFO_NO_PERIOD_WAKEUP,
	.buffer_bytes_max	= KIRKWOOD_SND_MAX_BUFFER_BYTES,
	.period_bytes_min	= KIRKWOOD_SND_MIN_PERIOD_BYTES,
	.period_bytes_max	= KIRKWOOD_SND_MAX_PERIOD_BYTES,
	.periods_min		= KIRKWOOD_SND_MIN_PERIODS,
	.periods_max		= KIRKWOOD_SND_MAX_PERIODS,
	.fifo_size		= 0,
};

static irqreturn_t kirkwood_dma_irq(int irq, void *dev_id)
{
	struct kirkwood_dma_data *priv = dev_id;
	unsigned long mask, status, cause;

	mask = readl(priv->io + KIRKWOOD_INT_MASK);
	status = readl(priv->io + KIRKWOOD_INT_CAUSE) & mask;

	cause = readl(priv->io + KIRKWOOD_ERR_CAUSE);
	if (unlikely(cause)) {
		printk(KERN_WARNING "%s: got err interrupt 0x%lx\n",
				__func__, cause);
		writel(cause, priv->io + KIRKWOOD_ERR_CAUSE);
	}

	/* we've enabled only bytes interrupts ... */
	if (status & ~(KIRKWOOD_INT_CAUSE_PLAY_BYTES | \
			KIRKWOOD_INT_CAUSE_REC_BYTES)) {
		printk(KERN_WARNING "%s: unexpected interrupt %lx\n",
			__func__, status);
		return IRQ_NONE;
	}

	/* ack int */
	writel(status, priv->io + KIRKWOOD_INT_CAUSE);

	if (status & KIRKWOOD_INT_CAUSE_PLAY_BYTES)
		snd_pcm_period_elapsed(priv->substream_play);

	if (status & KIRKWOOD_INT_CAUSE_REC_BYTES)
		snd_pcm_period_elapsed(priv->substream_rec);

	return IRQ_HANDLED;
}

static void
kirkwood_dma_conf_mbus_windows(void __iomem *base, int win,
			       unsigned long dma,
			       const struct mbus_dram_target_info *dram)
{
	int i;

	/* First disable and clear windows */
	writel(0, base + KIRKWOOD_AUDIO_WIN_CTRL_REG(win));
	writel(0, base + KIRKWOOD_AUDIO_WIN_BASE_REG(win));

	/* try to find matching cs for current dma address */
	for (i = 0; i < dram->num_cs; i++) {
		const struct mbus_dram_window *cs = dram->cs + i;
		if ((cs->base & 0xffff0000) < (dma & 0xffff0000)) {
			writel(cs->base & 0xffff0000,
				base + KIRKWOOD_AUDIO_WIN_BASE_REG(win));
			writel(((cs->size - 1) & 0xffff0000) |
				(cs->mbus_attr << 8) |
				(dram->mbus_dram_target_id << 4) | 1,
				base + KIRKWOOD_AUDIO_WIN_CTRL_REG(win));
		}
	}
}

static int kirkwood_dma_open(struct snd_pcm_substream *substream)
{
	int err;
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct kirkwood_dma_data *priv = kirkwood_priv(substream);
	const struct mbus_dram_target_info *dram;
	unsigned long addr;

	snd_soc_set_runtime_hwparams(substream, &kirkwood_dma_snd_hw);

	/* Ensure that all constraints linked to dma burst are fulfilled */
	err = snd_pcm_hw_constraint_minmax(runtime,
			SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
			priv->burst * 2,
			KIRKWOOD_AUDIO_BUF_MAX-1);
	if (err < 0)
		return err;

	err = snd_pcm_hw_constraint_step(runtime, 0,
			SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
			priv->burst);
	if (err < 0)
		return err;

	err = snd_pcm_hw_constraint_step(substream->runtime, 0,
			 SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
			 priv->burst);
	if (err < 0)
		return err;

	if (!priv->substream_play && !priv->substream_rec) {
		err = request_irq(priv->irq, kirkwood_dma_irq, IRQF_SHARED,
				  "kirkwood-i2s", priv);
		if (err)
			return -EBUSY;

		/*
		 * Enable Error interrupts. We're only ack'ing them but
		 * it's useful for diagnostics
		 */
		writel((unsigned int)-1, priv->io + KIRKWOOD_ERR_MASK);
	}

	dram = mv_mbus_dram_info();
	addr = substream->dma_buffer.addr;
	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
		if (priv->substream_play)
			return -EBUSY;
		priv->substream_play = substream;
		kirkwood_dma_conf_mbus_windows(priv->io,
			KIRKWOOD_PLAYBACK_WIN, addr, dram);
	} else {
		if (priv->substream_rec)
			return -EBUSY;
		priv->substream_rec = substream;
		kirkwood_dma_conf_mbus_windows(priv->io,
			KIRKWOOD_RECORD_WIN, addr, dram);
	}

	return 0;
}

static int kirkwood_dma_close(struct snd_pcm_substream *substream)
{
	struct kirkwood_dma_data *priv = kirkwood_priv(substream);

	if (!priv)
		return 0;

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
		priv->substream_play = NULL;
	else
		priv->substream_rec = NULL;

	if (!priv->substream_play && !priv->substream_rec) {
		writel(0, priv->io + KIRKWOOD_ERR_MASK);
		free_irq(priv->irq, priv);
	}

	return 0;
}

static int kirkwood_dma_hw_params(struct snd_pcm_substream *substream,
				struct snd_pcm_hw_params *params)
{
	struct snd_pcm_runtime *runtime = substream->runtime;

	snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
	runtime->dma_bytes = params_buffer_bytes(params);

	return 0;
}

static int kirkwood_dma_hw_free(struct snd_pcm_substream *substream)
{
	snd_pcm_set_runtime_buffer(substream, NULL);
	return 0;
}

static int kirkwood_dma_prepare(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct kirkwood_dma_data *priv = kirkwood_priv(substream);
	unsigned long size, count;

	/* compute buffer size in term of "words" as requested in specs */
	size = frames_to_bytes(runtime, runtime->buffer_size);
	size = (size>>2)-1;
	count = snd_pcm_lib_period_bytes(substream);

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
		writel(count, priv->io + KIRKWOOD_PLAY_BYTE_INT_COUNT);
		writel(runtime->dma_addr, priv->io + KIRKWOOD_PLAY_BUF_ADDR);
		writel(size, priv->io + KIRKWOOD_PLAY_BUF_SIZE);
	} else {
		writel(count, priv->io + KIRKWOOD_REC_BYTE_INT_COUNT);
		writel(runtime->dma_addr, priv->io + KIRKWOOD_REC_BUF_ADDR);
		writel(size, priv->io + KIRKWOOD_REC_BUF_SIZE);
	}


	return 0;
}

static snd_pcm_uframes_t kirkwood_dma_pointer(struct snd_pcm_substream
						*substream)
{
	struct kirkwood_dma_data *priv = kirkwood_priv(substream);
	snd_pcm_uframes_t count;

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
		count = bytes_to_frames(substream->runtime,
			readl(priv->io + KIRKWOOD_PLAY_BYTE_COUNT));
	else
		count = bytes_to_frames(substream->runtime,
			readl(priv->io + KIRKWOOD_REC_BYTE_COUNT));

	return count;
}

static const struct snd_pcm_ops kirkwood_dma_ops = {
	.open =		kirkwood_dma_open,
	.close =        kirkwood_dma_close,
	.ioctl =	snd_pcm_lib_ioctl,
	.hw_params =	kirkwood_dma_hw_params,
	.hw_free =      kirkwood_dma_hw_free,
	.prepare =      kirkwood_dma_prepare,
	.pointer =	kirkwood_dma_pointer,
};

static int kirkwood_dma_preallocate_dma_buffer(struct snd_pcm *pcm,
		int stream)
{
	struct snd_pcm_substream *substream = pcm->streams[stream].substream;
	struct snd_dma_buffer *buf = &substream->dma_buffer;
	size_t size = kirkwood_dma_snd_hw.buffer_bytes_max;

	buf->dev.type = SNDRV_DMA_TYPE_DEV;
	buf->dev.dev = pcm->card->dev;
	buf->area = dma_alloc_coherent(pcm->card->dev, size,
			&buf->addr, GFP_KERNEL);
	if (!buf->area)
		return -ENOMEM;
	buf->bytes = size;
	buf->private_data = NULL;

	return 0;
}

static int kirkwood_dma_new(struct snd_soc_pcm_runtime *rtd)
{
	struct snd_card *card = rtd->card->snd_card;
	struct snd_pcm *pcm = rtd->pcm;
	int ret;

	ret = dma_coerce_mask_and_coherent(card->dev, DMA_BIT_MASK(32));
	if (ret)
		return ret;

	if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream) {
		ret = kirkwood_dma_preallocate_dma_buffer(pcm,
				SNDRV_PCM_STREAM_PLAYBACK);
		if (ret)
			return ret;
	}

	if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) {
		ret = kirkwood_dma_preallocate_dma_buffer(pcm,
				SNDRV_PCM_STREAM_CAPTURE);
		if (ret)
			return ret;
	}

	return 0;
}

static void kirkwood_dma_free_dma_buffers(struct snd_pcm *pcm)
{
	struct snd_pcm_substream *substream;
	struct snd_dma_buffer *buf;
	int stream;

	for (stream = 0; stream < 2; stream++) {
		substream = pcm->streams[stream].substream;
		if (!substream)
			continue;
		buf = &substream->dma_buffer;
		if (!buf->area)
			continue;

		dma_free_coherent(pcm->card->dev, buf->bytes,
				buf->area, buf->addr);
		buf->area = NULL;
	}
}

const struct snd_soc_component_driver kirkwood_soc_component = {
	.name		= DRV_NAME,
	.ops		= &kirkwood_dma_ops,
	.pcm_new	= kirkwood_dma_new,
	.pcm_free	= kirkwood_dma_free_dma_buffers,
};
Commit	Line	Data
2874c5fd	1	// SPDX-License-Identifier: GPL-2.0-or-later
f9b95980	2	/*
	3	* kirkwood-dma.c
	4	*
	5	* (c) 2010 Arnaud Patard <apatard@mandriva.com>
69737897	6	* (c) 2010 Arnaud Patard <arnaud.patard@rtp-net.org>
f9b95980	7	*/
	8
	9	#include <linux/init.h>
	10	#include <linux/module.h>
	11	#include <linux/device.h>
	12	#include <linux/io.h>
	13	#include <linux/slab.h>
	14	#include <linux/interrupt.h>
	15	#include <linux/dma-mapping.h>
	16	#include <linux/mbus.h>
	17	#include <sound/soc.h>
f9b95980	18	#include "kirkwood.h"
f9b95980	19
a7d09429 RK	20	static struct kirkwood_dma_data kirkwood_priv(struct snd_pcm_substream subs)
	21	{
	22	struct snd_soc_pcm_runtime *soc_runtime = subs->private_data;
	23	return snd_soc_dai_get_drvdata(soc_runtime->cpu_dai);
	24	}
f9b95980	25
636d7e28	26	static const struct snd_pcm_hardware kirkwood_dma_snd_hw = {
920ec4e5 RK	27	.info = SNDRV_PCM_INFO_INTERLEAVED \|
	28	SNDRV_PCM_INFO_MMAP \|
	29	SNDRV_PCM_INFO_MMAP_VALID \|
	30	SNDRV_PCM_INFO_BLOCK_TRANSFER \|
	31	SNDRV_PCM_INFO_PAUSE \|
	32	SNDRV_PCM_INFO_NO_PERIOD_WAKEUP,
e4065f3f	33	.buffer_bytes_max = KIRKWOOD_SND_MAX_BUFFER_BYTES,
f9b95980	34	.period_bytes_min = KIRKWOOD_SND_MIN_PERIOD_BYTES,
	35	.period_bytes_max = KIRKWOOD_SND_MAX_PERIOD_BYTES,
	36	.periods_min = KIRKWOOD_SND_MIN_PERIODS,
	37	.periods_max = KIRKWOOD_SND_MAX_PERIODS,
	38	.fifo_size = 0,
	39	};
	40
f9b95980	41	static irqreturn_t kirkwood_dma_irq(int irq, void *dev_id)
f9b95980	42	{
a7d09429	43	struct kirkwood_dma_data *priv = dev_id;
f9b95980	44	unsigned long mask, status, cause;
	45
	46	mask = readl(priv->io + KIRKWOOD_INT_MASK);
	47	status = readl(priv->io + KIRKWOOD_INT_CAUSE) & mask;
	48
	49	cause = readl(priv->io + KIRKWOOD_ERR_CAUSE);
	50	if (unlikely(cause)) {
	51	printk(KERN_WARNING "%s: got err interrupt 0x%lx\n",
	52	__func__, cause);
	53	writel(cause, priv->io + KIRKWOOD_ERR_CAUSE);
f9b95980	54	}
	55
	56	/* we've enabled only bytes interrupts ... */
	57	if (status & ~(KIRKWOOD_INT_CAUSE_PLAY_BYTES \| \
	58	KIRKWOOD_INT_CAUSE_REC_BYTES)) {
	59	printk(KERN_WARNING "%s: unexpected interrupt %lx\n",
	60	__func__, status);
	61	return IRQ_NONE;
	62	}
	63
	64	/* ack int */
	65	writel(status, priv->io + KIRKWOOD_INT_CAUSE);
	66
	67	if (status & KIRKWOOD_INT_CAUSE_PLAY_BYTES)
a7d09429	68	snd_pcm_period_elapsed(priv->substream_play);
f9b95980	69
f9b95980	70	if (status & KIRKWOOD_INT_CAUSE_REC_BYTES)
a7d09429	71	snd_pcm_period_elapsed(priv->substream_rec);
f9b95980	72
	73	return IRQ_HANDLED;
	74	}
	75
63a9332b AL	76	static void
	77	kirkwood_dma_conf_mbus_windows(void __iomem *base, int win,
	78	unsigned long dma,
	79	const struct mbus_dram_target_info *dram)
f9b95980	80	{
	81	int i;
	82
	83	/* First disable and clear windows */
	84	writel(0, base + KIRKWOOD_AUDIO_WIN_CTRL_REG(win));
	85	writel(0, base + KIRKWOOD_AUDIO_WIN_BASE_REG(win));
	86
	87	/* try to find matching cs for current dma address */
	88	for (i = 0; i < dram->num_cs; i++) {
63a9332b	89	const struct mbus_dram_window *cs = dram->cs + i;
f9b95980	90	if ((cs->base & 0xffff0000) < (dma & 0xffff0000)) {
	91	writel(cs->base & 0xffff0000,
	92	base + KIRKWOOD_AUDIO_WIN_BASE_REG(win));
	93	writel(((cs->size - 1) & 0xffff0000) \|
	94	(cs->mbus_attr << 8) \|
	95	(dram->mbus_dram_target_id << 4) \| 1,
	96	base + KIRKWOOD_AUDIO_WIN_CTRL_REG(win));
	97	}
	98	}
	99	}
	100
	101	static int kirkwood_dma_open(struct snd_pcm_substream *substream)
	102	{
	103	int err;
	104	struct snd_pcm_runtime *runtime = substream->runtime;
a7d09429	105	struct kirkwood_dma_data *priv = kirkwood_priv(substream);
63a9332b	106	const struct mbus_dram_target_info *dram;
f9b95980	107	unsigned long addr;
f9b95980	108
f9b95980	109	snd_soc_set_runtime_hwparams(substream, &kirkwood_dma_snd_hw);
f9b95980	110
25985edc	111	/* Ensure that all constraints linked to dma burst are fulfilled */
f9b95980	112	err = snd_pcm_hw_constraint_minmax(runtime,
	113	SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
	114	priv->burst * 2,
	115	KIRKWOOD_AUDIO_BUF_MAX-1);
	116	if (err < 0)
	117	return err;
	118
	119	err = snd_pcm_hw_constraint_step(runtime, 0,
	120	SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
	121	priv->burst);
	122	if (err < 0)
	123	return err;
	124
	125	err = snd_pcm_hw_constraint_step(substream->runtime, 0,
	126	SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
	127	priv->burst);
	128	if (err < 0)
	129	return err;
	130
a7d09429	131	if (!priv->substream_play && !priv->substream_rec) {
f9b95980	132	err = request_irq(priv->irq, kirkwood_dma_irq, IRQF_SHARED,
a7d09429 RK	133	"kirkwood-i2s", priv);
a7d09429 RK	134	if (err)
f9b95980	135	return -EBUSY;
f9b95980	136
	137	/*
	138	* Enable Error interrupts. We're only ack'ing them but
25985edc	139	* it's useful for diagnostics
f9b95980	140	*/
e2c9917b	141	writel((unsigned int)-1, priv->io + KIRKWOOD_ERR_MASK);
f9b95980	142	}
f9b95980	143
63a9332b	144	dram = mv_mbus_dram_info();
ae6a5d37	145	addr = substream->dma_buffer.addr;
f9b95980	146	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
c4a42915 JFM	147	if (priv->substream_play)
c4a42915 JFM	148	return -EBUSY;
a7d09429	149	priv->substream_play = substream;
f9b95980	150	kirkwood_dma_conf_mbus_windows(priv->io,
63a9332b	151	KIRKWOOD_PLAYBACK_WIN, addr, dram);
f9b95980	152	} else {
c4a42915 JFM	153	if (priv->substream_rec)
c4a42915 JFM	154	return -EBUSY;
a7d09429	155	priv->substream_rec = substream;
f9b95980	156	kirkwood_dma_conf_mbus_windows(priv->io,
63a9332b	157	KIRKWOOD_RECORD_WIN, addr, dram);
f9b95980	158	}
	159
	160	return 0;
	161	}
	162
	163	static int kirkwood_dma_close(struct snd_pcm_substream *substream)
	164	{
a7d09429	165	struct kirkwood_dma_data *priv = kirkwood_priv(substream);
f9b95980	166
a7d09429	167	if (!priv)
f9b95980	168	return 0;
	169
	170	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
a7d09429	171	priv->substream_play = NULL;
f9b95980	172	else
a7d09429	173	priv->substream_rec = NULL;
f9b95980	174
a7d09429	175	if (!priv->substream_play && !priv->substream_rec) {
f9b95980	176	writel(0, priv->io + KIRKWOOD_ERR_MASK);
a7d09429	177	free_irq(priv->irq, priv);
f9b95980	178	}
	179
	180	return 0;
	181	}
	182
	183	static int kirkwood_dma_hw_params(struct snd_pcm_substream *substream,
	184	struct snd_pcm_hw_params *params)
	185	{
	186	struct snd_pcm_runtime *runtime = substream->runtime;
	187
	188	snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
	189	runtime->dma_bytes = params_buffer_bytes(params);
	190
	191	return 0;
	192	}
	193
	194	static int kirkwood_dma_hw_free(struct snd_pcm_substream *substream)
	195	{
	196	snd_pcm_set_runtime_buffer(substream, NULL);
	197	return 0;
	198	}
	199
	200	static int kirkwood_dma_prepare(struct snd_pcm_substream *substream)
	201	{
	202	struct snd_pcm_runtime *runtime = substream->runtime;
a7d09429	203	struct kirkwood_dma_data *priv = kirkwood_priv(substream);
f9b95980	204	unsigned long size, count;
f9b95980	205
f9b95980	206	/* compute buffer size in term of "words" as requested in specs */
	207	size = frames_to_bytes(runtime, runtime->buffer_size);
	208	size = (size>>2)-1;
	209	count = snd_pcm_lib_period_bytes(substream);
	210
	211	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
	212	writel(count, priv->io + KIRKWOOD_PLAY_BYTE_INT_COUNT);
	213	writel(runtime->dma_addr, priv->io + KIRKWOOD_PLAY_BUF_ADDR);
	214	writel(size, priv->io + KIRKWOOD_PLAY_BUF_SIZE);
	215	} else {
	216	writel(count, priv->io + KIRKWOOD_REC_BYTE_INT_COUNT);
	217	writel(runtime->dma_addr, priv->io + KIRKWOOD_REC_BUF_ADDR);
	218	writel(size, priv->io + KIRKWOOD_REC_BUF_SIZE);
	219	}
	220
	221
	222	return 0;
	223	}
	224
	225	static snd_pcm_uframes_t kirkwood_dma_pointer(struct snd_pcm_substream
	226	*substream)
	227	{
a7d09429	228	struct kirkwood_dma_data *priv = kirkwood_priv(substream);
f9b95980	229	snd_pcm_uframes_t count;
f9b95980	230
f9b95980	231	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
	232	count = bytes_to_frames(substream->runtime,
	233	readl(priv->io + KIRKWOOD_PLAY_BYTE_COUNT));
	234	else
	235	count = bytes_to_frames(substream->runtime,
	236	readl(priv->io + KIRKWOOD_REC_BYTE_COUNT));
	237
	238	return count;
	239	}
	240
115c7254	241	static const struct snd_pcm_ops kirkwood_dma_ops = {
f9b95980	242	.open = kirkwood_dma_open,
	243	.close = kirkwood_dma_close,
	244	.ioctl = snd_pcm_lib_ioctl,
	245	.hw_params = kirkwood_dma_hw_params,
	246	.hw_free = kirkwood_dma_hw_free,
	247	.prepare = kirkwood_dma_prepare,
	248	.pointer = kirkwood_dma_pointer,
	249	};
	250
	251	static int kirkwood_dma_preallocate_dma_buffer(struct snd_pcm *pcm,
	252	int stream)
	253	{
	254	struct snd_pcm_substream *substream = pcm->streams[stream].substream;
	255	struct snd_dma_buffer *buf = &substream->dma_buffer;
	256	size_t size = kirkwood_dma_snd_hw.buffer_bytes_max;
	257
	258	buf->dev.type = SNDRV_DMA_TYPE_DEV;
	259	buf->dev.dev = pcm->card->dev;
	260	buf->area = dma_alloc_coherent(pcm->card->dev, size,
	261	&buf->addr, GFP_KERNEL);
	262	if (!buf->area)
	263	return -ENOMEM;
	264	buf->bytes = size;
	265	buf->private_data = NULL;
	266
	267	return 0;
	268	}
	269
552d1ef6	270	static int kirkwood_dma_new(struct snd_soc_pcm_runtime *rtd)
f9b95980	271	{
552d1ef6	272	struct snd_card *card = rtd->card->snd_card;
552d1ef6	273	struct snd_pcm *pcm = rtd->pcm;
f9b95980	274	int ret;
f9b95980	275
c9bd5e69 RK	276	ret = dma_coerce_mask_and_coherent(card->dev, DMA_BIT_MASK(32));
	277	if (ret)
	278	return ret;
f9b95980	279
25e9e756	280	if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream) {
f9b95980	281	ret = kirkwood_dma_preallocate_dma_buffer(pcm,
	282	SNDRV_PCM_STREAM_PLAYBACK);
	283	if (ret)
	284	return ret;
	285	}
	286
25e9e756	287	if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) {
f9b95980	288	ret = kirkwood_dma_preallocate_dma_buffer(pcm,
	289	SNDRV_PCM_STREAM_CAPTURE);
	290	if (ret)
	291	return ret;
	292	}
	293
	294	return 0;
	295	}
	296
	297	static void kirkwood_dma_free_dma_buffers(struct snd_pcm *pcm)
	298	{
	299	struct snd_pcm_substream *substream;
	300	struct snd_dma_buffer *buf;
	301	int stream;
	302
	303	for (stream = 0; stream < 2; stream++) {
	304	substream = pcm->streams[stream].substream;
	305	if (!substream)
	306	continue;
	307	buf = &substream->dma_buffer;
	308	if (!buf->area)
	309	continue;
	310
	311	dma_free_coherent(pcm->card->dev, buf->bytes,
	312	buf->area, buf->addr);
	313	buf->area = NULL;
	314	}
	315	}
	316
f98fc0f8 KM	317	const struct snd_soc_component_driver kirkwood_soc_component = {
f98fc0f8 KM	318	.name = DRV_NAME,
f0fba2ad	319	.ops = &kirkwood_dma_ops,
f9b95980	320	.pcm_new = kirkwood_dma_new,
	321	.pcm_free = kirkwood_dma_free_dma_buffers,
	322	};