Changeset 679 for GPL/trunk/alsa-kernel/pci/ymfpci

Timestamp:

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

Author:

David Azarewicz

Message:

Merge changes from Paul's uniaud32next branch.

Location:

GPL/trunk

Files:

• . (modified) (1 prop)
• alsa-kernel/pci/ymfpci/ymfpci.c (modified) (17 diffs)
• alsa-kernel/pci/ymfpci/ymfpci.h (copied) (copied from GPL/branches/uniaud32-next/alsa-kernel/pci/ymfpci/ymfpci.h )
• alsa-kernel/pci/ymfpci/ymfpci_main.c (modified) (62 diffs)

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

@@ +1 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
 /*
  *  The driver for the Yamaha's DS1/DS1E cards
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
- *
- *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
- *
  */
 
@@ -23 +8 @@
 #include <linux/pci.h>
 #include <linux/time.h>
-#include <linux/moduleparam.h>
+#include <linux/module.h>
 #include <sound/core.h>
-#include <sound/ymfpci.h>
+#include "ymfpci.h"
 #include <sound/mpu401.h>
 #include <sound/opl3.h>
 #include <sound/initval.h>
+
+#ifdef TARGET_OS2
+#define KBUILD_MODNAME "ymfpci"
+#endif
 
 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
@@ -42 +31 @@
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
-static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;      /* Enable this card */
+static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;     /* Enable this card */
 static long fm_port[SNDRV_CARDS];
 static long mpu_port[SNDRV_CARDS];
@@ -48 +37 @@
 static long joystick_port[SNDRV_CARDS];
 #endif
-static int rear_switch[SNDRV_CARDS];
+static bool rear_switch[SNDRV_CARDS];
 
 module_param_array(index, int, NULL, 0444);
@@ -56 +45 @@
 module_param_array(enable, bool, NULL, 0444);
 MODULE_PARM_DESC(enable, "Enable Yamaha DS-1 soundcard.");
-module_param_array(mpu_port, long, NULL, 0444);
+module_param_hw_array(mpu_port, long, ioport, NULL, 0444);
 MODULE_PARM_DESC(mpu_port, "MPU-401 Port.");
-module_param_array(fm_port, long, NULL, 0444);
+module_param_hw_array(fm_port, long, ioport, NULL, 0444);
 MODULE_PARM_DESC(fm_port, "FM OPL-3 Port.");
 #ifdef SUPPORT_JOYSTICK
-module_param_array(joystick_port, long, NULL, 0444);
+module_param_hw_array(joystick_port, long, ioport, NULL, 0444);
 MODULE_PARM_DESC(joystick_port, "Joystick port address");
 #endif
@@ -67 +56 @@
 MODULE_PARM_DESC(rear_switch, "Enable shared rear/line-in switch");
 
-static DEFINE_PCI_DEVICE_TABLE(snd_ymfpci_ids) = {
+static const struct pci_device_id snd_ymfpci_ids[] = {
         { PCI_VDEVICE(YAMAHA, 0x0004), 0, },   /* YMF724 */
         { PCI_VDEVICE(YAMAHA, 0x000d), 0, },   /* YMF724F */
@@ -80 +69 @@
 
 #ifdef SUPPORT_JOYSTICK
-static int __devinit snd_ymfpci_create_gameport(struct snd_ymfpci *chip, int dev,
-                                                int legacy_ctrl, int legacy_ctrl2)
+static int snd_ymfpci_create_gameport(struct snd_ymfpci *chip, int dev,
+                                      int legacy_ctrl, int legacy_ctrl2)
 {
         struct gameport *gp;
@@ -107 +96 @@
                         }
                         if (!r) {
-                                printk(KERN_ERR "ymfpci: no gameport ports available\n");
+                                dev_err(chip->card->dev,
+                                        "no gameport ports available\n");
                                 return -EBUSY;
                         }
@@ -117 +107 @@
                 case 0x205: legacy_ctrl2 |= 3 << 6; break;
                 default:
-                        printk(KERN_ERR "ymfpci: invalid joystick port %#x", io_port);
+                        dev_err(chip->card->dev,
+                                "invalid joystick port %#x", io_port);
                         return -EINVAL;
                 }
@@ -123 +114 @@
 
         if (!r && !(r = request_region(io_port, 1, "YMFPCI gameport"))) {
-                printk(KERN_ERR "ymfpci: joystick port %#x is in use.\n", io_port);
+                dev_err(chip->card->dev,
+                        "joystick port %#x is in use.\n", io_port);
                 return -EBUSY;
         }
@@ -129 +121 @@
         chip->gameport = gp = gameport_allocate_port();
         if (!gp) {
-                printk(KERN_ERR "ymfpci: cannot allocate memory for gameport\n");
+                dev_err(chip->card->dev,
+                        "cannot allocate memory for gameport\n");
                 release_and_free_resource(r);
                 return -ENOMEM;
@@ -168 +161 @@
 #endif /* SUPPORT_JOYSTICK */
 
-static int __devinit snd_card_ymfpci_probe(struct pci_dev *pci,
-                                           const struct pci_device_id *pci_id)
+static int snd_card_ymfpci_probe(struct pci_dev *pci,
+                                 const struct pci_device_id *pci_id)
 {
         static int dev;
@@ -188 +181 @@
         }
 
-        err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
+        err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
+                           0, &card);
         if (err < 0)
                 return err;
@@ -264 +258 @@
                                      old_legacy_ctrl,
                                      &chip)) < 0) {
-                snd_card_free(card);
                 release_and_free_resource(mpu_res);
                 release_and_free_resource(fm_res);
-                return err;
+                goto free_card;
         }
         chip->fm_res = fm_res;
