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