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

/*
 * Copyright (c) 2010 Nuvoton technology corporation.
 *
 * Wan ZongShun <mcuos.com@gmail.com>
 *
 * 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;version 2 of the License.
 *
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/io.h>
#include <linux/platform_device.h>
#include <linux/slab.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/hardware.h>

#include "nuc900-audio.h"

static const struct snd_pcm_hardware nuc900_pcm_hardware = {
	.info			= SNDRV_PCM_INFO_INTERLEAVED |
					SNDRV_PCM_INFO_BLOCK_TRANSFER |
					SNDRV_PCM_INFO_MMAP |
					SNDRV_PCM_INFO_MMAP_VALID |
					SNDRV_PCM_INFO_PAUSE |
					SNDRV_PCM_INFO_RESUME,
	.formats		= SNDRV_PCM_FMTBIT_S16_LE,
	.channels_min		= 1,
	.channels_max		= 2,
	.buffer_bytes_max	= 4*1024,
	.period_bytes_min	= 1*1024,
	.period_bytes_max	= 4*1024,
	.periods_min		= 1,
	.periods_max		= 1024,
};

static int nuc900_dma_hw_params(struct snd_pcm_substream *substream,
	struct snd_pcm_hw_params *params)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct nuc900_audio *nuc900_audio = runtime->private_data;
	unsigned long flags;
	int ret = 0;

	ret = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
	if (ret < 0)
		return ret;

	spin_lock_irqsave(&nuc900_audio->lock, flags);

	nuc900_audio->substream = substream;
	nuc900_audio->dma_addr[substream->stream] = runtime->dma_addr;
	nuc900_audio->buffersize[substream->stream] =
						params_buffer_bytes(params);

	spin_unlock_irqrestore(&nuc900_audio->lock, flags);

	return ret;
}

static void nuc900_update_dma_register(struct snd_pcm_substream *substream,
				dma_addr_t dma_addr, size_t count)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct nuc900_audio *nuc900_audio = runtime->private_data;
	void __iomem *mmio_addr, *mmio_len;

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
		mmio_addr = nuc900_audio->mmio + ACTL_PDSTB;
		mmio_len = nuc900_audio->mmio + ACTL_PDST_LENGTH;
	} else {
		mmio_addr = nuc900_audio->mmio + ACTL_RDSTB;
		mmio_len = nuc900_audio->mmio + ACTL_RDST_LENGTH;
	}

	AUDIO_WRITE(mmio_addr, dma_addr);
	AUDIO_WRITE(mmio_len, count);
}

static void nuc900_dma_start(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct nuc900_audio *nuc900_audio = runtime->private_data;
	unsigned long val;

	val = AUDIO_READ(nuc900_audio->mmio + ACTL_CON);
	val |= (T_DMA_IRQ | R_DMA_IRQ);
	AUDIO_WRITE(nuc900_audio->mmio + ACTL_CON, val);
}

static void nuc900_dma_stop(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct nuc900_audio *nuc900_audio = runtime->private_data;
	unsigned long val;

	val = AUDIO_READ(nuc900_audio->mmio + ACTL_CON);
	val &= ~(T_DMA_IRQ | R_DMA_IRQ);
	AUDIO_WRITE(nuc900_audio->mmio + ACTL_CON, val);
}

static irqreturn_t nuc900_dma_interrupt(int irq, void *dev_id)
{
	struct snd_pcm_substream *substream = dev_id;
	struct nuc900_audio *nuc900_audio = substream->runtime->private_data;
	unsigned long val;

	spin_lock(&nuc900_audio->lock);

	val = AUDIO_READ(nuc900_audio->mmio + ACTL_CON);

	if (val & R_DMA_IRQ) {
		AUDIO_WRITE(nuc900_audio->mmio + ACTL_CON, val | R_DMA_IRQ);

		val = AUDIO_READ(nuc900_audio->mmio + ACTL_RSR);

		if (val & R_DMA_MIDDLE_IRQ) {
			val |= R_DMA_MIDDLE_IRQ;
			AUDIO_WRITE(nuc900_audio->mmio + ACTL_RSR, val);
		}

		if (val & R_DMA_END_IRQ) {
			val |= R_DMA_END_IRQ;
			AUDIO_WRITE(nuc900_audio->mmio + ACTL_RSR, val);
		}
	} else if (val & T_DMA_IRQ) {
		AUDIO_WRITE(nuc900_audio->mmio + ACTL_CON, val | T_DMA_IRQ);

		val = AUDIO_READ(nuc900_audio->mmio + ACTL_PSR);

		if (val & P_DMA_MIDDLE_IRQ) {
			val |= P_DMA_MIDDLE_IRQ;
			AUDIO_WRITE(nuc900_audio->mmio + ACTL_PSR, val);
		}

		if (val & P_DMA_END_IRQ) {
			val |= P_DMA_END_IRQ;
			AUDIO_WRITE(nuc900_audio->mmio + ACTL_PSR, val);
		}
	} else {
		dev_err(nuc900_audio->dev, "Wrong DMA interrupt status!\n");
		spin_unlock(&nuc900_audio->lock);
		return IRQ_HANDLED;
	}

	spin_unlock(&nuc900_audio->lock);

	snd_pcm_period_elapsed(substream);

	return IRQ_HANDLED;
}

static int nuc900_dma_hw_free(struct snd_pcm_substream *substream)
{
	snd_pcm_lib_free_pages(substream);
	return 0;
}

static int nuc900_dma_prepare(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct nuc900_audio *nuc900_audio = runtime->private_data;
	unsigned long flags, val;
	int ret = 0;

	spin_lock_irqsave(&nuc900_audio->lock, flags);

	nuc900_update_dma_register(substream,
				nuc900_audio->dma_addr[substream->stream],
				nuc900_audio->buffersize[substream->stream]);

	val = AUDIO_READ(nuc900_audio->mmio + ACTL_RESET);

	switch (runtime->channels) {
	case 1:
		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
			val &= ~(PLAY_LEFT_CHNNEL | PLAY_RIGHT_CHNNEL);
			val |= PLAY_RIGHT_CHNNEL;
		} else {
			val &= ~(RECORD_LEFT_CHNNEL | RECORD_RIGHT_CHNNEL);
			val |= RECORD_RIGHT_CHNNEL;
		}
		AUDIO_WRITE(nuc900_audio->mmio + ACTL_RESET, val);
		break;
	case 2:
		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
			val |= (PLAY_LEFT_CHNNEL | PLAY_RIGHT_CHNNEL);
		else
			val |= (RECORD_LEFT_CHNNEL | RECORD_RIGHT_CHNNEL);
		AUDIO_WRITE(nuc900_audio->mmio + ACTL_RESET, val);
		break;
	default:
		ret = -EINVAL;
	}
	spin_unlock_irqrestore(&nuc900_audio->lock, flags);
	return ret;
}

static int nuc900_dma_trigger(struct snd_pcm_substream *substream, int cmd)
{
	int ret = 0;

	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
	case SNDRV_PCM_TRIGGER_RESUME:
		nuc900_dma_start(substream);
		break;

	case SNDRV_PCM_TRIGGER_STOP:
	case SNDRV_PCM_TRIGGER_SUSPEND:
		nuc900_dma_stop(substream);
		break;

	default:
		ret = -EINVAL;
		break;
	}

	return ret;
}

static int nuc900_dma_getposition(struct snd_pcm_substream *substream,
					dma_addr_t *src, dma_addr_t *dst)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct nuc900_audio *nuc900_audio = runtime->private_data;

	if (src != NULL)
		*src = AUDIO_READ(nuc900_audio->mmio + ACTL_PDSTC);

	if (dst != NULL)
		*dst = AUDIO_READ(nuc900_audio->mmio + ACTL_RDSTC);

	return 0;
}

static snd_pcm_uframes_t nuc900_dma_pointer(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	dma_addr_t src, dst;
	unsigned long res;

	nuc900_dma_getposition(substream, &src, &dst);

	if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
		res = dst - runtime->dma_addr;
	else
		res = src - runtime->dma_addr;

	return bytes_to_frames(substream->runtime, res);
}

static int nuc900_dma_open(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct nuc900_audio *nuc900_audio;

	snd_soc_set_runtime_hwparams(substream, &nuc900_pcm_hardware);

	nuc900_audio = nuc900_ac97_data;

	if (request_irq(nuc900_audio->irq_num, nuc900_dma_interrupt,
			0, "nuc900-dma", substream))
		return -EBUSY;

	runtime->private_data = nuc900_audio;

	return 0;
}

static int nuc900_dma_close(struct snd_pcm_substream *substream)
{
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct nuc900_audio *nuc900_audio = runtime->private_data;

	free_irq(nuc900_audio->irq_num, substream);

	return 0;
}

static int nuc900_dma_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 nuc900_dma_ops = {
	.open		= nuc900_dma_open,
	.close		= nuc900_dma_close,
	.ioctl		= snd_pcm_lib_ioctl,
	.hw_params	= nuc900_dma_hw_params,
	.hw_free	= nuc900_dma_hw_free,
	.prepare	= nuc900_dma_prepare,
	.trigger	= nuc900_dma_trigger,
	.pointer	= nuc900_dma_pointer,
	.mmap		= nuc900_dma_mmap,
};

static void nuc900_dma_free_dma_buffers(struct snd_pcm *pcm)
{
	snd_pcm_lib_preallocate_free_for_all(pcm);
}

static u64 nuc900_pcm_dmamask = DMA_BIT_MASK(32);
static int nuc900_dma_new(struct snd_soc_pcm_runtime *rtd)
{
	struct snd_card *card = rtd->card->snd_card;
	struct snd_pcm *pcm = rtd->pcm;

	if (!card->dev->dma_mask)
		card->dev->dma_mask = &nuc900_pcm_dmamask;
	if (!card->dev->coherent_dma_mask)
		card->dev->coherent_dma_mask = DMA_BIT_MASK(32);

	snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
		card->dev, 4 * 1024, (4 * 1024) - 1);

	return 0;
}

static struct snd_soc_platform_driver nuc900_soc_platform = {
	.ops		= &nuc900_dma_ops,
	.pcm_new	= nuc900_dma_new,
	.pcm_free	= nuc900_dma_free_dma_buffers,
};

static int nuc900_soc_platform_probe(struct platform_device *pdev)
{
	return snd_soc_register_platform(&pdev->dev, &nuc900_soc_platform);
}

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

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

	.probe = nuc900_soc_platform_probe,
	.remove = nuc900_soc_platform_remove,
};

module_platform_driver(nuc900_pcm_driver);

MODULE_AUTHOR("Wan ZongShun, <mcuos.com@gmail.com>");
MODULE_DESCRIPTION("nuc900 Audio DMA module");
MODULE_LICENSE("GPL");
Commit	Line	Data
1082e270 WZ	1	/*
	2	* Copyright (c) 2010 Nuvoton technology corporation.
	3	*
	4	* Wan ZongShun <mcuos.com@gmail.com>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation;version 2 of the License.
	9	*
	10	*/
	11
	12	#include <linux/module.h>
	13	#include <linux/init.h>
	14	#include <linux/io.h>
	15	#include <linux/platform_device.h>
	16	#include <linux/slab.h>
	17	#include <linux/dma-mapping.h>
	18
	19	#include <sound/core.h>
	20	#include <sound/pcm.h>
	21	#include <sound/pcm_params.h>
	22	#include <sound/soc.h>
	23
	24	#include <mach/hardware.h>
	25