@@ -279 +272 @@
                 chip->reg_area_phys,
                 chip->irq);
-        if ((err = snd_ymfpci_pcm(chip, 0, NULL)) < 0) {
-                snd_card_free(card);
-                return err;
-        }
-        if ((err = snd_ymfpci_pcm_spdif(chip, 1, NULL)) < 0) {
-                snd_card_free(card);
-                return err;
-        }
-        if ((err = snd_ymfpci_pcm_4ch(chip, 2, NULL)) < 0) {
-                snd_card_free(card);
-                return err;
-        }
-        if ((err = snd_ymfpci_pcm2(chip, 3, NULL)) < 0) {
-                snd_card_free(card);
-                return err;
-        }
-        if ((err = snd_ymfpci_mixer(chip, rear_switch[dev])) < 0) {
-                snd_card_free(card);
-                return err;
-        }
-        if ((err = snd_ymfpci_timer(chip, 0)) < 0) {
-                snd_card_free(card);
-                return err;
-        }
+        err = snd_ymfpci_pcm(chip, 0);
+        if (err < 0)
+                goto free_card;
+
+        err = snd_ymfpci_pcm_spdif(chip, 1);
+        if (err < 0)
+                goto free_card;
+
+        err = snd_ymfpci_mixer(chip, rear_switch[dev]);
+        if (err < 0)
+                goto free_card;
+
+        if (chip->ac97->ext_id & AC97_EI_SDAC) {
+                err = snd_ymfpci_pcm_4ch(chip, 2);
+                if (err < 0)
+                        goto free_card;
+
+                err = snd_ymfpci_pcm2(chip, 3);
+                if (err < 0)
+                        goto free_card;
+        }
+        err = snd_ymfpci_timer(chip, 0);
+        if (err < 0)
+                goto free_card;
+
         if (chip->mpu_res) {
                 if ((err = snd_mpu401_uart_new(card, 0, MPU401_HW_YMFPCI,
                                                mpu_port[dev],
-                                               MPU401_INFO_INTEGRATED,
-                                               pci->irq, 0, &chip->rawmidi)) < 0) {
-                        printk(KERN_WARNING "ymfpci: cannot initialize MPU401 at 0x%lx, skipping...\n", mpu_port[dev]);
+                                               MPU401_INFO_INTEGRATED |
+                                               MPU401_INFO_IRQ_HOOK,
+                                               -1, &chip->rawmidi)) < 0) {
+                        dev_warn(card->dev,
+                                 "cannot initialize MPU401 at 0x%lx, skipping...\n",
+                                 mpu_port[dev]);
                         legacy_ctrl &= ~YMFPCI_LEGACY_MIEN; /* disable MPU401 irq */
                         pci_write_config_word(pci, PCIR_DSXG_LEGACY, legacy_ctrl);
@@ -318 +315 @@
                                            fm_port[dev] + 2,
                                            OPL3_HW_OPL3, 1, &opl3)) < 0) {
-                        printk(KERN_WARNING "ymfpci: cannot initialize FM OPL3 at 0x%lx, skipping...\n", fm_port[dev]);
+                        dev_warn(card->dev,
+                                 "cannot initialize FM OPL3 at 0x%lx, skipping...\n",
+                                 fm_port[dev]);
                         legacy_ctrl &= ~YMFPCI_LEGACY_FMEN;
                         pci_write_config_word(pci, PCIR_DSXG_LEGACY, legacy_ctrl);
                 } else if ((err = snd_opl3_hwdep_new(opl3, 0, 1, NULL)) < 0) {
-                        snd_card_free(card);
-                        snd_printk(KERN_ERR "cannot create opl3 hwdep\n");
-                        return err;
+                        dev_err(card->dev, "cannot create opl3 hwdep\n");
+                        goto free_card;
                 }
         }
@@ -330 +328 @@
         snd_ymfpci_create_gameport(chip, dev, legacy_ctrl, legacy_ctrl2);
 
-        if ((err = snd_card_register(card)) < 0) {
-                snd_card_free(card);
-                return err;
-        }
+        err = snd_card_register(card);
+        if (err < 0)
+                goto free_card;
+
         pci_set_drvdata(pci, card);
         dev++;
         return 0;
+
+free_card:
+        snd_card_free(card);
+        return err;
 }
 
