Changeset 745

Timestamp:

Sep 18, 2022, 11:24:34 AM (3 years ago)

Author:

Paul Smedley

Message:

Add some additional functions to minimise upstream patches

Location:

GPL/branches/uniaud32-next

Files:

• alsa-kernel/pci/atiixp.c (modified) (2 diffs)
• alsa-kernel/pci/bt87x.c (modified) (1 diff)
• alsa-kernel/pci/cs4281.c (modified) (1 diff)
• alsa-kernel/pci/cs5530.c (modified) (1 diff)
• alsa-kernel/pci/fm801.c (modified) (3 diffs)
• alsa-kernel/pci/hda/hda_intel.c (modified) (1 diff)
• include/linux/pci.h (modified) (2 diffs)
• include/linux/pgtable.h (modified) (1 diff)
• include/linux/vmalloc.h (modified) (1 diff)
• lib32/devres.c (modified) (3 diffs)

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

@@ -564 +564 @@
                 dev_dbg(&pci->dev, "atiixp quirk for %s.  Forcing codec %d\n",
                         snd_pci_quirk_name(q), q->value);
-
                 return q->value;
         }
@@ -1563 +1562 @@
         chip->pci = pci;
         chip->irq = -1;
-#ifndef TARGET_OS2
         err = pcim_iomap_regions(pci, 1 << 0, "ATI IXP AC97");
         if (err < 0)
                 return err;
-#else
-        err = pci_request_regions(pci, "ATI IXP AC97");
-        if (err < 0) {
-                pci_disable_device(pci);
-                kfree(chip);
-                return err;
-        }
-#endif
         chip->addr = pci_resource_start(pci, 0);
-#ifndef TARGET_OS2
         chip->remap_addr = pcim_iomap_table(pci)[0];
