[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 <sound/driver.h>
#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
	23	#include <sound/driver.h>
	24	#include <linux/init.h>
1da177e4 LT	25	#include <linux/interrupt.h>
1da177e4 LT	26	#include <linux/moduleparam.h>
62e96a1c	27	#include <linux/log2.h>
1da177e4 LT	28	#include <sound/core.h>
1da177e4 LT	29	#include <sound/timer.h>
1da177e4 LT	30
	31	#if defined(CONFIG_RTC) \|\| defined(CONFIG_RTC_MODULE)
	32
	33	#include <linux/mc146818rtc.h>
	34
	35	#define RTC_FREQ 1024 /* default frequency */
	36	#define NANO_SEC 1000000000L /* 10^9 in sec */
	37
	38	/*
	39	* prototypes
	40	*/
53d2f744 TI	41	static int rtctimer_open(struct snd_timer *t);
	42	static int rtctimer_close(struct snd_timer *t);
	43	static int rtctimer_start(struct snd_timer *t);
	44	static int rtctimer_stop(struct snd_timer *t);
1da177e4 LT	45
	46
	47	/*
	48	* The hardware dependent description for this timer.
	49	*/
53d2f744	50	static struct snd_timer_hardware rtc_hw = {
ac5d1a7d CL	51	.flags = SNDRV_TIMER_HW_AUTO \|
	52	SNDRV_TIMER_HW_FIRST \|
	53	SNDRV_TIMER_HW_TASKLET,
1da177e4 LT	54	.ticks = 100000000L, /* FIXME: XXX */
	55	.open = rtctimer_open,
	56	.close = rtctimer_close,
	57	.start = rtctimer_start,
	58	.stop = rtctimer_stop,
	59	};
	60
	61	static int rtctimer_freq = RTC_FREQ; /* frequency */
53d2f744	62	static struct snd_timer *rtctimer;
ac5d1a7d	63	static struct tasklet_struct rtc_tasklet;
1da177e4 LT	64	static rtc_task_t rtc_task;
	65
	66
	67	static int
53d2f744	68	rtctimer_open(struct snd_timer *t)
1da177e4 LT	69	{
	70	int err;
	71
	72	err = rtc_register(&rtc_task);
	73	if (err < 0)
	74	return err;
	75	t->private_data = &rtc_task;
	76	return 0;
	77	}
	78
	79	static int
53d2f744	80	rtctimer_close(struct snd_timer *t)
1da177e4 LT	81	{
	82	rtc_task_t *rtc = t->private_data;
	83	if (rtc) {
	84	rtc_unregister(rtc);
ac5d1a7d	85	tasklet_kill(&rtc_tasklet);
1da177e4 LT	86	t->private_data = NULL;
	87	}
	88	return 0;
	89	}
	90
	91	static int
53d2f744	92	rtctimer_start(struct snd_timer *timer)
1da177e4 LT	93	{
	94	rtc_task_t *rtc = timer->private_data;
	95	snd_assert(rtc != NULL, return -EINVAL);
	96	rtc_control(rtc, RTC_IRQP_SET, rtctimer_freq);
	97	rtc_control(rtc, RTC_PIE_ON, 0);
1da177e4 LT	98	return 0;
	99	}
	100
	101	static int
53d2f744	102	rtctimer_stop(struct snd_timer *timer)
1da177e4 LT	103	{
	104	rtc_task_t *rtc = timer->private_data;
	105	snd_assert(rtc != NULL, return -EINVAL);
	106	rtc_control(rtc, RTC_PIE_OFF, 0);
	107	return 0;
	108	}
	109
ac5d1a7d CL	110	static void rtctimer_tasklet(unsigned long data)
	111	{
	112	snd_timer_interrupt((struct snd_timer *)data, 1);
	113	}
	114
1da177e4 LT	115	/*
	116	* interrupt
	117	*/
	118	static void rtctimer_interrupt(void *private_data)
	119	{
ac5d1a7d	120	tasklet_hi_schedule(private_data);
1da177e4 LT	121	}
	122
	123
	124	/*
	125	* ENTRY functions
	126	*/
	127	static int __init rtctimer_init(void)
	128	{
d9ad1bdd	129	int err;
53d2f744	130	struct snd_timer *timer;
1da177e4	131
d9ad1bdd	132	if (rtctimer_freq < 2 \|\| rtctimer_freq > 8192 \|\|
62e96a1c	133	!is_power_of_2(rtctimer_freq)) {
de24214d CL	134	snd_printk(KERN_ERR "rtctimer: invalid frequency %d\n",
de24214d CL	135	rtctimer_freq);
1da177e4 LT	136	return -EINVAL;
	137	}
	138
	139	/* Create a new timer and set up the fields */
	140	err = snd_timer_global_new("rtc", SNDRV_TIMER_GLOBAL_RTC, &timer);
	141	if (err < 0)
	142	return err;
	143
de24214d	144	timer->module = THIS_MODULE;
1da177e4 LT	145	strcpy(timer->name, "RTC timer");
	146	timer->hw = rtc_hw;
	147	timer->hw.resolution = NANO_SEC / rtctimer_freq;
	148
ac5d1a7d CL	149	tasklet_init(&rtc_tasklet, rtctimer_tasklet, (unsigned long)timer);
ac5d1a7d CL	150
1da177e4 LT	151	/* set up RTC callback */
1da177e4 LT	152	rtc_task.func = rtctimer_interrupt;
ac5d1a7d	153	rtc_task.private_data = &rtc_tasklet;
1da177e4 LT	154
	155	err = snd_timer_global_register(timer);
	156	if (err < 0) {
	157	snd_timer_global_free(timer);
	158	return err;
	159	}
	160	rtctimer = timer; /* remember this */
	161
	162	return 0;
	163	}
	164
	165	static void __exit rtctimer_exit(void)
	166	{
	167	if (rtctimer) {
c461482c	168	snd_timer_global_free(rtctimer);
1da177e4 LT	169	rtctimer = NULL;
	170	}
	171	}
	172
	173
	174	/*
	175	* exported stuff
	176	*/
	177	module_init(rtctimer_init)
	178	module_exit(rtctimer_exit)
	179
	180	module_param(rtctimer_freq, int, 0444);
	181	MODULE_PARM_DESC(rtctimer_freq, "timer frequency in Hz");
	182
	183	MODULE_LICENSE("GPL");
	184
	185	MODULE_ALIAS("snd-timer-" __stringify(SNDRV_TIMER_GLOBAL_RTC));
	186
	187	#endif /* CONFIG_RTC \|\| CONFIG_RTC_MODULE */