-static void __devexit snd_card_ymfpci_remove(struct pci_dev *pci)
+static void snd_card_ymfpci_remove(struct pci_dev *pci)
 {
         snd_card_free(pci_get_drvdata(pci));
-        pci_set_drvdata(pci, NULL);
 }
 
-static struct pci_driver driver = {
-        .name = "Yamaha DS-1 PCI",
+static struct pci_driver ymfpci_driver = {
+        .name = KBUILD_MODNAME,
         .id_table = snd_ymfpci_ids,
         .probe = snd_card_ymfpci_probe,
-        .remove = __devexit_p(snd_card_ymfpci_remove),
-#ifdef CONFIG_PM
-        .suspend = snd_ymfpci_suspend,
-        .resume = snd_ymfpci_resume,
+        .remove = snd_card_ymfpci_remove,
+#ifdef CONFIG_PM_SLEEP
+        .driver = {
+                .pm = &snd_ymfpci_pm,
+        },
 #endif
 };
 
-static int __init alsa_card_ymfpci_init(void)
-{
-        return pci_register_driver(&driver);
-}
-
-static void __exit alsa_card_ymfpci_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-
-module_init(alsa_card_ymfpci_init)
-module_exit(alsa_card_ymfpci_exit)
+module_pci_driver(ymfpci_driver);

GPL/trunk/alsa-kernel/pci/ymfpci/ymfpci_main.c

@@ +1 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
 /*
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
  *  Routines for control of YMF724/740/744/754 chips
- *
- *   This program is free software; you can redistribute it and/or modify
- *   it under the terms of the GNU General Public License as published by
- *   the Free Software Foundation; either version 2 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *   GNU General Public License for more details.
- *
- *   You should have received a copy of the GNU General Public License
- *   along with this program; if not, write to the Free Software
- *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
- *
  */
+
+#ifdef TARGET_OS2
+#define KBUILD_MODNAME "ymfpci"
+#endif
 
 #include <linux/delay.h>
@@ -26 +16 @@
 #include <linux/sched.h>
 #include <linux/slab.h>
-#include <linux/vmalloc.h>
 #include <linux/mutex.h>
+#include <linux/module.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
@@ -33 +24 @@
 #include <sound/info.h>
 #include <sound/tlv.h>
-#include <sound/ymfpci.h>
+#include "ymfpci.h"
 #include <sound/asoundef.h>
 #include <sound/mpu401.h>
 
-#include <asm/io.h>
 #include <asm/byteorder.h>
 
@@ -87 +77 @@
                 schedule_timeout_uninterruptible(1);
         } while (time_before(jiffies, end_time));
-        snd_printk(KERN_ERR "codec_ready: codec %i is not ready [0x%x]\n", secondary, snd_ymfpci_readw(chip, reg));
+        dev_err(chip->card->dev,
+                "codec_ready: codec %i is not ready [0x%x]\n",
+                secondary, snd_ymfpci_readw(chip, reg));
         return -EBUSY;
 }
@@ -135 +127 @@
 }
 
