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