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 } 436