Changeset 679 for GPL/trunk/alsa-kernel/pci/cs4281.c

Timestamp:

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

Author:

David Azarewicz

Message:

Merge changes from Paul's uniaud32next branch.

Location:

GPL/trunk

Files:

• . (modified) (1 prop)
• alsa-kernel/pci/cs4281.c (modified) (52 diffs)

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

@@ +1 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
 /*
  *  Driver for Cirrus Logic CS4281 based PCI soundcard
  *  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
- *
  */
 
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
@@ -27 +12 @@
 #include <linux/slab.h>
 #include <linux/gameport.h>
-#include <linux/moduleparam.h>
+#include <linux/module.h>
 #include <sound/core.h>
 #include <sound/control.h>
@@ -38 +23 @@
 
 
+#ifdef TARGET_OS2
+#define KBUILD_MODNAME "cs4281"
+#endif
 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
 MODULE_DESCRIPTION("Cirrus Logic CS4281");
@@ -45 +33 @@
 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 switches */
-static int dual_codec[SNDRV_CARDS];     /* dual codec */
+static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;     /* Enable switches */
+static bool dual_codec[SNDRV_CARDS];    /* dual codec */
 
 module_param_array(index, int, NULL, 0444);
@@ -487 +475 @@
         struct gameport *gameport;
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
         u32 suspend_regs[SUSPEND_REGISTERS];
 #endif
@@ -495 +483 @@
 static irqreturn_t snd_cs4281_interrupt(int irq, void *dev_id);
 
-static DEFINE_PCI_DEVICE_TABLE(snd_cs4281_ids) = {
+static const struct pci_device_id snd_cs4281_ids[] = {
         { PCI_VDEVICE(CIRRUS, 0x6005), 0, },    /* CS4281 */
         { 0, }
@@ -565 +553 @@
                 }
         }
-        snd_printk(KERN_ERR "AC'97 write problem, reg = 0x%x, val = 0x%x\n", reg, val);
+        dev_err(chip->card->dev,
+                "AC'97 write problem, reg = 0x%x, val = 0x%x\n", reg, val);
 }
 
@@ -625 +614 @@
         }
 
-        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;
@@ -644 +634 @@
         }
         
-        snd_printk(KERN_ERR "AC'97 read problem (ACSTS_VSTS), reg = 0x%x\n", reg);
+        dev_err(chip->card->dev,
+                "AC'97 read problem (ACSTS_VSTS), reg = 0x%x\n", reg);
         result = 0xffff;
         goto __end;
@@ -707 +698 @@
 static unsigned int snd_cs4281_rate(unsigned int rate, unsigned int *real_rate)
 {
-        unsigned int val = ~0;
+        unsigned int val;
         
         if (real_rate)
@@ -720 +711 @@
         case 48000:     return 0;
         default:
-                goto __variable;
-        }
-      __variable:
+                break;
+        }
         val = 1536000 / rate;
         if (real_rate)
@@ -794 +784 @@
 }
 
-static int snd_cs4281_hw_params(struct snd_pcm_substream *substream,
-                                struct snd_pcm_hw_params *hw_params)
-{
-        return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
-}
-
-static int snd_cs4281_hw_free(struct snd_pcm_substream *substream)
-{
-        return snd_pcm_lib_free_pages(substream);
-}
-
 static int snd_cs4281_playback_prepare(struct snd_pcm_substream *substream)
 {
@@ -836 +815 @@
 
         /*
-        printk(KERN_DEBUG "DCC = 0x%x, buffer_size = 0x%x, jiffies = %li\n",
-               snd_cs4281_peekBA0(chip, dma->regDCC), runtime->buffer_size,
+        dev_dbg(chip->card->dev,
+                "DCC = 0x%x, buffer_size = 0x%x, jiffies = %li\n",
+                snd_cs4281_peekBA0(chip, dma->regDCC), runtime->buffer_size,
                jiffies);
         */
@@ -844 +824 @@
 }
 
-static struct snd_pcm_hardware snd_cs4281_playback =
+static const struct snd_pcm_hardware snd_cs4281_playback =
 {
         .info =                 SNDRV_PCM_INFO_MMAP |
@@ -869 +849 @@
 };
 
