[PATCH] ppc32: add sound support for Mac Mini
[linux-2.6.git] / sound / isa / sb / emu8000_callback.c
1 /*
2  *  synth callback routines for the emu8000 (AWE32/64)
3  *
4  *  Copyright (C) 1999 Steve Ratcliffe
5  *  Copyright (C) 1999-2000 Takashi Iwai <tiwai@suse.de>
6  *
7  *   This program is free software; you can redistribute it and/or modify
8  *   it under the terms of the GNU General Public License as published by
9  *   the Free Software Foundation; either version 2 of the License, or
10  *   (at your option) any later version.
11  *
12  *   This program is distributed in the hope that it will be useful,
13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *   GNU General Public License for more details.
16  *
17  *   You should have received a copy of the GNU General Public License
18  *   along with this program; if not, write to the Free Software
19  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
20  */
21
22 #include "emu8000_local.h"
23 #include <sound/asoundef.h>
24
25 /*
26  * prototypes
27  */
28 static snd_emux_voice_t *get_voice(snd_emux_t *emu, snd_emux_port_t *port);
29 static int start_voice(snd_emux_voice_t *vp);
30 static void trigger_voice(snd_emux_voice_t *vp);
31 static void release_voice(snd_emux_voice_t *vp);
32 static void update_voice(snd_emux_voice_t *vp, int update);
33 static void reset_voice(snd_emux_t *emu, int ch);
34 static void terminate_voice(snd_emux_voice_t *vp);
35 static void sysex(snd_emux_t *emu, char *buf, int len, int parsed, snd_midi_channel_set_t *chset);
36 #ifdef CONFIG_SND_SEQUENCER_OSS
37 static int oss_ioctl(snd_emux_t *emu, int cmd, int p1, int p2);
38 #endif
39 static int load_fx(snd_emux_t *emu, int type, int mode, const void __user *buf, long len);
40
41 static void set_pitch(emu8000_t *hw, snd_emux_voice_t *vp);
42 static void set_volume(emu8000_t *hw, snd_emux_voice_t *vp);
43 static void set_pan(emu8000_t *hw, snd_emux_voice_t *vp);
44 static void set_fmmod(emu8000_t *hw, snd_emux_voice_t *vp);
45 static void set_tremfreq(emu8000_t *hw, snd_emux_voice_t *vp);
46 static void set_fm2frq2(emu8000_t *hw, snd_emux_voice_t *vp);
47 static void set_filterQ(emu8000_t *hw, snd_emux_voice_t *vp);
48 static void snd_emu8000_tweak_voice(emu8000_t *emu, int ch);
49
50 /*
51  * Ensure a value is between two points
52  * macro evaluates its args more than once, so changed to upper-case.
53  */
54 #define LIMITVALUE(x, a, b) do { if ((x) < (a)) (x) = (a); else if ((x) > (b)) (x) = (b); } while (0)
55 #define LIMITMAX(x, a) do {if ((x) > (a)) (x) = (a); } while (0)
56
57
58 /*
59  * set up operators
60  */
61 static snd_emux_operators_t emu8000_ops = {
62         .owner =        THIS_MODULE,
63         .get_voice =    get_voice,
64         .prepare =      start_voice,
65         .trigger =      trigger_voice,
66         .release =      release_voice,
67         .update =       update_voice,
68         .terminate =    terminate_voice,
69         .reset =        reset_voice,
70         .sample_new =   snd_emu8000_sample_new,
71         .sample_free =  snd_emu8000_sample_free,
72         .sample_reset = snd_emu8000_sample_reset,
73         .load_fx =      load_fx,
74         .sysex =        sysex,
75 #ifdef CONFIG_SND_SEQUENCER_OSS
76         .oss_ioctl =    oss_ioctl,
77 #endif
78 };
79
80 void
81 snd_emu8000_ops_setup(emu8000_t *hw)
82 {
83         hw->emu->ops = emu8000_ops;
84 }
85
86
87
88 /*
89  * Terminate a voice
90  */
91 static void
92 release_voice(snd_emux_voice_t *vp)
93 {
94         int dcysusv;
95         emu8000_t *hw;
96
97         hw = vp->hw;
98         dcysusv = 0x8000 | (unsigned char)vp->reg.parm.modrelease;
99         EMU8000_DCYSUS_WRITE(hw, vp->ch, dcysusv);
100         dcysusv = 0x8000 | (unsigned char)vp->reg.parm.volrelease;
101         EMU8000_DCYSUSV_WRITE(hw, vp->ch, dcysusv);
102 }
103
104
105 /*
106  */
107 static void
108 terminate_voice(snd_emux_voice_t *vp)
109 {
110         emu8000_t *hw; 
111
112         hw = vp->hw;
113         EMU8000_DCYSUSV_WRITE(hw, vp->ch, 0x807F);
114 }
115
116
117 /*
118  */
119 static void
120 update_voice(snd_emux_voice_t *vp, int update)
121 {
122         emu8000_t *hw;
123
124         hw = vp->hw;
125         if (update & SNDRV_EMUX_UPDATE_VOLUME)
126                 set_volume(hw, vp);
127         if (update & SNDRV_EMUX_UPDATE_PITCH)
128                 set_pitch(hw, vp);
129         if ((update & SNDRV_EMUX_UPDATE_PAN) &&
130             vp->port->ctrls[EMUX_MD_REALTIME_PAN])
131                 set_pan(hw, vp);
132         if (update & SNDRV_EMUX_UPDATE_FMMOD)
133                 set_fmmod(hw, vp);
134         if (update & SNDRV_EMUX_UPDATE_TREMFREQ)
135                 set_tremfreq(hw, vp);
136         if (update & SNDRV_EMUX_UPDATE_FM2FRQ2)
137                 set_fm2frq2(hw, vp);
138         if (update & SNDRV_EMUX_UPDATE_Q)
139                 set_filterQ(hw, vp);
140 }
141
142
143 /*
144  * Find a channel (voice) within the EMU that is not in use or at least
145  * less in use than other channels.  Always returns a valid pointer
146  * no matter what.  If there is a real shortage of voices then one
147  * will be cut. Such is life.
148  *
149  * The channel index (vp->ch) must be initialized in this routine.
150  * In Emu8k, it is identical with the array index.
151  */
152 static snd_emux_voice_t *
153 get_voice(snd_emux_t *emu, snd_emux_port_t *port)
154 {
155         int  i;
156         snd_emux_voice_t *vp;
157         emu8000_t *hw;
158
159         /* what we are looking for, in order of preference */
160         enum {
161                 OFF=0, RELEASED, PLAYING, END
162         };
163
164         /* Keeps track of what we are finding */
165         struct best {
166                 unsigned int  time;
167                 int voice;
168         } best[END];
169         struct best *bp;
170
171         hw = emu->hw;
172
173         for (i = 0; i < END; i++) {
174                 best[i].time = (unsigned int)(-1); /* XXX MAX_?INT really */;
175                 best[i].voice = -1;
176         }
177
178         /*
179          * Go through them all and get a best one to use.
180          */
181         for (i = 0; i < emu->max_voices; i++) {
182                 int state, val;
183
184                 vp = &emu->voices[i];
185                 state = vp->state;
186
187                 if (state == SNDRV_EMUX_ST_OFF)
188                         bp = best + OFF;
189                 else if (state == SNDRV_EMUX_ST_RELEASED ||
190                          state == SNDRV_EMUX_ST_PENDING) {
191                         bp = best + RELEASED;
192                         val = (EMU8000_CVCF_READ(hw, vp->ch) >> 16) & 0xffff;
193                         if (! val)
194                                 bp = best + OFF;
195                 }
196                 else if (state & SNDRV_EMUX_ST_ON)
197                         bp = best + PLAYING;
198                 else
199                         continue;
200
201                 /* check if sample is finished playing (non-looping only) */
202                 if (state != SNDRV_EMUX_ST_OFF &&
203                     (vp->reg.sample_mode & SNDRV_SFNT_SAMPLE_SINGLESHOT)) {
204                         val = EMU8000_CCCA_READ(hw, vp->ch) & 0xffffff;
205                         if (val >= vp->reg.loopstart)
206                                 bp = best + OFF;
207                 }
208
209                 if (vp->time < bp->time) {
210                         bp->time = vp->time;
211                         bp->voice = i;
212                 }
213         }
214
215         for (i = 0; i < END; i++) {
216                 if (best[i].voice >= 0) {
217                         vp = &emu->voices[best[i].voice];
218                         vp->ch = best[i].voice;
219                         return vp;
220                 }
221         }
222
223         /* not found */
224         return NULL;
225 }
226
227 /*
228  */
229 static int
230 start_voice(snd_emux_voice_t *vp)
231 {
232         unsigned int temp;
233         int ch;
234         int addr;
235         snd_midi_channel_t *chan;
236         emu8000_t *hw;
237
238         hw = vp->hw;
239         ch = vp->ch;
240         chan = vp->chan;
241
242         /* channel to be silent and idle */
243         EMU8000_DCYSUSV_WRITE(hw, ch, 0x0080);
244         EMU8000_VTFT_WRITE(hw, ch, 0x0000FFFF);
245         EMU8000_CVCF_WRITE(hw, ch, 0x0000FFFF);
246         EMU8000_PTRX_WRITE(hw, ch, 0);
247         EMU8000_CPF_WRITE(hw, ch, 0);
248
249         /* set pitch offset */
250         set_pitch(hw, vp);
251
252         /* set envelope parameters */
253         EMU8000_ENVVAL_WRITE(hw, ch, vp->reg.parm.moddelay);
254         EMU8000_ATKHLD_WRITE(hw, ch, vp->reg.parm.modatkhld);
255         EMU8000_DCYSUS_WRITE(hw, ch, vp->reg.parm.moddcysus);
256         EMU8000_ENVVOL_WRITE(hw, ch, vp->reg.parm.voldelay);
257         EMU8000_ATKHLDV_WRITE(hw, ch, vp->reg.parm.volatkhld);
258         /* decay/sustain parameter for volume envelope is used
259            for triggerg the voice */
260
261         /* cutoff and volume */
262         set_volume(hw, vp);
263
264         /* modulation envelope heights */
265         EMU8000_PEFE_WRITE(hw, ch, vp->reg.parm.pefe);
266
267         /* lfo1/2 delay */
268         EMU8000_LFO1VAL_WRITE(hw, ch, vp->reg.parm.lfo1delay);
269         EMU8000_LFO2VAL_WRITE(hw, ch, vp->reg.parm.lfo2delay);
270
271         /* lfo1 pitch & cutoff shift */
272         set_fmmod(hw, vp);
273         /* lfo1 volume & freq */
274         set_tremfreq(hw, vp);
275         /* lfo2 pitch & freq */
276         set_fm2frq2(hw, vp);
277         /* pan & loop start */
278         set_pan(hw, vp);
279
280         /* chorus & loop end (chorus 8bit, MSB) */
281         addr = vp->reg.loopend - 1;
282         temp = vp->reg.parm.chorus;
283         temp += (int)chan->control[MIDI_CTL_E3_CHORUS_DEPTH] * 9 / 10;
284         LIMITMAX(temp, 255);
285         temp = (temp <<24) | (unsigned int)addr;
286         EMU8000_CSL_WRITE(hw, ch, temp);
287
288         /* Q & current address (Q 4bit value, MSB) */
289         addr = vp->reg.start - 1;
290         temp = vp->reg.parm.filterQ;
291         temp = (temp<<28) | (unsigned int)addr;
292         EMU8000_CCCA_WRITE(hw, ch, temp);
293
294         /* clear unknown registers */
295         EMU8000_00A0_WRITE(hw, ch, 0);
296         EMU8000_0080_WRITE(hw, ch, 0);
297
298         /* reset volume */
299         temp = vp->vtarget << 16;
300         EMU8000_VTFT_WRITE(hw, ch, temp | vp->ftarget);
301         EMU8000_CVCF_WRITE(hw, ch, temp | 0xff00);
302
303         return 0;
304 }
305
306 /*
307  * Start envelope
308  */
309 static void
310 trigger_voice(snd_emux_voice_t *vp)
311 {
312         int ch = vp->ch;
313         unsigned int temp;
314         emu8000_t *hw;
315
316         hw = vp->hw;
317
318         /* set reverb and pitch target */
319         temp = vp->reg.parm.reverb;
320         temp += (int)vp->chan->control[MIDI_CTL_E1_REVERB_DEPTH] * 9 / 10;
321         LIMITMAX(temp, 255);
322         temp = (temp << 8) | (vp->ptarget << 16) | vp->aaux;
323         EMU8000_PTRX_WRITE(hw, ch, temp);
324         EMU8000_CPF_WRITE(hw, ch, vp->ptarget << 16);
325         EMU8000_DCYSUSV_WRITE(hw, ch, vp->reg.parm.voldcysus);
326 }
327
328 /*
329  * reset voice parameters
330  */
331 static void
332 reset_voice(snd_emux_t *emu, int ch)
333 {
334         emu8000_t *hw;
335
336         hw = emu->hw;
337         EMU8000_DCYSUSV_WRITE(hw, ch, 0x807F);
338         snd_emu8000_tweak_voice(hw, ch);
339 }
340
341 /*
342  * Set the pitch of a possibly playing note.
343  */
344 static void
345 set_pitch(emu8000_t *hw, snd_emux_voice_t *vp)
346 {
347         EMU8000_IP_WRITE(hw, vp->ch, vp->apitch);
348 }
349
350 /*
351  * Set the volume of a possibly already playing note
352  */
353 static void
354 set_volume(emu8000_t *hw, snd_emux_voice_t *vp)
355 {
356         int  ifatn;
357
358         ifatn = (unsigned char)vp->acutoff;
359         ifatn = (ifatn << 8);
360         ifatn |= (unsigned char)vp->avol;
361         EMU8000_IFATN_WRITE(hw, vp->ch, ifatn);
362 }
363
364 /*
365  * Set pan and loop start address.
366  */
367 static void
368 set_pan(emu8000_t *hw, snd_emux_voice_t *vp)
369 {
370         unsigned int temp;
371
372         temp = ((unsigned int)vp->apan<<24) | ((unsigned int)vp->reg.loopstart - 1);
373         EMU8000_PSST_WRITE(hw, vp->ch, temp);
374 }
375
376 #define MOD_SENSE 18
377
378 static void
379 set_fmmod(emu8000_t *hw, snd_emux_voice_t *vp)
380 {
381         unsigned short fmmod;
382         short pitch;
383         unsigned char cutoff;
384         int modulation;
385
386         pitch = (char)(vp->reg.parm.fmmod>>8);
387         cutoff = (vp->reg.parm.fmmod & 0xff);
388         modulation = vp->chan->gm_modulation + vp->chan->midi_pressure;
389         pitch += (MOD_SENSE * modulation) / 1200;
390         LIMITVALUE(pitch, -128, 127);
391         fmmod = ((unsigned char)pitch<<8) | cutoff;
392         EMU8000_FMMOD_WRITE(hw, vp->ch, fmmod);
393 }
394
395 /* set tremolo (lfo1) volume & frequency */
396 static void
397 set_tremfreq(emu8000_t *hw, snd_emux_voice_t *vp)
398 {
399         EMU8000_TREMFRQ_WRITE(hw, vp->ch, vp->reg.parm.tremfrq);
400 }
401
402 /* set lfo2 pitch & frequency */
403 static void
404 set_fm2frq2(emu8000_t *hw, snd_emux_voice_t *vp)
405 {
406         unsigned short fm2frq2;
407         short pitch;
408         unsigned char freq;
409         int modulation;
410
411         pitch = (char)(vp->reg.parm.fm2frq2>>8);
412         freq = vp->reg.parm.fm2frq2 & 0xff;
413         modulation = vp->chan->gm_modulation + vp->chan->midi_pressure;
414         pitch += (MOD_SENSE * modulation) / 1200;
415         LIMITVALUE(pitch, -128, 127);
416         fm2frq2 = ((unsigned char)pitch<<8) | freq;
417         EMU8000_FM2FRQ2_WRITE(hw, vp->ch, fm2frq2);
418 }
419
420 /* set filterQ */
421 static void
422 set_filterQ(emu8000_t *hw, snd_emux_voice_t *vp)
423 {
424         unsigned int addr;
425         addr = EMU8000_CCCA_READ(hw, vp->ch) & 0xffffff;
426         addr |= (vp->reg.parm.filterQ << 28);
427         EMU8000_CCCA_WRITE(hw, vp->ch, addr);
428 }
429
430 /*
431  * set the envelope & LFO parameters to the default values
432  */
433 static void
434 snd_emu8000_tweak_voice(emu8000_t *emu, int i)
435 {
436         /* set all mod/vol envelope shape to minimum */
437         EMU8000_ENVVOL_WRITE(emu, i, 0x8000);
438         EMU8000_ENVVAL_WRITE(emu, i, 0x8000);
439         EMU8000_DCYSUS_WRITE(emu, i, 0x7F7F);
440         EMU8000_ATKHLDV_WRITE(emu, i, 0x7F7F);
441         EMU8000_ATKHLD_WRITE(emu, i, 0x7F7F);
442         EMU8000_PEFE_WRITE(emu, i, 0);  /* mod envelope height to zero */
443         EMU8000_LFO1VAL_WRITE(emu, i, 0x8000); /* no delay for LFO1 */
444         EMU8000_LFO2VAL_WRITE(emu, i, 0x8000);
445         EMU8000_IP_WRITE(emu, i, 0xE000);       /* no pitch shift */
446         EMU8000_IFATN_WRITE(emu, i, 0xFF00);    /* volume to minimum */
447         EMU8000_FMMOD_WRITE(emu, i, 0);
448         EMU8000_TREMFRQ_WRITE(emu, i, 0);
449         EMU8000_FM2FRQ2_WRITE(emu, i, 0);
450 }
451
452 /*
453  * sysex callback
454  */
455 static void
456 sysex(snd_emux_t *emu, char *buf, int len, int parsed, snd_midi_channel_set_t *chset)
457 {
458         emu8000_t *hw;
459
460         hw = emu->hw;
461
462         switch (parsed) {
463         case SNDRV_MIDI_SYSEX_GS_CHORUS_MODE:
464                 hw->chorus_mode = chset->gs_chorus_mode;
465                 snd_emu8000_update_chorus_mode(hw);
466                 break;
467
468         case SNDRV_MIDI_SYSEX_GS_REVERB_MODE:
469                 hw->reverb_mode = chset->gs_reverb_mode;
470                 snd_emu8000_update_reverb_mode(hw);
471                 break;
472         }
473 }
474
475
476 #ifdef CONFIG_SND_SEQUENCER_OSS
477 /*
478  * OSS ioctl callback
479  */
480 static int
481 oss_ioctl(snd_emux_t *emu, int cmd, int p1, int p2)
482 {
483         emu8000_t *hw;
484
485         hw = emu->hw;
486
487         switch (cmd) {
488         case _EMUX_OSS_REVERB_MODE:
489                 hw->reverb_mode = p1;
490                 snd_emu8000_update_reverb_mode(hw);
491                 break;
492
493         case _EMUX_OSS_CHORUS_MODE:
494                 hw->chorus_mode = p1;
495                 snd_emu8000_update_chorus_mode(hw);
496                 break;
497
498         case _EMUX_OSS_INITIALIZE_CHIP:
499                 /* snd_emu8000_init(hw); */ /*ignored*/
500                 break;
501
502         case _EMUX_OSS_EQUALIZER:
503                 hw->bass_level = p1;
504                 hw->treble_level = p2;
505                 snd_emu8000_update_equalizer(hw);
506                 break;
507         }
508         return 0;
509 }
510 #endif
511
512
513 /*
514  * additional patch keys
515  */
516
517 #define SNDRV_EMU8000_LOAD_CHORUS_FX    0x10    /* optarg=mode */
518 #define SNDRV_EMU8000_LOAD_REVERB_FX    0x11    /* optarg=mode */
519
520
521 /*
522  * callback routine
523  */
524
525 static int
526 load_fx(snd_emux_t *emu, int type, int mode, const void __user *buf, long len)
527 {
528         emu8000_t *hw;
529         hw = emu->hw;
530
531         /* skip header */
532         buf += 16;
533         len -= 16;
534
535         switch (type) {
536         case SNDRV_EMU8000_LOAD_CHORUS_FX:
537                 return snd_emu8000_load_chorus_fx(hw, mode, buf, len);
538         case SNDRV_EMU8000_LOAD_REVERB_FX:
539                 return snd_emu8000_load_reverb_fx(hw, mode, buf, len);
540         }
541         return -EINVAL;
542 }
543