[deliverable/linux.git] / sound / core / rtctimer.c

/*
 *  RTC based high-frequency timer
 *
 *  Copyright (C) 2000 Takashi Iwai
 *	based on rtctimer.c by Steve Ratcliffe
 *
 *   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 <linux/init.h>
#include <linux/interrupt.h>
#include <linux/moduleparam.h>
#include <linux/log2.h>
#include <sound/core.h>
#include <sound/timer.h>

#if defined(CONFIG_RTC) || defined(CONFIG_RTC_MODULE)

#include <linux/mc146818rtc.h>

#define RTC_FREQ	1024		/* default frequency */
#define NANO_SEC	1000000000L	/* 10^9 in sec */

/*
 * prototypes
 */
static int rtctimer_open(struct snd_timer *t);
static int rtctimer_close(struct snd_timer *t);
static int rtctimer_start(struct snd_timer *t);
static int rtctimer_stop(struct snd_timer *t);


/*
 * The hardware dependent description for this timer.
 */
static struct snd_timer_hardware rtc_hw = {
	.flags =	SNDRV_TIMER_HW_AUTO |
			SNDRV_TIMER_HW_FIRST |
			SNDRV_TIMER_HW_TASKLET,
	.ticks =	100000000L,		/* FIXME: XXX */
	.open =		rtctimer_open,
	.close =	rtctimer_close,
	.start =	rtctimer_start,
	.stop =		rtctimer_stop,
};

static int rtctimer_freq = RTC_FREQ;		/* frequency */
static struct snd_timer *rtctimer;
static struct tasklet_struct rtc_tasklet;
static rtc_task_t rtc_task;


static int
rtctimer_open(struct snd_timer *t)
{
	int err;

	err = rtc_register(&rtc_task);
	if (err < 0)
		return err;
	t->private_data = &rtc_task;
	return 0;
}

static int
rtctimer_close(struct snd_timer *t)
{
	rtc_task_t *rtc = t->private_data;
	if (rtc) {
		rtc_unregister(rtc);
		tasklet_kill(&rtc_tasklet);
		t->private_data = NULL;
	}
	return 0;
}

static int
rtctimer_start(struct snd_timer *timer)
{
	rtc_task_t *rtc = timer->private_data;
	snd_assert(rtc != NULL, return -EINVAL);
	rtc_control(rtc, RTC_IRQP_SET, rtctimer_freq);
	rtc_control(rtc, RTC_PIE_ON, 0);
	return 0;
}

static int
rtctimer_stop(struct snd_timer *timer)
{
	rtc_task_t *rtc = timer->private_data;
	snd_assert(rtc != NULL, return -EINVAL);
	rtc_control(rtc, RTC_PIE_OFF, 0);
	return 0;
}

static void rtctimer_tasklet(unsigned long data)
{
	snd_timer_interrupt((struct snd_timer *)data, 1);
}

/*
 * interrupt
 */
static void rtctimer_interrupt(void *private_data)
{
	tasklet_hi_schedule(private_data);
}


/*
 *  ENTRY functions
 */
static int __init rtctimer_init(void)
{
	int err;
	struct snd_timer *timer;

	if (rtctimer_freq < 2 || rtctimer_freq > 8192 ||
	    !is_power_of_2(rtctimer_freq)) {
		snd_printk(KERN_ERR "rtctimer: invalid frequency %d\n",
			   rtctimer_freq);
		return -EINVAL;
	}

	/* Create a new timer and set up the fields */
	err = snd_timer_global_new("rtc", SNDRV_TIMER_GLOBAL_RTC, &timer);
	if (err < 0)
		return err;

	timer->module = THIS_MODULE;
	strcpy(timer->name, "RTC timer");
	timer->hw = rtc_hw;
	timer->hw.resolution = NANO_SEC / rtctimer_freq;

	tasklet_init(&rtc_tasklet, rtctimer_tasklet, (unsigned long)timer);

	/* set up RTC callback */
	rtc_task.func = rtctimer_interrupt;
	rtc_task.private_data = &rtc_tasklet;

	err = snd_timer_global_register(timer);
	if (err < 0) {
		snd_timer_global_free(timer);
		return err;
	}
	rtctimer = timer; /* remember this */

	return 0;
}

