1/*
   2 *  Timers abstract layer
   3 *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
   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 <linux/delay.h>
  23#include <linux/init.h>
  24#include <linux/slab.h>
  25#include <linux/time.h>
  26#include <linux/mutex.h>
  27#include <linux/device.h>
  28#include <linux/module.h>
  29#include <linux/string.h>
  30#include <sound/core.h>
  31#include <sound/timer.h>
  32#include <sound/control.h>
  33#include <sound/info.h>
  34#include <sound/minors.h>
  35#include <sound/initval.h>
  36#include <linux/kmod.h>
  37
  38#if IS_ENABLED(CONFIG_SND_HRTIMER)
  39#define DEFAULT_TIMER_LIMIT 4
  40#elif IS_ENABLED(CONFIG_SND_RTCTIMER)
  41#define DEFAULT_TIMER_LIMIT 2
  42#else
  43#define DEFAULT_TIMER_LIMIT 1
  44#endif
  45
  46static int timer_limit = DEFAULT_TIMER_LIMIT;
  47static int timer_tstamp_monotonic = 1;
  48MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Takashi Iwai <tiwai@suse.de>");
  49MODULE_DESCRIPTION("ALSA timer interface");
  50MODULE_LICENSE("GPL");
  51module_param(timer_limit, int, 0444);
  52MODULE_PARM_DESC(timer_limit, "Maximum global timers in system.");
  53module_param(timer_tstamp_monotonic, int, 0444);
  54MODULE_PARM_DESC(timer_tstamp_monotonic, "Use posix monotonic clock source for timestamps (default).");
  55
  56MODULE_ALIAS_CHARDEV(CONFIG_SND_MAJOR, SNDRV_MINOR_TIMER);
  57MODULE_ALIAS("devname:snd/timer");
  58
  59struct snd_timer_user {
  60	struct snd_timer_instance *timeri;
  61	int tread;		/* enhanced read with timestamps and events */
  62	unsigned long ticks;
  63	unsigned long overrun;
  64	int qhead;
  65	int qtail;
  66	int qused;
  67	int queue_size;
 
  68	struct snd_timer_read *queue;
  69	struct snd_timer_tread *tqueue;
  70	spinlock_t qlock;
  71	unsigned long last_resolution;
  72	unsigned int filter;
  73	struct timespec tstamp;		/* trigger tstamp */
  74	wait_queue_head_t qchange_sleep;
  75	struct fasync_struct *fasync;
  76	struct mutex tread_sem;
  77};
  78
  79/* list of timers */
  80static LIST_HEAD(snd_timer_list);
  81
  82/* list of slave instances */
  83static LIST_HEAD(snd_timer_slave_list);
  84
  85/* lock for slave active lists */
  86static DEFINE_SPINLOCK(slave_active_lock);
  87
  88static DEFINE_MUTEX(register_mutex);
  89
  90static int snd_timer_free(struct snd_timer *timer);
  91static int snd_timer_dev_free(struct snd_device *device);
  92static int snd_timer_dev_register(struct snd_device *device);
  93static int snd_timer_dev_disconnect(struct snd_device *device);
  94
  95static void snd_timer_reschedule(struct snd_timer * timer, unsigned long ticks_left);
  96
  97/*
  98 * create a timer instance with the given owner string.
  99 * when timer is not NULL, increments the module counter
 100 */
 101static struct snd_timer_instance *snd_timer_instance_new(char *owner,
 102							 struct snd_timer *timer)
 103{
 104	struct snd_timer_instance *timeri;
 105	timeri = kzalloc(sizeof(*timeri), GFP_KERNEL);
 106	if (timeri == NULL)
 107		return NULL;
 108	timeri->owner = kstrdup(owner, GFP_KERNEL);
 109	if (! timeri->owner) {
 110		kfree(timeri);
 111		return NULL;
 112	}
 113	INIT_LIST_HEAD(&timeri->open_list);
 114	INIT_LIST_HEAD(&timeri->active_list);
 115	INIT_LIST_HEAD(&timeri->ack_list);
 116	INIT_LIST_HEAD(&timeri->slave_list_head);
 117	INIT_LIST_HEAD(&timeri->slave_active_head);
 118
 119	timeri->timer = timer;
 120	if (timer && !try_module_get(timer->module)) {
 121		kfree(timeri->owner);
 122		kfree(timeri);
 123		return NULL;
 124	}
 125
 126	return timeri;
 127}
 128
 129/*
 130 * find a timer instance from the given timer id
 131 */
 132static struct snd_timer *snd_timer_find(struct snd_timer_id *tid)
 133{
 134	struct snd_timer *timer = NULL;
 135
 136	list_for_each_entry(timer, &snd_timer_list, device_list) {
 137		if (timer->tmr_class != tid->dev_class)
 138			continue;
 139		if ((timer->tmr_class == SNDRV_TIMER_CLASS_CARD ||
 140		     timer->tmr_class == SNDRV_TIMER_CLASS_PCM) &&
 141		    (timer->card == NULL ||
 142		     timer->card->number != tid->card))
 143			continue;
 144		if (timer->tmr_device != tid->device)
 145			continue;
 146		if (timer->tmr_subdevice != tid->subdevice)
 147			continue;
 148		return timer;
 149	}
 150	return NULL;
 151}
 152
 153#ifdef CONFIG_MODULES
 154
 155static void snd_timer_request(struct snd_timer_id *tid)
 156{
 157	switch (tid->dev_class) {
 158	case SNDRV_TIMER_CLASS_GLOBAL:
 159		if (tid->device < timer_limit)
 160			request_module("snd-timer-%i", tid->device);
 161		break;
 162	case SNDRV_TIMER_CLASS_CARD:
 163	case SNDRV_TIMER_CLASS_PCM:
 164		if (tid->card < snd_ecards_limit)
 165			request_module("snd-card-%i", tid->card);
 166		break;
 167	default:
 168		break;
 169	}
 170}
 171
 172#endif
 173
 174/*
 175 * look for a master instance matching with the slave id of the given slave.
 176 * when found, relink the open_link of the slave.
 177 *
 178 * call this with register_mutex down.
 179 */
 180static void snd_timer_check_slave(struct snd_timer_instance *slave)
 181{
 182	struct snd_timer *timer;
 183	struct snd_timer_instance *master;
 184
 185	/* FIXME: it's really dumb to look up all entries.. */
 186	list_for_each_entry(timer, &snd_timer_list, device_list) {
 187		list_for_each_entry(master, &timer->open_list_head, open_list) {
 188			if (slave->slave_class == master->slave_class &&
 189			    slave->slave_id == master->slave_id) {
 190				list_move_tail(&slave->open_list,
 191					       &master->slave_list_head);
 192				spin_lock_irq(&slave_active_lock);
 193				slave->master = master;
 194				slave->timer = master->timer;
 195				spin_unlock_irq(&slave_active_lock);
 196				return;
 197			}
 198		}
 199	}
 200}
 201
 202/*
 203 * look for slave instances matching with the slave id of the given master.
 204 * when found, relink the open_link of slaves.
 205 *
 206 * call this with register_mutex down.
 207 */
 208static void snd_timer_check_master(struct snd_timer_instance *master)
 209{
 210	struct snd_timer_instance *slave, *tmp;
 211
 212	/* check all pending slaves */
 213	list_for_each_entry_safe(slave, tmp, &snd_timer_slave_list, open_list) {
 214		if (slave->slave_class == master->slave_class &&
 215		    slave->slave_id == master->slave_id) {
 216			list_move_tail(&slave->open_list, &master->slave_list_head);
 217			spin_lock_irq(&slave_active_lock);
 
 218			slave->master = master;
 219			slave->timer = master->timer;
 220			if (slave->flags & SNDRV_TIMER_IFLG_RUNNING)
 221				list_add_tail(&slave->active_list,
 222					      &master->slave_active_head);
 
 223			spin_unlock_irq(&slave_active_lock);
 224		}
 225	}
 226}
 227
 228/*
 229 * open a timer instance
 230 * when opening a master, the slave id must be here given.
 231 */
 232int snd_timer_open(struct snd_timer_instance **ti,
 233		   char *owner, struct snd_timer_id *tid,
 234		   unsigned int slave_id)
 235{
 236	struct snd_timer *timer;
 237	struct snd_timer_instance *timeri = NULL;
 238
 239	if (tid->dev_class == SNDRV_TIMER_CLASS_SLAVE) {
 240		/* open a slave instance */
 241		if (tid->dev_sclass <= SNDRV_TIMER_SCLASS_NONE ||
 242		    tid->dev_sclass > SNDRV_TIMER_SCLASS_OSS_SEQUENCER) {
 243			pr_debug("ALSA: timer: invalid slave class %i\n",
 244				 tid->dev_sclass);
 245			return -EINVAL;
 246		}
 247		mutex_lock(&register_mutex);
 248		timeri = snd_timer_instance_new(owner, NULL);
 249		if (!timeri) {
 250			mutex_unlock(&register_mutex);
 251			return -ENOMEM;
 252		}
 253		timeri->slave_class = tid->dev_sclass;
 254		timeri->slave_id = tid->device;
 255		timeri->flags |= SNDRV_TIMER_IFLG_SLAVE;
 256		list_add_tail(&timeri->open_list, &snd_timer_slave_list);
 257		snd_timer_check_slave(timeri);
 258		mutex_unlock(&register_mutex);
 259		*ti = timeri;
 260		return 0;
 261	}
 262
 263	/* open a master instance */
 264	mutex_lock(&register_mutex);
 265	timer = snd_timer_find(tid);
 266#ifdef CONFIG_MODULES
 267	if (!timer) {
 268		mutex_unlock(&register_mutex);
 269		snd_timer_request(tid);
 270		mutex_lock(&register_mutex);
 271		timer = snd_timer_find(tid);
 272	}
 273#endif
 274	if (!timer) {
 275		mutex_unlock(&register_mutex);
 276		return -ENODEV;
 277	}
 278	if (!list_empty(&timer->open_list_head)) {
 279		timeri = list_entry(timer->open_list_head.next,
 280				    struct snd_timer_instance, open_list);
 281		if (timeri->flags & SNDRV_TIMER_IFLG_EXCLUSIVE) {
 282			mutex_unlock(&register_mutex);
 283			return -EBUSY;
 284		}
 285	}
 286	timeri = snd_timer_instance_new(owner, timer);
 287	if (!timeri) {
 288		mutex_unlock(&register_mutex);
 289		return -ENOMEM;
 290	}
 
 
 
 291	timeri->slave_class = tid->dev_sclass;
 292	timeri->slave_id = slave_id;
 293	if (list_empty(&timer->open_list_head) && timer->hw.open)
 294		timer->hw.open(timer);
 295	list_add_tail(&timeri->open_list, &timer->open_list_head);
 296	snd_timer_check_master(timeri);
 297	mutex_unlock(&register_mutex);
 298	*ti = timeri;
 299	return 0;
 300}
 301
 302static int _snd_timer_stop(struct snd_timer_instance *timeri,
 303			   int keep_flag, int event);
 304
 305/*
 306 * close a timer instance
 307 */
 308int snd_timer_close(struct snd_timer_instance *timeri)
 309{
 310	struct snd_timer *timer = NULL;
 311	struct snd_timer_instance *slave, *tmp;
 312
 313	if (snd_BUG_ON(!timeri))
 314		return -ENXIO;
 315
 
 
 
 316	/* force to stop the timer */
 317	snd_timer_stop(timeri);
 318
 319	if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE) {
 320		/* wait, until the active callback is finished */
 321		spin_lock_irq(&slave_active_lock);
 322		while (timeri->flags & SNDRV_TIMER_IFLG_CALLBACK) {
 323			spin_unlock_irq(&slave_active_lock);
 324			udelay(10);
 325			spin_lock_irq(&slave_active_lock);
 326		}
 327		spin_unlock_irq(&slave_active_lock);
 328		mutex_lock(&register_mutex);
 329		list_del(&timeri->open_list);
 330		mutex_unlock(&register_mutex);
 331	} else {
 332		timer = timeri->timer;
 333		if (snd_BUG_ON(!timer))
 334			goto out;
 335		/* wait, until the active callback is finished */
 336		spin_lock_irq(&timer->lock);
 337		while (timeri->flags & SNDRV_TIMER_IFLG_CALLBACK) {
 338			spin_unlock_irq(&timer->lock);
 339			udelay(10);
 340			spin_lock_irq(&timer->lock);
 341		}
 342		spin_unlock_irq(&timer->lock);
 343		mutex_lock(&register_mutex);
 344		list_del(&timeri->open_list);
 345		if (timer && list_empty(&timer->open_list_head) &&
 346		    timer->hw.close)
 347			timer->hw.close(timer);
 348		/* remove slave links */
 
 
 349		list_for_each_entry_safe(slave, tmp, &timeri->slave_list_head,
 350					 open_list) {
 351			spin_lock_irq(&slave_active_lock);
 352			_snd_timer_stop(slave, 1, SNDRV_TIMER_EVENT_RESOLUTION);
 353			list_move_tail(&slave->open_list, &snd_timer_slave_list);
 354			slave->master = NULL;
 355			slave->timer = NULL;
 356			spin_unlock_irq(&slave_active_lock);
 
 357		}
 358		mutex_unlock(&register_mutex);
 
 
 
 
 
 359	}
 360 out:
 361	if (timeri->private_free)
 362		timeri->private_free(timeri);
 363	kfree(timeri->owner);
 364	kfree(timeri);
 365	if (timer)
 
 
 
 
 
 
 366		module_put(timer->module);
 
 
 
 367	return 0;
 368}
 369
 370unsigned long snd_timer_resolution(struct snd_timer_instance *timeri)
 371{
 372	struct snd_timer * timer;
 373
 374	if (timeri == NULL)
 375		return 0;
 376	if ((timer = timeri->timer) != NULL) {
 377		if (timer->hw.c_resolution)
 378			return timer->hw.c_resolution(timer);
 379		return timer->hw.resolution;
 380	}
 381	return 0;
 382}
 383
 384static void snd_timer_notify1(struct snd_timer_instance *ti, int event)
 385{
 386	struct snd_timer *timer;
 387	unsigned long flags;
 388	unsigned long resolution = 0;
 389	struct snd_timer_instance *ts;
 390	struct timespec tstamp;
 391
 392	if (timer_tstamp_monotonic)
 393		do_posix_clock_monotonic_gettime(&tstamp);
 394	else
 395		getnstimeofday(&tstamp);
 396	if (snd_BUG_ON(event < SNDRV_TIMER_EVENT_START ||
 397		       event > SNDRV_TIMER_EVENT_PAUSE))
 398		return;
 399	if (event == SNDRV_TIMER_EVENT_START ||
 400	    event == SNDRV_TIMER_EVENT_CONTINUE)
 401		resolution = snd_timer_resolution(ti);
 402	if (ti->ccallback)
 403		ti->ccallback(ti, event, &tstamp, resolution);
 404	if (ti->flags & SNDRV_TIMER_IFLG_SLAVE)
 405		return;
 406	timer = ti->timer;
 407	if (timer == NULL)
 408		return;
 409	if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)
 410		return;
 411	spin_lock_irqsave(&timer->lock, flags);
 412	list_for_each_entry(ts, &ti->slave_active_head, active_list)
 413		if (ts->ccallback)
 414			ts->ccallback(ti, event + 100, &tstamp, resolution);
 415	spin_unlock_irqrestore(&timer->lock, flags);
 416}
 417
 418static int snd_timer_start1(struct snd_timer *timer, struct snd_timer_instance *timeri,
 419			    unsigned long sticks)
 
 420{
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 421	list_move_tail(&timeri->active_list, &timer->active_list_head);
 422	if (timer->running) {
 423		if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)
 424			goto __start_now;
 425		timer->flags |= SNDRV_TIMER_FLG_RESCHED;
 426		timeri->flags |= SNDRV_TIMER_IFLG_START;
 427		return 1;	/* delayed start */
 428	} else {
 429		timer->sticks = sticks;
 
 430		timer->hw.start(timer);
 431	      __start_now:
 432		timer->running++;
 433		timeri->flags |= SNDRV_TIMER_IFLG_RUNNING;
 434		return 0;
 435	}
 
 
 
 
 
 436}
 437
 438static int snd_timer_start_slave(struct snd_timer_instance *timeri)
 
 
 439{
 440	unsigned long flags;
 441
 442	spin_lock_irqsave(&slave_active_lock, flags);
 
 
 
 
 443	timeri->flags |= SNDRV_TIMER_IFLG_RUNNING;
 444	if (timeri->master)
 
 445		list_add_tail(&timeri->active_list,
 446			      &timeri->master->slave_active_head);
 
 
 
 
 447	spin_unlock_irqrestore(&slave_active_lock, flags);
 448	return 1; /* delayed start */
 449}
 450
 451/*
 452 *  start the timer instance
 453 */
 454int snd_timer_start(struct snd_timer_instance *timeri, unsigned int ticks)
 455{
 456	struct snd_timer *timer;
 457	int result = -EINVAL;
 458	unsigned long flags;
 459
 460	if (timeri == NULL || ticks < 1)
 461		return -EINVAL;
 462	if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE) {
 463		result = snd_timer_start_slave(timeri);
 464		snd_timer_notify1(timeri, SNDRV_TIMER_EVENT_START);
 465		return result;
 466	}
 467	timer = timeri->timer;
 468	if (timer == NULL)
 469		return -EINVAL;
 470	spin_lock_irqsave(&timer->lock, flags);
 471	timeri->ticks = timeri->cticks = ticks;
 472	timeri->pticks = 0;
 473	result = snd_timer_start1(timer, timeri, ticks);
 474	spin_unlock_irqrestore(&timer->lock, flags);
 475	snd_timer_notify1(timeri, SNDRV_TIMER_EVENT_START);
 476	return result;
 477}
 478
 479static int _snd_timer_stop(struct snd_timer_instance * timeri,
 480			   int keep_flag, int event)
 481{
 482	struct snd_timer *timer;
 483	unsigned long flags;
 484
 485	if (snd_BUG_ON(!timeri))
 486		return -ENXIO;
 487
 488	if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE) {
 489		if (!keep_flag) {
 490			spin_lock_irqsave(&slave_active_lock, flags);
 491			timeri->flags &= ~SNDRV_TIMER_IFLG_RUNNING;
 492			spin_unlock_irqrestore(&slave_active_lock, flags);
 493		}
 494		goto __end;
 495	}
 496	timer = timeri->timer;
 497	if (!timer)
 498		return -EINVAL;
 499	spin_lock_irqsave(&timer->lock, flags);
 
 
 
 
 
 500	list_del_init(&timeri->ack_list);
 501	list_del_init(&timeri->active_list);
 
 
 
 
 
 
 502	if ((timeri->flags & SNDRV_TIMER_IFLG_RUNNING) &&
 503	    !(--timer->running)) {
 504		timer->hw.stop(timer);
 505		if (timer->flags & SNDRV_TIMER_FLG_RESCHED) {
 506			timer->flags &= ~SNDRV_TIMER_FLG_RESCHED;
 507			snd_timer_reschedule(timer, 0);
 508			if (timer->flags & SNDRV_TIMER_FLG_CHANGE) {
 509				timer->flags &= ~SNDRV_TIMER_FLG_CHANGE;
 510				timer->hw.start(timer);
 511			}
 512		}
 513	}
 514	if (!keep_flag)
 515		timeri->flags &=
 516			~(SNDRV_TIMER_IFLG_RUNNING | SNDRV_TIMER_IFLG_START);
 
 517	spin_unlock_irqrestore(&timer->lock, flags);
 518      __end:
 519	if (event != SNDRV_TIMER_EVENT_RESOLUTION)
 520		snd_timer_notify1(timeri, event);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 521	return 0;
 522}
 523
 524/*
 
 
 
 
 
 
 
 
 
 
 
 
 
 525 * stop the timer instance.
 526 *
 527 * do not call this from the timer callback!
 528 */
 529int snd_timer_stop(struct snd_timer_instance *timeri)
 530{
 531	struct snd_timer *timer;
 532	unsigned long flags;
 533	int err;
 534
 535	err = _snd_timer_stop(timeri, 0, SNDRV_TIMER_EVENT_STOP);
 536	if (err < 0)
 537		return err;
 538	timer = timeri->timer;
 539	if (!timer)
 540		return -EINVAL;
 541	spin_lock_irqsave(&timer->lock, flags);
 542	timeri->cticks = timeri->ticks;
 543	timeri->pticks = 0;
 544	spin_unlock_irqrestore(&timer->lock, flags);
 545	return 0;
 546}
 547
 548/*
 549 * start again..  the tick is kept.
 550 */
 551int snd_timer_continue(struct snd_timer_instance *timeri)
 552{
 553	struct snd_timer *timer;
 554	int result = -EINVAL;
 555	unsigned long flags;
 556
 557	if (timeri == NULL)
 558		return result;
 559	if (timeri->flags & SNDRV_TIMER_IFLG_SLAVE)
 560		return snd_timer_start_slave(timeri);
 561	timer = timeri->timer;
 562	if (! timer)
 563		return -EINVAL;
 564	spin_lock_irqsave(&timer->lock, flags);
 565	if (!timeri->cticks)
 566		timeri->cticks = 1;
 567	timeri->pticks = 0;
 568	result = snd_timer_start1(timer, timeri, timer->sticks);
 569	spin_unlock_irqrestore(&timer->lock, flags);
 570	snd_timer_notify1(timeri, SNDRV_TIMER_EVENT_CONTINUE);
 571	return result;
 572}
 573
 574/*
 575 * pause.. remember the ticks left
 576 */
 577int snd_timer_pause(struct snd_timer_instance * timeri)
 578{
 579	return _snd_timer_stop(timeri, 0, SNDRV_TIMER_EVENT_PAUSE);
 
 
 
 580}
 581
 582/*
 583 * reschedule the timer
 584 *
 585 * start pending instances and check the scheduling ticks.
 586 * when the scheduling ticks is changed set CHANGE flag to reprogram the timer.
 587 */
 588static void snd_timer_reschedule(struct snd_timer * timer, unsigned long ticks_left)
 589{
 590	struct snd_timer_instance *ti;
 591	unsigned long ticks = ~0UL;
 592
 593	list_for_each_entry(ti, &timer->active_list_head, active_list) {
 594		if (ti->flags & SNDRV_TIMER_IFLG_START) {
 595			ti->flags &= ~SNDRV_TIMER_IFLG_START;
 596			ti->flags |= SNDRV_TIMER_IFLG_RUNNING;
 597			timer->running++;
 598		}
 599		if (ti->flags & SNDRV_TIMER_IFLG_RUNNING) {
 600			if (ticks > ti->cticks)
 601				ticks = ti->cticks;
 602		}
 603	}
 604	if (ticks == ~0UL) {
 605		timer->flags &= ~SNDRV_TIMER_FLG_RESCHED;
 606		return;
 607	}
 608	if (ticks > timer->hw.ticks)
 609		ticks = timer->hw.ticks;
 610	if (ticks_left != ticks)
 611		timer->flags |= SNDRV_TIMER_FLG_CHANGE;
 612	timer->sticks = ticks;
 613}
 614
 615/*
 616 * timer tasklet
 617 *
 618 */
 619static void snd_timer_tasklet(unsigned long arg)
 620{
 621	struct snd_timer *timer = (struct snd_timer *) arg;
 622	struct snd_timer_instance *ti;
 623	struct list_head *p;
 624	unsigned long resolution, ticks;
 625	unsigned long flags;
 626
 
 
 
 627	spin_lock_irqsave(&timer->lock, flags);
 628	/* now process all callbacks */
 629	while (!list_empty(&timer->sack_list_head)) {
 630		p = timer->sack_list_head.next;		/* get first item */
 631		ti = list_entry(p, struct snd_timer_instance, ack_list);
 632
 633		/* remove from ack_list and make empty */
 634		list_del_init(p);
 635
 636		ticks = ti->pticks;
 637		ti->pticks = 0;
 638		resolution = ti->resolution;
 639
 640		ti->flags |= SNDRV_TIMER_IFLG_CALLBACK;
 641		spin_unlock(&timer->lock);
 642		if (ti->callback)
 643			ti->callback(ti, resolution, ticks);
 644		spin_lock(&timer->lock);
 645		ti->flags &= ~SNDRV_TIMER_IFLG_CALLBACK;
 646	}
 647	spin_unlock_irqrestore(&timer->lock, flags);
 648}
 649
 650/*
 651 * timer interrupt
 652 *
 653 * ticks_left is usually equal to timer->sticks.
 654 *
 655 */
 656void snd_timer_interrupt(struct snd_timer * timer, unsigned long ticks_left)
 657{
 658	struct snd_timer_instance *ti, *ts, *tmp;
 659	unsigned long resolution, ticks;
 660	struct list_head *p, *ack_list_head;
 661	unsigned long flags;
 662	int use_tasklet = 0;
 663
 664	if (timer == NULL)
 665		return;
 666
 
 
 
 667	spin_lock_irqsave(&timer->lock, flags);
 668
 669	/* remember the current resolution */
 670	if (timer->hw.c_resolution)
 671		resolution = timer->hw.c_resolution(timer);
 672	else
 673		resolution = timer->hw.resolution;
 674
 675	/* loop for all active instances
 676	 * Here we cannot use list_for_each_entry because the active_list of a
 677	 * processed instance is relinked to done_list_head before the callback
 678	 * is called.
 679	 */
 680	list_for_each_entry_safe(ti, tmp, &timer->active_list_head,
 681				 active_list) {
 682		if (!(ti->flags & SNDRV_TIMER_IFLG_RUNNING))
 683			continue;
 684		ti->pticks += ticks_left;
 685		ti->resolution = resolution;
 686		if (ti->cticks < ticks_left)
 687			ti->cticks = 0;
 688		else
 689			ti->cticks -= ticks_left;
 690		if (ti->cticks) /* not expired */
 691			continue;
 692		if (ti->flags & SNDRV_TIMER_IFLG_AUTO) {
 693			ti->cticks = ti->ticks;
 694		} else {
 695			ti->flags &= ~SNDRV_TIMER_IFLG_RUNNING;
 696			if (--timer->running)
 697				list_del(&ti->active_list);
 698		}
 699		if ((timer->hw.flags & SNDRV_TIMER_HW_TASKLET) ||
 700		    (ti->flags & SNDRV_TIMER_IFLG_FAST))
 701			ack_list_head = &timer->ack_list_head;
 702		else
 703			ack_list_head = &timer->sack_list_head;
 704		if (list_empty(&ti->ack_list))
 705			list_add_tail(&ti->ack_list, ack_list_head);
 706		list_for_each_entry(ts, &ti->slave_active_head, active_list) {
 707			ts->pticks = ti->pticks;
 708			ts->resolution = resolution;
 709			if (list_empty(&ts->ack_list))
 710				list_add_tail(&ts->ack_list, ack_list_head);
 711		}
 712	}
 713	if (timer->flags & SNDRV_TIMER_FLG_RESCHED)
 714		snd_timer_reschedule(timer, timer->sticks);
 715	if (timer->running) {
 716		if (timer->hw.flags & SNDRV_TIMER_HW_STOP) {
 717			timer->hw.stop(timer);
 718			timer->flags |= SNDRV_TIMER_FLG_CHANGE;
 719		}
 720		if (!(timer->hw.flags & SNDRV_TIMER_HW_AUTO) ||
 721		    (timer->flags & SNDRV_TIMER_FLG_CHANGE)) {
 722			/* restart timer */
 723			timer->flags &= ~SNDRV_TIMER_FLG_CHANGE;
 724			timer->hw.start(timer);
 725		}
 726	} else {
 727		timer->hw.stop(timer);
 728	}
 729
 730	/* now process all fast callbacks */
 731	while (!list_empty(&timer->ack_list_head)) {
 732		p = timer->ack_list_head.next;		/* get first item */
 733		ti = list_entry(p, struct snd_timer_instance, ack_list);
 734
 735		/* remove from ack_list and make empty */
 736		list_del_init(p);
 737
 738		ticks = ti->pticks;
 739		ti->pticks = 0;
 740
 741		ti->flags |= SNDRV_TIMER_IFLG_CALLBACK;
 742		spin_unlock(&timer->lock);
 743		if (ti->callback)
 744			ti->callback(ti, resolution, ticks);
 745		spin_lock(&timer->lock);
 746		ti->flags &= ~SNDRV_TIMER_IFLG_CALLBACK;
 747	}
 748
 749	/* do we have any slow callbacks? */
 750	use_tasklet = !list_empty(&timer->sack_list_head);
 751	spin_unlock_irqrestore(&timer->lock, flags);
 752
 753	if (use_tasklet)
 754		tasklet_schedule(&timer->task_queue);
 755}
 756
 757/*
 758
 759 */
 760
 761int snd_timer_new(struct snd_card *card, char *id, struct snd_timer_id *tid,
 762		  struct snd_timer **rtimer)
 763{
 764	struct snd_timer *timer;
 765	int err;
 766	static struct snd_device_ops ops = {
 767		.dev_free = snd_timer_dev_free,
 768		.dev_register = snd_timer_dev_register,
 769		.dev_disconnect = snd_timer_dev_disconnect,
 770	};
 771
 772	if (snd_BUG_ON(!tid))
 773		return -EINVAL;
 774	if (rtimer)
 775		*rtimer = NULL;
 776	timer = kzalloc(sizeof(*timer), GFP_KERNEL);
 777	if (timer == NULL) {
 778		pr_err("ALSA: timer: cannot allocate\n");
 779		return -ENOMEM;
 780	}
 781	timer->tmr_class = tid->dev_class;
 782	timer->card = card;
 783	timer->tmr_device = tid->device;
 784	timer->tmr_subdevice = tid->subdevice;
 785	if (id)
 786		strlcpy(timer->id, id, sizeof(timer->id));
 787	INIT_LIST_HEAD(&timer->device_list);
 788	INIT_LIST_HEAD(&timer->open_list_head);
 789	INIT_LIST_HEAD(&timer->active_list_head);
 790	INIT_LIST_HEAD(&timer->ack_list_head);
 791	INIT_LIST_HEAD(&timer->sack_list_head);
 792	spin_lock_init(&timer->lock);
 793	tasklet_init(&timer->task_queue, snd_timer_tasklet,
 794		     (unsigned long)timer);
 795	if (card != NULL) {
 796		timer->module = card->module;
 797		err = snd_device_new(card, SNDRV_DEV_TIMER, timer, &ops);
 798		if (err < 0) {
 799			snd_timer_free(timer);
 800			return err;
 801		}
 802	}
 803	if (rtimer)
 804		*rtimer = timer;
 805	return 0;
 806}
 807
 808static int snd_timer_free(struct snd_timer *timer)
 809{
 810	if (!timer)
 811		return 0;
 812
 813	mutex_lock(&register_mutex);
 814	if (! list_empty(&timer->open_list_head)) {
 815		struct list_head *p, *n;
 816		struct snd_timer_instance *ti;
 817		pr_warn("ALSA: timer %p is busy?\n", timer);
 818		list_for_each_safe(p, n, &timer->open_list_head) {
 819			list_del_init(p);
 820			ti = list_entry(p, struct snd_timer_instance, open_list);
 821			ti->timer = NULL;
 822		}
 823	}
 824	list_del(&timer->device_list);
 825	mutex_unlock(&register_mutex);
 826
 827	if (timer->private_free)
 828		timer->private_free(timer);
 829	kfree(timer);
 830	return 0;
 831}
 832
 833static int snd_timer_dev_free(struct snd_device *device)
 834{
 835	struct snd_timer *timer = device->device_data;
 836	return snd_timer_free(timer);
 837}
 838
 839static int snd_timer_dev_register(struct snd_device *dev)
 840{
 841	struct snd_timer *timer = dev->device_data;
 842	struct snd_timer *timer1;
 843
 844	if (snd_BUG_ON(!timer || !timer->hw.start || !timer->hw.stop))
 845		return -ENXIO;
 846	if (!(timer->hw.flags & SNDRV_TIMER_HW_SLAVE) &&
 847	    !timer->hw.resolution && timer->hw.c_resolution == NULL)
 848	    	return -EINVAL;
 849
 850	mutex_lock(&register_mutex);
 851	list_for_each_entry(timer1, &snd_timer_list, device_list) {
 852		if (timer1->tmr_class > timer->tmr_class)
 853			break;
 854		if (timer1->tmr_class < timer->tmr_class)
 855			continue;
 856		if (timer1->card && timer->card) {
 857			if (timer1->card->number > timer->card->number)
 858				break;
 859			if (timer1->card->number < timer->card->number)
 860				continue;
 861		}
 862		if (timer1->tmr_device > timer->tmr_device)
 863			break;
 864		if (timer1->tmr_device < timer->tmr_device)
 865			continue;
 866		if (timer1->tmr_subdevice > timer->tmr_subdevice)
 867			break;
 868		if (timer1->tmr_subdevice < timer->tmr_subdevice)
 869			continue;
 870		/* conflicts.. */
 871		mutex_unlock(&register_mutex);
 872		return -EBUSY;
 873	}
 874	list_add_tail(&timer->device_list, &timer1->device_list);
 875	mutex_unlock(&register_mutex);
 876	return 0;
 877}
 878
 879static int snd_timer_dev_disconnect(struct snd_device *device)
 880{
 881	struct snd_timer *timer = device->device_data;
 
 
 882	mutex_lock(&register_mutex);
 883	list_del_init(&timer->device_list);
 
 
 
 
 
 884	mutex_unlock(&register_mutex);
 885	return 0;
 886}
 887
 888void snd_timer_notify(struct snd_timer *timer, int event, struct timespec *tstamp)
 889{
 890	unsigned long flags;
 891	unsigned long resolution = 0;
 892	struct snd_timer_instance *ti, *ts;
 893
 
 
 894	if (! (timer->hw.flags & SNDRV_TIMER_HW_SLAVE))
 895		return;
 896	if (snd_BUG_ON(event < SNDRV_TIMER_EVENT_MSTART ||
 897		       event > SNDRV_TIMER_EVENT_MRESUME))
 898		return;
 899	spin_lock_irqsave(&timer->lock, flags);
 900	if (event == SNDRV_TIMER_EVENT_MSTART ||
 901	    event == SNDRV_TIMER_EVENT_MCONTINUE ||
 902	    event == SNDRV_TIMER_EVENT_MRESUME) {
 903		if (timer->hw.c_resolution)
 904			resolution = timer->hw.c_resolution(timer);
 905		else
 906			resolution = timer->hw.resolution;
 907	}
 908	list_for_each_entry(ti, &timer->active_list_head, active_list) {
 909		if (ti->ccallback)
 910			ti->ccallback(ti, event, tstamp, resolution);
 911		list_for_each_entry(ts, &ti->slave_active_head, active_list)
 912			if (ts->ccallback)
 913				ts->ccallback(ts, event, tstamp, resolution);
 914	}
 915	spin_unlock_irqrestore(&timer->lock, flags);
 916}
 917
 918/*
 919 * exported functions for global timers
 920 */
 921int snd_timer_global_new(char *id, int device, struct snd_timer **rtimer)
 922{
 923	struct snd_timer_id tid;
 924
 925	tid.dev_class = SNDRV_TIMER_CLASS_GLOBAL;
 926	tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE;
 927	tid.card = -1;
 928	tid.device = device;
 929	tid.subdevice = 0;
 930	return snd_timer_new(NULL, id, &tid, rtimer);
 931}
 932
 933int snd_timer_global_free(struct snd_timer *timer)
 934{
 935	return snd_timer_free(timer);
 936}
 937
 938int snd_timer_global_register(struct snd_timer *timer)
 939{
 940	struct snd_device dev;
 941
 942	memset(&dev, 0, sizeof(dev));
 943	dev.device_data = timer;
 944	return snd_timer_dev_register(&dev);
 945}
 946
 947/*
 948 *  System timer
 949 */
 950
 951struct snd_timer_system_private {
 952	struct timer_list tlist;
 953	unsigned long last_expires;
 954	unsigned long last_jiffies;
 955	unsigned long correction;
 956};
 957
 958static void snd_timer_s_function(unsigned long data)
 959{
 960	struct snd_timer *timer = (struct snd_timer *)data;
 961	struct snd_timer_system_private *priv = timer->private_data;
 962	unsigned long jiff = jiffies;
 963	if (time_after(jiff, priv->last_expires))
 964		priv->correction += (long)jiff - (long)priv->last_expires;
 965	snd_timer_interrupt(timer, (long)jiff - (long)priv->last_jiffies);
 966}
 967
 968static int snd_timer_s_start(struct snd_timer * timer)
 969{
 970	struct snd_timer_system_private *priv;
 971	unsigned long njiff;
 972
 973	priv = (struct snd_timer_system_private *) timer->private_data;
 974	njiff = (priv->last_jiffies = jiffies);
 975	if (priv->correction > timer->sticks - 1) {
 976		priv->correction -= timer->sticks - 1;
 977		njiff++;
 978	} else {
 979		njiff += timer->sticks - priv->correction;
 980		priv->correction = 0;
 981	}
 982	priv->last_expires = priv->tlist.expires = njiff;
 983	add_timer(&priv->tlist);
 984	return 0;
 985}
 986
 987static int snd_timer_s_stop(struct snd_timer * timer)
 988{
 989	struct snd_timer_system_private *priv;
 990	unsigned long jiff;
 991
 992	priv = (struct snd_timer_system_private *) timer->private_data;
 993	del_timer(&priv->tlist);
 994	jiff = jiffies;
 995	if (time_before(jiff, priv->last_expires))
 996		timer->sticks = priv->last_expires - jiff;
 997	else
 998		timer->sticks = 1;
 999	priv->correction = 0;
1000	return 0;
1001}
1002
 
 
 
 
 
 
 
 
 
