Merge master.kernel.org:/pub/scm/linux/kernel/git/mchehab/v4l-dvb
[linux-2.6] / sound / oss / sound_timer.c
1 /*
2  * sound/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 spinlock_t 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
80 static void tmr_reset(void)
81 {
82         unsigned long   flags;
83
84         spin_lock_irqsave(&lock,flags);
85         tmr_offs = 0;
86         ticks_offs = 0;
87         tmr_ctr = 0;
88         next_event_time = (unsigned long) -1;
89         prev_event_time = 0;
90         curr_ticks = 0;
91         spin_unlock_irqrestore(&lock,flags);
92 }
93
94 static int timer_open(int dev, int mode)
95 {
96         if (opened)
97                 return -EBUSY;
98         tmr_reset();
99         curr_tempo = 60;
100         curr_timebase = 100;
101         opened = 1;
102         reprogram_timer();
103         return 0;
104 }
105
106 static void timer_close(int dev)
107 {
108         opened = tmr_running = 0;
109         tmr->tmr_disable(tmr->dev);
110 }
111
112 static int timer_event(int dev, unsigned char *event)
113 {
114         unsigned char cmd = event[1];
115         unsigned long parm = *(int *) &event[4];
116
117         switch (cmd)
118         {
119                 case TMR_WAIT_REL:
120                         parm += prev_event_time;
121                 case TMR_WAIT_ABS:
122                         if (parm > 0)
123                         {
124                                 long time;
125
126                                 if (parm <= curr_ticks) /* It's the time */
127                                         return TIMER_NOT_ARMED;
128                                 time = parm;
129                                 next_event_time = prev_event_time = time;
130                                 return TIMER_ARMED;
131                         }
132                         break;
133
134                 case TMR_START:
135                         tmr_reset();
136                         tmr_running = 1;
137                         reprogram_timer();
138                         break;
139
140                 case TMR_STOP:
141                         tmr_running = 0;
142                         break;
143
144                 case TMR_CONTINUE:
145                         tmr_running = 1;
146                         reprogram_timer();
147                         break;
148
149                 case TMR_TEMPO:
150                         if (parm)
151                         {
152                                 if (parm < 8)
153                                         parm = 8;
154                                 if (parm > 250)
155                                         parm = 250;
156                                 tmr_offs = tmr_ctr;
157                                 ticks_offs += tmr2ticks(tmr_ctr);
158                                 tmr_ctr = 0;
159                                 curr_tempo = parm;
160                                 reprogram_timer();
161                         }
162                         break;
163
164                 case TMR_ECHO:
165                         seq_copy_to_input(event, 8);
166                         break;
167
168                 default:;
169         }
170         return TIMER_NOT_ARMED;
171 }
172
173 static unsigned long timer_get_time(int dev)
174 {
175         if (!opened)
176                 return 0;
177         return curr_ticks;
178 }
179
180 static int timer_ioctl(int dev, unsigned int cmd, void __user *arg)
181 {
182         int __user *p = arg;
183         int val;
184
185         switch (cmd) 
186         {
187                 case SNDCTL_TMR_SOURCE:
188                         val = TMR_INTERNAL;
189                         break;
190
191                 case SNDCTL_TMR_START:
192                         tmr_reset();
193                         tmr_running = 1;
194                         return 0;
195                 
196                 case SNDCTL_TMR_STOP:
197                         tmr_running = 0;
198                         return 0;
199
200                 case SNDCTL_TMR_CONTINUE:
201                         tmr_running = 1;
202                         return 0;
203
204                 case SNDCTL_TMR_TIMEBASE:
205                         if (get_user(val, p))
206                                 return -EFAULT;
207                         if (val) 
208                         {
209                                 if (val < 1)
210                                         val = 1;
211                                 if (val > 1000)
212                                         val = 1000;
213                                 curr_timebase = val;
214                         }
215                         val = curr_timebase;
216                         break;
217
218                 case SNDCTL_TMR_TEMPO:
219                         if (get_user(val, p))
220                                 return -EFAULT;
221                         if (val) 
222                         {
223                                 if (val < 8)
224                                         val = 8;
225                                 if (val > 250)
226                                         val = 250;
227                                 tmr_offs = tmr_ctr;
228                                 ticks_offs += tmr2ticks(tmr_ctr);
229                                 tmr_ctr = 0;
230                                 curr_tempo = val;
231                                 reprogram_timer();
232                         }
233                         val = curr_tempo;
234                         break;
235
236                 case SNDCTL_SEQ_CTRLRATE:
237                         if (get_user(val, p))
238                                 return -EFAULT;
239                         if (val != 0)   /* Can't change */
240                                 return -EINVAL;
241                         val = ((curr_tempo * curr_timebase) + 30) / 60;
242                         break;
243                 
244                 case SNDCTL_SEQ_GETTIME:
245                         val = curr_ticks;
246                         break;
247                 
248                 case SNDCTL_TMR_METRONOME:
249                 default:
250                         return -EINVAL;
251         }
252         return put_user(val, p);
253 }
254
255 static void timer_arm(int dev, long time)
256 {
257         if (time < 0)
258                 time = curr_ticks + 1;
259         else if (time <= curr_ticks)    /* It's the time */
260                 return;
261
262         next_event_time = prev_event_time = time;
263         return;
264 }
265
266 static struct sound_timer_operations sound_timer =
267 {
268         .owner          = THIS_MODULE,
269         .info           = {"Sound Timer", 0},
270         .priority       = 1,    /* Priority */
271         .devlink        = 0,    /* Local device link */
272         .open           = timer_open,
273         .close          = timer_close,
274         .event          = timer_event,
275         .get_time       = timer_get_time,
276         .ioctl          = timer_ioctl,
277         .arm_timer      = timer_arm
278 };
279
280 void sound_timer_interrupt(void)
281 {
282         unsigned long flags;
283         
284         if (!opened)
285                 return;
286
287         tmr->tmr_restart(tmr->dev);
288
289         if (!tmr_running)
290                 return;
291
292         spin_lock_irqsave(&lock,flags);
293         tmr_ctr++;
294         curr_ticks = ticks_offs + tmr2ticks(tmr_ctr);
295
296         if (curr_ticks >= next_event_time)
297         {
298                 next_event_time = (unsigned long) -1;
299                 sequencer_timer(0);
300         }
301         spin_unlock_irqrestore(&lock,flags);
302 }
303
304 void  sound_timer_init(struct sound_lowlev_timer *t, char *name)
305 {
306         int n;
307
308         if (initialized)
309         {
310                 if (t->priority <= tmr->priority)
311                         return; /* There is already a similar or better timer */
312                 tmr = t;
313                 return;
314         }
315         initialized = 1;
316         tmr = t;
317
318         n = sound_alloc_timerdev();
319         if (n == -1)
320                 n = 0;          /* Overwrite the system timer */
321         strcpy(sound_timer.info.name, name);
322         sound_timer_devs[n] = &sound_timer;
323 }