[net-next-2.6.git] / sound / core / pcm_timer.c

/*
 *  Digital Audio (PCM) abstract layer
 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
 *
 *
 *   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.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 */

#include <sound/driver.h>
#include <linux/time.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/timer.h>

/*
 *  Timer functions
 */

/* Greatest common divisor */
static unsigned long gcd(unsigned long a, unsigned long b)
{
	unsigned long r;
	if (a < b) {
		r = a;
		a = b;
		b = r;
	}
	while ((r = a % b) != 0) {
		a = b;
		b = r;
	}
	return b;
}

void snd_pcm_timer_resolution_change(struct snd_pcm_substream *substream)
{
	unsigned long rate, mult, fsize, l, post;
	struct snd_pcm_runtime *runtime = substream->runtime;
	
        mult = 1000000000;
	rate = runtime->rate;
	snd_assert(rate != 0, return);
	l = gcd(mult, rate);
	mult /= l;
	rate /= l;
	fsize = runtime->period_size;
	snd_assert(fsize != 0, return);
	l = gcd(rate, fsize);
	rate /= l;
	fsize /= l;
	post = 1;
	while ((mult * fsize) / fsize != mult) {
		mult /= 2;
		post *= 2;
	}
	if (rate == 0) {
		snd_printk(KERN_ERR "pcm timer resolution out of range (rate = %u, period_size = %lu)\n", runtime->rate, runtime->period_size);
		runtime->timer_resolution = -1;
		return;
	}
	runtime->timer_resolution = (mult * fsize / rate) * post;
}

static unsigned long snd_pcm_timer_resolution(struct snd_timer * timer)
{
	struct snd_pcm_substream *substream;
	
	substream = timer->private_data;
	return substream->runtime ? substream->runtime->timer_resolution : 0;
}

static int snd_pcm_timer_start(struct snd_timer * timer)
{
	unsigned long flags;
	struct snd_pcm_substream *substream;
	
	substream = snd_timer_chip(timer);
	spin_lock_irqsave(&substream->timer_lock, flags);
	substream->timer_running = 1;
	spin_unlock_irqrestore(&substream->timer_lock, flags);
	return 0;
}

static int snd_pcm_timer_stop(struct snd_timer * timer)
{
	unsigned long flags;
	struct snd_pcm_substream *substream;
	
	substream = snd_timer_chip(timer);
	spin_lock_irqsave(&substream->timer_lock, flags);
	substream->timer_running = 0;
	spin_unlock_irqrestore(&substream->timer_lock, flags);
	return 0;
}

static struct snd_timer_hardware snd_pcm_timer =
{
	.flags =	SNDRV_TIMER_HW_AUTO | SNDRV_TIMER_HW_SLAVE,
	.resolution =	0,
	.ticks =	1,
	.c_resolution =	snd_pcm_timer_resolution,
	.start =	snd_pcm_timer_start,
	.stop =		snd_pcm_timer_stop,
};

/*
 *  Init functions
 */

static void snd_pcm_timer_free(struct snd_timer *timer)
{
	struct snd_pcm_substream *substream = timer->private_data;
	substream->timer = NULL;
}

void snd_pcm_timer_init(struct snd_pcm_substream *substream)
{
	struct snd_timer_id tid;
	struct snd_timer *timer;
	
	tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE;
	tid.dev_class = SNDRV_TIMER_CLASS_PCM;
	tid.card = substream->pcm->card->number;
	tid.device = substream->pcm->device;
	tid.subdevice = (substream->number << 1) | (substream->stream & 1);
	if (snd_timer_new(substream->pcm->card, "PCM", &tid, &timer) < 0)
		return;
	sprintf(timer->name, "PCM %s %i-%i-%i",
			substream->stream == SNDRV_PCM_STREAM_CAPTURE ?
				"capture" : "playback",
			tid.card, tid.device, tid.subdevice);
	timer->hw = snd_pcm_timer;
	if (snd_device_register(timer->card, timer) < 0) {
		snd_device_free(timer->card, timer);
		return;
	}
	timer->private_data = substream;
	timer->private_free = snd_pcm_timer_free;
	substream->timer = timer;
}

void snd_pcm_timer_done(struct snd_pcm_substream *substream)
{
	if (substream->timer) {
		snd_device_free(substream->pcm->card, substream->timer);
		substream->timer = NULL;
	}
}
Commit	Line	Data
1da177e4 LT	1	/*
1da177e4 LT	2	* Digital Audio (PCM) abstract layer
c1017a4c	3	* Copyright (c) by Jaroslav Kysela <perex@perex.cz>
1da177e4 LT	4	*
	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; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	19	*
	20	*/
	21
	22	#include <sound/driver.h>
	23	#include <linux/time.h>
	24	#include <sound/core.h>
	25	#include <sound/pcm.h>
	26	#include <sound/timer.h>
	27
	28	/*
	29	* Timer functions
	30	*/
	31
	32	/* Greatest common divisor */
	33	static unsigned long gcd(unsigned long a, unsigned long b)
	34	{
	35	unsigned long r;
	36	if (a < b) {
	37	r = a;
	38	a = b;
	39	b = r;
	40	}
	41	while ((r = a % b) != 0) {
	42	a = b;
	43	b = r;
	44	}
	45	return b;
	46	}
	47
