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