[ALSA] Add even more 'const' to everything related to TLV
[linux-2.6.git] / sound / pci / trident / trident_main.c
index 08226f5..3bff321 100644 (file)
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
 #include <linux/gameport.h>
+#include <linux/dma-mapping.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(trident_t *trident, snd_trident_voice_t * voice, snd_pcm_substream_t *substream);
-static int snd_trident_pcm_mixer_free(trident_t *trident, snd_trident_voice_t * voice, snd_pcm_substream_t *substream);
-static irqreturn_t snd_trident_interrupt(int irq, void *dev_id, struct pt_regs *regs);
-#ifdef CONFIG_PM
-static int snd_trident_suspend(snd_card_t *card, pm_message_t state);
-static int snd_trident_resume(snd_card_t *card);
-#endif
-static int snd_trident_sis_reset(trident_t *trident);
+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(trident_t * trident, unsigned short v_min, unsigned short v_max);
-static int snd_trident_free(trident_t *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
@@ -62,7 +65,7 @@ static int snd_trident_free(trident_t *trident);
 
 
 #if 0
-static void snd_trident_print_voice_regs(trident_t *trident, int voice)
+static void snd_trident_print_voice_regs(struct snd_trident *trident, int voice)
 {
        unsigned int val, tmp;
 
@@ -104,7 +107,7 @@ static void snd_trident_print_voice_regs(trident_t *trident, int voice)
 #endif
 
 /*---------------------------------------------------------------------------
-   unsigned short snd_trident_codec_read(ac97_t *ac97, unsigned short reg)
+   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).
@@ -115,12 +118,12 @@ static void snd_trident_print_voice_regs(trident_t *trident, int voice)
    returns:     16 bit value read from the AC97.
   
   ---------------------------------------------------------------------------*/
-static unsigned short snd_trident_codec_read(ac97_t *ac97, unsigned short reg)
+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;
-       trident_t *trident = ac97->private_data;
+       struct snd_trident *trident = ac97->private_data;
 
        spin_lock_irqsave(&trident->reg_lock, flags);
        if (trident->device == TRIDENT_DEVICE_ID_DX) {
@@ -153,7 +156,8 @@ static unsigned short snd_trident_codec_read(ac97_t *ac97, unsigned short reg)
        }
 
        if (count == 0 && !trident->ac97_detect) {
-               snd_printk(KERN_ERR "ac97 codec read TIMEOUT [0x%x/0x%x]!!!\n", reg, data);
+               snd_printk(KERN_ERR "ac97 codec read TIMEOUT [0x%x/0x%x]!!!\n",
+                          reg, data);
                data = 0;
        }
 
@@ -162,7 +166,8 @@ static unsigned short snd_trident_codec_read(ac97_t *ac97, unsigned short reg)
 }
 
 /*---------------------------------------------------------------------------
-   void snd_trident_codec_write(ac97_t *ac97, unsigned short reg, unsigned short wdata)
+   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).
@@ -174,12 +179,13 @@ static unsigned short snd_trident_codec_read(ac97_t *ac97, unsigned short reg)
    returns:     TRUE if everything went ok, else FALSE.
   
   ---------------------------------------------------------------------------*/
-static void snd_trident_codec_write(ac97_t *ac97, unsigned short reg, unsigned short wdata)
+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;
-       trident_t *trident = ac97->private_data;
+       struct snd_trident *trident = ac97->private_data;
 
        data = ((unsigned long) wdata) << 16;
 
@@ -230,7 +236,7 @@ static void snd_trident_codec_write(ac97_t *ac97, unsigned short reg, unsigned s
 }
 
 /*---------------------------------------------------------------------------
-   void snd_trident_enable_eso(trident_t *trident)
+   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
@@ -241,7 +247,7 @@ static void snd_trident_codec_write(ac97_t *ac97, unsigned short reg, unsigned s
   
   ---------------------------------------------------------------------------*/
 
-static void snd_trident_enable_eso(trident_t * trident)
+static void snd_trident_enable_eso(struct snd_trident * trident)
 {
        unsigned int val;
 
@@ -254,7 +260,7 @@ static void snd_trident_enable_eso(trident_t * trident)
 }
 
 /*---------------------------------------------------------------------------
-   void snd_trident_disable_eso(trident_t *trident)
+   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
@@ -268,7 +274,7 @@ static void snd_trident_enable_eso(trident_t * trident)
   
   ---------------------------------------------------------------------------*/
 
-static void snd_trident_disable_eso(trident_t * trident)
+static void snd_trident_disable_eso(struct snd_trident * trident)
 {
        unsigned int tmp;
 
@@ -279,7 +285,7 @@ static void snd_trident_disable_eso(trident_t * trident)
 }
 
 /*---------------------------------------------------------------------------
-   void snd_trident_start_voice(trident_t * trident, unsigned int voice)
+   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
@@ -292,7 +298,7 @@ static void snd_trident_disable_eso(trident_t * trident)
 
   ---------------------------------------------------------------------------*/
 
-void snd_trident_start_voice(trident_t * trident, unsigned int voice)
+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;
@@ -300,8 +306,10 @@ void snd_trident_start_voice(trident_t * trident, unsigned int voice)
        outl(mask, TRID_REG(trident, reg));
 }
 
+EXPORT_SYMBOL(snd_trident_start_voice);
+
 /*---------------------------------------------------------------------------
-   void snd_trident_stop_voice(trident_t * trident, unsigned int 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
@@ -314,7 +322,7 @@ void snd_trident_start_voice(trident_t * trident, unsigned int voice)
 
   ---------------------------------------------------------------------------*/
 
-void snd_trident_stop_voice(trident_t * trident, unsigned int voice)
+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;
@@ -322,8 +330,10 @@ void snd_trident_stop_voice(trident_t * trident, unsigned int voice)
        outl(mask, TRID_REG(trident, reg));
 }
 
+EXPORT_SYMBOL(snd_trident_stop_voice);
+
 /*---------------------------------------------------------------------------
-    int snd_trident_allocate_pcm_channel(trident_t *trident)
+    int snd_trident_allocate_pcm_channel(struct snd_trident *trident)
   
     Description: Allocate hardware channel in Bank B (32-63).
   
@@ -333,7 +343,7 @@ void snd_trident_stop_voice(trident_t * trident, unsigned int voice)
   
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_allocate_pcm_channel(trident_t * trident)
+static int snd_trident_allocate_pcm_channel(struct snd_trident * trident)
 {
        int idx;
 
@@ -361,7 +371,7 @@ static int snd_trident_allocate_pcm_channel(trident_t * trident)
   
   ---------------------------------------------------------------------------*/
 
-static void snd_trident_free_pcm_channel(trident_t *trident, int channel)
+static void snd_trident_free_pcm_channel(struct snd_trident *trident, int channel)
 {
        if (channel < 32 || channel > 63)
                return;
@@ -383,7 +393,7 @@ static void snd_trident_free_pcm_channel(trident_t *trident, int channel)
   
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_allocate_synth_channel(trident_t * trident)
+static int snd_trident_allocate_synth_channel(struct snd_trident * trident)
 {
        int idx;
 
@@ -409,7 +419,7 @@ static int snd_trident_allocate_synth_channel(trident_t * trident)
   
   ---------------------------------------------------------------------------*/
 
-static void snd_trident_free_synth_channel(trident_t *trident, int channel)
+static void snd_trident_free_synth_channel(struct snd_trident *trident, int channel)
 {
        if (channel < 0 || channel > 31)
                return;
@@ -432,8 +442,8 @@ static void snd_trident_free_synth_channel(trident_t *trident, int channel)
   
   ---------------------------------------------------------------------------*/
 
-void snd_trident_write_voice_regs(trident_t * trident,
-                                 snd_trident_voice_t * voice)
+void snd_trident_write_voice_regs(struct snd_trident * trident,
+                                 struct snd_trident_voice * voice)
 {
        unsigned int FmcRvolCvol;
        unsigned int regs[5];
@@ -452,14 +462,16 @@ void snd_trident_write_voice_regs(trident_t * trident,
                                (voice->Vol & 0x000003ff) :
                                ((voice->Vol & 0x00003fc) << (16-2)) |
                                (voice->EC & 0x00000fff);
-               regs[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) | (voice->FMS & 0x0000000f);
+               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[0] = (voice->CSO << 16) | ((voice->Alpha & 0x00000fff) << 4) |
+                       (voice->FMS & 0x0000000f);
                regs[2] = (voice->ESO << 16) | (voice->Delta & 0x0ffff);
                regs[3] = FmcRvolCvol;
                break;
@@ -467,8 +479,10 @@ void snd_trident_write_voice_regs(trident_t * trident,
                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;
+               regs[2] = ((voice->Delta << 16) & 0xff000000) |
+                       (voice->ESO & 0x00ffffff);
+               regs[3] = (voice->Alpha << 20) |
+                       ((voice->FMS & 0x0000000f) << 16) | FmcRvolCvol;
                break;
        default:
                snd_BUG();
@@ -492,6 +506,8 @@ void snd_trident_write_voice_regs(trident_t * trident,
 #endif
 }
 
+EXPORT_SYMBOL(snd_trident_write_voice_regs);
+
 /*---------------------------------------------------------------------------
    snd_trident_write_cso_reg
   
@@ -504,14 +520,17 @@ void snd_trident_write_voice_regs(trident_t * trident,
   
   ---------------------------------------------------------------------------*/
 
-static void snd_trident_write_cso_reg(trident_t * trident, snd_trident_voice_t * voice, unsigned int CSO)
+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));
+               outl((voice->Delta << 24) |
+                    (voice->CSO & 0x00ffffff), TRID_REG(trident, CH_NX_DELTA_CSO));
        }
 }
 
@@ -527,14 +546,17 @@ static void snd_trident_write_cso_reg(trident_t * trident, snd_trident_voice_t *
   
   ---------------------------------------------------------------------------*/
 
-static void snd_trident_write_eso_reg(trident_t * trident, snd_trident_voice_t * voice, unsigned int ESO)
+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));
+               outl(((voice->Delta << 16) & 0xff000000) | (voice->ESO & 0x00ffffff),
+                    TRID_REG(trident, CH_NX_DELTA_ESO));
        }
 }
 