877211f5	48	void snd_pcm_timer_resolution_change(struct snd_pcm_substream *substream)
1da177e4 LT	49	{
1da177e4 LT	50	unsigned long rate, mult, fsize, l, post;
877211f5	51	struct snd_pcm_runtime *runtime = substream->runtime;
1da177e4 LT	52
	53	mult = 1000000000;
	54	rate = runtime->rate;
	55	snd_assert(rate != 0, return);
	56	l = gcd(mult, rate);
	57	mult /= l;
	58	rate /= l;
	59	fsize = runtime->period_size;
	60	snd_assert(fsize != 0, return);
	61	l = gcd(rate, fsize);
	62	rate /= l;
	63	fsize /= l;
	64	post = 1;
	65	while ((mult * fsize) / fsize != mult) {
	66	mult /= 2;
	67	post *= 2;
	68	}
	69	if (rate == 0) {
	70	snd_printk(KERN_ERR "pcm timer resolution out of range (rate = %u, period_size = %lu)\n", runtime->rate, runtime->period_size);
	71	runtime->timer_resolution = -1;
	72	return;
	73	}
	74	runtime->timer_resolution = (mult * fsize / rate) * post;
	75	}
	76
877211f5	77	static unsigned long snd_pcm_timer_resolution(struct snd_timer * timer)
1da177e4	78	{
877211f5	79	struct snd_pcm_substream *substream;
1da177e4 LT	80
	81	substream = timer->private_data;
	82	return substream->runtime ? substream->runtime->timer_resolution : 0;
	83	}
	84
877211f5	85	static int snd_pcm_timer_start(struct snd_timer * timer)
1da177e4 LT	86	{
1da177e4 LT	87	unsigned long flags;
877211f5	88	struct snd_pcm_substream *substream;
1da177e4 LT	89
	90	substream = snd_timer_chip(timer);
	91	spin_lock_irqsave(&substream->timer_lock, flags);
	92	substream->timer_running = 1;
	93	spin_unlock_irqrestore(&substream->timer_lock, flags);
	94	return 0;
	95	}
	96
877211f5	97	static int snd_pcm_timer_stop(struct snd_timer * timer)
1da177e4 LT	98	{
1da177e4 LT	99	unsigned long flags;
877211f5	100	struct snd_pcm_substream *substream;
1da177e4 LT	101
	102	substream = snd_timer_chip(timer);
	103	spin_lock_irqsave(&substream->timer_lock, flags);
	104	substream->timer_running = 0;
	105	spin_unlock_irqrestore(&substream->timer_lock, flags);
	106	return 0;
	107	}
	108
877211f5	109	static struct snd_timer_hardware snd_pcm_timer =
1da177e4 LT	110	{
	111	.flags = SNDRV_TIMER_HW_AUTO \| SNDRV_TIMER_HW_SLAVE,
	112	.resolution = 0,
	113	.ticks = 1,
	114	.c_resolution = snd_pcm_timer_resolution,
	115	.start = snd_pcm_timer_start,
	116	.stop = snd_pcm_timer_stop,
	117	};
	118
	119	/*
	120	* Init functions
	121	*/
	122
877211f5	123	static void snd_pcm_timer_free(struct snd_timer *timer)
1da177e4	124	{
877211f5	125	struct snd_pcm_substream *substream = timer->private_data;
1da177e4 LT	126	substream->timer = NULL;
	127	}
	128
877211f5	129	void snd_pcm_timer_init(struct snd_pcm_substream *substream)
1da177e4	130	{
877211f5 TI	131	struct snd_timer_id tid;
877211f5 TI	132	struct snd_timer *timer;
1da177e4 LT	133
	134	tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE;
	135	tid.dev_class = SNDRV_TIMER_CLASS_PCM;
	136	tid.card = substream->pcm->card->number;
	137	tid.device = substream->pcm->device;
	138	tid.subdevice = (substream->number << 1) \| (substream->stream & 1);
	139	if (snd_timer_new(substream->pcm->card, "PCM", &tid, &timer) < 0)
	140	return;
	141	sprintf(timer->name, "PCM %s %i-%i-%i",
	142	substream->stream == SNDRV_PCM_STREAM_CAPTURE ?
	143	"capture" : "playback",
	144	tid.card, tid.device, tid.subdevice);
	145	timer->hw = snd_pcm_timer;
	146	if (snd_device_register(timer->card, timer) < 0) {
	147	snd_device_free(timer->card, timer);
	148	return;
	149	}
	150	timer->private_data = substream;
	151	timer->private_free = snd_pcm_timer_free;
	152	substream->timer = timer;
	153	}
	154
877211f5	155	void snd_pcm_timer_done(struct snd_pcm_substream *substream)
1da177e4 LT	156	{
	157	if (substream->timer) {
	158	snd_device_free(substream->pcm->card, substream->timer);
	159	substream->timer = NULL;
	160	}
	161	}