Linux-2.6.12-rc2
[linux-2.6.git] / sound / core / seq / seq_timer.c
1 /*
2  *   ALSA sequencer Timer
3  *   Copyright (c) 1998-1999 by Frank van de Pol <fvdpol@coil.demon.nl>
4  *                              Jaroslav Kysela <perex@suse.cz>
5  *
6  *
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.
11  *
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.
16  *
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
20  *
21  */
22
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"
28 #include "seq_info.h"
29
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;
36
37 #define SKEW_BASE       0x10000 /* 16bit shift */
38
39 void snd_seq_timer_set_tick_resolution(seq_timer_tick_t *tick, int tempo, int ppq, int nticks)
40 {
41         if (tempo < 1000000)
42                 tick->resolution = (tempo * 1000) / ppq;
43         else {
44                 /* might overflow.. */
45                 unsigned int s;
46                 s = tempo % ppq;
47                 s = (s * 1000) / ppq;
48                 tick->resolution = (tempo / ppq) * 1000;
49                 tick->resolution += s;
50         }
51         if (tick->resolution <= 0)
52                 tick->resolution = 1;
53         tick->resolution *= nticks;
54         snd_seq_timer_update_tick(tick, 0);
55 }
56
57 /* create new timer (constructor) */
58 seq_timer_t *snd_seq_timer_new(void)
59 {
60         seq_timer_t *tmr;
61         
62         tmr = kcalloc(1, sizeof(*tmr), GFP_KERNEL);
63         if (tmr == NULL) {
64                 snd_printd("malloc failed for snd_seq_timer_new() \n");
65                 return NULL;
66         }
67         spin_lock_init(&tmr->lock);
68
69         /* reset setup to defaults */
70         snd_seq_timer_defaults(tmr);
71         
72         /* reset time */
73         snd_seq_timer_reset(tmr);
74         
75         return tmr;
76 }
77
78 /* delete timer (destructor) */
79 void snd_seq_timer_delete(seq_timer_t **tmr)
80 {
81         seq_timer_t *t = *tmr;
82         *tmr = NULL;
83
84         if (t == NULL) {
85                 snd_printd("oops: snd_seq_timer_delete() called with NULL timer\n");
86                 return;
87         }
88         t->running = 0;
89
90         /* reset time */
91         snd_seq_timer_stop(t);
92         snd_seq_timer_reset(t);
93
94         kfree(t);
95 }
96
97 void snd_seq_timer_defaults(seq_timer_t * tmr)
98 {
99         /* setup defaults */
100         tmr->ppq = 96;          /* 96 PPQ */
101         tmr->tempo = 500000;    /* 120 BPM */
102         snd_seq_timer_set_tick_resolution(&tmr->tick, tmr->tempo, tmr->ppq, 1);
103         tmr->running = 0;
104
105         tmr->type = SNDRV_SEQ_TIMER_ALSA;
106         tmr->alsa_id.dev_class = seq_default_timer_class;
107         tmr->alsa_id.dev_sclass = seq_default_timer_sclass;
108         tmr->alsa_id.card = seq_default_timer_card;
109         tmr->alsa_id.device = seq_default_timer_device;
110         tmr->alsa_id.subdevice = seq_default_timer_subdevice;
111         tmr->preferred_resolution = seq_default_timer_resolution;
112
113         tmr->skew = tmr->skew_base = SKEW_BASE;
114 }
115
116 void snd_seq_timer_reset(seq_timer_t * tmr)
117 {
118         unsigned long flags;
119
120         spin_lock_irqsave(&tmr->lock, flags);
121
122         /* reset time & songposition */
123         tmr->cur_time.tv_sec = 0;
124         tmr->cur_time.tv_nsec = 0;
125
126         tmr->tick.cur_tick = 0;
127         tmr->tick.fraction = 0;
128
129         spin_unlock_irqrestore(&tmr->lock, flags);
130 }
131
132
133 /* called by timer interrupt routine. the period time since previous invocation is passed */
134 static void snd_seq_timer_interrupt(snd_timer_instance_t *timeri,
135                                     unsigned long resolution,
136                                     unsigned long ticks)
137 {
138         unsigned long flags;
139         queue_t *q = (queue_t *)timeri->callback_data;
140         seq_timer_t *tmr;
141
142         if (q == NULL)
143                 return;
144         tmr = q->timer;
145         if (tmr == NULL)
146                 return;
147         if (!tmr->running)
148                 return;
149
150         resolution *= ticks;
151         if (tmr->skew != tmr->skew_base) {
152                 /* FIXME: assuming skew_base = 0x10000 */
153                 resolution = (resolution >> 16) * tmr->skew +
154                         (((resolution & 0xffff) * tmr->skew) >> 16);
155         }
156
157         spin_lock_irqsave(&tmr->lock, flags);
158
159         /* update timer */
160         snd_seq_inc_time_nsec(&tmr->cur_time, resolution);
161
162         /* calculate current tick */
163         snd_seq_timer_update_tick(&tmr->tick, resolution);
164
165         /* register actual time of this timer update */
166         do_gettimeofday(&tmr->last_update);
167
168         spin_unlock_irqrestore(&tmr->lock, flags);
169
170         /* check queues and dispatch events */
171         snd_seq_check_queue(q, 1, 0);
172 }
173
174 /* set current tempo */
175 int snd_seq_timer_set_tempo(seq_timer_t * tmr, int tempo)
176 {
177         unsigned long flags;
178
179         snd_assert(tmr, return -EINVAL);
180         if (tempo <= 0)
181                 return -EINVAL;
182         spin_lock_irqsave(&tmr->lock, flags);
183         if ((unsigned int)tempo != tmr->tempo) {
184                 tmr->tempo = tempo;
185                 snd_seq_timer_set_tick_resolution(&tmr->tick, tmr->tempo, tmr->ppq, 1);
186         }
187         spin_unlock_irqrestore(&tmr->lock, flags);
188         return 0;
189 }
190
191 /* set current ppq */
192 int snd_seq_timer_set_ppq(seq_timer_t * tmr, int ppq)
193 {
194         unsigned long flags;
195
196         snd_assert(tmr, return -EINVAL);
197         if (ppq <= 0)
198                 return -EINVAL;
199         spin_lock_irqsave(&tmr->lock, flags);
200         if (tmr->running && (ppq != tmr->ppq)) {
201                 /* refuse to change ppq on running timers */
202                 /* because it will upset the song position (ticks) */
203                 spin_unlock_irqrestore(&tmr->lock, flags);
204                 snd_printd("seq: cannot change ppq of a running timer\n");
205                 return -EBUSY;
206         }
207
208         tmr->ppq = ppq;
209         snd_seq_timer_set_tick_resolution(&tmr->tick, tmr->tempo, tmr->ppq, 1);
210         spin_unlock_irqrestore(&tmr->lock, flags);
211         return 0;
212 }
213
214 /* set current tick position */
215 int snd_seq_timer_set_position_tick(seq_timer_t *tmr, snd_seq_tick_time_t position)
216 {
217         unsigned long flags;
218
219         snd_assert(tmr, return -EINVAL);
220
221         spin_lock_irqsave(&tmr->lock, flags);
222         tmr->tick.cur_tick = position;
223         tmr->tick.fraction = 0;
224         spin_unlock_irqrestore(&tmr->lock, flags);
225         return 0;
226 }
227
228 /* set current real-time position */
229 int snd_seq_timer_set_position_time(seq_timer_t *tmr, snd_seq_real_time_t position)
230 {
231         unsigned long flags;
232
233         snd_assert(tmr, return -EINVAL);
234
235         snd_seq_sanity_real_time(&position);
236         spin_lock_irqsave(&tmr->lock, flags);
237         tmr->cur_time = position;
238         spin_unlock_irqrestore(&tmr->lock, flags);
239         return 0;
240 }
241
242 /* set timer skew */
243 int snd_seq_timer_set_skew(seq_timer_t *tmr, unsigned int skew, unsigned int base)
244 {
245         unsigned long flags;
246
247         snd_assert(tmr, return -EINVAL);
248
249         /* FIXME */
250         if (base != SKEW_BASE) {
251                 snd_printd("invalid skew base 0x%x\n", base);
252                 return -EINVAL;
253         }
254         spin_lock_irqsave(&tmr->lock, flags);
255         tmr->skew = skew;
256         spin_unlock_irqrestore(&tmr->lock, flags);
257         return 0;
258 }
259
260 int snd_seq_timer_open(queue_t *q)
261 {
262         snd_timer_instance_t *t;
263         seq_timer_t *tmr;
264         char str[32];
265         int err;
266
267         tmr = q->timer;
268         snd_assert(tmr != NULL, return -EINVAL);
269         if (tmr->timeri)
270                 return -EBUSY;
271         sprintf(str, "sequencer queue %i", q->queue);
272         if (tmr->type != SNDRV_SEQ_TIMER_ALSA)  /* standard ALSA timer */
273                 return -EINVAL;
274         if (tmr->alsa_id.dev_class != SNDRV_TIMER_CLASS_SLAVE)
275                 tmr->alsa_id.dev_sclass = SNDRV_TIMER_SCLASS_SEQUENCER;
276         err = snd_timer_open(&t, str, &tmr->alsa_id, q->queue);
277         if (err < 0 && tmr->alsa_id.dev_class != SNDRV_TIMER_CLASS_SLAVE) {
278                 if (tmr->alsa_id.dev_class != SNDRV_TIMER_CLASS_GLOBAL ||
279                     tmr->alsa_id.device != SNDRV_TIMER_GLOBAL_SYSTEM) {
280                         snd_timer_id_t tid;
281                         memset(&tid, 0, sizeof(tid));
282                         tid.dev_class = SNDRV_TIMER_CLASS_GLOBAL;
283                         tid.dev_sclass = SNDRV_TIMER_SCLASS_SEQUENCER;
284                         tid.card = -1;
285                         tid.device = SNDRV_TIMER_GLOBAL_SYSTEM;
286                         err = snd_timer_open(&t, str, &tid, q->queue);
287                 }
288                 if (err < 0) {
289                         snd_printk(KERN_ERR "seq fatal error: cannot create timer (%i)\n", err);
290                         return err;
291                 }
292         }
293         t->callback = snd_seq_timer_interrupt;
294         t->callback_data = q;
295         t->flags |= SNDRV_TIMER_IFLG_AUTO;
296         tmr->timeri = t;
297         return 0;
298 }
299
300 int snd_seq_timer_close(queue_t *q)
301 {
302         seq_timer_t *tmr;
303         
304         tmr = q->timer;
305         snd_assert(tmr != NULL, return -EINVAL);
306         if (tmr->timeri) {
307                 snd_timer_stop(tmr->timeri);
308                 snd_timer_close(tmr->timeri);
309                 tmr->timeri = NULL;
310         }
311         return 0;
312 }
313
314 int snd_seq_timer_stop(seq_timer_t * tmr)
315 {
316         if (! tmr->timeri)
317                 return -EINVAL;
318         if (!tmr->running)
319                 return 0;
320         tmr->running = 0;
321         snd_timer_pause(tmr->timeri);
322         return 0;
323 }
324
325 static int initialize_timer(seq_timer_t *tmr)
326 {
327         snd_timer_t *t;
328         t = tmr->timeri->timer;
329         snd_assert(t, return -EINVAL);
330
331         tmr->ticks = 1;
332         if (tmr->preferred_resolution &&
333             ! (t->hw.flags & SNDRV_TIMER_HW_SLAVE)) {
334                 unsigned long r = t->hw.resolution;
335                 if (! r && t->hw.c_resolution)
336                         r = t->hw.c_resolution(t);
337                 if (r) {
338                         tmr->ticks = (unsigned int)(1000000000uL / (r * tmr->preferred_resolution));
339                         if (! tmr->ticks)
340                                 tmr->ticks = 1;
341                 }
342         }
343         tmr->initialized = 1;
344         return 0;
345 }
346
347 int snd_seq_timer_start(seq_timer_t * tmr)
348 {
349         if (! tmr->timeri)
350                 return -EINVAL;
351         if (tmr->running)
352                 snd_seq_timer_stop(tmr);
353         snd_seq_timer_reset(tmr);
354         if (initialize_timer(tmr) < 0)
355                 return -EINVAL;
356         snd_timer_start(tmr->timeri, tmr->ticks);
357         tmr->running = 1;
358         do_gettimeofday(&tmr->last_update);
359         return 0;
360 }
361
362 int snd_seq_timer_continue(seq_timer_t * tmr)
363 {
364         if (! tmr->timeri)
365                 return -EINVAL;
366         if (tmr->running)
367                 return -EBUSY;
368         if (! tmr->initialized) {
369                 snd_seq_timer_reset(tmr);
370                 if (initialize_timer(tmr) < 0)
371                         return -EINVAL;
372         }
373         snd_timer_start(tmr->timeri, tmr->ticks);
374         tmr->running = 1;
375         do_gettimeofday(&tmr->last_update);
376         return 0;
377 }
378
379 /* return current 'real' time. use timeofday() to get better granularity. */
380 snd_seq_real_time_t snd_seq_timer_get_cur_time(seq_timer_t *tmr)
381 {
382         snd_seq_real_time_t cur_time;
383
384         cur_time = tmr->cur_time;
385         if (tmr->running) { 
386                 struct timeval tm;
387                 int usec;
388                 do_gettimeofday(&tm);
389                 usec = (int)(tm.tv_usec - tmr->last_update.tv_usec);
390                 if (usec < 0) {
391                         cur_time.tv_nsec += (1000000 + usec) * 1000;
392                         cur_time.tv_sec += tm.tv_sec - tmr->last_update.tv_sec - 1;
393                 } else {
394                         cur_time.tv_nsec += usec * 1000;
395                         cur_time.tv_sec += tm.tv_sec - tmr->last_update.tv_sec;
396                 }
397                 snd_seq_sanity_real_time(&cur_time);
398         }
399                 
400         return cur_time;        
401 }
402
403 /* TODO: use interpolation on tick queue (will only be useful for very
404  high PPQ values) */
405 snd_seq_tick_time_t snd_seq_timer_get_cur_tick(seq_timer_t *tmr)
406 {
407         return tmr->tick.cur_tick;
408 }
409
410
411 /* exported to seq_info.c */
412 void snd_seq_info_timer_read(snd_info_entry_t *entry, snd_info_buffer_t * buffer)
413 {
414         int idx;
415         queue_t *q;
416         seq_timer_t *tmr;
417         snd_timer_instance_t *ti;
418         unsigned long resolution;
419         
420         for (idx = 0; idx < SNDRV_SEQ_MAX_QUEUES; idx++) {
421                 q = queueptr(idx);
422                 if (q == NULL)
423                         continue;
424                 if ((tmr = q->timer) == NULL ||
425                     (ti = tmr->timeri) == NULL) {
426                         queuefree(q);
427                         continue;
428                 }
429                 snd_iprintf(buffer, "Timer for queue %i : %s\n", q->queue, ti->timer->name);
430                 resolution = snd_timer_resolution(ti) * tmr->ticks;
431                 snd_iprintf(buffer, "  Period time : %lu.%09lu\n", resolution / 1000000000, resolution % 1000000000);
432                 snd_iprintf(buffer, "  Skew : %u / %u\n", tmr->skew, tmr->skew_base);
433                 queuefree(q);
434         }
435 }