[deliverable/linux.git] / sound / soc / ep93xx / ep93xx-pcm.c

/*
 * linux/sound/arm/ep93xx-pcm.c - EP93xx ALSA PCM interface
 *
 * Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
 * Copyright (C) 2006 Applied Data Systems
 *
 * Rewritten for the SoC audio subsystem (Based on PXA2xx code):
 *   Copyright (c) 2008 Ryan Mallon
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/dmaengine.h>
#include <linux/dma-mapping.h>

#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>

#include <mach/dma.h>
#include <mach/hardware.h>
#include <mach/ep93xx-regs.h>

#include "ep93xx-pcm.h"

static const struct snd_pcm_hardware ep93xx_pcm_hardware = {
	.info			= (SNDRV_PCM_INFO_MMAP		|
				   SNDRV_PCM_INFO_MMAP_VALID	|
				   SNDRV_PCM_INFO_INTERLEAVED	|
				   SNDRV_PCM_INFO_BLOCK_TRANSFER),
				   
	.rates			= SNDRV_PCM_RATE_8000_192000,
	.rate_min		= SNDRV_PCM_RATE_8000,
	.rate_max		= SNDRV_PCM_RATE_192000,
	
	.formats		= (SNDRV_PCM_FMTBIT_S16_LE |
				   SNDRV_PCM_FMTBIT_S24_LE |
				   SNDRV_PCM_FMTBIT_S32_LE),
	
	.buffer_bytes_max	= 131072,
	.period_bytes_min	= 32,
	.period_bytes_max	= 32768,
	.periods_min		= 1,
	.periods_max		= 32,
	.fifo_size		= 32,
};

struct ep93xx_runtime_data
{
	int				pointer_bytes;
	int				periods;
	int				period_bytes;
	struct dma_chan			*dma_chan;
	struct ep93xx_dma_data		dma_data;
};

static void ep93xx_pcm_dma_callback(void *data)
{
	struct snd_pcm_substream *substream = data;
	struct ep93xx_runtime_data *rtd = substream->runtime->private_data;

	rtd->pointer_bytes += rtd->period_bytes;
	rtd->pointer_bytes %= rtd->period_bytes * rtd->periods;

	snd_pcm_period_elapsed(substream);
}

static bool ep93xx_pcm_dma_filter(struct dma_chan *chan, void *filter_param)
{
	struct ep93xx_dma_data *data = filter_param;

	if (data->direction == ep93xx_dma_chan_direction(chan)) {
		chan->private = data;
		return true;
	}

	return false;
}

static int ep93xx_pcm_open(struct snd_pcm_substream *substream)
{
	struct snd_soc_pcm_runtime *soc_rtd = substream->private_data;
	struct snd_soc_dai *cpu_dai = soc_rtd->cpu_dai;
	struct ep93xx_pcm_dma_params *dma_params;
	struct ep93xx_runtime_data *rtd;    
	dma_cap_mask_t mask;
	int ret;

	ret = snd_pcm_hw_constraint_integer(substream->runtime,
					    SNDRV_PCM_HW_PARAM_PERIODS);
	if (ret < 0)
		return ret;

	snd_soc_set_runtime_hwparams(substream, &ep93xx_pcm_hardware);

	rtd = kmalloc(sizeof(*rtd), GFP_KERNEL);
	if (!rtd) 
		return -ENOMEM;

	dma_cap_zero(mask);
	dma_cap_set(DMA_SLAVE, mask);
	dma_cap_set(DMA_CYCLIC, mask);

	dma_params = snd_soc_dai_get_dma_data(cpu_dai, substream);
	rtd->dma_data.port = dma_params->dma_port;
	rtd->dma_data.name = dma_params->name;

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
		rtd->dma_data.direction = DMA_TO_DEVICE;
	else
		rtd->dma_data.direction = DMA_FROM_DEVICE;

	rtd->dma_chan = dma_request_channel(mask, ep93xx_pcm_dma_filter,
					    &rtd->dma_data);
	if (!rtd->dma_chan) {
		kfree(rtd);
		return -EINVAL;
	}
	
	substream->runtime->private_data = rtd;
	return 0;
}

static int ep93xx_pcm_close(struct snd_pcm_substream *substream)
{
	struct ep93xx_runtime_data *rtd = substream->runtime->private_data;

	dma_release_channel(rtd->dma_chan);
	kfree(rtd);
	return 0;
}

static int ep93xx_pcm_dma_submit(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct ep93xx_runtime_data *rtd = runtime->private_data;
	struct dma_chan *chan = rtd->dma_chan;
	struct dma_device *dma_dev = chan->device;
	struct dma_async_tx_descriptor *desc;

	rtd->pointer_bytes = 0;
	desc = dma_dev->device_prep_dma_cyclic(chan, runtime->dma_addr,
					       rtd->period_bytes * rtd->periods,
					       rtd->period_bytes,
					       rtd->dma_data.direction);
	if (!desc)
		return -EINVAL;

	desc->callback = ep93xx_pcm_dma_callback;
	desc->callback_param = substream;

	dmaengine_submit(desc);
	return 0;
}

static void ep93xx_pcm_dma_flush(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct ep93xx_runtime_data *rtd = runtime->private_data;

	dmaengine_terminate_all(rtd->dma_chan);
}

static int ep93xx_pcm_hw_params(struct snd_pcm_substream *substream,
				struct snd_pcm_hw_params *params)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct ep93xx_runtime_data *rtd = runtime->private_data;

	snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);

	rtd->periods = params_periods(params);
	rtd->period_bytes = params_period_bytes(params);
	return 0;
}

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

static int ep93xx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
{
	int ret;

	ret = 0;
	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
	case SNDRV_PCM_TRIGGER_RESUME:
	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
		ret = ep93xx_pcm_dma_submit(substream);
		break;

	case SNDRV_PCM_TRIGGER_STOP:
	case SNDRV_PCM_TRIGGER_SUSPEND:
	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
		ep93xx_pcm_dma_flush(substream);
		break;

	default:
		ret = -EINVAL;
		break;
	}

	return ret;
}

static snd_pcm_uframes_t ep93xx_pcm_pointer(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct ep93xx_runtime_data *rtd = substream->runtime->private_data;

	/* FIXME: implement this with sub-period granularity */
	return bytes_to_frames(runtime, rtd->pointer_bytes);
}

