git.oblomov.eu Git - linux-2.6/blob - 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 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