-static struct snd_pcm_hardware snd_cs4281_capture =
+static const struct snd_pcm_hardware snd_cs4281_capture =
 {
         .info =                 SNDRV_PCM_INFO_MMAP |
@@ -948 +928 @@
 }
 
-static struct snd_pcm_ops snd_cs4281_playback_ops = {
+static const struct snd_pcm_ops snd_cs4281_playback_ops = {
         .open =         snd_cs4281_playback_open,
         .close =        snd_cs4281_playback_close,
-        .ioctl =        snd_pcm_lib_ioctl,
-        .hw_params =    snd_cs4281_hw_params,
-        .hw_free =      snd_cs4281_hw_free,
         .prepare =      snd_cs4281_playback_prepare,
         .trigger =      snd_cs4281_trigger,
@@ -959 +936 @@
 };
 
-static struct snd_pcm_ops snd_cs4281_capture_ops = {
+static const struct snd_pcm_ops snd_cs4281_capture_ops = {
         .open =         snd_cs4281_capture_open,
         .close =        snd_cs4281_capture_close,
-        .ioctl =        snd_pcm_lib_ioctl,
-        .hw_params =    snd_cs4281_hw_params,
-        .hw_free =      snd_cs4281_hw_free,
         .prepare =      snd_cs4281_capture_prepare,
         .trigger =      snd_cs4281_trigger,
@@ -970 +944 @@
 };
 
-static int __devinit snd_cs4281_pcm(struct cs4281 * chip, int device,
-                                    struct snd_pcm ** rpcm)
+static int snd_cs4281_pcm(struct cs4281 *chip, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         err = snd_pcm_new(chip->card, "CS4281", device, 1, 1, &pcm);
         if (err < 0)
@@ -990 +961 @@
         chip->pcm = pcm;
 
-        snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                              snd_dma_pci_data(chip->pci), 64*1024, 512*1024);
-
-        if (rpcm)
-                *rpcm = pcm;
+        snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV, &chip->pci->dev,
+                                       64*1024, 512*1024);
+
         return 0;
 }
@@ -1057 +1026 @@
 static const DECLARE_TLV_DB_SCALE(db_scale_dsp, -4650, 150, 0);
 
-static struct snd_kcontrol_new snd_cs4281_fm_vol = 
+static const struct snd_kcontrol_new snd_cs4281_fm_vol =
 {
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -1068 +1037 @@
 };
 
-static struct snd_kcontrol_new snd_cs4281_pcm_vol = 
+static const struct snd_kcontrol_new snd_cs4281_pcm_vol =
 {
         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -1094 +1063 @@
 }
 
