Changeset 615 for GPL/branches/uniaud32-next/alsa-kernel/pci/cs4281.c

Timestamp:

Jan 1, 2021, 5:31:48 AM (5 years ago)

Author:

Paul Smedley

Message:

Add source for uniaud32 based on code from linux kernel 5.4.86

Location:

GPL/branches/uniaud32-next

Files:

• . (copied) (copied from GPL/branches/uniaud32-linux-3.2.102 )
• alsa-kernel/pci/cs4281.c (modified) (49 diffs)

GPL/branches/uniaud32-next/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
- *
  */
 
-#ifdef TARGET_OS2
-#define KBUILD_MODNAME "cs4281"
-#endif
-
-#include <asm/io.h>
+#include <linux/io.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
@@ -42 +23 @@
 
 
+#ifdef TARGET_OS2
+#define KBUILD_MODNAME "cs4281"
+#endif
 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>");
 MODULE_DESCRIPTION("Cirrus Logic CS4281");
@@ -49 +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);
@@ -491 +475 @@
         struct gameport *gameport;
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
         u32 suspend_regs[SUSPEND_REGISTERS];
 #endif
@@ -499 +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, }
@@ -569 +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);
 }
 
@@ -629 +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;
@@ -648 +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;
@@ -711 +698 @@
 static unsigned int snd_cs4281_rate(unsigned int rate, unsigned int *real_rate)
 {
-        unsigned int val = ~0;
+        unsigned int val;
         
         if (real_rate)
@@ -724 +711 @@
         case 48000:     return 0;
         default:
-                goto __variable;
-        }
-      __variable:
+                break;
+        }
         val = 1536000 / rate;
         if (real_rate)
@@ -840 +826 @@
 
         /*
-        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);
         */
@@ -848 +835 @@
 }
 
-static struct snd_pcm_hardware snd_cs4281_playback =
+static const struct snd_pcm_hardware snd_cs4281_playback =
 {
         .info =                 SNDRV_PCM_INFO_MMAP |
@@ -873 +860 @@
 };
 
-static struct snd_pcm_hardware snd_cs4281_capture =
+static const struct snd_pcm_hardware snd_cs4281_capture =
 {
         .info =                 SNDRV_PCM_INFO_MMAP |
@@ -952 +939 @@
 }
 
-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,
@@ -963 +950 @@
 };
 
-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,
@@ -974 +961 @@
 };
 
-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)
@@ -997 +981 @@
                                               snd_dma_pci_data(chip->pci), 64*1024, 512*1024);
 
-        if (rpcm)
-                *rpcm = pcm;
         return 0;
 }
@@ -1061 +1043 @@
 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,
@@ -1072 +1054 @@
 };
 
-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,
@@ -1098 +1080 @@
 }
 
-static int __devinit snd_cs4281_mixer(struct cs4281 * chip)
+static int snd_cs4281_mixer(struct cs4281 *chip)
 {
         struct snd_card *card = chip->card;
@@ -1176 +1158 @@
 };
 
-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;
@@ -1200 +1181 @@
  */
 
-#if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
+#if IS_REACHABLE(CONFIG_GAMEPORT)
 
 static void snd_cs4281_gameport_trigger(struct gameport *gameport)
@@ -1264 +1245 @@
 }
 
-static int __devinit snd_cs4281_create_gameport(struct cs4281 *chip)
+static int snd_cs4281_create_gameport(struct cs4281 *chip)
 {
         struct gameport *gp;
@@ -1270 +1251 @@
         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;
         }
@@ -1301 +1283 @@
 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)
@@ -1317 +1299 @@
         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);
@@ -1340 +1320 @@
 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;
@@ -1366 +1346 @@
         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;
         }
@@ -1388 +1368 @@
         if (request_irq(pci->irq, snd_cs4281_interrupt, IRQF_SHARED,
                         KBUILD_MODNAME, chip)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_cs4281_free(chip);
                 return -ENOMEM;
@@ -1406 +1386 @@
 
         snd_cs4281_proc_init(chip);
-
-        snd_card_set_dev(card, &pci->dev);
 
         *rchip = chip;
@@ -1430 +1408 @@
                 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;
                 }
@@ -1441 +1420 @@
         
         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;
         }
@@ -1507 +1488 @@
         } 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;
 
@@ -1533 +1514 @@
         } 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;
 
@@ -1544 +1527 @@
                         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: ;
@@ -1574 +1558 @@
         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;
 
@@ -1770 +1754 @@
 }
 
-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,
@@ -1777 +1761 @@
 };
 
-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,
@@ -1784 +1768 @@
 };
 
-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;
@@ -1800 +1781 @@
         rmidi->private_data = chip;
         chip->rmidi = rmidi;
-        if (rrawmidi)
-                *rrawmidi = rmidi;
         return 0;
 }
@@ -1906 +1885 @@
 }
 
-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;
@@ -1922 +1901 @@
         }
 
-        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;
@@ -1936 +1916 @@
                 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;
@@ -1973 +1953 @@
 }
 
-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);
 }
 
@@ -1982 +1961 @@
  * Power Management
  */
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 
 static int saved_regs[SUSPEND_REGISTERS] = {
@@ -2002 +1981 @@
 #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;
@@ -2010 +1989 @@
 
         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);
@@ -2042 +2019 @@
         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);
@@ -2087 +2050 @@
         return 0;
 }
-#endif /* CONFIG_PM */
-
-static struct pci_driver driver = {
+
+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);