core/seq/seq_queue.c

50 static int queue_list_add(struct snd_seq_queue *q)
57 			queue_list[i] = q;
58 			q->queue = i;
68 	struct snd_seq_queue *q;
71 	q = queue_list[id];
72 	if (q) {
73 		guard(spinlock)(&q->owner_lock);
74 		if (q->owner == client) {
76 			q->klocked = 1;
79 			return q;
90 	struct snd_seq_queue *q;
92 	q = kzalloc(sizeof(*q), GFP_KERNEL);
93 	if (!q)
96 	spin_lock_init(&q->owner_lock);
97 	spin_lock_init(&q->check_lock);
98 	mutex_init(&q->timer_mutex);
99 	snd_use_lock_init(&q->use_lock);
100 	q->queue = -1;
102 	q->tickq = snd_seq_prioq_new();
103 	q->timeq = snd_seq_prioq_new();
104 	q->timer = snd_seq_timer_new();
105 	if (q->tickq == NULL || q->timeq == NULL || q->timer == NULL) {
106 		snd_seq_prioq_delete(&q->tickq);
107 		snd_seq_prioq_delete(&q->timeq);
108 		snd_seq_timer_delete(&q->timer);
109 		kfree(q);
113 	q->owner = owner;
114 	q->locked = locked;
115 	q->klocked = 0;
117 	return q;
121 static void queue_delete(struct snd_seq_queue *q)
124 	mutex_lock(&q->timer_mutex);
125 	snd_seq_timer_stop(q->timer);
126 	snd_seq_timer_close(q);
127 	mutex_unlock(&q->timer_mutex);
129 	snd_use_lock_sync(&q->use_lock);
131 	snd_seq_prioq_delete(&q->tickq);
132 	snd_seq_prioq_delete(&q->timeq);
133 	snd_seq_timer_delete(&q->timer);
135 	kfree(q);
158  * call snd_use_lock_free(&q->use_lock).
162 	struct snd_seq_queue *q;
164 	q = queue_new(client, locked);
165 	if (q == NULL)
167 	q->info_flags = info_flags;
168 	queue_use(q, client, 1);
169 	snd_use_lock_use(&q->use_lock);
170 	if (queue_list_add(q) < 0) {
171 		snd_use_lock_free(&q->use_lock);
172 		queue_delete(q);
175 	return q;
181 	struct snd_seq_queue *q;
185 	q = queue_list_remove(queueid, client);
186 	if (q == NULL)
188 	queue_delete(q);
197 	struct snd_seq_queue *q;
202 	q = queue_list[queueid];
203 	if (q)
204 		snd_use_lock_use(&q->use_lock);
205 	return q;
212 	struct snd_seq_queue *q;
215 		q = queueptr(i);
216 		if (q) {
217 			if (strncmp(q->name, name, sizeof(q->name)) == 0)
218 				return q;
219 			queuefree(q);
230 void snd_seq_check_queue(struct snd_seq_queue *q, int atomic, int hop)
237 	if (q == NULL)
241 	scoped_guard(spinlock_irqsave, &q->check_lock) {
242 		if (q->check_blocked) {
243 			q->check_again = 1;
246 		q->check_blocked = 1;
251 	cur_tick = snd_seq_timer_get_cur_tick(q->timer);
253 		cell = snd_seq_prioq_cell_out(q->tickq, &cur_tick);
262 	cur_time = snd_seq_timer_get_cur_time(q->timer, false);
264 		cell = snd_seq_prioq_cell_out(q->timeq, &cur_time);
274 	scoped_guard(spinlock_irqsave, &q->check_lock) {
275 		if (q->check_again) {
276 			q->check_again = 0;
280 		q->check_blocked = 0;
289 	struct snd_seq_queue *q;
294 	q = queueptr(dest);
295 	if (q == NULL)
301 			cell->event.time.tick += q->timer->tick.cur_tick;
306 					      &q->timer->cur_time);
315 		err = snd_seq_prioq_cell_in(q->tickq, cell);
320 		err = snd_seq_prioq_cell_in(q->timeq, cell);
325 		queuefree(q); /* unlock */
330 	snd_seq_check_queue(q, atomic, hop);
332 	queuefree(q); /* unlock */
340 static inline int check_access(struct snd_seq_queue *q, int client)
342 	return (q->owner == client) || (!q->locked && !q->klocked);
348 static int queue_access_lock(struct snd_seq_queue *q, int client)
352 	guard(spinlock_irqsave)(&q->owner_lock);
353 	access_ok = check_access(q, client);
355 		q->klocked = 1;
360 static inline void queue_access_unlock(struct snd_seq_queue *q)
362 	guard(spinlock_irqsave)(&q->owner_lock);
363 	q->klocked = 0;
369 	struct snd_seq_queue *q = queueptr(queueid);
372 	if (! q)
374 	scoped_guard(spinlock_irqsave, &q->owner_lock)
375 		access_ok = check_access(q, client);
376 	queuefree(q);
387 	struct snd_seq_queue *q = queueptr(queueid);
389 	if (q == NULL)
392 	if (! queue_access_lock(q, client)) {
393 		queuefree(q);
397 	scoped_guard(spinlock_irqsave, &q->owner_lock) {
398 		q->locked = locked ? 1 : 0;
399 		q->owner = client;
401 	queue_access_unlock(q);
402 	queuefree(q);
411  * q->use mutex should be down before calling this function to avoid
434  * q->use mutex should be down before calling this function
453 	struct snd_seq_queue *q = queueptr(queueid);
456 	if (q == NULL)
458 	if (! queue_access_lock(q, client)) {
459 		queuefree(q);
463 	result = snd_seq_timer_set_tempo_ppq(q->timer, info->tempo, info->ppq,
466 		result = snd_seq_timer_set_skew(q->timer, info->skew_value,
468 	queue_access_unlock(q);
469 	queuefree(q);
517 	struct snd_seq_queue *q;
520 	q = queueptr(queueid);
521 	if (q == NULL)
523 	result = test_bit(client, q->clients_bitmap) ? 1 : 0;
524 	queuefree(q);
538 	struct snd_seq_queue *q;
542 		q = queue_list_remove(i, client);
543 		if (q)
544 			queue_delete(q);
551 		q = queueptr(i);
552 		if (!q)
554 		if (test_bit(client, q->clients_bitmap)) {
555 			snd_seq_prioq_leave(q->tickq, client, 0);
556 			snd_seq_prioq_leave(q->timeq, client, 0);
557 			snd_seq_queue_use(q->queue, client, 0);
559 		queuefree(q);
571 	struct snd_seq_queue *q;
574 		q = queueptr(i);
575 		if (!q)
577 		if (test_bit(client, q->clients_bitmap) &&
579 		     q->queue == info->queue)) {
580 			snd_seq_prioq_remove_events(q->tickq, client, info);
581 			snd_seq_prioq_remove_events(q->timeq, client, info);
583 		queuefree(q);
592 static void queue_broadcast_event(struct snd_seq_queue *q, struct snd_seq_event *ev,
600 	sev.time.tick = q->timer->tick.cur_tick;
601 	sev.queue = q->queue;
602 	sev.data.queue.queue = q->queue;
615 static void snd_seq_queue_process_event(struct snd_seq_queue *q,
621 		snd_seq_prioq_leave(q->tickq, ev->source.client, 1);
622 		snd_seq_prioq_leave(q->timeq, ev->source.client, 1);
623 		if (! snd_seq_timer_start(q->timer))
624 			queue_broadcast_event(q, ev, atomic, hop);
628 		if (! snd_seq_timer_continue(q->timer))
629 			queue_broadcast_event(q, ev, atomic, hop);
633 		snd_seq_timer_stop(q->timer);
634 		queue_broadcast_event(q, ev, atomic, hop);
638 		snd_seq_timer_set_tempo(q->timer, ev->data.queue.param.value);
639 		queue_broadcast_event(q, ev, atomic, hop);
643 		if (snd_seq_timer_set_position_tick(q->timer, ev->data.queue.param.time.tick) == 0) {
644 			queue_broadcast_event(q, ev, atomic, hop);
649 		if (snd_seq_timer_set_position_time(q->timer, ev->data.queue.param.time.time) == 0) {
650 			queue_broadcast_event(q, ev, atomic, hop);
654 		if (snd_seq_timer_set_skew(q->timer,
657 			queue_broadcast_event(q, ev, atomic, hop);
670 	struct snd_seq_queue *q;
674 	q = queueptr(ev->data.queue.queue);
676 	if (q == NULL)
679 	if (! queue_access_lock(q, ev->source.client)) {
680 		queuefree(q);
684 	snd_seq_queue_process_event(q, ev, atomic, hop);
686 	queue_access_unlock(q);
687 	queuefree(q);
700 	struct snd_seq_queue *q;
706 		q = queueptr(i);
707 		if (!q)
710 		tmr = q->timer;
716 		scoped_guard(spinlock_irq, &q->owner_lock) {
717 			locked = q->locked;
718 			owner = q->owner;
721 		snd_iprintf(buffer, "queue %d: [%s]\n", q->queue, q->name);
724 		snd_iprintf(buffer, "queued time events : %d\n", snd_seq_prioq_avail(q->timeq));
725 		snd_iprintf(buffer, "queued tick events : %d\n", snd_seq_prioq_avail(q->tickq));
734 		queuefree(q);