Logo Search packages:      
Sourcecode: alsa-driver version File versions  Download package

emu10k1_callback.c

/*
 *  synth callback routines for Emu10k1
 *
 *  Copyright (C) 2000 Takashi Iwai <tiwai@suse.de>
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

#include "emu10k1_synth_local.h"
#include <sound/asoundef.h>

/* voice status */
enum {
      V_FREE=0, V_OFF, V_RELEASED, V_PLAYING, V_END
};

/* Keeps track of what we are finding */
struct best_voice {
      unsigned int time;
      int voice;
};

/*
 * prototypes
 */
static void lookup_voices(struct snd_emux *emux, struct snd_emu10k1 *hw,
                    struct best_voice *best, int active_only);
static struct snd_emux_voice *get_voice(struct snd_emux *emux,
                              struct snd_emux_port *port);
static int start_voice(struct snd_emux_voice *vp);
static void trigger_voice(struct snd_emux_voice *vp);
static void release_voice(struct snd_emux_voice *vp);
static void update_voice(struct snd_emux_voice *vp, int update);
static void terminate_voice(struct snd_emux_voice *vp);
static void free_voice(struct snd_emux_voice *vp);
static void set_fmmod(struct snd_emu10k1 *hw, struct snd_emux_voice *vp);
static void set_fm2frq2(struct snd_emu10k1 *hw, struct snd_emux_voice *vp);
static void set_filterQ(struct snd_emu10k1 *hw, struct snd_emux_voice *vp);

/*
 * Ensure a value is between two points
 * macro evaluates its args more than once, so changed to upper-case.
 */
#define LIMITVALUE(x, a, b) do { if ((x) < (a)) (x) = (a); else if ((x) > (b)) (x) = (b); } while (0)
#define LIMITMAX(x, a) do {if ((x) > (a)) (x) = (a); } while (0)


/*
 * set up operators
 */
static struct snd_emux_operators emu10k1_ops = {
      .owner =    THIS_MODULE,
      .get_voice =      get_voice,
      .prepare =  start_voice,
      .trigger =  trigger_voice,
      .release =  release_voice,
      .update =   update_voice,
      .terminate =      terminate_voice,
      .free_voice =     free_voice,
      .sample_new =     snd_emu10k1_sample_new,
      .sample_free =    snd_emu10k1_sample_free,
};

void
snd_emu10k1_ops_setup(struct snd_emux *emux)
{
      emux->ops = emu10k1_ops;
}


/*
 * get more voice for pcm
 *
 * terminate most inactive voice and give it as a pcm voice.
 */
int
snd_emu10k1_synth_get_voice(struct snd_emu10k1 *hw)
{
      struct snd_emux *emu;
      struct snd_emux_voice *vp;
      struct best_voice best[V_END];
      unsigned long flags;
      int i;

      emu = hw->synth;

      spin_lock_irqsave(&emu->voice_lock, flags);
      lookup_voices(emu, hw, best, 1); /* no OFF voices */
      for (i = 0; i < V_END; i++) {
            if (best[i].voice >= 0) {
                  int ch;
                  vp = &emu->voices[best[i].voice];
                  if ((ch = vp->ch) < 0) {
                        /*
                        printk(KERN_WARNING
                               "synth_get_voice: ch < 0 (%d) ??", i);
                        */
                        continue;
                  }
                  vp->emu->num_voices--;
                  vp->ch = -1;
                  vp->state = SNDRV_EMUX_ST_OFF;
                  spin_unlock_irqrestore(&emu->voice_lock, flags);
                  return ch;
            }
      }
      spin_unlock_irqrestore(&emu->voice_lock, flags);

      /* not found */
      return -ENOMEM;
}


/*
 * turn off the voice (not terminated)
 */
static void
release_voice(struct snd_emux_voice *vp)
{
      int dcysusv;
      struct snd_emu10k1 *hw;
      
      hw = vp->hw;
      dcysusv = 0x8000 | (unsigned char)vp->reg.parm.modrelease;
      snd_emu10k1_ptr_write(hw, DCYSUSM, vp->ch, dcysusv);
      dcysusv = 0x8000 | (unsigned char)vp->reg.parm.volrelease | DCYSUSV_CHANNELENABLE_MASK;
      snd_emu10k1_ptr_write(hw, DCYSUSV, vp->ch, dcysusv);
}


