2509 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * Timers abstract layer4 * 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 0x0001000028#define SNDRV_TIMER_IFLG_DEAD 0x0002000029 30#if IS_ENABLED(CONFIG_SND_HRTIMER)31#define DEFAULT_TIMER_LIMIT 432#else33#define DEFAULT_TIMER_LIMIT 134#endif35 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_UTIMER115#define SNDRV_UTIMERS_MAX_COUNT 128116/* 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#endif123 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 1000136static 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 id185 */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_MODULES208 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#endif227 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 instance297 * 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(®ister_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_MODULES333 if (!timer) {334 mutex_unlock(®ister_mutex);335 snd_timer_request(tid);336 mutex_lock(®ister_mutex);337 timer = snd_timer_find(tid);338 }339#endif340 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(®ister_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 instance416 * 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 instance467 */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, ®ister_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 else488 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 else517 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 else650 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 instance677 */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 else685 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 else699 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 else715 return snd_timer_start1(timeri, false, 0);716}717EXPORT_SYMBOL(snd_timer_continue);718 719/*720 * pause.. remember the ticks left721 */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 else727 return snd_timer_stop1(timeri, false);728}729EXPORT_SYMBOL(snd_timer_pause);730 731/*732 * reschedule the timer733 *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 work803 *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 interrupt820 *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 instances844 * Here we cannot use list_for_each_entry because the active_list of a845 * processed instance is relinked to done_list_head before the callback846 * 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 else859 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 else873 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)(®ister_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)(®ister_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)(®ister_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 timers1077 */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 timer1109 */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 = from_timer(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 del_timer(&priv->tlist);1156 jiff = jiffies;1157 if (time_before(jiff, priv->last_expires))1158 timer->sticks = priv->last_expires - jiff;1159 else1160 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 del_timer_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_stop1182};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 strcpy(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_FS1213/*1214 * Info interface1215 */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)(®ister_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#endif1290 1291/*1292 * USER SPACE interface1293 */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 else1389 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 int snd_timer_user_next_device(struct snd_timer_id __user *_tid)1519{1520 struct snd_timer_id id;1521 struct snd_timer *timer;1522 struct list_head *p;1523 1524 if (copy_from_user(&id, _tid, sizeof(id)))1525 return -EFAULT;1526 guard(mutex)(®ister_mutex);1527 if (id.dev_class < 0) { /* first item */1528 if (list_empty(&snd_timer_list))1529 snd_timer_user_zero_id(&id);1530 else {1531 timer = list_entry(snd_timer_list.next,1532 struct snd_timer, device_list);1533 snd_timer_user_copy_id(&id, timer);1534 }1535 } else {1536 switch (id.dev_class) {1537 case SNDRV_TIMER_CLASS_GLOBAL:1538 id.device = id.device < 0 ? 0 : id.device + 1;1539 list_for_each(p, &snd_timer_list) {1540 timer = list_entry(p, struct snd_timer, device_list);1541 if (timer->tmr_class > SNDRV_TIMER_CLASS_GLOBAL) {1542 snd_timer_user_copy_id(&id, timer);1543 break;1544 }1545 if (timer->tmr_device >= id.device) {1546 snd_timer_user_copy_id(&id, timer);1547 break;1548 }1549 }1550 if (p == &snd_timer_list)1551 snd_timer_user_zero_id(&id);1552 break;1553 case SNDRV_TIMER_CLASS_CARD:1554 case SNDRV_TIMER_CLASS_PCM:1555 if (id.card < 0) {1556 id.card = 0;1557 } else {1558 if (id.device < 0) {1559 id.device = 0;1560 } else {1561 if (id.subdevice < 0)1562 id.subdevice = 0;1563 else if (id.subdevice < INT_MAX)1564 id.subdevice++;1565 }1566 }1567 list_for_each(p, &snd_timer_list) {1568 timer = list_entry(p, struct snd_timer, device_list);1569 if (timer->tmr_class > id.dev_class) {1570 snd_timer_user_copy_id(&id, timer);1571 break;1572 }1573 if (timer->tmr_class < id.dev_class)1574 continue;1575 if (timer->card->number > id.card) {1576 snd_timer_user_copy_id(&id, timer);1577 break;1578 }1579 if (timer->card->number < id.card)1580 continue;1581 if (timer->tmr_device > id.device) {1582 snd_timer_user_copy_id(&id, timer);1583 break;1584 }1585 if (timer->tmr_device < id.device)1586 continue;1587 if (timer->tmr_subdevice > id.subdevice) {1588 snd_timer_user_copy_id(&id, timer);1589 break;1590 }1591 if (timer->tmr_subdevice < id.subdevice)1592 continue;1593 snd_timer_user_copy_id(&id, timer);1594 break;1595 }1596 if (p == &snd_timer_list)1597 snd_timer_user_zero_id(&id);1598 break;1599 default:1600 snd_timer_user_zero_id(&id);1601 }1602 }1603 if (copy_to_user(_tid, &id, sizeof(*_tid)))1604 return -EFAULT;1605 return 0;1606}1607 1608static int snd_timer_user_ginfo(struct file *file,1609 struct snd_timer_ginfo __user *_ginfo)1610{1611 struct snd_timer_ginfo *ginfo __free(kfree) = NULL;1612 struct snd_timer_id tid;1613 struct snd_timer *t;1614 struct list_head *p;1615 1616 ginfo = memdup_user(_ginfo, sizeof(*ginfo));1617 if (IS_ERR(ginfo))1618 return PTR_ERR(ginfo);1619 1620 tid = ginfo->tid;1621 memset(ginfo, 0, sizeof(*ginfo));1622 ginfo->tid = tid;1623 guard(mutex)(®ister_mutex);1624 t = snd_timer_find(&tid);1625 if (!t)1626 return -ENODEV;1627 ginfo->card = t->card ? t->card->number : -1;1628 if (t->hw.flags & SNDRV_TIMER_HW_SLAVE)1629 ginfo->flags |= SNDRV_TIMER_FLG_SLAVE;1630 strscpy(ginfo->id, t->id, sizeof(ginfo->id));1631 strscpy(ginfo->name, t->name, sizeof(ginfo->name));1632 scoped_guard(spinlock_irq, &t->lock)1633 ginfo->resolution = snd_timer_hw_resolution(t);1634 if (t->hw.resolution_min > 0) {1635 ginfo->resolution_min = t->hw.resolution_min;1636 ginfo->resolution_max = t->hw.resolution_max;1637 }1638 list_for_each(p, &t->open_list_head) {1639 ginfo->clients++;1640 }1641 if (copy_to_user(_ginfo, ginfo, sizeof(*ginfo)))1642 return -EFAULT;1643 return 0;1644}1645 1646static int timer_set_gparams(struct snd_timer_gparams *gparams)1647{1648 struct snd_timer *t;1649 1650 guard(mutex)(®ister_mutex);1651 t = snd_timer_find(&gparams->tid);1652 if (!t)1653 return -ENODEV;1654 if (!list_empty(&t->open_list_head))1655 return -EBUSY;1656 if (!t->hw.set_period)1657 return -ENOSYS;1658 return t->hw.set_period(t, gparams->period_num, gparams->period_den);1659}1660 1661static int snd_timer_user_gparams(struct file *file,1662 struct snd_timer_gparams __user *_gparams)1663{1664 struct snd_timer_gparams gparams;1665 1666 if (copy_from_user(&gparams, _gparams, sizeof(gparams)))1667 return -EFAULT;1668 return timer_set_gparams(&gparams);1669}1670 1671static int snd_timer_user_gstatus(struct file *file,1672 struct snd_timer_gstatus __user *_gstatus)1673{1674 struct snd_timer_gstatus gstatus;1675 struct snd_timer_id tid;1676 struct snd_timer *t;1677 int err = 0;1678 1679 if (copy_from_user(&gstatus, _gstatus, sizeof(gstatus)))1680 return -EFAULT;1681 tid = gstatus.tid;1682 memset(&gstatus, 0, sizeof(gstatus));1683 gstatus.tid = tid;1684 guard(mutex)(®ister_mutex);1685 t = snd_timer_find(&tid);1686 if (t != NULL) {1687 guard(spinlock_irq)(&t->lock);1688 gstatus.resolution = snd_timer_hw_resolution(t);1689 if (t->hw.precise_resolution) {1690 t->hw.precise_resolution(t, &gstatus.resolution_num,1691 &gstatus.resolution_den);1692 } else {1693 gstatus.resolution_num = gstatus.resolution;1694 gstatus.resolution_den = 1000000000uL;1695 }1696 } else {1697 err = -ENODEV;1698 }1699 if (err >= 0 && copy_to_user(_gstatus, &gstatus, sizeof(gstatus)))1700 err = -EFAULT;1701 return err;1702}1703 1704static int snd_timer_user_tselect(struct file *file,1705 struct snd_timer_select __user *_tselect)1706{1707 struct snd_timer_user *tu;1708 struct snd_timer_select tselect;1709 char str[32];1710 int err = 0;1711 1712 tu = file->private_data;1713 if (tu->timeri) {1714 snd_timer_close(tu->timeri);1715 snd_timer_instance_free(tu->timeri);1716 tu->timeri = NULL;1717 }1718 if (copy_from_user(&tselect, _tselect, sizeof(tselect))) {1719 err = -EFAULT;1720 goto __err;1721 }1722 sprintf(str, "application %i", current->pid);1723 if (tselect.id.dev_class != SNDRV_TIMER_CLASS_SLAVE)1724 tselect.id.dev_sclass = SNDRV_TIMER_SCLASS_APPLICATION;1725 tu->timeri = snd_timer_instance_new(str);1726 if (!tu->timeri) {1727 err = -ENOMEM;1728 goto __err;1729 }1730 1731 tu->timeri->flags |= SNDRV_TIMER_IFLG_FAST;1732 tu->timeri->callback = tu->tread1733 ? snd_timer_user_tinterrupt : snd_timer_user_interrupt;1734 tu->timeri->ccallback = snd_timer_user_ccallback;1735 tu->timeri->callback_data = (void *)tu;1736 tu->timeri->disconnect = snd_timer_user_disconnect;1737 1738 err = snd_timer_open(tu->timeri, &tselect.id, current->pid);1739 if (err < 0) {1740 snd_timer_instance_free(tu->timeri);1741 tu->timeri = NULL;1742 }1743 1744 __err:1745 return err;1746}1747 1748static int snd_timer_user_info(struct file *file,1749 struct snd_timer_info __user *_info)1750{1751 struct snd_timer_user *tu;1752 struct snd_timer_info *info __free(kfree) = NULL;1753 struct snd_timer *t;1754 1755 tu = file->private_data;1756 if (!tu->timeri)1757 return -EBADFD;1758 t = tu->timeri->timer;1759 if (!t)1760 return -EBADFD;1761 1762 info = kzalloc(sizeof(*info), GFP_KERNEL);1763 if (! info)1764 return -ENOMEM;1765 info->card = t->card ? t->card->number : -1;1766 if (t->hw.flags & SNDRV_TIMER_HW_SLAVE)1767 info->flags |= SNDRV_TIMER_FLG_SLAVE;1768 strscpy(info->id, t->id, sizeof(info->id));1769 strscpy(info->name, t->name, sizeof(info->name));1770 scoped_guard(spinlock_irq, &t->lock)1771 info->resolution = snd_timer_hw_resolution(t);1772 if (copy_to_user(_info, info, sizeof(*_info)))1773 return -EFAULT;1774 return 0;1775}1776 1777static int snd_timer_user_params(struct file *file,1778 struct snd_timer_params __user *_params)1779{1780 struct snd_timer_user *tu;1781 struct snd_timer_params params;1782 struct snd_timer *t;1783 int err;1784 1785 tu = file->private_data;1786 if (!tu->timeri)1787 return -EBADFD;1788 t = tu->timeri->timer;1789 if (!t)1790 return -EBADFD;1791 if (copy_from_user(¶ms, _params, sizeof(params)))1792 return -EFAULT;1793 if (!(t->hw.flags & SNDRV_TIMER_HW_SLAVE)) {1794 u64 resolution;1795 1796 if (params.ticks < 1) {1797 err = -EINVAL;1798 goto _end;1799 }1800 1801 /* Don't allow resolution less than 1ms */1802 resolution = snd_timer_resolution(tu->timeri);1803 resolution *= params.ticks;1804 if (resolution < 1000000) {1805 err = -EINVAL;1806 goto _end;1807 }1808 }1809 if (params.queue_size > 0 &&1810 (params.queue_size < 32 || params.queue_size > 1024)) {1811 err = -EINVAL;1812 goto _end;1813 }1814 if (params.filter & ~((1<<SNDRV_TIMER_EVENT_RESOLUTION)|1815 (1<<SNDRV_TIMER_EVENT_TICK)|1816 (1<<SNDRV_TIMER_EVENT_START)|1817 (1<<SNDRV_TIMER_EVENT_STOP)|1818 (1<<SNDRV_TIMER_EVENT_CONTINUE)|1819 (1<<SNDRV_TIMER_EVENT_PAUSE)|1820 (1<<SNDRV_TIMER_EVENT_SUSPEND)|1821 (1<<SNDRV_TIMER_EVENT_RESUME)|1822 (1<<SNDRV_TIMER_EVENT_MSTART)|1823 (1<<SNDRV_TIMER_EVENT_MSTOP)|1824 (1<<SNDRV_TIMER_EVENT_MCONTINUE)|1825 (1<<SNDRV_TIMER_EVENT_MPAUSE)|1826 (1<<SNDRV_TIMER_EVENT_MSUSPEND)|1827 (1<<SNDRV_TIMER_EVENT_MRESUME))) {1828 err = -EINVAL;1829 goto _end;1830 }1831 snd_timer_stop(tu->timeri);1832 scoped_guard(spinlock_irq, &t->lock) {1833 tu->timeri->flags &= ~(SNDRV_TIMER_IFLG_AUTO|1834 SNDRV_TIMER_IFLG_EXCLUSIVE|1835 SNDRV_TIMER_IFLG_EARLY_EVENT);1836 if (params.flags & SNDRV_TIMER_PSFLG_AUTO)1837 tu->timeri->flags |= SNDRV_TIMER_IFLG_AUTO;1838 if (params.flags & SNDRV_TIMER_PSFLG_EXCLUSIVE)1839 tu->timeri->flags |= SNDRV_TIMER_IFLG_EXCLUSIVE;1840 if (params.flags & SNDRV_TIMER_PSFLG_EARLY_EVENT)1841 tu->timeri->flags |= SNDRV_TIMER_IFLG_EARLY_EVENT;1842 }1843 if (params.queue_size > 0 &&1844 (unsigned int)tu->queue_size != params.queue_size) {1845 err = realloc_user_queue(tu, params.queue_size);1846 if (err < 0)1847 goto _end;1848 }1849 scoped_guard(spinlock_irq, &tu->qlock) {1850 tu->qhead = tu->qtail = tu->qused = 0;1851 if (tu->timeri->flags & SNDRV_TIMER_IFLG_EARLY_EVENT) {1852 if (tu->tread) {1853 struct snd_timer_tread64 tread;1854 1855 memset(&tread, 0, sizeof(tread));1856 tread.event = SNDRV_TIMER_EVENT_EARLY;1857 tread.tstamp_sec = 0;1858 tread.tstamp_nsec = 0;1859 tread.val = 0;1860 snd_timer_user_append_to_tqueue(tu, &tread);1861 } else {1862 struct snd_timer_read *r = &tu->queue[0];1863 1864 r->resolution = 0;1865 r->ticks = 0;1866 tu->qused++;1867 tu->qtail++;1868 }1869 }1870 tu->filter = params.filter;1871 tu->ticks = params.ticks;1872 }1873 err = 0;1874 _end:1875 if (copy_to_user(_params, ¶ms, sizeof(params)))1876 return -EFAULT;1877 return err;1878}1879 1880static int snd_timer_user_status32(struct file *file,1881 struct snd_timer_status32 __user *_status)1882 {1883 struct snd_timer_user *tu;1884 struct snd_timer_status32 status;1885 1886 tu = file->private_data;1887 if (!tu->timeri)1888 return -EBADFD;1889 memset(&status, 0, sizeof(status));1890 status.tstamp_sec = tu->tstamp.tv_sec;1891 status.tstamp_nsec = tu->tstamp.tv_nsec;1892 status.resolution = snd_timer_resolution(tu->timeri);1893 status.lost = tu->timeri->lost;1894 status.overrun = tu->overrun;1895 scoped_guard(spinlock_irq, &tu->qlock)1896 status.queue = tu->qused;1897 if (copy_to_user(_status, &status, sizeof(status)))1898 return -EFAULT;1899 return 0;1900}1901 1902static int snd_timer_user_status64(struct file *file,1903 struct snd_timer_status64 __user *_status)1904{1905 struct snd_timer_user *tu;1906 struct snd_timer_status64 status;1907 1908 tu = file->private_data;1909 if (!tu->timeri)1910 return -EBADFD;1911 memset(&status, 0, sizeof(status));1912 status.tstamp_sec = tu->tstamp.tv_sec;1913 status.tstamp_nsec = tu->tstamp.tv_nsec;1914 status.resolution = snd_timer_resolution(tu->timeri);1915 status.lost = tu->timeri->lost;1916 status.overrun = tu->overrun;1917 scoped_guard(spinlock_irq, &tu->qlock)1918 status.queue = tu->qused;1919 if (copy_to_user(_status, &status, sizeof(status)))1920 return -EFAULT;1921 return 0;1922}1923 1924static int snd_timer_user_start(struct file *file)1925{1926 int err;1927 struct snd_timer_user *tu;1928 1929 tu = file->private_data;1930 if (!tu->timeri)1931 return -EBADFD;1932 snd_timer_stop(tu->timeri);1933 tu->timeri->lost = 0;1934 tu->last_resolution = 0;1935 err = snd_timer_start(tu->timeri, tu->ticks);1936 if (err < 0)1937 return err;1938 return 0;1939}1940 1941static int snd_timer_user_stop(struct file *file)1942{1943 int err;1944 struct snd_timer_user *tu;1945 1946 tu = file->private_data;1947 if (!tu->timeri)1948 return -EBADFD;1949 err = snd_timer_stop(tu->timeri);1950 if (err < 0)1951 return err;1952 return 0;1953}1954 1955static int snd_timer_user_continue(struct file *file)1956{1957 int err;1958 struct snd_timer_user *tu;1959 1960 tu = file->private_data;1961 if (!tu->timeri)1962 return -EBADFD;1963 /* start timer instead of continue if it's not used before */1964 if (!(tu->timeri->flags & SNDRV_TIMER_IFLG_PAUSED))1965 return snd_timer_user_start(file);1966 tu->timeri->lost = 0;1967 err = snd_timer_continue(tu->timeri);1968 if (err < 0)1969 return err;1970 return 0;1971}1972 1973static int snd_timer_user_pause(struct file *file)1974{1975 int err;1976 struct snd_timer_user *tu;1977 1978 tu = file->private_data;1979 if (!tu->timeri)1980 return -EBADFD;1981 err = snd_timer_pause(tu->timeri);1982 if (err < 0)1983 return err;1984 return 0;1985}1986 1987static int snd_timer_user_tread(void __user *argp, struct snd_timer_user *tu,1988 unsigned int cmd, bool compat)1989{1990 int __user *p = argp;1991 int xarg, old_tread;1992 1993 if (tu->timeri) /* too late */1994 return -EBUSY;1995 if (get_user(xarg, p))1996 return -EFAULT;1997 1998 old_tread = tu->tread;1999 2000 if (!xarg)2001 tu->tread = TREAD_FORMAT_NONE;2002 else if (cmd == SNDRV_TIMER_IOCTL_TREAD64 ||2003 (IS_ENABLED(CONFIG_64BIT) && !compat))2004 tu->tread = TREAD_FORMAT_TIME64;2005 else2006 tu->tread = TREAD_FORMAT_TIME32;2007 2008 if (tu->tread != old_tread &&2009 realloc_user_queue(tu, tu->queue_size) < 0) {2010 tu->tread = old_tread;2011 return -ENOMEM;2012 }2013 2014 return 0;2015}2016 2017enum {2018 SNDRV_TIMER_IOCTL_START_OLD = _IO('T', 0x20),2019 SNDRV_TIMER_IOCTL_STOP_OLD = _IO('T', 0x21),2020 SNDRV_TIMER_IOCTL_CONTINUE_OLD = _IO('T', 0x22),2021 SNDRV_TIMER_IOCTL_PAUSE_OLD = _IO('T', 0x23),2022};2023 2024#ifdef CONFIG_SND_UTIMER2025/*2026 * Since userspace-driven timers are passed to userspace, we need to have an identifier2027 * which will allow us to use them (basically, the subdevice number of udriven timer).2028 */2029static DEFINE_IDA(snd_utimer_ids);2030 2031static void snd_utimer_put_id(struct snd_utimer *utimer)2032{2033 int timer_id = utimer->id;2034 2035 snd_BUG_ON(timer_id < 0 || timer_id >= SNDRV_UTIMERS_MAX_COUNT);2036 ida_free(&snd_utimer_ids, timer_id);2037}2038 2039static int snd_utimer_take_id(void)2040{2041 return ida_alloc_max(&snd_utimer_ids, SNDRV_UTIMERS_MAX_COUNT - 1, GFP_KERNEL);2042}2043 2044static void snd_utimer_free(struct snd_utimer *utimer)2045{2046 snd_timer_free(utimer->timer);2047 snd_utimer_put_id(utimer);2048 kfree(utimer->name);2049 kfree(utimer);2050}2051 2052static int snd_utimer_release(struct inode *inode, struct file *file)2053{2054 struct snd_utimer *utimer = (struct snd_utimer *)file->private_data;2055 2056 snd_utimer_free(utimer);2057 return 0;2058}2059 2060static int snd_utimer_trigger(struct file *file)2061{2062 struct snd_utimer *utimer = (struct snd_utimer *)file->private_data;2063 2064 snd_timer_interrupt(utimer->timer, utimer->timer->sticks);2065 return 0;2066}2067 2068static long snd_utimer_ioctl(struct file *file, unsigned int ioctl, unsigned long arg)2069{2070 switch (ioctl) {2071 case SNDRV_TIMER_IOCTL_TRIGGER:2072 return snd_utimer_trigger(file);2073 }2074 2075 return -ENOTTY;2076}2077 2078static const struct file_operations snd_utimer_fops = {2079 .llseek = noop_llseek,2080 .release = snd_utimer_release,2081 .unlocked_ioctl = snd_utimer_ioctl,2082};2083 2084static int snd_utimer_start(struct snd_timer *t)2085{2086 return 0;2087}2088 2089static int snd_utimer_stop(struct snd_timer *t)2090{2091 return 0;2092}2093 2094static int snd_utimer_open(struct snd_timer *t)2095{2096 return 0;2097}2098 2099static int snd_utimer_close(struct snd_timer *t)2100{2101 return 0;2102}2103 2104static const struct snd_timer_hardware timer_hw = {2105 .flags = SNDRV_TIMER_HW_AUTO | SNDRV_TIMER_HW_WORK,2106 .open = snd_utimer_open,2107 .close = snd_utimer_close,2108 .start = snd_utimer_start,2109 .stop = snd_utimer_stop,2110};2111 2112static int snd_utimer_create(struct snd_timer_uinfo *utimer_info,2113 struct snd_utimer **r_utimer)2114{2115 struct snd_utimer *utimer;2116 struct snd_timer *timer;2117 struct snd_timer_id tid;2118 int utimer_id;2119 int err = 0;2120 2121 if (!utimer_info || utimer_info->resolution == 0)2122 return -EINVAL;2123 2124 utimer = kzalloc(sizeof(*utimer), GFP_KERNEL);2125 if (!utimer)2126 return -ENOMEM;2127 2128 /* We hold the ioctl lock here so we won't get a race condition when allocating id */2129 utimer_id = snd_utimer_take_id();2130 if (utimer_id < 0) {2131 err = utimer_id;2132 goto err_take_id;2133 }2134 2135 utimer->name = kasprintf(GFP_KERNEL, "snd-utimer%d", utimer_id);2136 if (!utimer->name) {2137 err = -ENOMEM;2138 goto err_get_name;2139 }2140 2141 utimer->id = utimer_id;2142 2143 tid.dev_sclass = SNDRV_TIMER_SCLASS_APPLICATION;2144 tid.dev_class = SNDRV_TIMER_CLASS_GLOBAL;2145 tid.card = -1;2146 tid.device = SNDRV_TIMER_GLOBAL_UDRIVEN;2147 tid.subdevice = utimer_id;2148 2149 err = snd_timer_new(NULL, utimer->name, &tid, &timer);2150 if (err < 0) {2151 pr_err("Can't create userspace-driven timer\n");2152 goto err_timer_new;2153 }2154 2155 timer->module = THIS_MODULE;2156 timer->hw = timer_hw;2157 timer->hw.resolution = utimer_info->resolution;2158 timer->hw.ticks = 1;2159 timer->max_instances = MAX_SLAVE_INSTANCES;2160 2161 utimer->timer = timer;2162 2163 err = snd_timer_global_register(timer);2164 if (err < 0) {2165 pr_err("Can't register a userspace-driven timer\n");2166 goto err_timer_reg;2167 }2168 2169 *r_utimer = utimer;2170 return 0;2171 2172err_timer_reg:2173 snd_timer_free(timer);2174err_timer_new:2175 kfree(utimer->name);2176err_get_name:2177 snd_utimer_put_id(utimer);2178err_take_id:2179 kfree(utimer);2180 2181 return err;2182}2183 2184static int snd_utimer_ioctl_create(struct file *file,2185 struct snd_timer_uinfo __user *_utimer_info)2186{2187 struct snd_utimer *utimer;2188 struct snd_timer_uinfo *utimer_info __free(kfree) = NULL;2189 int err, timer_fd;2190 2191 utimer_info = memdup_user(_utimer_info, sizeof(*utimer_info));2192 if (IS_ERR(utimer_info))2193 return PTR_ERR(utimer_info);2194 2195 err = snd_utimer_create(utimer_info, &utimer);2196 if (err < 0)2197 return err;2198 2199 utimer_info->id = utimer->id;2200 2201 timer_fd = anon_inode_getfd(utimer->name, &snd_utimer_fops, utimer, O_RDWR | O_CLOEXEC);2202 if (timer_fd < 0) {2203 snd_utimer_free(utimer);2204 return timer_fd;2205 }2206 2207 utimer_info->fd = timer_fd;2208 2209 err = copy_to_user(_utimer_info, utimer_info, sizeof(*utimer_info));2210 if (err) {2211 /*2212 * "Leak" the fd, as there is nothing we can do about it.2213 * It might have been closed already since anon_inode_getfd2214 * makes it available for userspace.2215 *2216 * We have to rely on the process exit path to do any2217 * necessary cleanup (e.g. releasing the file).2218 */2219 return -EFAULT;2220 }2221 2222 return 0;2223}2224 2225#else2226 2227static int snd_utimer_ioctl_create(struct file *file,2228 struct snd_timer_uinfo __user *_utimer_info)2229{2230 return -ENOTTY;2231}2232 2233#endif2234 2235static long __snd_timer_user_ioctl(struct file *file, unsigned int cmd,2236 unsigned long arg, bool compat)2237{2238 struct snd_timer_user *tu;2239 void __user *argp = (void __user *)arg;2240 int __user *p = argp;2241 2242 tu = file->private_data;2243 switch (cmd) {2244 case SNDRV_TIMER_IOCTL_PVERSION:2245 return put_user(SNDRV_TIMER_VERSION, p) ? -EFAULT : 0;2246 case SNDRV_TIMER_IOCTL_NEXT_DEVICE:2247 return snd_timer_user_next_device(argp);2248 case SNDRV_TIMER_IOCTL_TREAD_OLD:2249 case SNDRV_TIMER_IOCTL_TREAD64:2250 return snd_timer_user_tread(argp, tu, cmd, compat);2251 case SNDRV_TIMER_IOCTL_GINFO:2252 return snd_timer_user_ginfo(file, argp);2253 case SNDRV_TIMER_IOCTL_GPARAMS:2254 return snd_timer_user_gparams(file, argp);2255 case SNDRV_TIMER_IOCTL_GSTATUS:2256 return snd_timer_user_gstatus(file, argp);2257 case SNDRV_TIMER_IOCTL_SELECT:2258 return snd_timer_user_tselect(file, argp);2259 case SNDRV_TIMER_IOCTL_INFO:2260 return snd_timer_user_info(file, argp);2261 case SNDRV_TIMER_IOCTL_PARAMS:2262 return snd_timer_user_params(file, argp);2263 case SNDRV_TIMER_IOCTL_STATUS32:2264 return snd_timer_user_status32(file, argp);2265 case SNDRV_TIMER_IOCTL_STATUS64:2266 return snd_timer_user_status64(file, argp);2267 case SNDRV_TIMER_IOCTL_START:2268 case SNDRV_TIMER_IOCTL_START_OLD:2269 return snd_timer_user_start(file);2270 case SNDRV_TIMER_IOCTL_STOP:2271 case SNDRV_TIMER_IOCTL_STOP_OLD:2272 return snd_timer_user_stop(file);2273 case SNDRV_TIMER_IOCTL_CONTINUE:2274 case SNDRV_TIMER_IOCTL_CONTINUE_OLD:2275 return snd_timer_user_continue(file);2276 case SNDRV_TIMER_IOCTL_PAUSE:2277 case SNDRV_TIMER_IOCTL_PAUSE_OLD:2278 return snd_timer_user_pause(file);2279 case SNDRV_TIMER_IOCTL_CREATE:2280 return snd_utimer_ioctl_create(file, argp);2281 }2282 return -ENOTTY;2283}2284 2285static long snd_timer_user_ioctl(struct file *file, unsigned int cmd,2286 unsigned long arg)2287{2288 struct snd_timer_user *tu = file->private_data;2289 2290 guard(mutex)(&tu->ioctl_lock);2291 return __snd_timer_user_ioctl(file, cmd, arg, false);2292}2293 2294static int snd_timer_user_fasync(int fd, struct file * file, int on)2295{2296 struct snd_timer_user *tu;2297 2298 tu = file->private_data;2299 return snd_fasync_helper(fd, file, on, &tu->fasync);2300}2301 2302static ssize_t snd_timer_user_read(struct file *file, char __user *buffer,2303 size_t count, loff_t *offset)2304{2305 struct snd_timer_tread64 *tread;2306 struct snd_timer_tread32 tread32;2307 struct snd_timer_user *tu;2308 long result = 0, unit;2309 int qhead;2310 int err = 0;2311 2312 tu = file->private_data;2313 switch (tu->tread) {2314 case TREAD_FORMAT_TIME64:2315 unit = sizeof(struct snd_timer_tread64);2316 break;2317 case TREAD_FORMAT_TIME32:2318 unit = sizeof(struct snd_timer_tread32);2319 break;2320 case TREAD_FORMAT_NONE:2321 unit = sizeof(struct snd_timer_read);2322 break;2323 default:2324 WARN_ONCE(1, "Corrupt snd_timer_user\n");2325 return -ENOTSUPP;2326 }2327 2328 mutex_lock(&tu->ioctl_lock);2329 spin_lock_irq(&tu->qlock);2330 while ((long)count - result >= unit) {2331 while (!tu->qused) {2332 wait_queue_entry_t wait;2333 2334 if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) {2335 err = -EAGAIN;2336 goto _error;2337 }2338 2339 set_current_state(TASK_INTERRUPTIBLE);2340 init_waitqueue_entry(&wait, current);2341 add_wait_queue(&tu->qchange_sleep, &wait);2342 2343 spin_unlock_irq(&tu->qlock);2344 mutex_unlock(&tu->ioctl_lock);2345 schedule();2346 mutex_lock(&tu->ioctl_lock);2347 spin_lock_irq(&tu->qlock);2348 2349 remove_wait_queue(&tu->qchange_sleep, &wait);2350 2351 if (tu->disconnected) {2352 err = -ENODEV;2353 goto _error;2354 }2355 if (signal_pending(current)) {2356 err = -ERESTARTSYS;2357 goto _error;2358 }2359 }2360 2361 qhead = tu->qhead++;2362 tu->qhead %= tu->queue_size;2363 tu->qused--;2364 spin_unlock_irq(&tu->qlock);2365 2366 tread = &tu->tqueue[qhead];2367 2368 switch (tu->tread) {2369 case TREAD_FORMAT_TIME64:2370 if (copy_to_user(buffer, tread,2371 sizeof(struct snd_timer_tread64)))2372 err = -EFAULT;2373 break;2374 case TREAD_FORMAT_TIME32:2375 memset(&tread32, 0, sizeof(tread32));2376 tread32 = (struct snd_timer_tread32) {2377 .event = tread->event,2378 .tstamp_sec = tread->tstamp_sec,2379 .tstamp_nsec = tread->tstamp_nsec,2380 .val = tread->val,2381 };2382 2383 if (copy_to_user(buffer, &tread32, sizeof(tread32)))2384 err = -EFAULT;2385 break;2386 case TREAD_FORMAT_NONE:2387 if (copy_to_user(buffer, &tu->queue[qhead],2388 sizeof(struct snd_timer_read)))2389 err = -EFAULT;2390 break;2391 default:2392 err = -ENOTSUPP;2393 break;2394 }2395 2396 spin_lock_irq(&tu->qlock);2397 if (err < 0)2398 goto _error;2399 result += unit;2400 buffer += unit;2401 }2402 _error:2403 spin_unlock_irq(&tu->qlock);2404 mutex_unlock(&tu->ioctl_lock);2405 return result > 0 ? result : err;2406}2407 2408static __poll_t snd_timer_user_poll(struct file *file, poll_table * wait)2409{2410 __poll_t mask;2411 struct snd_timer_user *tu;2412 2413 tu = file->private_data;2414 2415 poll_wait(file, &tu->qchange_sleep, wait);2416 2417 mask = 0;2418 guard(spinlock_irq)(&tu->qlock);2419 if (tu->qused)2420 mask |= EPOLLIN | EPOLLRDNORM;2421 if (tu->disconnected)2422 mask |= EPOLLERR;2423 2424 return mask;2425}2426 2427#ifdef CONFIG_COMPAT2428#include "timer_compat.c"2429#else2430#define snd_timer_user_ioctl_compat NULL2431#endif2432 2433static const struct file_operations snd_timer_f_ops =2434{2435 .owner = THIS_MODULE,2436 .read = snd_timer_user_read,2437 .open = snd_timer_user_open,2438 .release = snd_timer_user_release,2439 .poll = snd_timer_user_poll,2440 .unlocked_ioctl = snd_timer_user_ioctl,2441 .compat_ioctl = snd_timer_user_ioctl_compat,2442 .fasync = snd_timer_user_fasync,2443};2444 2445/* unregister the system timer */2446static void snd_timer_free_all(void)2447{2448 struct snd_timer *timer, *n;2449 2450 list_for_each_entry_safe(timer, n, &snd_timer_list, device_list)2451 snd_timer_free(timer);2452}2453 2454static struct device *timer_dev;2455 2456/*2457 * ENTRY functions2458 */2459 2460static int __init alsa_timer_init(void)2461{2462 int err;2463 2464 err = snd_device_alloc(&timer_dev, NULL);2465 if (err < 0)2466 return err;2467 dev_set_name(timer_dev, "timer");2468 2469#ifdef SNDRV_OSS_INFO_DEV_TIMERS2470 snd_oss_info_register(SNDRV_OSS_INFO_DEV_TIMERS, SNDRV_CARDS - 1,2471 "system timer");2472#endif2473 2474 err = snd_timer_register_system();2475 if (err < 0) {2476 pr_err("ALSA: unable to register system timer (%i)\n", err);2477 goto put_timer;2478 }2479 2480 err = snd_register_device(SNDRV_DEVICE_TYPE_TIMER, NULL, 0,2481 &snd_timer_f_ops, NULL, timer_dev);2482 if (err < 0) {2483 pr_err("ALSA: unable to register timer device (%i)\n", err);2484 snd_timer_free_all();2485 goto put_timer;2486 }2487 2488 snd_timer_proc_init();2489 return 0;2490 2491put_timer:2492 put_device(timer_dev);2493 return err;2494}2495 2496static void __exit alsa_timer_exit(void)2497{2498 snd_unregister_device(timer_dev);2499 snd_timer_free_all();2500 put_device(timer_dev);2501 snd_timer_proc_done();2502#ifdef SNDRV_OSS_INFO_DEV_TIMERS2503 snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_TIMERS, SNDRV_CARDS - 1);2504#endif2505}2506 2507module_init(alsa_timer_init)2508module_exit(alsa_timer_exit)2509