static int ep93xx_pcm_mmap(struct snd_pcm_substream *substream,
			   struct vm_area_struct *vma)
{
	struct snd_pcm_runtime *runtime = substream->runtime;

	return dma_mmap_writecombine(substream->pcm->card->dev, vma,
				     runtime->dma_area,
				     runtime->dma_addr,
				     runtime->dma_bytes);
}

static struct snd_pcm_ops ep93xx_pcm_ops = {
	.open		= ep93xx_pcm_open,
	.close		= ep93xx_pcm_close,
	.ioctl		= snd_pcm_lib_ioctl,
	.hw_params	= ep93xx_pcm_hw_params,
	.hw_free	= ep93xx_pcm_hw_free,
	.trigger	= ep93xx_pcm_trigger,
	.pointer	= ep93xx_pcm_pointer,
	.mmap		= ep93xx_pcm_mmap,
};

static int ep93xx_pcm_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 = ep93xx_pcm_hardware.buffer_bytes_max;

	buf->dev.type = SNDRV_DMA_TYPE_DEV;
	buf->dev.dev = pcm->card->dev;
	buf->private_data = NULL;
	buf->area = dma_alloc_writecombine(pcm->card->dev, size,
					   &buf->addr, GFP_KERNEL);
	buf->bytes = size;

	return (buf->area == NULL) ? -ENOMEM : 0;
}

static void ep93xx_pcm_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_writecombine(pcm->card->dev, buf->bytes, buf->area,
				      buf->addr);
		buf->area = NULL;
	}
}

static u64 ep93xx_pcm_dmamask = 0xffffffff;

static int ep93xx_pcm_new(struct snd_soc_pcm_runtime *rtd)
{
	struct snd_card *card = rtd->card->snd_card;
	struct snd_soc_dai *dai = rtd->cpu_dai;
	struct snd_pcm *pcm = rtd->pcm;
	int ret = 0;

	if (!card->dev->dma_mask)
		card->dev->dma_mask = &ep93xx_pcm_dmamask;
	if (!card->dev->coherent_dma_mask)
		card->dev->coherent_dma_mask = 0xffffffff;

	if (dai->driver->playback.channels_min) {
		ret = ep93xx_pcm_preallocate_dma_buffer(pcm,
					SNDRV_PCM_STREAM_PLAYBACK);
		if (ret)
			return ret;
	}

	if (dai->driver->capture.channels_min) {
		ret = ep93xx_pcm_preallocate_dma_buffer(pcm,
					SNDRV_PCM_STREAM_CAPTURE);
		if (ret)
			return ret;
	}

	return 0;
}

