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

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/cs46xx/cs46xx.c (modified) (11 diffs)
• alsa-kernel/pci/cs46xx/cs46xx.h (copied) (copied from GPL/branches/uniaud32-next/alsa-kernel/pci/cs46xx/cs46xx.h )
• alsa-kernel/pci/cs46xx/cs46xx_dsp_scb_types.h (copied) (copied from GPL/branches/uniaud32-next/alsa-kernel/pci/cs46xx/cs46xx_dsp_scb_types.h )
• alsa-kernel/pci/cs46xx/cs46xx_dsp_spos.h (copied) (copied from GPL/branches/uniaud32-next/alsa-kernel/pci/cs46xx/cs46xx_dsp_spos.h )
• alsa-kernel/pci/cs46xx/cs46xx_dsp_task_types.h (copied) (copied from GPL/branches/uniaud32-next/alsa-kernel/pci/cs46xx/cs46xx_dsp_task_types.h )
• alsa-kernel/pci/cs46xx/cs46xx_lib.c (modified) (104 diffs)
• alsa-kernel/pci/cs46xx/cs46xx_lib.h (modified) (3 diffs)
• alsa-kernel/pci/cs46xx/dsp_spos.c (modified) (49 diffs)
• alsa-kernel/pci/cs46xx/dsp_spos.h (modified) (1 diff)
• alsa-kernel/pci/cs46xx/dsp_spos_scb_lib.c (modified) (29 diffs)

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

@@ +1 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
 /*
  *  The driver for the Cirrus Logic's Sound Fusion CS46XX based soundcards
  *  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
- *
  */
 
@@ -26 +11 @@
 */
 
+#ifdef TARGET_OS2
+#define KBUILD_MODNAME "cs46xx"
+#endif
 #include <linux/pci.h>
 #include <linux/time.h>
 #include <linux/init.h>
-#include <linux/moduleparam.h>
+#include <linux/module.h>
 #include <sound/core.h>
-#include <sound/cs46xx.h>
+#include "cs46xx.h"
 #include <sound/initval.h>
 
@@ -47 +35 @@
 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 int external_amp[SNDRV_CARDS];
-static int thinkpad[SNDRV_CARDS];
+static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;     /* Enable this card */
+static bool external_amp[SNDRV_CARDS];
+static bool thinkpad[SNDRV_CARDS];
 #ifndef TARGET_OS2
-static int mmap_valid[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};
+static bool mmap_valid[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 1};
 #else
-static int mmap_valid[SNDRV_CARDS] = {1,1,1,1,1,1,1,1};
+static bool mmap_valid[SNDRV_CARDS] = {1,1,1,1,1,1,1,1};
 #endif
+
 module_param_array(index, int, NULL, 0444);
 MODULE_PARM_DESC(index, "Index value for the CS46xx soundcard.");
@@ -62 +51 @@
 MODULE_PARM_DESC(enable, "Enable CS46xx soundcard.");
 module_param_array(external_amp, bool, NULL, 0444);
-MODULE_PARM_DESC(external_amp, "Force to enable external amplifer.");
+MODULE_PARM_DESC(external_amp, "Force to enable external amplifier.");
 module_param_array(thinkpad, bool, NULL, 0444);
 MODULE_PARM_DESC(thinkpad, "Force to enable Thinkpad's CLKRUN control.");
@@ -68 +57 @@
 MODULE_PARM_DESC(mmap_valid, "Support OSS mmap.");
 
