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