static struct snd_soc_platform_driver ep93xx_soc_platform = {
	.ops		= &ep93xx_pcm_ops,
	.pcm_new	= &ep93xx_pcm_new,
	.pcm_free	= &ep93xx_pcm_free_dma_buffers,
};

static int __devinit ep93xx_soc_platform_probe(struct platform_device *pdev)
{
	return snd_soc_register_platform(&pdev->dev, &ep93xx_soc_platform);
}

static int __devexit ep93xx_soc_platform_remove(struct platform_device *pdev)
{
	snd_soc_unregister_platform(&pdev->dev);
	return 0;
}

static struct platform_driver ep93xx_pcm_driver = {
	.driver = {
			.name = "ep93xx-pcm-audio",
			.owner = THIS_MODULE,
	},

	.probe = ep93xx_soc_platform_probe,
	.remove = __devexit_p(ep93xx_soc_platform_remove),
};

static int __init ep93xx_soc_platform_init(void)
{
	return platform_driver_register(&ep93xx_pcm_driver);
}

static void __exit ep93xx_soc_platform_exit(void)
{
	platform_driver_unregister(&ep93xx_pcm_driver);
}

module_init(ep93xx_soc_platform_init);
module_exit(ep93xx_soc_platform_exit);

MODULE_AUTHOR("Ryan Mallon");
MODULE_DESCRIPTION("EP93xx ALSA PCM interface");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:ep93xx-pcm-audio");
Commit	Line	Data
db5bf412 RM	1	/*
	2	* linux/sound/arm/ep93xx-pcm.c - EP93xx ALSA PCM interface
	3	*
	4	* Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
	5	* Copyright (C) 2006 Applied Data Systems
	6	*
	7	* Rewritten for the SoC audio subsystem (Based on PXA2xx code):
1c5454ee	8	* Copyright (c) 2008 Ryan Mallon
db5bf412 RM	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License version 2 as
	12	* published by the Free Software Foundation.
	13	*/
	14
	15	#include <linux/module.h>
	16	#include <linux/init.h>
	17	#include <linux/device.h>
	18	#include <linux/slab.h>
