Changeset 679 for GPL/trunk/alsa-kernel/pci/es1938.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/es1938.c (modified) (50 diffs)

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

@@ +1 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
 /*
  *  Driver for ESS Solo-1 (ES1938, ES1946, ES1969) soundcard
@@ -11 +12 @@
  *  TODO:
  *    Rewrite better spinlocks
- *
- *
- *   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
- *
  */
 
@@ -47 +32 @@
 */
 
+#ifdef TARGET_OS2
+#define KBUILD_MODNAME "es1938"
+#endif
 
 #include <linux/init.h>
@@ -53 +41 @@
 #include <linux/slab.h>
 #include <linux/gameport.h>
-#include <linux/moduleparam.h>
+#include <linux/module.h>
 #include <linux/delay.h>
 #include <linux/dma-mapping.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/control.h>
@@ -64 +53 @@
 #include <sound/tlv.h>
 
-#include <asm/io.h>
-
 MODULE_AUTHOR("Jaromir Koutek <miri@punknet.cz>");
 MODULE_DESCRIPTION("ESS Solo-1");
@@ -74 +61 @@
                 "{TerraTec,128i PCI}}");
 
-#if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
+#if IS_REACHABLE(CONFIG_GAMEPORT)
 #define SUPPORT_JOYSTICK 1
 #endif
@@ -80 +67 @@
 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 this card */
+static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;     /* Enable this card */
 
 module_param_array(index, int, NULL, 0444);
@@ -237 +224 @@
         struct gameport *gameport;
 #endif
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
         unsigned char saved_regs[SAVED_REG_SIZE];
 #endif
@@ -244 +231 @@
 static irqreturn_t snd_es1938_interrupt(int irq, void *dev_id);
 