/*
 * terminate the voice
 */
static void
terminate_voice(struct snd_emux_voice *vp)
{
      struct snd_emu10k1 *hw;
      
      if (snd_BUG_ON(!vp))
            return;
      hw = vp->hw;
      snd_emu10k1_ptr_write(hw, DCYSUSV, vp->ch, 0x807f | DCYSUSV_CHANNELENABLE_MASK);
      if (vp->block) {
            struct snd_emu10k1_memblk *emem;
            emem = (struct snd_emu10k1_memblk *)vp->block;
            if (emem->map_locked > 0)
                  emem->map_locked--;
      }
}

/*
 * release the voice to system
 */
static void
free_voice(struct snd_emux_voice *vp)
{
      struct snd_emu10k1 *hw;
      
      hw = vp->hw;
      /* FIXME: emu10k1_synth is broken. */
      /* This can get called with hw == 0 */
      /* Problem apparent on plug, unplug then plug */
      /* on the Audigy 2 ZS Notebook. */
      if (hw && (vp->ch >= 0)) {
            snd_emu10k1_ptr_write(hw, IFATN, vp->ch, 0xff00);
            snd_emu10k1_ptr_write(hw, DCYSUSV, vp->ch, 0x807f | DCYSUSV_CHANNELENABLE_MASK);
            // snd_emu10k1_ptr_write(hw, DCYSUSV, vp->ch, 0);
            snd_emu10k1_ptr_write(hw, VTFT, vp->ch, 0xffff);
            snd_emu10k1_ptr_write(hw, CVCF, vp->ch, 0xffff);
            snd_emu10k1_voice_free(hw, &hw->voices[vp->ch]);
            vp->emu->num_voices--;
            vp->ch = -1;
      }
}


/*
 * update registers
 */
static void
update_voice(struct snd_emux_voice *vp, int update)
{
      struct snd_emu10k1 *hw;
      
      hw = vp->hw;
      if (update & SNDRV_EMUX_UPDATE_VOLUME)
            snd_emu10k1_ptr_write(hw, IFATN_ATTENUATION, vp->ch, vp->avol);
      if (update & SNDRV_EMUX_UPDATE_PITCH)
            snd_emu10k1_ptr_write(hw, IP, vp->ch, vp->apitch);
      if (update & SNDRV_EMUX_UPDATE_PAN) {
            snd_emu10k1_ptr_write(hw, PTRX_FXSENDAMOUNT_A, vp->ch, vp->apan);
            snd_emu10k1_ptr_write(hw, PTRX_FXSENDAMOUNT_B, vp->ch, vp->aaux);
      }
      if (update & SNDRV_EMUX_UPDATE_FMMOD)
            set_fmmod(hw, vp);
      if (update & SNDRV_EMUX_UPDATE_TREMFREQ)
            snd_emu10k1_ptr_write(hw, TREMFRQ, vp->ch, vp->reg.parm.tremfrq);
      if (update & SNDRV_EMUX_UPDATE_FM2FRQ2)
            set_fm2frq2(hw, vp);
      if (update & SNDRV_EMUX_UPDATE_Q)
            set_filterQ(hw, vp);
}


/*
 * look up voice table - get the best voice in order of preference
 */
/* spinlock held! */
static void
lookup_voices(struct snd_emux *emu, struct snd_emu10k1 *hw,
            struct best_voice *best, int active_only)
{
      struct snd_emux_voice *vp;
      struct best_voice *bp;
      int  i;

      for (i = 0; i < V_END; i++) {
            best[i].time = (unsigned int)-1; /* XXX MAX_?INT really */;
            best[i].voice = -1;
      }

