1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
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
37static struct snd_seq_queue *queue_list[SNDRV_SEQ_MAX_QUEUES];
38static DEFINE_SPINLOCK(queue_list_lock);
39
40static int num_queues;
41
42int snd_seq_queue_get_cur_queues(void)
43{
44 return num_queues;
45}
46
47
48
49
50static 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
69static 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
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
96static 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
129static void queue_delete(struct snd_seq_queue *q)
130{
131
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
137 snd_use_lock_sync(&q->use_lock);
138
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
150void snd_seq_queues_delete(void)
151{
152 int i;
153
154
155 for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) {
156 if (queue_list[i])
157 queue_delete(queue_list[i]);
158 }
159}
160
161static void queue_use(struct snd_seq_queue *queue, int client, int use);
162
163
164
165
166
167
168struct 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
187int 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
203struct 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
219struct 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
237void 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 snd_seq_tick_time_t cur_tick;
242 snd_seq_real_time_t cur_time;
243
244 if (q == NULL)
245 return;
246
247
248 spin_lock_irqsave(&q->check_lock, flags);
249 if (q->check_blocked) {
250 q->check_again = 1;
251 spin_unlock_irqrestore(&q->check_lock, flags);
252 return;
253 }
254 q->check_blocked = 1;
255 spin_unlock_irqrestore(&q->check_lock, flags);
256
257 __again:
258
259 cur_tick = snd_seq_timer_get_cur_tick(q->timer);
260 for (;;) {
261 cell = snd_seq_prioq_cell_out(q->tickq, &cur_tick);
262 if (!cell)
263 break;
264 snd_seq_dispatch_event(cell, atomic, hop);
265 }
266
267
268 cur_time = snd_seq_timer_get_cur_time(q->timer, false);
269 for (;;) {
270 cell = snd_seq_prioq_cell_out(q->timeq, &cur_time);
271 if (!cell)
272 break;
273 snd_seq_dispatch_event(cell, atomic, hop);
274 }
275
276
277 spin_lock_irqsave(&q->check_lock, flags);
278 if (q->check_again) {
279 q->check_again = 0;
280 spin_unlock_irqrestore(&q->check_lock, flags);
281 goto __again;
282 }
283 q->check_blocked = 0;
284 spin_unlock_irqrestore(&q->check_lock, flags);
285}
286
287
288
289int snd_seq_enqueue_event(struct snd_seq_event_cell *cell, int atomic, int hop)
290{
291 int dest, err;
292 struct snd_seq_queue *q;
293
294 if (snd_BUG_ON(!cell))
295 return -EINVAL;
296 dest = cell->event.queue;
297 q = queueptr(dest);
298 if (q == NULL)
299 return -EINVAL;
300
301 if ((cell->event.flags & SNDRV_SEQ_TIME_MODE_MASK) == SNDRV_SEQ_TIME_MODE_REL) {
302 switch (cell->event.flags & SNDRV_SEQ_TIME_STAMP_MASK) {
303 case SNDRV_SEQ_TIME_STAMP_TICK:
304 cell->event.time.tick += q->timer->tick.cur_tick;
305 break;
306
307 case SNDRV_SEQ_TIME_STAMP_REAL:
308 snd_seq_inc_real_time(&cell->event.time.time,
309 &q->timer->cur_time);
310 break;
311 }
312 cell->event.flags &= ~SNDRV_SEQ_TIME_MODE_MASK;
313 cell->event.flags |= SNDRV_SEQ_TIME_MODE_ABS;
314 }
315
316 switch (cell->event.flags & SNDRV_SEQ_TIME_STAMP_MASK) {
317 case SNDRV_SEQ_TIME_STAMP_TICK:
318 err = snd_seq_prioq_cell_in(q->tickq, cell);
319 break;
320
321 case SNDRV_SEQ_TIME_STAMP_REAL:
322 default:
323 err = snd_seq_prioq_cell_in(q->timeq, cell);
324 break;
325 }
326
327 if (err < 0) {
328 queuefree(q);
329 return err;
330 }
331
332
333 snd_seq_check_queue(q, atomic, hop);
334
335 queuefree(q);
336
337 return 0;
338}
339
340
341
342
343static inline int check_access(struct snd_seq_queue *q, int client)
344{
345 return (q->owner == client) || (!q->locked && !q->klocked);
346}
347
348
349
350
351static int queue_access_lock(struct snd_seq_queue *q, int client)
352{
353 unsigned long flags;
354 int access_ok;
355
356 spin_lock_irqsave(&q->owner_lock, flags);
357 access_ok = check_access(q, client);
358 if (access_ok)
359 q->klocked = 1;
360 spin_unlock_irqrestore(&q->owner_lock, flags);
361 return access_ok;
362}
363
364
365static inline void queue_access_unlock(struct snd_seq_queue *q)
366{
367 unsigned long flags;
368
369 spin_lock_irqsave(&q->owner_lock, flags);
370 q->klocked = 0;
371 spin_unlock_irqrestore(&q->owner_lock, flags);
372}
373
374
375int snd_seq_queue_check_access(int queueid, int client)
376{
377 struct snd_seq_queue *q = queueptr(queueid);
378 int access_ok;
379 unsigned long flags;
380
381 if (! q)
382 return 0;
383 spin_lock_irqsave(&q->owner_lock, flags);
384 access_ok = check_access(q, client);
385 spin_unlock_irqrestore(&q->owner_lock, flags);
386 queuefree(q);
387 return access_ok;
388}
389
390
391
392
393
394
395int snd_seq_queue_set_owner(int queueid, int client, int locked)
396{
397 struct snd_seq_queue *q = queueptr(queueid);
398 unsigned long flags;
399
400 if (q == NULL)
401 return -EINVAL;
402
403 if (! queue_access_lock(q, client)) {
404 queuefree(q);
405 return -EPERM;
406 }
407
408 spin_lock_irqsave(&q->owner_lock, flags);
409 q->locked = locked ? 1 : 0;
410 q->owner = client;
411 spin_unlock_irqrestore(&q->owner_lock, flags);
412 queue_access_unlock(q);
413 queuefree(q);
414
415 return 0;
416}
417
418
419
420
421
422
423
424
425int snd_seq_queue_timer_open(int queueid)
426{
427 int result = 0;
428 struct snd_seq_queue *queue;
429 struct snd_seq_timer *tmr;
430
431 queue = queueptr(queueid);
432 if (queue == NULL)
433 return -EINVAL;
434 tmr = queue->timer;
435 if ((result = snd_seq_timer_open(queue)) < 0) {
436 snd_seq_timer_defaults(tmr);
437 result = snd_seq_timer_open(queue);
438 }
439 queuefree(queue);
440 return result;
441}
442
443
444
445
446int snd_seq_queue_timer_close(int queueid)
447{
448 struct snd_seq_queue *queue;
449 int result = 0;
450
451 queue = queueptr(queueid);
452 if (queue == NULL)
453 return -EINVAL;
454 snd_seq_timer_close(queue);
455 queuefree(queue);
456 return result;
457}
458
459
460int snd_seq_queue_timer_set_tempo(int queueid, int client,
461 struct snd_seq_queue_tempo *info)
462{
463 struct snd_seq_queue *q = queueptr(queueid);
464 int result;
465
466 if (q == NULL)
467 return -EINVAL;
468 if (! queue_access_lock(q, client)) {
469 queuefree(q);
470 return -EPERM;
471 }
472
473 result = snd_seq_timer_set_tempo_ppq(q->timer, info->tempo, info->ppq);
474 if (result >= 0 && info->skew_base > 0)
475 result = snd_seq_timer_set_skew(q->timer, info->skew_value,
476 info->skew_base);
477 queue_access_unlock(q);
478 queuefree(q);
479 return result;
480}
481
482
483static void queue_use(struct snd_seq_queue *queue, int client, int use)
484{
485 if (use) {
486 if (!test_and_set_bit(client, queue->clients_bitmap))
487 queue->clients++;
488 } else {
489 if (test_and_clear_bit(client, queue->clients_bitmap))
490 queue->clients--;
491 }
492 if (queue->clients) {
493 if (use && queue->clients == 1)
494 snd_seq_timer_defaults(queue->timer);
495 snd_seq_timer_open(queue);
496 } else {
497 snd_seq_timer_close(queue);
498 }
499}
500
501
502
503
504
505int snd_seq_queue_use(int queueid, int client, int use)
506{
507 struct snd_seq_queue *queue;
508
509 queue = queueptr(queueid);
510 if (queue == NULL)
511 return -EINVAL;
512 mutex_lock(&queue->timer_mutex);
513 queue_use(queue, client, use);
514 mutex_unlock(&queue->timer_mutex);
515 queuefree(queue);
516 return 0;
517}
518
519
520
521
522
523
524int snd_seq_queue_is_used(int queueid, int client)
525{
526 struct snd_seq_queue *q;
527 int result;
528
529 q = queueptr(queueid);
530 if (q == NULL)
531 return -EINVAL;
532 result = test_bit(client, q->clients_bitmap) ? 1 : 0;
533 queuefree(q);
534 return result;
535}
536
537
538
539
540
541
542
543
544void snd_seq_queue_client_leave(int client)
545{
546 int i;
547 struct snd_seq_queue *q;
548
549
550 for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) {
551 if ((q = queue_list_remove(i, client)) != NULL)
552 queue_delete(q);
553 }
554
555
556
557
558 for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) {
559 if ((q = queueptr(i)) == NULL)
560 continue;
561 if (test_bit(client, q->clients_bitmap)) {
562 snd_seq_prioq_leave(q->tickq, client, 0);
563 snd_seq_prioq_leave(q->timeq, client, 0);
564 snd_seq_queue_use(q->queue, client, 0);
565 }
566 queuefree(q);
567 }
568}
569
570
571
572
573
574
575void snd_seq_queue_client_leave_cells(int client)
576{
577 int i;
578 struct snd_seq_queue *q;
579
580 for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) {
581 if ((q = queueptr(i)) == NULL)
582 continue;
583 snd_seq_prioq_leave(q->tickq, client, 0);
584 snd_seq_prioq_leave(q->timeq, client, 0);
585 queuefree(q);
586 }
587}
588
589
590void snd_seq_queue_remove_cells(int client, struct snd_seq_remove_events *info)
591{
592 int i;
593 struct snd_seq_queue *q;
594
595 for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) {
596 if ((q = queueptr(i)) == NULL)
597 continue;
598 if (test_bit(client, q->clients_bitmap) &&
599 (! (info->remove_mode & SNDRV_SEQ_REMOVE_DEST) ||
600 q->queue == info->queue)) {
601 snd_seq_prioq_remove_events(q->tickq, client, info);
602 snd_seq_prioq_remove_events(q->timeq, client, info);
603 }
604 queuefree(q);
605 }
606}
607
608
609
610
611
612
613static void queue_broadcast_event(struct snd_seq_queue *q, struct snd_seq_event *ev,
614 int atomic, int hop)
615{
616 struct snd_seq_event sev;
617
618 sev = *ev;
619
620 sev.flags = SNDRV_SEQ_TIME_STAMP_TICK|SNDRV_SEQ_TIME_MODE_ABS;
621 sev.time.tick = q->timer->tick.cur_tick;
622 sev.queue = q->queue;
623 sev.data.queue.queue = q->queue;
624
625
626 sev.source.client = SNDRV_SEQ_CLIENT_SYSTEM;
627 sev.source.port = SNDRV_SEQ_PORT_SYSTEM_TIMER;
628 sev.dest.client = SNDRV_SEQ_ADDRESS_SUBSCRIBERS;
629 snd_seq_kernel_client_dispatch(SNDRV_SEQ_CLIENT_SYSTEM, &sev, atomic, hop);
630}
631
632
633
634
635
636static void snd_seq_queue_process_event(struct snd_seq_queue *q,
637 struct snd_seq_event *ev,
638 int atomic, int hop)
639{
640 switch (ev->type) {
641 case SNDRV_SEQ_EVENT_START:
642 snd_seq_prioq_leave(q->tickq, ev->source.client, 1);
643 snd_seq_prioq_leave(q->timeq, ev->source.client, 1);
644 if (! snd_seq_timer_start(q->timer))
645 queue_broadcast_event(q, ev, atomic, hop);
646 break;
647
648 case SNDRV_SEQ_EVENT_CONTINUE:
649 if (! snd_seq_timer_continue(q->timer))
650 queue_broadcast_event(q, ev, atomic, hop);
651 break;
652
653 case SNDRV_SEQ_EVENT_STOP:
654 snd_seq_timer_stop(q->timer);
655 queue_broadcast_event(q, ev, atomic, hop);
656 break;
657
658 case SNDRV_SEQ_EVENT_TEMPO:
659 snd_seq_timer_set_tempo(q->timer, ev->data.queue.param.value);
660 queue_broadcast_event(q, ev, atomic, hop);
661 break;
662
663 case SNDRV_SEQ_EVENT_SETPOS_TICK:
664 if (snd_seq_timer_set_position_tick(q->timer, ev->data.queue.param.time.tick) == 0) {
665 queue_broadcast_event(q, ev, atomic, hop);
666 }
667 break;
668
669 case SNDRV_SEQ_EVENT_SETPOS_TIME:
670 if (snd_seq_timer_set_position_time(q->timer, ev->data.queue.param.time.time) == 0) {
671 queue_broadcast_event(q, ev, atomic, hop);
672 }
673 break;
674 case SNDRV_SEQ_EVENT_QUEUE_SKEW:
675 if (snd_seq_timer_set_skew(q->timer,
676 ev->data.queue.param.skew.value,
677 ev->data.queue.param.skew.base) == 0) {
678 queue_broadcast_event(q, ev, atomic, hop);
679 }
680 break;
681 }
682}
683
684
685
686
687
688
689int snd_seq_control_queue(struct snd_seq_event *ev, int atomic, int hop)
690{
691 struct snd_seq_queue *q;
692
693 if (snd_BUG_ON(!ev))
694 return -EINVAL;
695 q = queueptr(ev->data.queue.queue);
696
697 if (q == NULL)
698 return -EINVAL;
699
700 if (! queue_access_lock(q, ev->source.client)) {
701 queuefree(q);
702 return -EPERM;
703 }
704
705 snd_seq_queue_process_event(q, ev, atomic, hop);
706
707 queue_access_unlock(q);
708 queuefree(q);
709 return 0;
710}
711
712
713
714
715#ifdef CONFIG_SND_PROC_FS
716
717void snd_seq_info_queues_read(struct snd_info_entry *entry,
718 struct snd_info_buffer *buffer)
719{
720 int i, bpm;
721 struct snd_seq_queue *q;
722 struct snd_seq_timer *tmr;
723 bool locked;
724 int owner;
725
726 for (i = 0; i < SNDRV_SEQ_MAX_QUEUES; i++) {
727 if ((q = queueptr(i)) == NULL)
728 continue;
729
730 tmr = q->timer;
731 if (tmr->tempo)
732 bpm = 60000000 / tmr->tempo;
733 else
734 bpm = 0;
735
736 spin_lock_irq(&q->owner_lock);
737 locked = q->locked;
738 owner = q->owner;
739 spin_unlock_irq(&q->owner_lock);
740
741 snd_iprintf(buffer, "queue %d: [%s]\n", q->queue, q->name);
742 snd_iprintf(buffer, "owned by client : %d\n", owner);
743 snd_iprintf(buffer, "lock status : %s\n", locked ? "Locked" : "Free");
744 snd_iprintf(buffer, "queued time events : %d\n", snd_seq_prioq_avail(q->timeq));
745 snd_iprintf(buffer, "queued tick events : %d\n", snd_seq_prioq_avail(q->tickq));
746 snd_iprintf(buffer, "timer state : %s\n", tmr->running ? "Running" : "Stopped");
747 snd_iprintf(buffer, "timer PPQ : %d\n", tmr->ppq);
748 snd_iprintf(buffer, "current tempo : %d\n", tmr->tempo);
749 snd_iprintf(buffer, "current BPM : %d\n", bpm);
750 snd_iprintf(buffer, "current time : %d.%09d s\n", tmr->cur_time.tv_sec, tmr->cur_time.tv_nsec);
751 snd_iprintf(buffer, "current tick : %d\n", tmr->tick.cur_tick);
752 snd_iprintf(buffer, "\n");
753 queuefree(q);
754 }
755}
756#endif
757
758