[mirror_ubuntu-zesty-kernel.git] / sound / arm / pxa2xx-pcm.c

/*
 * linux/sound/arm/pxa2xx-pcm.c -- ALSA PCM interface for the Intel PXA2xx chip
 *
 * Author:	Nicolas Pitre
 * Created:	Nov 30, 2004
 * Copyright:	(C) 2004 MontaVista Software, Inc.
 *
 * 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 <sound/core.h>
#include <sound/pxa2xx-lib.h>

#include "pxa2xx-pcm.h"

static int pxa2xx_pcm_prepare(struct snd_pcm_substream *substream)
{
	struct pxa2xx_pcm_client *client = substream->private_data;

	__pxa2xx_pcm_prepare(substream);

	return client->prepare(substream);
}

static int pxa2xx_pcm_open(struct snd_pcm_substream *substream)
{
	struct pxa2xx_pcm_client *client = substream->private_data;
	struct snd_pcm_runtime *runtime = substream->runtime;
	struct pxa2xx_runtime_data *rtd;
	int ret;

	ret = __pxa2xx_pcm_open(substream);
	if (ret)
		goto out;

	rtd = runtime->private_data;

	rtd->params = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
		      client->playback_params : client->capture_params;
	ret = pxa_request_dma(rtd->params->name, DMA_PRIO_LOW,
			      pxa2xx_pcm_dma_irq, substream);
	if (ret < 0)
		goto err2;
	rtd->dma_ch = ret;

	ret = client->startup(substream);
	if (!ret)
		goto out;

	pxa_free_dma(rtd->dma_ch);
 err2:
	__pxa2xx_pcm_close(substream);
 out:
	return ret;
}

static int pxa2xx_pcm_close(struct snd_pcm_substream *substream)
{
	struct pxa2xx_pcm_client *client = substream->private_data;
	struct pxa2xx_runtime_data *rtd = substream->runtime->private_data;

	pxa_free_dma(rtd->dma_ch);
	client->shutdown(substream);

	return __pxa2xx_pcm_close(substream);
}

static struct snd_pcm_ops pxa2xx_pcm_ops = {
	.open		= pxa2xx_pcm_open,
	.close		= pxa2xx_pcm_close,
	.ioctl		= snd_pcm_lib_ioctl,
	.hw_params	= __pxa2xx_pcm_hw_params,
	.hw_free	= __pxa2xx_pcm_hw_free,
	.prepare	= pxa2xx_pcm_prepare,
	.trigger	= pxa2xx_pcm_trigger,
	.pointer	= pxa2xx_pcm_pointer,
	.mmap		= pxa2xx_pcm_mmap,
};

static u64 pxa2xx_pcm_dmamask = 0xffffffff;

int pxa2xx_pcm_new(struct snd_card *card, struct pxa2xx_pcm_client *client,
		   struct snd_pcm **rpcm)
{
	struct snd_pcm *pcm;
	int play = client->playback_params ? 1 : 0;
	int capt = client->capture_params ? 1 : 0;
	int ret;

	ret = snd_pcm_new(card, "PXA2xx-PCM", 0, play, capt, &pcm);
	if (ret)
		goto out;

	pcm->private_data = client;
	pcm->private_free = pxa2xx_pcm_free_dma_buffers;

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

	if (play) {
		int stream = SNDRV_PCM_STREAM_PLAYBACK;
		snd_pcm_set_ops(pcm, stream, &pxa2xx_pcm_ops);
		ret = pxa2xx_pcm_preallocate_dma_buffer(pcm, stream);
		if (ret)
			goto out;
	}
	if (capt) {
		int stream = SNDRV_PCM_STREAM_CAPTURE;
		snd_pcm_set_ops(pcm, stream, &pxa2xx_pcm_ops);
		ret = pxa2xx_pcm_preallocate_dma_buffer(pcm, stream);
		if (ret)
			goto out;
	}

	if (rpcm)
		*rpcm = pcm;
	ret = 0;

 out:
	return ret;
}

EXPORT_SYMBOL(pxa2xx_pcm_new);

MODULE_AUTHOR("Nicolas Pitre");
MODULE_DESCRIPTION("Intel PXA2xx PCM DMA module");
MODULE_LICENSE("GPL");
Commit	Line	Data
2c484df0 TI	1	/*
	2	* linux/sound/arm/pxa2xx-pcm.c -- ALSA PCM interface for the Intel PXA2xx chip
	3	*
	4	* Author: Nicolas Pitre
	5	* Created: Nov 30, 2004
	6	* Copyright: (C) 2004 MontaVista Software, Inc.
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*/
	12
da155d5b	13	#include <linux/module.h>
2c484df0	14	#include <sound/core.h>
a6d77317	15	#include <sound/pxa2xx-lib.h>
2c484df0 TI	16
	17	#include "pxa2xx-pcm.h"
	18
