ALSA: seq: Degrade the error message for too many opens
[pandora-kernel.git] / sound / core / seq / oss / seq_oss_timer.c
1 /*
2  * OSS compatible sequencer driver
3  *
4  * Timer control routines
5  *
6  * Copyright (C) 1998,99 Takashi Iwai <tiwai@suse.de>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
21  */
22
23 #include "seq_oss_timer.h"
24 #include "seq_oss_event.h"
25 #include <sound/seq_oss_legacy.h>
26 #include <linux/slab.h>
27
28 /*
29  */
30 #define MIN_OSS_TEMPO           8
31 #define MAX_OSS_TEMPO           360
32 #define MIN_OSS_TIMEBASE        1
33 #define MAX_OSS_TIMEBASE        1000
34
35 /*
36  */
37 static void calc_alsa_tempo(struct seq_oss_timer *timer);
38 static int send_timer_event(struct seq_oss_devinfo *dp, int type, int value);
39
40
41 /*
42  * create and register a new timer.
43  * if queue is not started yet, start it.
44  */
45 struct seq_oss_timer *
46 snd_seq_oss_timer_new(struct seq_oss_devinfo *dp)
47 {
48         struct seq_oss_timer *rec;
49
50         rec = kzalloc(sizeof(*rec), GFP_KERNEL);
51         if (rec == NULL)
52                 return NULL;
53
54         rec->dp = dp;
55         rec->cur_tick = 0;
56         rec->realtime = 0;
57         rec->running = 0;
58         rec->oss_tempo = 60;
59         rec->oss_timebase = 100;
60         calc_alsa_tempo(rec);
61
62         return rec;
63 }
64
65
66 /*
67  * delete timer.
68  * if no more timer exists, stop the queue.
69  */
70 void
71 snd_seq_oss_timer_delete(struct seq_oss_timer *rec)
72 {
73         if (rec) {
74                 snd_seq_oss_timer_stop(rec);
75                 kfree(rec);
76         }
77 }
78
79
80 /*
81  * process one timing event
82  * return 1 : event proceseed -- skip this event
83  *        0 : not a timer event -- enqueue this event
84  */
85 int
86 snd_seq_oss_process_timer_event(struct seq_oss_timer *rec, union evrec *ev)
87 {
88         abstime_t parm = ev->t.time;
89
90         if (ev->t.code == EV_TIMING) {
91                 switch (ev->t.cmd) {
92                 case TMR_WAIT_REL:
93                         parm += rec->cur_tick;
94                         rec->realtime = 0;
95                         /* continue to next */
96                 case TMR_WAIT_ABS:
97                         if (parm == 0) {
98                                 rec->realtime = 1;
99                         } else if (parm >= rec->cur_tick) {
100                                 rec->realtime = 0;
101                                 rec->cur_tick = parm;
102                         }
103                         return 1;       /* skip this event */
104                         
105                 case TMR_START:
106                         snd_seq_oss_timer_start(rec);
107                         return 1;
108
109                 }
110         } else if (ev->s.code == SEQ_WAIT) {
111                 /* time = from 1 to 3 bytes */
112                 parm = (ev->echo >> 8) & 0xffffff;
113                 if (parm > rec->cur_tick) {
114                         /* set next event time */
115                         rec->cur_tick = parm;
116                         rec->realtime = 0;
117                 }
118                 return 1;
119         }
120
121         return 0;
122 }
123
124
125 /*
126  * convert tempo units
127  */
128 static void
129 calc_alsa_tempo(struct seq_oss_timer *timer)
130 {
131         timer->tempo = (60 * 1000000) / timer->oss_tempo;
132         timer->ppq = timer->oss_timebase;
133 }
134
135
136 /*
137  * dispatch a timer event
138  */
139 static int
140 send_timer_event(struct seq_oss_devinfo *dp, int type, int value)
141 {
142         struct snd_seq_event ev;
143
144         memset(&ev, 0, sizeof(ev));
145         ev.type = type;
146         ev.source.client = dp->cseq;
147         ev.source.port = 0;
148         ev.dest.client = SNDRV_SEQ_CLIENT_SYSTEM;
149         ev.dest.port = SNDRV_SEQ_PORT_SYSTEM_TIMER;
150         ev.queue = dp->queue;
151         ev.data.queue.queue = dp->queue;
152         ev.data.queue.param.value = value;
153         return snd_seq_kernel_client_dispatch(dp->cseq, &ev, 1, 0);
154 }
155
156 /*
157  * set queue tempo and start queue
158  */
159 int
160 snd_seq_oss_timer_start(struct seq_oss_timer *timer)
161 {
162         struct seq_oss_devinfo *dp = timer->dp;
163         struct snd_seq_queue_tempo tmprec;
164
165         if (timer->running)
166                 snd_seq_oss_timer_stop(timer);
167
168         memset(&tmprec, 0, sizeof(tmprec));
169         tmprec.queue = dp->queue;
170         tmprec.ppq = timer->ppq;
171         tmprec.tempo = timer->tempo;
172         snd_seq_set_queue_tempo(dp->cseq, &tmprec);
173
174         send_timer_event(dp, SNDRV_SEQ_EVENT_START, 0);
175         timer->running = 1;
176         timer->cur_tick = 0;
177         return 0;
178 }
179
180
181 /*
182  * stop queue
183  */
184 int
185 snd_seq_oss_timer_stop(struct seq_oss_timer *timer)
186 {
187         if (! timer->running)
188                 return 0;
189         send_timer_event(timer->dp, SNDRV_SEQ_EVENT_STOP, 0);
190         timer->running = 0;
191         return 0;
192 }
193
194
195 /*
196  * continue queue
197  */
198 int
199 snd_seq_oss_timer_continue(struct seq_oss_timer *timer)
200 {
201         if (timer->running)
202                 return 0;
203         send_timer_event(timer->dp, SNDRV_SEQ_EVENT_CONTINUE, 0);
204         timer->running = 1;
205         return 0;
206 }
207
208
209 /*
210  * change queue tempo
211  */
212 int
213 snd_seq_oss_timer_tempo(struct seq_oss_timer *timer, int value)
214 {
215         if (value < MIN_OSS_TEMPO)
216                 value = MIN_OSS_TEMPO;
217         else if (value > MAX_OSS_TEMPO)
218                 value = MAX_OSS_TEMPO;
219         timer->oss_tempo = value;
220         calc_alsa_tempo(timer);
221         if (timer->running)
222                 send_timer_event(timer->dp, SNDRV_SEQ_EVENT_TEMPO, timer->tempo);
223         return 0;
224 }
225
226
227 /*
228  * ioctls
229  */
230 int
231 snd_seq_oss_timer_ioctl(struct seq_oss_timer *timer, unsigned int cmd, int __user *arg)
232 {
233         int value;
234
235         if (cmd == SNDCTL_SEQ_CTRLRATE) {
236                 debug_printk(("ctrl rate\n"));
237                 /* if *arg == 0, just return the current rate */
238                 if (get_user(value, arg))
239                         return -EFAULT;
240                 if (value)
241                         return -EINVAL;
242                 value = ((timer->oss_tempo * timer->oss_timebase) + 30) / 60;
243                 return put_user(value, arg) ? -EFAULT : 0;
244         }
245
246         if (timer->dp->seq_mode == SNDRV_SEQ_OSS_MODE_SYNTH)
247                 return 0;
248
249         switch (cmd) {
250         case SNDCTL_TMR_START:
251                 debug_printk(("timer start\n"));
252                 return snd_seq_oss_timer_start(timer);
253         case SNDCTL_TMR_STOP:
254                 debug_printk(("timer stop\n"));
255                 return snd_seq_oss_timer_stop(timer);
256         case SNDCTL_TMR_CONTINUE:
257                 debug_printk(("timer continue\n"));
258                 return snd_seq_oss_timer_continue(timer);
259         case SNDCTL_TMR_TEMPO:
260                 debug_printk(("timer tempo\n"));
261                 if (get_user(value, arg))
262                         return -EFAULT;
263                 return snd_seq_oss_timer_tempo(timer, value);
264         case SNDCTL_TMR_TIMEBASE:
265                 debug_printk(("timer timebase\n"));
266                 if (get_user(value, arg))
267                         return -EFAULT;
268                 if (value < MIN_OSS_TIMEBASE)
269                         value = MIN_OSS_TIMEBASE;
270                 else if (value > MAX_OSS_TIMEBASE)
271                         value = MAX_OSS_TIMEBASE;
272                 timer->oss_timebase = value;
273                 calc_alsa_tempo(timer);
274                 return 0;
275
276         case SNDCTL_TMR_METRONOME:
277         case SNDCTL_TMR_SELECT:
278         case SNDCTL_TMR_SOURCE:
279                 debug_printk(("timer XXX\n"));
280                 /* not supported */
281                 return 0;
282         }
283         return 0;
284 }