1003static struct snd_timer_hardware snd_timer_system =
1004{
1005	.flags =	SNDRV_TIMER_HW_FIRST | SNDRV_TIMER_HW_TASKLET,
1006	.resolution =	1000000000L / HZ,
1007	.ticks =	10000000L,
 
1008	.start =	snd_timer_s_start,
1009	.stop =		snd_timer_s_stop
1010};
1011
1012static void snd_timer_free_system(struct snd_timer *timer)
1013{
1014	kfree(timer->private_data);
1015}
1016
1017static int snd_timer_register_system(void)
1018{
1019	struct snd_timer *timer;
1020	struct snd_timer_system_private *priv;
1021	int err;
1022
1023	err = snd_timer_global_new("system", SNDRV_TIMER_GLOBAL_SYSTEM, &timer);
1024	if (err < 0)
1025		return err;
1026	strcpy(timer->name, "system timer");
1027	timer->hw = snd_timer_system;
1028	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1029	if (priv == NULL) {
1030		snd_timer_free(timer);
1031		return -ENOMEM;
1032	}
1033	init_timer(&priv->tlist);
1034	priv->tlist.function = snd_timer_s_function;
1035	priv->tlist.data = (unsigned long) timer;
1036	timer->private_data = priv;
1037	timer->private_free = snd_timer_free_system;
1038	return snd_timer_global_register(timer);
1039}
1040
1041#ifdef CONFIG_PROC_FS
1042/*
1043 *  Info interface
1044 */
1045
1046static void snd_timer_proc_read(struct snd_info_entry *entry,
1047				struct snd_info_buffer *buffer)
1048{
1049	struct snd_timer *timer;
1050	struct snd_timer_instance *ti;
1051
1052	mutex_lock(&register_mutex);
1053	list_for_each_entry(timer, &snd_timer_list, device_list) {
 
 
1054		switch (timer->tmr_class) {
1055		case SNDRV_TIMER_CLASS_GLOBAL:
1056			snd_iprintf(buffer, "G%i: ", timer->tmr_device);
1057			break;
1058		case SNDRV_TIMER_CLASS_CARD:
1059			snd_iprintf(buffer, "C%i-%i: ",
1060				    timer->card->number, timer->tmr_device);
1061			break;
1062		case SNDRV_TIMER_CLASS_PCM:
1063			snd_iprintf(buffer, "P%i-%i-%i: ", timer->card->number,
1064				    timer->tmr_device, timer->tmr_subdevice);
1065			break;
1066		default:
1067			snd_iprintf(buffer, "?%i-%i-%i-%i: ", timer->tmr_class,
1068				    timer->card ? timer->card->number : -1,
1069				    timer->tmr_device, timer->tmr_subdevice);
1070		}
1071		snd_iprintf(buffer, "%s :", timer->name);
1072		if (timer->hw.resolution)
1073			snd_iprintf(buffer, " %lu.%03luus (%lu ticks)",
1074				    timer->hw.resolution / 1000,
1075				    timer->hw.resolution % 1000,
1076				    timer->hw.ticks);
1077		if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE)
1078			snd_iprintf(buffer, " SLAVE");
1079		snd_iprintf(buffer, "\n");
1080		list_for_each_entry(ti, &timer->open_list_head, open_list)
1081			snd_iprintf(buffer, "  Client %s : %s\n",
1082				    ti->owner ? ti->owner : "unknown",
1083				    ti->flags & (SNDRV_TIMER_IFLG_START |
1084						 SNDRV_TIMER_IFLG_RUNNING)
1085				    ? "running" : "stopped");
1086	}
1087	mutex_unlock(&register_mutex);
1088}
1089
1090static struct snd_info_entry *snd_timer_proc_entry;
1091
1092static void __init snd_timer_proc_init(void)
1093{
1094	struct snd_info_entry *entry;
1095
1096	entry = snd_info_create_module_entry(THIS_MODULE, "timers", NULL);
1097	if (entry != NULL) {
1098		entry->c.text.read = snd_timer_proc_read;
1099		if (snd_info_register(entry) < 0) {
1100			snd_info_free_entry(entry);
1101			entry = NULL;
1102		}
1103	}
1104	snd_timer_proc_entry = entry;
1105}
1106
1107static void __exit snd_timer_proc_done(void)
1108{
1109	snd_info_free_entry(snd_timer_proc_entry);
1110}
1111#else /* !CONFIG_PROC_FS */
1112#define snd_timer_proc_init()
1113#define snd_timer_proc_done()
1114#endif
1115
1116/*
1117 *  USER SPACE interface
1118 */
1119
1120static void snd_timer_user_interrupt(struct snd_timer_instance *timeri,
1121				     unsigned long resolution,
1122				     unsigned long ticks)
1123{
1124	struct snd_timer_user *tu = timeri->callback_data;
1125	struct snd_timer_read *r;
1126	int prev;
1127
1128	spin_lock(&tu->qlock);
1129	if (tu->qused > 0) {
1130		prev = tu->qtail == 0 ? tu->queue_size - 1 : tu->qtail - 1;
1131		r = &tu->queue[prev];
1132		if (r->resolution == resolution) {
1133			r->ticks += ticks;
1134			goto __wake;
1135		}
1136	}
1137	if (tu->qused >= tu->queue_size) {
1138		tu->overrun++;
1139	} else {
1140		r = &tu->queue[tu->qtail++];
1141		tu->qtail %= tu->queue_size;
1142		r->resolution = resolution;
1143		r->ticks = ticks;
1144		tu->qused++;
1145	}
1146      __wake:
1147	spin_unlock(&tu->qlock);
1148	kill_fasync(&tu->fasync, SIGIO, POLL_IN);
1149	wake_up(&tu->qchange_sleep);
1150}
1151
1152static void snd_timer_user_append_to_tqueue(struct snd_timer_user *tu,
1153					    struct snd_timer_tread *tread)
1154{
1155	if (tu->qused >= tu->queue_size) {
1156		tu->overrun++;
1157	} else {
1158		memcpy(&tu->tqueue[tu->qtail++], tread, sizeof(*tread));
1159		tu->qtail %= tu->queue_size;
1160		tu->qused++;
1161	}
1162}
1163
1164static void snd_timer_user_ccallback(struct snd_timer_instance *timeri,
1165				     int event,
1166				     struct timespec *tstamp,
1167				     unsigned long resolution)
1168{
1169	struct snd_timer_user *tu = timeri->callback_data;
1170	struct snd_timer_tread r1;
1171	unsigned long flags;
1172
1173	if (event >= SNDRV_TIMER_EVENT_START &&
1174	    event <= SNDRV_TIMER_EVENT_PAUSE)
1175		tu->tstamp = *tstamp;
1176	if ((tu->filter & (1 << event)) == 0 || !tu->tread)
1177		return;
1178	r1.event = event;
1179	r1.tstamp = *tstamp;
1180	r1.val = resolution;
1181	spin_lock_irqsave(&tu->qlock, flags);
1182	snd_timer_user_append_to_tqueue(tu, &r1);
1183	spin_unlock_irqrestore(&tu->qlock, flags);
1184	kill_fasync(&tu->fasync, SIGIO, POLL_IN);
1185	wake_up(&tu->qchange_sleep);
1186}
1187
 
 
 
 
 
 
 
 
1188static void snd_timer_user_tinterrupt(struct snd_timer_instance *timeri,
1189				      unsigned long resolution,
1190				      unsigned long ticks)
1191{
1192	struct snd_timer_user *tu = timeri->callback_data;
1193	struct snd_timer_tread *r, r1;
1194	struct timespec tstamp;
1195	int prev, append = 0;
1196
1197	memset(&tstamp, 0, sizeof(tstamp));
1198	spin_lock(&tu->qlock);
1199	if ((tu->filter & ((1 << SNDRV_TIMER_EVENT_RESOLUTION) |
1200			   (1 << SNDRV_TIMER_EVENT_TICK))) == 0) {
1201		spin_unlock(&tu->qlock);
1202		return;
1203	}
1204	if (tu->last_resolution != resolution || ticks > 0) {
1205		if (timer_tstamp_monotonic)
1206			do_posix_clock_monotonic_gettime(&tstamp);
1207		else
1208			getnstimeofday(&tstamp);
1209	}
1210	if ((tu->filter & (1 << SNDRV_TIMER_EVENT_RESOLUTION)) &&
1211	    tu->last_resolution != resolution) {
1212		r1.event = SNDRV_TIMER_EVENT_RESOLUTION;
1213		r1.tstamp = tstamp;
1214		r1.val = resolution;
1215		snd_timer_user_append_to_tqueue(tu, &r1);
1216		tu->last_resolution = resolution;
1217		append++;
1218	}
1219	if ((tu->filter & (1 << SNDRV_TIMER_EVENT_TICK)) == 0)
1220		goto __wake;
1221	if (ticks == 0)
1222		goto __wake;
1223	if (tu->qused > 0) {
1224		prev = tu->qtail == 0 ? tu->queue_size - 1 : tu->qtail - 1;
1225		r = &tu->tqueue[prev];
1226		if (r->event == SNDRV_TIMER_EVENT_TICK) {
1227			r->tstamp = tstamp;
1228			r->val += ticks;
1229			append++;
1230			goto __wake;
1231		}
1232	}
1233	r1.event = SNDRV_TIMER_EVENT_TICK;
1234	r1.tstamp = tstamp;
1235	r1.val = ticks;
1236	snd_timer_user_append_to_tqueue(tu, &r1);
1237	append++;
1238      __wake:
1239	spin_unlock(&tu->qlock);
1240	if (append == 0)
1241		return;
1242	kill_fasync(&tu->fasync, SIGIO, POLL_IN);
1243	wake_up(&tu->qchange_sleep);
1244}
1245
1246static int snd_timer_user_open(struct inode *inode, struct file *file)
1247{
1248	struct snd_timer_user *tu;
1249	int err;
1250
1251	err = nonseekable_open(inode, file);
1252	if (err < 0)
1253		return err;
1254
1255	tu = kzalloc(sizeof(*tu), GFP_KERNEL);
1256	if (tu == NULL)
1257		return -ENOMEM;
1258	spin_lock_init(&tu->qlock);
1259	init_waitqueue_head(&tu->qchange_sleep);
1260	mutex_init(&tu->tread_sem);
1261	tu->ticks = 1;
1262	tu->queue_size = 128;
1263	tu->queue = kmalloc(tu->queue_size * sizeof(struct snd_timer_read),
1264			    GFP_KERNEL);
1265	if (tu->queue == NULL) {
1266		kfree(tu);
1267		return -ENOMEM;
1268	}
1269	file->private_data = tu;
1270	return 0;
1271}
1272
1273static int snd_timer_user_release(struct inode *inode, struct file *file)
1274{
1275	struct snd_timer_user *tu;
1276
1277	if (file->private_data) {
1278		tu = file->private_data;
1279		file->private_data = NULL;
 
1280		if (tu->timeri)
1281			snd_timer_close(tu->timeri);
 
1282		kfree(tu->queue);
1283		kfree(tu->tqueue);
1284		kfree(tu);
1285	}
1286	return 0;
1287}
1288
1289static void snd_timer_user_zero_id(struct snd_timer_id *id)
1290{
1291	id->dev_class = SNDRV_TIMER_CLASS_NONE;
1292	id->dev_sclass = SNDRV_TIMER_SCLASS_NONE;
1293	id->card = -1;
1294	id->device = -1;
1295	id->subdevice = -1;
1296}
1297
1298static void snd_timer_user_copy_id(struct snd_timer_id *id, struct snd_timer *timer)
1299{
1300	id->dev_class = timer->tmr_class;
1301	id->dev_sclass = SNDRV_TIMER_SCLASS_NONE;
1302	id->card = timer->card ? timer->card->number : -1;
1303	id->device = timer->tmr_device;
1304	id->subdevice = timer->tmr_subdevice;
1305}
1306
1307static int snd_timer_user_next_device(struct snd_timer_id __user *_tid)
1308{
1309	struct snd_timer_id id;
1310	struct snd_timer *timer;
1311	struct list_head *p;
1312
1313	if (copy_from_user(&id, _tid, sizeof(id)))
1314		return -EFAULT;
1315	mutex_lock(&register_mutex);
1316	if (id.dev_class < 0) {		/* first item */
1317		if (list_empty(&snd_timer_list))
1318			snd_timer_user_zero_id(&id);
1319		else {
1320			timer = list_entry(snd_timer_list.next,
1321					   struct snd_timer, device_list);
1322			snd_timer_user_copy_id(&id, timer);
1323		}
1324	} else {
1325		switch (id.dev_class) {
1326		case SNDRV_TIMER_CLASS_GLOBAL:
1327			id.device = id.device < 0 ? 0 : id.device + 1;
1328			list_for_each(p, &snd_timer_list) {
1329				timer = list_entry(p, struct snd_timer, device_list);
1330				if (timer->tmr_class > SNDRV_TIMER_CLASS_GLOBAL) {
1331					snd_timer_user_copy_id(&id, timer);
1332					break;
1333				}
1334				if (timer->tmr_device >= id.device) {
1335					snd_timer_user_copy_id(&id, timer);
1336					break;
1337				}
1338			}
1339			if (p == &snd_timer_list)
1340				snd_timer_user_zero_id(&id);
1341			break;
1342		case SNDRV_TIMER_CLASS_CARD:
1343		case SNDRV_TIMER_CLASS_PCM:
1344			if (id.card < 0) {
1345				id.card = 0;
1346			} else {
1347				if (id.card < 0) {
1348					id.card = 0;
1349				} else {
1350					if (id.device < 0) {
1351						id.device = 0;
1352					} else {
1353						if (id.subdevice < 0) {
1354							id.subdevice = 0;
1355						} else {
1356							id.subdevice++;
1357						}
1358					}
1359				}
1360			}
1361			list_for_each(p, &snd_timer_list) {
1362				timer = list_entry(p, struct snd_timer, device_list);
1363				if (timer->tmr_class > id.dev_class) {
1364					snd_timer_user_copy_id(&id, timer);
1365					break;
1366				}
1367				if (timer->tmr_class < id.dev_class)
1368					continue;
1369				if (timer->card->number > id.card) {
1370					snd_timer_user_copy_id(&id, timer);
1371					break;
1372				}
1373				if (timer->card->number < id.card)
1374					continue;
1375				if (timer->tmr_device > id.device) {
1376					snd_timer_user_copy_id(&id, timer);
1377					break;
1378				}
1379				if (timer->tmr_device < id.device)
1380					continue;
1381				if (timer->tmr_subdevice > id.subdevice) {
1382					snd_timer_user_copy_id(&id, timer);
1383					break;
1384				}
1385				if (timer->tmr_subdevice < id.subdevice)
1386					continue;
1387				snd_timer_user_copy_id(&id, timer);
1388				break;
1389			}
1390			if (p == &snd_timer_list)
1391				snd_timer_user_zero_id(&id);
1392			break;
1393		default:
1394			snd_timer_user_zero_id(&id);
1395		}
1396	}
1397	mutex_unlock(&register_mutex);
1398	if (copy_to_user(_tid, &id, sizeof(*_tid)))
1399		return -EFAULT;
1400	return 0;
1401}
1402
1403static int snd_timer_user_ginfo(struct file *file,
1404				struct snd_timer_ginfo __user *_ginfo)
1405{
1406	struct snd_timer_ginfo *ginfo;
1407	struct snd_timer_id tid;
1408	struct snd_timer *t;
1409	struct list_head *p;
1410	int err = 0;
1411
1412	ginfo = memdup_user(_ginfo, sizeof(*ginfo));
1413	if (IS_ERR(ginfo))
1414		return PTR_ERR(ginfo);
1415
1416	tid = ginfo->tid;
1417	memset(ginfo, 0, sizeof(*ginfo));
1418	ginfo->tid = tid;
1419	mutex_lock(&register_mutex);
1420	t = snd_timer_find(&tid);
1421	if (t != NULL) {
1422		ginfo->card = t->card ? t->card->number : -1;
1423		if (t->hw.flags & SNDRV_TIMER_HW_SLAVE)
1424			ginfo->flags |= SNDRV_TIMER_FLG_SLAVE;
1425		strlcpy(ginfo->id, t->id, sizeof(ginfo->id));
1426		strlcpy(ginfo->name, t->name, sizeof(ginfo->name));
1427		ginfo->resolution = t->hw.resolution;
1428		if (t->hw.resolution_min > 0) {
1429			ginfo->resolution_min = t->hw.resolution_min;
1430			ginfo->resolution_max = t->hw.resolution_max;
1431		}
1432		list_for_each(p, &t->open_list_head) {
1433			ginfo->clients++;
1434		}
1435	} else {
1436		err = -ENODEV;
1437	}
1438	mutex_unlock(&register_mutex);
1439	if (err >= 0 && copy_to_user(_ginfo, ginfo, sizeof(*ginfo)))
1440		err = -EFAULT;
1441	kfree(ginfo);
1442	return err;
1443}
1444
1445static int snd_timer_user_gparams(struct file *file,
1446				  struct snd_timer_gparams __user *_gparams)
1447{
1448	struct snd_timer_gparams gparams;
1449	struct snd_timer *t;
1450	int err;
1451
1452	if (copy_from_user(&gparams, _gparams, sizeof(gparams)))
1453		return -EFAULT;
1454	mutex_lock(&register_mutex);
1455	t = snd_timer_find(&gparams.tid);
1456	if (!t) {
1457		err = -ENODEV;
1458		goto _error;
1459	}
1460	if (!list_empty(&t->open_list_head)) {
1461		err = -EBUSY;
1462		goto _error;
1463	}
1464	if (!t->hw.set_period) {
1465		err = -ENOSYS;
1466		goto _error;
1467	}
1468	err = t->hw.set_period(t, gparams.period_num, gparams.period_den);
1469_error:
1470	mutex_unlock(&register_mutex);
1471	return err;
1472}
1473
 
 
 
 
 
 
 
 
 
 
1474static int snd_timer_user_gstatus(struct file *file,
1475				  struct snd_timer_gstatus __user *_gstatus)
1476{
1477	struct snd_timer_gstatus gstatus;
1478	struct snd_timer_id tid;
1479	struct snd_timer *t;
1480	int err = 0;
1481
1482	if (copy_from_user(&gstatus, _gstatus, sizeof(gstatus)))
1483		return -EFAULT;
1484	tid = gstatus.tid;
1485	memset(&gstatus, 0, sizeof(gstatus));
1486	gstatus.tid = tid;
1487	mutex_lock(&register_mutex);
1488	t = snd_timer_find(&tid);
1489	if (t != NULL) {
1490		if (t->hw.c_resolution)
1491			gstatus.resolution = t->hw.c_resolution(t);
1492		else
1493			gstatus.resolution = t->hw.resolution;
1494		if (t->hw.precise_resolution) {
1495			t->hw.precise_resolution(t, &gstatus.resolution_num,
1496						 &gstatus.resolution_den);
1497		} else {
1498			gstatus.resolution_num = gstatus.resolution;
1499			gstatus.resolution_den = 1000000000uL;
1500		}
1501	} else {
1502		err = -ENODEV;
1503	}
1504	mutex_unlock(&register_mutex);
1505	if (err >= 0 && copy_to_user(_gstatus, &gstatus, sizeof(gstatus)))
1506		err = -EFAULT;
1507	return err;
1508}
1509
1510static int snd_timer_user_tselect(struct file *file,
1511				  struct snd_timer_select __user *_tselect)
1512{
1513	struct snd_timer_user *tu;
1514	struct snd_timer_select tselect;
1515	char str[32];
1516	int err = 0;
1517
1518	tu = file->private_data;
1519	mutex_lock(&tu->tread_sem);
1520	if (tu->timeri) {
1521		snd_timer_close(tu->timeri);
1522		tu->timeri = NULL;
1523	}
1524	if (copy_from_user(&tselect, _tselect, sizeof(tselect))) {
1525		err = -EFAULT;
1526		goto __err;
1527	}
1528	sprintf(str, "application %i", current->pid);
1529	if (tselect.id.dev_class != SNDRV_TIMER_CLASS_SLAVE)
1530		tselect.id.dev_sclass = SNDRV_TIMER_SCLASS_APPLICATION;
1531	err = snd_timer_open(&tu->timeri, str, &tselect.id, current->pid);
1532	if (err < 0)
1533		goto __err;
1534
1535	kfree(tu->queue);
1536	tu->queue = NULL;
1537	kfree(tu->tqueue);
1538	tu->tqueue = NULL;
1539	if (tu->tread) {
1540		tu->tqueue = kmalloc(tu->queue_size * sizeof(struct snd_timer_tread),
1541				     GFP_KERNEL);
1542		if (tu->tqueue == NULL)
1543			err = -ENOMEM;
1544	} else {
1545		tu->queue = kmalloc(tu->queue_size * sizeof(struct snd_timer_read),
1546				    GFP_KERNEL);
1547		if (tu->queue == NULL)
1548			err = -ENOMEM;
1549	}
1550
1551      	if (err < 0) {
1552		snd_timer_close(tu->timeri);
1553      		tu->timeri = NULL;
1554      	} else {
1555		tu->timeri->flags |= SNDRV_TIMER_IFLG_FAST;
1556		tu->timeri->callback = tu->tread
1557			? snd_timer_user_tinterrupt : snd_timer_user_interrupt;
1558		tu->timeri->ccallback = snd_timer_user_ccallback;
1559		tu->timeri->callback_data = (void *)tu;
 
1560	}
1561
1562      __err:
1563      	mutex_unlock(&tu->tread_sem);
1564	return err;
1565}
1566
1567static int snd_timer_user_info(struct file *file,
1568			       struct snd_timer_info __user *_info)
1569{
1570	struct snd_timer_user *tu;
1571	struct snd_timer_info *info;
1572	struct snd_timer *t;
1573	int err = 0;
1574
1575	tu = file->private_data;
1576	if (!tu->timeri)
1577		return -EBADFD;
1578	t = tu->timeri->timer;
1579	if (!t)
1580		return -EBADFD;
1581
1582	info = kzalloc(sizeof(*info), GFP_KERNEL);
1583	if (! info)
1584		return -ENOMEM;
1585	info->card = t->card ? t->card->number : -1;
1586	if (t->hw.flags & SNDRV_TIMER_HW_SLAVE)
1587		info->flags |= SNDRV_TIMER_FLG_SLAVE;
1588	strlcpy(info->id, t->id, sizeof(info->id));
1589	strlcpy(info->name, t->name, sizeof(info->name));
1590	info->resolution = t->hw.resolution;
1591	if (copy_to_user(_info, info, sizeof(*_info)))
1592		err = -EFAULT;
1593	kfree(info);
1594	return err;
1595}
1596
1597static int snd_timer_user_params(struct file *file,
1598				 struct snd_timer_params __user *_params)
1599{
1600	struct snd_timer_user *tu;
1601	struct snd_timer_params params;
1602	struct snd_timer *t;
1603	struct snd_timer_read *tr;
1604	struct snd_timer_tread *ttr;
1605	int err;
1606
1607	tu = file->private_data;
1608	if (!tu->timeri)
1609		return -EBADFD;
1610	t = tu->timeri->timer;
1611	if (!t)
1612		return -EBADFD;
1613	if (copy_from_user(&params, _params, sizeof(params)))
1614		return -EFAULT;
1615	if (!(t->hw.flags & SNDRV_TIMER_HW_SLAVE) && params.ticks < 1) {
1616		err = -EINVAL;
1617		goto _end;
1618	}
1619	if (params.queue_size > 0 &&
1620	    (params.queue_size < 32 || params.queue_size > 1024)) {
1621		err = -EINVAL;
1622		goto _end;
1623	}
1624	if (params.filter & ~((1<<SNDRV_TIMER_EVENT_RESOLUTION)|
1625			      (1<<SNDRV_TIMER_EVENT_TICK)|
1626			      (1<<SNDRV_TIMER_EVENT_START)|
1627			      (1<<SNDRV_TIMER_EVENT_STOP)|
1628			      (1<<SNDRV_TIMER_EVENT_CONTINUE)|
1629			      (1<<SNDRV_TIMER_EVENT_PAUSE)|
1630			      (1<<SNDRV_TIMER_EVENT_SUSPEND)|
1631			      (1<<SNDRV_TIMER_EVENT_RESUME)|
1632			      (1<<SNDRV_TIMER_EVENT_MSTART)|
1633			      (1<<SNDRV_TIMER_EVENT_MSTOP)|
1634			      (1<<SNDRV_TIMER_EVENT_MCONTINUE)|
1635			      (1<<SNDRV_TIMER_EVENT_MPAUSE)|
1636			      (1<<SNDRV_TIMER_EVENT_MSUSPEND)|
1637			      (1<<SNDRV_TIMER_EVENT_MRESUME))) {
1638		err = -EINVAL;
1639		goto _end;
1640	}
1641	snd_timer_stop(tu->timeri);
1642	spin_lock_irq(&t->lock);
1643	tu->timeri->flags &= ~(SNDRV_TIMER_IFLG_AUTO|
1644			       SNDRV_TIMER_IFLG_EXCLUSIVE|
1645			       SNDRV_TIMER_IFLG_EARLY_EVENT);
1646	if (params.flags & SNDRV_TIMER_PSFLG_AUTO)
1647		tu->timeri->flags |= SNDRV_TIMER_IFLG_AUTO;
1648	if (params.flags & SNDRV_TIMER_PSFLG_EXCLUSIVE)
1649		tu->timeri->flags |= SNDRV_TIMER_IFLG_EXCLUSIVE;
1650	if (params.flags & SNDRV_TIMER_PSFLG_EARLY_EVENT)
1651		tu->timeri->flags |= SNDRV_TIMER_IFLG_EARLY_EVENT;
1652	spin_unlock_irq(&t->lock);
1653	if (params.queue_size > 0 &&
1654	    (unsigned int)tu->queue_size != params.queue_size) {
1655		if (tu->tread) {
1656			ttr = kmalloc(params.queue_size * sizeof(*ttr),
1657				      GFP_KERNEL);
1658			if (ttr) {
1659				kfree(tu->tqueue);
1660				tu->queue_size = params.queue_size;
1661				tu->tqueue = ttr;
1662			}
1663		} else {
1664			tr = kmalloc(params.queue_size * sizeof(*tr),
1665				     GFP_KERNEL);
1666			if (tr) {
1667				kfree(tu->queue);
1668				tu->queue_size = params.queue_size;
1669				tu->queue = tr;
1670			}
1671		}
1672	}
1673	tu->qhead = tu->qtail = tu->qused = 0;
1674	if (tu->timeri->flags & SNDRV_TIMER_IFLG_EARLY_EVENT) {
1675		if (tu->tread) {
1676			struct snd_timer_tread tread;
1677			tread.event = SNDRV_TIMER_EVENT_EARLY;
1678			tread.tstamp.tv_sec = 0;
1679			tread.tstamp.tv_nsec = 0;
1680			tread.val = 0;
1681			snd_timer_user_append_to_tqueue(tu, &tread);
1682		} else {
1683			struct snd_timer_read *r = &tu->queue[0];
1684			r->resolution = 0;
1685			r->ticks = 0;
1686			tu->qused++;
1687			tu->qtail++;
1688		}
1689	}
1690	tu->filter = params.filter;
1691	tu->ticks = params.ticks;
1692	err = 0;
1693 _end:
1694	if (copy_to_user(_params, &params, sizeof(params)))
1695		return -EFAULT;
1696	return err;
1697}
1698
1699static int snd_timer_user_status(struct file *file,
1700				 struct snd_timer_status __user *_status)
1701{
1702	struct snd_timer_user *tu;
1703	struct snd_timer_status status;
1704
1705	tu = file->private_data;
1706	if (!tu->timeri)
1707		return -EBADFD;
1708	memset(&status, 0, sizeof(status));
1709	status.tstamp = tu->tstamp;
1710	status.resolution = snd_timer_resolution(tu->timeri);
1711	status.lost = tu->timeri->lost;
1712	status.overrun = tu->overrun;
1713	spin_lock_irq(&tu->qlock);
1714	status.queue = tu->qused;
1715	spin_unlock_irq(&tu->qlock);
1716	if (copy_to_user(_status, &status, sizeof(status)))
1717		return -EFAULT;
1718	return 0;
1719}
1720
1721static int snd_timer_user_start(struct file *file)
1722{
1723	int err;
1724	struct snd_timer_user *tu;
1725
1726	tu = file->private_data;
1727	if (!tu->timeri)
1728		return -EBADFD;
1729	snd_timer_stop(tu->timeri);
1730	tu->timeri->lost = 0;
1731	tu->last_resolution = 0;
1732	return (err = snd_timer_start(tu->timeri, tu->ticks)) < 0 ? err : 0;
1733}
1734
1735static int snd_timer_user_stop(struct file *file)
1736{
1737	int err;
1738	struct snd_timer_user *tu;
1739
1740	tu = file->private_data;
1741	if (!tu->timeri)
1742		return -EBADFD;
1743	return (err = snd_timer_stop(tu->timeri)) < 0 ? err : 0;
1744}
1745
1746static int snd_timer_user_continue(struct file *file)
1747{
1748	int err;
1749	struct snd_timer_user *tu;
1750
1751	tu = file->private_data;
1752	if (!tu->timeri)
1753		return -EBADFD;
1754	tu->timeri->lost = 0;
1755	return (err = snd_timer_continue(tu->timeri)) < 0 ? err : 0;
1756}
1757
1758static int snd_timer_user_pause(struct file *file)
1759{
1760	int err;
1761	struct snd_timer_user *tu;
1762
1763	tu = file->private_data;
1764	if (!tu->timeri)
1765		return -EBADFD;
1766	return (err = snd_timer_pause(tu->timeri)) < 0 ? err : 0;
1767}
1768
1769enum {
1770	SNDRV_TIMER_IOCTL_START_OLD = _IO('T', 0x20),
1771	SNDRV_TIMER_IOCTL_STOP_OLD = _IO('T', 0x21),
1772	SNDRV_TIMER_IOCTL_CONTINUE_OLD = _IO('T', 0x22),
1773	SNDRV_TIMER_IOCTL_PAUSE_OLD = _IO('T', 0x23),
1774};
1775
1776static long snd_timer_user_ioctl(struct file *file, unsigned int cmd,
1777				 unsigned long arg)
1778{
1779	struct snd_timer_user *tu;
1780	void __user *argp = (void __user *)arg;
1781	int __user *p = argp;
1782
1783	tu = file->private_data;
1784	switch (cmd) {
1785	case SNDRV_TIMER_IOCTL_PVERSION:
1786		return put_user(SNDRV_TIMER_VERSION, p) ? -EFAULT : 0;
1787	case SNDRV_TIMER_IOCTL_NEXT_DEVICE:
1788		return snd_timer_user_next_device(argp);
1789	case SNDRV_TIMER_IOCTL_TREAD:
1790	{
1791		int xarg;
1792
1793		mutex_lock(&tu->tread_sem);
1794		if (tu->timeri)	{	/* too late */
1795			mutex_unlock(&tu->tread_sem);
1796			return -EBUSY;
1797		}
1798		if (get_user(xarg, p)) {
1799			mutex_unlock(&tu->tread_sem);
1800			return -EFAULT;
1801		}
1802		tu->tread = xarg ? 1 : 0;
1803		mutex_unlock(&tu->tread_sem);
1804		return 0;
1805	}
1806	case SNDRV_TIMER_IOCTL_GINFO:
1807		return snd_timer_user_ginfo(file, argp);
1808	case SNDRV_TIMER_IOCTL_GPARAMS:
1809		return snd_timer_user_gparams(file, argp);
1810	case SNDRV_TIMER_IOCTL_GSTATUS:
1811		return snd_timer_user_gstatus(file, argp);
1812	case SNDRV_TIMER_IOCTL_SELECT:
1813		return snd_timer_user_tselect(file, argp);
1814	case SNDRV_TIMER_IOCTL_INFO:
1815		return snd_timer_user_info(file, argp);
1816	case SNDRV_TIMER_IOCTL_PARAMS:
1817		return snd_timer_user_params(file, argp);
1818	case SNDRV_TIMER_IOCTL_STATUS:
1819		return snd_timer_user_status(file, argp);
1820	case SNDRV_TIMER_IOCTL_START:
1821	case SNDRV_TIMER_IOCTL_START_OLD:
1822		return snd_timer_user_start(file);
1823	case SNDRV_TIMER_IOCTL_STOP:
1824	case SNDRV_TIMER_IOCTL_STOP_OLD:
1825		return snd_timer_user_stop(file);
1826	case SNDRV_TIMER_IOCTL_CONTINUE:
1827	case SNDRV_TIMER_IOCTL_CONTINUE_OLD:
1828		return snd_timer_user_continue(file);
1829	case SNDRV_TIMER_IOCTL_PAUSE:
1830	case SNDRV_TIMER_IOCTL_PAUSE_OLD:
1831		return snd_timer_user_pause(file);
1832	}
1833	return -ENOTTY;
1834}
1835
 
 
 
 
 
 
 
 
 
 
 
 
1836static int snd_timer_user_fasync(int fd, struct file * file, int on)
1837{
1838	struct snd_timer_user *tu;
1839
1840	tu = file->private_data;
1841	return fasync_helper(fd, file, on, &tu->fasync);
1842}
1843
1844static ssize_t snd_timer_user_read(struct file *file, char __user *buffer,
1845				   size_t count, loff_t *offset)
1846{
1847	struct snd_timer_user *tu;
1848	long result = 0, unit;
 
1849	int err = 0;
1850
1851	tu = file->private_data;
1852	unit = tu->tread ? sizeof(struct snd_timer_tread) : sizeof(struct snd_timer_read);
1853	spin_lock_irq(&tu->qlock);
1854	while ((long)count - result >= unit) {
1855		while (!tu->qused) {
1856			wait_queue_t wait;
1857
1858			if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) {
1859				err = -EAGAIN;
1860				break;
1861			}
1862
1863			set_current_state(TASK_INTERRUPTIBLE);
1864			init_waitqueue_entry(&wait, current);
1865			add_wait_queue(&tu->qchange_sleep, &wait);
1866
1867			spin_unlock_irq(&tu->qlock);
1868			schedule();
1869			spin_lock_irq(&tu->qlock);
1870
1871			remove_wait_queue(&tu->qchange_sleep, &wait);
1872
 
 
 
 
1873			if (signal_pending(current)) {
1874				err = -ERESTARTSYS;
1875				break;
1876			}
1877		}
1878
 
 
1879		spin_unlock_irq(&tu->qlock);
1880		if (err < 0)
1881			goto _error;
1882
1883		if (tu->tread) {
1884			if (copy_to_user(buffer, &tu->tqueue[tu->qhead++],
1885					 sizeof(struct snd_timer_tread))) {
1886				err = -EFAULT;
1887				goto _error;
1888			}
1889		} else {
1890			if (copy_to_user(buffer, &tu->queue[tu->qhead++],
1891					 sizeof(struct snd_timer_read))) {
1892				err = -EFAULT;
1893				goto _error;
1894			}
1895		}
1896
1897		tu->qhead %= tu->queue_size;
1898
1899		result += unit;
1900		buffer += unit;
1901
1902		spin_lock_irq(&tu->qlock);
1903		tu->qused--;
 
 
 
 
1904	}
1905	spin_unlock_irq(&tu->qlock);
1906 _error:
 
