timer.c

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