019afb58	26	#include "nuc900-audio.h"
1082e270 WZ	27
	28	static const struct snd_pcm_hardware nuc900_pcm_hardware = {
	29	.info = SNDRV_PCM_INFO_INTERLEAVED \|
	30	SNDRV_PCM_INFO_BLOCK_TRANSFER \|
	31	SNDRV_PCM_INFO_MMAP \|
	32	SNDRV_PCM_INFO_MMAP_VALID \|
	33	SNDRV_PCM_INFO_PAUSE \|
	34	SNDRV_PCM_INFO_RESUME,
	35	.formats = SNDRV_PCM_FMTBIT_S16_LE,
	36	.channels_min = 1,
	37	.channels_max = 2,
	38	.buffer_bytes_max = 4*1024,
	39	.period_bytes_min = 1*1024,
	40	.period_bytes_max = 4*1024,
	41	.periods_min = 1,
	42	.periods_max = 1024,
	43	};
	44
	45	static int nuc900_dma_hw_params(struct snd_pcm_substream *substream,
	46	struct snd_pcm_hw_params *params)
	47	{
	48	struct snd_pcm_runtime *runtime = substream->runtime;
	49	struct nuc900_audio *nuc900_audio = runtime->private_data;
018334c0	50	unsigned long flags;
1082e270 WZ	51	int ret = 0;
1082e270 WZ	52
1082e270 WZ	53	ret = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
	54	if (ret < 0)
	55	return ret;
	56
3f1af9d2 AL	57	spin_lock_irqsave(&nuc900_audio->lock, flags);
3f1af9d2 AL	58
1082e270	59	nuc900_audio->substream = substream;
018334c0 WZ	60	nuc900_audio->dma_addr[substream->stream] = runtime->dma_addr;
	61	nuc900_audio->buffersize[substream->stream] =
	62	params_buffer_bytes(params);
1082e270 WZ	63
	64	spin_unlock_irqrestore(&nuc900_audio->lock, flags);
	65
	66	return ret;
	67	}
	68
	69	static void nuc900_update_dma_register(struct snd_pcm_substream *substream,
	70	dma_addr_t dma_addr, size_t count)
	71	{
	72	struct snd_pcm_runtime *runtime = substream->runtime;
	73	struct nuc900_audio *nuc900_audio = runtime->private_data;
	74	void __iomem mmio_addr, mmio_len;
	75
018334c0	76	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1082e270 WZ	77	mmio_addr = nuc900_audio->mmio + ACTL_PDSTB;
	78	mmio_len = nuc900_audio->mmio + ACTL_PDST_LENGTH;
	79	} else {
	80	mmio_addr = nuc900_audio->mmio + ACTL_RDSTB;
	81	mmio_len = nuc900_audio->mmio + ACTL_RDST_LENGTH;
	82	}
	83
	84	AUDIO_WRITE(mmio_addr, dma_addr);
	85	AUDIO_WRITE(mmio_len, count);
	86	}
	87
	88	static void nuc900_dma_start(struct snd_pcm_substream *substream)
	89	{
	90	struct snd_pcm_runtime *runtime = substream->runtime;
	91	struct nuc900_audio *nuc900_audio = runtime->private_data;
	92	unsigned long val;
	93
	94	val = AUDIO_READ(nuc900_audio->mmio + ACTL_CON);
	95	val \|= (T_DMA_IRQ \| R_DMA_IRQ);
	96	AUDIO_WRITE(nuc900_audio->mmio + ACTL_CON, val);
	97	}
	98
	99	static void nuc900_dma_stop(struct snd_pcm_substream *substream)
	100	{
	101	struct snd_pcm_runtime *runtime = substream->runtime;
	102	struct nuc900_audio *nuc900_audio = runtime->private_data;
	103	unsigned long val;
	104
	105	val = AUDIO_READ(nuc900_audio->mmio + ACTL_CON);
	106	val &= ~(T_DMA_IRQ \| R_DMA_IRQ);
	107	AUDIO_WRITE(nuc900_audio->mmio + ACTL_CON, val);
	108	}
	109
	110	static irqreturn_t nuc900_dma_interrupt(int irq, void *dev_id)
	111	{
	112	struct snd_pcm_substream *substream = dev_id;
	113	struct nuc900_audio *nuc900_audio = substream->runtime->private_data;
	114	unsigned long val;
	115
	116	spin_lock(&nuc900_audio->lock);
	117
	118	val = AUDIO_READ(nuc900_audio->mmio + ACTL_CON);
	119
	120	if (val & R_DMA_IRQ) {
	121	AUDIO_WRITE(nuc900_audio->mmio + ACTL_CON, val \| R_DMA_IRQ);
	122
	123	val = AUDIO_READ(nuc900_audio->mmio + ACTL_RSR);
	124
	125	if (val & R_DMA_MIDDLE_IRQ) {
	126	val \|= R_DMA_MIDDLE_IRQ;
	127	AUDIO_WRITE(nuc900_audio->mmio + ACTL_RSR, val);
	128	}
	129
	130	if (val & R_DMA_END_IRQ) {
	131	val \|= R_DMA_END_IRQ;
	132	AUDIO_WRITE(nuc900_audio->mmio + ACTL_RSR, val);
	133	}
	134	} else if (val & T_DMA_IRQ) {
	135	AUDIO_WRITE(nuc900_audio->mmio + ACTL_CON, val \| T_DMA_IRQ);
	136
	137	val = AUDIO_READ(nuc900_audio->mmio + ACTL_PSR);
	138
	139	if (val & P_DMA_MIDDLE_IRQ) {
	140	val \|= P_DMA_MIDDLE_IRQ;
141	AUDIO_WRITE(nuc900_audio->mmio + ACTL_PSR, val);
142	}
143
144	if (val & P_DMA_END_IRQ) {
145	val \|= P_DMA_END_IRQ;
146	AUDIO_WRITE(nuc900_audio->mmio + ACTL_PSR, val);
147	}
148	} else {
149	dev_err(nuc900_audio->dev, "Wrong DMA interrupt status!\n");
150	spin_unlock(&nuc900_audio->lock);
151	return IRQ_HANDLED;
152	}
153
154	spin_unlock(&nuc900_audio->lock);
155
156	snd_pcm_period_elapsed(substream);
157
158	return IRQ_HANDLED;
159	}
160
161	static int nuc900_dma_hw_free(struct snd_pcm_substream *substream)
162	{
163	snd_pcm_lib_free_pages(substream);
164	return 0;
165	}
166
167	static int nuc900_dma_prepare(struct snd_pcm_substream *substream)
168	{
169	struct snd_pcm_runtime *runtime = substream->runtime;
170	struct nuc900_audio *nuc900_audio = runtime->private_data;
018334c0	171	unsigned long flags, val;
3f1af9d2	172	int ret = 0;
1082e270 WZ	173
	174	spin_lock_irqsave(&nuc900_audio->lock, flags);
	175
	176	nuc900_update_dma_register(substream,
018334c0 WZ	177	nuc900_audio->dma_addr[substream->stream],
018334c0 WZ	178	nuc900_audio->buffersize[substream->stream]);
1082e270 WZ	179
	180	val = AUDIO_READ(nuc900_audio->mmio + ACTL_RESET);
	181
	182	switch (runtime->channels) {
	183	case 1:
018334c0	184	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1082e270 WZ	185	val &= ~(PLAY_LEFT_CHNNEL \| PLAY_RIGHT_CHNNEL);
	186	val \|= PLAY_RIGHT_CHNNEL;
	187	} else {
	188	val &= ~(RECORD_LEFT_CHNNEL \| RECORD_RIGHT_CHNNEL);
	189	val \|= RECORD_RIGHT_CHNNEL;
	190	}
	191	AUDIO_WRITE(nuc900_audio->mmio + ACTL_RESET, val);
	192	break;
	193	case 2:
018334c0	194	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1082e270 WZ	195	val \|= (PLAY_LEFT_CHNNEL \| PLAY_RIGHT_CHNNEL);
	196	else
	197	val \|= (RECORD_LEFT_CHNNEL \| RECORD_RIGHT_CHNNEL);
	198	AUDIO_WRITE(nuc900_audio->mmio + ACTL_RESET, val);
	199	break;
	200	default:
3f1af9d2	201	ret = -EINVAL;
1082e270 WZ	202	}
1082e270 WZ	203	spin_unlock_irqrestore(&nuc900_audio->lock, flags);
3f1af9d2	204	return ret;
1082e270 WZ	205	}
	206
	207	static int nuc900_dma_trigger(struct snd_pcm_substream *substream, int cmd)
	208	{
	209	int ret = 0;
	210
	211	switch (cmd) {
	212	case SNDRV_PCM_TRIGGER_START:
	213	case SNDRV_PCM_TRIGGER_RESUME:
	214	nuc900_dma_start(substream);
	215	break;
	216
	217	case SNDRV_PCM_TRIGGER_STOP:
	218	case SNDRV_PCM_TRIGGER_SUSPEND:
	219	nuc900_dma_stop(substream);
	220	break;
	221
	222	default:
	223	ret = -EINVAL;
	224	break;
	225	}
	226
	227	return ret;
	228	}
	229