1907	return result > 0 ? result : err;
1908}
1909
1910static unsigned int snd_timer_user_poll(struct file *file, poll_table * wait)
1911{
1912        unsigned int mask;
1913        struct snd_timer_user *tu;
1914
1915        tu = file->private_data;
1916
1917        poll_wait(file, &tu->qchange_sleep, wait);
1918
1919	mask = 0;
1920	if (tu->qused)
1921		mask |= POLLIN | POLLRDNORM;
 
 
1922
1923	return mask;
1924}
1925
1926#ifdef CONFIG_COMPAT
1927#include "timer_compat.c"
1928#else
1929#define snd_timer_user_ioctl_compat	NULL
1930#endif
1931
1932static const struct file_operations snd_timer_f_ops =
1933{
1934	.owner =	THIS_MODULE,
1935	.read =		snd_timer_user_read,
1936	.open =		snd_timer_user_open,
1937	.release =	snd_timer_user_release,
1938	.llseek =	no_llseek,
1939	.poll =		snd_timer_user_poll,
1940	.unlocked_ioctl =	snd_timer_user_ioctl,
1941	.compat_ioctl =	snd_timer_user_ioctl_compat,
1942	.fasync = 	snd_timer_user_fasync,
1943};
1944
 
 
 
 
 
 
 
 
 
 
 
