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