71 files changed, 693 insertions, 806 deletions

diff --git a/sound/pci/ac97/ac97_proc.c b/sound/pci/ac97/ac97_proc.c
index e120a11c69e8..20516b6907b5 100644
--- a/sound/pci/ac97/ac97_proc.c
+++ b/sound/pci/ac97/ac97_proc.c
@@ -436,25 +436,20 @@ void snd_ac97_proc_init(struct snd_ac97 * ac97)
                 return;
         prefix = ac97_is_audio(ac97) ? "ac97" : "mc97";
         sprintf(name, "%s#%d-%d", prefix, ac97->addr, ac97->num);
-        if ((entry = snd_info_create_card_entry(ac97->bus->card, name, ac97->bus->proc)) != NULL) {
+        entry = snd_info_create_card_entry(ac97->bus->card, name,
+                                           ac97->bus->proc);
+        if (entry)
                 snd_info_set_text_ops(entry, ac97, snd_ac97_proc_read);
-                if (snd_info_register(entry) < 0) {
-                        snd_info_free_entry(entry);
-                        entry = NULL;
-                }
-        }
         ac97->proc = entry;
         sprintf(name, "%s#%d-%d+regs", prefix, ac97->addr, ac97->num);
-        if ((entry = snd_info_create_card_entry(ac97->bus->card, name, ac97->bus->proc)) != NULL) {
+        entry = snd_info_create_card_entry(ac97->bus->card, name,
+                                           ac97->bus->proc);
+        if (entry) {
                 snd_info_set_text_ops(entry, ac97, snd_ac97_proc_regs_read);
 #ifdef CONFIG_SND_DEBUG
                 entry->mode |= 0200;
                 entry->c.text.write = snd_ac97_proc_regs_write;
 #endif
-                if (snd_info_register(entry) < 0) {
-                        snd_info_free_entry(entry);
-                        entry = NULL;
-                }
         }
         ac97->proc_regs = entry;
 }
@@ -473,13 +468,10 @@ void snd_ac97_bus_proc_init(struct snd_ac97_bus * bus)
         char name[32];
 
         sprintf(name, "codec97#%d", bus->num);
-        if ((entry = snd_info_create_card_entry(bus->card, name, bus->card->proc_root)) != NULL) {
+        entry = snd_info_create_card_entry(bus->card, name,
+                                           bus->card->proc_root);
+        if (entry)
                 entry->mode = S_IFDIR | 0555;
-                if (snd_info_register(entry) < 0) {
-                        snd_info_free_entry(entry);
-                        entry = NULL;
-                }
-        }
         bus->proc = entry;
 }
 
diff --git a/sound/pci/ad1889.c b/sound/pci/ad1889.c
index d9c54c08e2db..fef07ae648e6 100644
--- a/sound/pci/ad1889.c
+++ b/sound/pci/ad1889.c
@@ -644,16 +644,11 @@ snd_ad1889_pcm_init(struct snd_ad1889 *chip, int device)
         chip->psubs = NULL;
         chip->csubs = NULL;
 
-        err = snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
                                                 snd_dma_pci_data(chip->pci),
                                                 BUFFER_BYTES_MAX / 2,
                                                 BUFFER_BYTES_MAX);
 
-        if (err < 0) {
-                dev_err(chip->card->dev, "buffer allocation error: %d\n", err);
-                return err;
-        }
-        
         return 0;
 }
 
@@ -741,10 +736,8 @@ snd_ad1889_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffe
 static void
 snd_ad1889_proc_init(struct snd_ad1889 *chip)
 {
-        struct snd_info_entry *entry;
-
-        if (!snd_card_proc_new(chip->card, chip->card->driver, &entry))
-                snd_info_set_text_ops(entry, chip, snd_ad1889_proc_read);
+        snd_card_ro_proc_new(chip->card, chip->card->driver,
+                             chip, snd_ad1889_proc_read);
 }
 
 static const struct ac97_quirk ac97_quirks[] = {
diff --git a/sound/pci/ak4531_codec.c b/sound/pci/ak4531_codec.c
index 2fb1fbba3e5e..11e902cac71b 100644
--- a/sound/pci/ak4531_codec.c
+++ b/sound/pci/ak4531_codec.c
@@ -481,8 +481,5 @@ static void snd_ak4531_proc_read(struct snd_info_entry *entry,
 static void
 snd_ak4531_proc_init(struct snd_card *card, struct snd_ak4531 *ak4531)
 {
-        struct snd_info_entry *entry;
-
-        if (! snd_card_proc_new(card, "ak4531", &entry))
-                snd_info_set_text_ops(entry, ak4531, snd_ak4531_proc_read);
+        snd_card_ro_proc_new(card, "ak4531", ak4531, snd_ak4531_proc_read);
 }
diff --git a/sound/pci/ali5451/ali5451.c b/sound/pci/ali5451/ali5451.c
index 9f569379b77e..f7fbe05836b3 100644
--- a/sound/pci/ali5451/ali5451.c
+++ b/sound/pci/ali5451/ali5451.c
@@ -1882,10 +1882,8 @@ static int ali_suspend(struct device *dev)
                 return 0;
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        for (i = 0; i < chip->num_of_codecs; i++) {
-                snd_pcm_suspend_all(chip->pcm[i]);
+        for (i = 0; i < chip->num_of_codecs; i++)
                 snd_ac97_suspend(chip->ac97[i]);
-        }
 
         spin_lock_irq(&chip->reg_lock);
         
@@ -2051,9 +2049,7 @@ static void snd_ali_proc_read(struct snd_info_entry *entry,
 
 static void snd_ali_proc_init(struct snd_ali *codec)
 {
-        struct snd_info_entry *entry;
-        if (!snd_card_proc_new(codec->card, "ali5451", &entry))
-                snd_info_set_text_ops(entry, codec, snd_ali_proc_read);
+        snd_card_ro_proc_new(codec->card, "ali5451", codec, snd_ali_proc_read);
 }
 
 static int snd_ali_resources(struct snd_ali *codec)
diff --git a/sound/pci/als300.c b/sound/pci/als300.c
index eaa2d853d922..516b3d9cbfdf 100644
--- a/sound/pci/als300.c
+++ b/sound/pci/als300.c
@@ -731,7 +731,6 @@ static int snd_als300_suspend(struct device *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);
         return 0;
 }
diff --git a/sound/pci/als4000.c b/sound/pci/als4000.c
index 26b097edec8c..45fa38382e79 100644
--- a/sound/pci/als4000.c
+++ b/sound/pci/als4000.c
@@ -994,7 +994,6 @@ static int snd_als4000_suspend(struct device *dev)
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
         
-        snd_pcm_suspend_all(chip->pcm);
         snd_sbmixer_suspend(chip);
         return 0;
 }
diff --git a/sound/pci/asihpi/asihpi.c b/sound/pci/asihpi/asihpi.c
index aad74e809797..32b2f9802479 100644
--- a/sound/pci/asihpi/asihpi.c
+++ b/sound/pci/asihpi/asihpi.c
@@ -2782,10 +2782,8 @@ snd_asihpi_proc_read(struct snd_info_entry *entry,
 
 static void snd_asihpi_proc_init(struct snd_card_asihpi *asihpi)
 {
-        struct snd_info_entry *entry;
-
-        if (!snd_card_proc_new(asihpi->card, "info", &entry))
-                snd_info_set_text_ops(entry, asihpi, snd_asihpi_proc_read);
+        snd_card_ro_proc_new(asihpi->card, "info", asihpi,
+                             snd_asihpi_proc_read);
 }
 
 /*------------------------------------------------------------
diff --git a/sound/pci/atiixp.c b/sound/pci/atiixp.c
index 1a41f8c80243..169763c88f5e 100644
--- a/sound/pci/atiixp.c
+++ b/sound/pci/atiixp.c
@@ -733,6 +733,10 @@ static int snd_atiixp_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
         case SNDRV_PCM_TRIGGER_START:
         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
         case SNDRV_PCM_TRIGGER_RESUME:
+                if (dma->running && dma->suspended &&
+                    cmd == SNDRV_PCM_TRIGGER_RESUME)
+                        writel(dma->saved_curptr, chip->remap_addr +
+                               dma->ops->dt_cur);
                 dma->ops->enable_transfer(chip, 1);
                 dma->running = 1;
                 dma->suspended = 0;
@@ -740,9 +744,12 @@ static int snd_atiixp_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
         case SNDRV_PCM_TRIGGER_STOP:
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
         case SNDRV_PCM_TRIGGER_SUSPEND:
+                dma->suspended = cmd == SNDRV_PCM_TRIGGER_SUSPEND;
+                if (dma->running && dma->suspended)
+                        dma->saved_curptr = readl(chip->remap_addr +
+                                                  dma->ops->dt_cur);
                 dma->ops->enable_transfer(chip, 0);
                 dma->running = 0;
-                dma->suspended = cmd == SNDRV_PCM_TRIGGER_SUSPEND;
                 break;
         default:
                 err = -EINVAL;
@@ -1479,14 +1486,6 @@ static int snd_atiixp_suspend(struct device *dev)
         int i;
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        for (i = 0; i < NUM_ATI_PCMDEVS; i++)
-                if (chip->pcmdevs[i]) {
-                        struct atiixp_dma *dma = &chip->dmas[i];
-                        if (dma->substream && dma->running)
-                                dma->saved_curptr = readl(chip->remap_addr +
-                                                          dma->ops->dt_cur);
-                        snd_pcm_suspend_all(chip->pcmdevs[i]);
-                }
         for (i = 0; i < NUM_ATI_CODECS; i++)
                 snd_ac97_suspend(chip->ac97[i]);
         snd_atiixp_aclink_down(chip);
@@ -1514,8 +1513,6 @@ static int snd_atiixp_resume(struct device *dev)
                                 dma->substream->ops->prepare(dma->substream);
                                 writel((u32)dma->desc_buf.addr | ATI_REG_LINKPTR_EN,
                                        chip->remap_addr + dma->ops->llp_offset);
-                                writel(dma->saved_curptr, chip->remap_addr +
-                                       dma->ops->dt_cur);
                         }
                 }
 
@@ -1546,10 +1543,7 @@ static void snd_atiixp_proc_read(struct snd_info_entry *entry,
 
 static void snd_atiixp_proc_init(struct atiixp *chip)
 {
-        struct snd_info_entry *entry;
-
-        if (! snd_card_proc_new(chip->card, "atiixp", &entry))
-                snd_info_set_text_ops(entry, chip, snd_atiixp_proc_read);
+        snd_card_ro_proc_new(chip->card, "atiixp", chip, snd_atiixp_proc_read);
 }
 
 
diff --git a/sound/pci/atiixp_modem.c b/sound/pci/atiixp_modem.c
index dc1de860cedf..cece66bb3644 100644
--- a/sound/pci/atiixp_modem.c
+++ b/sound/pci/atiixp_modem.c
@@ -1125,8 +1125,6 @@ static int snd_atiixp_suspend(struct device *dev)
         int i;
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        for (i = 0; i < NUM_ATI_PCMDEVS; i++)
-                snd_pcm_suspend_all(chip->pcmdevs[i]);
         for (i = 0; i < NUM_ATI_CODECS; i++)
                 snd_ac97_suspend(chip->ac97[i]);
         snd_atiixp_aclink_down(chip);
@@ -1172,10 +1170,8 @@ static void snd_atiixp_proc_read(struct snd_info_entry *entry,
 
 static void snd_atiixp_proc_init(struct atiixp_modem *chip)
 {
-        struct snd_info_entry *entry;
-
-        if (! snd_card_proc_new(chip->card, "atiixp-modem", &entry))
-                snd_info_set_text_ops(entry, chip, snd_atiixp_proc_read);
+        snd_card_ro_proc_new(chip->card, "atiixp-modem", chip,
+                             snd_atiixp_proc_read);
 }
 
 
diff --git a/sound/pci/aw2/aw2-alsa.c b/sound/pci/aw2/aw2-alsa.c
index 9a49e4243a9c..b07c5fc1da56 100644
--- a/sound/pci/aw2/aw2-alsa.c
+++ b/sound/pci/aw2/aw2-alsa.c
@@ -624,15 +624,10 @@ static int snd_aw2_new_pcm(struct aw2 *chip)
 
         /* pre-allocation of buffers */
         /* Preallocate continuous pages. */
-        err = snd_pcm_lib_preallocate_pages_for_all(pcm_playback_ana,
-                                                    SNDRV_DMA_TYPE_DEV,
-                                                    snd_dma_pci_data
-                                                    (chip->pci),
-                                                    64 * 1024, 64 * 1024);
-        if (err)
-                dev_err(chip->card->dev,
-                        "snd_pcm_lib_preallocate_pages_for_all error (0x%X)\n",
-                        err);
+        snd_pcm_lib_preallocate_pages_for_all(pcm_playback_ana,
+                                              SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_pci_data(chip->pci),
+                                              64 * 1024, 64 * 1024);
 
         err = snd_pcm_new(chip->card, "Audiowerk2 digital playback", 1, 1, 0,
                           &pcm_playback_num);
@@ -661,15 +656,10 @@ static int snd_aw2_new_pcm(struct aw2 *chip)
 
         /* pre-allocation of buffers */
         /* Preallocate continuous pages. */
-        err = snd_pcm_lib_preallocate_pages_for_all(pcm_playback_num,
-                                                    SNDRV_DMA_TYPE_DEV,
-                                                    snd_dma_pci_data
-                                                    (chip->pci),
-                                                    64 * 1024, 64 * 1024);
-        if (err)
-                dev_err(chip->card->dev,
-                        "snd_pcm_lib_preallocate_pages_for_all error (0x%X)\n",
-                        err);
+        snd_pcm_lib_preallocate_pages_for_all(pcm_playback_num,
+                                              SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_pci_data(chip->pci),
+                                              64 * 1024, 64 * 1024);
 
         err = snd_pcm_new(chip->card, "Audiowerk2 capture", 2, 0, 1,
                           &pcm_capture);
@@ -699,16 +689,10 @@ static int snd_aw2_new_pcm(struct aw2 *chip)
 
         /* pre-allocation of buffers */
         /* Preallocate continuous pages. */
-        err = snd_pcm_lib_preallocate_pages_for_all(pcm_capture,
-                                                    SNDRV_DMA_TYPE_DEV,
-                                                    snd_dma_pci_data
-                                                    (chip->pci),
-                                                    64 * 1024, 64 * 1024);
-        if (err)
-                dev_err(chip->card->dev,
-                        "snd_pcm_lib_preallocate_pages_for_all error (0x%X)\n",
-                        err);
-
+        snd_pcm_lib_preallocate_pages_for_all(pcm_capture,
+                                              SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_pci_data(chip->pci),
+                                              64 * 1024, 64 * 1024);
 
         /* Create control */
         err = snd_ctl_add(chip->card, snd_ctl_new1(&aw2_control, chip));
diff --git a/sound/pci/azt3328.c b/sound/pci/azt3328.c
index fc18c29a8173..90348817f096 100644
--- a/sound/pci/azt3328.c
+++ b/sound/pci/azt3328.c
@@ -2699,10 +2699,6 @@ snd_azf3328_suspend(struct device *dev)
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
 
-        /* same pcm object for playback/capture */
-        snd_pcm_suspend_all(chip->pcm[AZF_CODEC_PLAYBACK]);
-        snd_pcm_suspend_all(chip->pcm[AZF_CODEC_I2S_OUT]);
-
         snd_azf3328_suspend_ac97(chip);
 
         snd_azf3328_suspend_regs(chip, chip->ctrl_io,
diff --git a/sound/pci/bt87x.c b/sound/pci/bt87x.c
index ba971042f871..0adcba10c067 100644
--- a/sound/pci/bt87x.c
+++ b/sound/pci/bt87x.c
@@ -714,11 +714,11 @@ static int snd_bt87x_pcm(struct snd_bt87x *chip, int device, char *name)
         pcm->private_data = chip;
         strcpy(pcm->name, name);
         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_bt87x_pcm_ops);
-        return snd_pcm_lib_preallocate_pages_for_all(pcm,
-                                                     SNDRV_DMA_TYPE_DEV_SG,
-                                                     snd_dma_pci_data(chip->pci),
-                                                        128 * 1024,
-                                                        ALIGN(255 * 4092, 1024));
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
+                                              snd_dma_pci_data(chip->pci),
+                                              128 * 1024,
+                                              ALIGN(255 * 4092, 1024));
+        return 0;
 }
 
 static int snd_bt87x_create(struct snd_card *card,
diff --git a/sound/pci/ca0106/ca0106_main.c b/sound/pci/ca0106/ca0106_main.c
index cd27b5536654..11ef0d636405 100644
--- a/sound/pci/ca0106/ca0106_main.c
+++ b/sound/pci/ca0106/ca0106_main.c
@@ -1402,21 +1402,17 @@ static int snd_ca0106_pcm(struct snd_ca0106 *emu, int device)
         for(substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; 
             substream; 
             substream = substream->next) {
-                if ((err = snd_pcm_lib_preallocate_pages(substream, 
-                                                         SNDRV_DMA_TYPE_DEV, 
-                                                         snd_dma_pci_data(emu->pci), 
-                                                         64*1024, 64*1024)) < 0) /* FIXME: 32*1024 for sound buffer, between 32and64 for Periods table. */
-                        return err;
+                snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_pci_data(emu->pci),
+                                              64*1024, 64*1024);
         }
 
         for (substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream; 
               substream; 
               substream = substream->next) {
-                if ((err = snd_pcm_lib_preallocate_pages(substream, 
-                                                   SNDRV_DMA_TYPE_DEV, 
-                                                   snd_dma_pci_data(emu->pci), 
-                                                   64*1024, 64*1024)) < 0)
-                        return err;
+                snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_pci_data(emu->pci),
+                                              64*1024, 64*1024);
         }
   
         err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK, map, 2,
