Changeset 772 for GPL/trunk/lib32/devres.c

Timestamp:

Apr 19, 2025, 8:08:37 PM (4 months ago)

Author:

David Azarewicz

Message:

Merge in changes from 6.6-LTS branch.
Fixed additional 25+ problems.

Location:

GPL/trunk

Files:

• . (modified) (1 prop)
• lib32/devres.c (modified) (12 diffs)

GPL/trunk/lib32/devres.c

@@ -9 +9 @@
 
 #include <linux/device.h>
+#include <linux/pci.h>
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/gfp.h>
 #include <linux/errno.h>
+#include <asm/io.h>
 
 struct devres_node {
         struct list_head                entry;
         dr_release_t                    release;
-#ifdef CONFIG_DEBUG_DEVRES
         const char                      *name;
         size_t                          size;
-#endif
 };
 
@@ -26 +26 @@
         struct devres_node              node;
         /* -- 3 pointers */
-        unsigned long long              data[]; /* guarantee ull alignment */
+        u8              data[]; /* guarantee ull alignment */
 };
 
@@ -36 +36 @@
 };
 
+static void set_node_dbginfo(struct devres_node *node, const char *name,
+                             size_t size)
+{
+        node->name = name;
+        node->size = size;
+}
+
 #define devres_log(dev, node, op)       do {} while (0)
 
@@ -76 +83 @@
 }
 
-#define devres_log(dev, node, op)       do {} while (0)
-
 static void add_dr(struct device *dev, struct devres_node *node)
 {
         devres_log(dev, node, "ADD");
         BUG_ON(!list_empty(&node->entry));
-//#ifndef TARGET_OS2
-        /* Traps here on OS/2 */
         list_add_tail(&node->entry, &dev->devres_head);
-//#endif
 }
 
@@ -99 +101 @@
 void devres_add(struct device *dev, void *res)
 {
-        /* Traps here on OS/2 */
         struct devres *dr = container_of(res, struct devres, data);
         unsigned long flags;
+
         spin_lock_irqsave(&dev->devres_lock, flags);
         add_dr(dev, &dr->node);
@@ -108 +110 @@
 
 /**
- * devres_alloc - Allocate device resource data
+ * __devres_alloc_node - Allocate device resource data
  * @release: Release function devres will be associated with
  * @size: Allocation size
  * @gfp: Allocation flags
  * @nid: NUMA node
+ * @name: Name of the resource
  *
  * Allocate devres of @size bytes.  The allocated area is zeroed, then
@@ -121 +124 @@
  * Pointer to allocated devres on success, NULL on failure.
  */
-void * devres_alloc_node(dr_release_t release, size_t size, gfp_t gfp, int nid)
+void *__devres_alloc_node(dr_release_t release, size_t size, gfp_t gfp, int nid,
+                          const char *name)
 {
         struct devres *dr;
 
         dr = alloc_dr(release, size, gfp | __GFP_ZERO, nid);
+        if (unlikely(!dr))
+                return NULL;
+        set_node_dbginfo(&dr->node, name, size);
         return dr->data;
 }
@@ -214 +221 @@
 }
 