51e2cc0c	19	#include <linux/dmaengine.h>
db5bf412 RM	20	#include <linux/dma-mapping.h>
	21
	22	#include <sound/core.h>
	23	#include <sound/pcm.h>
	24	#include <sound/pcm_params.h>
	25	#include <sound/soc.h>
	26
	27	#include <mach/dma.h>
	28	#include <mach/hardware.h>
	29	#include <mach/ep93xx-regs.h>
	30
	31	#include "ep93xx-pcm.h"
	32
	33	static const struct snd_pcm_hardware ep93xx_pcm_hardware = {
	34	.info = (SNDRV_PCM_INFO_MMAP \|
	35	SNDRV_PCM_INFO_MMAP_VALID \|
	36	SNDRV_PCM_INFO_INTERLEAVED \|
	37	SNDRV_PCM_INFO_BLOCK_TRANSFER),
	38
4cfeb695	39	.rates = SNDRV_PCM_RATE_8000_192000,
db5bf412	40	.rate_min = SNDRV_PCM_RATE_8000,
4cfeb695	41	.rate_max = SNDRV_PCM_RATE_192000,
db5bf412 RM	42
	43	.formats = (SNDRV_PCM_FMTBIT_S16_LE \|
	44	SNDRV_PCM_FMTBIT_S24_LE \|
	45	SNDRV_PCM_FMTBIT_S32_LE),
	46
	47	.buffer_bytes_max = 131072,
	48	.period_bytes_min = 32,
	49	.period_bytes_max = 32768,
	50	.periods_min = 1,
	51	.periods_max = 32,
	52	.fifo_size = 32,
	53	};
	54
	55	struct ep93xx_runtime_data
	56	{
db5bf412	57	int pointer_bytes;
db5bf412	58	int periods;
51e2cc0c MW	59	int period_bytes;
	60	struct dma_chan *dma_chan;
	61	struct ep93xx_dma_data dma_data;
db5bf412 RM	62	};
db5bf412 RM	63
51e2cc0c	64	static void ep93xx_pcm_dma_callback(void *data)
db5bf412	65	{
51e2cc0c MW	66	struct snd_pcm_substream *substream = data;
51e2cc0c MW	67	struct ep93xx_runtime_data *rtd = substream->runtime->private_data;
db5bf412	68
51e2cc0c MW	69	rtd->pointer_bytes += rtd->period_bytes;
	70	rtd->pointer_bytes %= rtd->period_bytes * rtd->periods;
	71
	72	snd_pcm_period_elapsed(substream);
db5bf412 RM	73	}
db5bf412 RM	74
51e2cc0c	75	static bool ep93xx_pcm_dma_filter(struct dma_chan chan, void filter_param)
db5bf412	76	{
51e2cc0c	77	struct ep93xx_dma_data *data = filter_param;
db5bf412	78
51e2cc0c MW	79	if (data->direction == ep93xx_dma_chan_direction(chan)) {
	80	chan->private = data;
	81	return true;
db5bf412	82	}
51e2cc0c MW	83
51e2cc0c MW	84	return false;
db5bf412 RM	85	}
	86
	87	static int ep93xx_pcm_open(struct snd_pcm_substream *substream)
	88	{
	89	struct snd_soc_pcm_runtime *soc_rtd = substream->private_data;
f0fba2ad	90	struct snd_soc_dai *cpu_dai = soc_rtd->cpu_dai;
db5bf412 RM	91	struct ep93xx_pcm_dma_params *dma_params;
db5bf412 RM	92	struct ep93xx_runtime_data *rtd;
51e2cc0c	93	dma_cap_mask_t mask;
db5bf412 RM	94	int ret;
db5bf412 RM	95
51e2cc0c MW	96	ret = snd_pcm_hw_constraint_integer(substream->runtime,
	97	SNDRV_PCM_HW_PARAM_PERIODS);
	98	if (ret < 0)
	99	return ret;
	100
db5bf412 RM	101	snd_soc_set_runtime_hwparams(substream, &ep93xx_pcm_hardware);
	102
	103	rtd = kmalloc(sizeof(*rtd), GFP_KERNEL);
	104	if (!rtd)
	105	return -ENOMEM;
	106
51e2cc0c MW	107	dma_cap_zero(mask);
	108	dma_cap_set(DMA_SLAVE, mask);
	109	dma_cap_set(DMA_CYCLIC, mask);
	110
	111	dma_params = snd_soc_dai_get_dma_data(cpu_dai, substream);
	112	rtd->dma_data.port = dma_params->dma_port;
	113	rtd->dma_data.name = dma_params->name;
	114
	115	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
	116	rtd->dma_data.direction = DMA_TO_DEVICE;
	117	else
	118	rtd->dma_data.direction = DMA_FROM_DEVICE;
	119
	120	rtd->dma_chan = dma_request_channel(mask, ep93xx_pcm_dma_filter,
	121	&rtd->dma_data);
	122	if (!rtd->dma_chan) {
db5bf412	123	kfree(rtd);
51e2cc0c	124	return -EINVAL;
db5bf412 RM	125	}
	126
	127	substream->runtime->private_data = rtd;
	128	return 0;
	129	}
	130
	131	static int ep93xx_pcm_close(struct snd_pcm_substream *substream)
	132	{
	133	struct ep93xx_runtime_data *rtd = substream->runtime->private_data;
	134
51e2cc0c	135	dma_release_channel(rtd->dma_chan);
db5bf412 RM	136	kfree(rtd);
	137	return 0;
	138	}
	139
