drivers/sound/sys_timer.c

   1 /*
   2  * sound/sys_timer.c
   3  *
   4  * The default timer for the Level 2 sequencer interface
   5  * Uses the (1/HZ sec) timer of kernel.
   6  */
   7 /*
   8  * Copyright (C) by Hannu Savolainen 1993-1997
   9  *
  10  * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  11  * Version 2 (June 1991). See the "COPYING" file distributed with this software
  12  * for more info.
  13  */
  14 /*
  15  * Thomas Sailer   : ioctl code reworked (vmalloc/vfree removed)
  16  * Andrew Veliath  : adapted tmr2ticks from level 1 sequencer (avoid overflow)
  17  */
  18 #include <linux/config.h>
  19
  20
  21 #include "sound_config.h"
  22
  23 #ifdef CONFIG_SEQUENCER
  24
  25 static volatile int opened = 0, tmr_running = 0;
  26 static volatile time_t tmr_offs, tmr_ctr;
  27 static volatile unsigned long ticks_offs;
  28 static volatile int curr_tempo, curr_timebase;
  29 static volatile unsigned long curr_ticks;
  30 static volatile unsigned long next_event_time;
  31 static unsigned long prev_event_time;
  32
  33 static void     poll_def_tmr(unsigned long dummy);
  34
  35
  36 static struct timer_list def_tmr =
  37 {NULL, NULL, 0, 0, poll_def_tmr};
  38
  39 static unsigned long
  40 tmr2ticks(int tmr_value)
  41 {
  42         /*
  43          *    Convert timer ticks to MIDI ticks
  44          */
  45
  46         unsigned long tmp;
  47         unsigned long scale;
  48
  49         /* tmr_value (ticks per sec) *
  50            1000000 (usecs per sec) / HZ (ticks per sec) -=> usecs */
  51         tmp = tmr_value * (1000000 / HZ);
  52         scale = (60 * 1000000) / (curr_tempo * curr_timebase);  /* usecs per MIDI tick */
  53         return (tmp + scale / 2) / scale;
  54 }
  55
  56 static void
  57 poll_def_tmr(unsigned long dummy)
  58 {
  59
  60         if (opened)
  61           {
  62
  63                   {
  64                           def_tmr.expires = (1) + jiffies;
  65                           add_timer(&def_tmr);
  66                   };
  67
  68                   if (tmr_running)
  69                     {
  70                             tmr_ctr++;
  71                             curr_ticks = ticks_offs + tmr2ticks(tmr_ctr);
  72
  73                             if (curr_ticks >= next_event_time)
  74                               {
  75                                       next_event_time = (unsigned long) -1;
  76                                       sequencer_timer(0);
  77                               }
  78                     }
  79           }
  80 }
  81
  82 static void
  83 tmr_reset(void)
  84 {
  85         unsigned long   flags;
  86
  87         save_flags(flags);
  88         cli();
  89         tmr_offs = 0;
  90         ticks_offs = 0;
  91         tmr_ctr = 0;
  92         next_event_time = (unsigned long) -1;
  93         prev_event_time = 0;
  94         curr_ticks = 0;
  95         restore_flags(flags);
  96 }
  97
  98 static int
  99 def_tmr_open(int dev, int mode)
 100 {
 101         if (opened)
 102                 return -EBUSY;
 103
 104         tmr_reset();
 105         curr_tempo = 60;
 106         curr_timebase = 100;
 107         opened = 1;
 108
 109         ;
 110
 111         {
 112                 def_tmr.expires = (1) + jiffies;
 113                 add_timer(&def_tmr);
 114         };
 115
 116         return 0;
 117 }
 118
 119 static void
 120 def_tmr_close(int dev)
 121 {
 122         opened = tmr_running = 0;
 123         del_timer(&def_tmr);;
 124 }
 125
 126 static int
 127 def_tmr_event(int dev, unsigned char *event)
 128 {
 129         unsigned char   cmd = event[1];
 130         unsigned long   parm = *(int *) &event[4];
 131
 132         switch (cmd)
 133           {
 134           case TMR_WAIT_REL:
 135                   parm += prev_event_time;
 136           case TMR_WAIT_ABS:
 137                   if (parm > 0)
 138                     {
 139                             long            time;
 140
 141                             if (parm <= curr_ticks)     /* It's the time */
 142                                     return TIMER_NOT_ARMED;
 143
 144                             time = parm;
 145                             next_event_time = prev_event_time = time;
 146
 147                             return TIMER_ARMED;
 148                     }
 149                   break;
 150
 151           case TMR_START:
 152                   tmr_reset();
 153                   tmr_running = 1;
 154                   break;
 155
 156           case TMR_STOP:
 157                   tmr_running = 0;
 158                   break;
 159
 160           case TMR_CONTINUE:
 161                   tmr_running = 1;
 162                   break;
 163
 164           case TMR_TEMPO:
 165                   if (parm)
 166                     {
 167                             if (parm < 8)
 168                                     parm = 8;
 169                             if (parm > 360)
 170                                     parm = 360;
 171                             tmr_offs = tmr_ctr;
 172                             ticks_offs += tmr2ticks(tmr_ctr);
 173                             tmr_ctr = 0;
 174                             curr_tempo = parm;
 175                     }
 176                   break;
 177
 178           case TMR_ECHO:
 179                   seq_copy_to_input(event, 8);
 180                   break;
 181
 182           default:;
 183           }
 184
 185         return TIMER_NOT_ARMED;
 186 }
 187
 188 static unsigned long
 189 def_tmr_get_time(int dev)
 190 {
 191         if (!opened)
 192                 return 0;
 193
 194         return curr_ticks;
 195 }
 196
 197 /* same as sound_timer.c:timer_ioctl!? */
 198 static int def_tmr_ioctl(int dev, unsigned int cmd, caddr_t arg)
 199 {
 200         int val;
 201
 202         switch (cmd) {
 203         case SNDCTL_TMR_SOURCE:
 204                 return __put_user(TMR_INTERNAL, (int *)arg);
 205
 206         case SNDCTL_TMR_START:
 207                 tmr_reset();
 208                 tmr_running = 1;
 209                 return 0;
 210
 211         case SNDCTL_TMR_STOP:
 212                 tmr_running = 0;
 213                 return 0;
 214
 215         case SNDCTL_TMR_CONTINUE:
 216                 tmr_running = 1;
 217                 return 0;
 218
 219         case SNDCTL_TMR_TIMEBASE:
 220                 if (__get_user(val, (int *)arg))
 221                         return -EFAULT;
 222                 if (val) {
 223                         if (val < 1)
 224                                 val = 1;
 225                         if (val > 1000)
 226                                 val = 1000;
 227                         curr_timebase = val;
 228                 }
 229                 return __put_user(curr_timebase, (int *)arg);
 230
 231         case SNDCTL_TMR_TEMPO:
 232                 if (__get_user(val, (int *)arg))
 233                         return -EFAULT;
 234                 if (val) {
 235                         if (val < 8)
 236                                 val = 8;
 237                         if (val > 250)
 238                                 val = 250;
 239                         tmr_offs = tmr_ctr;
 240                         ticks_offs += tmr2ticks(tmr_ctr);
 241                         tmr_ctr = 0;
 242                         curr_tempo = val;
 243                         reprogram_timer();
 244                 }
 245                 return __put_user(curr_tempo, (int *)arg);
 246
 247         case SNDCTL_SEQ_CTRLRATE:
 248                 if (__get_user(val, (int *)arg))
 249                         return -EFAULT;
 250                 if (val != 0)   /* Can't change */
 251                         return -EINVAL;
 252                 val = ((curr_tempo * curr_timebase) + 30) / 60;
 253                 return __put_user(val, (int *)arg);
 254
 255         case SNDCTL_SEQ_GETTIME:
 256                 return __put_user(curr_ticks, (int *)arg);
 257
 258         case SNDCTL_TMR_METRONOME:
 259                 /* NOP */
 260                 break;
 261
 262         default:;
 263         }
 264         return -EINVAL;
 265 }
 266
 267 static void
 268 def_tmr_arm(int dev, long time)
 269 {
 270         if (time < 0)
 271                 time = curr_ticks + 1;
 272         else if (time <= curr_ticks)    /* It's the time */
 273                 return;
 274
 275         next_event_time = prev_event_time = time;
 276
 277         return;
 278 }
 279
 280 struct sound_timer_operations default_sound_timer =
 281 {
 282         {"System clock", 0},
 283         0,                      /* Priority */
 284         0,                      /* Local device link */
 285         def_tmr_open,
 286         def_tmr_close,
 287         def_tmr_event,
 288         def_tmr_get_time,
 289         def_tmr_ioctl,
 290         def_tmr_arm
 291 };
 292
 293 #endif