-static u32 def_rate[8] = {
+static const u32 def_rate[8] = {
         100, 2000, 8000, 11025, 16000, 22050, 32000, 48000
 };
@@ -142 +134 @@
 {
         u32 i;
-        static u32 val[8] = {
+        static const u32 val[8] = {
                 0x00570000, 0x06AA0000, 0x18B20000, 0x20930000,
                 0x2B9A0000, 0x35A10000, 0x3EAA0000, 0x40000000
@@ -158 +150 @@
 {
         u32 i;
-        static u32 val[8] = {
+        static const u32 val[8] = {
                 0x35280000, 0x34A70000, 0x32020000, 0x31770000,
                 0x31390000, 0x31C90000, 0x33D00000, 0x40000000
@@ -320 +312 @@
                 if (ypcm->period_pos >= ypcm->period_size) {
                         /*
-                        printk(KERN_DEBUG
+                        dev_dbg(chip->card->dev,
                                "done - active_bank = 0x%x, start = 0x%x\n",
                                chip->active_bank,
@@ -335 +327 @@
                         unsigned int next_bank = 1 - chip->active_bank;
                         struct snd_ymfpci_playback_bank *bank;
-                        u32 volume;
+                        __le32 volume;
                         
                         bank = &voice->bank[next_bank];
@@ -373 +365 @@
                         ypcm->period_pos %= ypcm->period_size;
                         /*
-                        printk(KERN_DEBUG
+                        dev_dbg(chip->card->dev,
                                "done - active_bank = 0x%x, start = 0x%x\n",
                                chip->active_bank,
@@ -413 +405 @@
                         kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_INACTIVE;
                 }
-                /* fall through */
+                fallthrough;
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
         case SNDRV_PCM_TRIGGER_SUSPEND:
@@ -504 +496 @@
         struct snd_ymfpci_playback_bank *bank;
         unsigned int nbank;
-        u32 vol_left, vol_right;
+        __le32 vol_left, vol_right;
         u8 use_left, use_right;
         unsigned long flags;
@@ -598 +590 @@
 }
 
-static int __devinit snd_ymfpci_ac3_init(struct snd_ymfpci *chip)
-{
-        if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
+static int snd_ymfpci_ac3_init(struct snd_ymfpci *chip)
+{
+        if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &chip->pci->dev,
                                 4096, &chip->ac3_tmp_base) < 0)
                 return -ENOMEM;
@@ -641 +633 @@
         int err;
 
-        if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
-                return err;
         if ((err = snd_ymfpci_pcm_voice_alloc(ypcm, params_channels(hw_params))) < 0)
                 return err;
@@ -660 +650 @@
         /* wait, until the PCI operations are not finished */
         snd_ymfpci_irq_wait(chip);
-        snd_pcm_lib_free_pages(substream);
         if (ypcm->voices[1]) {
                 snd_ymfpci_voice_free(chip, ypcm->voices[1]);
@@ -696 +685 @@
 }
 
-static int snd_ymfpci_capture_hw_params(struct snd_pcm_substream *substream,
-                                        struct snd_pcm_hw_params *hw_params)
-{
-        return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
-}
-
 static int snd_ymfpci_capture_hw_free(struct snd_pcm_substream *substream)
 {
@@ -708 +691 @@
         /* wait, until the PCI operations are not finished */
         snd_ymfpci_irq_wait(chip);
-        return snd_pcm_lib_free_pages(substream);
+        return 0;
 }
 
@@ -780 +763 @@
 static void snd_ymfpci_irq_wait(struct snd_ymfpci *chip)
 {
-        wait_queue_t wait;
+        wait_queue_entry_t wait;
         int loops = 4;
 
@@ -844 +827 @@
 }
 
-static struct snd_pcm_hardware snd_ymfpci_playback =
+static const struct snd_pcm_hardware snd_ymfpci_playback =
 {
         .info =                 (SNDRV_PCM_INFO_MMAP |
@@ -866 +849 @@
 };
 
-static struct snd_pcm_hardware snd_ymfpci_capture =
+static const struct snd_pcm_hardware snd_ymfpci_capture =
 {
         .info =                 (SNDRV_PCM_INFO_MMAP |
@@ -898 +881 @@
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct snd_ymfpci_pcm *ypcm;
+        int err;
+
+        runtime->hw = snd_ymfpci_playback;
+        /* FIXME? True value is 256/48 = 5.33333 ms */
+        err = snd_pcm_hw_constraint_minmax(runtime,
+                                           SNDRV_PCM_HW_PARAM_PERIOD_TIME,
+                                           5334, UINT_MAX);
+        if (err < 0)
+                return err;
+        err = snd_pcm_hw_rule_noresample(runtime, 48000);
+        if (err < 0)
+                return err;
 
         ypcm = kzalloc(sizeof(*ypcm), GFP_KERNEL);
@@ -905 +900 @@
         ypcm->type = PLAYBACK_VOICE;
         ypcm->substream = substream;
-        runtime->hw = snd_ymfpci_playback;
         runtime->private_data = ypcm;
         runtime->private_free = snd_ymfpci_pcm_free_substream;
-        /* FIXME? True value is 256/48 = 5.33333 ms */
-        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 5333, UINT_MAX);
         return 0;
 }
@@ -1014 +1006 @@
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct snd_ymfpci_pcm *ypcm;
+        int err;
+
+        runtime->hw = snd_ymfpci_capture;
+        /* FIXME? True value is 256/48 = 5.33333 ms */
+        err = snd_pcm_hw_constraint_minmax(runtime,
+                                           SNDRV_PCM_HW_PARAM_PERIOD_TIME,
+                                           5334, UINT_MAX);
+        if (err < 0)
+                return err;
+        err = snd_pcm_hw_rule_noresample(runtime, 48000);
+        if (err < 0)
+                return err;
 
         ypcm = kzalloc(sizeof(*ypcm), GFP_KERNEL);
@@ -1023 +1027 @@
         ypcm->capture_bank_number = capture_bank_number;
         chip->capture_substream[capture_bank_number] = substream;
-        runtime->hw = snd_ymfpci_capture;
-        /* FIXME? True value is 256/48 = 5.33333 ms */
-        snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_TIME, 5333, UINT_MAX);
         runtime->private_data = ypcm;
         runtime->private_free = snd_ymfpci_pcm_free_substream;
@@ -1104 +1105 @@
 }
 
-static struct snd_pcm_ops snd_ymfpci_playback_ops = {
+static const struct snd_pcm_ops snd_ymfpci_playback_ops = {
         .open =                 snd_ymfpci_playback_open,
         .close =                snd_ymfpci_playback_close,
-        .ioctl =                snd_pcm_lib_ioctl,
         .hw_params =            snd_ymfpci_playback_hw_params,
         .hw_free =              snd_ymfpci_playback_hw_free,
@@ -1115 +1115 @@
 };
 
-static struct snd_pcm_ops snd_ymfpci_capture_rec_ops = {
+static const struct snd_pcm_ops snd_ymfpci_capture_rec_ops = {
         .open =                 snd_ymfpci_capture_rec_open,
         .close =                snd_ymfpci_capture_close,
-        .ioctl =                snd_pcm_lib_ioctl,
-        .hw_params =            snd_ymfpci_capture_hw_params,
         .hw_free =              snd_ymfpci_capture_hw_free,
         .prepare =              snd_ymfpci_capture_prepare,
@@ -1126 +1124 @@
 };
 
-int __devinit snd_ymfpci_pcm(struct snd_ymfpci *chip, int device, struct snd_pcm ** rpcm)
+int snd_ymfpci_pcm(struct snd_ymfpci *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(chip->card, "YMFPCI", device, 32, 1, &pcm)) < 0)
                 return err;
@@ -1145 +1141 @@
         chip->pcm = pcm;
 
-        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                              snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
-
-        if (rpcm)
-                *rpcm = pcm;
-        return 0;
-}
-
-static struct snd_pcm_ops snd_ymfpci_capture_ac97_ops = {
+        snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                       &chip->pci->dev, 64*1024, 256*1024);
+
+        return snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
+                                     snd_pcm_std_chmaps, 2, 0, NULL);
+}
+
+static const struct snd_pcm_ops snd_ymfpci_capture_ac97_ops = {
         .open =                 snd_ymfpci_capture_ac97_open,
         .close =                snd_ymfpci_capture_close,
-        .ioctl =                snd_pcm_lib_ioctl,
-        .hw_params =            snd_ymfpci_capture_hw_params,
         .hw_free =              snd_ymfpci_capture_hw_free,
         .prepare =              snd_ymfpci_capture_prepare,
@@ -1164 +1157 @@
 };
 
-int __devinit snd_ymfpci_pcm2(struct snd_ymfpci *chip, int device, struct snd_pcm ** rpcm)
+int snd_ymfpci_pcm2(struct snd_ymfpci *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(chip->card, "YMFPCI - PCM2", device, 0, 1, &pcm)) < 0)
                 return err;
@@ -1183 +1174 @@
         chip->pcm2 = pcm;
 
-        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                              snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
-
-        if (rpcm)
-                *rpcm = pcm;
-        return 0;
-}
-
-static struct snd_pcm_ops snd_ymfpci_playback_spdif_ops = {
+        snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                       &chip->pci->dev, 64*1024, 256*1024);
+
+        return 0;
+}
+
+static const struct snd_pcm_ops snd_ymfpci_playback_spdif_ops = {
         .open =                 snd_ymfpci_playback_spdif_open,
         .close =                snd_ymfpci_playback_spdif_close,
-        .ioctl =                snd_pcm_lib_ioctl,
         .hw_params =            snd_ymfpci_playback_hw_params,
         .hw_free =              snd_ymfpci_playback_hw_free,
@@ -1202 +1190 @@
 };
 
-int __devinit snd_ymfpci_pcm_spdif(struct snd_ymfpci *chip, int device, struct snd_pcm ** rpcm)
+int snd_ymfpci_pcm_spdif(struct snd_ymfpci *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(chip->card, "YMFPCI - IEC958", device, 1, 0, &pcm)) < 0)
                 return err;
