sound/pci/emu10k1/emu10k1_callback.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  synth callback routines for Emu10k1
   4  *
   5  *  Copyright (C) 2000 Takashi Iwai <tiwai@suse.de>
   6  */
   7
   8 #include <linux/export.h>
   9 #include "emu10k1_synth_local.h"
  10 #include <sound/asoundef.h>
  11
  12 /* voice status */
  13 enum {
  14         V_FREE=0, V_OFF, V_RELEASED, V_PLAYING, V_END
  15 };
  16
  17 /* Keeps track of what we are finding */
  18 struct best_voice {
  19         unsigned int time;
  20         int voice;
  21 };
  22
  23 /*
  24  * prototypes
  25  */
  26 static void lookup_voices(struct snd_emux *emux, struct snd_emu10k1 *hw,
  27                           struct best_voice *best, int active_only);
  28 static struct snd_emux_voice *get_voice(struct snd_emux *emux,
  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 terminate_voice(struct snd_emux_voice *vp);
  35 static void free_voice(struct snd_emux_voice *vp);
  36 static u32 make_fmmod(struct snd_emux_voice *vp);
  37 static u32 make_fm2frq2(struct snd_emux_voice *vp);
  38 static int get_pitch_shift(struct snd_emux *emu);
  39
  40 /*
  41  * Ensure a value is between two points
  42  * macro evaluates its args more than once, so changed to upper-case.
  43  */
  44 #define LIMITVALUE(x, a, b) do { if ((x) < (a)) (x) = (a); else if ((x) > (b)) (x) = (b); } while (0)
  45 #define LIMITMAX(x, a) do {if ((x) > (a)) (x) = (a); } while (0)
  46
  47
  48 /*
  49  * set up operators
  50  */
  51 static const struct snd_emux_operators emu10k1_ops = {
  52         .owner =        THIS_MODULE,
  53         .get_voice =    get_voice,
  54         .prepare =      start_voice,
  55         .trigger =      trigger_voice,
  56         .release =      release_voice,
  57         .update =       update_voice,
  58         .terminate =    terminate_voice,
  59         .free_voice =   free_voice,
  60         .sample_new =   snd_emu10k1_sample_new,
  61         .sample_free =  snd_emu10k1_sample_free,
  62         .get_pitch_shift = get_pitch_shift,
  63 };
  64
  65 void
  66 snd_emu10k1_ops_setup(struct snd_emux *emux)
  67 {
  68         emux->ops = emu10k1_ops;
  69 }
  70
  71
  72 /*
  73  * get more voice for pcm
  74  *
  75  * terminate most inactive voice and give it as a pcm voice.
  76  *
  77  * voice_lock is already held.
  78  */
  79 int
  80 snd_emu10k1_synth_get_voice(struct snd_emu10k1 *hw)
  81 {
  82         struct snd_emux *emu;
  83         struct snd_emux_voice *vp;
  84         struct best_voice best[V_END];
  85         int i;
  86
  87         emu = hw->synth;
  88
  89         lookup_voices(emu, hw, best, 1); /* no OFF voices */
  90         for (i = 0; i < V_END; i++) {
  91                 if (best[i].voice >= 0) {
  92                         int ch;
  93                         vp = &emu->voices[best[i].voice];
  94                         ch = vp->ch;
  95                         if (ch < 0) {
  96                                 /*
  97                                 dev_warn(emu->card->dev,
  98                                        "synth_get_voice: ch < 0 (%d) ??", i);
  99                                 */
 100                                 continue;
 101                         }
 102                         vp->emu->num_voices--;
 103                         vp->ch = -1;
 104                         vp->state = SNDRV_EMUX_ST_OFF;
 105                         return ch;
 106                 }
 107         }
 108
 109         /* not found */
 110         return -ENOMEM;
 111 }
 112
 113
 114 /*
 115  * turn off the voice (not terminated)
 116  */
 117 static void
 118 release_voice(struct snd_emux_voice *vp)
 119 {
 120         struct snd_emu10k1 *hw;
 121
 122         hw = vp->hw;
 123         snd_emu10k1_ptr_write_multiple(hw, vp->ch,
 124                 DCYSUSM, (unsigned char)vp->reg.parm.modrelease | DCYSUSM_PHASE1_MASK,
 125                 DCYSUSV, (unsigned char)vp->reg.parm.volrelease | DCYSUSV_PHASE1_MASK | DCYSUSV_CHANNELENABLE_MASK,
 126                 REGLIST_END);
 127 }
 128
 129
 130 /*
 131  * terminate the voice
 132  */
 133 static void
 134 terminate_voice(struct snd_emux_voice *vp)
 135 {
 136         struct snd_emu10k1 *hw;
 137
 138         if (snd_BUG_ON(!vp))
 139                 return;
 140         hw = vp->hw;
 141         snd_emu10k1_ptr_write_multiple(hw, vp->ch,
 142                 DCYSUSV, 0,
 143                 VTFT, VTFT_FILTERTARGET_MASK,
 144                 CVCF, CVCF_CURRENTFILTER_MASK,
 145                 PTRX, 0,
 146                 CPF, 0,
 147                 REGLIST_END);
 148         if (vp->block) {
 149                 struct snd_emu10k1_memblk *emem;
 150                 emem = (struct snd_emu10k1_memblk *)vp->block;
 151                 if (emem->map_locked > 0)
 152                         emem->map_locked--;
 153         }
 154 }
 155
 156 /*
 157  * release the voice to system
 158  */
 159 static void
 160 free_voice(struct snd_emux_voice *vp)
 161 {
 162         struct snd_emu10k1 *hw;
 163
 164         hw = vp->hw;
 165         /* FIXME: emu10k1_synth is broken. */
 166         /* This can get called with hw == 0 */
 167         /* Problem apparent on plug, unplug then plug */
 168         /* on the Audigy 2 ZS Notebook. */
 169         if (hw && (vp->ch >= 0)) {
 170                 snd_emu10k1_voice_free(hw, &hw->voices[vp->ch]);
 171                 vp->emu->num_voices--;
 172                 vp->ch = -1;
 173         }
 174 }
 175
 176
 177 /*
 178  * update registers
 179  */
 180 static void
 181 update_voice(struct snd_emux_voice *vp, int update)
 182 {
 183         struct snd_emu10k1 *hw;
 184
 185         hw = vp->hw;
 186         if (update & SNDRV_EMUX_UPDATE_VOLUME)
 187                 snd_emu10k1_ptr_write(hw, IFATN_ATTENUATION, vp->ch, vp->avol);
 188         if (update & SNDRV_EMUX_UPDATE_PITCH)
 189                 snd_emu10k1_ptr_write(hw, IP, vp->ch, vp->apitch);
 190         if (update & SNDRV_EMUX_UPDATE_PAN) {
 191                 snd_emu10k1_ptr_write(hw, PTRX_FXSENDAMOUNT_A, vp->ch, vp->apan);
 192                 snd_emu10k1_ptr_write(hw, PTRX_FXSENDAMOUNT_B, vp->ch, vp->aaux);
 193         }
 194         if (update & SNDRV_EMUX_UPDATE_FMMOD)
 195                 snd_emu10k1_ptr_write(hw, FMMOD, vp->ch, make_fmmod(vp));
 196         if (update & SNDRV_EMUX_UPDATE_TREMFREQ)
 197                 snd_emu10k1_ptr_write(hw, TREMFRQ, vp->ch, vp->reg.parm.tremfrq);
 198         if (update & SNDRV_EMUX_UPDATE_FM2FRQ2)
 199                 snd_emu10k1_ptr_write(hw, FM2FRQ2, vp->ch, make_fm2frq2(vp));
 200         if (update & SNDRV_EMUX_UPDATE_Q)
 201                 snd_emu10k1_ptr_write(hw, CCCA_RESONANCE, vp->ch, vp->reg.parm.filterQ);
 202 }
 203
 204
 205 /*
 206  * look up voice table - get the best voice in order of preference
 207  */
 208 /* spinlock held! */
 209 static void
 210 lookup_voices(struct snd_emux *emu, struct snd_emu10k1 *hw,
 211               struct best_voice *best, int active_only)
 212 {
 213         struct snd_emux_voice *vp;
 214         struct best_voice *bp;
 215         int  i;
 216
 217         for (i = 0; i < V_END; i++) {
 218                 best[i].time = (unsigned int)-1; /* XXX MAX_?INT really */
 219                 best[i].voice = -1;
 220         }
 221
 222         /*
 223          * Go through them all and get a best one to use.
 224          * NOTE: could also look at volume and pick the quietest one.
 225          */
 226         for (i = 0; i < emu->max_voices; i++) {
 227                 int state, val;
 228
 229                 vp = &emu->voices[i];
 230                 state = vp->state;
 231                 if (state == SNDRV_EMUX_ST_OFF) {
 232                         if (vp->ch < 0) {
 233                                 if (active_only)
 234                                         continue;
 235                                 bp = best + V_FREE;
 236                         } else
 237                                 bp = best + V_OFF;
 238                 }
 239                 else if (state == SNDRV_EMUX_ST_RELEASED ||
 240                          state == SNDRV_EMUX_ST_PENDING) {
 241                         bp = best + V_RELEASED;
 242 #if 1
 243                         val = snd_emu10k1_ptr_read(hw, CVCF_CURRENTVOL, vp->ch);
 244                         if (! val)
 245                                 bp = best + V_OFF;
 246 #endif
 247                 }
 248                 else if (state == SNDRV_EMUX_ST_STANDBY)
 249                         continue;
 250                 else if (state & SNDRV_EMUX_ST_ON)
 251                         bp = best + V_PLAYING;
 252                 else
 253                         continue;
 254
 255                 /* check if sample is finished playing (non-looping only) */
 256                 if (bp != best + V_OFF && bp != best + V_FREE &&
 257                     (vp->reg.sample_mode & SNDRV_SFNT_SAMPLE_SINGLESHOT)) {
 258                         val = snd_emu10k1_ptr_read(hw, CCCA_CURRADDR, vp->ch) - 64;
 259                         if (val >= vp->reg.loopstart)
 260                                 bp = best + V_OFF;
 261                 }
 262
 263                 if (vp->time < bp->time) {
 264                         bp->time = vp->time;
 265                         bp->voice = i;
 266                 }
 267         }
 268 }
 269
 270 /*
 271  * get an empty voice
 272  *
 273  * emu->voice_lock is already held.
 274  */
 275 static struct snd_emux_voice *
 276 get_voice(struct snd_emux *emu, struct snd_emux_port *port)
 277 {
 278         struct snd_emu10k1 *hw;
 279         struct snd_emux_voice *vp;
 280         struct best_voice best[V_END];
 281         int i;
 282
 283         hw = emu->hw;
 284
 285         lookup_voices(emu, hw, best, 0);
 286         for (i = 0; i < V_END; i++) {
 287                 if (best[i].voice >= 0) {
 288                         vp = &emu->voices[best[i].voice];
 289                         if (vp->ch < 0) {
 290                                 /* allocate a voice */
 291                                 struct snd_emu10k1_voice *hwvoice;
 292                                 if (snd_emu10k1_voice_alloc(hw, EMU10K1_SYNTH, 1, 1, NULL, &hwvoice) < 0)
 293                                         continue;
 294                                 vp->ch = hwvoice->number;
 295                                 emu->num_voices++;
 296                         }
 297                         return vp;
 298                 }
 299         }
 300
 301         /* not found */
 302         return NULL;
 303 }
 304
 305 /*
 306  * prepare envelopes and LFOs
 307  */
 308 static int
 309 start_voice(struct snd_emux_voice *vp)
 310 {
 311         unsigned int temp;
 312         int ch;
 313         u32 psst, dsl, map, ccca, vtarget;
 314         unsigned int addr, mapped_offset;
 315         struct snd_midi_channel *chan;
 316         struct snd_emu10k1 *hw;
 317         struct snd_emu10k1_memblk *emem;
 318
 319         hw = vp->hw;
 320         ch = vp->ch;
 321         if (snd_BUG_ON(ch < 0))
 322                 return -EINVAL;
 323         chan = vp->chan;
 324
 325         emem = (struct snd_emu10k1_memblk *)vp->block;
 326         if (emem == NULL)
 327                 return -EINVAL;
 328         emem->map_locked++;
 329         if (snd_emu10k1_memblk_map(hw, emem) < 0) {
 330                 /* dev_err(hw->card->devK, "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         temp = vp->reg.parm.reverb;
 352         temp += (int)vp->chan->control[MIDI_CTL_E1_REVERB_DEPTH] * 9 / 10;
 353         LIMITMAX(temp, 255);
 354         addr = vp->reg.loopstart;
 355         psst = (temp << 24) | addr;
 356
 357         addr = vp->reg.loopend;
 358         temp = vp->reg.parm.chorus;
 359         temp += (int)chan->control[MIDI_CTL_E3_CHORUS_DEPTH] * 9 / 10;
 360         LIMITMAX(temp, 255);
 361         dsl = (temp << 24) | addr;
 362
 363         map = (hw->silent_page.addr << hw->address_mode) | (hw->address_mode ? MAP_PTI_MASK1 : MAP_PTI_MASK0);
 364
 365         addr = vp->reg.start + 64;
 366         temp = vp->reg.parm.filterQ;
 367         ccca = (temp << 28) | addr;
 368         if (vp->apitch < 0xe400)
 369                 ccca |= CCCA_INTERPROM_0;
 370         else {
 371                 unsigned int shift = (vp->apitch - 0xe000) >> 10;
 372                 ccca |= shift << 25;
 373         }
 374         if (vp->reg.sample_mode & SNDRV_SFNT_SAMPLE_8BITS)
 375                 ccca |= CCCA_8BITSELECT;
 376
 377         vtarget = (unsigned int)vp->vtarget << 16;
 378
 379         snd_emu10k1_ptr_write_multiple(hw, ch,
 380                 /* channel to be silent and idle */
 381                 DCYSUSV, 0,
 382                 VTFT, VTFT_FILTERTARGET_MASK,
 383                 CVCF, CVCF_CURRENTFILTER_MASK,
 384                 PTRX, 0,
 385                 CPF, 0,
 386
 387                 /* set pitch offset */
 388                 IP, vp->apitch,
 389
 390                 /* set envelope parameters */
 391                 ENVVAL, vp->reg.parm.moddelay,
 392                 ATKHLDM, vp->reg.parm.modatkhld,
 393                 DCYSUSM, vp->reg.parm.moddcysus,
 394                 ENVVOL, vp->reg.parm.voldelay,
 395                 ATKHLDV, vp->reg.parm.volatkhld,
 396                 /* decay/sustain parameter for volume envelope is used
 397                    for triggerg the voice */
 398
 399                 /* cutoff and volume */
 400                 IFATN, (unsigned int)vp->acutoff << 8 | (unsigned char)vp->avol,
 401
 402                 /* modulation envelope heights */
 403                 PEFE, vp->reg.parm.pefe,
 404
 405                 /* lfo1/2 delay */
 406                 LFOVAL1, vp->reg.parm.lfo1delay,
 407                 LFOVAL2, vp->reg.parm.lfo2delay,
 408
 409                 /* lfo1 pitch & cutoff shift */
 410                 FMMOD, make_fmmod(vp),
 411                 /* lfo1 volume & freq */
 412                 TREMFRQ, vp->reg.parm.tremfrq,
 413                 /* lfo2 pitch & freq */
 414                 FM2FRQ2, make_fm2frq2(vp),
 415
 416                 /* reverb and loop start (reverb 8bit, MSB) */
 417                 PSST, psst,
 418
 419                 /* chorus & loop end (chorus 8bit, MSB) */
 420                 DSL, dsl,
 421
 422                 /* clear filter delay memory */
 423                 Z1, 0,
 424                 Z2, 0,
 425
 426                 /* invalidate maps */
 427                 MAPA, map,
 428                 MAPB, map,
 429
 430                 /* Q & current address (Q 4bit value, MSB) */
 431                 CCCA, ccca,
 432
 433                 /* cache */
 434                 CCR, REG_VAL_PUT(CCR_CACHEINVALIDSIZE, 64),
 435
 436                 /* reset volume */
 437                 VTFT, vtarget | vp->ftarget,
 438                 CVCF, vtarget | CVCF_CURRENTFILTER_MASK,
 439
 440                 REGLIST_END);
 441
 442         hw->voices[ch].dirty = 1;
 443         return 0;
 444 }
 445
 446 /*
 447  * Start envelope
 448  */
 449 static void
 450 trigger_voice(struct snd_emux_voice *vp)
 451 {
 452         unsigned int ptarget;
 453         struct snd_emu10k1 *hw;
 454         struct snd_emu10k1_memblk *emem;
 455
 456         hw = vp->hw;
 457
 458         emem = (struct snd_emu10k1_memblk *)vp->block;
 459         if (! emem || emem->mapped_page < 0)
 460                 return; /* not mapped */
 461
 462 #if 0
 463         ptarget = (unsigned int)vp->ptarget << 16;
 464 #else
 465         ptarget = IP_TO_CP(vp->apitch);
 466 #endif
 467         snd_emu10k1_ptr_write_multiple(hw, vp->ch,
 468                 /* set pitch target and pan (volume) */
 469                 PTRX, ptarget | (vp->apan << 8) | vp->aaux,
 470
 471                 /* current pitch and fractional address */
 472                 CPF, ptarget,
 473
 474                 /* enable envelope engine */
 475                 DCYSUSV, vp->reg.parm.voldcysus | DCYSUSV_CHANNELENABLE_MASK,
 476
 477                 REGLIST_END);
 478 }
 479
 480 #define MOD_SENSE 18
 481
 482 /* calculate lfo1 modulation height and cutoff register */
 483 static u32
 484 make_fmmod(struct snd_emux_voice *vp)
 485 {
 486         short pitch;
 487         unsigned char cutoff;
 488         int modulation;
 489
 490         pitch = (char)(vp->reg.parm.fmmod>>8);
 491         cutoff = (vp->reg.parm.fmmod & 0xff);
 492         modulation = vp->chan->gm_modulation + vp->chan->midi_pressure;
 493         pitch += (MOD_SENSE * modulation) / 1200;
 494         LIMITVALUE(pitch, -128, 127);
 495         return ((unsigned char)pitch << 8) | cutoff;
 496 }
 497
 498 /* calculate set lfo2 pitch & frequency register */
 499 static u32
 500 make_fm2frq2(struct snd_emux_voice *vp)
 501 {
 502         short pitch;
 503         unsigned char freq;
 504         int modulation;
 505
 506         pitch = (char)(vp->reg.parm.fm2frq2>>8);
 507         freq = vp->reg.parm.fm2frq2 & 0xff;
 508         modulation = vp->chan->gm_modulation + vp->chan->midi_pressure;
 509         pitch += (MOD_SENSE * modulation) / 1200;
 510         LIMITVALUE(pitch, -128, 127);
 511         return ((unsigned char)pitch << 8) | freq;
 512 }
 513
 514 static int get_pitch_shift(struct snd_emux *emu)
 515 {
 516         struct snd_emu10k1 *hw = emu->hw;
 517
 518         return (hw->card_capabilities->emu_model &&
 519                         hw->emu1010.word_clock == 44100) ? 0 : -501;
 520 }