/*

   *  Maintained by Jaroslav Kysela <perex@perex.cz>

   *  Originated by audio@tridentmicro.com
   *  Fri Feb 19 15:55:28 MST 1999
   *  Routines for control of Trident 4DWave (DX and NX) chip
   *
   *  BUGS:
   *
   *  TODO:
   *    ---
   *
   *   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
   *
   *
   *  SiS7018 S/PDIF support by Thomas Winischhofer <thomas@winischhofer.net>
   */

  #include <linux/delay.h>
  #include <linux/init.h>
  #include <linux/interrupt.h>
  #include <linux/pci.h>
  #include <linux/slab.h>
  #include <linux/vmalloc.h>
  #include <linux/gameport.h>

  #include <linux/dma-mapping.h>

  #include <linux/export.h>

  
  #include <sound/core.h>
  #include <sound/info.h>
  #include <sound/control.h>

  #include <sound/tlv.h>

  #include <sound/trident.h>
  #include <sound/asoundef.h>
  
  #include <asm/io.h>

  static int snd_trident_pcm_mixer_build(struct snd_trident *trident,
  				       struct snd_trident_voice * voice,
  				       struct snd_pcm_substream *substream);
  static int snd_trident_pcm_mixer_free(struct snd_trident *trident,
  				      struct snd_trident_voice * voice,
  				      struct snd_pcm_substream *substream);

  static irqreturn_t snd_trident_interrupt(int irq, void *dev_id);

  static int snd_trident_sis_reset(struct snd_trident *trident);

  static void snd_trident_clear_voices(struct snd_trident * trident,
  				     unsigned short v_min, unsigned short v_max);
  static int snd_trident_free(struct snd_trident *trident);

  
  /*
   *  common I/O routines
   */
  
  
  #if 0

  static void snd_trident_print_voice_regs(struct snd_trident *trident, int voice)

  {
  	unsigned int val, tmp;

  	printk(KERN_DEBUG "Trident voice %i:
  ", voice);

  	outb(voice, TRID_REG(trident, T4D_LFO_GC_CIR));
  	val = inl(TRID_REG(trident, CH_LBA));

  	printk(KERN_DEBUG "LBA: 0x%x
  ", val);

  	val = inl(TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC));

  	printk(KERN_DEBUG "GVSel: %i
  ", val >> 31);
  	printk(KERN_DEBUG "Pan: 0x%x
  ", (val >> 24) & 0x7f);
  	printk(KERN_DEBUG "Vol: 0x%x
  ", (val >> 16) & 0xff);
  	printk(KERN_DEBUG "CTRL: 0x%x
  ", (val >> 12) & 0x0f);
  	printk(KERN_DEBUG "EC: 0x%x
  ", val & 0x0fff);

  	if (trident->device != TRIDENT_DEVICE_ID_NX) {
  		val = inl(TRID_REG(trident, CH_DX_CSO_ALPHA_FMS));

  		printk(KERN_DEBUG "CSO: 0x%x
  ", val >> 16);

  		printk("Alpha: 0x%x
  ", (val >> 4) & 0x0fff);

  		printk(KERN_DEBUG "FMS: 0x%x
  ", val & 0x0f);

  		val = inl(TRID_REG(trident, CH_DX_ESO_DELTA));

  		printk(KERN_DEBUG "ESO: 0x%x
  ", val >> 16);
  		printk(KERN_DEBUG "Delta: 0x%x
  ", val & 0xffff);

  		val = inl(TRID_REG(trident, CH_DX_FMC_RVOL_CVOL));
  	} else {		// TRIDENT_DEVICE_ID_NX
  		val = inl(TRID_REG(trident, CH_NX_DELTA_CSO));
  		tmp = (val >> 24) & 0xff;

  		printk(KERN_DEBUG "CSO: 0x%x
  ", val & 0x00ffffff);

  		val = inl(TRID_REG(trident, CH_NX_DELTA_ESO));
  		tmp |= (val >> 16) & 0xff00;

  		printk(KERN_DEBUG "Delta: 0x%x
  ", tmp);
  		printk(KERN_DEBUG "ESO: 0x%x
  ", val & 0x00ffffff);

  		val = inl(TRID_REG(trident, CH_NX_ALPHA_FMS_FMC_RVOL_CVOL));

  		printk(KERN_DEBUG "Alpha: 0x%x
  ", val >> 20);
  		printk(KERN_DEBUG "FMS: 0x%x
  ", (val >> 16) & 0x0f);

  	}

  	printk(KERN_DEBUG "FMC: 0x%x
  ", (val >> 14) & 3);
  	printk(KERN_DEBUG "RVol: 0x%x
  ", (val >> 7) & 0x7f);
  	printk(KERN_DEBUG "CVol: 0x%x
  ", val & 0x7f);

  }
  #endif
  
  /*---------------------------------------------------------------------------

     unsigned short snd_trident_codec_read(struct snd_ac97 *ac97, unsigned short reg)

    
     Description: This routine will do all of the reading from the external
                  CODEC (AC97).
    
     Parameters:  ac97 - ac97 codec structure
                  reg - CODEC register index, from AC97 Hal.
   
     returns:     16 bit value read from the AC97.
    
    ---------------------------------------------------------------------------*/

  static unsigned short snd_trident_codec_read(struct snd_ac97 *ac97, unsigned short reg)

  {
  	unsigned int data = 0, treg;
  	unsigned short count = 0xffff;
  	unsigned long flags;

  	struct snd_trident *trident = ac97->private_data;

  
  	spin_lock_irqsave(&trident->reg_lock, flags);
  	if (trident->device == TRIDENT_DEVICE_ID_DX) {
  		data = (DX_AC97_BUSY_READ | (reg & 0x000000ff));
  		outl(data, TRID_REG(trident, DX_ACR1_AC97_R));
  		do {
  			data = inl(TRID_REG(trident, DX_ACR1_AC97_R));
  			if ((data & DX_AC97_BUSY_READ) == 0)
  				break;
  		} while (--count);
  	} else if (trident->device == TRIDENT_DEVICE_ID_NX) {
  		data = (NX_AC97_BUSY_READ | (reg & 0x000000ff));
  		treg = ac97->num == 0 ? NX_ACR2_AC97_R_PRIMARY : NX_ACR3_AC97_R_SECONDARY;
  		outl(data, TRID_REG(trident, treg));
  		do {
  			data = inl(TRID_REG(trident, treg));
  			if ((data & 0x00000C00) == 0)
  				break;
  		} while (--count);
  	} else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
  		data = SI_AC97_BUSY_READ | SI_AC97_AUDIO_BUSY | (reg & 0x000000ff);
  		if (ac97->num == 1)
  			data |= SI_AC97_SECONDARY;
  		outl(data, TRID_REG(trident, SI_AC97_READ));
  		do {
  			data = inl(TRID_REG(trident, SI_AC97_READ));
  			if ((data & (SI_AC97_BUSY_READ)) == 0)
  				break;
  		} while (--count);
  	}
  
  	if (count == 0 && !trident->ac97_detect) {

  		snd_printk(KERN_ERR "ac97 codec read TIMEOUT [0x%x/0x%x]!!!
  ",
  			   reg, data);

  		data = 0;
  	}
  
  	spin_unlock_irqrestore(&trident->reg_lock, flags);
  	return ((unsigned short) (data >> 16));
  }
  
  /*---------------------------------------------------------------------------

     void snd_trident_codec_write(struct snd_ac97 *ac97, unsigned short reg,
     unsigned short wdata)

    
     Description: This routine will do all of the writing to the external
                  CODEC (AC97).
    
     Parameters:	ac97 - ac97 codec structure
     	        reg - CODEC register index, from AC97 Hal.
                  data  - Lower 16 bits are the data to write to CODEC.
    
     returns:     TRUE if everything went ok, else FALSE.
    
    ---------------------------------------------------------------------------*/

  static void snd_trident_codec_write(struct snd_ac97 *ac97, unsigned short reg,
  				    unsigned short wdata)

  {
  	unsigned int address, data;
  	unsigned short count = 0xffff;
  	unsigned long flags;

  	struct snd_trident *trident = ac97->private_data;

  
  	data = ((unsigned long) wdata) << 16;
  
  	spin_lock_irqsave(&trident->reg_lock, flags);
  	if (trident->device == TRIDENT_DEVICE_ID_DX) {
  		address = DX_ACR0_AC97_W;
  
  		/* read AC-97 write register status */
  		do {
  			if ((inw(TRID_REG(trident, address)) & DX_AC97_BUSY_WRITE) == 0)
  				break;
  		} while (--count);
  
  		data |= (DX_AC97_BUSY_WRITE | (reg & 0x000000ff));
  	} else if (trident->device == TRIDENT_DEVICE_ID_NX) {
  		address = NX_ACR1_AC97_W;
  
  		/* read AC-97 write register status */
  		do {
  			if ((inw(TRID_REG(trident, address)) & NX_AC97_BUSY_WRITE) == 0)
  				break;
  		} while (--count);
  
  		data |= (NX_AC97_BUSY_WRITE | (ac97->num << 8) | (reg & 0x000000ff));
  	} else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
  		address = SI_AC97_WRITE;
  
  		/* read AC-97 write register status */
  		do {
  			if ((inw(TRID_REG(trident, address)) & (SI_AC97_BUSY_WRITE)) == 0)
  				break;
  		} while (--count);
  
  		data |= SI_AC97_BUSY_WRITE | SI_AC97_AUDIO_BUSY | (reg & 0x000000ff);
  		if (ac97->num == 1)
  			data |= SI_AC97_SECONDARY;
  	} else {
  		address = 0;	/* keep GCC happy */
  		count = 0;	/* return */
  	}
  
  	if (count == 0) {
  		spin_unlock_irqrestore(&trident->reg_lock, flags);
  		return;
  	}
  	outl(data, TRID_REG(trident, address));
  	spin_unlock_irqrestore(&trident->reg_lock, flags);
  }
  
  /*---------------------------------------------------------------------------

     void snd_trident_enable_eso(struct snd_trident *trident)

    
     Description: This routine will enable end of loop interrupts.
                  End of loop interrupts will occur when a running
                  channel reaches ESO.
                  Also enables middle of loop interrupts.
    
     Parameters:  trident - pointer to target device class for 4DWave.
    
    ---------------------------------------------------------------------------*/

  static void snd_trident_enable_eso(struct snd_trident * trident)

  {
  	unsigned int val;
  
  	val = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
  	val |= ENDLP_IE;
  	val |= MIDLP_IE;
  	if (trident->device == TRIDENT_DEVICE_ID_SI7018)
  		val |= BANK_B_EN;
  	outl(val, TRID_REG(trident, T4D_LFO_GC_CIR));
  }
  
  /*---------------------------------------------------------------------------

     void snd_trident_disable_eso(struct snd_trident *trident)

    
     Description: This routine will disable end of loop interrupts.
                  End of loop interrupts will occur when a running
                  channel reaches ESO.
                  Also disables middle of loop interrupts.
    
     Parameters:  
                  trident - pointer to target device class for 4DWave.
    
     returns:     TRUE if everything went ok, else FALSE.
    
    ---------------------------------------------------------------------------*/

  static void snd_trident_disable_eso(struct snd_trident * trident)

  {
  	unsigned int tmp;
  
  	tmp = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
  	tmp &= ~ENDLP_IE;
  	tmp &= ~MIDLP_IE;
  	outl(tmp, TRID_REG(trident, T4D_LFO_GC_CIR));
  }
  
  /*---------------------------------------------------------------------------

     void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice)

  
      Description: Start a voice, any channel 0 thru 63.
                   This routine automatically handles the fact that there are
                   more than 32 channels available.
  
      Parameters : voice - Voice number 0 thru n.
                   trident - pointer to target device class for 4DWave.
  
      Return Value: None.
  
    ---------------------------------------------------------------------------*/

  void snd_trident_start_voice(struct snd_trident * trident, unsigned int voice)

  {
  	unsigned int mask = 1 << (voice & 0x1f);
  	unsigned int reg = (voice & 0x20) ? T4D_START_B : T4D_START_A;
  
  	outl(mask, TRID_REG(trident, reg));
  }

  EXPORT_SYMBOL(snd_trident_start_voice);

  /*---------------------------------------------------------------------------

     void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice)

  
      Description: Stop a voice, any channel 0 thru 63.
                   This routine automatically handles the fact that there are
                   more than 32 channels available.
  
      Parameters : voice - Voice number 0 thru n.
                   trident - pointer to target device class for 4DWave.
  
      Return Value: None.
  
    ---------------------------------------------------------------------------*/

  void snd_trident_stop_voice(struct snd_trident * trident, unsigned int voice)

  {
  	unsigned int mask = 1 << (voice & 0x1f);
  	unsigned int reg = (voice & 0x20) ? T4D_STOP_B : T4D_STOP_A;
  
  	outl(mask, TRID_REG(trident, reg));
  }

  EXPORT_SYMBOL(snd_trident_stop_voice);

  /*---------------------------------------------------------------------------

      int snd_trident_allocate_pcm_channel(struct snd_trident *trident)

    
      Description: Allocate hardware channel in Bank B (32-63).
    
      Parameters :  trident - pointer to target device class for 4DWave.
    
      Return Value: hardware channel - 32-63 or -1 when no channel is available
    
    ---------------------------------------------------------------------------*/

  static int snd_trident_allocate_pcm_channel(struct snd_trident * trident)

  {
  	int idx;
  
  	if (trident->ChanPCMcnt >= trident->ChanPCM)
  		return -1;
  	for (idx = 31; idx >= 0; idx--) {
  		if (!(trident->ChanMap[T4D_BANK_B] & (1 << idx))) {
  			trident->ChanMap[T4D_BANK_B] |= 1 << idx;
  			trident->ChanPCMcnt++;
  			return idx + 32;
  		}
  	}
  	return -1;
  }
  
  /*---------------------------------------------------------------------------
      void snd_trident_free_pcm_channel(int channel)
    
      Description: Free hardware channel in Bank B (32-63)
    
      Parameters :  trident - pointer to target device class for 4DWave.
  	          channel - hardware channel number 0-63
    
      Return Value: none
    
    ---------------------------------------------------------------------------*/

  static void snd_trident_free_pcm_channel(struct snd_trident *trident, int channel)

  {
  	if (channel < 32 || channel > 63)
  		return;
  	channel &= 0x1f;
  	if (trident->ChanMap[T4D_BANK_B] & (1 << channel)) {
  		trident->ChanMap[T4D_BANK_B] &= ~(1 << channel);
  		trident->ChanPCMcnt--;
  	}
  }
  
  /*---------------------------------------------------------------------------
      unsigned int snd_trident_allocate_synth_channel(void)
    
      Description: Allocate hardware channel in Bank A (0-31).
    
      Parameters :  trident - pointer to target device class for 4DWave.
    
      Return Value: hardware channel - 0-31 or -1 when no channel is available
    
    ---------------------------------------------------------------------------*/

  static int snd_trident_allocate_synth_channel(struct snd_trident * trident)

  {
  	int idx;
  
  	for (idx = 31; idx >= 0; idx--) {
  		if (!(trident->ChanMap[T4D_BANK_A] & (1 << idx))) {
  			trident->ChanMap[T4D_BANK_A] |= 1 << idx;
  			trident->synth.ChanSynthCount++;
  			return idx;
  		}
  	}
  	return -1;
  }
  
  /*---------------------------------------------------------------------------
      void snd_trident_free_synth_channel( int channel )
    
      Description: Free hardware channel in Bank B (0-31).
    
      Parameters :  trident - pointer to target device class for 4DWave.
  	          channel - hardware channel number 0-63
    
      Return Value: none
    
    ---------------------------------------------------------------------------*/

  static void snd_trident_free_synth_channel(struct snd_trident *trident, int channel)

  {
  	if (channel < 0 || channel > 31)
  		return;
  	channel &= 0x1f;
  	if (trident->ChanMap[T4D_BANK_A] & (1 << channel)) {
  		trident->ChanMap[T4D_BANK_A] &= ~(1 << channel);
  		trident->synth.ChanSynthCount--;
  	}
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_write_voice_regs
    
     Description: This routine will complete and write the 5 hardware channel
                  registers to hardware.
    

     Parameters:  trident - pointer to target device class for 4DWave.

                  voice - synthesizer voice structure
                  Each register field.
    
    ---------------------------------------------------------------------------*/

  void snd_trident_write_voice_regs(struct snd_trident * trident,
  				  struct snd_trident_voice * voice)

  {
  	unsigned int FmcRvolCvol;
  	unsigned int regs[5];
  
  	regs[1] = voice->LBA;
  	regs[4] = (voice->GVSel << 31) |
  		  ((voice->Pan & 0x0000007f) << 24) |
  		  ((voice->CTRL & 0x0000000f) << 12);
  	FmcRvolCvol = ((voice->FMC & 3) << 14) |
  	              ((voice->RVol & 0x7f) << 7) |
  	              (voice->CVol & 0x7f);
  
  	switch (trident->device) {
  	case TRIDENT_DEVICE_ID_SI7018:
  		regs[4] |= voice->number > 31 ?
  				(voice->Vol & 0x000003ff) :
  				((voice->Vol & 0x00003fc) << (16-2)) |
  				(voice->EC & 0x00000fff);

  		regs[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) |
  			(voice->FMS & 0x0000000f);

  		regs[2] = (voice->ESO << 16) | (voice->Delta & 0x0ffff);
  		regs[3] = (voice->Attribute << 16) | FmcRvolCvol;
  		break;
  	case TRIDENT_DEVICE_ID_DX:
  		regs[4] |= ((voice->Vol & 0x000003fc) << (16-2)) |
  			   (voice->EC & 0x00000fff);

  		regs[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) |
  			(voice->FMS & 0x0000000f);

  		regs[2] = (voice->ESO << 16) | (voice->Delta & 0x0ffff);
  		regs[3] = FmcRvolCvol;
  		break;
  	case TRIDENT_DEVICE_ID_NX:
  		regs[4] |= ((voice->Vol & 0x000003fc) << (16-2)) |
  			   (voice->EC & 0x00000fff);
  		regs[0] = (voice->Delta << 24) | (voice->CSO & 0x00ffffff);

  		regs[2] = ((voice->Delta << 16) & 0xff000000) |
  			(voice->ESO & 0x00ffffff);
  		regs[3] = (voice->Alpha << 20) |
  			((voice->FMS & 0x0000000f) << 16) | FmcRvolCvol;

  		break;
  	default:
  		snd_BUG();

  		return;

  	}
  
  	outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
  	outl(regs[0], TRID_REG(trident, CH_START + 0));
  	outl(regs[1], TRID_REG(trident, CH_START + 4));
  	outl(regs[2], TRID_REG(trident, CH_START + 8));
  	outl(regs[3], TRID_REG(trident, CH_START + 12));
  	outl(regs[4], TRID_REG(trident, CH_START + 16));
  
  #if 0

  	printk(KERN_DEBUG "written %i channel:
  ", voice->number);
  	printk(KERN_DEBUG "  regs[0] = 0x%x/0x%x
  ",
  	       regs[0], inl(TRID_REG(trident, CH_START + 0)));
  	printk(KERN_DEBUG "  regs[1] = 0x%x/0x%x
  ",
  	       regs[1], inl(TRID_REG(trident, CH_START + 4)));
  	printk(KERN_DEBUG "  regs[2] = 0x%x/0x%x
  ",
  	       regs[2], inl(TRID_REG(trident, CH_START + 8)));
  	printk(KERN_DEBUG "  regs[3] = 0x%x/0x%x
  ",
  	       regs[3], inl(TRID_REG(trident, CH_START + 12)));
  	printk(KERN_DEBUG "  regs[4] = 0x%x/0x%x
  ",
  	       regs[4], inl(TRID_REG(trident, CH_START + 16)));

  #endif
  }

  EXPORT_SYMBOL(snd_trident_write_voice_regs);

  /*---------------------------------------------------------------------------
     snd_trident_write_cso_reg
    
     Description: This routine will write the new CSO offset
                  register to hardware.
    

     Parameters:  trident - pointer to target device class for 4DWave.

                  voice - synthesizer voice structure
                  CSO - new CSO value
    
    ---------------------------------------------------------------------------*/

  static void snd_trident_write_cso_reg(struct snd_trident * trident,
  				      struct snd_trident_voice * voice,
  				      unsigned int CSO)

  {
  	voice->CSO = CSO;
  	outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
  	if (trident->device != TRIDENT_DEVICE_ID_NX) {
  		outw(voice->CSO, TRID_REG(trident, CH_DX_CSO_ALPHA_FMS) + 2);
  	} else {

  		outl((voice->Delta << 24) |
  		     (voice->CSO & 0x00ffffff), TRID_REG(trident, CH_NX_DELTA_CSO));

  	}
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_write_eso_reg
    
     Description: This routine will write the new ESO offset
                  register to hardware.
    

     Parameters:  trident - pointer to target device class for 4DWave.

                  voice - synthesizer voice structure
                  ESO - new ESO value
    
    ---------------------------------------------------------------------------*/

  static void snd_trident_write_eso_reg(struct snd_trident * trident,
  				      struct snd_trident_voice * voice,
  				      unsigned int ESO)

  {
  	voice->ESO = ESO;
  	outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
  	if (trident->device != TRIDENT_DEVICE_ID_NX) {
  		outw(voice->ESO, TRID_REG(trident, CH_DX_ESO_DELTA) + 2);
  	} else {

  		outl(((voice->Delta << 16) & 0xff000000) | (voice->ESO & 0x00ffffff),
  		     TRID_REG(trident, CH_NX_DELTA_ESO));

  	}
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_write_vol_reg
    
     Description: This routine will write the new voice volume
                  register to hardware.
    

     Parameters:  trident - pointer to target device class for 4DWave.

                  voice - synthesizer voice structure
                  Vol - new voice volume
    
    ---------------------------------------------------------------------------*/

  static void snd_trident_write_vol_reg(struct snd_trident * trident,
  				      struct snd_trident_voice * voice,
  				      unsigned int Vol)

  {
  	voice->Vol = Vol;
  	outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
  	switch (trident->device) {
  	case TRIDENT_DEVICE_ID_DX:
  	case TRIDENT_DEVICE_ID_NX:
  		outb(voice->Vol >> 2, TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 2));
  		break;
  	case TRIDENT_DEVICE_ID_SI7018:

  		/* printk(KERN_DEBUG "voice->Vol = 0x%x
  ", voice->Vol); */

  		outw((voice->CTRL << 12) | voice->Vol,
  		     TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC));

  		break;
  	}
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_write_pan_reg
    
     Description: This routine will write the new voice pan
                  register to hardware.
    

     Parameters:  trident - pointer to target device class for 4DWave.

                  voice - synthesizer voice structure
                  Pan - new pan value
    
    ---------------------------------------------------------------------------*/

  static void snd_trident_write_pan_reg(struct snd_trident * trident,
  				      struct snd_trident_voice * voice,
  				      unsigned int Pan)

  {
  	voice->Pan = Pan;
  	outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));

  	outb(((voice->GVSel & 0x01) << 7) | (voice->Pan & 0x7f),
  	     TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 3));

  }
  
  /*---------------------------------------------------------------------------
     snd_trident_write_rvol_reg
    
     Description: This routine will write the new reverb volume
                  register to hardware.
    

     Parameters:  trident - pointer to target device class for 4DWave.

                  voice - synthesizer voice structure
                  RVol - new reverb volume
    
    ---------------------------------------------------------------------------*/

  static void snd_trident_write_rvol_reg(struct snd_trident * trident,
  				       struct snd_trident_voice * voice,
  				       unsigned int RVol)

  {
  	voice->RVol = RVol;
  	outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));

  	outw(((voice->FMC & 0x0003) << 14) | ((voice->RVol & 0x007f) << 7) |
  	     (voice->CVol & 0x007f),
  	     TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ?
  		      CH_NX_ALPHA_FMS_FMC_RVOL_CVOL : CH_DX_FMC_RVOL_CVOL));

  }
  
  /*---------------------------------------------------------------------------
     snd_trident_write_cvol_reg
    
     Description: This routine will write the new chorus volume
                  register to hardware.
    

     Parameters:  trident - pointer to target device class for 4DWave.

                  voice - synthesizer voice structure
                  CVol - new chorus volume
    
    ---------------------------------------------------------------------------*/

  static void snd_trident_write_cvol_reg(struct snd_trident * trident,
  				       struct snd_trident_voice * voice,
  				       unsigned int CVol)

  {
  	voice->CVol = CVol;
  	outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));

  	outw(((voice->FMC & 0x0003) << 14) | ((voice->RVol & 0x007f) << 7) |
  	     (voice->CVol & 0x007f),
  	     TRID_REG(trident, trident->device == TRIDENT_DEVICE_ID_NX ?
  		      CH_NX_ALPHA_FMS_FMC_RVOL_CVOL : CH_DX_FMC_RVOL_CVOL));

  }
  
  /*---------------------------------------------------------------------------
     snd_trident_convert_rate
  
     Description: This routine converts rate in HZ to hardware delta value.
    

     Parameters:  trident - pointer to target device class for 4DWave.

                  rate - Real or Virtual channel number.
    
     Returns:     Delta value.
    
    ---------------------------------------------------------------------------*/
  static unsigned int snd_trident_convert_rate(unsigned int rate)
  {
  	unsigned int delta;
  
  	// We special case 44100 and 8000 since rounding with the equation
  	// does not give us an accurate enough value. For 11025 and 22050
  	// the equation gives us the best answer. All other frequencies will
  	// also use the equation. JDW
  	if (rate == 44100)
  		delta = 0xeb3;
  	else if (rate == 8000)
  		delta = 0x2ab;
  	else if (rate == 48000)
  		delta = 0x1000;
  	else
  		delta = (((rate << 12) + 24000) / 48000) & 0x0000ffff;
  	return delta;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_convert_adc_rate
  
     Description: This routine converts rate in HZ to hardware delta value.
    

     Parameters:  trident - pointer to target device class for 4DWave.

                  rate - Real or Virtual channel number.
    
     Returns:     Delta value.
    
    ---------------------------------------------------------------------------*/
  static unsigned int snd_trident_convert_adc_rate(unsigned int rate)
  {
  	unsigned int delta;
  
  	// We special case 44100 and 8000 since rounding with the equation
  	// does not give us an accurate enough value. For 11025 and 22050
  	// the equation gives us the best answer. All other frequencies will
  	// also use the equation. JDW
  	if (rate == 44100)
  		delta = 0x116a;
  	else if (rate == 8000)
  		delta = 0x6000;
  	else if (rate == 48000)
  		delta = 0x1000;
  	else
  		delta = ((48000 << 12) / rate) & 0x0000ffff;
  	return delta;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_spurious_threshold
  
     Description: This routine converts rate in HZ to spurious threshold.
    

     Parameters:  trident - pointer to target device class for 4DWave.

                  rate - Real or Virtual channel number.
    
     Returns:     Delta value.
    
    ---------------------------------------------------------------------------*/

  static unsigned int snd_trident_spurious_threshold(unsigned int rate,
  						   unsigned int period_size)

  {
  	unsigned int res = (rate * period_size) / 48000;
  	if (res < 64)
  		res = res / 2;
  	else
  		res -= 32;
  	return res;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_control_mode
  
     Description: This routine returns a control mode for a PCM channel.
    

     Parameters:  trident - pointer to target device class for 4DWave.

                  substream  - PCM substream
    
     Returns:     Control value.
    
    ---------------------------------------------------------------------------*/

  static unsigned int snd_trident_control_mode(struct snd_pcm_substream *substream)

  {
  	unsigned int CTRL;

  	struct snd_pcm_runtime *runtime = substream->runtime;

  
  	/* set ctrl mode
  	   CTRL default: 8-bit (unsigned) mono, loop mode enabled
  	 */
  	CTRL = 0x00000001;
  	if (snd_pcm_format_width(runtime->format) == 16)
  		CTRL |= 0x00000008;	// 16-bit data
  	if (snd_pcm_format_signed(runtime->format))
  		CTRL |= 0x00000002;	// signed data
  	if (runtime->channels > 1)
  		CTRL |= 0x00000004;	// stereo data
  	return CTRL;
  }
  
  /*
   *  PCM part
   */
  
  /*---------------------------------------------------------------------------
     snd_trident_ioctl
    
     Description: Device I/O control handler for playback/capture parameters.
    

     Parameters:   substream  - PCM substream class

                  cmd     - what ioctl message to process
                  arg     - additional message infoarg     
    
     Returns:     Error status
    
    ---------------------------------------------------------------------------*/

  static int snd_trident_ioctl(struct snd_pcm_substream *substream,

  			     unsigned int cmd,
  			     void *arg)
  {
  	/* FIXME: it seems that with small periods the behaviour of
  	          trident hardware is unpredictable and interrupt generator
  	          is broken */
  	return snd_pcm_lib_ioctl(substream, cmd, arg);
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_allocate_pcm_mem
    
     Description: Allocate PCM ring buffer for given substream
    
     Parameters:  substream  - PCM substream class
  		hw_params  - hardware parameters
    
     Returns:     Error status
    
    ---------------------------------------------------------------------------*/

  static int snd_trident_allocate_pcm_mem(struct snd_pcm_substream *substream,
  					struct snd_pcm_hw_params *hw_params)

  {

  	struct snd_trident *trident = snd_pcm_substream_chip(substream);
  	struct snd_pcm_runtime *runtime = substream->runtime;
  	struct snd_trident_voice *voice = runtime->private_data;

  	int err;
  
  	if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
  		return err;
  	if (trident->tlb.entries) {
  		if (err > 0) { /* change */
  			if (voice->memblk)
  				snd_trident_free_pages(trident, voice->memblk);
  			voice->memblk = snd_trident_alloc_pages(trident, substream);
  			if (voice->memblk == NULL)
  				return -ENOMEM;
  		}
  	}
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_allocate_evoice
    
     Description: Allocate extra voice as interrupt generator
    
     Parameters:  substream  - PCM substream class
  		hw_params  - hardware parameters
    
     Returns:     Error status
    
    ---------------------------------------------------------------------------*/

  static int snd_trident_allocate_evoice(struct snd_pcm_substream *substream,
  				       struct snd_pcm_hw_params *hw_params)

  {

  	struct snd_trident *trident = snd_pcm_substream_chip(substream);
  	struct snd_pcm_runtime *runtime = substream->runtime;
  	struct snd_trident_voice *voice = runtime->private_data;
  	struct snd_trident_voice *evoice = voice->extra;

  
  	/* voice management */
  
  	if (params_buffer_size(hw_params) / 2 != params_period_size(hw_params)) {
  		if (evoice == NULL) {
  			evoice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
  			if (evoice == NULL)
  				return -ENOMEM;
  			voice->extra = evoice;
  			evoice->substream = substream;
  		}
  	} else {
  		if (evoice != NULL) {
  			snd_trident_free_voice(trident, evoice);
  			voice->extra = evoice = NULL;
  		}
  	}
  
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_hw_params
    
     Description: Set the hardware parameters for the playback device.
    
     Parameters:  substream  - PCM substream class
  		hw_params  - hardware parameters
    
     Returns:     Error status
    
    ---------------------------------------------------------------------------*/

  static int snd_trident_hw_params(struct snd_pcm_substream *substream,
  				 struct snd_pcm_hw_params *hw_params)

  {
  	int err;
  
  	err = snd_trident_allocate_pcm_mem(substream, hw_params);
  	if (err >= 0)
  		err = snd_trident_allocate_evoice(substream, hw_params);
  	return err;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_playback_hw_free
    
     Description: Release the hardware resources for the playback device.
    
     Parameters:  substream  - PCM substream class
    
     Returns:     Error status
    
    ---------------------------------------------------------------------------*/

  static int snd_trident_hw_free(struct snd_pcm_substream *substream)

  {

  	struct snd_trident *trident = snd_pcm_substream_chip(substream);
  	struct snd_pcm_runtime *runtime = substream->runtime;
  	struct snd_trident_voice *voice = runtime->private_data;
  	struct snd_trident_voice *evoice = voice ? voice->extra : NULL;

  
  	if (trident->tlb.entries) {
  		if (voice && voice->memblk) {
  			snd_trident_free_pages(trident, voice->memblk);
  			voice->memblk = NULL;
  		}
  	}
  	snd_pcm_lib_free_pages(substream);
  	if (evoice != NULL) {
  		snd_trident_free_voice(trident, evoice);
  		voice->extra = NULL;
  	}
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_playback_prepare
    
     Description: Prepare playback device for playback.
    
     Parameters:  substream  - PCM substream class
    
     Returns:     Error status
    
    ---------------------------------------------------------------------------*/

  static int snd_trident_playback_prepare(struct snd_pcm_substream *substream)

  {

  	struct snd_trident *trident = snd_pcm_substream_chip(substream);
  	struct snd_pcm_runtime *runtime = substream->runtime;
  	struct snd_trident_voice *voice = runtime->private_data;
  	struct snd_trident_voice *evoice = voice->extra;
  	struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number];

  
  	spin_lock_irq(&trident->reg_lock);	
  
  	/* set delta (rate) value */
  	voice->Delta = snd_trident_convert_rate(runtime->rate);
  	voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size);
  
  	/* set Loop Begin Address */
  	if (voice->memblk)
  		voice->LBA = voice->memblk->offset;
  	else
  		voice->LBA = runtime->dma_addr;
   
  	voice->CSO = 0;
  	voice->ESO = runtime->buffer_size - 1;	/* in samples */
  	voice->CTRL = snd_trident_control_mode(substream);
  	voice->FMC = 3;
  	voice->GVSel = 1;
  	voice->EC = 0;
  	voice->Alpha = 0;
  	voice->FMS = 0;
  	voice->Vol = mix->vol;
  	voice->RVol = mix->rvol;
  	voice->CVol = mix->cvol;
  	voice->Pan = mix->pan;
  	voice->Attribute = 0;
  #if 0
  	voice->Attribute = (1<<(30-16))|(2<<(26-16))|
  			   (0<<(24-16))|(0x1f<<(19-16));
  #else
  	voice->Attribute = 0;
  #endif
  
  	snd_trident_write_voice_regs(trident, voice);
  
  	if (evoice != NULL) {
  		evoice->Delta = voice->Delta;
  		evoice->spurious_threshold = voice->spurious_threshold;
  		evoice->LBA = voice->LBA;
  		evoice->CSO = 0;
  		evoice->ESO = (runtime->period_size * 2) + 4 - 1; /* in samples */
  		evoice->CTRL = voice->CTRL;
  		evoice->FMC = 3;
  		evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
  		evoice->EC = 0;
  		evoice->Alpha = 0;
  		evoice->FMS = 0;
  		evoice->Vol = 0x3ff;			/* mute */
  		evoice->RVol = evoice->CVol = 0x7f;	/* mute */
  		evoice->Pan = 0x7f;			/* mute */
  #if 0
  		evoice->Attribute = (1<<(30-16))|(2<<(26-16))|
  				    (0<<(24-16))|(0x1f<<(19-16));
  #else
  		evoice->Attribute = 0;
  #endif
  		snd_trident_write_voice_regs(trident, evoice);
  		evoice->isync2 = 1;
  		evoice->isync_mark = runtime->period_size;
  		evoice->ESO = (runtime->period_size * 2) - 1;
  	}
  
  	spin_unlock_irq(&trident->reg_lock);
  
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_capture_hw_params
    
     Description: Set the hardware parameters for the capture device.
    
     Parameters:  substream  - PCM substream class
  		hw_params  - hardware parameters
    
     Returns:     Error status
    
    ---------------------------------------------------------------------------*/

  static int snd_trident_capture_hw_params(struct snd_pcm_substream *substream,
  					 struct snd_pcm_hw_params *hw_params)

  {
  	return snd_trident_allocate_pcm_mem(substream, hw_params);
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_capture_prepare
    
     Description: Prepare capture device for playback.
    
     Parameters:  substream  - PCM substream class
    
     Returns:     Error status
    
    ---------------------------------------------------------------------------*/

  static int snd_trident_capture_prepare(struct snd_pcm_substream *substream)

  {

  	struct snd_trident *trident = snd_pcm_substream_chip(substream);
  	struct snd_pcm_runtime *runtime = substream->runtime;
  	struct snd_trident_voice *voice = runtime->private_data;

  	unsigned int val, ESO_bytes;
  
  	spin_lock_irq(&trident->reg_lock);

  	// Initialize the channel and set channel Mode

  	outb(0, TRID_REG(trident, LEGACY_DMAR15));
  
  	// Set DMA channel operation mode register
  	outb(0x54, TRID_REG(trident, LEGACY_DMAR11));
  
  	// Set channel buffer Address, DMAR0 expects contiguous PCI memory area	
  	voice->LBA = runtime->dma_addr;
  	outl(voice->LBA, TRID_REG(trident, LEGACY_DMAR0));
  	if (voice->memblk)
  		voice->LBA = voice->memblk->offset;
  
  	// set ESO
  	ESO_bytes = snd_pcm_lib_buffer_bytes(substream) - 1;
  	outb((ESO_bytes & 0x00ff0000) >> 16, TRID_REG(trident, LEGACY_DMAR6));
  	outw((ESO_bytes & 0x0000ffff), TRID_REG(trident, LEGACY_DMAR4));
  	ESO_bytes++;
  
  	// Set channel sample rate, 4.12 format
  	val = (((unsigned int) 48000L << 12) + (runtime->rate/2)) / runtime->rate;
  	outw(val, TRID_REG(trident, T4D_SBDELTA_DELTA_R));
  
  	// Set channel interrupt blk length
  	if (snd_pcm_format_width(runtime->format) == 16) {
  		val = (unsigned short) ((ESO_bytes >> 1) - 1);
  	} else {
  		val = (unsigned short) (ESO_bytes - 1);
  	}
  
  	outl((val << 16) | val, TRID_REG(trident, T4D_SBBL_SBCL));
  
  	// Right now, set format and start to run captureing, 
  	// continuous run loop enable.
  	trident->bDMAStart = 0x19;	// 0001 1001b
  
  	if (snd_pcm_format_width(runtime->format) == 16)
  		trident->bDMAStart |= 0x80;
  	if (snd_pcm_format_signed(runtime->format))
  		trident->bDMAStart |= 0x20;
  	if (runtime->channels > 1)
  		trident->bDMAStart |= 0x40;
  
  	// Prepare capture intr channel
  
  	voice->Delta = snd_trident_convert_rate(runtime->rate);
  	voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size);
  	voice->isync = 1;
  	voice->isync_mark = runtime->period_size;
  	voice->isync_max = runtime->buffer_size;
  
  	// Set voice parameters
  	voice->CSO = 0;
  	voice->ESO = voice->isync_ESO = (runtime->period_size * 2) + 6 - 1;
  	voice->CTRL = snd_trident_control_mode(substream);
  	voice->FMC = 3;
  	voice->RVol = 0x7f;
  	voice->CVol = 0x7f;
  	voice->GVSel = 1;
  	voice->Pan = 0x7f;		/* mute */
  	voice->Vol = 0x3ff;		/* mute */
  	voice->EC = 0;
  	voice->Alpha = 0;
  	voice->FMS = 0;
  	voice->Attribute = 0;
  
  	snd_trident_write_voice_regs(trident, voice);
  
  	spin_unlock_irq(&trident->reg_lock);
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_si7018_capture_hw_params
    
     Description: Set the hardware parameters for the capture device.
    
     Parameters:  substream  - PCM substream class
  		hw_params  - hardware parameters
    
     Returns:     Error status
    
    ---------------------------------------------------------------------------*/

  static int snd_trident_si7018_capture_hw_params(struct snd_pcm_substream *substream,
  						struct snd_pcm_hw_params *hw_params)

  {
  	int err;
  
  	if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
  		return err;
  
  	return snd_trident_allocate_evoice(substream, hw_params);
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_si7018_capture_hw_free
    
     Description: Release the hardware resources for the capture device.
    
     Parameters:  substream  - PCM substream class
    
     Returns:     Error status
    
    ---------------------------------------------------------------------------*/

  static int snd_trident_si7018_capture_hw_free(struct snd_pcm_substream *substream)

  {

  	struct snd_trident *trident = snd_pcm_substream_chip(substream);
  	struct snd_pcm_runtime *runtime = substream->runtime;
  	struct snd_trident_voice *voice = runtime->private_data;
  	struct snd_trident_voice *evoice = voice ? voice->extra : NULL;

  
  	snd_pcm_lib_free_pages(substream);
  	if (evoice != NULL) {
  		snd_trident_free_voice(trident, evoice);
  		voice->extra = NULL;
  	}
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_si7018_capture_prepare
    
     Description: Prepare capture device for playback.
    
     Parameters:  substream  - PCM substream class
    
     Returns:     Error status
    
    ---------------------------------------------------------------------------*/

  static int snd_trident_si7018_capture_prepare(struct snd_pcm_substream *substream)

  {

  	struct snd_trident *trident = snd_pcm_substream_chip(substream);
  	struct snd_pcm_runtime *runtime = substream->runtime;
  	struct snd_trident_voice *voice = runtime->private_data;
  	struct snd_trident_voice *evoice = voice->extra;

  
  	spin_lock_irq(&trident->reg_lock);
  
  	voice->LBA = runtime->dma_addr;
  	voice->Delta = snd_trident_convert_adc_rate(runtime->rate);
  	voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size);
  
  	// Set voice parameters
  	voice->CSO = 0;
  	voice->ESO = runtime->buffer_size - 1;		/* in samples */
  	voice->CTRL = snd_trident_control_mode(substream);
  	voice->FMC = 0;
  	voice->RVol = 0;
  	voice->CVol = 0;
  	voice->GVSel = 1;
  	voice->Pan = T4D_DEFAULT_PCM_PAN;
  	voice->Vol = 0;
  	voice->EC = 0;
  	voice->Alpha = 0;
  	voice->FMS = 0;
  
  	voice->Attribute = (2 << (30-16)) |
  			   (2 << (26-16)) |
  			   (2 << (24-16)) |
  			   (1 << (23-16));
  
  	snd_trident_write_voice_regs(trident, voice);
  
  	if (evoice != NULL) {
  		evoice->Delta = snd_trident_convert_rate(runtime->rate);
  		evoice->spurious_threshold = voice->spurious_threshold;
  		evoice->LBA = voice->LBA;
  		evoice->CSO = 0;
  		evoice->ESO = (runtime->period_size * 2) + 20 - 1; /* in samples, 20 means correction */
  		evoice->CTRL = voice->CTRL;
  		evoice->FMC = 3;
  		evoice->GVSel = 0;
  		evoice->EC = 0;
  		evoice->Alpha = 0;
  		evoice->FMS = 0;
  		evoice->Vol = 0x3ff;			/* mute */
  		evoice->RVol = evoice->CVol = 0x7f;	/* mute */
  		evoice->Pan = 0x7f;			/* mute */
  		evoice->Attribute = 0;
  		snd_trident_write_voice_regs(trident, evoice);
  		evoice->isync2 = 1;
  		evoice->isync_mark = runtime->period_size;
  		evoice->ESO = (runtime->period_size * 2) - 1;
  	}
  	
  	spin_unlock_irq(&trident->reg_lock);
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_foldback_prepare
    
     Description: Prepare foldback capture device for playback.
    
     Parameters:  substream  - PCM substream class
    
     Returns:     Error status
    
    ---------------------------------------------------------------------------*/

  static int snd_trident_foldback_prepare(struct snd_pcm_substream *substream)

  {

  	struct snd_trident *trident = snd_pcm_substream_chip(substream);
  	struct snd_pcm_runtime *runtime = substream->runtime;
  	struct snd_trident_voice *voice = runtime->private_data;
  	struct snd_trident_voice *evoice = voice->extra;

  
  	spin_lock_irq(&trident->reg_lock);
  
  	/* Set channel buffer Address */
  	if (voice->memblk)
  		voice->LBA = voice->memblk->offset;
  	else
  		voice->LBA = runtime->dma_addr;
  
  	/* set target ESO for channel */
  	voice->ESO = runtime->buffer_size - 1;	/* in samples */
  
  	/* set sample rate */
  	voice->Delta = 0x1000;
  	voice->spurious_threshold = snd_trident_spurious_threshold(48000, runtime->period_size);
  
  	voice->CSO = 0;
  	voice->CTRL = snd_trident_control_mode(substream);
  	voice->FMC = 3;
  	voice->RVol = 0x7f;
  	voice->CVol = 0x7f;
  	voice->GVSel = 1;
  	voice->Pan = 0x7f;	/* mute */
  	voice->Vol = 0x3ff;	/* mute */
  	voice->EC = 0;
  	voice->Alpha = 0;
  	voice->FMS = 0;
  	voice->Attribute = 0;
  
  	/* set up capture channel */
  	outb(((voice->number & 0x3f) | 0x80), TRID_REG(trident, T4D_RCI + voice->foldback_chan));
  
  	snd_trident_write_voice_regs(trident, voice);
  
  	if (evoice != NULL) {
  		evoice->Delta = voice->Delta;
  		evoice->spurious_threshold = voice->spurious_threshold;
  		evoice->LBA = voice->LBA;
  		evoice->CSO = 0;
  		evoice->ESO = (runtime->period_size * 2) + 4 - 1; /* in samples */
  		evoice->CTRL = voice->CTRL;
  		evoice->FMC = 3;
  		evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
  		evoice->EC = 0;
  		evoice->Alpha = 0;
  		evoice->FMS = 0;
  		evoice->Vol = 0x3ff;			/* mute */
  		evoice->RVol = evoice->CVol = 0x7f;	/* mute */
  		evoice->Pan = 0x7f;			/* mute */
  		evoice->Attribute = 0;
  		snd_trident_write_voice_regs(trident, evoice);
  		evoice->isync2 = 1;
  		evoice->isync_mark = runtime->period_size;
  		evoice->ESO = (runtime->period_size * 2) - 1;
  	}
  
  	spin_unlock_irq(&trident->reg_lock);
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_spdif_hw_params
    
     Description: Set the hardware parameters for the spdif device.
    
     Parameters:  substream  - PCM substream class
  		hw_params  - hardware parameters
    
     Returns:     Error status
    
    ---------------------------------------------------------------------------*/

  static int snd_trident_spdif_hw_params(struct snd_pcm_substream *substream,
  				       struct snd_pcm_hw_params *hw_params)

  {

  	struct snd_trident *trident = snd_pcm_substream_chip(substream);

  	unsigned int old_bits = 0, change = 0;
  	int err;
  
  	err = snd_trident_allocate_pcm_mem(substream, hw_params);
  	if (err < 0)
  		return err;
  
  	if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
  		err = snd_trident_allocate_evoice(substream, hw_params);
  		if (err < 0)
  			return err;
  	}
  
  	/* prepare SPDIF channel */
  	spin_lock_irq(&trident->reg_lock);
  	old_bits = trident->spdif_pcm_bits;
  	if (old_bits & IEC958_AES0_PROFESSIONAL)
  		trident->spdif_pcm_bits &= ~IEC958_AES0_PRO_FS;
  	else
  		trident->spdif_pcm_bits &= ~(IEC958_AES3_CON_FS << 24);
  	if (params_rate(hw_params) >= 48000) {
  		trident->spdif_pcm_ctrl = 0x3c;	// 48000 Hz
  		trident->spdif_pcm_bits |=
  			trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
  				IEC958_AES0_PRO_FS_48000 :
  				(IEC958_AES3_CON_FS_48000 << 24);
  	}
  	else if (params_rate(hw_params) >= 44100) {
  		trident->spdif_pcm_ctrl = 0x3e;	// 44100 Hz
  		trident->spdif_pcm_bits |=
  			trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
  				IEC958_AES0_PRO_FS_44100 :
  				(IEC958_AES3_CON_FS_44100 << 24);
  	}
  	else {
  		trident->spdif_pcm_ctrl = 0x3d;	// 32000 Hz
  		trident->spdif_pcm_bits |=
  			trident->spdif_bits & IEC958_AES0_PROFESSIONAL ?
  				IEC958_AES0_PRO_FS_32000 :
  				(IEC958_AES3_CON_FS_32000 << 24);
  	}
  	change = old_bits != trident->spdif_pcm_bits;
  	spin_unlock_irq(&trident->reg_lock);
  
  	if (change)
  		snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE, &trident->spdif_pcm_ctl->id);
  
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_spdif_prepare
    
     Description: Prepare SPDIF device for playback.
    
     Parameters:  substream  - PCM substream class
    
     Returns:     Error status
    
    ---------------------------------------------------------------------------*/

  static int snd_trident_spdif_prepare(struct snd_pcm_substream *substream)

  {

  	struct snd_trident *trident = snd_pcm_substream_chip(substream);
  	struct snd_pcm_runtime *runtime = substream->runtime;
  	struct snd_trident_voice *voice = runtime->private_data;
  	struct snd_trident_voice *evoice = voice->extra;
  	struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[substream->number];

  	unsigned int RESO, LBAO;
  	unsigned int temp;
  
  	spin_lock_irq(&trident->reg_lock);
  
  	if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
  
  		/* set delta (rate) value */
  		voice->Delta = snd_trident_convert_rate(runtime->rate);
  		voice->spurious_threshold = snd_trident_spurious_threshold(runtime->rate, runtime->period_size);
  
  		/* set Loop Back Address */
  		LBAO = runtime->dma_addr;
  		if (voice->memblk)
  			voice->LBA = voice->memblk->offset;
  		else
  			voice->LBA = LBAO;
  
  		voice->isync = 1;
  		voice->isync3 = 1;
  		voice->isync_mark = runtime->period_size;
  		voice->isync_max = runtime->buffer_size;
  
  		/* set target ESO for channel */
  		RESO = runtime->buffer_size - 1;
  		voice->ESO = voice->isync_ESO = (runtime->period_size * 2) + 6 - 1;
  
  		/* set ctrl mode */
  		voice->CTRL = snd_trident_control_mode(substream);
  
  		voice->FMC = 3;
  		voice->RVol = 0x7f;
  		voice->CVol = 0x7f;
  		voice->GVSel = 1;
  		voice->Pan = 0x7f;
  		voice->Vol = 0x3ff;
  		voice->EC = 0;
  		voice->CSO = 0;
  		voice->Alpha = 0;
  		voice->FMS = 0;
  		voice->Attribute = 0;
  
  		/* prepare surrogate IRQ channel */
  		snd_trident_write_voice_regs(trident, voice);
  
  		outw((RESO & 0xffff), TRID_REG(trident, NX_SPESO));
  		outb((RESO >> 16), TRID_REG(trident, NX_SPESO + 2));
  		outl((LBAO & 0xfffffffc), TRID_REG(trident, NX_SPLBA));
  		outw((voice->CSO & 0xffff), TRID_REG(trident, NX_SPCTRL_SPCSO));
  		outb((voice->CSO >> 16), TRID_REG(trident, NX_SPCTRL_SPCSO + 2));
  
  		/* set SPDIF setting */
  		outb(trident->spdif_pcm_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
  		outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
  
  	} else {	/* SiS */
  	
  		/* set delta (rate) value */
  		voice->Delta = 0x800;
  		voice->spurious_threshold = snd_trident_spurious_threshold(48000, runtime->period_size);
  
  		/* set Loop Begin Address */
  		if (voice->memblk)
  			voice->LBA = voice->memblk->offset;
  		else
  			voice->LBA = runtime->dma_addr;
  
  		voice->CSO = 0;
  		voice->ESO = runtime->buffer_size - 1;	/* in samples */
  		voice->CTRL = snd_trident_control_mode(substream);
  		voice->FMC = 3;
  		voice->GVSel = 1;
  		voice->EC = 0;
  		voice->Alpha = 0;
  		voice->FMS = 0;
  		voice->Vol = mix->vol;
  		voice->RVol = mix->rvol;
  		voice->CVol = mix->cvol;
  		voice->Pan = mix->pan;
  		voice->Attribute = (1<<(30-16))|(7<<(26-16))|
  				   (0<<(24-16))|(0<<(19-16));
  
  		snd_trident_write_voice_regs(trident, voice);
  
  		if (evoice != NULL) {
  			evoice->Delta = voice->Delta;
  			evoice->spurious_threshold = voice->spurious_threshold;
  			evoice->LBA = voice->LBA;
  			evoice->CSO = 0;
  			evoice->ESO = (runtime->period_size * 2) + 4 - 1; /* in samples */
  			evoice->CTRL = voice->CTRL;
  			evoice->FMC = 3;
  			evoice->GVSel = trident->device == TRIDENT_DEVICE_ID_SI7018 ? 0 : 1;
  			evoice->EC = 0;
  			evoice->Alpha = 0;
  			evoice->FMS = 0;
  			evoice->Vol = 0x3ff;			/* mute */
  			evoice->RVol = evoice->CVol = 0x7f;	/* mute */
  			evoice->Pan = 0x7f;			/* mute */
  			evoice->Attribute = 0;
  			snd_trident_write_voice_regs(trident, evoice);
  			evoice->isync2 = 1;
  			evoice->isync_mark = runtime->period_size;
  			evoice->ESO = (runtime->period_size * 2) - 1;
  		}
  
  		outl(trident->spdif_pcm_bits, TRID_REG(trident, SI_SPDIF_CS));
  		temp = inl(TRID_REG(trident, T4D_LFO_GC_CIR));
  		temp &= ~(1<<19);
  		outl(temp, TRID_REG(trident, T4D_LFO_GC_CIR));
  		temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL));
  		temp |= SPDIF_EN;
  		outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
  	}
  
  	spin_unlock_irq(&trident->reg_lock);
  
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_trigger
    
     Description: Start/stop devices
    
     Parameters:  substream  - PCM substream class
     		cmd	- trigger command (STOP, GO)
    
     Returns:     Error status
    
    ---------------------------------------------------------------------------*/

  static int snd_trident_trigger(struct snd_pcm_substream *substream,

  			       int cmd)
  				    
  {

  	struct snd_trident *trident = snd_pcm_substream_chip(substream);

  	struct snd_pcm_substream *s;

  	unsigned int what, whati, capture_flag, spdif_flag;

  	struct snd_trident_voice *voice, *evoice;

  	unsigned int val, go;
  
  	switch (cmd) {
  	case SNDRV_PCM_TRIGGER_START:
  	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
  	case SNDRV_PCM_TRIGGER_RESUME:
  		go = 1;
  		break;
  	case SNDRV_PCM_TRIGGER_STOP:
  	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
  	case SNDRV_PCM_TRIGGER_SUSPEND:
  		go = 0;
  		break;
  	default:
  		return -EINVAL;
  	}
  	what = whati = capture_flag = spdif_flag = 0;
  	spin_lock(&trident->reg_lock);
  	val = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff;

  	snd_pcm_group_for_each_entry(s, substream) {

  		if ((struct snd_trident *) snd_pcm_substream_chip(s) == trident) {
  			voice = s->runtime->private_data;

  			evoice = voice->extra;
  			what |= 1 << (voice->number & 0x1f);
  			if (evoice == NULL) {
  				whati |= 1 << (voice->number & 0x1f);
  			} else {
  				what |= 1 << (evoice->number & 0x1f);
  				whati |= 1 << (evoice->number & 0x1f);
  				if (go)
  					evoice->stimer = val;
  			}
  			if (go) {
  				voice->running = 1;
  				voice->stimer = val;
  			} else {
  				voice->running = 0;
  			}
  			snd_pcm_trigger_done(s, substream);
  			if (voice->capture)
  				capture_flag = 1;
  			if (voice->spdif)
  				spdif_flag = 1;
  		}
  	}
  	if (spdif_flag) {
  		if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
  			outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));

  			val = trident->spdif_pcm_ctrl;
  			if (!go)
  				val &= ~(0x28);
  			outb(val, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));

  		} else {
  			outl(trident->spdif_pcm_bits, TRID_REG(trident, SI_SPDIF_CS));
  			val = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) | SPDIF_EN;
  			outl(val, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
  		}
  	}
  	if (!go)
  		outl(what, TRID_REG(trident, T4D_STOP_B));
  	val = inl(TRID_REG(trident, T4D_AINTEN_B));
  	if (go) {
  		val |= whati;
  	} else {
  		val &= ~whati;
  	}
  	outl(val, TRID_REG(trident, T4D_AINTEN_B));
  	if (go) {
  		outl(what, TRID_REG(trident, T4D_START_B));
  
  		if (capture_flag && trident->device != TRIDENT_DEVICE_ID_SI7018)
  			outb(trident->bDMAStart, TRID_REG(trident, T4D_SBCTRL_SBE2R_SBDD));
  	} else {
  		if (capture_flag && trident->device != TRIDENT_DEVICE_ID_SI7018)
  			outb(0x00, TRID_REG(trident, T4D_SBCTRL_SBE2R_SBDD));
  	}
  	spin_unlock(&trident->reg_lock);
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_playback_pointer
    
     Description: This routine return the playback position
                  
     Parameters:	substream  - PCM substream class
  
     Returns:     position of buffer
    
    ---------------------------------------------------------------------------*/

  static snd_pcm_uframes_t snd_trident_playback_pointer(struct snd_pcm_substream *substream)

  {

  	struct snd_trident *trident = snd_pcm_substream_chip(substream);
  	struct snd_pcm_runtime *runtime = substream->runtime;
  	struct snd_trident_voice *voice = runtime->private_data;

  	unsigned int cso;
  
  	if (!voice->running)
  		return 0;
  
  	spin_lock(&trident->reg_lock);
  
  	outb(voice->number, TRID_REG(trident, T4D_LFO_GC_CIR));
  
  	if (trident->device != TRIDENT_DEVICE_ID_NX) {
  		cso = inw(TRID_REG(trident, CH_DX_CSO_ALPHA_FMS + 2));
  	} else {		// ID_4DWAVE_NX
  		cso = (unsigned int) inl(TRID_REG(trident, CH_NX_DELTA_CSO)) & 0x00ffffff;
  	}
  
  	spin_unlock(&trident->reg_lock);
  
  	if (cso >= runtime->buffer_size)
  		cso = 0;
  
  	return cso;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_capture_pointer
    
     Description: This routine return the capture position
                  

     Parameters:   pcm1    - PCM device class

  
     Returns:     position of buffer
    
    ---------------------------------------------------------------------------*/

  static snd_pcm_uframes_t snd_trident_capture_pointer(struct snd_pcm_substream *substream)

  {

  	struct snd_trident *trident = snd_pcm_substream_chip(substream);
  	struct snd_pcm_runtime *runtime = substream->runtime;
  	struct snd_trident_voice *voice = runtime->private_data;

  	unsigned int result;
  
  	if (!voice->running)
  		return 0;
  
  	result = inw(TRID_REG(trident, T4D_SBBL_SBCL));
  	if (runtime->channels > 1)
  		result >>= 1;
  	if (result > 0)
  		result = runtime->buffer_size - result;
  
  	return result;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_spdif_pointer
    
     Description: This routine return the SPDIF playback position
                  
     Parameters:	substream  - PCM substream class
  
     Returns:     position of buffer
    
    ---------------------------------------------------------------------------*/

  static snd_pcm_uframes_t snd_trident_spdif_pointer(struct snd_pcm_substream *substream)

  {

  	struct snd_trident *trident = snd_pcm_substream_chip(substream);
  	struct snd_pcm_runtime *runtime = substream->runtime;
  	struct snd_trident_voice *voice = runtime->private_data;

  	unsigned int result;
  
  	if (!voice->running)
  		return 0;
  
  	result = inl(TRID_REG(trident, NX_SPCTRL_SPCSO)) & 0x00ffffff;
  
  	return result;
  }
  
  /*
   *  Playback support device description
   */

  static struct snd_pcm_hardware snd_trident_playback =

  {
  	.info =			(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
  				 SNDRV_PCM_INFO_BLOCK_TRANSFER |
  				 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |

  				 SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */),

  	.formats =		(SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
  				 SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
  	.rates =		SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
  	.rate_min =		4000,
  	.rate_max =		48000,
  	.channels_min =		1,
  	.channels_max =		2,
  	.buffer_bytes_max =	(256*1024),
  	.period_bytes_min =	64,
  	.period_bytes_max =	(256*1024),
  	.periods_min =		1,
  	.periods_max =		1024,
  	.fifo_size =		0,
  };
  
  /*
   *  Capture support device description
   */

  static struct snd_pcm_hardware snd_trident_capture =

  {
  	.info =			(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
  				 SNDRV_PCM_INFO_BLOCK_TRANSFER |
  				 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |

  				 SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */),

  	.formats =		(SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
  				 SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U16_LE),
  	.rates =		SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
  	.rate_min =		4000,
  	.rate_max =		48000,
  	.channels_min =		1,
  	.channels_max =		2,
  	.buffer_bytes_max =	(128*1024),
  	.period_bytes_min =	64,
  	.period_bytes_max =	(128*1024),
  	.periods_min =		1,
  	.periods_max =		1024,
  	.fifo_size =		0,
  };
  
  /*
   *  Foldback capture support device description
   */

  static struct snd_pcm_hardware snd_trident_foldback =

  {
  	.info =			(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
  				 SNDRV_PCM_INFO_BLOCK_TRANSFER |
  				 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |

  				 SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */),

  	.formats =		SNDRV_PCM_FMTBIT_S16_LE,
  	.rates =		SNDRV_PCM_RATE_48000,
  	.rate_min =		48000,
  	.rate_max =		48000,
  	.channels_min =		2,
  	.channels_max =		2,
  	.buffer_bytes_max =	(128*1024),
  	.period_bytes_min =	64,
  	.period_bytes_max =	(128*1024),
  	.periods_min =		1,
  	.periods_max =		1024,
  	.fifo_size =		0,
  };
  
  /*
   *  SPDIF playback support device description
   */

  static struct snd_pcm_hardware snd_trident_spdif =

  {
  	.info =			(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
  				 SNDRV_PCM_INFO_BLOCK_TRANSFER |
  				 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |

  				 SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */),

  	.formats =		SNDRV_PCM_FMTBIT_S16_LE,
  	.rates =		(SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |
  				 SNDRV_PCM_RATE_48000),
  	.rate_min =		32000,
  	.rate_max =		48000,
  	.channels_min =		2,
  	.channels_max =		2,
  	.buffer_bytes_max =	(128*1024),
  	.period_bytes_min =	64,
  	.period_bytes_max =	(128*1024),
  	.periods_min =		1,
  	.periods_max =		1024,
  	.fifo_size =		0,
  };

  static struct snd_pcm_hardware snd_trident_spdif_7018 =

  {
  	.info =			(SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
  				 SNDRV_PCM_INFO_BLOCK_TRANSFER |
  				 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_SYNC_START |

  				 SNDRV_PCM_INFO_PAUSE /* | SNDRV_PCM_INFO_RESUME */),

  	.formats =		SNDRV_PCM_FMTBIT_S16_LE,
  	.rates =		SNDRV_PCM_RATE_48000,
  	.rate_min =		48000,
  	.rate_max =		48000,
  	.channels_min =		2,
  	.channels_max =		2,
  	.buffer_bytes_max =	(128*1024),
  	.period_bytes_min =	64,
  	.period_bytes_max =	(128*1024),
  	.periods_min =		1,
  	.periods_max =		1024,
  	.fifo_size =		0,
  };

  static void snd_trident_pcm_free_substream(struct snd_pcm_runtime *runtime)

  {

  	struct snd_trident_voice *voice = runtime->private_data;
  	struct snd_trident *trident;

  
  	if (voice) {
  		trident = voice->trident;
  		snd_trident_free_voice(trident, voice);
  	}
  }

  static int snd_trident_playback_open(struct snd_pcm_substream *substream)

  {

  	struct snd_trident *trident = snd_pcm_substream_chip(substream);
  	struct snd_pcm_runtime *runtime = substream->runtime;
  	struct snd_trident_voice *voice;

  
  	voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
  	if (voice == NULL)
  		return -EAGAIN;
  	snd_trident_pcm_mixer_build(trident, voice, substream);
  	voice->substream = substream;
  	runtime->private_data = voice;
  	runtime->private_free = snd_trident_pcm_free_substream;
  	runtime->hw = snd_trident_playback;
  	snd_pcm_set_sync(substream);
  	snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024);
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_playback_close
    
     Description: This routine will close the 4DWave playback device. For now 
                  we will simply free the dma transfer buffer.
                  
     Parameters:	substream  - PCM substream class
  
    ---------------------------------------------------------------------------*/

  static int snd_trident_playback_close(struct snd_pcm_substream *substream)

  {

  	struct snd_trident *trident = snd_pcm_substream_chip(substream);
  	struct snd_pcm_runtime *runtime = substream->runtime;
  	struct snd_trident_voice *voice = runtime->private_data;

  
  	snd_trident_pcm_mixer_free(trident, voice, substream);
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_spdif_open
    
     Description: This routine will open the 4DWave SPDIF device.
  
     Parameters:	substream  - PCM substream class
  
     Returns:     status  - success or failure flag
    
    ---------------------------------------------------------------------------*/

  static int snd_trident_spdif_open(struct snd_pcm_substream *substream)

  {

  	struct snd_trident *trident = snd_pcm_substream_chip(substream);
  	struct snd_trident_voice *voice;
  	struct snd_pcm_runtime *runtime = substream->runtime;

  	
  	voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
  	if (voice == NULL)
  		return -EAGAIN;
  	voice->spdif = 1;
  	voice->substream = substream;
  	spin_lock_irq(&trident->reg_lock);
  	trident->spdif_pcm_bits = trident->spdif_bits;
  	spin_unlock_irq(&trident->reg_lock);
  
  	runtime->private_data = voice;
  	runtime->private_free = snd_trident_pcm_free_substream;
  	if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
  		runtime->hw = snd_trident_spdif;
  	} else {
  		runtime->hw = snd_trident_spdif_7018;
  	}
  
  	trident->spdif_pcm_ctl->vd[0].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
  	snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE |
  		       SNDRV_CTL_EVENT_MASK_INFO, &trident->spdif_pcm_ctl->id);
  
  	snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024);
  	return 0;
  }
  
  
  /*---------------------------------------------------------------------------
     snd_trident_spdif_close
    
     Description: This routine will close the 4DWave SPDIF device.
                  
     Parameters:	substream  - PCM substream class
  
    ---------------------------------------------------------------------------*/

  static int snd_trident_spdif_close(struct snd_pcm_substream *substream)

  {

  	struct snd_trident *trident = snd_pcm_substream_chip(substream);

  	unsigned int temp;
  
  	spin_lock_irq(&trident->reg_lock);
  	// restore default SPDIF setting
  	if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
  		outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
  		outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
  	} else {
  		outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
  		temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL));
  		if (trident->spdif_ctrl) {
  			temp |= SPDIF_EN;
  		} else {
  			temp &= ~SPDIF_EN;
  		}
  		outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
  	}
  	spin_unlock_irq(&trident->reg_lock);
  	trident->spdif_pcm_ctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
  	snd_ctl_notify(trident->card, SNDRV_CTL_EVENT_MASK_VALUE |
  		       SNDRV_CTL_EVENT_MASK_INFO, &trident->spdif_pcm_ctl->id);
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_capture_open
    
     Description: This routine will open the 4DWave capture device.
  
     Parameters:	substream  - PCM substream class
  
     Returns:     status  - success or failure flag
  
    ---------------------------------------------------------------------------*/

  static int snd_trident_capture_open(struct snd_pcm_substream *substream)

  {

  	struct snd_trident *trident = snd_pcm_substream_chip(substream);
  	struct snd_trident_voice *voice;
  	struct snd_pcm_runtime *runtime = substream->runtime;

  
  	voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
  	if (voice == NULL)
  		return -EAGAIN;
  	voice->capture = 1;
  	voice->substream = substream;
  	runtime->private_data = voice;
  	runtime->private_free = snd_trident_pcm_free_substream;
  	runtime->hw = snd_trident_capture;
  	snd_pcm_set_sync(substream);
  	snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024);
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_capture_close
    
     Description: This routine will close the 4DWave capture device. For now 
                  we will simply free the dma transfer buffer.
                  
     Parameters:	substream  - PCM substream class
  
    ---------------------------------------------------------------------------*/

  static int snd_trident_capture_close(struct snd_pcm_substream *substream)

  {
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_foldback_open
    
     Description: This routine will open the 4DWave foldback capture device.
  
     Parameters:	substream  - PCM substream class
  
     Returns:     status  - success or failure flag
  
    ---------------------------------------------------------------------------*/

  static int snd_trident_foldback_open(struct snd_pcm_substream *substream)

  {

  	struct snd_trident *trident = snd_pcm_substream_chip(substream);
  	struct snd_trident_voice *voice;
  	struct snd_pcm_runtime *runtime = substream->runtime;

  
  	voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
  	if (voice == NULL)
  		return -EAGAIN;
  	voice->foldback_chan = substream->number;
  	voice->substream = substream;
  	runtime->private_data = voice;
  	runtime->private_free = snd_trident_pcm_free_substream;
  	runtime->hw = snd_trident_foldback;
  	snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, 0, 64*1024);
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_foldback_close
    
     Description: This routine will close the 4DWave foldback capture device. 
  		For now we will simply free the dma transfer buffer.
                  
     Parameters:	substream  - PCM substream class
  
    ---------------------------------------------------------------------------*/

  static int snd_trident_foldback_close(struct snd_pcm_substream *substream)

  {

  	struct snd_trident *trident = snd_pcm_substream_chip(substream);
  	struct snd_trident_voice *voice;
  	struct snd_pcm_runtime *runtime = substream->runtime;
  	voice = runtime->private_data;

  	
  	/* stop capture channel */
  	spin_lock_irq(&trident->reg_lock);
  	outb(0x00, TRID_REG(trident, T4D_RCI + voice->foldback_chan));
  	spin_unlock_irq(&trident->reg_lock);
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     PCM operations
    ---------------------------------------------------------------------------*/

  static struct snd_pcm_ops snd_trident_playback_ops = {

  	.open =		snd_trident_playback_open,
  	.close =	snd_trident_playback_close,
  	.ioctl =	snd_trident_ioctl,
  	.hw_params =	snd_trident_hw_params,
  	.hw_free =	snd_trident_hw_free,
  	.prepare =	snd_trident_playback_prepare,
  	.trigger =	snd_trident_trigger,
  	.pointer =	snd_trident_playback_pointer,
  };

  static struct snd_pcm_ops snd_trident_nx_playback_ops = {

  	.open =		snd_trident_playback_open,
  	.close =	snd_trident_playback_close,
  	.ioctl =	snd_trident_ioctl,
  	.hw_params =	snd_trident_hw_params,
  	.hw_free =	snd_trident_hw_free,
  	.prepare =	snd_trident_playback_prepare,
  	.trigger =	snd_trident_trigger,
  	.pointer =	snd_trident_playback_pointer,
  	.page =		snd_pcm_sgbuf_ops_page,
  };

  static struct snd_pcm_ops snd_trident_capture_ops = {

  	.open =		snd_trident_capture_open,
  	.close =	snd_trident_capture_close,
  	.ioctl =	snd_trident_ioctl,
  	.hw_params =	snd_trident_capture_hw_params,
  	.hw_free =	snd_trident_hw_free,
  	.prepare =	snd_trident_capture_prepare,
  	.trigger =	snd_trident_trigger,
  	.pointer =	snd_trident_capture_pointer,
  };

  static struct snd_pcm_ops snd_trident_si7018_capture_ops = {

  	.open =		snd_trident_capture_open,
  	.close =	snd_trident_capture_close,
  	.ioctl =	snd_trident_ioctl,
  	.hw_params =	snd_trident_si7018_capture_hw_params,
  	.hw_free =	snd_trident_si7018_capture_hw_free,
  	.prepare =	snd_trident_si7018_capture_prepare,
  	.trigger =	snd_trident_trigger,
  	.pointer =	snd_trident_playback_pointer,
  };

  static struct snd_pcm_ops snd_trident_foldback_ops = {

  	.open =		snd_trident_foldback_open,
  	.close =	snd_trident_foldback_close,
  	.ioctl =	snd_trident_ioctl,
  	.hw_params =	snd_trident_hw_params,
  	.hw_free =	snd_trident_hw_free,
  	.prepare =	snd_trident_foldback_prepare,
  	.trigger =	snd_trident_trigger,
  	.pointer =	snd_trident_playback_pointer,
  };

  static struct snd_pcm_ops snd_trident_nx_foldback_ops = {

  	.open =		snd_trident_foldback_open,
  	.close =	snd_trident_foldback_close,
  	.ioctl =	snd_trident_ioctl,
  	.hw_params =	snd_trident_hw_params,
  	.hw_free =	snd_trident_hw_free,
  	.prepare =	snd_trident_foldback_prepare,
  	.trigger =	snd_trident_trigger,
  	.pointer =	snd_trident_playback_pointer,
  	.page =		snd_pcm_sgbuf_ops_page,
  };

  static struct snd_pcm_ops snd_trident_spdif_ops = {

  	.open =		snd_trident_spdif_open,
  	.close =	snd_trident_spdif_close,
  	.ioctl =	snd_trident_ioctl,
  	.hw_params =	snd_trident_spdif_hw_params,
  	.hw_free =	snd_trident_hw_free,
  	.prepare =	snd_trident_spdif_prepare,
  	.trigger =	snd_trident_trigger,
  	.pointer =	snd_trident_spdif_pointer,
  };

  static struct snd_pcm_ops snd_trident_spdif_7018_ops = {

  	.open =		snd_trident_spdif_open,
  	.close =	snd_trident_spdif_close,
  	.ioctl =	snd_trident_ioctl,
  	.hw_params =	snd_trident_spdif_hw_params,
  	.hw_free =	snd_trident_hw_free,
  	.prepare =	snd_trident_spdif_prepare,
  	.trigger =	snd_trident_trigger,
  	.pointer =	snd_trident_playback_pointer,
  };
  
  /*---------------------------------------------------------------------------

     snd_trident_pcm
    
     Description: This routine registers the 4DWave device for PCM support.
                  

     Parameters:  trident - pointer to target device class for 4DWave.

  
     Returns:     None
    
    ---------------------------------------------------------------------------*/

  int __devinit snd_trident_pcm(struct snd_trident * trident,
  			      int device, struct snd_pcm ** rpcm)

  {

  	struct snd_pcm *pcm;

  	int err;
  
  	if (rpcm)
  		*rpcm = NULL;
  	if ((err = snd_pcm_new(trident->card, "trident_dx_nx", device, trident->ChanPCM, 1, &pcm)) < 0)
  		return err;
  
  	pcm->private_data = trident;

  
  	if (trident->tlb.entries) {
  		snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_nx_playback_ops);
  	} else {
  		snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_playback_ops);
  	}
  	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
  			trident->device != TRIDENT_DEVICE_ID_SI7018 ?
  			&snd_trident_capture_ops :
  			&snd_trident_si7018_capture_ops);
  
  	pcm->info_flags = 0;
  	pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
  	strcpy(pcm->name, "Trident 4DWave");
  	trident->pcm = pcm;
  
  	if (trident->tlb.entries) {

  		struct snd_pcm_substream *substream;

  		for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next)
  			snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV_SG,
  						      snd_dma_pci_data(trident->pci),
  						      64*1024, 128*1024);
  		snd_pcm_lib_preallocate_pages(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream,
  					      SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
  					      64*1024, 128*1024);
  	} else {
  		snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
  						      snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
  	}
  
  	if (rpcm)
  		*rpcm = pcm;
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_foldback_pcm
    
     Description: This routine registers the 4DWave device for foldback PCM support.
                  

     Parameters:  trident - pointer to target device class for 4DWave.

  
     Returns:     None
    
    ---------------------------------------------------------------------------*/

  int __devinit snd_trident_foldback_pcm(struct snd_trident * trident,
  				       int device, struct snd_pcm ** rpcm)

  {

  	struct snd_pcm *foldback;

  	int err;
  	int num_chan = 3;

  	struct snd_pcm_substream *substream;

  
  	if (rpcm)
  		*rpcm = NULL;
  	if (trident->device == TRIDENT_DEVICE_ID_NX)
  		num_chan = 4;
  	if ((err = snd_pcm_new(trident->card, "trident_dx_nx", device, 0, num_chan, &foldback)) < 0)
  		return err;
  
  	foldback->private_data = trident;

  	if (trident->tlb.entries)
  		snd_pcm_set_ops(foldback, SNDRV_PCM_STREAM_CAPTURE, &snd_trident_nx_foldback_ops);
  	else
  		snd_pcm_set_ops(foldback, SNDRV_PCM_STREAM_CAPTURE, &snd_trident_foldback_ops);
  	foldback->info_flags = 0;
  	strcpy(foldback->name, "Trident 4DWave");
  	substream = foldback->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
  	strcpy(substream->name, "Front Mixer");
  	substream = substream->next;
  	strcpy(substream->name, "Reverb Mixer");
  	substream = substream->next;
  	strcpy(substream->name, "Chorus Mixer");
  	if (num_chan == 4) {
  		substream = substream->next;
  		strcpy(substream->name, "Second AC'97 ADC");
  	}
  	trident->foldback = foldback;
  
  	if (trident->tlb.entries)
  		snd_pcm_lib_preallocate_pages_for_all(foldback, SNDRV_DMA_TYPE_DEV_SG,
  						      snd_dma_pci_data(trident->pci), 0, 128*1024);
  	else
  		snd_pcm_lib_preallocate_pages_for_all(foldback, SNDRV_DMA_TYPE_DEV,
  						      snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
  
  	if (rpcm)
  		*rpcm = foldback;
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_spdif
    
     Description: This routine registers the 4DWave-NX device for SPDIF support.
                  

     Parameters:  trident - pointer to target device class for 4DWave-NX.

  
     Returns:     None
    
    ---------------------------------------------------------------------------*/

  int __devinit snd_trident_spdif_pcm(struct snd_trident * trident,
  				    int device, struct snd_pcm ** rpcm)

  {

  	struct snd_pcm *spdif;

  	int err;
  
  	if (rpcm)
  		*rpcm = NULL;
  	if ((err = snd_pcm_new(trident->card, "trident_dx_nx IEC958", device, 1, 0, &spdif)) < 0)
  		return err;
  
  	spdif->private_data = trident;

  	if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
  		snd_pcm_set_ops(spdif, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_spdif_ops);
  	} else {
  		snd_pcm_set_ops(spdif, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_spdif_7018_ops);
  	}
  	spdif->info_flags = 0;
  	strcpy(spdif->name, "Trident 4DWave IEC958");
  	trident->spdif = spdif;
  
  	snd_pcm_lib_preallocate_pages_for_all(spdif, SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
  
  	if (rpcm)
  		*rpcm = spdif;
  	return 0;
  }
  
  /*
   *  Mixer part
   */
  
  
  /*---------------------------------------------------------------------------
      snd_trident_spdif_control
  
      Description: enable/disable S/PDIF out from ac97 mixer
    ---------------------------------------------------------------------------*/

  #define snd_trident_spdif_control_info	snd_ctl_boolean_mono_info

  static int snd_trident_spdif_control_get(struct snd_kcontrol *kcontrol,
  					 struct snd_ctl_elem_value *ucontrol)

  {

  	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);

  	unsigned char val;
  
  	spin_lock_irq(&trident->reg_lock);
  	val = trident->spdif_ctrl;
  	ucontrol->value.integer.value[0] = val == kcontrol->private_value;
  	spin_unlock_irq(&trident->reg_lock);
  	return 0;
  }

  static int snd_trident_spdif_control_put(struct snd_kcontrol *kcontrol,
  					 struct snd_ctl_elem_value *ucontrol)

  {

  	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);

  	unsigned char val;
  	int change;
  
  	val = ucontrol->value.integer.value[0] ? (unsigned char) kcontrol->private_value : 0x00;
  	spin_lock_irq(&trident->reg_lock);
  	/* S/PDIF C Channel bits 0-31 : 48khz, SCMS disabled */
  	change = trident->spdif_ctrl != val;
  	trident->spdif_ctrl = val;
  	if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
  		if ((inb(TRID_REG(trident, NX_SPCTRL_SPCSO + 3)) & 0x10) == 0) {
  			outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
  			outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
  		}
  	} else {
  		if (trident->spdif == NULL) {
  			unsigned int temp;
  			outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
  			temp = inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & ~SPDIF_EN;
  			if (val)
  				temp |= SPDIF_EN;
  			outl(temp, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
  		}
  	}
  	spin_unlock_irq(&trident->reg_lock);
  	return change;
  }

  static struct snd_kcontrol_new snd_trident_spdif_control __devinitdata =

  {
  	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
  	.name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
  	.info =		snd_trident_spdif_control_info,
  	.get =		snd_trident_spdif_control_get,
  	.put =		snd_trident_spdif_control_put,
  	.private_value = 0x28,
  };
  
  /*---------------------------------------------------------------------------
      snd_trident_spdif_default
  
      Description: put/get the S/PDIF default settings
    ---------------------------------------------------------------------------*/

  static int snd_trident_spdif_default_info(struct snd_kcontrol *kcontrol,
  					  struct snd_ctl_elem_info *uinfo)

  {
  	uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
  	uinfo->count = 1;
  	return 0;
  }

  static int snd_trident_spdif_default_get(struct snd_kcontrol *kcontrol,
  					 struct snd_ctl_elem_value *ucontrol)

  {

  	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);

  
  	spin_lock_irq(&trident->reg_lock);
  	ucontrol->value.iec958.status[0] = (trident->spdif_bits >> 0) & 0xff;
  	ucontrol->value.iec958.status[1] = (trident->spdif_bits >> 8) & 0xff;
  	ucontrol->value.iec958.status[2] = (trident->spdif_bits >> 16) & 0xff;
  	ucontrol->value.iec958.status[3] = (trident->spdif_bits >> 24) & 0xff;
  	spin_unlock_irq(&trident->reg_lock);
  	return 0;
  }

  static int snd_trident_spdif_default_put(struct snd_kcontrol *kcontrol,
  					 struct snd_ctl_elem_value *ucontrol)

  {

  	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);

  	unsigned int val;
  	int change;
  
  	val = (ucontrol->value.iec958.status[0] << 0) |
  	      (ucontrol->value.iec958.status[1] << 8) |
  	      (ucontrol->value.iec958.status[2] << 16) |
  	      (ucontrol->value.iec958.status[3] << 24);
  	spin_lock_irq(&trident->reg_lock);
  	change = trident->spdif_bits != val;
  	trident->spdif_bits = val;
  	if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
  		if ((inb(TRID_REG(trident, NX_SPCTRL_SPCSO + 3)) & 0x10) == 0)
  			outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
  	} else {
  		if (trident->spdif == NULL)
  			outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
  	}
  	spin_unlock_irq(&trident->reg_lock);
  	return change;
  }

  static struct snd_kcontrol_new snd_trident_spdif_default __devinitdata =

  {
  	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
  	.name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
  	.info =		snd_trident_spdif_default_info,
  	.get =		snd_trident_spdif_default_get,
  	.put =		snd_trident_spdif_default_put
  };
  
  /*---------------------------------------------------------------------------
      snd_trident_spdif_mask
  
      Description: put/get the S/PDIF mask
    ---------------------------------------------------------------------------*/

  static int snd_trident_spdif_mask_info(struct snd_kcontrol *kcontrol,
  				       struct snd_ctl_elem_info *uinfo)

  {
  	uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
  	uinfo->count = 1;
  	return 0;
  }

  static int snd_trident_spdif_mask_get(struct snd_kcontrol *kcontrol,
  				      struct snd_ctl_elem_value *ucontrol)

  {
  	ucontrol->value.iec958.status[0] = 0xff;
  	ucontrol->value.iec958.status[1] = 0xff;
  	ucontrol->value.iec958.status[2] = 0xff;
  	ucontrol->value.iec958.status[3] = 0xff;
  	return 0;
  }

  static struct snd_kcontrol_new snd_trident_spdif_mask __devinitdata =

  {
  	.access =	SNDRV_CTL_ELEM_ACCESS_READ,
  	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
  	.name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,MASK),
  	.info =		snd_trident_spdif_mask_info,
  	.get =		snd_trident_spdif_mask_get,
  };
  
  /*---------------------------------------------------------------------------
      snd_trident_spdif_stream
  
      Description: put/get the S/PDIF stream settings
    ---------------------------------------------------------------------------*/

  static int snd_trident_spdif_stream_info(struct snd_kcontrol *kcontrol,
  					 struct snd_ctl_elem_info *uinfo)

  {
  	uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
  	uinfo->count = 1;
  	return 0;
  }

  static int snd_trident_spdif_stream_get(struct snd_kcontrol *kcontrol,
  					struct snd_ctl_elem_value *ucontrol)

  {

  	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);

  
  	spin_lock_irq(&trident->reg_lock);
  	ucontrol->value.iec958.status[0] = (trident->spdif_pcm_bits >> 0) & 0xff;
  	ucontrol->value.iec958.status[1] = (trident->spdif_pcm_bits >> 8) & 0xff;
  	ucontrol->value.iec958.status[2] = (trident->spdif_pcm_bits >> 16) & 0xff;
  	ucontrol->value.iec958.status[3] = (trident->spdif_pcm_bits >> 24) & 0xff;
  	spin_unlock_irq(&trident->reg_lock);
  	return 0;
  }

  static int snd_trident_spdif_stream_put(struct snd_kcontrol *kcontrol,
  					struct snd_ctl_elem_value *ucontrol)

  {

  	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);

  	unsigned int val;
  	int change;
  
  	val = (ucontrol->value.iec958.status[0] << 0) |
  	      (ucontrol->value.iec958.status[1] << 8) |
  	      (ucontrol->value.iec958.status[2] << 16) |
  	      (ucontrol->value.iec958.status[3] << 24);
  	spin_lock_irq(&trident->reg_lock);
  	change = trident->spdif_pcm_bits != val;
  	trident->spdif_pcm_bits = val;
  	if (trident->spdif != NULL) {
  		if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
  			outl(trident->spdif_pcm_bits, TRID_REG(trident, NX_SPCSTATUS));
  		} else {
  			outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
  		}
  	}
  	spin_unlock_irq(&trident->reg_lock);
  	return change;
  }

  static struct snd_kcontrol_new snd_trident_spdif_stream __devinitdata =

  {
  	.access =	SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
  	.iface =	SNDRV_CTL_ELEM_IFACE_PCM,
  	.name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,PCM_STREAM),
  	.info =		snd_trident_spdif_stream_info,
  	.get =		snd_trident_spdif_stream_get,
  	.put =		snd_trident_spdif_stream_put
  };
  
  /*---------------------------------------------------------------------------
      snd_trident_ac97_control
  
      Description: enable/disable rear path for ac97
    ---------------------------------------------------------------------------*/

  #define snd_trident_ac97_control_info	snd_ctl_boolean_mono_info

  static int snd_trident_ac97_control_get(struct snd_kcontrol *kcontrol,
  					struct snd_ctl_elem_value *ucontrol)

  {

  	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);

  	unsigned char val;
  
  	spin_lock_irq(&trident->reg_lock);
  	val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
  	ucontrol->value.integer.value[0] = (val & (1 << kcontrol->private_value)) ? 1 : 0;
  	spin_unlock_irq(&trident->reg_lock);
  	return 0;
  }

  static int snd_trident_ac97_control_put(struct snd_kcontrol *kcontrol,
  					struct snd_ctl_elem_value *ucontrol)

  {

  	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);

  	unsigned char val;
  	int change = 0;
  
  	spin_lock_irq(&trident->reg_lock);
  	val = trident->ac97_ctrl = inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
  	val &= ~(1 << kcontrol->private_value);
  	if (ucontrol->value.integer.value[0])
  		val |= 1 << kcontrol->private_value;
  	change = val != trident->ac97_ctrl;
  	trident->ac97_ctrl = val;
  	outl(trident->ac97_ctrl = val, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
  	spin_unlock_irq(&trident->reg_lock);
  	return change;
  }

  static struct snd_kcontrol_new snd_trident_ac97_rear_control __devinitdata =

  {
  	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
  	.name =         "Rear Path",
  	.info =		snd_trident_ac97_control_info,
  	.get =		snd_trident_ac97_control_get,
  	.put =		snd_trident_ac97_control_put,
  	.private_value = 4,
  };
  
  /*---------------------------------------------------------------------------
      snd_trident_vol_control
  
      Description: wave & music volume control
    ---------------------------------------------------------------------------*/

  static int snd_trident_vol_control_info(struct snd_kcontrol *kcontrol,
  					struct snd_ctl_elem_info *uinfo)

  {
  	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
  	uinfo->count = 2;
  	uinfo->value.integer.min = 0;
  	uinfo->value.integer.max = 255;
  	return 0;
  }

  static int snd_trident_vol_control_get(struct snd_kcontrol *kcontrol,
  				       struct snd_ctl_elem_value *ucontrol)

  {

  	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);

  	unsigned int val;
  
  	val = trident->musicvol_wavevol;
  	ucontrol->value.integer.value[0] = 255 - ((val >> kcontrol->private_value) & 0xff);
  	ucontrol->value.integer.value[1] = 255 - ((val >> (kcontrol->private_value + 8)) & 0xff);
  	return 0;
  }

  static const DECLARE_TLV_DB_SCALE(db_scale_gvol, -6375, 25, 0);

  static int snd_trident_vol_control_put(struct snd_kcontrol *kcontrol,
  				       struct snd_ctl_elem_value *ucontrol)

  {

  	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);

  	unsigned int val;
  	int change = 0;
  
  	spin_lock_irq(&trident->reg_lock);
  	val = trident->musicvol_wavevol;
  	val &= ~(0xffff << kcontrol->private_value);
  	val |= ((255 - (ucontrol->value.integer.value[0] & 0xff)) |
  	        ((255 - (ucontrol->value.integer.value[1] & 0xff)) << 8)) << kcontrol->private_value;
  	change = val != trident->musicvol_wavevol;
  	outl(trident->musicvol_wavevol = val, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
  	spin_unlock_irq(&trident->reg_lock);
  	return change;
  }

  static struct snd_kcontrol_new snd_trident_vol_music_control __devinitdata =

  {
  	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
  	.name =         "Music Playback Volume",
  	.info =		snd_trident_vol_control_info,
  	.get =		snd_trident_vol_control_get,
  	.put =		snd_trident_vol_control_put,
  	.private_value = 16,

  	.tlv = { .p = db_scale_gvol },

  };

  static struct snd_kcontrol_new snd_trident_vol_wave_control __devinitdata =

  {
  	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
  	.name =         "Wave Playback Volume",
  	.info =		snd_trident_vol_control_info,
  	.get =		snd_trident_vol_control_get,
  	.put =		snd_trident_vol_control_put,
  	.private_value = 0,

  	.tlv = { .p = db_scale_gvol },

  };
  
  /*---------------------------------------------------------------------------
      snd_trident_pcm_vol_control
  
      Description: PCM front volume control
    ---------------------------------------------------------------------------*/

  static int snd_trident_pcm_vol_control_info(struct snd_kcontrol *kcontrol,
  					    struct snd_ctl_elem_info *uinfo)

  {

  	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);

  
  	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
  	uinfo->count = 1;
  	uinfo->value.integer.min = 0;
  	uinfo->value.integer.max = 255;
  	if (trident->device == TRIDENT_DEVICE_ID_SI7018)
  		uinfo->value.integer.max = 1023;
  	return 0;
  }

  static int snd_trident_pcm_vol_control_get(struct snd_kcontrol *kcontrol,
  					   struct snd_ctl_elem_value *ucontrol)

  {

  	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
  	struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];

  
  	if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
  		ucontrol->value.integer.value[0] = 1023 - mix->vol;
  	} else {
  		ucontrol->value.integer.value[0] = 255 - (mix->vol>>2);
  	}
  	return 0;
  }

  static int snd_trident_pcm_vol_control_put(struct snd_kcontrol *kcontrol,
  					   struct snd_ctl_elem_value *ucontrol)

  {

  	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
  	struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];

  	unsigned int val;
  	int change = 0;
  
  	if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
  		val = 1023 - (ucontrol->value.integer.value[0] & 1023);
  	} else {
  		val = (255 - (ucontrol->value.integer.value[0] & 255)) << 2;
  	}
  	spin_lock_irq(&trident->reg_lock);
  	change = val != mix->vol;
  	mix->vol = val;
  	if (mix->voice != NULL)
  		snd_trident_write_vol_reg(trident, mix->voice, val);
  	spin_unlock_irq(&trident->reg_lock);
  	return change;
  }

  static struct snd_kcontrol_new snd_trident_pcm_vol_control __devinitdata =

  {
  	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
  	.name =         "PCM Front Playback Volume",
  	.access =	SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
  	.count =	32,
  	.info =		snd_trident_pcm_vol_control_info,
  	.get =		snd_trident_pcm_vol_control_get,
  	.put =		snd_trident_pcm_vol_control_put,

  	/* FIXME: no tlv yet */

  };
  
  /*---------------------------------------------------------------------------
      snd_trident_pcm_pan_control
  
      Description: PCM front pan control
    ---------------------------------------------------------------------------*/

  static int snd_trident_pcm_pan_control_info(struct snd_kcontrol *kcontrol,
  					    struct snd_ctl_elem_info *uinfo)

  {
  	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
  	uinfo->count = 1;
  	uinfo->value.integer.min = 0;
  	uinfo->value.integer.max = 127;
  	return 0;
  }

  static int snd_trident_pcm_pan_control_get(struct snd_kcontrol *kcontrol,
  					   struct snd_ctl_elem_value *ucontrol)

  {

  	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
  	struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];

  
  	ucontrol->value.integer.value[0] = mix->pan;
  	if (ucontrol->value.integer.value[0] & 0x40) {
  		ucontrol->value.integer.value[0] = (0x3f - (ucontrol->value.integer.value[0] & 0x3f));
  	} else {
  		ucontrol->value.integer.value[0] |= 0x40;
  	}
  	return 0;
  }

  static int snd_trident_pcm_pan_control_put(struct snd_kcontrol *kcontrol,
  					   struct snd_ctl_elem_value *ucontrol)

  {

  	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
  	struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];

  	unsigned char val;
  	int change = 0;
  
  	if (ucontrol->value.integer.value[0] & 0x40)
  		val = ucontrol->value.integer.value[0] & 0x3f;
  	else
  		val = (0x3f - (ucontrol->value.integer.value[0] & 0x3f)) | 0x40;
  	spin_lock_irq(&trident->reg_lock);
  	change = val != mix->pan;
  	mix->pan = val;
  	if (mix->voice != NULL)
  		snd_trident_write_pan_reg(trident, mix->voice, val);
  	spin_unlock_irq(&trident->reg_lock);
  	return change;
  }

  static struct snd_kcontrol_new snd_trident_pcm_pan_control __devinitdata =

  {
  	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
  	.name =         "PCM Pan Playback Control",
  	.access =	SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
  	.count =	32,
  	.info =		snd_trident_pcm_pan_control_info,
  	.get =		snd_trident_pcm_pan_control_get,
  	.put =		snd_trident_pcm_pan_control_put,
  };
  
  /*---------------------------------------------------------------------------
      snd_trident_pcm_rvol_control
  
      Description: PCM reverb volume control
    ---------------------------------------------------------------------------*/

  static int snd_trident_pcm_rvol_control_info(struct snd_kcontrol *kcontrol,
  					     struct snd_ctl_elem_info *uinfo)

  {
  	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
  	uinfo->count = 1;
  	uinfo->value.integer.min = 0;
  	uinfo->value.integer.max = 127;
  	return 0;
  }

  static int snd_trident_pcm_rvol_control_get(struct snd_kcontrol *kcontrol,
  					    struct snd_ctl_elem_value *ucontrol)

  {

  	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
  	struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];

  
  	ucontrol->value.integer.value[0] = 127 - mix->rvol;
  	return 0;
  }

  static int snd_trident_pcm_rvol_control_put(struct snd_kcontrol *kcontrol,
  					    struct snd_ctl_elem_value *ucontrol)

  {

  	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
  	struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];

  	unsigned short val;
  	int change = 0;
  
  	val = 0x7f - (ucontrol->value.integer.value[0] & 0x7f);
  	spin_lock_irq(&trident->reg_lock);
  	change = val != mix->rvol;
  	mix->rvol = val;
  	if (mix->voice != NULL)
  		snd_trident_write_rvol_reg(trident, mix->voice, val);
  	spin_unlock_irq(&trident->reg_lock);
  	return change;
  }

  static const DECLARE_TLV_DB_SCALE(db_scale_crvol, -3175, 25, 1);

  static struct snd_kcontrol_new snd_trident_pcm_rvol_control __devinitdata =

  {
  	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
  	.name =         "PCM Reverb Playback Volume",
  	.access =	SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
  	.count = 	32,
  	.info =		snd_trident_pcm_rvol_control_info,
  	.get =		snd_trident_pcm_rvol_control_get,
  	.put =		snd_trident_pcm_rvol_control_put,

  	.tlv = { .p = db_scale_crvol },

  };
  
  /*---------------------------------------------------------------------------
      snd_trident_pcm_cvol_control
  
      Description: PCM chorus volume control
    ---------------------------------------------------------------------------*/

  static int snd_trident_pcm_cvol_control_info(struct snd_kcontrol *kcontrol,
  					     struct snd_ctl_elem_info *uinfo)

  {
  	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
  	uinfo->count = 1;
  	uinfo->value.integer.min = 0;
  	uinfo->value.integer.max = 127;
  	return 0;
  }

  static int snd_trident_pcm_cvol_control_get(struct snd_kcontrol *kcontrol,
  					    struct snd_ctl_elem_value *ucontrol)

  {

  	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
  	struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];

  
  	ucontrol->value.integer.value[0] = 127 - mix->cvol;
  	return 0;
  }

  static int snd_trident_pcm_cvol_control_put(struct snd_kcontrol *kcontrol,
  					    struct snd_ctl_elem_value *ucontrol)

  {

  	struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
  	struct snd_trident_pcm_mixer *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];

  	unsigned short val;
  	int change = 0;
  
  	val = 0x7f - (ucontrol->value.integer.value[0] & 0x7f);
  	spin_lock_irq(&trident->reg_lock);
  	change = val != mix->cvol;
  	mix->cvol = val;
  	if (mix->voice != NULL)
  		snd_trident_write_cvol_reg(trident, mix->voice, val);
  	spin_unlock_irq(&trident->reg_lock);
  	return change;
  }

  static struct snd_kcontrol_new snd_trident_pcm_cvol_control __devinitdata =

  {
  	.iface =	SNDRV_CTL_ELEM_IFACE_MIXER,
  	.name =         "PCM Chorus Playback Volume",
  	.access =	SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
  	.count =	32,
  	.info =		snd_trident_pcm_cvol_control_info,
  	.get =		snd_trident_pcm_cvol_control_get,
  	.put =		snd_trident_pcm_cvol_control_put,

  	.tlv = { .p = db_scale_crvol },

  };

  static void snd_trident_notify_pcm_change1(struct snd_card *card,
  					   struct snd_kcontrol *kctl,
  					   int num, int activate)

  {

  	struct snd_ctl_elem_id id;

  	if (! kctl)
  		return;

  	if (activate)
  		kctl->vd[num].access &= ~SNDRV_CTL_ELEM_ACCESS_INACTIVE;
  	else
  		kctl->vd[num].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
  	snd_ctl_notify(card, SNDRV_CTL_EVENT_MASK_VALUE |
  		       SNDRV_CTL_EVENT_MASK_INFO,
  		       snd_ctl_build_ioff(&id, kctl, num));
  }

  static void snd_trident_notify_pcm_change(struct snd_trident *trident,
  					  struct snd_trident_pcm_mixer *tmix,
  					  int num, int activate)

  {
  	snd_trident_notify_pcm_change1(trident->card, trident->ctl_vol, num, activate);
  	snd_trident_notify_pcm_change1(trident->card, trident->ctl_pan, num, activate);
  	snd_trident_notify_pcm_change1(trident->card, trident->ctl_rvol, num, activate);
  	snd_trident_notify_pcm_change1(trident->card, trident->ctl_cvol, num, activate);
  }

  static int snd_trident_pcm_mixer_build(struct snd_trident *trident,
  				       struct snd_trident_voice *voice,
  				       struct snd_pcm_substream *substream)

  {

  	struct snd_trident_pcm_mixer *tmix;

  	if (snd_BUG_ON(!trident || !voice || !substream))
  		return -EINVAL;

  	tmix = &trident->pcm_mixer[substream->number];
  	tmix->voice = voice;
  	tmix->vol = T4D_DEFAULT_PCM_VOL;
  	tmix->pan = T4D_DEFAULT_PCM_PAN;
  	tmix->rvol = T4D_DEFAULT_PCM_RVOL;
  	tmix->cvol = T4D_DEFAULT_PCM_CVOL;
  	snd_trident_notify_pcm_change(trident, tmix, substream->number, 1);
  	return 0;
  }

  static int snd_trident_pcm_mixer_free(struct snd_trident *trident, struct snd_trident_voice *voice, struct snd_pcm_substream *substream)

  {

  	struct snd_trident_pcm_mixer *tmix;

  	if (snd_BUG_ON(!trident || !substream))
  		return -EINVAL;

  	tmix = &trident->pcm_mixer[substream->number];
  	tmix->voice = NULL;
  	snd_trident_notify_pcm_change(trident, tmix, substream->number, 0);
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_mixer
    
     Description: This routine registers the 4DWave device for mixer support.
                  

     Parameters:  trident - pointer to target device class for 4DWave.

  
     Returns:     None
    
    ---------------------------------------------------------------------------*/

  static int __devinit snd_trident_mixer(struct snd_trident * trident, int pcm_spdif_device)

  {

  	struct snd_ac97_template _ac97;
  	struct snd_card *card = trident->card;
  	struct snd_kcontrol *kctl;
  	struct snd_ctl_elem_value *uctl;

  	int idx, err, retries = 2;

  	static struct snd_ac97_bus_ops ops = {

  		.write = snd_trident_codec_write,
  		.read = snd_trident_codec_read,
  	};

  	uctl = kzalloc(sizeof(*uctl), GFP_KERNEL);

  	if (!uctl)
  		return -ENOMEM;
  
  	if ((err = snd_ac97_bus(trident->card, 0, &ops, NULL, &trident->ac97_bus)) < 0)
  		goto __out;
  
  	memset(&_ac97, 0, sizeof(_ac97));
  	_ac97.private_data = trident;
  	trident->ac97_detect = 1;
  
        __again:
  	if ((err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97)) < 0) {
  		if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
  			if ((err = snd_trident_sis_reset(trident)) < 0)
  				goto __out;
  			if (retries-- > 0)
  				goto __again;
  			err = -EIO;
  		}
  		goto __out;
  	}
  	
  	/* secondary codec? */
  	if (trident->device == TRIDENT_DEVICE_ID_SI7018 &&
  	    (inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0) {
  		_ac97.num = 1;
  		err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97_sec);
  		if (err < 0)

  			snd_printk(KERN_ERR "SI7018: the secondary codec - invalid access
  ");

  #if 0	// only for my testing purpose --jk
  		{

  			struct snd_ac97 *mc97;

  			err = snd_ac97_modem(trident->card, &_ac97, &mc97);
  			if (err < 0)

  				snd_printk(KERN_ERR "snd_ac97_modem returned error %i
  ", err);

  		}
  #endif
  	}
  	
  	trident->ac97_detect = 0;
  
  	if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
  		if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_vol_wave_control, trident))) < 0)
  			goto __out;
  		kctl->put(kctl, uctl);
  		if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_vol_music_control, trident))) < 0)
  			goto __out;
  		kctl->put(kctl, uctl);
  		outl(trident->musicvol_wavevol = 0x00000000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
  	} else {
  		outl(trident->musicvol_wavevol = 0xffff0000, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
  	}
  
  	for (idx = 0; idx < 32; idx++) {

  		struct snd_trident_pcm_mixer *tmix;

  		
  		tmix = &trident->pcm_mixer[idx];
  		tmix->voice = NULL;
  	}
  	if ((trident->ctl_vol = snd_ctl_new1(&snd_trident_pcm_vol_control, trident)) == NULL)
  		goto __nomem;
  	if ((err = snd_ctl_add(card, trident->ctl_vol)))
  		goto __out;
  		
  	if ((trident->ctl_pan = snd_ctl_new1(&snd_trident_pcm_pan_control, trident)) == NULL)
  		goto __nomem;
  	if ((err = snd_ctl_add(card, trident->ctl_pan)))
  		goto __out;
  
  	if ((trident->ctl_rvol = snd_ctl_new1(&snd_trident_pcm_rvol_control, trident)) == NULL)
  		goto __nomem;
  	if ((err = snd_ctl_add(card, trident->ctl_rvol)))
  		goto __out;
  
  	if ((trident->ctl_cvol = snd_ctl_new1(&snd_trident_pcm_cvol_control, trident)) == NULL)
  		goto __nomem;
  	if ((err = snd_ctl_add(card, trident->ctl_cvol)))
  		goto __out;
  
  	if (trident->device == TRIDENT_DEVICE_ID_NX) {
  		if ((err = snd_ctl_add(card, kctl = snd_ctl_new1(&snd_trident_ac97_rear_control, trident))) < 0)
  			goto __out;
  		kctl->put(kctl, uctl);
  	}
  	if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018) {
  
  		kctl = snd_ctl_new1(&snd_trident_spdif_control, trident);
  		if (kctl == NULL) {
  			err = -ENOMEM;
  			goto __out;
  		}
  		if (trident->ac97->ext_id & AC97_EI_SPDIF)
  			kctl->id.index++;
  		if (trident->ac97_sec && (trident->ac97_sec->ext_id & AC97_EI_SPDIF))
  			kctl->id.index++;
  		idx = kctl->id.index;
  		if ((err = snd_ctl_add(card, kctl)) < 0)
  			goto __out;
  		kctl->put(kctl, uctl);
  
  		kctl = snd_ctl_new1(&snd_trident_spdif_default, trident);
  		if (kctl == NULL) {
  			err = -ENOMEM;
  			goto __out;
  		}
  		kctl->id.index = idx;
  		kctl->id.device = pcm_spdif_device;
  		if ((err = snd_ctl_add(card, kctl)) < 0)
  			goto __out;
  
  		kctl = snd_ctl_new1(&snd_trident_spdif_mask, trident);
  		if (kctl == NULL) {
  			err = -ENOMEM;
  			goto __out;
  		}
  		kctl->id.index = idx;
  		kctl->id.device = pcm_spdif_device;
  		if ((err = snd_ctl_add(card, kctl)) < 0)
  			goto __out;
  
  		kctl = snd_ctl_new1(&snd_trident_spdif_stream, trident);
  		if (kctl == NULL) {
  			err = -ENOMEM;
  			goto __out;
  		}
  		kctl->id.index = idx;
  		kctl->id.device = pcm_spdif_device;
  		if ((err = snd_ctl_add(card, kctl)) < 0)
  			goto __out;
  		trident->spdif_pcm_ctl = kctl;
  	}
  
  	err = 0;
  	goto __out;
  
   __nomem:
  	err = -ENOMEM;
  
   __out:
  	kfree(uctl);
  
  	return err;
  }
  
  /*
   * gameport interface
   */
  
  #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
  
  static unsigned char snd_trident_gameport_read(struct gameport *gameport)
  {

  	struct snd_trident *chip = gameport_get_port_data(gameport);

  	if (snd_BUG_ON(!chip))
  		return 0;

  	return inb(TRID_REG(chip, GAMEPORT_LEGACY));
  }
  
  static void snd_trident_gameport_trigger(struct gameport *gameport)
  {

  	struct snd_trident *chip = gameport_get_port_data(gameport);

  	if (snd_BUG_ON(!chip))
  		return;

  	outb(0xff, TRID_REG(chip, GAMEPORT_LEGACY));
  }
  
  static int snd_trident_gameport_cooked_read(struct gameport *gameport, int *axes, int *buttons)
  {

  	struct snd_trident *chip = gameport_get_port_data(gameport);

  	int i;

  	if (snd_BUG_ON(!chip))
  		return 0;

  
  	*buttons = (~inb(TRID_REG(chip, GAMEPORT_LEGACY)) >> 4) & 0xf;
  
  	for (i = 0; i < 4; i++) {
  		axes[i] = inw(TRID_REG(chip, GAMEPORT_AXES + i * 2));
  		if (axes[i] == 0xffff) axes[i] = -1;
  	}
          
          return 0;
  }
  
  static int snd_trident_gameport_open(struct gameport *gameport, int mode)
  {

  	struct snd_trident *chip = gameport_get_port_data(gameport);

  	if (snd_BUG_ON(!chip))
  		return 0;

  
  	switch (mode) {
  		case GAMEPORT_MODE_COOKED:
  			outb(GAMEPORT_MODE_ADC, TRID_REG(chip, GAMEPORT_GCR));

  			msleep(20);

  			return 0;
  		case GAMEPORT_MODE_RAW:
  			outb(0, TRID_REG(chip, GAMEPORT_GCR));
  			return 0;
  		default:
  			return -1;
  	}
  }

  int __devinit snd_trident_create_gameport(struct snd_trident *chip)

  {
  	struct gameport *gp;
  
  	chip->gameport = gp = gameport_allocate_port();
  	if (!gp) {
  		printk(KERN_ERR "trident: cannot allocate memory for gameport
  ");
  		return -ENOMEM;
  	}
  
  	gameport_set_name(gp, "Trident 4DWave");
  	gameport_set_phys(gp, "pci%s/gameport0", pci_name(chip->pci));
  	gameport_set_dev_parent(gp, &chip->pci->dev);
  
  	gameport_set_port_data(gp, chip);
  	gp->fuzz = 64;
  	gp->read = snd_trident_gameport_read;
  	gp->trigger = snd_trident_gameport_trigger;
  	gp->cooked_read = snd_trident_gameport_cooked_read;
  	gp->open = snd_trident_gameport_open;
  
  	gameport_register_port(gp);
  
  	return 0;
  }

  static inline void snd_trident_free_gameport(struct snd_trident *chip)

  {
  	if (chip->gameport) {
  		gameport_unregister_port(chip->gameport);
  		chip->gameport = NULL;
  	}
  }
  #else

  int __devinit snd_trident_create_gameport(struct snd_trident *chip) { return -ENOSYS; }
  static inline void snd_trident_free_gameport(struct snd_trident *chip) { }

  #endif /* CONFIG_GAMEPORT */
  
  /*
   * delay for 1 tick
   */

  static inline void do_delay(struct snd_trident *chip)

  {

  	schedule_timeout_uninterruptible(1);

  }
  
  /*
   *  SiS reset routine
   */

  static int snd_trident_sis_reset(struct snd_trident *trident)

  {
  	unsigned long end_time;
  	unsigned int i;
  	int r;
  
  	r = trident->in_suspend ? 0 : 2;	/* count of retries */
        __si7018_retry:
  	pci_write_config_byte(trident->pci, 0x46, 0x04);	/* SOFTWARE RESET */
  	udelay(100);
  	pci_write_config_byte(trident->pci, 0x46, 0x00);
  	udelay(100);
  	/* disable AC97 GPIO interrupt */
  	outb(0x00, TRID_REG(trident, SI_AC97_GPIO));
  	/* initialize serial interface, force cold reset */
  	i = PCMOUT|SURROUT|CENTEROUT|LFEOUT|SECONDARY_ID|COLD_RESET;
  	outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
  	udelay(1000);
  	/* remove cold reset */
  	i &= ~COLD_RESET;
  	outl(i, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
  	udelay(2000);
  	/* wait, until the codec is ready */
  	end_time = (jiffies + (HZ * 3) / 4) + 1;
  	do {
  		if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_PRIMARY_READY) != 0)
  			goto __si7018_ok;
  		do_delay(trident);
  	} while (time_after_eq(end_time, jiffies));

  	snd_printk(KERN_ERR "AC'97 codec ready error [0x%x]
  ", inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)));

  	if (r-- > 0) {
  		end_time = jiffies + HZ;
  		do {
  			do_delay(trident);
  		} while (time_after_eq(end_time, jiffies));
  		goto __si7018_retry;
  	}
        __si7018_ok:
  	/* wait for the second codec */
  	do {
  		if ((inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)) & SI_AC97_SECONDARY_READY) != 0)
  			break;
  		do_delay(trident);
  	} while (time_after_eq(end_time, jiffies));
  	/* enable 64 channel mode */
  	outl(BANK_B_EN, TRID_REG(trident, T4D_LFO_GC_CIR));
  	return 0;
  }
  
  /*  
   *  /proc interface
   */

  static void snd_trident_proc_read(struct snd_info_entry *entry, 
  				  struct snd_info_buffer *buffer)

  {

  	struct snd_trident *trident = entry->private_data;

  	char *s;
  
  	switch (trident->device) {
  	case TRIDENT_DEVICE_ID_SI7018:
  		s = "SiS 7018 Audio";
  		break;
  	case TRIDENT_DEVICE_ID_DX:
  		s = "Trident 4DWave PCI DX";
  		break;
  	case TRIDENT_DEVICE_ID_NX:
  		s = "Trident 4DWave PCI NX";
  		break;
  	default:
  		s = "???";
  	}
  	snd_iprintf(buffer, "%s
  
  ", s);
  	snd_iprintf(buffer, "Spurious IRQs    : %d
  ", trident->spurious_irq_count);
  	snd_iprintf(buffer, "Spurious IRQ dlta: %d
  ", trident->spurious_irq_max_delta);
  	if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018)
  		snd_iprintf(buffer, "IEC958 Mixer Out : %s
  ", trident->spdif_ctrl == 0x28 ? "on" : "off");
  	if (trident->device == TRIDENT_DEVICE_ID_NX) {
  		snd_iprintf(buffer, "Rear Speakers    : %s
  ", trident->ac97_ctrl & 0x00000010 ? "on" : "off");
  		if (trident->tlb.entries) {
  			snd_iprintf(buffer,"
  Virtual Memory
  ");
  			snd_iprintf(buffer, "Memory Maximum : %d
  ", trident->tlb.memhdr->size);
  			snd_iprintf(buffer, "Memory Used    : %d
  ", trident->tlb.memhdr->used);
  			snd_iprintf(buffer, "Memory Free    : %d
  ", snd_util_mem_avail(trident->tlb.memhdr));
  		}
  	}

  }

  static void __devinit snd_trident_proc_init(struct snd_trident * trident)

  {

  	struct snd_info_entry *entry;

  	const char *s = "trident";
  	
  	if (trident->device == TRIDENT_DEVICE_ID_SI7018)
  		s = "sis7018";
  	if (! snd_card_proc_new(trident->card, s, &entry))

  		snd_info_set_text_ops(entry, trident, snd_trident_proc_read);

  }

  static int snd_trident_dev_free(struct snd_device *device)

  {

  	struct snd_trident *trident = device->device_data;

  	return snd_trident_free(trident);
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_tlb_alloc
    
     Description: Allocate and set up the TLB page table on 4D NX.
  		Each entry has 4 bytes (physical PCI address).
                  

     Parameters:  trident - pointer to target device class for 4DWave.

  
     Returns:     0 or negative error code
    
    ---------------------------------------------------------------------------*/

  static int __devinit snd_trident_tlb_alloc(struct snd_trident *trident)

  {
  	int i;
  
  	/* TLB array must be aligned to 16kB !!! so we allocate
  	   32kB region and correct offset when necessary */
  
  	if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
  				2 * SNDRV_TRIDENT_MAX_PAGES * 4, &trident->tlb.buffer) < 0) {
  		snd_printk(KERN_ERR "trident: unable to allocate TLB buffer
  ");
  		return -ENOMEM;
  	}

  	trident->tlb.entries = (unsigned int*)ALIGN((unsigned long)trident->tlb.buffer.area, SNDRV_TRIDENT_MAX_PAGES * 4);
  	trident->tlb.entries_dmaaddr = ALIGN(trident->tlb.buffer.addr, SNDRV_TRIDENT_MAX_PAGES * 4);

  	/* allocate shadow TLB page table (virtual addresses) */

  	trident->tlb.shadow_entries = vmalloc(SNDRV_TRIDENT_MAX_PAGES*sizeof(unsigned long));

  	if (trident->tlb.shadow_entries == NULL) {
  		snd_printk(KERN_ERR "trident: unable to allocate shadow TLB entries
  ");
  		return -ENOMEM;
  	}
  	/* allocate and setup silent page and initialise TLB entries */
  	if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
  				SNDRV_TRIDENT_PAGE_SIZE, &trident->tlb.silent_page) < 0) {
  		snd_printk(KERN_ERR "trident: unable to allocate silent page
  ");
  		return -ENOMEM;
  	}
  	memset(trident->tlb.silent_page.area, 0, SNDRV_TRIDENT_PAGE_SIZE);
  	for (i = 0; i < SNDRV_TRIDENT_MAX_PAGES; i++) {
  		trident->tlb.entries[i] = cpu_to_le32(trident->tlb.silent_page.addr & ~(SNDRV_TRIDENT_PAGE_SIZE-1));
  		trident->tlb.shadow_entries[i] = (unsigned long)trident->tlb.silent_page.area;
  	}
  
  	/* use emu memory block manager code to manage tlb page allocation */
  	trident->tlb.memhdr = snd_util_memhdr_new(SNDRV_TRIDENT_PAGE_SIZE * SNDRV_TRIDENT_MAX_PAGES);
  	if (trident->tlb.memhdr == NULL)
  		return -ENOMEM;

  	trident->tlb.memhdr->block_extra_size = sizeof(struct snd_trident_memblk_arg);

  	return 0;
  }
  
  /*
   * initialize 4D DX chip
   */

  static void snd_trident_stop_all_voices(struct snd_trident *trident)

  {
  	outl(0xffffffff, TRID_REG(trident, T4D_STOP_A));
  	outl(0xffffffff, TRID_REG(trident, T4D_STOP_B));
  	outl(0, TRID_REG(trident, T4D_AINTEN_A));
  	outl(0, TRID_REG(trident, T4D_AINTEN_B));
  }

  static int snd_trident_4d_dx_init(struct snd_trident *trident)

  {
  	struct pci_dev *pci = trident->pci;
  	unsigned long end_time;
  
  	/* reset the legacy configuration and whole audio/wavetable block */
  	pci_write_config_dword(pci, 0x40, 0);	/* DDMA */
  	pci_write_config_byte(pci, 0x44, 0);	/* ports */
  	pci_write_config_byte(pci, 0x45, 0);	/* Legacy DMA */
  	pci_write_config_byte(pci, 0x46, 4); /* reset */
  	udelay(100);
  	pci_write_config_byte(pci, 0x46, 0); /* release reset */
  	udelay(100);
  	
  	/* warm reset of the AC'97 codec */
  	outl(0x00000001, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
  	udelay(100);
  	outl(0x00000000, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
  	/* DAC on, disable SB IRQ and try to force ADC valid signal */
  	trident->ac97_ctrl = 0x0000004a;
  	outl(trident->ac97_ctrl, TRID_REG(trident, DX_ACR2_AC97_COM_STAT));
  	/* wait, until the codec is ready */
  	end_time = (jiffies + (HZ * 3) / 4) + 1;
  	do {
  		if ((inl(TRID_REG(trident, DX_ACR2_AC97_COM_STAT)) & 0x0010) != 0)
  			goto __dx_ok;
  		do_delay(trident);
  	} while (time_after_eq(end_time, jiffies));
  	snd_printk(KERN_ERR "AC'97 codec ready error
  ");
  	return -EIO;
  
   __dx_ok:
  	snd_trident_stop_all_voices(trident);
  
  	return 0;
  }
  
  /*
   * initialize 4D NX chip
   */

  static int snd_trident_4d_nx_init(struct snd_trident *trident)

  {
  	struct pci_dev *pci = trident->pci;
  	unsigned long end_time;
  
  	/* reset the legacy configuration and whole audio/wavetable block */
  	pci_write_config_dword(pci, 0x40, 0);	/* DDMA */
  	pci_write_config_byte(pci, 0x44, 0);	/* ports */
  	pci_write_config_byte(pci, 0x45, 0);	/* Legacy DMA */
  
  	pci_write_config_byte(pci, 0x46, 1); /* reset */
  	udelay(100);
  	pci_write_config_byte(pci, 0x46, 0); /* release reset */
  	udelay(100);
  
  	/* warm reset of the AC'97 codec */
  	outl(0x00000001, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
  	udelay(100);
  	outl(0x00000000, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
  	/* wait, until the codec is ready */
  	end_time = (jiffies + (HZ * 3) / 4) + 1;
  	do {
  		if ((inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)) & 0x0008) != 0)
  			goto __nx_ok;
  		do_delay(trident);
  	} while (time_after_eq(end_time, jiffies));
  	snd_printk(KERN_ERR "AC'97 codec ready error [0x%x]
  ", inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)));
  	return -EIO;
  
   __nx_ok:
  	/* DAC on */
  	trident->ac97_ctrl = 0x00000002;
  	outl(trident->ac97_ctrl, TRID_REG(trident, NX_ACR0_AC97_COM_STAT));
  	/* disable SB IRQ */
  	outl(NX_SB_IRQ_DISABLE, TRID_REG(trident, T4D_MISCINT));
  
  	snd_trident_stop_all_voices(trident);
  
  	if (trident->tlb.entries != NULL) {
  		unsigned int i;
  		/* enable virtual addressing via TLB */
  		i = trident->tlb.entries_dmaaddr;
  		i |= 0x00000001;
  		outl(i, TRID_REG(trident, NX_TLBC));
  	} else {
  		outl(0, TRID_REG(trident, NX_TLBC));
  	}
  	/* initialize S/PDIF */
  	outl(trident->spdif_bits, TRID_REG(trident, NX_SPCSTATUS));
  	outb(trident->spdif_ctrl, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
  
  	return 0;
  }
  
  /*
   * initialize sis7018 chip
   */

  static int snd_trident_sis_init(struct snd_trident *trident)

  {
  	int err;
  
  	if ((err = snd_trident_sis_reset(trident)) < 0)
  		return err;
  
  	snd_trident_stop_all_voices(trident);
  
  	/* initialize S/PDIF */
  	outl(trident->spdif_bits, TRID_REG(trident, SI_SPDIF_CS));
  
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_create
    
     Description: This routine will create the device specific class for
                  the 4DWave card. It will also perform basic initialization.
                  

     Parameters:  card  - which card to create

                  pci   - interface to PCI bus resource info
                  dma1ptr - playback dma buffer
                  dma2ptr - capture dma buffer
                  irqptr  -  interrupt resource info
  
     Returns:     4DWave device class private data
    
    ---------------------------------------------------------------------------*/

  int __devinit snd_trident_create(struct snd_card *card,

  		       struct pci_dev *pci,
  		       int pcm_streams,
  		       int pcm_spdif_device,
  		       int max_wavetable_size,

  		       struct snd_trident ** rtrident)

  {

  	struct snd_trident *trident;

  	int i, err;

  	struct snd_trident_voice *voice;
  	struct snd_trident_pcm_mixer *tmix;
  	static struct snd_device_ops ops = {

  		.dev_free =	snd_trident_dev_free,
  	};
  
  	*rtrident = NULL;
  
  	/* enable PCI device */
  	if ((err = pci_enable_device(pci)) < 0)
  		return err;
  	/* check, if we can restrict PCI DMA transfers to 30 bits */

  	if (pci_set_dma_mask(pci, DMA_BIT_MASK(30)) < 0 ||
  	    pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(30)) < 0) {

  		snd_printk(KERN_ERR "architecture does not support 30bit PCI busmaster DMA
  ");

  		pci_disable_device(pci);
  		return -ENXIO;
  	}
  	

  	trident = kzalloc(sizeof(*trident), GFP_KERNEL);

  	if (trident == NULL) {
  		pci_disable_device(pci);
  		return -ENOMEM;
  	}
  	trident->device = (pci->vendor << 16) | pci->device;
  	trident->card = card;
  	trident->pci = pci;
  	spin_lock_init(&trident->reg_lock);
  	spin_lock_init(&trident->event_lock);
  	spin_lock_init(&trident->voice_alloc);
  	if (pcm_streams < 1)
  		pcm_streams = 1;
  	if (pcm_streams > 32)
  		pcm_streams = 32;
  	trident->ChanPCM = pcm_streams;
  	if (max_wavetable_size < 0 )
  		max_wavetable_size = 0;
  	trident->synth.max_size = max_wavetable_size * 1024;
  	trident->irq = -1;
  
  	trident->midi_port = TRID_REG(trident, T4D_MPU401_BASE);
  	pci_set_master(pci);
  
  	if ((err = pci_request_regions(pci, "Trident Audio")) < 0) {
  		kfree(trident);
  		pci_disable_device(pci);
  		return err;
  	}
  	trident->port = pci_resource_start(pci, 0);

  	if (request_irq(pci->irq, snd_trident_interrupt, IRQF_SHARED,

  			KBUILD_MODNAME, trident)) {

  		snd_printk(KERN_ERR "unable to grab IRQ %d
  ", pci->irq);

  		snd_trident_free(trident);
  		return -EBUSY;
  	}
  	trident->irq = pci->irq;
  
  	/* allocate 16k-aligned TLB for NX cards */
  	trident->tlb.entries = NULL;
  	trident->tlb.buffer.area = NULL;
  	if (trident->device == TRIDENT_DEVICE_ID_NX) {
  		if ((err = snd_trident_tlb_alloc(trident)) < 0) {
  			snd_trident_free(trident);
  			return err;
  		}
  	}
  
  	trident->spdif_bits = trident->spdif_pcm_bits = SNDRV_PCM_DEFAULT_CON_SPDIF;
  
  	/* initialize chip */
  	switch (trident->device) {
  	case TRIDENT_DEVICE_ID_DX:
  		err = snd_trident_4d_dx_init(trident);
  		break;
  	case TRIDENT_DEVICE_ID_NX:
  		err = snd_trident_4d_nx_init(trident);
  		break;
  	case TRIDENT_DEVICE_ID_SI7018:
  		err = snd_trident_sis_init(trident);
  		break;
  	default:
  		snd_BUG();
  		break;
  	}
  	if (err < 0) {
  		snd_trident_free(trident);
  		return err;
  	}
  
  	if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, trident, &ops)) < 0) {
  		snd_trident_free(trident);
  		return err;
  	}
  
  	if ((err = snd_trident_mixer(trident, pcm_spdif_device)) < 0)
  		return err;
  	
  	/* initialise synth voices */
  	for (i = 0; i < 64; i++) {
  		voice = &trident->synth.voices[i];
  		voice->number = i;
  		voice->trident = trident;
  	}
  	/* initialize pcm mixer entries */
  	for (i = 0; i < 32; i++) {
  		tmix = &trident->pcm_mixer[i];
  		tmix->vol = T4D_DEFAULT_PCM_VOL;
  		tmix->pan = T4D_DEFAULT_PCM_PAN;
  		tmix->rvol = T4D_DEFAULT_PCM_RVOL;
  		tmix->cvol = T4D_DEFAULT_PCM_CVOL;
  	}
  
  	snd_trident_enable_eso(trident);

  	snd_trident_proc_init(trident);
  	snd_card_set_dev(card, &pci->dev);
  	*rtrident = trident;
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_free
    
     Description: This routine will free the device specific class for
                  the 4DWave card. 
                  

     Parameters:  trident  - device specific private data for 4DWave card

  
     Returns:     None.
    
    ---------------------------------------------------------------------------*/

  static int snd_trident_free(struct snd_trident *trident)

  {
  	snd_trident_free_gameport(trident);
  	snd_trident_disable_eso(trident);
  	// Disable S/PDIF out
  	if (trident->device == TRIDENT_DEVICE_ID_NX)
  		outb(0x00, TRID_REG(trident, NX_SPCTRL_SPCSO + 3));
  	else if (trident->device == TRIDENT_DEVICE_ID_SI7018) {
  		outl(0, TRID_REG(trident, SI_SERIAL_INTF_CTRL));
  	}

  	if (trident->irq >= 0)
  		free_irq(trident->irq, trident);

  	if (trident->tlb.buffer.area) {
  		outl(0, TRID_REG(trident, NX_TLBC));
  		if (trident->tlb.memhdr)
  			snd_util_memhdr_free(trident->tlb.memhdr);
  		if (trident->tlb.silent_page.area)
  			snd_dma_free_pages(&trident->tlb.silent_page);
  		vfree(trident->tlb.shadow_entries);
  		snd_dma_free_pages(&trident->tlb.buffer);
  	}

  	pci_release_regions(trident->pci);
  	pci_disable_device(trident->pci);
  	kfree(trident);
  	return 0;
  }
  
  /*---------------------------------------------------------------------------
     snd_trident_interrupt
    
     Description: ISR for Trident 4DWave device
                  

     Parameters:  trident  - device specific private data for 4DWave card

  
     Problems:    It seems that Trident chips generates interrupts more than
                  one time in special cases. The spurious interrupts are
                  detected via sample timer (T4D_STIMER) and computing
                  corresponding delta value. The limits are detected with
                  the method try & fail so it is possible that it won't
                  work on all computers. [jaroslav]
  
     Returns:     None.
    
    ---------------------------------------------------------------------------*/

  static irqreturn_t snd_trident_interrupt(int irq, void *dev_id)

  {

  	struct snd_trident *trident = dev_id;

  	unsigned int audio_int, chn_int, stimer, channel, mask, tmp;
  	int delta;

  	struct snd_trident_voice *voice;

  
  	audio_int = inl(TRID_REG(trident, T4D_MISCINT));
  	if ((audio_int & (ADDRESS_IRQ|MPU401_IRQ)) == 0)
  		return IRQ_NONE;
  	if (audio_int & ADDRESS_IRQ) {
  		// get interrupt status for all channels
  		spin_lock(&trident->reg_lock);
  		stimer = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff;
  		chn_int = inl(TRID_REG(trident, T4D_AINT_A));
  		if (chn_int == 0)
  			goto __skip1;
  		outl(chn_int, TRID_REG(trident, T4D_AINT_A));	/* ack */
  	      __skip1:
  		chn_int = inl(TRID_REG(trident, T4D_AINT_B));
  		if (chn_int == 0)
  			goto __skip2;
  		for (channel = 63; channel >= 32; channel--) {
  			mask = 1 << (channel&0x1f);
  			if ((chn_int & mask) == 0)
  				continue;
  			voice = &trident->synth.voices[channel];
  			if (!voice->pcm || voice->substream == NULL) {
  				outl(mask, TRID_REG(trident, T4D_STOP_B));
  				continue;
  			}
  			delta = (int)stimer - (int)voice->stimer;
  			if (delta < 0)
  				delta = -delta;
  			if ((unsigned int)delta < voice->spurious_threshold) {
  				/* do some statistics here */
  				trident->spurious_irq_count++;
  				if (trident->spurious_irq_max_delta < (unsigned int)delta)
  					trident->spurious_irq_max_delta = delta;
  				continue;
  			}
  			voice->stimer = stimer;
  			if (voice->isync) {
  				if (!voice->isync3) {
  					tmp = inw(TRID_REG(trident, T4D_SBBL_SBCL));
  					if (trident->bDMAStart & 0x40)
  						tmp >>= 1;
  					if (tmp > 0)
  						tmp = voice->isync_max - tmp;
  				} else {
  					tmp = inl(TRID_REG(trident, NX_SPCTRL_SPCSO)) & 0x00ffffff;
  				}
  				if (tmp < voice->isync_mark) {
  					if (tmp > 0x10)
  						tmp = voice->isync_ESO - 7;
  					else
  						tmp = voice->isync_ESO + 2;
  					/* update ESO for IRQ voice to preserve sync */
  					snd_trident_stop_voice(trident, voice->number);
  					snd_trident_write_eso_reg(trident, voice, tmp);
  					snd_trident_start_voice(trident, voice->number);
  				}
  			} else if (voice->isync2) {
  				voice->isync2 = 0;
  				/* write original ESO and update CSO for IRQ voice to preserve sync */
  				snd_trident_stop_voice(trident, voice->number);
  				snd_trident_write_cso_reg(trident, voice, voice->isync_mark);
  				snd_trident_write_eso_reg(trident, voice, voice->ESO);
  				snd_trident_start_voice(trident, voice->number);
  			}
  #if 0
  			if (voice->extra) {
  				/* update CSO for extra voice to preserve sync */
  				snd_trident_stop_voice(trident, voice->extra->number);
  				snd_trident_write_cso_reg(trident, voice->extra, 0);
  				snd_trident_start_voice(trident, voice->extra->number);
  			}
  #endif
  			spin_unlock(&trident->reg_lock);
  			snd_pcm_period_elapsed(voice->substream);
  			spin_lock(&trident->reg_lock);
  		}
  		outl(chn_int, TRID_REG(trident, T4D_AINT_B));	/* ack */
  	      __skip2:
  		spin_unlock(&trident->reg_lock);
  	}
  	if (audio_int & MPU401_IRQ) {
  		if (trident->rmidi) {

  			snd_mpu401_uart_interrupt(irq, trident->rmidi->private_data);

  		} else {
  			inb(TRID_REG(trident, T4D_MPUR0));
  		}
  	}
  	// outl((ST_TARGET_REACHED | MIXER_OVERFLOW | MIXER_UNDERFLOW), TRID_REG(trident, T4D_MISCINT));
  	return IRQ_HANDLED;
  }

  struct snd_trident_voice *snd_trident_alloc_voice(struct snd_trident * trident, int type, int client, int port)

  {

  	struct snd_trident_voice *pvoice;

  	unsigned long flags;
  	int idx;
  
  	spin_lock_irqsave(&trident->voice_alloc, flags);
  	if (type == SNDRV_TRIDENT_VOICE_TYPE_PCM) {
  		idx = snd_trident_allocate_pcm_channel(trident);
  		if(idx < 0) {
  			spin_unlock_irqrestore(&trident->voice_alloc, flags);
  			return NULL;
  		}
  		pvoice = &trident->synth.voices[idx];
  		pvoice->use = 1;
  		pvoice->pcm = 1;
  		pvoice->capture = 0;
  		pvoice->spdif = 0;
  		pvoice->memblk = NULL;
  		pvoice->substream = NULL;
  		spin_unlock_irqrestore(&trident->voice_alloc, flags);
  		return pvoice;
  	}
  	if (type == SNDRV_TRIDENT_VOICE_TYPE_SYNTH) {
  		idx = snd_trident_allocate_synth_channel(trident);
  		if(idx < 0) {
  			spin_unlock_irqrestore(&trident->voice_alloc, flags);
  			return NULL;
  		}
  		pvoice = &trident->synth.voices[idx];
  		pvoice->use = 1;
  		pvoice->synth = 1;
  		pvoice->client = client;
  		pvoice->port = port;
  		pvoice->memblk = NULL;
  		spin_unlock_irqrestore(&trident->voice_alloc, flags);
  		return pvoice;
  	}
  	if (type == SNDRV_TRIDENT_VOICE_TYPE_MIDI) {
  	}
  	spin_unlock_irqrestore(&trident->voice_alloc, flags);
  	return NULL;
  }

  EXPORT_SYMBOL(snd_trident_alloc_voice);

  void snd_trident_free_voice(struct snd_trident * trident, struct snd_trident_voice *voice)

  {
  	unsigned long flags;

  	void (*private_free)(struct snd_trident_voice *);

  	void *private_data;
  
  	if (voice == NULL || !voice->use)
  		return;
  	snd_trident_clear_voices(trident, voice->number, voice->number);
  	spin_lock_irqsave(&trident->voice_alloc, flags);
  	private_free = voice->private_free;
  	private_data = voice->private_data;
  	voice->private_free = NULL;
  	voice->private_data = NULL;
  	if (voice->pcm)
  		snd_trident_free_pcm_channel(trident, voice->number);
  	if (voice->synth)
  		snd_trident_free_synth_channel(trident, voice->number);
  	voice->use = voice->pcm = voice->synth = voice->midi = 0;
  	voice->capture = voice->spdif = 0;
  	voice->sample_ops = NULL;
  	voice->substream = NULL;
  	voice->extra = NULL;
  	spin_unlock_irqrestore(&trident->voice_alloc, flags);
  	if (private_free)
  		private_free(voice);
  }

  EXPORT_SYMBOL(snd_trident_free_voice);

  static void snd_trident_clear_voices(struct snd_trident * trident, unsigned short v_min, unsigned short v_max)

  {
  	unsigned int i, val, mask[2] = { 0, 0 };

  	if (snd_BUG_ON(v_min > 63 || v_max > 63))
  		return;

  	for (i = v_min; i <= v_max; i++)
  		mask[i >> 5] |= 1 << (i & 0x1f);
  	if (mask[0]) {
  		outl(mask[0], TRID_REG(trident, T4D_STOP_A));
  		val = inl(TRID_REG(trident, T4D_AINTEN_A));
  		outl(val & ~mask[0], TRID_REG(trident, T4D_AINTEN_A));
  	}
  	if (mask[1]) {
  		outl(mask[1], TRID_REG(trident, T4D_STOP_B));
  		val = inl(TRID_REG(trident, T4D_AINTEN_B));
  		outl(val & ~mask[1], TRID_REG(trident, T4D_AINTEN_B));
  	}
  }
  
  #ifdef CONFIG_PM

  int snd_trident_suspend(struct pci_dev *pci, pm_message_t state)

  {

  	struct snd_card *card = pci_get_drvdata(pci);
  	struct snd_trident *trident = card->private_data;

  
  	trident->in_suspend = 1;

  	snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);

  	snd_pcm_suspend_all(trident->pcm);

  	snd_pcm_suspend_all(trident->foldback);
  	snd_pcm_suspend_all(trident->spdif);

  
  	snd_ac97_suspend(trident->ac97);

  	snd_ac97_suspend(trident->ac97_sec);

  	pci_disable_device(pci);
  	pci_save_state(pci);

  	pci_set_power_state(pci, pci_choose_state(pci, state));

  	return 0;
  }

  int snd_trident_resume(struct pci_dev *pci)

  {

  	struct snd_card *card = pci_get_drvdata(pci);
  	struct snd_trident *trident = card->private_data;

  	pci_set_power_state(pci, PCI_D0);

  	pci_restore_state(pci);

  	if (pci_enable_device(pci) < 0) {
  		printk(KERN_ERR "trident: pci_enable_device failed, "
  		       "disabling device
  ");
  		snd_card_disconnect(card);
  		return -EIO;
  	}
  	pci_set_master(pci);

  
  	switch (trident->device) {
  	case TRIDENT_DEVICE_ID_DX:
  		snd_trident_4d_dx_init(trident);
  		break;
  	case TRIDENT_DEVICE_ID_NX:
  		snd_trident_4d_nx_init(trident);
  		break;
  	case TRIDENT_DEVICE_ID_SI7018:
  		snd_trident_sis_init(trident);
  		break;
  	}
  
  	snd_ac97_resume(trident->ac97);

  	snd_ac97_resume(trident->ac97_sec);

  
  	/* restore some registers */
  	outl(trident->musicvol_wavevol, TRID_REG(trident, T4D_MUSICVOL_WAVEVOL));
  
  	snd_trident_enable_eso(trident);

  	snd_power_change_state(card, SNDRV_CTL_POWER_D0);

  	trident->in_suspend = 0;
  	return 0;
  }
  #endif /* CONFIG_PM */