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