49acf73b	230	static int nuc900_dma_getposition(struct snd_pcm_substream *substream,
1082e270 WZ	231	dma_addr_t src, dma_addr_t dst)
	232	{
	233	struct snd_pcm_runtime *runtime = substream->runtime;
	234	struct nuc900_audio *nuc900_audio = runtime->private_data;
	235
	236	if (src != NULL)
	237	*src = AUDIO_READ(nuc900_audio->mmio + ACTL_PDSTC);
	238
	239	if (dst != NULL)
	240	*dst = AUDIO_READ(nuc900_audio->mmio + ACTL_RDSTC);
	241
	242	return 0;
	243	}
	244
	245	static snd_pcm_uframes_t nuc900_dma_pointer(struct snd_pcm_substream *substream)
	246	{
	247	struct snd_pcm_runtime *runtime = substream->runtime;
	248	dma_addr_t src, dst;
	249	unsigned long res;
	250
	251	nuc900_dma_getposition(substream, &src, &dst);
	252
	253	if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
	254	res = dst - runtime->dma_addr;
	255	else
	256	res = src - runtime->dma_addr;
	257
	258	return bytes_to_frames(substream->runtime, res);
	259	}
	260
	261	static int nuc900_dma_open(struct snd_pcm_substream *substream)
	262	{
	263	struct snd_pcm_runtime *runtime = substream->runtime;
	264	struct nuc900_audio *nuc900_audio;
	265
	266	snd_soc_set_runtime_hwparams(substream, &nuc900_pcm_hardware);
	267
	268	nuc900_audio = nuc900_ac97_data;
	269
	270	if (request_irq(nuc900_audio->irq_num, nuc900_dma_interrupt,
88e24c3a	271	0, "nuc900-dma", substream))
1082e270 WZ	272	return -EBUSY;
	273
	274	runtime->private_data = nuc900_audio;
	275
	276	return 0;
	277	}
	278
	279	static int nuc900_dma_close(struct snd_pcm_substream *substream)
	280	{
	281	struct snd_pcm_runtime *runtime = substream->runtime;
	282	struct nuc900_audio *nuc900_audio = runtime->private_data;
	283
	284	free_irq(nuc900_audio->irq_num, substream);
	285
	286	return 0;
	287	}
	288
	289	static int nuc900_dma_mmap(struct snd_pcm_substream *substream,
	290	struct vm_area_struct *vma)
	291	{
	292	struct snd_pcm_runtime *runtime = substream->runtime;
	293
	294	return dma_mmap_writecombine(substream->pcm->card->dev, vma,
	295	runtime->dma_area,
	296	runtime->dma_addr,
	297	runtime->dma_bytes);
	298	}
	299
	300	static struct snd_pcm_ops nuc900_dma_ops = {
	301	.open = nuc900_dma_open,
	302	.close = nuc900_dma_close,
	303	.ioctl = snd_pcm_lib_ioctl,
	304	.hw_params = nuc900_dma_hw_params,
	305	.hw_free = nuc900_dma_hw_free,
	306	.prepare = nuc900_dma_prepare,
	307	.trigger = nuc900_dma_trigger,
	308	.pointer = nuc900_dma_pointer,
	309	.mmap = nuc900_dma_mmap,
	310	};
	311
	312	static void nuc900_dma_free_dma_buffers(struct snd_pcm *pcm)
	313	{
	314	snd_pcm_lib_preallocate_free_for_all(pcm);
	315	}
	316
	317	static u64 nuc900_pcm_dmamask = DMA_BIT_MASK(32);
