Changeset 34 for GPL/trunk/alsa-kernel/pci/trident

Timestamp:

Dec 11, 2005, 5:57:39 PM (20 years ago)

Author:

vladest

Message:

Latest update from ALSA. some intial > 15 interrupts support

Location:

GPL/trunk/alsa-kernel/pci/trident

Files:

• trident.c (modified) (1 diff)
• trident_main.c (modified) (108 diffs)
• trident_memory.c (modified) (18 diffs)
• trident_synth.c (modified) (36 diffs)

GPL/trunk/alsa-kernel/pci/trident/trident.c

@@ -83 +83 @@
         static int dev;
         snd_card_t *card;
-        trident_t *trident;
+        struct snd_trident *trident;
         const char *str;
         int err, pcm_dev = 0;

GPL/trunk/alsa-kernel/pci/trident/trident_main.c

@@ -44 +44 @@
 }
 
-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 int snd_trident_pcm_mixer_build(struct snd_trident *trident, struct snd_trident_voice* voice, snd_pcm_substream_t *substream);
+static int snd_trident_pcm_mixer_free(struct snd_trident *trident, struct snd_trident_voice* 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, unsigned int state);
-static int snd_trident_resume(snd_card_t *card, unsigned int state);
-#endif
-static int snd_trident_sis_reset(trident_t *trident);
+static int snd_trident_sis_reset(struct snd_trident *trident);
 
 /*
@@ -59 +55 @@
 
 #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;
@@ -117 +113 @@
     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);
@@ -176 +172 @@
     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;
@@ -227 +223 @@
 
 /*---------------------------------------------------------------------------
- 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.
@@ -238 +234 @@
  ---------------------------------------------------------------------------*/
 
-static void snd_trident_enable_eso(trident_t * trident)
+static void snd_trident_enable_eso(struct snd_trident * trident)
 {
     unsigned int val;
@@ -251 +247 @@
 
 /*---------------------------------------------------------------------------
- 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.
@@ -265 +261 @@
  ---------------------------------------------------------------------------*/
 
-static void snd_trident_disable_eso(trident_t * trident)
+static void snd_trident_disable_eso(struct snd_trident * trident)
 {
     unsigned int tmp;
@@ -276 +272 @@
 
 /*---------------------------------------------------------------------------
- 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.
@@ -289 +285 @@
  ---------------------------------------------------------------------------*/
 
-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);
@@ -298 +294 @@
 
 /*---------------------------------------------------------------------------
- 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.
@@ -311 +307 @@
  ---------------------------------------------------------------------------*/
 
-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);
@@ -320 +316 @@
 
 /*---------------------------------------------------------------------------
- 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).
@@ -330 +326 @@
  ---------------------------------------------------------------------------*/
 
-static int snd_trident_allocate_pcm_channel(trident_t * trident)
+static int snd_trident_allocate_pcm_channel(struct snd_trident * trident)
 {
     int idx;
@@ -358 +354 @@
  ---------------------------------------------------------------------------*/
 
-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)
@@ -380 +376 @@
  ---------------------------------------------------------------------------*/
 
-static int snd_trident_allocate_synth_channel(trident_t * trident)
+static int snd_trident_allocate_synth_channel(struct snd_trident * trident)
 {
     int idx;
@@ -406 +402 @@
  ---------------------------------------------------------------------------*/
 
-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)
@@ -429 +425 @@
  ---------------------------------------------------------------------------*/
 
-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;
@@ -501 +497 @@
  ---------------------------------------------------------------------------*/
 
-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;
@@ -524 +520 @@
  ---------------------------------------------------------------------------*/
 
-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;
@@ -547 +543 @@
  ---------------------------------------------------------------------------*/
 
-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;
@@ -575 +571 @@
  ---------------------------------------------------------------------------*/
 
-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;
@@ -594 +590 @@
  ---------------------------------------------------------------------------*/
 
-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;
@@ -614 +610 @@
  ---------------------------------------------------------------------------*/
 