      /*
       * Go through them all and get a best one to use.
       * NOTE: could also look at volume and pick the quietest one.
       */
      for (i = 0; i < emu->max_voices; i++) {
            int state, val;

            vp = &emu->voices[i];
            state = vp->state;
            if (state == SNDRV_EMUX_ST_OFF) {
                  if (vp->ch < 0) {
                        if (active_only)
                              continue;
                        bp = best + V_FREE;
                  } else
                        bp = best + V_OFF;
            }
            else if (state == SNDRV_EMUX_ST_RELEASED ||
                   state == SNDRV_EMUX_ST_PENDING) {
                  bp = best + V_RELEASED;
#if 1
                  val = snd_emu10k1_ptr_read(hw, CVCF_CURRENTVOL, vp->ch);
                  if (! val)
                        bp = best + V_OFF;
#endif
            }
            else if (state == SNDRV_EMUX_ST_STANDBY)
                  continue;
            else if (state & SNDRV_EMUX_ST_ON)
                  bp = best + V_PLAYING;
            else
                  continue;

            /* check if sample is finished playing (non-looping only) */
            if (bp != best + V_OFF && bp != best + V_FREE &&
                (vp->reg.sample_mode & SNDRV_SFNT_SAMPLE_SINGLESHOT)) {
                  val = snd_emu10k1_ptr_read(hw, CCCA_CURRADDR, vp->ch);
                  if (val >= vp->reg.loopstart)
                        bp = best + V_OFF;
            }

            if (vp->time < bp->time) {
                  bp->time = vp->time;
                  bp->voice = i;
            }
      }
}

/*
 * get an empty voice
 *
 * emu->voice_lock is already held.
 */
static struct snd_emux_voice *
get_voice(struct snd_emux *emu, struct snd_emux_port *port)
{
      struct snd_emu10k1 *hw;
      struct snd_emux_voice *vp;
      struct best_voice best[V_END];
      int i;

      hw = emu->hw;

      lookup_voices(emu, hw, best, 0);
      for (i = 0; i < V_END; i++) {
            if (best[i].voice >= 0) {
                  vp = &emu->voices[best[i].voice];
                  if (vp->ch < 0) {
                        /* allocate a voice */
                        struct snd_emu10k1_voice *hwvoice;
                        if (snd_emu10k1_voice_alloc(hw, EMU10K1_SYNTH, 1, &hwvoice) < 0 || hwvoice == NULL)
                              continue;
                        vp->ch = hwvoice->number;
                        emu->num_voices++;
                  }
                  return vp;
            }
      }

      /* not found */
      return NULL;
}

/*
 * prepare envelopes and LFOs
 */
