sound/core/seq/seq_timer.c

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