Changeset 744 for GPL/branches

Timestamp:

Sep 18, 2022, 11:16:00 AM (3 years ago)

Author:

Paul Smedley

Message:

Add some additional functions to minimise upstream patches

Location:

GPL/branches/uniaud32-exp

Files:

• alsa-kernel/pci/atiixp.c (modified) (1 diff)
• 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) (1 diff)
• alsa-kernel/pci/hda/hda_intel.c (modified) (1 diff)
• include/linux/pci.h (modified) (2 diffs)
• lib32/devres.c (modified) (3 diffs)

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

@@ -1563 +1563 @@
         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-exp/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-exp/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-exp/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-exp/alsa-kernel/pci/fm801.c

@@ -1195 +1195 @@
         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;

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

@@ -1895 +1895 @@
 #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-exp/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-exp/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);
 
 /*
@@ -527 +563 @@
 }
 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);