Changeset 679 for GPL/trunk/alsa-kernel/pci/ens1370.c

Timestamp:

Mar 18, 2021, 8:57:36 PM (4 years ago)

Author:

David Azarewicz

Message:

Merge changes from Paul's uniaud32next branch.

Location:

GPL/trunk

Files:

• . (modified) (1 prop)
• alsa-kernel/pci/ens1370.c (modified) (72 diffs)

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

@@ +1 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
 /*
  *  Driver for Ensoniq ES1370/ES1371 AudioPCI soundcard
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>,
  *                   Thomas Sailer <sailer@ife.ee.ethz.ch>
- *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
- *
  */
 
@@ -23 +9 @@
  * for ens1371 only ( FIXME )
  * derived from cs4281.c, atiixp.c and via82xx.c
- * using http://www.alsa-project.org/~tiwai/writing-an-alsa-driver/
+ * using http://www.alsa-project.org/~tiwai/writing-an-alsa-driver/ 
  * by Kurt J. Bosch
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
@@ -34 +20 @@
 #include <linux/slab.h>
 #include <linux/gameport.h>
-#include <linux/moduleparam.h>
+#include <linux/module.h>
 #include <linux/mutex.h>
 
@@ -56 +42 @@
 #ifdef CHIP1370
 #define DRIVER_NAME "ENS1370"
+#define CHIP_NAME "ES1370" /* it can be ENS but just to keep compatibility... */
 #else
 #define DRIVER_NAME "ENS1371"
-#endif
-
-
+#define CHIP_NAME "ES1371"
+#endif
+
+
+#ifdef TARGET_OS2
+#define KBUILD_MODNAME "ens137x"
+#endif
 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, Thomas Sailer <sailer@ife.ee.ethz.ch>");
 MODULE_LICENSE("GPL");
@@ -78 +69 @@
 #endif
 
-#if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
+#if IS_REACHABLE(CONFIG_GAMEPORT)
 #define SUPPORT_JOYSTICK
 #endif
@@ -84 +75 @@
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
-static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;      /* Enable switches */
+static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;     /* Enable switches */
 #ifdef SUPPORT_JOYSTICK
 #ifdef CHIP1371
 static int joystick_port[SNDRV_CARDS];
 #else
-static int joystick[SNDRV_CARDS];
+static bool joystick[SNDRV_CARDS];
 #endif
 #endif
@@ -105 +96 @@
 #ifdef SUPPORT_JOYSTICK
 #ifdef CHIP1371
-module_param_array(joystick_port, int, NULL, 0444);
+module_param_hw_array(joystick_port, int, ioport, NULL, 0444);
 MODULE_PARM_DESC(joystick_port, "Joystick port address.");
 #else
@@ -230 +221 @@
 #define   ES_1371_CODEC_RDY        (1<<31)      /* codec ready */
 #define   ES_1371_CODEC_WIP        (1<<30)      /* codec register access in progress */
+#define   EV_1938_CODEC_MAGIC      (1<<26)
 #define   ES_1371_CODEC_PIRD       (1<<23)      /* codec read/write select register */
 #define   ES_1371_CODEC_WRITE(a,d) ((((a)&0x7f)<<16)|(((d)&0xffff)<<0))
@@ -444 +436 @@
 static irqreturn_t snd_audiopci_interrupt(int irq, void *dev_id);
 