static void __exit rtctimer_exit(void)
{
	if (rtctimer) {
		snd_timer_global_free(rtctimer);
		rtctimer = NULL;
	}
}


/*
 * exported stuff
 */
module_init(rtctimer_init)
module_exit(rtctimer_exit)

module_param(rtctimer_freq, int, 0444);
MODULE_PARM_DESC(rtctimer_freq, "timer frequency in Hz");

MODULE_LICENSE("GPL");

MODULE_ALIAS("snd-timer-" __stringify(SNDRV_TIMER_GLOBAL_RTC));

#endif /* CONFIG_RTC || CONFIG_RTC_MODULE */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* RTC based high-frequency timer
	3	*
	4	* Copyright (C) 2000 Takashi Iwai
	5	* based on rtctimer.c by Steve Ratcliffe
	6	*
	7	* This program is free software; you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation; either version 2 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program; if not, write to the Free Software
	19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	20	*
	21	*/
	22
1da177e4	23	#include <linux/init.h>
1da177e4 LT	24	#include <linux/interrupt.h>
1da177e4 LT	25	#include <linux/moduleparam.h>
62e96a1c	26	#include <linux/log2.h>
1da177e4 LT	27	#include <sound/core.h>
1da177e4 LT	28	#include <sound/timer.h>
1da177e4 LT	29
	30	#if defined(CONFIG_RTC) \|\| defined(CONFIG_RTC_MODULE)
	31
	32	#include <linux/mc146818rtc.h>
	33
	34	#define RTC_FREQ 1024 /* default frequency */
	35	#define NANO_SEC 1000000000L /* 10^9 in sec */
	36
	37	/*
	38	* prototypes
	39	*/
53d2f744 TI	40	static int rtctimer_open(struct snd_timer *t);
	41	static int rtctimer_close(struct snd_timer *t);
	42	static int rtctimer_start(struct snd_timer *t);
	43	static int rtctimer_stop(struct snd_timer *t);
1da177e4 LT	44
	45
	46	/*
	47	* The hardware dependent description for this timer.
	48	*/
53d2f744	49	static struct snd_timer_hardware rtc_hw = {
ac5d1a7d CL	50	.flags = SNDRV_TIMER_HW_AUTO \|
	51	SNDRV_TIMER_HW_FIRST \|
	52	SNDRV_TIMER_HW_TASKLET,
1da177e4 LT	53	.ticks = 100000000L, /* FIXME: XXX */
	54	.open = rtctimer_open,
	55	.close = rtctimer_close,
	56	.start = rtctimer_start,
	57	.stop = rtctimer_stop,
	58	};
	59
	60	static int rtctimer_freq = RTC_FREQ; /* frequency */
53d2f744	61	static struct snd_timer *rtctimer;
ac5d1a7d	62	static struct tasklet_struct rtc_tasklet;
1da177e4 LT	63	static rtc_task_t rtc_task;
	64
	65
	66	static int
53d2f744	67	rtctimer_open(struct snd_timer *t)
1da177e4 LT	68	{
	69	int err;
	70
	71	err = rtc_register(&rtc_task);
	72	if (err < 0)
	73	return err;
	74	t->private_data = &rtc_task;
	75	return 0;
	76	}
	77
	78	static int
53d2f744	79	rtctimer_close(struct snd_timer *t)
1da177e4 LT	80	{
	81	rtc_task_t *rtc = t->private_data;
	82	if (rtc) {
	83	rtc_unregister(rtc);
ac5d1a7d	84	tasklet_kill(&rtc_tasklet);
1da177e4 LT	85	t->private_data = NULL;
	86	}
	87	return 0;
	88	}
	89
	90	static int