51e2cc0c MW	140	static int ep93xx_pcm_dma_submit(struct snd_pcm_substream *substream)
	141	{
	142	struct snd_pcm_runtime *runtime = substream->runtime;
	143	struct ep93xx_runtime_data *rtd = runtime->private_data;
	144	struct dma_chan *chan = rtd->dma_chan;
	145	struct dma_device *dma_dev = chan->device;
	146	struct dma_async_tx_descriptor *desc;
	147
	148	rtd->pointer_bytes = 0;
	149	desc = dma_dev->device_prep_dma_cyclic(chan, runtime->dma_addr,
	150	rtd->period_bytes * rtd->periods,
	151	rtd->period_bytes,
	152	rtd->dma_data.direction);
	153	if (!desc)
	154	return -EINVAL;
	155
	156	desc->callback = ep93xx_pcm_dma_callback;
	157	desc->callback_param = substream;
	158
	159	dmaengine_submit(desc);
	160	return 0;
	161	}
	162
	163	static void ep93xx_pcm_dma_flush(struct snd_pcm_substream *substream)
	164	{
	165	struct snd_pcm_runtime *runtime = substream->runtime;
	166	struct ep93xx_runtime_data *rtd = runtime->private_data;
	167
	168	dmaengine_terminate_all(rtd->dma_chan);
	169	}
	170
db5bf412 RM	171	static int ep93xx_pcm_hw_params(struct snd_pcm_substream *substream,
	172	struct snd_pcm_hw_params *params)
	173	{
	174	struct snd_pcm_runtime *runtime = substream->runtime;
	175	struct ep93xx_runtime_data *rtd = runtime->private_data;
db5bf412 RM	176
db5bf412 RM	177	snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
db5bf412	178
51e2cc0c MW	179	rtd->periods = params_periods(params);
51e2cc0c MW	180	rtd->period_bytes = params_period_bytes(params);
db5bf412 RM	181	return 0;
	182	}
	183
	184	static int ep93xx_pcm_hw_free(struct snd_pcm_substream *substream)
	185	{
	186	snd_pcm_set_runtime_buffer(substream, NULL);
	187	return 0;
	188	}
	189
	190	static int ep93xx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
	191	{
db5bf412	192	int ret;
db5bf412 RM	193
	194	ret = 0;
	195	switch (cmd) {
	196	case SNDRV_PCM_TRIGGER_START:
	197	case SNDRV_PCM_TRIGGER_RESUME:
	198	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
51e2cc0c	199	ret = ep93xx_pcm_dma_submit(substream);
db5bf412 RM	200	break;
	201
	202	case SNDRV_PCM_TRIGGER_STOP:
	203	case SNDRV_PCM_TRIGGER_SUSPEND:
	204	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
51e2cc0c	205	ep93xx_pcm_dma_flush(substream);
db5bf412 RM	206	break;
	207
	208	default:
	209	ret = -EINVAL;
	210	break;
	211	}
	212
	213	return ret;
	214	}
	215
	216	static snd_pcm_uframes_t ep93xx_pcm_pointer(struct snd_pcm_substream *substream)
	217	{
	218	struct snd_pcm_runtime *runtime = substream->runtime;
	219	struct ep93xx_runtime_data *rtd = substream->runtime->private_data;
	220
	221	/* FIXME: implement this with sub-period granularity */
	222	return bytes_to_frames(runtime, rtd->pointer_bytes);
	223	}
	224
	225	static int ep93xx_pcm_mmap(struct snd_pcm_substream *substream,
	226	struct vm_area_struct *vma)
	227	{
	228	struct snd_pcm_runtime *runtime = substream->runtime;
	229
	230	return dma_mmap_writecombine(substream->pcm->card->dev, vma,
	231	runtime->dma_area,
	232	runtime->dma_addr,
	233	runtime->dma_bytes);
	234	}
	235
	236	static struct snd_pcm_ops ep93xx_pcm_ops = {
	237	.open = ep93xx_pcm_open,
	238	.close = ep93xx_pcm_close,
	239	.ioctl = snd_pcm_lib_ioctl,
	240	.hw_params = ep93xx_pcm_hw_params,
	241	.hw_free = ep93xx_pcm_hw_free,
	242	.trigger = ep93xx_pcm_trigger,
	243	.pointer = ep93xx_pcm_pointer,
	244	.mmap = ep93xx_pcm_mmap,
	245	};
	246
	247	static int ep93xx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
	248	{
	249	struct snd_pcm_substream *substream = pcm->streams[stream].substream;
	250	struct snd_dma_buffer *buf = &substream->dma_buffer;
	251	size_t size = ep93xx_pcm_hardware.buffer_bytes_max;
	252
	253	buf->dev.type = SNDRV_DMA_TYPE_DEV;
	254	buf->dev.dev = pcm->card->dev;
	255	buf->private_data = NULL;
	256	buf->area = dma_alloc_writecombine(pcm->card->dev, size,
	257	&buf->addr, GFP_KERNEL);
	258	buf->bytes = size;
	259
	260	return (buf->area == NULL) ? -ENOMEM : 0;
	261	}
	262
	263	static void ep93xx_pcm_free_dma_buffers(struct snd_pcm *pcm)
	264	{
	265	struct snd_pcm_substream *substream;
	266	struct snd_dma_buffer *buf;
	267	int stream;
	268
	269	for (stream = 0; stream < 2; stream++) {
270	substream = pcm->streams[stream].substream;
271	if (!substream)
272	continue;
273
274	buf = &substream->dma_buffer;
275	if (!buf->area)
276	continue;
277
278	dma_free_writecombine(pcm->card->dev, buf->bytes, buf->area,
279	buf->addr);
280	buf->area = NULL;
281	}
282	}
283
284	static u64 ep93xx_pcm_dmamask = 0xffffffff;
285
552d1ef6	286	static int ep93xx_pcm_new(struct snd_soc_pcm_runtime *rtd)
db5bf412	287	{
552d1ef6 LG	288	struct snd_card *card = rtd->card->snd_card;
	289	struct snd_soc_dai *dai = rtd->cpu_dai;
	290	struct snd_pcm *pcm = rtd->pcm;
db5bf412 RM	291	int ret = 0;
	292
	293	if (!card->dev->dma_mask)
	294	card->dev->dma_mask = &ep93xx_pcm_dmamask;
	295	if (!card->dev->coherent_dma_mask)
	296	card->dev->coherent_dma_mask = 0xffffffff;
	297
f0fba2ad	298	if (dai->driver->playback.channels_min) {
db5bf412 RM	299	ret = ep93xx_pcm_preallocate_dma_buffer(pcm,
	300	SNDRV_PCM_STREAM_PLAYBACK);
	301	if (ret)
	302	return ret;
	303	}
	304
f0fba2ad	305	if (dai->driver->capture.channels_min) {
db5bf412 RM	306	ret = ep93xx_pcm_preallocate_dma_buffer(pcm,
	307	SNDRV_PCM_STREAM_CAPTURE);
	308	if (ret)
	309	return ret;
	310	}
	311
	312	return 0;
	313	}
	314
