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