@@ -1220 +1206 @@
         chip->pcm_spdif = pcm;
 
-        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                              snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
-
-        if (rpcm)
-                *rpcm = pcm;
-        return 0;
-}
-
-static struct snd_pcm_ops snd_ymfpci_playback_4ch_ops = {
+        snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                       &chip->pci->dev, 64*1024, 256*1024);
+
+        return 0;
+}
+
+static const struct snd_pcm_ops snd_ymfpci_playback_4ch_ops = {
         .open =                 snd_ymfpci_playback_4ch_open,
         .close =                snd_ymfpci_playback_4ch_close,
-        .ioctl =                snd_pcm_lib_ioctl,
         .hw_params =            snd_ymfpci_playback_hw_params,
         .hw_free =              snd_ymfpci_playback_hw_free,
@@ -1239 +1222 @@
 };
 
-int __devinit snd_ymfpci_pcm_4ch(struct snd_ymfpci *chip, int device, struct snd_pcm ** rpcm)
+static const struct snd_pcm_chmap_elem surround_map[] = {
+        { .channels = 1,
+          .map = { SNDRV_CHMAP_MONO } },
+        { .channels = 2,
+          .map = { SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
+        {0}
+};
+
+int snd_ymfpci_pcm_4ch(struct snd_ymfpci *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(chip->card, "YMFPCI - Rear", device, 1, 0, &pcm)) < 0)
                 return err;
@@ -1257 +1246 @@
         chip->pcm_4ch = pcm;
 
-        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                              snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
-
-        if (rpcm)
-                *rpcm = pcm;
-        return 0;
+        snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                       &chip->pci->dev, 64*1024, 256*1024);
+
+        return snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
+                                     surround_map, 2, 0, NULL);
 }
 
@@ -1303 +1291 @@
 }
 
-static struct snd_kcontrol_new snd_ymfpci_spdif_default __devinitdata =
+static const struct snd_kcontrol_new snd_ymfpci_spdif_default =
 {
         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
@@ -1331 +1319 @@
 }
 