@@ -550,7 +572,9 @@ static void snd_trident_write_eso_reg(trident_t * trident, snd_trident_voice_t *
   
   ---------------------------------------------------------------------------*/
 
-static void snd_trident_write_vol_reg(trident_t * trident, snd_trident_voice_t * voice, unsigned int Vol)
+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));
@@ -561,7 +585,8 @@ static void snd_trident_write_vol_reg(trident_t * trident, snd_trident_voice_t *
                break;
        case TRIDENT_DEVICE_ID_SI7018:
                // printk("voice->Vol = 0x%x\n", voice->Vol);
-               outw((voice->CTRL << 12) | voice->Vol, TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC));
+               outw((voice->CTRL << 12) | voice->Vol,
+                    TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC));
                break;
        }
 }
@@ -578,11 +603,14 @@ static void snd_trident_write_vol_reg(trident_t * trident, snd_trident_voice_t *
   
   ---------------------------------------------------------------------------*/
 
-static void snd_trident_write_pan_reg(trident_t * trident, snd_trident_voice_t * voice, unsigned int Pan)
+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));
+       outb(((voice->GVSel & 0x01) << 7) | (voice->Pan & 0x7f),
+            TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC + 3));
 }
 
 /*---------------------------------------------------------------------------
@@ -597,12 +625,16 @@ static void snd_trident_write_pan_reg(trident_t * trident, snd_trident_voice_t *
   
   ---------------------------------------------------------------------------*/
 
-static void snd_trident_write_rvol_reg(trident_t * trident, snd_trident_voice_t * voice, unsigned int RVol)
+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));
+       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));
 }
 
 /*---------------------------------------------------------------------------
@@ -617,12 +649,16 @@ static void snd_trident_write_rvol_reg(trident_t * trident, snd_trident_voice_t
   
   ---------------------------------------------------------------------------*/
 
-static void snd_trident_write_cvol_reg(trident_t * trident, snd_trident_voice_t * voice, unsigned int CVol)
+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));
+       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));
 }
 
 /*---------------------------------------------------------------------------
@@ -696,7 +732,8 @@ static unsigned int snd_trident_convert_adc_rate(unsigned int rate)
    Returns:     Delta value.
   
   ---------------------------------------------------------------------------*/