@@ -1910,11 +1906,8 @@ static int snd_ca0106_suspend(struct device *dev)
 {
         struct snd_card *card = dev_get_drvdata(dev);
         struct snd_ca0106 *chip = card->private_data;
-        int i;
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        for (i = 0; i < 4; i++)
-                snd_pcm_suspend_all(chip->pcm[i]);
         if (chip->details->ac97)
                 snd_ac97_suspend(chip->ac97);
         snd_ca0106_mixer_suspend(chip);
diff --git a/sound/pci/ca0106/ca0106_proc.c b/sound/pci/ca0106/ca0106_proc.c
index a2c85cc37972..f5b8934db735 100644
--- a/sound/pci/ca0106/ca0106_proc.c
+++ b/sound/pci/ca0106/ca0106_proc.c
@@ -424,30 +424,20 @@ static void snd_ca0106_proc_i2c_write(struct snd_info_entry *entry,
 
 int snd_ca0106_proc_init(struct snd_ca0106 *emu)
 {
-        struct snd_info_entry *entry;
-        
-        if(! snd_card_proc_new(emu->card, "iec958", &entry))
-                snd_info_set_text_ops(entry, emu, snd_ca0106_proc_iec958);
-        if(! snd_card_proc_new(emu->card, "ca0106_reg32", &entry)) {
-                snd_info_set_text_ops(entry, emu, snd_ca0106_proc_reg_read32);
-                entry->c.text.write = snd_ca0106_proc_reg_write32;
-                entry->mode |= 0200;
-        }
-        if(! snd_card_proc_new(emu->card, "ca0106_reg16", &entry))
-                snd_info_set_text_ops(entry, emu, snd_ca0106_proc_reg_read16);
-        if(! snd_card_proc_new(emu->card, "ca0106_reg8", &entry))
-                snd_info_set_text_ops(entry, emu, snd_ca0106_proc_reg_read8);
-        if(! snd_card_proc_new(emu->card, "ca0106_regs1", &entry)) {
-                snd_info_set_text_ops(entry, emu, snd_ca0106_proc_reg_read1);
-                entry->c.text.write = snd_ca0106_proc_reg_write;
-                entry->mode |= 0200;
-        }
-        if(! snd_card_proc_new(emu->card, "ca0106_i2c", &entry)) {
-                entry->c.text.write = snd_ca0106_proc_i2c_write;
-                entry->private_data = emu;
-                entry->mode |= 0200;
-        }
-        if(! snd_card_proc_new(emu->card, "ca0106_regs2", &entry)) 
-                snd_info_set_text_ops(entry, emu, snd_ca0106_proc_reg_read2);
+        snd_card_ro_proc_new(emu->card, "iec958", emu, snd_ca0106_proc_iec958);
+        snd_card_rw_proc_new(emu->card, "ca0106_reg32", emu,
+                             snd_ca0106_proc_reg_read32,
+                             snd_ca0106_proc_reg_write32);
+        snd_card_ro_proc_new(emu->card, "ca0106_reg16", emu,
+                             snd_ca0106_proc_reg_read16);
+        snd_card_ro_proc_new(emu->card, "ca0106_reg8", emu,
+                             snd_ca0106_proc_reg_read8);
+        snd_card_rw_proc_new(emu->card, "ca0106_regs1", emu,
+                             snd_ca0106_proc_reg_read1,
+                             snd_ca0106_proc_reg_write);
+        snd_card_rw_proc_new(emu->card, "ca0106_i2c", emu, NULL,
+                             snd_ca0106_proc_i2c_write);
+        snd_card_ro_proc_new(emu->card, "ca0106_regs2", emu,
+                             snd_ca0106_proc_reg_read2);
         return 0;
 }
diff --git a/sound/pci/cmipci.c b/sound/pci/cmipci.c
index 452cc79b44af..701be04aed53 100644
--- a/sound/pci/cmipci.c
+++ b/sound/pci/cmipci.c
@@ -2792,10 +2792,7 @@ static void snd_cmipci_proc_read(struct snd_info_entry *entry,
 
 static void snd_cmipci_proc_init(struct cmipci *cm)
 {
-        struct snd_info_entry *entry;
-
-        if (! snd_card_proc_new(cm->card, "cmipci", &entry))
-                snd_info_set_text_ops(entry, cm, snd_cmipci_proc_read);
+        snd_card_ro_proc_new(cm->card, "cmipci", cm, snd_cmipci_proc_read);
 }
 
 static const struct pci_device_id snd_cmipci_ids[] = {
@@ -3351,10 +3348,6 @@ static int snd_cmipci_suspend(struct device *dev)
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
         
-        snd_pcm_suspend_all(cm->pcm);
-        snd_pcm_suspend_all(cm->pcm2);
-        snd_pcm_suspend_all(cm->pcm_spdif);
-
         /* save registers */
         for (i = 0; i < ARRAY_SIZE(saved_regs); i++)
                 cm->saved_regs[i] = snd_cmipci_read(cm, saved_regs[i]);
diff --git a/sound/pci/cs4281.c b/sound/pci/cs4281.c
index ec4247638fa1..15bbf9564c82 100644
--- a/sound/pci/cs4281.c
+++ b/sound/pci/cs4281.c
@@ -1174,8 +1174,7 @@ static void snd_cs4281_proc_init(struct cs4281 *chip)
 {
         struct snd_info_entry *entry;
 
-        if (! snd_card_proc_new(chip->card, "cs4281", &entry))
-                snd_info_set_text_ops(entry, chip, snd_cs4281_proc_read);
+        snd_card_ro_proc_new(chip->card, "cs4281", chip, snd_cs4281_proc_read);
         if (! snd_card_proc_new(chip->card, "cs4281_BA0", &entry)) {
                 entry->content = SNDRV_INFO_CONTENT_DATA;
                 entry->private_data = chip;
@@ -2002,8 +2001,6 @@ static int cs4281_suspend(struct device *dev)
         unsigned int i;
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        snd_pcm_suspend_all(chip->pcm);
-
         snd_ac97_suspend(chip->ac97);
         snd_ac97_suspend(chip->ac97_secondary);
 
diff --git a/sound/pci/cs46xx/cs46xx_dsp_spos.h b/sound/pci/cs46xx/cs46xx_dsp_spos.h
index 8008c59288a6..a02e1e19c021 100644
--- a/sound/pci/cs46xx/cs46xx_dsp_spos.h
+++ b/sound/pci/cs46xx/cs46xx_dsp_spos.h
@@ -177,22 +177,16 @@ struct dsp_spos_instance {
         /* proc fs */  
         struct snd_card *snd_card;
         struct snd_info_entry * proc_dsp_dir;
-        struct snd_info_entry * proc_sym_info_entry;
-        struct snd_info_entry * proc_modules_info_entry;
-        struct snd_info_entry * proc_parameter_dump_info_entry;
-        struct snd_info_entry * proc_sample_dump_info_entry;
 
         /* SCB's descriptors */
         int nscb;
         int scb_highest_frag_index;
         struct dsp_scb_descriptor scbs[DSP_MAX_SCB_DESC];
-        struct snd_info_entry * proc_scb_info_entry;
         struct dsp_scb_descriptor * the_null_scb;
 
         /* Task's descriptors */
         int ntask;
         struct dsp_task_descriptor tasks[DSP_MAX_TASK_DESC];
-        struct snd_info_entry * proc_task_info_entry;
 
         /* SPDIF status */
         int spdif_status_out;
diff --git a/sound/pci/cs46xx/cs46xx_lib.c b/sound/pci/cs46xx/cs46xx_lib.c
index 750eec437a79..a77d4cc44028 100644
--- a/sound/pci/cs46xx/cs46xx_lib.c
+++ b/sound/pci/cs46xx/cs46xx_lib.c
@@ -3781,12 +3781,6 @@ static int snd_cs46xx_suspend(struct device *dev)
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
         chip->in_suspend = 1;
-        snd_pcm_suspend_all(chip->pcm);
-#ifdef CONFIG_SND_CS46XX_NEW_DSP
-        snd_pcm_suspend_all(chip->pcm_rear);
-        snd_pcm_suspend_all(chip->pcm_center_lfe);
-        snd_pcm_suspend_all(chip->pcm_iec958);
-#endif
         // chip->ac97_powerdown = snd_cs46xx_codec_read(chip, AC97_POWER_CONTROL);
         // chip->ac97_general_purpose = snd_cs46xx_codec_read(chip, BA0_AC97_GENERAL_PURPOSE);
 
diff --git a/sound/pci/cs46xx/dsp_spos.c b/sound/pci/cs46xx/dsp_spos.c
index 5fc497c6d738..c28e58602679 100644
--- a/sound/pci/cs46xx/dsp_spos.c
+++ b/sound/pci/cs46xx/dsp_spos.c
@@ -799,92 +799,49 @@ int cs46xx_dsp_proc_init (struct snd_card *card, struct snd_cs46xx *chip)
 
         ins->snd_card = card;
 
-        if ((entry = snd_info_create_card_entry(card, "dsp", card->proc_root)) != NULL) {
-                entry->content = SNDRV_INFO_CONTENT_TEXT;
+        entry = snd_info_create_card_entry(card, "dsp", card->proc_root);
+        if (entry)
                 entry->mode = S_IFDIR | 0555;
-      
-                if (snd_info_register(entry) < 0) {
-                        snd_info_free_entry(entry);
-                        entry = NULL;
-                }
-        }
-
         ins->proc_dsp_dir = entry;
 
         if (!ins->proc_dsp_dir)
                 return -ENOMEM;
 
-        if ((entry = snd_info_create_card_entry(card, "spos_symbols", ins->proc_dsp_dir)) != NULL) {
-                entry->content = SNDRV_INFO_CONTENT_TEXT;
-                entry->private_data = chip;
-                entry->mode = S_IFREG | 0644;
-                entry->c.text.read = cs46xx_dsp_proc_symbol_table_read;
-                if (snd_info_register(entry) < 0) {
-                        snd_info_free_entry(entry);
-                        entry = NULL;
-                }
-        }
-        ins->proc_sym_info_entry = entry;
+        entry = snd_info_create_card_entry(card, "spos_symbols",
+                                           ins->proc_dsp_dir);
+        if (entry)
+                snd_info_set_text_ops(entry, chip,
+                                      cs46xx_dsp_proc_symbol_table_read);
     
-        if ((entry = snd_info_create_card_entry(card, "spos_modules", ins->proc_dsp_dir)) != NULL) {
-                entry->content = SNDRV_INFO_CONTENT_TEXT;
-                entry->private_data = chip;
-                entry->mode = S_IFREG | 0644;
-                entry->c.text.read = cs46xx_dsp_proc_modules_read;
-                if (snd_info_register(entry) < 0) {
-                        snd_info_free_entry(entry);
-                        entry = NULL;
-                }
-        }
-        ins->proc_modules_info_entry = entry;
-
-        if ((entry = snd_info_create_card_entry(card, "parameter", ins->proc_dsp_dir)) != NULL) {
-                entry->content = SNDRV_INFO_CONTENT_TEXT;
-                entry->private_data = chip;
-                entry->mode = S_IFREG | 0644;
-                entry->c.text.read = cs46xx_dsp_proc_parameter_dump_read;
-                if (snd_info_register(entry) < 0) {
-                        snd_info_free_entry(entry);
-                        entry = NULL;
-                }
-        }
-        ins->proc_parameter_dump_info_entry = entry;
-
-        if ((entry = snd_info_create_card_entry(card, "sample", ins->proc_dsp_dir)) != NULL) {
-                entry->content = SNDRV_INFO_CONTENT_TEXT;
-                entry->private_data = chip;
-                entry->mode = S_IFREG | 0644;
-                entry->c.text.read = cs46xx_dsp_proc_sample_dump_read;
-                if (snd_info_register(entry) < 0) {
-                        snd_info_free_entry(entry);
-                        entry = NULL;
-                }
-        }
-        ins->proc_sample_dump_info_entry = entry;
-
-        if ((entry = snd_info_create_card_entry(card, "task_tree", ins->proc_dsp_dir)) != NULL) {
-                entry->content = SNDRV_INFO_CONTENT_TEXT;
-                entry->private_data = chip;
-                entry->mode = S_IFREG | 0644;
-                entry->c.text.read = cs46xx_dsp_proc_task_tree_read;
-                if (snd_info_register(entry) < 0) {
-                        snd_info_free_entry(entry);
-                        entry = NULL;
-                }
-        }
-        ins->proc_task_info_entry = entry;
-
-        if ((entry = snd_info_create_card_entry(card, "scb_info", ins->proc_dsp_dir)) != NULL) {
-                entry->content = SNDRV_INFO_CONTENT_TEXT;
-                entry->private_data = chip;
-                entry->mode = S_IFREG | 0644;
-                entry->c.text.read = cs46xx_dsp_proc_scb_read;
-                if (snd_info_register(entry) < 0) {
-                        snd_info_free_entry(entry);
-                        entry = NULL;
-                }
-        }
-        ins->proc_scb_info_entry = entry;
+        entry = snd_info_create_card_entry(card, "spos_modules",
+                                           ins->proc_dsp_dir);
+        if (entry)
+                snd_info_set_text_ops(entry, chip,
+                                      cs46xx_dsp_proc_modules_read);
+
+        entry = snd_info_create_card_entry(card, "parameter",
+                                           ins->proc_dsp_dir);
+        if (entry)
+                snd_info_set_text_ops(entry, chip,
+                                      cs46xx_dsp_proc_parameter_dump_read);
+
+        entry = snd_info_create_card_entry(card, "sample",
+                                           ins->proc_dsp_dir);
+        if (entry)
+                snd_info_set_text_ops(entry, chip,
+                                      cs46xx_dsp_proc_sample_dump_read);
+
+        entry = snd_info_create_card_entry(card, "task_tree",
+                                           ins->proc_dsp_dir);
+        if (entry)
+                snd_info_set_text_ops(entry, chip,
+                                      cs46xx_dsp_proc_task_tree_read);
+
+        entry = snd_info_create_card_entry(card, "scb_info",
+                                           ins->proc_dsp_dir);
+        if (entry)
+                snd_info_set_text_ops(entry, chip,
+                                      cs46xx_dsp_proc_scb_read);
 
         mutex_lock(&chip->spos_mutex);
         /* register/update SCB's entries on proc */
@@ -906,24 +863,6 @@ int cs46xx_dsp_proc_done (struct snd_cs46xx *chip)
         if (!ins)
                 return 0;
 
-        snd_info_free_entry(ins->proc_sym_info_entry);
-        ins->proc_sym_info_entry = NULL;
-
-        snd_info_free_entry(ins->proc_modules_info_entry);
-        ins->proc_modules_info_entry = NULL;
-
-        snd_info_free_entry(ins->proc_parameter_dump_info_entry);
-        ins->proc_parameter_dump_info_entry = NULL;
-
-        snd_info_free_entry(ins->proc_sample_dump_info_entry);
-        ins->proc_sample_dump_info_entry = NULL;
-
-        snd_info_free_entry(ins->proc_scb_info_entry);
-        ins->proc_scb_info_entry = NULL;
-
-        snd_info_free_entry(ins->proc_task_info_entry);
-        ins->proc_task_info_entry = NULL;
-
         mutex_lock(&chip->spos_mutex);
         for (i = 0; i < ins->nscb; ++i) {
                 if (ins->scbs[i].deleted) continue;
diff --git a/sound/pci/cs46xx/dsp_spos_scb_lib.c b/sound/pci/cs46xx/dsp_spos_scb_lib.c
index 8d0a3d357345..1d9d610262de 100644
--- a/sound/pci/cs46xx/dsp_spos_scb_lib.c
+++ b/sound/pci/cs46xx/dsp_spos_scb_lib.c
@@ -254,8 +254,9 @@ void cs46xx_dsp_proc_register_scb_desc (struct snd_cs46xx *chip,
         if (ins->snd_card != NULL && ins->proc_dsp_dir != NULL &&
             scb->proc_info == NULL) {
   
-                if ((entry = snd_info_create_card_entry(ins->snd_card, scb->scb_name, 
-                                                        ins->proc_dsp_dir)) != NULL) {
+                entry = snd_info_create_card_entry(ins->snd_card, scb->scb_name,
+                                                   ins->proc_dsp_dir);
+                if (entry) {
                         scb_info = kmalloc(sizeof(struct proc_scb_info), GFP_KERNEL);
                         if (!scb_info) {
                                 snd_info_free_entry(entry);
@@ -265,18 +266,8 @@ void cs46xx_dsp_proc_register_scb_desc (struct snd_cs46xx *chip,
 
                         scb_info->chip = chip;
                         scb_info->scb_desc = scb;
-      
-                        entry->content = SNDRV_INFO_CONTENT_TEXT;
-                        entry->private_data = scb_info;
-                        entry->mode = S_IFREG | 0644;
-      
-                        entry->c.text.read = cs46xx_dsp_proc_scb_info_read;
-      
-                        if (snd_info_register(entry) < 0) {
-                                snd_info_free_entry(entry);
-                                kfree (scb_info);
-                                entry = NULL;
-                        }
+                        snd_info_set_text_ops(entry, scb_info,
+                                              cs46xx_dsp_proc_scb_info_read);
                 }
 out:
                 scb->proc_info = entry;
diff --git a/sound/pci/cs5535audio/cs5535audio_pm.c b/sound/pci/cs5535audio/cs5535audio_pm.c
index 82bd10b68a77..446ef1f1b45a 100644
--- a/sound/pci/cs5535audio/cs5535audio_pm.c
+++ b/sound/pci/cs5535audio/cs5535audio_pm.c
@@ -62,7 +62,6 @@ static int __maybe_unused snd_cs5535audio_suspend(struct device *dev)
         int i;
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        snd_pcm_suspend_all(cs5535au->pcm);
         snd_ac97_suspend(cs5535au->ac97);
         for (i = 0; i < NUM_CS5535AUDIO_DMAS; i++) {
                 struct cs5535audio_dma *dma = &cs5535au->dmas[i];
diff --git a/sound/pci/ctxfi/ctatc.c b/sound/pci/ctxfi/ctatc.c
index 2ada8444abd9..e622613ea947 100644
--- a/sound/pci/ctxfi/ctatc.c
+++ b/sound/pci/ctxfi/ctatc.c
@@ -1548,18 +1548,10 @@ static void atc_connect_resources(struct ct_atc *atc)
 #ifdef CONFIG_PM_SLEEP
 static int atc_suspend(struct ct_atc *atc)
 {
-        int i;
         struct hw *hw = atc->hw;
 
         snd_power_change_state(atc->card, SNDRV_CTL_POWER_D3hot);
 
-        for (i = FRONT; i < NUM_PCMS; i++) {
-                if (!atc->pcms[i])
-                        continue;
-
-                snd_pcm_suspend_all(atc->pcms[i]);
-        }
-
         atc_release_resources(atc);
 
         hw->suspend(hw);
diff --git a/sound/pci/echoaudio/echoaudio.c b/sound/pci/echoaudio/echoaudio.c
index 907cf1a46712..ea876b0b02b9 100644
--- a/sound/pci/echoaudio/echoaudio.c
+++ b/sound/pci/echoaudio/echoaudio.c
@@ -884,17 +884,15 @@ static const struct snd_pcm_ops digital_capture_ops = {
 static int snd_echo_preallocate_pages(struct snd_pcm *pcm, struct device *dev)
 {
         struct snd_pcm_substream *ss;
-        int stream, err;
+        int stream;
 
         for (stream = 0; stream < 2; stream++)
-                for (ss = pcm->streams[stream].substream; ss; ss = ss->next) {
-                        err = snd_pcm_lib_preallocate_pages(ss, SNDRV_DMA_TYPE_DEV_SG,
-                                                            dev,
-                                                            ss->number ? 0 : 128<<10,
-                                                            256<<10);
-                        if (err < 0)
-                                return err;
-                }
+                for (ss = pcm->streams[stream].substream; ss; ss = ss->next)
+                        snd_pcm_lib_preallocate_pages(ss, SNDRV_DMA_TYPE_DEV_SG,
+                                                      dev,
+                                                      ss->number ? 0 : 128<<10,
+                                                      256<<10);
+
         return 0;
 }
 
@@ -2165,9 +2163,6 @@ static int snd_echo_suspend(struct device *dev)
 {
         struct echoaudio *chip = dev_get_drvdata(dev);
 
-        snd_pcm_suspend_all(chip->analog_pcm);
-        snd_pcm_suspend_all(chip->digital_pcm);
-
 #ifdef ECHOCARD_HAS_MIDI
         /* This call can sleep */
         if (chip->midi_out)
diff --git a/sound/pci/emu10k1/emu10k1.c b/sound/pci/emu10k1/emu10k1.c
index d3203df50a1a..3c41a0edcfb0 100644
--- a/sound/pci/emu10k1/emu10k1.c
+++ b/sound/pci/emu10k1/emu10k1.c
@@ -224,12 +224,6 @@ static int snd_emu10k1_suspend(struct device *dev)
 
         cancel_delayed_work_sync(&emu->emu1010.firmware_work);
 
-        snd_pcm_suspend_all(emu->pcm);
-        snd_pcm_suspend_all(emu->pcm_mic);
-        snd_pcm_suspend_all(emu->pcm_efx);
-        snd_pcm_suspend_all(emu->pcm_multi);
-        snd_pcm_suspend_all(emu->pcm_p16v);
-
         snd_ac97_suspend(emu->ac97);
 
         snd_emu10k1_efx_suspend(emu);
diff --git a/sound/pci/emu10k1/emu10k1x.c b/sound/pci/emu10k1/emu10k1x.c
index 611589cbdad6..576c7bd03a1a 100644
--- a/sound/pci/emu10k1/emu10k1x.c
+++ b/sound/pci/emu10k1/emu10k1x.c
@@ -1065,15 +1065,9 @@ static void snd_emu10k1x_proc_reg_write(struct snd_info_entry *entry,
 
 static int snd_emu10k1x_proc_init(struct emu10k1x *emu)
 {
-        struct snd_info_entry *entry;
-        
-        if(! snd_card_proc_new(emu->card, "emu10k1x_regs", &entry)) {
-                snd_info_set_text_ops(entry, emu, snd_emu10k1x_proc_reg_read);
-                entry->c.text.write = snd_emu10k1x_proc_reg_write;
-                entry->mode |= 0200;
-                entry->private_data = emu;
-        }
-        
+        snd_card_rw_proc_new(emu->card, "emu10k1x_regs", emu,
+                             snd_emu10k1x_proc_reg_read,
+                             snd_emu10k1x_proc_reg_write);
         return 0;
 }
 
diff --git a/sound/pci/emu10k1/emupcm.c b/sound/pci/emu10k1/emupcm.c
index 30b3472d0b75..f6b4cb9ac75c 100644
--- a/sound/pci/emu10k1/emupcm.c
+++ b/sound/pci/emu10k1/emupcm.c
@@ -1427,11 +1427,14 @@ int snd_emu10k1_pcm(struct snd_emu10k1 *emu, int device)
         emu->pcm = pcm;
 
         for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next)
-                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;
+                snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV_SG,
+                                              snd_dma_pci_data(emu->pci),
+                                              64*1024, 64*1024);
 
         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);
+                snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_pci_data(emu->pci),
+                                              64*1024, 64*1024);
 
         return 0;
 }
@@ -1455,8 +1458,9 @@ int snd_emu10k1_pcm_multi(struct snd_emu10k1 *emu, int device)
         emu->pcm_multi = pcm;
 
         for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next)
-                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;
+                snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV_SG,
+                                              snd_dma_pci_data(emu->pci),
+                                              64*1024, 64*1024);
 
         return 0;
 }
@@ -1489,7 +1493,9 @@ int snd_emu10k1_pcm_mic(struct snd_emu10k1 *emu, int device)
         strcpy(pcm->name, "Mic Capture");
         emu->pcm_mic = pcm;
 
-        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(emu->pci), 64*1024, 64*1024);
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_pci_data(emu->pci),
+                                              64*1024, 64*1024);
 
         return 0;
 }
@@ -1862,7 +1868,9 @@ int snd_emu10k1_pcm_efx(struct snd_emu10k1 *emu, int device)
         if (err < 0)
                 return err;
 
-        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(emu->pci), 64*1024, 64*1024);
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_pci_data(emu->pci),
+                                              64*1024, 64*1024);
 
         return 0;
 }
diff --git a/sound/pci/emu10k1/emuproc.c b/sound/pci/emu10k1/emuproc.c
index b57008031792..a3d9f06e8e6a 100644
--- a/sound/pci/emu10k1/emuproc.c
+++ b/sound/pci/emu10k1/emuproc.c
@@ -568,55 +568,40 @@ int snd_emu10k1_proc_init(struct snd_emu10k1 *emu)
         struct snd_info_entry *entry;
 #ifdef CONFIG_SND_DEBUG
         if (emu->card_capabilities->emu_model) {
-                if (! snd_card_proc_new(emu->card, "emu1010_regs", &entry)) 
-                        snd_info_set_text_ops(entry, emu, snd_emu_proc_emu1010_reg_read);
-        }
-        if (! snd_card_proc_new(emu->card, "io_regs", &entry)) {
-                snd_info_set_text_ops(entry, emu, snd_emu_proc_io_reg_read);
-                entry->c.text.write = snd_emu_proc_io_reg_write;
-                entry->mode |= 0200;
-        }
-        if (! snd_card_proc_new(emu->card, "ptr_regs00a", &entry)) {
-                snd_info_set_text_ops(entry, emu, snd_emu_proc_ptr_reg_read00a);
-                entry->c.text.write = snd_emu_proc_ptr_reg_write00;
-                entry->mode |= 0200;
-        }
-        if (! snd_card_proc_new(emu->card, "ptr_regs00b", &entry)) {
-                snd_info_set_text_ops(entry, emu, snd_emu_proc_ptr_reg_read00b);
-                entry->c.text.write = snd_emu_proc_ptr_reg_write00;
-                entry->mode |= 0200;
-        }
-        if (! snd_card_proc_new(emu->card, "ptr_regs20a", &entry)) {
-                snd_info_set_text_ops(entry, emu, snd_emu_proc_ptr_reg_read20a);
-                entry->c.text.write = snd_emu_proc_ptr_reg_write20;
-                entry->mode |= 0200;
-        }
-        if (! snd_card_proc_new(emu->card, "ptr_regs20b", &entry)) {
-                snd_info_set_text_ops(entry, emu, snd_emu_proc_ptr_reg_read20b);
-                entry->c.text.write = snd_emu_proc_ptr_reg_write20;
-                entry->mode |= 0200;
-        }
-        if (! snd_card_proc_new(emu->card, "ptr_regs20c", &entry)) {
-                snd_info_set_text_ops(entry, emu, snd_emu_proc_ptr_reg_read20c);
-                entry->c.text.write = snd_emu_proc_ptr_reg_write20;
-                entry->mode |= 0200;
+                snd_card_ro_proc_new(emu->card, "emu1010_regs",
+                                     emu, snd_emu_proc_emu1010_reg_read);
         }
+        snd_card_rw_proc_new(emu->card, "io_regs", emu,
+                             snd_emu_proc_io_reg_read,
+                             snd_emu_proc_io_reg_write);
+        snd_card_rw_proc_new(emu->card, "ptr_regs00a", emu,
+                             snd_emu_proc_ptr_reg_read00a,
+                             snd_emu_proc_ptr_reg_write00);
+        snd_card_rw_proc_new(emu->card, "ptr_regs00b", emu,
+                             snd_emu_proc_ptr_reg_read00b,
+                             snd_emu_proc_ptr_reg_write00);
+        snd_card_rw_proc_new(emu->card, "ptr_regs20a", emu,
+                             snd_emu_proc_ptr_reg_read20a,
+                             snd_emu_proc_ptr_reg_write20);
+        snd_card_rw_proc_new(emu->card, "ptr_regs20b", emu,
+                             snd_emu_proc_ptr_reg_read20b,
+                             snd_emu_proc_ptr_reg_write20);
+        snd_card_rw_proc_new(emu->card, "ptr_regs20c", emu,
+                             snd_emu_proc_ptr_reg_read20c,
+                             snd_emu_proc_ptr_reg_write20);
 #endif
         
-        if (! snd_card_proc_new(emu->card, "emu10k1", &entry))
-                snd_info_set_text_ops(entry, emu, snd_emu10k1_proc_read);
+        snd_card_ro_proc_new(emu->card, "emu10k1", emu, snd_emu10k1_proc_read);
 
-        if (emu->card_capabilities->emu10k2_chip) {
-                if (! snd_card_proc_new(emu->card, "spdif-in", &entry))
-                        snd_info_set_text_ops(entry, emu, snd_emu10k1_proc_spdif_read);
-        }
-        if (emu->card_capabilities->ca0151_chip) {
-                if (! snd_card_proc_new(emu->card, "capture-rates", &entry))
-                        snd_info_set_text_ops(entry, emu, snd_emu10k1_proc_rates_read);
-        }
+        if (emu->card_capabilities->emu10k2_chip)
+                snd_card_ro_proc_new(emu->card, "spdif-in", emu,
+                                     snd_emu10k1_proc_spdif_read);
+        if (emu->card_capabilities->ca0151_chip)
+                snd_card_ro_proc_new(emu->card, "capture-rates", emu,
+                                     snd_emu10k1_proc_rates_read);
 
-        if (! snd_card_proc_new(emu->card, "voices", &entry))
-                snd_info_set_text_ops(entry, emu, snd_emu10k1_proc_voices_read);
+        snd_card_ro_proc_new(emu->card, "voices", emu,
+                             snd_emu10k1_proc_voices_read);
 
         if (! snd_card_proc_new(emu->card, "fx8010_gpr", &entry)) {
                 entry->content = SNDRV_INFO_CONTENT_DATA;
@@ -646,11 +631,7 @@ int snd_emu10k1_proc_init(struct snd_emu10k1 *emu)
                 entry->size = emu->audigy ? A_TOTAL_SIZE_CODE : TOTAL_SIZE_CODE;
                 entry->c.ops = &snd_emu10k1_proc_ops_fx8010;
         }
-        if (! snd_card_proc_new(emu->card, "fx8010_acode", &entry)) {
-                entry->content = SNDRV_INFO_CONTENT_TEXT;
-                entry->private_data = emu;
-                entry->mode = S_IFREG | 0444 /*| S_IWUSR*/;
-                entry->c.text.read = snd_emu10k1_proc_acode_read;
-        }
+        snd_card_ro_proc_new(emu->card, "fx8010_acode", emu,
+                             snd_emu10k1_proc_acode_read);
         return 0;
 }
diff --git a/sound/pci/emu10k1/p16v.c b/sound/pci/emu10k1/p16v.c
index 4948b95f6665..672017cac4c7 100644
--- a/sound/pci/emu10k1/p16v.c
+++ b/sound/pci/emu10k1/p16v.c
@@ -656,11 +656,10 @@ int snd_p16v_pcm(struct snd_emu10k1 *emu, int device)
         for(substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; 
             substream; 
             substream = substream->next) {
-                if ((err = snd_pcm_lib_preallocate_pages(substream, 
-                                                         SNDRV_DMA_TYPE_DEV, 
-                                                         snd_dma_pci_data(emu->pci), 
-                                                         ((65536 - 64) * 8), ((65536 - 64) * 8))) < 0) 
-                        return err;
+                snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_pci_data(emu->pci),
+                                              (65536 - 64) * 8,
+                                              (65536 - 64) * 8);
                 /*
                 dev_dbg(emu->card->dev,
                            "preallocate playback substream: err=%d\n", err);
@@ -670,11 +669,9 @@ int snd_p16v_pcm(struct snd_emu10k1 *emu, int device)
         for (substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream; 
               substream; 
               substream = substream->next) {
-                if ((err = snd_pcm_lib_preallocate_pages(substream, 
-                                                   SNDRV_DMA_TYPE_DEV, 
-                                                   snd_dma_pci_data(emu->pci), 
-                                                   65536 - 64, 65536 - 64)) < 0)
-                        return err;
+                snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_pci_data(emu->pci),
+                                              65536 - 64, 65536 - 64);
                 /*
                 dev_dbg(emu->card->dev,
                            "preallocate capture substream: err=%d\n", err);
diff --git a/sound/pci/ens1370.c b/sound/pci/ens1370.c
index 727eb3da1fda..1cfff35e370e 100644
--- a/sound/pci/ens1370.c
+++ b/sound/pci/ens1370.c
@@ -1902,10 +1902,8 @@ static void snd_ensoniq_proc_read(struct snd_info_entry *entry,
 
 static void snd_ensoniq_proc_init(struct ensoniq *ensoniq)
 {
-        struct snd_info_entry *entry;
-
-        if (! snd_card_proc_new(ensoniq->card, "audiopci", &entry))
-                snd_info_set_text_ops(entry, ensoniq, snd_ensoniq_proc_read);
+        snd_card_ro_proc_new(ensoniq->card, "audiopci", ensoniq,
+                             snd_ensoniq_proc_read);
 }
 
 /*
@@ -2037,9 +2035,6 @@ static int snd_ensoniq_suspend(struct device *dev)
         
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
 
-        snd_pcm_suspend_all(ensoniq->pcm1);
-        snd_pcm_suspend_all(ensoniq->pcm2);
-        
 #ifdef CHIP1371 
         snd_ac97_suspend(ensoniq->u.es1371.ac97);
 #else
diff --git a/sound/pci/es1938.c b/sound/pci/es1938.c
index 9d248eb2e26c..84d07bce581c 100644
--- a/sound/pci/es1938.c
+++ b/sound/pci/es1938.c
@@ -1475,7 +1475,6 @@ static int es1938_suspend(struct device *dev)
         unsigned char *s, *d;
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        snd_pcm_suspend_all(chip->pcm);
 
         /* save mixer-related registers */
         for (s = saved_regs, d = chip->saved_regs; *s; s++, d++)
diff --git a/sound/pci/es1968.c b/sound/pci/es1968.c
index 0b1845ca6005..9dcb698fc8c7 100644
--- a/sound/pci/es1968.c
+++ b/sound/pci/es1968.c
@@ -2392,7 +2392,6 @@ static int es1968_suspend(struct device *dev)
         chip->in_suspend = 1;
         cancel_work_sync(&chip->hwvol_work);
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        snd_pcm_suspend_all(chip->pcm);
         snd_ac97_suspend(chip->ac97);
         snd_es1968_bob_stop(chip);
         return 0;
diff --git a/sound/pci/fm801.c b/sound/pci/fm801.c
index e3fb9c61017c..1317f3183eb1 100644
--- a/sound/pci/fm801.c
+++ b/sound/pci/fm801.c
@@ -1408,7 +1408,6 @@ static int snd_fm801_suspend(struct device *dev)
         if (chip->tea575x_tuner & TUNER_ONLY) {
                 /* FIXME: tea575x suspend */
         } else {
-                snd_pcm_suspend_all(chip->pcm);
                 snd_ac97_suspend(chip->ac97);
                 snd_ac97_suspend(chip->ac97_sec);
         }
diff --git a/sound/pci/hda/hda_beep.c b/sound/pci/hda/hda_beep.c
index 066b5b59c4d7..b7d9160ed868 100644
--- a/sound/pci/hda/hda_beep.c
+++ b/sound/pci/hda/hda_beep.c
@@ -127,44 +127,6 @@ static void turn_off_beep(struct hda_beep *beep)
         }
 }
 
-static void snd_hda_do_detach(struct hda_beep *beep)
-{
-        if (beep->registered)
-                input_unregister_device(beep->dev);
-        else
-                input_free_device(beep->dev);
-        beep->dev = NULL;
-        turn_off_beep(beep);
-}
-
-static int snd_hda_do_attach(struct hda_beep *beep)
-{
-        struct input_dev *input_dev;
-        struct hda_codec *codec = beep->codec;
-
-        input_dev = input_allocate_device();
-        if (!input_dev)
-                return -ENOMEM;
-
-        /* setup digital beep device */
-        input_dev->name = "HDA Digital PCBeep";
-        input_dev->phys = beep->phys;
-        input_dev->id.bustype = BUS_PCI;
-        input_dev->dev.parent = &codec->card->card_dev;
-
-        input_dev->id.vendor = codec->core.vendor_id >> 16;
-        input_dev->id.product = codec->core.vendor_id & 0xffff;
-        input_dev->id.version = 0x01;
-
-        input_dev->evbit[0] = BIT_MASK(EV_SND);
-        input_dev->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE);
-        input_dev->event = snd_hda_beep_event;
-        input_set_drvdata(input_dev, beep);
-
-        beep->dev = input_dev;
-        return 0;
-}
-
 /**
  * snd_hda_enable_beep_device - Turn on/off beep sound
  * @codec: the HDA codec
@@ -186,6 +148,38 @@ int snd_hda_enable_beep_device(struct hda_codec *codec, int enable)
 }
 EXPORT_SYMBOL_GPL(snd_hda_enable_beep_device);
 
+static int beep_dev_register(struct snd_device *device)
+{
+        struct hda_beep *beep = device->device_data;
+        int err;
+
+        err = input_register_device(beep->dev);
+        if (!err)
+                beep->registered = true;
+        return err;
+}
+
+static int beep_dev_disconnect(struct snd_device *device)
+{
+        struct hda_beep *beep = device->device_data;
+
+        if (beep->registered)
+                input_unregister_device(beep->dev);
+        else
+                input_free_device(beep->dev);
+        turn_off_beep(beep);
+        return 0;
+}
+
+static int beep_dev_free(struct snd_device *device)
+{
+        struct hda_beep *beep = device->device_data;
+
+        beep->codec->beep = NULL;
+        kfree(beep);
+        return 0;
+}
+
 /**
  * snd_hda_attach_beep_device - Attach a beep input device
  * @codec: the HDA codec
@@ -194,14 +188,16 @@ EXPORT_SYMBOL_GPL(snd_hda_enable_beep_device);
  * Attach a beep object to the given widget.  If beep hint is turned off
  * explicitly or beep_mode of the codec is turned off, this doesn't nothing.
  *
- * The attached beep device has to be registered via
- * snd_hda_register_beep_device() and released via snd_hda_detach_beep_device()
- * appropriately.
- *
  * Currently, only one beep device is allowed to each codec.
  */
 int snd_hda_attach_beep_device(struct hda_codec *codec, int nid)
 {
+        static struct snd_device_ops ops = {
+                .dev_register = beep_dev_register,
+                .dev_disconnect = beep_dev_disconnect,
+                .dev_free = beep_dev_free,
+        };
+        struct input_dev *input_dev;
         struct hda_beep *beep;
         int err;
 
@@ -226,14 +222,41 @@ int snd_hda_attach_beep_device(struct hda_codec *codec, int nid)
         INIT_WORK(&beep->beep_work, &snd_hda_generate_beep);
         mutex_init(&beep->mutex);
 
-        err = snd_hda_do_attach(beep);
-        if (err < 0) {
-                kfree(beep);
-                codec->beep = NULL;
-                return err;
+        input_dev = input_allocate_device();
+        if (!input_dev) {
+                err = -ENOMEM;
+                goto err_free;
         }
 
+        /* setup digital beep device */
+        input_dev->name = "HDA Digital PCBeep";
+        input_dev->phys = beep->phys;
+        input_dev->id.bustype = BUS_PCI;
+        input_dev->dev.parent = &codec->card->card_dev;
+
+        input_dev->id.vendor = codec->core.vendor_id >> 16;
+        input_dev->id.product = codec->core.vendor_id & 0xffff;
+        input_dev->id.version = 0x01;
+
+        input_dev->evbit[0] = BIT_MASK(EV_SND);
+        input_dev->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE);
+        input_dev->event = snd_hda_beep_event;
+        input_set_drvdata(input_dev, beep);
+
+        beep->dev = input_dev;
+
+        err = snd_device_new(codec->card, SNDRV_DEV_JACK, beep, &ops);
+        if (err < 0)
+                goto err_input;
+
         return 0;
+
+ err_input:
+        input_free_device(beep->dev);
+ err_free:
+        kfree(beep);
+        codec->beep = NULL;
+        return err;
 }
 EXPORT_SYMBOL_GPL(snd_hda_attach_beep_device);
 
