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