53d2f744	91	rtctimer_start(struct snd_timer *timer)
1da177e4 LT	92	{
	93	rtc_task_t *rtc = timer->private_data;
	94	snd_assert(rtc != NULL, return -EINVAL);
	95	rtc_control(rtc, RTC_IRQP_SET, rtctimer_freq);
	96	rtc_control(rtc, RTC_PIE_ON, 0);
1da177e4 LT	97	return 0;
	98	}
	99
	100	static int
53d2f744	101	rtctimer_stop(struct snd_timer *timer)
1da177e4 LT	102	{
	103	rtc_task_t *rtc = timer->private_data;
	104	snd_assert(rtc != NULL, return -EINVAL);
	105	rtc_control(rtc, RTC_PIE_OFF, 0);
	106	return 0;
	107	}
	108
ac5d1a7d CL	109	static void rtctimer_tasklet(unsigned long data)
	110	{
	111	snd_timer_interrupt((struct snd_timer *)data, 1);
	112	}
	113
1da177e4 LT	114	/*
	115	* interrupt
	116	*/
	117	static void rtctimer_interrupt(void *private_data)
	118	{
ac5d1a7d	119	tasklet_hi_schedule(private_data);
1da177e4 LT	120	}
	121
	122
	123	/*
	124	* ENTRY functions
	125	*/
	126	static int __init rtctimer_init(void)
	127	{
d9ad1bdd	128	int err;
53d2f744	129	struct snd_timer *timer;
1da177e4	130
d9ad1bdd	131	if (rtctimer_freq < 2 \|\| rtctimer_freq > 8192 \|\|
62e96a1c	132	!is_power_of_2(rtctimer_freq)) {
de24214d CL	133	snd_printk(KERN_ERR "rtctimer: invalid frequency %d\n",
de24214d CL	134	rtctimer_freq);
1da177e4 LT	135	return -EINVAL;
	136	}
	137
	138	/* Create a new timer and set up the fields */
	139	err = snd_timer_global_new("rtc", SNDRV_TIMER_GLOBAL_RTC, &timer);
	140	if (err < 0)
	141	return err;
	142
de24214d	143	timer->module = THIS_MODULE;
1da177e4 LT	144	strcpy(timer->name, "RTC timer");
	145	timer->hw = rtc_hw;
	146	timer->hw.resolution = NANO_SEC / rtctimer_freq;
	147
ac5d1a7d CL	148	tasklet_init(&rtc_tasklet, rtctimer_tasklet, (unsigned long)timer);
ac5d1a7d CL	149
1da177e4 LT	150	/* set up RTC callback */
1da177e4 LT	151	rtc_task.func = rtctimer_interrupt;
ac5d1a7d	152	rtc_task.private_data = &rtc_tasklet;
1da177e4 LT	153
	154	err = snd_timer_global_register(timer);
	155	if (err < 0) {
	156	snd_timer_global_free(timer);
	157	return err;
	158	}
	159	rtctimer = timer; /* remember this */
	160
	161	return 0;
	162	}
	163
	164	static void __exit rtctimer_exit(void)
	165	{
	166	if (rtctimer) {
c461482c	167	snd_timer_global_free(rtctimer);
1da177e4 LT	168	rtctimer = NULL;
	169	}
	170	}
	171
	172
	173	/*
	174	* exported stuff
	175	*/
	176	module_init(rtctimer_init)
	177	module_exit(rtctimer_exit)
	178
	179	module_param(rtctimer_freq, int, 0444);
	180	MODULE_PARM_DESC(rtctimer_freq, "timer frequency in Hz");
	181
	182	MODULE_LICENSE("GPL");
	183
	184	MODULE_ALIAS("snd-timer-" __stringify(SNDRV_TIMER_GLOBAL_RTC));
	185
	186	#endif /* CONFIG_RTC \|\| CONFIG_RTC_MODULE */