/* * ALSA timer back-end using hrtimer * Copyright (C) 2008 Takashi Iwai * *   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/slab.h>#include <linux/module.h>#include <linux/moduleparam.h>#include <linux/hrtimer.h>#include <sound/core.h>#include <sound/timer.h> MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");MODULE_DESCRIPTION("ALSA hrtimer backend");MODULE_LICENSE("GPL"); MODULE_ALIAS("snd-timer-" __stringify(SNDRV_TIMER_GLOBAL_HRTIMER)); #define NANO_SEC	1000000000UL	/* 10^9 in sec */static unsigned int resolution; struct snd_hrtimer {	struct snd_timer *timer;	struct hrtimer hrt;	atomic_t running;}; static enum hrtimer_restart snd_hrtimer_callback(struct hrtimer *hrt){	struct snd_hrtimer *stime = container_of(hrt, struct snd_hrtimer, hrt);	struct snd_timer *t = stime->timer;	unsigned long oruns; 	if (!atomic_read(&stime->running))		return HRTIMER_NORESTART; 	oruns = hrtimer_forward_now(hrt, ns_to_ktime(t->sticks * resolution));	snd_timer_interrupt(stime->timer, t->sticks * oruns); 	if (!atomic_read(&stime->running))		return HRTIMER_NORESTART;	return HRTIMER_RESTART;} static int snd_hrtimer_open(struct snd_timer *t){	struct snd_hrtimer *stime; 	stime = kmalloc(sizeof(*stime), GFP_KERNEL);	if (!stime)		return -ENOMEM;	hrtimer_init(&stime->hrt, CLOCK_MONOTONIC, HRTIMER_MODE_REL);	stime->timer = t;	stime->hrt.function = snd_hrtimer_callback;	atomic_set(&stime->running, 0);	t->private_data = stime;	return 0;} static int snd_hrtimer_close(struct snd_timer *t){	struct snd_hrtimer *stime = t->private_data; 	if (stime) {		hrtimer_cancel(&stime->hrt);		kfree(stime);		t->private_data = NULL;	}	return 0;} static int snd_hrtimer_start(struct snd_timer *t){	struct snd_hrtimer *stime = t->private_data; 	atomic_set(&stime->running, 0);	hrtimer_cancel(&stime->hrt);	hrtimer_start(&stime->hrt, ns_to_ktime(t->sticks * resolution),		      HRTIMER_MODE_REL);	atomic_set(&stime->running, 1);	return 0;} static int snd_hrtimer_stop(struct snd_timer *t){	struct snd_hrtimer *stime = t->private_data;	atomic_set(&stime->running, 0);	return 0;} static struct snd_timer_hardware hrtimer_hw = {	.flags =	SNDRV_TIMER_HW_AUTO | SNDRV_TIMER_HW_TASKLET,	.open =		snd_hrtimer_open,	.close =	snd_hrtimer_close,	.start =	snd_hrtimer_start,	.stop =		snd_hrtimer_stop,}; /* * entry functions */ static struct snd_timer *mytimer; static int __init snd_hrtimer_init(void){	struct snd_timer *timer;	struct timespec tp;	int err; 	hrtimer_get_res(CLOCK_MONOTONIC, &tp);	if (tp.tv_sec > 0 || !tp.tv_nsec) {		snd_printk(KERN_ERR			   "snd-hrtimer: Invalid resolution %u.%09u",			   (unsigned)tp.tv_sec, (unsigned)tp.tv_nsec);		return -EINVAL;	}	resolution = tp.tv_nsec; 	/* Create a new timer and set up the fields */	err = snd_timer_global_new("hrtimer", SNDRV_TIMER_GLOBAL_HRTIMER,				   &timer);	if (err < 0)		return err; 	timer->module = THIS_MODULE;	strcpy(timer->name, "HR timer");	timer->hw = hrtimer_hw;	timer->hw.resolution = resolution;	timer->hw.ticks = NANO_SEC / resolution; 	err = snd_timer_global_register(timer);	if (err < 0) {		snd_timer_global_free(timer);		return err;	}	mytimer = timer; /* remember this */ 	return 0;} static void __exit snd_hrtimer_exit(void){	if (mytimer) {		snd_timer_global_free(mytimer);		mytimer = NULL;	}} module_init(snd_hrtimer_init);module_exit(snd_hrtimer_exit);