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

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/trident/trident.c (modified) (12 diffs)
• alsa-kernel/pci/trident/trident.h (copied) (copied from GPL/branches/uniaud32-next/alsa-kernel/pci/trident/trident.h )
• alsa-kernel/pci/trident/trident_main.c (modified) (68 diffs)
• alsa-kernel/pci/trident/trident_memory.c (modified) (6 diffs)

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

@@ +1 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
 /*
  *  Driver for Trident 4DWave DX/NX & SiS SI7018 Audio PCI soundcard
@@ -4 +5 @@
  *  Driver was originated by Trident <audio@tridentmicro.com>
  *                           Fri Feb 19 15:55:28 MST 1999
- *
- *
- *   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
- *
  */
 
@@ -25 +10 @@
 #include <linux/pci.h>
 #include <linux/time.h>
-#include <linux/moduleparam.h>
+#include <linux/module.h>
 #include <sound/core.h>
-#include <sound/trident.h>
+#include "trident.h"
 #include <sound/initval.h>
+
+#ifdef TARGET_OS2
+#define KBUILD_MODNAME "trident"
+#endif
 
 MODULE_AUTHOR("Jaroslav Kysela <perex@perex.cz>, <audio@tridentmicro.com>");
@@ -48 +37 @@
 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
-static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;      /* Enable this card */
+static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;     /* Enable this card */
 #ifndef TARGET_OS2
 static int pcm_channels[SNDRV_CARDS] = {[0 ... (SNDRV_CARDS - 1)] = 32};
@@ -68 +57 @@
 MODULE_PARM_DESC(wavetable_size, "Maximum memory size in kB for wavetable synth.");
 