static int
start_voice(struct snd_emux_voice *vp)
{
      unsigned int temp;
      int ch;
      unsigned int addr, mapped_offset;
      struct snd_midi_channel *chan;
      struct snd_emu10k1 *hw;
      struct snd_emu10k1_memblk *emem;
      
      hw = vp->hw;
      ch = vp->ch;
      if (snd_BUG_ON(ch < 0))
            return -EINVAL;
      chan = vp->chan;

      emem = (struct snd_emu10k1_memblk *)vp->block;
      if (emem == NULL)
            return -EINVAL;
      emem->map_locked++;
      if (snd_emu10k1_memblk_map(hw, emem) < 0) {
            /* printk(KERN_ERR "emu: cannot map!\n"); */
            return -ENOMEM;
      }
      mapped_offset = snd_emu10k1_memblk_offset(emem) >> 1;
      vp->reg.start += mapped_offset;
      vp->reg.end += mapped_offset;
      vp->reg.loopstart += mapped_offset;
      vp->reg.loopend += mapped_offset;

      /* set channel routing */
      /* A = left(0), B = right(1), C = reverb(c), D = chorus(d) */
      if (hw->audigy) {
            temp = FXBUS_MIDI_LEFT | (FXBUS_MIDI_RIGHT << 8) | 
                  (FXBUS_MIDI_REVERB << 16) | (FXBUS_MIDI_CHORUS << 24);
            snd_emu10k1_ptr_write(hw, A_FXRT1, ch, temp);
      } else {
            temp = (FXBUS_MIDI_LEFT << 16) | (FXBUS_MIDI_RIGHT << 20) | 
                  (FXBUS_MIDI_REVERB << 24) | (FXBUS_MIDI_CHORUS << 28);
            snd_emu10k1_ptr_write(hw, FXRT, ch, temp);
      }

      /* channel to be silent and idle */
      snd_emu10k1_ptr_write(hw, DCYSUSV, ch, 0x0000);
      snd_emu10k1_ptr_write(hw, VTFT, ch, 0x0000FFFF);
      snd_emu10k1_ptr_write(hw, CVCF, ch, 0x0000FFFF);
      snd_emu10k1_ptr_write(hw, PTRX, ch, 0);
      snd_emu10k1_ptr_write(hw, CPF, ch, 0);

      /* set pitch offset */
      snd_emu10k1_ptr_write(hw, IP, vp->ch, vp->apitch);

      /* set envelope parameters */
      snd_emu10k1_ptr_write(hw, ENVVAL, ch, vp->reg.parm.moddelay);
      snd_emu10k1_ptr_write(hw, ATKHLDM, ch, vp->reg.parm.modatkhld);
      snd_emu10k1_ptr_write(hw, DCYSUSM, ch, vp->reg.parm.moddcysus);
      snd_emu10k1_ptr_write(hw, ENVVOL, ch, vp->reg.parm.voldelay);
      snd_emu10k1_ptr_write(hw, ATKHLDV, ch, vp->reg.parm.volatkhld);
      /* decay/sustain parameter for volume envelope is used
         for triggerg the voice */

      /* cutoff and volume */
      temp = (unsigned int)vp->acutoff << 8 | (unsigned char)vp->avol;
      snd_emu10k1_ptr_write(hw, IFATN, vp->ch, temp);

      /* modulation envelope heights */
      snd_emu10k1_ptr_write(hw, PEFE, ch, vp->reg.parm.pefe);

      /* lfo1/2 delay */
      snd_emu10k1_ptr_write(hw, LFOVAL1, ch, vp->reg.parm.lfo1delay);
      snd_emu10k1_ptr_write(hw, LFOVAL2, ch, vp->reg.parm.lfo2delay);

      /* lfo1 pitch & cutoff shift */
      set_fmmod(hw, vp);
      /* lfo1 volume & freq */
      snd_emu10k1_ptr_write(hw, TREMFRQ, vp->ch, vp->reg.parm.tremfrq);
      /* lfo2 pitch & freq */
      set_fm2frq2(hw, vp);

      /* reverb and loop start (reverb 8bit, MSB) */
      temp = vp->reg.parm.reverb;
      temp += (int)vp->chan->control[MIDI_CTL_E1_REVERB_DEPTH] * 9 / 10;
      LIMITMAX(temp, 255);
      addr = vp->reg.loopstart;
      snd_emu10k1_ptr_write(hw, PSST, vp->ch, (temp << 24) | addr);

      /* chorus & loop end (chorus 8bit, MSB) */
      addr = vp->reg.loopend;
      temp = vp->reg.parm.chorus;
      temp += (int)chan->control[MIDI_CTL_E3_CHORUS_DEPTH] * 9 / 10;
      LIMITMAX(temp, 255);
      temp = (temp <<24) | addr;
      snd_emu10k1_ptr_write(hw, DSL, ch, temp);

      /* clear filter delay memory */
      snd_emu10k1_ptr_write(hw, Z1, ch, 0);
      snd_emu10k1_ptr_write(hw, Z2, ch, 0);

      /* invalidate maps */
      temp = (hw->silent_page.addr << 1) | MAP_PTI_MASK;
      snd_emu10k1_ptr_write(hw, MAPA, ch, temp);
      snd_emu10k1_ptr_write(hw, MAPB, ch, temp);
#if 0
      /* cache */
      {
            unsigned int val, sample;
            val = 32;
            if (vp->reg.sample_mode & SNDRV_SFNT_SAMPLE_8BITS)
                  sample = 0x80808080;
            else {
                  sample = 0;
                  val *= 2;
            }

            /* cache */
            snd_emu10k1_ptr_write(hw, CCR, ch, 0x1c << 16);
            snd_emu10k1_ptr_write(hw, CDE, ch, sample);
            snd_emu10k1_ptr_write(hw, CDF, ch, sample);

            /* invalidate maps */
            temp = ((unsigned int)hw->silent_page.addr << 1) | MAP_PTI_MASK;
            snd_emu10k1_ptr_write(hw, MAPA, ch, temp);
            snd_emu10k1_ptr_write(hw, MAPB, ch, temp);
            
            /* fill cache */
            val -= 4;
            val <<= 25;
            val |= 0x1c << 16;
            snd_emu10k1_ptr_write(hw, CCR, ch, val);
      }
#endif

      /* Q & current address (Q 4bit value, MSB) */
      addr = vp->reg.start;
      temp = vp->reg.parm.filterQ;
      temp = (temp<<28) | addr;
      if (vp->apitch < 0xe400)
            temp |= CCCA_INTERPROM_0;
      else {
            unsigned int shift = (vp->apitch - 0xe000) >> 10;
            temp |= shift << 25;
      }
      if (vp->reg.sample_mode & SNDRV_SFNT_SAMPLE_8BITS)
            temp |= CCCA_8BITSELECT;
      snd_emu10k1_ptr_write(hw, CCCA, ch, temp);

      /* reset volume */
      temp = (unsigned int)vp->vtarget << 16;
      snd_emu10k1_ptr_write(hw, VTFT, ch, temp | vp->ftarget);
      snd_emu10k1_ptr_write(hw, CVCF, ch, temp | 0xff00);
      return 0;
}

