perf: Correctly align perf event tracing buffer
[linux-2.6.git] / sound / oss / sound_timer.c
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 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 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         strcpy(sound_timer.info.name, name);
324         sound_timer_devs[n] = &sound_timer;
325 }
326 EXPORT_SYMBOL(sound_timer_init);
327