3 * Copyright (c) 1998-1999 by Frank van de Pol <fvdpol@coil.demon.nl>
4 * Jaroslav Kysela <perex@suse.cz>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include <sound/driver.h>
24 #include <sound/core.h>
25 #include <linux/slab.h>
26 #include "seq_timer.h"
27 #include "seq_queue.h"
30 extern int seq_default_timer_class
;
31 extern int seq_default_timer_sclass
;
32 extern int seq_default_timer_card
;
33 extern int seq_default_timer_device
;
34 extern int seq_default_timer_subdevice
;
35 extern int seq_default_timer_resolution
;
37 /* allowed sequencer timer frequencies, in Hz */
38 #define MIN_FREQUENCY 10
39 #define MAX_FREQUENCY 6250
40 #define DEFAULT_FREQUENCY 1000
42 #define SKEW_BASE 0x10000 /* 16bit shift */
44 static void snd_seq_timer_set_tick_resolution(seq_timer_tick_t
*tick
,
48 tick
->resolution
= (tempo
* 1000) / ppq
;
50 /* might overflow.. */
54 tick
->resolution
= (tempo
/ ppq
) * 1000;
55 tick
->resolution
+= s
;
57 if (tick
->resolution
<= 0)
59 snd_seq_timer_update_tick(tick
, 0);
62 /* create new timer (constructor) */
63 seq_timer_t
*snd_seq_timer_new(void)
67 tmr
= kzalloc(sizeof(*tmr
), GFP_KERNEL
);
69 snd_printd("malloc failed for snd_seq_timer_new() \n");
72 spin_lock_init(&tmr
->lock
);
74 /* reset setup to defaults */
75 snd_seq_timer_defaults(tmr
);
78 snd_seq_timer_reset(tmr
);
83 /* delete timer (destructor) */
84 void snd_seq_timer_delete(seq_timer_t
**tmr
)
86 seq_timer_t
*t
= *tmr
;
90 snd_printd("oops: snd_seq_timer_delete() called with NULL timer\n");
96 snd_seq_timer_stop(t
);
97 snd_seq_timer_reset(t
);
102 void snd_seq_timer_defaults(seq_timer_t
* tmr
)
105 tmr
->ppq
= 96; /* 96 PPQ */
106 tmr
->tempo
= 500000; /* 120 BPM */
107 snd_seq_timer_set_tick_resolution(&tmr
->tick
, tmr
->tempo
, tmr
->ppq
);
110 tmr
->type
= SNDRV_SEQ_TIMER_ALSA
;
111 tmr
->alsa_id
.dev_class
= seq_default_timer_class
;
112 tmr
->alsa_id
.dev_sclass
= seq_default_timer_sclass
;
113 tmr
->alsa_id
.card
= seq_default_timer_card
;
114 tmr
->alsa_id
.device
= seq_default_timer_device
;
115 tmr
->alsa_id
.subdevice
= seq_default_timer_subdevice
;
116 tmr
->preferred_resolution
= seq_default_timer_resolution
;
118 tmr
->skew
= tmr
->skew_base
= SKEW_BASE
;
121 void snd_seq_timer_reset(seq_timer_t
* tmr
)
125 spin_lock_irqsave(&tmr
->lock
, flags
);
127 /* reset time & songposition */
128 tmr
->cur_time
.tv_sec
= 0;
129 tmr
->cur_time
.tv_nsec
= 0;
131 tmr
->tick
.cur_tick
= 0;
132 tmr
->tick
.fraction
= 0;
134 spin_unlock_irqrestore(&tmr
->lock
, flags
);
138 /* called by timer interrupt routine. the period time since previous invocation is passed */
139 static void snd_seq_timer_interrupt(snd_timer_instance_t
*timeri
,
140 unsigned long resolution
,
144 queue_t
*q
= (queue_t
*)timeri
->callback_data
;
156 if (tmr
->skew
!= tmr
->skew_base
) {
157 /* FIXME: assuming skew_base = 0x10000 */
158 resolution
= (resolution
>> 16) * tmr
->skew
+
159 (((resolution
& 0xffff) * tmr
->skew
) >> 16);
162 spin_lock_irqsave(&tmr
->lock
, flags
);
165 snd_seq_inc_time_nsec(&tmr
->cur_time
, resolution
);
167 /* calculate current tick */
168 snd_seq_timer_update_tick(&tmr
->tick
, resolution
);
170 /* register actual time of this timer update */
171 do_gettimeofday(&tmr
->last_update
);
173 spin_unlock_irqrestore(&tmr
->lock
, flags
);
175 /* check queues and dispatch events */
176 snd_seq_check_queue(q
, 1, 0);
179 /* set current tempo */
180 int snd_seq_timer_set_tempo(seq_timer_t
* tmr
, int tempo
)
184 snd_assert(tmr
, return -EINVAL
);
187 spin_lock_irqsave(&tmr
->lock
, flags
);
188 if ((unsigned int)tempo
!= tmr
->tempo
) {
190 snd_seq_timer_set_tick_resolution(&tmr
->tick
, tmr
->tempo
, tmr
->ppq
);
192 spin_unlock_irqrestore(&tmr
->lock
, flags
);
196 /* set current ppq */
197 int snd_seq_timer_set_ppq(seq_timer_t
* tmr
, int ppq
)
201 snd_assert(tmr
, return -EINVAL
);
204 spin_lock_irqsave(&tmr
->lock
, flags
);
205 if (tmr
->running
&& (ppq
!= tmr
->ppq
)) {
206 /* refuse to change ppq on running timers */
207 /* because it will upset the song position (ticks) */
208 spin_unlock_irqrestore(&tmr
->lock
, flags
);
209 snd_printd("seq: cannot change ppq of a running timer\n");
214 snd_seq_timer_set_tick_resolution(&tmr
->tick
, tmr
->tempo
, tmr
->ppq
);
215 spin_unlock_irqrestore(&tmr
->lock
, flags
);
219 /* set current tick position */
220 int snd_seq_timer_set_position_tick(seq_timer_t
*tmr
, snd_seq_tick_time_t position
)
224 snd_assert(tmr
, return -EINVAL
);
226 spin_lock_irqsave(&tmr
->lock
, flags
);
227 tmr
->tick
.cur_tick
= position
;
228 tmr
->tick
.fraction
= 0;
229 spin_unlock_irqrestore(&tmr
->lock
, flags
);
233 /* set current real-time position */
234 int snd_seq_timer_set_position_time(seq_timer_t
*tmr
, snd_seq_real_time_t position
)
238 snd_assert(tmr
, return -EINVAL
);
240 snd_seq_sanity_real_time(&position
);
241 spin_lock_irqsave(&tmr
->lock
, flags
);
242 tmr
->cur_time
= position
;
243 spin_unlock_irqrestore(&tmr
->lock
, flags
);
248 int snd_seq_timer_set_skew(seq_timer_t
*tmr
, unsigned int skew
, unsigned int base
)
252 snd_assert(tmr
, return -EINVAL
);
255 if (base
!= SKEW_BASE
) {
256 snd_printd("invalid skew base 0x%x\n", base
);
259 spin_lock_irqsave(&tmr
->lock
, flags
);
261 spin_unlock_irqrestore(&tmr
->lock
, flags
);
265 int snd_seq_timer_open(queue_t
*q
)
267 snd_timer_instance_t
*t
;
273 snd_assert(tmr
!= NULL
, return -EINVAL
);
276 sprintf(str
, "sequencer queue %i", q
->queue
);
277 if (tmr
->type
!= SNDRV_SEQ_TIMER_ALSA
) /* standard ALSA timer */
279 if (tmr
->alsa_id
.dev_class
!= SNDRV_TIMER_CLASS_SLAVE
)
280 tmr
->alsa_id
.dev_sclass
= SNDRV_TIMER_SCLASS_SEQUENCER
;
281 err
= snd_timer_open(&t
, str
, &tmr
->alsa_id
, q
->queue
);
282 if (err
< 0 && tmr
->alsa_id
.dev_class
!= SNDRV_TIMER_CLASS_SLAVE
) {
283 if (tmr
->alsa_id
.dev_class
!= SNDRV_TIMER_CLASS_GLOBAL
||
284 tmr
->alsa_id
.device
!= SNDRV_TIMER_GLOBAL_SYSTEM
) {
286 memset(&tid
, 0, sizeof(tid
));
287 tid
.dev_class
= SNDRV_TIMER_CLASS_GLOBAL
;
288 tid
.dev_sclass
= SNDRV_TIMER_SCLASS_SEQUENCER
;
290 tid
.device
= SNDRV_TIMER_GLOBAL_SYSTEM
;
291 err
= snd_timer_open(&t
, str
, &tid
, q
->queue
);
294 snd_printk(KERN_ERR
"seq fatal error: cannot create timer (%i)\n", err
);
298 t
->callback
= snd_seq_timer_interrupt
;
299 t
->callback_data
= q
;
300 t
->flags
|= SNDRV_TIMER_IFLG_AUTO
;
305 int snd_seq_timer_close(queue_t
*q
)
310 snd_assert(tmr
!= NULL
, return -EINVAL
);
312 snd_timer_stop(tmr
->timeri
);
313 snd_timer_close(tmr
->timeri
);
319 int snd_seq_timer_stop(seq_timer_t
* tmr
)
326 snd_timer_pause(tmr
->timeri
);
330 static int initialize_timer(seq_timer_t
*tmr
)
335 t
= tmr
->timeri
->timer
;
336 snd_assert(t
, return -EINVAL
);
338 freq
= tmr
->preferred_resolution
;
340 freq
= DEFAULT_FREQUENCY
;
341 else if (freq
< MIN_FREQUENCY
)
342 freq
= MIN_FREQUENCY
;
343 else if (freq
> MAX_FREQUENCY
)
344 freq
= MAX_FREQUENCY
;
347 if (!(t
->hw
.flags
& SNDRV_TIMER_HW_SLAVE
)) {
348 unsigned long r
= t
->hw
.resolution
;
349 if (! r
&& t
->hw
.c_resolution
)
350 r
= t
->hw
.c_resolution(t
);
352 tmr
->ticks
= (unsigned int)(1000000000uL / (r
* freq
));
357 tmr
->initialized
= 1;
361 int snd_seq_timer_start(seq_timer_t
* tmr
)
366 snd_seq_timer_stop(tmr
);
367 snd_seq_timer_reset(tmr
);
368 if (initialize_timer(tmr
) < 0)
370 snd_timer_start(tmr
->timeri
, tmr
->ticks
);
372 do_gettimeofday(&tmr
->last_update
);
376 int snd_seq_timer_continue(seq_timer_t
* tmr
)
382 if (! tmr
->initialized
) {
383 snd_seq_timer_reset(tmr
);
384 if (initialize_timer(tmr
) < 0)
387 snd_timer_start(tmr
->timeri
, tmr
->ticks
);
389 do_gettimeofday(&tmr
->last_update
);
393 /* return current 'real' time. use timeofday() to get better granularity. */
394 snd_seq_real_time_t
snd_seq_timer_get_cur_time(seq_timer_t
*tmr
)
396 snd_seq_real_time_t cur_time
;
398 cur_time
= tmr
->cur_time
;
402 do_gettimeofday(&tm
);
403 usec
= (int)(tm
.tv_usec
- tmr
->last_update
.tv_usec
);
405 cur_time
.tv_nsec
+= (1000000 + usec
) * 1000;
406 cur_time
.tv_sec
+= tm
.tv_sec
- tmr
->last_update
.tv_sec
- 1;
408 cur_time
.tv_nsec
+= usec
* 1000;
409 cur_time
.tv_sec
+= tm
.tv_sec
- tmr
->last_update
.tv_sec
;
411 snd_seq_sanity_real_time(&cur_time
);
417 /* TODO: use interpolation on tick queue (will only be useful for very
419 snd_seq_tick_time_t
snd_seq_timer_get_cur_tick(seq_timer_t
*tmr
)
421 return tmr
->tick
.cur_tick
;
425 /* exported to seq_info.c */
426 void snd_seq_info_timer_read(snd_info_entry_t
*entry
, snd_info_buffer_t
* buffer
)
431 snd_timer_instance_t
*ti
;
432 unsigned long resolution
;
434 for (idx
= 0; idx
< SNDRV_SEQ_MAX_QUEUES
; idx
++) {
438 if ((tmr
= q
->timer
) == NULL
||
439 (ti
= tmr
->timeri
) == NULL
) {
443 snd_iprintf(buffer
, "Timer for queue %i : %s\n", q
->queue
, ti
->timer
->name
);
444 resolution
= snd_timer_resolution(ti
) * tmr
->ticks
;
445 snd_iprintf(buffer
, " Period time : %lu.%09lu\n", resolution
/ 1000000000, resolution
% 1000000000);
446 snd_iprintf(buffer
, " Skew : %u / %u\n", tmr
->skew
, tmr
->skew_base
);