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