-static int release_nodes(struct device *dev, struct list_head *first,
-                         struct list_head *end, unsigned long flags)
-{
-//      LIST_HEAD(todo);
-        struct list_head todo;
-
-        int cnt;
+static void release_nodes(struct device *dev, struct list_head *todo)
+{
         struct devres *dr, *tmp;
-
-        cnt = remove_nodes(dev, first, end, &todo);
-
-        spin_unlock_irqrestore(&dev->devres_lock, flags);
 
         /* Release.  Note that both devres and devres_group are
          * handled as devres in the following loop.  This is safe.
          */
-        list_for_each_entry_safe_reverse(dr, tmp, &todo, node.entry, struct devres) {
+        list_for_each_entry_safe_reverse(dr, tmp, todo, node.entry, struct devres) {
                 devres_log(dev, &dr->node, "REL");
                 dr->node.release(dev, dr->data);
                 kfree(dr);
         }
-
-        return cnt;
 }
 
@@ -249 +245 @@
 {
         unsigned long flags;
+        struct list_head todo;
+        int cnt;
 
         /* Looks like an uninitialized device structure */
         if (WARN_ON(dev->devres_head.next == NULL))
                 return -ENODEV;
+
+        /* Nothing to release if list is empty */
+        if (list_empty(&dev->devres_head))
+                return 0;
+
         spin_lock_irqsave(&dev->devres_lock, flags);
-        return release_nodes(dev, dev->devres_head.next, &dev->devres_head,
-                             flags);
-}
+        cnt = remove_nodes(dev, dev->devres_head.next, &dev->devres_head, &todo);
+        spin_unlock_irqrestore(&dev->devres_lock, flags);
+
+        release_nodes(dev, &todo);
+        return cnt;
+}
+
+/**
+ * devres_open_group - Open a new devres group
+ * @dev: Device to open devres group for
+ * @id: Separator ID
+ * @gfp: Allocation flags
+ *
+ * Open a new devres group for @dev with @id.  For @id, using a
+ * pointer to an object which won't be used for another group is
+ * recommended.  If @id is NULL, address-wise unique ID is created.
+ *
+ * RETURNS:
+ * ID of the new group, NULL on failure.
+ */
+void * devres_open_group(struct device *dev, void *id, gfp_t gfp)
+{
+        struct devres_group *grp;
+        unsigned long flags;
+
+        grp = kmalloc(sizeof(*grp), gfp);
+        if (unlikely(!grp))
+                return NULL;
+
+        grp->node[0].release = &group_open_release;
+        grp->node[1].release = &group_close_release;
+        INIT_LIST_HEAD(&grp->node[0].entry);
+        INIT_LIST_HEAD(&grp->node[1].entry);
+        set_node_dbginfo(&grp->node[0], "grp<", 0);
+        set_node_dbginfo(&grp->node[1], "grp>", 0);
+        grp->id = grp;
+        if (id)
+                grp->id = id;
+
+        spin_lock_irqsave(&dev->devres_lock, flags);
+        add_dr(dev, &grp->node[0]);
+        spin_unlock_irqrestore(&dev->devres_lock, flags);
+        return grp->id;
+}
+EXPORT_SYMBOL_GPL(devres_open_group);
+
+/* Find devres group with ID @id.  If @id is NULL, look for the latest. */
+static struct devres_group * find_group(struct device *dev, void *id)
+{
+        struct devres_node *node;
+
+        list_for_each_entry_reverse(node, &dev->devres_head, entry, struct devres_node) {
+                struct devres_group *grp;
+
+                if (node->release != &group_open_release)
+                        continue;
+
+                grp = container_of(node, struct devres_group, node[0]);
+
+                if (id) {
+                        if (grp->id == id)
+                                return grp;
+                } else if (list_empty(&grp->node[1].entry))
+                        return grp;
+        }
+
+        return NULL;
+}
+
+/**
+ * devres_release_group - Release resources in a devres group
+ * @dev: Device to release group for
+ * @id: ID of target group, can be NULL
+ *
+ * Release all resources in the group identified by @id.  If @id is
+ * NULL, the latest open group is selected.  The selected group and
+ * groups properly nested inside the selected group are removed.
+ *
+ * RETURNS:
+ * The number of released non-group resources.
+ */
+int devres_release_group(struct device *dev, void *id)
+{
+        struct devres_group *grp;
+        unsigned long flags;
+        struct list_head todo;
+        int cnt = 0;
+
+        spin_lock_irqsave(&dev->devres_lock, flags);
+
+        grp = find_group(dev, id);
+        if (grp) {
+                struct list_head *first = &grp->node[0].entry;
+                struct list_head *end = &dev->devres_head;
+
+                if (!list_empty(&grp->node[1].entry))
+                        end = grp->node[1].entry.next;
+
+                cnt = remove_nodes(dev, first, end, &todo);
+                spin_unlock_irqrestore(&dev->devres_lock, flags);
+
+                release_nodes(dev, &todo);
+        } else {
+                WARN_ON(1);
+                spin_unlock_irqrestore(&dev->devres_lock, flags);
+        }
+
+        return cnt;
+}
+EXPORT_SYMBOL_GPL(devres_release_group);
 
 static struct devres *find_dr(struct device *dev, dr_release_t release,
@@ -306 +416 @@
 
 /**
+ * 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);
+
+/*
+ * Custom devres actions allow inserting a simple function call
+ * into the teadown sequence.
+ */
+
+struct action_devres {
+        void *data;
+        void (*action)(void *);
+};
+
+static void devm_action_release(struct device *dev, void *res)
+{
+        struct action_devres *devres = res;
+
+        devres->action(devres->data);
+}
+
+/**
  * devm_add_action() - add a custom action to list of managed resources
  * @dev: Device that owns the action
@@ -316 +478 @@
 int devm_add_action(struct device *dev, void (*action)(void *), void *data)
 {
+        struct action_devres *devres;
+
+        devres = devres_alloc(devm_action_release,
+                              sizeof(struct action_devres), GFP_KERNEL);
+        if (!devres)
+                return -ENOMEM;
+
+        devres->data = data;
+        devres->action = action;
+
+        devres_add(dev, devres);
+
         return 0;
 }
@@ -331 +505 @@
 {
 }
+
+/*
+ * Managed kmalloc/kfree
+ */
+static void devm_kmalloc_release(struct device *dev, void *res)
+{
+        /* noop */
+}
+
+/**
+ * devm_kmalloc - Resource-managed kmalloc
+ * @dev: Device to allocate memory for
+ * @size: Allocation size
+ * @gfp: Allocation gfp flags
+ *
+ * Managed kmalloc.  Memory allocated with this function is
+ * automatically freed on driver detach.  Like all other devres
+ * resources, guaranteed alignment is unsigned long long.
+ *
+ * RETURNS:
+ * Pointer to allocated memory on success, NULL on failure.
+ */
+void *devm_kmalloc(struct device *dev, size_t size, gfp_t gfp)
+{
+        struct devres *dr;
+
+        if (unlikely(!size))
+                return ZERO_SIZE_PTR;
+
+        /* use raw alloc_dr for kmalloc caller tracing */
+        dr = alloc_dr(devm_kmalloc_release, size, gfp, dev_to_node(dev));
+        if (unlikely(!dr))
+                return NULL;
+
+        /*
+         * This is named devm_kzalloc_release for historical reasons
+         * The initial implementation did not support kmalloc, only kzalloc
+         */
+        set_node_dbginfo(&dr->node, "devm_kzalloc_release", size);
+        devres_add(dev, dr->data);
+        return dr->data;
+}
+EXPORT_SYMBOL_GPL(devm_kmalloc);
+
+enum devm_ioremap_type {
+        DEVM_IOREMAP = 0,
+        DEVM_IOREMAP_UC,
+        DEVM_IOREMAP_WC,
+        DEVM_IOREMAP_NP,
+};
+
+void devm_ioremap_release(struct device *dev, void *res)
+{
+        iounmap(*(void __iomem **)res);
+}
+
+static void *__devm_ioremap(struct device *dev, resource_size_t offset,
+                                    resource_size_t size,
+                                    enum devm_ioremap_type type)
+{
+        void __iomem **ptr, *addr = NULL;
+
+        ptr = devres_alloc(devm_ioremap_release, sizeof(*ptr), GFP_KERNEL);
+        if (!ptr)
+                return NULL;
+
+        switch (type) {
+        case DEVM_IOREMAP:
+                addr = ioremap(offset, size);
+                break;
+#if 0
+        case DEVM_IOREMAP_UC:
+                addr = ioremap_uc(offset, size);
+                break;
+        case DEVM_IOREMAP_WC:
+                addr = ioremap_wc(offset, size);
+                break;
+        case DEVM_IOREMAP_NP:
+                addr = ioremap_np(offset, size);
+                break;
+#endif
+        }
+
+        if (addr) {
+                *ptr = addr;
+                devres_add(dev, ptr);
+        } else
+                devres_free(ptr);
+
+        return addr;
+}
+
+/**
+ * devm_ioremap - Managed ioremap()
+ * @dev: Generic device to remap IO address for
+ * @offset: Resource address to map
+ * @size: Size of map
+ *
+ * Managed ioremap().  Map is automatically unmapped on driver detach.
+ */
+void __iomem *devm_ioremap(struct device *dev, resource_size_t offset,
+                           resource_size_t size)
+{
+        return __devm_ioremap(dev, offset, size, DEVM_IOREMAP);
+}
+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, (char*)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);