m68knommu: make sure 2nd FEC eth interface pins are enabled on 5275 ColdFire
[~shefty/rdma-dev.git] / sound / synth / emux / emux_oss.c
1 /*
2  *  Interface for OSS sequencer emulation
3  *
4  *  Copyright (C) 1999 Takashi Iwai <tiwai@suse.de>
5  *
6  *   This program is free software; you can redistribute it and/or modify
7  *   it under the terms of the GNU General Public License as published by
8  *   the Free Software Foundation; either version 2 of the License, or
9  *   (at your option) any later version.
10  *
11  *   This program is distributed in the hope that it will be useful,
12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *   GNU General Public License for more details.
15  *
16  *   You should have received a copy of the GNU General Public License
17  *   along with this program; if not, write to the Free Software
18  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19  *
20  * Changes
21  * 19990227   Steve Ratcliffe   Made separate file and merged in latest
22  *                              midi emulation.
23  */
24
25
26 #ifdef CONFIG_SND_SEQUENCER_OSS
27
28 #include <linux/export.h>
29 #include <asm/uaccess.h>
30 #include <sound/core.h>
31 #include "emux_voice.h"
32 #include <sound/asoundef.h>
33
34 static int snd_emux_open_seq_oss(struct snd_seq_oss_arg *arg, void *closure);
35 static int snd_emux_close_seq_oss(struct snd_seq_oss_arg *arg);
36 static int snd_emux_ioctl_seq_oss(struct snd_seq_oss_arg *arg, unsigned int cmd,
37                                   unsigned long ioarg);
38 static int snd_emux_load_patch_seq_oss(struct snd_seq_oss_arg *arg, int format,
39                                        const char __user *buf, int offs, int count);
40 static int snd_emux_reset_seq_oss(struct snd_seq_oss_arg *arg);
41 static int snd_emux_event_oss_input(struct snd_seq_event *ev, int direct,
42                                     void *private, int atomic, int hop);
43 static void reset_port_mode(struct snd_emux_port *port, int midi_mode);
44 static void emuspec_control(struct snd_emux *emu, struct snd_emux_port *port,
45                             int cmd, unsigned char *event, int atomic, int hop);
46 static void gusspec_control(struct snd_emux *emu, struct snd_emux_port *port,
47                             int cmd, unsigned char *event, int atomic, int hop);
48 static void fake_event(struct snd_emux *emu, struct snd_emux_port *port,
49                        int ch, int param, int val, int atomic, int hop);
50
51 /* operators */
52 static struct snd_seq_oss_callback oss_callback = {
53         .owner = THIS_MODULE,
54         .open = snd_emux_open_seq_oss,
55         .close = snd_emux_close_seq_oss,
56         .ioctl = snd_emux_ioctl_seq_oss,
57         .load_patch = snd_emux_load_patch_seq_oss,
58         .reset = snd_emux_reset_seq_oss,
59 };
60
61
62 /*
63  * register OSS synth
64  */
65
66 void
67 snd_emux_init_seq_oss(struct snd_emux *emu)
68 {
69         struct snd_seq_oss_reg *arg;
70         struct snd_seq_device *dev;
71
72         if (snd_seq_device_new(emu->card, 0, SNDRV_SEQ_DEV_ID_OSS,
73                                sizeof(struct snd_seq_oss_reg), &dev) < 0)
74                 return;
75
76         emu->oss_synth = dev;
77         strcpy(dev->name, emu->name);
78         arg = SNDRV_SEQ_DEVICE_ARGPTR(dev);
79         arg->type = SYNTH_TYPE_SAMPLE;
80         arg->subtype = SAMPLE_TYPE_AWE32;
81         arg->nvoices = emu->max_voices;
82         arg->oper = oss_callback;
83         arg->private_data = emu;
84
85         /* register to OSS synth table */
86         snd_device_register(emu->card, dev);
87 }
88
89
90 /*
91  * unregister
92  */
93 void
94 snd_emux_detach_seq_oss(struct snd_emux *emu)
95 {
96         if (emu->oss_synth) {
97                 snd_device_free(emu->card, emu->oss_synth);
98                 emu->oss_synth = NULL;
99         }
100 }
101
102
103 /* use port number as a unique soundfont client number */
104 #define SF_CLIENT_NO(p) ((p) + 0x1000)
105
106 /*
107  * open port for OSS sequencer
108  */
109 static int
110 snd_emux_open_seq_oss(struct snd_seq_oss_arg *arg, void *closure)
111 {
112         struct snd_emux *emu;
113         struct snd_emux_port *p;
114         struct snd_seq_port_callback callback;
115         char tmpname[64];
116
117         emu = closure;
118         if (snd_BUG_ON(!arg || !emu))
119                 return -ENXIO;
120
121         mutex_lock(&emu->register_mutex);
122
123         if (!snd_emux_inc_count(emu)) {
124                 mutex_unlock(&emu->register_mutex);
125                 return -EFAULT;
126         }
127
128         memset(&callback, 0, sizeof(callback));
129         callback.owner = THIS_MODULE;
130         callback.event_input = snd_emux_event_oss_input;
131
132         sprintf(tmpname, "%s OSS Port", emu->name);
133         p = snd_emux_create_port(emu, tmpname, 32,
134                                  1, &callback);
135         if (p == NULL) {
136                 snd_printk(KERN_ERR "can't create port\n");
137                 snd_emux_dec_count(emu);
138                 mutex_unlock(&emu->register_mutex);
139                 return -ENOMEM;
140         }
141
142         /* fill the argument data */
143         arg->private_data = p;
144         arg->addr.client = p->chset.client;
145         arg->addr.port = p->chset.port;
146         p->oss_arg = arg;
147
148         reset_port_mode(p, arg->seq_mode);
149
150         snd_emux_reset_port(p);
151
152         mutex_unlock(&emu->register_mutex);
153         return 0;
154 }
155
156
157 #define DEFAULT_DRUM_FLAGS      ((1<<9) | (1<<25))
158
159 /*
160  * reset port mode
161  */
162 static void
163 reset_port_mode(struct snd_emux_port *port, int midi_mode)
164 {
165         if (midi_mode) {
166                 port->port_mode = SNDRV_EMUX_PORT_MODE_OSS_MIDI;
167                 port->drum_flags = DEFAULT_DRUM_FLAGS;
168                 port->volume_atten = 0;
169                 port->oss_arg->event_passing = SNDRV_SEQ_OSS_PROCESS_KEYPRESS;
170         } else {
171                 port->port_mode = SNDRV_EMUX_PORT_MODE_OSS_SYNTH;
172                 port->drum_flags = 0;
173                 port->volume_atten = 32;
174                 port->oss_arg->event_passing = SNDRV_SEQ_OSS_PROCESS_EVENTS;
175         }
176 }
177
178
179 /*
180  * close port
181  */
182 static int
183 snd_emux_close_seq_oss(struct snd_seq_oss_arg *arg)
184 {
185         struct snd_emux *emu;
186         struct snd_emux_port *p;
187
188         if (snd_BUG_ON(!arg))
189                 return -ENXIO;
190         p = arg->private_data;
191         if (snd_BUG_ON(!p))
192                 return -ENXIO;
193
194         emu = p->emu;
195         if (snd_BUG_ON(!emu))
196                 return -ENXIO;
197
198         mutex_lock(&emu->register_mutex);
199         snd_emux_sounds_off_all(p);
200         snd_soundfont_close_check(emu->sflist, SF_CLIENT_NO(p->chset.port));
201         snd_seq_event_port_detach(p->chset.client, p->chset.port);
202         snd_emux_dec_count(emu);
203
204         mutex_unlock(&emu->register_mutex);
205         return 0;
206 }
207
208
209 /*
210  * load patch
211  */
212 static int
213 snd_emux_load_patch_seq_oss(struct snd_seq_oss_arg *arg, int format,
214                             const char __user *buf, int offs, int count)
215 {
216         struct snd_emux *emu;
217         struct snd_emux_port *p;
218         int rc;
219
220         if (snd_BUG_ON(!arg))
221                 return -ENXIO;
222         p = arg->private_data;
223         if (snd_BUG_ON(!p))
224                 return -ENXIO;
225
226         emu = p->emu;
227         if (snd_BUG_ON(!emu))
228                 return -ENXIO;
229
230         if (format == GUS_PATCH)
231                 rc = snd_soundfont_load_guspatch(emu->sflist, buf, count,
232                                                  SF_CLIENT_NO(p->chset.port));
233         else if (format == SNDRV_OSS_SOUNDFONT_PATCH) {
234                 struct soundfont_patch_info patch;
235                 if (count < (int)sizeof(patch))
236                         rc = -EINVAL;
237                 if (copy_from_user(&patch, buf, sizeof(patch)))
238                         rc = -EFAULT;
239                 if (patch.type >= SNDRV_SFNT_LOAD_INFO &&
240                     patch.type <= SNDRV_SFNT_PROBE_DATA)
241                         rc = snd_soundfont_load(emu->sflist, buf, count, SF_CLIENT_NO(p->chset.port));
242                 else {
243                         if (emu->ops.load_fx)
244                                 rc = emu->ops.load_fx(emu, patch.type, patch.optarg, buf, count);
245                         else
246                                 rc = -EINVAL;
247                 }
248         } else
249                 rc = 0;
250         return rc;
251 }
252
253
254 /*
255  * ioctl
256  */
257 static int
258 snd_emux_ioctl_seq_oss(struct snd_seq_oss_arg *arg, unsigned int cmd, unsigned long ioarg)
259 {
260         struct snd_emux_port *p;
261         struct snd_emux *emu;
262
263         if (snd_BUG_ON(!arg))
264                 return -ENXIO;
265         p = arg->private_data;
266         if (snd_BUG_ON(!p))
267                 return -ENXIO;
268
269         emu = p->emu;
270         if (snd_BUG_ON(!emu))
271                 return -ENXIO;
272
273         switch (cmd) {
274         case SNDCTL_SEQ_RESETSAMPLES:
275                 snd_soundfont_remove_samples(emu->sflist);
276                 return 0;
277                         
278         case SNDCTL_SYNTH_MEMAVL:
279                 if (emu->memhdr)
280                         return snd_util_mem_avail(emu->memhdr);
281                 return 0;
282         }
283
284         return 0;
285 }
286
287
288 /*
289  * reset device
290  */
291 static int
292 snd_emux_reset_seq_oss(struct snd_seq_oss_arg *arg)
293 {
294         struct snd_emux_port *p;
295
296         if (snd_BUG_ON(!arg))
297                 return -ENXIO;
298         p = arg->private_data;
299         if (snd_BUG_ON(!p))
300                 return -ENXIO;
301         snd_emux_reset_port(p);
302         return 0;
303 }
304
305
306 /*
307  * receive raw events: only SEQ_PRIVATE is accepted.
308  */
309 static int
310 snd_emux_event_oss_input(struct snd_seq_event *ev, int direct, void *private_data,
311                          int atomic, int hop)
312 {
313         struct snd_emux *emu;
314         struct snd_emux_port *p;
315         unsigned char cmd, *data;
316
317         p = private_data;
318         if (snd_BUG_ON(!p))
319                 return -EINVAL;
320         emu = p->emu;
321         if (snd_BUG_ON(!emu))
322                 return -EINVAL;
323         if (ev->type != SNDRV_SEQ_EVENT_OSS)
324                 return snd_emux_event_input(ev, direct, private_data, atomic, hop);
325
326         data = ev->data.raw8.d;
327         /* only SEQ_PRIVATE is accepted */
328         if (data[0] != 0xfe)
329                 return 0;
330         cmd = data[2] & _EMUX_OSS_MODE_VALUE_MASK;
331         if (data[2] & _EMUX_OSS_MODE_FLAG)
332                 emuspec_control(emu, p, cmd, data, atomic, hop);
333         else
334                 gusspec_control(emu, p, cmd, data, atomic, hop);
335         return 0;
336 }
337
338
339 /*
340  * OSS/AWE driver specific h/w controls
341  */
342 static void
343 emuspec_control(struct snd_emux *emu, struct snd_emux_port *port, int cmd,
344                 unsigned char *event, int atomic, int hop)
345 {
346         int voice;
347         unsigned short p1;
348         short p2;
349         int i;
350         struct snd_midi_channel *chan;
351
352         voice = event[3];
353         if (voice < 0 || voice >= port->chset.max_channels)
354                 chan = NULL;
355         else
356                 chan = &port->chset.channels[voice];
357
358         p1 = *(unsigned short *) &event[4];
359         p2 = *(short *) &event[6];
360
361         switch (cmd) {
362 #if 0 /* don't do this atomically */
363         case _EMUX_OSS_REMOVE_LAST_SAMPLES:
364                 snd_soundfont_remove_unlocked(emu->sflist);
365                 break;
366 #endif
367         case _EMUX_OSS_SEND_EFFECT:
368                 if (chan)
369                         snd_emux_send_effect_oss(port, chan, p1, p2);
370                 break;
371                 
372         case _EMUX_OSS_TERMINATE_ALL:
373                 snd_emux_terminate_all(emu);
374                 break;
375
376         case _EMUX_OSS_TERMINATE_CHANNEL:
377                 /*snd_emux_mute_channel(emu, chan);*/
378                 break;
379         case _EMUX_OSS_RESET_CHANNEL:
380                 /*snd_emux_channel_init(chset, chan);*/
381                 break;
382
383         case _EMUX_OSS_RELEASE_ALL:
384                 fake_event(emu, port, voice, MIDI_CTL_ALL_NOTES_OFF, 0, atomic, hop);
385                 break;
386         case _EMUX_OSS_NOTEOFF_ALL:
387                 fake_event(emu, port, voice, MIDI_CTL_ALL_SOUNDS_OFF, 0, atomic, hop);
388                 break;
389
390         case _EMUX_OSS_INITIAL_VOLUME:
391                 if (p2) {
392                         port->volume_atten = (short)p1;
393                         snd_emux_update_port(port, SNDRV_EMUX_UPDATE_VOLUME);
394                 }
395                 break;
396
397         case _EMUX_OSS_CHN_PRESSURE:
398                 if (chan) {
399                         chan->midi_pressure = p1;
400                         snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_FMMOD|SNDRV_EMUX_UPDATE_FM2FRQ2);
401                 }
402                 break;
403
404         case _EMUX_OSS_CHANNEL_MODE:
405                 reset_port_mode(port, p1);
406                 snd_emux_reset_port(port);
407                 break;
408
409         case _EMUX_OSS_DRUM_CHANNELS:
410                 port->drum_flags = *(unsigned int*)&event[4];
411                 for (i = 0; i < port->chset.max_channels; i++) {
412                         chan = &port->chset.channels[i];
413                         chan->drum_channel = ((port->drum_flags >> i) & 1) ? 1 : 0;
414                 }
415                 break;
416
417         case _EMUX_OSS_MISC_MODE:
418                 if (p1 < EMUX_MD_END)
419                         port->ctrls[p1] = p2;
420                 break;
421         case _EMUX_OSS_DEBUG_MODE:
422                 break;
423
424         default:
425                 if (emu->ops.oss_ioctl)
426                         emu->ops.oss_ioctl(emu, cmd, p1, p2);
427                 break;
428         }
429 }
430
431 /*
432  * GUS specific h/w controls
433  */
434
435 #include <linux/ultrasound.h>
436
437 static void
438 gusspec_control(struct snd_emux *emu, struct snd_emux_port *port, int cmd,
439                 unsigned char *event, int atomic, int hop)
440 {
441         int voice;
442         unsigned short p1;
443         short p2;
444         int plong;
445         struct snd_midi_channel *chan;
446
447         if (port->port_mode != SNDRV_EMUX_PORT_MODE_OSS_SYNTH)
448                 return;
449         if (cmd == _GUS_NUMVOICES)
450                 return;
451         voice = event[3];
452         if (voice < 0 || voice >= port->chset.max_channels)
453                 return;
454
455         chan = &port->chset.channels[voice];
456
457         p1 = *(unsigned short *) &event[4];
458         p2 = *(short *) &event[6];
459         plong = *(int*) &event[4];
460
461         switch (cmd) {
462         case _GUS_VOICESAMPLE:
463                 chan->midi_program = p1;
464                 return;
465
466         case _GUS_VOICEBALA:
467                 /* 0 to 15 --> 0 to 127 */
468                 chan->control[MIDI_CTL_MSB_PAN] = (int)p1 << 3;
469                 snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_PAN);
470                 return;
471
472         case _GUS_VOICEVOL:
473         case _GUS_VOICEVOL2:
474                 /* not supported yet */
475                 return;
476
477         case _GUS_RAMPRANGE:
478         case _GUS_RAMPRATE:
479         case _GUS_RAMPMODE:
480         case _GUS_RAMPON:
481         case _GUS_RAMPOFF:
482                 /* volume ramping not supported */
483                 return;
484
485         case _GUS_VOLUME_SCALE:
486                 return;
487
488         case _GUS_VOICE_POS:
489 #ifdef SNDRV_EMUX_USE_RAW_EFFECT
490                 snd_emux_send_effect(port, chan, EMUX_FX_SAMPLE_START,
491                                      (short)(plong & 0x7fff),
492                                      EMUX_FX_FLAG_SET);
493                 snd_emux_send_effect(port, chan, EMUX_FX_COARSE_SAMPLE_START,
494                                      (plong >> 15) & 0xffff,
495                                      EMUX_FX_FLAG_SET);
496 #endif
497                 return;
498         }
499 }
500
501
502 /*
503  * send an event to midi emulation
504  */
505 static void
506 fake_event(struct snd_emux *emu, struct snd_emux_port *port, int ch, int param, int val, int atomic, int hop)
507 {
508         struct snd_seq_event ev;
509         memset(&ev, 0, sizeof(ev));
510         ev.type = SNDRV_SEQ_EVENT_CONTROLLER;
511         ev.data.control.channel = ch;
512         ev.data.control.param = param;
513         ev.data.control.value = val;
514         snd_emux_event_input(&ev, 0, port, atomic, hop);
515 }
516
517 #endif /* CONFIG_SND_SEQUENCER_OSS */