root/sound/isa/sb/emu8000_callback.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. snd_emu8000_ops_setup
  2. release_voice
  3. terminate_voice
  4. update_voice
  5. get_voice
  6. start_voice
  7. trigger_voice
  8. reset_voice
  9. set_pitch
  10. set_volume
  11. set_pan
  12. set_fmmod
  13. set_tremfreq
  14. set_fm2frq2
  15. set_filterQ
  16. snd_emu8000_tweak_voice
  17. sysex
  18. oss_ioctl
  19. load_fx
   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(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(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(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(hw);
 482                 break;
 483 
 484         case _EMUX_OSS_CHORUS_MODE:
 485                 hw->chorus_mode = p1;
 486                 snd_emu8000_update_chorus_mode(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(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(hw, mode, buf, len);
 529         case SNDRV_EMU8000_LOAD_REVERB_FX:
 530                 return snd_emu8000_load_reverb_fx(hw, mode, buf, len);
 531         }
 532         return -EINVAL;
 533 }
 534
/* [<][>][^][v][top][bottom][index][help] */