-static DEFINE_PCI_DEVICE_TABLE(snd_audiopci_ids) = {
+static const struct pci_device_id snd_audiopci_ids[] = {
 #ifdef CHIP1370
         { PCI_VDEVICE(ENSONIQ, 0x5000), 0, },   /* ES1370 */
@@ -465 +457 @@
 
 #ifdef CHIP1370
-static unsigned int snd_es1370_fixed_rates[] =
+static const unsigned int snd_es1370_fixed_rates[] =
         {5512, 11025, 22050, 44100};
-static struct snd_pcm_hw_constraint_list snd_es1370_hw_constraints_rates = {
-        .count = 4,
+static const struct snd_pcm_hw_constraint_list snd_es1370_hw_constraints_rates = {
+        .count = 4, 
         .list = snd_es1370_fixed_rates,
         .mask = 0,
 };
-static struct snd_ratnum es1370_clock = {
+static const struct snd_ratnum es1370_clock = {
         .num = ES_1370_SRCLOCK,
-        .den_min = 29,
+        .den_min = 29, 
         .den_max = 353,
         .den_step = 1,
 };
-static struct snd_pcm_hw_constraint_ratnums snd_es1370_hw_constraints_clock = {
+static const struct snd_pcm_hw_constraint_ratnums snd_es1370_hw_constraints_clock = {
         .nrats = 1,
         .rats = &es1370_clock,
 };
 #else
-static struct snd_ratden es1371_dac_clock = {
+static const struct snd_ratden es1371_dac_clock = {
         .num_min = 3000 * (1 << 15),
         .num_max = 48000 * (1 << 15),
@@ -489 +481 @@
         .den = 1 << 15,
 };
-static struct snd_pcm_hw_constraint_ratdens snd_es1371_hw_constraints_dac_clock = {
+static const struct snd_pcm_hw_constraint_ratdens snd_es1371_hw_constraints_dac_clock = {
         .nrats = 1,
         .rats = &es1371_dac_clock,
 };
-static struct snd_ratnum es1371_adc_clock = {
+static const struct snd_ratnum es1371_adc_clock = {
         .num = 48000 << 15,
-        .den_min = 32768,
+        .den_min = 32768, 
         .den_max = 393216,
         .den_step = 1,
 };
-static struct snd_pcm_hw_constraint_ratnums snd_es1371_hw_constraints_adc_clock = {
+static const struct snd_pcm_hw_constraint_ratnums snd_es1371_hw_constraints_adc_clock = {
         .nrats = 1,
         .rats = &es1371_adc_clock,
@@ -523 +515 @@
                 cond_resched();
         }
-        snd_printk(KERN_ERR "wait src ready timeout 0x%lx [0x%x]\n",
+        dev_err(ensoniq->card->dev, "wait src ready timeout 0x%lx [0x%x]\n",
                    ES_REG(ensoniq, 1371_SMPRATE), r);
         return 0;
@@ -585 +577 @@
 
 #if 0
-        printk(KERN_DEBUG
+        dev_dbg(ensoniq->card->dev,
                "CODEC WRITE: reg = 0x%x, val = 0x%x (0x%x), creg = 0x%x\n",
                reg, val, ES_1370_CODEC_WRITE(reg, val), ES_REG(ensoniq, 1370_CODEC));
@@ -596 +588 @@
                 schedule_timeout_uninterruptible(1);
         } while (time_after(end_time, jiffies));
-        snd_printk(KERN_ERR "codec write timeout, status = 0x%x\n",
+        dev_err(ensoniq->card->dev, "codec write timeout, status = 0x%x\n",
                    inl(ES_REG(ensoniq, STATUS)));
 }
@@ -603 +595 @@
 
 #ifdef CHIP1371
+
+static inline bool is_ev1938(struct ensoniq *ensoniq)
+{
+        return ensoniq->pci->device == 0x8938;
+}
 
 static void snd_es1371_codec_write(struct snd_ac97 *ac97,
@@ -608 +605 @@
 {
         struct ensoniq *ensoniq = ac97->private_data;
-        unsigned int t, x;
-
+        unsigned int t, x, flag;
+
+        flag = is_ev1938(ensoniq) ? EV_1938_CODEC_MAGIC : 0;
         mutex_lock(&ensoniq->src_mutex);
         for (t = 0; t < POLL_COUNT; t++) {
@@ -631 +629 @@
                                         break;
                         }
-                        outl(ES_1371_CODEC_WRITE(reg, val), ES_REG(ensoniq, 1371_CODEC));
+                        outl(ES_1371_CODEC_WRITE(reg, val) | flag,
+                             ES_REG(ensoniq, 1371_CODEC));
                         /* restore SRC reg */
                         snd_es1371_wait_src_ready(ensoniq);
@@ -640 +639 @@
         }
         mutex_unlock(&ensoniq->src_mutex);
-        snd_printk(KERN_ERR "codec write timeout at 0x%lx [0x%x]\n",
+        dev_err(ensoniq->card->dev, "codec write timeout at 0x%lx [0x%x]\n",
                    ES_REG(ensoniq, 1371_CODEC), inl(ES_REG(ensoniq, 1371_CODEC)));
 }
@@ -648 +647 @@
 {
         struct ensoniq *ensoniq = ac97->private_data;
-        unsigned int t, x, fail = 0;
-
+        unsigned int t, x, flag, fail = 0;
+
+        flag = is_ev1938(ensoniq) ? EV_1938_CODEC_MAGIC : 0;
       __again:
         mutex_lock(&ensoniq->src_mutex);
@@ -672 +672 @@
                                         break;
                         }
-                        outl(ES_1371_CODEC_READS(reg), ES_REG(ensoniq, 1371_CODEC));
+                        outl(ES_1371_CODEC_READS(reg) | flag,
+                             ES_REG(ensoniq, 1371_CODEC));
                         /* restore SRC reg */
                         snd_es1371_wait_src_ready(ensoniq);
@@ -684 +685 @@
                         for (t = 0; t < POLL_COUNT; t++) {
                                 if ((x = inl(ES_REG(ensoniq, 1371_CODEC))) & ES_1371_CODEC_RDY) {
+                                        if (is_ev1938(ensoniq)) {
+                                                for (t = 0; t < 100; t++)
+                                                        inl(ES_REG(ensoniq, CONTROL));
+                                                x = inl(ES_REG(ensoniq, 1371_CODEC));
+                                        }
                                         mutex_unlock(&ensoniq->src_mutex);
                                         return ES_1371_CODEC_READ(x);
@@ -690 +696 @@
                         mutex_unlock(&ensoniq->src_mutex);
                         if (++fail > 10) {
-                                snd_printk(KERN_ERR "codec read timeout (final) "
-                                           "at 0x%lx, reg = 0x%x [0x%x]\n",
+                                dev_err(ensoniq->card->dev,
+                                        "codec read timeout (final) at 0x%lx, reg = 0x%x [0x%x]\n",
                                            ES_REG(ensoniq, 1371_CODEC), reg,
                                            inl(ES_REG(ensoniq, 1371_CODEC)));
@@ -700 +706 @@
         }
         mutex_unlock(&ensoniq->src_mutex);
-        snd_printk(KERN_ERR "es1371: codec read timeout at 0x%lx [0x%x]\n",
+        dev_err(ensoniq->card->dev, "codec read timeout at 0x%lx [0x%x]\n",
                    ES_REG(ensoniq, 1371_CODEC), inl(ES_REG(ensoniq, 1371_CODEC)));
         return 0;
@@ -716 +722 @@
 static void snd_es1371_adc_rate(struct ensoniq * ensoniq, unsigned int rate)
 {
-        unsigned int n, truncm, freq, result;
+        unsigned int n, truncm, freq;
 
         mutex_lock(&ensoniq->src_mutex);
@@ -724 +730 @@
         truncm = (21 * n - 1) | 1;
         freq = ((48000UL << 15) / rate) * n;
-        result = (48000UL << 15) / (freq / n);
         if (rate >= 24000) {
                 if (truncm > 239)
@@ -855 +860 @@
  */
 
-static int snd_ensoniq_hw_params(struct snd_pcm_substream *substream,
-                                 struct snd_pcm_hw_params *hw_params)
-{
-        return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
-}
-
-static int snd_ensoniq_hw_free(struct snd_pcm_substream *substream)
-{
-        return snd_pcm_lib_free_pages(substream);
-}
-
 static int snd_ensoniq_playback1_prepare(struct snd_pcm_substream *substream)
 {
@@ -1043 +1037 @@
 }
 
-static struct snd_pcm_hardware snd_ensoniq_playback1 =
+static const struct snd_pcm_hardware snd_ensoniq_playback1 =
 {
         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
@@ -1055 +1049 @@
 #else
                                 (SNDRV_PCM_RATE_KNOT |  /* 5512Hz rate */
-                                 SNDRV_PCM_RATE_11025 | SNDRV_PCM_RATE_22050 |
+                                 SNDRV_PCM_RATE_11025 | SNDRV_PCM_RATE_22050 | 
                                  SNDRV_PCM_RATE_44100),
 #endif
@@ -1070 +1064 @@
 };
 
-static struct snd_pcm_hardware snd_ensoniq_playback2 =
+static const struct snd_pcm_hardware snd_ensoniq_playback2 =
 {
         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
-                                 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_PAUSE |
+                                 SNDRV_PCM_INFO_MMAP_VALID | SNDRV_PCM_INFO_PAUSE | 
                                  SNDRV_PCM_INFO_SYNC_START),
         .formats =              SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE,
@@ -1090 +1084 @@
 };
 
-static struct snd_pcm_hardware snd_ensoniq_capture =
+static const struct snd_pcm_hardware snd_ensoniq_capture =
 {
         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
@@ -1211 +1205 @@
 }
 
-static struct snd_pcm_ops snd_ensoniq_playback1_ops = {
+static const struct snd_pcm_ops snd_ensoniq_playback1_ops = {
         .open =         snd_ensoniq_playback1_open,
         .close =        snd_ensoniq_playback1_close,
-        .ioctl =        snd_pcm_lib_ioctl,
-        .hw_params =    snd_ensoniq_hw_params,
-        .hw_free =      snd_ensoniq_hw_free,
         .prepare =      snd_ensoniq_playback1_prepare,
         .trigger =      snd_ensoniq_trigger,
@@ -1222 +1213 @@
 };
 
-static struct snd_pcm_ops snd_ensoniq_playback2_ops = {
+static const struct snd_pcm_ops snd_ensoniq_playback2_ops = {
         .open =         snd_ensoniq_playback2_open,
         .close =        snd_ensoniq_playback2_close,
-        .ioctl =        snd_pcm_lib_ioctl,
-        .hw_params =    snd_ensoniq_hw_params,
-        .hw_free =      snd_ensoniq_hw_free,
         .prepare =      snd_ensoniq_playback2_prepare,
         .trigger =      snd_ensoniq_trigger,
@@ -1233 +1221 @@
 };
 
-static struct snd_pcm_ops snd_ensoniq_capture_ops = {
+static const struct snd_pcm_ops snd_ensoniq_capture_ops = {
         .open =         snd_ensoniq_capture_open,
         .close =        snd_ensoniq_capture_close,
-        .ioctl =        snd_pcm_lib_ioctl,
-        .hw_params =    snd_ensoniq_hw_params,
-        .hw_free =      snd_ensoniq_hw_free,
         .prepare =      snd_ensoniq_capture_prepare,
         .trigger =      snd_ensoniq_trigger,
@@ -1244 +1229 @@
 };
 
-static int __devinit snd_ensoniq_pcm(struct ensoniq * ensoniq, int device,
-                                     struct snd_pcm ** rpcm)
+static const struct snd_pcm_chmap_elem surround_map[] = {
+        { .channels = 1,
+          .map = { SNDRV_CHMAP_MONO } },
+        { .channels = 2,
+          .map = { SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
+        {0}
+};
+
+static int snd_ensoniq_pcm(struct ensoniq *ensoniq, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
-#ifdef CHIP1370
-        err = snd_pcm_new(ensoniq->card, "ES1370/1", device, 1, 1, &pcm);
-#else
-        err = snd_pcm_new(ensoniq->card, "ES1371/1", device, 1, 1, &pcm);
-#endif
+        err = snd_pcm_new(ensoniq->card, CHIP_NAME "/1", device, 1, 1, &pcm);
         if (err < 0)
                 return err;
@@ -1269 +1255 @@
         pcm->private_data = ensoniq;
         pcm->info_flags = 0;
-#ifdef CHIP1370
-        strcpy(pcm->name, "ES1370 DAC2/ADC");
+        strcpy(pcm->name, CHIP_NAME " DAC2/ADC");
+        ensoniq->pcm1 = pcm;
+
+        snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                       &ensoniq->pci->dev, 64*1024, 128*1024);
+
+#ifdef CHIP1370
+        err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
+                                     surround_map, 2, 0, NULL);
 #else
-        strcpy(pcm->name, "ES1371 DAC2/ADC");
-#endif
-        ensoniq->pcm1 = pcm;
-
-        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                              snd_dma_pci_data(ensoniq->pci), 64*1024, 128*1024);
-
-        if (rpcm)
-                *rpcm = pcm;
-        return 0;
-}
-
-static int __devinit snd_ensoniq_pcm2(struct ensoniq * ensoniq, int device,
-                                      struct snd_pcm ** rpcm)
+        err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
+                                     snd_pcm_std_chmaps, 2, 0, NULL);
+#endif
+        return err;
+}
+
+static int snd_ensoniq_pcm2(struct ensoniq *ensoniq, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
-#ifdef CHIP1370
-        err = snd_pcm_new(ensoniq->card, "ES1370/2", device, 1, 0, &pcm);
-#else
-        err = snd_pcm_new(ensoniq->card, "ES1371/2", device, 1, 0, &pcm);
-#endif
+        err = snd_pcm_new(ensoniq->card, CHIP_NAME "/2", device, 1, 0, &pcm);
         if (err < 0)
                 return err;
@@ -1307 +1287 @@
         pcm->private_data = ensoniq;
         pcm->info_flags = 0;
-#ifdef CHIP1370
-        strcpy(pcm->name, "ES1370 DAC1");
+        strcpy(pcm->name, CHIP_NAME " DAC1");
+        ensoniq->pcm2 = pcm;
+
+        snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                       &ensoniq->pci->dev, 64*1024, 128*1024);
+
+#ifdef CHIP1370
+        err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
+                                     snd_pcm_std_chmaps, 2, 0, NULL);
 #else
-        strcpy(pcm->name, "ES1371 DAC1");
-#endif
-        ensoniq->pcm2 = pcm;
-
-        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                              snd_dma_pci_data(ensoniq->pci), 64*1024, 128*1024);
-
-        if (rpcm)
-                *rpcm = pcm;
-        return 0;
+        err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
+                                     surround_map, 2, 0, NULL);
+#endif
+        return err;
 }
 
@@ -1456 +1437 @@
 
 /* spdif controls */
-static struct snd_kcontrol_new snd_es1371_mixer_spdif[] __devinitdata = {
+static const struct snd_kcontrol_new snd_es1371_mixer_spdif[] = {
         ES1371_SPDIF(SNDRV_CTL_NAME_IEC958("",PLAYBACK,SWITCH)),
         {
@@ -1518 +1499 @@
 }
 
-static struct snd_kcontrol_new snd_ens1373_rear __devinitdata =
+static const struct snd_kcontrol_new snd_ens1373_rear =
 {
         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -1536 +1517 @@
         
         spin_lock_irq(&ensoniq->reg_lock);
-        if ((ensoniq->ctrl & ES_1371_GPIO_OUTM) >= 4)
+        if (ensoniq->ctrl & ES_1371_GPIO_OUT(4))
                 val = 1;
         ucontrol->value.integer.value[0] = val;
@@ -1563 +1544 @@
 }
 
-static struct snd_kcontrol_new snd_ens1373_line __devinitdata =
+static const struct snd_kcontrol_new snd_ens1373_line =
 {
         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -1585 +1566 @@
 
 static int es1371_quirk_lookup(struct ensoniq *ensoniq,
-                                struct es1371_quirk *list)
+                               const struct es1371_quirk *list)
 {
         while (list->vid != (unsigned short)PCI_ANY_ID) {
@@ -1597 +1578 @@
 }
 
-static struct es1371_quirk es1371_spdif_present[] __devinitdata = {
+static const struct es1371_quirk es1371_spdif_present[] = {
         { .vid = PCI_VENDOR_ID_ENSONIQ, .did = PCI_DEVICE_ID_ENSONIQ_CT5880, .rev = CT5880REV_CT5880_C },
         { .vid = PCI_VENDOR_ID_ENSONIQ, .did = PCI_DEVICE_ID_ENSONIQ_CT5880, .rev = CT5880REV_CT5880_D },
@@ -1606 +1587 @@
 };
 
-static struct snd_pci_quirk ens1373_line_quirk[] __devinitdata = {
+static const struct snd_pci_quirk ens1373_line_quirk[] = {
         SND_PCI_QUIRK_ID(0x1274, 0x2000), /* GA-7DXR */
         SND_PCI_QUIRK_ID(0x1458, 0xa000), /* GA-8IEXP */
@@ -1612 +1593 @@
 };
 
-static int __devinit snd_ensoniq_1371_mixer(struct ensoniq *ensoniq,
-                                            int has_spdif, int has_line)
+static int snd_ensoniq_1371_mixer(struct ensoniq *ensoniq,
+                                  int has_spdif, int has_line)
 {
         struct snd_card *card = ensoniq->card;
@@ -1619 +1600 @@
         struct snd_ac97_template ac97;
         int err;
-        static struct snd_ac97_bus_ops ops = {
+        static const struct snd_ac97_bus_ops ops = {
                 .write = snd_es1371_codec_write,
                 .read = snd_es1371_codec_read,
@@ -1721 +1702 @@
  */
 
-static struct snd_kcontrol_new snd_es1370_controls[2] __devinitdata = {
+static const struct snd_kcontrol_new snd_es1370_controls[2] = {
 ENSONIQ_CONTROL("PCM 0 Output also on Line-In Jack", ES_1370_XCTL0),
 ENSONIQ_CONTROL("Mic +5V bias", ES_1370_XCTL1)
@@ -1734 +1715 @@
 }
 
-static int __devinit snd_ensoniq_1370_mixer(struct ensoniq * ensoniq)
+static int snd_ensoniq_1370_mixer(struct ensoniq *ensoniq)
 {
         struct snd_card *card = ensoniq->card;
@@ -1768 +1749 @@
 
 #ifdef CHIP1371
-static int __devinit snd_ensoniq_get_joystick_port(int dev)
+static int snd_ensoniq_get_joystick_port(struct ensoniq *ensoniq, int dev)
 {
         switch (joystick_port[dev]) {
@@ -1780 +1761 @@
 
         default:
-                printk(KERN_ERR "ens1371: invalid joystick port %#x", joystick_port[dev]);
+                dev_err(ensoniq->card->dev,
+                        "invalid joystick port %#x", joystick_port[dev]);
                 return 0;
         }
 }
 #else
-static inline int snd_ensoniq_get_joystick_port(int dev)
+static int snd_ensoniq_get_joystick_port(struct ensoniq *ensoniq, int dev)
 {
         return joystick[dev] ? 0x200 : 0;
@@ -1791 +1773 @@
 #endif
 
-static int __devinit snd_ensoniq_create_gameport(struct ensoniq *ensoniq, int dev)
+static int snd_ensoniq_create_gameport(struct ensoniq *ensoniq, int dev)
 {
         struct gameport *gp;
         int io_port;
 
-        io_port = snd_ensoniq_get_joystick_port(dev);
+        io_port = snd_ensoniq_get_joystick_port(ensoniq, dev);
 
         switch (io_port) {
@@ -1807 +1789 @@
                                 break;
                 if (io_port > 0x218) {
-                        printk(KERN_WARNING "ens137x: no gameport ports available\n");
+                        dev_warn(ensoniq->card->dev,
+                                 "no gameport ports available\n");
                         return -EBUSY;
                 }
@@ -1814 +1797 @@
         default:
                 if (!request_region(io_port, 8, "ens137x: gameport")) {
-                        printk(KERN_WARNING "ens137x: gameport io port 0x%#x in use\n",
+                        dev_warn(ensoniq->card->dev,
+                                 "gameport io port %#x in use\n",
                                io_port);
                         return -EBUSY;
@@ -1823 +1807 @@
         ensoniq->gameport = gp = gameport_allocate_port();
         if (!gp) {
-                printk(KERN_ERR "ens137x: cannot allocate memory for gameport\n");
+                dev_err(ensoniq->card->dev,
+                        "cannot allocate memory for gameport\n");
                 release_region(io_port, 8);
                 return -ENOMEM;
@@ -1866 +1851 @@
  */
 
-static void snd_ensoniq_proc_read(struct snd_info_entry *entry,
+static void snd_ensoniq_proc_read(struct snd_info_entry *entry, 
                                   struct snd_info_buffer *buffer)
 {
         struct ensoniq *ensoniq = entry->private_data;
 
-#ifdef CHIP1370
-        snd_iprintf(buffer, "Ensoniq AudioPCI ES1370\n\n");
-#else
-        snd_iprintf(buffer, "Ensoniq AudioPCI ES1371\n\n");
-#endif
+        snd_iprintf(buffer, "Ensoniq AudioPCI " CHIP_NAME "\n\n");
         snd_iprintf(buffer, "Joystick enable  : %s\n",
                     ensoniq->ctrl & ES_JYSTK_EN ? "on" : "off");
@@ -1889 +1870 @@
 }
 
-static void __devinit snd_ensoniq_proc_init(struct ensoniq * ensoniq)
-{
-        struct snd_info_entry *entry;
-
-        if (! snd_card_proc_new(ensoniq->card, "audiopci", &entry))
-                snd_info_set_text_ops(entry, ensoniq, snd_ensoniq_proc_read);
+static void snd_ensoniq_proc_init(struct ensoniq *ensoniq)
+{
+        snd_card_ro_proc_new(ensoniq->card, "audiopci", ensoniq,
+                             snd_ensoniq_proc_read);
 }
 
@@ -1913 +1892 @@
         outl(0, ES_REG(ensoniq, SERIAL));       /* clear serial interface */
 #endif
-        if (ensoniq->irq >= 0)
-                synchronize_irq(ensoniq->irq);
-        pci_set_power_state(ensoniq->pci, 3);
+        pci_set_power_state(ensoniq->pci, PCI_D3hot);
       __hw_end:
 #ifdef CHIP1370
@@ -1936 +1913 @@
 
 #ifdef CHIP1371
-static struct snd_pci_quirk es1371_amplifier_hack[] __devinitdata = {
+static const struct snd_pci_quirk es1371_amplifier_hack[] = {
         SND_PCI_QUIRK_ID(0x107b, 0x2150),       /* Gateway Solo 2150 */
         SND_PCI_QUIRK_ID(0x13bd, 0x100c),       /* EV1938 on Mebius PC-MJ100V */
@@ -1944 +1921 @@
 };
 
-static struct es1371_quirk es1371_ac97_reset_hack[] = {
+static const struct es1371_quirk es1371_ac97_reset_hack[] = {
         { .vid = PCI_VENDOR_ID_ENSONIQ, .did = PCI_DEVICE_ID_ENSONIQ_CT5880, .rev = CT5880REV_CT5880_C },
         { .vid = PCI_VENDOR_ID_ENSONIQ, .did = PCI_DEVICE_ID_ENSONIQ_CT5880, .rev = CT5880REV_CT5880_D },
@@ -2015 +1992 @@
         outb(0x00, ES_REG(ensoniq, UART_RES));
         outl(ensoniq->cssr, ES_REG(ensoniq, STATUS));
-        synchronize_irq(ensoniq->irq);
-}
-
-#ifdef CONFIG_PM
-static int snd_ensoniq_suspend(struct pci_dev *pci, pm_message_t state)
-{
-        struct snd_card *card = pci_get_drvdata(pci);
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int snd_ensoniq_suspend(struct device *dev)
+{
+        struct snd_card *card = dev_get_drvdata(dev);
         struct ensoniq *ensoniq = card->private_data;
         
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
 
-        snd_pcm_suspend_all(ensoniq->pcm1);
-        snd_pcm_suspend_all(ensoniq->pcm2);
-        
 #ifdef CHIP1371 
         snd_ac97_suspend(ensoniq->u.es1371.ac97);
@@ -2041 +2014 @@
         snd_ak4531_suspend(ensoniq->u.es1370.ak4531);
 #endif  
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, pci_choose_state(pci, state));
-        return 0;
-}
-
-static int snd_ensoniq_resume(struct pci_dev *pci)
-{
-        struct snd_card *card = pci_get_drvdata(pci);
+        return 0;
+}
+
+static int snd_ensoniq_resume(struct device *dev)
+{
+        struct snd_card *card = dev_get_drvdata(dev);
         struct ensoniq *ensoniq = card->private_data;
-
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR DRIVER_NAME ": pci_enable_device failed, "
-                       "disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
 
         snd_ensoniq_chip_init(ensoniq);
@@ -2073 +2032 @@
         return 0;
 }
-#endif /* CONFIG_PM */
-
-
-static int __devinit snd_ensoniq_create(struct snd_card *card,
-                                     struct pci_dev *pci,
-                                     struct ensoniq ** rensoniq)
+
+static SIMPLE_DEV_PM_OPS(snd_ensoniq_pm, snd_ensoniq_suspend, snd_ensoniq_resume);
+#define SND_ENSONIQ_PM_OPS      &snd_ensoniq_pm
+#else
+#define SND_ENSONIQ_PM_OPS      NULL
+#endif /* CONFIG_PM_SLEEP */
+
+static int snd_ensoniq_create(struct snd_card *card,
+                              struct pci_dev *pci,
+                              struct ensoniq **rensoniq)
 {
         struct ensoniq *ensoniq;
         int err;
-        static struct snd_device_ops ops = {
+        static const struct snd_device_ops ops = {
                 .dev_free =     snd_ensoniq_dev_free,
         };
@@ -2106 +2069 @@
         ensoniq->port = pci_resource_start(pci, 0);
         if (request_irq(pci->irq, snd_audiopci_interrupt, IRQF_SHARED,
-                        "Ensoniq AudioPCI", ensoniq)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                        KBUILD_MODNAME, ensoniq)) {
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_ensoniq_free(ensoniq);
                 return -EBUSY;
         }
         ensoniq->irq = pci->irq;
-#ifdef CHIP1370
-        if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
+        card->sync_irq = ensoniq->irq;
+#ifdef CHIP1370
+        if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &pci->dev,
                                 16, &ensoniq->dma_bug) < 0) {
-                snd_printk(KERN_ERR "unable to allocate space for phantom area - dma_bug\n");
+                dev_err(card->dev, "unable to allocate space for phantom area - dma_bug\n");
                 snd_ensoniq_free(ensoniq);
                 return -EBUSY;
@@ -2153 +2117 @@
 
         snd_ensoniq_proc_init(ensoniq);
-
-        snd_card_set_dev(card, &pci->dev);
 
         *rensoniq = ensoniq;
@@ -2321 +2283 @@
 }
 
-static struct snd_rawmidi_ops snd_ensoniq_midi_output =
+static const struct snd_rawmidi_ops snd_ensoniq_midi_output =
 {
         .open =         snd_ensoniq_midi_output_open,
@@ -2328 +2290 @@
 };
 
-static struct snd_rawmidi_ops snd_ensoniq_midi_input =
+static const struct snd_rawmidi_ops snd_ensoniq_midi_input =
 {
         .open =         snd_ensoniq_midi_input_open,
@@ -2335 +2297 @@
 };
 
-static int __devinit snd_ensoniq_midi(struct ensoniq * ensoniq, int device,
-                                      struct snd_rawmidi **rrawmidi)
+static int snd_ensoniq_midi(struct ensoniq *ensoniq, int device)
 {
         struct snd_rawmidi *rmidi;
         int err;
 
-        if (rrawmidi)
-                *rrawmidi = NULL;
         if ((err = snd_rawmidi_new(ensoniq->card, "ES1370/1", device, 1, 1, &rmidi)) < 0)
                 return err;
-#ifdef CHIP1370
-        strcpy(rmidi->name, "ES1370");
-#else
-        strcpy(rmidi->name, "ES1371");
-#endif
+        strcpy(rmidi->name, CHIP_NAME);
         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_OUTPUT, &snd_ensoniq_midi_output);
         snd_rawmidi_set_ops(rmidi, SNDRV_RAWMIDI_STREAM_INPUT, &snd_ensoniq_midi_input);
@@ -2356 +2311 @@
         rmidi->private_data = ensoniq;
         ensoniq->rmidi = rmidi;
-        if (rrawmidi)
-                *rrawmidi = rmidi;
         return 0;
 }
@@ -2400 +2353 @@
 }
 
-static int __devinit snd_audiopci_probe(struct pci_dev *pci,
-                                        const struct pci_device_id *pci_id)
+static int snd_audiopci_probe(struct pci_dev *pci,
+                              const struct pci_device_id *pci_id)
 {
         static int dev;
         struct snd_card *card;
         struct ensoniq *ensoniq;
-        int err, pcm_devs[2];
+        int err;
 
         if (dev >= SNDRV_CARDS)
@@ -2415 +2368 @@
         }
 
-        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
+        err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
+                           0, &card);
         if (err < 0)
                 return err;
@@ -2425 +2379 @@
         card->private_data = ensoniq;
 
-        pcm_devs[0] = 0; pcm_devs[1] = 1;
 #ifdef CHIP1370
         if ((err = snd_ensoniq_1370_mixer(ensoniq)) < 0) {
@@ -2438 +2391 @@
         }
 #endif
-        if ((err = snd_ensoniq_pcm(ensoniq, 0, NULL)) < 0) {
+        if ((err = snd_ensoniq_pcm(ensoniq, 0)) < 0) {
                 snd_card_free(card);
                 return err;
         }
-        if ((err = snd_ensoniq_pcm2(ensoniq, 1, NULL)) < 0) {
+        if ((err = snd_ensoniq_pcm2(ensoniq, 1)) < 0) {
                 snd_card_free(card);
                 return err;
         }
-        if ((err = snd_ensoniq_midi(ensoniq, 0, NULL)) < 0) {
+        if ((err = snd_ensoniq_midi(ensoniq, 0)) < 0) {
                 snd_card_free(card);
                 return err;
@@ -2472 +2425 @@
 }
 
-static void __devexit snd_audiopci_remove(struct pci_dev *pci)
+static void snd_audiopci_remove(struct pci_dev *pci)
 {
         snd_card_free(pci_get_drvdata(pci));
-        pci_set_drvdata(pci, NULL);
-}
-
-static struct pci_driver driver = {
-        .name = DRIVER_NAME,
+}
+
+static struct pci_driver ens137x_driver = {
+        .name = KBUILD_MODNAME,
         .id_table = snd_audiopci_ids,
         .probe = snd_audiopci_probe,
-        .remove = __devexit_p(snd_audiopci_remove),
-#ifdef CONFIG_PM
-        .suspend = snd_ensoniq_suspend,
-        .resume = snd_ensoniq_resume,
-#endif
+        .remove = snd_audiopci_remove,
+        .driver = {
+                .pm = SND_ENSONIQ_PM_OPS,
+        },
 };
         
-#ifdef CHIP1370
-static int __init alsa_card_ens1370_init(void)
-{
-        return pci_register_driver(&driver);
-}
-
-static void __exit alsa_card_ens1370_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_ens1370_init)
-module_exit(alsa_card_ens1370_exit)
-#endif
-
-#ifdef CHIP1371
-static int __init alsa_card_ens1371_init(void)
-{
-        return pci_register_driver(&driver);
-}
-
-static void __exit alsa_card_ens1371_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-module_init(alsa_card_ens1371_init)
-module_exit(alsa_card_ens1371_exit)
-#endif
-
-
+module_pci_driver(ens137x_driver);