-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;
@@ -774 +770 @@
                                  snd_pcm_hw_params_t * hw_params)
 {
-    trident_t *trident = snd_pcm_substream_chip(substream);
+    struct snd_trident *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_voice*voice = (struct snd_trident_voice*) runtime->private_data;
     int err;
 
@@ -808 +804 @@
                                 snd_pcm_hw_params_t * hw_params)
 {
-    trident_t *trident = snd_pcm_substream_chip(substream);
+    struct snd_trident *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_voice*voice = (struct snd_trident_voice*) runtime->private_data;
+    struct snd_trident_voice*evoice = voice->extra;
 
     /* voice management */
@@ -869 +865 @@
 static int snd_trident_hw_free(snd_pcm_substream_t * substream)
 {
-    trident_t *trident = snd_pcm_substream_chip(substream);
+    struct snd_trident *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_voice*voice = (struct snd_trident_voice*) runtime->private_data;
+    struct snd_trident_voice*evoice = voice ? voice->extra : NULL;
 
     if (trident->tlb.entries) {
@@ -901 +897 @@
 static int snd_trident_playback_prepare(snd_pcm_substream_t * substream)
 {
-    trident_t *trident = snd_pcm_substream_chip(substream);
+    struct snd_trident *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_voice*voice = (struct snd_trident_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);
@@ -1004 +1000 @@
 static int snd_trident_capture_prepare(snd_pcm_substream_t * substream)
 {
-    trident_t *trident = snd_pcm_substream_chip(substream);
+    struct snd_trident *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_voice*voice = (struct snd_trident_voice*) runtime->private_data;
     unsigned int val, ESO_bytes;
 
@@ -1118 +1114 @@
 static int snd_trident_si7018_capture_hw_free(snd_pcm_substream_t * substream)
 {
-    trident_t *trident = snd_pcm_substream_chip(substream);
+    struct snd_trident *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_voice*voice = (struct snd_trident_voice*) runtime->private_data;
+    struct snd_trident_voice*evoice = voice ? voice->extra : NULL;
 
     snd_pcm_lib_free_pages(substream);
@@ -1144 +1140 @@
 static int snd_trident_si7018_capture_prepare(snd_pcm_substream_t * substream)
 {
-    trident_t *trident = snd_pcm_substream_chip(substream);
+    struct snd_trident *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_voice*voice = (struct snd_trident_voice*) runtime->private_data;
+    struct snd_trident_voice*evoice = voice->extra;
 
     spin_lock_irq(&trident->reg_lock);
@@ -1214 +1210 @@
 static int snd_trident_foldback_prepare(snd_pcm_substream_t * substream)
 {
-    trident_t *trident = snd_pcm_substream_chip(substream);
+    struct snd_trident *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_voice*voice = (struct snd_trident_voice*) runtime->private_data;
+    struct snd_trident_voice*evoice = voice->extra;
 
     spin_lock_irq(&trident->reg_lock);
@@ -1293 +1289 @@
                                        snd_pcm_hw_params_t * 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;
@@ -1357 +1353 @@
 static int snd_trident_spdif_prepare(snd_pcm_substream_t * substream)
 {
-    trident_t *trident = snd_pcm_substream_chip(substream);
+    struct snd_trident *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_voice*voice = (struct snd_trident_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 +1494 @@
 
 {
-    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;
     unsigned int what, whati, capture_flag, spdif_flag;
-    snd_trident_voice_t *voice, *evoice;
+    struct snd_trident_voice*voice, *evoice;
     unsigned int val, go;
 
@@ -1524 +1520 @@
     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 = (struct snd_trident_voice*) s->runtime->private_data;
             evoice = voice->extra;
             what |= 1 << (voice->number & 0x1f);
@@ -1594 +1590 @@
 static snd_pcm_uframes_t snd_trident_playback_pointer(snd_pcm_substream_t * substream)
 {
-    trident_t *trident = snd_pcm_substream_chip(substream);
+    struct snd_trident *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_voice*voice = (struct snd_trident_voice*) runtime->private_data;
     unsigned int cso;
 
@@ -1633 +1629 @@
 static snd_pcm_uframes_t snd_trident_capture_pointer(snd_pcm_substream_t * substream)
 {
-    trident_t *trident = snd_pcm_substream_chip(substream);
+    struct snd_trident *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_voice*voice = (struct snd_trident_voice*) runtime->private_data;
     unsigned int result;
 
@@ -1663 +1659 @@
 static snd_pcm_uframes_t snd_trident_spdif_pointer(snd_pcm_substream_t * substream)
 {
-    trident_t *trident = snd_pcm_substream_chip(substream);
+    struct snd_trident *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_voice*voice = (struct snd_trident_voice*) runtime->private_data;
     unsigned int result;
 
@@ -1797 +1793 @@
 static void snd_trident_pcm_free_substream(snd_pcm_runtime_t *runtime)
 {
-    snd_trident_voice_t *voice = (snd_trident_voice_t *) runtime->private_data;
-    trident_t *trident;
+    struct snd_trident_voice*voice = (struct snd_trident_voice*) runtime->private_data;
+    struct snd_trident *trident;
 
     if (voice) {
@@ -1808 +1804 @@
 static int snd_trident_playback_open(snd_pcm_substream_t * substream)
 {
-    trident_t *trident = snd_pcm_substream_chip(substream);
+    struct snd_trident *trident = snd_pcm_substream_chip(substream);
     snd_pcm_runtime_t *runtime = substream->runtime;
-    snd_trident_voice_t *voice;
+    struct snd_trident_voice*voice;
 
     voice = snd_trident_alloc_voice(trident, SNDRV_TRIDENT_VOICE_TYPE_PCM, 0, 0);
@@ -1836 +1832 @@
 static int snd_trident_playback_close(snd_pcm_substream_t * substream)
 {
-    trident_t *trident = snd_pcm_substream_chip(substream);
+    struct snd_trident *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_voice*voice = (struct snd_trident_voice*) runtime->private_data;
 
     snd_trident_pcm_mixer_free(trident, voice, substream);
@@ -1857 +1853 @@
 static int snd_trident_spdif_open(snd_pcm_substream_t * substream)
 {
-    trident_t *trident = snd_pcm_substream_chip(substream);
-    snd_trident_voice_t *voice;
+    struct snd_trident *trident = snd_pcm_substream_chip(substream);
+    struct snd_trident_voice*voice;
     snd_pcm_runtime_t *runtime = substream->runtime;
 
@@ -1898 +1894 @@
 static int snd_trident_spdif_close(snd_pcm_substream_t * substream)
 {
-    trident_t *trident = snd_pcm_substream_chip(substream);
+    struct snd_trident *trident = snd_pcm_substream_chip(substream);
     unsigned int temp;
 
@@ -1936 +1932 @@
 static int snd_trident_capture_open(snd_pcm_substream_t * substream)
 {
-    trident_t *trident = snd_pcm_substream_chip(substream);
-    snd_trident_voice_t *voice;
+    struct snd_trident *trident = snd_pcm_substream_chip(substream);
+    struct snd_trident_voice*voice;
     snd_pcm_runtime_t *runtime = substream->runtime;
 
@@ -1980 +1976 @@
 static int snd_trident_foldback_open(snd_pcm_substream_t * substream)
 {
-    trident_t *trident = snd_pcm_substream_chip(substream);
-    snd_trident_voice_t *voice;
+    struct snd_trident *trident = snd_pcm_substream_chip(substream);
+    struct snd_trident_voice*voice;
     snd_pcm_runtime_t *runtime = substream->runtime;
 
@@ -2007 +2003 @@
 static int snd_trident_foldback_close(snd_pcm_substream_t * substream)
 {
-    trident_t *trident = snd_pcm_substream_chip(substream);
-    snd_trident_voice_t *voice;
+    struct snd_trident *trident = snd_pcm_substream_chip(substream);
+    struct snd_trident_voice*voice;
     snd_pcm_runtime_t *runtime = substream->runtime;
-    voice = (snd_trident_voice_t *) runtime->private_data;
+    voice = (struct snd_trident_voice*) runtime->private_data;
 
     /* stop capture channel */
@@ -2125 +2121 @@
 static void snd_trident_pcm_free(snd_pcm_t *pcm)
 {
-    trident_t *trident = pcm->private_data;
+    struct snd_trident *trident = pcm->private_data;
     trident->pcm = NULL;
     snd_pcm_lib_preallocate_free_for_all(pcm);
@@ -2132 +2128 @@
 static void snd_trident_foldback_pcm_free(snd_pcm_t *pcm)
 {
-    trident_t *trident = pcm->private_data;
+    struct snd_trident *trident = pcm->private_data;
     trident->foldback = NULL;
     snd_pcm_lib_preallocate_free_for_all(pcm);
@@ -2139 +2135 @@
 static void snd_trident_spdif_pcm_free(snd_pcm_t *pcm)
 {
-    trident_t *trident = pcm->private_data;
+    struct snd_trident *trident = pcm->private_data;
     trident->spdif = NULL;
     snd_pcm_lib_preallocate_free_for_all(pcm);
@@ -2155 +2151 @@
  ---------------------------------------------------------------------------*/
 
-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, snd_pcm_t ** rpcm)
 {
         snd_pcm_t *pcm;
@@ -2213 +2209 @@
  ---------------------------------------------------------------------------*/
 
-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, snd_pcm_t ** rpcm)
 {
         snd_pcm_t *foldback;
@@ -2271 +2267 @@
  ---------------------------------------------------------------------------*/
 
-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, snd_pcm_t ** rpcm)
 {
         snd_pcm_t *spdif;
@@ -2321 +2317 @@
                                          snd_ctl_elem_value_t * ucontrol)
 {
-    trident_t *trident = snd_kcontrol_chip(kcontrol);
+    struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
     unsigned char val;
 
@@ -2334 +2330 @@
                                          snd_ctl_elem_value_t * ucontrol)
 {
-    trident_t *trident = snd_kcontrol_chip(kcontrol);
+    struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
     unsigned char val;
     int change;
@@ -2388 +2384 @@
                                          snd_ctl_elem_value_t * ucontrol)
 {
-    trident_t *trident = snd_kcontrol_chip(kcontrol);
+    struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
 
     spin_lock_irq(&trident->reg_lock);
@@ -2402 +2398 @@
                                          snd_ctl_elem_value_t * ucontrol)
 {
-    trident_t *trident = snd_kcontrol_chip(kcontrol);
+    struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
     unsigned int val;
     int change;
@@ -2481 +2477 @@
                                         snd_ctl_elem_value_t * ucontrol)
 {
-    trident_t *trident = snd_kcontrol_chip(kcontrol);
+    struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
 
     spin_lock_irq(&trident->reg_lock);
@@ -2495 +2491 @@
                                         snd_ctl_elem_value_t * ucontrol)
 {
-    trident_t *trident = snd_kcontrol_chip(kcontrol);
+    struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
     unsigned int val;
     int change;
@@ -2545 +2541 @@
                                         snd_ctl_elem_value_t * ucontrol)
 {
-    trident_t *trident = snd_kcontrol_chip(kcontrol);
+    struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
     unsigned char val;
 
@@ -2558 +2554 @@
                                         snd_ctl_elem_value_t * ucontrol)
 {
-    trident_t *trident = snd_kcontrol_chip(kcontrol);
+    struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
     unsigned char val;
     int change = 0;
@@ -2602 +2598 @@
                                        snd_ctl_elem_value_t * ucontrol)
 {
-    trident_t *trident = snd_kcontrol_chip(kcontrol);
+    struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
     unsigned int val;
 
@@ -2614 +2610 @@
                                        snd_ctl_elem_value_t * ucontrol)
 {
-    trident_t *trident = snd_kcontrol_chip(kcontrol);
+    struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
     unsigned int val;
     int change = 0;
@@ -2659 +2655 @@
 static int snd_trident_pcm_vol_control_info(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
 {
-    trident_t *trident = snd_kcontrol_chip(kcontrol);
+    struct snd_trident *trident = snd_kcontrol_chip(kcontrol);
 
     uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
@@ -2673 +2669 @@
                                            snd_ctl_elem_value_t * 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) {
@@ -2687 +2683 @@
                                            snd_ctl_elem_value_t * 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;
@@ -2735 +2731 @@
                                            snd_ctl_elem_value_t * 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;
@@ -2750 +2746 @@
                                            snd_ctl_elem_value_t * 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;
@@ -2797 +2793 @@
                                             snd_ctl_elem_value_t * 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;
@@ -2807 +2803 @@
                                             snd_ctl_elem_value_t * 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;
@@ -2851 +2847 @@
                                             snd_ctl_elem_value_t * 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;
@@ -2861 +2857 @@
                                             snd_ctl_elem_value_t * 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;
@@ -2901 +2897 @@
 }
 
-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);
@@ -2909 +2905 @@
 }
 
-static int snd_trident_pcm_mixer_build(trident_t *trident, snd_trident_voice_t *voice, snd_pcm_substream_t *substream)
-{
-    snd_trident_pcm_mixer_t *tmix;
+static int snd_trident_pcm_mixer_build(struct snd_trident *trident, struct snd_trident_voice*voice, snd_pcm_substream_t *substream)
+{
+    struct snd_trident_pcm_mixer*tmix;
 
     snd_assert(trident != NULL && voice != NULL && substream != NULL, return -EINVAL);
@@ -2924 +2920 @@
 }
 
-static int snd_trident_pcm_mixer_free(trident_t *trident, snd_trident_voice_t *voice, snd_pcm_substream_t *substream)
-{
-    snd_trident_pcm_mixer_t *tmix;
+static int snd_trident_pcm_mixer_free(struct snd_trident *trident, struct snd_trident_voice*voice, snd_pcm_substream_t *substream)
+{
+    struct snd_trident_pcm_mixer*tmix;
 
     snd_assert(trident != NULL && substream != NULL, return -EINVAL);
@@ -2946 +2942 @@
  ---------------------------------------------------------------------------*/
 
-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;
@@ -3013 +3009 @@
 
     for (idx = 0; idx < 32; idx++) {
-        snd_trident_pcm_mixer_t *tmix;
+        struct snd_trident_pcm_mixer*tmix;
 
         tmix = &trident->pcm_mixer[idx];
@@ -3107 +3103 @@
 typedef struct snd_trident_gameport {
     struct gameport info;
-    trident_t *chip;
+    struct snd_trident *chip;
 } trident_gameport_t;
 
@@ -3113 +3109 @@
 {
     trident_gameport_t *gp = (trident_gameport_t *)gameport;
-    trident_t *chip;
+    struct snd_trident *chip;
     snd_assert(gp, return 0);
     chip = gp->chip;
@@ -3122 +3118 @@
 {
     trident_gameport_t *gp = (trident_gameport_t *)gameport;
-    trident_t *chip;
+    struct snd_trident *chip;
     snd_assert(gp, return);
     chip = gp->chip;
@@ -3131 +3127 @@
 {
     trident_gameport_t *gp = (trident_gameport_t *)gameport;
-    trident_t *chip;
+    struct snd_trident *chip;
     int i;
 
@@ -3150 +3146 @@
 {
     trident_gameport_t *gp = (trident_gameport_t *)gameport;
-    trident_t *chip;
+    struct snd_trident *chip;
     snd_assert(gp, return -1);
     chip = gp->chip;
@@ -3167 +3163 @@
 }
 
-void __devinit snd_trident_gameport(trident_t *chip)
+void __devinit snd_trident_gameport(struct snd_trident *chip)
 {
     trident_gameport_t *gp;
@@ -3188 +3184 @@
 
 #else
-void __devinit snd_trident_gameport(trident_t *chip)
+void __devinit snd_trident_gameport(struct snd_trident *chip)
 {
 }
@@ -3196 +3192 @@
  * delay for 1 tick
  */
-inline static void do_delay(trident_t *chip)
+inline static void do_delay(struct snd_trident *chip)
 {
     set_current_state(TASK_UNINTERRUPTIBLE);
@@ -3206 +3202 @@
  */
 
-static int snd_trident_sis_reset(trident_t *trident)
+static int snd_trident_sis_reset(struct snd_trident *trident)
 {
     unsigned long end_time;
@@ -3262 +3258 @@
                                   snd_info_buffer_t * buffer)
 {
-    trident_t *trident = entry->private_data;
+    struct snd_trident *trident = entry->private_data;
     char *s;
 
@@ -3300 +3296 @@
 }
 
-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;
@@ -3313 +3309 @@
 static int snd_trident_dev_free(snd_device_t *device)
 {
-    trident_t *trident = device->device_data;
+    struct snd_trident *trident = device->device_data;
     return snd_trident_free(trident);
 }
@@ -3329 +3325 @@
  ---------------------------------------------------------------------------*/
 
-static int __devinit snd_trident_tlb_alloc(trident_t *trident)
+static int __devinit snd_trident_tlb_alloc(struct snd_trident *trident)
 {
         int i;
@@ -3366 +3362 @@
                 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;
 }
@@ -3374 +3370 @@
  */
 
-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));
@@ -3382 +3378 @@
 }
 
-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;
@@ -3422 +3418 @@
  * 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;
@@ -3479 +3475 @@
  * initialize sis7018 chip
  */
-static int snd_trident_sis_init(trident_t *trident)
+static int snd_trident_sis_init(struct snd_trident *trident)
 {
     int err;
@@ -3515 +3511 @@
                                  int pcm_spdif_device,
                                  int max_wavetable_size,
-                                 trident_t ** rtrident)
-{
-    trident_t *trident;
+                                 struct snd_trident ** rtrident)
+{
+    struct snd_trident *trident;
     int i, err;
-    snd_trident_voice_t *voice;
-    snd_trident_pcm_mixer_t *tmix;
+    struct snd_trident_voice*voice;
+    struct snd_trident_pcm_mixer*tmix;
 #ifdef TARGET_OS2
     static snd_device_ops_t ops = {
@@ -3627 +3623 @@
     snd_trident_enable_eso(trident);
 
-    snd_card_set_pm_callback(card, snd_trident_suspend, snd_trident_resume, trident);
-
     snd_trident_proc_init(trident);
     if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, trident, &ops)) < 0) {
@@ -3650 +3644 @@
  ---------------------------------------------------------------------------*/
 
-int snd_trident_free(trident_t *trident)
+int snd_trident_free(struct snd_trident *trident)
 {
 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
@@ -3702 +3696 @@
 static irqreturn_t snd_trident_interrupt(int irq, void *dev_id, struct pt_regs *regs)
 {
-    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;
 #ifdef TARGET_OS2
     int fOurIrq = FALSE;
@@ -3821 +3815 @@
 
  ---------------------------------------------------------------------------*/
-int snd_trident_attach_synthesizer(trident_t *trident)
+int snd_trident_attach_synthesizer(struct snd_trident *trident)
 {
 #ifdef CONFIG_SND_SEQUENCER
     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
@@ -3833 +3827 @@
 }
 
-int snd_trident_detach_synthesizer(trident_t *trident)
+int snd_trident_detach_synthesizer(struct snd_trident *trident)
 {
 #ifdef CONFIG_SND_SEQUENCER
@@ -3844 +3838 @@
 }
 
-snd_trident_voice_t *snd_trident_alloc_voice(trident_t * trident, int type, int client, int port)
-{
-    snd_trident_voice_t *pvoice;
+struct snd_trident_voice*snd_trident_alloc_voice(struct snd_trident * trident, int type, int client, int port)
+{
+    struct snd_trident_voice*pvoice;
     unsigned long flags;
     int idx;
@@ -3888 +3882 @@
 }
 
-void snd_trident_free_voice(trident_t * trident, snd_trident_voice_t *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;
 
@@ -3916 +3910 @@
 }
 
-void snd_trident_clear_voices(trident_t * trident, unsigned short v_min, unsigned short v_max)
+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 };
@@ -3937 +3931 @@
 
 #ifdef CONFIG_PM
-
-static int snd_trident_suspend(snd_card_t *card, unsigned int state)
-{
-    trident_t *trident = card->pm_private_data;
+int snd_trident_suspend(struct pci_dev *pci, pm_message_t state)
+{
+    struct snd_card *card = pci_get_drvdata(pci);
+    struct snd_trident *trident = card->private_data;
 
     trident->in_suspend = 1;
+    snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
     snd_pcm_suspend_all(trident->pcm);
-    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) {
@@ -3960 +3952 @@
         break;
     }
-    return 0;
-}
-
-static int snd_trident_resume(snd_card_t *card, unsigned int state)
-{
-    trident_t *trident = card->pm_private_data;
-
-    pci_enable_device(trident->pci);
-    pci_set_dma_mask(trident->pci, 0x3fffffff); /* to be sure */
-    pci_set_master(trident->pci); /* to be sure */
+    pci_disable_device(pci);
+    pci_save_state(pci);
+    return 0;
+}
+
+int snd_trident_resume(struct pci_dev *pci)
+{
+    struct snd_card *card = pci_get_drvdata(pci);
+    struct snd_trident *trident = card->private_data;
+
+    pci_restore_state(pci);
+    pci_enable_device(pci);
+    pci_set_master(pci); /* to be sure */
 
     switch (trident->device) {
@@ -3984 +3979 @@
 
     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));
@@ -3991 +3986 @@
     snd_trident_enable_eso(trident);
 
+    snd_power_change_state(card, SNDRV_CTL_POWER_D0);
     trident->in_suspend = 0;
     return 0;

GPL/trunk/alsa-kernel/pci/trident/trident_memory.c

@@ -66 +66 @@
 
 /* fill TLB entries -- we need to fill two entries */
-static inline void set_tlb_bus(trident_t *trident, int page, unsigned long ptr, dma_addr_t addr)
+static inline void set_tlb_bus(struct snd_trident *trident, int page, unsigned long ptr, dma_addr_t addr)
 {
         page <<= 1;
@@ -72 +72 @@
         __set_tlb_bus(trident, page+1, ptr + SNDRV_TRIDENT_PAGE_SIZE, addr + SNDRV_TRIDENT_PAGE_SIZE);
 }
-static inline void set_silent_tlb(trident_t *trident, int page)
+static inline void set_silent_tlb(struct snd_trident *trident, int page)
 {
     page <<= 1;
@@ -97 +97 @@
 
 /* fill TLB entries -- UNIT_PAGES entries must be filled */
-static inline void set_tlb_bus(trident_t *trident, int page, unsigned long ptr, dma_addr_t addr)
+static inline void set_tlb_bus(struct snd_trident *trident, int page, unsigned long ptr, dma_addr_t addr)
 {
         int i;
@@ -107 +107 @@
         }
 }
-static inline void set_silent_tlb(trident_t *trident, int page)
+static inline void set_silent_tlb(struct snd_trident *trident, int page)
 {
         int i;
@@ -119 +119 @@
 
 /* calculate buffer pointer from offset address */
-inline static void *offset_ptr(trident_t *trident, int offset)
+inline static void *offset_ptr(struct snd_trident *trident, int offset)
 {
         char *ptr;
@@ -128 +128 @@
 
 /* first and last (aligned) pages of memory block */
-#define firstpg(blk)    (((snd_trident_memblk_arg_t*)snd_util_memblk_argptr(blk))->first_page)
-#define lastpg(blk)     (((snd_trident_memblk_arg_t*)snd_util_memblk_argptr(blk))->last_page)
+#define firstpg(blk)    (((struct snd_trident_memblk_arg*)snd_util_memblk_argptr(blk))->first_page)
+#define lastpg(blk)     (((struct snd_trident_memblk_arg*)snd_util_memblk_argptr(blk))->last_page)
 
 /*
@@ -185 +185 @@
  */
 static snd_util_memblk_t *
-snd_trident_alloc_sg_pages(trident_t *trident, snd_pcm_substream_t *substream)
+snd_trident_alloc_sg_pages(struct snd_trident *trident, snd_pcm_substream_t *substream)
 {
         snd_util_memhdr_t *hdr;
@@ -232 +232 @@
  */
 static snd_util_memblk_t *
-snd_trident_alloc_cont_pages(trident_t *trident, snd_pcm_substream_t *substream)
+snd_trident_alloc_cont_pages(struct snd_trident *trident, snd_pcm_substream_t *substream)
 {
         snd_util_memhdr_t *hdr;
@@ -272 +272 @@
  */
 snd_util_memblk_t *
-snd_trident_alloc_pages(trident_t *trident, snd_pcm_substream_t *substream)
+snd_trident_alloc_pages(struct snd_trident *trident, snd_pcm_substream_t *substream)
 {
         snd_assert(trident != NULL, return NULL);
@@ -286 +286 @@
  * release DMA buffer from page table
  */
-int snd_trident_free_pages(trident_t *trident, snd_util_memblk_t *blk)
+int snd_trident_free_pages(struct snd_trident *trident, snd_util_memblk_t *blk)
 {
         snd_util_memhdr_t *hdr;
@@ -314 +314 @@
 /*
  */
-static int synth_alloc_pages(trident_t *hw, snd_util_memblk_t *blk);
-static int synth_free_pages(trident_t *hw, snd_util_memblk_t *blk);
+static int synth_alloc_pages(struct snd_trident *hw, snd_util_memblk_t *blk);
+static int synth_free_pages(struct snd_trident *hw, snd_util_memblk_t *blk);
 
 /*
@@ -321 +321 @@
  */
 snd_util_memblk_t *
-snd_trident_synth_alloc(trident_t *hw, unsigned int size)
+snd_trident_synth_alloc(struct snd_trident *hw, unsigned int size)
 {
         snd_util_memblk_t *blk;
@@ -346 +346 @@
  */
 int
-snd_trident_synth_free(trident_t *hw, snd_util_memblk_t *blk)
+snd_trident_synth_free(struct snd_trident *hw, snd_util_memblk_t *blk)
 {
         snd_util_memhdr_t *hdr = hw->tlb.memhdr; 
@@ -361 +361 @@
  * reset TLB entry and free kernel page
  */
-static void clear_tlb(trident_t *trident, int page)
+static void clear_tlb(struct snd_trident *trident, int page)
 {
         void *ptr = page_to_ptr(trident, page);
@@ -403 +403 @@
  * allocate kernel pages and assign them to TLB
  */
-static int synth_alloc_pages(trident_t *hw, snd_util_memblk_t *blk)
+static int synth_alloc_pages(struct snd_trident *hw, snd_util_memblk_t *blk)
 {
         int page, first_page, last_page;
@@ -439 +439 @@
  * free pages
  */
-static int synth_free_pages(trident_t *trident, snd_util_memblk_t *blk)
+static int synth_free_pages(struct snd_trident *trident, snd_util_memblk_t *blk)
 {
         int page, first_page, last_page;
@@ -453 +453 @@
  * bzero(blk + offset, size)
  */
-int snd_trident_synth_bzero(trident_t *trident, snd_util_memblk_t *blk, int offset, int size)
+int snd_trident_synth_bzero(struct snd_trident *trident, snd_util_memblk_t *blk, int offset, int size)
 {
         int page, nextofs, end_offset, temp, temp1;
@@ -476 +476 @@
  * copy_from_user(blk + offset, data, size)
  */
-int snd_trident_synth_copy_from_user(trident_t *trident, snd_util_memblk_t *blk, int offset, const char *data, int size)
+int snd_trident_synth_copy_from_user(struct snd_trident *trident, snd_util_memblk_t *blk, int offset, const char *data, int size)
 {
         int page, nextofs, end_offset, temp, temp1;

GPL/trunk/alsa-kernel/pci/trident/trident_synth.c

@@ -190 +190 @@
  */
 
-static void sample_start(trident_t * trident, snd_trident_voice_t * voice, snd_seq_position_t position);
-static void sample_stop(trident_t * trident, snd_trident_voice_t * voice, snd_seq_stop_mode_t mode);
-static void sample_freq(trident_t * trident, snd_trident_voice_t * voice, snd_seq_frequency_t freq);
-static void sample_volume(trident_t * trident, snd_trident_voice_t * voice, snd_seq_ev_volume_t * volume);
-static void sample_loop(trident_t * trident, snd_trident_voice_t * voice, snd_seq_ev_loop_t * loop);
-static void sample_pos(trident_t * trident, snd_trident_voice_t * voice, snd_seq_position_t position);
-static void sample_private1(trident_t * trident, snd_trident_voice_t * voice, unsigned char *data);
-
-static snd_trident_sample_ops_t sample_ops =
+static void sample_start(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_position_t position);
+static void sample_stop(struct snd_trident * trident, struct snd_trident_voice * voice, int mode);
+static void sample_freq(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_frequency_t freq);
+static void sample_volume(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_ev_volume_t * volume);
+static void sample_loop(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_ev_loop_t * loop);
+static void sample_pos(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_position_t position);
+static void sample_private1(struct snd_trident * trident, struct snd_trident_voice * voice, unsigned char *data);
+
+static struct snd_trident_sample_ops sample_ops =
 {
     sample_start,
@@ -209 +209 @@
 };
 
-static void snd_trident_simple_init(snd_trident_voice_t * voice)
+static void snd_trident_simple_init(struct snd_trident_voice * voice)
 {
     //voice->handler_wave = interrupt_wave;
@@ -218 +218 @@
 }
 
-static void sample_start(trident_t * trident, snd_trident_voice_t * voice, snd_seq_position_t position)
+static void sample_start(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_position_t position)
 {
     simple_instrument_t *simple;
@@ -303 +303 @@
 }
 
-static void sample_stop(trident_t * trident, snd_trident_voice_t * voice, snd_seq_stop_mode_t mode)
+static void sample_stop(struct snd_trident * trident, struct snd_trident_voice * voice, int mode)
 {
     unsigned long flags;
@@ -327 +327 @@
 }
 
-static void sample_freq(trident_t * trident, snd_trident_voice_t * voice, snd_seq_frequency_t freq)
+static void sample_freq(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_frequency_t freq)
 {
     unsigned long flags;
@@ -353 +353 @@
 }
 
-static void sample_volume(trident_t * trident, snd_trident_voice_t * voice, snd_seq_ev_volume_t * volume)
+static void sample_volume(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_ev_volume_t * volume)
 {
     unsigned long flags;
@@ -405 +405 @@
 }
 
-static void sample_loop(trident_t * trident, snd_trident_voice_t * voice, snd_seq_ev_loop_t * loop)
+static void sample_loop(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_ev_loop_t * loop)
 {
     unsigned long flags;
@@ -444 +444 @@
 }
 
-static void sample_pos(trident_t * trident, snd_trident_voice_t * voice, snd_seq_position_t position)
+static void sample_pos(struct snd_trident * trident, struct snd_trident_voice * voice, snd_seq_position_t position)
 {
     unsigned long flags;
@@ -494 +494 @@
 }
 
-static void sample_private1(trident_t * trident, snd_trident_voice_t * voice, unsigned char *data)
+static void sample_private1(struct snd_trident * trident, struct snd_trident_voice * voice, unsigned char *data)
 {
 }
@@ -505 +505 @@
                                          char __user *data, long len, int atomic)
 {
-        trident_t *trident = private_data;
+        struct snd_trident *trident = private_data;
         int size = instr->size;
         int shift = 0;
@@ -559 +559 @@
                                          char *data, long len, int atomic)
 {
-    //trident_t *trident = private_data;
+    //struct snd_trident *trident = private_data;
     int size = instr->size;
     int shift = 0;
@@ -580 +580 @@
                                             int atomic)
 {
-    trident_t *trident = private_data;
+    struct snd_trident *trident = private_data;
     int size = instr->size;
 
@@ -611 +611 @@
 }
 
-static void select_instrument(trident_t * trident, snd_trident_voice_t * v)
+static void select_instrument(struct snd_trident * trident, struct snd_trident_voice * v)
 {
     snd_seq_kinstr_t *instr;
@@ -628 +628 @@
 */
 
-static void event_sample(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v)
+static void event_sample(snd_seq_event_t * ev, struct snd_trident_port * p, struct snd_trident_voice * v)
 {
     if (v->sample_ops && v->sample_ops->sample_stop)
@@ -642 +642 @@
 }
 
-static void event_cluster(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v)
+static void event_cluster(snd_seq_event_t * ev, struct snd_trident_port * p, struct snd_trident_voice * v)
 {
     if (v->sample_ops && v->sample_ops->sample_stop)
@@ -650 +650 @@
 }
 
-static void event_start(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v)
+static void event_start(snd_seq_event_t * ev, struct snd_trident_port * p, struct snd_trident_voice * v)
 {
     if (v->sample_ops && v->sample_ops->sample_start)
@@ -656 +656 @@
 }
 
-static void event_stop(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v)
+static void event_stop(snd_seq_event_t * ev, struct snd_trident_port * p, struct snd_trident_voice * v)
 {
     if (v->sample_ops && v->sample_ops->sample_stop)
@@ -662 +662 @@
 }
 
-static void event_freq(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v)
+static void event_freq(snd_seq_event_t * ev, struct snd_trident_port * p, struct snd_trident_voice * v)
 {
     if (v->sample_ops && v->sample_ops->sample_freq)
@@ -668 +668 @@
 }
 
-static void event_volume(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v)
+static void event_volume(snd_seq_event_t * ev, struct snd_trident_port * p, struct snd_trident_voice * v)
 {
     if (v->sample_ops && v->sample_ops->sample_volume)
@@ -674 +674 @@
 }
 
-static void event_loop(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v)
+static void event_loop(snd_seq_event_t * ev, struct snd_trident_port * p, struct snd_trident_voice * v)
 {
     if (v->sample_ops && v->sample_ops->sample_loop)
@@ -680 +680 @@
 }
 
-static void event_position(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v)
+static void event_position(snd_seq_event_t * ev, struct snd_trident_port * p, struct snd_trident_voice * v)
 {
     if (v->sample_ops && v->sample_ops->sample_pos)
@@ -686 +686 @@
 }
 
-static void event_private1(snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v)
+static void event_private1(snd_seq_event_t * ev, struct snd_trident_port * p, struct snd_trident_voice * v)
 {
     if (v->sample_ops && v->sample_ops->sample_private1)
@@ -692 +692 @@
 }
 
-typedef void (trident_sample_event_handler_t) (snd_seq_event_t * ev, snd_trident_port_t * p, snd_trident_voice_t * v);
+typedef void (trident_sample_event_handler_t) (snd_seq_event_t * ev, struct snd_trident_port * p, struct snd_trident_voice * v);
 
 static trident_sample_event_handler_t *trident_sample_event_handlers[9] =
@@ -707 +707 @@
 };
 
-static void snd_trident_sample_event(snd_seq_event_t * ev, snd_trident_port_t * p)
+static void snd_trident_sample_event(snd_seq_event_t * ev, struct snd_trident_port * p)
 {
     int idx, voice;
-    trident_t *trident = p->trident;
-    snd_trident_voice_t *v;
+    struct snd_trident *trident = p->trident;
+    struct snd_trident_voice *v;
     unsigned long flags;
 
@@ -734 +734 @@
 */
 
-static void snd_trident_synth_free_voices(trident_t * trident, int client, int port)
+static void snd_trident_synth_free_voices(struct snd_trident * trident, int client, int port)
 {
     int idx;
-    snd_trident_voice_t *voice;
+    struct snd_trident_voice *voice;
 
     for (idx = 0; idx < 32; idx++) {
@@ -748 +748 @@
 static int snd_trident_synth_use(void *private_data, snd_seq_port_subscribe_t * info)
 {
-    snd_trident_port_t *port = (snd_trident_port_t *) private_data;
-    trident_t *trident = port->trident;
-    snd_trident_voice_t *voice;
+    struct snd_trident_port *port = (struct snd_trident_port *) private_data;
+    struct snd_trident *trident = port->trident;
+    struct snd_trident_voice *voice;
     unsigned int idx;
     unsigned long flags;
@@ -787 +787 @@
 static int snd_trident_synth_unuse(void *private_data, snd_seq_port_subscribe_t * info)
 {
-    snd_trident_port_t *port = (snd_trident_port_t *) private_data;
-    trident_t *trident = port->trident;
+    struct snd_trident_port *port = (struct snd_trident_port *) private_data;
+    struct snd_trident *trident = port->trident;
     unsigned long flags;
 
@@ -801 +801 @@
 */
 
-static void snd_trident_synth_free_private_instruments(snd_trident_port_t * p, int client)
+static void snd_trident_synth_free_private_instruments(struct snd_trident_port * p, int client)
 {
     snd_seq_instr_header_t ifree;
@@ -812 +812 @@
 int snd_trident_synth_event_input(snd_seq_event_t * ev, int direct, void *private_data, int atomic, int hop)
 {
-    snd_trident_port_t *p = (snd_trident_port_t *) private_data;
+    struct snd_trident_port *p = (struct snd_trident_port *) private_data;
 
     if (p == NULL)
@@ -844 +844 @@
 {
     int idx;
-    trident_t *trident = private_data;
-    snd_trident_voice_t *pvoice;
+    struct snd_trident *trident = private_data;
+    struct snd_trident_voice *pvoice;
     unsigned long flags;
 
@@ -869 +869 @@
 static void snd_trident_synth_free_port(void *private_data)
 {
-    snd_trident_port_t *p = (snd_trident_port_t *) private_data;
+    struct snd_trident_port *p = (struct snd_trident_port *) private_data;
 
     if (p)
@@ -875 +875 @@
 }
 
-static int snd_trident_synth_create_port(trident_t * trident, int idx)
-{
-    snd_trident_port_t *p;
-    snd_seq_port_callback_t callbacks;
+static int snd_trident_synth_create_port(struct snd_trident * trident, int idx)
+{
+    struct snd_trident_port *p;
+    struct snd_seq_port_callback callbacks;
     char name[32];
     char *str;
@@ -928 +928 @@
 static int snd_trident_synth_new_device(snd_seq_device_t *dev)
 {
-    trident_t *trident;
+    struct snd_trident *trident;
     int client, i;
-    snd_seq_client_callback_t callbacks;
+    struct snd_seq_client_callback callbacks;
     snd_seq_client_info_t cinfo;
     snd_seq_port_subscribe_t sub;
@@ -936 +936 @@
     char *str;
 
-    trident = *(trident_t **)SNDRV_SEQ_DEVICE_ARGPTR(dev);
+    trident = *(struct snd_trident **)SNDRV_SEQ_DEVICE_ARGPTR(dev);
     if (trident == NULL)
         return -EINVAL;
@@ -994 +994 @@
 static int snd_trident_synth_delete_device(snd_seq_device_t *dev)
 {
-    trident_t *trident;
-
-    trident = *(trident_t **)SNDRV_SEQ_DEVICE_ARGPTR(dev);
+    struct snd_trident *trident;
+
+    trident = *(struct snd_trident **)SNDRV_SEQ_DEVICE_ARGPTR(dev);
     if (trident == NULL)
         return -EINVAL;
@@ -1018 +1018 @@
 
     return snd_seq_device_register_driver(SNDRV_SEQ_DEV_ID_TRIDENT, &ops,
-                                          sizeof(trident_t*));
+                                          sizeof(struct snd_trident*));
 }