d18f8376	19	static int pxa2xx_pcm_prepare(struct snd_pcm_substream *substream)
2c484df0	20	{
d18f8376	21	struct pxa2xx_pcm_client *client = substream->private_data;
2c484df0	22
a6d77317	23	__pxa2xx_pcm_prepare(substream);
2c484df0 TI	24
	25	return client->prepare(substream);
	26	}
	27
d18f8376	28	static int pxa2xx_pcm_open(struct snd_pcm_substream *substream)
2c484df0	29	{
d18f8376 TI	30	struct pxa2xx_pcm_client *client = substream->private_data;
d18f8376 TI	31	struct snd_pcm_runtime *runtime = substream->runtime;
2c484df0 TI	32	struct pxa2xx_runtime_data *rtd;
	33	int ret;
	34
a6d77317	35	ret = __pxa2xx_pcm_open(substream);
2c484df0 TI	36	if (ret)
	37	goto out;
	38
a6d77317	39	rtd = runtime->private_data;
2c484df0 TI	40
	41	rtd->params = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
	42	client->playback_params : client->capture_params;
	43	ret = pxa_request_dma(rtd->params->name, DMA_PRIO_LOW,
	44	pxa2xx_pcm_dma_irq, substream);
	45	if (ret < 0)
	46	goto err2;
	47	rtd->dma_ch = ret;
	48
2c484df0 TI	49	ret = client->startup(substream);
	50	if (!ret)
	51	goto out;
	52
	53	pxa_free_dma(rtd->dma_ch);
	54	err2:
a6d77317	55	__pxa2xx_pcm_close(substream);
2c484df0 TI	56	out:
	57	return ret;
	58	}
	59
d18f8376	60	static int pxa2xx_pcm_close(struct snd_pcm_substream *substream)
2c484df0	61	{
d18f8376	62	struct pxa2xx_pcm_client *client = substream->private_data;
2c484df0 TI	63	struct pxa2xx_runtime_data *rtd = substream->runtime->private_data;
	64
	65	pxa_free_dma(rtd->dma_ch);
	66	client->shutdown(substream);
2c484df0	67
a6d77317	68	return __pxa2xx_pcm_close(substream);
2c484df0 TI	69	}
2c484df0 TI	70
d18f8376	71	static struct snd_pcm_ops pxa2xx_pcm_ops = {
2c484df0 TI	72	.open = pxa2xx_pcm_open,
	73	.close = pxa2xx_pcm_close,
	74	.ioctl = snd_pcm_lib_ioctl,
a6d77317 DES	75	.hw_params = __pxa2xx_pcm_hw_params,
a6d77317 DES	76	.hw_free = __pxa2xx_pcm_hw_free,
2c484df0 TI	77	.prepare = pxa2xx_pcm_prepare,
	78	.trigger = pxa2xx_pcm_trigger,
	79	.pointer = pxa2xx_pcm_pointer,
	80	.mmap = pxa2xx_pcm_mmap,
	81	};
	82
2c484df0 TI	83	static u64 pxa2xx_pcm_dmamask = 0xffffffff;
2c484df0 TI	84
d18f8376 TI	85	int pxa2xx_pcm_new(struct snd_card card, struct pxa2xx_pcm_client client,
d18f8376 TI	86	struct snd_pcm **rpcm)
2c484df0	87	{
d18f8376	88	struct snd_pcm *pcm;
2c484df0 TI	89	int play = client->playback_params ? 1 : 0;
	90	int capt = client->capture_params ? 1 : 0;
	91	int ret;
	92
	93	ret = snd_pcm_new(card, "PXA2xx-PCM", 0, play, capt, &pcm);
	94	if (ret)
	95	goto out;
	96
	97	pcm->private_data = client;
	98	pcm->private_free = pxa2xx_pcm_free_dma_buffers;
	99
	100	if (!card->dev->dma_mask)
	101	card->dev->dma_mask = &pxa2xx_pcm_dmamask;
	102	if (!card->dev->coherent_dma_mask)
	103	card->dev->coherent_dma_mask = 0xffffffff;
	104
	105	if (play) {
	106	int stream = SNDRV_PCM_STREAM_PLAYBACK;
	107	snd_pcm_set_ops(pcm, stream, &pxa2xx_pcm_ops);
	108	ret = pxa2xx_pcm_preallocate_dma_buffer(pcm, stream);
	109	if (ret)
	110	goto out;
	111	}
	112	if (capt) {
	113	int stream = SNDRV_PCM_STREAM_CAPTURE;
	114	snd_pcm_set_ops(pcm, stream, &pxa2xx_pcm_ops);
	115	ret = pxa2xx_pcm_preallocate_dma_buffer(pcm, stream);
	116	if (ret)
	117	goto out;
	118	}
	119
	120	if (rpcm)
	121	*rpcm = pcm;
	122	ret = 0;
	123
	124	out:
	125	return ret;
	126	}
	127
	128	EXPORT_SYMBOL(pxa2xx_pcm_new);
	129
	130	MODULE_AUTHOR("Nicolas Pitre");
	131	MODULE_DESCRIPTION("Intel PXA2xx PCM DMA module");
	132	MODULE_LICENSE("GPL");