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 fasync_struct *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 list_for_each_entry(ts, &ti->slave_active_head, active_list) 524 if (ts->ccallback) 525 ts->ccallback(ts, event + 100, &tstamp, resolution); 526 } 527 528 /* start/continue a master timer */ 529 static int snd_timer_start1(struct snd_timer_instance *timeri, 530 bool start, unsigned long ticks) 531 { 532 struct snd_timer *timer; 533 int result; 534 unsigned long flags; 535 536 timer = timeri->timer; 537 if (!timer) 538 return -EINVAL; 539 540 spin_lock_irqsave(&timer->lock, flags); 541 if (timeri->flags & SNDRV_TIMER_IFLG_DEAD) { 542 result = -EINVAL; 543 goto unlock; 544 } 545 if (timer->card && timer->card->shutdown) { 546 result = -ENODEV; 547 goto unlock; 548 } 549 if (timeri->flags & (SNDRV_TIMER_IFLG_RUNNING | 550 SNDRV_TIMER_IFLG_START)) { 551 result = -EBUSY; 552 goto unlock; 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 unlock: 580 spin_unlock_irqrestore(&timer->lock, flags); 581 return result; 582 } 583 584 /* start/continue a slave timer */ 585 static int snd_timer_start_slave(struct snd_timer_instance *timeri, 586 bool start) 587 { 588 unsigned long flags; 589 int err; 590 591 spin_lock_irqsave(&slave_active_lock, flags); 592 if (timeri->flags & SNDRV_TIMER_IFLG_DEAD) { 593 err = -EINVAL; 594 goto unlock; 595 } 596 if (timeri->flags & SNDRV_TIMER_IFLG_RUNNING) { 597 err = -EBUSY; 598 goto unlock; 599 } 600 timeri->flags |= SNDRV_TIMER_IFLG_RUNNING; 601 if (timeri->master && timeri->timer) { 602 spin_lock(&timeri->timer->lock); 603 list_add_tail(&timeri->active_list, 604 &timeri->master->slave_active_head); 605 snd_timer_notify1(timeri, start ? SNDRV_TIMER_EVENT_START : 606 SNDRV_TIMER_EVENT_CONTINUE); 607 spin_unlock(&timeri->timer->lock); 608 } 609 err = 1; /* delayed start */ 610 unlock: 611 spin_unlock_irqrestore(&slave_active_lock, flags); 612 return err; 613 } 614 615 /* stop/pause a master timer */ 616 static int snd_timer_stop1(struct snd_timer_instance *timeri, bool stop) 617 { 618 struct snd_timer *timer; 619 int result = 0; 620 unsigned long flags; 621 622 timer = timeri->timer; 623 if (!timer) 624 return -EINVAL; 625 spin_lock_irqsave(&timer->lock, flags); 626 if (!(timeri->flags & (SNDRV_TIMER_IFLG_RUNNING | 627 SNDRV_TIMER_IFLG_START))) { 628 result = -EBUSY; 629 goto unlock; 630 } 631 list_del_init(&timeri->ack_list); 632 list_del_init(&timeri->active_list); 633 if (timer->card && timer->card->shutdown) 634 goto unlock; 635 if (stop) { 636 timeri->cticks = timeri->ticks; 637 timeri->pticks = 0; 638 } 639 if ((timeri->flags & SNDRV_TIMER_IFLG_RUNNING) && 640 !(--timer->running)) { 641 timer->hw.stop(timer); 642 if (timer->flags & SNDRV_TIMER_FLG_RESCHED) { 643 timer->flags &= ~SNDRV_TIMER_FLG_RESCHED; 644 snd_timer_reschedule(timer, 0); 645 if (timer->flags & SNDRV_TIMER_FLG_CHANGE) { 646 timer->flags &= ~SNDRV_TIMER_FLG_CHANGE; 647 timer->hw.start(timer); 648 } 649 } 650 } 651 timeri->flags &= ~(SNDRV_TIMER_IFLG_RUNNING | SNDRV_TIMER_IFLG_START); 652 if (stop) 653 timeri->flags &= ~SNDRV_TIMER_IFLG_PAUSED; 654 else 655 timeri->flags |= SNDRV_TIMER_IFLG_PAUSED; 656 snd_timer_notify1(timeri, stop ? SNDRV_TIMER_EVENT_STOP : 657 SNDRV_TIMER_EVENT_PAUSE); 658 unlock: 659 spin_unlock_irqrestore(&timer->lock, flags); 660 return result; 661 } 662 663 /* stop/pause a slave timer */ 664 static int snd_timer_stop_slave(struct snd_timer_instance *timeri, bool stop) 665 { 666 unsigned long flags; 667 668 spin_lock_irqsave(&slave_active_lock, flags); 669 if (!(timeri->flags & SNDRV_TIMER_IFLG_RUNNING)) { 670 spin_unlock_irqrestore(&slave_active_lock, flags); 671 return -EBUSY; 672 } 673 timeri->flags &= ~SNDRV_TIMER_IFLG_RUNNING; 674 if (timeri->timer) { 675 spin_lock(&timeri->timer->lock); 676 list_del_init(&timeri->ack_list); 677 list_del_init(&timeri->active_list); 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 0; 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 1250 mutex_lock(®ister_mutex); 1251 list_for_each_entry(timer, &snd_timer_list, device_list) { 1252 if (timer->card && timer->card->shutdown) 1253 continue; 1254 switch (timer->tmr_class) { 1255 case SNDRV_TIMER_CLASS_GLOBAL: 1256 snd_iprintf(buffer, "G%i: ", timer->tmr_device); 1257 break; 1258 case SNDRV_TIMER_CLASS_CARD: 1259 snd_iprintf(buffer, "C%i-%i: ", 1260 timer->card->number, timer->tmr_device); 1261 break; 1262 case SNDRV_TIMER_CLASS_PCM: 1263 snd_iprintf(buffer, "P%i-%i-%i: ", timer->card->number, 1264 timer->tmr_device, timer->tmr_subdevice); 1265 break; 1266 default: 1267 snd_iprintf(buffer, "?%i-%i-%i-%i: ", timer->tmr_class, 1268 timer->card ? timer->card->number : -1, 1269 timer->tmr_device, timer->tmr_subdevice); 1270 } 1271 snd_iprintf(buffer, "%s :", timer->name); 1272 if (timer->hw.resolution) 1273 snd_iprintf(buffer, " %lu.%03luus (%lu ticks)", 1274 timer->hw.resolution / 1000, 1275 timer->hw.resolution % 1000, 1276 timer->hw.ticks); 1277 if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE) 1278 snd_iprintf(buffer, " SLAVE"); 1279 snd_iprintf(buffer, "\n"); 1280 list_for_each_entry(ti, &timer->open_list_head, open_list) 1281 snd_iprintf(buffer, " Client %s : %s\n", 1282 ti->owner ? ti->owner : "unknown", 1283 (ti->flags & (SNDRV_TIMER_IFLG_START | 1284 SNDRV_TIMER_IFLG_RUNNING)) 1285 ? "running" : "stopped"); 1286 } 1287 mutex_unlock(®ister_mutex); 1288 } 1289 1290 static struct snd_info_entry *snd_timer_proc_entry; 1291 1292 static void __init snd_timer_proc_init(void) 1293 { 1294 struct snd_info_entry *entry; 1295 1296 entry = snd_info_create_module_entry(THIS_MODULE, "timers", NULL); 1297 if (entry != NULL) { 1298 entry->c.text.read = snd_timer_proc_read; 1299 if (snd_info_register(entry) < 0) { 1300 snd_info_free_entry(entry); 1301 entry = NULL; 1302 } 1303 } 1304 snd_timer_proc_entry = entry; 1305 } 1306 1307 static void __exit snd_timer_proc_done(void) 1308 { 1309 snd_info_free_entry(snd_timer_proc_entry); 1310 } 1311 #else /* !CONFIG_SND_PROC_FS */ 1312 #define snd_timer_proc_init() 1313 #define snd_timer_proc_done() 1314 #endif 1315 1316 /* 1317 * USER SPACE interface 1318 */ 1319 1320 static void snd_timer_user_interrupt(struct snd_timer_instance *timeri, 1321 unsigned long resolution, 1322 unsigned long ticks) 1323 { 1324 struct snd_timer_user *tu = timeri->callback_data; 1325 struct snd_timer_read *r; 1326 int prev; 1327 1328 spin_lock(&tu->qlock); 1329 if (tu->qused > 0) { 1330 prev = tu->qtail == 0 ? tu->queue_size - 1 : tu->qtail - 1; 1331 r = &tu->queue[prev]; 1332 if (r->resolution == resolution) { 1333 r->ticks += ticks; 1334 goto __wake; 1335 } 1336 } 1337 if (tu->qused >= tu->queue_size) { 1338 tu->overrun++; 1339 } else { 1340 r = &tu->queue[tu->qtail++]; 1341 tu->qtail %= tu->queue_size; 1342 r->resolution = resolution; 1343 r->ticks = ticks; 1344 tu->qused++; 1345 } 1346 __wake: 1347 spin_unlock(&tu->qlock); 1348 kill_fasync(&tu->fasync, SIGIO, POLL_IN); 1349 wake_up(&tu->qchange_sleep); 1350 } 1351 1352 static void snd_timer_user_append_to_tqueue(struct snd_timer_user *tu, 1353 struct snd_timer_tread64 *tread) 1354 { 1355 if (tu->qused >= tu->queue_size) { 1356 tu->overrun++; 1357 } else { 1358 memcpy(&tu->tqueue[tu->qtail++], tread, sizeof(*tread)); 1359 tu->qtail %= tu->queue_size; 1360 tu->qused++; 1361 } 1362 } 1363 1364 static void snd_timer_user_ccallback(struct snd_timer_instance *timeri, 1365 int event, 1366 struct timespec64 *tstamp, 1367 unsigned long resolution) 1368 { 1369 struct snd_timer_user *tu = timeri->callback_data; 1370 struct snd_timer_tread64 r1; 1371 unsigned long flags; 1372 1373 if (event >= SNDRV_TIMER_EVENT_START && 1374 event <= SNDRV_TIMER_EVENT_PAUSE) 1375 tu->tstamp = *tstamp; 1376 if ((tu->filter & (1 << event)) == 0 || !tu->tread) 1377 return; 1378 memset(&r1, 0, sizeof(r1)); 1379 r1.event = event; 1380 r1.tstamp_sec = tstamp->tv_sec; 1381 r1.tstamp_nsec = tstamp->tv_nsec; 1382 r1.val = resolution; 1383 spin_lock_irqsave(&tu->qlock, flags); 1384 snd_timer_user_append_to_tqueue(tu, &r1); 1385 spin_unlock_irqrestore(&tu->qlock, flags); 1386 kill_fasync(&tu->fasync, SIGIO, POLL_IN); 1387 wake_up(&tu->qchange_sleep); 1388 } 1389 1390 static void snd_timer_user_disconnect(struct snd_timer_instance *timeri) 1391 { 1392 struct snd_timer_user *tu = timeri->callback_data; 1393 1394 tu->disconnected = true; 1395 wake_up(&tu->qchange_sleep); 1396 } 1397 1398 static void snd_timer_user_tinterrupt(struct snd_timer_instance *timeri, 1399 unsigned long resolution, 1400 unsigned long ticks) 1401 { 1402 struct snd_timer_user *tu = timeri->callback_data; 1403 struct snd_timer_tread64 *r, r1; 1404 struct timespec64 tstamp; 1405 int prev, append = 0; 1406 1407 memset(&r1, 0, sizeof(r1)); 1408 memset(&tstamp, 0, sizeof(tstamp)); 1409 spin_lock(&tu->qlock); 1410 if ((tu->filter & ((1 << SNDRV_TIMER_EVENT_RESOLUTION) | 1411 (1 << SNDRV_TIMER_EVENT_TICK))) == 0) { 1412 spin_unlock(&tu->qlock); 1413 return; 1414 } 1415 if (tu->last_resolution != resolution || ticks > 0) { 1416 if (timer_tstamp_monotonic) 1417 ktime_get_ts64(&tstamp); 1418 else 1419 ktime_get_real_ts64(&tstamp); 1420 } 1421 if ((tu->filter & (1 << SNDRV_TIMER_EVENT_RESOLUTION)) && 1422 tu->last_resolution != resolution) { 1423 r1.event = SNDRV_TIMER_EVENT_RESOLUTION; 1424 r1.tstamp_sec = tstamp.tv_sec; 1425 r1.tstamp_nsec = tstamp.tv_nsec; 1426 r1.val = resolution; 1427 snd_timer_user_append_to_tqueue(tu, &r1); 1428 tu->last_resolution = resolution; 1429 append++; 1430 } 1431 if ((tu->filter & (1 << SNDRV_TIMER_EVENT_TICK)) == 0) 1432 goto __wake; 1433 if (ticks == 0) 1434 goto __wake; 1435 if (tu->qused > 0) { 1436 prev = tu->qtail == 0 ? tu->queue_size - 1 : tu->qtail - 1; 1437 r = &tu->tqueue[prev]; 1438 if (r->event == SNDRV_TIMER_EVENT_TICK) { 1439 r->tstamp_sec = tstamp.tv_sec; 1440 r->tstamp_nsec = tstamp.tv_nsec; 1441 r->val += ticks; 1442 append++; 1443 goto __wake; 1444 } 1445 } 1446 r1.event = SNDRV_TIMER_EVENT_TICK; 1447 r1.tstamp_sec = tstamp.tv_sec; 1448 r1.tstamp_nsec = tstamp.tv_nsec; 1449 r1.val = ticks; 1450 snd_timer_user_append_to_tqueue(tu, &r1); 1451 append++; 1452 __wake: 1453 spin_unlock(&tu->qlock); 1454 if (append == 0) 1455 return; 1456 kill_fasync(&tu->fasync, SIGIO, POLL_IN); 1457 wake_up(&tu->qchange_sleep); 1458 } 1459 1460 static int realloc_user_queue(struct snd_timer_user *tu, int size) 1461 { 1462 struct snd_timer_read *queue = NULL; 1463 struct snd_timer_tread64 *tqueue = NULL; 1464 1465 if (tu->tread) { 1466 tqueue = kcalloc(size, sizeof(*tqueue), GFP_KERNEL); 1467 if (!tqueue) 1468 return -ENOMEM; 1469 } else { 1470 queue = kcalloc(size, sizeof(*queue), GFP_KERNEL); 1471 if (!queue) 1472 return -ENOMEM; 1473 } 1474 1475 spin_lock_irq(&tu->qlock); 1476 kfree(tu->queue); 1477 kfree(tu->tqueue); 1478 tu->queue_size = size; 1479 tu->queue = queue; 1480 tu->tqueue = tqueue; 1481 tu->qhead = tu->qtail = tu->qused = 0; 1482 spin_unlock_irq(&tu->qlock); 1483 1484 return 0; 1485 } 1486 1487 static int snd_timer_user_open(struct inode *inode, struct file *file) 1488 { 1489 struct snd_timer_user *tu; 1490 int err; 1491 1492 err = stream_open(inode, file); 1493 if (err < 0) 1494 return err; 1495 1496 tu = kzalloc(sizeof(*tu), GFP_KERNEL); 1497 if (tu == NULL) 1498 return -ENOMEM; 1499 spin_lock_init(&tu->qlock); 1500 init_waitqueue_head(&tu->qchange_sleep); 1501 mutex_init(&tu->ioctl_lock); 1502 tu->ticks = 1; 1503 if (realloc_user_queue(tu, 128) < 0) { 1504 kfree(tu); 1505 return -ENOMEM; 1506 } 1507 file->private_data = tu; 1508 return 0; 1509 } 1510 1511 static int snd_timer_user_release(struct inode *inode, struct file *file) 1512 { 1513 struct snd_timer_user *tu; 1514 1515 if (file->private_data) { 1516 tu = file->private_data; 1517 file->private_data = NULL; 1518 mutex_lock(&tu->ioctl_lock); 1519 if (tu->timeri) { 1520 snd_timer_close(tu->timeri); 1521 snd_timer_instance_free(tu->timeri); 1522 } 1523 mutex_unlock(&tu->ioctl_lock); 1524 kfree(tu->queue); 1525 kfree(tu->tqueue); 1526 kfree(tu); 1527 } 1528 return 0; 1529 } 1530 1531 static void snd_timer_user_zero_id(struct snd_timer_id *id) 1532 { 1533 id->dev_class = SNDRV_TIMER_CLASS_NONE; 1534 id->dev_sclass = SNDRV_TIMER_SCLASS_NONE; 1535 id->card = -1; 1536 id->device = -1; 1537 id->subdevice = -1; 1538 } 1539 1540 static void snd_timer_user_copy_id(struct snd_timer_id *id, struct snd_timer *timer) 1541 { 1542 id->dev_class = timer->tmr_class; 1543 id->dev_sclass = SNDRV_TIMER_SCLASS_NONE; 1544 id->card = timer->card ? timer->card->number : -1; 1545 id->device = timer->tmr_device; 1546 id->subdevice = timer->tmr_subdevice; 1547 } 1548 1549 static int snd_timer_user_next_device(struct snd_timer_id __user *_tid) 1550 { 1551 struct snd_timer_id id; 1552 struct snd_timer *timer; 1553 struct list_head *p; 1554 1555 if (copy_from_user(&id, _tid, sizeof(id))) 1556 return -EFAULT; 1557 mutex_lock(®ister_mutex); 1558 if (id.dev_class < 0) { /* first item */ 1559 if (list_empty(&snd_timer_list)) 1560 snd_timer_user_zero_id(&id); 1561 else { 1562 timer = list_entry(snd_timer_list.next, 1563 struct snd_timer, device_list); 1564 snd_timer_user_copy_id(&id, timer); 1565 } 1566 } else { 1567 switch (id.dev_class) { 1568 case SNDRV_TIMER_CLASS_GLOBAL: 1569 id.device = id.device < 0 ? 0 : id.device + 1; 1570 list_for_each(p, &snd_timer_list) { 1571 timer = list_entry(p, struct snd_timer, device_list); 1572 if (timer->tmr_class > SNDRV_TIMER_CLASS_GLOBAL) { 1573 snd_timer_user_copy_id(&id, timer); 1574 break; 1575 } 1576 if (timer->tmr_device >= id.device) { 1577 snd_timer_user_copy_id(&id, timer); 1578 break; 1579 } 1580 } 1581 if (p == &snd_timer_list) 1582 snd_timer_user_zero_id(&id); 1583 break; 1584 case SNDRV_TIMER_CLASS_CARD: 1585 case SNDRV_TIMER_CLASS_PCM: 1586 if (id.card < 0) { 1587 id.card = 0; 1588 } else { 1589 if (id.device < 0) { 1590 id.device = 0; 1591 } else { 1592 if (id.subdevice < 0) 1593 id.subdevice = 0; 1594 else if (id.subdevice < INT_MAX) 1595 id.subdevice++; 1596 } 1597 } 1598 list_for_each(p, &snd_timer_list) { 1599 timer = list_entry(p, struct snd_timer, device_list); 1600 if (timer->tmr_class > id.dev_class) { 1601 snd_timer_user_copy_id(&id, timer); 1602 break; 1603 } 1604 if (timer->tmr_class < id.dev_class) 1605 continue; 1606 if (timer->card->number > id.card) { 1607 snd_timer_user_copy_id(&id, timer); 1608 break; 1609 } 1610 if (timer->card->number < id.card) 1611 continue; 1612 if (timer->tmr_device > id.device) { 1613 snd_timer_user_copy_id(&id, timer); 1614 break; 1615 } 1616 if (timer->tmr_device < id.device) 1617 continue; 1618 if (timer->tmr_subdevice > id.subdevice) { 1619 snd_timer_user_copy_id(&id, timer); 1620 break; 1621 } 1622 if (timer->tmr_subdevice < id.subdevice) 1623 continue; 1624 snd_timer_user_copy_id(&id, timer); 1625 break; 1626 } 1627 if (p == &snd_timer_list) 1628 snd_timer_user_zero_id(&id); 1629 break; 1630 default: 1631 snd_timer_user_zero_id(&id); 1632 } 1633 } 1634 mutex_unlock(®ister_mutex); 1635 if (copy_to_user(_tid, &id, sizeof(*_tid))) 1636 return -EFAULT; 1637 return 0; 1638 } 1639 1640 static int snd_timer_user_ginfo(struct file *file, 1641 struct snd_timer_ginfo __user *_ginfo) 1642 { 1643 struct snd_timer_ginfo *ginfo; 1644 struct snd_timer_id tid; 1645 struct snd_timer *t; 1646 struct list_head *p; 1647 int err = 0; 1648 1649 ginfo = memdup_user(_ginfo, sizeof(*ginfo)); 1650 if (IS_ERR(ginfo)) 1651 return PTR_ERR(ginfo); 1652 1653 tid = ginfo->tid; 1654 memset(ginfo, 0, sizeof(*ginfo)); 1655 ginfo->tid = tid; 1656 mutex_lock(®ister_mutex); 1657 t = snd_timer_find(&tid); 1658 if (t != NULL) { 1659 ginfo->card = t->card ? t->card->number : -1; 1660 if (t->hw.flags & SNDRV_TIMER_HW_SLAVE) 1661 ginfo->flags |= SNDRV_TIMER_FLG_SLAVE; 1662 strscpy(ginfo->id, t->id, sizeof(ginfo->id)); 1663 strscpy(ginfo->name, t->name, sizeof(ginfo->name)); 1664 ginfo->resolution = t->hw.resolution; 1665 if (t->hw.resolution_min > 0) { 1666 ginfo->resolution_min = t->hw.resolution_min; 1667 ginfo->resolution_max = t->hw.resolution_max; 1668 } 1669 list_for_each(p, &t->open_list_head) { 1670 ginfo->clients++; 1671 } 1672 } else { 1673 err = -ENODEV; 1674 } 1675 mutex_unlock(®ister_mutex); 1676 if (err >= 0 && copy_to_user(_ginfo, ginfo, sizeof(*ginfo))) 1677 err = -EFAULT; 1678 kfree(ginfo); 1679 return err; 1680 } 1681 1682 static int timer_set_gparams(struct snd_timer_gparams *gparams) 1683 { 1684 struct snd_timer *t; 1685 int err; 1686 1687 mutex_lock(®ister_mutex); 1688 t = snd_timer_find(&gparams->tid); 1689 if (!t) { 1690 err = -ENODEV; 1691 goto _error; 1692 } 1693 if (!list_empty(&t->open_list_head)) { 1694 err = -EBUSY; 1695 goto _error; 1696 } 1697 if (!t->hw.set_period) { 1698 err = -ENOSYS; 1699 goto _error; 1700 } 1701 err = t->hw.set_period(t, gparams->period_num, gparams->period_den); 1702 _error: 1703 mutex_unlock(®ister_mutex); 1704 return err; 1705 } 1706 1707 static int snd_timer_user_gparams(struct file *file, 1708 struct snd_timer_gparams __user *_gparams) 1709 { 1710 struct snd_timer_gparams gparams; 1711 1712 if (copy_from_user(&gparams, _gparams, sizeof(gparams))) 1713 return -EFAULT; 1714 return timer_set_gparams(&gparams); 1715 } 1716 1717 static int snd_timer_user_gstatus(struct file *file, 1718 struct snd_timer_gstatus __user *_gstatus) 1719 { 1720 struct snd_timer_gstatus gstatus; 1721 struct snd_timer_id tid; 1722 struct snd_timer *t; 1723 int err = 0; 1724 1725 if (copy_from_user(&gstatus, _gstatus, sizeof(gstatus))) 1726 return -EFAULT; 1727 tid = gstatus.tid; 1728 memset(&gstatus, 0, sizeof(gstatus)); 1729 gstatus.tid = tid; 1730 mutex_lock(®ister_mutex); 1731 t = snd_timer_find(&tid); 1732 if (t != NULL) { 1733 spin_lock_irq(&t->lock); 1734 gstatus.resolution = snd_timer_hw_resolution(t); 1735 if (t->hw.precise_resolution) { 1736 t->hw.precise_resolution(t, &gstatus.resolution_num, 1737 &gstatus.resolution_den); 1738 } else { 1739 gstatus.resolution_num = gstatus.resolution; 1740 gstatus.resolution_den = 1000000000uL; 1741 } 1742 spin_unlock_irq(&t->lock); 1743 } else { 1744 err = -ENODEV; 1745 } 1746 mutex_unlock(®ister_mutex); 1747 if (err >= 0 && copy_to_user(_gstatus, &gstatus, sizeof(gstatus))) 1748 err = -EFAULT; 1749 return err; 1750 } 1751 1752 static int snd_timer_user_tselect(struct file *file, 1753 struct snd_timer_select __user *_tselect) 1754 { 1755 struct snd_timer_user *tu; 1756 struct snd_timer_select tselect; 1757 char str[32]; 1758 int err = 0; 1759 1760 tu = file->private_data; 1761 if (tu->timeri) { 1762 snd_timer_close(tu->timeri); 1763 snd_timer_instance_free(tu->timeri); 1764 tu->timeri = NULL; 1765 } 1766 if (copy_from_user(&tselect, _tselect, sizeof(tselect))) { 1767 err = -EFAULT; 1768 goto __err; 1769 } 1770 sprintf(str, "application %i", current->pid); 1771 if (tselect.id.dev_class != SNDRV_TIMER_CLASS_SLAVE) 1772 tselect.id.dev_sclass = SNDRV_TIMER_SCLASS_APPLICATION; 1773 tu->timeri = snd_timer_instance_new(str); 1774 if (!tu->timeri) { 1775 err = -ENOMEM; 1776 goto __err; 1777 } 1778 1779 tu->timeri->flags |= SNDRV_TIMER_IFLG_FAST; 1780 tu->timeri->callback = tu->tread 1781 ? snd_timer_user_tinterrupt : snd_timer_user_interrupt; 1782 tu->timeri->ccallback = snd_timer_user_ccallback; 1783 tu->timeri->callback_data = (void *)tu; 1784 tu->timeri->disconnect = snd_timer_user_disconnect; 1785 1786 err = snd_timer_open(tu->timeri, &tselect.id, current->pid); 1787 if (err < 0) { 1788 snd_timer_instance_free(tu->timeri); 1789 tu->timeri = NULL; 1790 } 1791 1792 __err: 1793 return err; 1794 } 1795 1796 static int snd_timer_user_info(struct file *file, 1797 struct snd_timer_info __user *_info) 1798 { 1799 struct snd_timer_user *tu; 1800 struct snd_timer_info *info; 1801 struct snd_timer *t; 1802 int err = 0; 1803 1804 tu = file->private_data; 1805 if (!tu->timeri) 1806 return -EBADFD; 1807 t = tu->timeri->timer; 1808 if (!t) 1809 return -EBADFD; 1810 1811 info = kzalloc(sizeof(*info), GFP_KERNEL); 1812 if (! info) 1813 return -ENOMEM; 1814 info->card = t->card ? t->card->number : -1; 1815 if (t->hw.flags & SNDRV_TIMER_HW_SLAVE) 1816 info->flags |= SNDRV_TIMER_FLG_SLAVE; 1817 strscpy(info->id, t->id, sizeof(info->id)); 1818 strscpy(info->name, t->name, sizeof(info->name)); 1819 info->resolution = t->hw.resolution; 1820 if (copy_to_user(_info, info, sizeof(*_info))) 1821 err = -EFAULT; 1822 kfree(info); 1823 return err; 1824 } 1825 1826 static int snd_timer_user_params(struct file *file, 1827 struct snd_timer_params __user *_params) 1828 { 1829 struct snd_timer_user *tu; 1830 struct snd_timer_params params; 1831 struct snd_timer *t; 1832 int err; 1833 1834 tu = file->private_data; 1835 if (!tu->timeri) 1836 return -EBADFD; 1837 t = tu->timeri->timer; 1838 if (!t) 1839 return -EBADFD; 1840 if (copy_from_user(¶ms, _params, sizeof(params))) 1841 return -EFAULT; 1842 if (!(t->hw.flags & SNDRV_TIMER_HW_SLAVE)) { 1843 u64 resolution; 1844 1845 if (params.ticks < 1) { 1846 err = -EINVAL; 1847 goto _end; 1848 } 1849 1850 /* Don't allow resolution less than 1ms */ 1851 resolution = snd_timer_resolution(tu->timeri); 1852 resolution *= params.ticks; 1853 if (resolution < 1000000) { 1854 err = -EINVAL; 1855 goto _end; 1856 } 1857 } 1858 if (params.queue_size > 0 && 1859 (params.queue_size < 32 || params.queue_size > 1024)) { 1860 err = -EINVAL; 1861 goto _end; 1862 } 1863 if (params.filter & ~((1<<SNDRV_TIMER_EVENT_RESOLUTION)| 1864 (1<<SNDRV_TIMER_EVENT_TICK)| 1865 (1<<SNDRV_TIMER_EVENT_START)| 1866 (1<<SNDRV_TIMER_EVENT_STOP)| 1867 (1<<SNDRV_TIMER_EVENT_CONTINUE)| 1868 (1<<SNDRV_TIMER_EVENT_PAUSE)| 1869 (1<<SNDRV_TIMER_EVENT_SUSPEND)| 1870 (1<<SNDRV_TIMER_EVENT_RESUME)| 1871 (1<<SNDRV_TIMER_EVENT_MSTART)| 1872 (1<<SNDRV_TIMER_EVENT_MSTOP)| 1873 (1<<SNDRV_TIMER_EVENT_MCONTINUE)| 1874 (1<<SNDRV_TIMER_EVENT_MPAUSE)| 1875 (1<<SNDRV_TIMER_EVENT_MSUSPEND)| 1876 (1<<SNDRV_TIMER_EVENT_MRESUME))) { 1877 err = -EINVAL; 1878 goto _end; 1879 } 1880 snd_timer_stop(tu->timeri); 1881 spin_lock_irq(&t->lock); 1882 tu->timeri->flags &= ~(SNDRV_TIMER_IFLG_AUTO| 1883 SNDRV_TIMER_IFLG_EXCLUSIVE| 1884 SNDRV_TIMER_IFLG_EARLY_EVENT); 1885 if (params.flags & SNDRV_TIMER_PSFLG_AUTO) 1886 tu->timeri->flags |= SNDRV_TIMER_IFLG_AUTO; 1887 if (params.flags & SNDRV_TIMER_PSFLG_EXCLUSIVE) 1888 tu->timeri->flags |= SNDRV_TIMER_IFLG_EXCLUSIVE; 1889 if (params.flags & SNDRV_TIMER_PSFLG_EARLY_EVENT) 1890 tu->timeri->flags |= SNDRV_TIMER_IFLG_EARLY_EVENT; 1891 spin_unlock_irq(&t->lock); 1892 if (params.queue_size > 0 && 1893 (unsigned int)tu->queue_size != params.queue_size) { 1894 err = realloc_user_queue(tu, params.queue_size); 1895 if (err < 0) 1896 goto _end; 1897 } 1898 spin_lock_irq(&tu->qlock); 1899 tu->qhead = tu->qtail = tu->qused = 0; 1900 if (tu->timeri->flags & SNDRV_TIMER_IFLG_EARLY_EVENT) { 1901 if (tu->tread) { 1902 struct snd_timer_tread64 tread; 1903 memset(&tread, 0, sizeof(tread)); 1904 tread.event = SNDRV_TIMER_EVENT_EARLY; 1905 tread.tstamp_sec = 0; 1906 tread.tstamp_nsec = 0; 1907 tread.val = 0; 1908 snd_timer_user_append_to_tqueue(tu, &tread); 1909 } else { 1910 struct snd_timer_read *r = &tu->queue[0]; 1911 r->resolution = 0; 1912 r->ticks = 0; 1913 tu->qused++; 1914 tu->qtail++; 1915 } 1916 } 1917 tu->filter = params.filter; 1918 tu->ticks = params.ticks; 1919 spin_unlock_irq(&tu->qlock); 1920 err = 0; 1921 _end: 1922 if (copy_to_user(_params, ¶ms, sizeof(params))) 1923 return -EFAULT; 1924 return err; 1925 } 1926 1927 static int snd_timer_user_status32(struct file *file, 1928 struct snd_timer_status32 __user *_status) 1929 { 1930 struct snd_timer_user *tu; 1931 struct snd_timer_status32 status; 1932 1933 tu = file->private_data; 1934 if (!tu->timeri) 1935 return -EBADFD; 1936 memset(&status, 0, sizeof(status)); 1937 status.tstamp_sec = tu->tstamp.tv_sec; 1938 status.tstamp_nsec = tu->tstamp.tv_nsec; 1939 status.resolution = snd_timer_resolution(tu->timeri); 1940 status.lost = tu->timeri->lost; 1941 status.overrun = tu->overrun; 1942 spin_lock_irq(&tu->qlock); 1943 status.queue = tu->qused; 1944 spin_unlock_irq(&tu->qlock); 1945 if (copy_to_user(_status, &status, sizeof(status))) 1946 return -EFAULT; 1947 return 0; 1948 } 1949 1950 static int snd_timer_user_status64(struct file *file, 1951 struct snd_timer_status64 __user *_status) 1952 { 1953 struct snd_timer_user *tu; 1954 struct snd_timer_status64 status; 1955 1956 tu = file->private_data; 1957 if (!tu->timeri) 1958 return -EBADFD; 1959 memset(&status, 0, sizeof(status)); 1960 status.tstamp_sec = tu->tstamp.tv_sec; 1961 status.tstamp_nsec = tu->tstamp.tv_nsec; 1962 status.resolution = snd_timer_resolution(tu->timeri); 1963 status.lost = tu->timeri->lost; 1964 status.overrun = tu->overrun; 1965 spin_lock_irq(&tu->qlock); 1966 status.queue = tu->qused; 1967 spin_unlock_irq(&tu->qlock); 1968 if (copy_to_user(_status, &status, sizeof(status))) 1969 return -EFAULT; 1970 return 0; 1971 } 1972 1973 static int snd_timer_user_start(struct file *file) 1974 { 1975 int err; 1976 struct snd_timer_user *tu; 1977 1978 tu = file->private_data; 1979 if (!tu->timeri) 1980 return -EBADFD; 1981 snd_timer_stop(tu->timeri); 1982 tu->timeri->lost = 0; 1983 tu->last_resolution = 0; 1984 err = snd_timer_start(tu->timeri, tu->ticks); 1985 if (err < 0) 1986 return err; 1987 return 0; 1988 } 1989 1990 static int snd_timer_user_stop(struct file *file) 1991 { 1992 int err; 1993 struct snd_timer_user *tu; 1994 1995 tu = file->private_data; 1996 if (!tu->timeri) 1997 return -EBADFD; 1998 err = snd_timer_stop(tu->timeri); 1999 if (err < 0) 2000 return err; 2001 return 0; 2002 } 2003 2004 static int snd_timer_user_continue(struct file *file) 2005 { 2006 int err; 2007 struct snd_timer_user *tu; 2008 2009 tu = file->private_data; 2010 if (!tu->timeri) 2011 return -EBADFD; 2012 /* start timer instead of continue if it's not used before */ 2013 if (!(tu->timeri->flags & SNDRV_TIMER_IFLG_PAUSED)) 2014 return snd_timer_user_start(file); 2015 tu->timeri->lost = 0; 2016 err = snd_timer_continue(tu->timeri); 2017 if (err < 0) 2018 return err; 2019 return 0; 2020 } 2021 2022 static int snd_timer_user_pause(struct file *file) 2023 { 2024 int err; 2025 struct snd_timer_user *tu; 2026 2027 tu = file->private_data; 2028 if (!tu->timeri) 2029 return -EBADFD; 2030 err = snd_timer_pause(tu->timeri); 2031 if (err < 0) 2032 return err; 2033 return 0; 2034 } 2035 2036 static int snd_timer_user_tread(void __user *argp, struct snd_timer_user *tu, 2037 unsigned int cmd, bool compat) 2038 { 2039 int __user *p = argp; 2040 int xarg, old_tread; 2041 2042 if (tu->timeri) /* too late */ 2043 return -EBUSY; 2044 if (get_user(xarg, p)) 2045 return -EFAULT; 2046 2047 old_tread = tu->tread; 2048 2049 if (!xarg) 2050 tu->tread = TREAD_FORMAT_NONE; 2051 else if (cmd == SNDRV_TIMER_IOCTL_TREAD64 || 2052 (IS_ENABLED(CONFIG_64BIT) && !compat)) 2053 tu->tread = TREAD_FORMAT_TIME64; 2054 else 2055 tu->tread = TREAD_FORMAT_TIME32; 2056 2057 if (tu->tread != old_tread && 2058 realloc_user_queue(tu, tu->queue_size) < 0) { 2059 tu->tread = old_tread; 2060 return -ENOMEM; 2061 } 2062 2063 return 0; 2064 } 2065 2066 enum { 2067 SNDRV_TIMER_IOCTL_START_OLD = _IO('T', 0x20), 2068 SNDRV_TIMER_IOCTL_STOP_OLD = _IO('T', 0x21), 2069 SNDRV_TIMER_IOCTL_CONTINUE_OLD = _IO('T', 0x22), 2070 SNDRV_TIMER_IOCTL_PAUSE_OLD = _IO('T', 0x23), 2071 }; 2072 2073 static long __snd_timer_user_ioctl(struct file *file, unsigned int cmd, 2074 unsigned long arg, bool compat) 2075 { 2076 struct snd_timer_user *tu; 2077 void __user *argp = (void __user *)arg; 2078 int __user *p = argp; 2079 2080 tu = file->private_data; 2081 switch (cmd) { 2082 case SNDRV_TIMER_IOCTL_PVERSION: 2083 return put_user(SNDRV_TIMER_VERSION, p) ? -EFAULT : 0; 2084 case SNDRV_TIMER_IOCTL_NEXT_DEVICE: 2085 return snd_timer_user_next_device(argp); 2086 case SNDRV_TIMER_IOCTL_TREAD_OLD: 2087 case SNDRV_TIMER_IOCTL_TREAD64: 2088 return snd_timer_user_tread(argp, tu, cmd, compat); 2089 case SNDRV_TIMER_IOCTL_GINFO: 2090 return snd_timer_user_ginfo(file, argp); 2091 case SNDRV_TIMER_IOCTL_GPARAMS: 2092 return snd_timer_user_gparams(file, argp); 2093 case SNDRV_TIMER_IOCTL_GSTATUS: 2094 return snd_timer_user_gstatus(file, argp); 2095 case SNDRV_TIMER_IOCTL_SELECT: 2096 return snd_timer_user_tselect(file, argp); 2097 case SNDRV_TIMER_IOCTL_INFO: 2098 return snd_timer_user_info(file, argp); 2099 case SNDRV_TIMER_IOCTL_PARAMS: 2100 return snd_timer_user_params(file, argp); 2101 case SNDRV_TIMER_IOCTL_STATUS32: 2102 return snd_timer_user_status32(file, argp); 2103 case SNDRV_TIMER_IOCTL_STATUS64: 2104 return snd_timer_user_status64(file, argp); 2105 case SNDRV_TIMER_IOCTL_START: 2106 case SNDRV_TIMER_IOCTL_START_OLD: 2107 return snd_timer_user_start(file); 2108 case SNDRV_TIMER_IOCTL_STOP: 2109 case SNDRV_TIMER_IOCTL_STOP_OLD: 2110 return snd_timer_user_stop(file); 2111 case SNDRV_TIMER_IOCTL_CONTINUE: 2112 case SNDRV_TIMER_IOCTL_CONTINUE_OLD: 2113 return snd_timer_user_continue(file); 2114 case SNDRV_TIMER_IOCTL_PAUSE: 2115 case SNDRV_TIMER_IOCTL_PAUSE_OLD: 2116 return snd_timer_user_pause(file); 2117 } 2118 return -ENOTTY; 2119 } 2120 2121 static long snd_timer_user_ioctl(struct file *file, unsigned int cmd, 2122 unsigned long arg) 2123 { 2124 struct snd_timer_user *tu = file->private_data; 2125 long ret; 2126 2127 mutex_lock(&tu->ioctl_lock); 2128 ret = __snd_timer_user_ioctl(file, cmd, arg, false); 2129 mutex_unlock(&tu->ioctl_lock); 2130 return ret; 2131 } 2132 2133 static int snd_timer_user_fasync(int fd, struct file * file, int on) 2134 { 2135 struct snd_timer_user *tu; 2136 2137 tu = file->private_data; 2138 return fasync_helper(fd, file, on, &tu->fasync); 2139 } 2140 2141 static ssize_t snd_timer_user_read(struct file *file, char __user *buffer, 2142 size_t count, loff_t *offset) 2143 { 2144 struct snd_timer_tread64 *tread; 2145 struct snd_timer_tread32 tread32; 2146 struct snd_timer_user *tu; 2147 long result = 0, unit; 2148 int qhead; 2149 int err = 0; 2150 2151 tu = file->private_data; 2152 switch (tu->tread) { 2153 case TREAD_FORMAT_TIME64: 2154 unit = sizeof(struct snd_timer_tread64); 2155 break; 2156 case TREAD_FORMAT_TIME32: 2157 unit = sizeof(struct snd_timer_tread32); 2158 break; 2159 case TREAD_FORMAT_NONE: 2160 unit = sizeof(struct snd_timer_read); 2161 break; 2162 default: 2163 WARN_ONCE(1, "Corrupt snd_timer_user\n"); 2164 return -ENOTSUPP; 2165 } 2166 2167 mutex_lock(&tu->ioctl_lock); 2168 spin_lock_irq(&tu->qlock); 2169 while ((long)count - result >= unit) { 2170 while (!tu->qused) { 2171 wait_queue_entry_t wait; 2172 2173 if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) { 2174 err = -EAGAIN; 2175 goto _error; 2176 } 2177 2178 set_current_state(TASK_INTERRUPTIBLE); 2179 init_waitqueue_entry(&wait, current); 2180 add_wait_queue(&tu->qchange_sleep, &wait); 2181 2182 spin_unlock_irq(&tu->qlock); 2183 mutex_unlock(&tu->ioctl_lock); 2184 schedule(); 2185 mutex_lock(&tu->ioctl_lock); 2186 spin_lock_irq(&tu->qlock); 2187 2188 remove_wait_queue(&tu->qchange_sleep, &wait); 2189 2190 if (tu->disconnected) { 2191 err = -ENODEV; 2192 goto _error; 2193 } 2194 if (signal_pending(current)) { 2195 err = -ERESTARTSYS; 2196 goto _error; 2197 } 2198 } 2199 2200 qhead = tu->qhead++; 2201 tu->qhead %= tu->queue_size; 2202 tu->qused--; 2203 spin_unlock_irq(&tu->qlock); 2204 2205 tread = &tu->tqueue[qhead]; 2206 2207 switch (tu->tread) { 2208 case TREAD_FORMAT_TIME64: 2209 if (copy_to_user(buffer, tread, 2210 sizeof(struct snd_timer_tread64))) 2211 err = -EFAULT; 2212 break; 2213 case TREAD_FORMAT_TIME32: 2214 memset(&tread32, 0, sizeof(tread32)); 2215 tread32 = (struct snd_timer_tread32) { 2216 .event = tread->event, 2217 .tstamp_sec = tread->tstamp_sec, 2218 .tstamp_nsec = tread->tstamp_nsec, 2219 .val = tread->val, 2220 }; 2221 2222 if (copy_to_user(buffer, &tread32, sizeof(tread32))) 2223 err = -EFAULT; 2224 break; 2225 case TREAD_FORMAT_NONE: 2226 if (copy_to_user(buffer, &tu->queue[qhead], 2227 sizeof(struct snd_timer_read))) 2228 err = -EFAULT; 2229 break; 2230 default: 2231 err = -ENOTSUPP; 2232 break; 2233 } 2234 2235 spin_lock_irq(&tu->qlock); 2236 if (err < 0) 2237 goto _error; 2238 result += unit; 2239 buffer += unit; 2240 } 2241 _error: 2242 spin_unlock_irq(&tu->qlock); 2243 mutex_unlock(&tu->ioctl_lock); 2244 return result > 0 ? result : err; 2245 } 2246 2247 static __poll_t snd_timer_user_poll(struct file *file, poll_table * wait) 2248 { 2249 __poll_t mask; 2250 struct snd_timer_user *tu; 2251 2252 tu = file->private_data; 2253 2254 poll_wait(file, &tu->qchange_sleep, wait); 2255 2256 mask = 0; 2257 spin_lock_irq(&tu->qlock); 2258 if (tu->qused) 2259 mask |= EPOLLIN | EPOLLRDNORM; 2260 if (tu->disconnected) 2261 mask |= EPOLLERR; 2262 spin_unlock_irq(&tu->qlock); 2263 2264 return mask; 2265 } 2266 2267 #ifdef CONFIG_COMPAT 2268 #include "timer_compat.c" 2269 #else 2270 #define snd_timer_user_ioctl_compat NULL 2271 #endif 2272 2273 static const struct file_operations snd_timer_f_ops = 2274 { 2275 .owner = THIS_MODULE, 2276 .read = snd_timer_user_read, 2277 .open = snd_timer_user_open, 2278 .release = snd_timer_user_release, 2279 .llseek = no_llseek, 2280 .poll = snd_timer_user_poll, 2281 .unlocked_ioctl = snd_timer_user_ioctl, 2282 .compat_ioctl = snd_timer_user_ioctl_compat, 2283 .fasync = snd_timer_user_fasync, 2284 }; 2285 2286 /* unregister the system timer */ 2287 static void snd_timer_free_all(void) 2288 { 2289 struct snd_timer *timer, *n; 2290 2291 list_for_each_entry_safe(timer, n, &snd_timer_list, device_list) 2292 snd_timer_free(timer); 2293 } 2294 2295 static struct device timer_dev; 2296 2297 /* 2298 * ENTRY functions 2299 */ 2300 2301 static int __init alsa_timer_init(void) 2302 { 2303 int err; 2304 2305 snd_device_initialize(&timer_dev, NULL); 2306 dev_set_name(&timer_dev, "timer"); 2307 2308 #ifdef SNDRV_OSS_INFO_DEV_TIMERS 2309 snd_oss_info_register(SNDRV_OSS_INFO_DEV_TIMERS, SNDRV_CARDS - 1, 2310 "system timer"); 2311 #endif 2312 2313 err = snd_timer_register_system(); 2314 if (err < 0) { 2315 pr_err("ALSA: unable to register system timer (%i)\n", err); 2316 goto put_timer; 2317 } 2318 2319 err = snd_register_device(SNDRV_DEVICE_TYPE_TIMER, NULL, 0, 2320 &snd_timer_f_ops, NULL, &timer_dev); 2321 if (err < 0) { 2322 pr_err("ALSA: unable to register timer device (%i)\n", err); 2323 snd_timer_free_all(); 2324 goto put_timer; 2325 } 2326 2327 snd_timer_proc_init(); 2328 return 0; 2329 2330 put_timer: 2331 put_device(&timer_dev); 2332 return err; 2333 } 2334 2335 static void __exit alsa_timer_exit(void) 2336 { 2337 snd_unregister_device(&timer_dev); 2338 snd_timer_free_all(); 2339 put_device(&timer_dev); 2340 snd_timer_proc_done(); 2341 #ifdef SNDRV_OSS_INFO_DEV_TIMERS 2342 snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_TIMERS, SNDRV_CARDS - 1); 2343 #endif 2344 } 2345 2346 module_init(alsa_timer_init) 2347 module_exit(alsa_timer_exit) 2348