dfbfcfbe5dd26ccbd4c6cda719bf7b51e849b3c9
[linux-3.10.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 #include <sound/driver.h>
26
27 #ifdef CONFIG_SND_SEQUENCER_OSS
28
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         snd_assert(arg != NULL && emu != NULL, return -ENXIO);
119
120         down(&emu->register_mutex);
121
122         if (!snd_emux_inc_count(emu)) {
123                 up(&emu->register_mutex);
124                 return -EFAULT;
125         }
126
127         memset(&callback, 0, sizeof(callback));
128         callback.owner = THIS_MODULE;
129         callback.event_input = snd_emux_event_oss_input;
130
131         sprintf(tmpname, "%s OSS Port", emu->name);
132         p = snd_emux_create_port(emu, tmpname, 32,
133                                  1, &callback);
134         if (p == NULL) {
135                 snd_printk("can't create port\n");
136                 snd_emux_dec_count(emu);
137                 up(&emu->register_mutex);
138                 return -ENOMEM;
139         }
140
141         /* fill the argument data */
142         arg->private_data = p;
143         arg->addr.client = p->chset.client;
144         arg->addr.port = p->chset.port;
145         p->oss_arg = arg;
146
147         reset_port_mode(p, arg->seq_mode);
148
149         snd_emux_reset_port(p);
150
151         up(&emu->register_mutex);
152         return 0;
153 }
154
155
156 #define DEFAULT_DRUM_FLAGS      ((1<<9) | (1<<25))
157
158 /*
159  * reset port mode
160  */
161 static void
162 reset_port_mode(struct snd_emux_port *port, int midi_mode)
163 {
164         if (midi_mode) {
165                 port->port_mode = SNDRV_EMUX_PORT_MODE_OSS_MIDI;
166                 port->drum_flags = DEFAULT_DRUM_FLAGS;
167                 port->volume_atten = 0;
168                 port->oss_arg->event_passing = SNDRV_SEQ_OSS_PROCESS_KEYPRESS;
169         } else {
170                 port->port_mode = SNDRV_EMUX_PORT_MODE_OSS_SYNTH;
171                 port->drum_flags = 0;
172                 port->volume_atten = 32;
173                 port->oss_arg->event_passing = SNDRV_SEQ_OSS_PROCESS_EVENTS;
174         }
175 }
176
177
178 /*
179  * close port
180  */
181 static int
182 snd_emux_close_seq_oss(struct snd_seq_oss_arg *arg)
183 {
184         struct snd_emux *emu;
185         struct snd_emux_port *p;
186
187         snd_assert(arg != NULL, return -ENXIO);
188         p = arg->private_data;
189         snd_assert(p != NULL, return -ENXIO);
190
191         emu = p->emu;
192         snd_assert(emu != NULL, return -ENXIO);
193
194         down(&emu->register_mutex);
195         snd_emux_sounds_off_all(p);
196         snd_soundfont_close_check(emu->sflist, SF_CLIENT_NO(p->chset.port));
197         snd_seq_event_port_detach(p->chset.client, p->chset.port);
198         snd_emux_dec_count(emu);
199
200         up(&emu->register_mutex);
201         return 0;
202 }
203
204
205 /*
206  * load patch
207  */
208 static int
209 snd_emux_load_patch_seq_oss(struct snd_seq_oss_arg *arg, int format,
210                             const char __user *buf, int offs, int count)
211 {
212         struct snd_emux *emu;
213         struct snd_emux_port *p;
214         int rc;
215
216         snd_assert(arg != NULL, return -ENXIO);
217         p = arg->private_data;
218         snd_assert(p != NULL, return -ENXIO);
219
220         emu = p->emu;
221         snd_assert(emu != NULL, return -ENXIO);
222
223         if (format == GUS_PATCH)
224                 rc = snd_soundfont_load_guspatch(emu->sflist, buf, count,
225                                                  SF_CLIENT_NO(p->chset.port));
226         else if (format == SNDRV_OSS_SOUNDFONT_PATCH) {
227                 struct soundfont_patch_info patch;
228                 if (count < (int)sizeof(patch))
229                         rc = -EINVAL;
230                 if (copy_from_user(&patch, buf, sizeof(patch)))
231                         rc = -EFAULT;
232                 if (patch.type >= SNDRV_SFNT_LOAD_INFO &&
233                     patch.type <= SNDRV_SFNT_PROBE_DATA)
234                         rc = snd_soundfont_load(emu->sflist, buf, count, SF_CLIENT_NO(p->chset.port));
235                 else {
236                         if (emu->ops.load_fx)
237                                 rc = emu->ops.load_fx(emu, patch.type, patch.optarg, buf, count);
238                         else
239                                 rc = -EINVAL;
240                 }
241         } else
242                 rc = 0;
243         return rc;
244 }
245
246
247 /*
248  * ioctl
249  */
250 static int
251 snd_emux_ioctl_seq_oss(struct snd_seq_oss_arg *arg, unsigned int cmd, unsigned long ioarg)
252 {
253         struct snd_emux_port *p;
254         struct snd_emux *emu;
255
256         snd_assert(arg != NULL, return -ENXIO);
257         p = arg->private_data;
258         snd_assert(p != NULL, return -ENXIO);
259
260         emu = p->emu;
261         snd_assert(emu != NULL, return -ENXIO);
262
263         switch (cmd) {
264         case SNDCTL_SEQ_RESETSAMPLES:
265                 snd_soundfont_remove_samples(emu->sflist);
266                 return 0;
267                         
268         case SNDCTL_SYNTH_MEMAVL:
269                 if (emu->memhdr)
270                         return snd_util_mem_avail(emu->memhdr);
271                 return 0;
272         }
273
274         return 0;
275 }
276
277
278 /*
279  * reset device
280  */
281 static int
282 snd_emux_reset_seq_oss(struct snd_seq_oss_arg *arg)
283 {
284         struct snd_emux_port *p;
285
286         snd_assert(arg != NULL, return -ENXIO);
287         p = arg->private_data;
288         snd_assert(p != NULL, return -ENXIO);
289         snd_emux_reset_port(p);
290         return 0;
291 }
292
293
294 /*
295  * receive raw events: only SEQ_PRIVATE is accepted.
296  */
297 static int
298 snd_emux_event_oss_input(struct snd_seq_event *ev, int direct, void *private_data,
299                          int atomic, int hop)
300 {
301         struct snd_emux *emu;
302         struct snd_emux_port *p;
303         unsigned char cmd, *data;
304
305         p = private_data;
306         snd_assert(p != NULL, return -EINVAL);
307         emu = p->emu;
308         snd_assert(emu != NULL, return -EINVAL);
309         if (ev->type != SNDRV_SEQ_EVENT_OSS)
310                 return snd_emux_event_input(ev, direct, private_data, atomic, hop);
311
312         data = ev->data.raw8.d;
313         /* only SEQ_PRIVATE is accepted */
314         if (data[0] != 0xfe)
315                 return 0;
316         cmd = data[2] & _EMUX_OSS_MODE_VALUE_MASK;
317         if (data[2] & _EMUX_OSS_MODE_FLAG)
318                 emuspec_control(emu, p, cmd, data, atomic, hop);
319         else
320                 gusspec_control(emu, p, cmd, data, atomic, hop);
321         return 0;
322 }
323
324
325 /*
326  * OSS/AWE driver specific h/w controls
327  */
328 static void
329 emuspec_control(struct snd_emux *emu, struct snd_emux_port *port, int cmd,
330                 unsigned char *event, int atomic, int hop)
331 {
332         int voice;
333         unsigned short p1;
334         short p2;
335         int i;
336         struct snd_midi_channel *chan;
337
338         voice = event[3];
339         if (voice < 0 || voice >= port->chset.max_channels)
340                 chan = NULL;
341         else
342                 chan = &port->chset.channels[voice];
343
344         p1 = *(unsigned short *) &event[4];
345         p2 = *(short *) &event[6];
346
347         switch (cmd) {
348 #if 0 /* don't do this atomically */
349         case _EMUX_OSS_REMOVE_LAST_SAMPLES:
350                 snd_soundfont_remove_unlocked(emu->sflist);
351                 break;
352 #endif
353         case _EMUX_OSS_SEND_EFFECT:
354                 if (chan)
355                         snd_emux_send_effect_oss(port, chan, p1, p2);
356                 break;
357                 
358         case _EMUX_OSS_TERMINATE_ALL:
359                 snd_emux_terminate_all(emu);
360                 break;
361
362         case _EMUX_OSS_TERMINATE_CHANNEL:
363                 /*snd_emux_mute_channel(emu, chan);*/
364                 break;
365         case _EMUX_OSS_RESET_CHANNEL:
366                 /*snd_emux_channel_init(chset, chan);*/
367                 break;
368
369         case _EMUX_OSS_RELEASE_ALL:
370                 fake_event(emu, port, voice, MIDI_CTL_ALL_NOTES_OFF, 0, atomic, hop);
371                 break;
372         case _EMUX_OSS_NOTEOFF_ALL:
373                 fake_event(emu, port, voice, MIDI_CTL_ALL_SOUNDS_OFF, 0, atomic, hop);
374                 break;
375
376         case _EMUX_OSS_INITIAL_VOLUME:
377                 if (p2) {
378                         port->volume_atten = (short)p1;
379                         snd_emux_update_port(port, SNDRV_EMUX_UPDATE_VOLUME);
380                 }
381                 break;
382
383         case _EMUX_OSS_CHN_PRESSURE:
384                 if (chan) {
385                         chan->midi_pressure = p1;
386                         snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_FMMOD|SNDRV_EMUX_UPDATE_FM2FRQ2);
387                 }
388                 break;
389
390         case _EMUX_OSS_CHANNEL_MODE:
391                 reset_port_mode(port, p1);
392                 snd_emux_reset_port(port);
393                 break;
394
395         case _EMUX_OSS_DRUM_CHANNELS:
396                 port->drum_flags = *(unsigned int*)&event[4];
397                 for (i = 0; i < port->chset.max_channels; i++) {
398                         chan = &port->chset.channels[i];
399                         chan->drum_channel = ((port->drum_flags >> i) & 1) ? 1 : 0;
400                 }
401                 break;
402
403         case _EMUX_OSS_MISC_MODE:
404                 if (p1 < EMUX_MD_END)
405                         port->ctrls[p1] = p2;
406                 break;
407         case _EMUX_OSS_DEBUG_MODE:
408                 break;
409
410         default:
411                 if (emu->ops.oss_ioctl)
412                         emu->ops.oss_ioctl(emu, cmd, p1, p2);
413                 break;
414         }
415 }
416
417 /*
418  * GUS specific h/w controls
419  */
420
421 #include <linux/ultrasound.h>
422
423 static void
424 gusspec_control(struct snd_emux *emu, struct snd_emux_port *port, int cmd,
425                 unsigned char *event, int atomic, int hop)
426 {
427         int voice;
428         unsigned short p1;
429         short p2;
430         int plong;
431         struct snd_midi_channel *chan;
432
433         if (port->port_mode != SNDRV_EMUX_PORT_MODE_OSS_SYNTH)
434                 return;
435         if (cmd == _GUS_NUMVOICES)
436                 return;
437         voice = event[3];
438         if (voice < 0 || voice >= port->chset.max_channels)
439                 return;
440
441         chan = &port->chset.channels[voice];
442
443         p1 = *(unsigned short *) &event[4];
444         p2 = *(short *) &event[6];
445         plong = *(int*) &event[4];
446
447         switch (cmd) {
448         case _GUS_VOICESAMPLE:
449                 chan->midi_program = p1;
450                 return;
451
452         case _GUS_VOICEBALA:
453                 /* 0 to 15 --> 0 to 127 */
454                 chan->control[MIDI_CTL_MSB_PAN] = (int)p1 << 3;
455                 snd_emux_update_channel(port, chan, SNDRV_EMUX_UPDATE_PAN);
456                 return;
457
458         case _GUS_VOICEVOL:
459         case _GUS_VOICEVOL2:
460                 /* not supported yet */
461                 return;
462
463         case _GUS_RAMPRANGE:
464         case _GUS_RAMPRATE:
465         case _GUS_RAMPMODE:
466         case _GUS_RAMPON:
467         case _GUS_RAMPOFF:
468                 /* volume ramping not supported */
469                 return;
470
471         case _GUS_VOLUME_SCALE:
472                 return;
473
474         case _GUS_VOICE_POS:
475 #ifdef SNDRV_EMUX_USE_RAW_EFFECT
476                 snd_emux_send_effect(port, chan, EMUX_FX_SAMPLE_START,
477                                      (short)(plong & 0x7fff),
478                                      EMUX_FX_FLAG_SET);
479                 snd_emux_send_effect(port, chan, EMUX_FX_COARSE_SAMPLE_START,
480                                      (plong >> 15) & 0xffff,
481                                      EMUX_FX_FLAG_SET);
482 #endif
483                 return;
484         }
485 }
486
487
488 /*
489  * send an event to midi emulation
490  */
491 static void
492 fake_event(struct snd_emux *emu, struct snd_emux_port *port, int ch, int param, int val, int atomic, int hop)
493 {
494         struct snd_seq_event ev;
495         memset(&ev, 0, sizeof(ev));
496         ev.type = SNDRV_SEQ_EVENT_CONTROLLER;
497         ev.data.control.channel = ch;
498         ev.data.control.param = param;
499         ev.data.control.value = val;
500         snd_emux_event_input(&ev, 0, port, atomic, hop);
501 }
502
503 #endif /* CONFIG_SND_SEQUENCER_OSS */