-static DEFINE_PCI_DEVICE_TABLE(snd_trident_ids) = {
+static const struct pci_device_id snd_trident_ids[] = {
         {PCI_DEVICE(PCI_VENDOR_ID_TRIDENT, PCI_DEVICE_ID_TRIDENT_4DWAVE_DX), 
                 PCI_CLASS_MULTIMEDIA_AUDIO << 8, 0xffff00, 0},
@@ -79 +68 @@
 MODULE_DEVICE_TABLE(pci, snd_trident_ids);
 
-static int __devinit snd_trident_probe(struct pci_dev *pci,
-                                       const struct pci_device_id *pci_id)
+static int snd_trident_probe(struct pci_dev *pci,
+                             const struct pci_device_id *pci_id)
 {
         static int dev;
@@ -95 +84 @@
         }
 
-        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;
@@ -128 +118 @@
                 strcpy(card->shortname, "Trident ");
         }
-        strcat(card->shortname, card->driver);
+        strcat(card->shortname, str);
         sprintf(card->longname, "%s PCI Audio at 0x%lx, irq %d",
                 card->shortname, trident->port, trident->irq);
 
-        if ((err = snd_trident_pcm(trident, pcm_dev++, NULL)) < 0) {
+        if ((err = snd_trident_pcm(trident, pcm_dev++)) < 0) {
                 snd_card_free(card);
                 return err;
@@ -139 +129 @@
         case TRIDENT_DEVICE_ID_DX:
         case TRIDENT_DEVICE_ID_NX:
-                if ((err = snd_trident_foldback_pcm(trident, pcm_dev++, NULL)) < 0) {
+                if ((err = snd_trident_foldback_pcm(trident, pcm_dev++)) < 0) {
                         snd_card_free(card);
                         return err;
@@ -146 +136 @@
         }
         if (trident->device == TRIDENT_DEVICE_ID_NX || trident->device == TRIDENT_DEVICE_ID_SI7018) {
-                if ((err = snd_trident_spdif_pcm(trident, pcm_dev++, NULL)) < 0) {
+                if ((err = snd_trident_spdif_pcm(trident, pcm_dev++)) < 0) {
                         snd_card_free(card);
                         return err;
@@ -154 +144 @@
             (err = snd_mpu401_uart_new(card, 0, MPU401_HW_TRID4DWAVE,
                                        trident->midi_port,
-                                       MPU401_INFO_INTEGRATED,
-                                       trident->irq, 0, &trident->rmidi)) < 0) {
+                                       MPU401_INFO_INTEGRATED |
+                                       MPU401_INFO_IRQ_HOOK,
+                                       -1, &trident->rmidi)) < 0) {
                 snd_card_free(card);
                 return err;
@@ -171 +162 @@
 }
 
-static void __devexit snd_trident_remove(struct pci_dev *pci)
+static void snd_trident_remove(struct pci_dev *pci)
 {
         snd_card_free(pci_get_drvdata(pci));
-        pci_set_drvdata(pci, NULL);
 }
 
-static struct pci_driver driver = {
-        .name = "Trident4DWaveAudio",
+static struct pci_driver trident_driver = {
+        .name = KBUILD_MODNAME,
         .id_table = snd_trident_ids,
         .probe = snd_trident_probe,
-        .remove = __devexit_p(snd_trident_remove),
-#ifdef CONFIG_PM
-        .suspend = snd_trident_suspend,
-        .resume = snd_trident_resume,
+        .remove = snd_trident_remove,
+#ifdef CONFIG_PM_SLEEP
+        .driver = {
+                .pm = &snd_trident_pm,
+        },
 #endif
 };
 
-static int __init alsa_card_trident_init(void)
-{
-        return pci_register_driver(&driver);
-}
-
-static void __exit alsa_card_trident_exit(void)
-{
-        pci_unregister_driver(&driver);
-}
-
-module_init(alsa_card_trident_init)
-module_exit(alsa_card_trident_exit)
+module_pci_driver(trident_driver);

GPL/trunk/alsa-kernel/pci/trident/trident_main.c

@@ +1 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
 /*
  *  Maintained by Jaroslav Kysela <perex@perex.cz>
@@ -10 +11 @@
  *    ---
  *
- *   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
- *
- *
  *  SiS7018 S/PDIF support by Thomas Winischhofer <thomas@winischhofer.net>
  */
+
+#ifdef TARGET_OS2
+#define KBUILD_MODNAME "trident"
+#endif
 
 #include <linux/delay.h>
@@ -36 +26 @@
 #include <linux/gameport.h>
 #include <linux/dma-mapping.h>
+#include <linux/export.h>
+#include <linux/io.h>
 
 #include <sound/core.h>
@@ -41 +33 @@
 #include <sound/control.h>
 #include <sound/tlv.h>
-#include <sound/trident.h>
+#include "trident.h"
 #include <sound/asoundef.h>
-
-#include <asm/io.h>
 
 static int snd_trident_pcm_mixer_build(struct snd_trident *trident,
@@ -69 +59 @@
         unsigned int val, tmp;
 
-        printk(KERN_DEBUG "Trident voice %i:\n", voice);
+        dev_dbg(trident->card->dev, "Trident voice %i:\n", voice);
         outb(voice, TRID_REG(trident, T4D_LFO_GC_CIR));
         val = inl(TRID_REG(trident, CH_LBA));
-        printk(KERN_DEBUG "LBA: 0x%x\n", val);
+        dev_dbg(trident->card->dev, "LBA: 0x%x\n", val);
         val = inl(TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC));
-        printk(KERN_DEBUG "GVSel: %i\n", val >> 31);
-        printk(KERN_DEBUG "Pan: 0x%x\n", (val >> 24) & 0x7f);
-        printk(KERN_DEBUG "Vol: 0x%x\n", (val >> 16) & 0xff);
-        printk(KERN_DEBUG "CTRL: 0x%x\n", (val >> 12) & 0x0f);
-        printk(KERN_DEBUG "EC: 0x%x\n", val & 0x0fff);
+        dev_dbg(trident->card->dev, "GVSel: %i\n", val >> 31);
+        dev_dbg(trident->card->dev, "Pan: 0x%x\n", (val >> 24) & 0x7f);
+        dev_dbg(trident->card->dev, "Vol: 0x%x\n", (val >> 16) & 0xff);
+        dev_dbg(trident->card->dev, "CTRL: 0x%x\n", (val >> 12) & 0x0f);
+        dev_dbg(trident->card->dev, "EC: 0x%x\n", val & 0x0fff);
         if (trident->device != TRIDENT_DEVICE_ID_NX) {
                 val = inl(TRID_REG(trident, CH_DX_CSO_ALPHA_FMS));
-                printk(KERN_DEBUG "CSO: 0x%x\n", val >> 16);
-                printk("Alpha: 0x%x\n", (val >> 4) & 0x0fff);
-                printk(KERN_DEBUG "FMS: 0x%x\n", val & 0x0f);
+                dev_dbg(trident->card->dev, "CSO: 0x%x\n", val >> 16);
+                dev_dbg(trident->card->dev, "Alpha: 0x%x\n", (val >> 4) & 0x0fff);
+                dev_dbg(trident->card->dev, "FMS: 0x%x\n", val & 0x0f);
                 val = inl(TRID_REG(trident, CH_DX_ESO_DELTA));
-                printk(KERN_DEBUG "ESO: 0x%x\n", val >> 16);
-                printk(KERN_DEBUG "Delta: 0x%x\n", val & 0xffff);
+                dev_dbg(trident->card->dev, "ESO: 0x%x\n", val >> 16);
+                dev_dbg(trident->card->dev, "Delta: 0x%x\n", val & 0xffff);
                 val = inl(TRID_REG(trident, CH_DX_FMC_RVOL_CVOL));
         } else {                // TRIDENT_DEVICE_ID_NX
                 val = inl(TRID_REG(trident, CH_NX_DELTA_CSO));
                 tmp = (val >> 24) & 0xff;
-                printk(KERN_DEBUG "CSO: 0x%x\n", val & 0x00ffffff);
+                dev_dbg(trident->card->dev, "CSO: 0x%x\n", val & 0x00ffffff);
                 val = inl(TRID_REG(trident, CH_NX_DELTA_ESO));
                 tmp |= (val >> 16) & 0xff00;
-                printk(KERN_DEBUG "Delta: 0x%x\n", tmp);
-                printk(KERN_DEBUG "ESO: 0x%x\n", val & 0x00ffffff);
+                dev_dbg(trident->card->dev, "Delta: 0x%x\n", tmp);
+                dev_dbg(trident->card->dev, "ESO: 0x%x\n", val & 0x00ffffff);
                 val = inl(TRID_REG(trident, CH_NX_ALPHA_FMS_FMC_RVOL_CVOL));
-                printk(KERN_DEBUG "Alpha: 0x%x\n", val >> 20);
-                printk(KERN_DEBUG "FMS: 0x%x\n", (val >> 16) & 0x0f);
-        }
-        printk(KERN_DEBUG "FMC: 0x%x\n", (val >> 14) & 3);
-        printk(KERN_DEBUG "RVol: 0x%x\n", (val >> 7) & 0x7f);
-        printk(KERN_DEBUG "CVol: 0x%x\n", val & 0x7f);
+                dev_dbg(trident->card->dev, "Alpha: 0x%x\n", val >> 20);
+                dev_dbg(trident->card->dev, "FMS: 0x%x\n", (val >> 16) & 0x0f);
+        }
+        dev_dbg(trident->card->dev, "FMC: 0x%x\n", (val >> 14) & 3);
+        dev_dbg(trident->card->dev, "RVol: 0x%x\n", (val >> 7) & 0x7f);
+        dev_dbg(trident->card->dev, "CVol: 0x%x\n", val & 0x7f);
 }
 #endif
@@ -156 +146 @@
 
         if (count == 0 && !trident->ac97_detect) {
-                snd_printk(KERN_ERR "ac97 codec read TIMEOUT [0x%x/0x%x]!!!\n",
+                dev_err(trident->card->dev,
+                        "ac97 codec read TIMEOUT [0x%x/0x%x]!!!\n",
                            reg, data);
                 data = 0;
@@ -497 +488 @@
 
 #if 0
-        printk(KERN_DEBUG "written %i channel:\n", voice->number);
-        printk(KERN_DEBUG "  regs[0] = 0x%x/0x%x\n",
+        dev_dbg(trident->card->dev, "written %i channel:\n", voice->number);
+        dev_dbg(trident->card->dev, "  regs[0] = 0x%x/0x%x\n",
                regs[0], inl(TRID_REG(trident, CH_START + 0)));
-        printk(KERN_DEBUG "  regs[1] = 0x%x/0x%x\n",
+        dev_dbg(trident->card->dev, "  regs[1] = 0x%x/0x%x\n",
                regs[1], inl(TRID_REG(trident, CH_START + 4)));
-        printk(KERN_DEBUG "  regs[2] = 0x%x/0x%x\n",
+        dev_dbg(trident->card->dev, "  regs[2] = 0x%x/0x%x\n",
                regs[2], inl(TRID_REG(trident, CH_START + 8)));
-        printk(KERN_DEBUG "  regs[3] = 0x%x/0x%x\n",
+        dev_dbg(trident->card->dev, "  regs[3] = 0x%x/0x%x\n",
                regs[3], inl(TRID_REG(trident, CH_START + 12)));
-        printk(KERN_DEBUG "  regs[4] = 0x%x/0x%x\n",
+        dev_dbg(trident->card->dev, "  regs[4] = 0x%x/0x%x\n",
                regs[4], inl(TRID_REG(trident, CH_START + 16)));
 #endif
@@ -589 +580 @@
                 break;
         case TRIDENT_DEVICE_ID_SI7018:
-                /* printk(KERN_DEBUG "voice->Vol = 0x%x\n", voice->Vol); */
+                /* dev_dbg(trident->card->dev, "voice->Vol = 0x%x\n", voice->Vol); */
                 outw((voice->CTRL << 12) | voice->Vol,
                      TRID_REG(trident, CH_GVSEL_PAN_VOL_CTRL_EC));
@@ -782 +773 @@
 
 /*---------------------------------------------------------------------------
-   snd_trident_ioctl
-  
-   Description: Device I/O control handler for playback/capture parameters.
-  
-   Parameters:   substream  - PCM substream class
-                cmd     - what ioctl message to process
-                arg     - additional message infoarg     
-  
-   Returns:     Error status
-  
-  ---------------------------------------------------------------------------*/
-
-static int snd_trident_ioctl(struct snd_pcm_substream *substream,
-                             unsigned int cmd,
-                             void *arg)
-{
-        /* FIXME: it seems that with small periods the behaviour of
-                  trident hardware is unpredictable and interrupt generator
-                  is broken */
-        return snd_pcm_lib_ioctl(substream, cmd, arg);
-}
-
-/*---------------------------------------------------------------------------
    snd_trident_allocate_pcm_mem
   
@@ -822 +790 @@
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct snd_trident_voice *voice = runtime->private_data;
-        int err;
-
-        if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
-                return err;
+
         if (trident->tlb.entries) {
-                if (err > 0) { /* change */
+                if (runtime->buffer_changed) {
                         if (voice->memblk)
                                 snd_trident_free_pages(trident, voice->memblk);
@@ -925 +890 @@
                 }
         }
-        snd_pcm_lib_free_pages(substream);
         if (evoice != NULL) {
                 snd_trident_free_voice(trident, evoice);
@@ -1142 +1106 @@
                                                 struct snd_pcm_hw_params *hw_params)
 {
-        int err;
-
-        if ((err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params))) < 0)
-                return err;
-
         return snd_trident_allocate_evoice(substream, hw_params);
 }
@@ -1168 +1127 @@
         struct snd_trident_voice *evoice = voice ? voice->extra : NULL;
 
-        snd_pcm_lib_free_pages(substream);
         if (evoice != NULL) {
                 snd_trident_free_voice(trident, evoice);
@@ -1727 +1685 @@
  */
 
-static struct snd_pcm_hardware snd_trident_playback =
+static const struct snd_pcm_hardware snd_trident_playback =
 {
         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
@@ -1752 +1710 @@
  */
 
-static struct snd_pcm_hardware snd_trident_capture =
+static const struct snd_pcm_hardware snd_trident_capture =
 {
         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
@@ -1777 +1735 @@
  */
 
-static struct snd_pcm_hardware snd_trident_foldback =
+static const struct snd_pcm_hardware snd_trident_foldback =
 {
         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
@@ -1801 +1759 @@
  */
 
-static struct snd_pcm_hardware snd_trident_spdif =
+static const struct snd_pcm_hardware snd_trident_spdif =
 {
         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
@@ -1822 +1780 @@
 };
 
-static struct snd_pcm_hardware snd_trident_spdif_7018 =
+static const struct snd_pcm_hardware snd_trident_spdif_7018 =
 {
         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
@@ -2070 +2028 @@
   ---------------------------------------------------------------------------*/
 
-static struct snd_pcm_ops snd_trident_playback_ops = {
+static const struct snd_pcm_ops snd_trident_playback_ops = {
         .open =         snd_trident_playback_open,
         .close =        snd_trident_playback_close,
-        .ioctl =        snd_trident_ioctl,
         .hw_params =    snd_trident_hw_params,
         .hw_free =      snd_trident_hw_free,
@@ -2081 +2038 @@
 };
 
-static struct snd_pcm_ops snd_trident_nx_playback_ops = {
+static const struct snd_pcm_ops snd_trident_nx_playback_ops = {
         .open =         snd_trident_playback_open,
         .close =        snd_trident_playback_close,
-        .ioctl =        snd_trident_ioctl,
         .hw_params =    snd_trident_hw_params,
         .hw_free =      snd_trident_hw_free,
@@ -2090 +2046 @@
         .trigger =      snd_trident_trigger,
         .pointer =      snd_trident_playback_pointer,
-        .page =         snd_pcm_sgbuf_ops_page,
 };
 
-static struct snd_pcm_ops snd_trident_capture_ops = {
+static const struct snd_pcm_ops snd_trident_capture_ops = {
         .open =         snd_trident_capture_open,
         .close =        snd_trident_capture_close,
-        .ioctl =        snd_trident_ioctl,
         .hw_params =    snd_trident_capture_hw_params,
         .hw_free =      snd_trident_hw_free,
@@ -2104 +2058 @@
 };
 
-static struct snd_pcm_ops snd_trident_si7018_capture_ops = {
+static const struct snd_pcm_ops snd_trident_si7018_capture_ops = {
         .open =         snd_trident_capture_open,
         .close =        snd_trident_capture_close,
-        .ioctl =        snd_trident_ioctl,
         .hw_params =    snd_trident_si7018_capture_hw_params,
         .hw_free =      snd_trident_si7018_capture_hw_free,
@@ -2115 +2068 @@
 };
 
-static struct snd_pcm_ops snd_trident_foldback_ops = {
+static const struct snd_pcm_ops snd_trident_foldback_ops = {
         .open =         snd_trident_foldback_open,
         .close =        snd_trident_foldback_close,
-        .ioctl =        snd_trident_ioctl,
         .hw_params =    snd_trident_hw_params,
         .hw_free =      snd_trident_hw_free,
@@ -2126 +2078 @@
 };
 
-static struct snd_pcm_ops snd_trident_nx_foldback_ops = {
+static const struct snd_pcm_ops snd_trident_nx_foldback_ops = {
         .open =         snd_trident_foldback_open,
         .close =        snd_trident_foldback_close,
-        .ioctl =        snd_trident_ioctl,
         .hw_params =    snd_trident_hw_params,
         .hw_free =      snd_trident_hw_free,
@@ -2135 +2086 @@
         .trigger =      snd_trident_trigger,
         .pointer =      snd_trident_playback_pointer,
-        .page =         snd_pcm_sgbuf_ops_page,
 };
 
-static struct snd_pcm_ops snd_trident_spdif_ops = {
+static const struct snd_pcm_ops snd_trident_spdif_ops = {
         .open =         snd_trident_spdif_open,
         .close =        snd_trident_spdif_close,
-        .ioctl =        snd_trident_ioctl,
         .hw_params =    snd_trident_spdif_hw_params,
         .hw_free =      snd_trident_hw_free,
@@ -2149 +2098 @@
 };
 
-static struct snd_pcm_ops snd_trident_spdif_7018_ops = {
+static const struct snd_pcm_ops snd_trident_spdif_7018_ops = {
         .open =         snd_trident_spdif_open,
         .close =        snd_trident_spdif_close,
-        .ioctl =        snd_trident_ioctl,
         .hw_params =    snd_trident_spdif_hw_params,
         .hw_free =      snd_trident_hw_free,
@@ -2171 +2119 @@
   ---------------------------------------------------------------------------*/
 
-int __devinit snd_trident_pcm(struct snd_trident * trident,
-                              int device, struct snd_pcm ** rpcm)
+int snd_trident_pcm(struct snd_trident *trident, int device)
 {
         struct snd_pcm *pcm;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(trident->card, "trident_dx_nx", device, trident->ChanPCM, 1, &pcm)) < 0)
                 return err;
@@ -2202 +2147 @@
                 struct snd_pcm_substream *substream;
                 for (substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream; substream; substream = substream->next)
-                        snd_pcm_lib_preallocate_pages(substream, SNDRV_DMA_TYPE_DEV_SG,
-                                                      snd_dma_pci_data(trident->pci),
-                                                      64*1024, 128*1024);
-                snd_pcm_lib_preallocate_pages(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream,
-                                              SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
-                                              64*1024, 128*1024);
+                        snd_pcm_set_managed_buffer(substream, SNDRV_DMA_TYPE_DEV_SG,
+                                                   &trident->pci->dev,
+                                                   64*1024, 128*1024);
+                snd_pcm_set_managed_buffer(pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream,
+                                           SNDRV_DMA_TYPE_DEV,
+                                           &trident->pci->dev,
+                                           64*1024, 128*1024);
         } else {
-                snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
-                                                      snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
-        }
-
-        if (rpcm)
-                *rpcm = pcm;
+                snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV,
+                                               &trident->pci->dev,
+                                               64*1024, 128*1024);
+        }
+
         return 0;
 }
@@ -2229 +2174 @@
   ---------------------------------------------------------------------------*/
 
-int __devinit snd_trident_foldback_pcm(struct snd_trident * trident,
-                                       int device, struct snd_pcm ** rpcm)
+int snd_trident_foldback_pcm(struct snd_trident *trident, int device)
 {
         struct snd_pcm *foldback;
@@ -2237 +2181 @@
         struct snd_pcm_substream *substream;
 
-        if (rpcm)
-                *rpcm = NULL;
         if (trident->device == TRIDENT_DEVICE_ID_NX)
                 num_chan = 4;
@@ -2264 +2206 @@
 
         if (trident->tlb.entries)
-                snd_pcm_lib_preallocate_pages_for_all(foldback, SNDRV_DMA_TYPE_DEV_SG,
-                                                      snd_dma_pci_data(trident->pci), 0, 128*1024);
+                snd_pcm_set_managed_buffer_all(foldback, SNDRV_DMA_TYPE_DEV_SG,
+                                               &trident->pci->dev,
+                                               0, 128*1024);
         else
-                snd_pcm_lib_preallocate_pages_for_all(foldback, SNDRV_DMA_TYPE_DEV,
-                                                      snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
-
-        if (rpcm)
-                *rpcm = foldback;
+                snd_pcm_set_managed_buffer_all(foldback, SNDRV_DMA_TYPE_DEV,
+                                               &trident->pci->dev,
+                                               64*1024, 128*1024);
+
         return 0;
 }
@@ -2286 +2228 @@
   ---------------------------------------------------------------------------*/
 
-int __devinit snd_trident_spdif_pcm(struct snd_trident * trident,
-                                    int device, struct snd_pcm ** rpcm)
+int snd_trident_spdif_pcm(struct snd_trident *trident, int device)
 {
         struct snd_pcm *spdif;
         int err;
 
-        if (rpcm)
-                *rpcm = NULL;
         if ((err = snd_pcm_new(trident->card, "trident_dx_nx IEC958", device, 1, 0, &spdif)) < 0)
                 return err;
@@ -2307 +2246 @@
         trident->spdif = spdif;
 
-        snd_pcm_lib_preallocate_pages_for_all(spdif, SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci), 64*1024, 128*1024);
-
-        if (rpcm)
-                *rpcm = spdif;
+        snd_pcm_set_managed_buffer_all(spdif, SNDRV_DMA_TYPE_DEV,
+                                       &trident->pci->dev, 64*1024, 128*1024);
+
         return 0;
 }
@@ -2371 +2309 @@
 }
 
-static struct snd_kcontrol_new snd_trident_spdif_control __devinitdata =
+static const struct snd_kcontrol_new snd_trident_spdif_control =
 {
         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -2434 +2372 @@
 }
 
-static struct snd_kcontrol_new snd_trident_spdif_default __devinitdata =
+static const struct snd_kcontrol_new snd_trident_spdif_default =
 {
         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
@@ -2467 +2405 @@
 }
 
-static struct snd_kcontrol_new snd_trident_spdif_mask __devinitdata =
+static const struct snd_kcontrol_new snd_trident_spdif_mask =
 {
         .access =       SNDRV_CTL_ELEM_ACCESS_READ,
@@ -2529 +2467 @@
 }
 
-static struct snd_kcontrol_new snd_trident_spdif_stream __devinitdata =
+static const struct snd_kcontrol_new snd_trident_spdif_stream =
 {
         .access =       SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_INACTIVE,
@@ -2579 +2517 @@
 }
 
-static struct snd_kcontrol_new snd_trident_ac97_rear_control __devinitdata =
+static const struct snd_kcontrol_new snd_trident_ac97_rear_control =
 {
         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -2637 +2575 @@
 }
 
-static struct snd_kcontrol_new snd_trident_vol_music_control __devinitdata =
+static const struct snd_kcontrol_new snd_trident_vol_music_control =
 {
         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -2648 +2586 @@
 };
 
-static struct snd_kcontrol_new snd_trident_vol_wave_control __devinitdata =
+static const struct snd_kcontrol_new snd_trident_vol_wave_control =
 {
         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -2715 +2653 @@
 }
 
-static struct snd_kcontrol_new snd_trident_pcm_vol_control __devinitdata =
+static const struct snd_kcontrol_new snd_trident_pcm_vol_control =
 {
         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -2779 +2717 @@
 }
 
-static struct snd_kcontrol_new snd_trident_pcm_pan_control __devinitdata =
+static const struct snd_kcontrol_new snd_trident_pcm_pan_control =
 {
         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -2836 +2774 @@
 static const DECLARE_TLV_DB_SCALE(db_scale_crvol, -3175, 25, 1);
 
-static struct snd_kcontrol_new snd_trident_pcm_rvol_control __devinitdata =
+static const struct snd_kcontrol_new snd_trident_pcm_rvol_control =
 {
         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -2892 +2830 @@
 }
 
-static struct snd_kcontrol_new snd_trident_pcm_cvol_control __devinitdata =
+static const struct snd_kcontrol_new snd_trident_pcm_cvol_control =
 {
         .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
@@ -2972 +2910 @@
   ---------------------------------------------------------------------------*/
 
-static int __devinit snd_trident_mixer(struct snd_trident * trident, int pcm_spdif_device)
+static int snd_trident_mixer(struct snd_trident *trident, int pcm_spdif_device)
 {
         struct snd_ac97_template _ac97;
@@ -2979 +2917 @@
         struct snd_ctl_elem_value *uctl;
         int idx, err, retries = 2;
-        static struct snd_ac97_bus_ops ops = {
+        static const struct snd_ac97_bus_ops ops = {
                 .write = snd_trident_codec_write,
                 .read = snd_trident_codec_read,
@@ -3013 +2951 @@
                 err = snd_ac97_mixer(trident->ac97_bus, &_ac97, &trident->ac97_sec);
                 if (err < 0)
-                        snd_printk(KERN_ERR "SI7018: the secondary codec - invalid access\n");
+                        dev_err(trident->card->dev,
+                                "SI7018: the secondary codec - invalid access\n");
 #if 0   // only for my testing purpose --jk
                 {
@@ -3019 +2958 @@
                         err = snd_ac97_modem(trident->card, &_ac97, &mc97);
                         if (err < 0)
-                                snd_printk(KERN_ERR "snd_ac97_modem returned error %i\n", err);
+                                dev_err(trident->card->dev,
+                                        "snd_ac97_modem returned error %i\n", err);
                 }
 #endif
@@ -3133 +3073 @@
  */
 
-#if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
+#if IS_REACHABLE(CONFIG_GAMEPORT)
 
 static unsigned char snd_trident_gameport_read(struct gameport *gameport)
@@ -3191 +3131 @@
 }
 
-int __devinit snd_trident_create_gameport(struct snd_trident *chip)
+int snd_trident_create_gameport(struct snd_trident *chip)
 {
         struct gameport *gp;
@@ -3197 +3137 @@
         chip->gameport = gp = gameport_allocate_port();
         if (!gp) {
-                printk(KERN_ERR "trident: cannot allocate memory for gameport\n");
+                dev_err(chip->card->dev,
+                        "cannot allocate memory for gameport\n");
                 return -ENOMEM;
         }
@@ -3225 +3166 @@
 }
 #else
-int __devinit snd_trident_create_gameport(struct snd_trident *chip) { return -ENOSYS; }
+int snd_trident_create_gameport(struct snd_trident *chip) { return -ENOSYS; }
 static inline void snd_trident_free_gameport(struct snd_trident *chip) { }
 #endif /* CONFIG_GAMEPORT */
@@ -3270 +3211 @@
                 do_delay(trident);
         } while (time_after_eq(end_time, jiffies));
-        snd_printk(KERN_ERR "AC'97 codec ready error [0x%x]\n", inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)));
+        dev_err(trident->card->dev, "AC'97 codec ready error [0x%x]\n",
+                inl(TRID_REG(trident, SI_SERIAL_INTF_CTRL)));
         if (r-- > 0) {
                 end_time = jiffies + HZ;
@@ -3329 +3271 @@
 }
 
-static void __devinit snd_trident_proc_init(struct snd_trident * trident)
-{
-        struct snd_info_entry *entry;
+static void snd_trident_proc_init(struct snd_trident *trident)
+{
         const char *s = "trident";
         
         if (trident->device == TRIDENT_DEVICE_ID_SI7018)
                 s = "sis7018";
-        if (! snd_card_proc_new(trident->card, s, &entry))
-                snd_info_set_text_ops(entry, trident, snd_trident_proc_read);
+        snd_card_ro_proc_new(trident->card, s, trident, snd_trident_proc_read);
 }
 
@@ -3358 +3298 @@
   ---------------------------------------------------------------------------*/
 
-static int __devinit snd_trident_tlb_alloc(struct snd_trident *trident)
+static int snd_trident_tlb_alloc(struct snd_trident *trident)
 {
         int i;
@@ -3365 +3305 @@
            32kB region and correct offset when necessary */
 
-        if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
+        if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &trident->pci->dev,
                                 2 * SNDRV_TRIDENT_MAX_PAGES * 4, &trident->tlb.buffer) < 0) {
-                snd_printk(KERN_ERR "trident: unable to allocate TLB buffer\n");
+                dev_err(trident->card->dev, "unable to allocate TLB buffer\n");
                 return -ENOMEM;
         }
-        trident->tlb.entries = (unsigned int*)ALIGN((unsigned long)trident->tlb.buffer.area, SNDRV_TRIDENT_MAX_PAGES * 4);
+        trident->tlb.entries = (__le32 *)ALIGN((unsigned long)trident->tlb.buffer.area, SNDRV_TRIDENT_MAX_PAGES * 4);
         trident->tlb.entries_dmaaddr = ALIGN(trident->tlb.buffer.addr, SNDRV_TRIDENT_MAX_PAGES * 4);
         /* allocate shadow TLB page table (virtual addresses) */
-        trident->tlb.shadow_entries = vmalloc(SNDRV_TRIDENT_MAX_PAGES*sizeof(unsigned long));
-        if (trident->tlb.shadow_entries == NULL) {
-                snd_printk(KERN_ERR "trident: unable to allocate shadow TLB entries\n");
+        trident->tlb.shadow_entries =
+                vmalloc(array_size(SNDRV_TRIDENT_MAX_PAGES,
+                                   sizeof(unsigned long)));
+        if (!trident->tlb.shadow_entries)
                 return -ENOMEM;
-        }
+
         /* allocate and setup silent page and initialise TLB entries */
-        if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(trident->pci),
+        if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, &trident->pci->dev,
                                 SNDRV_TRIDENT_PAGE_SIZE, &trident->tlb.silent_page) < 0) {
-                snd_printk(KERN_ERR "trident: unable to allocate silent page\n");
+                dev_err(trident->card->dev, "unable to allocate silent page\n");
                 return -ENOMEM;
         }
@@ -3439 +3380 @@
                 do_delay(trident);
         } while (time_after_eq(end_time, jiffies));
-        snd_printk(KERN_ERR "AC'97 codec ready error\n");
+        dev_err(trident->card->dev, "AC'97 codec ready error\n");
         return -EIO;
 
@@ -3477 +3418 @@
                 do_delay(trident);
         } while (time_after_eq(end_time, jiffies));
-        snd_printk(KERN_ERR "AC'97 codec ready error [0x%x]\n", inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)));
+        dev_err(trident->card->dev, "AC'97 codec ready error [0x%x]\n",
+                inl(TRID_REG(trident, NX_ACR0_AC97_COM_STAT)));
         return -EIO;
 
@@ -3539 +3481 @@
   ---------------------------------------------------------------------------*/
 
-int __devinit snd_trident_create(struct snd_card *card,
+int snd_trident_create(struct snd_card *card,
                        struct pci_dev *pci,
                        int pcm_streams,
@@ -3550 +3492 @@
         struct snd_trident_voice *voice;
         struct snd_trident_pcm_mixer *tmix;
-        static struct snd_device_ops ops = {
+        static const struct snd_device_ops ops = {
                 .dev_free =     snd_trident_dev_free,
         };
@@ -3560 +3502 @@
                 return err;
         /* check, if we can restrict PCI DMA transfers to 30 bits */
-        if (pci_set_dma_mask(pci, DMA_BIT_MASK(30)) < 0 ||
-            pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(30)) < 0) {
-                snd_printk(KERN_ERR "architecture does not support 30bit PCI busmaster DMA\n");
+        if (dma_set_mask(&pci->dev, DMA_BIT_MASK(30)) < 0 ||
+            dma_set_coherent_mask(&pci->dev, DMA_BIT_MASK(30)) < 0) {
+                dev_err(card->dev,
+                        "architecture does not support 30bit PCI busmaster DMA\n");
                 pci_disable_device(pci);
                 return -ENXIO;
@@ -3599 +3542 @@
 
         if (request_irq(pci->irq, snd_trident_interrupt, IRQF_SHARED,
-                        "Trident Audio", trident)) {
-                snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
+                        KBUILD_MODNAME, trident)) {
+                dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                 snd_trident_free(trident);
                 return -EBUSY;
         }
         trident->irq = pci->irq;
+        card->sync_irq = trident->irq;
 
         /* allocate 16k-aligned TLB for NX cards */
@@ -3664 +3608 @@
 
         snd_trident_proc_init(trident);
-        snd_card_set_dev(card, &pci->dev);
         *rtrident = trident;
         return 0;
@@ -3695 +3638 @@
         if (trident->tlb.buffer.area) {
                 outl(0, TRID_REG(trident, NX_TLBC));
-                if (trident->tlb.memhdr)
-                        snd_util_memhdr_free(trident->tlb.memhdr);
+                snd_util_memhdr_free(trident->tlb.memhdr);
                 if (trident->tlb.silent_page.area)
                         snd_dma_free_pages(&trident->tlb.silent_page);
@@ -3873 +3815 @@
         unsigned long flags;
         void (*private_free)(struct snd_trident_voice *);
-        void *private_data;
 
         if (voice == NULL || !voice->use)
@@ -3880 +3821 @@
         spin_lock_irqsave(&trident->voice_alloc, flags);
         private_free = voice->private_free;
-        private_data = voice->private_data;
         voice->private_free = NULL;
         voice->private_data = NULL;
@@ -3919 +3859 @@
 }
 
-#ifdef CONFIG_PM
-int snd_trident_suspend(struct pci_dev *pci, pm_message_t state)
-{
-        struct snd_card *card = pci_get_drvdata(pci);
+#ifdef CONFIG_PM_SLEEP
+static int snd_trident_suspend(struct device *dev)
+{
+        struct snd_card *card = dev_get_drvdata(dev);
         struct snd_trident *trident = card->private_data;
 
         trident->in_suspend = 1;
         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
-        snd_pcm_suspend_all(trident->pcm);
-        snd_pcm_suspend_all(trident->foldback);
-        snd_pcm_suspend_all(trident->spdif);
-
         snd_ac97_suspend(trident->ac97);
         snd_ac97_suspend(trident->ac97_sec);
-
-        pci_disable_device(pci);
-        pci_save_state(pci);
-        pci_set_power_state(pci, pci_choose_state(pci, state));
-        return 0;
-}
-
-int snd_trident_resume(struct pci_dev *pci)
-{
-        struct snd_card *card = pci_get_drvdata(pci);
+        return 0;
+}
+
+static int snd_trident_resume(struct device *dev)
+{
+        struct snd_card *card = dev_get_drvdata(dev);
         struct snd_trident *trident = card->private_data;
-
-        pci_set_power_state(pci, PCI_D0);
-        pci_restore_state(pci);
-        if (pci_enable_device(pci) < 0) {
-                printk(KERN_ERR "trident: pci_enable_device failed, "
-                       "disabling device\n");
-                snd_card_disconnect(card);
-                return -EIO;
-        }
-        pci_set_master(pci);
 
         switch (trident->device) {
@@ -3979 +3901 @@
         return 0;
 }
-#endif /* CONFIG_PM */
+
+SIMPLE_DEV_PM_OPS(snd_trident_pm, snd_trident_suspend, snd_trident_resume);
+#endif /* CONFIG_PM_SLEEP */

GPL/trunk/alsa-kernel/pci/trident/trident_memory.c

@@ +1 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
 /*
  *  Copyright (c) by Jaroslav Kysela <perex@perex.cz>
@@ -6 +7 @@
  *  Trident 4DWave-NX memory page allocation (TLB area)
  *  Trident chip can handle only 16MByte of the memory at the same time.
- *
- *
- *   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/pci.h>
 #include <linux/time.h>
@@ -30 +15 @@
 
 #include <sound/core.h>
-#include <sound/trident.h>
+#include "trident.h"
 
 /* page arguments of these two macros are Trident page (4096 bytes), not like
@@ -140 +125 @@
 search_empty(struct snd_util_memhdr *hdr, int size)
 {
-        struct snd_util_memblk *blk, *prev;
+        struct snd_util_memblk *blk;
         int page, psize;
         struct list_head *p;
 
         psize = get_aligned_page(size + ALIGN_PAGE_SIZE -1);
-        prev = NULL;
         page = 0;
         list_for_each(p, &hdr->block) {
@@ -214 +198 @@
                 return NULL;
         }
-                        
+                           
         /* set TLB entries */
         idx = 0;
@@ -263 +247 @@
                 return NULL;
         }
-                        
+                           
         /* set TLB entries */
         addr = runtime->dma_addr;