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