1945/*
1946 *  ENTRY functions
1947 */
1948
1949static int __init alsa_timer_init(void)
1950{
1951	int err;
1952
 
 
 
1953#ifdef SNDRV_OSS_INFO_DEV_TIMERS
1954	snd_oss_info_register(SNDRV_OSS_INFO_DEV_TIMERS, SNDRV_CARDS - 1,
1955			      "system timer");
1956#endif
1957
1958	if ((err = snd_timer_register_system()) < 0)
 
1959		pr_err("ALSA: unable to register system timer (%i)\n", err);
1960	if ((err = snd_register_device(SNDRV_DEVICE_TYPE_TIMER, NULL, 0,
1961				       &snd_timer_f_ops, NULL, "timer")) < 0)
 
 
 
 
 
1962		pr_err("ALSA: unable to register timer device (%i)\n", err);
 
 
 
 
 
1963	snd_timer_proc_init();
1964	return 0;
1965}
1966
1967static void __exit alsa_timer_exit(void)
1968{
1969	struct list_head *p, *n;
1970
1971	snd_unregister_device(SNDRV_DEVICE_TYPE_TIMER, NULL, 0);
1972	/* unregister the system timer */
1973	list_for_each_safe(p, n, &snd_timer_list) {
1974		struct snd_timer *timer = list_entry(p, struct snd_timer, device_list);
1975		snd_timer_free(timer);
1976	}
1977	snd_timer_proc_done();
1978#ifdef SNDRV_OSS_INFO_DEV_TIMERS
1979	snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_TIMERS, SNDRV_CARDS - 1);
1980#endif
1981}
1982
1983module_init(alsa_timer_init)
1984module_exit(alsa_timer_exit)
1985
1986EXPORT_SYMBOL(snd_timer_open);
1987EXPORT_SYMBOL(snd_timer_close);
1988EXPORT_SYMBOL(snd_timer_resolution);
1989EXPORT_SYMBOL(snd_timer_start);
1990EXPORT_SYMBOL(snd_timer_stop);
1991EXPORT_SYMBOL(snd_timer_continue);
1992EXPORT_SYMBOL(snd_timer_pause);
1993EXPORT_SYMBOL(snd_timer_new);
1994EXPORT_SYMBOL(snd_timer_notify);
1995EXPORT_SYMBOL(snd_timer_global_new);
1996EXPORT_SYMBOL(snd_timer_global_free);
1997EXPORT_SYMBOL(snd_timer_global_register);
1998EXPORT_SYMBOL(snd_timer_interrupt);