552d1ef6	318	static int nuc900_dma_new(struct snd_soc_pcm_runtime *rtd)
1082e270	319	{
552d1ef6	320	struct snd_card *card = rtd->card->snd_card;
552d1ef6 LG	321	struct snd_pcm *pcm = rtd->pcm;
552d1ef6 LG	322
1082e270 WZ	323	if (!card->dev->dma_mask)
	324	card->dev->dma_mask = &nuc900_pcm_dmamask;
	325	if (!card->dev->coherent_dma_mask)
	326	card->dev->coherent_dma_mask = DMA_BIT_MASK(32);
	327
	328	snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
	329	card->dev, 4 * 1024, (4 * 1024) - 1);
	330
	331	return 0;
	332	}
	333
f0fba2ad LG	334	static struct snd_soc_platform_driver nuc900_soc_platform = {
f0fba2ad LG	335	.ops = &nuc900_dma_ops,
1082e270 WZ	336	.pcm_new = nuc900_dma_new,
1082e270 WZ	337	.pcm_free = nuc900_dma_free_dma_buffers,
a7a9820b	338	};
1082e270	339
ce69ace5	340	static int nuc900_soc_platform_probe(struct platform_device *pdev)
1082e270	341	{
f0fba2ad	342	return snd_soc_register_platform(&pdev->dev, &nuc900_soc_platform);
1082e270 WZ	343	}
1082e270 WZ	344
ce69ace5	345	static int nuc900_soc_platform_remove(struct platform_device *pdev)
1082e270	346	{
f0fba2ad LG	347	snd_soc_unregister_platform(&pdev->dev);
f0fba2ad LG	348	return 0;
1082e270 WZ	349	}
1082e270 WZ	350
f0fba2ad LG	351	static struct platform_driver nuc900_pcm_driver = {
	352	.driver = {
	353	.name = "nuc900-pcm-audio",
	354	.owner = THIS_MODULE,
	355	},
	356
	357	.probe = nuc900_soc_platform_probe,
ce69ace5	358	.remove = nuc900_soc_platform_remove,
f0fba2ad LG	359	};
f0fba2ad LG	360
d0efa6a2	361	module_platform_driver(nuc900_pcm_driver);
1082e270 WZ	362
	363	MODULE_AUTHOR("Wan ZongShun, <mcuos.com@gmail.com>");
	364	MODULE_DESCRIPTION("nuc900 Audio DMA module");
	365	MODULE_LICENSE("GPL");