f0fba2ad LG	315	static struct snd_soc_platform_driver ep93xx_soc_platform = {
f0fba2ad LG	316	.ops = &ep93xx_pcm_ops,
db5bf412 RM	317	.pcm_new = &ep93xx_pcm_new,
	318	.pcm_free = &ep93xx_pcm_free_dma_buffers,
	319	};
f0fba2ad LG	320
	321	static int __devinit ep93xx_soc_platform_probe(struct platform_device *pdev)
	322	{
	323	return snd_soc_register_platform(&pdev->dev, &ep93xx_soc_platform);
	324	}
	325
	326	static int __devexit ep93xx_soc_platform_remove(struct platform_device *pdev)
	327	{
	328	snd_soc_unregister_platform(&pdev->dev);
	329	return 0;
	330	}
	331
	332	static struct platform_driver ep93xx_pcm_driver = {
	333	.driver = {
	334	.name = "ep93xx-pcm-audio",
	335	.owner = THIS_MODULE,
	336	},
	337
	338	.probe = ep93xx_soc_platform_probe,
	339	.remove = __devexit_p(ep93xx_soc_platform_remove),
	340	};
db5bf412 RM	341
	342	static int __init ep93xx_soc_platform_init(void)
	343	{
f0fba2ad	344	return platform_driver_register(&ep93xx_pcm_driver);
db5bf412 RM	345	}
	346
	347	static void __exit ep93xx_soc_platform_exit(void)
	348	{
f0fba2ad	349	platform_driver_unregister(&ep93xx_pcm_driver);
db5bf412 RM	350	}
	351
	352	module_init(ep93xx_soc_platform_init);
	353	module_exit(ep93xx_soc_platform_exit);
	354
1c5454ee	355	MODULE_AUTHOR("Ryan Mallon");
db5bf412 RM	356	MODULE_DESCRIPTION("EP93xx ALSA PCM interface");
db5bf412 RM	357	MODULE_LICENSE("GPL");
93068169	358	MODULE_ALIAS("platform:ep93xx-pcm-audio");