-static DEFINE_PCI_DEVICE_TABLE(snd_es1938_ids) = {
+static const struct pci_device_id snd_es1938_ids[] = {
         { PCI_VDEVICE(ESS, 0x1969), 0, },   /* Solo-1 */
         { 0, }
@@ -255 +242 @@
 #define GET_LOOP_TIMEOUT        0x01000
 
-#undef REG_DEBUG
 /* -----------------------------------------------------------------
  * Write to a mixer register
@@ -266 +252 @@
         outb(val, SLSB_REG(chip, MIXERDATA));
         spin_unlock_irqrestore(&chip->mixer_lock, flags);
-#ifdef REG_DEBUG
-        snd_printk(KERN_DEBUG "Mixer reg %02x set to %02x\n", reg, val);
-#endif
+        dev_dbg(chip->card->dev, "Mixer reg %02x set to %02x\n", reg, val);
 }
 
@@ -282 +266 @@
         data = inb(SLSB_REG(chip, MIXERDATA));
         spin_unlock_irqrestore(&chip->mixer_lock, flags);
-#ifdef REG_DEBUG
-        snd_printk(KERN_DEBUG "Mixer reg %02x now is %02x\n", reg, data);
-#endif
+        dev_dbg(chip->card->dev, "Mixer reg %02x now is %02x\n", reg, data);
         return data;
 }
@@ -303 +285 @@
                 new = (old & ~mask) | (val & mask);
                 outb(new, SLSB_REG(chip, MIXERDATA));
-#ifdef REG_DEBUG
-                snd_printk(KERN_DEBUG "Mixer reg %02x was %02x, set to %02x\n",
+                dev_dbg(chip->card->dev,
+                        "Mixer reg %02x was %02x, set to %02x\n",
                            reg, old, new);
-#endif
         }
         spin_unlock_irqrestore(&chip->mixer_lock, flags);
@@ -325 +306 @@
                 }
         }
-        printk(KERN_ERR "snd_es1938_write_cmd timeout (0x02%x/0x02%x)\n", cmd, v);
+        dev_err(chip->card->dev,
+                "snd_es1938_write_cmd timeout (0x02%x/0x02%x)\n", cmd, v);
 }
 
@@ -338 +320 @@
                 if ((v = inb(SLSB_REG(chip, STATUS))) & 0x80)
                         return inb(SLSB_REG(chip, READDATA));
-        snd_printk(KERN_ERR "get_byte timeout: status 0x02%x\n", v);
+        dev_err(chip->card->dev, "get_byte timeout: status 0x02%x\n", v);
         return -ENODEV;
 }
@@ -352 +334 @@
         snd_es1938_write_cmd(chip, val);
         spin_unlock_irqrestore(&chip->reg_lock, flags);
-#ifdef REG_DEBUG
-        snd_printk(KERN_DEBUG "Reg %02x set to %02x\n", reg, val);
-#endif
+        dev_dbg(chip->card->dev, "Reg %02x set to %02x\n", reg, val);
 }
 
@@ -369 +349 @@
         val = snd_es1938_get_byte(chip);
         spin_unlock_irqrestore(&chip->reg_lock, flags);
-#ifdef REG_DEBUG
-        snd_printk(KERN_DEBUG "Reg %02x now is %02x\n", reg, val);
-#endif
+        dev_dbg(chip->card->dev, "Reg %02x now is %02x\n", reg, val);
         return val;
 }
@@ -392 +370 @@
                 new = (old & ~mask) | (val & mask);
                 snd_es1938_write_cmd(chip, new);
-#ifdef REG_DEBUG
-                snd_printk(KERN_DEBUG "Reg %02x was %02x, set to %02x\n",
+                dev_dbg(chip->card->dev, "Reg %02x was %02x, set to %02x\n",
                            reg, old, new);
-#endif
         }
         spin_unlock_irqrestore(&chip->reg_lock, flags);
@@ -417 +393 @@
                 }
         }
-        snd_printk(KERN_ERR "ESS Solo-1 reset failed\n");
+        dev_err(chip->card->dev, "ESS Solo-1 reset failed\n");
 
      __next:
@@ -449 +425 @@
 }
 
-static struct snd_ratnum clocks[2] = {
+static const struct snd_ratnum clocks[2] = {
         {
                 .num = 793800,
@@ -464 +440 @@
 };
 
-static struct snd_pcm_hw_constraint_ratnums hw_constraints_clocks = {
+static const struct snd_pcm_hw_constraint_ratnums hw_constraints_clocks = {
         .nrats = 2,
         .rats = clocks,
@@ -852 +828 @@
 
 static int snd_es1938_capture_copy(struct snd_pcm_substream *substream,
-                                   int channel,
-                                   snd_pcm_uframes_t pos,
-                                   void __user *dst,
-                                   snd_pcm_uframes_t count)
+                                   int channel, unsigned long pos,
+                                   void __user *dst, unsigned long count)
 {
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct es1938 *chip = snd_pcm_substream_chip(substream);
-        pos <<= chip->dma1_shift;
-        count <<= chip->dma1_shift;
+
         if (snd_BUG_ON(pos + count > chip->dma1_size))
                 return -EINVAL;
@@ -869 +842 @@
                 if (copy_to_user(dst, runtime->dma_area + pos + 1, count - 1))
                         return -EFAULT;
-                if (put_user(runtime->dma_area[0], ((unsigned char __user *)dst) + count - 1))
+                if (put_user(runtime->dma_area[0],
+                             ((unsigned char __user *)dst) + count - 1))
                         return -EFAULT;
         }
@@ -875 +849 @@
 }
 
-/*
- * buffer management
- */
-static int snd_es1938_pcm_hw_params(struct snd_pcm_substream *substream,
-                                    struct snd_pcm_hw_params *hw_params)
-
-{
-        int err;
-
-        if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
-                return err;
-        return 0;
-}
-
-static int snd_es1938_pcm_hw_free(struct snd_pcm_substream *substream)
-{
-        return snd_pcm_lib_free_pages(substream);
+static int snd_es1938_capture_copy_kernel(struct snd_pcm_substream *substream,
+                                          int channel, unsigned long pos,
+                                          void *dst, unsigned long count)
+{
+        struct snd_pcm_runtime *runtime = substream->runtime;
+        struct es1938 *chip = snd_pcm_substream_chip(substream);
+
+        if (snd_BUG_ON(pos + count > chip->dma1_size))
+                return -EINVAL;
+        if (pos + count < chip->dma1_size) {
+                memcpy(dst, runtime->dma_area + pos + 1, count);
+        } else {
+                memcpy(dst, runtime->dma_area + pos + 1, count - 1);
+                runtime->dma_area[0] = *((unsigned char *)dst + count - 1);
+        }
+        return 0;
 }
 
@@ -897 +870 @@
  * Audio1 Capture (ADC)
  * ----------------------------------------------------------------------*/
-static struct snd_pcm_hardware snd_es1938_capture =
+static const struct snd_pcm_hardware snd_es1938_capture =
 {
         .info =                 (SNDRV_PCM_INFO_INTERLEAVED |
@@ -919 +892 @@
  * Audio2 Playback (DAC)
  * -----------------------------------------------------------------------*/
-static struct snd_pcm_hardware snd_es1938_playback =
+static const struct snd_pcm_hardware snd_es1938_playback =
 {
         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
@@ -1005 +978 @@
 }
 
-static struct snd_pcm_ops snd_es1938_playback_ops = {
+static const struct snd_pcm_ops snd_es1938_playback_ops = {
         .open =         snd_es1938_playback_open,
         .close =        snd_es1938_playback_close,
-        .ioctl =        snd_pcm_lib_ioctl,
-        .hw_params =    snd_es1938_pcm_hw_params,
-        .hw_free =      snd_es1938_pcm_hw_free,
         .prepare =      snd_es1938_playback_prepare,
         .trigger =      snd_es1938_playback_trigger,
@@ -1016 +986 @@
 };
 
-static struct snd_pcm_ops snd_es1938_capture_ops = {
+static const struct snd_pcm_ops snd_es1938_capture_ops = {
         .open =         snd_es1938_capture_open,
         .close =        snd_es1938_capture_close,
-        .ioctl =        snd_pcm_lib_ioctl,
-        .hw_params =    snd_es1938_pcm_hw_params,
-        .hw_free =      snd_es1938_pcm_hw_free,
         .prepare =      snd_es1938_capture_prepare,
         .trigger =      snd_es1938_capture_trigger,
         .pointer =      snd_es1938_capture_pointer,
-        .copy =         snd_es1938_capture_copy,
+        .copy_user =    snd_es1938_capture_copy,
+        .copy_kernel =  snd_es1938_capture_copy_kernel,
 };
 
-static int __devinit snd_es1938_new_pcm(struct es1938 *chip, int device)
+static int snd_es1938_new_pcm(struct es1938 *chip, int device)
 {
         struct snd_pcm *pcm;
@@ -1042 +1010 @@
         strcpy(pcm->name, "ESS Solo-1");
 
-        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                              snd_dma_pci_data(chip->pci), 64*1024, 64*1024);
+        snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                       &chip->pci->dev, 64*1024, 64*1024);
 
         chip->pcm = pcm;
@@ -1057 +1025 @@
                                struct snd_ctl_elem_info *uinfo)
 {
-        static char *texts[8] = {
+        static const char * const texts[8] = {
                 "Mic", "Mic Master", "CD", "AOUT",
                 "Mic1", "Mix", "Line", "Master"
         };
 
-        uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
-        uinfo->count = 1;
-        uinfo->value.enumerated.items = 8;
-        if (uinfo->value.enumerated.item > 7)
-                uinfo->value.enumerated.item = 7;
-        strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
-        return 0;
+        return snd_ctl_enum_info(uinfo, 1, 8, texts);
 }
 
@@ -1322 +1284 @@
 }
 
+#ifndef TARGET_OS2
+static const DECLARE_TLV_DB_RANGE(db_scale_master,
+        0, 54, TLV_DB_SCALE_ITEM(-3600, 50, 1),
+        54, 63, TLV_DB_SCALE_ITEM(-900, 100, 0),
+);
+
+static const DECLARE_TLV_DB_RANGE(db_scale_audio1,
+        0, 8, TLV_DB_SCALE_ITEM(-3300, 300, 1),
+        8, 15, TLV_DB_SCALE_ITEM(-900, 150, 0),
+);
+
+static const DECLARE_TLV_DB_RANGE(db_scale_audio2,
+        0, 8, TLV_DB_SCALE_ITEM(-3450, 300, 1),
+        8, 15, TLV_DB_SCALE_ITEM(-1050, 150, 0),
+);
+
+static const DECLARE_TLV_DB_RANGE(db_scale_mic,
+        0, 8, TLV_DB_SCALE_ITEM(-2400, 300, 1),
+        8, 15, TLV_DB_SCALE_ITEM(0, 150, 0),
+);
+
+static const DECLARE_TLV_DB_RANGE(db_scale_line,
+        0, 8, TLV_DB_SCALE_ITEM(-3150, 300, 1),
+        8, 15, TLV_DB_SCALE_ITEM(-750, 150, 0),
+);
+#else
 static unsigned int db_scale_master[] = {
         TLV_DB_RANGE_HEAD(2),
@@ -1351 +1339 @@
         8, 15, TLV_DB_SCALE_ITEM(-750, 150, 0),
 };
+#endif
 
 static const DECLARE_TLV_DB_SCALE(db_scale_capture, 0, 150, 0);
 
-static struct snd_kcontrol_new snd_es1938_controls[] = {
+static const struct snd_kcontrol_new snd_es1938_controls[] = {
 ES1938_DOUBLE_TLV("Master Playback Volume", 0, 0x60, 0x62, 0, 0, 63, 0,
                   db_scale_master),
@@ -1462 +1451 @@
 }
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 /*
  * PM support
  */
 
-static unsigned char saved_regs[SAVED_REG_SIZE+1] = {
+static const unsigned char saved_regs[SAVED_REG_SIZE+1] = {
         0x14, 0x1a, 0x1c, 0x3a, 0x3c, 0x3e, 0x36, 0x38,
         0x50, 0x52, 0x60, 0x61, 0x62, 0x63, 0x64, 0x68,
@@ -1475 +1464 @@
 
 
-static int es1938_suspend(struct pci_dev *pci, pm_message_t state)
-{
-        struct snd_card *card = pci_get_drvdata(pci);
+static int es1938_suspend(struct device *dev)
+{
+        struct snd_card *card = dev_get_drvdata(dev);
         struct es1938 *chip = card->private_data;
-        unsigned char *s, *d;
+        const unsigned char *s;
+        unsigned char *d;
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        snd_pcm_suspend_all(chip->pcm);
 
         /* save mixer-related registers */
@@ -1492 +1481 @@
                 free_irq(chip->irq, chip);
                 chip->irq = -1;
-        }
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, pci_choose_state(pci, state));
-        return 0;
-}
-
-static int es1938_resume(struct pci_dev *pci)
-{
-        struct snd_card *card = pci_get_drvdata(pci);
+                card->sync_irq = -1;
+        }
+        return 0;
+}
+
+static int es1938_resume(struct device *dev)
+{
+        struct pci_dev *pci = to_pci_dev(dev);
+        struct snd_card *card = dev_get_drvdata(dev);
         struct es1938 *chip = card->private_data;
-        unsigned char *s, *d;
-
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "es1938: pci_enable_device failed, "
-                       "disabling device\n");
+        const unsigned char *s;
+        unsigned char *d;
+
+        if (request_irq(pci->irq, snd_es1938_interrupt,
+                        IRQF_SHARED, KBUILD_MODNAME, chip)) {
+                dev_err(dev, "unable to grab IRQ %d, disabling device\n",
+                        pci->irq);
                 snd_card_disconnect(card);
                 return -EIO;
         }
-
-        if (request_irq(pci->irq, snd_es1938_interrupt,
-                        IRQF_SHARED, "ES1938", chip)) {
-                printk(KERN_ERR "es1938: unable to grab IRQ %d, "
-                       "disabling device\n", pci->irq);
-                snd_card_disconnect(card);
-                return -EIO;
-        }
         chip->irq = pci->irq;
+        card->sync_irq = chip->irq;
         snd_es1938_chip_init(chip);
 
@@ -1535 +1516 @@
         return 0;
 }
-#endif /* CONFIG_PM */
+
+static SIMPLE_DEV_PM_OPS(es1938_pm, es1938_suspend, es1938_resume);
+#define ES1938_PM_OPS   &es1938_pm
+#else
+#define ES1938_PM_OPS   NULL
+#endif /* CONFIG_PM_SLEEP */
 
 #ifdef SUPPORT_JOYSTICK
-static int __devinit snd_es1938_create_gameport(struct es1938 *chip)
+static int snd_es1938_create_gameport(struct es1938 *chip)
 {
         struct gameport *gp;
@@ -1544 +1530 @@
         chip->gameport = gp = gameport_allocate_port();
         if (!gp) {
-                printk(KERN_ERR "es1938: cannot allocate memory for gameport\n");
+                dev_err(chip->card->dev,
+                        "cannot allocate memory for gameport\n");
                 return -ENOMEM;
         }
@@ -1593 +1580 @@
 }
 
-static int __devinit snd_es1938_create(struct snd_card *card,
-                                    struct pci_dev * pci,
-                                    struct es1938 ** rchip)
+static int snd_es1938_create(struct snd_card *card,
+                             struct pci_dev *pci,
+                             struct es1938 **rchip)
 {
         struct es1938 *chip;
         int err;
-        static struct snd_device_ops ops = {
+        static const struct snd_device_ops ops = {
                 .dev_free =     snd_es1938_dev_free,
         };
@@ -1609 +1596 @@
                 return err;
         /* check, if we can restrict PCI DMA transfers to 24 bits */
-        if (pci_set_dma_mask(pci, DMA_BIT_MASK(24)) < 0 ||
-            pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(24)) < 0) {
-                snd_printk(KERN_ERR "architecture does not support 24bit PCI busmaster DMA\n");
+        if (dma_set_mask(&pci->dev, DMA_BIT_MASK(24)) < 0 ||
+            dma_set_coherent_mask(&pci->dev, DMA_BIT_MASK(24)) < 0) {
+                dev_err(card->dev,
+                        "architecture does not support 24bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
@@ -1637 +1625 @@
         chip->game_port = pci_resource_start(pci, 4);
         if (request_irq(pci->irq, snd_es1938_interrupt, IRQF_SHARED,
-                        "ES1938", chip)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                        KBUILD_MODNAME, chip)) {
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_es1938_free(chip);
                 return -EBUSY;
         }
         chip->irq = pci->irq;
-#ifdef ES1938_DDEBUG
-        snd_printk(KERN_DEBUG "create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n",
+        card->sync_irq = chip->irq;
+        dev_dbg(card->dev,
+                "create: io: 0x%lx, sb: 0x%lx, vc: 0x%lx, mpu: 0x%lx, game: 0x%lx\n",
                    chip->io_port, chip->sb_port, chip->vc_port, chip->mpu_port, chip->game_port);
-#endif
 
         chip->ddma_port = chip->vc_port + 0x00;         /* fix from Thomas Sailer */
@@ -1656 +1644 @@
                 return err;
         }
-
-        snd_card_set_dev(card, &pci->dev);
 
         *rchip = chip;
@@ -1669 +1655 @@
 {
         struct es1938 *chip = dev_id;
-        unsigned char status, audiostatus;
+        unsigned char status;
+        __always_unused unsigned char audiostatus;
         int handled = 0;
 
         status = inb(SLIO_REG(chip, IRQCONTROL));
 #if 0
-        printk(KERN_DEBUG "Es1938debug - interrupt status: =0x%x\n", status);
+        dev_dbg(chip->card->dev,
+                "Es1938debug - interrupt status: =0x%x\n", status);
 #endif
         
@@ -1680 +1668 @@
         if (status & 0x10) {
 #if 0
-                printk(KERN_DEBUG
+                dev_dbg(chip->card->dev,
                        "Es1938debug - AUDIO channel 1 interrupt\n");
-                printk(KERN_DEBUG
+                dev_dbg(chip->card->dev,
                        "Es1938debug - AUDIO channel 1 DMAC DMA count: %u\n",
                        inw(SLDM_REG(chip, DMACOUNT)));
-                printk(KERN_DEBUG
+                dev_dbg(chip->card->dev,
                        "Es1938debug - AUDIO channel 1 DMAC DMA base: %u\n",
                        inl(SLDM_REG(chip, DMAADDR)));
-                printk(KERN_DEBUG
+                dev_dbg(chip->card->dev,
                        "Es1938debug - AUDIO channel 1 DMAC DMA status: 0x%x\n",
                        inl(SLDM_REG(chip, DMASTATUS)));
@@ -1704 +1692 @@
         if (status & 0x20) {
 #if 0
-                printk(KERN_DEBUG
+                dev_dbg(chip->card->dev,
                        "Es1938debug - AUDIO channel 2 interrupt\n");
-                printk(KERN_DEBUG
+                dev_dbg(chip->card->dev,
                        "Es1938debug - AUDIO channel 2 DMAC DMA count: %u\n",
                        inw(SLIO_REG(chip, AUDIO2DMACOUNT)));
-                printk(KERN_DEBUG
+                dev_dbg(chip->card->dev,
                        "Es1938debug - AUDIO channel 2 DMAC DMA base: %u\n",
                        inl(SLIO_REG(chip, AUDIO2DMAADDR)));
@@ -1753 +1741 @@
 #define ES1938_DMA_SIZE 64
 
-static int __devinit snd_es1938_mixer(struct es1938 *chip)
+static int snd_es1938_mixer(struct es1938 *chip)
 {
         struct snd_card *card;
@@ -1791 +1779 @@
        
 
-static int __devinit snd_es1938_probe(struct pci_dev *pci,
-                                      const struct pci_device_id *pci_id)
+static int snd_es1938_probe(struct pci_dev *pci,
+                            const struct pci_device_id *pci_id)
 {
         static int dev;
@@ -1807 +1795 @@
         }
 
-        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;
@@ -1842 +1831 @@
                             SLSB_REG(chip, FMHIGHADDR),
                             OPL3_HW_OPL3, 1, &opl3) < 0) {
-                printk(KERN_ERR "es1938: OPL3 not detected at 0x%lx\n",
+                dev_err(card->dev, "OPL3 not detected at 0x%lx\n",
                            SLSB_REG(chip, FMLOWADDR));
         } else {
@@ -1855 +1844 @@
         }
         if (snd_mpu401_uart_new(card, 0, MPU401_HW_MPU401,
-                                chip->mpu_port, MPU401_INFO_INTEGRATED,
-                                chip->irq, 0, &chip->rmidi) < 0) {
-                printk(KERN_ERR "es1938: unable to initialize MPU-401\n");
+                                chip->mpu_port,
+                                MPU401_INFO_INTEGRATED | MPU401_INFO_IRQ_HOOK,
+                                -1, &chip->rmidi) < 0) {
+                dev_err(card->dev, "unable to initialize MPU-401\n");
         } else {
                 // this line is vital for MIDI interrupt handling on ess-solo1
@@ -1876 +1866 @@
 }
 
-static void __devexit snd_es1938_remove(struct pci_dev *pci)
+static void snd_es1938_remove(struct pci_dev *pci)
 {
         snd_card_free(pci_get_drvdata(pci));
-        pci_set_drvdata(pci, NULL);
-}
-
-static struct pci_driver driver = {
-        .name = "ESS ES1938 (Solo-1)",
+}
+
+static struct pci_driver es1938_driver = {
+        .name = KBUILD_MODNAME,
         .id_table = snd_es1938_ids,
         .probe = snd_es1938_probe,
-        .remove = __devexit_p(snd_es1938_remove),
-#ifdef CONFIG_PM
-        .suspend = es1938_suspend,
-        .resume = es1938_resume,
-#endif
+        .remove = snd_es1938_remove,
+        .driver = {
+                .pm = ES1938_PM_OPS,
+        },
 };
 
-static int __init alsa_card_es1938_init(void)
-{
-        return pci_register_driver(&driver);
-}
-
-static void __exit alsa_card_es1938_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-
-module_init(alsa_card_es1938_init)
-module_exit(alsa_card_es1938_exit)
+module_pci_driver(es1938_driver);