-static unsigned int snd_trident_spurious_threshold(unsigned int rate, unsigned int period_size)
+static unsigned int snd_trident_spurious_threshold(unsigned int rate,
+                                                  unsigned int period_size)
 {
        unsigned int res = (rate * period_size) / 48000;
        if (res < 64)
@@ -717,10 +754,10 @@ static unsigned int snd_trident_spurious_threshold(unsigned int rate, unsigned i
    Returns:     Control value.
   
   ---------------------------------------------------------------------------*/
-static unsigned int snd_trident_control_mode(snd_pcm_substream_t *substream)
+static unsigned int snd_trident_control_mode(struct snd_pcm_substream *substream)
 {
        unsigned int CTRL;
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       struct snd_pcm_runtime *runtime = substream->runtime;
 
        /* set ctrl mode
           CTRL default: 8-bit (unsigned) mono, loop mode enabled
@@ -752,7 +789,7 @@ static unsigned int snd_trident_control_mode(snd_pcm_substream_t *substream)
   
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_ioctl(snd_pcm_substream_t * substream,
+static int snd_trident_ioctl(struct snd_pcm_substream *substream,
                             unsigned int cmd,
                             void *arg)
 {
@@ -774,12 +811,12 @@ static int snd_trident_ioctl(snd_pcm_substream_t * substream,
   
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_allocate_pcm_mem(snd_pcm_substream_t * substream,
-                                       snd_pcm_hw_params_t * hw_params)
+static int snd_trident_allocate_pcm_mem(struct snd_pcm_substream *substream,
+                                       struct snd_pcm_hw_params *hw_params)
 {
-       trident_t *trident = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
-       snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data;
+       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)
@@ -808,13 +845,13 @@ static int snd_trident_allocate_pcm_mem(snd_pcm_substream_t * substream,
   
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_allocate_evoice(snd_pcm_substream_t * substream,
-                                      snd_pcm_hw_params_t * hw_params)
+static int snd_trident_allocate_evoice(struct snd_pcm_substream *substream,
+                                      struct snd_pcm_hw_params *hw_params)
 {
-       trident_t *trident = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
-       snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data;
-       snd_trident_voice_t *evoice = voice->extra;
+       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 */
 
@@ -848,8 +885,8 @@ static int snd_trident_allocate_evoice(snd_pcm_substream_t * substream,
   
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_hw_params(snd_pcm_substream_t * substream,
-                                snd_pcm_hw_params_t * hw_params)
+static int snd_trident_hw_params(struct snd_pcm_substream *substream,
+                                struct snd_pcm_hw_params *hw_params)
 {
        int err;
 
@@ -870,12 +907,12 @@ static int snd_trident_hw_params(snd_pcm_substream_t * substream,
   
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_hw_free(snd_pcm_substream_t * substream)
+static int snd_trident_hw_free(struct snd_pcm_substream *substream)
 {
-       trident_t *trident = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
-       snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data;
-       snd_trident_voice_t *evoice = voice ? voice->extra : NULL;
+       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) {
@@ -902,13 +939,13 @@ static int snd_trident_hw_free(snd_pcm_substream_t * substream)
   
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_playback_prepare(snd_pcm_substream_t * substream)
+static int snd_trident_playback_prepare(struct snd_pcm_substream *substream)
 {
-       trident_t *trident = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
-       snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data;
-       snd_trident_voice_t *evoice = voice->extra;
-       snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[substream->number];
+       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);      
 
@@ -988,8 +1025,8 @@ static int snd_trident_playback_prepare(snd_pcm_substream_t * substream)
   
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_capture_hw_params(snd_pcm_substream_t * substream,
-                                        snd_pcm_hw_params_t * hw_params)
+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);
 }
@@ -1005,11 +1042,11 @@ static int snd_trident_capture_hw_params(snd_pcm_substream_t * substream,
   
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_capture_prepare(snd_pcm_substream_t * substream)
+static int snd_trident_capture_prepare(struct snd_pcm_substream *substream)
 {
-       trident_t *trident = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
-       snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data;
+       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);
@@ -1097,8 +1134,8 @@ static int snd_trident_capture_prepare(snd_pcm_substream_t * substream)
   
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_si7018_capture_hw_params(snd_pcm_substream_t * substream,
-                                               snd_pcm_hw_params_t * hw_params)
+static int snd_trident_si7018_capture_hw_params(struct snd_pcm_substream *substream,
+                                               struct snd_pcm_hw_params *hw_params)
 {
        int err;
 
@@ -1119,12 +1156,12 @@ static int snd_trident_si7018_capture_hw_params(snd_pcm_substream_t * substream,
   
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_si7018_capture_hw_free(snd_pcm_substream_t * substream)
+static int snd_trident_si7018_capture_hw_free(struct snd_pcm_substream *substream)
 {
-       trident_t *trident = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
-       snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data;
-       snd_trident_voice_t *evoice = voice ? voice->extra : NULL;
+       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) {
@@ -1145,12 +1182,12 @@ static int snd_trident_si7018_capture_hw_free(snd_pcm_substream_t * substream)
   
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_si7018_capture_prepare(snd_pcm_substream_t * substream)
+static int snd_trident_si7018_capture_prepare(struct snd_pcm_substream *substream)
 {
-       trident_t *trident = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
-       snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data;
-       snd_trident_voice_t *evoice = voice->extra;
+       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);
 
@@ -1216,12 +1253,12 @@ static int snd_trident_si7018_capture_prepare(snd_pcm_substream_t * substream)
   
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_foldback_prepare(snd_pcm_substream_t * substream)
+static int snd_trident_foldback_prepare(struct snd_pcm_substream *substream)
 {
-       trident_t *trident = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
-       snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data;
-       snd_trident_voice_t *evoice = voice->extra;
+       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);
 
@@ -1294,10 +1331,10 @@ static int snd_trident_foldback_prepare(snd_pcm_substream_t * substream)
   
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_spdif_hw_params(snd_pcm_substream_t * substream,
-                                      snd_pcm_hw_params_t * hw_params)
+static int snd_trident_spdif_hw_params(struct snd_pcm_substream *substream,
+                                      struct snd_pcm_hw_params *hw_params)
 {
-       trident_t *trident = snd_pcm_substream_chip(substream);
+       struct snd_trident *trident = snd_pcm_substream_chip(substream);
        unsigned int old_bits = 0, change = 0;
        int err;
 
@@ -1359,13 +1396,13 @@ static int snd_trident_spdif_hw_params(snd_pcm_substream_t * substream,
   
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_spdif_prepare(snd_pcm_substream_t * substream)
+static int snd_trident_spdif_prepare(struct snd_pcm_substream *substream)
 {
-       trident_t *trident = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
-       snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data;
-       snd_trident_voice_t *evoice = voice->extra;
-       snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[substream->number];
+       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;
 
@@ -1498,15 +1535,15 @@ static int snd_trident_spdif_prepare(snd_pcm_substream_t * substream)
   
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_trigger(snd_pcm_substream_t *substream,
+static int snd_trident_trigger(struct snd_pcm_substream *substream,
                               int cmd)
                                    
 {
-       trident_t *trident = snd_pcm_substream_chip(substream);
+       struct snd_trident *trident = snd_pcm_substream_chip(substream);
        struct list_head *pos;
-       snd_pcm_substream_t *s;
+       struct snd_pcm_substream *s;
        unsigned int what, whati, capture_flag, spdif_flag;
-       snd_trident_voice_t *voice, *evoice;
+       struct snd_trident_voice *voice, *evoice;
        unsigned int val, go;
 
        switch (cmd) {
@@ -1528,8 +1565,8 @@ static int snd_trident_trigger(snd_pcm_substream_t *substream,
        val = inl(TRID_REG(trident, T4D_STIMER)) & 0x00ffffff;
        snd_pcm_group_for_each(pos, substream) {
                s = snd_pcm_group_substream_entry(pos);
-               if ((trident_t *) snd_pcm_substream_chip(s) == trident) {
-                       voice = (snd_trident_voice_t *) s->runtime->private_data;
+               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) {
@@ -1596,11 +1633,11 @@ static int snd_trident_trigger(snd_pcm_substream_t *substream,
   
   ---------------------------------------------------------------------------*/
 
-static snd_pcm_uframes_t snd_trident_playback_pointer(snd_pcm_substream_t * substream)
+static snd_pcm_uframes_t snd_trident_playback_pointer(struct snd_pcm_substream *substream)
 {
-       trident_t *trident = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
-       snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data;
+       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)
@@ -1635,11 +1672,11 @@ static snd_pcm_uframes_t snd_trident_playback_pointer(snd_pcm_substream_t * subs
   
   ---------------------------------------------------------------------------*/
 
-static snd_pcm_uframes_t snd_trident_capture_pointer(snd_pcm_substream_t * substream)
+static snd_pcm_uframes_t snd_trident_capture_pointer(struct snd_pcm_substream *substream)
 {
-       trident_t *trident = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
-       snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data;
+       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)
@@ -1665,11 +1702,11 @@ static snd_pcm_uframes_t snd_trident_capture_pointer(snd_pcm_substream_t * subst
   
   ---------------------------------------------------------------------------*/
 
-static snd_pcm_uframes_t snd_trident_spdif_pointer(snd_pcm_substream_t * substream)
+static snd_pcm_uframes_t snd_trident_spdif_pointer(struct snd_pcm_substream *substream)
 {
-       trident_t *trident = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
-       snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data;
+       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)
@@ -1684,7 +1721,7 @@ static snd_pcm_uframes_t snd_trident_spdif_pointer(snd_pcm_substream_t * substre
  *  Playback support device description
  */
 
-static snd_pcm_hardware_t snd_trident_playback =
+static struct snd_pcm_hardware snd_trident_playback =
 {
        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
                                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
@@ -1709,7 +1746,7 @@ static snd_pcm_hardware_t snd_trident_playback =
  *  Capture support device description
  */
 
-static snd_pcm_hardware_t snd_trident_capture =
+static struct snd_pcm_hardware snd_trident_capture =
 {
        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
                                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
@@ -1734,7 +1771,7 @@ static snd_pcm_hardware_t snd_trident_capture =
  *  Foldback capture support device description
  */
 
-static snd_pcm_hardware_t snd_trident_foldback =
+static struct snd_pcm_hardware snd_trident_foldback =
 {
        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
                                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
@@ -1758,7 +1795,7 @@ static snd_pcm_hardware_t snd_trident_foldback =
  *  SPDIF playback support device description
  */
 
-static snd_pcm_hardware_t snd_trident_spdif =
+static struct snd_pcm_hardware snd_trident_spdif =
 {
        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
                                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
@@ -1779,7 +1816,7 @@ static snd_pcm_hardware_t snd_trident_spdif =
        .fifo_size =            0,
 };
 
-static snd_pcm_hardware_t snd_trident_spdif_7018 =
+static struct snd_pcm_hardware snd_trident_spdif_7018 =
 {
        .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
                                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
@@ -1799,10 +1836,10 @@ static snd_pcm_hardware_t snd_trident_spdif_7018 =
        .fifo_size =            0,
 };
 
-static void snd_trident_pcm_free_substream(snd_pcm_runtime_t *runtime)
+static void snd_trident_pcm_free_substream(struct snd_pcm_runtime *runtime)
 {
-       snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data;
-       trident_t *trident;
+       struct snd_trident_voice *voice = runtime->private_data;
+       struct snd_trident *trident;
 
        if (voice) {
                trident = voice->trident;
@@ -1810,11 +1847,11 @@ static void snd_trident_pcm_free_substream(snd_pcm_runtime_t *runtime)
        }
 }
 
-static int snd_trident_playback_open(snd_pcm_substream_t * substream)
+static int snd_trident_playback_open(struct snd_pcm_substream *substream)
 {
-       trident_t *trident = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
-       snd_trident_voice_t *voice;
+       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)
@@ -1838,11 +1875,11 @@ static int snd_trident_playback_open(snd_pcm_substream_t * substream)
    Parameters: substream  - PCM substream class
 
   ---------------------------------------------------------------------------*/
-static int snd_trident_playback_close(snd_pcm_substream_t * substream)
+static int snd_trident_playback_close(struct snd_pcm_substream *substream)
 {
-       trident_t *trident = snd_pcm_substream_chip(substream);
-       snd_pcm_runtime_t *runtime = substream->runtime;
-       snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data;
+       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;
@@ -1859,11 +1896,11 @@ static int snd_trident_playback_close(snd_pcm_substream_t * substream)
   
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_spdif_open(snd_pcm_substream_t * substream)
+static int snd_trident_spdif_open(struct snd_pcm_substream *substream)
 {
-       trident_t *trident = snd_pcm_substream_chip(substream);
-       snd_trident_voice_t *voice;
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       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)
@@ -1900,9 +1937,9 @@ static int snd_trident_spdif_open(snd_pcm_substream_t * substream)
 
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_spdif_close(snd_pcm_substream_t * substream)
+static int snd_trident_spdif_close(struct snd_pcm_substream *substream)
 {
-       trident_t *trident = snd_pcm_substream_chip(substream);
+       struct snd_trident *trident = snd_pcm_substream_chip(substream);
        unsigned int temp;
 
        spin_lock_irq(&trident->reg_lock);
@@ -1938,11 +1975,11 @@ static int snd_trident_spdif_close(snd_pcm_substream_t * substream)
 
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_capture_open(snd_pcm_substream_t * substream)
+static int snd_trident_capture_open(struct snd_pcm_substream *substream)
 {
-       trident_t *trident = snd_pcm_substream_chip(substream);
-       snd_trident_voice_t *voice;
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       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)
@@ -1966,7 +2003,7 @@ static int snd_trident_capture_open(snd_pcm_substream_t * substream)
    Parameters: substream  - PCM substream class
 
   ---------------------------------------------------------------------------*/
-static int snd_trident_capture_close(snd_pcm_substream_t * substream)
+static int snd_trident_capture_close(struct snd_pcm_substream *substream)
 {
        return 0;
 }
@@ -1982,11 +2019,11 @@ static int snd_trident_capture_close(snd_pcm_substream_t * substream)
 
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_foldback_open(snd_pcm_substream_t * substream)
+static int snd_trident_foldback_open(struct snd_pcm_substream *substream)
 {
-       trident_t *trident = snd_pcm_substream_chip(substream);
-       snd_trident_voice_t *voice;
-       snd_pcm_runtime_t *runtime = substream->runtime;
+       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)
@@ -2009,12 +2046,12 @@ static int snd_trident_foldback_open(snd_pcm_substream_t * substream)
    Parameters: substream  - PCM substream class
 
   ---------------------------------------------------------------------------*/
-static int snd_trident_foldback_close(snd_pcm_substream_t * substream)
+static int snd_trident_foldback_close(struct snd_pcm_substream *substream)
 {
-       trident_t *trident = snd_pcm_substream_chip(substream);
-       snd_trident_voice_t *voice;
-       snd_pcm_runtime_t *runtime = substream->runtime;
-       voice = (snd_trident_voice_t *) runtime->private_data;
+       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);
@@ -2027,7 +2064,7 @@ static int snd_trident_foldback_close(snd_pcm_substream_t * substream)
    PCM operations
   ---------------------------------------------------------------------------*/
 
-static snd_pcm_ops_t snd_trident_playback_ops = {
+static struct snd_pcm_ops snd_trident_playback_ops = {
        .open =         snd_trident_playback_open,
        .close =        snd_trident_playback_close,
        .ioctl =        snd_trident_ioctl,
@@ -2038,7 +2075,7 @@ static snd_pcm_ops_t snd_trident_playback_ops = {
        .pointer =      snd_trident_playback_pointer,
 };
 
-static snd_pcm_ops_t snd_trident_nx_playback_ops = {
+static struct snd_pcm_ops snd_trident_nx_playback_ops = {
        .open =         snd_trident_playback_open,
        .close =        snd_trident_playback_close,
        .ioctl =        snd_trident_ioctl,
@@ -2050,7 +2087,7 @@ static snd_pcm_ops_t snd_trident_nx_playback_ops = {
        .page =         snd_pcm_sgbuf_ops_page,
 };
 
-static snd_pcm_ops_t snd_trident_capture_ops = {
+static struct snd_pcm_ops snd_trident_capture_ops = {
        .open =         snd_trident_capture_open,
        .close =        snd_trident_capture_close,
        .ioctl =        snd_trident_ioctl,
@@ -2061,7 +2098,7 @@ static snd_pcm_ops_t snd_trident_capture_ops = {
        .pointer =      snd_trident_capture_pointer,
 };
 
-static snd_pcm_ops_t snd_trident_si7018_capture_ops = {
+static struct snd_pcm_ops snd_trident_si7018_capture_ops = {
        .open =         snd_trident_capture_open,
        .close =        snd_trident_capture_close,
        .ioctl =        snd_trident_ioctl,
@@ -2072,7 +2109,7 @@ static snd_pcm_ops_t snd_trident_si7018_capture_ops = {
        .pointer =      snd_trident_playback_pointer,
 };
 
-static snd_pcm_ops_t snd_trident_foldback_ops = {
+static struct snd_pcm_ops snd_trident_foldback_ops = {
        .open =         snd_trident_foldback_open,
        .close =        snd_trident_foldback_close,
        .ioctl =        snd_trident_ioctl,
@@ -2083,7 +2120,7 @@ static snd_pcm_ops_t snd_trident_foldback_ops = {
        .pointer =      snd_trident_playback_pointer,
 };
 
-static snd_pcm_ops_t snd_trident_nx_foldback_ops = {
+static struct snd_pcm_ops snd_trident_nx_foldback_ops = {
        .open =         snd_trident_foldback_open,
        .close =        snd_trident_foldback_close,
        .ioctl =        snd_trident_ioctl,
@@ -2095,7 +2132,7 @@ static snd_pcm_ops_t snd_trident_nx_foldback_ops = {
        .page =         snd_pcm_sgbuf_ops_page,
 };
 
-static snd_pcm_ops_t snd_trident_spdif_ops = {
+static struct snd_pcm_ops snd_trident_spdif_ops = {
        .open =         snd_trident_spdif_open,
        .close =        snd_trident_spdif_close,
        .ioctl =        snd_trident_ioctl,
@@ -2106,7 +2143,7 @@ static snd_pcm_ops_t snd_trident_spdif_ops = {
        .pointer =      snd_trident_spdif_pointer,
 };
 
-static snd_pcm_ops_t snd_trident_spdif_7018_ops = {
+static struct snd_pcm_ops snd_trident_spdif_7018_ops = {
        .open =         snd_trident_spdif_open,
        .close =        snd_trident_spdif_close,
        .ioctl =        snd_trident_ioctl,
@@ -2118,37 +2155,6 @@ static snd_pcm_ops_t snd_trident_spdif_7018_ops = {
 };
 
 /*---------------------------------------------------------------------------
-   snd_trident_pcm_free
-  
-   Description: This routine release the 4DWave private data.
-                
-   Paramters:   private_data - pointer to 4DWave device info.
-
-   Returns:     None
-  
-  ---------------------------------------------------------------------------*/
-static void snd_trident_pcm_free(snd_pcm_t *pcm)
-{
-       trident_t *trident = pcm->private_data;
-       trident->pcm = NULL;
-       snd_pcm_lib_preallocate_free_for_all(pcm);
-}
-
-static void snd_trident_foldback_pcm_free(snd_pcm_t *pcm)
-{
-       trident_t *trident = pcm->private_data;
-       trident->foldback = NULL;
-       snd_pcm_lib_preallocate_free_for_all(pcm);
-}
-
-static void snd_trident_spdif_pcm_free(snd_pcm_t *pcm)
-{
-       trident_t *trident = pcm->private_data;
-       trident->spdif = NULL;
-       snd_pcm_lib_preallocate_free_for_all(pcm);
-}
-
-/*---------------------------------------------------------------------------
    snd_trident_pcm
   
    Description: This routine registers the 4DWave device for PCM support.
@@ -2159,9 +2165,10 @@ static void snd_trident_spdif_pcm_free(snd_pcm_t *pcm)
   
   ---------------------------------------------------------------------------*/
 
-int __devinit snd_trident_pcm(trident_t * trident, int device, snd_pcm_t ** rpcm)
+int __devinit snd_trident_pcm(struct snd_trident * trident,
+                             int device, struct snd_pcm ** rpcm)
 {
-       snd_pcm_t *pcm;
+       struct snd_pcm *pcm;
        int err;
 
        if (rpcm)
@@ -2170,7 +2177,6 @@ int __devinit snd_trident_pcm(trident_t * trident, int device, snd_pcm_t ** rpcm
                return err;
 
        pcm->private_data = trident;
-       pcm->private_free = snd_trident_pcm_free;
 
        if (trident->tlb.entries) {
                snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_nx_playback_ops);
@@ -2188,7 +2194,7 @@ int __devinit snd_trident_pcm(trident_t * trident, int device, snd_pcm_t ** rpcm
        trident->pcm = pcm;
 
        if (trident->tlb.entries) {
-               snd_pcm_substream_t *substream;
+               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),
@@ -2217,12 +2223,13 @@ int __devinit snd_trident_pcm(trident_t * trident, int device, snd_pcm_t ** rpcm
   
   ---------------------------------------------------------------------------*/
 
-int __devinit snd_trident_foldback_pcm(trident_t * trident, int device, snd_pcm_t ** rpcm)
+int __devinit snd_trident_foldback_pcm(struct snd_trident * trident,
+                                      int device, struct snd_pcm ** rpcm)
 {
-       snd_pcm_t *foldback;
+       struct snd_pcm *foldback;
        int err;
        int num_chan = 3;
-       snd_pcm_substream_t *substream;
+       struct snd_pcm_substream *substream;
 
        if (rpcm)
                *rpcm = NULL;
@@ -2232,7 +2239,6 @@ int __devinit snd_trident_foldback_pcm(trident_t * trident, int device, snd_pcm_
                return err;
 
        foldback->private_data = trident;
-       foldback->private_free = snd_trident_foldback_pcm_free;
        if (trident->tlb.entries)
                snd_pcm_set_ops(foldback, SNDRV_PCM_STREAM_CAPTURE, &snd_trident_nx_foldback_ops);
        else
@@ -2274,9 +2280,10 @@ int __devinit snd_trident_foldback_pcm(trident_t * trident, int device, snd_pcm_
   
   ---------------------------------------------------------------------------*/
 
-int __devinit snd_trident_spdif_pcm(trident_t * trident, int device, snd_pcm_t ** rpcm)
+int __devinit snd_trident_spdif_pcm(struct snd_trident * trident,
+                                   int device, struct snd_pcm ** rpcm)
 {
-       snd_pcm_t *spdif;
+       struct snd_pcm *spdif;
        int err;
 
        if (rpcm)
@@ -2285,7 +2292,6 @@ int __devinit snd_trident_spdif_pcm(trident_t * trident, int device, snd_pcm_t *
                return err;
 
        spdif->private_data = trident;
-       spdif->private_free = snd_trident_spdif_pcm_free;
        if (trident->device != TRIDENT_DEVICE_ID_SI7018) {
                snd_pcm_set_ops(spdif, SNDRV_PCM_STREAM_PLAYBACK, &snd_trident_spdif_ops);
        } else {
@@ -2313,7 +2319,8 @@ int __devinit snd_trident_spdif_pcm(trident_t * trident, int device, snd_pcm_t *
     Description: enable/disable S/PDIF out from ac97 mixer
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_spdif_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+static int snd_trident_spdif_control_info(struct snd_kcontrol *kcontrol,
+                                         struct snd_ctl_elem_info *uinfo)
 {
        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
        uinfo->count = 1;
@@ -2322,10 +2329,10 @@ static int snd_trident_spdif_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem
        return 0;
 }
 
-static int snd_trident_spdif_control_get(snd_kcontrol_t * kcontrol,
-                                        snd_ctl_elem_value_t * ucontrol)
+static int snd_trident_spdif_control_get(struct snd_kcontrol *kcontrol,
+                                        struct snd_ctl_elem_value *ucontrol)
 {
-       trident_t *trident = snd_kcontrol_chip(kcontrol);
+       struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
        unsigned char val;
 
        spin_lock_irq(&trident->reg_lock);
@@ -2335,10 +2342,10 @@ static int snd_trident_spdif_control_get(snd_kcontrol_t * kcontrol,
        return 0;
 }
 
-static int snd_trident_spdif_control_put(snd_kcontrol_t * kcontrol,
-                                        snd_ctl_elem_value_t * ucontrol)
+static int snd_trident_spdif_control_put(struct snd_kcontrol *kcontrol,
+                                        struct snd_ctl_elem_value *ucontrol)
 {
-       trident_t *trident = snd_kcontrol_chip(kcontrol);
+       struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
        unsigned char val;
        int change;
 
@@ -2366,7 +2373,7 @@ static int snd_trident_spdif_control_put(snd_kcontrol_t * kcontrol,
        return change;
 }
 
-static snd_kcontrol_new_t snd_trident_spdif_control __devinitdata =
+static struct snd_kcontrol_new snd_trident_spdif_control __devinitdata =
 {
        .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
        .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH),
@@ -2382,17 +2389,18 @@ static snd_kcontrol_new_t snd_trident_spdif_control __devinitdata =
     Description: put/get the S/PDIF default settings
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_spdif_default_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+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(snd_kcontrol_t * kcontrol,
-                                        snd_ctl_elem_value_t * ucontrol)
+static int snd_trident_spdif_default_get(struct snd_kcontrol *kcontrol,
+                                        struct snd_ctl_elem_value *ucontrol)
 {
-       trident_t *trident = snd_kcontrol_chip(kcontrol);
+       struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
 
        spin_lock_irq(&trident->reg_lock);
        ucontrol->value.iec958.status[0] = (trident->spdif_bits >> 0) & 0xff;
@@ -2403,10 +2411,10 @@ static int snd_trident_spdif_default_get(snd_kcontrol_t * kcontrol,
        return 0;
 }
 
-static int snd_trident_spdif_default_put(snd_kcontrol_t * kcontrol,
-                                        snd_ctl_elem_value_t * ucontrol)
+static int snd_trident_spdif_default_put(struct snd_kcontrol *kcontrol,
+                                        struct snd_ctl_elem_value *ucontrol)
 {
-       trident_t *trident = snd_kcontrol_chip(kcontrol);
+       struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
        unsigned int val;
        int change;
 
@@ -2428,7 +2436,7 @@ static int snd_trident_spdif_default_put(snd_kcontrol_t * kcontrol,
        return change;
 }
 
-static snd_kcontrol_new_t snd_trident_spdif_default __devinitdata =
+static struct snd_kcontrol_new snd_trident_spdif_default __devinitdata =
 {
        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
        .name =         SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
@@ -2443,15 +2451,16 @@ static snd_kcontrol_new_t snd_trident_spdif_default __devinitdata =
     Description: put/get the S/PDIF mask
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_spdif_mask_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+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(snd_kcontrol_t * kcontrol,
-                                     snd_ctl_elem_value_t * ucontrol)
+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;
@@ -2460,7 +2469,7 @@ static int snd_trident_spdif_mask_get(snd_kcontrol_t * kcontrol,
        return 0;
 }
 
-static snd_kcontrol_new_t snd_trident_spdif_mask __devinitdata =
+static struct snd_kcontrol_new snd_trident_spdif_mask __devinitdata =
 {
        .access =       SNDRV_CTL_ELEM_ACCESS_READ,
        .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
@@ -2475,17 +2484,18 @@ static snd_kcontrol_new_t snd_trident_spdif_mask __devinitdata =
     Description: put/get the S/PDIF stream settings
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_spdif_stream_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+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(snd_kcontrol_t * kcontrol,
-                                       snd_ctl_elem_value_t * ucontrol)
+static int snd_trident_spdif_stream_get(struct snd_kcontrol *kcontrol,
+                                       struct snd_ctl_elem_value *ucontrol)
 {
-       trident_t *trident = snd_kcontrol_chip(kcontrol);
+       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;
@@ -2496,10 +2506,10 @@ static int snd_trident_spdif_stream_get(snd_kcontrol_t * kcontrol,
        return 0;
 }
 
-static int snd_trident_spdif_stream_put(snd_kcontrol_t * kcontrol,
-                                       snd_ctl_elem_value_t * ucontrol)
+static int snd_trident_spdif_stream_put(struct snd_kcontrol *kcontrol,
+                                       struct snd_ctl_elem_value *ucontrol)
 {
-       trident_t *trident = snd_kcontrol_chip(kcontrol);
+       struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
        unsigned int val;
        int change;
 
@@ -2521,7 +2531,7 @@ static int snd_trident_spdif_stream_put(snd_kcontrol_t * kcontrol,
        return change;
 }
 
-static snd_kcontrol_new_t snd_trident_spdif_stream __devinitdata =
+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,
@@ -2537,7 +2547,8 @@ static snd_kcontrol_new_t snd_trident_spdif_stream __devinitdata =
     Description: enable/disable rear path for ac97
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_ac97_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+static int snd_trident_ac97_control_info(struct snd_kcontrol *kcontrol,
+                                        struct snd_ctl_elem_info *uinfo)
 {
        uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
        uinfo->count = 1;
@@ -2546,10 +2557,10 @@ static int snd_trident_ac97_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_
        return 0;
 }
 
-static int snd_trident_ac97_control_get(snd_kcontrol_t * kcontrol,
-                                       snd_ctl_elem_value_t * ucontrol)
+static int snd_trident_ac97_control_get(struct snd_kcontrol *kcontrol,
+                                       struct snd_ctl_elem_value *ucontrol)
 {
-       trident_t *trident = snd_kcontrol_chip(kcontrol);
+       struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
        unsigned char val;
 
        spin_lock_irq(&trident->reg_lock);
@@ -2559,10 +2570,10 @@ static int snd_trident_ac97_control_get(snd_kcontrol_t * kcontrol,
        return 0;
 }
 
-static int snd_trident_ac97_control_put(snd_kcontrol_t * kcontrol,
-                                       snd_ctl_elem_value_t * ucontrol)
+static int snd_trident_ac97_control_put(struct snd_kcontrol *kcontrol,
+                                       struct snd_ctl_elem_value *ucontrol)
 {
-       trident_t *trident = snd_kcontrol_chip(kcontrol);
+       struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
        unsigned char val;
        int change = 0;
 
@@ -2578,7 +2589,7 @@ static int snd_trident_ac97_control_put(snd_kcontrol_t * kcontrol,
        return change;
 }
 
-static snd_kcontrol_new_t snd_trident_ac97_rear_control __devinitdata =
+static struct snd_kcontrol_new snd_trident_ac97_rear_control __devinitdata =
 {
        .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
        .name =         "Rear Path",
@@ -2594,7 +2605,8 @@ static snd_kcontrol_new_t snd_trident_ac97_rear_control __devinitdata =
     Description: wave & music volume control
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_vol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+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;
@@ -2603,10 +2615,10 @@ static int snd_trident_vol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_i
        return 0;
 }
 
-static int snd_trident_vol_control_get(snd_kcontrol_t * kcontrol,
-                                      snd_ctl_elem_value_t * ucontrol)
+static int snd_trident_vol_control_get(struct snd_kcontrol *kcontrol,
+                                      struct snd_ctl_elem_value *ucontrol)
 {
-       trident_t *trident = snd_kcontrol_chip(kcontrol);
+       struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
        unsigned int val;
 
        val = trident->musicvol_wavevol;
@@ -2615,10 +2627,12 @@ static int snd_trident_vol_control_get(snd_kcontrol_t * kcontrol,
        return 0;
 }
 
-static int snd_trident_vol_control_put(snd_kcontrol_t * kcontrol,
-                                      snd_ctl_elem_value_t * ucontrol)
+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)
 {
-       trident_t *trident = snd_kcontrol_chip(kcontrol);
+       struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
        unsigned int val;
        int change = 0;
 
@@ -2633,7 +2647,7 @@ static int snd_trident_vol_control_put(snd_kcontrol_t * kcontrol,
        return change;
 }
 
-static snd_kcontrol_new_t snd_trident_vol_music_control __devinitdata =
+static struct snd_kcontrol_new snd_trident_vol_music_control __devinitdata =
 {
        .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
        .name =         "Music Playback Volume",
@@ -2641,9 +2655,10 @@ static snd_kcontrol_new_t snd_trident_vol_music_control __devinitdata =
        .get =          snd_trident_vol_control_get,
        .put =          snd_trident_vol_control_put,
        .private_value = 16,
+       .tlv = { .p = db_scale_gvol },
 };
 
-static snd_kcontrol_new_t snd_trident_vol_wave_control __devinitdata =
+static struct snd_kcontrol_new snd_trident_vol_wave_control __devinitdata =
 {
        .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
        .name =         "Wave Playback Volume",
@@ -2651,6 +2666,7 @@ static snd_kcontrol_new_t snd_trident_vol_wave_control __devinitdata =
        .get =          snd_trident_vol_control_get,
        .put =          snd_trident_vol_control_put,
        .private_value = 0,
+       .tlv = { .p = db_scale_gvol },
 };
 
 /*---------------------------------------------------------------------------
@@ -2659,9 +2675,10 @@ static snd_kcontrol_new_t snd_trident_vol_wave_control __devinitdata =
     Description: PCM front volume control
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_pcm_vol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+static int snd_trident_pcm_vol_control_info(struct snd_kcontrol *kcontrol,
+                                           struct snd_ctl_elem_info *uinfo)
 {
-       trident_t *trident = snd_kcontrol_chip(kcontrol);
+       struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
 
        uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
        uinfo->count = 1;
@@ -2672,11 +2689,11 @@ static int snd_trident_pcm_vol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_el
        return 0;
 }
 
-static int snd_trident_pcm_vol_control_get(snd_kcontrol_t * kcontrol,
-                                          snd_ctl_elem_value_t * ucontrol)
+static int snd_trident_pcm_vol_control_get(struct snd_kcontrol *kcontrol,
+                                          struct snd_ctl_elem_value *ucontrol)
 {
-       trident_t *trident = snd_kcontrol_chip(kcontrol);
-       snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
+       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;
@@ -2686,11 +2703,11 @@ static int snd_trident_pcm_vol_control_get(snd_kcontrol_t * kcontrol,
        return 0;
 }
 
-static int snd_trident_pcm_vol_control_put(snd_kcontrol_t * kcontrol,
-                                          snd_ctl_elem_value_t * ucontrol)
+static int snd_trident_pcm_vol_control_put(struct snd_kcontrol *kcontrol,
+                                          struct snd_ctl_elem_value *ucontrol)
 {
-       trident_t *trident = snd_kcontrol_chip(kcontrol);
-       snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
+       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;
 
@@ -2708,7 +2725,7 @@ static int snd_trident_pcm_vol_control_put(snd_kcontrol_t * kcontrol,
        return change;
 }
 
-static snd_kcontrol_new_t snd_trident_pcm_vol_control __devinitdata =
+static struct snd_kcontrol_new snd_trident_pcm_vol_control __devinitdata =
 {
        .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
        .name =         "PCM Front Playback Volume",
@@ -2717,6 +2734,7 @@ static snd_kcontrol_new_t snd_trident_pcm_vol_control __devinitdata =
        .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 */
 };
 
 /*---------------------------------------------------------------------------
@@ -2725,7 +2743,8 @@ static snd_kcontrol_new_t snd_trident_pcm_vol_control __devinitdata =
     Description: PCM front pan control
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_pcm_pan_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+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;
@@ -2734,11 +2753,11 @@ static int snd_trident_pcm_pan_control_info(snd_kcontrol_t *kcontrol, snd_ctl_el
        return 0;
 }
 
-static int snd_trident_pcm_pan_control_get(snd_kcontrol_t * kcontrol,
-                                          snd_ctl_elem_value_t * ucontrol)
+static int snd_trident_pcm_pan_control_get(struct snd_kcontrol *kcontrol,
+                                          struct snd_ctl_elem_value *ucontrol)
 {
-       trident_t *trident = snd_kcontrol_chip(kcontrol);
-       snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
+       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) {
@@ -2749,11 +2768,11 @@ static int snd_trident_pcm_pan_control_get(snd_kcontrol_t * kcontrol,
        return 0;
 }
 
-static int snd_trident_pcm_pan_control_put(snd_kcontrol_t * kcontrol,
-                                          snd_ctl_elem_value_t * ucontrol)
+static int snd_trident_pcm_pan_control_put(struct snd_kcontrol *kcontrol,
+                                          struct snd_ctl_elem_value *ucontrol)
 {
-       trident_t *trident = snd_kcontrol_chip(kcontrol);
-       snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
+       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;
 
@@ -2770,7 +2789,7 @@ static int snd_trident_pcm_pan_control_put(snd_kcontrol_t * kcontrol,
        return change;
 }
 
-static snd_kcontrol_new_t snd_trident_pcm_pan_control __devinitdata =
+static struct snd_kcontrol_new snd_trident_pcm_pan_control __devinitdata =
 {
        .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
        .name =         "PCM Pan Playback Control",
@@ -2787,7 +2806,8 @@ static snd_kcontrol_new_t snd_trident_pcm_pan_control __devinitdata =
     Description: PCM reverb volume control
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_pcm_rvol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+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;
@@ -2796,21 +2816,21 @@ static int snd_trident_pcm_rvol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_e
        return 0;
 }
 
-static int snd_trident_pcm_rvol_control_get(snd_kcontrol_t * kcontrol,
-                                           snd_ctl_elem_value_t * ucontrol)
+static int snd_trident_pcm_rvol_control_get(struct snd_kcontrol *kcontrol,
+                                           struct snd_ctl_elem_value *ucontrol)
 {
-       trident_t *trident = snd_kcontrol_chip(kcontrol);
-       snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
+       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(snd_kcontrol_t * kcontrol,
-                                           snd_ctl_elem_value_t * ucontrol)
+static int snd_trident_pcm_rvol_control_put(struct snd_kcontrol *kcontrol,
+                                           struct snd_ctl_elem_value *ucontrol)
 {
-       trident_t *trident = snd_kcontrol_chip(kcontrol);
-       snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
+       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;
 
@@ -2824,7 +2844,9 @@ static int snd_trident_pcm_rvol_control_put(snd_kcontrol_t * kcontrol,
        return change;
 }
 
-static snd_kcontrol_new_t snd_trident_pcm_rvol_control __devinitdata =
+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",
@@ -2833,6 +2855,7 @@ static snd_kcontrol_new_t snd_trident_pcm_rvol_control __devinitdata =
        .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 },
 };
 
 /*---------------------------------------------------------------------------
@@ -2841,7 +2864,8 @@ static snd_kcontrol_new_t snd_trident_pcm_rvol_control __devinitdata =
     Description: PCM chorus volume control
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_pcm_cvol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
+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;
@@ -2850,21 +2874,21 @@ static int snd_trident_pcm_cvol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_e
        return 0;
 }
 
-static int snd_trident_pcm_cvol_control_get(snd_kcontrol_t * kcontrol,
-                                           snd_ctl_elem_value_t * ucontrol)
+static int snd_trident_pcm_cvol_control_get(struct snd_kcontrol *kcontrol,
+                                           struct snd_ctl_elem_value *ucontrol)
 {
-       trident_t *trident = snd_kcontrol_chip(kcontrol);
-       snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
+       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(snd_kcontrol_t * kcontrol,
-                                           snd_ctl_elem_value_t * ucontrol)
+static int snd_trident_pcm_cvol_control_put(struct snd_kcontrol *kcontrol,
+                                           struct snd_ctl_elem_value *ucontrol)
 {
-       trident_t *trident = snd_kcontrol_chip(kcontrol);
-       snd_trident_pcm_mixer_t *mix = &trident->pcm_mixer[snd_ctl_get_ioffnum(kcontrol, &ucontrol->id)];
+       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;
 
@@ -2878,7 +2902,7 @@ static int snd_trident_pcm_cvol_control_put(snd_kcontrol_t * kcontrol,
        return change;
 }
 
-static snd_kcontrol_new_t snd_trident_pcm_cvol_control __devinitdata =
+static struct snd_kcontrol_new snd_trident_pcm_cvol_control __devinitdata =
 {
        .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
        .name =         "PCM Chorus Playback Volume",
@@ -2887,11 +2911,14 @@ static snd_kcontrol_new_t snd_trident_pcm_cvol_control __devinitdata =
        .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(snd_card_t * card, snd_kcontrol_t *kctl, int num, int activate)
+static void snd_trident_notify_pcm_change1(struct snd_card *card,
+                                          struct snd_kcontrol *kctl,
+                                          int num, int activate)
 {
-       snd_ctl_elem_id_t id;
+       struct snd_ctl_elem_id id;
 
        if (! kctl)
                return;
@@ -2904,7 +2931,9 @@ static void snd_trident_notify_pcm_change1(snd_card_t * card, snd_kcontrol_t *kc
                       snd_ctl_build_ioff(&id, kctl, num));
 }
 
-static void snd_trident_notify_pcm_change(trident_t *trident, snd_trident_pcm_mixer_t *tmix, int num, int activate)
+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);
@@ -2912,9 +2941,11 @@ static void snd_trident_notify_pcm_change(trident_t *trident, snd_trident_pcm_mi
        snd_trident_notify_pcm_change1(trident->card, trident->ctl_cvol, num, activate);
 }
 
-static int snd_trident_pcm_mixer_build(trident_t *trident, snd_trident_voice_t *voice, snd_pcm_substream_t *substream)
+static int snd_trident_pcm_mixer_build(struct snd_trident *trident,
+                                      struct snd_trident_voice *voice,
+                                      struct snd_pcm_substream *substream)
 {
-       snd_trident_pcm_mixer_t *tmix;
+       struct snd_trident_pcm_mixer *tmix;
 
        snd_assert(trident != NULL && voice != NULL && substream != NULL, return -EINVAL);
        tmix = &trident->pcm_mixer[substream->number];
@@ -2927,9 +2958,9 @@ static int snd_trident_pcm_mixer_build(trident_t *trident, snd_trident_voice_t *
        return 0;
 }
 
-static int snd_trident_pcm_mixer_free(trident_t *trident, snd_trident_voice_t *voice, snd_pcm_substream_t *substream)
+static int snd_trident_pcm_mixer_free(struct snd_trident *trident, struct snd_trident_voice *voice, struct snd_pcm_substream *substream)
 {
-       snd_trident_pcm_mixer_t *tmix;
+       struct snd_trident_pcm_mixer *tmix;
 
        snd_assert(trident != NULL && substream != NULL, return -EINVAL);
        tmix = &trident->pcm_mixer[substream->number];
@@ -2949,14 +2980,14 @@ static int snd_trident_pcm_mixer_free(trident_t *trident, snd_trident_voice_t *v
   
   ---------------------------------------------------------------------------*/
 
-static int __devinit snd_trident_mixer(trident_t * trident, int pcm_spdif_device)
+static int __devinit snd_trident_mixer(struct snd_trident * trident, int pcm_spdif_device)
 {
-       ac97_template_t _ac97;
-       snd_card_t * card = trident->card;
-       snd_kcontrol_t *kctl;
-       snd_ctl_elem_value_t *uctl;
+       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 ac97_bus_ops_t ops = {
+       static struct snd_ac97_bus_ops ops = {
                .write = snd_trident_codec_write,
                .read = snd_trident_codec_read,
        };
@@ -2993,7 +3024,7 @@ static int __devinit snd_trident_mixer(trident_t * trident, int pcm_spdif_device
                        snd_printk(KERN_ERR "SI7018: the secondary codec - invalid access\n");
 #if 0  // only for my testing purpose --jk
                {
-                       ac97_t *mc97;
+                       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\n", err);
@@ -3016,7 +3047,7 @@ static int __devinit snd_trident_mixer(trident_t * trident, int pcm_spdif_device
        }
 
        for (idx = 0; idx < 32; idx++) {
-               snd_trident_pcm_mixer_t *tmix;
+               struct snd_trident_pcm_mixer *tmix;
                
                tmix = &trident->pcm_mixer[idx];
                tmix->voice = NULL;
@@ -3114,7 +3145,7 @@ static int __devinit snd_trident_mixer(trident_t * trident, int pcm_spdif_device
 
 static unsigned char snd_trident_gameport_read(struct gameport *gameport)
 {
-       trident_t *chip = gameport_get_port_data(gameport);
+       struct snd_trident *chip = gameport_get_port_data(gameport);
 
        snd_assert(chip, return 0);
        return inb(TRID_REG(chip, GAMEPORT_LEGACY));
@@ -3122,7 +3153,7 @@ static unsigned char snd_trident_gameport_read(struct gameport *gameport)
 
 static void snd_trident_gameport_trigger(struct gameport *gameport)
 {
-       trident_t *chip = gameport_get_port_data(gameport);
+       struct snd_trident *chip = gameport_get_port_data(gameport);
 
        snd_assert(chip, return);
        outb(0xff, TRID_REG(chip, GAMEPORT_LEGACY));
@@ -3130,7 +3161,7 @@ static void snd_trident_gameport_trigger(struct gameport *gameport)
 
 static int snd_trident_gameport_cooked_read(struct gameport *gameport, int *axes, int *buttons)
 {
-       trident_t *chip = gameport_get_port_data(gameport);
+       struct snd_trident *chip = gameport_get_port_data(gameport);
        int i;
 
        snd_assert(chip, return 0);
@@ -3147,7 +3178,7 @@ static int snd_trident_gameport_cooked_read(struct gameport *gameport, int *axes
 
 static int snd_trident_gameport_open(struct gameport *gameport, int mode)
 {
-       trident_t *chip = gameport_get_port_data(gameport);
+       struct snd_trident *chip = gameport_get_port_data(gameport);
 
        snd_assert(chip, return 0);
 
@@ -3164,7 +3195,7 @@ static int snd_trident_gameport_open(struct gameport *gameport, int mode)
        }
 }
 
-int __devinit snd_trident_create_gameport(trident_t *chip)
+int __devinit snd_trident_create_gameport(struct snd_trident *chip)
 {
        struct gameport *gp;
 
@@ -3190,7 +3221,7 @@ int __devinit snd_trident_create_gameport(trident_t *chip)
        return 0;
 }
 
-static inline void snd_trident_free_gameport(trident_t *chip)
+static inline void snd_trident_free_gameport(struct snd_trident *chip)
 {
        if (chip->gameport) {
                gameport_unregister_port(chip->gameport);
@@ -3198,24 +3229,23 @@ static inline void snd_trident_free_gameport(trident_t *chip)
        }
 }
 #else
-int __devinit snd_trident_create_gameport(trident_t *chip) { return -ENOSYS; }
-static inline void snd_trident_free_gameport(trident_t *chip) { }
+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(trident_t *chip)
+static inline void do_delay(struct snd_trident *chip)
 {
-       set_current_state(TASK_UNINTERRUPTIBLE);
-       schedule_timeout(1);
+       schedule_timeout_uninterruptible(1);
 }
 
 /*
  *  SiS reset routine
  */
 
-static int snd_trident_sis_reset(trident_t *trident)
+static int snd_trident_sis_reset(struct snd_trident *trident)
 {
        unsigned long end_time;
        unsigned int i;
@@ -3268,10 +3298,10 @@ static int snd_trident_sis_reset(trident_t *trident)
  *  /proc interface
  */
 
-static void snd_trident_proc_read(snd_info_entry_t *entry, 
-                                 snd_info_buffer_t * buffer)
+static void snd_trident_proc_read(struct snd_info_entry *entry, 
+                                 struct snd_info_buffer *buffer)
 {
-       trident_t *trident = entry->private_data;
+       struct snd_trident *trident = entry->private_data;
        char *s;
 
        switch (trident->device) {
@@ -3309,20 +3339,20 @@ static void snd_trident_proc_read(snd_info_entry_t *entry,
 #endif
 }
 
-static void __devinit snd_trident_proc_init(trident_t * trident)
+static void __devinit snd_trident_proc_init(struct snd_trident * trident)
 {
-       snd_info_entry_t *entry;
+       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, 1024, snd_trident_proc_read);
+               snd_info_set_text_ops(entry, trident, snd_trident_proc_read);
 }
 
-static int snd_trident_dev_free(snd_device_t *device)
+static int snd_trident_dev_free(struct snd_device *device)
 {
-       trident_t *trident = device->device_data;
+       struct snd_trident *trident = device->device_data;
        return snd_trident_free(trident);
 }
 
@@ -3338,7 +3368,7 @@ static int snd_trident_dev_free(snd_device_t *device)
   
   ---------------------------------------------------------------------------*/
 
-static int __devinit snd_trident_tlb_alloc(trident_t *trident)
+static int __devinit snd_trident_tlb_alloc(struct snd_trident *trident)
 {
        int i;
 
@@ -3350,10 +3380,10 @@ static int __devinit snd_trident_tlb_alloc(trident_t *trident)
                snd_printk(KERN_ERR "trident: unable to allocate TLB buffer\n");
                return -ENOMEM;
        }
-       trident->tlb.entries = (unsigned int*)(((unsigned long)trident->tlb.buffer.area + SNDRV_TRIDENT_MAX_PAGES * 4 - 1) & ~(SNDRV_TRIDENT_MAX_PAGES * 4 - 1));
-       trident->tlb.entries_dmaaddr = (trident->tlb.buffer.addr + SNDRV_TRIDENT_MAX_PAGES * 4 - 1) & ~(SNDRV_TRIDENT_MAX_PAGES * 4 - 1);
+       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 = (unsigned long *)vmalloc(SNDRV_TRIDENT_MAX_PAGES*sizeof(unsigned long));
+       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\n");
                return -ENOMEM;
@@ -3375,7 +3405,7 @@ static int __devinit snd_trident_tlb_alloc(trident_t *trident)
        if (trident->tlb.memhdr == NULL)
                return -ENOMEM;
 
-       trident->tlb.memhdr->block_extra_size = sizeof(snd_trident_memblk_arg_t);
+       trident->tlb.memhdr->block_extra_size = sizeof(struct snd_trident_memblk_arg);
        return 0;
 }
 
@@ -3383,7 +3413,7 @@ static int __devinit snd_trident_tlb_alloc(trident_t *trident)
  * initialize 4D DX chip
  */
 
-static void snd_trident_stop_all_voices(trident_t *trident)
+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));
@@ -3391,7 +3421,7 @@ static void snd_trident_stop_all_voices(trident_t *trident)
        outl(0, TRID_REG(trident, T4D_AINTEN_B));
 }
 
-static int snd_trident_4d_dx_init(trident_t *trident)
+static int snd_trident_4d_dx_init(struct snd_trident *trident)
 {
        struct pci_dev *pci = trident->pci;
        unsigned long end_time;
@@ -3431,7 +3461,7 @@ static int snd_trident_4d_dx_init(trident_t *trident)
 /*
  * initialize 4D NX chip
  */
-static int snd_trident_4d_nx_init(trident_t *trident)
+static int snd_trident_4d_nx_init(struct snd_trident *trident)
 {
        struct pci_dev *pci = trident->pci;
        unsigned long end_time;
@@ -3488,7 +3518,7 @@ static int snd_trident_4d_nx_init(trident_t *trident)
 /*
  * initialize sis7018 chip
  */
-static int snd_trident_sis_init(trident_t *trident)
+static int snd_trident_sis_init(struct snd_trident *trident)
 {
        int err;
 
@@ -3519,18 +3549,18 @@ static int snd_trident_sis_init(trident_t *trident)
   
   ---------------------------------------------------------------------------*/
 
-int __devinit snd_trident_create(snd_card_t * card,
+int __devinit snd_trident_create(struct snd_card *card,
                       struct pci_dev *pci,
                       int pcm_streams,
                       int pcm_spdif_device,
                       int max_wavetable_size,
-                      trident_t ** rtrident)
+                      struct snd_trident ** rtrident)
 {
-       trident_t *trident;
+       struct snd_trident *trident;
        int i, err;
-       snd_trident_voice_t *voice;
-       snd_trident_pcm_mixer_t *tmix;
-       static snd_device_ops_t ops = {
+       struct snd_trident_voice *voice;
+       struct snd_trident_pcm_mixer *tmix;
+       static struct snd_device_ops ops = {
                .dev_free =     snd_trident_dev_free,
        };
 
@@ -3540,8 +3570,8 @@ int __devinit snd_trident_create(snd_card_t * card,
        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, 0x3fffffff) < 0 ||
-           pci_set_consistent_dma_mask(pci, 0x3fffffff) < 0) {
+       if (pci_set_dma_mask(pci, DMA_30BIT_MASK) < 0 ||
+           pci_set_consistent_dma_mask(pci, DMA_30BIT_MASK) < 0) {
                snd_printk(KERN_ERR "architecture does not support 30bit PCI busmaster DMA\n");
                pci_disable_device(pci);
                return -ENXIO;
@@ -3578,7 +3608,8 @@ int __devinit snd_trident_create(snd_card_t * card,
        }
        trident->port = pci_resource_start(pci, 0);
 
-       if (request_irq(pci->irq, snd_trident_interrupt, SA_INTERRUPT|SA_SHIRQ, "Trident Audio", (void *) trident)) {
+       if (request_irq(pci->irq, snd_trident_interrupt, IRQF_SHARED,
+                       "Trident Audio", trident)) {
                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
                snd_trident_free(trident);
                return -EBUSY;
@@ -3642,8 +3673,6 @@ int __devinit snd_trident_create(snd_card_t * card,
 
        snd_trident_enable_eso(trident);
 
-       
-       snd_card_set_pm_callback(card, snd_trident_suspend, snd_trident_resume, trident);
        snd_trident_proc_init(trident);
        snd_card_set_dev(card, &pci->dev);
        *rtrident = trident;
@@ -3662,7 +3691,7 @@ int __devinit snd_trident_create(snd_card_t * card,
   
   ---------------------------------------------------------------------------*/
 
-static int snd_trident_free(trident_t *trident)
+static int snd_trident_free(struct snd_trident *trident)
 {
        snd_trident_free_gameport(trident);
        snd_trident_disable_eso(trident);
@@ -3682,7 +3711,7 @@ static int snd_trident_free(trident_t *trident)
                snd_dma_free_pages(&trident->tlb.buffer);
        }
        if (trident->irq >= 0)
-               free_irq(trident->irq, (void *)trident);
+               free_irq(trident->irq, trident);
        pci_release_regions(trident->pci);
        pci_disable_device(trident->pci);
        kfree(trident);
@@ -3707,12 +3736,12 @@ static int snd_trident_free(trident_t *trident)
   
   ---------------------------------------------------------------------------*/
 
-static irqreturn_t snd_trident_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+static irqreturn_t snd_trident_interrupt(int irq, void *dev_id)
 {
-       trident_t *trident = dev_id;
+       struct snd_trident *trident = dev_id;
        unsigned int audio_int, chn_int, stimer, channel, mask, tmp;
        int delta;
-       snd_trident_voice_t *voice;
+       struct snd_trident_voice *voice;
 
        audio_int = inl(TRID_REG(trident, T4D_MISCINT));
        if ((audio_int & (ADDRESS_IRQ|MPU401_IRQ)) == 0)
@@ -3795,7 +3824,7 @@ static irqreturn_t snd_trident_interrupt(int irq, void *dev_id, struct pt_regs *
        }
        if (audio_int & MPU401_IRQ) {
                if (trident->rmidi) {
-                       snd_mpu401_uart_interrupt(irq, trident->rmidi->private_data, regs);
+                       snd_mpu401_uart_interrupt(irq, trident->rmidi->private_data);
                } else {
                        inb(TRID_REG(trident, T4D_MPUR0));
                }
@@ -3814,21 +3843,21 @@ static irqreturn_t snd_trident_interrupt(int irq, void *dev_id, struct pt_regs *
    Returns:     None.
   
   ---------------------------------------------------------------------------*/
-int snd_trident_attach_synthesizer(trident_t *trident)
+int snd_trident_attach_synthesizer(struct snd_trident *trident)
 {      
 #if defined(CONFIG_SND_SEQUENCER) || (defined(MODULE) && defined(CONFIG_SND_SEQUENCER_MODULE))
        if (snd_seq_device_new(trident->card, 1, SNDRV_SEQ_DEV_ID_TRIDENT,
-                              sizeof(trident_t*), &trident->seq_dev) >= 0) {
+                              sizeof(struct snd_trident *), &trident->seq_dev) >= 0) {
                strcpy(trident->seq_dev->name, "4DWave");
-               *(trident_t**)SNDRV_SEQ_DEVICE_ARGPTR(trident->seq_dev) = trident;
+               *(struct snd_trident **)SNDRV_SEQ_DEVICE_ARGPTR(trident->seq_dev) = trident;
        }
 #endif
        return 0;
 }
 
-snd_trident_voice_t *snd_trident_alloc_voice(trident_t * trident, int type, int client, int port)
+struct snd_trident_voice *snd_trident_alloc_voice(struct snd_trident * trident, int type, int client, int port)
 {
-       snd_trident_voice_t *pvoice;
+       struct snd_trident_voice *pvoice;
        unsigned long flags;
        int idx;
 
@@ -3870,10 +3899,12 @@ snd_trident_voice_t *snd_trident_alloc_voice(trident_t * trident, int type, int
        return NULL;
 }
 
-void snd_trident_free_voice(trident_t * trident, snd_trident_voice_t *voice)
+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)(snd_trident_voice_t *);
+       void (*private_free)(struct snd_trident_voice *);
        void *private_data;
 
        if (voice == NULL || !voice->use)
@@ -3898,7 +3929,9 @@ void snd_trident_free_voice(trident_t * trident, snd_trident_voice_t *voice)
                private_free(voice);
 }
 
-static void snd_trident_clear_voices(trident_t * trident, unsigned short v_min, unsigned short v_max)
+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 };
 
@@ -3919,41 +3952,40 @@ static void snd_trident_clear_voices(trident_t * trident, unsigned short v_min,
 }
 
 #ifdef CONFIG_PM
-static int snd_trident_suspend(snd_card_t *card, pm_message_t state)
+int snd_trident_suspend(struct pci_dev *pci, pm_message_t state)
 {
-       trident_t *trident = card->pm_private_data;
+       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);
-       if (trident->foldback)
-               snd_pcm_suspend_all(trident->foldback);
-       if (trident->spdif)
-               snd_pcm_suspend_all(trident->spdif);
+       snd_pcm_suspend_all(trident->foldback);
+       snd_pcm_suspend_all(trident->spdif);
 
        snd_ac97_suspend(trident->ac97);
-       if (trident->ac97_sec)
-               snd_ac97_suspend(trident->ac97_sec);
+       snd_ac97_suspend(trident->ac97_sec);
 
-       switch (trident->device) {
-       case TRIDENT_DEVICE_ID_DX:
-       case TRIDENT_DEVICE_ID_NX:
-               break;                  /* TODO */
-       case TRIDENT_DEVICE_ID_SI7018:
-               break;
-       }
-       pci_disable_device(trident->pci);
+       pci_disable_device(pci);
+       pci_save_state(pci);
+       pci_set_power_state(pci, pci_choose_state(pci, state));
        return 0;
 }
 
-static int snd_trident_resume(snd_card_t *card)
+int snd_trident_resume(struct pci_dev *pci)
 {
-       trident_t *trident = card->pm_private_data;
+       struct snd_card *card = pci_get_drvdata(pci);
+       struct snd_trident *trident = card->private_data;
 
-       pci_enable_device(trident->pci);
-       if (pci_set_dma_mask(trident->pci, 0x3fffffff) < 0 ||
-           pci_set_consistent_dma_mask(trident->pci, 0x3fffffff) < 0)
-               snd_printk(KERN_WARNING "trident: can't set the proper DMA mask\n");
-       pci_set_master(trident->pci); /* to be sure */
+       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\n");
+               snd_card_disconnect(card);
+               return -EIO;
+       }
+       pci_set_master(pci);
 
        switch (trident->device) {
        case TRIDENT_DEVICE_ID_DX:
@@ -3968,25 +4000,15 @@ static int snd_trident_resume(snd_card_t *card)
        }
 
        snd_ac97_resume(trident->ac97);
-       if (trident->ac97_sec)
-               snd_ac97_resume(trident->ac97_sec);
+       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 */
-
-EXPORT_SYMBOL(snd_trident_alloc_voice);
-EXPORT_SYMBOL(snd_trident_free_voice);
-EXPORT_SYMBOL(snd_trident_start_voice);
-EXPORT_SYMBOL(snd_trident_stop_voice);
-EXPORT_SYMBOL(snd_trident_write_voice_regs);
-/* trident_memory.c symbols */
-EXPORT_SYMBOL(snd_trident_synth_alloc);
-EXPORT_SYMBOL(snd_trident_synth_free);
-EXPORT_SYMBOL(snd_trident_synth_copy_from_user);