1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * ALSA sequencer Timing queue handling 4 * Copyright (c) 1998-1999 by Frank van de Pol <fvdpol@coil.demon.nl> 5 * 6 * MAJOR CHANGES 7 * Nov. 13, 1999 Takashi Iwai <iwai@ww.uni-erlangen.de> 8 * - Queues are allocated dynamically via ioctl. 9 * - When owner client is deleted, all owned queues are deleted, too. 10 * - Owner of unlocked queue is kept unmodified even if it is 11 * manipulated by other clients. 12 * - Owner field in SET_QUEUE_OWNER ioctl must be identical with the 13 * caller client. i.e. Changing owner to a third client is not 14 * allowed. 15 * 16 * Aug. 30, 2000 Takashi Iwai 17 * - Queues are managed in static array again, but with better way. 18 * The API itself is identical. 19 * - The queue is locked when struct snd_seq_queue pointer is returned via 20 * queueptr(). This pointer *MUST* be released afterward by 21 * queuefree(ptr). 22 * - Addition of experimental sync support. 23 */ 24 25 #include <linux/init.h> 26 #include <linux/slab.h> 27 #include <sound/core.h> 28 29 #include "seq_memory.h" 30 #include "seq_queue.h" 31 #include "seq_clientmgr.h" 32 #include "seq_fifo.h" 33 #include "seq_timer.h" 34 #include "seq_info.h" 35 36 /* list of allocated queues */ 37 static struct snd_seq_queue *queue_list[SNDRV_SEQ_MAX_QUEUES]; 38 static DEFINE_SPINLOCK(queue_list_lock); 39 /* number of queues allocated */ 40 static int num_queues; 41 42 int snd_seq_queue_get_cur_queues(void) 43 { 44 return num_queues; 45 } 46 47 /*----------------------------------------------------------------*/ 48 49 /* assign queue id and insert to list */ 50 static int queue_list_add(struct snd_seq_queue *q) 51 { 52 int i; 53 unsigned long flags; 54 55 spin_lock_irqsave(&queue_list_lock, flags); 56 for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) { 57 if (! queue_list[i]) { 58 queue_list[i] = q; 59 q->queue = i; 60 num_queues++; 61 spin_unlock_irqrestore(&queue_list_lock, flags); 62 return i; 63 } 64 } 65 spin_unlock_irqrestore(&queue_list_lock, flags); 66 return -1; 67 } 68 69 static struct snd_seq_queue *queue_list_remove(int id, int client) 70 { 71 struct snd_seq_queue *q; 72 unsigned long flags; 73 74 spin_lock_irqsave(&queue_list_lock, flags); 75 q = queue_list[id]; 76 if (q) { 77 spin_lock(&q->owner_lock); 78 if (q->owner == client) { 79 /* found */ 80 q->klocked = 1; 81 spin_unlock(&q->owner_lock); 82 queue_list[id] = NULL; 83 num_queues--; 84 spin_unlock_irqrestore(&queue_list_lock, flags); 85 return q; 86 } 87 spin_unlock(&q->owner_lock); 88 } 89 spin_unlock_irqrestore(&queue_list_lock, flags); 90 return NULL; 91 } 92 93 /*----------------------------------------------------------------*/ 94 95 /* create new queue (constructor) */ 96 static struct snd_seq_queue *queue_new(int owner, int locked) 97 { 98 struct snd_seq_queue *q; 99 100 q = kzalloc(sizeof(*q), GFP_KERNEL); 101 if (!q) 102 return NULL; 103 104 spin_lock_init(&q->owner_lock); 105 spin_lock_init(&q->check_lock); 106 mutex_init(&q->timer_mutex); 107 snd_use_lock_init(&q->use_lock); 108 q->queue = -1; 109 110 q->tickq = snd_seq_prioq_new(); 111 q->timeq = snd_seq_prioq_new(); 112 q->timer = snd_seq_timer_new(); 113 if (q->tickq == NULL || q->timeq == NULL || q->timer == NULL) { 114 snd_seq_prioq_delete(&q->tickq); 115 snd_seq_prioq_delete(&q->timeq); 116 snd_seq_timer_delete(&q->timer); 117 kfree(q); 118 return NULL; 119 } 120 121 q->owner = owner; 122 q->locked = locked; 123 q->klocked = 0; 124 125 return q; 126 } 127 128 /* delete queue (destructor) */ 129 static void queue_delete(struct snd_seq_queue *q) 130 { 131 /* stop and release the timer */ 132 mutex_lock(&q->timer_mutex); 133 snd_seq_timer_stop(q->timer); 134 snd_seq_timer_close(q); 135 mutex_unlock(&q->timer_mutex); 136 /* wait until access free */ 137 snd_use_lock_sync(&q->use_lock); 138 /* release resources... */ 139 snd_seq_prioq_delete(&q->tickq); 140 snd_seq_prioq_delete(&q->timeq); 141 snd_seq_timer_delete(&q->timer); 142 143 kfree(q); 144 } 145 146 147 /*----------------------------------------------------------------*/ 148 149 /* delete all existing queues */ 150 void snd_seq_queues_delete(void) 151 { 152 int i; 153 154 /* clear list */ 155 for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) { 156 if (queue_list[i]) 157 queue_delete(queue_list[i]); 158 } 159 } 160 161 static void queue_use(struct snd_seq_queue *queue, int client, int use); 162 163 /* allocate a new queue - 164 * return pointer to new queue or ERR_PTR(-errno) for error 165 * The new queue's use_lock is set to 1. It is the caller's responsibility to 166 * call snd_use_lock_free(&q->use_lock). 167 */ 168 struct snd_seq_queue *snd_seq_queue_alloc(int client, int locked, unsigned int info_flags) 169 { 170 struct snd_seq_queue *q; 171 172 q = queue_new(client, locked); 173 if (q == NULL) 174 return ERR_PTR(-ENOMEM); 175 q->info_flags = info_flags; 176 queue_use(q, client, 1); 177 snd_use_lock_use(&q->use_lock); 178 if (queue_list_add(q) < 0) { 179 snd_use_lock_free(&q->use_lock); 180 queue_delete(q); 181 return ERR_PTR(-ENOMEM); 182 } 183 return q; 184 } 185 186 /* delete a queue - queue must be owned by the client */ 187 int snd_seq_queue_delete(int client, int queueid) 188 { 189 struct snd_seq_queue *q; 190 191 if (queueid < 0 || queueid >= SNDRV_SEQ_MAX_QUEUES) 192 return -EINVAL; 193 q = queue_list_remove(queueid, client); 194 if (q == NULL) 195 return -EINVAL; 196 queue_delete(q); 197 198 return 0; 199 } 200 201 202 /* return pointer to queue structure for specified id */ 203 struct snd_seq_queue *queueptr(int queueid) 204 { 205 struct snd_seq_queue *q; 206 unsigned long flags; 207 208 if (queueid < 0 || queueid >= SNDRV_SEQ_MAX_QUEUES) 209 return NULL; 210 spin_lock_irqsave(&queue_list_lock, flags); 211 q = queue_list[queueid]; 212 if (q) 213 snd_use_lock_use(&q->use_lock); 214 spin_unlock_irqrestore(&queue_list_lock, flags); 215 return q; 216 } 217 218 /* return the (first) queue matching with the specified name */ 219 struct snd_seq_queue *snd_seq_queue_find_name(char *name) 220 { 221 int i; 222 struct snd_seq_queue *q; 223 224 for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) { 225 if ((q = queueptr(i)) != NULL) { 226 if (strncmp(q->name, name, sizeof(q->name)) == 0) 227 return q; 228 queuefree(q); 229 } 230 } 231 return NULL; 232 } 233 234 235 /* -------------------------------------------------------- */ 236 237 void snd_seq_check_queue(struct snd_seq_queue *q, int atomic, int hop) 238 { 239 unsigned long flags; 240 struct snd_seq_event_cell *cell; 241 242 if (q == NULL) 243 return; 244 245 /* make this function non-reentrant */ 246 spin_lock_irqsave(&q->check_lock, flags); 247 if (q->check_blocked) { 248 q->check_again = 1; 249 spin_unlock_irqrestore(&q->check_lock, flags); 250 return; /* other thread is already checking queues */ 251 } 252 q->check_blocked = 1; 253 spin_unlock_irqrestore(&q->check_lock, flags); 254 255 __again: 256 /* Process tick queue... */ 257 for (;;) { 258 cell = snd_seq_prioq_cell_out(q->tickq, 259 &q->timer->tick.cur_tick); 260 if (!cell) 261 break; 262 snd_seq_dispatch_event(cell, atomic, hop); 263 } 264 265 /* Process time queue... */ 266 for (;;) { 267 cell = snd_seq_prioq_cell_out(q->timeq, &q->timer->cur_time); 268 if (!cell) 269 break; 270 snd_seq_dispatch_event(cell, atomic, hop); 271 } 272 273 /* free lock */ 274 spin_lock_irqsave(&q->check_lock, flags); 275 if (q->check_again) { 276 q->check_again = 0; 277 spin_unlock_irqrestore(&q->check_lock, flags); 278 goto __again; 279 } 280 q->check_blocked = 0; 281 spin_unlock_irqrestore(&q->check_lock, flags); 282 } 283 284 285 /* enqueue a event to singe queue */ 286 int snd_seq_enqueue_event(struct snd_seq_event_cell *cell, int atomic, int hop) 287 { 288 int dest, err; 289 struct snd_seq_queue *q; 290 291 if (snd_BUG_ON(!cell)) 292 return -EINVAL; 293 dest = cell->event.queue; /* destination queue */ 294 q = queueptr(dest); 295 if (q == NULL) 296 return -EINVAL; 297 /* handle relative time stamps, convert them into absolute */ 298 if ((cell->event.flags & SNDRV_SEQ_TIME_MODE_MASK) == SNDRV_SEQ_TIME_MODE_REL) { 299 switch (cell->event.flags & SNDRV_SEQ_TIME_STAMP_MASK) { 300 case SNDRV_SEQ_TIME_STAMP_TICK: 301 cell->event.time.tick += q->timer->tick.cur_tick; 302 break; 303 304 case SNDRV_SEQ_TIME_STAMP_REAL: 305 snd_seq_inc_real_time(&cell->event.time.time, 306 &q->timer->cur_time); 307 break; 308 } 309 cell->event.flags &= ~SNDRV_SEQ_TIME_MODE_MASK; 310 cell->event.flags |= SNDRV_SEQ_TIME_MODE_ABS; 311 } 312 /* enqueue event in the real-time or midi queue */ 313 switch (cell->event.flags & SNDRV_SEQ_TIME_STAMP_MASK) { 314 case SNDRV_SEQ_TIME_STAMP_TICK: 315 err = snd_seq_prioq_cell_in(q->tickq, cell); 316 break; 317 318 case SNDRV_SEQ_TIME_STAMP_REAL: 319 default: 320 err = snd_seq_prioq_cell_in(q->timeq, cell); 321 break; 322 } 323 324 if (err < 0) { 325 queuefree(q); /* unlock */ 326 return err; 327 } 328 329 /* trigger dispatching */ 330 snd_seq_check_queue(q, atomic, hop); 331 332 queuefree(q); /* unlock */ 333 334 return 0; 335 } 336 337 338 /*----------------------------------------------------------------*/ 339 340 static inline int check_access(struct snd_seq_queue *q, int client) 341 { 342 return (q->owner == client) || (!q->locked && !q->klocked); 343 } 344 345 /* check if the client has permission to modify queue parameters. 346 * if it does, lock the queue 347 */ 348 static int queue_access_lock(struct snd_seq_queue *q, int client) 349 { 350 unsigned long flags; 351 int access_ok; 352 353 spin_lock_irqsave(&q->owner_lock, flags); 354 access_ok = check_access(q, client); 355 if (access_ok) 356 q->klocked = 1; 357 spin_unlock_irqrestore(&q->owner_lock, flags); 358 return access_ok; 359 } 360 361 /* unlock the queue */ 362 static inline void queue_access_unlock(struct snd_seq_queue *q) 363 { 364 unsigned long flags; 365 366 spin_lock_irqsave(&q->owner_lock, flags); 367 q->klocked = 0; 368 spin_unlock_irqrestore(&q->owner_lock, flags); 369 } 370 371 /* exported - only checking permission */ 372 int snd_seq_queue_check_access(int queueid, int client) 373 { 374 struct snd_seq_queue *q = queueptr(queueid); 375 int access_ok; 376 unsigned long flags; 377 378 if (! q) 379 return 0; 380 spin_lock_irqsave(&q->owner_lock, flags); 381 access_ok = check_access(q, client); 382 spin_unlock_irqrestore(&q->owner_lock, flags); 383 queuefree(q); 384 return access_ok; 385 } 386 387 /*----------------------------------------------------------------*/ 388 389 /* 390 * change queue's owner and permission 391 */ 392 int snd_seq_queue_set_owner(int queueid, int client, int locked) 393 { 394 struct snd_seq_queue *q = queueptr(queueid); 395 396 if (q == NULL) 397 return -EINVAL; 398 399 if (! queue_access_lock(q, client)) { 400 queuefree(q); 401 return -EPERM; 402 } 403 404 q->locked = locked ? 1 : 0; 405 q->owner = client; 406 queue_access_unlock(q); 407 queuefree(q); 408 409 return 0; 410 } 411 412 413 /*----------------------------------------------------------------*/ 414 415 /* open timer - 416 * q->use mutex should be down before calling this function to avoid 417 * confliction with snd_seq_queue_use() 418 */ 419 int snd_seq_queue_timer_open(int queueid) 420 { 421 int result = 0; 422 struct snd_seq_queue *queue; 423 struct snd_seq_timer *tmr; 424 425 queue = queueptr(queueid); 426 if (queue == NULL) 427 return -EINVAL; 428 tmr = queue->timer; 429 if ((result = snd_seq_timer_open(queue)) < 0) { 430 snd_seq_timer_defaults(tmr); 431 result = snd_seq_timer_open(queue); 432 } 433 queuefree(queue); 434 return result; 435 } 436 437 /* close timer - 438 * q->use mutex should be down before calling this function 439 */ 440 int snd_seq_queue_timer_close(int queueid) 441 { 442 struct snd_seq_queue *queue; 443 int result = 0; 444 445 queue = queueptr(queueid); 446 if (queue == NULL) 447 return -EINVAL; 448 snd_seq_timer_close(queue); 449 queuefree(queue); 450 return result; 451 } 452 453 /* change queue tempo and ppq */ 454 int snd_seq_queue_timer_set_tempo(int queueid, int client, 455 struct snd_seq_queue_tempo *info) 456 { 457 struct snd_seq_queue *q = queueptr(queueid); 458 int result; 459 460 if (q == NULL) 461 return -EINVAL; 462 if (! queue_access_lock(q, client)) { 463 queuefree(q); 464 return -EPERM; 465 } 466 467 result = snd_seq_timer_set_tempo_ppq(q->timer, info->tempo, info->ppq); 468 if (result >= 0 && info->skew_base > 0) 469 result = snd_seq_timer_set_skew(q->timer, info->skew_value, 470 info->skew_base); 471 queue_access_unlock(q); 472 queuefree(q); 473 return result; 474 } 475 476 /* use or unuse this queue */ 477 static void queue_use(struct snd_seq_queue *queue, int client, int use) 478 { 479 if (use) { 480 if (!test_and_set_bit(client, queue->clients_bitmap)) 481 queue->clients++; 482 } else { 483 if (test_and_clear_bit(client, queue->clients_bitmap)) 484 queue->clients--; 485 } 486 if (queue->clients) { 487 if (use && queue->clients == 1) 488 snd_seq_timer_defaults(queue->timer); 489 snd_seq_timer_open(queue); 490 } else { 491 snd_seq_timer_close(queue); 492 } 493 } 494 495 /* use or unuse this queue - 496 * if it is the first client, starts the timer. 497 * if it is not longer used by any clients, stop the timer. 498 */ 499 int snd_seq_queue_use(int queueid, int client, int use) 500 { 501 struct snd_seq_queue *queue; 502 503 queue = queueptr(queueid); 504 if (queue == NULL) 505 return -EINVAL; 506 mutex_lock(&queue->timer_mutex); 507 queue_use(queue, client, use); 508 mutex_unlock(&queue->timer_mutex); 509 queuefree(queue); 510 return 0; 511 } 512 513 /* 514 * check if queue is used by the client 515 * return negative value if the queue is invalid. 516 * return 0 if not used, 1 if used. 517 */ 518 int snd_seq_queue_is_used(int queueid, int client) 519 { 520 struct snd_seq_queue *q; 521 int result; 522 523 q = queueptr(queueid); 524 if (q == NULL) 525 return -EINVAL; /* invalid queue */ 526 result = test_bit(client, q->clients_bitmap) ? 1 : 0; 527 queuefree(q); 528 return result; 529 } 530 531 532 /*----------------------------------------------------------------*/ 533 534 /* notification that client has left the system - 535 * stop the timer on all queues owned by this client 536 */ 537 void snd_seq_queue_client_termination(int client) 538 { 539 unsigned long flags; 540 int i; 541 struct snd_seq_queue *q; 542 543 for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) { 544 if ((q = queueptr(i)) == NULL) 545 continue; 546 spin_lock_irqsave(&q->owner_lock, flags); 547 if (q->owner == client) 548 q->klocked = 1; 549 spin_unlock_irqrestore(&q->owner_lock, flags); 550 if (q->owner == client) { 551 if (q->timer->running) 552 snd_seq_timer_stop(q->timer); 553 snd_seq_timer_reset(q->timer); 554 } 555 queuefree(q); 556 } 557 } 558 559 /* final stage notification - 560 * remove cells for no longer exist client (for non-owned queue) 561 * or delete this queue (for owned queue) 562 */ 563 void snd_seq_queue_client_leave(int client) 564 { 565 int i; 566 struct snd_seq_queue *q; 567 568 /* delete own queues from queue list */ 569 for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) { 570 if ((q = queue_list_remove(i, client)) != NULL) 571 queue_delete(q); 572 } 573 574 /* remove cells from existing queues - 575 * they are not owned by this client 576 */ 577 for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) { 578 if ((q = queueptr(i)) == NULL) 579 continue; 580 if (test_bit(client, q->clients_bitmap)) { 581 snd_seq_prioq_leave(q->tickq, client, 0); 582 snd_seq_prioq_leave(q->timeq, client, 0); 583 snd_seq_queue_use(q->queue, client, 0); 584 } 585 queuefree(q); 586 } 587 } 588 589 590 591 /*----------------------------------------------------------------*/ 592 593 /* remove cells from all queues */ 594 void snd_seq_queue_client_leave_cells(int client) 595 { 596 int i; 597 struct snd_seq_queue *q; 598 599 for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) { 600 if ((q = queueptr(i)) == NULL) 601 continue; 602 snd_seq_prioq_leave(q->tickq, client, 0); 603 snd_seq_prioq_leave(q->timeq, client, 0); 604 queuefree(q); 605 } 606 } 607 608 /* remove cells based on flush criteria */ 609 void snd_seq_queue_remove_cells(int client, struct snd_seq_remove_events *info) 610 { 611 int i; 612 struct snd_seq_queue *q; 613 614 for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) { 615 if ((q = queueptr(i)) == NULL) 616 continue; 617 if (test_bit(client, q->clients_bitmap) && 618 (! (info->remove_mode & SNDRV_SEQ_REMOVE_DEST) || 619 q->queue == info->queue)) { 620 snd_seq_prioq_remove_events(q->tickq, client, info); 621 snd_seq_prioq_remove_events(q->timeq, client, info); 622 } 623 queuefree(q); 624 } 625 } 626 627 /*----------------------------------------------------------------*/ 628 629 /* 630 * send events to all subscribed ports 631 */ 632 static void queue_broadcast_event(struct snd_seq_queue *q, struct snd_seq_event *ev, 633 int atomic, int hop) 634 { 635 struct snd_seq_event sev; 636 637 sev = *ev; 638 639 sev.flags = SNDRV_SEQ_TIME_STAMP_TICK|SNDRV_SEQ_TIME_MODE_ABS; 640 sev.time.tick = q->timer->tick.cur_tick; 641 sev.queue = q->queue; 642 sev.data.queue.queue = q->queue; 643 644 /* broadcast events from Timer port */ 645 sev.source.client = SNDRV_SEQ_CLIENT_SYSTEM; 646 sev.source.port = SNDRV_SEQ_PORT_SYSTEM_TIMER; 647 sev.dest.client = SNDRV_SEQ_ADDRESS_SUBSCRIBERS; 648 snd_seq_kernel_client_dispatch(SNDRV_SEQ_CLIENT_SYSTEM, &sev, atomic, hop); 649 } 650 651 /* 652 * process a received queue-control event. 653 * this function is exported for seq_sync.c. 654 */ 655 static void snd_seq_queue_process_event(struct snd_seq_queue *q, 656 struct snd_seq_event *ev, 657 int atomic, int hop) 658 { 659 switch (ev->type) { 660 case SNDRV_SEQ_EVENT_START: 661 snd_seq_prioq_leave(q->tickq, ev->source.client, 1); 662 snd_seq_prioq_leave(q->timeq, ev->source.client, 1); 663 if (! snd_seq_timer_start(q->timer)) 664 queue_broadcast_event(q, ev, atomic, hop); 665 break; 666 667 case SNDRV_SEQ_EVENT_CONTINUE: 668 if (! snd_seq_timer_continue(q->timer)) 669 queue_broadcast_event(q, ev, atomic, hop); 670 break; 671 672 case SNDRV_SEQ_EVENT_STOP: 673 snd_seq_timer_stop(q->timer); 674 queue_broadcast_event(q, ev, atomic, hop); 675 break; 676 677 case SNDRV_SEQ_EVENT_TEMPO: 678 snd_seq_timer_set_tempo(q->timer, ev->data.queue.param.value); 679 queue_broadcast_event(q, ev, atomic, hop); 680 break; 681 682 case SNDRV_SEQ_EVENT_SETPOS_TICK: 683 if (snd_seq_timer_set_position_tick(q->timer, ev->data.queue.param.time.tick) == 0) { 684 queue_broadcast_event(q, ev, atomic, hop); 685 } 686 break; 687 688 case SNDRV_SEQ_EVENT_SETPOS_TIME: 689 if (snd_seq_timer_set_position_time(q->timer, ev->data.queue.param.time.time) == 0) { 690 queue_broadcast_event(q, ev, atomic, hop); 691 } 692 break; 693 case SNDRV_SEQ_EVENT_QUEUE_SKEW: 694 if (snd_seq_timer_set_skew(q->timer, 695 ev->data.queue.param.skew.value, 696 ev->data.queue.param.skew.base) == 0) { 697 queue_broadcast_event(q, ev, atomic, hop); 698 } 699 break; 700 } 701 } 702 703 704 /* 705 * Queue control via timer control port: 706 * this function is exported as a callback of timer port. 707 */ 708 int snd_seq_control_queue(struct snd_seq_event *ev, int atomic, int hop) 709 { 710 struct snd_seq_queue *q; 711 712 if (snd_BUG_ON(!ev)) 713 return -EINVAL; 714 q = queueptr(ev->data.queue.queue); 715 716 if (q == NULL) 717 return -EINVAL; 718 719 if (! queue_access_lock(q, ev->source.client)) { 720 queuefree(q); 721 return -EPERM; 722 } 723 724 snd_seq_queue_process_event(q, ev, atomic, hop); 725 726 queue_access_unlock(q); 727 queuefree(q); 728 return 0; 729 } 730 731 732 /*----------------------------------------------------------------*/ 733 734 #ifdef CONFIG_SND_PROC_FS 735 /* exported to seq_info.c */ 736 void snd_seq_info_queues_read(struct snd_info_entry *entry, 737 struct snd_info_buffer *buffer) 738 { 739 int i, bpm; 740 struct snd_seq_queue *q; 741 struct snd_seq_timer *tmr; 742 743 for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) { 744 if ((q = queueptr(i)) == NULL) 745 continue; 746 747 tmr = q->timer; 748 if (tmr->tempo) 749 bpm = 60000000 / tmr->tempo; 750 else 751 bpm = 0; 752 753 snd_iprintf(buffer, "queue %d: [%s]\n", q->queue, q->name); 754 snd_iprintf(buffer, "owned by client : %d\n", q->owner); 755 snd_iprintf(buffer, "lock status : %s\n", q->locked ? "Locked" : "Free"); 756 snd_iprintf(buffer, "queued time events : %d\n", snd_seq_prioq_avail(q->timeq)); 757 snd_iprintf(buffer, "queued tick events : %d\n", snd_seq_prioq_avail(q->tickq)); 758 snd_iprintf(buffer, "timer state : %s\n", tmr->running ? "Running" : "Stopped"); 759 snd_iprintf(buffer, "timer PPQ : %d\n", tmr->ppq); 760 snd_iprintf(buffer, "current tempo : %d\n", tmr->tempo); 761 snd_iprintf(buffer, "current BPM : %d\n", bpm); 762 snd_iprintf(buffer, "current time : %d.%09d s\n", tmr->cur_time.tv_sec, tmr->cur_time.tv_nsec); 763 snd_iprintf(buffer, "current tick : %d\n", tmr->tick.cur_tick); 764 snd_iprintf(buffer, "\n"); 765 queuefree(q); 766 } 767 } 768 #endif /* CONFIG_SND_PROC_FS */ 769 770