@@ -243,41 +266,11 @@ EXPORT_SYMBOL_GPL(snd_hda_attach_beep_device);
  */
 void snd_hda_detach_beep_device(struct hda_codec *codec)
 {
-        struct hda_beep *beep = codec->beep;
-        if (beep) {
-                if (beep->dev)
-                        snd_hda_do_detach(beep);
-                codec->beep = NULL;
-                kfree(beep);
-        }
+        if (!codec->bus->shutdown && codec->beep)
+                snd_device_free(codec->card, codec->beep);
 }
 EXPORT_SYMBOL_GPL(snd_hda_detach_beep_device);
 
-/**
- * snd_hda_register_beep_device - Register the beep device
- * @codec: the HDA codec
- */
-int snd_hda_register_beep_device(struct hda_codec *codec)
-{
-        struct hda_beep *beep = codec->beep;
-        int err;
-
-        if (!beep || !beep->dev)
-                return 0;
-
-        err = input_register_device(beep->dev);
-        if (err < 0) {
-                codec_err(codec, "hda_beep: unable to register input device\n");
-                input_free_device(beep->dev);
-                codec->beep = NULL;
-                kfree(beep);
-                return err;
-        }
-        beep->registered = true;
-        return 0;
-}
-EXPORT_SYMBOL_GPL(snd_hda_register_beep_device);
-
 static bool ctl_has_mute(struct snd_kcontrol *kcontrol)
 {
         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
diff --git a/sound/pci/hda/hda_beep.h b/sound/pci/hda/hda_beep.h
index f1457c6b3969..a25358a4807a 100644
--- a/sound/pci/hda/hda_beep.h
+++ b/sound/pci/hda/hda_beep.h
@@ -34,7 +34,6 @@ struct hda_beep {
 int snd_hda_enable_beep_device(struct hda_codec *codec, int enable);
 int snd_hda_attach_beep_device(struct hda_codec *codec, int nid);
 void snd_hda_detach_beep_device(struct hda_codec *codec);
-int snd_hda_register_beep_device(struct hda_codec *codec);
 #else
 static inline int snd_hda_attach_beep_device(struct hda_codec *codec, int nid)
 {
@@ -43,9 +42,5 @@ static inline int snd_hda_attach_beep_device(struct hda_codec *codec, int nid)
 static inline void snd_hda_detach_beep_device(struct hda_codec *codec)
 {
 }
-static inline int snd_hda_register_beep_device(struct hda_codec *codec)
-{
-        return 0;
-}
 #endif
 #endif
diff --git a/sound/pci/hda/hda_codec.c b/sound/pci/hda/hda_codec.c
index 9f8d59e7e89f..5f2005098a60 100644
--- a/sound/pci/hda/hda_codec.c
+++ b/sound/pci/hda/hda_codec.c
@@ -813,7 +813,6 @@ void snd_hda_codec_register(struct hda_codec *codec)
         if (codec->registered)
                 return;
         if (device_is_registered(hda_codec_dev(codec))) {
-                snd_hda_register_beep_device(codec);
                 codec_display_power(codec, true);
                 pm_runtime_enable(hda_codec_dev(codec));
                 /* it was powered up in snd_hda_codec_new(), now all done */
@@ -828,14 +827,6 @@ static int snd_hda_codec_dev_register(struct snd_device *device)
         return 0;
 }
 
-static int snd_hda_codec_dev_disconnect(struct snd_device *device)
-{
-        struct hda_codec *codec = device->device_data;
-
-        snd_hda_detach_beep_device(codec);
-        return 0;
-}
-
 static int snd_hda_codec_dev_free(struct snd_device *device)
 {
         struct hda_codec *codec = device->device_data;
@@ -921,7 +912,6 @@ int snd_hda_codec_device_new(struct hda_bus *bus, struct snd_card *card,
         int err;
         static struct snd_device_ops dev_ops = {
                 .dev_register = snd_hda_codec_dev_register,
-                .dev_disconnect = snd_hda_codec_dev_disconnect,
                 .dev_free = snd_hda_codec_dev_free,
         };
 
@@ -2917,18 +2907,16 @@ static void hda_call_codec_resume(struct hda_codec *codec)
                 hda_jackpoll_work(&codec->jackpoll_work.work);
         else
                 snd_hda_jack_report_sync(codec);
+        codec->core.dev.power.power_state = PMSG_ON;
         snd_hdac_leave_pm(&codec->core);
 }
 
 static int hda_codec_runtime_suspend(struct device *dev)
 {
         struct hda_codec *codec = dev_to_hda_codec(dev);
-        struct hda_pcm *pcm;
         unsigned int state;
 
         cancel_delayed_work_sync(&codec->jackpoll_work);
-        list_for_each_entry(pcm, &codec->pcm_list_head, list)
-                snd_pcm_suspend_all(pcm->pcm);
         state = hda_call_codec_suspend(codec);
         if (codec->link_down_at_suspend ||
             (codec_has_clkstop(codec) && codec_has_epss(codec) &&
@@ -2950,10 +2938,48 @@ static int hda_codec_runtime_resume(struct device *dev)
 }
 #endif /* CONFIG_PM */
 
+#ifdef CONFIG_PM_SLEEP
+static int hda_codec_pm_suspend(struct device *dev)
+{
+        dev->power.power_state = PMSG_SUSPEND;
+        return pm_runtime_force_suspend(dev);
+}
+
+static int hda_codec_pm_resume(struct device *dev)
+{
+        dev->power.power_state = PMSG_RESUME;
+        return pm_runtime_force_resume(dev);
+}
+
+static int hda_codec_pm_freeze(struct device *dev)
+{
+        dev->power.power_state = PMSG_FREEZE;
+        return pm_runtime_force_suspend(dev);
+}
+
+static int hda_codec_pm_thaw(struct device *dev)
+{
+        dev->power.power_state = PMSG_THAW;
+        return pm_runtime_force_resume(dev);
+}
+
+static int hda_codec_pm_restore(struct device *dev)
+{
+        dev->power.power_state = PMSG_RESTORE;
+        return pm_runtime_force_resume(dev);
+}
+#endif /* CONFIG_PM_SLEEP */
+
 /* referred in hda_bind.c */
 const struct dev_pm_ops hda_codec_driver_pm = {
-        SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
-                                pm_runtime_force_resume)
+#ifdef CONFIG_PM_SLEEP
+        .suspend = hda_codec_pm_suspend,
+        .resume = hda_codec_pm_resume,
+        .freeze = hda_codec_pm_freeze,
+        .thaw = hda_codec_pm_thaw,
+        .poweroff = hda_codec_pm_suspend,
+        .restore = hda_codec_pm_restore,
+#endif /* CONFIG_PM_SLEEP */
         SET_RUNTIME_PM_OPS(hda_codec_runtime_suspend, hda_codec_runtime_resume,
                            NULL)
 };
diff --git a/sound/pci/hda/hda_proc.c b/sound/pci/hda/hda_proc.c
index a65740419650..853842987fa1 100644
--- a/sound/pci/hda/hda_proc.c
+++ b/sound/pci/hda/hda_proc.c
@@ -919,15 +919,8 @@ static void print_codec_info(struct snd_info_entry *entry,
 int snd_hda_codec_proc_new(struct hda_codec *codec)
 {
         char name[32];
-        struct snd_info_entry *entry;
-        int err;
 
         snprintf(name, sizeof(name), "codec#%d", codec->core.addr);
-        err = snd_card_proc_new(codec->card, name, &entry);
-        if (err < 0)
-                return err;
-
-        snd_info_set_text_ops(entry, codec, print_codec_info);
-        return 0;
+        return snd_card_ro_proc_new(codec->card, name, codec, print_codec_info);
 }
 
diff --git a/sound/pci/hda/hda_tegra.c b/sound/pci/hda/hda_tegra.c
index 97a176d817a0..3d68f9ef7694 100644
--- a/sound/pci/hda/hda_tegra.c
+++ b/sound/pci/hda/hda_tegra.c
@@ -32,6 +32,7 @@
 #include <linux/slab.h>
 #include <linux/time.h>
 #include <linux/string.h>
+#include <linux/pm_runtime.h>
 
 #include <sound/core.h>
 #include <sound/initval.h>
@@ -218,7 +219,6 @@ disable_hda:
         return rc;
 }
 
-#ifdef CONFIG_PM_SLEEP
 static void hda_tegra_disable_clocks(struct hda_tegra *data)
 {
         clk_disable_unprepare(data->hda2hdmi_clk);
@@ -229,43 +229,72 @@ static void hda_tegra_disable_clocks(struct hda_tegra *data)
 /*
  * power management
  */
-static int hda_tegra_suspend(struct device *dev)
+static int __maybe_unused hda_tegra_suspend(struct device *dev)
 {
         struct snd_card *card = dev_get_drvdata(dev);
-        struct azx *chip = card->private_data;
-        struct hda_tegra *hda = container_of(chip, struct hda_tegra, chip);
-        struct hdac_bus *bus = azx_bus(chip);
+        int rc;
 
+        rc = pm_runtime_force_suspend(dev);
+        if (rc < 0)
+                return rc;
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
 
-        azx_stop_chip(chip);
-        synchronize_irq(bus->irq);
-        azx_enter_link_reset(chip);
-        hda_tegra_disable_clocks(hda);
+        return 0;
+}
+
+static int __maybe_unused hda_tegra_resume(struct device *dev)
+{
+        struct snd_card *card = dev_get_drvdata(dev);
+        int rc;
+
+        rc = pm_runtime_force_resume(dev);
+        if (rc < 0)
+                return rc;
+        snd_power_change_state(card, SNDRV_CTL_POWER_D0);
 
         return 0;
 }
 
-static int hda_tegra_resume(struct device *dev)
+static int __maybe_unused hda_tegra_runtime_suspend(struct device *dev)
 {
         struct snd_card *card = dev_get_drvdata(dev);
         struct azx *chip = card->private_data;
         struct hda_tegra *hda = container_of(chip, struct hda_tegra, chip);
+        struct hdac_bus *bus = azx_bus(chip);
 
-        hda_tegra_enable_clocks(hda);
+        if (chip && chip->running) {
+                azx_stop_chip(chip);
+                synchronize_irq(bus->irq);
+                azx_enter_link_reset(chip);
+        }
+        hda_tegra_disable_clocks(hda);
 
-        hda_tegra_init(hda);
+        return 0;
+}
 
-        azx_init_chip(chip, 1);
+static int __maybe_unused hda_tegra_runtime_resume(struct device *dev)
+{
+        struct snd_card *card = dev_get_drvdata(dev);
+        struct azx *chip = card->private_data;
+        struct hda_tegra *hda = container_of(chip, struct hda_tegra, chip);
+        int rc;
 
-        snd_power_change_state(card, SNDRV_CTL_POWER_D0);
+        rc = hda_tegra_enable_clocks(hda);
+        if (rc != 0)
+                return rc;
+        if (chip && chip->running) {
+                hda_tegra_init(hda);
+                azx_init_chip(chip, 1);
+        }
 
         return 0;
 }
-#endif /* CONFIG_PM_SLEEP */
 
 static const struct dev_pm_ops hda_tegra_pm = {
         SET_SYSTEM_SLEEP_PM_OPS(hda_tegra_suspend, hda_tegra_resume)
+        SET_RUNTIME_PM_OPS(hda_tegra_runtime_suspend,
+                           hda_tegra_runtime_resume,
+                           NULL)
 };
 
 static int hda_tegra_dev_disconnect(struct snd_device *device)
@@ -303,7 +332,23 @@ static int hda_tegra_init_chip(struct azx *chip, struct platform_device *pdev)
         struct hdac_bus *bus = azx_bus(chip);
         struct device *dev = hda->dev;
         struct resource *res;
-        int err;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        hda->regs = devm_ioremap_resource(dev, res);
+        if (IS_ERR(hda->regs))
+                return PTR_ERR(hda->regs);
+
+        bus->remap_addr = hda->regs + HDA_BAR0;
+        bus->addr = res->start + HDA_BAR0;
+
+        hda_tegra_init(hda);
+
+        return 0;
+}
+
+static int hda_tegra_init_clk(struct hda_tegra *hda)
+{
+        struct device *dev = hda->dev;
 
         hda->hda_clk = devm_clk_get(dev, "hda");
         if (IS_ERR(hda->hda_clk)) {
@@ -321,22 +366,6 @@ static int hda_tegra_init_chip(struct azx *chip, struct platform_device *pdev)
                 return PTR_ERR(hda->hda2hdmi_clk);
         }
 
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        hda->regs = devm_ioremap_resource(dev, res);
-        if (IS_ERR(hda->regs))
-                return PTR_ERR(hda->regs);
-
-        bus->remap_addr = hda->regs + HDA_BAR0;
-        bus->addr = res->start + HDA_BAR0;
-
-        err = hda_tegra_enable_clocks(hda);
-        if (err) {
-                dev_err(dev, "failed to get enable clocks\n");
-                return err;
-        }
-
-        hda_tegra_init(hda);
-
         return 0;
 }
 
@@ -347,8 +376,8 @@ static int hda_tegra_first_init(struct azx *chip, struct platform_device *pdev)
         int err;
         unsigned short gcap;
         int irq_id = platform_get_irq(pdev, 0);
-        const char *sname;
-        struct device_node *root;
+        const char *sname, *drv_name = "tegra-hda";
+        struct device_node *np = pdev->dev.of_node;
 
         err = hda_tegra_init_chip(chip, pdev);
         if (err)
@@ -407,17 +436,11 @@ static int hda_tegra_first_init(struct azx *chip, struct platform_device *pdev)
         }
 
         /* driver name */
-        strcpy(card->driver, "tegra-hda");
-
-        root = of_find_node_by_path("/");
-        sname = of_get_property(root, "compatible", NULL);
-        of_node_put(root);
-        if (!sname) {
-                dev_err(card->dev,
-                        "failed to get compatible property from root node\n");
-                return -ENODEV;
-        }
+        strncpy(card->driver, drv_name, sizeof(card->driver));
         /* shortname for card */
+        sname = of_get_property(np, "nvidia,model", NULL);
+        if (!sname)
+                sname = drv_name;
         if (strlen(sname) > sizeof(card->shortname))
                 dev_info(card->dev, "truncating shortname for card\n");
         strncpy(card->shortname, sname, sizeof(card->shortname));
@@ -487,7 +510,8 @@ MODULE_DEVICE_TABLE(of, hda_tegra_match);
 
 static int hda_tegra_probe(struct platform_device *pdev)
 {
-        const unsigned int driver_flags = AZX_DCAPS_CORBRP_SELF_CLEAR;
+        const unsigned int driver_flags = AZX_DCAPS_CORBRP_SELF_CLEAR |
+                                          AZX_DCAPS_PM_RUNTIME;
         struct snd_card *card;
         struct azx *chip;
         struct hda_tegra *hda;
@@ -506,12 +530,21 @@ static int hda_tegra_probe(struct platform_device *pdev)
                 return err;
         }
 
+        err = hda_tegra_init_clk(hda);
+        if (err < 0)
+                goto out_free;
+
         err = hda_tegra_create(card, driver_flags, hda);
         if (err < 0)
                 goto out_free;
         card->private_data = chip;
 
         dev_set_drvdata(&pdev->dev, card);
+
+        pm_runtime_enable(hda->dev);
+        if (!azx_has_pm_runtime(chip))
+                pm_runtime_forbid(hda->dev);
+
         schedule_work(&hda->probe_work);
 
         return 0;
@@ -528,6 +561,7 @@ static void hda_tegra_probe_work(struct work_struct *work)
         struct platform_device *pdev = to_platform_device(hda->dev);
         int err;
 
+        pm_runtime_get_sync(hda->dev);
         err = hda_tegra_first_init(chip, pdev);
         if (err < 0)
                 goto out_free;
@@ -549,12 +583,18 @@ static void hda_tegra_probe_work(struct work_struct *work)
         snd_hda_set_power_save(&chip->bus, power_save * 1000);
 
  out_free:
+        pm_runtime_put(hda->dev);
         return; /* no error return from async probe */
 }
 
 static int hda_tegra_remove(struct platform_device *pdev)
 {
-        return snd_card_free(dev_get_drvdata(&pdev->dev));
+        int ret;
+
+        ret = snd_card_free(dev_get_drvdata(&pdev->dev));
+        pm_runtime_disable(&pdev->dev);
+
+        return ret;
 }
 
 static void hda_tegra_shutdown(struct platform_device *pdev)
diff --git a/sound/pci/hda/patch_conexant.c b/sound/pci/hda/patch_conexant.c
index a4ee7656d9ee..fb65ad31e86c 100644
--- a/sound/pci/hda/patch_conexant.c
+++ b/sound/pci/hda/patch_conexant.c
@@ -936,6 +936,9 @@ static const struct snd_pci_quirk cxt5066_fixups[] = {
         SND_PCI_QUIRK(0x103c, 0x8299, "HP 800 G3 SFF", CXT_FIXUP_HP_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x103c, 0x829a, "HP 800 G3 DM", CXT_FIXUP_HP_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x103c, 0x8455, "HP Z2 G4", CXT_FIXUP_HP_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x103c, 0x8456, "HP Z2 G4 SFF", CXT_FIXUP_HP_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x103c, 0x8457, "HP Z2 G4 mini", CXT_FIXUP_HP_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x103c, 0x8458, "HP Z2 G4 mini premium", CXT_FIXUP_HP_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1043, 0x138d, "Asus", CXT_FIXUP_HEADPHONE_MIC_PIN),
         SND_PCI_QUIRK(0x152d, 0x0833, "OLPC XO-1.5", CXT_FIXUP_OLPC_XO),
         SND_PCI_QUIRK(0x17aa, 0x20f2, "Lenovo T400", CXT_PINCFG_LENOVO_TP410),
diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c
index 46f88dc7b7e8..8b3ac690efa3 100644
--- a/sound/pci/hda/patch_hdmi.c
+++ b/sound/pci/hda/patch_hdmi.c
@@ -57,10 +57,11 @@ MODULE_PARM_DESC(static_hdmi_pcm, "Don't restrict PCM parameters per ELD info");
 #define is_geminilake(codec) (((codec)->core.vendor_id == 0x8086280d) || \
                                 ((codec)->core.vendor_id == 0x80862800))
 #define is_cannonlake(codec) ((codec)->core.vendor_id == 0x8086280c)
+#define is_icelake(codec) ((codec)->core.vendor_id == 0x8086280f)
 #define is_haswell_plus(codec) (is_haswell(codec) || is_broadwell(codec) \
                                 || is_skylake(codec) || is_broxton(codec) \
-                                || is_kabylake(codec)) || is_geminilake(codec) \
-                                || is_cannonlake(codec)
+                                || is_kabylake(codec) || is_geminilake(codec) \
+                                || is_cannonlake(codec) || is_icelake(codec))
 #define is_valleyview(codec) ((codec)->core.vendor_id == 0x80862882)
 #define is_cherryview(codec) ((codec)->core.vendor_id == 0x80862883)
 #define is_valleyview_plus(codec) (is_valleyview(codec) || is_cherryview(codec))
@@ -181,6 +182,8 @@ struct hdmi_spec {
 
         struct hdac_chmap chmap;
         hda_nid_t vendor_nid;
+        const int *port_map;
+        int port_num;
 };
 
 #ifdef CONFIG_SND_HDA_COMPONENT
@@ -1865,7 +1868,7 @@ static int generic_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
         hda_nid_t pin_nid;
         struct snd_pcm_runtime *runtime = substream->runtime;
         bool non_pcm;
-        int pinctl;
+        int pinctl, stripe;
         int err = 0;
 
         mutex_lock(&spec->pcm_lock);
@@ -1909,6 +1912,14 @@ static int generic_hdmi_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
         per_pin->channels = substream->runtime->channels;
         per_pin->setup = true;
 
+        if (get_wcaps(codec, cvt_nid) & AC_WCAP_STRIPE) {
+                stripe = snd_hdac_get_stream_stripe_ctl(&codec->bus->core,
+                                                        substream);
+                snd_hda_codec_write(codec, cvt_nid, 0,
+                                    AC_VERB_SET_STRIPE_CONTROL,
+                                    stripe);
+        }
+
         hdmi_setup_audio_infoframe(codec, per_pin, non_pcm);
         mutex_unlock(&per_pin->lock);
         if (spec->dyn_pin_out) {
@@ -2410,12 +2421,11 @@ static void intel_haswell_fixup_connect_list(struct hda_codec *codec,
         snd_hda_override_conn_list(codec, nid, spec->num_cvts, spec->cvt_nids);
 }
 
-#define INTEL_VENDOR_NID 0x08
-#define INTEL_GLK_VENDOR_NID 0x0B
-#define INTEL_GET_VENDOR_VERB 0xf81
-#define INTEL_SET_VENDOR_VERB 0x781
-#define INTEL_EN_DP12                   0x02 /* enable DP 1.2 features */
-#define INTEL_EN_ALL_PIN_CVTS   0x01 /* enable 2nd & 3rd pins and convertors */
+#define INTEL_GET_VENDOR_VERB   0xf81
+#define INTEL_GET_VENDOR_VERB   0xf81
+#define INTEL_SET_VENDOR_VERB   0x781
+#define INTEL_EN_DP12           0x02    /* enable DP 1.2 features */
+#define INTEL_EN_ALL_PIN_CVTS   0x01    /* enable 2nd & 3rd pins and convertors */
 
 static void intel_haswell_enable_all_pins(struct hda_codec *codec,
                                           bool update_tree)
@@ -2495,11 +2505,29 @@ static int intel_base_nid(struct hda_codec *codec)
 
 static int intel_pin2port(void *audio_ptr, int pin_nid)
 {
-        int base_nid = intel_base_nid(audio_ptr);
+        struct hda_codec *codec = audio_ptr;
+        struct hdmi_spec *spec = codec->spec;
+        int base_nid, i;
 
-        if (WARN_ON(pin_nid < base_nid || pin_nid >= base_nid + 3))
-                return -1;
-        return pin_nid - base_nid + 1; /* intel port is 1-based */
+        if (!spec->port_num) {
+                base_nid = intel_base_nid(codec);
+                if (WARN_ON(pin_nid < base_nid || pin_nid >= base_nid + 3))
+                        return -1;
+                return pin_nid - base_nid + 1; /* intel port is 1-based */
+        }
+
+        /*
+         * looking for the pin number in the mapping table and return
+         * the index which indicate the port number
+         */
+        for (i = 0; i < spec->port_num; i++) {
+                if (pin_nid == spec->port_map[i])
+                        return i + 1;
+        }
+
+        /* return -1 if pin number exceeds our expectation */
+        codec_info(codec, "Can't find the HDMI/DP port for pin %d\n", pin_nid);
+        return -1;
 }
 
 static void intel_pin_eld_notify(void *audio_ptr, int port, int pipe)
@@ -2600,7 +2628,8 @@ static int parse_intel_hdmi(struct hda_codec *codec)
 }
 
 /* Intel Haswell and onwards; audio component with eld notifier */
-static int intel_hsw_common_init(struct hda_codec *codec, hda_nid_t vendor_nid)
+static int intel_hsw_common_init(struct hda_codec *codec, hda_nid_t vendor_nid,
+                                 const int *port_map, int port_num)
 {
         struct hdmi_spec *spec;
         int err;
@@ -2612,6 +2641,8 @@ static int intel_hsw_common_init(struct hda_codec *codec, hda_nid_t vendor_nid)
         codec->dp_mst = true;
         spec->dyn_pcm_assign = true;
         spec->vendor_nid = vendor_nid;
+        spec->port_map = port_map;
+        spec->port_num = port_num;
 
         intel_haswell_enable_all_pins(codec, true);
         intel_haswell_fixup_enable_dp12(codec);
@@ -2630,12 +2661,23 @@ static int intel_hsw_common_init(struct hda_codec *codec, hda_nid_t vendor_nid)
 
 static int patch_i915_hsw_hdmi(struct hda_codec *codec)
 {
-        return intel_hsw_common_init(codec, INTEL_VENDOR_NID);
+        return intel_hsw_common_init(codec, 0x08, NULL, 0);
 }
 
 static int patch_i915_glk_hdmi(struct hda_codec *codec)
 {
-        return intel_hsw_common_init(codec, INTEL_GLK_VENDOR_NID);
+        return intel_hsw_common_init(codec, 0x0b, NULL, 0);
+}
+
+static int patch_i915_icl_hdmi(struct hda_codec *codec)
+{
+        /*
+         * pin to port mapping table where the value indicate the pin number and
+         * the index indicate the port number with 1 base.
+         */
+        static const int map[] = {0x4, 0x6, 0x8, 0xa, 0xb};
+
+        return intel_hsw_common_init(codec, 0x02, map, ARRAY_SIZE(map));
 }
 
 /* Intel Baytrail and Braswell; with eld notifier */
@@ -3878,6 +3920,7 @@ HDA_CODEC_ENTRY(0x11069f81, "VX900 HDMI/DP",	patch_via_hdmi),
 HDA_CODEC_ENTRY(0x11069f84, "VX11 HDMI/DP",     patch_generic_hdmi),
 HDA_CODEC_ENTRY(0x11069f85, "VX11 HDMI/DP",     patch_generic_hdmi),
 HDA_CODEC_ENTRY(0x80860054, "IbexPeak HDMI",    patch_i915_cpt_hdmi),
+HDA_CODEC_ENTRY(0x80862800, "Geminilake HDMI",  patch_i915_glk_hdmi),
 HDA_CODEC_ENTRY(0x80862801, "Bearlake HDMI",    patch_generic_hdmi),
 HDA_CODEC_ENTRY(0x80862802, "Cantiga HDMI",     patch_generic_hdmi),
 HDA_CODEC_ENTRY(0x80862803, "Eaglelake HDMI",   patch_generic_hdmi),
@@ -3891,7 +3934,7 @@ HDA_CODEC_ENTRY(0x8086280a, "Broxton HDMI",	patch_i915_hsw_hdmi),
 HDA_CODEC_ENTRY(0x8086280b, "Kabylake HDMI",    patch_i915_hsw_hdmi),
 HDA_CODEC_ENTRY(0x8086280c, "Cannonlake HDMI",  patch_i915_glk_hdmi),
 HDA_CODEC_ENTRY(0x8086280d, "Geminilake HDMI",  patch_i915_glk_hdmi),
-HDA_CODEC_ENTRY(0x80862800, "Geminilake HDMI",  patch_i915_glk_hdmi),
+HDA_CODEC_ENTRY(0x8086280f, "Icelake HDMI",     patch_i915_icl_hdmi),
 HDA_CODEC_ENTRY(0x80862880, "CedarTrail HDMI",  patch_generic_hdmi),
 HDA_CODEC_ENTRY(0x80862882, "Valleyview2 HDMI", patch_i915_byt_hdmi),
 HDA_CODEC_ENTRY(0x80862883, "Braswell HDMI",    patch_i915_byt_hdmi),
diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c
index 1ffa36e987b4..384719d5c44e 100644
--- a/sound/pci/hda/patch_realtek.c
+++ b/sound/pci/hda/patch_realtek.c
@@ -118,6 +118,7 @@ struct alc_spec {
         unsigned int has_alc5505_dsp:1;
         unsigned int no_depop_delay:1;
         unsigned int done_hp_init:1;
+        unsigned int no_shutup_pins:1;
 
         /* for PLL fix */
         hda_nid_t pll_nid;
@@ -476,6 +477,14 @@ static void alc_auto_setup_eapd(struct hda_codec *codec, bool on)
                 set_eapd(codec, *p, on);
 }
 
+static void alc_shutup_pins(struct hda_codec *codec)
+{
+        struct alc_spec *spec = codec->spec;
+
+        if (!spec->no_shutup_pins)
+                snd_hda_shutup_pins(codec);
+}
+
 /* generic shutup callback;
  * just turning off EAPD and a little pause for avoiding pop-noise
  */
@@ -486,7 +495,7 @@ static void alc_eapd_shutup(struct hda_codec *codec)
         alc_auto_setup_eapd(codec, false);
         if (!spec->no_depop_delay)
                 msleep(200);
-        snd_hda_shutup_pins(codec);
+        alc_shutup_pins(codec);
 }
 
 /* generic EAPD initialization */
@@ -814,7 +823,7 @@ static inline void alc_shutup(struct hda_codec *codec)
         if (spec && spec->shutup)
                 spec->shutup(codec);
         else
-                snd_hda_shutup_pins(codec);
+                alc_shutup_pins(codec);
 }
 
 static void alc_reboot_notify(struct hda_codec *codec)