-#else
-        chip->remap_addr = pci_ioremap_bar(pci, 0);
-#endif
+
         if (devm_request_irq(&pci->dev, pci->irq, snd_atiixp_interrupt,
                              IRQF_SHARED, KBUILD_MODNAME, chip)) {

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

@@ -706 +706 @@
         spin_lock_init(&chip->reg_lock);
 
-#ifndef TARGET_OS2
         err = pcim_iomap_regions(pci, 1 << 0, "Bt87x audio");
         if (err < 0)
                 return err;
         chip->mmio = pcim_iomap_table(pci)[0];
-#else
-        err = pci_request_regions(pci, "Bt87x audio");
-        if (err < 0) {
-                kfree(chip);
-                pci_disable_device(pci);
-                return err;
-        }
-        chip->mmio = pci_ioremap_bar(pci, 0);
-#endif
+
         chip->reg_control = CTL_A_PWRDN | CTL_DA_ES2 |
                             CTL_PKTP_16 | (15 << CTL_DA_SDR_SHIFT);

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

@@ -1309 +1309 @@
         chip->dual_codec = dual_codec;
 
-#ifndef TARGET_OS2
         err = pcim_iomap_regions(pci, 0x03, "CS4281"); /* 2 BARs */
         if (err < 0)
                 return err;
-#else
-        err = pci_request_regions(pci, "CS4281");
-        if (err < 0) {
-                kfree(chip);
-                pci_disable_device(pci);
-                return err;
-        }
-#endif
         chip->ba0_addr = pci_resource_start(pci, 0);
         chip->ba1_addr = pci_resource_start(pci, 1);
 
-#ifndef TARGET_OS2
         chip->ba0 = pcim_iomap_table(pci)[0];
         chip->ba1 = pcim_iomap_table(pci)[1];
-#else
-        chip->ba0 = pci_ioremap_bar(pci, 0);
-        chip->ba1 = pci_ioremap_bar(pci, 1);
-#endif
+
         if (devm_request_irq(&pci->dev, pci->irq, snd_cs4281_interrupt,
                              IRQF_SHARED, KBUILD_MODNAME, chip)) {

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

@@ -100 +100 @@
                 return err;
         chip->pci_base = pci_resource_start(pci, 0);
-#ifndef TARGET_OS2
         mem = pcim_iomap_table(pci)[0];
-#else
-        mem = pci_ioremap_bar(pci, 0);
-#endif
         map = readw(mem + 0x18);
 

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

@@ -1186 +1186 @@
 }
 
-
 static int snd_fm801_create(struct snd_card *card,
                             struct pci_dev *pci,
@@ -1195 +1194 @@
         int err;
 
-#ifndef TARGET_OS2
         err = pcim_enable_device(pci);
         if (err < 0)
                 return err;
-#else
-        if ((err = pci_enable_device(pci)) < 0)
-                return err;
-#endif
         spin_lock_init(&chip->reg_lock);
         chip->card = card;
@@ -1231 +1225 @@
 
         if ((chip->tea575x_tuner & TUNER_ONLY) == 0) {
-#ifndef TARGET_OS2
                 if (devm_request_irq(&pci->dev, pci->irq, snd_fm801_interrupt,
                                 IRQF_SHARED, KBUILD_MODNAME, chip)) {
-#else
-                if (request_irq(pci->irq, snd_fm801_interrupt, IRQF_SHARED,
-                                KBUILD_MODNAME, chip)) {
-#endif
                         dev_err(card->dev, "unable to grab IRQ %d\n", pci->irq);
                         return -EBUSY;

GPL/branches/uniaud32-next/alsa-kernel/pci/hda/hda_intel.c

@@ -1891 +1891 @@
 #endif
 
-#ifndef TARGET_OS2
         err = pcim_iomap_regions(pci, 1 << 0, "ICH HD audio");
-#else
-        err = pci_request_regions(pci, "ICH HD audio");
-#endif
         if (err < 0)
                 return err;
 
         bus->addr = pci_resource_start(pci, 0);
-#ifndef TARGET_OS2
         bus->remap_addr = pcim_iomap_table(pci)[0];
-#else
-        bus->remap_addr = pci_ioremap_bar(pci, 0);
-#endif
+
         if (chip->driver_type == AZX_DRIVER_SKL)
                 snd_hdac_bus_parse_capabilities(bus);

GPL/branches/uniaud32-next/include/linux/pci.h

@@ -781 +781 @@
 #define dev_is_pci(d) (true)
 int pcim_enable_device(struct pci_dev *pdev);
-#define pcim_iomap pci_iomap
 int pcim_iomap_regions(struct pci_dev *pdev, int mask, const char *name);
 
@@ -789 +788 @@
 }
 void pci_intx(struct pci_dev *pdev, int enable);
+#define PCI_STD_NUM_BARS        6       /* Number of standard BARs */
+int __must_check pci_request_region(struct pci_dev *, int, char *);
+void pci_release_region(struct pci_dev *, int);
+void __iomem * const *pcim_iomap_table(struct pci_dev *pdev);
 
 #endif /* LINUX_PCI_H */

GPL/branches/uniaud32-next/include/linux/pgtable.h

@@ -2 +2 @@
 #define _LINUX_PGTABLE_H
 
+
 #endif /* _LINUX_PGTABLE_H */

GPL/branches/uniaud32-next/include/linux/vmalloc.h

@@ -8 +8 @@
 #include <asm/page.h>
 
+#define VM_MAP                  0x00000004      /* vmap()ed pages */
 
 struct vm_struct {

GPL/branches/uniaud32-next/lib32/devres.c

@@ -9 +9 @@
 
 #include <linux/device.h>
+#include <linux/pci.h>
 #include <linux/module.h>
 #include <linux/slab.h>
@@ -310 +311 @@
         return NULL;
 }
+
+/**
+ * devres_get - Find devres, if non-existent, add one atomically
+ * @dev: Device to lookup or add devres for
+ * @new_res: Pointer to new initialized devres to add if not found
+ * @match: Match function (optional)
+ * @match_data: Data for the match function
+ *
+ * Find the latest devres of @dev which has the same release function
+ * as @new_res and for which @match return 1.  If found, @new_res is
+ * freed; otherwise, @new_res is added atomically.
+ *
+ * RETURNS:
+ * Pointer to found or added devres.
+ */
+void * devres_get(struct device *dev, void *new_res,
+                  dr_match_t match, void *match_data)
+{
+        struct devres *new_dr = container_of(new_res, struct devres, data);
+        struct devres *dr;
+        unsigned long flags;
+
+        spin_lock_irqsave(&dev->devres_lock, flags);
+        dr = find_dr(dev, new_dr->node.release, match, match_data);
+        if (!dr) {
+                add_dr(dev, &new_dr->node);
+                dr = new_dr;
+                new_res = NULL;
+        }
+        spin_unlock_irqrestore(&dev->devres_lock, flags);
+        devres_free(new_res);
+
+        return dr->data;
+}
+EXPORT_SYMBOL_GPL(devres_get);
 
 /*
@@ -472 +508 @@
 }
 EXPORT_SYMBOL(devm_ioremap);
+
+/**
+ * devm_kvasprintf - Allocate resource managed space and format a string
+ *                   into that.
+ * @dev: Device to allocate memory for
+ * @gfp: the GFP mask used in the devm_kmalloc() call when
+ *       allocating memory
+ * @fmt: The printf()-style format string
+ * @ap: Arguments for the format string
+ * RETURNS:
+ * Pointer to allocated string on success, NULL on failure.
+ */
+char *devm_kvasprintf(struct device *dev, gfp_t gfp, const char *fmt,
+                      va_list ap)
+{
+        unsigned int len;
+        char *p;
+        va_list aq;
+
+        va_copy(aq, ap);
+        len = vsnprintf(NULL, 0, fmt, aq);
+        va_end(aq);
+
+        p = devm_kmalloc(dev, len+1, gfp);
+        if (!p)
+                return NULL;
+
+        vsnprintf(p, len+1, fmt, ap);
+
+        return p;
+}
+EXPORT_SYMBOL(devm_kvasprintf);
+/**
+ * devm_kasprintf - Allocate resource managed space and format a string
+ *                  into that.
+ * @dev: Device to allocate memory for
+ * @gfp: the GFP mask used in the devm_kmalloc() call when
+ *       allocating memory
+ * @fmt: The printf()-style format string
+ * @...: Arguments for the format string
+ * RETURNS:
+ * Pointer to allocated string on success, NULL on failure.
+ */
+char *devm_kasprintf(struct device *dev, gfp_t gfp, const char *fmt, ...)
+{
+        va_list ap;
+        char *p;
+
+        va_start(ap, fmt);
+        p = devm_kvasprintf(dev, gfp, fmt, ap);
+        va_end(ap);
+
+        return p;
+}
+EXPORT_SYMBOL_GPL(devm_kasprintf);
+
+/*
+ * PCI iomap devres
+ */
+#define PCIM_IOMAP_MAX  PCI_STD_NUM_BARS
+
+struct pcim_iomap_devres {
+        void __iomem *table[PCIM_IOMAP_MAX];
+};
+
+static void pcim_iomap_release(struct device *gendev, void *res)
+{
+        struct pci_dev *dev = to_pci_dev(gendev);
+        struct pcim_iomap_devres *this = res;
+        int i;
+
+        for (i = 0; i < PCIM_IOMAP_MAX; i++)
+                if (this->table[i])
+                        pci_iounmap(dev, this->table[i]);
+}
+
+/**
+ * pcim_iomap_table - access iomap allocation table
+ * @pdev: PCI device to access iomap table for
+ *
+ * Access iomap allocation table for @dev.  If iomap table doesn't
+ * exist and @pdev is managed, it will be allocated.  All iomaps
+ * recorded in the iomap table are automatically unmapped on driver
+ * detach.
+ *
+ * This function might sleep when the table is first allocated but can
+ * be safely called without context and guaranteed to succeed once
+ * allocated.
+ */
+void __iomem * const *pcim_iomap_table(struct pci_dev *pdev)
+{
+        struct pcim_iomap_devres *dr, *new_dr;
+
+        dr = devres_find(&pdev->dev, pcim_iomap_release, NULL, NULL);
+        if (dr)
+                return dr->table;
+
+        new_dr = devres_alloc(pcim_iomap_release, sizeof(*new_dr), GFP_KERNEL);
+        if (!new_dr)
+                return NULL;
+        dr = devres_get(&pdev->dev, new_dr, NULL, NULL);
+        return dr->table;
+}
+EXPORT_SYMBOL(pcim_iomap_table);
+
+/**
+ * pcim_iomap - Managed pcim_iomap()
+ * @pdev: PCI device to iomap for
+ * @bar: BAR to iomap
+ * @maxlen: Maximum length of iomap
+ *
+ * Managed pci_iomap().  Map is automatically unmapped on driver
+ * detach.
+ */
+void __iomem *pcim_iomap(struct pci_dev *pdev, int bar, unsigned long maxlen)
+{
+        void __iomem **tbl;
+
+        BUG_ON(bar >= PCIM_IOMAP_MAX);
+
+        tbl = (void __iomem **)pcim_iomap_table(pdev);
+        if (!tbl || tbl[bar])   /* duplicate mappings not allowed */
+                return NULL;
+
+        tbl[bar] = pci_iomap(pdev, bar, maxlen);
+        return tbl[bar];
+}
+EXPORT_SYMBOL(pcim_iomap);
+
+/**
+ * pcim_iounmap - Managed pci_iounmap()
+ * @pdev: PCI device to iounmap for
+ * @addr: Address to unmap
+ *
+ * Managed pci_iounmap().  @addr must have been mapped using pcim_iomap().
+ */
+void pcim_iounmap(struct pci_dev *pdev, void __iomem *addr)
+{
+        void __iomem **tbl;
+        int i;
+
+        pci_iounmap(pdev, addr);
+
+        tbl = (void __iomem **)pcim_iomap_table(pdev);
+        BUG_ON(!tbl);
+
+        for (i = 0; i < PCIM_IOMAP_MAX; i++)
+                if (tbl[i] == addr) {
+                        tbl[i] = NULL;
+                        return;
+                }
+        WARN_ON(1);
+}
+EXPORT_SYMBOL(pcim_iounmap);
+
+/**
+ * pcim_iomap_regions - Request and iomap PCI BARs
+ * @pdev: PCI device to map IO resources for
+ * @mask: Mask of BARs to request and iomap
+ * @name: Name used when requesting regions
+ *
+ * Request and iomap regions specified by @mask.
+ */
+int pcim_iomap_regions(struct pci_dev *pdev, int mask, const char *name)
+{
+        void __iomem * const *iomap;
+        int i, rc;
+
+        iomap = pcim_iomap_table(pdev);
+        if (!iomap)
+                return -ENOMEM;
+
+        for (i = 0; i < DEVICE_COUNT_RESOURCE; i++) {
+                unsigned long len;
+
+                if (!(mask & (1 << i)))
+                        continue;
+
+                rc = -EINVAL;
+                len = pci_resource_len(pdev, i);
+                if (!len)
+                        goto err_inval;
+
+                rc = pci_request_region(pdev, i, name);
+                if (rc)
+                        goto err_inval;
+
+                rc = -ENOMEM;
+                if (!pcim_iomap(pdev, i, 0))
+                        goto err_region;
+        }
+
+        return 0;
+
+ err_region:
+        pci_release_region(pdev, i);
+ err_inval:
+        while (--i >= 0) {
+                if (!(mask & (1 << i)))
+                        continue;
+                pcim_iounmap(pdev, iomap[i]);
+                pci_release_region(pdev, i);
+        }
+
+        return rc;
+}
+EXPORT_SYMBOL(pcim_iomap_regions);