Linux Audio

Check our new training course

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