@@ -2950,7 +2959,7 @@ static void alc269_shutup(struct hda_codec *codec)
                         (alc_get_coef0(codec) & 0x00ff) == 0x018) {
                 msleep(150);
         }
-        snd_hda_shutup_pins(codec);
+        alc_shutup_pins(codec);
 }
 
 static struct coef_fw alc282_coefs[] = {
@@ -3053,14 +3062,15 @@ static void alc282_shutup(struct hda_codec *codec)
         if (hp_pin_sense)
                 msleep(85);
 
-        snd_hda_codec_write(codec, hp_pin, 0,
-                            AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
+        if (!spec->no_shutup_pins)
+                snd_hda_codec_write(codec, hp_pin, 0,
+                                    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
 
         if (hp_pin_sense)
                 msleep(100);
 
         alc_auto_setup_eapd(codec, false);
-        snd_hda_shutup_pins(codec);
+        alc_shutup_pins(codec);
         alc_write_coef_idx(codec, 0x78, coef78);
 }
 
@@ -3166,15 +3176,16 @@ static void alc283_shutup(struct hda_codec *codec)
         if (hp_pin_sense)
                 msleep(100);
 
-        snd_hda_codec_write(codec, hp_pin, 0,
-                            AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
+        if (!spec->no_shutup_pins)
+                snd_hda_codec_write(codec, hp_pin, 0,
+                                    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
 
         alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
 
         if (hp_pin_sense)
                 msleep(100);
         alc_auto_setup_eapd(codec, false);
-        snd_hda_shutup_pins(codec);
+        alc_shutup_pins(codec);
         alc_write_coef_idx(codec, 0x43, 0x9614);
 }
 
@@ -3240,14 +3251,15 @@ static void alc256_shutup(struct hda_codec *codec)
         /* NOTE: call this before clearing the pin, otherwise codec stalls */
         alc_update_coef_idx(codec, 0x46, 0, 3 << 12);
 
-        snd_hda_codec_write(codec, hp_pin, 0,
-                            AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
+        if (!spec->no_shutup_pins)
+                snd_hda_codec_write(codec, hp_pin, 0,
+                                    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
 
         if (hp_pin_sense)
                 msleep(100);
 
         alc_auto_setup_eapd(codec, false);
-        snd_hda_shutup_pins(codec);
+        alc_shutup_pins(codec);
 }
 
 static void alc225_init(struct hda_codec *codec)
@@ -3334,7 +3346,7 @@ static void alc225_shutup(struct hda_codec *codec)
                 msleep(100);
 
         alc_auto_setup_eapd(codec, false);
-        snd_hda_shutup_pins(codec);
+        alc_shutup_pins(codec);
 }
 
 static void alc_default_init(struct hda_codec *codec)
@@ -3388,14 +3400,15 @@ static void alc_default_shutup(struct hda_codec *codec)
         if (hp_pin_sense)
                 msleep(85);
 
-        snd_hda_codec_write(codec, hp_pin, 0,
-                            AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
+        if (!spec->no_shutup_pins)
+                snd_hda_codec_write(codec, hp_pin, 0,
+                                    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
 
         if (hp_pin_sense)
                 msleep(100);
 
         alc_auto_setup_eapd(codec, false);
-        snd_hda_shutup_pins(codec);
+        alc_shutup_pins(codec);
 }
 
 static void alc294_hp_init(struct hda_codec *codec)
@@ -3412,8 +3425,9 @@ static void alc294_hp_init(struct hda_codec *codec)
 
         msleep(100);
 
-        snd_hda_codec_write(codec, hp_pin, 0,
-                            AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
+        if (!spec->no_shutup_pins)
+                snd_hda_codec_write(codec, hp_pin, 0,
+                                    AC_VERB_SET_PIN_WIDGET_CONTROL, 0x0);
 
         alc_update_coef_idx(codec, 0x6f, 0x000f, 0);/* Set HP depop to manual mode */
         alc_update_coefex_idx(codec, 0x58, 0x00, 0x8000, 0x8000); /* HP depop procedure start */
@@ -3433,7 +3447,9 @@ static void alc294_init(struct hda_codec *codec)
 {
         struct alc_spec *spec = codec->spec;
 
-        if (!spec->done_hp_init) {
+        /* required only at boot or S4 resume time */
+        if (!spec->done_hp_init ||
+            codec->core.dev.power.power_state.event == PM_EVENT_RESTORE) {
                 alc294_hp_init(codec);
                 spec->done_hp_init = true;
         }
@@ -5007,16 +5023,12 @@ static void alc_fixup_auto_mute_via_amp(struct hda_codec *codec,
         }
 }
 
-static void alc_no_shutup(struct hda_codec *codec)
-{
-}
-
 static void alc_fixup_no_shutup(struct hda_codec *codec,
                                 const struct hda_fixup *fix, int action)
 {
         if (action == HDA_FIXUP_ACT_PRE_PROBE) {
                 struct alc_spec *spec = codec->spec;
-                spec->shutup = alc_no_shutup;
+                spec->no_shutup_pins = 1;
         }
 }
 
@@ -5479,7 +5491,7 @@ static void alc_headset_btn_callback(struct hda_codec *codec,
         jack->jack->button_state = report;
 }
 
-static void alc_fixup_headset_jack(struct hda_codec *codec,
+static void alc295_fixup_chromebook(struct hda_codec *codec,
                                     const struct hda_fixup *fix, int action)
 {
 
@@ -5489,6 +5501,16 @@ static void alc_fixup_headset_jack(struct hda_codec *codec,
                                                     alc_headset_btn_callback);
                 snd_hda_jack_add_kctl(codec, 0x55, "Headset Jack", false,
                                       SND_JACK_HEADSET, alc_headset_btn_keymap);
+                switch (codec->core.vendor_id) {
+                case 0x10ec0295:
+                        alc_update_coef_idx(codec, 0x4a, 0x8000, 1 << 15); /* Reset HP JD */
+                        alc_update_coef_idx(codec, 0x4a, 0x8000, 0 << 15);
+                        break;
+                case 0x10ec0236:
+                        alc_update_coef_idx(codec, 0x1b, 0x8000, 1 << 15); /* Reset HP JD */
+                        alc_update_coef_idx(codec, 0x1b, 0x8000, 0 << 15);
+                        break;
+                }
                 break;
         case HDA_FIXUP_ACT_INIT:
                 switch (codec->core.vendor_id) {
@@ -5658,9 +5680,13 @@ enum {
         ALC294_FIXUP_ASUS_MIC,
         ALC294_FIXUP_ASUS_HEADSET_MIC,
         ALC294_FIXUP_ASUS_SPK,
-        ALC225_FIXUP_HEADSET_JACK,
         ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
         ALC285_FIXUP_LENOVO_PC_BEEP_IN_NOISE,
+        ALC255_FIXUP_ACER_HEADSET_MIC,
+        ALC295_FIXUP_CHROME_BOOK,
+        ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE,
+        ALC225_FIXUP_WYSE_AUTO_MUTE,
+        ALC225_FIXUP_WYSE_DISABLE_MIC_VREF,
 };
 
 static const struct hda_fixup alc269_fixups[] = {
@@ -6603,9 +6629,9 @@ static const struct hda_fixup alc269_fixups[] = {
                 .chained = true,
                 .chain_id = ALC294_FIXUP_ASUS_HEADSET_MIC
         },
-        [ALC225_FIXUP_HEADSET_JACK] = {
+        [ALC295_FIXUP_CHROME_BOOK] = {
                 .type = HDA_FIXUP_FUNC,
-                .v.func = alc_fixup_headset_jack,
+                .v.func = alc295_fixup_chromebook,
         },
         [ALC293_FIXUP_SYSTEM76_MIC_NO_PRESENCE] = {
                 .type = HDA_FIXUP_PINS,
@@ -6627,6 +6653,38 @@ static const struct hda_fixup alc269_fixups[] = {
                 .chained = true,
                 .chain_id = ALC285_FIXUP_LENOVO_HEADPHONE_NOISE
         },
+        [ALC255_FIXUP_ACER_HEADSET_MIC] = {
+                .type = HDA_FIXUP_PINS,
+                .v.pins = (const struct hda_pintbl[]) {
+                        { 0x19, 0x03a11130 },
+                        { 0x1a, 0x90a60140 }, /* use as internal mic */
+                        { }
+                },
+                .chained = true,
+                .chain_id = ALC255_FIXUP_HEADSET_MODE_NO_HP_MIC
+        },
+        [ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE] = {
+                .type = HDA_FIXUP_PINS,
+                .v.pins = (const struct hda_pintbl[]) {
+                        { 0x16, 0x01011020 }, /* Rear Line out */
+                        { 0x19, 0x01a1913c }, /* use as Front headset mic, without its own jack detect */
+                        { }
+                },
+                .chained = true,
+                .chain_id = ALC225_FIXUP_WYSE_AUTO_MUTE
+        },
+        [ALC225_FIXUP_WYSE_AUTO_MUTE] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = alc_fixup_auto_mute_via_amp,
+                .chained = true,
+                .chain_id = ALC225_FIXUP_WYSE_DISABLE_MIC_VREF
+        },
+        [ALC225_FIXUP_WYSE_DISABLE_MIC_VREF] = {
+                .type = HDA_FIXUP_FUNC,
+                .v.func = alc_fixup_disable_mic_vref,
+                .chained = true,
+                .chain_id = ALC269_FIXUP_HEADSET_MODE_NO_HP_MIC
+        },
 };
 
 static const struct snd_pci_quirk alc269_fixup_tbl[] = {
@@ -6646,6 +6704,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = {
         SND_PCI_QUIRK(0x1025, 0x128f, "Acer Veriton Z6860G", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1025, 0x1290, "Acer Veriton Z4860G", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1025, 0x1291, "Acer Veriton Z4660G", ALC286_FIXUP_ACER_AIO_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x1025, 0x1330, "Acer TravelMate X514-51T", ALC255_FIXUP_ACER_HEADSET_MIC),
         SND_PCI_QUIRK(0x1028, 0x0470, "Dell M101z", ALC269_FIXUP_DELL_M101Z),
         SND_PCI_QUIRK(0x1028, 0x054b, "Dell XPS one 2710", ALC275_FIXUP_DELL_XPS),
         SND_PCI_QUIRK(0x1028, 0x05bd, "Dell Latitude E6440", ALC292_FIXUP_DELL_E7X),
@@ -6677,6 +6736,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = {
         SND_PCI_QUIRK(0x1028, 0x0704, "Dell XPS 13 9350", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE),
         SND_PCI_QUIRK(0x1028, 0x0706, "Dell Inspiron 7559", ALC256_FIXUP_DELL_INSPIRON_7559_SUBWOOFER),
         SND_PCI_QUIRK(0x1028, 0x0725, "Dell Inspiron 3162", ALC255_FIXUP_DELL_SPK_NOISE),
+        SND_PCI_QUIRK(0x1028, 0x0738, "Dell Precision 5820", ALC269_FIXUP_NO_SHUTUP),
         SND_PCI_QUIRK(0x1028, 0x075b, "Dell XPS 13 9360", ALC256_FIXUP_DELL_XPS_13_HEADPHONE_NOISE),
         SND_PCI_QUIRK(0x1028, 0x075c, "Dell XPS 27 7760", ALC298_FIXUP_SPK_VOLUME),
         SND_PCI_QUIRK(0x1028, 0x075d, "Dell AIO", ALC298_FIXUP_SPK_VOLUME),
@@ -6689,6 +6749,8 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = {
         SND_PCI_QUIRK(0x1028, 0x0871, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
         SND_PCI_QUIRK(0x1028, 0x0872, "Dell Precision 3630", ALC255_FIXUP_DELL_HEADSET_MIC),
         SND_PCI_QUIRK(0x1028, 0x0873, "Dell Precision 3930", ALC255_FIXUP_DUMMY_LINEOUT_VERB),
+        SND_PCI_QUIRK(0x1028, 0x08ad, "Dell WYSE AIO", ALC225_FIXUP_DELL_WYSE_AIO_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x1028, 0x08ae, "Dell WYSE NB", ALC225_FIXUP_DELL1_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1028, 0x0935, "Dell", ALC274_FIXUP_DELL_AIO_LINEOUT_VERB),
         SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE),
@@ -6751,11 +6813,13 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = {
         SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
         SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
         SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
+        SND_PCI_QUIRK(0x103c, 0x802e, "HP Z240 SFF", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x103c, 0x802f, "HP Z240", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
         SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
         SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360),
-        SND_PCI_QUIRK(0x103c, 0x82bf, "HP", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
-        SND_PCI_QUIRK(0x103c, 0x82c0, "HP", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x103c, 0x82bf, "HP G3 mini", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
+        SND_PCI_QUIRK(0x103c, 0x82c0, "HP G3 mini premium", ALC221_FIXUP_HP_MIC_NO_PRESENCE),
         SND_PCI_QUIRK(0x103c, 0x83b9, "HP Spectre x360", ALC269_FIXUP_HP_MUTE_LED_MIC3),
         SND_PCI_QUIRK(0x1043, 0x103e, "ASUS X540SA", ALC256_FIXUP_ASUS_MIC),
         SND_PCI_QUIRK(0x1043, 0x103f, "ASUS TX300", ALC282_FIXUP_ASUS_TX300),
@@ -6771,7 +6835,6 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = {
         SND_PCI_QUIRK(0x1043, 0x12e0, "ASUS X541SA", ALC256_FIXUP_ASUS_MIC),
         SND_PCI_QUIRK(0x1043, 0x13b0, "ASUS Z550SA", ALC256_FIXUP_ASUS_MIC),
         SND_PCI_QUIRK(0x1043, 0x1427, "Asus Zenbook UX31E", ALC269VB_FIXUP_ASUS_ZENBOOK),
-        SND_PCI_QUIRK(0x1043, 0x14a1, "ASUS UX533FD", ALC294_FIXUP_ASUS_SPK),
         SND_PCI_QUIRK(0x1043, 0x1517, "Asus Zenbook UX31A", ALC269VB_FIXUP_ASUS_ZENBOOK_UX31A),
         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_FIXUP_STEREO_DMIC),
         SND_PCI_QUIRK(0x1043, 0x1a13, "Asus G73Jw", ALC269_FIXUP_ASUS_G73JW),
@@ -7036,7 +7099,7 @@ static const struct hda_model_fixup alc269_fixup_models[] = {
         {.id = ALC255_FIXUP_DUMMY_LINEOUT_VERB, .name = "alc255-dummy-lineout"},
         {.id = ALC255_FIXUP_DELL_HEADSET_MIC, .name = "alc255-dell-headset"},
         {.id = ALC295_FIXUP_HP_X360, .name = "alc295-hp-x360"},
-        {.id = ALC225_FIXUP_HEADSET_JACK, .name = "alc-sense-combo"},
+        {.id = ALC295_FIXUP_CHROME_BOOK, .name = "alc-sense-combo"},
         {}
 };
 #define ALC225_STANDARD_PINS \
@@ -7391,6 +7454,10 @@ static const struct snd_hda_pin_quirk alc269_pin_fixup_tbl[] = {
         SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
                 {0x12, 0x90a60130},
                 {0x17, 0x90170110},
+                {0x21, 0x03211020}),
+        SND_HDA_PIN_QUIRK(0x10ec0294, 0x1043, "ASUS", ALC294_FIXUP_ASUS_SPK,
+                {0x12, 0x90a60130},
+                {0x17, 0x90170110},
                 {0x21, 0x04211020}),
         SND_HDA_PIN_QUIRK(0x10ec0295, 0x1028, "Dell", ALC269_FIXUP_DELL1_MIC_NO_PRESENCE,
                 ALC295_STANDARD_PINS,
diff --git a/sound/pci/ice1712/ews.c b/sound/pci/ice1712/ews.c
index b8af747ecb43..7646c93e8268 100644
--- a/sound/pci/ice1712/ews.c
+++ b/sound/pci/ice1712/ews.c
@@ -826,7 +826,12 @@ static int snd_ice1712_6fire_read_pca(struct snd_ice1712 *ice, unsigned char reg
 
         snd_i2c_lock(ice->i2c);
         byte = reg;
-        snd_i2c_sendbytes(spec->i2cdevs[EWS_I2C_6FIRE], &byte, 1);
+        if (snd_i2c_sendbytes(spec->i2cdevs[EWS_I2C_6FIRE], &byte, 1)) {
+                snd_i2c_unlock(ice->i2c);
+                dev_err(ice->card->dev, "cannot send pca\n");
+                return -EIO;
+        }
+
         byte = 0;
         if (snd_i2c_readbytes(spec->i2cdevs[EWS_I2C_6FIRE], &byte, 1) != 1) {
                 snd_i2c_unlock(ice->i2c);
diff --git a/sound/pci/ice1712/ice1712.c b/sound/pci/ice1712/ice1712.c
index f1fe497c2f9d..fa7d90ee6e2d 100644
--- a/sound/pci/ice1712/ice1712.c
+++ b/sound/pci/ice1712/ice1712.c
@@ -1603,10 +1603,7 @@ static void snd_ice1712_proc_read(struct snd_info_entry *entry,
 
 static void snd_ice1712_proc_init(struct snd_ice1712 *ice)
 {
-        struct snd_info_entry *entry;
-
-        if (!snd_card_proc_new(ice->card, "ice1712", &entry))
-                snd_info_set_text_ops(entry, ice, snd_ice1712_proc_read);
+        snd_card_ro_proc_new(ice->card, "ice1712", ice, snd_ice1712_proc_read);
 }
 
 /*
@@ -2792,9 +2789,6 @@ static int snd_ice1712_suspend(struct device *dev)
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
 
-        snd_pcm_suspend_all(ice->pcm);
-        snd_pcm_suspend_all(ice->pcm_pro);
-        snd_pcm_suspend_all(ice->pcm_ds);
         snd_ac97_suspend(ice->ac97);
 
         spin_lock_irq(&ice->reg_lock);
diff --git a/sound/pci/ice1712/ice1724.c b/sound/pci/ice1712/ice1724.c
index 057c2f394ea7..a7d640ee4a17 100644
--- a/sound/pci/ice1712/ice1724.c
+++ b/sound/pci/ice1712/ice1724.c
@@ -1571,10 +1571,7 @@ static void snd_vt1724_proc_read(struct snd_info_entry *entry,
 
 static void snd_vt1724_proc_init(struct snd_ice1712 *ice)
 {
-        struct snd_info_entry *entry;
-
-        if (!snd_card_proc_new(ice->card, "ice1724", &entry))
-                snd_info_set_text_ops(entry, ice, snd_vt1724_proc_read);
+        snd_card_ro_proc_new(ice->card, "ice1724", ice, snd_vt1724_proc_read);
 }
 
 /*
@@ -2804,9 +2801,6 @@ static int snd_vt1724_suspend(struct device *dev)
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
 
-        snd_pcm_suspend_all(ice->pcm);
-        snd_pcm_suspend_all(ice->pcm_pro);
-        snd_pcm_suspend_all(ice->pcm_ds);
         snd_ac97_suspend(ice->ac97);
 
         spin_lock_irq(&ice->reg_lock);
diff --git a/sound/pci/ice1712/pontis.c b/sound/pci/ice1712/pontis.c
index 93b8cfc6636f..f499f1e8d0c9 100644
--- a/sound/pci/ice1712/pontis.c
+++ b/sound/pci/ice1712/pontis.c
@@ -659,12 +659,8 @@ static void wm_proc_regs_read(struct snd_info_entry *entry, struct snd_info_buff
 
 static void wm_proc_init(struct snd_ice1712 *ice)
 {
-        struct snd_info_entry *entry;
-        if (! snd_card_proc_new(ice->card, "wm_codec", &entry)) {
-                snd_info_set_text_ops(entry, ice, wm_proc_regs_read);
-                entry->mode |= 0200;
-                entry->c.text.write = wm_proc_regs_write;
-        }
+        snd_card_rw_proc_new(ice->card, "wm_codec", ice, wm_proc_regs_read,
+                             wm_proc_regs_write);
 }
 
 static void cs_proc_regs_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
@@ -684,9 +680,7 @@ static void cs_proc_regs_read(struct snd_info_entry *entry, struct snd_info_buff
 
 static void cs_proc_init(struct snd_ice1712 *ice)
 {
-        struct snd_info_entry *entry;
-        if (! snd_card_proc_new(ice->card, "cs_codec", &entry))
-                snd_info_set_text_ops(entry, ice, cs_proc_regs_read);
+        snd_card_ro_proc_new(ice->card, "cs_codec", ice, cs_proc_regs_read);
 }
 
 
diff --git a/sound/pci/ice1712/prodigy192.c b/sound/pci/ice1712/prodigy192.c
index 3919aed39ca0..d243309029d3 100644
--- a/sound/pci/ice1712/prodigy192.c
+++ b/sound/pci/ice1712/prodigy192.c
@@ -651,9 +651,8 @@ static void stac9460_proc_regs_read(struct snd_info_entry *entry,
 
 static void stac9460_proc_init(struct snd_ice1712 *ice)
 {
-        struct snd_info_entry *entry;
-        if (!snd_card_proc_new(ice->card, "stac9460_codec", &entry))
-                snd_info_set_text_ops(entry, ice, stac9460_proc_regs_read);
+        snd_card_ro_proc_new(ice->card, "stac9460_codec", ice,
+                             stac9460_proc_regs_read);
 }
 
 
diff --git a/sound/pci/ice1712/prodigy_hifi.c b/sound/pci/ice1712/prodigy_hifi.c
index c97b5528e4b8..72f252c936e5 100644
--- a/sound/pci/ice1712/prodigy_hifi.c
+++ b/sound/pci/ice1712/prodigy_hifi.c
@@ -904,12 +904,8 @@ static void wm_proc_regs_read(struct snd_info_entry *entry,
 
 static void wm_proc_init(struct snd_ice1712 *ice)
 {
-        struct snd_info_entry *entry;
-        if (!snd_card_proc_new(ice->card, "wm_codec", &entry)) {
-                snd_info_set_text_ops(entry, ice, wm_proc_regs_read);
-                entry->mode |= 0200;
-                entry->c.text.write = wm_proc_regs_write;
-        }
+        snd_card_rw_proc_new(ice->card, "wm_codec", ice, wm_proc_regs_read,
+                             wm_proc_regs_write);
 }
 
 static int prodigy_hifi_add_controls(struct snd_ice1712 *ice)
diff --git a/sound/pci/ice1712/quartet.c b/sound/pci/ice1712/quartet.c
index 5bc836241c97..8ad964ee0b65 100644
--- a/sound/pci/ice1712/quartet.c
+++ b/sound/pci/ice1712/quartet.c
@@ -502,9 +502,7 @@ static void proc_regs_read(struct snd_info_entry *entry,
 
 static void proc_init(struct snd_ice1712 *ice)
 {
-        struct snd_info_entry *entry;
-        if (!snd_card_proc_new(ice->card, "quartet", &entry))
-                snd_info_set_text_ops(entry, ice, proc_regs_read);
+        snd_card_ro_proc_new(ice->card, "quartet", ice, proc_regs_read);
 }
 
 static int qtet_mute_get(struct snd_kcontrol *kcontrol,
diff --git a/sound/pci/intel8x0.c b/sound/pci/intel8x0.c
index ffddcdfe0c66..2784bf48cf5a 100644
--- a/sound/pci/intel8x0.c
+++ b/sound/pci/intel8x0.c
@@ -2614,8 +2614,6 @@ static int intel8x0_suspend(struct device *dev)
         int i;
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        for (i = 0; i < chip->pcm_devs; i++)
-                snd_pcm_suspend_all(chip->pcm[i]);
         for (i = 0; i < chip->ncodecs; i++)
                 snd_ac97_suspend(chip->ac97[i]);
         if (chip->device_type == DEVICE_INTEL_ICH4)
@@ -2865,10 +2863,8 @@ static void snd_intel8x0_proc_read(struct snd_info_entry * entry,
 
 static void snd_intel8x0_proc_init(struct intel8x0 *chip)
 {
-        struct snd_info_entry *entry;
-
-        if (! snd_card_proc_new(chip->card, "intel8x0", &entry))
-                snd_info_set_text_ops(entry, chip, snd_intel8x0_proc_read);
+        snd_card_ro_proc_new(chip->card, "intel8x0", chip,
+                             snd_intel8x0_proc_read);
 }
 
 static int snd_intel8x0_dev_free(struct snd_device *device)
diff --git a/sound/pci/intel8x0m.c b/sound/pci/intel8x0m.c
index c84629190cba..43c654e15452 100644
--- a/sound/pci/intel8x0m.c
+++ b/sound/pci/intel8x0m.c
@@ -1025,11 +1025,8 @@ static int intel8x0m_suspend(struct device *dev)
 {
         struct snd_card *card = dev_get_drvdata(dev);
         struct intel8x0m *chip = card->private_data;
-        int i;
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        for (i = 0; i < chip->pcm_devs; i++)
-                snd_pcm_suspend_all(chip->pcm[i]);
         snd_ac97_suspend(chip->ac97);
         if (chip->irq >= 0) {
                 free_irq(chip->irq, chip);
@@ -1087,10 +1084,8 @@ static void snd_intel8x0m_proc_read(struct snd_info_entry * entry,
 
 static void snd_intel8x0m_proc_init(struct intel8x0m *chip)
 {
-        struct snd_info_entry *entry;
-
-        if (! snd_card_proc_new(chip->card, "intel8x0m", &entry))
-                snd_info_set_text_ops(entry, chip, snd_intel8x0m_proc_read);
+        snd_card_ro_proc_new(chip->card, "intel8x0m", chip,
+                             snd_intel8x0m_proc_read);
 }
 
 static int snd_intel8x0m_dev_free(struct snd_device *device)
diff --git a/sound/pci/korg1212/korg1212.c b/sound/pci/korg1212/korg1212.c
index 4e189a93f475..fe4aba8a08ea 100644
--- a/sound/pci/korg1212/korg1212.c
+++ b/sound/pci/korg1212/korg1212.c
@@ -2090,10 +2090,8 @@ static void snd_korg1212_proc_read(struct snd_info_entry *entry,
 
 static void snd_korg1212_proc_init(struct snd_korg1212 *korg1212)
 {
-        struct snd_info_entry *entry;
-
-        if (! snd_card_proc_new(korg1212->card, "korg1212", &entry))
-                snd_info_set_text_ops(entry, korg1212, snd_korg1212_proc_read);
+        snd_card_ro_proc_new(korg1212->card, "korg1212", korg1212,
+                             snd_korg1212_proc_read);
 }
 
 static int
diff --git a/sound/pci/lola/lola_proc.c b/sound/pci/lola/lola_proc.c
index 904e3c4f4dfe..1603f9c81897 100644
--- a/sound/pci/lola/lola_proc.c
+++ b/sound/pci/lola/lola_proc.c
@@ -208,15 +208,9 @@ static void lola_proc_regs_read(struct snd_info_entry *entry,
 
 void lola_proc_debug_new(struct lola *chip)
 {
-        struct snd_info_entry *entry;
-
-        if (!snd_card_proc_new(chip->card, "codec", &entry))
-                snd_info_set_text_ops(entry, chip, lola_proc_codec_read);
-        if (!snd_card_proc_new(chip->card, "codec_rw", &entry)) {
-                snd_info_set_text_ops(entry, chip, lola_proc_codec_rw_read);
-                entry->mode |= 0200;
-                entry->c.text.write = lola_proc_codec_rw_write;
-        }
-        if (!snd_card_proc_new(chip->card, "regs", &entry))
-                snd_info_set_text_ops(entry, chip, lola_proc_regs_read);
+        snd_card_ro_proc_new(chip->card, "codec", chip, lola_proc_codec_read);
+        snd_card_rw_proc_new(chip->card, "codec_rw", chip,
+                             lola_proc_codec_rw_read,
+                             lola_proc_codec_rw_write);
+        snd_card_ro_proc_new(chip->card, "regs", chip, lola_proc_regs_read);
 }
diff --git a/sound/pci/lx6464es/lx6464es.c b/sound/pci/lx6464es/lx6464es.c
index 54f6252faca6..ae23a2dfbdea 100644
--- a/sound/pci/lx6464es/lx6464es.c
+++ b/sound/pci/lx6464es/lx6464es.c
@@ -854,11 +854,9 @@ static int lx_pcm_create(struct lx6464es *chip)
         pcm->nonatomic = true;
         strcpy(pcm->name, card_name);
 
-        err = snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                                    snd_dma_pci_data(chip->pci),
-                                                    size, size);
-        if (err < 0)
-                return err;
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                              snd_dma_pci_data(chip->pci),
+                                              size, size);
 
         chip->pcm = pcm;
         chip->capture_stream.is_capture = 1;
@@ -948,13 +946,7 @@ static void lx_proc_levels_read(struct snd_info_entry *entry,
 
 static int lx_proc_create(struct snd_card *card, struct lx6464es *chip)
 {
-        struct snd_info_entry *entry;
-        int err = snd_card_proc_new(card, "levels", &entry);
-        if (err < 0)
-                return err;
-
-        snd_info_set_text_ops(entry, chip, lx_proc_levels_read);
-        return 0;
+        return snd_card_ro_proc_new(card, "levels", chip, lx_proc_levels_read);
 }
 
 
diff --git a/sound/pci/maestro3.c b/sound/pci/maestro3.c
index 62962178a9d7..1a9468c14aaf 100644
--- a/sound/pci/maestro3.c
+++ b/sound/pci/maestro3.c
@@ -2422,7 +2422,6 @@ static int m3_suspend(struct device *dev)
         chip->in_suspend = 1;
         cancel_work_sync(&chip->hwvol_work);
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        snd_pcm_suspend_all(chip->pcm);
         snd_ac97_suspend(chip->ac97);
 
         msleep(10); /* give the assp a chance to idle.. */
diff --git a/sound/pci/mixart/mixart.c b/sound/pci/mixart/mixart.c
index 9cd297a42f24..92f616df3863 100644
--- a/sound/pci/mixart/mixart.c
+++ b/sound/pci/mixart/mixart.c
@@ -1220,10 +1220,8 @@ static void snd_mixart_proc_init(struct snd_mixart *chip)
         struct snd_info_entry *entry;
 
         /* text interface to read perf and temp meters */
-        if (! snd_card_proc_new(chip->card, "board_info", &entry)) {
-                entry->private_data = chip;
-                entry->c.text.read = snd_mixart_proc_read;
-        }
+        snd_card_ro_proc_new(chip->card, "board_info", chip,
+                             snd_mixart_proc_read);
 
         if (! snd_card_proc_new(chip->card, "mixart_BA0", &entry)) {
                 entry->content = SNDRV_INFO_CONTENT_DATA;
diff --git a/sound/pci/nm256/nm256.c b/sound/pci/nm256/nm256.c
index b97f4ea6b56c..85e46ff44ac3 100644
--- a/sound/pci/nm256/nm256.c
+++ b/sound/pci/nm256/nm256.c
@@ -1413,7 +1413,6 @@ static int nm256_suspend(struct device *dev)
         struct nm256 *chip = card->private_data;
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        snd_pcm_suspend_all(chip->pcm);
         snd_ac97_suspend(chip->ac97);
         chip->coeffs_current = 0;
         return 0;
diff --git a/sound/pci/oxygen/oxygen_lib.c b/sound/pci/oxygen/oxygen_lib.c
index b4ef5804212d..3ae9dd4b39e8 100644
--- a/sound/pci/oxygen/oxygen_lib.c
+++ b/sound/pci/oxygen/oxygen_lib.c
@@ -244,10 +244,7 @@ static void oxygen_proc_read(struct snd_info_entry *entry,
 
 static void oxygen_proc_init(struct oxygen *chip)
 {
-        struct snd_info_entry *entry;
-
-        if (!snd_card_proc_new(chip->card, "oxygen", &entry))
-                snd_info_set_text_ops(entry, chip, oxygen_proc_read);
+        snd_card_ro_proc_new(chip->card, "oxygen", chip, oxygen_proc_read);
 }
 
 static const struct pci_device_id *
@@ -373,7 +370,7 @@ static void oxygen_init(struct oxygen *chip)
         for (i = 0; i < 8; ++i)
                 chip->dac_volume[i] = chip->model.dac_volume_min;
         chip->dac_mute = 1;
-        chip->spdif_playback_enable = 1;
+        chip->spdif_playback_enable = 0;
         chip->spdif_bits = OXYGEN_SPDIF_C | OXYGEN_SPDIF_ORIGINAL |
                 (IEC958_AES1_CON_PCM_CODER << OXYGEN_SPDIF_CATEGORY_SHIFT);
         chip->spdif_pcm_bits = chip->spdif_bits;
@@ -744,13 +741,10 @@ static int oxygen_pci_suspend(struct device *dev)
 {
         struct snd_card *card = dev_get_drvdata(dev);
         struct oxygen *chip = card->private_data;
-        unsigned int i, saved_interrupt_mask;
+        unsigned int saved_interrupt_mask;
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
 
-        for (i = 0; i < PCM_COUNT; ++i)
-                snd_pcm_suspend(chip->streams[i]);
-
         if (chip->model.suspend)
                 chip->model.suspend(chip);
 
diff --git a/sound/pci/oxygen/pcm1796.h b/sound/pci/oxygen/pcm1796.h
index 34d07dd2d22e..d5dcb09e44cd 100644
--- a/sound/pci/oxygen/pcm1796.h
+++ b/sound/pci/oxygen/pcm1796.h
@@ -10,7 +10,6 @@
 #define PCM1796_MUTE            0x01
 #define PCM1796_DME             0x02
 #define PCM1796_DMF_MASK        0x0c
-#define PCM1796_DMF_DISABLED    0x00
 #define PCM1796_DMF_48          0x04
 #define PCM1796_DMF_441         0x08
 #define PCM1796_DMF_32          0x0c
diff --git a/sound/pci/oxygen/xonar_pcm179x.c b/sound/pci/oxygen/xonar_pcm179x.c
index 24109d37ca09..a1c6b98b191e 100644
--- a/sound/pci/oxygen/xonar_pcm179x.c
+++ b/sound/pci/oxygen/xonar_pcm179x.c
@@ -331,7 +331,7 @@ static void pcm1796_init(struct oxygen *chip)
         struct xonar_pcm179x *data = chip->model_data;
 
         data->pcm1796_regs[0][18 - PCM1796_REG_BASE] =
-                PCM1796_DMF_DISABLED | PCM1796_FMT_24_I2S | PCM1796_ATLD;
+                PCM1796_FMT_24_I2S | PCM1796_ATLD;
         if (!data->broken_i2c)
                 data->pcm1796_regs[0][18 - PCM1796_REG_BASE] |= PCM1796_MUTE;
         data->pcm1796_regs[0][19 - PCM1796_REG_BASE] =
@@ -621,6 +621,23 @@ static void update_pcm1796_oversampling(struct oxygen *chip)
                 pcm1796_write_cached(chip, i, 20, reg);
 }
 
+static void update_pcm1796_deemph(struct oxygen *chip)
+{
+        struct xonar_pcm179x *data = chip->model_data;
+        unsigned int i;
+        u8 reg;
+
+        reg = data->pcm1796_regs[0][18 - PCM1796_REG_BASE] & ~PCM1796_DMF_MASK;
+        if (data->current_rate == 48000)
+                reg |= PCM1796_DMF_48;
+        else if (data->current_rate == 44100)
+                reg |= PCM1796_DMF_441;
+        else if (data->current_rate == 32000)
+                reg |= PCM1796_DMF_32;
+        for (i = 0; i < data->dacs; ++i)
+                pcm1796_write_cached(chip, i, 18, reg);
+}
+
 static void set_pcm1796_params(struct oxygen *chip,
                                struct snd_pcm_hw_params *params)
 {
@@ -629,6 +646,7 @@ static void set_pcm1796_params(struct oxygen *chip,
         msleep(1);
         data->current_rate = params_rate(params);
         update_pcm1796_oversampling(chip);
+        update_pcm1796_deemph(chip);
 }
 
 static void update_pcm1796_volume(struct oxygen *chip)
@@ -653,9 +671,11 @@ static void update_pcm1796_mute(struct oxygen *chip)
         unsigned int i;
         u8 value;
 
-        value = PCM1796_DMF_DISABLED | PCM1796_FMT_24_I2S | PCM1796_ATLD;
+        value = data->pcm1796_regs[0][18 - PCM1796_REG_BASE];
         if (chip->dac_mute)
                 value |= PCM1796_MUTE;
+        else
+                value &= ~PCM1796_MUTE;
         for (i = 0; i < data->dacs; ++i)
                 pcm1796_write_cached(chip, i, 18, value);
 }
@@ -777,6 +797,49 @@ static const struct snd_kcontrol_new rolloff_control = {
         .put = rolloff_put,
 };
 
+static int deemph_get(struct snd_kcontrol *ctl,
+                       struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_pcm179x *data = chip->model_data;
+
+        value->value.integer.value[0] =
+                !!(data->pcm1796_regs[0][18 - PCM1796_REG_BASE] & PCM1796_DME);
+        return 0;
+}
+
+static int deemph_put(struct snd_kcontrol *ctl,
+                       struct snd_ctl_elem_value *value)
+{
+        struct oxygen *chip = ctl->private_data;
+        struct xonar_pcm179x *data = chip->model_data;
+        unsigned int i;
+        int changed;
+        u8 reg;
+
+        mutex_lock(&chip->mutex);
+        reg = data->pcm1796_regs[0][18 - PCM1796_REG_BASE];
+        if (!value->value.integer.value[0])
+                reg &= ~PCM1796_DME;
+        else
+                reg |= PCM1796_DME;
+        changed = reg != data->pcm1796_regs[0][18 - PCM1796_REG_BASE];
+        if (changed) {
+                for (i = 0; i < data->dacs; ++i)
+                        pcm1796_write(chip, i, 18, reg);
+        }
+        mutex_unlock(&chip->mutex);
+        return changed;
+}
+
+static const struct snd_kcontrol_new deemph_control = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "De-emphasis Playback Switch",
+        .info = snd_ctl_boolean_mono_info,
+        .get = deemph_get,
+        .put = deemph_put,
+};
+
 static const struct snd_kcontrol_new hdav_hdmi_control = {
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
         .name = "HDMI Playback Switch",
@@ -1011,6 +1074,10 @@ static int add_pcm1796_controls(struct oxygen *chip)
                                   snd_ctl_new1(&rolloff_control, chip));
                 if (err < 0)
                         return err;
+                err = snd_ctl_add(chip->card,
+                                  snd_ctl_new1(&deemph_control, chip));
+                if (err < 0)
+                        return err;
         }
         return 0;
 }
diff --git a/sound/pci/pcxhr/pcxhr.c b/sound/pci/pcxhr/pcxhr.c
index e57da4036231..4ab7efc6e9f7 100644
--- a/sound/pci/pcxhr/pcxhr.c
+++ b/sound/pci/pcxhr/pcxhr.c
@@ -1454,21 +1454,14 @@ static void pcxhr_proc_ltc(struct snd_info_entry *entry,
 
 static void pcxhr_proc_init(struct snd_pcxhr *chip)
 {
-        struct snd_info_entry *entry;
-
-        if (! snd_card_proc_new(chip->card, "info", &entry))
-                snd_info_set_text_ops(entry, chip, pcxhr_proc_info);
-        if (! snd_card_proc_new(chip->card, "sync", &entry))
-                snd_info_set_text_ops(entry, chip, pcxhr_proc_sync);
+        snd_card_ro_proc_new(chip->card, "info", chip, pcxhr_proc_info);
+        snd_card_ro_proc_new(chip->card, "sync", chip, pcxhr_proc_sync);
         /* gpio available on stereo sound cards only */
-        if (chip->mgr->is_hr_stereo &&
-            !snd_card_proc_new(chip->card, "gpio", &entry)) {
-                snd_info_set_text_ops(entry, chip, pcxhr_proc_gpio_read);
-                entry->c.text.write = pcxhr_proc_gpo_write;
-                entry->mode |= 0200;
-        }
-        if (!snd_card_proc_new(chip->card, "ltc", &entry))
-                snd_info_set_text_ops(entry, chip, pcxhr_proc_ltc);
+        if (chip->mgr->is_hr_stereo)
+                snd_card_rw_proc_new(chip->card, "gpio", chip,
+                                     pcxhr_proc_gpio_read,
+                                     pcxhr_proc_gpo_write);
+        snd_card_ro_proc_new(chip->card, "ltc", chip, pcxhr_proc_ltc);
 }
 /* end of proc interface */
 
diff --git a/sound/pci/riptide/riptide.c b/sound/pci/riptide/riptide.c
index 23017e3bc76c..8d1a56a9bcfd 100644
--- a/sound/pci/riptide/riptide.c
+++ b/sound/pci/riptide/riptide.c
@@ -1158,7 +1158,6 @@ static int riptide_suspend(struct device *dev)
 
         chip->in_suspend = 1;
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        snd_pcm_suspend_all(chip->pcm);
         snd_ac97_suspend(chip->ac97);
         return 0;
 }
@@ -1974,10 +1973,8 @@ snd_riptide_proc_read(struct snd_info_entry *entry,
 
 static void snd_riptide_proc_init(struct snd_riptide *chip)
 {
-        struct snd_info_entry *entry;
-
-        if (!snd_card_proc_new(chip->card, "riptide", &entry))
-                snd_info_set_text_ops(entry, chip, snd_riptide_proc_read);
+        snd_card_ro_proc_new(chip->card, "riptide", chip,
+                             snd_riptide_proc_read);
 }
 
 static int snd_riptide_mixer(struct snd_riptide *chip)
diff --git a/sound/pci/rme32.c b/sound/pci/rme32.c
index 3ac8c71d567c..c6bcc0715716 100644
--- a/sound/pci/rme32.c
+++ b/sound/pci/rme32.c
@@ -1568,10 +1568,7 @@ snd_rme32_proc_read(struct snd_info_entry * entry, struct snd_info_buffer *buffe
 
 static void snd_rme32_proc_init(struct rme32 *rme32)
 {
-        struct snd_info_entry *entry;
-
-        if (! snd_card_proc_new(rme32->card, "rme32", &entry))
-                snd_info_set_text_ops(entry, rme32, snd_rme32_proc_read);
+        snd_card_ro_proc_new(rme32->card, "rme32", rme32, snd_rme32_proc_read);
 }
 
 /*
diff --git a/sound/pci/rme96.c b/sound/pci/rme96.c
index dcfa4d7a73e2..42c6b5e09072 100644
--- a/sound/pci/rme96.c
+++ b/sound/pci/rme96.c
@@ -1868,10 +1868,7 @@ snd_rme96_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer
 
 static void snd_rme96_proc_init(struct rme96 *rme96)
 {
-        struct snd_info_entry *entry;
-
-        if (! snd_card_proc_new(rme96->card, "rme96", &entry))
-                snd_info_set_text_ops(entry, rme96, snd_rme96_proc_read);
+        snd_card_ro_proc_new(rme96->card, "rme96", rme96, snd_rme96_proc_read);
 }
 
 /*
@@ -2388,8 +2385,6 @@ static int rme96_suspend(struct device *dev)
         struct rme96 *rme96 = card->private_data;
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        snd_pcm_suspend(rme96->playback_substream);
-        snd_pcm_suspend(rme96->capture_substream);
 
         /* save capture & playback pointers */
         rme96->playback_pointer = readl(rme96->iobase + RME96_IO_GET_PLAY_POS)
diff --git a/sound/pci/rme9652/hdsp.c b/sound/pci/rme9652/hdsp.c
index ba99ff0e93e0..29bef48a3af3 100644
--- a/sound/pci/rme9652/hdsp.c
+++ b/sound/pci/rme9652/hdsp.c
@@ -3708,10 +3708,7 @@ snd_hdsp_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buffer)
 
 static void snd_hdsp_proc_init(struct hdsp *hdsp)
 {
-        struct snd_info_entry *entry;
-
-        if (! snd_card_proc_new(hdsp->card, "hdsp", &entry))
-                snd_info_set_text_ops(entry, hdsp, snd_hdsp_proc_read);
+        snd_card_ro_proc_new(hdsp->card, "hdsp", hdsp, snd_hdsp_proc_read);
 }
 
 static void snd_hdsp_free_buffers(struct hdsp *hdsp)
diff --git a/sound/pci/rme9652/hdspm.c b/sound/pci/rme9652/hdspm.c
index 679ad0415e3b..1209cf0b05e0 100644
--- a/sound/pci/rme9652/hdspm.c
+++ b/sound/pci/rme9652/hdspm.c
@@ -5287,44 +5287,35 @@ static void snd_hdspm_proc_ports_out(struct snd_info_entry *entry,
 
 static void snd_hdspm_proc_init(struct hdspm *hdspm)
 {
-        struct snd_info_entry *entry;
+        void (*read)(struct snd_info_entry *, struct snd_info_buffer *) = NULL;
 
-        if (!snd_card_proc_new(hdspm->card, "hdspm", &entry)) {
-                switch (hdspm->io_type) {
-                case AES32:
-                        snd_info_set_text_ops(entry, hdspm,
-                                        snd_hdspm_proc_read_aes32);
-                        break;
-                case MADI:
-                        snd_info_set_text_ops(entry, hdspm,
-                                        snd_hdspm_proc_read_madi);
-                        break;
-                case MADIface:
-                        /* snd_info_set_text_ops(entry, hdspm,
-                         snd_hdspm_proc_read_madiface); */
-                        break;
-                case RayDAT:
-                        snd_info_set_text_ops(entry, hdspm,
-                                        snd_hdspm_proc_read_raydat);
-                        break;
-                case AIO:
-                        break;
-                }
-        }
-
-        if (!snd_card_proc_new(hdspm->card, "ports.in", &entry)) {
-                snd_info_set_text_ops(entry, hdspm, snd_hdspm_proc_ports_in);
+        switch (hdspm->io_type) {
+        case AES32:
+                read = snd_hdspm_proc_read_aes32;
+                break;
+        case MADI:
+                read = snd_hdspm_proc_read_madi;
+                break;
+        case MADIface:
+                /* read = snd_hdspm_proc_read_madiface; */
+                break;
+        case RayDAT:
+                read = snd_hdspm_proc_read_raydat;
+                break;
+        case AIO:
+                break;
         }
 
-        if (!snd_card_proc_new(hdspm->card, "ports.out", &entry)) {
-                snd_info_set_text_ops(entry, hdspm, snd_hdspm_proc_ports_out);
-        }
+        snd_card_ro_proc_new(hdspm->card, "hdspm", hdspm, read);
+        snd_card_ro_proc_new(hdspm->card, "ports.in", hdspm,
+                             snd_hdspm_proc_ports_in);
+        snd_card_ro_proc_new(hdspm->card, "ports.out", hdspm,
+                             snd_hdspm_proc_ports_out);
 
 #ifdef CONFIG_SND_DEBUG
         /* debug file to read all hdspm registers */
-        if (!snd_card_proc_new(hdspm->card, "debug", &entry))
-                snd_info_set_text_ops(entry, hdspm,
-                                snd_hdspm_proc_read_debug);
+        snd_card_ro_proc_new(hdspm->card, "debug", hdspm,
+                             snd_hdspm_proc_read_debug);
 #endif
 }
 
@@ -6411,7 +6402,6 @@ static int snd_hdspm_create_hwdep(struct snd_card *card,
  ------------------------------------------------------------*/
 static int snd_hdspm_preallocate_memory(struct hdspm *hdspm)
 {
-        int err;
         struct snd_pcm *pcm;
         size_t wanted;
 
@@ -6419,21 +6409,10 @@ static int snd_hdspm_preallocate_memory(struct hdspm *hdspm)
 
         wanted = HDSPM_DMA_AREA_BYTES;
 
-        err =
-             snd_pcm_lib_preallocate_pages_for_all(pcm,
-                                                   SNDRV_DMA_TYPE_DEV_SG,
-                                                   snd_dma_pci_data(hdspm->pci),
-                                                   wanted,
-                                                   wanted);
-        if (err < 0) {
-                dev_dbg(hdspm->card->dev,
-                        "Could not preallocate %zd Bytes\n", wanted);
-
-                return err;
-        } else
-                dev_dbg(hdspm->card->dev,
-                        " Preallocated %zd Bytes\n", wanted);
-
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
+                                              snd_dma_pci_data(hdspm->pci),
+                                              wanted, wanted);
+        dev_dbg(hdspm->card->dev, " Preallocated %zd Bytes\n", wanted);
         return 0;
 }
 
diff --git a/sound/pci/rme9652/rme9652.c b/sound/pci/rme9652/rme9652.c
index edd765e22377..5228b982da5a 100644
--- a/sound/pci/rme9652/rme9652.c
+++ b/sound/pci/rme9652/rme9652.c
@@ -1737,10 +1737,8 @@ snd_rme9652_proc_read(struct snd_info_entry *entry, struct snd_info_buffer *buff
 
 static void snd_rme9652_proc_init(struct snd_rme9652 *rme9652)
 {
-        struct snd_info_entry *entry;
-
-        if (! snd_card_proc_new(rme9652->card, "rme9652", &entry))
-                snd_info_set_text_ops(entry, rme9652, snd_rme9652_proc_read);
+        snd_card_ro_proc_new(rme9652->card, "rme9652", rme9652,
+                             snd_rme9652_proc_read);
 }
 
 static void snd_rme9652_free_buffers(struct snd_rme9652 *rme9652)
diff --git a/sound/pci/sis7019.c b/sound/pci/sis7019.c
index 964acf302479..6b27980d77a8 100644
--- a/sound/pci/sis7019.c
+++ b/sound/pci/sis7019.c
@@ -1214,7 +1214,6 @@ static int sis_suspend(struct device *dev)
         int i;
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        snd_pcm_suspend_all(sis->pcm);
         if (sis->codecs_present & SIS_PRIMARY_CODEC_PRESENT)
                 snd_ac97_suspend(sis->ac97[0]);
         if (sis->codecs_present & SIS_SECONDARY_CODEC_PRESENT)
diff --git a/sound/pci/sonicvibes.c b/sound/pci/sonicvibes.c
index 7218f38b59db..71d5ad3cffd6 100644
--- a/sound/pci/sonicvibes.c
+++ b/sound/pci/sonicvibes.c
@@ -1171,10 +1171,8 @@ static void snd_sonicvibes_proc_read(struct snd_info_entry *entry,
 
 static void snd_sonicvibes_proc_init(struct sonicvibes *sonic)
 {
-        struct snd_info_entry *entry;
-
-        if (! snd_card_proc_new(sonic->card, "sonicvibes", &entry))
-                snd_info_set_text_ops(entry, sonic, snd_sonicvibes_proc_read);
+        snd_card_ro_proc_new(sonic->card, "sonicvibes", sonic,
+                             snd_sonicvibes_proc_read);
 }
 
 /*
diff --git a/sound/pci/trident/trident_main.c b/sound/pci/trident/trident_main.c
index 5523e193d556..0ff32d3f5d3b 100644
--- a/sound/pci/trident/trident_main.c
+++ b/sound/pci/trident/trident_main.c
@@ -3320,13 +3320,11 @@ static void snd_trident_proc_read(struct snd_info_entry *entry,
 
 static void snd_trident_proc_init(struct snd_trident *trident)
 {
-        struct snd_info_entry *entry;
         const char *s = "trident";
         
         if (trident->device == TRIDENT_DEVICE_ID_SI7018)
                 s = "sis7018";
-        if (! snd_card_proc_new(trident->card, s, &entry))
-                snd_info_set_text_ops(entry, trident, snd_trident_proc_read);
+        snd_card_ro_proc_new(trident->card, s, trident, snd_trident_proc_read);
 }
 
 static int snd_trident_dev_free(struct snd_device *device)
@@ -3915,10 +3913,6 @@ static int snd_trident_suspend(struct device *dev)
 
         trident->in_suspend = 1;
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        snd_pcm_suspend_all(trident->pcm);
-        snd_pcm_suspend_all(trident->foldback);
-        snd_pcm_suspend_all(trident->spdif);
-
         snd_ac97_suspend(trident->ac97);
         snd_ac97_suspend(trident->ac97_sec);
         return 0;
diff --git a/sound/pci/via82xx.c b/sound/pci/via82xx.c
index c488c5afa195..dee1c487d6ba 100644
--- a/sound/pci/via82xx.c
+++ b/sound/pci/via82xx.c
@@ -2144,10 +2144,8 @@ static void snd_via82xx_proc_read(struct snd_info_entry *entry,
 
 static void snd_via82xx_proc_init(struct via82xx *chip)
 {
-        struct snd_info_entry *entry;
-
-        if (! snd_card_proc_new(chip->card, "via82xx", &entry))
-                snd_info_set_text_ops(entry, chip, snd_via82xx_proc_read);
+        snd_card_ro_proc_new(chip->card, "via82xx", chip,
+                             snd_via82xx_proc_read);
 }
 
 /*
@@ -2278,8 +2276,6 @@ static int snd_via82xx_suspend(struct device *dev)
         int i;
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        for (i = 0; i < 2; i++)
-                snd_pcm_suspend_all(chip->pcms[i]);
         for (i = 0; i < chip->num_devs; i++)
                 snd_via82xx_channel_reset(chip, &chip->devs[i]);
         synchronize_irq(chip->irq);
diff --git a/sound/pci/via82xx_modem.c b/sound/pci/via82xx_modem.c
index b13c8688cc8d..7e0bebce7b77 100644
--- a/sound/pci/via82xx_modem.c
+++ b/sound/pci/via82xx_modem.c
@@ -865,11 +865,9 @@ static int snd_via686_pcm_new(struct via82xx_modem *chip)
         init_viadev(chip, 0, VIA_REG_MO_STATUS, 0);
         init_viadev(chip, 1, VIA_REG_MI_STATUS, 1);
 
-        if ((err = snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
-                                                         snd_dma_pci_data(chip->pci),
-                                                         64*1024, 128*1024)) < 0)
-                return err;
-
+        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV_SG,
+                                              snd_dma_pci_data(chip->pci),
+                                              64*1024, 128*1024);
         return 0;
 }
 
@@ -937,10 +935,8 @@ static void snd_via82xx_proc_read(struct snd_info_entry *entry, struct snd_info_
 
 static void snd_via82xx_proc_init(struct via82xx_modem *chip)
 {
-        struct snd_info_entry *entry;
-
-        if (! snd_card_proc_new(chip->card, "via82xx", &entry))
-                snd_info_set_text_ops(entry, chip, snd_via82xx_proc_read);
+        snd_card_ro_proc_new(chip->card, "via82xx", chip,
+                             snd_via82xx_proc_read);
 }
 
 /*
@@ -1038,8 +1034,6 @@ static int snd_via82xx_suspend(struct device *dev)
         int i;
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        for (i = 0; i < 2; i++)
-                snd_pcm_suspend_all(chip->pcms[i]);
         for (i = 0; i < chip->num_devs; i++)
                 snd_via82xx_channel_reset(chip, &chip->devs[i]);
         synchronize_irq(chip->irq);
diff --git a/sound/pci/ymfpci/ymfpci_main.c b/sound/pci/ymfpci/ymfpci_main.c
index a4926fb03991..4d48877f211f 100644
--- a/sound/pci/ymfpci/ymfpci_main.c
+++ b/sound/pci/ymfpci/ymfpci_main.c
@@ -1985,11 +1985,7 @@ static void snd_ymfpci_proc_read(struct snd_info_entry *entry,
 
 static int snd_ymfpci_proc_init(struct snd_card *card, struct snd_ymfpci *chip)
 {
-        struct snd_info_entry *entry;
-        
-        if (! snd_card_proc_new(card, "ymfpci", &entry))
-                snd_info_set_text_ops(entry, chip, snd_ymfpci_proc_read);
-        return 0;
+        return snd_card_ro_proc_new(card, "ymfpci", chip, snd_ymfpci_proc_read);
 }
 
 /*
@@ -2304,10 +2300,6 @@ static int snd_ymfpci_suspend(struct device *dev)
         unsigned int i;
         
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        snd_pcm_suspend_all(chip->pcm);
-        snd_pcm_suspend_all(chip->pcm2);
-        snd_pcm_suspend_all(chip->pcm_spdif);
-        snd_pcm_suspend_all(chip->pcm_4ch);
         snd_ac97_suspend(chip->ac97);
         for (i = 0; i < YDSXGR_NUM_SAVED_REGS; i++)
                 chip->saved_regs[i] = snd_ymfpci_readl(chip, saved_regs_index[i]);