-static struct snd_kcontrol_new snd_ymfpci_spdif_mask __devinitdata =
+static const struct snd_kcontrol_new snd_ymfpci_spdif_mask =
 {
         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
@@ -1378 +1366 @@
 }
 
-static struct snd_kcontrol_new snd_ymfpci_spdif_stream __devinitdata =
+static const struct snd_kcontrol_new snd_ymfpci_spdif_stream =
 {
         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
@@ -1426 +1414 @@
 }
 
-static struct snd_kcontrol_new snd_ymfpci_drec_source __devinitdata = {
+static const struct snd_kcontrol_new snd_ymfpci_drec_source = {
         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE,
         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -1596 +1584 @@
 }
 
-
-static struct snd_kcontrol_new snd_ymfpci_controls[] __devinitdata = {
+static const struct snd_kcontrol_new snd_ymfpci_dup4ch = {
+        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
+        .name = "4ch Duplication",
+        .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
+        .info = snd_ymfpci_info_dup4ch,
+        .get = snd_ymfpci_get_dup4ch,
+        .put = snd_ymfpci_put_dup4ch,
+};
+
+static const struct snd_kcontrol_new snd_ymfpci_controls[] = {
 {
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -1616 +1612 @@
 YMFPCI_DOUBLE("ADC Playback Volume", 1, YDSXGR_SECADCOUTVOL),
 YMFPCI_DOUBLE("ADC Capture Volume", 1, YDSXGR_SECADCLOOPVOL),
-YMFPCI_DOUBLE("FM Legacy Volume", 0, YDSXGR_LEGACYOUTVOL),
+YMFPCI_DOUBLE("FM Legacy Playback Volume", 0, YDSXGR_LEGACYOUTVOL),
 YMFPCI_DOUBLE(SNDRV_CTL_NAME_IEC958("AC97 ", PLAYBACK,VOLUME), 0, YDSXGR_ZVOUTVOL),
 YMFPCI_DOUBLE(SNDRV_CTL_NAME_IEC958("", CAPTURE,VOLUME), 0, YDSXGR_ZVLOOPVOL),
@@ -1624 +1620 @@
 YMFPCI_SINGLE(SNDRV_CTL_NAME_IEC958("",CAPTURE,SWITCH), 0, YDSXGR_SPDIFINCTRL, 0),
 YMFPCI_SINGLE(SNDRV_CTL_NAME_IEC958("Loop",NONE,NONE), 0, YDSXGR_SPDIFINCTRL, 4),
-{
-        .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
-        .name = "4ch Duplication",
-        .info = snd_ymfpci_info_dup4ch,
-        .get = snd_ymfpci_get_dup4ch,
-        .put = snd_ymfpci_put_dup4ch,
-},
 };
 
@@ -1698 +1687 @@
 }
 
-static struct snd_kcontrol_new snd_ymfpci_rear_shared __devinitdata = {
+static const struct snd_kcontrol_new snd_ymfpci_rear_shared = {
         .name = "Shared Rear/Line-In Switch",
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -1762 +1751 @@
 }
 
-static struct snd_kcontrol_new snd_ymfpci_pcm_volume __devinitdata = {
+static const struct snd_kcontrol_new snd_ymfpci_pcm_volume = {
         .iface = SNDRV_CTL_ELEM_IFACE_PCM,
         .name = "PCM Playback Volume",
@@ -1789 +1778 @@
 }
 
-int __devinit snd_ymfpci_mixer(struct snd_ymfpci *chip, int rear_switch)
+int snd_ymfpci_mixer(struct snd_ymfpci *chip, int rear_switch)
 {
         struct snd_ac97_template ac97;
@@ -1796 +1785 @@
         unsigned int idx;
         int err;
-        static struct snd_ac97_bus_ops ops = {
+        static const struct snd_ac97_bus_ops ops = {
                 .write = snd_ymfpci_codec_write,
                 .read = snd_ymfpci_codec_read,
@@ -1818 +1807 @@
         for (idx = 0; idx < ARRAY_SIZE(snd_ymfpci_controls); idx++) {
                 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snd_ymfpci_controls[idx], chip))) < 0)
+                        return err;
+        }
+        if (chip->ac97->ext_id & AC97_EI_SDAC) {
+                kctl = snd_ctl_new1(&snd_ymfpci_dup4ch, chip);
+                err = snd_ctl_add(chip->card, kctl);
+                if (err < 0)
                         return err;
         }
@@ -1918 +1913 @@
 }
 
-static struct snd_timer_hardware snd_ymfpci_timer_hw = {
+static const struct snd_timer_hardware snd_ymfpci_timer_hw = {
         .flags = SNDRV_TIMER_HW_AUTO,
         .resolution = 10417, /* 1 / 96 kHz = 10.41666...us */
@@ -1927 +1922 @@
 };
 
-int __devinit snd_ymfpci_timer(struct snd_ymfpci *chip, int device)
+int snd_ymfpci_timer(struct snd_ymfpci *chip, int device)
 {
         struct snd_timer *timer = NULL;
@@ -1963 +1958 @@
 }
 
-static int __devinit 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;
+static int snd_ymfpci_proc_init(struct snd_card *card, struct snd_ymfpci *chip)
+{
+        return snd_card_ro_proc_new(card, "ymfpci", chip, snd_ymfpci_proc_read);
 }
 
@@ -2023 +2014 @@
         if (err >= 0) {
                 if (chip->dsp_microcode->size != YDSXG_DSPLENGTH) {
-                        snd_printk(KERN_ERR "DSP microcode has wrong size\n");
+                        dev_err(chip->card->dev,
+                                "DSP microcode has wrong size\n");
                         err = -EINVAL;
                 }
@@ -2038 +2030 @@
         if (err >= 0) {
                 if (chip->controller_microcode->size != YDSXG_CTRLLENGTH) {
-                        snd_printk(KERN_ERR "controller microcode"
-                                   " has wrong size\n");
+                        dev_err(chip->card->dev,
+                                "controller microcode has wrong size\n");
                         err = -EINVAL;
                 }
@@ -2085 +2077 @@
 }
 
-static int __devinit snd_ymfpci_memalloc(struct snd_ymfpci *chip)
+static int snd_ymfpci_memalloc(struct snd_ymfpci *chip)
 {
         long size, playback_ctrl_size;
@@ -2105 +2097 @@
         /* work_ptr must be aligned to 256 bytes, but it's already
            covered with the kernel page allocation mechanism */
-        if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
+        if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &chip->pci->dev,
                                 size, &chip->work_ptr) < 0) 
                 return -ENOMEM;
@@ -2114 +2106 @@
         chip->bank_base_playback = ptr;
         chip->bank_base_playback_addr = ptr_addr;
-        chip->ctrl_playback = (u32 *)ptr;
+        chip->ctrl_playback = (__le32 *)ptr;
         chip->ctrl_playback[0] = cpu_to_le32(YDSXG_PLAYBACK_VOICES);
         ptr += ALIGN(playback_ctrl_size, 0x100);
@@ -2214 +2206 @@
          * the chip again unless reboot.  ACPI bug?
          */
-        pci_set_power_state(chip->pci, 3);
+        pci_set_power_state(chip->pci, PCI_D3hot);
 #endif
 
-#ifdef CONFIG_PM
-        vfree(chip->saved_regs);
+#ifdef CONFIG_PM_SLEEP
+        kfree(chip->saved_regs);
 #endif
         if (chip->irq >= 0)
@@ -2225 +2217 @@
         release_and_free_resource(chip->fm_res);
         snd_ymfpci_free_gameport(chip);
-        if (chip->reg_area_virt)
-                iounmap(chip->reg_area_virt);
+        iounmap(chip->reg_area_virt);
         if (chip->work_ptr.area)
                 snd_dma_free_pages(&chip->work_ptr);
@@ -2247 +2238 @@
 }
 
-#ifdef CONFIG_PM
-static int saved_regs_index[] = {
+#ifdef CONFIG_PM_SLEEP
+static const int saved_regs_index[] = {
         /* spdif */
         YDSXGR_SPDIFOUTCTRL,
@@ -2277 +2268 @@
 #define YDSXGR_NUM_SAVED_REGS   ARRAY_SIZE(saved_regs_index)
 
-int snd_ymfpci_suspend(struct pci_dev *pci, pm_message_t state)
-{
-        struct snd_card *card = pci_get_drvdata(pci);
+static int snd_ymfpci_suspend(struct device *dev)
+{
+        struct snd_card *card = dev_get_drvdata(dev);
         struct snd_ymfpci *chip = card->private_data;
         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]);
         chip->saved_ydsxgr_mode = snd_ymfpci_readl(chip, YDSXGR_MODE);
+        pci_read_config_word(chip->pci, PCIR_DSXG_LEGACY,
+                             &chip->saved_dsxg_legacy);
+        pci_read_config_word(chip->pci, PCIR_DSXG_ELEGACY,
+                             &chip->saved_dsxg_elegacy);
         snd_ymfpci_writel(chip, YDSXGR_NATIVEDACOUTVOL, 0);
         snd_ymfpci_writel(chip, YDSXGR_BUF441OUTVOL, 0);
         snd_ymfpci_disable_dsp(chip);
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, pci_choose_state(pci, state));
-        return 0;
-}
-
-int snd_ymfpci_resume(struct pci_dev *pci)
-{
-        struct snd_card *card = pci_get_drvdata(pci);
+        return 0;
+}
+
+static int snd_ymfpci_resume(struct device *dev)
+{
+        struct pci_dev *pci = to_pci_dev(dev);
+        struct snd_card *card = dev_get_drvdata(dev);
         struct snd_ymfpci *chip = card->private_data;
         unsigned int i;
 
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "ymfpci: pci_enable_device failed, "
-                       "disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
         snd_ymfpci_aclink_reset(pci);
         snd_ymfpci_codec_ready(chip, 0);
@@ -2325 +2305 @@
 
         snd_ac97_resume(chip->ac97);
+
+        pci_write_config_word(chip->pci, PCIR_DSXG_LEGACY,
+                              chip->saved_dsxg_legacy);
+        pci_write_config_word(chip->pci, PCIR_DSXG_ELEGACY,
+                              chip->saved_dsxg_elegacy);
 
         /* start hw again */
@@ -2336 +2321 @@
         return 0;
 }
-#endif /* CONFIG_PM */
-
-int __devinit snd_ymfpci_create(struct snd_card *card,
-                                struct pci_dev * pci,
-                                unsigned short old_legacy_ctrl,
-                                struct snd_ymfpci ** rchip)
+
+SIMPLE_DEV_PM_OPS(snd_ymfpci_pm, snd_ymfpci_suspend, snd_ymfpci_resume);
+#endif /* CONFIG_PM_SLEEP */
+
+int snd_ymfpci_create(struct snd_card *card,
+                      struct pci_dev *pci,
+                      unsigned short old_legacy_ctrl,
+                      struct snd_ymfpci **rchip)
 {
         struct snd_ymfpci *chip;
         int err;
-        static struct snd_device_ops ops = {
+        static const struct snd_device_ops ops = {
                 .dev_free =     snd_ymfpci_dev_free,
         };
@@ -2369 +2356 @@
         chip->irq = -1;
         chip->device_id = pci->device;
-#ifndef TARGET_OS2
         chip->rev = pci->revision;
-#else
-        chip->rev = snd_pci_revision(pci);
-#endif
         chip->reg_area_phys = pci_resource_start(pci, 0);
-        chip->reg_area_virt = ioremap_nocache(chip->reg_area_phys, 0x8000);
+        chip->reg_area_virt = ioremap(chip->reg_area_phys, 0x8000);
         pci_set_master(pci);
         chip->src441_used = -1;
 
         if ((chip->res_reg_area = request_mem_region(chip->reg_area_phys, 0x8000, "YMFPCI")) == NULL) {
-                snd_printk(KERN_ERR "unable to grab memory region 0x%lx-0x%lx\n", chip->reg_area_phys, chip->reg_area_phys + 0x8000 - 1);
-                snd_ymfpci_free(chip);
-                return -EBUSY;
+                dev_err(chip->card->dev,
+                        "unable to grab memory region 0x%lx-0x%lx\n",
+                        chip->reg_area_phys, chip->reg_area_phys + 0x8000 - 1);
+                err = -EBUSY;
+                goto free_chip;
         }
         if (request_irq(pci->irq, snd_ymfpci_interrupt, IRQF_SHARED,
-                        "YMFPCI", chip)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
-                snd_ymfpci_free(chip);
-                return -EBUSY;
+                        KBUILD_MODNAME, chip)) {
+                dev_err(chip->card->dev, "unable to grab IRQ %d\n", pci->irq);
+                err = -EBUSY;
+                goto free_chip;
         }
         chip->irq = pci->irq;
+        card->sync_irq = chip->irq;
 
         snd_ymfpci_aclink_reset(pci);
         if (snd_ymfpci_codec_ready(chip, 0) < 0) {
-                snd_ymfpci_free(chip);
-                return -EIO;
+                err = -EIO;
+                goto free_chip;
         }
 
         err = snd_ymfpci_request_firmware(chip);
         if (err < 0) {
-                snd_printk(KERN_ERR "firmware request failed: %d\n", err);
-                snd_ymfpci_free(chip);
-                return err;
+                dev_err(chip->card->dev, "firmware request failed: %d\n", err);
+                goto free_chip;
         }
         snd_ymfpci_download_image(chip);
@@ -2409 +2394 @@
 
         if (snd_ymfpci_memalloc(chip) < 0) {
-                snd_ymfpci_free(chip);
-                return -EIO;
-        }
-
-        if ((err = snd_ymfpci_ac3_init(chip)) < 0) {
-                snd_ymfpci_free(chip);
-                return err;
-        }
-
-#ifdef CONFIG_PM
-        chip->saved_regs = vmalloc(YDSXGR_NUM_SAVED_REGS * sizeof(u32));
+                err = -EIO;
+                goto free_chip;
+        }
+
+        err = snd_ymfpci_ac3_init(chip);
+        if (err < 0)
+                goto free_chip;
+
+#ifdef CONFIG_PM_SLEEP
+        chip->saved_regs = kmalloc_array(YDSXGR_NUM_SAVED_REGS, sizeof(u32),
+                                         GFP_KERNEL);
         if (chip->saved_regs == NULL) {
-                snd_ymfpci_free(chip);
-                return -ENOMEM;
+                err = -ENOMEM;
+                goto free_chip;
         }
 #endif
 
-        if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
-                snd_ymfpci_free(chip);
-                return err;
-        }
+        err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
+        if (err < 0)
+                goto free_chip;
 
         snd_ymfpci_proc_init(card, chip);
 
-        snd_card_set_dev(card, &pci->dev);
-
         *rchip = chip;
         return 0;
-}
+
+free_chip:
+        snd_ymfpci_free(chip);
+        return err;
+}