-static int __devinit snd_cs4281_mixer(struct cs4281 * chip)
+static int snd_cs4281_mixer(struct cs4281 *chip)
 {
         struct snd_card *card = chip->card;
         struct snd_ac97_template ac97;
         int err;
-        static struct snd_ac97_bus_ops ops = {
+        static const struct snd_ac97_bus_ops ops = {
                 .write = snd_cs4281_ac97_write,
                 .read = snd_cs4281_ac97_read,
@@ -1164 +1133 @@
 }
 
-static struct snd_info_entry_ops snd_cs4281_proc_ops_BA0 = {
+static const struct snd_info_entry_ops snd_cs4281_proc_ops_BA0 = {
         .read = snd_cs4281_BA0_read,
 };
 
-static struct snd_info_entry_ops snd_cs4281_proc_ops_BA1 = {
+static const struct snd_info_entry_ops snd_cs4281_proc_ops_BA1 = {
         .read = snd_cs4281_BA1_read,
 };
 
-static void __devinit snd_cs4281_proc_init(struct cs4281 * chip)
+static void snd_cs4281_proc_init(struct cs4281 *chip)
 {
         struct snd_info_entry *entry;
 
-        if (! snd_card_proc_new(chip->card, "cs4281", &entry))
-                snd_info_set_text_ops(entry, chip, snd_cs4281_proc_read);
+        snd_card_ro_proc_new(chip->card, "cs4281", chip, snd_cs4281_proc_read);
         if (! snd_card_proc_new(chip->card, "cs4281_BA0", &entry)) {
                 entry->content = SNDRV_INFO_CONTENT_DATA;
@@ -1196 +1164 @@
  */
 
-#if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
+#if IS_REACHABLE(CONFIG_GAMEPORT)
 
 static void snd_cs4281_gameport_trigger(struct gameport *gameport)
@@ -1260 +1228 @@
 }
 
-static int __devinit snd_cs4281_create_gameport(struct cs4281 *chip)
+static int snd_cs4281_create_gameport(struct cs4281 *chip)
 {
         struct gameport *gp;
@@ -1266 +1234 @@
         chip->gameport = gp = gameport_allocate_port();
         if (!gp) {
-                printk(KERN_ERR "cs4281: cannot allocate memory for gameport\n");
+                dev_err(chip->card->dev,
+                        "cannot allocate memory for gameport\n");
                 return -ENOMEM;
         }
@@ -1297 +1266 @@
 static inline int snd_cs4281_create_gameport(struct cs4281 *chip) { return -ENOSYS; }
 static inline void snd_cs4281_free_gameport(struct cs4281 *chip) { }
-#endif /* CONFIG_GAMEPORT || (MODULE && CONFIG_GAMEPORT_MODULE) */
+#endif /* IS_REACHABLE(CONFIG_GAMEPORT) */
 
 static int snd_cs4281_free(struct cs4281 *chip)
 {
         snd_cs4281_free_gameport(chip);
-
-        if (chip->irq >= 0)
-                synchronize_irq(chip->irq);
 
         /* Mask interrupts */
@@ -1313 +1279 @@
         snd_cs4281_pokeBA0(chip, BA0_SSPM, 0);
         /* PCI interface - D3 state */
-        pci_set_power_state(chip->pci, 3);
+        pci_set_power_state(chip->pci, PCI_D3hot);
 
         if (chip->irq >= 0)
                 free_irq(chip->irq, chip);
-        if (chip->ba0)
-                iounmap(chip->ba0);
-        if (chip->ba1)
-                iounmap(chip->ba1);
+        iounmap(chip->ba0);
+        iounmap(chip->ba1);
         pci_release_regions(chip->pci);
         pci_disable_device(chip->pci);
@@ -1336 +1300 @@
 static int snd_cs4281_chip_init(struct cs4281 *chip); /* defined below */
 
-static int __devinit snd_cs4281_create(struct snd_card *card,
-                                       struct pci_dev *pci,
-                                       struct cs4281 ** rchip,
-                                       int dual_codec)
+static int snd_cs4281_create(struct snd_card *card,
+                             struct pci_dev *pci,
+                             struct cs4281 **rchip,
+                             int dual_codec)
 {
         struct cs4281 *chip;
         unsigned int tmp;
         int err;
-        static struct snd_device_ops ops = {
+        static const struct snd_device_ops ops = {
                 .dev_free =     snd_cs4281_dev_free,
         };
@@ -1362 +1326 @@
         pci_set_master(pci);
         if (dual_codec < 0 || dual_codec > 3) {
-                snd_printk(KERN_ERR "invalid dual_codec option %d\n", dual_codec);
+                dev_err(card->dev, "invalid dual_codec option %d\n", dual_codec);
                 dual_codec = 0;
         }
@@ -1383 +1347 @@
         
         if (request_irq(pci->irq, snd_cs4281_interrupt, IRQF_SHARED,
-                        "CS4281", chip)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                        KBUILD_MODNAME, chip)) {
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_cs4281_free(chip);
                 return -ENOMEM;
         }
         chip->irq = pci->irq;
+        card->sync_irq = chip->irq;
 
         tmp = snd_cs4281_chip_init(chip);
@@ -1402 +1367 @@
 
         snd_cs4281_proc_init(chip);
-
-        snd_card_set_dev(card, &pci->dev);
 
         *rchip = chip;
@@ -1426 +1389 @@
                 tmp = snd_cs4281_peekBA0(chip, BA0_CFLR);
                 if (tmp != BA0_CFLR_DEFAULT) {
-                        snd_printk(KERN_ERR "CFLR setup failed (0x%x)\n", tmp);
+                        dev_err(chip->card->dev,
+                                "CFLR setup failed (0x%x)\n", tmp);
                         return -EIO;
                 }
@@ -1437 +1401 @@
         
         if ((tmp = snd_cs4281_peekBA0(chip, BA0_SERC1)) != (BA0_SERC1_SO1EN | BA0_SERC1_AC97)) {
-                snd_printk(KERN_ERR "SERC1 AC'97 check failed (0x%x)\n", tmp);
+                dev_err(chip->card->dev,
+                        "SERC1 AC'97 check failed (0x%x)\n", tmp);
                 return -EIO;
         }
         if ((tmp = snd_cs4281_peekBA0(chip, BA0_SERC2)) != (BA0_SERC2_SI1EN | BA0_SERC2_AC97)) {
-                snd_printk(KERN_ERR "SERC2 AC'97 check failed (0x%x)\n", tmp);
+                dev_err(chip->card->dev,
+                        "SERC2 AC'97 check failed (0x%x)\n", tmp);
                 return -EIO;
         }
@@ -1503 +1469 @@
         } while (time_after_eq(end_time, jiffies));
 
-        snd_printk(KERN_ERR "DLLRDY not seen\n");
+        dev_err(chip->card->dev, "DLLRDY not seen\n");
         return -EIO;
 
@@ -1529 +1495 @@
         } while (time_after_eq(end_time, jiffies));
 
-        snd_printk(KERN_ERR "never read codec ready from AC'97 (0x%x)\n", snd_cs4281_peekBA0(chip, BA0_ACSTS));
+        dev_err(chip->card->dev,
+                "never read codec ready from AC'97 (0x%x)\n",
+                snd_cs4281_peekBA0(chip, BA0_ACSTS));
         return -EIO;
 
@@ -1540 +1508 @@
                         schedule_timeout_uninterruptible(1);
                 } while (time_after_eq(end_time, jiffies));
-                snd_printk(KERN_INFO "secondary codec doesn't respond. disable it...\n");
+                dev_info(chip->card->dev,
+                         "secondary codec doesn't respond. disable it...\n");
                 chip->dual_codec = 0;
         __codec2_ok: ;
@@ -1570 +1539 @@
         if (--retry_count > 0)
                 goto __retry;
-        snd_printk(KERN_ERR "never read ISV3 and ISV4 from AC'97\n");
+        dev_err(chip->card->dev, "never read ISV3 and ISV4 from AC'97\n");
         return -EIO;
 
@@ -1633 +1602 @@
                                         BA0_HISR_DMA(2) |
                                         BA0_HISR_DMA(3)));
-        synchronize_irq(chip->irq);
 
         return 0;
@@ -1766 +1734 @@
 }
 
-static struct snd_rawmidi_ops snd_cs4281_midi_output =
+static const struct snd_rawmidi_ops snd_cs4281_midi_output =
 {
         .open =         snd_cs4281_midi_output_open,
@@ -1773 +1741 @@
 };
 
-static struct snd_rawmidi_ops snd_cs4281_midi_input =
+static const struct snd_rawmidi_ops snd_cs4281_midi_input =
 {
         .open =         snd_cs4281_midi_input_open,
@@ -1780 +1748 @@
 };
 
-static int __devinit snd_cs4281_midi(struct cs4281 * chip, int device,
-                                     struct snd_rawmidi **rrawmidi)
+static int snd_cs4281_midi(struct cs4281 *chip, int device)
 {
         struct snd_rawmidi *rmidi;
         int err;
 
-        if (rrawmidi)
-                *rrawmidi = NULL;
         if ((err = snd_rawmidi_new(chip->card, "CS4281", device, 1, 1, &rmidi)) < 0)
                 return err;
@@ -1796 +1761 @@
         rmidi->private_data = chip;
         chip->rmidi = rmidi;
-        if (rrawmidi)
-                *rrawmidi = rmidi;
         return 0;
 }
@@ -1902 +1865 @@
 }
 
-static int __devinit snd_cs4281_probe(struct pci_dev *pci,
-                                      const struct pci_device_id *pci_id)
+static int snd_cs4281_probe(struct pci_dev *pci,
+                            const struct pci_device_id *pci_id)
 {
         static int dev;
@@ -1918 +1881 @@
         }
 
-        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;
@@ -1932 +1896 @@
                 return err;
         }
