Changeset 615 for GPL/branches/uniaud32-next/alsa-kernel/pci/atiixp.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/atiixp.c (modified) (46 diffs)

GPL/branches/uniaud32-next/alsa-kernel/pci/atiixp.c

@@ +1 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
 /*
  *   ALSA driver for ATI IXP 150/200/250/300 AC97 controllers
  *
  *      Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
- *
- *   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>
@@ -48 +34 @@
 static int ac97_clock = 48000;
 static char *ac97_quirk;
-static int spdif_aclink = 1;
+static bool spdif_aclink = 1;
 static int ac97_codec = -1;
 
@@ -65 +51 @@
 
 /* just for backward compatibility */
-//static int enable;
+//static bool enable;
 module_param(enable, bool, 0444);
 
@@ -212 +198 @@
 
 struct atiixp_dma_desc {
-        u32 addr;       /* DMA buffer address */
+        __le32 addr;    /* DMA buffer address */
         u16 status;     /* status bits */
         u16 size;       /* size of the packet in dwords */
-        u32 next;       /* address of the next packet descriptor */
+        __le32 next;    /* address of the next packet descriptor */
 };
 
@@ -291 +277 @@
 /*
  */
-static DEFINE_PCI_DEVICE_TABLE(snd_atiixp_ids) = {
+static const struct pci_device_id snd_atiixp_ids[] = {
         { PCI_VDEVICE(ATI, 0x4341), 0 }, /* SB200 */
         { PCI_VDEVICE(ATI, 0x4361), 0 }, /* SB300 */
@@ -301 +287 @@
 MODULE_DEVICE_TABLE(pci, snd_atiixp_ids);
 
-static struct snd_pci_quirk atiixp_quirks[] __devinitdata = {
+static struct snd_pci_quirk atiixp_quirks[] = {
         SND_PCI_QUIRK(0x105b, 0x0c81, "Foxconn RC4107MA-RS2", 0),
         SND_PCI_QUIRK(0x15bd, 0x3100, "DFI RS482", 0),
@@ -440 +426 @@
         while (atiixp_read(chip, PHYS_OUT_ADDR) & ATI_REG_PHYS_OUT_ADDR_EN) {
                 if (! timeout--) {
-                        snd_printk(KERN_WARNING "atiixp: codec acquire timeout\n");
+                        dev_warn(chip->card->dev, "codec acquire timeout\n");
                         return -EBUSY;
                 }
@@ -471 +457 @@
         /* time out may happen during reset */
         if (reg < 0x7c)
-                snd_printk(KERN_WARNING "atiixp: codec read timeout (reg %x)\n", reg);
+                dev_warn(chip->card->dev, "codec read timeout (reg %x)\n", reg);
         return 0xffff;
 }
@@ -495 +481 @@
         struct atiixp *chip = ac97->private_data;
         return snd_atiixp_codec_read(chip, ac97->num, reg);
-    
+ 
 }
 
@@ -532 +518 @@
                 atiixp_update(chip, CMD, ATI_REG_CMD_AC_RESET, ATI_REG_CMD_AC_RESET);
                 if (!--timeout) {
-                        snd_printk(KERN_ERR "atiixp: codec reset timeout\n");
+                        dev_err(chip->card->dev, "codec reset timeout\n");
                         break;
                 }
@@ -545 +531 @@
 }
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 static int snd_atiixp_aclink_down(struct atiixp *chip)
 {
@@ -571 +557 @@
 #define CODEC_CHECK_BITS (ALL_CODEC_NOT_READY|ATI_REG_ISR_NEW_FRAME)
 
-static int __devinit ac97_probing_bugs(struct pci_dev *pci)
+static int ac97_probing_bugs(struct pci_dev *pci)
 {
         const struct snd_pci_quirk *q;
@@ -577 +563 @@
         q = snd_pci_quirk_lookup(pci, atiixp_quirks);
         if (q) {
-#ifndef TARGET_OS2
-                snd_printdd(KERN_INFO "Atiixp quirk for %s.  "
-                            "Forcing codec %d\n", q->name, q->value);
-#endif
+                dev_dbg(&pci->dev, "atiixp quirk for %s.  Forcing codec %d\n",
+                        snd_pci_quirk_name(q), q->value);
+
                 return q->value;
         }
@@ -587 +572 @@
 }
 
-static int __devinit snd_atiixp_codec_detect(struct atiixp *chip)
+static int snd_atiixp_codec_detect(struct atiixp *chip)
 {
         int timeout;
@@ -611 +596 @@
 
         if ((chip->codec_not_ready_bits & ALL_CODEC_NOT_READY) == ALL_CODEC_NOT_READY) {
-                snd_printk(KERN_ERR "atiixp: no codec detected!\n");
+                dev_err(chip->card->dev, "no codec detected!\n");
                 return -ENXIO;
         }
@@ -687 +672 @@
                 return bytes_to_frames(runtime, curptr);
         }
-        snd_printd("atiixp: invalid DMA pointer read 0x%x (buf=%x)\n",
+        dev_dbg(chip->card->dev, "invalid DMA pointer read 0x%x (buf=%x)\n",
                    readl(chip->remap_addr + dma->ops->dt_cur), dma->buf_addr);
         return 0;
@@ -699 +684 @@
         if (! dma->substream || ! dma->running)
                 return;
-        snd_printdd("atiixp: XRUN detected (DMA %d)\n", dma->ops->type);
-        snd_pcm_stream_lock(dma->substream);
-        snd_pcm_stop(dma->substream, SNDRV_PCM_STATE_XRUN);
-        snd_pcm_stream_unlock(dma->substream);
+        dev_dbg(chip->card->dev, "XRUN detected (DMA %d)\n", dma->ops->type);
+        snd_pcm_stop_xrun(dma->substream);
 }
 
@@ -747 +730 @@
         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
         case SNDRV_PCM_TRIGGER_RESUME:
+                if (dma->running && dma->suspended &&
+                    cmd == SNDRV_PCM_TRIGGER_RESUME)
+                        writel(dma->saved_curptr, chip->remap_addr +
+                               dma->ops->dt_cur);
                 dma->ops->enable_transfer(chip, 1);
                 dma->running = 1;
@@ -754 +741 @@
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
         case SNDRV_PCM_TRIGGER_SUSPEND:
+                dma->suspended = cmd == SNDRV_PCM_TRIGGER_SUSPEND;
+                if (dma->running && dma->suspended)
+                        dma->saved_curptr = readl(chip->remap_addr +
+                                                  dma->ops->dt_cur);
                 dma->ops->enable_transfer(chip, 0);
                 dma->running = 0;
-                dma->suspended = cmd == SNDRV_PCM_TRIGGER_SUSPEND;
                 break;
         default:
@@ -917 +907 @@
                 data |= ATI_REG_OUT_DMA_SLOT_BIT(10) |
                         ATI_REG_OUT_DMA_SLOT_BIT(11);
-                /* fallthru */
+                /* fall through */
         case 6:
                 data |= ATI_REG_OUT_DMA_SLOT_BIT(7) |
                         ATI_REG_OUT_DMA_SLOT_BIT(8);
-                /* fallthru */
+                /* fall through */
         case 4:
                 data |= ATI_REG_OUT_DMA_SLOT_BIT(6) |
                         ATI_REG_OUT_DMA_SLOT_BIT(9);
-                /* fallthru */
+                /* fall through */
         default:
                 data |= ATI_REG_OUT_DMA_SLOT_BIT(3) |
@@ -1023 +1013 @@
  * pcm hardware definition, identical for all DMA types
  */
-static struct snd_pcm_hardware snd_atiixp_pcm_hw =
+static const struct snd_pcm_hardware snd_atiixp_pcm_hw =
 {
         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
@@ -1162 +1152 @@
 
 /* AC97 playback */
-static struct snd_pcm_ops snd_atiixp_playback_ops = {
+static const struct snd_pcm_ops snd_atiixp_playback_ops = {
         .open =         snd_atiixp_playback_open,
         .close =        snd_atiixp_playback_close,
@@ -1174 +1164 @@
 
 /* AC97 capture */
-static struct snd_pcm_ops snd_atiixp_capture_ops = {
+static const struct snd_pcm_ops snd_atiixp_capture_ops = {
         .open =         snd_atiixp_capture_open,
         .close =        snd_atiixp_capture_close,
@@ -1186 +1176 @@
 
 /* SPDIF playback */
-static struct snd_pcm_ops snd_atiixp_spdif_ops = {
+static const struct snd_pcm_ops snd_atiixp_spdif_ops = {
         .open =         snd_atiixp_spdif_open,
         .close =        snd_atiixp_spdif_close,
@@ -1197 +1187 @@
 };
 
-static struct ac97_pcm atiixp_pcm_defs[] __devinitdata = {
+static const struct ac97_pcm atiixp_pcm_defs[] = {
         /* front PCM */
         {
@@ -1233 +1223 @@
 };
 
-static struct atiixp_dma_ops snd_atiixp_playback_dma_ops = {
+static const struct atiixp_dma_ops snd_atiixp_playback_dma_ops = {
         .type = ATI_DMA_PLAYBACK,
         .llp_offset = ATI_REG_OUT_DMA_LINKPTR,
@@ -1242 +1232 @@
 };
         
-static struct atiixp_dma_ops snd_atiixp_capture_dma_ops = {
+static const struct atiixp_dma_ops snd_atiixp_capture_dma_ops = {
         .type = ATI_DMA_CAPTURE,
         .llp_offset = ATI_REG_IN_DMA_LINKPTR,
@@ -1251 +1241 @@
 };
         
-static struct atiixp_dma_ops snd_atiixp_spdif_dma_ops = {
+static const struct atiixp_dma_ops snd_atiixp_spdif_dma_ops = {
         .type = ATI_DMA_SPDIF,
         .llp_offset = ATI_REG_SPDF_DMA_LINKPTR,
@@ -1261 +1251 @@
         
 
-static int __devinit snd_atiixp_pcm_new(struct atiixp *chip)
+static int snd_atiixp_pcm_new(struct atiixp *chip)
 {
         struct snd_pcm *pcm;
+        struct snd_pcm_chmap *chmap;
         struct snd_ac97_bus *pbus = chip->ac97_bus;
         int err, i, num_pcms;
@@ -1306 +1297 @@
                                               snd_dma_pci_data(chip->pci),
                                               64*1024, 128*1024);
+
+        err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK,
+                                     snd_pcm_alt_chmaps, chip->max_channels, 0,
+                                     &chmap);
+        if (err < 0)
+                return err;
+        chmap->channel_mask = SND_PCM_CHMAP_MASK_2468;
+        chip->ac97[0]->chmaps[SNDRV_PCM_STREAM_PLAYBACK] = chmap;
 
         /* no SPDIF support on codec? */
@@ -1395 +1394 @@
  */
 
-static struct ac97_quirk ac97_quirks[] __devinitdata = {
+static const struct ac97_quirk ac97_quirks[] = {
         {
                 .subvendor = 0x103c,
@@ -1417 +1416 @@
 };
 
-static int __devinit snd_atiixp_mixer_new(struct atiixp *chip, int clock,
-                                          const char *quirk_override)
+static int snd_atiixp_mixer_new(struct atiixp *chip, int clock,
+                                const char *quirk_override)
 {
         struct snd_ac97_bus *pbus;
@@ -1455 +1454 @@
                 if ((err = snd_ac97_mixer(pbus, &ac97, &chip->ac97[i])) < 0) {
                         chip->ac97[i] = NULL; /* to be sure */
-                        snd_printdd("atiixp: codec %d not available for audio\n", i);
+                        dev_dbg(chip->card->dev,
+                                "codec %d not available for audio\n", i);
                         continue;
                 }
@@ -1462 +1462 @@
 
         if (! codec_count) {
-                snd_printk(KERN_ERR "atiixp: no codec available\n");
+                dev_err(chip->card->dev, "no codec available\n");
                 return -ENODEV;
         }
@@ -1472 +1472 @@
 
 
-#ifdef CONFIG_PM
+#ifdef CONFIG_PM_SLEEP
 /*
  * power management
  */
-static int snd_atiixp_suspend(struct pci_dev *pci, pm_message_t state)
-{
-        struct snd_card *card = pci_get_drvdata(pci);
+static int snd_atiixp_suspend(struct device *dev)
+{
+        struct snd_card *card = dev_get_drvdata(dev);
         struct atiixp *chip = card->private_data;
         int i;
 
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        for (i = 0; i < NUM_ATI_PCMDEVS; i++)
-                if (chip->pcmdevs[i]) {
-                        struct atiixp_dma *dma = &chip->dmas[i];
-                        if (dma->substream && dma->running)
-                                dma->saved_curptr = readl(chip->remap_addr +
-                                                          dma->ops->dt_cur);
-                        snd_pcm_suspend_all(chip->pcmdevs[i]);
-                }
         for (i = 0; i < NUM_ATI_CODECS; i++)
                 snd_ac97_suspend(chip->ac97[i]);
         snd_atiixp_aclink_down(chip);
         snd_atiixp_chip_stop(chip);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, pci_choose_state(pci, state));
-        return 0;
-}
-
-static int snd_atiixp_resume(struct pci_dev *pci)
-{
-        struct snd_card *card = pci_get_drvdata(pci);
+        return 0;
+}
+
+static int snd_atiixp_resume(struct device *dev)
+{
+        struct snd_card *card = dev_get_drvdata(dev);
         struct atiixp *chip = card->private_data;
         int i;
-
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "atiixp: pci_enable_device failed, "
-                       "disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
 
         snd_atiixp_aclink_reset(chip);
@@ -1532 +1510 @@
                                 writel((u32)dma->desc_buf.addr | ATI_REG_LINKPTR_EN,
                                        chip->remap_addr + dma->ops->llp_offset);
-                                writel(dma->saved_curptr, chip->remap_addr +
-                                       dma->ops->dt_cur);
                         }
                 }
@@ -1540 +1516 @@
         return 0;
 }
-#endif /* CONFIG_PM */
-
-
-#ifdef CONFIG_PROC_FS
+
+static SIMPLE_DEV_PM_OPS(snd_atiixp_pm, snd_atiixp_suspend, snd_atiixp_resume);
+#define SND_ATIIXP_PM_OPS       &snd_atiixp_pm
+#else
+#define SND_ATIIXP_PM_OPS       NULL
+#endif /* CONFIG_PM_SLEEP */
+
+
 /*
  * proc interface for register dump
@@ -1558 +1538 @@
 }
 
-static void __devinit snd_atiixp_proc_init(struct atiixp *chip)
-{
-        struct snd_info_entry *entry;
-
-        if (! snd_card_proc_new(chip->card, "atiixp", &entry))
-                snd_info_set_text_ops(entry, chip, snd_atiixp_proc_read);
-}
-#else /* !CONFIG_PROC_FS */
-#define snd_atiixp_proc_init(chip)
-#endif
+static void snd_atiixp_proc_init(struct atiixp *chip)
+{
+        snd_card_ro_proc_new(chip->card, "atiixp", chip, snd_atiixp_proc_read);
+}
 
 
@@ -1583 +1557 @@
         if (chip->irq >= 0)
                 free_irq(chip->irq, chip);
-        if (chip->remap_addr)
-                iounmap(chip->remap_addr);
+        iounmap(chip->remap_addr);
         pci_release_regions(chip->pci);
         pci_disable_device(chip->pci);
@@ -1600 +1573 @@
  * constructor for chip instance
  */
-static int __devinit snd_atiixp_create(struct snd_card *card,
-                                      struct pci_dev *pci,
-                                      struct atiixp **r_chip)
+static int snd_atiixp_create(struct snd_card *card,
+                             struct pci_dev *pci,
+                             struct atiixp **r_chip)
 {
         static struct snd_device_ops ops = {
@@ -1632 +1605 @@
         chip->remap_addr = pci_ioremap_bar(pci, 0);
         if (chip->remap_addr == NULL) {
-                snd_printk(KERN_ERR "AC'97 space ioremap problem\n");
+                dev_err(card->dev, "AC'97 space ioremap problem\n");
                 snd_atiixp_free(chip);
                 return -EIO;
@@ -1639 +1612 @@
         if (request_irq(pci->irq, snd_atiixp_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_atiixp_free(chip);
                 return -EBUSY;
@@ -1652 +1625 @@
         }
 
-        snd_card_set_dev(card, &pci->dev);
-
         *r_chip = chip;
         return 0;
@@ -1659 +1630 @@
 
 
-static int __devinit snd_atiixp_probe(struct pci_dev *pci,
-                                     const struct pci_device_id *pci_id)
+static int snd_atiixp_probe(struct pci_dev *pci,
+                            const struct pci_device_id *pci_id)
 {
         struct snd_card *card;
@@ -1666 +1637 @@
         int err;
 
-        err = snd_card_create(index, id, THIS_MODULE, 0, &card);
+        err = snd_card_new(&pci->dev, index, id, THIS_MODULE, 0, &card);
         if (err < 0)
                 return err;
@@ -1712 +1683 @@
 }
 
-static void __devexit snd_atiixp_remove(struct pci_dev *pci)
+static void snd_atiixp_remove(struct pci_dev *pci)
 {
         snd_card_free(pci_get_drvdata(pci));
-        pci_set_drvdata(pci, NULL);
-}
-
-static struct pci_driver driver = {
+}
+
+static struct pci_driver atiixp_driver = {
         .name = KBUILD_MODNAME,
         .id_table = snd_atiixp_ids,
         .probe = snd_atiixp_probe,
-        .remove = __devexit_p(snd_atiixp_remove),
-#ifdef CONFIG_PM
-        .suspend = snd_atiixp_suspend,
-        .resume = snd_atiixp_resume,
-#endif
+        .remove = snd_atiixp_remove,
+        .driver = {
+                .pm = SND_ATIIXP_PM_OPS,
+        },
 };
 
-
-static int __init alsa_card_atiixp_init(void)
-{
-        return pci_register_driver(&driver);
-}
-
-static void __exit alsa_card_atiixp_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-
-module_init(alsa_card_atiixp_init)
-module_exit(alsa_card_atiixp_exit)
+module_pci_driver(atiixp_driver);