Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-or-later
2 : : /*
3 : : * ALSA sequencer Timer
4 : : * Copyright (c) 1998-1999 by Frank van de Pol <fvdpol@coil.demon.nl>
5 : : * Jaroslav Kysela <perex@perex.cz>
6 : : */
7 : :
8 : : #include <sound/core.h>
9 : : #include <linux/slab.h>
10 : : #include "seq_timer.h"
11 : : #include "seq_queue.h"
12 : : #include "seq_info.h"
13 : :
14 : : /* allowed sequencer timer frequencies, in Hz */
15 : : #define MIN_FREQUENCY 10
16 : : #define MAX_FREQUENCY 6250
17 : : #define DEFAULT_FREQUENCY 1000
18 : :
19 : : #define SKEW_BASE 0x10000 /* 16bit shift */
20 : :
21 : 0 : static void snd_seq_timer_set_tick_resolution(struct snd_seq_timer *tmr)
22 : : {
23 [ # # ]: 0 : if (tmr->tempo < 1000000)
24 : 0 : tmr->tick.resolution = (tmr->tempo * 1000) / tmr->ppq;
25 : : else {
26 : : /* might overflow.. */
27 : 0 : unsigned int s;
28 : 0 : s = tmr->tempo % tmr->ppq;
29 : 0 : s = (s * 1000) / tmr->ppq;
30 : 0 : tmr->tick.resolution = (tmr->tempo / tmr->ppq) * 1000;
31 : 0 : tmr->tick.resolution += s;
32 : : }
33 [ # # ]: 0 : if (tmr->tick.resolution <= 0)
34 : 0 : tmr->tick.resolution = 1;
35 [ # # ]: 0 : snd_seq_timer_update_tick(&tmr->tick, 0);
36 : 0 : }
37 : :
38 : : /* create new timer (constructor) */
39 : 0 : struct snd_seq_timer *snd_seq_timer_new(void)
40 : : {
41 : 0 : struct snd_seq_timer *tmr;
42 : :
43 : 0 : tmr = kzalloc(sizeof(*tmr), GFP_KERNEL);
44 [ # # ]: 0 : if (!tmr)
45 : : return NULL;
46 : 0 : spin_lock_init(&tmr->lock);
47 : :
48 : : /* reset setup to defaults */
49 : 0 : snd_seq_timer_defaults(tmr);
50 : :
51 : : /* reset time */
52 : 0 : snd_seq_timer_reset(tmr);
53 : :
54 : 0 : return tmr;
55 : : }
56 : :
57 : : /* delete timer (destructor) */
58 : 0 : void snd_seq_timer_delete(struct snd_seq_timer **tmr)
59 : : {
60 : 0 : struct snd_seq_timer *t = *tmr;
61 : 0 : *tmr = NULL;
62 : :
63 [ # # ]: 0 : if (t == NULL) {
64 : : pr_debug("ALSA: seq: snd_seq_timer_delete() called with NULL timer\n");
65 : : return;
66 : : }
67 : 0 : t->running = 0;
68 : :
69 : : /* reset time */
70 : 0 : snd_seq_timer_stop(t);
71 : 0 : snd_seq_timer_reset(t);
72 : :
73 : 0 : kfree(t);
74 : : }
75 : :
76 : 0 : void snd_seq_timer_defaults(struct snd_seq_timer * tmr)
77 : : {
78 : 0 : unsigned long flags;
79 : :
80 : 0 : spin_lock_irqsave(&tmr->lock, flags);
81 : : /* setup defaults */
82 : 0 : tmr->ppq = 96; /* 96 PPQ */
83 : 0 : tmr->tempo = 500000; /* 120 BPM */
84 : 0 : snd_seq_timer_set_tick_resolution(tmr);
85 : 0 : tmr->running = 0;
86 : :
87 : 0 : tmr->type = SNDRV_SEQ_TIMER_ALSA;
88 : 0 : tmr->alsa_id.dev_class = seq_default_timer_class;
89 : 0 : tmr->alsa_id.dev_sclass = seq_default_timer_sclass;
90 : 0 : tmr->alsa_id.card = seq_default_timer_card;
91 : 0 : tmr->alsa_id.device = seq_default_timer_device;
92 : 0 : tmr->alsa_id.subdevice = seq_default_timer_subdevice;
93 : 0 : tmr->preferred_resolution = seq_default_timer_resolution;
94 : :
95 : 0 : tmr->skew = tmr->skew_base = SKEW_BASE;
96 : 0 : spin_unlock_irqrestore(&tmr->lock, flags);
97 : 0 : }
98 : :
99 : 0 : static void seq_timer_reset(struct snd_seq_timer *tmr)
100 : : {
101 : : /* reset time & songposition */
102 : 0 : tmr->cur_time.tv_sec = 0;
103 : 0 : tmr->cur_time.tv_nsec = 0;
104 : :
105 : 0 : tmr->tick.cur_tick = 0;
106 : 0 : tmr->tick.fraction = 0;
107 : : }
108 : :
109 : 0 : void snd_seq_timer_reset(struct snd_seq_timer *tmr)
110 : : {
111 : 0 : unsigned long flags;
112 : :
113 : 0 : spin_lock_irqsave(&tmr->lock, flags);
114 : 0 : seq_timer_reset(tmr);
115 : 0 : spin_unlock_irqrestore(&tmr->lock, flags);
116 : 0 : }
117 : :
118 : :
119 : : /* called by timer interrupt routine. the period time since previous invocation is passed */
120 : 0 : static void snd_seq_timer_interrupt(struct snd_timer_instance *timeri,
121 : : unsigned long resolution,
122 : : unsigned long ticks)
123 : : {
124 : 0 : unsigned long flags;
125 : 0 : struct snd_seq_queue *q = timeri->callback_data;
126 : 0 : struct snd_seq_timer *tmr;
127 : :
128 [ # # ]: 0 : if (q == NULL)
129 : : return;
130 : 0 : tmr = q->timer;
131 [ # # ]: 0 : if (tmr == NULL)
132 : : return;
133 : 0 : spin_lock_irqsave(&tmr->lock, flags);
134 [ # # ]: 0 : if (!tmr->running) {
135 : 0 : spin_unlock_irqrestore(&tmr->lock, flags);
136 : 0 : return;
137 : : }
138 : :
139 : 0 : resolution *= ticks;
140 [ # # ]: 0 : if (tmr->skew != tmr->skew_base) {
141 : : /* FIXME: assuming skew_base = 0x10000 */
142 : 0 : resolution = (resolution >> 16) * tmr->skew +
143 : 0 : (((resolution & 0xffff) * tmr->skew) >> 16);
144 : : }
145 : :
146 : : /* update timer */
147 : 0 : snd_seq_inc_time_nsec(&tmr->cur_time, resolution);
148 : :
149 : : /* calculate current tick */
150 [ # # ]: 0 : snd_seq_timer_update_tick(&tmr->tick, resolution);
151 : :
152 : : /* register actual time of this timer update */
153 : 0 : ktime_get_ts64(&tmr->last_update);
154 : :
155 : 0 : spin_unlock_irqrestore(&tmr->lock, flags);
156 : :
157 : : /* check queues and dispatch events */
158 : 0 : snd_seq_check_queue(q, 1, 0);
159 : : }
160 : :
161 : : /* set current tempo */
162 : 0 : int snd_seq_timer_set_tempo(struct snd_seq_timer * tmr, int tempo)
163 : : {
164 : 0 : unsigned long flags;
165 : :
166 [ # # ]: 0 : if (snd_BUG_ON(!tmr))
167 : : return -EINVAL;
168 [ # # ]: 0 : if (tempo <= 0)
169 : : return -EINVAL;
170 : 0 : spin_lock_irqsave(&tmr->lock, flags);
171 [ # # ]: 0 : if ((unsigned int)tempo != tmr->tempo) {
172 : 0 : tmr->tempo = tempo;
173 : 0 : snd_seq_timer_set_tick_resolution(tmr);
174 : : }
175 : 0 : spin_unlock_irqrestore(&tmr->lock, flags);
176 : 0 : return 0;
177 : : }
178 : :
179 : : /* set current tempo and ppq in a shot */
180 : 0 : int snd_seq_timer_set_tempo_ppq(struct snd_seq_timer *tmr, int tempo, int ppq)
181 : : {
182 : 0 : int changed;
183 : 0 : unsigned long flags;
184 : :
185 [ # # ]: 0 : if (snd_BUG_ON(!tmr))
186 : : return -EINVAL;
187 [ # # ]: 0 : if (tempo <= 0 || ppq <= 0)
188 : : return -EINVAL;
189 : 0 : spin_lock_irqsave(&tmr->lock, flags);
190 [ # # # # ]: 0 : if (tmr->running && (ppq != tmr->ppq)) {
191 : : /* refuse to change ppq on running timers */
192 : : /* because it will upset the song position (ticks) */
193 : 0 : spin_unlock_irqrestore(&tmr->lock, flags);
194 : 0 : pr_debug("ALSA: seq: cannot change ppq of a running timer\n");
195 : 0 : return -EBUSY;
196 : : }
197 [ # # # # ]: 0 : changed = (tempo != tmr->tempo) || (ppq != tmr->ppq);
198 : 0 : tmr->tempo = tempo;
199 : 0 : tmr->ppq = ppq;
200 [ # # ]: 0 : if (changed)
201 : 0 : snd_seq_timer_set_tick_resolution(tmr);
202 : 0 : spin_unlock_irqrestore(&tmr->lock, flags);
203 : 0 : return 0;
204 : : }
205 : :
206 : : /* set current tick position */
207 : 0 : int snd_seq_timer_set_position_tick(struct snd_seq_timer *tmr,
208 : : snd_seq_tick_time_t position)
209 : : {
210 : 0 : unsigned long flags;
211 : :
212 [ # # ]: 0 : if (snd_BUG_ON(!tmr))
213 : : return -EINVAL;
214 : :
215 : 0 : spin_lock_irqsave(&tmr->lock, flags);
216 : 0 : tmr->tick.cur_tick = position;
217 : 0 : tmr->tick.fraction = 0;
218 : 0 : spin_unlock_irqrestore(&tmr->lock, flags);
219 : 0 : return 0;
220 : : }
221 : :
222 : : /* set current real-time position */
223 : 0 : int snd_seq_timer_set_position_time(struct snd_seq_timer *tmr,
224 : : snd_seq_real_time_t position)
225 : : {
226 : 0 : unsigned long flags;
227 : :
228 [ # # ]: 0 : if (snd_BUG_ON(!tmr))
229 : : return -EINVAL;
230 : :
231 : : snd_seq_sanity_real_time(&position);
232 : 0 : spin_lock_irqsave(&tmr->lock, flags);
233 : 0 : tmr->cur_time = position;
234 : 0 : spin_unlock_irqrestore(&tmr->lock, flags);
235 : 0 : return 0;
236 : : }
237 : :
238 : : /* set timer skew */
239 : 0 : int snd_seq_timer_set_skew(struct snd_seq_timer *tmr, unsigned int skew,
240 : : unsigned int base)
241 : : {
242 : 0 : unsigned long flags;
243 : :
244 [ # # ]: 0 : if (snd_BUG_ON(!tmr))
245 : : return -EINVAL;
246 : :
247 : : /* FIXME */
248 [ # # ]: 0 : if (base != SKEW_BASE) {
249 : : pr_debug("ALSA: seq: invalid skew base 0x%x\n", base);
250 : : return -EINVAL;
251 : : }
252 : 0 : spin_lock_irqsave(&tmr->lock, flags);
253 : 0 : tmr->skew = skew;
254 : 0 : spin_unlock_irqrestore(&tmr->lock, flags);
255 : 0 : return 0;
256 : : }
257 : :
258 : 0 : int snd_seq_timer_open(struct snd_seq_queue *q)
259 : : {
260 : 0 : struct snd_timer_instance *t;
261 : 0 : struct snd_seq_timer *tmr;
262 : 0 : char str[32];
263 : 0 : int err;
264 : :
265 : 0 : tmr = q->timer;
266 [ # # ]: 0 : if (snd_BUG_ON(!tmr))
267 : : return -EINVAL;
268 [ # # ]: 0 : if (tmr->timeri)
269 : : return -EBUSY;
270 : 0 : sprintf(str, "sequencer queue %i", q->queue);
271 [ # # ]: 0 : if (tmr->type != SNDRV_SEQ_TIMER_ALSA) /* standard ALSA timer */
272 : : return -EINVAL;
273 [ # # ]: 0 : if (tmr->alsa_id.dev_class != SNDRV_TIMER_CLASS_SLAVE)
274 : 0 : tmr->alsa_id.dev_sclass = SNDRV_TIMER_SCLASS_SEQUENCER;
275 : 0 : t = snd_timer_instance_new(str);
276 [ # # ]: 0 : if (!t)
277 : : return -ENOMEM;
278 : 0 : t->callback = snd_seq_timer_interrupt;
279 : 0 : t->callback_data = q;
280 : 0 : t->flags |= SNDRV_TIMER_IFLG_AUTO;
281 : 0 : err = snd_timer_open(t, &tmr->alsa_id, q->queue);
282 [ # # # # ]: 0 : if (err < 0 && tmr->alsa_id.dev_class != SNDRV_TIMER_CLASS_SLAVE) {
283 [ # # ]: 0 : if (tmr->alsa_id.dev_class != SNDRV_TIMER_CLASS_GLOBAL ||
284 [ # # ]: 0 : tmr->alsa_id.device != SNDRV_TIMER_GLOBAL_SYSTEM) {
285 : 0 : struct snd_timer_id tid;
286 : 0 : memset(&tid, 0, sizeof(tid));
287 : 0 : tid.dev_class = SNDRV_TIMER_CLASS_GLOBAL;
288 : 0 : tid.dev_sclass = SNDRV_TIMER_SCLASS_SEQUENCER;
289 : 0 : tid.card = -1;
290 : 0 : tid.device = SNDRV_TIMER_GLOBAL_SYSTEM;
291 : 0 : err = snd_timer_open(t, &tid, q->queue);
292 : : }
293 : : }
294 [ # # ]: 0 : if (err < 0) {
295 : 0 : pr_err("ALSA: seq fatal error: cannot create timer (%i)\n", err);
296 : 0 : snd_timer_instance_free(t);
297 : 0 : return err;
298 : : }
299 : 0 : spin_lock_irq(&tmr->lock);
300 : 0 : tmr->timeri = t;
301 : 0 : spin_unlock_irq(&tmr->lock);
302 : 0 : return 0;
303 : : }
304 : :
305 : 0 : int snd_seq_timer_close(struct snd_seq_queue *q)
306 : : {
307 : 0 : struct snd_seq_timer *tmr;
308 : 0 : struct snd_timer_instance *t;
309 : :
310 : 0 : tmr = q->timer;
311 [ # # ]: 0 : if (snd_BUG_ON(!tmr))
312 : : return -EINVAL;
313 : 0 : spin_lock_irq(&tmr->lock);
314 : 0 : t = tmr->timeri;
315 : 0 : tmr->timeri = NULL;
316 : 0 : spin_unlock_irq(&tmr->lock);
317 [ # # ]: 0 : if (t) {
318 : 0 : snd_timer_close(t);
319 : 0 : snd_timer_instance_free(t);
320 : : }
321 : : return 0;
322 : : }
323 : :
324 : 0 : static int seq_timer_stop(struct snd_seq_timer *tmr)
325 : : {
326 : 0 : if (! tmr->timeri)
327 : : return -EINVAL;
328 [ # # ]: 0 : if (!tmr->running)
329 : : return 0;
330 : 0 : tmr->running = 0;
331 : 0 : snd_timer_pause(tmr->timeri);
332 : 0 : return 0;
333 : : }
334 : :
335 : 0 : int snd_seq_timer_stop(struct snd_seq_timer *tmr)
336 : : {
337 : 0 : unsigned long flags;
338 : 0 : int err;
339 : :
340 : 0 : spin_lock_irqsave(&tmr->lock, flags);
341 [ # # ]: 0 : err = seq_timer_stop(tmr);
342 : 0 : spin_unlock_irqrestore(&tmr->lock, flags);
343 : 0 : return err;
344 : : }
345 : :
346 : 0 : static int initialize_timer(struct snd_seq_timer *tmr)
347 : : {
348 : 0 : struct snd_timer *t;
349 : 0 : unsigned long freq;
350 : :
351 : 0 : t = tmr->timeri->timer;
352 [ # # ]: 0 : if (!t)
353 : : return -EINVAL;
354 : :
355 : 0 : freq = tmr->preferred_resolution;
356 [ # # ]: 0 : if (!freq)
357 : : freq = DEFAULT_FREQUENCY;
358 : 0 : else if (freq < MIN_FREQUENCY)
359 : : freq = MIN_FREQUENCY;
360 : : else if (freq > MAX_FREQUENCY)
361 : : freq = MAX_FREQUENCY;
362 : :
363 : 0 : tmr->ticks = 1;
364 [ # # ]: 0 : if (!(t->hw.flags & SNDRV_TIMER_HW_SLAVE)) {
365 : 0 : unsigned long r = snd_timer_resolution(tmr->timeri);
366 [ # # ]: 0 : if (r) {
367 : 0 : tmr->ticks = (unsigned int)(1000000000uL / (r * freq));
368 [ # # ]: 0 : if (! tmr->ticks)
369 : 0 : tmr->ticks = 1;
370 : : }
371 : : }
372 : 0 : tmr->initialized = 1;
373 : 0 : return 0;
374 : : }
375 : :
376 : 0 : static int seq_timer_start(struct snd_seq_timer *tmr)
377 : : {
378 [ # # ]: 0 : if (! tmr->timeri)
379 : : return -EINVAL;
380 [ # # ]: 0 : if (tmr->running)
381 : 0 : seq_timer_stop(tmr);
382 : 0 : seq_timer_reset(tmr);
383 [ # # ]: 0 : if (initialize_timer(tmr) < 0)
384 : : return -EINVAL;
385 : 0 : snd_timer_start(tmr->timeri, tmr->ticks);
386 : 0 : tmr->running = 1;
387 : 0 : ktime_get_ts64(&tmr->last_update);
388 : 0 : return 0;
389 : : }
390 : :
391 : 0 : int snd_seq_timer_start(struct snd_seq_timer *tmr)
392 : : {
393 : 0 : unsigned long flags;
394 : 0 : int err;
395 : :
396 : 0 : spin_lock_irqsave(&tmr->lock, flags);
397 : 0 : err = seq_timer_start(tmr);
398 : 0 : spin_unlock_irqrestore(&tmr->lock, flags);
399 : 0 : return err;
400 : : }
401 : :
402 : 0 : static int seq_timer_continue(struct snd_seq_timer *tmr)
403 : : {
404 [ # # ]: 0 : if (! tmr->timeri)
405 : : return -EINVAL;
406 [ # # ]: 0 : if (tmr->running)
407 : : return -EBUSY;
408 [ # # ]: 0 : if (! tmr->initialized) {
409 : 0 : seq_timer_reset(tmr);
410 [ # # ]: 0 : if (initialize_timer(tmr) < 0)
411 : : return -EINVAL;
412 : : }
413 : 0 : snd_timer_start(tmr->timeri, tmr->ticks);
414 : 0 : tmr->running = 1;
415 : 0 : ktime_get_ts64(&tmr->last_update);
416 : 0 : return 0;
417 : : }
418 : :
419 : 0 : int snd_seq_timer_continue(struct snd_seq_timer *tmr)
420 : : {
421 : 0 : unsigned long flags;
422 : 0 : int err;
423 : :
424 : 0 : spin_lock_irqsave(&tmr->lock, flags);
425 : 0 : err = seq_timer_continue(tmr);
426 : 0 : spin_unlock_irqrestore(&tmr->lock, flags);
427 : 0 : return err;
428 : : }
429 : :
430 : : /* return current 'real' time. use timeofday() to get better granularity. */
431 : 0 : snd_seq_real_time_t snd_seq_timer_get_cur_time(struct snd_seq_timer *tmr,
432 : : bool adjust_ktime)
433 : : {
434 : 0 : snd_seq_real_time_t cur_time;
435 : 0 : unsigned long flags;
436 : :
437 : 0 : spin_lock_irqsave(&tmr->lock, flags);
438 : 0 : cur_time = tmr->cur_time;
439 [ # # # # ]: 0 : if (adjust_ktime && tmr->running) {
440 : 0 : struct timespec64 tm;
441 : :
442 : 0 : ktime_get_ts64(&tm);
443 : 0 : tm = timespec64_sub(tm, tmr->last_update);
444 : 0 : cur_time.tv_nsec += tm.tv_nsec;
445 : 0 : cur_time.tv_sec += tm.tv_sec;
446 : 0 : snd_seq_sanity_real_time(&cur_time);
447 : : }
448 : 0 : spin_unlock_irqrestore(&tmr->lock, flags);
449 : 0 : return cur_time;
450 : : }
451 : :
452 : : /* TODO: use interpolation on tick queue (will only be useful for very
453 : : high PPQ values) */
454 : 0 : snd_seq_tick_time_t snd_seq_timer_get_cur_tick(struct snd_seq_timer *tmr)
455 : : {
456 : 0 : snd_seq_tick_time_t cur_tick;
457 : 0 : unsigned long flags;
458 : :
459 : 0 : spin_lock_irqsave(&tmr->lock, flags);
460 : 0 : cur_tick = tmr->tick.cur_tick;
461 : 0 : spin_unlock_irqrestore(&tmr->lock, flags);
462 : 0 : return cur_tick;
463 : : }
464 : :
465 : :
466 : : #ifdef CONFIG_SND_PROC_FS
467 : : /* exported to seq_info.c */
468 : 0 : void snd_seq_info_timer_read(struct snd_info_entry *entry,
469 : : struct snd_info_buffer *buffer)
470 : : {
471 : 0 : int idx;
472 : 0 : struct snd_seq_queue *q;
473 : 0 : struct snd_seq_timer *tmr;
474 : 0 : struct snd_timer_instance *ti;
475 : 0 : unsigned long resolution;
476 : :
477 [ # # ]: 0 : for (idx = 0; idx < SNDRV_SEQ_MAX_QUEUES; idx++) {
478 : 0 : q = queueptr(idx);
479 [ # # ]: 0 : if (q == NULL)
480 : 0 : continue;
481 : 0 : mutex_lock(&q->timer_mutex);
482 : 0 : tmr = q->timer;
483 [ # # ]: 0 : if (!tmr)
484 : 0 : goto unlock;
485 : 0 : ti = tmr->timeri;
486 [ # # ]: 0 : if (!ti)
487 : 0 : goto unlock;
488 : 0 : snd_iprintf(buffer, "Timer for queue %i : %s\n", q->queue, ti->timer->name);
489 : 0 : resolution = snd_timer_resolution(ti) * tmr->ticks;
490 : 0 : snd_iprintf(buffer, " Period time : %lu.%09lu\n", resolution / 1000000000, resolution % 1000000000);
491 : 0 : snd_iprintf(buffer, " Skew : %u / %u\n", tmr->skew, tmr->skew_base);
492 : 0 : unlock:
493 : 0 : mutex_unlock(&q->timer_mutex);
494 : 0 : queuefree(q);
495 : : }
496 : 0 : }
497 : : #endif /* CONFIG_SND_PROC_FS */
498 : :
|