-static DEFINE_PCI_DEVICE_TABLE(snd_cs46xx_ids) = {
+static const struct pci_device_id snd_cs46xx_ids[] = {
         { PCI_VDEVICE(CIRRUS, 0x6001), 0, },   /* CS4280 */
         { PCI_VDEVICE(CIRRUS, 0x6003), 0, },   /* CS4612 */
@@ -77 +66 @@
 MODULE_DEVICE_TABLE(pci, snd_cs46xx_ids);
 
-static int __devinit snd_card_cs46xx_probe(struct pci_dev *pci,
-                                           const struct pci_device_id *pci_id)
+static int snd_card_cs46xx_probe(struct pci_dev *pci,
+                                 const struct pci_device_id *pci_id)
 {
         static int dev;
@@ -92 +81 @@
         }
 
-        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;
@@ -103 +93 @@
         card->private_data = chip;
         chip->accept_valid = mmap_valid[dev];
-        if ((err = snd_cs46xx_pcm(chip, 0, NULL)) < 0) {
+        if ((err = snd_cs46xx_pcm(chip, 0)) < 0) {
                 snd_card_free(card);
                 return err;
         }
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
-        if ((err = snd_cs46xx_pcm_rear(chip,1, NULL)) < 0) {
+        if ((err = snd_cs46xx_pcm_rear(chip, 1)) < 0) {
                 snd_card_free(card);
                 return err;
         }
-        if ((err = snd_cs46xx_pcm_iec958(chip,2,NULL)) < 0) {
+        if ((err = snd_cs46xx_pcm_iec958(chip, 2)) < 0) {
                 snd_card_free(card);
                 return err;
@@ -123 +113 @@
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
         if (chip->nr_ac97_codecs ==2) {
-                if ((err = snd_cs46xx_pcm_center_lfe(chip,3,NULL)) < 0) {
+                if ((err = snd_cs46xx_pcm_center_lfe(chip, 3)) < 0) {
                         snd_card_free(card);
                         return err;
@@ -129 +119 @@
         }
 #endif
-        if ((err = snd_cs46xx_midi(chip, 0, NULL)) < 0) {
+        if ((err = snd_cs46xx_midi(chip, 0)) < 0) {
                 snd_card_free(card);
                 return err;
@@ -159 +149 @@
 }
 
-static void __devexit snd_card_cs46xx_remove(struct pci_dev *pci)
+static void snd_card_cs46xx_remove(struct pci_dev *pci)
 {
         snd_card_free(pci_get_drvdata(pci));
-        pci_set_drvdata(pci, NULL);
 }
 
-static struct pci_driver driver = {
-        .name = "Sound Fusion CS46xx",
+static struct pci_driver cs46xx_driver = {
+        .name = KBUILD_MODNAME,
         .id_table = snd_cs46xx_ids,
         .probe = snd_card_cs46xx_probe,
-        .remove = __devexit_p(snd_card_cs46xx_remove),
-#ifdef CONFIG_PM
-        .suspend = snd_cs46xx_suspend,
-        .resume = snd_cs46xx_resume,
+        .remove = snd_card_cs46xx_remove,
+#ifdef CONFIG_PM_SLEEP
+        .driver = {
+                .pm = &snd_cs46xx_pm,
+        },
 #endif
 };
 
-static int __init alsa_card_cs46xx_init(void)
-{
-        return pci_register_driver(&driver);
-}
-
-static void __exit alsa_card_cs46xx_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-
-module_init(alsa_card_cs46xx_init)
-module_exit(alsa_card_cs46xx_exit)
+module_pci_driver(cs46xx_driver);

GPL/trunk/alsa-kernel/pci/cs46xx/cs46xx_lib.c

@@ +1 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
 /*
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
@@ -29 +30 @@
  *           supported by the cs46xx DSP's. 
  *           Benny <benny@hostmobility.com>
- *                
- *   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 "cs46xx"
+#endif
 
 #include <linux/delay.h>
@@ -54 +44 @@
 #include <linux/gameport.h>
 #include <linux/mutex.h>
-
+#include <linux/export.h>
+#include <linux/module.h>
+#include <linux/firmware.h>
+#include <linux/vmalloc.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
@@ -61 +55 @@
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
-#include <sound/cs46xx.h>
-
-#include <asm/io.h>
+#include "cs46xx.h"
 
 #include "cs46xx_lib.h"
@@ -71 +63 @@
 
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
-static struct snd_pcm_ops snd_cs46xx_playback_rear_ops;
-static struct snd_pcm_ops snd_cs46xx_playback_indirect_rear_ops;
-static struct snd_pcm_ops snd_cs46xx_playback_clfe_ops;
-static struct snd_pcm_ops snd_cs46xx_playback_indirect_clfe_ops;
-static struct snd_pcm_ops snd_cs46xx_playback_iec958_ops;
-static struct snd_pcm_ops snd_cs46xx_playback_indirect_iec958_ops;
-#endif
-
-static struct snd_pcm_ops snd_cs46xx_playback_ops;
-static struct snd_pcm_ops snd_cs46xx_playback_indirect_ops;
-static struct snd_pcm_ops snd_cs46xx_capture_ops;
-static struct snd_pcm_ops snd_cs46xx_capture_indirect_ops;
+static const struct snd_pcm_ops snd_cs46xx_playback_rear_ops;
+static const struct snd_pcm_ops snd_cs46xx_playback_indirect_rear_ops;
+static const struct snd_pcm_ops snd_cs46xx_playback_clfe_ops;
+static const struct snd_pcm_ops snd_cs46xx_playback_indirect_clfe_ops;
+static const struct snd_pcm_ops snd_cs46xx_playback_iec958_ops;
+static const struct snd_pcm_ops snd_cs46xx_playback_indirect_iec958_ops;
+#endif
+
+static const struct snd_pcm_ops snd_cs46xx_playback_ops;
+static const struct snd_pcm_ops snd_cs46xx_playback_indirect_ops;
+static const struct snd_pcm_ops snd_cs46xx_capture_ops;
+static const struct snd_pcm_ops snd_cs46xx_capture_indirect_ops;
 
 static unsigned short snd_cs46xx_codec_read(struct snd_cs46xx *chip,
@@ -94 +86 @@
         if (snd_BUG_ON(codec_index != CS46XX_PRIMARY_CODEC_INDEX &&
                        codec_index != CS46XX_SECONDARY_CODEC_INDEX))
-                return -EINVAL;
+                return 0xffff;
 
         chip->active_ctrl(chip, 1);
@@ -114 +106 @@
         tmp = snd_cs46xx_peekBA0(chip, BA0_ACCTL);
         if ((tmp & ACCTL_VFRM) == 0) {
-                snd_printk(KERN_WARNING  "cs46xx: ACCTL_VFRM not set 0x%x\n",tmp);
+                dev_warn(chip->card->dev, "ACCTL_VFRM not set 0x%x\n", tmp);
                 snd_cs46xx_pokeBA0(chip, BA0_ACCTL, (tmp & (~ACCTL_ESYN)) | ACCTL_VFRM );
                 msleep(50);
@@ -166 +158 @@
         }
 
-        snd_printk(KERN_ERR "AC'97 read problem (ACCTL_DCV), reg = 0x%x\n", reg);
+        dev_err(chip->card->dev,
+                "AC'97 read problem (ACCTL_DCV), reg = 0x%x\n", reg);
         result = 0xffff;
         goto end;
@@ -185 +178 @@
         }
         
-        snd_printk(KERN_ERR "AC'97 read problem (ACSTS_VSTS), codec_index %d, reg = 0x%x\n", codec_index, reg);
+        dev_err(chip->card->dev,
+                "AC'97 read problem (ACSTS_VSTS), codec_index %d, reg = 0x%x\n",
+                codec_index, reg);
         result = 0xffff;
         goto end;
@@ -195 +190 @@
          */
 #if 0
-        printk(KERN_DEBUG "e) reg = 0x%x, val = 0x%x, BA0_ACCAD = 0x%x\n", reg,
+        dev_dbg(chip->card->dev,
+                "e) reg = 0x%x, val = 0x%x, BA0_ACCAD = 0x%x\n", reg,
                         snd_cs46xx_peekBA0(chip, BA0_ACSDA),
                         snd_cs46xx_peekBA0(chip, BA0_ACCAD));
@@ -284 +280 @@
                 }
         }
-        snd_printk(KERN_ERR "AC'97 write problem, codec_index = %d, reg = 0x%x, val = 0x%x\n", codec_index, reg, val);
+        dev_err(chip->card->dev,
+                "AC'97 write problem, codec_index = %d, reg = 0x%x, val = 0x%x\n",
+                codec_index, reg, val);
  end:
         chip->active_ctrl(chip, -1);
@@ -330 +328 @@
 }
 
-#ifdef CONFIG_SND_CS46XX_NEW_DSP
-
-#include "imgs/cwc4630.h"
-#include "imgs/cwcasync.h"
-#include "imgs/cwcsnoop.h"
-#include "imgs/cwcbinhack.h"
-#include "imgs/cwcdma.h"
+static inline void memcpy_le32(void *dst, const void *src, unsigned int len)
+{
+#ifdef __LITTLE_ENDIAN
+        memcpy(dst, src, len);
+#else
+        u32 *_dst = dst;
+        const __le32 *_src = src;
+        len /= 4;
+        while (len-- > 0)
+                *_dst++ = le32_to_cpu(*_src++);
+#endif
+}
+
+#ifdef CONFIG_SND_CS46XX_NEW_DSP
+
+static const char *module_names[CS46XX_DSP_MODULES] = {
+        "cwc4630", "cwcasync", "cwcsnoop", "cwcbinhack", "cwcdma"
+};
+
+MODULE_FIRMWARE("cs46xx/cwc4630");
+MODULE_FIRMWARE("cs46xx/cwcasync");
+MODULE_FIRMWARE("cs46xx/cwcsnoop");
+MODULE_FIRMWARE("cs46xx/cwcbinhack");
+MODULE_FIRMWARE("cs46xx/cwcdma");
+
+static void free_module_desc(struct dsp_module_desc *module)
+{
+        if (!module)
+                return;
+        kfree(module->module_name);
+        kfree(module->symbol_table.symbols);
+        if (module->segments) {
+                int i;
+                for (i = 0; i < module->nsegments; i++)
+                        kfree(module->segments[i].data);
+                kfree(module->segments);
+        }
+        kfree(module);
+}
+
+/* firmware binary format:
+ * le32 nsymbols;
+ * struct {
+ *      le32 address;
+ *      char symbol_name[DSP_MAX_SYMBOL_NAME];
+ *      le32 symbol_type;
+ * } symbols[nsymbols];
+ * le32 nsegments;
+ * struct {
+ *      le32 segment_type;
+ *      le32 offset;
+ *      le32 size;
+ *      le32 data[size];
+ * } segments[nsegments];
+ */
+
+static int load_firmware(struct snd_cs46xx *chip,
+                         struct dsp_module_desc **module_ret,
+                         const char *fw_name)
+{
+        int i, err;
+        unsigned int nums, fwlen, fwsize;
+        const __le32 *fwdat;
+        struct dsp_module_desc *module = NULL;
+        const struct firmware *fw;
+        char fw_path[32];
+
+        sprintf(fw_path, "cs46xx/%s", fw_name);
+        err = request_firmware(&fw, fw_path, &chip->pci->dev);
+        if (err < 0)
+                return err;
+        fwsize = fw->size / 4;
+        if (fwsize < 2) {
+                err = -EINVAL;
+                goto error;
+        }
+
+        err = -ENOMEM;
+        module = kzalloc(sizeof(*module), GFP_KERNEL);
+        if (!module)
+                goto error;
+        module->module_name = kstrdup(fw_name, GFP_KERNEL);
+        if (!module->module_name)
+                goto error;
+
+        fwlen = 0;
+        fwdat = (const __le32 *)fw->data;
+        nums = module->symbol_table.nsymbols = le32_to_cpu(fwdat[fwlen++]);
+        if (nums >= 40)
+                goto error_inval;
+        module->symbol_table.symbols =
+                kcalloc(nums, sizeof(struct dsp_symbol_entry), GFP_KERNEL);
+        if (!module->symbol_table.symbols)
+                goto error;
+        for (i = 0; i < nums; i++) {
+                struct dsp_symbol_entry *entry =
+                        &module->symbol_table.symbols[i];
+                if (fwlen + 2 + DSP_MAX_SYMBOL_NAME / 4 > fwsize)
+                        goto error_inval;
+                entry->address = le32_to_cpu(fwdat[fwlen++]);
+                memcpy(entry->symbol_name, &fwdat[fwlen], DSP_MAX_SYMBOL_NAME - 1);
+                fwlen += DSP_MAX_SYMBOL_NAME / 4;
+                entry->symbol_type = le32_to_cpu(fwdat[fwlen++]);
+        }
+
+        if (fwlen >= fwsize)
+                goto error_inval;
+        nums = module->nsegments = le32_to_cpu(fwdat[fwlen++]);
+        if (nums > 10)
+                goto error_inval;
+        module->segments =
+                kcalloc(nums, sizeof(struct dsp_segment_desc), GFP_KERNEL);
+        if (!module->segments)
+                goto error;
+        for (i = 0; i < nums; i++) {
+                struct dsp_segment_desc *entry = &module->segments[i];
+                if (fwlen + 3 > fwsize)
+                        goto error_inval;
+                entry->segment_type = le32_to_cpu(fwdat[fwlen++]);
+                entry->offset = le32_to_cpu(fwdat[fwlen++]);
+                entry->size = le32_to_cpu(fwdat[fwlen++]);
+                if (fwlen + entry->size > fwsize)
+                        goto error_inval;
+                entry->data = kmalloc_array(entry->size, 4, GFP_KERNEL);
+                if (!entry->data)
+                        goto error;
+                memcpy_le32(entry->data, &fwdat[fwlen], entry->size * 4);
+                fwlen += entry->size;
+        }
+
+        *module_ret = module;
+        release_firmware(fw);
+        return 0;
+
+ error_inval:
+        err = -EINVAL;
+ error:
+        free_module_desc(module);
+        release_firmware(fw);
+        return err;
+}
 
 int snd_cs46xx_clear_BA1(struct snd_cs46xx *chip,
@@ -361 +493 @@
 #else /* old DSP image */
 
-#include "cs46xx_image.h"
+struct ba1_struct {
+        struct {
+                u32 offset;
+                u32 size;
+        } memory[BA1_MEMORY_COUNT];
+        u32 map[BA1_DWORD_SIZE];
+};
+
+MODULE_FIRMWARE("cs46xx/ba1");
+
+static int load_firmware(struct snd_cs46xx *chip)
+{
+        const struct firmware *fw;
+        int i, size, err;
+
+        err = request_firmware(&fw, "cs46xx/ba1", &chip->pci->dev);
+        if (err < 0)
+                return err;
+        if (fw->size != sizeof(*chip->ba1)) {
+                err = -EINVAL;
+                goto error;
+        }
+
+        chip->ba1 = vmalloc(sizeof(*chip->ba1));
+        if (!chip->ba1) {
+                err = -ENOMEM;
+                goto error;
+        }
+
+        memcpy_le32(chip->ba1, fw->data, sizeof(*chip->ba1));
+
+        /* sanity check */
+        size = 0;
+        for (i = 0; i < BA1_MEMORY_COUNT; i++)
+                size += chip->ba1->memory[i].size;
+        if (size > BA1_DWORD_SIZE * 4)
+                err = -EINVAL;
+
+ error:
+        release_firmware(fw);
+        return err;
+}
 
 int snd_cs46xx_download_image(struct snd_cs46xx *chip)
 {
         int idx, err;
-        unsigned long offset = 0;
+        unsigned int offset = 0;
+        struct ba1_struct *ba1 = chip->ba1;
 
         for (idx = 0; idx < BA1_MEMORY_COUNT; idx++) {
-                if ((err = snd_cs46xx_download(chip,
-                                               &BA1Struct.map[offset],
-                                               BA1Struct.memory[idx].offset,
-                                               BA1Struct.memory[idx].size)) < 0)
+                err = snd_cs46xx_download(chip,
+                                          &ba1->map[offset],
+                                          ba1->memory[idx].offset,
+                                          ba1->memory[idx].size);
+                if (err < 0)
                         return err;
-                offset += BA1Struct.memory[idx].size >> 2;
+                offset += ba1->memory[idx].size >> 2;
         }       
         return 0;
@@ -429 +604 @@
   
         if(status & SERBST_WBSY) {
-                snd_printk(KERN_ERR "cs46xx: failure waiting for "
-                           "FIFO command to complete\n");
+                dev_err(chip->card->dev,
+                        "failure waiting for FIFO command to complete\n");
                 return -EINVAL;
         }
@@ -467 +642 @@
                  */
                 if (cs46xx_wait_for_fifo(chip,1)) {
-                        snd_printdd ("failed waiting for FIFO at addr (%02X)\n",idx);
+                        dev_dbg(chip->card->dev,
+                                "failed waiting for FIFO at addr (%02X)\n",
+                                idx);
 
                         if (powerdown)
@@ -515 +692 @@
 
         if (snd_cs46xx_peek(chip, BA1_SPCR) & SPCR_RUNFR)
-                snd_printk(KERN_ERR "SPCR_RUNFR never reset\n");
+                dev_err(chip->card->dev, "SPCR_RUNFR never reset\n");
 }
 
@@ -594 +771 @@
 
         /*
-         *  We can not capture at at rate greater than the Input Rate (48000).
+         *  We can not capture at a rate greater than the Input Rate (48000).
          *  Return an error if an attempt is made to stray outside that limit.
          */
@@ -701 +878 @@
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct snd_cs46xx_pcm * cpcm = runtime->private_data;
-        snd_pcm_indirect_playback_transfer(substream, &cpcm->pcm_rec, snd_cs46xx_pb_trans_copy);
-        return 0;
+        return snd_pcm_indirect_playback_transfer(substream, &cpcm->pcm_rec,
+                                                  snd_cs46xx_pb_trans_copy);
 }
 
@@ -717 +894 @@
 {
         struct snd_cs46xx *chip = snd_pcm_substream_chip(substream);
-        snd_pcm_indirect_capture_transfer(substream, &chip->capt.pcm_rec, snd_cs46xx_cp_trans_copy);
-        return 0;
+        return snd_pcm_indirect_capture_transfer(substream, &chip->capt.pcm_rec,
+                                                 snd_cs46xx_cp_trans_copy);
 }
 
@@ -875 +1052 @@
                                                                    cpcm, cpcm->hw_buf.addr,cpcm->pcm_channel_id);
                 if (cpcm->pcm_channel == NULL) {
-                        snd_printk(KERN_ERR "cs46xx: failed to create virtual PCM channel\n");
+                        dev_err(chip->card->dev,
+                                "failed to create virtual PCM channel\n");
                         return -ENOMEM;
                 }
@@ -888 +1066 @@
                                                                          cpcm->hw_buf.addr,
                                                                          cpcm->pcm_channel_id)) == NULL) {
-                        snd_printk(KERN_ERR "cs46xx: failed to re-create virtual PCM channel\n");
+                        dev_err(chip->card->dev,
+                                "failed to re-create virtual PCM channel\n");
                         return -ENOMEM;
                 }
@@ -937 +1116 @@
          }
 
-        snd_printdd ("period_size (%d), periods (%d) buffer_size(%d)\n",
+        dev_dbg(chip->card->dev,
+                "period_size (%d), periods (%d) buffer_size(%d)\n",
                      period_size, params_periods(hw_params),
                      params_buffer_bytes(hw_params));
@@ -1249 +1429 @@
 }
 
-static struct snd_pcm_hardware snd_cs46xx_playback =
+static const struct snd_pcm_hardware snd_cs46xx_playback =
 {
         .info =                 (SNDRV_PCM_INFO_MMAP |
                                  SNDRV_PCM_INFO_INTERLEAVED | 
                                  SNDRV_PCM_INFO_BLOCK_TRANSFER /*|*/
-                                 /*SNDRV_PCM_INFO_RESUME*/),
+                                 /*SNDRV_PCM_INFO_RESUME*/ |
+                                 SNDRV_PCM_INFO_SYNC_APPLPTR),
         .formats =              (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_U8 |
                                  SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S16_BE |
@@ -1271 +1452 @@
 };
 
-static struct snd_pcm_hardware snd_cs46xx_capture =
+static const struct snd_pcm_hardware snd_cs46xx_capture =
 {
         .info =                 (SNDRV_PCM_INFO_MMAP |
                                  SNDRV_PCM_INFO_INTERLEAVED |
                                  SNDRV_PCM_INFO_BLOCK_TRANSFER /*|*/
-                                 /*SNDRV_PCM_INFO_RESUME*/),
+                                 /*SNDRV_PCM_INFO_RESUME*/ |
+                                 SNDRV_PCM_INFO_SYNC_APPLPTR),
         .formats =              SNDRV_PCM_FMTBIT_S16_LE,
         .rates =                SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
@@ -1293 +1475 @@
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
 
-static unsigned int period_sizes[] = { 32, 64, 128, 256, 512, 1024, 2048 };
-
-static struct snd_pcm_hw_constraint_list hw_constraints_period_sizes = {
+static const unsigned int period_sizes[] = { 32, 64, 128, 256, 512, 1024, 2048 };
+
+static const struct snd_pcm_hw_constraint_list hw_constraints_period_sizes = {
         .count = ARRAY_SIZE(period_sizes),
         .list = period_sizes,
@@ -1317 +1499 @@
         if (cpcm == NULL)
                 return -ENOMEM;
-        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,
                                 PAGE_SIZE, &cpcm->hw_buf) < 0) {
                 kfree(cpcm);
@@ -1352 +1534 @@
 static int snd_cs46xx_playback_open(struct snd_pcm_substream *substream)
 {
-        snd_printdd("open front channel\n");
+        dev_dbg(substream->pcm->card->dev, "open front channel\n");
         return _cs46xx_playback_open_channel(substream,DSP_PCM_MAIN_CHANNEL);
 }
@@ -1359 +1541 @@
 static int snd_cs46xx_playback_open_rear(struct snd_pcm_substream *substream)
 {
-        snd_printdd("open rear channel\n");
-
+        dev_dbg(substream->pcm->card->dev, "open rear channel\n");
         return _cs46xx_playback_open_channel(substream,DSP_PCM_REAR_CHANNEL);
 }
@@ -1366 +1547 @@
 static int snd_cs46xx_playback_open_clfe(struct snd_pcm_substream *substream)
 {
-        snd_printdd("open center - LFE channel\n");
-
+        dev_dbg(substream->pcm->card->dev, "open center - LFE channel\n");
         return _cs46xx_playback_open_channel(substream,DSP_PCM_CENTER_LFE_CHANNEL);
 }
@@ -1375 +1555 @@
         struct snd_cs46xx *chip = snd_pcm_substream_chip(substream);
 
-        snd_printdd("open raw iec958 channel\n");
+        dev_dbg(chip->card->dev, "open raw iec958 channel\n");
 
         mutex_lock(&chip->spos_mutex);
@@ -1391 +1571 @@
         struct snd_cs46xx *chip = snd_pcm_substream_chip(substream);
   
-        snd_printdd("close raw iec958 channel\n");
+        dev_dbg(chip->card->dev, "close raw iec958 channel\n");
 
         err = snd_cs46xx_playback_close(substream);
@@ -1407 +1587 @@
         struct snd_cs46xx *chip = snd_pcm_substream_chip(substream);
 
-        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,
                                 PAGE_SIZE, &chip->capt.hw_buf) < 0)
                 return -ENOMEM;
@@ -1467 +1647 @@
 
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
-static struct snd_pcm_ops snd_cs46xx_playback_rear_ops = {
+static const struct snd_pcm_ops snd_cs46xx_playback_rear_ops = {
         .open =                 snd_cs46xx_playback_open_rear,
         .close =                snd_cs46xx_playback_close,
-        .ioctl =                snd_pcm_lib_ioctl,
         .hw_params =            snd_cs46xx_playback_hw_params,
         .hw_free =              snd_cs46xx_playback_hw_free,
@@ -1478 +1657 @@
 };
 
-static struct snd_pcm_ops snd_cs46xx_playback_indirect_rear_ops = {
+static const struct snd_pcm_ops snd_cs46xx_playback_indirect_rear_ops = {
         .open =                 snd_cs46xx_playback_open_rear,
         .close =                snd_cs46xx_playback_close,
-        .ioctl =                snd_pcm_lib_ioctl,
         .hw_params =            snd_cs46xx_playback_hw_params,
         .hw_free =              snd_cs46xx_playback_hw_free,
@@ -1490 +1668 @@
 };
 
-static struct snd_pcm_ops snd_cs46xx_playback_clfe_ops = {
+static const struct snd_pcm_ops snd_cs46xx_playback_clfe_ops = {
         .open =                 snd_cs46xx_playback_open_clfe,
         .close =                snd_cs46xx_playback_close,
-        .ioctl =                snd_pcm_lib_ioctl,
         .hw_params =            snd_cs46xx_playback_hw_params,
         .hw_free =              snd_cs46xx_playback_hw_free,
@@ -1501 +1678 @@
 };
 
-static struct snd_pcm_ops snd_cs46xx_playback_indirect_clfe_ops = {
+static const struct snd_pcm_ops snd_cs46xx_playback_indirect_clfe_ops = {
         .open =                 snd_cs46xx_playback_open_clfe,
         .close =                snd_cs46xx_playback_close,
-        .ioctl =                snd_pcm_lib_ioctl,
         .hw_params =            snd_cs46xx_playback_hw_params,
         .hw_free =              snd_cs46xx_playback_hw_free,
@@ -1513 +1689 @@
 };
 
-static struct snd_pcm_ops snd_cs46xx_playback_iec958_ops = {
+static const struct snd_pcm_ops snd_cs46xx_playback_iec958_ops = {
         .open =                 snd_cs46xx_playback_open_iec958,
         .close =                snd_cs46xx_playback_close_iec958,
-        .ioctl =                snd_pcm_lib_ioctl,
         .hw_params =            snd_cs46xx_playback_hw_params,
         .hw_free =              snd_cs46xx_playback_hw_free,
@@ -1524 +1699 @@
 };
 
-static struct snd_pcm_ops snd_cs46xx_playback_indirect_iec958_ops = {
+static const struct snd_pcm_ops snd_cs46xx_playback_indirect_iec958_ops = {
         .open =                 snd_cs46xx_playback_open_iec958,
         .close =                snd_cs46xx_playback_close_iec958,
-        .ioctl =                snd_pcm_lib_ioctl,
         .hw_params =            snd_cs46xx_playback_hw_params,
         .hw_free =              snd_cs46xx_playback_hw_free,
@@ -1538 +1712 @@
 #endif
 
-static struct snd_pcm_ops snd_cs46xx_playback_ops = {
+static const struct snd_pcm_ops snd_cs46xx_playback_ops = {
         .open =                 snd_cs46xx_playback_open,
         .close =                snd_cs46xx_playback_close,
-        .ioctl =                snd_pcm_lib_ioctl,
         .hw_params =            snd_cs46xx_playback_hw_params,
         .hw_free =              snd_cs46xx_playback_hw_free,
@@ -1549 +1722 @@
 };
 
-static struct snd_pcm_ops snd_cs46xx_playback_indirect_ops = {
+static const struct snd_pcm_ops snd_cs46xx_playback_indirect_ops = {
         .open =                 snd_cs46xx_playback_open,
         .close =                snd_cs46xx_playback_close,
-        .ioctl =                snd_pcm_lib_ioctl,
         .hw_params =            snd_cs46xx_playback_hw_params,
         .hw_free =              snd_cs46xx_playback_hw_free,
@@ -1561 +1733 @@
 };
 
-static struct snd_pcm_ops snd_cs46xx_capture_ops = {
+static const struct snd_pcm_ops snd_cs46xx_capture_ops = {
         .open =                 snd_cs46xx_capture_open,
         .close =                snd_cs46xx_capture_close,
-        .ioctl =                snd_pcm_lib_ioctl,
         .hw_params =            snd_cs46xx_capture_hw_params,
         .hw_free =              snd_cs46xx_capture_hw_free,
@@ -1572 +1743 @@
 };
 
-static struct snd_pcm_ops snd_cs46xx_capture_indirect_ops = {
+static const struct snd_pcm_ops snd_cs46xx_capture_indirect_ops = {
         .open =                 snd_cs46xx_capture_open,
         .close =                snd_cs46xx_capture_close,
-        .ioctl =                snd_pcm_lib_ioctl,
         .hw_params =            snd_cs46xx_capture_hw_params,
         .hw_free =              snd_cs46xx_capture_hw_free,
@@ -1590 +1760 @@
 #endif
 
-int __devinit snd_cs46xx_pcm(struct snd_cs46xx *chip, int device, struct snd_pcm ** rpcm)
+int snd_cs46xx_pcm(struct snd_cs46xx *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(chip->card, "CS46xx", device, MAX_PLAYBACK_CHANNELS, 1, &pcm)) < 0)
                 return err;
@@ -1611 +1779 @@
 
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                              snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
-
-        if (rpcm)
-                *rpcm = pcm;
-
-        return 0;
-}
-
-
-#ifdef CONFIG_SND_CS46XX_NEW_DSP
-int __devinit snd_cs46xx_pcm_rear(struct snd_cs46xx *chip, int device, struct snd_pcm ** rpcm)
+                                              &chip->pci->dev,
+                                              64*1024, 256*1024);
+
+        return 0;
+}
+
+
+#ifdef CONFIG_SND_CS46XX_NEW_DSP
+int snd_cs46xx_pcm_rear(struct snd_cs46xx *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
-
-        if (rpcm)
-                *rpcm = NULL;
 
         if ((err = snd_pcm_new(chip->card, "CS46xx - Rear", device, MAX_PLAYBACK_CHANNELS, 0, &pcm)) < 0)
@@ -1642 +1805 @@
 
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                              snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
-
-        if (rpcm)
-                *rpcm = pcm;
-
-        return 0;
-}
-
-int __devinit snd_cs46xx_pcm_center_lfe(struct snd_cs46xx *chip, int device, struct snd_pcm ** rpcm)
+                                              &chip->pci->dev,
+                                              64*1024, 256*1024);
+
+        return 0;
+}
+
+int snd_cs46xx_pcm_center_lfe(struct snd_cs46xx *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
-
-        if (rpcm)
-                *rpcm = NULL;
 
         if ((err = snd_pcm_new(chip->card, "CS46xx - Center LFE", device, MAX_PLAYBACK_CHANNELS, 0, &pcm)) < 0)
@@ -1671 +1829 @@
 
         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                              snd_dma_pci_data(chip->pci), 64*1024, 256*1024);
-
-        if (rpcm)
-                *rpcm = pcm;
-
-        return 0;
-}
-
-int __devinit snd_cs46xx_pcm_iec958(struct snd_cs46xx *chip, int device, struct snd_pcm ** rpcm)
+                                              &chip->pci->dev,
+                                              64*1024, 256*1024);
+
+        return 0;
+}
+
+int snd_cs46xx_pcm_iec958(struct snd_cs46xx *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
-
-        if (rpcm)
-                *rpcm = NULL;
 
         if ((err = snd_pcm_new(chip->card, "CS46xx - IEC958", device, 1, 0, &pcm)) < 0)
@@ -1697 +1850 @@
         pcm->info_flags = 0;
         strcpy(pcm->name, "CS46xx - IEC958");
-        chip->pcm_rear = pcm;
+        chip->pcm_iec958 = 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;
+                                              &chip->pci->dev,
+                                              64*1024, 256*1024);
 
         return 0;
@@ -2092 +2243 @@
 
 
-static struct snd_kcontrol_new snd_cs46xx_controls[] __devinitdata = {
+static const struct snd_kcontrol_new snd_cs46xx_controls[] = {
 {
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -2207 +2358 @@
 }
 
-static struct snd_kcontrol_new snd_cs46xx_front_dup_ctl = {
+static const struct snd_kcontrol_new snd_cs46xx_front_dup_ctl = {
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
         .name = "Duplicate Front",
@@ -2218 +2369 @@
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
 /* Only available on the Hercules Game Theater XP soundcard */
-static struct snd_kcontrol_new snd_hercules_controls[] = {
+static const struct snd_kcontrol_new snd_hercules_controls[] = {
 {
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -2239 +2390 @@
         /* set the desired CODEC mode */
         if (ac97->num == CS46XX_PRIMARY_CODEC_INDEX) {
-                snd_printdd("cs46xx: CODEC1 mode %04x\n", 0x0);
+                dev_dbg(ac97->bus->card->dev, "CODEC1 mode %04x\n", 0x0);
                 snd_cs46xx_ac97_write(ac97, AC97_CSR_ACMODE, 0x0);
         } else if (ac97->num == CS46XX_SECONDARY_CODEC_INDEX) {
-                snd_printdd("cs46xx: CODEC2 mode %04x\n", 0x3);
+                dev_dbg(ac97->bus->card->dev, "CODEC2 mode %04x\n", 0x3);
                 snd_cs46xx_ac97_write(ac97, AC97_CSR_ACMODE, 0x3);
         } else {
@@ -2274 +2425 @@
         } while (time_after_eq(end_time, jiffies));
 
-        snd_printk(KERN_ERR "CS46xx secondary codec doesn't respond!\n");  
-}
-#endif
-
-static int __devinit cs46xx_detect_codec(struct snd_cs46xx *chip, int codec)
+        dev_err(ac97->bus->card->dev,
+                "CS46xx secondary codec doesn't respond!\n");
+}
+#endif
+
+static int cs46xx_detect_codec(struct snd_cs46xx *chip, int codec)
 {
         int idx, err;
@@ -2294 +2446 @@
                 udelay(10);
                 if (snd_cs46xx_codec_read(chip, AC97_RESET, codec) & 0x8000) {
-                        snd_printdd("snd_cs46xx: seconadry codec not present\n");
+                        dev_dbg(chip->card->dev,
+                                "secondary codec not present\n");
                         return -ENXIO;
                 }
@@ -2307 +2460 @@
                 msleep(10);
         }
-        snd_printdd("snd_cs46xx: codec %d detection timeout\n", codec);
+        dev_dbg(chip->card->dev, "codec %d detection timeout\n", codec);
         return -ENXIO;
 }
 
-int __devinit snd_cs46xx_mixer(struct snd_cs46xx *chip, int spdif_device)
+int snd_cs46xx_mixer(struct snd_cs46xx *chip, int spdif_device)
 {
         struct snd_card *card = chip->card;
@@ -2317 +2470 @@
         int err;
         unsigned int idx;
-        static struct snd_ac97_bus_ops ops = {
+        static const struct snd_ac97_bus_ops ops = {
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
                 .reset = snd_cs46xx_codec_reset,
@@ -2327 +2480 @@
         /* detect primary codec */
         chip->nr_ac97_codecs = 0;
-        snd_printdd("snd_cs46xx: detecting primary codec\n");
+        dev_dbg(chip->card->dev, "detecting primary codec\n");
         if ((err = snd_ac97_bus(card, 0, &ops, chip, &chip->ac97_bus)) < 0)
                 return err;
@@ -2337 +2490 @@
 
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
-        snd_printdd("snd_cs46xx: detecting seconadry codec\n");
+        dev_dbg(chip->card->dev, "detecting secondary codec\n");
         /* try detect a secondary codec */
         if (! cs46xx_detect_codec(chip, CS46XX_SECONDARY_CODEC_INDEX))
@@ -2362 +2515 @@
         if (chip->nr_ac97_codecs == 1) {
                 unsigned int id2 = chip->ac97[CS46XX_PRIMARY_CODEC_INDEX]->id & 0xffff;
-                if (id2 == 0x592b || id2 == 0x592d) {
+                if ((id2 & 0xfff0) == 0x5920) { /* CS4294 and CS4298 */
                         err = snd_ctl_add(card, snd_ctl_new1(&snd_cs46xx_front_dup_ctl, chip));
                         if (err < 0)
@@ -2372 +2525 @@
         /* do soundcard specific mixer setup */
         if (chip->mixer_init) {
-                snd_printdd ("calling chip->mixer_init(chip);\n");
+                dev_dbg(chip->card->dev, "calling chip->mixer_init(chip);\n");
                 chip->mixer_init(chip);
         }
@@ -2517 +2670 @@
 }
 
-static struct snd_rawmidi_ops snd_cs46xx_midi_output =
+static const struct snd_rawmidi_ops snd_cs46xx_midi_output =
 {
         .open =         snd_cs46xx_midi_output_open,
@@ -2524 +2677 @@
 };
 
-static struct snd_rawmidi_ops snd_cs46xx_midi_input =
+static const struct snd_rawmidi_ops snd_cs46xx_midi_input =
 {
         .open =         snd_cs46xx_midi_input_open,
@@ -2531 +2684 @@
 };
 
-int __devinit snd_cs46xx_midi(struct snd_cs46xx *chip, int device, struct snd_rawmidi **rrawmidi)
+int snd_cs46xx_midi(struct snd_cs46xx *chip, int device)
 {
         struct snd_rawmidi *rmidi;
         int err;
 
-        if (rrawmidi)
-                *rrawmidi = NULL;
         if ((err = snd_rawmidi_new(chip->card, "CS46XX", device, 1, 1, &rmidi)) < 0)
                 return err;
@@ -2546 +2697 @@
         rmidi->private_data = chip;
         chip->rmidi = rmidi;
-        if (rrawmidi)
-                *rrawmidi = NULL;
         return 0;
 }
@@ -2556 +2705 @@
  */
 
-#if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
+#if IS_REACHABLE(CONFIG_GAMEPORT)
 
 static void snd_cs46xx_gameport_trigger(struct gameport *gameport)
@@ -2613 +2762 @@
 }
 
-int __devinit snd_cs46xx_gameport(struct snd_cs46xx *chip)
+int snd_cs46xx_gameport(struct snd_cs46xx *chip)
 {
         struct gameport *gp;
@@ -2619 +2768 @@
         chip->gameport = gp = gameport_allocate_port();
         if (!gp) {
-                printk(KERN_ERR "cs46xx: cannot allocate memory for gameport\n");
+                dev_err(chip->card->dev,
+                        "cannot allocate memory for gameport\n");
                 return -ENOMEM;
         }
@@ -2649 +2799 @@
 }
 #else
-int __devinit snd_cs46xx_gameport(struct snd_cs46xx *chip) { return -ENOSYS; }
+int snd_cs46xx_gameport(struct snd_cs46xx *chip) { return -ENOSYS; }
 static inline void snd_cs46xx_remove_gameport(struct snd_cs46xx *chip) { }
 #endif /* CONFIG_GAMEPORT */
 
-#ifdef CONFIG_PROC_FS
+#ifdef CONFIG_SND_PROC_FS
 /*
  *  proc interface
@@ -2670 +2820 @@
 }
 
-static struct snd_info_entry_ops snd_cs46xx_proc_io_ops = {
+static const struct snd_info_entry_ops snd_cs46xx_proc_io_ops = {
         .read = snd_cs46xx_io_read,
 };
 
-static int __devinit snd_cs46xx_proc_init(struct snd_card *card, struct snd_cs46xx *chip)
+static int snd_cs46xx_proc_init(struct snd_card *card, struct snd_cs46xx *chip)
 {
         struct snd_info_entry *entry;
@@ -2686 +2836 @@
                         entry->c.ops = &snd_cs46xx_proc_io_ops;
                         entry->size = region->size;
-                        entry->mode = S_IFREG | S_IRUSR;
+                        entry->mode = S_IFREG | 0400;
                 }
         }
@@ -2702 +2852 @@
         return 0;
 }
-#else /* !CONFIG_PROC_FS */
+#else /* !CONFIG_SND_PROC_FS */
 #define snd_cs46xx_proc_init(card, chip)
 #define snd_cs46xx_proc_done(chip)
@@ -2785 +2935 @@
         for (idx = 0; idx < 5; idx++) {
                 struct snd_cs46xx_region *region = &chip->region.idx[idx];
-                if (region->remap_addr)
-                        iounmap(region->remap_addr);
+
+                iounmap(region->remap_addr);
                 release_and_free_resource(region->resource);
         }
@@ -2795 +2945 @@
                 chip->dsp_spos_instance = NULL;
         }
+        for (idx = 0; idx < CS46XX_DSP_MODULES; idx++)
+                free_module_desc(chip->modules[idx]);
+#else
+        vfree(chip->ba1);
 #endif
         
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
         kfree(chip->saved_regs);
 #endif
@@ -2952 +3106 @@
 
 
-        snd_printk(KERN_ERR "create - never read codec ready from AC'97\n");
-        snd_printk(KERN_ERR "it is not probably bug, try to use CS4236 driver\n");
+        dev_err(chip->card->dev,
+                "create - never read codec ready from AC'97\n");
+        dev_err(chip->card->dev,
+                "it is not probably bug, try to use CS4236 driver\n");
         return -EIO;
  ok1:
@@ -2971 +3127 @@
                  */
                 if (!(snd_cs46xx_peekBA0(chip, BA0_ACSTS2) & ACSTS_CRDY))
-                        snd_printdd("cs46xx: never read card ready from secondary AC'97\n");
+                        dev_dbg(chip->card->dev,
+                                "never read card ready from secondary AC'97\n");
         }
 #endif
@@ -3001 +3158 @@
 
 #ifndef CONFIG_SND_CS46XX_NEW_DSP
-        snd_printk(KERN_ERR "create - never read ISV3 & ISV4 from AC'97\n");
+        dev_err(chip->card->dev,
+                "create - never read ISV3 & ISV4 from AC'97\n");
         return -EIO;
 #else
@@ -3008 +3166 @@
            with the same problem I would like to know. (Benny) */
 
-        snd_printk(KERN_ERR "ERROR: snd-cs46xx: never read ISV3 & ISV4 from AC'97\n");
-        snd_printk(KERN_ERR "       Try reloading the ALSA driver, if you find something\n");
-        snd_printk(KERN_ERR "       broken or not working on your soundcard upon\n");
-        snd_printk(KERN_ERR "       this message please report to alsa-devel@alsa-project.org\n");
+        dev_err(chip->card->dev, "never read ISV3 & ISV4 from AC'97\n");
+        dev_err(chip->card->dev,
+                "Try reloading the ALSA driver, if you find something\n");
+        dev_err(chip->card->dev,
+                "broken or not working on your soundcard upon\n");
+        dev_err(chip->card->dev,
+                "this message please report to alsa-devel@alsa-project.org\n");
 
         return -EIO;
@@ -3061 +3222 @@
 }
 
-int __devinit snd_cs46xx_start_dsp(struct snd_cs46xx *chip)
+int snd_cs46xx_start_dsp(struct snd_cs46xx *chip)
 {       
         unsigned int tmp;
+#ifdef CONFIG_SND_CS46XX_NEW_DSP
+        int i;
+#endif
+        int err;
+
         /*
          *  Reset the processor.
@@ -3072 +3238 @@
          */
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
-#if 0
-        if (cs46xx_dsp_load_module(chip, &cwcemb80_module) < 0) {
-                snd_printk(KERN_ERR "image download error\n");
-                return -EIO;
-        }
-#endif
-
-        if (cs46xx_dsp_load_module(chip, &cwc4630_module) < 0) {
-                snd_printk(KERN_ERR "image download error [cwc4630]\n");
-                return -EIO;
-        }
-
-        if (cs46xx_dsp_load_module(chip, &cwcasync_module) < 0) {
-                snd_printk(KERN_ERR "image download error [cwcasync]\n");
-                return -EIO;
-        }
-
-        if (cs46xx_dsp_load_module(chip, &cwcsnoop_module) < 0) {
-                snd_printk(KERN_ERR "image download error [cwcsnoop]\n");
-                return -EIO;
-        }
-
-        if (cs46xx_dsp_load_module(chip, &cwcbinhack_module) < 0) {
-                snd_printk(KERN_ERR "image download error [cwcbinhack]\n");
-                return -EIO;
-        }
-
-        if (cs46xx_dsp_load_module(chip, &cwcdma_module) < 0) {
-                snd_printk(KERN_ERR "image download error [cwcdma]\n");
-                return -EIO;
+        for (i = 0; i < CS46XX_DSP_MODULES; i++) {
+                err = load_firmware(chip, &chip->modules[i], module_names[i]);
+                if (err < 0) {
+                        dev_err(chip->card->dev, "firmware load error [%s]\n",
+                                   module_names[i]);
+                        return err;
+                }
+                err = cs46xx_dsp_load_module(chip, chip->modules[i]);
+                if (err < 0) {
+                        dev_err(chip->card->dev, "image download error [%s]\n",
+                                   module_names[i]);
+                        return err;
+                }
         }
 
@@ -3107 +3256 @@
                 return -EIO;
 #else
+        err = load_firmware(chip);
+        if (err < 0)
+                return err;
+
         /* old image */
-        if (snd_cs46xx_download_image(chip) < 0) {
-                snd_printk(KERN_ERR "image download error\n");
-                return -EIO;
+        err = snd_cs46xx_download_image(chip);
+        if (err < 0) {
+                dev_err(chip->card->dev, "image download error\n");
+                return err;
         }
 
@@ -3162 +3316 @@
         u16 modem_power,pin_config,logic_type;
 
-        snd_printdd ("cs46xx: cs46xx_setup_eapd_slot()+\n");
+        dev_dbg(chip->card->dev, "cs46xx_setup_eapd_slot()+\n");
 
         /*
@@ -3180 +3334 @@
          */
         if(chip->nr_ac97_codecs != 2) {
-                snd_printk (KERN_ERR "cs46xx: cs46xx_setup_eapd_slot() - no secondary codec configured\n");
+                dev_err(chip->card->dev,
+                        "cs46xx_setup_eapd_slot() - no secondary codec configured\n");
                 return -EINVAL;
         }
@@ -3221 +3376 @@
 
         if ( cs46xx_wait_for_fifo(chip,1) ) {
-          snd_printdd("FIFO is busy\n");
+                dev_dbg(chip->card->dev, "FIFO is busy\n");
           
           return -EINVAL;
@@ -3242 +3397 @@
                  */
                 if ( cs46xx_wait_for_fifo(chip,200) ) {
-                        snd_printdd("failed waiting for FIFO at addr (%02X)\n",idx);
+                        dev_dbg(chip->card->dev,
+                                "failed waiting for FIFO at addr (%02X)\n",
+                                idx);
 
                         return -EINVAL;
@@ -3331 +3488 @@
         chip->amplifier += change;
         if (chip->amplifier && !old) {
-                snd_printdd ("Hercules amplifier ON\n");
+                dev_dbg(chip->card->dev, "Hercules amplifier ON\n");
 
                 snd_cs46xx_pokeBA0(chip, BA0_EGPIODR, 
@@ -3338 +3495 @@
                                    EGPIOPTR_GPPT2 | val2);   /* open-drain on output */
         } else if (old && !chip->amplifier) {
-                snd_printdd ("Hercules amplifier OFF\n");
+                dev_dbg(chip->card->dev, "Hercules amplifier OFF\n");
                 snd_cs46xx_pokeBA0(chip, BA0_EGPIODR,  val1 & ~EGPIODR_GPOE2); /* disable */
                 snd_cs46xx_pokeBA0(chip, BA0_EGPIOPTR, val2 & ~EGPIOPTR_GPPT2); /* disable */
@@ -3346 +3503 @@
 static void voyetra_mixer_init (struct snd_cs46xx *chip)
 {
-        snd_printdd ("initializing Voyetra mixer\n");
+        dev_dbg(chip->card->dev, "initializing Voyetra mixer\n");
 
         /* Enable SPDIF out */
@@ -3364 +3521 @@
         hercules_init(chip);
 
-        snd_printdd ("initializing Hercules mixer\n");
+        dev_dbg(chip->card->dev, "initializing Hercules mixer\n");
 
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
@@ -3375 +3532 @@
                 kctl = snd_ctl_new1(&snd_hercules_controls[idx], chip);
                 if ((err = snd_ctl_add(card, kctl)) < 0) {
-                        printk (KERN_ERR "cs46xx: failed to initialize Hercules mixer (%d)\n",err);
+                        dev_err(card->dev,
+                                "failed to initialize Hercules mixer (%d)\n",
+                                err);
                         break;
                 }
@@ -3477 +3636 @@
 };
 
-static struct cs_card_type __devinitdata cards[] = {
+static struct cs_card_type cards[] = {
         {
                 .vendor = 0x1489,
@@ -3590 +3749 @@
  * APM support
  */
-#ifdef CONFIG_PM
-static unsigned int saved_regs[] = {
+#ifdef CONFIG_PM_SLEEP
+static const unsigned int saved_regs[] = {
         BA0_ACOSV,
         /*BA0_ASER_FADDR,*/
@@ -3599 +3758 @@
 };
 
-int snd_cs46xx_suspend(struct pci_dev *pci, pm_message_t state)
-{
-        struct snd_card *card = pci_get_drvdata(pci);
+static int snd_cs46xx_suspend(struct device *dev)
+{
+        struct snd_card *card = dev_get_drvdata(dev);
         struct snd_cs46xx *chip = card->private_data;
         int i, amp_saved;
@@ -3607 +3766 @@
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
         chip->in_suspend = 1;
-        snd_pcm_suspend_all(chip->pcm);
         // chip->ac97_powerdown = snd_cs46xx_codec_read(chip, AC97_POWER_CONTROL);
         // chip->ac97_general_purpose = snd_cs46xx_codec_read(chip, BA0_AC97_GENERAL_PURPOSE);
@@ -3625 +3783 @@
         chip->active_ctrl(chip, -chip->amplifier);
         chip->amplifier = amp_saved; /* restore the status */
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, pci_choose_state(pci, state));
-        return 0;
-}
-
-int snd_cs46xx_resume(struct pci_dev *pci)
-{
-        struct snd_card *card = pci_get_drvdata(pci);
+        return 0;
+}
+
+static int snd_cs46xx_resume(struct device *dev)
+{
+        struct snd_card *card = dev_get_drvdata(dev);
         struct snd_cs46xx *chip = card->private_data;
         int amp_saved;
@@ -3641 +3795 @@
 #endif
         unsigned int tmp;
-
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "cs46xx: pci_enable_device failed, "
-                       "disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
 
         amp_saved = chip->amplifier;
@@ -3707 +3851 @@
         return 0;
 }
-#endif /* CONFIG_PM */
+
+SIMPLE_DEV_PM_OPS(snd_cs46xx_pm, snd_cs46xx_suspend, snd_cs46xx_resume);
+#endif /* CONFIG_PM_SLEEP */
 
 
@@ -3713 +3859 @@
  */
 
-int __devinit snd_cs46xx_create(struct snd_card *card,
-                      struct pci_dev * pci,
+int snd_cs46xx_create(struct snd_card *card,
+                      struct pci_dev *pci,
                       int external_amp, int thinkpad,
-                      struct snd_cs46xx ** rchip)
+                      struct snd_cs46xx **rchip)
 {
         struct snd_cs46xx *chip;
@@ -3723 +3869 @@
         struct cs_card_type *cp;
         u16 ss_card, ss_vendor;
-        static struct snd_device_ops ops = {
+        static const struct snd_device_ops ops = {
                 .dev_free =     snd_cs46xx_dev_free,
         };
@@ -3749 +3895 @@
         if (chip->ba0_addr == 0 || chip->ba0_addr == (unsigned long)~0 ||
             chip->ba1_addr == 0 || chip->ba1_addr == (unsigned long)~0) {
-                snd_printk(KERN_ERR "wrong address(es) - ba0 = 0x%lx, ba1 = 0x%lx\n",
+                dev_err(chip->card->dev,
+                        "wrong address(es) - ba0 = 0x%lx, ba1 = 0x%lx\n",
                            chip->ba0_addr, chip->ba1_addr);
                 snd_cs46xx_free(chip);
@@ -3786 +3933 @@
         for (cp = &cards[0]; cp->name; cp++) {
                 if (cp->vendor == ss_vendor && cp->id == ss_card) {
-                        snd_printdd ("hack for %s enabled\n", cp->name);
+                        dev_dbg(chip->card->dev, "hack for %s enabled\n",
+                                cp->name);
 
                         chip->amplifier_ctrl = cp->amp;
@@ -3799 +3947 @@
 
         if (external_amp) {
-                snd_printk(KERN_INFO "Crystal EAPD support forced on.\n");
+                dev_info(chip->card->dev,
+                         "Crystal EAPD support forced on.\n");
                 chip->amplifier_ctrl = amp_voyetra;
         }
 
         if (thinkpad) {
-                snd_printk(KERN_INFO "Activating CLKRUN hack for Thinkpad.\n");
+                dev_info(chip->card->dev,
+                         "Activating CLKRUN hack for Thinkpad.\n");
                 chip->active_ctrl = clkrun_hack;
                 clkrun_init(chip);
@@ -3822 +3972 @@
                 if ((region->resource = request_mem_region(region->base, region->size,
                                                            region->name)) == NULL) {
-                        snd_printk(KERN_ERR "unable to request memory region 0x%lx-0x%lx\n",
+                        dev_err(chip->card->dev,
+                                "unable to request memory region 0x%lx-0x%lx\n",
                                    region->base, region->base + region->size - 1);
                         snd_cs46xx_free(chip);
                         return -EBUSY;
                 }
-                region->remap_addr = ioremap_nocache(region->base, region->size);
+                region->remap_addr = ioremap(region->base, region->size);
                 if (region->remap_addr == NULL) {
-                        snd_printk(KERN_ERR "%s ioremap problem\n", region->name);
+                        dev_err(chip->card->dev,
+                                "%s ioremap problem\n", region->name);
                         snd_cs46xx_free(chip);
                         return -ENOMEM;
@@ -3836 +3988 @@
 
         if (request_irq(pci->irq, snd_cs46xx_interrupt, IRQF_SHARED,
-                        "CS46XX", chip)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                        KBUILD_MODNAME, chip)) {
+                dev_err(chip->card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_cs46xx_free(chip);
                 return -EBUSY;
         }
         chip->irq = pci->irq;
+        card->sync_irq = chip->irq;
 
 #ifdef CONFIG_SND_CS46XX_NEW_DSP
@@ -3864 +4017 @@
         snd_cs46xx_proc_init(card, chip);
 
-#ifdef CONFIG_PM
-        chip->saved_regs = kmalloc(sizeof(*chip->saved_regs) *
-                                   ARRAY_SIZE(saved_regs), GFP_KERNEL);
+#ifdef CONFIG_PM_SLEEP
+        chip->saved_regs = kmalloc_array(ARRAY_SIZE(saved_regs),
+                                         sizeof(*chip->saved_regs),
+                                         GFP_KERNEL);
         if (!chip->saved_regs) {
                 snd_cs46xx_free(chip);
@@ -3875 +4029 @@
         chip->active_ctrl(chip, -1); /* disable CLKRUN */
 
-        snd_card_set_dev(card, &pci->dev);
-
         *rchip = chip;
         return 0;

GPL/trunk/alsa-kernel/pci/cs46xx/cs46xx_lib.h

@@ +1 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 /*
  *  The driver for the Cirrus Logic's Sound Fusion CS46XX based soundcards
  *  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
- *
  */
 
@@ -91 +76 @@
 void cs46xx_dsp_spos_destroy (struct snd_cs46xx * chip);
 int cs46xx_dsp_load_module (struct snd_cs46xx * chip, struct dsp_module_desc * module);
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 int cs46xx_dsp_resume(struct snd_cs46xx * chip);
 #endif
 struct dsp_symbol_entry *cs46xx_dsp_lookup_symbol (struct snd_cs46xx * chip, char * symbol_name,
                                                    int symbol_type);
-#ifdef CONFIG_PROC_FS
+#ifdef CONFIG_SND_PROC_FS
 int cs46xx_dsp_proc_init (struct snd_card *card, struct snd_cs46xx *chip);
 int cs46xx_dsp_proc_done (struct snd_cs46xx *chip);
@@ -119 +104 @@
 struct dsp_scb_descriptor * cs46xx_dsp_create_scb (struct snd_cs46xx *chip, char * name,
                                                    u32 * scb_data, u32 dest);
-#ifdef CONFIG_PROC_FS
+#ifdef CONFIG_SND_PROC_FS
 void cs46xx_dsp_proc_free_scb_desc (struct dsp_scb_descriptor * scb);
 void cs46xx_dsp_proc_register_scb_desc (struct snd_cs46xx *chip,

GPL/trunk/alsa-kernel/pci/cs46xx/dsp_spos.c

@@ +1 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
 /*
- *   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
- *
  */
 
@@ -21 +8 @@
 
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/pm.h>
@@ -33 +20 @@
 #include <sound/info.h>
 #include <sound/asoundef.h>
-#include <sound/cs46xx.h>
+#include "cs46xx.h"
 
 #include "cs46xx_lib.h"
@@ -41 +28 @@
                                   struct dsp_scb_descriptor * fg_entry);
 
-static enum wide_opcode wide_opcodes[] = { 
+static const enum wide_opcode wide_opcodes[] = {
         WIDE_FOR_BEGIN_LOOP,
         WIDE_FOR_BEGIN_LOOP2,
@@ -86 +73 @@
                                                 address |=  loval >> 15;
             
-                                                snd_printdd("handle_wideop[1]: %05x:%05x addr %04x\n",hival,loval,address);
+                                                dev_dbg(chip->card->dev,
+                                                        "handle_wideop[1]: %05x:%05x addr %04x\n",
+                                                        hival, loval, address);
             
                                                 if ( !(address & 0x8000) ) {
                                                         address += (ins->code.offset / 2) - overlay_begin_address;
                                                 } else {
-                                                        snd_printdd("handle_wideop[1]: ROM symbol not reallocated\n");
+                                                        dev_dbg(chip->card->dev,
+                                                                "handle_wideop[1]: ROM symbol not reallocated\n");
                                                 }
             
@@ -103 +93 @@
                                                 address |=  loval >> 15;
             
-                                                snd_printdd("handle_wideop:[2] %05x:%05x addr %04x\n",hival,loval,address);            
-                                                nreallocated ++;
+                                                dev_dbg(chip->card->dev,
+                                                        "handle_wideop:[2] %05x:%05x addr %04x\n",
+                                                        hival, loval, address);
+                                                nreallocated++;
                                         } /* wide_opcodes[j] == wide_op */
                                 } /* for */
@@ -114 +106 @@
         }
 
-        snd_printdd("dsp_spos: %d instructions reallocated\n",nreallocated);
+        dev_dbg(chip->card->dev,
+                "dsp_spos: %d instructions reallocated\n", nreallocated);
         return nreallocated;
 }
@@ -158 +151 @@
         for (i = 0;i < module->symbol_table.nsymbols; ++i) {
                 if (ins->symbol_table.nsymbols == (DSP_MAX_SYMBOLS - 1)) {
-                        snd_printk(KERN_ERR "dsp_spos: symbol table is full\n");
+                        dev_err(chip->card->dev,
+                                "dsp_spos: symbol table is full\n");
                         return -ENOMEM;
                 }
@@ -177 +171 @@
                         ins->symbol_table.nsymbols++;
                 } else {
-          /* if (0) printk ("dsp_spos: symbol <%s> duplicated, probably nothing wrong with that (Cirrus?)\n",
-                             module->symbol_table.symbols[i].symbol_name); */
+#if 0
+                        dev_dbg(chip->card->dev,
+                                "dsp_spos: symbol <%s> duplicated, probably nothing wrong with that (Cirrus?)\n",
+                                module->symbol_table.symbols[i].symbol_name); */
+#endif
                 }
         }
@@ -193 +190 @@
 
         if (ins->symbol_table.nsymbols == (DSP_MAX_SYMBOLS - 1)) {
-                snd_printk(KERN_ERR "dsp_spos: symbol table is full\n");
+                dev_err(chip->card->dev, "dsp_spos: symbol table is full\n");
                 return NULL;
         }
@@ -200 +197 @@
                                      symbol_name,
                                      type) != NULL) {
-                snd_printk(KERN_ERR "dsp_spos: symbol <%s> duplicated\n", symbol_name);
+                dev_err(chip->card->dev,
+                        "dsp_spos: symbol <%s> duplicated\n", symbol_name);
                 return NULL;
         }
@@ -230 +228 @@
 
         /* better to use vmalloc for this big table */
-        ins->symbol_table.symbols = vmalloc(sizeof(struct dsp_symbol_entry) *
-                                            DSP_MAX_SYMBOLS);
+        ins->symbol_table.symbols =
+                vmalloc(array_size(DSP_MAX_SYMBOLS,
+                                   sizeof(struct dsp_symbol_entry)));
         ins->code.data = kmalloc(DSP_CODE_BYTE_SIZE, GFP_KERNEL);
-        ins->modules = kmalloc(sizeof(struct dsp_module_desc) * DSP_MAX_MODULES, GFP_KERNEL);
+        ins->modules = kmalloc_array(DSP_MAX_MODULES,
+                                     sizeof(struct dsp_module_desc),
+                                     GFP_KERNEL);
         if (!ins->symbol_table.symbols || !ins->code.data || !ins->modules) {
                 cs46xx_dsp_spos_destroy(chip);
@@ -288 +289 @@
 
                 cs46xx_dsp_proc_free_scb_desc ( (ins->scbs + i) );
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
                 kfree(ins->scbs[i].data);
 #endif
@@ -306 +307 @@
 
         if (!parameter) {
-                snd_printdd("dsp_spos: module got no parameter segment\n");
+                dev_dbg(chip->card->dev,
+                        "dsp_spos: module got no parameter segment\n");
                 return 0;
         }
@@ -313 +315 @@
         dsize   = parameter->size * 4;
 
-        snd_printdd("dsp_spos: "
-                    "downloading parameter data to chip (%08x-%08x)\n",
+        dev_dbg(chip->card->dev,
+                "dsp_spos: downloading parameter data to chip (%08x-%08x)\n",
                     doffset,doffset + dsize);
         if (snd_cs46xx_download (chip, parameter->data, doffset, dsize)) {
-                snd_printk(KERN_ERR "dsp_spos: "
-                           "failed to download parameter data to DSP\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: failed to download parameter data to DSP\n");
                 return -EINVAL;
         }
@@ -330 +332 @@
 
         if (!sample) {
-                snd_printdd("dsp_spos: module got no sample segment\n");
+                dev_dbg(chip->card->dev,
+                        "dsp_spos: module got no sample segment\n");
                 return 0;
         }
@@ -337 +340 @@
         dsize   =  sample->size * 4;
 
-        snd_printdd("dsp_spos: downloading sample data to chip (%08x-%08x)\n",
+        dev_dbg(chip->card->dev,
+                "dsp_spos: downloading sample data to chip (%08x-%08x)\n",
                     doffset,doffset + dsize);
 
         if (snd_cs46xx_download (chip,sample->data,doffset,dsize)) {
-                snd_printk(KERN_ERR "dsp_spos: failed to sample data to DSP\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: failed to sample data to DSP\n");
                 return -EINVAL;
         }
@@ -355 +360 @@
 
         if (ins->nmodules == DSP_MAX_MODULES - 1) {
-                snd_printk(KERN_ERR "dsp_spos: to many modules loaded into DSP\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: to many modules loaded into DSP\n");
                 return -ENOMEM;
         }
 
-        snd_printdd("dsp_spos: loading module %s into DSP\n", module->module_name);
+        dev_dbg(chip->card->dev,
+                "dsp_spos: loading module %s into DSP\n", module->module_name);
   
         if (ins->nmodules == 0) {
-                snd_printdd("dsp_spos: clearing parameter area\n");
+                dev_dbg(chip->card->dev, "dsp_spos: clearing parameter area\n");
                 snd_cs46xx_clear_BA1(chip, DSP_PARAMETER_BYTE_OFFSET, DSP_PARAMETER_BYTE_SIZE);
         }
@@ -372 +379 @@
 
         if (ins->nmodules == 0) {
-                snd_printdd("dsp_spos: clearing sample area\n");
+                dev_dbg(chip->card->dev, "dsp_spos: clearing sample area\n");
                 snd_cs46xx_clear_BA1(chip, DSP_SAMPLE_BYTE_OFFSET, DSP_SAMPLE_BYTE_SIZE);
         }
@@ -382 +389 @@
 
         if (ins->nmodules == 0) {
-                snd_printdd("dsp_spos: clearing code area\n");
+                dev_dbg(chip->card->dev, "dsp_spos: clearing code area\n");
                 snd_cs46xx_clear_BA1(chip, DSP_CODE_BYTE_OFFSET, DSP_CODE_BYTE_SIZE);
         }
 
         if (code == NULL) {
-                snd_printdd("dsp_spos: module got no code segment\n");
+                dev_dbg(chip->card->dev,
+                        "dsp_spos: module got no code segment\n");
         } else {
                 if (ins->code.offset + code->size > DSP_CODE_BYTE_SIZE) {
-                        snd_printk(KERN_ERR "dsp_spos: no space available in DSP\n");
+                        dev_err(chip->card->dev,
+                                "dsp_spos: no space available in DSP\n");
                         return -ENOMEM;
                 }
@@ -402 +411 @@
                         return -ENOMEM;
                 if (add_symbols(chip,module)) {
-                        snd_printk(KERN_ERR "dsp_spos: failed to load symbol table\n");
+                        dev_err(chip->card->dev,
+                                "dsp_spos: failed to load symbol table\n");
                         return -ENOMEM;
                 }
@@ -408 +418 @@
                 doffset = (code->offset * 4 + ins->code.offset * 4 + DSP_CODE_BYTE_OFFSET);
                 dsize   = code->size * 4;
-                snd_printdd("dsp_spos: downloading code to chip (%08x-%08x)\n",
+                dev_dbg(chip->card->dev,
+                        "dsp_spos: downloading code to chip (%08x-%08x)\n",
                             doffset,doffset + dsize);   
 
@@ -414 +425 @@
 
                 if (snd_cs46xx_download (chip,(ins->code.data + ins->code.offset),doffset,dsize)) {
-                        snd_printk(KERN_ERR "dsp_spos: failed to download code to DSP\n");
+                        dev_err(chip->card->dev,
+                                "dsp_spos: failed to download code to DSP\n");
                         return -EINVAL;
                 }
@@ -448 +460 @@
 
 #if 0
-        printk ("dsp_spos: symbol <%s> type %02x not found\n",
+        dev_err(chip->card->dev, "dsp_spos: symbol <%s> type %02x not found\n",
                 symbol_name,symbol_type);
 #endif
@@ -456 +468 @@
 
 
-#ifdef CONFIG_PROC_FS
+#ifdef CONFIG_SND_PROC_FS
 static struct dsp_symbol_entry *
 cs46xx_dsp_lookup_symbol_addr (struct snd_cs46xx * chip, u32 address, int symbol_type)
@@ -775 +787 @@
         ins->snd_card = card;
 
-        if ((entry = snd_info_create_card_entry(card, "dsp", card->proc_root)) != NULL) {
-                entry->content = SNDRV_INFO_CONTENT_TEXT;
-                entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
-      
-                if (snd_info_register(entry) < 0) {
-                        snd_info_free_entry(entry);
-                        entry = NULL;
-                }
-        }
-
+        entry = snd_info_create_card_entry(card, "dsp", card->proc_root);
+        if (entry)
+                entry->mode = S_IFDIR | 0555;
         ins->proc_dsp_dir = entry;
 
@@ -790 +795 @@
                 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 | S_IRUGO | S_IWUSR;
-                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 | S_IRUGO | S_IWUSR;
-                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 | S_IRUGO | S_IWUSR;
-                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 | S_IRUGO | S_IWUSR;
-                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 | S_IRUGO | S_IWUSR;
-                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 | S_IRUGO | S_IWUSR;
-                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);
@@ -879 +848 @@
         int i;
 
-        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;
+        if (!ins)
+                return 0;
 
         mutex_lock(&chip->spos_mutex);
@@ -909 +863 @@
         return 0;
 }
-#endif /* CONFIG_PROC_FS */
-
-static int debug_tree;
+#endif /* CONFIG_SND_PROC_FS */
+
 static void _dsp_create_task_tree (struct snd_cs46xx *chip, u32 * task_data,
                                    u32  dest, int size)
@@ -920 +873 @@
 
         for (i = 0; i < size; ++i) {
-                if (debug_tree) printk ("addr %p, val %08x\n",spdst,task_data[i]);
+                dev_dbg(chip->card->dev, "addr %p, val %08x\n",
+                        spdst, task_data[i]);
                 writel(task_data[i],spdst);
                 spdst += sizeof(u32);
@@ -926 +880 @@
 }
 
-static int debug_scb;
 static void _dsp_create_scb (struct snd_cs46xx *chip, u32 * scb_data, u32 dest)
 {
@@ -934 +887 @@
 
         for (i = 0; i < 0x10; ++i) {
-                if (debug_scb) printk ("addr %p, val %08x\n",spdst,scb_data[i]);
+                dev_dbg(chip->card->dev, "addr %p, val %08x\n",
+                        spdst, scb_data[i]);
                 writel(scb_data[i],spdst);
                 spdst += sizeof(u32);
@@ -961 +915 @@
 
         if (ins->nscb == DSP_MAX_SCB_DESC - 1) {
-                snd_printk(KERN_ERR "dsp_spos: got no place for other SCB\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: got no place for other SCB\n");
                 return NULL;
         }
@@ -992 +947 @@
 
         if (ins->ntask == DSP_MAX_TASK_DESC - 1) {
-                snd_printk(KERN_ERR "dsp_spos: got no place for other TASK\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: got no place for other TASK\n");
                 return NULL;
         }
@@ -1020 +976 @@
         struct dsp_scb_descriptor * desc;
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
         /* copy the data for resume */
         scb_data = kmemdup(scb_data, SCB_BYTES, GFP_KERNEL);
@@ -1032 +988 @@
                 _dsp_create_scb(chip,scb_data,dest);
         } else {
-                snd_printk(KERN_ERR "dsp_spos: failed to map SCB\n");
-#ifdef CONFIG_PM
+                dev_err(chip->card->dev, "dsp_spos: failed to map SCB\n");
+#ifdef CONFIG_PM_SLEEP
                 kfree(scb_data);
 #endif
@@ -1053 +1009 @@
                 _dsp_create_task_tree(chip,task_data,dest,size);
         } else {
-                snd_printk(KERN_ERR "dsp_spos: failed to map TASK\n");
+                dev_err(chip->card->dev, "dsp_spos: failed to map TASK\n");
         }
 
@@ -1083 +1039 @@
         int fifo_addr, fifo_span, valid_slots;
 
-        static struct dsp_spos_control_block sposcb = {
+        static const struct dsp_spos_control_block sposcb = {
                 /* 0 */ HFG_TREE_SCB,HFG_STACK,
                 /* 1 */ SPOSCB_ADDR,BG_TREE_SCB_ADDR,
@@ -1106 +1062 @@
         null_algorithm  = cs46xx_dsp_lookup_symbol(chip, "NULLALGORITHM", SYMBOL_CODE);
         if (null_algorithm == NULL) {
-                snd_printk(KERN_ERR "dsp_spos: symbol NULLALGORITHM not found\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: symbol NULLALGORITHM not found\n");
                 return -EIO;
         }
@@ -1112 +1069 @@
         fg_task_tree_header_code = cs46xx_dsp_lookup_symbol(chip, "FGTASKTREEHEADERCODE", SYMBOL_CODE);  
         if (fg_task_tree_header_code == NULL) {
-                snd_printk(KERN_ERR "dsp_spos: symbol FGTASKTREEHEADERCODE not found\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: symbol FGTASKTREEHEADERCODE not found\n");
                 return -EIO;
         }
@@ -1118 +1076 @@
         task_tree_header_code = cs46xx_dsp_lookup_symbol(chip, "TASKTREEHEADERCODE", SYMBOL_CODE);  
         if (task_tree_header_code == NULL) {
-                snd_printk(KERN_ERR "dsp_spos: symbol TASKTREEHEADERCODE not found\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: symbol TASKTREEHEADERCODE not found\n");
                 return -EIO;
         }
@@ -1124 +1083 @@
         task_tree_thread = cs46xx_dsp_lookup_symbol(chip, "TASKTREETHREAD", SYMBOL_CODE);
         if (task_tree_thread == NULL) {
-                snd_printk(KERN_ERR "dsp_spos: symbol TASKTREETHREAD not found\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: symbol TASKTREETHREAD not found\n");
                 return -EIO;
         }
@@ -1130 +1090 @@
         magic_snoop_task = cs46xx_dsp_lookup_symbol(chip, "MAGICSNOOPTASK", SYMBOL_CODE);
         if (magic_snoop_task == NULL) {
-                snd_printk(KERN_ERR "dsp_spos: symbol MAGICSNOOPTASK not found\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: symbol MAGICSNOOPTASK not found\n");
                 return -EIO;
         }
@@ -1414 +1375 @@
         if (chip->nr_ac97_codecs == 2) {
                 /* create CODEC tasklet for rear Center/LFE output 
-                   slot 6 and 9 on seconadry CODEC */
+                   slot 6 and 9 on secondary CODEC */
                 clfe_codec_out_scb = cs46xx_dsp_create_codec_out_scb(chip,"CodecOutSCB_CLFE",0x0030,0x0030,
                                                                      CLFE_MIXER_SCB_ADDR,
@@ -1477 +1438 @@
 
  _fail_end:
-        snd_printk(KERN_ERR "dsp_spos: failed to setup SCB's in DSP\n");
+        dev_err(chip->card->dev, "dsp_spos: failed to setup SCB's in DSP\n");
         return -EINVAL;
 }
@@ -1492 +1453 @@
         s16_async_codec_input_task = cs46xx_dsp_lookup_symbol(chip, "S16_ASYNCCODECINPUTTASK", SYMBOL_CODE);
         if (s16_async_codec_input_task == NULL) {
-                snd_printk(KERN_ERR "dsp_spos: symbol S16_ASYNCCODECINPUTTASK not found\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: symbol S16_ASYNCCODECINPUTTASK not found\n");
                 return -EIO;
         }
         spdifo_task = cs46xx_dsp_lookup_symbol(chip, "SPDIFOTASK", SYMBOL_CODE);
         if (spdifo_task == NULL) {
-                snd_printk(KERN_ERR "dsp_spos: symbol SPDIFOTASK not found\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: symbol SPDIFOTASK not found\n");
                 return -EIO;
         }
@@ -1503 +1466 @@
         spdifi_task = cs46xx_dsp_lookup_symbol(chip, "SPDIFITASK", SYMBOL_CODE);
         if (spdifi_task == NULL) {
-                snd_printk(KERN_ERR "dsp_spos: symbol SPDIFITASK not found\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: symbol SPDIFITASK not found\n");
                 return -EIO;
         }
@@ -1884 +1848 @@
 
         if (i == 25) {
-                snd_printk(KERN_ERR "dsp_spos: SPIOWriteTask not responding\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: SPIOWriteTask not responding\n");
                 return -EBUSY;
         }
@@ -1938 +1903 @@
 }
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 int cs46xx_dsp_resume(struct snd_cs46xx * chip)
 {

GPL/trunk/alsa-kernel/pci/cs46xx/dsp_spos.h

@@ +1 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
 /*
  *  The driver for the Cirrus Logic's Sound Fusion CS46XX based soundcards
  *  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
- *
  */
 

GPL/trunk/alsa-kernel/pci/cs46xx/dsp_spos_scb_lib.c

@@ +1 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
 /*
- *
- *   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
- *
  */
 
@@ -22 +8 @@
 
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/pm.h>
@@ -32 +18 @@
 #include <sound/control.h>
 #include <sound/info.h>
-#include <sound/cs46xx.h>
+#include "cs46xx.h"
 
 #include "cs46xx_lib.h"
@@ -68 +54 @@
 }
 
-#ifdef CONFIG_PROC_FS
+#ifdef CONFIG_SND_PROC_FS
 static void cs46xx_dsp_proc_scb_info_read (struct snd_info_entry *entry,
                                            struct snd_info_buffer *buffer)
@@ -74 +60 @@
         struct proc_scb_info * scb_info  = entry->private_data;
         struct dsp_scb_descriptor * scb = scb_info->scb_desc;
-        struct dsp_spos_instance * ins;
         struct snd_cs46xx *chip = scb_info->chip;
         int j,col;
         void __iomem *dst = chip->region.idx[1].remap_addr + DSP_PARAMETER_BYTE_OFFSET;
-
-        ins = chip->dsp_spos_instance;
 
         mutex_lock(&chip->spos_mutex);
@@ -204 +187 @@
 
         ins->scbs[scb->index].deleted = 1;
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
         kfree(ins->scbs[scb->index].data);
         ins->scbs[scb->index].data = NULL;
@@ -229 +212 @@
 
 
-#ifdef CONFIG_PROC_FS
+#ifdef CONFIG_SND_PROC_FS
 void cs46xx_dsp_proc_free_scb_desc (struct dsp_scb_descriptor * scb)
 {
         if (scb->proc_info) {
                 struct proc_scb_info * scb_info = scb->proc_info->private_data;
-
-                snd_printdd("cs46xx_dsp_proc_free_scb_desc: freeing %s\n",scb->scb_name);
+                struct snd_cs46xx *chip = scb_info->chip;
+
+                dev_dbg(chip->card->dev,
+                        "cs46xx_dsp_proc_free_scb_desc: freeing %s\n",
+                        scb->scb_name);
 
                 snd_info_free_entry(scb->proc_info);
@@ -255 +241 @@
             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) {
@@ -266 +253 @@
                         scb_info->chip = chip;
                         scb_info->scb_desc = scb;
-      
-                        entry->content = SNDRV_INFO_CONTENT_TEXT;
-                        entry->private_data = scb_info;
-                        entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
-      
-                        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:
@@ -283 +260 @@
         }
 }
-#endif /* CONFIG_PROC_FS */
+#endif /* CONFIG_SND_PROC_FS */
 
 static struct dsp_scb_descriptor * 
@@ -306 +283 @@
         scb_data[SCBfuncEntryPtr] |= task_entry->address;
 
-        snd_printdd("dsp_spos: creating SCB <%s>\n",name);
+        dev_dbg(chip->card->dev, "dsp_spos: creating SCB <%s>\n", name);
 
         scb = cs46xx_dsp_create_scb(chip,name,scb_data,dest);
@@ -321 +298 @@
         if (scb->parent_scb_ptr) {
 #if 0
-                printk ("scb->parent_scb_ptr = %s\n",scb->parent_scb_ptr->scb_name);
-                printk ("scb->parent_scb_ptr->next_scb_ptr = %s\n",scb->parent_scb_ptr->next_scb_ptr->scb_name);
-                printk ("scb->parent_scb_ptr->sub_list_ptr = %s\n",scb->parent_scb_ptr->sub_list_ptr->scb_name);
+                dev_dbg(chip->card->dev,
+                        "scb->parent_scb_ptr = %s\n",
+                        scb->parent_scb_ptr->scb_name);
+                dev_dbg(chip->card->dev,
+                        "scb->parent_scb_ptr->next_scb_ptr = %s\n",
+                        scb->parent_scb_ptr->next_scb_ptr->scb_name);
+                dev_dbg(chip->card->dev,
+                        "scb->parent_scb_ptr->sub_list_ptr = %s\n",
+                        scb->parent_scb_ptr->sub_list_ptr->scb_name);
 #endif
                 /* link to  parent SCB */
@@ -369 +352 @@
   
         if (task_entry == NULL) {
-                snd_printk (KERN_ERR "dsp_spos: symbol %s not found\n",task_entry_name);
+                dev_err(chip->card->dev,
+                        "dsp_spos: symbol %s not found\n", task_entry_name);
                 return NULL;
         }
@@ -583 +567 @@
     
                 if (ins->null_algorithm == NULL) {
-                        snd_printk (KERN_ERR "dsp_spos: symbol NULLALGORITHM not found\n");
+                        dev_err(chip->card->dev,
+                                "dsp_spos: symbol NULLALGORITHM not found\n");
                         return NULL;
                 }    
@@ -613 +598 @@
         unsigned int correctionPerGOF, correctionPerSec;
 
-        snd_printdd( "dsp_spos: setting %s rate to %u\n",scb_name,rate);
+        dev_dbg(chip->card->dev, "dsp_spos: setting %s rate to %u\n",
+                scb_name, rate);
 
         /*
@@ -671 +657 @@
                         
                         if (ins->s16_up == NULL) {
-                                snd_printk (KERN_ERR "dsp_spos: symbol S16_UPSRC not found\n");
+                                dev_err(chip->card->dev,
+                                        "dsp_spos: symbol S16_UPSRC not found\n");
                                 return NULL;
                         }    
@@ -1159 +1146 @@
 }
 
-static u32 pcm_reader_buffer_addr[DSP_MAX_PCM_CHANNELS] = {
+static const u32 pcm_reader_buffer_addr[DSP_MAX_PCM_CHANNELS] = {
         0x0600, /* 1 */
         0x1500, /* 2 */
@@ -1194 +1181 @@
 };
 
-static u32 src_output_buffer_addr[DSP_MAX_SRC_NR] = {
+static const u32 src_output_buffer_addr[DSP_MAX_SRC_NR] = {
         0x2B80,
         0x2BA0,
@@ -1211 +1198 @@
 };
 
-static u32 src_delay_buffer_addr[DSP_MAX_SRC_NR] = {
+static const u32 src_delay_buffer_addr[DSP_MAX_SRC_NR] = {
         0x2480,
         0x2500,
@@ -1266 +1253 @@
                    alter the raw data stream ...) */
                 if (sample_rate == 48000) {
-                        snd_printdd ("IEC958 pass through\n");
+                        dev_dbg(chip->card->dev, "IEC958 pass through\n");
                         /* Hack to bypass creating a new SRC */
                         pass_through = 1;
@@ -1300 +1287 @@
 
         if (pcm_index == -1) {
-                snd_printk (KERN_ERR "dsp_spos: no free PCM channel\n");
+                dev_err(chip->card->dev, "dsp_spos: no free PCM channel\n");
                 return NULL;
         }
@@ -1306 +1293 @@
         if (src_scb == NULL) {
                 if (ins->nsrc_scb >= DSP_MAX_SRC_NR) {
-                        snd_printk(KERN_ERR "dsp_spos: to many SRC instances\n!");
+                        dev_err(chip->card->dev,
+                                "dsp_spos: too many SRC instances\n!");
                         return NULL;
                 }
@@ -1332 +1320 @@
                 snprintf (scb_name,DSP_MAX_SCB_NAME,"SrcTask_SCB%d",src_index);
                 
-                snd_printdd( "dsp_spos: creating SRC \"%s\"\n",scb_name);
+                dev_dbg(chip->card->dev,
+                        "dsp_spos: creating SRC \"%s\"\n", scb_name);
                 src_scb = cs46xx_dsp_create_src_task_scb(chip,scb_name,
                                                          sample_rate,
@@ -1344 +1333 @@
 
                 if (!src_scb) {
-                        snd_printk (KERN_ERR "dsp_spos: failed to create SRCtaskSCB\n");
+                        dev_err(chip->card->dev,
+                                "dsp_spos: failed to create SRCtaskSCB\n");
                         return NULL;
                 }
@@ -1356 +1346 @@
         snprintf (scb_name,DSP_MAX_SCB_NAME,"PCMReader_SCB%d",pcm_index);
 
-        snd_printdd( "dsp_spos: creating PCM \"%s\" (%d)\n",scb_name,
-                 pcm_channel_id);
+        dev_dbg(chip->card->dev, "dsp_spos: creating PCM \"%s\" (%d)\n",
+                scb_name, pcm_channel_id);
 
         pcm_scb = cs46xx_dsp_create_pcm_reader_scb(chip,scb_name,
@@ -1370 +1360 @@
 
         if (!pcm_scb) {
-                snd_printk (KERN_ERR "dsp_spos: failed to create PCMreaderSCB\n");
+                dev_err(chip->card->dev,
+                        "dsp_spos: failed to create PCMreaderSCB\n");
                 return NULL;
         }
@@ -1420 +1411 @@
                 break; 
         default:
-                snd_printdd ("period size (%d) not supported by HW\n", period_size);
+                dev_dbg(chip->card->dev,
+                        "period size (%d) not supported by HW\n", period_size);
                 return -EINVAL;
         }
@@ -1458 +1450 @@
                 break; 
         default:
-                snd_printdd ("period size (%d) not supported by HW\n", period_size);
+                dev_dbg(chip->card->dev,
+                        "period size (%d) not supported by HW\n", period_size);
                 return -EINVAL;
         }
@@ -1724 +1717 @@
 
         if ( ins->spdif_status_out & DSP_SPDIF_STATUS_OUTPUT_ENABLED ) {
-                /* remove AsynchFGTxSCB and and PCMSerialInput_II */
+                /* remove AsynchFGTxSCB and PCMSerialInput_II */
                 cs46xx_dsp_disable_spdif_out (chip);