Changeset 745 for GPL/branches/uniaud32-next/lib32/devres.c

Timestamp:

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

Author:

Paul Smedley

Message:

Add some additional functions to minimise upstream patches

File:

• GPL/branches/uniaud32-next/lib32/devres.c (modified) (3 diffs)

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);