sound/pci/emu10k1/emu10k1_callback.c

   1 /*
   2  *  synth callback routines for Emu10k1
   3  *
   4  *  Copyright (C) 2000 Takashi Iwai <tiwai@suse.de>
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation; either version 2 of the License, or
   9  *   (at your option) any later version.
  10  *
  11  *   This program is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *   GNU General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU General Public License
  17  *   along with this program; if not, write to the Free Software
  18  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19  */
  20
  21 #include "emu10k1_synth_local.h"
  22 #include <sound/asoundef.h>
  23
  24 /* voice status */
  25 enum {
  26         V_FREE=0, V_OFF, V_RELEASED, V_PLAYING, V_END
  27 };
  28
  29 /* Keeps track of what we are finding */
  30 typedef struct best_voice {
  31         unsigned int time;
  32         int voice;
  33 } best_voice_t;
  34
  35 /*
  36  * prototypes
  37  */
  38 static void lookup_voices(snd_emux_t *emu, emu10k1_t *hw, best_voice_t *best, int active_only);
  39 static snd_emux_voice_t *get_voice(snd_emux_t *emu, snd_emux_port_t *port);
  40 static int start_voice(snd_emux_voice_t *vp);
  41 static void trigger_voice(snd_emux_voice_t *vp);
  42 static void release_voice(snd_emux_voice_t *vp);
  43 static void update_voice(snd_emux_voice_t *vp, int update);
  44 static void terminate_voice(snd_emux_voice_t *vp);
  45 static void free_voice(snd_emux_voice_t *vp);
  46
  47 static void set_fmmod(emu10k1_t *hw, snd_emux_voice_t *vp);
  48 static void set_fm2frq2(emu10k1_t *hw, snd_emux_voice_t *vp);
  49 static void set_filterQ(emu10k1_t *hw, snd_emux_voice_t *vp);
  50
  51 /*
  52  * Ensure a value is between two points
  53  * macro evaluates its args more than once, so changed to upper-case.
  54  */
  55 #define LIMITVALUE(x, a, b) do { if ((x) < (a)) (x) = (a); else if ((x) > (b)) (x) = (b); } while (0)
  56 #define LIMITMAX(x, a) do {if ((x) > (a)) (x) = (a); } while (0)
  57
  58
  59 /*
  60  * set up operators
  61  */
  62 static snd_emux_operators_t emu10k1_ops = {
  63         .owner =        THIS_MODULE,
  64         .get_voice =    get_voice,
  65         .prepare =      start_voice,
  66         .trigger =      trigger_voice,
  67         .release =      release_voice,
  68         .update =       update_voice,
  69         .terminate =    terminate_voice,
  70         .free_voice =   free_voice,
  71         .sample_new =   snd_emu10k1_sample_new,
  72         .sample_free =  snd_emu10k1_sample_free,
  73 };
  74
  75 void
  76 snd_emu10k1_ops_setup(snd_emux_t *emu)
  77 {
  78         emu->ops = emu10k1_ops;
  79 }
  80
  81
  82 /*
  83  * get more voice for pcm
  84  *
  85  * terminate most inactive voice and give it as a pcm voice.
  86  */
  87 int
  88 snd_emu10k1_synth_get_voice(emu10k1_t *hw)
  89 {
  90         snd_emux_t *emu;
  91         snd_emux_voice_t *vp;
  92         best_voice_t best[V_END];
  93         unsigned long flags;
  94         int i;
  95
  96         emu = hw->synth;
  97
  98         spin_lock_irqsave(&emu->voice_lock, flags);
  99         lookup_voices(emu, hw, best, 1); /* no OFF voices */
 100         for (i = 0; i < V_END; i++) {
 101                 if (best[i].voice >= 0) {
 102                         int ch;
 103                         vp = &emu->voices[best[i].voice];
 104                         if ((ch = vp->ch) < 0) {
 105                                 //printk("synth_get_voice: ch < 0 (%d) ??", i);
 106                                 continue;
 107                         }
 108                         vp->emu->num_voices--;
 109                         vp->ch = -1;
 110                         vp->state = SNDRV_EMUX_ST_OFF;
 111                         spin_unlock_irqrestore(&emu->voice_lock, flags);
 112                         return ch;
 113                 }
 114         }
 115         spin_unlock_irqrestore(&emu->voice_lock, flags);
 116
 117         /* not found */
 118         return -ENOMEM;
 119 }
 120
 121
 122 /*
 123  * turn off the voice (not terminated)
 124  */
 125 static void
 126 release_voice(snd_emux_voice_t *vp)
 127 {
 128         int dcysusv;
 129         emu10k1_t *hw;
 130
 131         hw = vp->hw;
 132         dcysusv = 0x8000 | (unsigned char)vp->reg.parm.modrelease;
 133         snd_emu10k1_ptr_write(hw, DCYSUSM, vp->ch, dcysusv);
 134         dcysusv = 0x8000 | (unsigned char)vp->reg.parm.volrelease | DCYSUSV_CHANNELENABLE_MASK;
 135         snd_emu10k1_ptr_write(hw, DCYSUSV, vp->ch, dcysusv);
 136 }
 137
 138
 139 /*
 140  * terminate the voice
 141  */
 142 static void
 143 terminate_voice(snd_emux_voice_t *vp)
 144 {
 145         emu10k1_t *hw;
 146
 147         snd_assert(vp, return);
 148         hw = vp->hw;
 149         snd_emu10k1_ptr_write(hw, DCYSUSV, vp->ch, 0x807f | DCYSUSV_CHANNELENABLE_MASK);
 150         if (vp->block) {
 151                 emu10k1_memblk_t *emem;
 152                 emem = (emu10k1_memblk_t *)vp->block;
 153                 if (emem->map_locked > 0)
 154                         emem->map_locked--;
 155         }
 156 }
 157
 158 /*
 159  * release the voice to system
 160  */
 161 static void
 162 free_voice(snd_emux_voice_t *vp)
 163 {
 164         emu10k1_t *hw;
 165
 166         hw = vp->hw;
 167         if (vp->ch >= 0) {
 168                 snd_emu10k1_ptr_write(hw, IFATN, vp->ch, 0xff00);
 169                 snd_emu10k1_ptr_write(hw, DCYSUSV, vp->ch, 0x807f | DCYSUSV_CHANNELENABLE_MASK);
 170                 // snd_emu10k1_ptr_write(hw, DCYSUSV, vp->ch, 0);
 171                 snd_emu10k1_ptr_write(hw, VTFT, vp->ch, 0xffff);
 172                 snd_emu10k1_ptr_write(hw, CVCF, vp->ch, 0xffff);
 173                 snd_emu10k1_voice_free(hw, &hw->voices[vp->ch]);
 174                 vp->emu->num_voices--;
 175                 vp->ch = -1;
 176         }
 177 }
 178
 179
 180 /*
 181  * update registers
 182  */
 183 static void
 184 update_voice(snd_emux_voice_t *vp, int update)
 185 {
 186         emu10k1_t *hw;
 187
 188         hw = vp->hw;
 189         if (update & SNDRV_EMUX_UPDATE_VOLUME)
 190                 snd_emu10k1_ptr_write(hw, IFATN_ATTENUATION, vp->ch, vp->avol);
 191         if (update & SNDRV_EMUX_UPDATE_PITCH)
 192                 snd_emu10k1_ptr_write(hw, IP, vp->ch, vp->apitch);
 193         if (update & SNDRV_EMUX_UPDATE_PAN) {
 194                 snd_emu10k1_ptr_write(hw, PTRX_FXSENDAMOUNT_A, vp->ch, vp->apan);
 195                 snd_emu10k1_ptr_write(hw, PTRX_FXSENDAMOUNT_B, vp->ch, vp->aaux);
 196         }
 197         if (update & SNDRV_EMUX_UPDATE_FMMOD)
 198                 set_fmmod(hw, vp);
 199         if (update & SNDRV_EMUX_UPDATE_TREMFREQ)
 200                 snd_emu10k1_ptr_write(hw, TREMFRQ, vp->ch, vp->reg.parm.tremfrq);
 201         if (update & SNDRV_EMUX_UPDATE_FM2FRQ2)
 202                 set_fm2frq2(hw, vp);
 203         if (update & SNDRV_EMUX_UPDATE_Q)
 204                 set_filterQ(hw, vp);
 205 }
 206
 207
 208 /*
 209  * look up voice table - get the best voice in order of preference
 210  */
 211 /* spinlock held! */
 212 static void
 213 lookup_voices(snd_emux_t *emu, emu10k1_t *hw, best_voice_t *best, int active_only)
 214 {
 215         snd_emux_voice_t *vp;
 216         best_voice_t *bp;
 217         int  i;
 218
 219         for (i = 0; i < V_END; i++) {
 220                 best[i].time = (unsigned int)-1; /* XXX MAX_?INT really */;
 221                 best[i].voice = -1;
 222         }
 223
 224         /*
 225          * Go through them all and get a best one to use.
 226          * NOTE: could also look at volume and pick the quietest one.
 227          */
 228         for (i = 0; i < emu->max_voices; i++) {
 229                 int state, val;
 230
 231                 vp = &emu->voices[i];
 232                 state = vp->state;
 233                 if (state == SNDRV_EMUX_ST_OFF) {
 234                         if (vp->ch < 0) {
 235                                 if (active_only)
 236                                         continue;
 237                                 bp = best + V_FREE;
 238                         } else
 239                                 bp = best + V_OFF;
 240                 }
 241                 else if (state == SNDRV_EMUX_ST_RELEASED ||
 242                          state == SNDRV_EMUX_ST_PENDING) {
 243                         bp = best + V_RELEASED;
 244 #if 1
 245                         val = snd_emu10k1_ptr_read(hw, CVCF_CURRENTVOL, vp->ch);
 246                         if (! val)
 247                                 bp = best + V_OFF;
 248 #endif
 249                 }
 250                 else if (state == SNDRV_EMUX_ST_STANDBY)
 251                         continue;
 252                 else if (state & SNDRV_EMUX_ST_ON)
 253                         bp = best + V_PLAYING;
 254                 else
 255                         continue;
 256
 257                 /* check if sample is finished playing (non-looping only) */
 258                 if (bp != best + V_OFF && bp != best + V_FREE &&
 259                     (vp->reg.sample_mode & SNDRV_SFNT_SAMPLE_SINGLESHOT)) {
 260                         val = snd_emu10k1_ptr_read(hw, CCCA_CURRADDR, vp->ch);
 261                         if (val >= vp->reg.loopstart)
 262                                 bp = best + V_OFF;
 263                 }
 264
 265                 if (vp->time < bp->time) {
 266                         bp->time = vp->time;
 267                         bp->voice = i;
 268                 }
 269         }
 270 }
 271
 272 /*
 273  * get an empty voice
 274  *
 275  * emu->voice_lock is already held.
 276  */
 277 static snd_emux_voice_t *
 278 get_voice(snd_emux_t *emu, snd_emux_port_t *port)
 279 {
 280         emu10k1_t *hw;
 281         snd_emux_voice_t *vp;
 282         best_voice_t best[V_END];
 283         int i;
 284
 285         hw = emu->hw;
 286
 287         lookup_voices(emu, hw, best, 0);
 288         for (i = 0; i < V_END; i++) {
 289                 if (best[i].voice >= 0) {
 290                         vp = &emu->voices[best[i].voice];
 291                         if (vp->ch < 0) {
 292                                 /* allocate a voice */
 293                                 emu10k1_voice_t *hwvoice;
 294                                 if (snd_emu10k1_voice_alloc(hw, EMU10K1_SYNTH, 1, &hwvoice) < 0 || hwvoice == NULL)
 295                                         continue;
 296                                 vp->ch = hwvoice->number;
 297                                 emu->num_voices++;
 298                         }
 299                         return vp;
 300                 }
 301         }
 302
 303         /* not found */
 304         return NULL;
 305 }
 306
 307 /*
 308  * prepare envelopes and LFOs
 309  */
 310 static int
 311 start_voice(snd_emux_voice_t *vp)
 312 {
 313         unsigned int temp;
 314         int ch;
 315         unsigned int addr, mapped_offset;
 316         snd_midi_channel_t *chan;
 317         emu10k1_t *hw;
 318         emu10k1_memblk_t *emem;
 319
 320         hw = vp->hw;
 321         ch = vp->ch;
 322         snd_assert(ch >= 0, return -EINVAL);
 323         chan = vp->chan;
 324
 325         emem = (emu10k1_memblk_t *)vp->block;
 326         if (emem == NULL)
 327                 return -EINVAL;
 328         emem->map_locked++;
 329         if (snd_emu10k1_memblk_map(hw, emem) < 0) {
 330                 // printk("emu: cannot map!\n");
 331                 return -ENOMEM;
 332         }
 333         mapped_offset = snd_emu10k1_memblk_offset(emem) >> 1;
 334         vp->reg.start += mapped_offset;
 335         vp->reg.end += mapped_offset;
 336         vp->reg.loopstart += mapped_offset;
 337         vp->reg.loopend += mapped_offset;
 338
 339         /* set channel routing */
 340         /* A = left(0), B = right(1), C = reverb(c), D = chorus(d) */
 341         if (hw->audigy) {
 342                 temp = FXBUS_MIDI_LEFT | (FXBUS_MIDI_RIGHT << 8) |
 343                         (FXBUS_MIDI_REVERB << 16) | (FXBUS_MIDI_CHORUS << 24);
 344                 snd_emu10k1_ptr_write(hw, A_FXRT1, ch, temp);
 345         } else {
 346                 temp = (FXBUS_MIDI_LEFT << 16) | (FXBUS_MIDI_RIGHT << 20) |
 347                         (FXBUS_MIDI_REVERB << 24) | (FXBUS_MIDI_CHORUS << 28);
 348                 snd_emu10k1_ptr_write(hw, FXRT, ch, temp);
 349         }
 350
 351         /* channel to be silent and idle */
 352         snd_emu10k1_ptr_write(hw, DCYSUSV, ch, 0x0000);
 353         snd_emu10k1_ptr_write(hw, VTFT, ch, 0x0000FFFF);
 354         snd_emu10k1_ptr_write(hw, CVCF, ch, 0x0000FFFF);
 355         snd_emu10k1_ptr_write(hw, PTRX, ch, 0);
 356         snd_emu10k1_ptr_write(hw, CPF, ch, 0);
 357
 358         /* set pitch offset */
 359         snd_emu10k1_ptr_write(hw, IP, vp->ch, vp->apitch);
 360
 361         /* set envelope parameters */
 362         snd_emu10k1_ptr_write(hw, ENVVAL, ch, vp->reg.parm.moddelay);
 363         snd_emu10k1_ptr_write(hw, ATKHLDM, ch, vp->reg.parm.modatkhld);
 364         snd_emu10k1_ptr_write(hw, DCYSUSM, ch, vp->reg.parm.moddcysus);
 365         snd_emu10k1_ptr_write(hw, ENVVOL, ch, vp->reg.parm.voldelay);
 366         snd_emu10k1_ptr_write(hw, ATKHLDV, ch, vp->reg.parm.volatkhld);
 367         /* decay/sustain parameter for volume envelope is used
 368            for triggerg the voice */
 369
 370         /* cutoff and volume */
 371         temp = (unsigned int)vp->acutoff << 8 | (unsigned char)vp->avol;
 372         snd_emu10k1_ptr_write(hw, IFATN, vp->ch, temp);
 373
 374         /* modulation envelope heights */
 375         snd_emu10k1_ptr_write(hw, PEFE, ch, vp->reg.parm.pefe);
 376
 377         /* lfo1/2 delay */
 378         snd_emu10k1_ptr_write(hw, LFOVAL1, ch, vp->reg.parm.lfo1delay);
 379         snd_emu10k1_ptr_write(hw, LFOVAL2, ch, vp->reg.parm.lfo2delay);
 380
 381         /* lfo1 pitch & cutoff shift */
 382         set_fmmod(hw, vp);
 383         /* lfo1 volume & freq */
 384         snd_emu10k1_ptr_write(hw, TREMFRQ, vp->ch, vp->reg.parm.tremfrq);
 385         /* lfo2 pitch & freq */
 386         set_fm2frq2(hw, vp);
 387
 388         /* reverb and loop start (reverb 8bit, MSB) */
 389         temp = vp->reg.parm.reverb;
 390         temp += (int)vp->chan->control[MIDI_CTL_E1_REVERB_DEPTH] * 9 / 10;
 391         LIMITMAX(temp, 255);
 392         addr = vp->reg.loopstart;
 393         snd_emu10k1_ptr_write(hw, PSST, vp->ch, (temp << 24) | addr);
 394
 395         /* chorus & loop end (chorus 8bit, MSB) */
 396         addr = vp->reg.loopend;
 397         temp = vp->reg.parm.chorus;
 398         temp += (int)chan->control[MIDI_CTL_E3_CHORUS_DEPTH] * 9 / 10;
 399         LIMITMAX(temp, 255);
 400         temp = (temp <<24) | addr;
 401         snd_emu10k1_ptr_write(hw, DSL, ch, temp);
 402
 403         /* clear filter delay memory */
 404         snd_emu10k1_ptr_write(hw, Z1, ch, 0);
 405         snd_emu10k1_ptr_write(hw, Z2, ch, 0);
 406
 407         /* invalidate maps */
 408         temp = (hw->silent_page.addr << 1) | MAP_PTI_MASK;
 409         snd_emu10k1_ptr_write(hw, MAPA, ch, temp);
 410         snd_emu10k1_ptr_write(hw, MAPB, ch, temp);
 411 #if 0
 412         /* cache */
 413         {
 414                 unsigned int val, sample;
 415                 val = 32;
 416                 if (vp->reg.sample_mode & SNDRV_SFNT_SAMPLE_8BITS)
 417                         sample = 0x80808080;
 418                 else {
 419                         sample = 0;
 420                         val *= 2;
 421                 }
 422
 423                 /* cache */
 424                 snd_emu10k1_ptr_write(hw, CCR, ch, 0x1c << 16);
 425                 snd_emu10k1_ptr_write(hw, CDE, ch, sample);
 426                 snd_emu10k1_ptr_write(hw, CDF, ch, sample);
 427
 428                 /* invalidate maps */
 429                 temp = ((unsigned int)hw->silent_page.addr << 1) | MAP_PTI_MASK;
 430                 snd_emu10k1_ptr_write(hw, MAPA, ch, temp);
 431                 snd_emu10k1_ptr_write(hw, MAPB, ch, temp);
 432
 433                 /* fill cache */
 434                 val -= 4;
 435                 val <<= 25;
 436                 val |= 0x1c << 16;
 437                 snd_emu10k1_ptr_write(hw, CCR, ch, val);
 438         }
 439 #endif
 440
 441         /* Q & current address (Q 4bit value, MSB) */
 442         addr = vp->reg.start;
 443         temp = vp->reg.parm.filterQ;
 444         temp = (temp<<28) | addr;
 445         if (vp->apitch < 0xe400)
 446                 temp |= CCCA_INTERPROM_0;
 447         else {
 448                 unsigned int shift = (vp->apitch - 0xe000) >> 10;
 449                 temp |= shift << 25;
 450         }
 451         if (vp->reg.sample_mode & SNDRV_SFNT_SAMPLE_8BITS)
 452                 temp |= CCCA_8BITSELECT;
 453         snd_emu10k1_ptr_write(hw, CCCA, ch, temp);
 454
 455         /* reset volume */
 456         temp = (unsigned int)vp->vtarget << 16;
 457         snd_emu10k1_ptr_write(hw, VTFT, ch, temp | vp->ftarget);
 458         snd_emu10k1_ptr_write(hw, CVCF, ch, temp | 0xff00);
 459         return 0;
 460 }
 461
 462 /*
 463  * Start envelope
 464  */
 465 static void
 466 trigger_voice(snd_emux_voice_t *vp)
 467 {
 468         unsigned int temp, ptarget;
 469         emu10k1_t *hw;
 470         emu10k1_memblk_t *emem;
 471
 472         hw = vp->hw;
 473
 474         emem = (emu10k1_memblk_t *)vp->block;
 475         if (! emem || emem->mapped_page < 0)
 476                 return; /* not mapped */
 477
 478 #if 0
 479         ptarget = (unsigned int)vp->ptarget << 16;
 480 #else
 481         ptarget = IP_TO_CP(vp->apitch);
 482 #endif
 483         /* set pitch target and pan (volume) */
 484         temp = ptarget | (vp->apan << 8) | vp->aaux;
 485         snd_emu10k1_ptr_write(hw, PTRX, vp->ch, temp);
 486
 487         /* pitch target */
 488         snd_emu10k1_ptr_write(hw, CPF, vp->ch, ptarget);
 489
 490         /* trigger voice */
 491         snd_emu10k1_ptr_write(hw, DCYSUSV, vp->ch, vp->reg.parm.voldcysus|DCYSUSV_CHANNELENABLE_MASK);
 492 }
 493
 494 #define MOD_SENSE 18
 495
 496 /* set lfo1 modulation height and cutoff */
 497 static void
 498 set_fmmod(emu10k1_t *hw, snd_emux_voice_t *vp)
 499 {
 500         unsigned short fmmod;
 501         short pitch;
 502         unsigned char cutoff;
 503         int modulation;
 504
 505         pitch = (char)(vp->reg.parm.fmmod>>8);
 506         cutoff = (vp->reg.parm.fmmod & 0xff);
 507         modulation = vp->chan->gm_modulation + vp->chan->midi_pressure;
 508         pitch += (MOD_SENSE * modulation) / 1200;
 509         LIMITVALUE(pitch, -128, 127);
 510         fmmod = ((unsigned char)pitch<<8) | cutoff;
 511         snd_emu10k1_ptr_write(hw, FMMOD, vp->ch, fmmod);
 512 }
 513
 514 /* set lfo2 pitch & frequency */
 515 static void
 516 set_fm2frq2(emu10k1_t *hw, snd_emux_voice_t *vp)
 517 {
 518         unsigned short fm2frq2;
 519         short pitch;
 520         unsigned char freq;
 521         int modulation;
 522
 523         pitch = (char)(vp->reg.parm.fm2frq2>>8);
 524         freq = vp->reg.parm.fm2frq2 & 0xff;
 525         modulation = vp->chan->gm_modulation + vp->chan->midi_pressure;
 526         pitch += (MOD_SENSE * modulation) / 1200;
 527         LIMITVALUE(pitch, -128, 127);
 528         fm2frq2 = ((unsigned char)pitch<<8) | freq;
 529         snd_emu10k1_ptr_write(hw, FM2FRQ2, vp->ch, fm2frq2);
 530 }
 531
 532 /* set filterQ */
 533 static void
 534 set_filterQ(emu10k1_t *hw, snd_emux_voice_t *vp)
 535 {
 536         unsigned int val;
 537         val = snd_emu10k1_ptr_read(hw, CCCA, vp->ch) & ~CCCA_RESONANCE;
 538         val |= (vp->reg.parm.filterQ << 28);
 539         snd_emu10k1_ptr_write(hw, CCCA, vp->ch, val);
 540 }