-        if ((err = snd_cs4281_pcm(chip, 0, NULL)) < 0) {
+        if ((err = snd_cs4281_pcm(chip, 0)) < 0) {
                 snd_card_free(card);
                 return err;
         }
-        if ((err = snd_cs4281_midi(chip, 0, NULL)) < 0) {
+        if ((err = snd_cs4281_midi(chip, 0)) < 0) {
                 snd_card_free(card);
                 return err;
@@ -1969 +1933 @@
 }
 
-static void __devexit snd_cs4281_remove(struct pci_dev *pci)
+static void snd_cs4281_remove(struct pci_dev *pci)
 {
         snd_card_free(pci_get_drvdata(pci));
-        pci_set_drvdata(pci, NULL);
 }
 
@@ -1978 +1941 @@
  * Power Management
  */
-#ifdef CONFIG_PM
-
-static int saved_regs[SUSPEND_REGISTERS] = {
+#ifdef CONFIG_PM_SLEEP
+
+static const int saved_regs[SUSPEND_REGISTERS] = {
         BA0_JSCTL,
         BA0_GPIOR,
@@ -1998 +1961 @@
 #define CLKCR1_CKRA                             0x00010000L
 
-static int cs4281_suspend(struct pci_dev *pci, pm_message_t state)
-{
-        struct snd_card *card = pci_get_drvdata(pci);
+static int cs4281_suspend(struct device *dev)
+{
+        struct snd_card *card = dev_get_drvdata(dev);
         struct cs4281 *chip = card->private_data;
         u32 ulCLK;
@@ -2006 +1969 @@
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        snd_pcm_suspend_all(chip->pcm);
-
         snd_ac97_suspend(chip->ac97);
         snd_ac97_suspend(chip->ac97_secondary);
@@ -2038 +1999 @@
         ulCLK &= ~CLKCR1_CKRA;
         snd_cs4281_pokeBA0(chip, BA0_CLKCR1, ulCLK);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, pci_choose_state(pci, state));
-        return 0;
-}
-
-static int cs4281_resume(struct pci_dev *pci)
-{
-        struct snd_card *card = pci_get_drvdata(pci);
+        return 0;
+}
+
+static int cs4281_resume(struct device *dev)
+{
+        struct snd_card *card = dev_get_drvdata(dev);
         struct cs4281 *chip = card->private_data;
         unsigned int i;
         u32 ulCLK;
-
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "cs4281: pci_enable_device failed, "
-                       "disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
 
         ulCLK = snd_cs4281_peekBA0(chip, BA0_CLKCR1);
@@ -2083 +2030 @@
         return 0;
 }
-#endif /* CONFIG_PM */
-
-static struct pci_driver driver = {
-        .name = "CS4281",
+
+static SIMPLE_DEV_PM_OPS(cs4281_pm, cs4281_suspend, cs4281_resume);
+#define CS4281_PM_OPS   &cs4281_pm
+#else
+#define CS4281_PM_OPS   NULL
+#endif /* CONFIG_PM_SLEEP */
+
+static struct pci_driver cs4281_driver = {
+        .name = KBUILD_MODNAME,
         .id_table = snd_cs4281_ids,
         .probe = snd_cs4281_probe,
-        .remove = __devexit_p(snd_cs4281_remove),
-#ifdef CONFIG_PM
-        .suspend = cs4281_suspend,
-        .resume = cs4281_resume,
-#endif
+        .remove = snd_cs4281_remove,
+        .driver = {
+                .pm = CS4281_PM_OPS,
+        },
 };
         
-static int __init alsa_card_cs4281_init(void)
-{
-        return pci_register_driver(&driver);
-}
-
-static void __exit alsa_card_cs4281_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-
-module_init(alsa_card_cs4281_init)
-module_exit(alsa_card_cs4281_exit)
+module_pci_driver(cs4281_driver);