[deliverable/linux.git] / sound / soc / kirkwood / kirkwood-dma.c

/*
 * kirkwood-dma.c
 *
 * (c) 2010 Arnaud Patard <apatard@mandriva.com>
 * (c) 2010 Arnaud Patard <arnaud.patard@rtp-net.org>
 *
 *  This program is free software; you can redistribute  it and/or modify it
 *  under  the terms of  the GNU General  Public License as published by the
 *  Free Software Foundation;  either version 2 of the  License, or (at your
 *  option) any later version.
 */

#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 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;
	}
}

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