/*
 * Start envelope
 */
static void
trigger_voice(struct snd_emux_voice *vp)
{
      unsigned int temp, ptarget;
      struct snd_emu10k1 *hw;
      struct snd_emu10k1_memblk *emem;
      
      hw = vp->hw;

      emem = (struct snd_emu10k1_memblk *)vp->block;
      if (! emem || emem->mapped_page < 0)
            return; /* not mapped */

#if 0
      ptarget = (unsigned int)vp->ptarget << 16;
#else
      ptarget = IP_TO_CP(vp->apitch);
#endif
      /* set pitch target and pan (volume) */
      temp = ptarget | (vp->apan << 8) | vp->aaux;
      snd_emu10k1_ptr_write(hw, PTRX, vp->ch, temp);

      /* pitch target */
      snd_emu10k1_ptr_write(hw, CPF, vp->ch, ptarget);

      /* trigger voice */
      snd_emu10k1_ptr_write(hw, DCYSUSV, vp->ch, vp->reg.parm.voldcysus|DCYSUSV_CHANNELENABLE_MASK);
}

#define MOD_SENSE 18

/* set lfo1 modulation height and cutoff */
static void
set_fmmod(struct snd_emu10k1 *hw, struct snd_emux_voice *vp)
{
      unsigned short fmmod;
      short pitch;
      unsigned char cutoff;
      int modulation;

      pitch = (char)(vp->reg.parm.fmmod>>8);
      cutoff = (vp->reg.parm.fmmod & 0xff);
      modulation = vp->chan->gm_modulation + vp->chan->midi_pressure;
      pitch += (MOD_SENSE * modulation) / 1200;
      LIMITVALUE(pitch, -128, 127);
      fmmod = ((unsigned char)pitch<<8) | cutoff;
      snd_emu10k1_ptr_write(hw, FMMOD, vp->ch, fmmod);
}

/* set lfo2 pitch & frequency */
static void
set_fm2frq2(struct snd_emu10k1 *hw, struct snd_emux_voice *vp)
{
      unsigned short fm2frq2;
      short pitch;
      unsigned char freq;
      int modulation;

      pitch = (char)(vp->reg.parm.fm2frq2>>8);
      freq = vp->reg.parm.fm2frq2 & 0xff;
      modulation = vp->chan->gm_modulation + vp->chan->midi_pressure;
      pitch += (MOD_SENSE * modulation) / 1200;
      LIMITVALUE(pitch, -128, 127);
      fm2frq2 = ((unsigned char)pitch<<8) | freq;
      snd_emu10k1_ptr_write(hw, FM2FRQ2, vp->ch, fm2frq2);
}

/* set filterQ */
static void
set_filterQ(struct snd_emu10k1 *hw, struct snd_emux_voice *vp)
{
      unsigned int val;
      val = snd_emu10k1_ptr_read(hw, CCCA, vp->ch) & ~CCCA_RESONANCE;
      val |= (vp->reg.parm.filterQ << 28);
      snd_emu10k1_ptr_write(hw, CCCA, vp->ch, val);
}

Generated by  Doxygen 1.6.0   Back to index