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