111 files changed, 870 insertions, 1219 deletions

diff --git a/sound/pci/Kconfig b/sound/pci/Kconfig
index 50dd0086cfb1..edfc1b8d553e 100644
--- a/sound/pci/Kconfig
+++ b/sound/pci/Kconfig
@@ -793,6 +793,15 @@ config SND_RME9652
           To compile this driver as a module, choose M here: the module
           will be called snd-rme9652.
 
+config SND_SE6X
+        tristate "Studio Evolution SE6X"
+        depends on SND_OXYGEN=n && SND_VIRTUOSO=n  # PCI ID conflict
+        select SND_OXYGEN_LIB
+        select SND_PCM
+        select SND_MPU401_UART
+        help
+          Say Y or M here only if you actually have this sound card.
+
 config SND_SIS7019
         tristate "SiS 7019 Audio Accelerator"
         depends on X86_32
diff --git a/sound/pci/ad1889.c b/sound/pci/ad1889.c
index 1610c38337af..850a8c984c25 100644
--- a/sound/pci/ad1889.c
+++ b/sound/pci/ad1889.c
@@ -40,14 +40,13 @@
 #include <linux/compiler.h>
 #include <linux/delay.h>
 #include <linux/module.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/initval.h>
 #include <sound/ac97_codec.h>
 
-#include <asm/io.h>
-
 #include "ad1889.h"
 #include "ac97/ac97_id.h"
 
@@ -623,14 +622,11 @@ snd_ad1889_interrupt(int irq, void *dev_id)
 }
 
 static int
-snd_ad1889_pcm_init(struct snd_ad1889 *chip, int device, struct snd_pcm **rpcm)
+snd_ad1889_pcm_init(struct snd_ad1889 *chip, int device)
 {
         int err;
         struct snd_pcm *pcm;
 
-        if (rpcm)
-                *rpcm = NULL;
-
         err = snd_pcm_new(chip->card, chip->card->driver, device, 1, 1, &pcm);
         if (err < 0)
                 return err;
@@ -658,9 +654,6 @@ snd_ad1889_pcm_init(struct snd_ad1889 *chip, int device, struct snd_pcm **rpcm)
                 return err;
         }
         
-        if (rpcm)
-                *rpcm = pcm;
-        
         return 0;
 }
 
@@ -859,12 +852,9 @@ snd_ad1889_free(struct snd_ad1889 *chip)
                 free_irq(chip->irq, chip);
 
 skip_hw:
-        if (chip->iobase)
-                iounmap(chip->iobase);
-
+        iounmap(chip->iobase);
         pci_release_regions(chip->pci);
         pci_disable_device(chip->pci);
-
         kfree(chip);
         return 0;
 }
