~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/oss/sound_timer.c

Version: ~ [ linux-5.12-rc1 ] ~ [ linux-5.11.2 ] ~ [ linux-5.10.19 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.101 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.177 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.222 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.258 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.258 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * sound/oss/sound_timer.c
  3  */
  4 /*
  5  * Copyright (C) by Hannu Savolainen 1993-1997
  6  *
  7  * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  8  * Version 2 (June 1991). See the "COPYING" file distributed with this software
  9  * for more info.
 10  */
 11 /*
 12  * Thomas Sailer   : ioctl code reworked (vmalloc/vfree removed)
 13  */
 14 #include <linux/string.h>
 15 #include <linux/spinlock.h>
 16 
 17 #include "sound_config.h"
 18 
 19 static volatile int initialized, opened, tmr_running;
 20 static volatile time_t tmr_offs, tmr_ctr;
 21 static volatile unsigned long ticks_offs;
 22 static volatile int curr_tempo, curr_timebase;
 23 static volatile unsigned long curr_ticks;
 24 static volatile unsigned long next_event_time;
 25 static unsigned long prev_event_time;
 26 static volatile unsigned long usecs_per_tmr;    /* Length of the current interval */
 27 
 28 static struct sound_lowlev_timer *tmr;
 29 static DEFINE_SPINLOCK(lock);
 30 
 31 static unsigned long tmr2ticks(int tmr_value)
 32 {
 33         /*
 34          *    Convert timer ticks to MIDI ticks
 35          */
 36 
 37         unsigned long tmp;
 38         unsigned long scale;
 39 
 40         tmp = tmr_value * usecs_per_tmr;        /* Convert to usecs */
 41         scale = (60 * 1000000) / (curr_tempo * curr_timebase);  /* usecs per MIDI tick */
 42         return (tmp + (scale / 2)) / scale;
 43 }
 44 
 45 void reprogram_timer(void)
 46 {
 47         unsigned long   usecs_per_tick;
 48 
 49         /*
 50          *      The user is changing the timer rate before setting a timer
 51          *      slap, bad bad not allowed.
 52          */
 53          
 54         if(!tmr)
 55                 return;
 56                 
 57         usecs_per_tick = (60 * 1000000) / (curr_tempo * curr_timebase);
 58 
 59         /*
 60          * Don't kill the system by setting too high timer rate
 61          */
 62         if (usecs_per_tick < 2000)
 63                 usecs_per_tick = 2000;
 64 
 65         usecs_per_tmr = tmr->tmr_start(tmr->dev, usecs_per_tick);
 66 }
 67 
 68 void sound_timer_syncinterval(unsigned int new_usecs)
 69 {
 70         /*
 71          *    This routine is called by the hardware level if
 72          *      the clock frequency has changed for some reason.
 73          */
 74         tmr_offs = tmr_ctr;
 75         ticks_offs += tmr2ticks(tmr_ctr);
 76         tmr_ctr = 0;
 77         usecs_per_tmr = new_usecs;
 78 }
 79 EXPORT_SYMBOL(sound_timer_syncinterval);
 80 
 81 static void tmr_reset(void)
 82 {
 83         unsigned long   flags;
 84 
 85         spin_lock_irqsave(&lock,flags);
 86         tmr_offs = 0;
 87         ticks_offs = 0;
 88         tmr_ctr = 0;
 89         next_event_time = (unsigned long) -1;
 90         prev_event_time = 0;
 91         curr_ticks = 0;
 92         spin_unlock_irqrestore(&lock,flags);
 93 }
 94 
 95 static int timer_open(int dev, int mode)
 96 {
 97         if (opened)
 98                 return -EBUSY;
 99         tmr_reset();
100         curr_tempo = 60;
101         curr_timebase = 100;
102         opened = 1;
103         reprogram_timer();
104         return 0;
105 }
106 
107 static void timer_close(int dev)
108 {
109         opened = tmr_running = 0;
110         tmr->tmr_disable(tmr->dev);
111 }
112 
113 static int timer_event(int dev, unsigned char *event)
114 {
115         unsigned char cmd = event[1];
116         unsigned long parm = *(int *) &event[4];
117 
118         switch (cmd)
119         {
120                 case TMR_WAIT_REL:
121                         parm += prev_event_time;
122                 case TMR_WAIT_ABS:
123                         if (parm > 0)
124                         {
125                                 long time;
126 
127                                 if (parm <= curr_ticks) /* It's the time */
128                                         return TIMER_NOT_ARMED;
129                                 time = parm;
130                                 next_event_time = prev_event_time = time;
131                                 return TIMER_ARMED;
132                         }
133                         break;
134 
135                 case TMR_START:
136                         tmr_reset();
137                         tmr_running = 1;
138                         reprogram_timer();
139                         break;
140 
141                 case TMR_STOP:
142                         tmr_running = 0;
143                         break;
144 
145                 case TMR_CONTINUE:
146                         tmr_running = 1;
147                         reprogram_timer();
148                         break;
149 
150                 case TMR_TEMPO:
151                         if (parm)
152                         {
153                                 if (parm < 8)
154                                         parm = 8;
155                                 if (parm > 250)
156                                         parm = 250;
157                                 tmr_offs = tmr_ctr;
158                                 ticks_offs += tmr2ticks(tmr_ctr);
159                                 tmr_ctr = 0;
160                                 curr_tempo = parm;
161                                 reprogram_timer();
162                         }
163                         break;
164 
165                 case TMR_ECHO:
166                         seq_copy_to_input(event, 8);
167                         break;
168 
169                 default:;
170         }
171         return TIMER_NOT_ARMED;
172 }
173 
174 static unsigned long timer_get_time(int dev)
175 {
176         if (!opened)
177                 return 0;
178         return curr_ticks;
179 }
180 
181 static int timer_ioctl(int dev, unsigned int cmd, void __user *arg)
182 {
183         int __user *p = arg;
184         int val;
185 
186         switch (cmd) 
187         {
188                 case SNDCTL_TMR_SOURCE:
189                         val = TMR_INTERNAL;
190                         break;
191 
192                 case SNDCTL_TMR_START:
193                         tmr_reset();
194                         tmr_running = 1;
195                         return 0;
196                 
197                 case SNDCTL_TMR_STOP:
198                         tmr_running = 0;
199                         return 0;
200 
201                 case SNDCTL_TMR_CONTINUE:
202                         tmr_running = 1;
203                         return 0;
204 
205                 case SNDCTL_TMR_TIMEBASE:
206                         if (get_user(val, p))
207                                 return -EFAULT;
208                         if (val) 
209                         {
210                                 if (val < 1)
211                                         val = 1;
212                                 if (val > 1000)
213                                         val = 1000;
214                                 curr_timebase = val;
215                         }
216                         val = curr_timebase;
217                         break;
218 
219                 case SNDCTL_TMR_TEMPO:
220                         if (get_user(val, p))
221                                 return -EFAULT;
222                         if (val) 
223                         {
224                                 if (val < 8)
225                                         val = 8;
226                                 if (val > 250)
227                                         val = 250;
228                                 tmr_offs = tmr_ctr;
229                                 ticks_offs += tmr2ticks(tmr_ctr);
230                                 tmr_ctr = 0;
231                                 curr_tempo = val;
232                                 reprogram_timer();
233                         }
234                         val = curr_tempo;
235                         break;
236 
237                 case SNDCTL_SEQ_CTRLRATE:
238                         if (get_user(val, p))
239                                 return -EFAULT;
240                         if (val != 0)   /* Can't change */
241                                 return -EINVAL;
242                         val = ((curr_tempo * curr_timebase) + 30) / 60;
243                         break;
244                 
245                 case SNDCTL_SEQ_GETTIME:
246                         val = curr_ticks;
247                         break;
248                 
249                 case SNDCTL_TMR_METRONOME:
250                 default:
251                         return -EINVAL;
252         }
253         return put_user(val, p);
254 }
255 
256 static void timer_arm(int dev, long time)
257 {
258         if (time < 0)
259                 time = curr_ticks + 1;
260         else if (time <= curr_ticks)    /* It's the time */
261                 return;
262 
263         next_event_time = prev_event_time = time;
264         return;
265 }
266 
267 static struct sound_timer_operations sound_timer =
268 {
269         .owner          = THIS_MODULE,
270         .info           = {"Sound Timer", 0},
271         .priority       = 1,    /* Priority */
272         .devlink        = 0,    /* Local device link */
273         .open           = timer_open,
274         .close          = timer_close,
275         .event          = timer_event,
276         .get_time       = timer_get_time,
277         .ioctl          = timer_ioctl,
278         .arm_timer      = timer_arm
279 };
280 
281 void sound_timer_interrupt(void)
282 {
283         unsigned long flags;
284         
285         if (!opened)
286                 return;
287 
288         tmr->tmr_restart(tmr->dev);
289 
290         if (!tmr_running)
291                 return;
292 
293         spin_lock_irqsave(&lock,flags);
294         tmr_ctr++;
295         curr_ticks = ticks_offs + tmr2ticks(tmr_ctr);
296 
297         if (curr_ticks >= next_event_time)
298         {
299                 next_event_time = (unsigned long) -1;
300                 sequencer_timer(0);
301         }
302         spin_unlock_irqrestore(&lock,flags);
303 }
304 EXPORT_SYMBOL(sound_timer_interrupt);
305 
306 void  sound_timer_init(struct sound_lowlev_timer *t, char *name)
307 {
308         int n;
309 
310         if (initialized)
311         {
312                 if (t->priority <= tmr->priority)
313                         return; /* There is already a similar or better timer */
314                 tmr = t;
315                 return;
316         }
317         initialized = 1;
318         tmr = t;
319 
320         n = sound_alloc_timerdev();
321         if (n == -1)
322                 n = 0;          /* Overwrite the system timer */
323         strlcpy(sound_timer.info.name, name, sizeof(sound_timer.info.name));
324         sound_timer_devs[n] = &sound_timer;
325 }
326 EXPORT_SYMBOL(sound_timer_init);
327 
328 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp