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 34static int timer_limit = DEFAULT_TIMER_LIMIT; 35static int timer_tstamp_monotonic = 1; 36MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Takashi Iwai <tiwai@suse.de>"); 37MODULE_DESCRIPTION("ALSA timer interface"); 38MODULE_LICENSE("GPL"); 39module_param(timer_limit, int, 0444); 40MODULE_PARM_DESC(timer_limit, "Maximum global timers in system."); 41module_param(timer_tstamp_monotonic, int, 0444); 42MODULE_PARM_DESC(timer_tstamp_monotonic, "Use posix monotonic clock source for timestamps (default)."); 43 44MODULE_ALIAS_CHARDEV(CONFIG_SND_MAJOR, SNDRV_MINOR_TIMER); 45MODULE_ALIAS("devname:snd/timer"); 46 47enum timer_tread_format { 48 TREAD_FORMAT_NONE = 0, 49 TREAD_FORMAT_TIME64, 50 TREAD_FORMAT_TIME32, 51}; 52 53struct snd_timer_tread32 { 54 int event; 55 s32 tstamp_sec; 56 s32 tstamp_nsec; 57 unsigned int val; 58}; 59 60struct 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 69struct snd_timer_user { 70 struct snd_timer_instance *timeri; 71 int tread; /* enhanced read with timestamps and events */ 72 unsigned long ticks; 73 unsigned long overrun; 74 int qhead; 75 int qtail; 76 int qused; 77 int queue_size; 78 bool disconnected; 79 struct snd_timer_read *queue; 80 struct snd_timer_tread64 *tqueue; 81 spinlock_t qlock; 82 unsigned long last_resolution; 83 unsigned int filter; 84 struct timespec64 tstamp; /* trigger tstamp */ 85 wait_queue_head_t qchange_sleep; 86 struct snd_fasync *fasync; 87 struct mutex ioctl_lock; 88}; 89 90struct 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 102struct 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 */ 115static LIST_HEAD(snd_timer_list); 116 117/* list of slave instances */ 118static LIST_HEAD(snd_timer_slave_list); 119 120/* lock for slave active lists */ 121static DEFINE_SPINLOCK(slave_active_lock); 122 123#define MAX_SLAVE_INSTANCES 1000 124static int num_slaves; 125 126static DEFINE_MUTEX(register_mutex); 127 128static int snd_timer_free(struct snd_timer *timer); 129static int snd_timer_dev_free(struct snd_device *device); 130static int snd_timer_dev_register(struct snd_device *device); 131static int snd_timer_dev_disconnect(struct snd_device *device); 132 133static 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 */ 138struct 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} 158EXPORT_SYMBOL(snd_timer_instance_new); 159 160void 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} 169EXPORT_SYMBOL(snd_timer_instance_free); 170 171/* 172 * find a timer instance from the given timer id 173 */ 174static 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 197static 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 */ 217static 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 */ 244static 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 */ 268static 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 282static 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 */ 289int 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); 372list_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} 383EXPORT_SYMBOL(snd_timer_open); 384 385/* 386 * close a timer instance 387 * call this with register_mutex down. 388 */ 389static 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 */ 455void 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} 469EXPORT_SYMBOL(snd_timer_close); 470 471static 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 479unsigned 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} 495EXPORT_SYMBOL(snd_timer_resolution); 496 497static void snd_timer_notify1(struct snd_timer_instance *ti, int event) 498{ 499 struct snd_timer *timer = ti->timer; 500 unsigned long resolution = 0; 501 struct snd_timer_instance *ts; 502 struct timespec64 tstamp; 503 504 if (timer_tstamp_monotonic) 505 ktime_get_ts64(&tstamp); 506 else 507 ktime_get_real_ts64(&tstamp); 508 if (snd_BUG_ON(event < SNDRV_TIMER_EVENT_START || 509 event > SNDRV_TIMER_EVENT_PAUSE)) 510 return; 511 if (timer && 512 (event == SNDRV_TIMER_EVENT_START || 513 event == SNDRV_TIMER_EVENT_CONTINUE)) 514 resolution = snd_timer_hw_resolution(timer); 515 if (ti->ccallback) 516 ti->ccallback(ti, event, &tstamp, resolution); 517 if (ti->flags & SNDRV_TIMER_IFLG_SLAVE) 518 return; 519 if (timer == NULL) 520 return; 521 if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE) 522 return; 523 event += 10; /* convert to SNDRV_TIMER_EVENT_MXXX */ 524 list_for_each_entry(ts, &ti->slave_active_head, active_list) 525 if (ts->ccallback) 526 ts->ccallback(ts, event, &tstamp, resolution); 527} 528 529/* start/continue a master timer */ 530static int snd_timer_start1(struct snd_timer_instance *timeri, 531 bool start, unsigned long ticks) 532{ 533 struct snd_timer *timer; 534 int result; 535 unsigned long flags; 536 537 timer = timeri->timer; 538 if (!timer) 539 return -EINVAL; 540 541 spin_lock_irqsave(&timer->lock, flags); 542 if (timeri->flags & SNDRV_TIMER_IFLG_DEAD) { 543 result = -EINVAL; 544 goto unlock; 545 } 546 if (timer->card && timer->card->shutdown) { 547 result = -ENODEV; 548 goto unlock; 549 } 550 if (timeri->flags & (SNDRV_TIMER_IFLG_RUNNING | 551 SNDRV_TIMER_IFLG_START)) { 552 result = -EBUSY; 553 goto unlock; 554 } 555 556 if (start) 557 timeri->ticks = timeri->cticks = ticks; 558 else if (!timeri->cticks) 559 timeri->cticks = 1; 560 timeri->pticks = 0; 561 562 list_move_tail(&timeri->active_list, &timer->active_list_head); 563 if (timer->running) { 564 if (timer->hw.flags & SNDRV_TIMER_HW_SLAVE) 565 goto __start_now; 566 timer->flags |= SNDRV_TIMER_FLG_RESCHED; 567 timeri->flags |= SNDRV_TIMER_IFLG_START; 568 result = 1; /* delayed start */ 569 } else { 570 if (start) 571 timer->sticks = ticks; 572 timer->hw.start(timer); 573 __start_now: 574 timer->running++; 575 timeri->flags |= SNDRV_TIMER_IFLG_RUNNING; 576 result = 0; 577 } 578 snd_timer_notify1(timeri, start ? SNDRV_TIMER_EVENT_START : 579 SNDRV_TIMER_EVENT_CONTINUE); 580 unlock: 581 spin_unlock_irqrestore(&timer->lock, flags); 582 return result; 583} 584 585/* start/continue a slave timer */ 586static int snd_timer_start_slave(struct snd_timer_instance *timeri, 587 bool start) 588{ 589 unsigned long flags; 590 int err; 591 592 spin_lock_irqsave(&slave_active_lock, flags); 593 if (timeri->flags & SNDRV_TIMER_IFLG_DEAD) { 594 err = -EINVAL; 595 goto unlock; 596 } 597 if (timeri->flags & SNDRV_TIMER_IFLG_RUNNING) { 598 err = -EBUSY; 599 goto unlock; 600 } 601 timeri->flags |= SNDRV_TIMER_IFLG_RUNNING; 602 if (timeri->master && timeri->timer) { 603 spin_lock(&timeri->timer->lock); 604 list_add_tail(&timeri->active_list, 605 &timeri->master->slave_active_head); 606 snd_timer_notify1(timeri, start ? SNDRV_TIMER_EVENT_START : 607 SNDRV_TIMER_EVENT_CONTINUE); 608 spin_unlock(&timeri->timer->lock); 609 } 610 err = 1; /* delayed start */ 611 unlock: 612 spin_unlock_irqrestore(&slave_active_lock, flags); 613 return err; 614} 615 616/* stop/pause a master timer */ 617static int snd_timer_stop1(struct snd_timer_instance *timeri, bool stop) 618{ 619 struct snd_timer *timer; 620 int result = 0; 621 unsigned long flags; 622 623 timer = timeri->timer; 624 if (!timer) 625 return -EINVAL; 626 spin_lock_irqsave(&timer->lock, flags); 627 list_del_init(&timeri->ack_list); 628 list_del_init(&timeri->active_list); 629 if (!(timeri->flags & (SNDRV_TIMER_IFLG_RUNNING | 630 SNDRV_TIMER_IFLG_START))) { 631 result = -EBUSY; 632 goto unlock; 633 } 634 if (timer->card && timer->card->shutdown) 635 goto unlock; 636 if (stop) { 637 timeri->cticks = timeri->ticks; 638 timeri->pticks = 0; 639 } 640 if ((timeri->flags & SNDRV_TIMER_IFLG_RUNNING) && 641 !(--timer->running)) { 642 timer->hw.stop(timer); 643 if (timer->flags & SNDRV_TIMER_FLG_RESCHED) { 644 timer->flags &= ~SNDRV_TIMER_FLG_RESCHED; 645 snd_timer_reschedule(timer, 0); 646 if (timer->flags & SNDRV_TIMER_FLG_CHANGE) { 647 timer->flags &= ~SNDRV_TIMER_FLG_CHANGE; 648 timer->hw.start(timer); 649 } 650 } 651 } 652 timeri->flags &= ~(SNDRV_TIMER_IFLG_RUNNING | SNDRV_TIMER_IFLG_START); 653 if (stop) 654 timeri->flags &= ~SNDRV_TIMER_IFLG_PAUSED; 655 else 656 timeri->flags |= SNDRV_TIMER_IFLG_PAUSED; 657 snd_timer_notify1(timeri, stop ? SNDRV_TIMER_EVENT_STOP : 658 SNDRV_TIMER_EVENT_PAUSE); 659 unlock: 660 spin_unlock_irqrestore(&timer->lock, flags); 661 return result; 662} 663 664/* stop/pause a slave timer */ 665static int snd_timer_stop_slave(struct snd_timer_instance *timeri, bool stop) 666{ 667 unsigned long flags; 668 bool running; 669 670 spin_lock_irqsave(&slave_active_lock, flags); 671 running = timeri->flags & SNDRV_TIMER_IFLG_RUNNING; 672 timeri->flags &= ~SNDRV_TIMER_IFLG_RUNNING; 673 if (timeri->timer) { 674 spin_lock(&timeri->timer->lock); 675 list_del_init(&timeri->ack_list); 676 list_del_init(&timeri->active_list); 677 if (running) 678 snd_timer_notify1(timeri, stop ? SNDRV_TIMER_EVENT_STOP : 679 SNDRV_TIMER_EVENT_PAUSE); 680 spin_unlock(&timeri->timer->lock); 681 } 682 spin_unlock_irqrestore(&slave_active_lock, flags); 683 return running ? 0 : -EBUSY; 684} 685 686/* 687 * start the timer instance 688 */ 689int 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} 698EXPORT_SYMBOL(snd_timer_start); 699 700/* 701 * stop the timer instance. 702 * 703 * do not call this from the timer callback! 704 */ 705int 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} 712EXPORT_SYMBOL(snd_timer_stop); 713 714/* 715 * start again.. the tick is kept. 716 */ 717int 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} 728EXPORT_SYMBOL(snd_timer_continue); 729 730/* 731 * pause.. remember the ticks left 732 */ 733int 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} 740EXPORT_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 */ 748static 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 */ 776static 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 */ 804static 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 */ 819static 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 */ 840void 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} 928EXPORT_SYMBOL(snd_timer_interrupt); 929 930/* 931 932 */ 933 934int 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 strlcpy(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} 984EXPORT_SYMBOL(snd_timer_new); 985 986static 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 1011static 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 1017static 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 1057static 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 1073void 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} 1100EXPORT_SYMBOL(snd_timer_notify); 1101 1102/* 1103 * exported functions for global timers 1104 */ 1105int 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} 1116EXPORT_SYMBOL(snd_timer_global_new); 1117 1118int snd_timer_global_free(struct snd_timer *timer) 1119{ 1120 return snd_timer_free(timer); 1121} 1122EXPORT_SYMBOL(snd_timer_global_free); 1123 1124int 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} 1132EXPORT_SYMBOL(snd_timer_global_register); 1133 1134/* 1135 * System timer 1136 */ 1137 1138struct 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 1146static 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 1157static 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 1176static 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 1192static 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 1201static 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 1211static void snd_timer_free_system(struct snd_timer *timer) 1212{ 1213 kfree(timer->private_data); 1214} 1215 1216static 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 1244static 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 1290static struct snd_info_entry *snd_timer_proc_entry; 1291 1292static 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 1307static 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 1320static 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 snd_kill_fasync(tu->fasync, SIGIO, POLL_IN); 1349 wake_up(&tu->qchange_sleep); 1350} 1351 1352static 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 1364static 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 snd_kill_fasync(tu->fasync, SIGIO, POLL_IN); 1387 wake_up(&tu->qchange_sleep); 1388} 1389 1390static 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 1398static 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 snd_kill_fasync(tu->fasync, SIGIO, POLL_IN); 1457 wake_up(&tu->qchange_sleep); 1458} 1459 1460static 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 1487static 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 1511static 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 snd_fasync_free(tu->fasync); 1525 kfree(tu->queue); 1526 kfree(tu->tqueue); 1527 kfree(tu); 1528 } 1529 return 0; 1530} 1531 1532static void snd_timer_user_zero_id(struct snd_timer_id *id) 1533{ 1534 id->dev_class = SNDRV_TIMER_CLASS_NONE; 1535 id->dev_sclass = SNDRV_TIMER_SCLASS_NONE; 1536 id->card = -1; 1537 id->device = -1; 1538 id->subdevice = -1; 1539} 1540 1541static void snd_timer_user_copy_id(struct snd_timer_id *id, struct snd_timer *timer) 1542{ 1543 id->dev_class = timer->tmr_class; 1544 id->dev_sclass = SNDRV_TIMER_SCLASS_NONE; 1545 id->card = timer->card ? timer->card->number : -1; 1546 id->device = timer->tmr_device; 1547 id->subdevice = timer->tmr_subdevice; 1548} 1549 1550static int snd_timer_user_next_device(struct snd_timer_id __user *_tid) 1551{ 1552 struct snd_timer_id id; 1553 struct snd_timer *timer; 1554 struct list_head *p; 1555 1556 if (copy_from_user(&id, _tid, sizeof(id))) 1557 return -EFAULT; 1558 mutex_lock(®ister_mutex); 1559 if (id.dev_class < 0) { /* first item */ 1560 if (list_empty(&snd_timer_list)) 1561 snd_timer_user_zero_id(&id); 1562 else { 1563 timer = list_entry(snd_timer_list.next, 1564 struct snd_timer, device_list); 1565 snd_timer_user_copy_id(&id, timer); 1566 } 1567 } else { 1568 switch (id.dev_class) { 1569 case SNDRV_TIMER_CLASS_GLOBAL: 1570 id.device = id.device < 0 ? 0 : id.device + 1; 1571 list_for_each(p, &snd_timer_list) { 1572 timer = list_entry(p, struct snd_timer, device_list); 1573 if (timer->tmr_class > SNDRV_TIMER_CLASS_GLOBAL) { 1574 snd_timer_user_copy_id(&id, timer); 1575 break; 1576 } 1577 if (timer->tmr_device >= id.device) { 1578 snd_timer_user_copy_id(&id, timer); 1579 break; 1580 } 1581 } 1582 if (p == &snd_timer_list) 1583 snd_timer_user_zero_id(&id); 1584 break; 1585 case SNDRV_TIMER_CLASS_CARD: 1586 case SNDRV_TIMER_CLASS_PCM: 1587 if (id.card < 0) { 1588 id.card = 0; 1589 } else { 1590 if (id.device < 0) { 1591 id.device = 0; 1592 } else { 1593 if (id.subdevice < 0) 1594 id.subdevice = 0; 1595 else if (id.subdevice < INT_MAX) 1596 id.subdevice++; 1597 } 1598 } 1599 list_for_each(p, &snd_timer_list) { 1600 timer = list_entry(p, struct snd_timer, device_list); 1601 if (timer->tmr_class > id.dev_class) { 1602 snd_timer_user_copy_id(&id, timer); 1603 break; 1604 } 1605 if (timer->tmr_class < id.dev_class) 1606 continue; 1607 if (timer->card->number > id.card) { 1608 snd_timer_user_copy_id(&id, timer); 1609 break; 1610 } 1611 if (timer->card->number < id.card) 1612 continue; 1613 if (timer->tmr_device > id.device) { 1614 snd_timer_user_copy_id(&id, timer); 1615 break; 1616 } 1617 if (timer->tmr_device < id.device) 1618 continue; 1619 if (timer->tmr_subdevice > id.subdevice) { 1620 snd_timer_user_copy_id(&id, timer); 1621 break; 1622 } 1623 if (timer->tmr_subdevice < id.subdevice) 1624 continue; 1625 snd_timer_user_copy_id(&id, timer); 1626 break; 1627 } 1628 if (p == &snd_timer_list) 1629 snd_timer_user_zero_id(&id); 1630 break; 1631 default: 1632 snd_timer_user_zero_id(&id); 1633 } 1634 } 1635 mutex_unlock(®ister_mutex); 1636 if (copy_to_user(_tid, &id, sizeof(*_tid))) 1637 return -EFAULT; 1638 return 0; 1639} 1640 1641static int snd_timer_user_ginfo(struct file *file, 1642 struct snd_timer_ginfo __user *_ginfo) 1643{ 1644 struct snd_timer_ginfo *ginfo; 1645 struct snd_timer_id tid; 1646 struct snd_timer *t; 1647 struct list_head *p; 1648 int err = 0; 1649 1650 ginfo = memdup_user(_ginfo, sizeof(*ginfo)); 1651 if (IS_ERR(ginfo)) 1652 return PTR_ERR(ginfo); 1653 1654 tid = ginfo->tid; 1655 memset(ginfo, 0, sizeof(*ginfo)); 1656 ginfo->tid = tid; 1657 mutex_lock(®ister_mutex); 1658 t = snd_timer_find(&tid); 1659 if (t != NULL) { 1660 ginfo->card = t->card ? t->card->number : -1; 1661 if (t->hw.flags & SNDRV_TIMER_HW_SLAVE) 1662 ginfo->flags |= SNDRV_TIMER_FLG_SLAVE; 1663 strlcpy(ginfo->id, t->id, sizeof(ginfo->id)); 1664 strlcpy(ginfo->name, t->name, sizeof(ginfo->name)); 1665 ginfo->resolution = t->hw.resolution; 1666 if (t->hw.resolution_min > 0) { 1667 ginfo->resolution_min = t->hw.resolution_min; 1668 ginfo->resolution_max = t->hw.resolution_max; 1669 } 1670 list_for_each(p, &t->open_list_head) { 1671 ginfo->clients++; 1672 } 1673 } else { 1674 err = -ENODEV; 1675 } 1676 mutex_unlock(®ister_mutex); 1677 if (err >= 0 && copy_to_user(_ginfo, ginfo, sizeof(*ginfo))) 1678 err = -EFAULT; 1679 kfree(ginfo); 1680 return err; 1681} 1682 1683static int timer_set_gparams(struct snd_timer_gparams *gparams) 1684{ 1685 struct snd_timer *t; 1686 int err; 1687 1688 mutex_lock(®ister_mutex); 1689 t = snd_timer_find(&gparams->tid); 1690 if (!t) { 1691 err = -ENODEV; 1692 goto _error; 1693 } 1694 if (!list_empty(&t->open_list_head)) { 1695 err = -EBUSY; 1696 goto _error; 1697 } 1698 if (!t->hw.set_period) { 1699 err = -ENOSYS; 1700 goto _error; 1701 } 1702 err = t->hw.set_period(t, gparams->period_num, gparams->period_den); 1703_error: 1704 mutex_unlock(®ister_mutex); 1705 return err; 1706} 1707 1708static int snd_timer_user_gparams(struct file *file, 1709 struct snd_timer_gparams __user *_gparams) 1710{ 1711 struct snd_timer_gparams gparams; 1712 1713 if (copy_from_user(&gparams, _gparams, sizeof(gparams))) 1714 return -EFAULT; 1715 return timer_set_gparams(&gparams); 1716} 1717 1718static int snd_timer_user_gstatus(struct file *file, 1719 struct snd_timer_gstatus __user *_gstatus) 1720{ 1721 struct snd_timer_gstatus gstatus; 1722 struct snd_timer_id tid; 1723 struct snd_timer *t; 1724 int err = 0; 1725 1726 if (copy_from_user(&gstatus, _gstatus, sizeof(gstatus))) 1727 return -EFAULT; 1728 tid = gstatus.tid; 1729 memset(&gstatus, 0, sizeof(gstatus)); 1730 gstatus.tid = tid; 1731 mutex_lock(®ister_mutex); 1732 t = snd_timer_find(&tid); 1733 if (t != NULL) { 1734 spin_lock_irq(&t->lock); 1735 gstatus.resolution = snd_timer_hw_resolution(t); 1736 if (t->hw.precise_resolution) { 1737 t->hw.precise_resolution(t, &gstatus.resolution_num, 1738 &gstatus.resolution_den); 1739 } else { 1740 gstatus.resolution_num = gstatus.resolution; 1741 gstatus.resolution_den = 1000000000uL; 1742 } 1743 spin_unlock_irq(&t->lock); 1744 } else { 1745 err = -ENODEV; 1746 } 1747 mutex_unlock(®ister_mutex); 1748 if (err >= 0 && copy_to_user(_gstatus, &gstatus, sizeof(gstatus))) 1749 err = -EFAULT; 1750 return err; 1751} 1752 1753static int snd_timer_user_tselect(struct file *file, 1754 struct snd_timer_select __user *_tselect) 1755{ 1756 struct snd_timer_user *tu; 1757 struct snd_timer_select tselect; 1758 char str[32]; 1759 int err = 0; 1760 1761 tu = file->private_data; 1762 if (tu->timeri) { 1763 snd_timer_close(tu->timeri); 1764 snd_timer_instance_free(tu->timeri); 1765 tu->timeri = NULL; 1766 } 1767 if (copy_from_user(&tselect, _tselect, sizeof(tselect))) { 1768 err = -EFAULT; 1769 goto __err; 1770 } 1771 sprintf(str, "application %i", current->pid); 1772 if (tselect.id.dev_class != SNDRV_TIMER_CLASS_SLAVE) 1773 tselect.id.dev_sclass = SNDRV_TIMER_SCLASS_APPLICATION; 1774 tu->timeri = snd_timer_instance_new(str); 1775 if (!tu->timeri) { 1776 err = -ENOMEM; 1777 goto __err; 1778 } 1779 1780 tu->timeri->flags |= SNDRV_TIMER_IFLG_FAST; 1781 tu->timeri->callback = tu->tread 1782 ? snd_timer_user_tinterrupt : snd_timer_user_interrupt; 1783 tu->timeri->ccallback = snd_timer_user_ccallback; 1784 tu->timeri->callback_data = (void *)tu; 1785 tu->timeri->disconnect = snd_timer_user_disconnect; 1786 1787 err = snd_timer_open(tu->timeri, &tselect.id, current->pid); 1788 if (err < 0) { 1789 snd_timer_instance_free(tu->timeri); 1790 tu->timeri = NULL; 1791 } 1792 1793 __err: 1794 return err; 1795} 1796 1797static int snd_timer_user_info(struct file *file, 1798 struct snd_timer_info __user *_info) 1799{ 1800 struct snd_timer_user *tu; 1801 struct snd_timer_info *info; 1802 struct snd_timer *t; 1803 int err = 0; 1804 1805 tu = file->private_data; 1806 if (!tu->timeri) 1807 return -EBADFD; 1808 t = tu->timeri->timer; 1809 if (!t) 1810 return -EBADFD; 1811 1812 info = kzalloc(sizeof(*info), GFP_KERNEL); 1813 if (! info) 1814 return -ENOMEM; 1815 info->card = t->card ? t->card->number : -1; 1816 if (t->hw.flags & SNDRV_TIMER_HW_SLAVE) 1817 info->flags |= SNDRV_TIMER_FLG_SLAVE; 1818 strlcpy(info->id, t->id, sizeof(info->id)); 1819 strlcpy(info->name, t->name, sizeof(info->name)); 1820 info->resolution = t->hw.resolution; 1821 if (copy_to_user(_info, info, sizeof(*_info))) 1822 err = -EFAULT; 1823 kfree(info); 1824 return err; 1825} 1826 1827static int snd_timer_user_params(struct file *file, 1828 struct snd_timer_params __user *_params) 1829{ 1830 struct snd_timer_user *tu; 1831 struct snd_timer_params params; 1832 struct snd_timer *t; 1833 int err; 1834 1835 tu = file->private_data; 1836 if (!tu->timeri) 1837 return -EBADFD; 1838 t = tu->timeri->timer; 1839 if (!t) 1840 return -EBADFD; 1841 if (copy_from_user(¶ms, _params, sizeof(params))) 1842 return -EFAULT; 1843 if (!(t->hw.flags & SNDRV_TIMER_HW_SLAVE)) { 1844 u64 resolution; 1845 1846 if (params.ticks < 1) { 1847 err = -EINVAL; 1848 goto _end; 1849 } 1850 1851 /* Don't allow resolution less than 1ms */ 1852 resolution = snd_timer_resolution(tu->timeri); 1853 resolution *= params.ticks; 1854 if (resolution < 1000000) { 1855 err = -EINVAL; 1856 goto _end; 1857 } 1858 } 1859 if (params.queue_size > 0 && 1860 (params.queue_size < 32 || params.queue_size > 1024)) { 1861 err = -EINVAL; 1862 goto _end; 1863 } 1864 if (params.filter & ~((1<<SNDRV_TIMER_EVENT_RESOLUTION)| 1865 (1<<SNDRV_TIMER_EVENT_TICK)| 1866 (1<<SNDRV_TIMER_EVENT_START)| 1867 (1<<SNDRV_TIMER_EVENT_STOP)| 1868 (1<<SNDRV_TIMER_EVENT_CONTINUE)| 1869 (1<<SNDRV_TIMER_EVENT_PAUSE)| 1870 (1<<SNDRV_TIMER_EVENT_SUSPEND)| 1871 (1<<SNDRV_TIMER_EVENT_RESUME)| 1872 (1<<SNDRV_TIMER_EVENT_MSTART)| 1873 (1<<SNDRV_TIMER_EVENT_MSTOP)| 1874 (1<<SNDRV_TIMER_EVENT_MCONTINUE)| 1875 (1<<SNDRV_TIMER_EVENT_MPAUSE)| 1876 (1<<SNDRV_TIMER_EVENT_MSUSPEND)| 1877 (1<<SNDRV_TIMER_EVENT_MRESUME))) { 1878 err = -EINVAL; 1879 goto _end; 1880 } 1881 snd_timer_stop(tu->timeri); 1882 spin_lock_irq(&t->lock); 1883 tu->timeri->flags &= ~(SNDRV_TIMER_IFLG_AUTO| 1884 SNDRV_TIMER_IFLG_EXCLUSIVE| 1885 SNDRV_TIMER_IFLG_EARLY_EVENT); 1886 if (params.flags & SNDRV_TIMER_PSFLG_AUTO) 1887 tu->timeri->flags |= SNDRV_TIMER_IFLG_AUTO; 1888 if (params.flags & SNDRV_TIMER_PSFLG_EXCLUSIVE) 1889 tu->timeri->flags |= SNDRV_TIMER_IFLG_EXCLUSIVE; 1890 if (params.flags & SNDRV_TIMER_PSFLG_EARLY_EVENT) 1891 tu->timeri->flags |= SNDRV_TIMER_IFLG_EARLY_EVENT; 1892 spin_unlock_irq(&t->lock); 1893 if (params.queue_size > 0 && 1894 (unsigned int)tu->queue_size != params.queue_size) { 1895 err = realloc_user_queue(tu, params.queue_size); 1896 if (err < 0) 1897 goto _end; 1898 } 1899 spin_lock_irq(&tu->qlock); 1900 tu->qhead = tu->qtail = tu->qused = 0; 1901 if (tu->timeri->flags & SNDRV_TIMER_IFLG_EARLY_EVENT) { 1902 if (tu->tread) { 1903 struct snd_timer_tread64 tread; 1904 memset(&tread, 0, sizeof(tread)); 1905 tread.event = SNDRV_TIMER_EVENT_EARLY; 1906 tread.tstamp_sec = 0; 1907 tread.tstamp_nsec = 0; 1908 tread.val = 0; 1909 snd_timer_user_append_to_tqueue(tu, &tread); 1910 } else { 1911 struct snd_timer_read *r = &tu->queue[0]; 1912 r->resolution = 0; 1913 r->ticks = 0; 1914 tu->qused++; 1915 tu->qtail++; 1916 } 1917 } 1918 tu->filter = params.filter; 1919 tu->ticks = params.ticks; 1920 spin_unlock_irq(&tu->qlock); 1921 err = 0; 1922 _end: 1923 if (copy_to_user(_params, ¶ms, sizeof(params))) 1924 return -EFAULT; 1925 return err; 1926} 1927 1928static int snd_timer_user_status32(struct file *file, 1929 struct snd_timer_status32 __user *_status) 1930 { 1931 struct snd_timer_user *tu; 1932 struct snd_timer_status32 status; 1933 1934 tu = file->private_data; 1935 if (!tu->timeri) 1936 return -EBADFD; 1937 memset(&status, 0, sizeof(status)); 1938 status.tstamp_sec = tu->tstamp.tv_sec; 1939 status.tstamp_nsec = tu->tstamp.tv_nsec; 1940 status.resolution = snd_timer_resolution(tu->timeri); 1941 status.lost = tu->timeri->lost; 1942 status.overrun = tu->overrun; 1943 spin_lock_irq(&tu->qlock); 1944 status.queue = tu->qused; 1945 spin_unlock_irq(&tu->qlock); 1946 if (copy_to_user(_status, &status, sizeof(status))) 1947 return -EFAULT; 1948 return 0; 1949} 1950 1951static int snd_timer_user_status64(struct file *file, 1952 struct snd_timer_status64 __user *_status) 1953{ 1954 struct snd_timer_user *tu; 1955 struct snd_timer_status64 status; 1956 1957 tu = file->private_data; 1958 if (!tu->timeri) 1959 return -EBADFD; 1960 memset(&status, 0, sizeof(status)); 1961 status.tstamp_sec = tu->tstamp.tv_sec; 1962 status.tstamp_nsec = tu->tstamp.tv_nsec; 1963 status.resolution = snd_timer_resolution(tu->timeri); 1964 status.lost = tu->timeri->lost; 1965 status.overrun = tu->overrun; 1966 spin_lock_irq(&tu->qlock); 1967 status.queue = tu->qused; 1968 spin_unlock_irq(&tu->qlock); 1969 if (copy_to_user(_status, &status, sizeof(status))) 1970 return -EFAULT; 1971 return 0; 1972} 1973 1974static int snd_timer_user_start(struct file *file) 1975{ 1976 int err; 1977 struct snd_timer_user *tu; 1978 1979 tu = file->private_data; 1980 if (!tu->timeri) 1981 return -EBADFD; 1982 snd_timer_stop(tu->timeri); 1983 tu->timeri->lost = 0; 1984 tu->last_resolution = 0; 1985 err = snd_timer_start(tu->timeri, tu->ticks); 1986 if (err < 0) 1987 return err; 1988 return 0; 1989} 1990 1991static int snd_timer_user_stop(struct file *file) 1992{ 1993 int err; 1994 struct snd_timer_user *tu; 1995 1996 tu = file->private_data; 1997 if (!tu->timeri) 1998 return -EBADFD; 1999 err = snd_timer_stop(tu->timeri); 2000 if (err < 0) 2001 return err; 2002 return 0; 2003} 2004 2005static int snd_timer_user_continue(struct file *file) 2006{ 2007 int err; 2008 struct snd_timer_user *tu; 2009 2010 tu = file->private_data; 2011 if (!tu->timeri) 2012 return -EBADFD; 2013 /* start timer instead of continue if it's not used before */ 2014 if (!(tu->timeri->flags & SNDRV_TIMER_IFLG_PAUSED)) 2015 return snd_timer_user_start(file); 2016 tu->timeri->lost = 0; 2017 err = snd_timer_continue(tu->timeri); 2018 if (err < 0) 2019 return err; 2020 return 0; 2021} 2022 2023static int snd_timer_user_pause(struct file *file) 2024{ 2025 int err; 2026 struct snd_timer_user *tu; 2027 2028 tu = file->private_data; 2029 if (!tu->timeri) 2030 return -EBADFD; 2031 err = snd_timer_pause(tu->timeri); 2032 if (err < 0) 2033 return err; 2034 return 0; 2035} 2036 2037static int snd_timer_user_tread(void __user *argp, struct snd_timer_user *tu, 2038 unsigned int cmd, bool compat) 2039{ 2040 int __user *p = argp; 2041 int xarg, old_tread; 2042 2043 if (tu->timeri) /* too late */ 2044 return -EBUSY; 2045 if (get_user(xarg, p)) 2046 return -EFAULT; 2047 2048 old_tread = tu->tread; 2049 2050 if (!xarg) 2051 tu->tread = TREAD_FORMAT_NONE; 2052 else if (cmd == SNDRV_TIMER_IOCTL_TREAD64 || 2053 (IS_ENABLED(CONFIG_64BIT) && !compat)) 2054 tu->tread = TREAD_FORMAT_TIME64; 2055 else 2056 tu->tread = TREAD_FORMAT_TIME32; 2057 2058 if (tu->tread != old_tread && 2059 realloc_user_queue(tu, tu->queue_size) < 0) { 2060 tu->tread = old_tread; 2061 return -ENOMEM; 2062 } 2063 2064 return 0; 2065} 2066 2067enum { 2068 SNDRV_TIMER_IOCTL_START_OLD = _IO('T', 0x20), 2069 SNDRV_TIMER_IOCTL_STOP_OLD = _IO('T', 0x21), 2070 SNDRV_TIMER_IOCTL_CONTINUE_OLD = _IO('T', 0x22), 2071 SNDRV_TIMER_IOCTL_PAUSE_OLD = _IO('T', 0x23), 2072}; 2073 2074static long __snd_timer_user_ioctl(struct file *file, unsigned int cmd, 2075 unsigned long arg, bool compat) 2076{ 2077 struct snd_timer_user *tu; 2078 void __user *argp = (void __user *)arg; 2079 int __user *p = argp; 2080 2081 tu = file->private_data; 2082 switch (cmd) { 2083 case SNDRV_TIMER_IOCTL_PVERSION: 2084 return put_user(SNDRV_TIMER_VERSION, p) ? -EFAULT : 0; 2085 case SNDRV_TIMER_IOCTL_NEXT_DEVICE: 2086 return snd_timer_user_next_device(argp); 2087 case SNDRV_TIMER_IOCTL_TREAD_OLD: 2088 case SNDRV_TIMER_IOCTL_TREAD64: 2089 return snd_timer_user_tread(argp, tu, cmd, compat); 2090 case SNDRV_TIMER_IOCTL_GINFO: 2091 return snd_timer_user_ginfo(file, argp); 2092 case SNDRV_TIMER_IOCTL_GPARAMS: 2093 return snd_timer_user_gparams(file, argp); 2094 case SNDRV_TIMER_IOCTL_GSTATUS: 2095 return snd_timer_user_gstatus(file, argp); 2096 case SNDRV_TIMER_IOCTL_SELECT: 2097 return snd_timer_user_tselect(file, argp); 2098 case SNDRV_TIMER_IOCTL_INFO: 2099 return snd_timer_user_info(file, argp); 2100 case SNDRV_TIMER_IOCTL_PARAMS: 2101 return snd_timer_user_params(file, argp); 2102 case SNDRV_TIMER_IOCTL_STATUS32: 2103 return snd_timer_user_status32(file, argp); 2104 case SNDRV_TIMER_IOCTL_STATUS64: 2105 return snd_timer_user_status64(file, argp); 2106 case SNDRV_TIMER_IOCTL_START: 2107 case SNDRV_TIMER_IOCTL_START_OLD: 2108 return snd_timer_user_start(file); 2109 case SNDRV_TIMER_IOCTL_STOP: 2110 case SNDRV_TIMER_IOCTL_STOP_OLD: 2111 return snd_timer_user_stop(file); 2112 case SNDRV_TIMER_IOCTL_CONTINUE: 2113 case SNDRV_TIMER_IOCTL_CONTINUE_OLD: 2114 return snd_timer_user_continue(file); 2115 case SNDRV_TIMER_IOCTL_PAUSE: 2116 case SNDRV_TIMER_IOCTL_PAUSE_OLD: 2117 return snd_timer_user_pause(file); 2118 } 2119 return -ENOTTY; 2120} 2121 2122static long snd_timer_user_ioctl(struct file *file, unsigned int cmd, 2123 unsigned long arg) 2124{ 2125 struct snd_timer_user *tu = file->private_data; 2126 long ret; 2127 2128 mutex_lock(&tu->ioctl_lock); 2129 ret = __snd_timer_user_ioctl(file, cmd, arg, false); 2130 mutex_unlock(&tu->ioctl_lock); 2131 return ret; 2132} 2133 2134static int snd_timer_user_fasync(int fd, struct file * file, int on) 2135{ 2136 struct snd_timer_user *tu; 2137 2138 tu = file->private_data; 2139 return snd_fasync_helper(fd, file, on, &tu->fasync); 2140} 2141 2142static ssize_t snd_timer_user_read(struct file *file, char __user *buffer, 2143 size_t count, loff_t *offset) 2144{ 2145 struct snd_timer_tread64 *tread; 2146 struct snd_timer_tread32 tread32; 2147 struct snd_timer_user *tu; 2148 long result = 0, unit; 2149 int qhead; 2150 int err = 0; 2151 2152 tu = file->private_data; 2153 switch (tu->tread) { 2154 case TREAD_FORMAT_TIME64: 2155 unit = sizeof(struct snd_timer_tread64); 2156 break; 2157 case TREAD_FORMAT_TIME32: 2158 unit = sizeof(struct snd_timer_tread32); 2159 break; 2160 case TREAD_FORMAT_NONE: 2161 unit = sizeof(struct snd_timer_read); 2162 break; 2163 default: 2164 WARN_ONCE(1, "Corrupt snd_timer_user\n"); 2165 return -ENOTSUPP; 2166 } 2167 2168 mutex_lock(&tu->ioctl_lock); 2169 spin_lock_irq(&tu->qlock); 2170 while ((long)count - result >= unit) { 2171 while (!tu->qused) { 2172 wait_queue_entry_t wait; 2173 2174 if ((file->f_flags & O_NONBLOCK) != 0 || result > 0) { 2175 err = -EAGAIN; 2176 goto _error; 2177 } 2178 2179 set_current_state(TASK_INTERRUPTIBLE); 2180 init_waitqueue_entry(&wait, current); 2181 add_wait_queue(&tu->qchange_sleep, &wait); 2182 2183 spin_unlock_irq(&tu->qlock); 2184 mutex_unlock(&tu->ioctl_lock); 2185 schedule(); 2186 mutex_lock(&tu->ioctl_lock); 2187 spin_lock_irq(&tu->qlock); 2188 2189 remove_wait_queue(&tu->qchange_sleep, &wait); 2190 2191 if (tu->disconnected) { 2192 err = -ENODEV; 2193 goto _error; 2194 } 2195 if (signal_pending(current)) { 2196 err = -ERESTARTSYS; 2197 goto _error; 2198 } 2199 } 2200 2201 qhead = tu->qhead++; 2202 tu->qhead %= tu->queue_size; 2203 tu->qused--; 2204 spin_unlock_irq(&tu->qlock); 2205 2206 tread = &tu->tqueue[qhead]; 2207 2208 switch (tu->tread) { 2209 case TREAD_FORMAT_TIME64: 2210 if (copy_to_user(buffer, tread, 2211 sizeof(struct snd_timer_tread64))) 2212 err = -EFAULT; 2213 break; 2214 case TREAD_FORMAT_TIME32: 2215 memset(&tread32, 0, sizeof(tread32)); 2216 tread32 = (struct snd_timer_tread32) { 2217 .event = tread->event, 2218 .tstamp_sec = tread->tstamp_sec, 2219 .tstamp_nsec = tread->tstamp_nsec, 2220 .val = tread->val, 2221 }; 2222 2223 if (copy_to_user(buffer, &tread32, sizeof(tread32))) 2224 err = -EFAULT; 2225 break; 2226 case TREAD_FORMAT_NONE: 2227 if (copy_to_user(buffer, &tu->queue[qhead], 2228 sizeof(struct snd_timer_read))) 2229 err = -EFAULT; 2230 break; 2231 default: 2232 err = -ENOTSUPP; 2233 break; 2234 } 2235 2236 spin_lock_irq(&tu->qlock); 2237 if (err < 0) 2238 goto _error; 2239 result += unit; 2240 buffer += unit; 2241 } 2242 _error: 2243 spin_unlock_irq(&tu->qlock); 2244 mutex_unlock(&tu->ioctl_lock); 2245 return result > 0 ? result : err; 2246} 2247 2248static __poll_t snd_timer_user_poll(struct file *file, poll_table * wait) 2249{ 2250 __poll_t mask; 2251 struct snd_timer_user *tu; 2252 2253 tu = file->private_data; 2254 2255 poll_wait(file, &tu->qchange_sleep, wait); 2256 2257 mask = 0; 2258 spin_lock_irq(&tu->qlock); 2259 if (tu->qused) 2260 mask |= EPOLLIN | EPOLLRDNORM; 2261 if (tu->disconnected) 2262 mask |= EPOLLERR; 2263 spin_unlock_irq(&tu->qlock); 2264 2265 return mask; 2266} 2267 2268#ifdef CONFIG_COMPAT 2269#include "timer_compat.c" 2270#else 2271#define snd_timer_user_ioctl_compat NULL 2272#endif 2273 2274static const struct file_operations snd_timer_f_ops = 2275{ 2276 .owner = THIS_MODULE, 2277 .read = snd_timer_user_read, 2278 .open = snd_timer_user_open, 2279 .release = snd_timer_user_release, 2280 .llseek = no_llseek, 2281 .poll = snd_timer_user_poll, 2282 .unlocked_ioctl = snd_timer_user_ioctl, 2283 .compat_ioctl = snd_timer_user_ioctl_compat, 2284 .fasync = snd_timer_user_fasync, 2285}; 2286 2287/* unregister the system timer */ 2288static void snd_timer_free_all(void) 2289{ 2290 struct snd_timer *timer, *n; 2291 2292 list_for_each_entry_safe(timer, n, &snd_timer_list, device_list) 2293 snd_timer_free(timer); 2294} 2295 2296static struct device timer_dev; 2297 2298/* 2299 * ENTRY functions 2300 */ 2301 2302static int __init alsa_timer_init(void) 2303{ 2304 int err; 2305 2306 snd_device_initialize(&timer_dev, NULL); 2307 dev_set_name(&timer_dev, "timer"); 2308 2309#ifdef SNDRV_OSS_INFO_DEV_TIMERS 2310 snd_oss_info_register(SNDRV_OSS_INFO_DEV_TIMERS, SNDRV_CARDS - 1, 2311 "system timer"); 2312#endif 2313 2314 err = snd_timer_register_system(); 2315 if (err < 0) { 2316 pr_err("ALSA: unable to register system timer (%i)\n", err); 2317 goto put_timer; 2318 } 2319 2320 err = snd_register_device(SNDRV_DEVICE_TYPE_TIMER, NULL, 0, 2321 &snd_timer_f_ops, NULL, &timer_dev); 2322 if (err < 0) { 2323 pr_err("ALSA: unable to register timer device (%i)\n", err); 2324 snd_timer_free_all(); 2325 goto put_timer; 2326 } 2327 2328 snd_timer_proc_init(); 2329 return 0; 2330 2331put_timer: 2332 put_device(&timer_dev); 2333 return err; 2334} 2335 2336static void __exit alsa_timer_exit(void) 2337{ 2338 snd_unregister_device(&timer_dev); 2339 snd_timer_free_all(); 2340 put_device(&timer_dev); 2341 snd_timer_proc_done(); 2342#ifdef SNDRV_OSS_INFO_DEV_TIMERS 2343 snd_oss_info_unregister(SNDRV_OSS_INFO_DEV_TIMERS, SNDRV_CARDS - 1); 2344#endif 2345} 2346 2347module_init(alsa_timer_init) 2348module_exit(alsa_timer_exit) 2349