@@ -1016,7 +1006,7 @@ snd_ad1889_probe(struct pci_dev *pci,
         if (err < 0)
                 goto free_and_ret;
         
-        err = snd_ad1889_pcm_init(chip, 0, NULL);
+        err = snd_ad1889_pcm_init(chip, 0);
         if (err < 0)
                 goto free_and_ret;
 
diff --git a/sound/pci/ali5451/ali5451.c b/sound/pci/ali5451/ali5451.c
index af89e42b2160..c8d499575c01 100644
--- a/sound/pci/ali5451/ali5451.c
+++ b/sound/pci/ali5451/ali5451.c
@@ -25,7 +25,7 @@
  *
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -1873,7 +1873,6 @@ static int snd_ali_mixer(struct snd_ali *codec)
 #ifdef CONFIG_PM_SLEEP
 static int ali_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_ali *chip = card->private_data;
         struct snd_ali_image *im;
@@ -1914,16 +1913,11 @@ static int ali_suspend(struct device *dev)
         outl(0xffffffff, ALI_REG(chip, ALI_STOP));
 
         spin_unlock_irq(&chip->reg_lock);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int ali_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_ali *chip = card->private_data;
         struct snd_ali_image *im;
@@ -1933,15 +1927,6 @@ static int ali_resume(struct device *dev)
         if (!im)
                 return 0;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         spin_lock_irq(&chip->reg_lock);
         
         for (i = 0; i < ALI_CHANNELS; i++) {
diff --git a/sound/pci/als300.c b/sound/pci/als300.c
index 7bb6ac565107..57e034f208dc 100644
--- a/sound/pci/als300.c
+++ b/sound/pci/als300.c
@@ -37,8 +37,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/interrupt.h>
 #include <linux/slab.h>
-
-#include <asm/io.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/control.h>
@@ -728,35 +727,20 @@ static int snd_als300_create(struct snd_card *card,
 #ifdef CONFIG_PM_SLEEP
 static int snd_als300_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_als300 *chip = card->private_data;
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
         snd_pcm_suspend_all(chip->pcm);
         snd_ac97_suspend(chip->ac97);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_als300_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_als300 *chip = card->private_data;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_als300_init(chip);
         snd_ac97_resume(chip->ac97);
 
diff --git a/sound/pci/als4000.c b/sound/pci/als4000.c
index d3e6424ee656..a3dea464134d 100644
--- a/sound/pci/als4000.c
+++ b/sound/pci/als4000.c
@@ -65,7 +65,7 @@
  * - power management? (card can do voice wakeup according to datasheet!!)
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/init.h>
 #include <linux/pci.h>
 #include <linux/gameport.h>
@@ -988,7 +988,6 @@ static void snd_card_als4000_remove(struct pci_dev *pci)
 #ifdef CONFIG_PM_SLEEP
 static int snd_als4000_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_card_als4000 *acard = card->private_data;
         struct snd_sb *chip = acard->chip;
@@ -997,29 +996,15 @@ static int snd_als4000_suspend(struct device *dev)
         
         snd_pcm_suspend_all(chip->pcm);
         snd_sbmixer_suspend(chip);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_als4000_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_card_als4000 *acard = card->private_data;
         struct snd_sb *chip = acard->chip;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_als4000_configure(chip);
         snd_sbdsp_reset(chip);
         snd_sbmixer_resume(chip);
diff --git a/sound/pci/asihpi/asihpi.c b/sound/pci/asihpi/asihpi.c
index e9273fb2a505..e5cd7be85355 100644
--- a/sound/pci/asihpi/asihpi.c
+++ b/sound/pci/asihpi/asihpi.c
@@ -540,9 +540,8 @@ static void snd_card_asihpi_pcm_timer_start(struct snd_pcm_substream *
         expiry = HZ / 200;
 
         expiry = max(expiry, 1); /* don't let it be zero! */
-        dpcm->timer.expires = jiffies + expiry;
+        mod_timer(&dpcm->timer, jiffies + expiry);
         dpcm->respawn_timer = 1;
-        add_timer(&dpcm->timer);
 }
 
 static void snd_card_asihpi_pcm_timer_stop(struct snd_pcm_substream *substream)
@@ -1064,9 +1063,8 @@ static int snd_card_asihpi_playback_open(struct snd_pcm_substream *substream)
             If internal and other stream playing, can't switch
         */
 
-        init_timer(&dpcm->timer);
-        dpcm->timer.data = (unsigned long) dpcm;
-        dpcm->timer.function = snd_card_asihpi_timer_function;
+        setup_timer(&dpcm->timer, snd_card_asihpi_timer_function,
+                    (unsigned long) dpcm);
         dpcm->substream = substream;
         runtime->private_data = dpcm;
         runtime->private_free = snd_card_asihpi_runtime_free;
@@ -1246,9 +1244,8 @@ static int snd_card_asihpi_capture_open(struct snd_pcm_substream *substream)
         if (err)
                 return -EIO;
 
-        init_timer(&dpcm->timer);
-        dpcm->timer.data = (unsigned long) dpcm;
-        dpcm->timer.function = snd_card_asihpi_timer_function;
+        setup_timer(&dpcm->timer, snd_card_asihpi_timer_function,
+                    (unsigned long) dpcm);
         dpcm->substream = substream;
         runtime->private_data = dpcm;
         runtime->private_free = snd_card_asihpi_runtime_free;
@@ -2832,14 +2829,11 @@ static int snd_asihpi_hpi_ioctl(struct snd_hwdep *hw, struct file *file,
 /* results in /dev/snd/hwC#D0 file for each card with index #
    also /proc/asound/hwdep will contain '#-00: asihpi (HPI) for each card'
 */
-static int snd_asihpi_hpi_new(struct snd_card_asihpi *asihpi,
-                              int device, struct snd_hwdep **rhwdep)
+static int snd_asihpi_hpi_new(struct snd_card_asihpi *asihpi, int device)
 {
         struct snd_hwdep *hw;
         int err;
 
-        if (rhwdep)
-                *rhwdep = NULL;
         err = snd_hwdep_new(asihpi->card, "HPI", device, &hw);
         if (err < 0)
                 return err;
@@ -2849,8 +2843,6 @@ static int snd_asihpi_hpi_new(struct snd_card_asihpi *asihpi,
         hw->ops.ioctl = snd_asihpi_hpi_ioctl;
         hw->ops.release = snd_asihpi_hpi_release;
         hw->private_data = asihpi;
-        if (rhwdep)
-                *rhwdep = hw;
         return 0;
 }
 
@@ -2993,7 +2985,7 @@ static int snd_asihpi_probe(struct pci_dev *pci_dev,
 
         /* always create, can be enabled or disabled dynamically
             by enable_hwdep  module param*/
-        snd_asihpi_hpi_new(asihpi, 0, NULL);
+        snd_asihpi_hpi_new(asihpi, 0);
 
         strcpy(card->driver, "ASIHPI");
 
diff --git a/sound/pci/asihpi/hpi6000.c b/sound/pci/asihpi/hpi6000.c
index 2414d7a2239d..2d6364825d4d 100644
--- a/sound/pci/asihpi/hpi6000.c
+++ b/sound/pci/asihpi/hpi6000.c
@@ -47,7 +47,7 @@
 
 /* operational/messaging errors */
 #define HPI6000_ERROR_MSG_RESP_IDLE_TIMEOUT             901
-
+#define HPI6000_ERROR_RESP_GET_LEN                      902
 #define HPI6000_ERROR_MSG_RESP_GET_RESP_ACK             903
 #define HPI6000_ERROR_MSG_GET_ADR                       904
 #define HPI6000_ERROR_RESP_GET_ADR                      905
@@ -1365,7 +1365,10 @@ static short hpi6000_message_response_sequence(struct hpi_adapter_obj *pao,
                 length = hpi_read_word(pdo, HPI_HIF_ADDR(length));
         } while (hpi6000_check_PCI2040_error_flag(pao, H6READ) && --timeout);
         if (!timeout)
-                length = sizeof(struct hpi_response);
+                return HPI6000_ERROR_RESP_GET_LEN;
+
+        if (length > phr->size)
+                return HPI_ERROR_RESPONSE_BUFFER_TOO_SMALL;
 
         /* get the response */
         p_data = (u32 *)phr;
diff --git a/sound/pci/asihpi/hpioctl.c b/sound/pci/asihpi/hpioctl.c
index 6aa677e60555..6610bd096fc9 100644
--- a/sound/pci/asihpi/hpioctl.c
+++ b/sound/pci/asihpi/hpioctl.c
@@ -28,7 +28,7 @@
 #include <linux/interrupt.h>
 #include <linux/slab.h>
 #include <linux/moduleparam.h>
-#include <asm/uaccess.h>
+#include <linux/uaccess.h>
 #include <linux/pci.h>
 #include <linux/stringify.h>
 #include <linux/module.h>
@@ -153,6 +153,8 @@ long asihpi_hpi_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                 goto out;
         }
 
+        res_max_size = min_t(size_t, res_max_size, sizeof(*hr));
+
         switch (hm->h.function) {
         case HPI_SUBSYS_CREATE_ADAPTER:
         case HPI_ADAPTER_DELETE:
@@ -539,10 +541,8 @@ void asihpi_adapter_remove(struct pci_dev *pci_dev)
         hpi_send_recv_ex(&hm, &hr, HOWNER_KERNEL);
 
         /* unmap PCI memory space, mapped during device init. */
-        for (idx = 0; idx < HPI_MAX_ADAPTER_MEM_SPACES; idx++) {
-                if (pci.ap_mem_base[idx])
-                        iounmap(pci.ap_mem_base[idx]);
-        }
+        for (idx = 0; idx < HPI_MAX_ADAPTER_MEM_SPACES; ++idx)
+                iounmap(pci.ap_mem_base[idx]);
 
         if (pa->irq)
                 free_irq(pa->irq, pa);
diff --git a/sound/pci/atiixp.c b/sound/pci/atiixp.c
index 9c1c4452a8ee..d5f15c9bbeda 100644
--- a/sound/pci/atiixp.c
+++ b/sound/pci/atiixp.c
@@ -19,7 +19,7 @@
  *
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -1474,7 +1474,6 @@ static int snd_atiixp_mixer_new(struct atiixp *chip, int clock,
  */
 static int snd_atiixp_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct atiixp *chip = card->private_data;
         int i;
@@ -1492,29 +1491,15 @@ static int snd_atiixp_suspend(struct device *dev)
                 snd_ac97_suspend(chip->ac97[i]);
         snd_atiixp_aclink_down(chip);
         snd_atiixp_chip_stop(chip);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_atiixp_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct atiixp *chip = card->private_data;
         int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_atiixp_aclink_reset(chip);
         snd_atiixp_chip_start(chip);
 
@@ -1585,8 +1570,7 @@ static int snd_atiixp_free(struct atiixp *chip)
       __hw_end:
         if (chip->irq >= 0)
                 free_irq(chip->irq, chip);
-        if (chip->remap_addr)
-                iounmap(chip->remap_addr);
+        iounmap(chip->remap_addr);
         pci_release_regions(chip->pci);
         pci_disable_device(chip->pci);
         kfree(chip);
diff --git a/sound/pci/atiixp_modem.c b/sound/pci/atiixp_modem.c
index b2f63e0727de..0a38e08164ab 100644
--- a/sound/pci/atiixp_modem.c
+++ b/sound/pci/atiixp_modem.c
@@ -19,7 +19,7 @@
  *
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -1120,7 +1120,6 @@ static int snd_atiixp_mixer_new(struct atiixp_modem *chip, int clock)
  */
 static int snd_atiixp_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct atiixp_modem *chip = card->private_data;
         int i;
@@ -1132,29 +1131,15 @@ static int snd_atiixp_suspend(struct device *dev)
                 snd_ac97_suspend(chip->ac97[i]);
         snd_atiixp_aclink_down(chip);
         snd_atiixp_chip_stop(chip);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_atiixp_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct atiixp_modem *chip = card->private_data;
         int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_atiixp_aclink_reset(chip);
         snd_atiixp_chip_start(chip);
 
@@ -1211,8 +1196,7 @@ static int snd_atiixp_free(struct atiixp_modem *chip)
       __hw_end:
         if (chip->irq >= 0)
                 free_irq(chip->irq, chip);
-        if (chip->remap_addr)
-                iounmap(chip->remap_addr);
+        iounmap(chip->remap_addr);
         pci_release_regions(chip->pci);
         pci_disable_device(chip->pci);
         kfree(chip);
diff --git a/sound/pci/au88x0/au88x0.h b/sound/pci/au88x0/au88x0.h
index 3a8fefefea77..bcc648bf6478 100644
--- a/sound/pci/au88x0/au88x0.h
+++ b/sound/pci/au88x0/au88x0.h
@@ -17,9 +17,8 @@
 #ifndef __SOUND_AU88X0_H
 #define __SOUND_AU88X0_H
 
-#ifdef __KERNEL__
 #include <linux/pci.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/rawmidi.h>
@@ -27,7 +26,6 @@
 #include <sound/hwdep.h>
 #include <sound/ac97_codec.h>
 #include <sound/tlv.h>
-#endif
 
 #ifndef CHIP_AU8820
 #include "au88x0_eq.h"
diff --git a/sound/pci/aw2/aw2-alsa.c b/sound/pci/aw2/aw2-alsa.c
index e1cf01949fda..8d2fee7b33bd 100644
--- a/sound/pci/aw2/aw2-alsa.c
+++ b/sound/pci/aw2/aw2-alsa.c
@@ -229,9 +229,7 @@ static int snd_aw2_dev_free(struct snd_device *device)
         if (chip->irq >= 0)
                 free_irq(chip->irq, (void *)chip);
         /* release the i/o ports & memory */
-        if (chip->iobase_virt)
-                iounmap(chip->iobase_virt);
-
+        iounmap(chip->iobase_virt);
         pci_release_regions(chip->pci);
         /* disable the PCI entry */
         pci_disable_device(chip->pci);
diff --git a/sound/pci/aw2/aw2-saa7146.c b/sound/pci/aw2/aw2-saa7146.c
index 6d24e9536777..1d7890459334 100644
--- a/sound/pci/aw2/aw2-saa7146.c
+++ b/sound/pci/aw2/aw2-saa7146.c
@@ -27,7 +27,7 @@
 #include <linux/pci.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/initval.h>
 #include <sound/pcm.h>
diff --git a/sound/pci/azt3328.c b/sound/pci/azt3328.c
index fdbb9c05c77b..a40a2b4c8fd7 100644
--- a/sound/pci/azt3328.c
+++ b/sound/pci/azt3328.c
@@ -179,7 +179,7 @@
  *  - use MMIO (memory-mapped I/O)? Slightly faster access, e.g. for gameport.
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/init.h>
 #include <linux/bug.h> /* WARN_ONCE */
 #include <linux/pci.h>
@@ -2694,7 +2694,6 @@ snd_azf3328_resume_ac97(const struct snd_azf3328 *chip)
 static int
 snd_azf3328_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_azf3328 *chip = card->private_data;
         u16 *saved_regs_ctrl_u16;
@@ -2720,29 +2719,15 @@ snd_azf3328_suspend(struct device *dev)
                 ARRAY_SIZE(chip->saved_regs_mpu), chip->saved_regs_mpu);
         snd_azf3328_suspend_regs(chip, chip->opl3_io,
                 ARRAY_SIZE(chip->saved_regs_opl3), chip->saved_regs_opl3);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int
 snd_azf3328_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         const struct snd_azf3328 *chip = card->private_data;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_azf3328_resume_regs(chip, chip->saved_regs_game, chip->game_io,
                                         ARRAY_SIZE(chip->saved_regs_game));
         snd_azf3328_resume_regs(chip, chip->saved_regs_mpu, chip->mpu_io,
diff --git a/sound/pci/bt87x.c b/sound/pci/bt87x.c
index 058b9973c09c..5925b7170e25 100644
--- a/sound/pci/bt87x.c
+++ b/sound/pci/bt87x.c
@@ -27,7 +27,7 @@
 #include <linux/slab.h>
 #include <linux/module.h>
 #include <linux/bitops.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
@@ -690,8 +690,7 @@ static int snd_bt87x_free(struct snd_bt87x *chip)
                 snd_bt87x_stop(chip);
         if (chip->irq >= 0)
                 free_irq(chip->irq, chip);
-        if (chip->mmio)
-                iounmap(chip->mmio);
+        iounmap(chip->mmio);
         pci_release_regions(chip->pci);
         pci_disable_device(chip->pci);
         kfree(chip);
diff --git a/sound/pci/ca0106/ca0106_main.c b/sound/pci/ca0106/ca0106_main.c
index 96af33965b51..dd75b7536fa2 100644
--- a/sound/pci/ca0106/ca0106_main.c
+++ b/sound/pci/ca0106/ca0106_main.c
@@ -1910,7 +1910,6 @@ static void snd_ca0106_remove(struct pci_dev *pci)
 #ifdef CONFIG_PM_SLEEP
 static int snd_ca0106_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_ca0106 *chip = card->private_data;
         int i;
@@ -1923,30 +1922,15 @@ static int snd_ca0106_suspend(struct device *dev)
         snd_ca0106_mixer_suspend(chip);
 
         ca0106_stop_chip(chip);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_ca0106_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_ca0106 *chip = card->private_data;
         int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-
-        if (pci_enable_device(pci) < 0) {
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-
-        pci_set_master(pci);
-
         ca0106_init_chip(chip, 1);
 
         if (chip->details->ac97)
diff --git a/sound/pci/ca0106/ca0106_mixer.c b/sound/pci/ca0106/ca0106_mixer.c
index 68c0eb0a2807..025805cba779 100644
--- a/sound/pci/ca0106/ca0106_mixer.c
+++ b/sound/pci/ca0106/ca0106_mixer.c
@@ -70,7 +70,7 @@
 #include <sound/ac97_codec.h>
 #include <sound/info.h>
 #include <sound/tlv.h>
-#include <asm/io.h>
+#include <linux/io.h>
 
 #include "ca0106.h"
 
diff --git a/sound/pci/ca0106/ca0106_proc.c b/sound/pci/ca0106/ca0106_proc.c
index 4f9c2821bb31..2c5c28adbefd 100644
--- a/sound/pci/ca0106/ca0106_proc.c
+++ b/sound/pci/ca0106/ca0106_proc.c
@@ -64,13 +64,13 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/moduleparam.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/initval.h>
 #include <sound/pcm.h>
 #include <sound/ac97_codec.h>
 #include <sound/info.h>
 #include <sound/asoundef.h>
-#include <asm/io.h>
 
 #include "ca0106.h"
 
diff --git a/sound/pci/cmipci.c b/sound/pci/cmipci.c
index 85ed40339db9..1d0f2cad2f5a 100644
--- a/sound/pci/cmipci.c
+++ b/sound/pci/cmipci.c
@@ -20,7 +20,7 @@
 /* Does not work. Warning may block system in capture mode */
 /* #define USE_VAR48KRATE */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -3347,7 +3347,6 @@ static unsigned char saved_mixers[] = {
 
 static int snd_cmipci_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct cmipci *cm = card->private_data;
         int i;
@@ -3366,29 +3365,15 @@ static int snd_cmipci_suspend(struct device *dev)
 
         /* disable ints */
         snd_cmipci_write(cm, CM_REG_INT_HLDCLR, 0);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_cmipci_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct cmipci *cm = card->private_data;
         int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         /* reset / initialize to a sane state */
         snd_cmipci_write(cm, CM_REG_INT_HLDCLR, 0);
         snd_cmipci_ch_reset(cm, CM_CH_PLAY);
diff --git a/sound/pci/cs4281.c b/sound/pci/cs4281.c
index 4c49b5c8a7b3..c296fd0dbc9c 100644
--- a/sound/pci/cs4281.c
+++ b/sound/pci/cs4281.c
@@ -19,7 +19,7 @@
  *
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -973,14 +973,11 @@ static struct snd_pcm_ops snd_cs4281_capture_ops = {
         .pointer =      snd_cs4281_pointer,
 };
 
-static int snd_cs4281_pcm(struct cs4281 *chip, int device,
-                          struct snd_pcm **rpcm)
+static int snd_cs4281_pcm(struct cs4281 *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         err = snd_pcm_new(chip->card, "CS4281", device, 1, 1, &pcm);
         if (err < 0)
                 return err;
@@ -996,8 +993,6 @@ static int snd_cs4281_pcm(struct cs4281 *chip, int device,
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(chip->pci), 64*1024, 512*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 
@@ -1321,10 +1316,8 @@ static int snd_cs4281_free(struct cs4281 *chip)
 
         if (chip->irq >= 0)
                 free_irq(chip->irq, chip);
-        if (chip->ba0)
-                iounmap(chip->ba0);
-        if (chip->ba1)
-                iounmap(chip->ba1);
+        iounmap(chip->ba0);
+        iounmap(chip->ba1);
         pci_release_regions(chip->pci);
         pci_disable_device(chip->pci);
 
@@ -1788,14 +1781,11 @@ static struct snd_rawmidi_ops snd_cs4281_midi_input =
         .trigger =      snd_cs4281_midi_input_trigger,
 };
 
-static int snd_cs4281_midi(struct cs4281 *chip, int device,
-                           struct snd_rawmidi **rrawmidi)
+static int snd_cs4281_midi(struct cs4281 *chip, int device)
 {
         struct snd_rawmidi *rmidi;
         int err;
 
-        if (rrawmidi)
-                *rrawmidi = NULL;
         if ((err = snd_rawmidi_new(chip->card, "CS4281", device, 1, 1, &rmidi)) < 0)
                 return err;
         strcpy(rmidi->name, "CS4281");
@@ -1804,8 +1794,6 @@ static int snd_cs4281_midi(struct cs4281 *chip, int device,
         rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX;
         rmidi->private_data = chip;
         chip->rmidi = rmidi;
-        if (rrawmidi)
-                *rrawmidi = rmidi;
         return 0;
 }
 
@@ -1941,11 +1929,11 @@ static int snd_cs4281_probe(struct pci_dev *pci,
                 snd_card_free(card);
                 return err;
         }
-        if ((err = snd_cs4281_pcm(chip, 0, NULL)) < 0) {
+        if ((err = snd_cs4281_pcm(chip, 0)) < 0) {
                 snd_card_free(card);
                 return err;
         }
-        if ((err = snd_cs4281_midi(chip, 0, NULL)) < 0) {
+        if ((err = snd_cs4281_midi(chip, 0)) < 0) {
                 snd_card_free(card);
                 return err;
         }
@@ -2008,7 +1996,6 @@ static int saved_regs[SUSPEND_REGISTERS] = {
 
 static int cs4281_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct cs4281 *chip = card->private_data;
         u32 ulCLK;
@@ -2047,30 +2034,16 @@ static int cs4281_suspend(struct device *dev)
         ulCLK = snd_cs4281_peekBA0(chip, BA0_CLKCR1);
         ulCLK &= ~CLKCR1_CKRA;
         snd_cs4281_pokeBA0(chip, BA0_CLKCR1, ulCLK);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int cs4281_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct cs4281 *chip = card->private_data;
         unsigned int i;
         u32 ulCLK;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         ulCLK = snd_cs4281_peekBA0(chip, BA0_CLKCR1);
         ulCLK |= CLKCR1_CKRA;
         snd_cs4281_pokeBA0(chip, BA0_CLKCR1, ulCLK);
diff --git a/sound/pci/cs46xx/cs46xx.c b/sound/pci/cs46xx/cs46xx.c
index 6a6858c07826..655fbea1692c 100644
--- a/sound/pci/cs46xx/cs46xx.c
+++ b/sound/pci/cs46xx/cs46xx.c
@@ -100,16 +100,16 @@ static int snd_card_cs46xx_probe(struct pci_dev *pci,
         }
         card->private_data = chip;
         chip->accept_valid = mmap_valid[dev];
-        if ((err = snd_cs46xx_pcm(chip, 0, NULL)) < 0) {
+        if ((err = snd_cs46xx_pcm(chip, 0)) < 0) {
                 snd_card_free(card);
                 return err;
         }
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
-        if ((err = snd_cs46xx_pcm_rear(chip,1, NULL)) < 0) {
+        if ((err = snd_cs46xx_pcm_rear(chip, 1)) < 0) {
                 snd_card_free(card);
                 return err;
         }
-        if ((err = snd_cs46xx_pcm_iec958(chip,2,NULL)) < 0) {
+        if ((err = snd_cs46xx_pcm_iec958(chip, 2)) < 0) {
                 snd_card_free(card);
                 return err;
         }
@@ -120,13 +120,13 @@ static int snd_card_cs46xx_probe(struct pci_dev *pci,
         }
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
         if (chip->nr_ac97_codecs ==2) {
-                if ((err = snd_cs46xx_pcm_center_lfe(chip,3,NULL)) < 0) {
+                if ((err = snd_cs46xx_pcm_center_lfe(chip, 3)) < 0) {
                         snd_card_free(card);
                         return err;
                 }
         }
 #endif
-        if ((err = snd_cs46xx_midi(chip, 0, NULL)) < 0) {
+        if ((err = snd_cs46xx_midi(chip, 0)) < 0) {
                 snd_card_free(card);
                 return err;
         }
diff --git a/sound/pci/cs46xx/cs46xx.h b/sound/pci/cs46xx/cs46xx.h
index c49a082c378b..9c9f89a8be5f 100644
--- a/sound/pci/cs46xx/cs46xx.h
+++ b/sound/pci/cs46xx/cs46xx.h
@@ -1737,12 +1737,12 @@ int snd_cs46xx_create(struct snd_card *card,
                       struct snd_cs46xx **rcodec);
 extern const struct dev_pm_ops snd_cs46xx_pm;
 
-int snd_cs46xx_pcm(struct snd_cs46xx *chip, int device, struct snd_pcm **rpcm);
-int snd_cs46xx_pcm_rear(struct snd_cs46xx *chip, int device, struct snd_pcm **rpcm);
-int snd_cs46xx_pcm_iec958(struct snd_cs46xx *chip, int device, struct snd_pcm **rpcm);
-int snd_cs46xx_pcm_center_lfe(struct snd_cs46xx *chip, int device, struct snd_pcm **rpcm);
+int snd_cs46xx_pcm(struct snd_cs46xx *chip, int device);
+int snd_cs46xx_pcm_rear(struct snd_cs46xx *chip, int device);
+int snd_cs46xx_pcm_iec958(struct snd_cs46xx *chip, int device);
+int snd_cs46xx_pcm_center_lfe(struct snd_cs46xx *chip, int device);
 int snd_cs46xx_mixer(struct snd_cs46xx *chip, int spdif_device);
-int snd_cs46xx_midi(struct snd_cs46xx *chip, int device, struct snd_rawmidi **rmidi);
+int snd_cs46xx_midi(struct snd_cs46xx *chip, int device);
 int snd_cs46xx_start_dsp(struct snd_cs46xx *chip);
 int snd_cs46xx_gameport(struct snd_cs46xx *chip);
 
diff --git a/sound/pci/cs46xx/cs46xx_lib.c b/sound/pci/cs46xx/cs46xx_lib.c
index 32b44f25b5c8..8d74004b1ed2 100644
--- a/sound/pci/cs46xx/cs46xx_lib.c
+++ b/sound/pci/cs46xx/cs46xx_lib.c
@@ -57,6 +57,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/vmalloc.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/control.h>
@@ -65,8 +66,6 @@
 #include <sound/pcm_params.h>
 #include "cs46xx.h"
 
-#include <asm/io.h>
-
 #include "cs46xx_lib.h"
 #include "dsp_spos.h"
 
@@ -1778,13 +1777,11 @@ static struct snd_pcm_ops snd_cs46xx_capture_indirect_ops = {
 #define MAX_PLAYBACK_CHANNELS   1
 #endif
 
-int snd_cs46xx_pcm(struct snd_cs46xx *chip, int device, struct snd_pcm **rpcm)
+int snd_cs46xx_pcm(struct snd_cs46xx *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(chip->card, "CS46xx", device, MAX_PLAYBACK_CHANNELS, 1, &pcm)) < 0)
                 return err;
 
@@ -1801,23 +1798,16 @@ int snd_cs46xx_pcm(struct snd_cs46xx *chip, int device, struct snd_pcm **rpcm)
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
-
         return 0;
 }
 
 
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
-int snd_cs46xx_pcm_rear(struct snd_cs46xx *chip, int device,
-                        struct snd_pcm **rpcm)
+int snd_cs46xx_pcm_rear(struct snd_cs46xx *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
-
         if ((err = snd_pcm_new(chip->card, "CS46xx - Rear", device, MAX_PLAYBACK_CHANNELS, 0, &pcm)) < 0)
                 return err;
 
@@ -1833,21 +1823,14 @@ int snd_cs46xx_pcm_rear(struct snd_cs46xx *chip, int device,
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
-
         return 0;
 }
 
-int snd_cs46xx_pcm_center_lfe(struct snd_cs46xx *chip, int device,
-                              struct snd_pcm **rpcm)
+int snd_cs46xx_pcm_center_lfe(struct snd_cs46xx *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
-
         if ((err = snd_pcm_new(chip->card, "CS46xx - Center LFE", device, MAX_PLAYBACK_CHANNELS, 0, &pcm)) < 0)
                 return err;
 
@@ -1863,21 +1846,14 @@ int snd_cs46xx_pcm_center_lfe(struct snd_cs46xx *chip, int device,
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
-
         return 0;
 }
 
-int snd_cs46xx_pcm_iec958(struct snd_cs46xx *chip, int device,
-                          struct snd_pcm **rpcm)
+int snd_cs46xx_pcm_iec958(struct snd_cs46xx *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
-
         if ((err = snd_pcm_new(chip->card, "CS46xx - IEC958", device, 1, 0, &pcm)) < 0)
                 return err;
 
@@ -1893,9 +1869,6 @@ int snd_cs46xx_pcm_iec958(struct snd_cs46xx *chip, int device,
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
-
         return 0;
 }
 #endif
@@ -2724,13 +2697,11 @@ static struct snd_rawmidi_ops snd_cs46xx_midi_input =
         .trigger =      snd_cs46xx_midi_input_trigger,
 };
 
-int snd_cs46xx_midi(struct snd_cs46xx *chip, int device, struct snd_rawmidi **rrawmidi)
+int snd_cs46xx_midi(struct snd_cs46xx *chip, int device)
 {
         struct snd_rawmidi *rmidi;
         int err;
 
-        if (rrawmidi)
-                *rrawmidi = NULL;
         if ((err = snd_rawmidi_new(chip->card, "CS46XX", device, 1, 1, &rmidi)) < 0)
                 return err;
         strcpy(rmidi->name, "CS46XX");
@@ -2739,8 +2710,6 @@ int snd_cs46xx_midi(struct snd_cs46xx *chip, int device, struct snd_rawmidi **rr
         rmidi->info_flags |= SNDRV_RAWMIDI_INFO_OUTPUT | SNDRV_RAWMIDI_INFO_INPUT | SNDRV_RAWMIDI_INFO_DUPLEX;
         rmidi->private_data = chip;
         chip->rmidi = rmidi;
-        if (rrawmidi)
-                *rrawmidi = NULL;
         return 0;
 }
 
@@ -2979,8 +2948,8 @@ static int snd_cs46xx_free(struct snd_cs46xx *chip)
 
         for (idx = 0; idx < 5; idx++) {
                 struct snd_cs46xx_region *region = &chip->region.idx[idx];
-                if (region->remap_addr)
-                        iounmap(region->remap_addr);
+
+                iounmap(region->remap_addr);
                 release_and_free_resource(region->resource);
         }
 
@@ -3804,7 +3773,6 @@ static unsigned int saved_regs[] = {
 
 static int snd_cs46xx_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_cs46xx *chip = card->private_data;
         int i, amp_saved;
@@ -3829,16 +3797,11 @@ static int snd_cs46xx_suspend(struct device *dev)
         /* disable CLKRUN */
         chip->active_ctrl(chip, -chip->amplifier);
         chip->amplifier = amp_saved; /* restore the status */
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_cs46xx_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_cs46xx *chip = card->private_data;
         int amp_saved;
@@ -3847,15 +3810,6 @@ static int snd_cs46xx_resume(struct device *dev)
 #endif
         unsigned int tmp;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         amp_saved = chip->amplifier;
         chip->amplifier = 0;
         chip->active_ctrl(chip, 1); /* force to on */
diff --git a/sound/pci/cs46xx/dsp_spos.c b/sound/pci/cs46xx/dsp_spos.c
index 1c4a0fb3ffef..5c99efb004c0 100644
--- a/sound/pci/cs46xx/dsp_spos.c
+++ b/sound/pci/cs46xx/dsp_spos.c
@@ -20,7 +20,7 @@
  */
 
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/init.h>
diff --git a/sound/pci/cs46xx/dsp_spos_scb_lib.c b/sound/pci/cs46xx/dsp_spos_scb_lib.c
index 8284bc9b5858..2c90c0bded69 100644
--- a/sound/pci/cs46xx/dsp_spos_scb_lib.c
+++ b/sound/pci/cs46xx/dsp_spos_scb_lib.c
@@ -21,7 +21,7 @@
  */
 
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/pm.h>
 #include <linux/init.h>
diff --git a/sound/pci/cs5530.c b/sound/pci/cs5530.c
index b1025507a467..0a8cf94c4858 100644
--- a/sound/pci/cs5530.c
+++ b/sound/pci/cs5530.c
@@ -223,7 +223,7 @@ static int snd_cs5530_create(struct snd_card *card,
                 return err;
         }
 
-        err = snd_sb16dsp_pcm(chip->sb, 0, &chip->sb->pcm);
+        err = snd_sb16dsp_pcm(chip->sb, 0);
         if (err < 0) {
                 dev_err(card->dev, "Could not create PCM\n");
                 snd_cs5530_free(chip);
diff --git a/sound/pci/cs5535audio/cs5535audio.c b/sound/pci/cs5535audio/cs5535audio.c
index 16288e4d338a..802c33f1cc59 100644
--- a/sound/pci/cs5535audio/cs5535audio.c
+++ b/sound/pci/cs5535audio/cs5535audio.c
@@ -27,7 +27,7 @@
 #include <linux/pci.h>
 #include <linux/slab.h>
 #include <linux/module.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/control.h>
 #include <sound/pcm.h>
diff --git a/sound/pci/cs5535audio/cs5535audio_pm.c b/sound/pci/cs5535audio/cs5535audio_pm.c
index 34cc60057d0c..06ac5d8da362 100644
--- a/sound/pci/cs5535audio/cs5535audio_pm.c
+++ b/sound/pci/cs5535audio/cs5535audio_pm.c
@@ -57,7 +57,6 @@ static void snd_cs5535audio_stop_hardware(struct cs5535audio *cs5535au)
 
 static int snd_cs5535audio_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct cs5535audio *cs5535au = card->private_data;
         int i;
@@ -72,34 +71,17 @@ static int snd_cs5535audio_suspend(struct device *dev)
         }
         /* save important regs, then disable aclink in hw */
         snd_cs5535audio_stop_hardware(cs5535au);
-
-        if (pci_save_state(pci)) {
-                dev_err(dev, "pci_save_state failed!\n");
-                return -EIO;
-        }
-        pci_disable_device(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_cs5535audio_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct cs5535audio *cs5535au = card->private_data;
         u32 tmp;
         int timeout;
         int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         /* set LNK_WRM_RST to reset AC link */
         cs_writel(cs5535au, ACC_CODEC_CNTL, ACC_CODEC_CNTL_LNK_WRM_RST);
 
diff --git a/sound/pci/ctxfi/cthw20k1.c b/sound/pci/ctxfi/cthw20k1.c
index b425aa8ee578..1cac55fd1139 100644
--- a/sound/pci/ctxfi/cthw20k1.c
+++ b/sound/pci/ctxfi/cthw20k1.c
@@ -1985,10 +1985,7 @@ static int hw_card_shutdown(struct hw *hw)
                 free_irq(hw->irq, hw);
 
         hw->irq = -1;
-
-        if (hw->mem_base)
-                iounmap(hw->mem_base);
-
+        iounmap(hw->mem_base);
         hw->mem_base = NULL;
 
         if (hw->io_base)
@@ -2099,20 +2096,11 @@ static int hw_suspend(struct hw *hw)
                 pci_write_config_dword(pci, UAA_CFG_SPACE_FLAG, 0x0);
         }
 
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
-
         return 0;
 }
 
 static int hw_resume(struct hw *hw, struct card_conf *info)
 {
-        struct pci_dev *pci = hw->pci;
-
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-
         /* Re-initialize card hardware. */
         return hw_card_init(hw, info);
 }
diff --git a/sound/pci/ctxfi/cthw20k2.c b/sound/pci/ctxfi/cthw20k2.c
index 253899d13790..955ad871e9a8 100644
--- a/sound/pci/ctxfi/cthw20k2.c
+++ b/sound/pci/ctxfi/cthw20k2.c
@@ -2110,10 +2110,7 @@ static int hw_card_shutdown(struct hw *hw)
                 free_irq(hw->irq, hw);
 
         hw->irq = -1;
-
-        if (hw->mem_base)
-                iounmap(hw->mem_base);
-
+        iounmap(hw->mem_base);
         hw->mem_base = NULL;
 
         if (hw->io_base)
@@ -2209,24 +2206,12 @@ static int hw_card_init(struct hw *hw, struct card_conf *info)
 #ifdef CONFIG_PM_SLEEP
 static int hw_suspend(struct hw *hw)
 {
-        struct pci_dev *pci = hw->pci;
-
         hw_card_stop(hw);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
-
         return 0;
 }
 
 static int hw_resume(struct hw *hw, struct card_conf *info)
 {
-        struct pci_dev *pci = hw->pci;
-
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-
         /* Re-initialize card hardware. */
         return hw_card_init(hw, info);
 }
diff --git a/sound/pci/echoaudio/darla20.c b/sound/pci/echoaudio/darla20.c
index 4632946205a8..c95da6301677 100644
--- a/sound/pci/echoaudio/darla20.c
+++ b/sound/pci/echoaudio/darla20.c
@@ -43,6 +43,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -51,7 +52,6 @@
 #include <sound/pcm_params.h>
 #include <sound/asoundef.h>
 #include <sound/initval.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/darla24.c b/sound/pci/echoaudio/darla24.c
index f81c839cc887..3013b4daa19e 100644
--- a/sound/pci/echoaudio/darla24.c
+++ b/sound/pci/echoaudio/darla24.c
@@ -47,6 +47,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -55,7 +56,6 @@
 #include <sound/pcm_params.h>
 #include <sound/asoundef.h>
 #include <sound/initval.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/echo3g.c b/sound/pci/echoaudio/echo3g.c
index 3a5346c33d76..1f34a07b0b19 100644
--- a/sound/pci/echoaudio/echo3g.c
+++ b/sound/pci/echoaudio/echo3g.c
@@ -54,6 +54,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -63,7 +64,6 @@
 #include <sound/asoundef.h>
 #include <sound/initval.h>
 #include <sound/rawmidi.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/echoaudio.c b/sound/pci/echoaudio/echoaudio.c
index 21228adaa70c..a962de03ebb6 100644
--- a/sound/pci/echoaudio/echoaudio.c
+++ b/sound/pci/echoaudio/echoaudio.c
@@ -1872,12 +1872,8 @@ static int snd_echo_free(struct echoaudio *chip)
         if (chip->comm_page)
                 snd_dma_free_pages(&chip->commpage_dma_buf);
 
-        if (chip->dsp_registers)
-                iounmap(chip->dsp_registers);
-
+        iounmap(chip->dsp_registers);
         release_and_free_resource(chip->iores);
-
-
         pci_disable_device(chip->pci);
 
         /* release chip data */
@@ -2162,7 +2158,6 @@ ctl_error:
 
 static int snd_echo_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct echoaudio *chip = dev_get_drvdata(dev);
 
         snd_pcm_suspend_all(chip->analog_pcm);
@@ -2188,9 +2183,6 @@ static int snd_echo_suspend(struct device *dev)
         chip->dsp_code = NULL;
         free_irq(chip->irq, chip);
         chip->irq = -1;
-        pci_save_state(pci);
-        pci_disable_device(pci);
-
         return 0;
 }
 
@@ -2204,7 +2196,6 @@ static int snd_echo_resume(struct device *dev)
         u32 pipe_alloc_mask;
         int err;
 
-        pci_restore_state(pci);
         commpage_bak = kmalloc(sizeof(struct echoaudio), GFP_KERNEL);
         if (commpage_bak == NULL)
                 return -ENOMEM;
diff --git a/sound/pci/echoaudio/gina20.c b/sound/pci/echoaudio/gina20.c
index 9cb81c500824..4fa32a2e97db 100644
--- a/sound/pci/echoaudio/gina20.c
+++ b/sound/pci/echoaudio/gina20.c
@@ -47,6 +47,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -55,7 +56,6 @@
 #include <sound/pcm_params.h>
 #include <sound/asoundef.h>
 #include <sound/initval.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/gina24.c b/sound/pci/echoaudio/gina24.c
index 35d3e6eac990..b1bcacaef257 100644
--- a/sound/pci/echoaudio/gina24.c
+++ b/sound/pci/echoaudio/gina24.c
@@ -53,6 +53,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -61,7 +62,6 @@
 #include <sound/pcm_params.h>
 #include <sound/asoundef.h>
 #include <sound/initval.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/indigo.c b/sound/pci/echoaudio/indigo.c
index 8d91842d1268..175af9b1435f 100644
--- a/sound/pci/echoaudio/indigo.c
+++ b/sound/pci/echoaudio/indigo.c
@@ -45,6 +45,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -53,7 +54,6 @@
 #include <sound/pcm_params.h>
 #include <sound/asoundef.h>
 #include <sound/initval.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/indigodj.c b/sound/pci/echoaudio/indigodj.c
index 289cb969f5b9..8c60314e4901 100644
--- a/sound/pci/echoaudio/indigodj.c
+++ b/sound/pci/echoaudio/indigodj.c
@@ -45,6 +45,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -53,7 +54,6 @@
 #include <sound/pcm_params.h>
 #include <sound/asoundef.h>
 #include <sound/initval.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/indigoio.c b/sound/pci/echoaudio/indigoio.c
index 405a3f2e496f..f7618edfd79c 100644
--- a/sound/pci/echoaudio/indigoio.c
+++ b/sound/pci/echoaudio/indigoio.c
@@ -46,6 +46,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -54,7 +55,6 @@
 #include <sound/pcm_params.h>
 #include <sound/asoundef.h>
 #include <sound/initval.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/layla20.c b/sound/pci/echoaudio/layla20.c
index b392dd776b71..12e5d2164dc4 100644
--- a/sound/pci/echoaudio/layla20.c
+++ b/sound/pci/echoaudio/layla20.c
@@ -52,6 +52,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -61,7 +62,6 @@
 #include <sound/asoundef.h>
 #include <sound/initval.h>
 #include <sound/rawmidi.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/layla24.c b/sound/pci/echoaudio/layla24.c
index bc7f730b0ec6..6e4023728ef5 100644
--- a/sound/pci/echoaudio/layla24.c
+++ b/sound/pci/echoaudio/layla24.c
@@ -54,6 +54,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -63,7 +64,6 @@
 #include <sound/asoundef.h>
 #include <sound/initval.h>
 #include <sound/rawmidi.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/mia.c b/sound/pci/echoaudio/mia.c
index 27a9a6e5db2d..2f7562f1aefb 100644
--- a/sound/pci/echoaudio/mia.c
+++ b/sound/pci/echoaudio/mia.c
@@ -53,6 +53,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -62,7 +63,6 @@
 #include <sound/asoundef.h>
 #include <sound/initval.h>
 #include <sound/rawmidi.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/echoaudio/midi.c b/sound/pci/echoaudio/midi.c
index d913749d154a..a8fe58335ddc 100644
--- a/sound/pci/echoaudio/midi.c
+++ b/sound/pci/echoaudio/midi.c
@@ -257,9 +257,8 @@ static void snd_echo_midi_output_trigger(struct snd_rawmidi_substream *substream
         spin_lock_irq(&chip->lock);
         if (up) {
                 if (!chip->tinuse) {
-                        init_timer(&chip->timer);
-                        chip->timer.function = snd_echo_midi_output_write;
-                        chip->timer.data = (unsigned long)chip;
+                        setup_timer(&chip->timer, snd_echo_midi_output_write,
+                                    (unsigned long)chip);
                         chip->tinuse = 1;
                 }
         } else {
diff --git a/sound/pci/echoaudio/mona.c b/sound/pci/echoaudio/mona.c
index 3d13875c303d..34d499466393 100644
--- a/sound/pci/echoaudio/mona.c
+++ b/sound/pci/echoaudio/mona.c
@@ -51,6 +51,7 @@
 #include <linux/module.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -59,7 +60,6 @@
 #include <sound/pcm_params.h>
 #include <sound/asoundef.h>
 #include <sound/initval.h>
-#include <asm/io.h>
 #include <linux/atomic.h>
 #include "echoaudio.h"
 
diff --git a/sound/pci/emu10k1/emu10k1.c b/sound/pci/emu10k1/emu10k1.c
index 4c171636efcd..37d0220a094c 100644
--- a/sound/pci/emu10k1/emu10k1.c
+++ b/sound/pci/emu10k1/emu10k1.c
@@ -132,11 +132,11 @@ static int snd_card_emu10k1_probe(struct pci_dev *pci,
                 goto error;
         card->private_data = emu;
         emu->delay_pcm_irq = delay_pcm_irq[dev] & 0x1f;
-        if ((err = snd_emu10k1_pcm(emu, 0, NULL)) < 0)
+        if ((err = snd_emu10k1_pcm(emu, 0)) < 0)
                 goto error;
-        if ((err = snd_emu10k1_pcm_mic(emu, 1, NULL)) < 0)
+        if ((err = snd_emu10k1_pcm_mic(emu, 1)) < 0)
                 goto error;
-        if ((err = snd_emu10k1_pcm_efx(emu, 2, NULL)) < 0)
+        if ((err = snd_emu10k1_pcm_efx(emu, 2)) < 0)
                 goto error;
         /* This stores the periods table. */
         if (emu->card_capabilities->ca0151_chip) { /* P16V */   
@@ -151,10 +151,10 @@ static int snd_card_emu10k1_probe(struct pci_dev *pci,
         if ((err = snd_emu10k1_timer(emu, 0)) < 0)
                 goto error;
 
-        if ((err = snd_emu10k1_pcm_multi(emu, 3, NULL)) < 0)
+        if ((err = snd_emu10k1_pcm_multi(emu, 3)) < 0)
                 goto error;
         if (emu->card_capabilities->ca0151_chip) { /* P16V */
-                if ((err = snd_p16v_pcm(emu, 4, NULL)) < 0)
+                if ((err = snd_p16v_pcm(emu, 4)) < 0)
                         goto error;
         }
         if (emu->audigy) {
@@ -164,7 +164,7 @@ static int snd_card_emu10k1_probe(struct pci_dev *pci,
                 if ((err = snd_emu10k1_midi(emu)) < 0)
                         goto error;
         }
-        if ((err = snd_emu10k1_fx8010_new(emu, 0, NULL)) < 0)
+        if ((err = snd_emu10k1_fx8010_new(emu, 0)) < 0)
                 goto error;
 #ifdef ENABLE_SYNTH
         if (snd_seq_device_new(card, 1, SNDRV_SEQ_DEV_ID_EMU10K1_SYNTH,
@@ -210,7 +210,6 @@ static void snd_card_emu10k1_remove(struct pci_dev *pci)
 #ifdef CONFIG_PM_SLEEP
 static int snd_emu10k1_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_emu10k1 *emu = card->private_data;
 
@@ -232,28 +231,14 @@ static int snd_emu10k1_suspend(struct device *dev)
                 snd_p16v_suspend(emu);
 
         snd_emu10k1_done(emu);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_emu10k1_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_emu10k1 *emu = card->private_data;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_emu10k1_resume_init(emu);
         snd_emu10k1_efx_resume(emu);
         snd_ac97_resume(emu->ac97);
diff --git a/sound/pci/emu10k1/emu10k1x.c b/sound/pci/emu10k1/emu10k1x.c
index 15933f92f63a..6d1b98d14327 100644
--- a/sound/pci/emu10k1/emu10k1x.c
+++ b/sound/pci/emu10k1/emu10k1x.c
@@ -847,15 +847,13 @@ static const struct snd_pcm_chmap_elem clfe_map[] = {
         { }
 };
 
-static int snd_emu10k1x_pcm(struct emu10k1x *emu, int device, struct snd_pcm **rpcm)
+static int snd_emu10k1x_pcm(struct emu10k1x *emu, int device)
 {
         struct snd_pcm *pcm;
         const struct snd_pcm_chmap_elem *map = NULL;
         int err;
         int capture = 0;
   
-        if (rpcm)
-                *rpcm = NULL;
         if (device == 0)
                 capture = 1;
         
@@ -896,15 +894,8 @@ static int snd_emu10k1x_pcm(struct emu10k1x *emu, int device, struct snd_pcm **r
                                               snd_dma_pci_data(emu->pci), 
                                               32*1024, 32*1024);
   
-        err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK, map, 2,
+        return snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK, map, 2,
                                      1 << 2, NULL);
-        if (err < 0)
-                return err;
-
-        if (rpcm)
-                *rpcm = pcm;
-  
-        return 0;
 }
 
 static int snd_emu10k1x_create(struct snd_card *card,
@@ -1583,15 +1574,15 @@ static int snd_emu10k1x_probe(struct pci_dev *pci,
                 return err;
         }
 
-        if ((err = snd_emu10k1x_pcm(chip, 0, NULL)) < 0) {
+        if ((err = snd_emu10k1x_pcm(chip, 0)) < 0) {
                 snd_card_free(card);
                 return err;
         }
-        if ((err = snd_emu10k1x_pcm(chip, 1, NULL)) < 0) {
+        if ((err = snd_emu10k1x_pcm(chip, 1)) < 0) {
                 snd_card_free(card);
                 return err;
         }
-        if ((err = snd_emu10k1x_pcm(chip, 2, NULL)) < 0) {
+        if ((err = snd_emu10k1x_pcm(chip, 2)) < 0) {
                 snd_card_free(card);
                 return err;
         }
diff --git a/sound/pci/emu10k1/emufx.c b/sound/pci/emu10k1/emufx.c
index eb5c0aba41c1..56fc47bd6dba 100644
--- a/sound/pci/emu10k1/emufx.c
+++ b/sound/pci/emu10k1/emufx.c
@@ -2641,14 +2641,11 @@ static int snd_emu10k1_fx8010_release(struct snd_hwdep * hw, struct file *file)
         return 0;
 }
 
-int snd_emu10k1_fx8010_new(struct snd_emu10k1 *emu, int device,
-                           struct snd_hwdep **rhwdep)
+int snd_emu10k1_fx8010_new(struct snd_emu10k1 *emu, int device)
 {
         struct snd_hwdep *hw;
         int err;
         
-        if (rhwdep)
-                *rhwdep = NULL;
         if ((err = snd_hwdep_new(emu->card, "FX8010", device, &hw)) < 0)
                 return err;
         strcpy(hw->name, "EMU10K1 (FX8010)");
@@ -2657,8 +2654,6 @@ int snd_emu10k1_fx8010_new(struct snd_emu10k1 *emu, int device,
         hw->ops.ioctl = snd_emu10k1_fx8010_ioctl;
         hw->ops.release = snd_emu10k1_fx8010_release;
         hw->private_data = emu;
-        if (rhwdep)
-                *rhwdep = hw;
         return 0;
 }
 
diff --git a/sound/pci/emu10k1/emupcm.c b/sound/pci/emu10k1/emupcm.c
index f82481bd2542..0dc07385af0e 100644
--- a/sound/pci/emu10k1/emupcm.c
+++ b/sound/pci/emu10k1/emupcm.c
@@ -1400,15 +1400,12 @@ static struct snd_pcm_ops snd_emu10k1_efx_playback_ops = {
         .page =                 snd_pcm_sgbuf_ops_page,
 };
 
-int snd_emu10k1_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm **rpcm)
+int snd_emu10k1_pcm(struct snd_emu10k1 *emu, int device)
 {
         struct snd_pcm *pcm;
         struct snd_pcm_substream *substream;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
-
         if ((err = snd_pcm_new(emu->card, "emu10k1", device, 32, 1, &pcm)) < 0)
                 return err;
 
@@ -1429,22 +1426,15 @@ int snd_emu10k1_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm **rpcm)
         for (substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream; substream; substream = substream->next)
                 snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(emu->pci), 64*1024, 64*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
-
         return 0;
 }
 
-int snd_emu10k1_pcm_multi(struct snd_emu10k1 *emu, int device,
-                          struct snd_pcm **rpcm)
+int snd_emu10k1_pcm_multi(struct snd_emu10k1 *emu, int device)
 {
         struct snd_pcm *pcm;
         struct snd_pcm_substream *substream;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
-
         if ((err = snd_pcm_new(emu->card, "emu10k1", device, 1, 0, &pcm)) < 0)
                 return err;
 
@@ -1461,9 +1451,6 @@ int snd_emu10k1_pcm_multi(struct snd_emu10k1 *emu, int device,
                 if ((err = snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV_SG, snd_dma_pci_data(emu->pci), 64*1024, 64*1024)) < 0)
                         return err;
 
-        if (rpcm)
-                *rpcm = pcm;
-
         return 0;
 }
 
@@ -1479,15 +1466,11 @@ static struct snd_pcm_ops snd_emu10k1_capture_mic_ops = {
         .pointer =              snd_emu10k1_capture_pointer,
 };
 
-int snd_emu10k1_pcm_mic(struct snd_emu10k1 *emu, int device,
-                        struct snd_pcm **rpcm)
+int snd_emu10k1_pcm_mic(struct snd_emu10k1 *emu, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
-
         if ((err = snd_pcm_new(emu->card, "emu10k1 mic", device, 0, 1, &pcm)) < 0)
                 return err;
 
@@ -1501,8 +1484,6 @@ int snd_emu10k1_pcm_mic(struct snd_emu10k1 *emu, int device,
 
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(emu->pci), 64*1024, 64*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 
@@ -1822,16 +1803,12 @@ static struct snd_pcm_ops snd_emu10k1_fx8010_playback_ops = {
         .ack =                  snd_emu10k1_fx8010_playback_transfer,
 };
 
-int snd_emu10k1_pcm_efx(struct snd_emu10k1 *emu, int device,
-                        struct snd_pcm **rpcm)
+int snd_emu10k1_pcm_efx(struct snd_emu10k1 *emu, int device)
 {
         struct snd_pcm *pcm;
         struct snd_kcontrol *kctl;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
-
         if ((err = snd_pcm_new(emu->card, "emu10k1 efx", device, 8, 1, &pcm)) < 0)
                 return err;
 
@@ -1843,8 +1820,6 @@ int snd_emu10k1_pcm_efx(struct snd_emu10k1 *emu, int device,
         pcm->info_flags = 0;
         strcpy(pcm->name, "Multichannel Capture/PT Playback");
         emu->pcm_efx = pcm;
-        if (rpcm)
-                *rpcm = pcm;
 
         /* EFX capture - record the "FXBUS2" channels, by default we connect the EXTINs 
          * to these
diff --git a/sound/pci/emu10k1/p16v.c b/sound/pci/emu10k1/p16v.c
index 7ef3898a7806..3c60b433de9f 100644
--- a/sound/pci/emu10k1/p16v.c
+++ b/sound/pci/emu10k1/p16v.c
@@ -166,11 +166,8 @@ static struct snd_pcm_hardware snd_p16v_capture_hw = {
 static void snd_p16v_pcm_free_substream(struct snd_pcm_runtime *runtime)
 {
         struct snd_emu10k1_pcm *epcm = runtime->private_data;
-  
-        if (epcm) {
-                /* dev_dbg(emu->card->dev, "epcm free: %p\n", epcm); */
-                kfree(epcm);
-        }
+
+        kfree(epcm);
 }
 
 /* open_playback callback */
@@ -640,7 +637,7 @@ int snd_p16v_free(struct snd_emu10k1 *chip)
         return 0;
 }
 
-int snd_p16v_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm **rpcm)
+int snd_p16v_pcm(struct snd_emu10k1 *emu, int device)
 {
         struct snd_pcm *pcm;
         struct snd_pcm_substream *substream;
@@ -649,8 +646,6 @@ int snd_p16v_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm **rpcm)
   
         /* dev_dbg(emu->card->dev, "snd_p16v_pcm called. device=%d\n", device); */
         emu->p16v_device_offset = device;
-        if (rpcm)
-                *rpcm = NULL;
 
         if ((err = snd_pcm_new(emu->card, "p16v", device, 1, capture, &pcm)) < 0)
                 return err;
@@ -694,9 +689,6 @@ int snd_p16v_pcm(struct snd_emu10k1 *emu, int device, struct snd_pcm **rpcm)
                 */
         }
   
-        if (rpcm)
-                *rpcm = pcm;
-  
         return 0;
 }
 
diff --git a/sound/pci/ens1370.c b/sound/pci/ens1370.c
index d94cb3ca7a64..0dc44ebb0032 100644
--- a/sound/pci/ens1370.c
+++ b/sound/pci/ens1370.c
@@ -26,7 +26,7 @@
  * by Kurt J. Bosch
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -1268,14 +1268,11 @@ static const struct snd_pcm_chmap_elem surround_map[] = {
         { }
 };
 
-static int snd_ensoniq_pcm(struct ensoniq *ensoniq, int device,
-                           struct snd_pcm **rpcm)
+static int snd_ensoniq_pcm(struct ensoniq *ensoniq, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         err = snd_pcm_new(ensoniq->card, CHIP_NAME "/1", device, 1, 1, &pcm);
         if (err < 0)
                 return err;
@@ -1302,22 +1299,14 @@ static int snd_ensoniq_pcm(struct ensoniq *ensoniq, int device,
         err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
                                      snd_pcm_std_chmaps, 2, 0, NULL);
 #endif
-        if (err < 0)
-                return err;
-
-        if (rpcm)
-                *rpcm = pcm;
-        return 0;
+        return err;
 }
 
-static int snd_ensoniq_pcm2(struct ensoniq *ensoniq, int device,
-                            struct snd_pcm **rpcm)
+static int snd_ensoniq_pcm2(struct ensoniq *ensoniq, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         err = snd_pcm_new(ensoniq->card, CHIP_NAME "/2", device, 1, 0, &pcm);
         if (err < 0)
                 return err;
@@ -1342,12 +1331,7 @@ static int snd_ensoniq_pcm2(struct ensoniq *ensoniq, int device,
         err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
                                      surround_map, 2, 0, NULL);
 #endif
-        if (err < 0)
-                return err;
-
-        if (rpcm)
-                *rpcm = pcm;
-        return 0;
+        return err;
 }
 
 /*
@@ -2049,7 +2033,6 @@ static void snd_ensoniq_chip_init(struct ensoniq *ensoniq)
 #ifdef CONFIG_PM_SLEEP
 static int snd_ensoniq_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct ensoniq *ensoniq = card->private_data;
         
@@ -2070,28 +2053,14 @@ static int snd_ensoniq_suspend(struct device *dev)
         udelay(100);
         snd_ak4531_suspend(ensoniq->u.es1370.ak4531);
 #endif  
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_ensoniq_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(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) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_ensoniq_chip_init(ensoniq);
 
 #ifdef CHIP1371 
@@ -2362,14 +2331,11 @@ static struct snd_rawmidi_ops snd_ensoniq_midi_input =
         .trigger =      snd_ensoniq_midi_input_trigger,
 };
 
-static int 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;
         strcpy(rmidi->name, CHIP_NAME);
@@ -2379,8 +2345,6 @@ static int snd_ensoniq_midi(struct ensoniq *ensoniq, int device,
                 SNDRV_RAWMIDI_INFO_DUPLEX;
         rmidi->private_data = ensoniq;
         ensoniq->rmidi = rmidi;
-        if (rrawmidi)
-                *rrawmidi = rmidi;
         return 0;
 }
 
@@ -2462,15 +2426,15 @@ static int snd_audiopci_probe(struct pci_dev *pci,
                 return err;
         }
 #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;
         }
diff --git a/sound/pci/es1938.c b/sound/pci/es1938.c
index 0fc46eb4e251..e1858d9d23d8 100644
--- a/sound/pci/es1938.c
+++ b/sound/pci/es1938.c
@@ -55,6 +55,7 @@
 #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>
 #include <sound/pcm.h>
@@ -63,8 +64,6 @@
 #include <sound/initval.h>
 #include <sound/tlv.h>
 
-#include <asm/io.h>
-
 MODULE_AUTHOR("Jaromir Koutek <miri@punknet.cz>");
 MODULE_DESCRIPTION("ESS Solo-1");
 MODULE_LICENSE("GPL");
@@ -1454,7 +1453,6 @@ static unsigned char saved_regs[SAVED_REG_SIZE+1] = {
 
 static int es1938_suspend(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;
@@ -1471,9 +1469,6 @@ static int es1938_suspend(struct device *dev)
                 free_irq(chip->irq, chip);
                 chip->irq = -1;
         }
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
@@ -1484,14 +1479,6 @@ static int es1938_resume(struct device *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) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-
         if (request_irq(pci->irq, snd_es1938_interrupt,
                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
                 dev_err(dev, "unable to grab IRQ %d, disabling device\n",
diff --git a/sound/pci/es1968.c b/sound/pci/es1968.c
index 6039700f8579..059f3846d7b8 100644
--- a/sound/pci/es1968.c
+++ b/sound/pci/es1968.c
@@ -94,7 +94,7 @@
  *      places.
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -2383,7 +2383,6 @@ static void snd_es1968_start_irq(struct es1968 *chip)
  */
 static int es1968_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct es1968 *chip = card->private_data;
 
@@ -2396,16 +2395,11 @@ static int es1968_suspend(struct device *dev)
         snd_pcm_suspend_all(chip->pcm);
         snd_ac97_suspend(chip->ac97);
         snd_es1968_bob_stop(chip);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int es1968_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct es1968 *chip = card->private_data;
         struct esschan *es;
@@ -2413,16 +2407,6 @@ static int es1968_resume(struct device *dev)
         if (! chip->do_pm)
                 return 0;
 
-        /* restore all our config */
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_es1968_chip_init(chip);
 
         /* need to restore the base pointers.. */ 
diff --git a/sound/pci/fm801.c b/sound/pci/fm801.c
index d167afffce5f..1fdd92b6f18f 100644
--- a/sound/pci/fm801.c
+++ b/sound/pci/fm801.c
@@ -2,8 +2,6 @@
  *  The driver for the ForteMedia FM801 based soundcards
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
  *
- *  Support FM only card by Andy Shevchenko <andy@smile.org.ua>
- *
  *   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
@@ -14,10 +12,6 @@
  *   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
- *
  */
 
 #include <linux/delay.h>
@@ -704,13 +698,11 @@ static struct snd_pcm_ops snd_fm801_capture_ops = {
         .pointer =      snd_fm801_capture_pointer,
 };
 
-static int snd_fm801_pcm(struct fm801 *chip, int device, struct snd_pcm **rpcm)
+static int snd_fm801_pcm(struct fm801 *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(chip->card, "FM801", device, 1, 1, &pcm)) < 0)
                 return err;
 
@@ -726,16 +718,10 @@ static int snd_fm801_pcm(struct fm801 *chip, int device, struct snd_pcm **rpcm)
                                               snd_dma_pci_data(chip->pci),
                                               chip->multichannel ? 128*1024 : 64*1024, 128*1024);
 
-        err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
+        return snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
                                      snd_pcm_alt_chmaps,
                                      chip->multichannel ? 6 : 2, 0,
                                      NULL);
-        if (err < 0)
-                return err;
-
-        if (rpcm)
-                *rpcm = pcm;
-        return 0;
 }
 
 /*
@@ -1186,12 +1172,6 @@ static int snd_fm801_free(struct fm801 *chip)
                 v4l2_device_unregister(&chip->v4l2_dev);
         }
 #endif
-        if (chip->irq >= 0)
-                free_irq(chip->irq, chip);
-        pci_release_regions(chip->pci);
-        pci_disable_device(chip->pci);
-
-        kfree(chip);
         return 0;
 }
 
@@ -1214,28 +1194,23 @@ static int snd_fm801_create(struct snd_card *card,
         };
 
         *rchip = NULL;
-        if ((err = pci_enable_device(pci)) < 0)
+        if ((err = pcim_enable_device(pci)) < 0)
                 return err;
-        chip = kzalloc(sizeof(*chip), GFP_KERNEL);
-        if (chip == NULL) {
-                pci_disable_device(pci);
+        chip = devm_kzalloc(&pci->dev, sizeof(*chip), GFP_KERNEL);
+        if (chip == NULL)
                 return -ENOMEM;
-        }
         spin_lock_init(&chip->reg_lock);
         chip->card = card;
         chip->pci = pci;
         chip->irq = -1;
         chip->tea575x_tuner = tea575x_tuner;
-        if ((err = pci_request_regions(pci, "FM801")) < 0) {
-                kfree(chip);
-                pci_disable_device(pci);
+        if ((err = pci_request_regions(pci, "FM801")) < 0)
                 return err;
-        }
         chip->port = pci_resource_start(pci, 0);
         if ((tea575x_tuner & TUNER_ONLY) == 0) {
-                if (request_irq(pci->irq, snd_fm801_interrupt, IRQF_SHARED,
-                                KBUILD_MODNAME, chip)) {
-                        dev_err(card->dev, "unable to grab IRQ %d\n", chip->irq);
+                if (devm_request_irq(&pci->dev, pci->irq, snd_fm801_interrupt,
+                                IRQF_SHARED, KBUILD_MODNAME, chip)) {
+                        dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                         snd_fm801_free(chip);
                         return -EBUSY;
                 }
@@ -1250,12 +1225,6 @@ static int snd_fm801_create(struct snd_card *card,
         /* init might set tuner access method */
         tea575x_tuner = chip->tea575x_tuner;
 
-        if (chip->irq >= 0 && (tea575x_tuner & TUNER_ONLY)) {
-                pci_clear_master(pci);
-                free_irq(chip->irq, chip);
-                chip->irq = -1;
-        }
-
         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
                 snd_fm801_free(chip);
                 return err;
@@ -1340,7 +1309,7 @@ static int snd_card_fm801_probe(struct pci_dev *pci,
         if (chip->tea575x_tuner & TUNER_ONLY)
                 goto __fm801_tuner_only;
 
-        if ((err = snd_fm801_pcm(chip, 0, NULL)) < 0) {
+        if ((err = snd_fm801_pcm(chip, 0)) < 0) {
                 snd_card_free(card);
                 return err;
         }
@@ -1392,7 +1361,6 @@ static unsigned char saved_regs[] = {
 
 static int snd_fm801_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct fm801 *chip = card->private_data;
         int i;
@@ -1404,29 +1372,15 @@ static int snd_fm801_suspend(struct device *dev)
         for (i = 0; i < ARRAY_SIZE(saved_regs); i++)
                 chip->saved_regs[i] = inw(chip->port + saved_regs[i]);
         /* FIXME: tea575x suspend */
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_fm801_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct fm801 *chip = card->private_data;
         int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_fm801_chip_init(chip, 1);
         snd_ac97_resume(chip->ac97);
         snd_ac97_resume(chip->ac97_sec);
diff --git a/sound/pci/hda/Kconfig b/sound/pci/hda/Kconfig
index ebf4c2fb99df..7f0f2c5a4e97 100644
--- a/sound/pci/hda/Kconfig
+++ b/sound/pci/hda/Kconfig
@@ -107,6 +107,7 @@ config SND_HDA_PATCH_LOADER
 config SND_HDA_CODEC_REALTEK
         tristate "Build Realtek HD-audio codec support"
         select SND_HDA_GENERIC
+        select INPUT
         help
           Say Y or M here to include Realtek HD-audio codec support in
           snd-hda-intel driver, such as ALC880.
diff --git a/sound/pci/hda/hda_auto_parser.c b/sound/pci/hda/hda_auto_parser.c
index 1ede82200ee5..3f8706bb3d16 100644
--- a/sound/pci/hda/hda_auto_parser.c
+++ b/sound/pci/hda/hda_auto_parser.c
@@ -409,10 +409,10 @@ int snd_hda_parse_pin_defcfg(struct hda_codec *codec,
         /*
          * debug prints of the parsed results
          */
-        codec_info(codec, "autoconfig: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x) type:%s\n",
-                   cfg->line_outs, cfg->line_out_pins[0], cfg->line_out_pins[1],
-                   cfg->line_out_pins[2], cfg->line_out_pins[3],
-                   cfg->line_out_pins[4],
+        codec_info(codec, "autoconfig for %s: line_outs=%d (0x%x/0x%x/0x%x/0x%x/0x%x) type:%s\n",
+                   codec->chip_name, cfg->line_outs, cfg->line_out_pins[0],
+                   cfg->line_out_pins[1], cfg->line_out_pins[2],
+                   cfg->line_out_pins[3], cfg->line_out_pins[4],
                    cfg->line_out_type == AUTO_PIN_HP_OUT ? "hp" :
                    (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT ?
                     "speaker" : "line"));
@@ -920,6 +920,8 @@ void snd_hda_pick_pin_fixup(struct hda_codec *codec,
                         codec->fixup_id = pq->value;
 #ifdef CONFIG_SND_DEBUG_VERBOSE
                         codec->fixup_name = pq->name;
+                        codec_dbg(codec, "%s: picked fixup %s (pin match)\n",
+                                  codec->chip_name, codec->fixup_name);
 #endif
                         codec->fixup_list = fixlist;
                         return;
@@ -960,6 +962,8 @@ void snd_hda_pick_fixup(struct hda_codec *codec,
                 codec->fixup_list = NULL;
                 codec->fixup_name = NULL;
                 codec->fixup_id = HDA_FIXUP_ID_NO_FIXUP;
+                codec_dbg(codec, "%s: picked no fixup (nofixup specified)\n",
+                          codec->chip_name);
                 return;
         }
 
@@ -969,6 +973,8 @@ void snd_hda_pick_fixup(struct hda_codec *codec,
                                 codec->fixup_id = models->id;
                                 codec->fixup_name = models->name;
                                 codec->fixup_list = fixlist;
+                                codec_dbg(codec, "%s: picked fixup %s (model specified)\n",
+                                          codec->chip_name, codec->fixup_name);
                                 return;
                         }
                         models++;
@@ -980,6 +986,8 @@ void snd_hda_pick_fixup(struct hda_codec *codec,
                         id = q->value;
 #ifdef CONFIG_SND_DEBUG_VERBOSE
                         name = q->name;
+                        codec_dbg(codec, "%s: picked fixup %s (PCI SSID%s)\n",
+                                  codec->chip_name, name, q->subdevice_mask ? "" : " - vendor generic");
 #endif
                 }
         }
@@ -992,6 +1000,8 @@ void snd_hda_pick_fixup(struct hda_codec *codec,
                                 id = q->value;
 #ifdef CONFIG_SND_DEBUG_VERBOSE
                                 name = q->name;
+                                codec_dbg(codec, "%s: picked fixup %s (codec SSID)\n",
+                                          codec->chip_name, name);
 #endif
                                 break;
                         }
diff --git a/sound/pci/hda/hda_controller.c b/sound/pci/hda/hda_controller.c
index 0cfc9c8c4b4e..a2ce773bdc62 100644
--- a/sound/pci/hda/hda_controller.c
+++ b/sound/pci/hda/hda_controller.c
@@ -657,6 +657,9 @@ static int azx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
                 azx_writel(chip, SSYNC, azx_readl(chip, SSYNC) & ~sbits);
         if (start) {
                 azx_timecounter_init(substream, 0, 0);
+                snd_pcm_gettime(substream->runtime, &substream->runtime->trigger_tstamp);
+                substream->runtime->trigger_tstamp_latched = true;
+
                 if (nsync > 1) {
                         cycle_t cycle_last;
 
@@ -939,7 +942,8 @@ static int azx_attach_pcm_stream(struct hda_bus *bus, struct hda_codec *codec,
                                               chip->card->dev,
                                               size, MAX_PREALLOC_SIZE);
         /* link to codec */
-        pcm->dev = &codec->dev;
+        for (s = 0; s < 2; s++)
+                pcm->streams[s].dev.parent = &codec->dev;
         return 0;
 }
 
@@ -957,7 +961,6 @@ static int azx_alloc_cmd_io(struct azx *chip)
                 dev_err(chip->card->dev, "cannot allocate CORB/RIRB\n");
         return err;
 }
-EXPORT_SYMBOL_GPL(azx_alloc_cmd_io);
 
 static void azx_init_cmd_io(struct azx *chip)
 {
@@ -1022,7 +1025,6 @@ static void azx_init_cmd_io(struct azx *chip)
         azx_writeb(chip, RIRBCTL, AZX_RBCTL_DMA_EN | AZX_RBCTL_IRQ_EN);
         spin_unlock_irq(&chip->reg_lock);
 }
-EXPORT_SYMBOL_GPL(azx_init_cmd_io);
 
 static void azx_free_cmd_io(struct azx *chip)
 {
@@ -1032,7 +1034,6 @@ static void azx_free_cmd_io(struct azx *chip)
         azx_writeb(chip, CORBCTL, 0);
         spin_unlock_irq(&chip->reg_lock);
 }
-EXPORT_SYMBOL_GPL(azx_free_cmd_io);
 
 static unsigned int azx_command_addr(u32 cmd)
 {
@@ -1312,7 +1313,6 @@ static int azx_send_cmd(struct hda_bus *bus, unsigned int val)
         else
                 return azx_corb_send_cmd(bus, val);
 }
-EXPORT_SYMBOL_GPL(azx_send_cmd);
 
 /* get a response */
 static unsigned int azx_get_response(struct hda_bus *bus,
@@ -1326,7 +1326,6 @@ static unsigned int azx_get_response(struct hda_bus *bus,
         else
                 return azx_rirb_get_response(bus, addr);
 }
-EXPORT_SYMBOL_GPL(azx_get_response);
 
 #ifdef CONFIG_SND_HDA_DSP_LOADER
 /*
@@ -1993,4 +1992,4 @@ void azx_notifier_unregister(struct azx *chip)
 EXPORT_SYMBOL_GPL(azx_notifier_unregister);
 
 MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("Common HDA driver funcitons");
+MODULE_DESCRIPTION("Common HDA driver functions");
diff --git a/sound/pci/hda/hda_hwdep.c b/sound/pci/hda/hda_hwdep.c
index 014a7849e8fd..11b5a42b4ec8 100644
--- a/sound/pci/hda/hda_hwdep.c
+++ b/sound/pci/hda/hda_hwdep.c
@@ -109,7 +109,6 @@ int snd_hda_create_hwdep(struct hda_codec *codec)
         hwdep->iface = SNDRV_HWDEP_IFACE_HDA;
         hwdep->private_data = codec;
         hwdep->exclusive = 1;
-        hwdep->groups = snd_hda_dev_attr_groups;
 
         hwdep->ops.open = hda_hwdep_open;
         hwdep->ops.ioctl = hda_hwdep_ioctl;
@@ -118,7 +117,11 @@ int snd_hda_create_hwdep(struct hda_codec *codec)
 #endif
 
         /* link to codec */
-        hwdep->dev = &codec->dev;
+        hwdep->dev.parent = &codec->dev;
+
+        /* for sysfs */
+        hwdep->dev.groups = snd_hda_dev_attr_groups;
+        dev_set_drvdata(&hwdep->dev, codec);
 
         return 0;
 }
diff --git a/sound/pci/hda/hda_i915.c b/sound/pci/hda/hda_i915.c
index d4d0375ac181..714894527e06 100644
--- a/sound/pci/hda/hda_i915.c
+++ b/sound/pci/hda/hda_i915.c
@@ -18,10 +18,12 @@
 
 #include <linux/init.h>
 #include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/component.h>
+#include <drm/i915_component.h>
 #include <sound/core.h>
-#include <drm/i915_powerwell.h>
 #include "hda_priv.h"
-#include "hda_i915.h"
+#include "hda_intel.h"
 
 /* Intel HSW/BDW display HDA controller Extended Mode registers.
  * EM4 (M value) and EM5 (N Value) are used to convert CDClk (Core Display
@@ -31,32 +33,33 @@
 #define AZX_REG_EM4                     0x100c
 #define AZX_REG_EM5                     0x1010
 
-static int (*get_power)(void);
-static int (*put_power)(void);
-static int (*get_cdclk)(void);
-
-int hda_display_power(bool enable)
+int hda_display_power(struct hda_intel *hda, bool enable)
 {
-        if (!get_power || !put_power)
+        struct i915_audio_component *acomp = &hda->audio_component;
+
+        if (!acomp->ops)
                 return -ENODEV;
 
-        pr_debug("HDA display power %s \n",
-                        enable ? "Enable" : "Disable");
+        dev_dbg(&hda->chip.pci->dev, "display power %s\n",
+                enable ? "enable" : "disable");
         if (enable)
-                return get_power();
+                acomp->ops->get_power(acomp->dev);
         else
-                return put_power();
+                acomp->ops->put_power(acomp->dev);
+
+        return 0;
 }
 
-void haswell_set_bclk(struct azx *chip)
+void haswell_set_bclk(struct hda_intel *hda)
 {
         int cdclk_freq;
         unsigned int bclk_m, bclk_n;
+        struct i915_audio_component *acomp = &hda->audio_component;
 
-        if (!get_cdclk)
+        if (!acomp->ops)
                 return;
 
-        cdclk_freq = get_cdclk();
+        cdclk_freq = acomp->ops->get_cdclk_freq(acomp->dev);
         switch (cdclk_freq) {
         case 337500:
                 bclk_m = 16;
@@ -80,51 +83,108 @@ void haswell_set_bclk(struct azx *chip)
                 break;
         }
 
-        azx_writew(chip, EM4, bclk_m);
-        azx_writew(chip, EM5, bclk_n);
+        azx_writew(&hda->chip, EM4, bclk_m);
+        azx_writew(&hda->chip, EM5, bclk_n);
 }
 
-
-int hda_i915_init(void)
+static int hda_component_master_bind(struct device *dev)
 {
-        int err = 0;
-
-        get_power = symbol_request(i915_request_power_well);
-        if (!get_power) {
-                pr_warn("hda-i915: get_power symbol get fail\n");
-                return -ENODEV;
+        struct snd_card *card = dev_get_drvdata(dev);
+        struct azx *chip = card->private_data;
+        struct hda_intel *hda = container_of(chip, struct hda_intel, chip);
+        struct i915_audio_component *acomp = &hda->audio_component;
+        int ret;
+
+        ret = component_bind_all(dev, acomp);
+        if (ret < 0)
+                return ret;
+
+        if (WARN_ON(!(acomp->dev && acomp->ops && acomp->ops->get_power &&
+                      acomp->ops->put_power && acomp->ops->get_cdclk_freq))) {
+                ret = -EINVAL;
+                goto out_unbind;
         }
 
-        put_power = symbol_request(i915_release_power_well);
-        if (!put_power) {
-                symbol_put(i915_request_power_well);
-                get_power = NULL;
-                return -ENODEV;
+        /*
+         * Atm, we don't support dynamic unbinding initiated by the child
+         * component, so pin its containing module until we unbind.
+         */
+        if (!try_module_get(acomp->ops->owner)) {
+                ret = -ENODEV;
+                goto out_unbind;
         }
 
-        get_cdclk = symbol_request(i915_get_cdclk_freq);
-        if (!get_cdclk) /* may have abnormal BCLK and audio playback rate */
-                pr_warn("hda-i915: get_cdclk symbol get fail\n");
+        return 0;
 
-        pr_debug("HDA driver get symbol successfully from i915 module\n");
+out_unbind:
+        component_unbind_all(dev, acomp);
 
-        return err;
+        return ret;
 }
 
-int hda_i915_exit(void)
+static void hda_component_master_unbind(struct device *dev)
 {
-        if (get_power) {
-                symbol_put(i915_request_power_well);
-                get_power = NULL;
-        }
-        if (put_power) {
-                symbol_put(i915_release_power_well);
-                put_power = NULL;
-        }
-        if (get_cdclk) {
-                symbol_put(i915_get_cdclk_freq);
-                get_cdclk = NULL;
+        struct snd_card *card = dev_get_drvdata(dev);
+        struct azx *chip = card->private_data;
+        struct hda_intel *hda = container_of(chip, struct hda_intel, chip);
+        struct i915_audio_component *acomp = &hda->audio_component;
+
+        module_put(acomp->ops->owner);
+        component_unbind_all(dev, acomp);
+        WARN_ON(acomp->ops || acomp->dev);
+}
+
+static const struct component_master_ops hda_component_master_ops = {
+        .bind = hda_component_master_bind,
+        .unbind = hda_component_master_unbind,
+};
+
+static int hda_component_master_match(struct device *dev, void *data)
+{
+        /* i915 is the only supported component */
+        return !strcmp(dev->driver->name, "i915");
+}
+
+int hda_i915_init(struct hda_intel *hda)
+{
+        struct component_match *match = NULL;
+        struct device *dev = &hda->chip.pci->dev;
+        struct i915_audio_component *acomp = &hda->audio_component;
+        int ret;
+
+        component_match_add(dev, &match, hda_component_master_match, hda);
+        ret = component_master_add_with_match(dev, &hda_component_master_ops,
+                                              match);
+        if (ret < 0)
+                goto out_err;
+
+        /*
+         * Atm, we don't support deferring the component binding, so make sure
+         * i915 is loaded and that the binding successfully completes.
+         */
+        request_module("i915");
+
+        if (!acomp->ops) {
+                ret = -ENODEV;
+                goto out_master_del;
         }
 
+        dev_dbg(dev, "bound to i915 component master\n");
+
+        return 0;
+out_master_del:
+        component_master_del(dev, &hda_component_master_ops);
+out_err:
+        dev_err(dev, "failed to add i915 component master (%d)\n", ret);
+
+        return ret;
+}
+
+int hda_i915_exit(struct hda_intel *hda)
+{
+        struct device *dev = &hda->chip.pci->dev;
+
+        component_master_del(dev, &hda_component_master_ops);
+
         return 0;
 }
diff --git a/sound/pci/hda/hda_i915.h b/sound/pci/hda/hda_i915.h
deleted file mode 100644
index e6072c627583..000000000000
--- a/sound/pci/hda/hda_i915.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- *  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.
- */
-#ifndef __SOUND_HDA_I915_H
-#define __SOUND_HDA_I915_H
-
-#ifdef CONFIG_SND_HDA_I915
-int hda_display_power(bool enable);
-void haswell_set_bclk(struct azx *chip);
-int hda_i915_init(void);
-int hda_i915_exit(void);
-#else
-static inline int hda_display_power(bool enable) { return 0; }
-static inline void haswell_set_bclk(struct azx *chip) { return; }
-static inline int hda_i915_init(void)
-{
-        return -ENODEV;
-}
-static inline int hda_i915_exit(void)
-{
-        return 0;
-}
-#endif
-
-#endif
diff --git a/sound/pci/hda/hda_intel.c b/sound/pci/hda/hda_intel.c
index d426a0bd6a5f..4ca3d5d02436 100644
--- a/sound/pci/hda/hda_intel.c
+++ b/sound/pci/hda/hda_intel.c
@@ -63,7 +63,7 @@
 #include "hda_codec.h"
 #include "hda_controller.h"
 #include "hda_priv.h"
-#include "hda_i915.h"
+#include "hda_intel.h"
 
 /* position fix mode */
 enum {
@@ -354,31 +354,6 @@ static char *driver_short_names[] = {
         [AZX_DRIVER_GENERIC] = "HD-Audio Generic",
 };
 
-struct hda_intel {
-        struct azx chip;
-
-        /* for pending irqs */
-        struct work_struct irq_pending_work;
-
-        /* sync probing */
-        struct completion probe_wait;
-        struct work_struct probe_work;
-
-        /* card list (for power_save trigger) */
-        struct list_head list;
-
-        /* extra flags */
-        unsigned int irq_pending_warned:1;
-
-        /* VGA-switcheroo setup */
-        unsigned int use_vga_switcheroo:1;
-        unsigned int vga_switcheroo_registered:1;
-        unsigned int init_failed:1; /* delayed init failed */
-
-        /* secondary power domain for hdmi audio under vga device */
-        struct dev_pm_domain hdmi_pm_domain;
-};
-
 #ifdef CONFIG_X86
 static void __mark_pages_wc(struct azx *chip, struct snd_dma_buffer *dmab, bool on)
 {
@@ -795,7 +770,6 @@ static int param_set_xint(const char *val, const struct kernel_param *kp)
  */
 static int azx_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct azx *chip;
         struct hda_intel *hda;
@@ -824,11 +798,8 @@ static int azx_suspend(struct device *dev)
 
         if (chip->msi)
                 pci_disable_msi(chip->pci);
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL)
-                hda_display_power(false);
+                hda_display_power(hda, false);
         return 0;
 }
 
@@ -848,18 +819,9 @@ static int azx_resume(struct device *dev)
                 return 0;
 
         if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL) {
-                hda_display_power(true);
-                haswell_set_bclk(chip);
-        }
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(chip->card->dev,
-                        "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
+                hda_display_power(hda, true);
+                haswell_set_bclk(hda);
         }
-        pci_set_master(pci);
         if (chip->msi)
                 if (pci_enable_msi(pci) < 0)
                         chip->msi = 0;
@@ -901,7 +863,7 @@ static int azx_runtime_suspend(struct device *dev)
         azx_enter_link_reset(chip);
         azx_clear_irq_pending(chip);
         if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL)
-                hda_display_power(false);
+                hda_display_power(hda, false);
 
         return 0;
 }
@@ -927,8 +889,8 @@ static int azx_runtime_resume(struct device *dev)
                 return 0;
 
         if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL) {
-                hda_display_power(true);
-                haswell_set_bclk(chip);
+                hda_display_power(hda, true);
+                haswell_set_bclk(hda);
         }
 
         /* Read STATESTS before controller reset */
@@ -1138,8 +1100,7 @@ static int azx_free(struct azx *chip)
                 free_irq(chip->irq, (void*)chip);
         if (chip->msi)
                 pci_disable_msi(chip->pci);
-        if (chip->remap_addr)
-                iounmap(chip->remap_addr);
+        iounmap(chip->remap_addr);
 
         azx_free_stream_pages(chip);
         if (chip->region_requested)
@@ -1150,8 +1111,8 @@ static int azx_free(struct azx *chip)
         release_firmware(chip->fw);
 #endif
         if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL) {
-                hda_display_power(false);
-                hda_i915_exit();
+                hda_display_power(hda, false);
+                hda_i915_exit(hda);
         }
         kfree(hda);
 
@@ -1629,8 +1590,12 @@ static int azx_first_init(struct azx *chip)
         /* initialize chip */
         azx_init_pci(chip);
 
-        if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL)
-                haswell_set_bclk(chip);
+        if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL) {
+                struct hda_intel *hda;
+
+                hda = container_of(chip, struct hda_intel, chip);
+                haswell_set_bclk(hda);
+        }
 
         azx_init_chip(chip, (probe_only[dev] & 2) == 0);
 
@@ -1910,13 +1875,10 @@ static int azx_probe_continue(struct azx *chip)
         /* Request power well for Haswell HDA controller and codec */
         if (chip->driver_caps & AZX_DCAPS_I915_POWERWELL) {
 #ifdef CONFIG_SND_HDA_I915
-                err = hda_i915_init();
-                if (err < 0) {
-                        dev_err(chip->card->dev,
-                                "Error request power-well from i915\n");
+                err = hda_i915_init(hda);
+                if (err < 0)
                         goto out_free;
-                }
-                err = hda_display_power(true);
+                err = hda_display_power(hda, true);
                 if (err < 0) {
                         dev_err(chip->card->dev,
                                 "Cannot turn on display power on i915\n");
@@ -2004,7 +1966,7 @@ static const struct pci_device_id azx_ids[] = {
           .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH_NOPM },
         /* Panther Point */
         { PCI_DEVICE(0x8086, 0x1e20),
-          .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH },
+          .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH_NOPM },
         /* Lynx Point */
         { PCI_DEVICE(0x8086, 0x8c20),
           .driver_data = AZX_DRIVER_PCH | AZX_DCAPS_INTEL_PCH },
diff --git a/sound/pci/hda/hda_intel.h b/sound/pci/hda/hda_intel.h
new file mode 100644
index 000000000000..348611835476
--- /dev/null
+++ b/sound/pci/hda/hda_intel.h
@@ -0,0 +1,71 @@
+/*
+ *  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.
+ */
+#ifndef __SOUND_HDA_INTEL_H
+#define __SOUND_HDA_INTEL_H
+
+#include <drm/i915_component.h>
+#include "hda_priv.h"
+
+struct hda_intel {
+        struct azx chip;
+
+        /* for pending irqs */
+        struct work_struct irq_pending_work;
+
+        /* sync probing */
+        struct completion probe_wait;
+        struct work_struct probe_work;
+
+        /* card list (for power_save trigger) */
+        struct list_head list;
+
+        /* extra flags */
+        unsigned int irq_pending_warned:1;
+
+        /* VGA-switcheroo setup */
+        unsigned int use_vga_switcheroo:1;
+        unsigned int vga_switcheroo_registered:1;
+        unsigned int init_failed:1; /* delayed init failed */
+
+        /* secondary power domain for hdmi audio under vga device */
+        struct dev_pm_domain hdmi_pm_domain;
+
+        /* i915 component interface */
+        struct i915_audio_component audio_component;
+};
+
+#ifdef CONFIG_SND_HDA_I915
+int hda_display_power(struct hda_intel *hda, bool enable);
+void haswell_set_bclk(struct hda_intel *hda);
+int hda_i915_init(struct hda_intel *hda);
+int hda_i915_exit(struct hda_intel *hda);
+#else
+static inline int hda_display_power(struct hda_intel *hda, bool enable)
+{
+        return 0;
+}
+static inline void haswell_set_bclk(struct hda_intel *hda) { return; }
+static inline int hda_i915_init(struct hda_intel *hda)
+{
+        return -ENODEV;
+}
+static inline int hda_i915_exit(struct hda_intel *hda)
+{
+        return 0;
+}
+#endif
+
+#endif
diff --git a/sound/pci/hda/hda_priv.h b/sound/pci/hda/hda_priv.h
index 166e3e84b963..daf458299753 100644
--- a/sound/pci/hda/hda_priv.h
+++ b/sound/pci/hda/hda_priv.h
@@ -15,7 +15,7 @@
 #ifndef __SOUND_HDA_PRIV_H
 #define __SOUND_HDA_PRIV_H
 
-#include <linux/clocksource.h>
+#include <linux/timecounter.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 
diff --git a/sound/pci/hda/hda_tegra.c b/sound/pci/hda/hda_tegra.c
index 227990bc02e3..375e94f4cf52 100644
--- a/sound/pci/hda/hda_tegra.c
+++ b/sound/pci/hda/hda_tegra.c
@@ -329,8 +329,8 @@ static int hda_tegra_init_chip(struct azx *chip, struct platform_device *pdev)
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         hda->regs = devm_ioremap_resource(dev, res);
-        if (IS_ERR(chip->remap_addr))
-                return PTR_ERR(chip->remap_addr);
+        if (IS_ERR(hda->regs))
+                return PTR_ERR(hda->regs);
 
         chip->remap_addr = hda->regs + HDA_BAR0;
         chip->addr = res->start + HDA_BAR0;
diff --git a/sound/pci/hda/patch_analog.c b/sound/pci/hda/patch_analog.c
index a9d78e275138..d285904cdb64 100644
--- a/sound/pci/hda/patch_analog.c
+++ b/sound/pci/hda/patch_analog.c
@@ -739,39 +739,6 @@ static int patch_ad1981(struct hda_codec *codec)
  *      E/F quad mic array
  */
 
-#ifdef ENABLE_AD_STATIC_QUIRKS
-static int ad198x_ch_mode_info(struct snd_kcontrol *kcontrol,
-                               struct snd_ctl_elem_info *uinfo)
-{
-        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        struct ad198x_spec *spec = codec->spec;
-        return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
-                                    spec->num_channel_mode);
-}
-
-static int ad198x_ch_mode_get(struct snd_kcontrol *kcontrol,
-                              struct snd_ctl_elem_value *ucontrol)
-{
-        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        struct ad198x_spec *spec = codec->spec;
-        return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
-                                   spec->num_channel_mode, spec->multiout.max_channels);
-}
-
-static int ad198x_ch_mode_put(struct snd_kcontrol *kcontrol,
-                              struct snd_ctl_elem_value *ucontrol)
-{
-        struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
-        struct ad198x_spec *spec = codec->spec;
-        int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
-                                      spec->num_channel_mode,
-                                      &spec->multiout.max_channels);
-        if (err >= 0 && spec->need_dac_fix)
-                spec->multiout.num_dacs = spec->multiout.max_channels / 2;
-        return err;
-}
-#endif /* ENABLE_AD_STATIC_QUIRKS */
-
 static int ad1988_auto_smux_enum_info(struct snd_kcontrol *kcontrol,
                                       struct snd_ctl_elem_info *uinfo)
 {
diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
index 65f1f4e18ea5..b2b24a8b3dac 100644
--- a/sound/pci/hda/patch_realtek.c
+++ b/sound/pci/hda/patch_realtek.c
@@ -29,6 +29,7 @@
 #include <linux/pci.h>
 #include <linux/dmi.h>
 #include <linux/module.h>
+#include <linux/input.h>
 #include <sound/core.h>
 #include <sound/jack.h>
 #include "hda_codec.h"
@@ -120,6 +121,7 @@ struct alc_spec {
         hda_nid_t pll_nid;
         unsigned int pll_coef_idx, pll_coef_bit;
         unsigned int coef0;
+        struct input_dev *kb_dev;
 };
 
 /*
@@ -3472,6 +3474,79 @@ static void alc280_fixup_hp_gpio4(struct hda_codec *codec,
         }
 }
 
+static void gpio2_mic_hotkey_event(struct hda_codec *codec,
+                                   struct hda_jack_callback *event)
+{
+        struct alc_spec *spec = codec->spec;
+
+        /* GPIO2 just toggles on a keypress/keyrelease cycle. Therefore
+           send both key on and key off event for every interrupt. */
+        input_report_key(spec->kb_dev, KEY_MICMUTE, 1);
+        input_sync(spec->kb_dev);
+        input_report_key(spec->kb_dev, KEY_MICMUTE, 0);
+        input_sync(spec->kb_dev);
+}
+
+static void alc280_fixup_hp_gpio2_mic_hotkey(struct hda_codec *codec,
+                                             const struct hda_fixup *fix, int action)
+{
+        /* GPIO1 = set according to SKU external amp
+           GPIO2 = mic mute hotkey
+           GPIO3 = mute LED
+           GPIO4 = mic mute LED */
+        static const struct hda_verb gpio_init[] = {
+                { 0x01, AC_VERB_SET_GPIO_MASK, 0x1e },
+                { 0x01, AC_VERB_SET_GPIO_DIRECTION, 0x1a },
+                { 0x01, AC_VERB_SET_GPIO_DATA, 0x02 },
+                {}
+        };
+
+        struct alc_spec *spec = codec->spec;
+
+        if (action == HDA_FIXUP_ACT_PRE_PROBE) {
+                spec->kb_dev = input_allocate_device();
+                if (!spec->kb_dev) {
+                        codec_err(codec, "Out of memory (input_allocate_device)\n");
+                        return;
+                }
+                spec->kb_dev->name = "Microphone Mute Button";
+                spec->kb_dev->evbit[0] = BIT_MASK(EV_KEY);
+                spec->kb_dev->keybit[BIT_WORD(KEY_MICMUTE)] = BIT_MASK(KEY_MICMUTE);
+                if (input_register_device(spec->kb_dev)) {
+                        codec_err(codec, "input_register_device failed\n");
+                        input_free_device(spec->kb_dev);
+                        spec->kb_dev = NULL;
+                        return;
+                }
+
+                snd_hda_add_verbs(codec, gpio_init);
+                snd_hda_codec_write_cache(codec, codec->afg, 0,
+                                          AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x04);
+                snd_hda_jack_detect_enable_callback(codec, codec->afg,
+                                                    gpio2_mic_hotkey_event);
+
+                spec->gen.vmaster_mute.hook = alc_fixup_gpio_mute_hook;
+                spec->gen.cap_sync_hook = alc_fixup_gpio_mic_mute_hook;
+                spec->gpio_led = 0;
+                spec->mute_led_polarity = 0;
+                spec->gpio_mute_led_mask = 0x08;
+                spec->gpio_mic_led_mask = 0x10;
+                return;
+        }
+
+        if (!spec->kb_dev)
+                return;
+
+        switch (action) {
+        case HDA_FIXUP_ACT_PROBE:
+                spec->init_amp = ALC_INIT_DEFAULT;
+                break;
+        case HDA_FIXUP_ACT_FREE:
+                input_unregister_device(spec->kb_dev);
+                spec->kb_dev = NULL;
+        }
+}
+
 static void alc269_fixup_hp_line1_mic1_led(struct hda_codec *codec,
                                 const struct hda_fixup *fix, int action)
 {
@@ -4341,6 +4416,8 @@ enum {
         ALC282_FIXUP_ASPIRE_V5_PINS,
         ALC280_FIXUP_HP_GPIO4,
         ALC286_FIXUP_HP_GPIO_LED,
+        ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY,
+        ALC280_FIXUP_HP_DOCK_PINS,
 };
 
 static const struct hda_fixup alc269_fixups[] = {
@@ -4814,6 +4891,21 @@ static const struct hda_fixup alc269_fixups[] = {
                 .type = HDA_FIXUP_FUNC,
                 .v.func = alc286_fixup_hp_gpio_led,
         },
+        [ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = alc280_fixup_hp_gpio2_mic_hotkey,
+        },
+        [ALC280_FIXUP_HP_DOCK_PINS] = {
+                .type = HDA_FIXUP_PINS,
+                .v.pins = (const struct hda_pintbl[]) {
+                        { 0x1b, 0x21011020 }, /* line-out */
+                        { 0x1a, 0x01a1903c }, /* headset mic */
+                        { 0x18, 0x2181103f }, /* line-in */
+                        { },
+                },
+                .chained = true,
+                .chain_id = ALC280_FIXUP_HP_GPIO4
+        },
 };
 
 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
@@ -4843,7 +4935,9 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = {
         SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2),
         SND_PCI_QUIRK(0x103c, 0x18e6, "HP", ALC269_FIXUP_HP_GPIO_LED),
         SND_PCI_QUIRK(0x103c, 0x218b, "HP", ALC269_FIXUP_LIMIT_INT_MIC_BOOST_MUTE_LED),
+        SND_PCI_QUIRK(0x103c, 0x225f, "HP", ALC280_FIXUP_HP_GPIO2_MIC_HOTKEY),
         /* ALC282 */
+        SND_PCI_QUIRK(0x103c, 0x21f9, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
         SND_PCI_QUIRK(0x103c, 0x2210, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
         SND_PCI_QUIRK(0x103c, 0x2214, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
         SND_PCI_QUIRK(0x103c, 0x2236, "HP", ALC269_FIXUP_HP_LINE1_MIC1_LED),
@@ -4856,6 +4950,8 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = {
         SND_PCI_QUIRK(0x103c, 0x226b, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
         SND_PCI_QUIRK(0x103c, 0x226e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
         SND_PCI_QUIRK(0x103c, 0x2271, "HP", ALC286_FIXUP_HP_GPIO_LED),
+        SND_PCI_QUIRK(0x103c, 0x2272, "HP", ALC280_FIXUP_HP_DOCK_PINS),
+        SND_PCI_QUIRK(0x103c, 0x2273, "HP", ALC280_FIXUP_HP_DOCK_PINS),
         SND_PCI_QUIRK(0x103c, 0x229e, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
         SND_PCI_QUIRK(0x103c, 0x22b2, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
         SND_PCI_QUIRK(0x103c, 0x22b7, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
diff --git a/sound/pci/hda/patch_sigmatel.c b/sound/pci/hda/patch_sigmatel.c
index 605d14003d25..87eff3173ce9 100644
--- a/sound/pci/hda/patch_sigmatel.c
+++ b/sound/pci/hda/patch_sigmatel.c
@@ -79,6 +79,7 @@ enum {
         STAC_ALIENWARE_M17X,
         STAC_92HD89XX_HP_FRONT_JACK,
         STAC_92HD89XX_HP_Z1_G2_RIGHT_MIC_JACK,
+        STAC_92HD73XX_ASUS_MOBO,
         STAC_92HD73XX_MODELS
 };
 
@@ -99,6 +100,7 @@ enum {
         STAC_HP_ENVY_BASS,
         STAC_HP_BNB13_EQ,
         STAC_HP_ENVY_TS_BASS,
+        STAC_92HD83XXX_GPIO10_EAPD,
         STAC_92HD83XXX_MODELS
 };
 
@@ -1910,7 +1912,18 @@ static const struct hda_fixup stac92hd73xx_fixups[] = {
         [STAC_92HD89XX_HP_Z1_G2_RIGHT_MIC_JACK] = {
                 .type = HDA_FIXUP_PINS,
                 .v.pins = stac92hd89xx_hp_z1_g2_right_mic_jack_pin_configs,
-        }
+        },
+        [STAC_92HD73XX_ASUS_MOBO] = {
+                .type = HDA_FIXUP_PINS,
+                .v.pins = (const struct hda_pintbl[]) {
+                        /* enable 5.1 and SPDIF out */
+                        { 0x0c, 0x01014411 },
+                        { 0x0d, 0x01014410 },
+                        { 0x0e, 0x01014412 },
+                        { 0x22, 0x014b1180 },
+                        { }
+                }
+        },
 };
 
 static const struct hda_model_fixup stac92hd73xx_models[] = {
@@ -1922,6 +1935,7 @@ static const struct hda_model_fixup stac92hd73xx_models[] = {
         { .id = STAC_DELL_M6_BOTH, .name = "dell-m6" },
         { .id = STAC_DELL_EQ, .name = "dell-eq" },
         { .id = STAC_ALIENWARE_M17X, .name = "alienware" },
+        { .id = STAC_92HD73XX_ASUS_MOBO, .name = "asus-mobo" },
         {}
 };
 
@@ -1974,6 +1988,8 @@ static const struct snd_pci_quirk stac92hd73xx_fixup_tbl[] = {
                                 "HP Z1 G2", STAC_92HD89XX_HP_Z1_G2_RIGHT_MIC_JACK),
         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x2b17,
                                 "unknown HP", STAC_92HD89XX_HP_FRONT_JACK),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_ASUSTEK, 0x83f8, "ASUS AT4NM10",
+                      STAC_92HD73XX_ASUS_MOBO),
         {} /* terminator */
 };
 
@@ -2141,6 +2157,19 @@ static void stac92hd83xxx_fixup_headset_jack(struct hda_codec *codec,
                 spec->headset_jack = 1;
 }
 
+static void stac92hd83xxx_fixup_gpio10_eapd(struct hda_codec *codec,
+                                            const struct hda_fixup *fix,
+                                            int action)
+{
+        struct sigmatel_spec *spec = codec->spec;
+
+        if (action != HDA_FIXUP_ACT_PRE_PROBE)
+                return;
+        spec->eapd_mask = spec->gpio_mask = spec->gpio_dir =
+                spec->gpio_data = 0x10;
+        spec->eapd_switch = 0;
+}
+
 static const struct hda_verb hp_bnb13_eq_verbs[] = {
         /* 44.1KHz base */
         { 0x22, 0x7A6, 0x3E },
@@ -2656,6 +2685,10 @@ static const struct hda_fixup stac92hd83xxx_fixups[] = {
                         {}
                 },
         },
+        [STAC_92HD83XXX_GPIO10_EAPD] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = stac92hd83xxx_fixup_gpio10_eapd,
+        },
 };
 
 static const struct hda_model_fixup stac92hd83xxx_models[] = {
@@ -2861,6 +2894,8 @@ static const struct snd_pci_quirk stac92hd83xxx_fixup_tbl[] = {
         SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x148a,
                       "HP Mini", STAC_92HD83XXX_HP_LED),
         SND_PCI_QUIRK_VENDOR(PCI_VENDOR_ID_HP, "HP", STAC_92HD83XXX_HP),
+        SND_PCI_QUIRK(PCI_VENDOR_ID_TOSHIBA, 0xfa91,
+                      "Toshiba Satellite S50D", STAC_92HD83XXX_GPIO10_EAPD),
         {} /* terminator */
 };
 
diff --git a/sound/pci/ice1712/ak4xxx.c b/sound/pci/ice1712/ak4xxx.c
index 3981823f9094..179ef7a5f0d1 100644
--- a/sound/pci/ice1712/ak4xxx.c
+++ b/sound/pci/ice1712/ak4xxx.c
@@ -21,7 +21,7 @@
  *
  */      
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/slab.h>
diff --git a/sound/pci/ice1712/ice1712.c b/sound/pci/ice1712/ice1712.c
index b039b46152c6..f7b1523e8a82 100644
--- a/sound/pci/ice1712/ice1712.c
+++ b/sound/pci/ice1712/ice1712.c
@@ -880,13 +880,11 @@ static struct snd_pcm_ops snd_ice1712_capture_ops = {
         .pointer =      snd_ice1712_capture_pointer,
 };
 
-static int snd_ice1712_pcm(struct snd_ice1712 *ice, int device, struct snd_pcm **rpcm)
+static int snd_ice1712_pcm(struct snd_ice1712 *ice, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         err = snd_pcm_new(ice->card, "ICE1712 consumer", device, 1, 1, &pcm);
         if (err < 0)
                 return err;
@@ -902,22 +900,17 @@ static int snd_ice1712_pcm(struct snd_ice1712 *ice, int device, struct snd_pcm *
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(ice->pci), 64*1024, 64*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
-
         dev_warn(ice->card->dev,
                  "Consumer PCM code does not work well at the moment --jk\n");
 
         return 0;
 }
 
-static int snd_ice1712_pcm_ds(struct snd_ice1712 *ice, int device, struct snd_pcm **rpcm)
+static int snd_ice1712_pcm_ds(struct snd_ice1712 *ice, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         err = snd_pcm_new(ice->card, "ICE1712 consumer (DS)", device, 6, 0, &pcm);
         if (err < 0)
                 return err;
@@ -932,9 +925,6 @@ static int snd_ice1712_pcm_ds(struct snd_ice1712 *ice, int device, struct snd_pc
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(ice->pci), 64*1024, 128*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
-
         return 0;
 }
 
@@ -1260,13 +1250,11 @@ static struct snd_pcm_ops snd_ice1712_capture_pro_ops = {
         .pointer =      snd_ice1712_capture_pro_pointer,
 };
 
-static int snd_ice1712_pcm_profi(struct snd_ice1712 *ice, int device, struct snd_pcm **rpcm)
+static int snd_ice1712_pcm_profi(struct snd_ice1712 *ice, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         err = snd_pcm_new(ice->card, "ICE1712 multi", device, 1, 1, &pcm);
         if (err < 0)
                 return err;
@@ -1282,8 +1270,6 @@ static int snd_ice1712_pcm_profi(struct snd_ice1712 *ice, int device, struct snd
                                               snd_dma_pci_data(ice->pci), 256*1024, 256*1024);
 
         ice->pcm_pro = pcm;
-        if (rpcm)
-                *rpcm = pcm;
 
         if (ice->cs8427) {
                 /* assign channels to iec958 */
@@ -2691,14 +2677,14 @@ static int snd_ice1712_probe(struct pci_dev *pci,
         c = &no_matched;
  __found:
 
-        err = snd_ice1712_pcm_profi(ice, pcm_dev++, NULL);
+        err = snd_ice1712_pcm_profi(ice, pcm_dev++);
         if (err < 0) {
                 snd_card_free(card);
                 return err;
         }
 
         if (ice_has_con_ac97(ice)) {
-                err = snd_ice1712_pcm(ice, pcm_dev++, NULL);
+                err = snd_ice1712_pcm(ice, pcm_dev++);
                 if (err < 0) {
                         snd_card_free(card);
                         return err;
@@ -2726,7 +2712,7 @@ static int snd_ice1712_probe(struct pci_dev *pci,
         }
 
         if (ice_has_con_ac97(ice)) {
-                err = snd_ice1712_pcm_ds(ice, pcm_dev++, NULL);
+                err = snd_ice1712_pcm_ds(ice, pcm_dev++);
                 if (err < 0) {
                         snd_card_free(card);
                         return err;
@@ -2798,7 +2784,6 @@ static void snd_ice1712_remove(struct pci_dev *pci)
 #ifdef CONFIG_PM_SLEEP
 static int snd_ice1712_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_ice1712 *ice = card->private_data;
 
@@ -2820,16 +2805,11 @@ static int snd_ice1712_suspend(struct device *dev)
 
         if (ice->pm_suspend)
                 ice->pm_suspend(ice);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_ice1712_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_ice1712 *ice = card->private_data;
         int rate;
@@ -2837,16 +2817,6 @@ static int snd_ice1712_resume(struct device *dev)
         if (!ice->pm_suspend_enabled)
                 return 0;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-
-        if (pci_enable_device(pci) < 0) {
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-
-        pci_set_master(pci);
-
         if (ice->cur_rate)
                 rate = ice->cur_rate;
         else
diff --git a/sound/pci/ice1712/ice1724.c b/sound/pci/ice1712/ice1724.c
index d73da157ea14..0b22c00642bb 100644
--- a/sound/pci/ice1712/ice1724.c
+++ b/sound/pci/ice1712/ice1724.c
@@ -2798,7 +2798,6 @@ static void snd_vt1724_remove(struct pci_dev *pci)
 #ifdef CONFIG_PM_SLEEP
 static int snd_vt1724_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_ice1712 *ice = card->private_data;
 
@@ -2821,32 +2820,17 @@ static int snd_vt1724_suspend(struct device *dev)
 
         if (ice->pm_suspend)
                 ice->pm_suspend(ice);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_vt1724_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_ice1712 *ice = card->private_data;
 
         if (!ice->pm_suspend_enabled)
                 return 0;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-
-        if (pci_enable_device(pci) < 0) {
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-
-        pci_set_master(pci);
-
         snd_vt1724_chip_reset(ice);
 
         if (snd_vt1724_chip_init(ice) < 0) {
diff --git a/sound/pci/ice1712/juli.c b/sound/pci/ice1712/juli.c
index a1536c1a7ed4..4f0213427152 100644
--- a/sound/pci/ice1712/juli.c
+++ b/sound/pci/ice1712/juli.c
@@ -491,15 +491,17 @@ static int juli_resume(struct snd_ice1712 *ice)
         /* akm4358 un-reset, un-mute */
         snd_akm4xxx_reset(ak, 0);
         /* reinit ak4114 */
-        snd_ak4114_reinit(spec->ak4114);
+        snd_ak4114_resume(spec->ak4114);
         return 0;
 }
 
 static int juli_suspend(struct snd_ice1712 *ice)
 {
         struct snd_akm4xxx *ak = ice->akm;
+        struct juli_spec *spec = ice->spec;
         /* akm4358 reset and soft-mute */
         snd_akm4xxx_reset(ak, 1);
+        snd_ak4114_suspend(spec->ak4114);
         return 0;
 }
 #endif
diff --git a/sound/pci/ice1712/wm8766.c b/sound/pci/ice1712/wm8766.c
index 21b373b2e260..f7ac8d5e862c 100644
--- a/sound/pci/ice1712/wm8766.c
+++ b/sound/pci/ice1712/wm8766.c
@@ -183,22 +183,6 @@ void snd_wm8766_set_if(struct snd_wm8766 *wm, u16 dac)
         snd_wm8766_write(wm, WM8766_REG_IFCTRL, val | dac);
 }
 
-void snd_wm8766_set_master_mode(struct snd_wm8766 *wm, u16 mode)
-{
-        u16 val = wm->regs[WM8766_REG_DACCTRL3] & ~WM8766_DAC3_MSTR_MASK;
-
-        mode &= WM8766_DAC3_MSTR_MASK;
-        snd_wm8766_write(wm, WM8766_REG_DACCTRL3, val | mode);
-}
-
-void snd_wm8766_set_power(struct snd_wm8766 *wm, u16 power)
-{
-        u16 val = wm->regs[WM8766_REG_DACCTRL3] & ~WM8766_DAC3_POWER_MASK;
-
-        power &= WM8766_DAC3_POWER_MASK;
-        snd_wm8766_write(wm, WM8766_REG_DACCTRL3, val | power);
-}
-
 void snd_wm8766_volume_restore(struct snd_wm8766 *wm)
 {
         u16 val = wm->regs[WM8766_REG_DACR1];
diff --git a/sound/pci/ice1712/wm8766.h b/sound/pci/ice1712/wm8766.h
index c119f84bd2c2..18c8d9d47b38 100644
--- a/sound/pci/ice1712/wm8766.h
+++ b/sound/pci/ice1712/wm8766.h
@@ -155,8 +155,6 @@ struct snd_wm8766 {
 void snd_wm8766_init(struct snd_wm8766 *wm);
 void snd_wm8766_resume(struct snd_wm8766 *wm);
 void snd_wm8766_set_if(struct snd_wm8766 *wm, u16 dac);
-void snd_wm8766_set_master_mode(struct snd_wm8766 *wm, u16 mode);
-void snd_wm8766_set_power(struct snd_wm8766 *wm, u16 power);
 void snd_wm8766_volume_restore(struct snd_wm8766 *wm);
 int snd_wm8766_build_controls(struct snd_wm8766 *wm);
 
diff --git a/sound/pci/ice1712/wm8776.c b/sound/pci/ice1712/wm8776.c
index e66c0da62014..ebd2fe4b4a57 100644
--- a/sound/pci/ice1712/wm8776.c
+++ b/sound/pci/ice1712/wm8776.c
@@ -452,21 +452,6 @@ void snd_wm8776_resume(struct snd_wm8776 *wm)
                 snd_wm8776_write(wm, i, wm->regs[i]);
 }
 
-void snd_wm8776_set_dac_if(struct snd_wm8776 *wm, u16 dac)
-{
-        snd_wm8776_write(wm, WM8776_REG_DACIFCTRL, dac);
-}
-
-void snd_wm8776_set_adc_if(struct snd_wm8776 *wm, u16 adc)
-{
-        snd_wm8776_write(wm, WM8776_REG_ADCIFCTRL, adc);
-}
-
-void snd_wm8776_set_master_mode(struct snd_wm8776 *wm, u16 mode)
-{
-        snd_wm8776_write(wm, WM8776_REG_MSTRCTRL, mode);
-}
-
 void snd_wm8776_set_power(struct snd_wm8776 *wm, u16 power)
 {
         snd_wm8776_write(wm, WM8776_REG_PWRDOWN, power);
diff --git a/sound/pci/ice1712/wm8776.h b/sound/pci/ice1712/wm8776.h
index 93a2d6971154..42acef05540c 100644
--- a/sound/pci/ice1712/wm8776.h
+++ b/sound/pci/ice1712/wm8776.h
@@ -216,9 +216,6 @@ struct snd_wm8776 {
 
 void snd_wm8776_init(struct snd_wm8776 *wm);
 void snd_wm8776_resume(struct snd_wm8776 *wm);
-void snd_wm8776_set_dac_if(struct snd_wm8776 *wm, u16 dac);
-void snd_wm8776_set_adc_if(struct snd_wm8776 *wm, u16 adc);
-void snd_wm8776_set_master_mode(struct snd_wm8776 *wm, u16 mode);
 void snd_wm8776_set_power(struct snd_wm8776 *wm, u16 power);
 void snd_wm8776_volume_restore(struct snd_wm8776 *wm);
 int snd_wm8776_build_controls(struct snd_wm8776 *wm);
diff --git a/sound/pci/intel8x0.c b/sound/pci/intel8x0.c
index 4a28252a42b9..2c5484eeb963 100644
--- a/sound/pci/intel8x0.c
+++ b/sound/pci/intel8x0.c
@@ -26,7 +26,7 @@
  *
  */      
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -2654,7 +2654,6 @@ static int snd_intel8x0_free(struct intel8x0 *chip)
  */
 static int intel8x0_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct intel8x0 *chip = card->private_data;
         int i;
@@ -2682,12 +2681,6 @@ static int intel8x0_suspend(struct device *dev)
                 free_irq(chip->irq, chip);
                 chip->irq = -1;
         }
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        /* The call below may disable built-in speaker on some laptops
-         * after S2RAM.  So, don't touch it.
-         */
-        /* pci_set_power_state(pci, PCI_D3hot); */
         return 0;
 }
 
@@ -2698,14 +2691,6 @@ static int intel8x0_resume(struct device *dev)
         struct intel8x0 *chip = card->private_data;
         int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
         snd_intel8x0_chip_init(chip, 0);
         if (request_irq(pci->irq, snd_intel8x0_interrupt,
                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
diff --git a/sound/pci/intel8x0m.c b/sound/pci/intel8x0m.c
index 6b40235be13c..7577f31cd504 100644
--- a/sound/pci/intel8x0m.c
+++ b/sound/pci/intel8x0m.c
@@ -23,7 +23,7 @@
  *
  */      
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -1023,7 +1023,6 @@ static int snd_intel8x0m_free(struct intel8x0m *chip)
  */
 static int intel8x0m_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct intel8x0m *chip = card->private_data;
         int i;
@@ -1036,9 +1035,6 @@ static int intel8x0m_suspend(struct device *dev)
                 free_irq(chip->irq, chip);
                 chip->irq = -1;
         }
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
@@ -1048,14 +1044,6 @@ static int intel8x0m_resume(struct device *dev)
         struct snd_card *card = dev_get_drvdata(dev);
         struct intel8x0m *chip = card->private_data;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
         if (request_irq(pci->irq, snd_intel8x0m_interrupt,
                         IRQF_SHARED, KBUILD_MODNAME, chip)) {
                 dev_err(dev, "unable to grab IRQ %d, disabling device\n",
diff --git a/sound/pci/korg1212/korg1212.c b/sound/pci/korg1212/korg1212.c
index 59d21c9401d2..7acbc21d642a 100644
--- a/sound/pci/korg1212/korg1212.c
+++ b/sound/pci/korg1212/korg1212.c
@@ -28,6 +28,7 @@
 #include <linux/module.h>
 #include <linux/mutex.h>
 #include <linux/firmware.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/info.h>
@@ -36,8 +37,6 @@
 #include <sound/pcm_params.h>
 #include <sound/initval.h>
 
-#include <asm/io.h>
-
 // ----------------------------------------------------------------------------
 // Debug Stuff
 // ----------------------------------------------------------------------------
@@ -585,8 +584,7 @@ static void snd_korg1212_SendStop(struct snd_korg1212 *korg1212)
                 korg1212->sharedBufferPtr->cardCommand = 0xffffffff;
                 /* program the timer */
                 korg1212->stop_pending_cnt = HZ;
-                korg1212->timer.expires = jiffies + 1;
-                add_timer(&korg1212->timer);
+                mod_timer(&korg1212->timer, jiffies + 1);
         }
 }
 
@@ -617,8 +615,7 @@ static void snd_korg1212_timer_func(unsigned long data)
         } else {
                 if (--korg1212->stop_pending_cnt > 0) {
                         /* reprogram timer */
-                        korg1212->timer.expires = jiffies + 1;
-                        add_timer(&korg1212->timer);
+                        mod_timer(&korg1212->timer, jiffies + 1);
                 } else {
                         snd_printd("korg1212_timer_func timeout\n");
                         korg1212->sharedBufferPtr->cardCommand = 0;
@@ -2172,9 +2169,8 @@ static int snd_korg1212_create(struct snd_card *card, struct pci_dev *pci,
         init_waitqueue_head(&korg1212->wait);
         spin_lock_init(&korg1212->lock);
         mutex_init(&korg1212->open_mutex);
-        init_timer(&korg1212->timer);
-        korg1212->timer.function = snd_korg1212_timer_func;
-        korg1212->timer.data = (unsigned long)korg1212;
+        setup_timer(&korg1212->timer, snd_korg1212_timer_func,
+                    (unsigned long)korg1212);
 
         korg1212->irq = -1;
         korg1212->clkSource = K1212_CLKIDX_Local;
diff --git a/sound/pci/lola/lola.c b/sound/pci/lola/lola.c
index 4cf4be5ef82a..9ff600084973 100644
--- a/sound/pci/lola/lola.c
+++ b/sound/pci/lola/lola.c
@@ -551,10 +551,8 @@ static void lola_free(struct lola *chip)
         lola_free_mixer(chip);
         if (chip->irq >= 0)
                 free_irq(chip->irq, (void *)chip);
-        if (chip->bar[0].remap_addr)
-                iounmap(chip->bar[0].remap_addr);
-        if (chip->bar[1].remap_addr)
-                iounmap(chip->bar[1].remap_addr);
+        iounmap(chip->bar[0].remap_addr);
+        iounmap(chip->bar[1].remap_addr);
         if (chip->rb.area)
                 snd_dma_free_pages(&chip->rb);
         pci_release_regions(chip->pci);
diff --git a/sound/pci/maestro3.c b/sound/pci/maestro3.c
index 98823d11d485..9be660993bd0 100644
--- a/sound/pci/maestro3.c
+++ b/sound/pci/maestro3.c
@@ -31,7 +31,7 @@
 #define CARD_NAME "ESS Maestro3/Allegro/Canyon3D-2"
 #define DRIVER_NAME "Maestro3"
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -2395,7 +2395,6 @@ static int snd_m3_free(struct snd_m3 *chip)
 #ifdef CONFIG_PM_SLEEP
 static int m3_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_m3 *chip = card->private_data;
         int i, dsp_index;
@@ -2421,16 +2420,11 @@ static int m3_suspend(struct device *dev)
         for (i = REV_B_DATA_MEMORY_BEGIN ; i <= REV_B_DATA_MEMORY_END; i++)
                 chip->suspend_mem[dsp_index++] =
                         snd_m3_assp_read(chip, MEMTYPE_INTERNAL_DATA, i);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int m3_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_m3 *chip = card->private_data;
         int i, dsp_index;
@@ -2438,15 +2432,6 @@ static int m3_resume(struct device *dev)
         if (chip->suspend_mem == NULL)
                 return 0;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         /* first lets just bring everything back. .*/
         snd_m3_outw(chip, 0, 0x54);
         snd_m3_outw(chip, 0, 0x56);
diff --git a/sound/pci/mixart/mixart.c b/sound/pci/mixart/mixart.c
index 1faf47e81570..c3a9f39f8d61 100644
--- a/sound/pci/mixart/mixart.c
+++ b/sound/pci/mixart/mixart.c
@@ -1114,10 +1114,9 @@ static int snd_mixart_free(struct mixart_mgr *mgr)
         }
 
         /* release the i/o ports */
-        for (i = 0; i < 2; i++) {
-                if (mgr->mem[i].virt)
-                        iounmap(mgr->mem[i].virt);
-        }
+        for (i = 0; i < 2; ++i)
+                iounmap(mgr->mem[i].virt);
+
         pci_release_regions(mgr->pci);
 
         /* free flowarray */
diff --git a/sound/pci/mixart/mixart_core.c b/sound/pci/mixart/mixart_core.c
index fe80313674d9..dccf3db48fe0 100644
--- a/sound/pci/mixart/mixart_core.c
+++ b/sound/pci/mixart/mixart_core.c
@@ -23,8 +23,8 @@
 #include <linux/interrupt.h>
 #include <linux/mutex.h>
 #include <linux/pci.h>
+#include <linux/io.h>
 
-#include <asm/io.h>
 #include <sound/core.h>
 #include "mixart.h"
 #include "mixart_hwdep.h"
diff --git a/sound/pci/mixart/mixart_hwdep.c b/sound/pci/mixart/mixart_hwdep.c
index 9996a4dead0f..5bfd3ac80db5 100644
--- a/sound/pci/mixart/mixart_hwdep.c
+++ b/sound/pci/mixart/mixart_hwdep.c
@@ -26,7 +26,7 @@
 #include <linux/vmalloc.h>
 #include <linux/slab.h>
 #include <linux/module.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include "mixart.h"
 #include "mixart_mixer.h"
diff --git a/sound/pci/nm256/nm256.c b/sound/pci/nm256/nm256.c
index 4e41a4e29a1e..4735e27cc773 100644
--- a/sound/pci/nm256/nm256.c
+++ b/sound/pci/nm256/nm256.c
@@ -24,7 +24,7 @@
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  */
   
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -1392,7 +1392,6 @@ snd_nm256_peek_for_sig(struct nm256 *chip)
  */
 static int nm256_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct nm256 *chip = card->private_data;
 
@@ -1400,15 +1399,11 @@ static int nm256_suspend(struct device *dev)
         snd_pcm_suspend_all(chip->pcm);
         snd_ac97_suspend(chip->ac97);
         chip->coeffs_current = 0;
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int nm256_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct nm256 *chip = card->private_data;
         int i;
@@ -1416,15 +1411,6 @@ static int nm256_resume(struct device *dev)
         /* Perform a full reset on the hardware */
         chip->in_resume = 1;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_nm256_init_chip(chip);
 
         /* restore ac97 */
@@ -1460,10 +1446,8 @@ static int snd_nm256_free(struct nm256 *chip)
         if (chip->irq >= 0)
                 free_irq(chip->irq, chip);
 
-        if (chip->cport)
-                iounmap(chip->cport);
-        if (chip->buffer)
-                iounmap(chip->buffer);
+        iounmap(chip->cport);
+        iounmap(chip->buffer);
         release_and_free_resource(chip->res_cport);
         release_and_free_resource(chip->res_buffer);
 
diff --git a/sound/pci/oxygen/Makefile b/sound/pci/oxygen/Makefile
index 8f4c409f7e45..ab085d753661 100644
--- a/sound/pci/oxygen/Makefile
+++ b/sound/pci/oxygen/Makefile
@@ -1,8 +1,10 @@
 snd-oxygen-lib-objs := oxygen_io.o oxygen_lib.o oxygen_mixer.o oxygen_pcm.o
 snd-oxygen-objs := oxygen.o xonar_dg_mixer.o xonar_dg.o
+snd-se6x-objs := se6x.o
 snd-virtuoso-objs := virtuoso.o xonar_lib.o \
         xonar_pcm179x.o xonar_cs43xx.o xonar_wm87x6.o xonar_hdmi.o
 
 obj-$(CONFIG_SND_OXYGEN_LIB) += snd-oxygen-lib.o
 obj-$(CONFIG_SND_OXYGEN) += snd-oxygen.o
+obj-$(CONFIG_SND_SE6X) += snd-se6x.o
 obj-$(CONFIG_SND_VIRTUOSO) += snd-virtuoso.o
diff --git a/sound/pci/oxygen/oxygen.h b/sound/pci/oxygen/oxygen.h
index c10ab077afd8..293d0b9a50c3 100644
--- a/sound/pci/oxygen/oxygen.h
+++ b/sound/pci/oxygen/oxygen.h
@@ -35,7 +35,7 @@
 #define CAPTURE_1_FROM_SPDIF    0x0080
 #define CAPTURE_2_FROM_I2S_2    0x0100
 #define CAPTURE_2_FROM_AC97_1   0x0200
-     /* CAPTURE_3_FROM_I2S_3            not implemented */
+#define CAPTURE_3_FROM_I2S_3    0x0400
 #define MIDI_OUTPUT             0x0800
 #define MIDI_INPUT              0x1000
 #define AC97_CD_INPUT           0x2000
diff --git a/sound/pci/oxygen/oxygen_io.c b/sound/pci/oxygen/oxygen_io.c
index 4b8a32c37e31..c7851da37749 100644
--- a/sound/pci/oxygen/oxygen_io.c
+++ b/sound/pci/oxygen/oxygen_io.c
@@ -20,9 +20,9 @@
 #include <linux/delay.h>
 #include <linux/sched.h>
 #include <linux/export.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/mpu401.h>
-#include <asm/io.h>
 #include "oxygen.h"
 
 u8 oxygen_read8(struct oxygen *chip, unsigned int reg)
diff --git a/sound/pci/oxygen/oxygen_lib.c b/sound/pci/oxygen/oxygen_lib.c
index b67e30602473..ffff3b25fd73 100644
--- a/sound/pci/oxygen/oxygen_lib.c
+++ b/sound/pci/oxygen/oxygen_lib.c
@@ -319,11 +319,12 @@ static void oxygen_restore_eeprom(struct oxygen *chip,
 
 static void configure_pcie_bridge(struct pci_dev *pci)
 {
-        enum { PEX811X, PI7C9X110 };
+        enum { PEX811X, PI7C9X110, XIO2001 };
         static const struct pci_device_id bridge_ids[] = {
                 { PCI_VDEVICE(PLX, 0x8111), .driver_data = PEX811X },
                 { PCI_VDEVICE(PLX, 0x8112), .driver_data = PEX811X },
                 { PCI_DEVICE(0x12d8, 0xe110), .driver_data = PI7C9X110 },
+                { PCI_VDEVICE(TI, 0x8240), .driver_data = XIO2001 },
                 { }
         };
         struct pci_dev *bridge;
@@ -357,6 +358,14 @@ static void configure_pcie_bridge(struct pci_dev *pci)
                 tmp |= 1;       /* park the PCI arbiter to the sound chip */
                 pci_write_config_dword(bridge, 0x40, tmp);
                 break;
+
+        case XIO2001: /* Texas Instruments XIO2001 PCIe/PCI bridge */
+                pci_read_config_dword(bridge, 0xe8, &tmp);
+                tmp &= ~0xf;    /* request length limit: 64 bytes */
+                tmp &= ~(0xf << 8);
+                tmp |= 1 << 8;  /* request count limit: one buffer */
+                pci_write_config_dword(bridge, 0xe8, tmp);
+                break;
         }
 }
 
@@ -441,9 +450,18 @@ static void oxygen_init(struct oxygen *chip)
                 oxygen_write16(chip, OXYGEN_I2S_B_FORMAT,
                                OXYGEN_I2S_MASTER |
                                OXYGEN_I2S_MUTE_MCLK);
-        oxygen_write16(chip, OXYGEN_I2S_C_FORMAT,
-                       OXYGEN_I2S_MASTER |
-                       OXYGEN_I2S_MUTE_MCLK);
+        if (chip->model.device_config & CAPTURE_3_FROM_I2S_3)
+                oxygen_write16(chip, OXYGEN_I2S_C_FORMAT,
+                               OXYGEN_RATE_48000 |
+                               chip->model.adc_i2s_format |
+                               OXYGEN_I2S_MCLK(chip->model.adc_mclks) |
+                               OXYGEN_I2S_BITS_16 |
+                               OXYGEN_I2S_MASTER |
+                               OXYGEN_I2S_BCLK_64);
+        else
+                oxygen_write16(chip, OXYGEN_I2S_C_FORMAT,
+                               OXYGEN_I2S_MASTER |
+                               OXYGEN_I2S_MUTE_MCLK);
         oxygen_clear_bits32(chip, OXYGEN_SPDIF_CONTROL,
                             OXYGEN_SPDIF_OUT_ENABLE |
                             OXYGEN_SPDIF_LOOPBACK);
@@ -728,7 +746,6 @@ EXPORT_SYMBOL(oxygen_pci_remove);
 #ifdef CONFIG_PM_SLEEP
 static int oxygen_pci_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct oxygen *chip = card->private_data;
         unsigned int i, saved_interrupt_mask;
@@ -736,8 +753,7 @@ static int oxygen_pci_suspend(struct device *dev)
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
 
         for (i = 0; i < PCM_COUNT; ++i)
-                if (chip->streams[i])
-                        snd_pcm_suspend(chip->streams[i]);
+                snd_pcm_suspend(chip->streams[i]);
 
         if (chip->model.suspend)
                 chip->model.suspend(chip);
@@ -753,10 +769,6 @@ static int oxygen_pci_suspend(struct device *dev)
         flush_work(&chip->spdif_input_bits_work);
         flush_work(&chip->gpio_work);
         chip->interrupt_mask = saved_interrupt_mask;
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
@@ -788,20 +800,10 @@ static void oxygen_restore_ac97(struct oxygen *chip, unsigned int codec)
 
 static int oxygen_pci_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct oxygen *chip = card->private_data;
         unsigned int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "cannot reenable device");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         oxygen_write16(chip, OXYGEN_DMA_STATUS, 0);
         oxygen_write16(chip, OXYGEN_INTERRUPT_MASK, 0);
         for (i = 0; i < OXYGEN_IO_SIZE; ++i)
diff --git a/sound/pci/oxygen/oxygen_mixer.c b/sound/pci/oxygen/oxygen_mixer.c
index 5988e044c519..6492bca8c70f 100644
--- a/sound/pci/oxygen/oxygen_mixer.c
+++ b/sound/pci/oxygen/oxygen_mixer.c
@@ -786,6 +786,9 @@ static const struct snd_kcontrol_new controls[] = {
                 .get = upmix_get,
                 .put = upmix_put,
         },
+};
+
+static const struct snd_kcontrol_new spdif_output_controls[] = {
         {
                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
                 .name = SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
@@ -938,6 +941,33 @@ static const struct {
                 },
         },
         {
+                .pcm_dev = CAPTURE_3_FROM_I2S_3,
+                .controls = {
+                        {
+                                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                                .name = "Analog Input Monitor Playback Switch",
+                                .index = 2,
+                                .info = snd_ctl_boolean_mono_info,
+                                .get = monitor_get,
+                                .put = monitor_put,
+                                .private_value = OXYGEN_ADC_MONITOR_C,
+                        },
+                        {
+                                .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+                                .name = "Analog Input Monitor Playback Volume",
+                                .index = 2,
+                                .access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
+                                          SNDRV_CTL_ELEM_ACCESS_TLV_READ,
+                                .info = monitor_volume_info,
+                                .get = monitor_get,
+                                .put = monitor_put,
+                                .private_value = OXYGEN_ADC_MONITOR_C_HALF_VOL
+                                                | (1 << 8),
+                                .tlv = { .p = monitor_db_scale, },
+                        },
+                },
+        },
+        {
                 .pcm_dev = CAPTURE_1_FROM_SPDIF,
                 .controls = {
                         {
@@ -1073,6 +1103,12 @@ int oxygen_mixer_init(struct oxygen *chip)
         err = add_controls(chip, controls, ARRAY_SIZE(controls));
         if (err < 0)
                 return err;
+        if (chip->model.device_config & PLAYBACK_1_TO_SPDIF) {
+                err = add_controls(chip, spdif_output_controls,
+                                   ARRAY_SIZE(spdif_output_controls));
+                if (err < 0)
+                        return err;
+        }
         if (chip->model.device_config & CAPTURE_1_FROM_SPDIF) {
                 err = add_controls(chip, spdif_input_controls,
                                    ARRAY_SIZE(spdif_input_controls));
diff --git a/sound/pci/oxygen/oxygen_pcm.c b/sound/pci/oxygen/oxygen_pcm.c
index 02828240ba15..aa2ebd1d6d12 100644
--- a/sound/pci/oxygen/oxygen_pcm.c
+++ b/sound/pci/oxygen/oxygen_pcm.c
@@ -144,9 +144,11 @@ static int oxygen_open(struct snd_pcm_substream *substream,
                 runtime->hw = *oxygen_hardware[channel];
         switch (channel) {
         case PCM_C:
-                runtime->hw.rates &= ~(SNDRV_PCM_RATE_32000 |
-                                       SNDRV_PCM_RATE_64000);
-                runtime->hw.rate_min = 44100;
+                if (chip->model.device_config & CAPTURE_1_FROM_SPDIF) {
+                        runtime->hw.rates &= ~(SNDRV_PCM_RATE_32000 |
+                                               SNDRV_PCM_RATE_64000);
+                        runtime->hw.rate_min = 44100;
+                }
                 /* fall through */
         case PCM_A:
         case PCM_B:
@@ -430,17 +432,36 @@ static int oxygen_rec_c_hw_params(struct snd_pcm_substream *substream,
                                   struct snd_pcm_hw_params *hw_params)
 {
         struct oxygen *chip = snd_pcm_substream_chip(substream);
+        bool is_spdif;
         int err;
 
         err = oxygen_hw_params(substream, hw_params);
         if (err < 0)
                 return err;
 
+        is_spdif = chip->model.device_config & CAPTURE_1_FROM_SPDIF;
+
         spin_lock_irq(&chip->reg_lock);
         oxygen_write8_masked(chip, OXYGEN_REC_FORMAT,
                              oxygen_format(hw_params) << OXYGEN_REC_FORMAT_C_SHIFT,
                              OXYGEN_REC_FORMAT_C_MASK);
+        if (!is_spdif)
+                oxygen_write16_masked(chip, OXYGEN_I2S_C_FORMAT,
+                                      oxygen_rate(hw_params) |
+                                      chip->model.adc_i2s_format |
+                                      get_mclk(chip, PCM_B, hw_params) |
+                                      oxygen_i2s_bits(hw_params),
+                                      OXYGEN_I2S_RATE_MASK |
+                                      OXYGEN_I2S_FORMAT_MASK |
+                                      OXYGEN_I2S_MCLK_MASK |
+                                      OXYGEN_I2S_BITS_MASK);
         spin_unlock_irq(&chip->reg_lock);
+
+        if (!is_spdif) {
+                mutex_lock(&chip->mutex);
+                chip->model.set_adc_params(chip, hw_params);
+                mutex_unlock(&chip->mutex);
+        }
         return 0;
 }
 
@@ -676,11 +697,6 @@ static struct snd_pcm_ops oxygen_ac97_ops = {
         .pointer   = oxygen_pointer,
 };
 
-static void oxygen_pcm_free(struct snd_pcm *pcm)
-{
-        snd_pcm_lib_preallocate_free_for_all(pcm);
-}
-
 int oxygen_pcm_init(struct oxygen *chip)
 {
         struct snd_pcm *pcm;
@@ -705,7 +721,6 @@ int oxygen_pcm_init(struct oxygen *chip)
                         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
                                         &oxygen_rec_b_ops);
                 pcm->private_data = chip;
-                pcm->private_free = oxygen_pcm_free;
                 strcpy(pcm->name, "Multichannel");
                 if (outs)
                         snd_pcm_lib_preallocate_pages(pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream,
@@ -734,7 +749,6 @@ int oxygen_pcm_init(struct oxygen *chip)
                         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
                                         &oxygen_rec_c_ops);
                 pcm->private_data = chip;
-                pcm->private_free = oxygen_pcm_free;
                 strcpy(pcm->name, "Digital");
                 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                                       snd_dma_pci_data(chip->pci),
@@ -765,12 +779,29 @@ int oxygen_pcm_init(struct oxygen *chip)
                         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
                                         &oxygen_rec_b_ops);
                 pcm->private_data = chip;
-                pcm->private_free = oxygen_pcm_free;
                 strcpy(pcm->name, outs ? "Front Panel" : "Analog 2");
                 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                                       snd_dma_pci_data(chip->pci),
                                                       DEFAULT_BUFFER_BYTES,
                                                       BUFFER_BYTES_MAX);
         }
+
+        ins = !!(chip->model.device_config & CAPTURE_3_FROM_I2S_3);
+        if (ins) {
+                err = snd_pcm_new(chip->card, "Analog3", 3, 0, ins, &pcm);
+                if (err < 0)
+                        return err;
+                snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
+                                &oxygen_rec_c_ops);
+                oxygen_write8_masked(chip, OXYGEN_REC_ROUTING,
+                                     OXYGEN_REC_C_ROUTE_I2S_ADC_3,
+                                     OXYGEN_REC_C_ROUTE_MASK);
+                pcm->private_data = chip;
+                strcpy(pcm->name, "Analog 3");
+                snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                                      snd_dma_pci_data(chip->pci),
+                                                      DEFAULT_BUFFER_BYTES,
+                                                      BUFFER_BYTES_MAX);
+        }
         return 0;
 }
diff --git a/sound/pci/oxygen/se6x.c b/sound/pci/oxygen/se6x.c
new file mode 100644
index 000000000000..f70d514c1084
--- /dev/null
+++ b/sound/pci/oxygen/se6x.c
@@ -0,0 +1,160 @@
+/*
+ * C-Media CMI8787 driver for the Studio Evolution SE6X
+ *
+ * Copyright (c) Clemens Ladisch <clemens@ladisch.de>
+ *
+ *  This driver is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License, version 2.
+ *
+ *  This driver 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 driver; if not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * CMI8787:
+ *
+ *   SPI    -> microcontroller (not actually used)
+ *   GPIO 0 -> do.
+ *   GPIO 2 -> do.
+ *
+ *   DAC0   -> both PCM1792A (L+R, each in mono mode)
+ *   ADC1  <-  1st PCM1804
+ *   ADC2  <-  2nd PCM1804
+ *   ADC3  <-  3rd PCM1804
+ */
+
+#include <linux/pci.h>
+#include <linux/module.h>
+#include <sound/core.h>
+#include <sound/control.h>
+#include <sound/initval.h>
+#include <sound/pcm.h>
+#include "oxygen.h"
+
+MODULE_AUTHOR("Clemens Ladisch <clemens@ladisch.de>");
+MODULE_DESCRIPTION("Studio Evolution SE6X driver");
+MODULE_LICENSE("GPL v2");
+MODULE_SUPPORTED_DEVICE("{{Studio Evolution,SE6X}}");
+
+static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
+static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
+static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
+
+module_param_array(index, int, NULL, 0444);
+MODULE_PARM_DESC(index, "card index");
+module_param_array(id, charp, NULL, 0444);
+MODULE_PARM_DESC(id, "ID string");
+module_param_array(enable, bool, NULL, 0444);
+MODULE_PARM_DESC(enable, "enable card");
+
+static const struct pci_device_id se6x_ids[] = {
+        { OXYGEN_PCI_SUBID(0x13f6, 0x8788) },
+        { }
+};
+MODULE_DEVICE_TABLE(pci, se6x_ids);
+
+static void se6x_init(struct oxygen *chip)
+{
+        oxygen_set_bits16(chip, OXYGEN_GPIO_CONTROL, 0x005);
+
+        snd_component_add(chip->card, "PCM1792A");
+        snd_component_add(chip->card, "PCM1804");
+}
+
+static int se6x_control_filter(struct snd_kcontrol_new *template)
+{
+        /* no DAC volume/mute */
+        if (!strncmp(template->name, "Master Playback ", 16))
+                return 1;
+        return 0;
+}
+
+static void se6x_cleanup(struct oxygen *chip)
+{
+}
+
+static void set_pcm1792a_params(struct oxygen *chip,
+                                struct snd_pcm_hw_params *params)
+{
+        /* nothing to do (the microcontroller monitors DAC_LRCK) */
+}
+
+static void set_pcm1804_params(struct oxygen *chip,
+                               struct snd_pcm_hw_params *params)
+{
+}
+
+static unsigned int se6x_adjust_dac_routing(struct oxygen *chip,
+                                            unsigned int play_routing)
+{
+        /* route the same stereo pair to DAC0 and DAC1 */
+        return ( play_routing       & OXYGEN_PLAY_DAC0_SOURCE_MASK) |
+               ((play_routing << 2) & OXYGEN_PLAY_DAC1_SOURCE_MASK);
+}
+
+static const struct oxygen_model model_se6x = {
+        .shortname = "Studio Evolution SE6X",
+        .longname = "C-Media Oxygen HD Audio",
+        .chip = "CMI8787",
+        .init = se6x_init,
+        .control_filter = se6x_control_filter,
+        .cleanup = se6x_cleanup,
+        .set_dac_params = set_pcm1792a_params,
+        .set_adc_params = set_pcm1804_params,
+        .adjust_dac_routing = se6x_adjust_dac_routing,
+        .device_config = PLAYBACK_0_TO_I2S |
+                         CAPTURE_0_FROM_I2S_1 |
+                         CAPTURE_2_FROM_I2S_2 |
+                         CAPTURE_3_FROM_I2S_3,
+        .dac_channels_pcm = 2,
+        .function_flags = OXYGEN_FUNCTION_SPI,
+        .dac_mclks = OXYGEN_MCLKS(256, 128, 128),
+        .adc_mclks = OXYGEN_MCLKS(256, 256, 128),
+        .dac_i2s_format = OXYGEN_I2S_FORMAT_LJUST,
+        .adc_i2s_format = OXYGEN_I2S_FORMAT_I2S,
+};
+
+static int se6x_get_model(struct oxygen *chip,
+                          const struct pci_device_id *pci_id)
+{
+        chip->model = model_se6x;
+        return 0;
+}
+
+static int se6x_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
+{
+        static int dev;
+        int err;
+
+        if (dev >= SNDRV_CARDS)
+                return -ENODEV;
+        if (!enable[dev]) {
+                ++dev;
+                return -ENOENT;
+        }
+        err = oxygen_pci_probe(pci, index[dev], id[dev], THIS_MODULE,
+                               se6x_ids, se6x_get_model);
+        if (err >= 0)
+                ++dev;
+        return err;
+}
+
+static struct pci_driver se6x_driver = {
+        .name = KBUILD_MODNAME,
+        .id_table = se6x_ids,
+        .probe = se6x_probe,
+        .remove = oxygen_pci_remove,
+#ifdef CONFIG_PM_SLEEP
+        .driver = {
+                .pm = &oxygen_pci_pm,
+        },
+#endif
+        .shutdown = oxygen_pci_shutdown,
+};
+
+module_pci_driver(se6x_driver);
diff --git a/sound/pci/pcxhr/pcxhr_core.c b/sound/pci/pcxhr/pcxhr_core.c
index 181f7729d409..c5194f5b150a 100644
--- a/sound/pci/pcxhr/pcxhr_core.c
+++ b/sound/pci/pcxhr/pcxhr_core.c
@@ -24,7 +24,7 @@
 #include <linux/firmware.h>
 #include <linux/interrupt.h>
 #include <linux/pci.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include "pcxhr.h"
 #include "pcxhr_mixer.h"
diff --git a/sound/pci/pcxhr/pcxhr_hwdep.c b/sound/pci/pcxhr/pcxhr_hwdep.c
index 15a8ce5f1f48..80633055e17e 100644
--- a/sound/pci/pcxhr/pcxhr_hwdep.c
+++ b/sound/pci/pcxhr/pcxhr_hwdep.c
@@ -25,7 +25,7 @@
 #include <linux/firmware.h>
 #include <linux/pci.h>
 #include <linux/module.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/hwdep.h>
 #include "pcxhr.h"
diff --git a/sound/pci/riptide/riptide.c b/sound/pci/riptide/riptide.c
index 6abc2ac8fffb..94639d6b5fb5 100644
--- a/sound/pci/riptide/riptide.c
+++ b/sound/pci/riptide/riptide.c
@@ -99,7 +99,7 @@
 #include <linux/firmware.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <asm/io.h>
+#include <linux/io.h>
 #include <sound/core.h>
 #include <sound/info.h>
 #include <sound/control.h>
@@ -1153,7 +1153,6 @@ static void riptide_handleirq(unsigned long dev_id)
 #ifdef CONFIG_PM_SLEEP
 static int riptide_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_riptide *chip = card->private_data;
 
@@ -1161,27 +1160,14 @@ static int riptide_suspend(struct device *dev)
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
         snd_pcm_suspend_all(chip->pcm);
         snd_ac97_suspend(chip->ac97);
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int riptide_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_riptide *chip = card->private_data;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "riptide: pci_enable_device failed, "
-                       "disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
         snd_riptide_initialize(chip);
         snd_ac97_resume(chip->ac97);
         snd_power_change_state(card, SNDRV_CTL_POWER_D0);
@@ -1706,14 +1692,11 @@ static struct snd_pcm_ops snd_riptide_capture_ops = {
         .pointer = snd_riptide_pointer,
 };
 
-static int
-snd_riptide_pcm(struct snd_riptide *chip, int device, struct snd_pcm **rpcm)
+static int snd_riptide_pcm(struct snd_riptide *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err =
              snd_pcm_new(chip->card, "RIPTIDE", device, PLAYBACK_SUBSTREAMS, 1,
                          &pcm)) < 0)
@@ -1729,8 +1712,6 @@ snd_riptide_pcm(struct snd_riptide *chip, int device, struct snd_pcm **rpcm)
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
                                               snd_dma_pci_data(chip->pci),
                                               64 * 1024, 128 * 1024);
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 
@@ -2030,32 +2011,43 @@ snd_riptide_joystick_probe(struct pci_dev *pci, const struct pci_device_id *id)
 {
         static int dev;
         struct gameport *gameport;
+        int ret;
 
         if (dev >= SNDRV_CARDS)
                 return -ENODEV;
+
         if (!enable[dev]) {
-                dev++;
-                return -ENOENT;
+                ret = -ENOENT;
+                goto inc_dev;
         }
 
-        if (!joystick_port[dev++])
-                return 0;
+        if (!joystick_port[dev]) {
+                ret = 0;
+                goto inc_dev;
+        }
 
         gameport = gameport_allocate_port();
-        if (!gameport)
-                return -ENOMEM;
+        if (!gameport) {
+                ret = -ENOMEM;
+                goto inc_dev;
+        }
         if (!request_region(joystick_port[dev], 8, "Riptide gameport")) {
                 snd_printk(KERN_WARNING
                            "Riptide: cannot grab gameport 0x%x\n",
                            joystick_port[dev]);
                 gameport_free_port(gameport);
-                return -EBUSY;
+                ret = -EBUSY;
+                goto inc_dev;
         }
 
         gameport->io = joystick_port[dev];
         gameport_register_port(gameport);
         pci_set_drvdata(pci, gameport);
-        return 0;
+
+        ret = 0;
+inc_dev:
+        dev++;
+        return ret;
 }
 
 static void snd_riptide_joystick_remove(struct pci_dev *pci)
@@ -2092,7 +2084,7 @@ snd_card_riptide_probe(struct pci_dev *pci, const struct pci_device_id *pci_id)
         if (err < 0)
                 goto error;
         card->private_data = chip;
-        err = snd_riptide_pcm(chip, 0, NULL);
+        err = snd_riptide_pcm(chip, 0);
         if (err < 0)
                 goto error;
         err = snd_riptide_mixer(chip);
diff --git a/sound/pci/rme32.c b/sound/pci/rme32.c
index 6c60dcd2e5a1..23d7f5d30c41 100644
--- a/sound/pci/rme32.c
+++ b/sound/pci/rme32.c
@@ -75,6 +75,7 @@
 #include <linux/interrupt.h>
 #include <linux/pci.h>
 #include <linux/module.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/info.h>
@@ -85,8 +86,6 @@
 #include <sound/asoundef.h>
 #include <sound/initval.h>
 
-#include <asm/io.h>
-
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;     /* Enable this card */
@@ -632,7 +631,7 @@ snd_rme32_setframelog(struct rme32 * rme32, int n_channels, int is_playback)
         }
 }
 
-static int snd_rme32_setformat(struct rme32 * rme32, int format)
+static int snd_rme32_setformat(struct rme32 *rme32, snd_pcm_format_t format)
 {
         switch (format) {
         case SNDRV_PCM_FORMAT_S16_LE:
diff --git a/sound/pci/rme96.c b/sound/pci/rme96.c
index 2f1a85185a16..2306ccf7281e 100644
--- a/sound/pci/rme96.c
+++ b/sound/pci/rme96.c
@@ -29,6 +29,7 @@
 #include <linux/pci.h>
 #include <linux/module.h>
 #include <linux/vmalloc.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/info.h>
@@ -38,8 +39,6 @@
 #include <sound/asoundef.h>
 #include <sound/initval.h>
 
-#include <asm/io.h>
-
 /* note, two last pcis should be equal, it is not a bug */
 
 MODULE_AUTHOR("Anders Torger <torger@ludd.luth.se>");
@@ -922,8 +921,7 @@ snd_rme96_setframelog(struct rme96 *rme96,
 }
 
 static int
-snd_rme96_playback_setformat(struct rme96 *rme96,
-                             int format)
+snd_rme96_playback_setformat(struct rme96 *rme96, snd_pcm_format_t format)
 {
         switch (format) {
         case SNDRV_PCM_FORMAT_S16_LE:
@@ -940,8 +938,7 @@ snd_rme96_playback_setformat(struct rme96 *rme96,
 }
 
 static int
-snd_rme96_capture_setformat(struct rme96 *rme96,
-                            int format)
+snd_rme96_capture_setformat(struct rme96 *rme96, snd_pcm_format_t format)
 {
         switch (format) {
         case SNDRV_PCM_FORMAT_S16_LE:
@@ -2358,7 +2355,6 @@ snd_rme96_create_switches(struct snd_card *card,
 
 static int rme96_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct rme96 *rme96 = card->private_data;
 
@@ -2381,26 +2377,14 @@ static int rme96_suspend(struct device *dev)
         /* disable the DAC  */
         rme96->areg &= ~RME96_AR_DAC_EN;
         writel(rme96->areg, rme96->iobase + RME96_IO_ADDITIONAL_REG);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-
         return 0;
 }
 
 static int rme96_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct rme96 *rme96 = card->private_data;
 
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-
         /* reset playback and record buffer pointers */
         writel(0, rme96->iobase + RME96_IO_SET_PLAY_POS
                   + rme96->playback_pointer);
diff --git a/sound/pci/rme9652/hdsp.c b/sound/pci/rme9652/hdsp.c
index cf5a6c8b9a63..c19e021ccf66 100644
--- a/sound/pci/rme9652/hdsp.c
+++ b/sound/pci/rme9652/hdsp.c
@@ -29,6 +29,7 @@
 #include <linux/module.h>
 #include <linux/math64.h>
 #include <linux/vmalloc.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/control.h>
@@ -42,7 +43,6 @@
 
 #include <asm/byteorder.h>
 #include <asm/current.h>
-#include <asm/io.h>
 
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
@@ -1428,10 +1428,8 @@ static void snd_hdsp_midi_output_timer(unsigned long data)
            leaving istimer wherever it was set before.
         */
 
-        if (hmidi->istimer) {
-                hmidi->timer.expires = 1 + jiffies;
-                add_timer(&hmidi->timer);
-        }
+        if (hmidi->istimer)
+                mod_timer(&hmidi->timer, 1 + jiffies);
 
         spin_unlock_irqrestore (&hmidi->lock, flags);
 }
@@ -1445,11 +1443,9 @@ static void snd_hdsp_midi_output_trigger(struct snd_rawmidi_substream *substream
         spin_lock_irqsave (&hmidi->lock, flags);
         if (up) {
                 if (!hmidi->istimer) {
-                        init_timer(&hmidi->timer);
-                        hmidi->timer.function = snd_hdsp_midi_output_timer;
-                        hmidi->timer.data = (unsigned long) hmidi;
-                        hmidi->timer.expires = 1 + jiffies;
-                        add_timer(&hmidi->timer);
+                        setup_timer(&hmidi->timer, snd_hdsp_midi_output_timer,
+                                    (unsigned long) hmidi);
+                        mod_timer(&hmidi->timer, 1 + jiffies);
                         hmidi->istimer++;
                 }
         } else {
@@ -5309,9 +5305,7 @@ static int snd_hdsp_free(struct hdsp *hdsp)
 
         release_firmware(hdsp->firmware);
         vfree(hdsp->fw_uploaded);
-
-        if (hdsp->iobase)
-                iounmap(hdsp->iobase);
+        iounmap(hdsp->iobase);
 
         if (hdsp->port)
                 pci_release_regions(hdsp->pci);
diff --git a/sound/pci/rme9652/hdspm.c b/sound/pci/rme9652/hdspm.c
index 3342705a5715..ca67f896d117 100644
--- a/sound/pci/rme9652/hdspm.c
+++ b/sound/pci/rme9652/hdspm.c
@@ -136,7 +136,7 @@
 #include <linux/slab.h>
 #include <linux/pci.h>
 #include <linux/math64.h>
-#include <asm/io.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/control.h>
@@ -1957,10 +1957,8 @@ static void snd_hdspm_midi_output_timer(unsigned long data)
            leaving istimer wherever it was set before.
         */
 
-        if (hmidi->istimer) {
-                hmidi->timer.expires = 1 + jiffies;
-                add_timer(&hmidi->timer);
-        }
+        if (hmidi->istimer)
+                mod_timer(&hmidi->timer, 1 + jiffies);
 
         spin_unlock_irqrestore (&hmidi->lock, flags);
 }
@@ -1975,11 +1973,9 @@ snd_hdspm_midi_output_trigger(struct snd_rawmidi_substream *substream, int up)
         spin_lock_irqsave (&hmidi->lock, flags);
         if (up) {
                 if (!hmidi->istimer) {
-                        init_timer(&hmidi->timer);
-                        hmidi->timer.function = snd_hdspm_midi_output_timer;
-                        hmidi->timer.data = (unsigned long) hmidi;
-                        hmidi->timer.expires = 1 + jiffies;
-                        add_timer(&hmidi->timer);
+                        setup_timer(&hmidi->timer, snd_hdspm_midi_output_timer,
+                                    (unsigned long) hmidi);
+                        mod_timer(&hmidi->timer, 1 + jiffies);
                         hmidi->istimer++;
                 }
         } else {
@@ -6086,6 +6082,9 @@ static int snd_hdspm_playback_open(struct snd_pcm_substream *substream)
                 snd_pcm_hw_constraint_minmax(runtime,
                                              SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
                                              64, 8192);
+                snd_pcm_hw_constraint_minmax(runtime,
+                                             SNDRV_PCM_HW_PARAM_PERIODS,
+                                             2, 2);
                 break;
         }
 
@@ -6160,6 +6159,9 @@ static int snd_hdspm_capture_open(struct snd_pcm_substream *substream)
                 snd_pcm_hw_constraint_minmax(runtime,
                                              SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
                                              64, 8192);
+                snd_pcm_hw_constraint_minmax(runtime,
+                                             SNDRV_PCM_HW_PARAM_PERIODS,
+                                             2, 2);
                 break;
         }
 
@@ -6965,9 +6967,7 @@ static int snd_hdspm_free(struct hdspm * hdspm)
                 free_irq(hdspm->irq, (void *) hdspm);
 
         kfree(hdspm->mixer);
-
-        if (hdspm->iobase)
-                iounmap(hdspm->iobase);
+        iounmap(hdspm->iobase);
 
         if (hdspm->port)
                 pci_release_regions(hdspm->pci);
diff --git a/sound/pci/rme9652/rme9652.c b/sound/pci/rme9652/rme9652.c
index 6521521853b8..fdbc0aa2776a 100644
--- a/sound/pci/rme9652/rme9652.c
+++ b/sound/pci/rme9652/rme9652.c
@@ -25,6 +25,7 @@
 #include <linux/interrupt.h>
 #include <linux/pci.h>
 #include <linux/module.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/control.h>
@@ -34,7 +35,6 @@
 #include <sound/initval.h>
 
 #include <asm/current.h>
-#include <asm/io.h>
 
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
@@ -1756,8 +1756,7 @@ static int snd_rme9652_free(struct snd_rme9652 *rme9652)
 
         if (rme9652->irq >= 0)
                 free_irq(rme9652->irq, (void *)rme9652);
-        if (rme9652->iobase)
-                iounmap(rme9652->iobase);
+        iounmap(rme9652->iobase);
         if (rme9652->port)
                 pci_release_regions(rme9652->pci);
 
diff --git a/sound/pci/sis7019.c b/sound/pci/sis7019.c
index 7f6a0a0d115a..efe669b80256 100644
--- a/sound/pci/sis7019.c
+++ b/sound/pci/sis7019.c
@@ -1064,12 +1064,9 @@ static int sis_chip_free(struct sis7019 *sis)
         if (sis->irq >= 0)
                 free_irq(sis->irq, sis);
 
-        if (sis->ioaddr)
-                iounmap(sis->ioaddr);
-
+        iounmap(sis->ioaddr);
         pci_release_regions(sis->pci);
         pci_disable_device(sis->pci);
-
         sis_free_suspend(sis);
         return 0;
 }
@@ -1211,7 +1208,6 @@ static int sis_chip_init(struct sis7019 *sis)
 #ifdef CONFIG_PM_SLEEP
 static int sis_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct sis7019 *sis = card->private_data;
         void __iomem *ioaddr = sis->ioaddr;
@@ -1240,9 +1236,6 @@ static int sis_suspend(struct device *dev)
                 ioaddr += 4096;
         }
 
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
@@ -1254,14 +1247,6 @@ static int sis_resume(struct device *dev)
         void __iomem *ioaddr = sis->ioaddr;
         int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-
-        if (pci_enable_device(pci) < 0) {
-                dev_err(&pci->dev, "unable to re-enable device\n");
-                goto error;
-        }
-
         if (sis_chip_init(sis)) {
                 dev_err(&pci->dev, "unable to re-init controller\n");
                 goto error;
@@ -1284,7 +1269,6 @@ static int sis_resume(struct device *dev)
         memset(sis->suspend_state[0], 0, 4096);
 
         sis->irq = pci->irq;
-        pci_set_master(pci);
 
         if (sis->codecs_present & SIS_PRIMARY_CODEC_PRESENT)
                 snd_ac97_resume(sis->ac97[0]);
diff --git a/sound/pci/sonicvibes.c b/sound/pci/sonicvibes.c
index 313a7328bf9c..0f40624a4275 100644
--- a/sound/pci/sonicvibes.c
+++ b/sound/pci/sonicvibes.c
@@ -30,6 +30,7 @@
 #include <linux/gameport.h>
 #include <linux/module.h>
 #include <linux/dma-mapping.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/pcm.h>
@@ -39,8 +40,6 @@
 #include <sound/opl3.h>
 #include <sound/initval.h>
 
-#include <asm/io.h>
-
 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
 MODULE_DESCRIPTION("S3 SonicVibes PCI");
 MODULE_LICENSE("GPL");
@@ -880,8 +879,7 @@ static struct snd_pcm_ops snd_sonicvibes_capture_ops = {
         .pointer =      snd_sonicvibes_capture_pointer,
 };
 
-static int snd_sonicvibes_pcm(struct sonicvibes *sonic, int device,
-                              struct snd_pcm **rpcm)
+static int snd_sonicvibes_pcm(struct sonicvibes *sonic, int device)
 {
         struct snd_pcm *pcm;
         int err;
@@ -902,8 +900,6 @@ static int snd_sonicvibes_pcm(struct sonicvibes *sonic, int device,
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(sonic->pci), 64*1024, 128*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 
@@ -1491,7 +1487,7 @@ static int snd_sonic_probe(struct pci_dev *pci,
                 (unsigned long long)pci_resource_start(pci, 1),
                 sonic->irq);
 
-        if ((err = snd_sonicvibes_pcm(sonic, 0, NULL)) < 0) {
+        if ((err = snd_sonicvibes_pcm(sonic, 0)) < 0) {
                 snd_card_free(card);
                 return err;
         }
diff --git a/sound/pci/trident/trident.c b/sound/pci/trident/trident.c
index a54cd6879b31..cedf13b64803 100644
--- a/sound/pci/trident/trident.c
+++ b/sound/pci/trident/trident.c
@@ -127,21 +127,21 @@ static int snd_trident_probe(struct pci_dev *pci,
         sprintf(card->longname, "%s PCI Audio at 0x%lx, irq %d",
                 card->shortname, trident->port, trident->irq);
 
-        if ((err = snd_trident_pcm(trident, pcm_dev++, NULL)) < 0) {
+        if ((err = snd_trident_pcm(trident, pcm_dev++)) < 0) {
                 snd_card_free(card);
                 return err;
         }
         switch (trident->device) {
         case TRIDENT_DEVICE_ID_DX:
         case TRIDENT_DEVICE_ID_NX:
-                if ((err = snd_trident_foldback_pcm(trident, pcm_dev++, NULL)) < 0) {
+                if ((err = snd_trident_foldback_pcm(trident, pcm_dev++)) < 0) {
                         snd_card_free(card);
                         return err;
                 }
                 break;
         }
         if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018) {
-                if ((err = snd_trident_spdif_pcm(trident, pcm_dev++, NULL)) < 0) {
+                if ((err = snd_trident_spdif_pcm(trident, pcm_dev++)) < 0) {
                         snd_card_free(card);
                         return err;
                 }
diff --git a/sound/pci/trident/trident.h b/sound/pci/trident/trident.h
index 5f110eb56e47..9624e5937719 100644
--- a/sound/pci/trident/trident.h
+++ b/sound/pci/trident/trident.h
@@ -420,9 +420,9 @@ int snd_trident_create(struct snd_card *card,
                        struct snd_trident ** rtrident);
 int snd_trident_create_gameport(struct snd_trident *trident);
 
-int snd_trident_pcm(struct snd_trident * trident, int device, struct snd_pcm **rpcm);
-int snd_trident_foldback_pcm(struct snd_trident * trident, int device, struct snd_pcm **rpcm);
-int snd_trident_spdif_pcm(struct snd_trident * trident, int device, struct snd_pcm **rpcm);
+int snd_trident_pcm(struct snd_trident *trident, int device);
+int snd_trident_foldback_pcm(struct snd_trident *trident, int device);
+int snd_trident_spdif_pcm(struct snd_trident *trident, int device);
 int snd_trident_attach_synthesizer(struct snd_trident * trident);
 struct snd_trident_voice *snd_trident_alloc_voice(struct snd_trident * trident, int type,
                                              int client, int port);
diff --git a/sound/pci/trident/trident_main.c b/sound/pci/trident/trident_main.c
index 57cd757acfe7..b72be035f785 100644
--- a/sound/pci/trident/trident_main.c
+++ b/sound/pci/trident/trident_main.c
@@ -36,6 +36,7 @@
 #include <linux/gameport.h>
 #include <linux/dma-mapping.h>
 #include <linux/export.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/info.h>
@@ -44,8 +45,6 @@
 #include "trident.h"
 #include <sound/asoundef.h>
 
-#include <asm/io.h>
-
 static int snd_trident_pcm_mixer_build(struct snd_trident *trident,
                                        struct snd_trident_voice * voice,
                                        struct snd_pcm_substream *substream);
@@ -2172,14 +2171,11 @@ static struct snd_pcm_ops snd_trident_spdif_7018_ops = {
   
   ---------------------------------------------------------------------------*/
 
-int snd_trident_pcm(struct snd_trident *trident,
-                    int device, struct snd_pcm **rpcm)
+int snd_trident_pcm(struct snd_trident *trident, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(trident->card, "trident_dx_nx", device, trident->ChanPCM, 1, &pcm)) < 0)
                 return err;
 
@@ -2214,8 +2210,6 @@ int snd_trident_pcm(struct snd_trident *trident,
                                                       snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
         }
 
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 
@@ -2230,16 +2224,13 @@ int snd_trident_pcm(struct snd_trident *trident,
   
   ---------------------------------------------------------------------------*/
 
-int snd_trident_foldback_pcm(struct snd_trident *trident,
-                             int device, struct snd_pcm **rpcm)
+int snd_trident_foldback_pcm(struct snd_trident *trident, int device)
 {
         struct snd_pcm *foldback;
         int err;
         int num_chan = 3;
         struct snd_pcm_substream *substream;
 
-        if (rpcm)
-                *rpcm = NULL;
         if (trident->device == TRIDENT_DEVICE_ID_NX)
                 num_chan = 4;
         if ((err = snd_pcm_new(trident->card, "trident_dx_nx", device, 0, num_chan, &foldback)) < 0)
@@ -2271,8 +2262,6 @@ int snd_trident_foldback_pcm(struct snd_trident *trident,
                 snd_pcm_lib_preallocate_pages_for_all(foldback, SNDRV_DMA_TYPE_DEV,
                                                       snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
 
-        if (rpcm)
-                *rpcm = foldback;
         return 0;
 }
 
@@ -2287,14 +2276,11 @@ int snd_trident_foldback_pcm(struct snd_trident *trident,
   
   ---------------------------------------------------------------------------*/
 
-int snd_trident_spdif_pcm(struct snd_trident *trident,
-                          int device, struct snd_pcm **rpcm)
+int snd_trident_spdif_pcm(struct snd_trident *trident, int device)
 {
         struct snd_pcm *spdif;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(trident->card, "trident_dx_nx IEC958", device, 1, 0, &spdif)) < 0)
                 return err;
 
@@ -2310,8 +2296,6 @@ int snd_trident_spdif_pcm(struct snd_trident *trident,
 
         snd_pcm_lib_preallocate_pages_for_all(spdif, SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
 
-        if (rpcm)
-                *rpcm = spdif;
         return 0;
 }
 
@@ -3926,7 +3910,6 @@ static void snd_trident_clear_voices(struct snd_trident * trident, unsigned shor
 #ifdef CONFIG_PM_SLEEP
 static int snd_trident_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_trident *trident = card->private_data;
 
@@ -3938,28 +3921,14 @@ static int snd_trident_suspend(struct device *dev)
 
         snd_ac97_suspend(trident->ac97);
         snd_ac97_suspend(trident->ac97_sec);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_trident_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_trident *trident = card->private_data;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         switch (trident->device) {
         case TRIDENT_DEVICE_ID_DX:
                 snd_trident_4d_dx_init(trident);
diff --git a/sound/pci/trident/trident_memory.c b/sound/pci/trident/trident_memory.c
index 04c474658e3c..b9ebb51893c5 100644
--- a/sound/pci/trident/trident_memory.c
+++ b/sound/pci/trident/trident_memory.c
@@ -23,7 +23,7 @@
  *
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/pci.h>
 #include <linux/time.h>
 #include <linux/mutex.h>
diff --git a/sound/pci/via82xx.c b/sound/pci/via82xx.c
index e088467fb736..8622283e89f3 100644
--- a/sound/pci/via82xx.c
+++ b/sound/pci/via82xx.c
@@ -46,7 +46,7 @@
  *      - Optimize position calculation for the 823x chips. 
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -2271,7 +2271,6 @@ static int snd_via82xx_chip_init(struct via82xx *chip)
  */
 static int snd_via82xx_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct via82xx *chip = card->private_data;
         int i;
@@ -2291,28 +2290,15 @@ static int snd_via82xx_suspend(struct device *dev)
                 chip->capture_src_saved[1] = inb(chip->port + VIA_REG_CAPTURE_CHANNEL + 0x10);
         }
 
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_via82xx_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct via82xx *chip = card->private_data;
         int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_via82xx_chip_init(chip);
 
         if (chip->chip_type == TYPE_VIA686) {
diff --git a/sound/pci/via82xx_modem.c b/sound/pci/via82xx_modem.c
index fd46ffe12e4f..99b9137bc677 100644
--- a/sound/pci/via82xx_modem.c
+++ b/sound/pci/via82xx_modem.c
@@ -31,7 +31,7 @@
  *      modems.
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
 #include <linux/init.h>
@@ -1031,7 +1031,6 @@ static int snd_via82xx_chip_init(struct via82xx_modem *chip)
  */
 static int snd_via82xx_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct via82xx_modem *chip = card->private_data;
         int i;
@@ -1043,29 +1042,15 @@ static int snd_via82xx_suspend(struct device *dev)
                 snd_via82xx_channel_reset(chip, &chip->devs[i]);
         synchronize_irq(chip->irq);
         snd_ac97_suspend(chip->ac97);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
 static int snd_via82xx_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct via82xx_modem *chip = card->private_data;
         int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
-
         snd_via82xx_chip_init(chip);
 
         snd_ac97_resume(chip->ac97);
diff --git a/sound/pci/vx222/vx222.c b/sound/pci/vx222/vx222.c
index c5a25e39e3a8..ecbaf473fc1e 100644
--- a/sound/pci/vx222/vx222.c
+++ b/sound/pci/vx222/vx222.c
@@ -259,32 +259,17 @@ static void snd_vx222_remove(struct pci_dev *pci)
 #ifdef CONFIG_PM_SLEEP
 static int snd_vx222_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_vx222 *vx = card->private_data;
-        int err;
 
-        err = snd_vx_suspend(&vx->core);
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
-        return err;
+        return snd_vx_suspend(&vx->core);
 }
 
 static int snd_vx222_resume(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_vx222 *vx = card->private_data;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
         return snd_vx_resume(&vx->core);
 }
 
diff --git a/sound/pci/vx222/vx222_ops.c b/sound/pci/vx222/vx222_ops.c
index 52c1a8d5b88a..af83b3b38052 100644
--- a/sound/pci/vx222/vx222_ops.c
+++ b/sound/pci/vx222/vx222_ops.c
@@ -24,11 +24,11 @@
 #include <linux/device.h>
 #include <linux/firmware.h>
 #include <linux/mutex.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/control.h>
 #include <sound/tlv.h>
-#include <asm/io.h>
 #include "vx222.h"
 
 
diff --git a/sound/pci/ymfpci/ymfpci.c b/sound/pci/ymfpci/ymfpci.c
index 47a192369e8f..812e27a1bcbc 100644
--- a/sound/pci/ymfpci/ymfpci.c
+++ b/sound/pci/ymfpci/ymfpci.c
@@ -283,11 +283,11 @@ static int snd_card_ymfpci_probe(struct pci_dev *pci,
                 card->shortname,
                 chip->reg_area_phys,
                 chip->irq);
-        if ((err = snd_ymfpci_pcm(chip, 0, NULL)) < 0) {
+        if ((err = snd_ymfpci_pcm(chip, 0)) < 0) {
                 snd_card_free(card);
                 return err;
         }
-        if ((err = snd_ymfpci_pcm_spdif(chip, 1, NULL)) < 0) {
+        if ((err = snd_ymfpci_pcm_spdif(chip, 1)) < 0) {
                 snd_card_free(card);
                 return err;
         }
@@ -297,12 +297,12 @@ static int snd_card_ymfpci_probe(struct pci_dev *pci,
                 return err;
         }
         if (chip->ac97->ext_id & AC97_EI_SDAC) {
-                err = snd_ymfpci_pcm_4ch(chip, 2, NULL);
+                err = snd_ymfpci_pcm_4ch(chip, 2);
                 if (err < 0) {
                         snd_card_free(card);
                         return err;
                 }
-                err = snd_ymfpci_pcm2(chip, 3, NULL);
+                err = snd_ymfpci_pcm2(chip, 3);
                 if (err < 0) {
                         snd_card_free(card);
                         return err;
diff --git a/sound/pci/ymfpci/ymfpci.h b/sound/pci/ymfpci/ymfpci.h
index 4631a2348915..149d4cb46998 100644
--- a/sound/pci/ymfpci/ymfpci.h
+++ b/sound/pci/ymfpci/ymfpci.h
@@ -379,10 +379,10 @@ void snd_ymfpci_free_gameport(struct snd_ymfpci *chip);
 
 extern const struct dev_pm_ops snd_ymfpci_pm;
 
-int snd_ymfpci_pcm(struct snd_ymfpci *chip, int device, struct snd_pcm **rpcm);
-int snd_ymfpci_pcm2(struct snd_ymfpci *chip, int device, struct snd_pcm **rpcm);
-int snd_ymfpci_pcm_spdif(struct snd_ymfpci *chip, int device, struct snd_pcm **rpcm);
-int snd_ymfpci_pcm_4ch(struct snd_ymfpci *chip, int device, struct snd_pcm **rpcm);
+int snd_ymfpci_pcm(struct snd_ymfpci *chip, int device);
+int snd_ymfpci_pcm2(struct snd_ymfpci *chip, int device);
+int snd_ymfpci_pcm_spdif(struct snd_ymfpci *chip, int device);
+int snd_ymfpci_pcm_4ch(struct snd_ymfpci *chip, int device);
 int snd_ymfpci_mixer(struct snd_ymfpci *chip, int rear_switch);
 int snd_ymfpci_timer(struct snd_ymfpci *chip, int device);
 
diff --git a/sound/pci/ymfpci/ymfpci_main.c b/sound/pci/ymfpci/ymfpci_main.c
index 81c916a5eb96..4c26076dbf78 100644
--- a/sound/pci/ymfpci/ymfpci_main.c
+++ b/sound/pci/ymfpci/ymfpci_main.c
@@ -27,6 +27,7 @@
 #include <linux/slab.h>
 #include <linux/mutex.h>
 #include <linux/module.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
 #include <sound/control.h>
@@ -36,7 +37,6 @@
 #include <sound/asoundef.h>
 #include <sound/mpu401.h>
 
-#include <asm/io.h>
 #include <asm/byteorder.h>
 
 /*
@@ -1145,13 +1145,11 @@ static struct snd_pcm_ops snd_ymfpci_capture_rec_ops = {
         .pointer =              snd_ymfpci_capture_pointer,
 };
 
-int snd_ymfpci_pcm(struct snd_ymfpci *chip, int device, struct snd_pcm **rpcm)
+int snd_ymfpci_pcm(struct snd_ymfpci *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(chip->card, "YMFPCI", device, 32, 1, &pcm)) < 0)
                 return err;
         pcm->private_data = chip;
@@ -1167,14 +1165,8 @@ int snd_ymfpci_pcm(struct snd_ymfpci *chip, int device, struct snd_pcm **rpcm)
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
 
-        err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
+        return snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
                                      snd_pcm_std_chmaps, 2, 0, NULL);
-        if (err < 0)
-                return err;
-
-        if (rpcm)
-                *rpcm = pcm;
-        return 0;
 }
 
 static struct snd_pcm_ops snd_ymfpci_capture_ac97_ops = {
@@ -1188,13 +1180,11 @@ static struct snd_pcm_ops snd_ymfpci_capture_ac97_ops = {
         .pointer =              snd_ymfpci_capture_pointer,
 };
 
-int snd_ymfpci_pcm2(struct snd_ymfpci *chip, int device, struct snd_pcm **rpcm)
+int snd_ymfpci_pcm2(struct snd_ymfpci *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(chip->card, "YMFPCI - PCM2", device, 0, 1, &pcm)) < 0)
                 return err;
         pcm->private_data = chip;
@@ -1210,8 +1200,6 @@ int snd_ymfpci_pcm2(struct snd_ymfpci *chip, int device, struct snd_pcm **rpcm)
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 
@@ -1226,14 +1214,11 @@ static struct snd_pcm_ops snd_ymfpci_playback_spdif_ops = {
         .pointer =              snd_ymfpci_playback_pointer,
 };
 
-int snd_ymfpci_pcm_spdif(struct snd_ymfpci *chip, int device,
-                         struct snd_pcm **rpcm)
+int snd_ymfpci_pcm_spdif(struct snd_ymfpci *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(chip->card, "YMFPCI - IEC958", device, 1, 0, &pcm)) < 0)
                 return err;
         pcm->private_data = chip;
@@ -1248,8 +1233,6 @@ int snd_ymfpci_pcm_spdif(struct snd_ymfpci *chip, int device,
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
 
@@ -1272,14 +1255,11 @@ static const struct snd_pcm_chmap_elem surround_map[] = {
         { }
 };
 
-int snd_ymfpci_pcm_4ch(struct snd_ymfpci *chip, int device,
-                       struct snd_pcm **rpcm)
+int snd_ymfpci_pcm_4ch(struct snd_ymfpci *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(chip->card, "YMFPCI - Rear", device, 1, 0, &pcm)) < 0)
                 return err;
         pcm->private_data = chip;
@@ -1294,14 +1274,8 @@ int snd_ymfpci_pcm_4ch(struct snd_ymfpci *chip, int device,
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                               snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
 
-        err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
+        return snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
                                      surround_map, 2, 0, NULL);
-        if (err < 0)
-                return err;
-
-        if (rpcm)
-                *rpcm = pcm;
-        return 0;
 }
 
 static int snd_ymfpci_spdif_default_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
@@ -2272,8 +2246,7 @@ static int snd_ymfpci_free(struct snd_ymfpci *chip)
         release_and_free_resource(chip->mpu_res);
         release_and_free_resource(chip->fm_res);
         snd_ymfpci_free_gameport(chip);
-        if (chip->reg_area_virt)
-                iounmap(chip->reg_area_virt);
+        iounmap(chip->reg_area_virt);
         if (chip->work_ptr.area)
                 snd_dma_free_pages(&chip->work_ptr);
         
@@ -2326,7 +2299,6 @@ static int saved_regs_index[] = {
 
 static int snd_ymfpci_suspend(struct device *dev)
 {
-        struct pci_dev *pci = to_pci_dev(dev);
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_ymfpci *chip = card->private_data;
         unsigned int i;
@@ -2347,9 +2319,6 @@ static int snd_ymfpci_suspend(struct device *dev)
         snd_ymfpci_writel(chip, YDSXGR_NATIVEDACOUTVOL, 0);
         snd_ymfpci_writel(chip, YDSXGR_BUF441OUTVOL, 0);
         snd_ymfpci_disable_dsp(chip);
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, PCI_D3hot);
         return 0;
 }
 
@@ -2360,14 +2329,6 @@ static int snd_ymfpci_resume(struct device *dev)
         struct snd_ymfpci *chip = card->private_data;
         unsigned int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                dev_err(dev, "pci_enable_device failed, disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
         snd_ymfpci_aclink_reset(pci);
         snd_ymfpci_codec_ready(chip, 0);
         snd_ymfpci_download_image(chip);