Changeset 772 for GPL/trunk/lib32

Timestamp:

Apr 19, 2025, 8:08:37 PM (7 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/Makefile (modified) (1 diff)
• lib32/bitmap.c (modified) (2 diffs)
• lib32/component.c (copied) (copied from GPL/branches/uniaud32-exp/lib32/component.c )
• lib32/devres.c (modified) (12 diffs)
• lib32/driver.c (modified) (2 diffs)
• lib32/drivers_base.c (modified) (1 diff)
• lib32/driversbase.c (deleted)
• lib32/internal.h (modified) (1 diff)
• lib32/irq.c (modified) (1 diff)
• lib32/memory.c (modified) (5 diffs)
• lib32/misc.c (modified) (3 diffs)
• lib32/ossidc.c (modified) (2 diffs)
• lib32/pci.c (modified) (5 diffs)
• lib32/regcache-rbtree.c (modified) (1 diff)
• lib32/regcache.c (modified) (3 diffs)
• lib32/regmap.c (modified) (2 diffs)
• lib32/soundmixer.c (modified) (1 diff)
• lib32/vsprintf.c (modified) (2 diffs)

GPL/trunk/lib32/Makefile

@@ -30 +30 @@
   strncmp.obj timer.obj kobject.obj driver.obj drivers_base.obj &
   instropl2.obj instropl3.obj vsprintf.obj bitmap.obj find_next_bit.obj &
-  regmap.obj regcache.obj regcache-flat.obj regcache-rbtree.obj
+  regmap.obj regcache.obj regcache-flat.obj regcache-rbtree.obj &
+  component.obj
 
 TARGET = linuxlib

GPL/trunk/lib32/bitmap.c

@@ -512 +512 @@
                         int nmaskbits)
 {
-        if (!access_ok(VERIFY_READ, ubuf, ulen))
+        if (!access_ok(ubuf, ulen))
                 return -EFAULT;
         return __bitmap_parse((const char *)ubuf, ulen, 1, maskp, nmaskbits);
@@ -704 +704 @@
                         int nmaskbits)
 {
-        if (!access_ok(VERIFY_READ, ubuf, ulen))
+        if (!access_ok(ubuf, ulen))
                 return -EFAULT;
         return __bitmap_parselist((const char *)ubuf,

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

GPL/trunk/lib32/driver.c

@@ -557 +557 @@
 //                      goto probe_failed;
         }
-#ifdef TARGET_OS2xxx
+#ifdef NOT_USED
         driver_bound(dev);
         ret = 1;
@@ -613 +613 @@
                 else if (drv->remove)
                         drv->remove(dev);
-                devres_release_all(dev);
+//              devres_release_all(dev);
                 dev->driver = NULL;
                 klist_remove(&dev->p->knode_driver);

GPL/trunk/lib32/drivers_base.c

@@ -173 +173 @@
          */
         drv = dev->driver;
+#if 0
         return drv ? drv->name :
                         (dev->bus ? dev->bus->name :
                         (dev->class ? dev->class->name : ""));
+#else
+        return "uniaud32";
+#endif
 }
+
+int device_match_name(struct device *dev, const void *name)
+{
+        return sysfs_streq(dev_name(dev), name);
+}
+EXPORT_SYMBOL_GPL(device_match_name);
+
+int device_match_of_node(struct device *dev, const void *np)
+{
+        return dev->of_node == np;
+}
+EXPORT_SYMBOL_GPL(device_match_of_node);

GPL/trunk/lib32/internal.h

@@ -274 +274 @@
 
 extern struct regcache_ops regcache_rbtree_ops;
-extern struct regcache_ops regcache_lzo_ops;
+extern struct regcache_ops regcache_maple_ops;
 extern struct regcache_ops regcache_flat_ops;
 

GPL/trunk/lib32/irq.c

@@ -249 +249 @@
 //******************************************************************************
 
+/*
+ * Device resource management aware IRQ request/free implementation.
+ */
+struct irq_devres {
+        unsigned int irq;
+        void *dev_id;
+}; 
+
+static void devm_irq_release(struct device *dev, void *res)
+{
+        struct irq_devres *this = res;
+
+        free_irq(this->irq, this->dev_id);
+}
+
+/**
+ *      devm_request_threaded_irq - allocate an interrupt line for a managed device
+ *      @dev: device to request interrupt for
+ *      @irq: Interrupt line to allocate
+ *      @handler: Function to be called when the IRQ occurs
+ *      @thread_fn: function to be called in a threaded interrupt context. NULL
+ *                  for devices which handle everything in @handler
+ *      @irqflags: Interrupt type flags
+ *      @devname: An ascii name for the claiming device, dev_name(dev) if NULL
+ *      @dev_id: A cookie passed back to the handler function
+ *
+ *      Except for the extra @dev argument, this function takes the
+ *      same arguments and performs the same function as
+ *      request_threaded_irq().  IRQs requested with this function will be
+ *      automatically freed on driver detach.
+ *
+ *      If an IRQ allocated with this function needs to be freed
+ *      separately, devm_free_irq() must be used.
+ */
+int devm_request_threaded_irq(struct device *dev, unsigned int irq,
+                              irq_handler_t handler, irq_handler_t thread_fn,
+                              unsigned long irqflags, const char *devname,
+                              void *dev_id)
+{
+        struct irq_devres *dr;
+        int rc;
+
+        dr = devres_alloc(devm_irq_release, sizeof(struct irq_devres),
+                          GFP_KERNEL);
+        if (!dr)
+                return -ENOMEM;
+
+        if (!devname)
+                devname = dev_name(dev);
+
+        rc = request_irq(irq, handler, irqflags, devname,
+                                  dev_id);
+        if (rc) {
+                devres_free(dr);
+                return rc;
+        }
+
+        dr->irq = irq;
+        dr->dev_id = dev_id;
+        devres_add(dev, dr);
+
+        return 0;
+}

GPL/trunk/lib32/memory.c

@@ -424 +424 @@
 void *__vmalloc(unsigned long size, gfp_t gfp_mask)
 {
-        return vmalloc(size);
+    LINEAR addr;
+    addr = (LINEAR) vmalloc(size);
+
+    if (gfp_mask & __GFP_ZERO)
+        memset((LINEAR)addr, 0, size);
+
+    return addr;
 }
 //******************************************************************************
@@ -610 +616 @@
 
 //******************************************************************************
+//******************************************************************************
 #ifdef DEBUGHEAP
 void *__kmalloc(int size, int flags, const char *filename, int lineno)
@@ -626 +633 @@
     }
     if(size >= 4096) {
-        return vmalloc(size);
-    }
+        addr = (LINEAR)vmalloc(size);
+    } else {
 #ifdef DEBUGHEAP
-    addr = (LINEAR)malloc(size, filename, lineno);
+        addr = (LINEAR)malloc(size, filename, lineno);
 #else
-    addr = (LINEAR)malloc(size);
+        addr = (LINEAR)malloc(size);
 #endif
+    }
     if(addr == NULL) {
         DebugInt3();
         return 0;
     }
+    if (flags & __GFP_ZERO)
+        memset((LINEAR)addr, 0, size);
         //dprintf(("kmalloc %d returned %x", size, addr));
     return addr;
 }
 
+//******************************************************************************
 //******************************************************************************
 #ifdef DEBUGHEAP
@@ -668 +679 @@
 
 //******************************************************************************
-void *kzalloc(size_t size, unsigned int flags)
-{
-        void *ret;
-        ret = _kmalloc(size, flags);
-        if (ret)
-                memset(ret, 0, size);
-        return ret;
-}
-//******************************************************************************
 //******************************************************************************
 void *kcalloc(size_t n, size_t size, unsigned int flags)
@@ -773 +775 @@
         return buf;
 }
+
 //******************************************************************************
 //******************************************************************************

GPL/trunk/lib32/misc.c

@@ -28 +28 @@
 #include <linux/init.h>
 #include <linux/fs.h>
+#include <linux/of.h>
 #include <linux/poll.h>
 #define CONFIG_PROC_FS 1
@@ -39 +40 @@
 #include <linux/firmware.h>
 #include <linux/ctype.h>
+#include <linux/math64.h>
 #include <dbgos2.h>
 
 void StringOut(char *DbgStr);
+extern int vscnprintf(char *buf, size_t size, const char *fmt, va_list args);
 
 struct new_utsname system_utsname = {0};
@@ -784 +787 @@
         free_pages((unsigned long) ptr, pg);
 }
+
+/**
+ * of_node_put() - Decrement refcount of a node
+ * @node:       Node to dec refcount, NULL is supported to simplify writing of
+ *              callers
+ */
+void of_node_put(struct device_node *node)
+{
+        if (node)
+                kobject_put(&node->kobj);
+}
+
+/**
+ * sysfs_streq - return true if strings are equal, modulo trailing newline
+ * @s1: one string
+ * @s2: another string
+ *
+ * This routine returns true iff two strings are equal, treating both
+ * NUL and newline-then-NUL as equivalent string terminations.  It's
+ * geared for use with sysfs input strings, which generally terminate
+ * with newlines but are compared against values without newlines.
+ */
+bool sysfs_streq(const char *s1, const char *s2)
+{
+        while (*s1 && *s1 == *s2) {
+                s1++;
+                s2++;
+        }
+
+        if (*s1 == *s2)
+                return true;
+        if (!*s1 && *s2 == '\n' && !s2[1])
+                return true;
+        if (*s1 == '\n' && !s1[1] && !*s2)
+                return true;
+        return false;
+}
+EXPORT_SYMBOL(sysfs_streq);
+
+u64 div64_u64_rem(u64 dividend, u64 divisor, u64 *remainder)
+{
+        u32 high = divisor >> 32;
+        u64 quot;
+
+        if (high == 0) {
+                u32 rem32;
+                quot = div_u64_rem(dividend, divisor, &rem32);
+                *remainder = rem32;
+        } else {
+                int n = fls(high);
+                quot = div_u64(dividend >> n, divisor >> n);
+
+                if (quot != 0)
+                        quot--;
+
+                *remainder = dividend - quot * divisor;
+                if (*remainder >= divisor) {
+                        quot++;
+                        *remainder -= divisor;
+                }
+        }
+
+        return quot;
+}
+
+/**
+ * memset32() - Fill a memory area with a uint32_t
+ * @s: Pointer to the start of the area.
+ * @v: The value to fill the area with
+ * @count: The number of values to store
+ *
+ * Differs from memset() in that it fills with a uint32_t instead
+ * of a byte.  Remember that @count is the number of uint32_ts to
+ * store, not the number of bytes.
+ */
+void *memset32(uint32_t *s, uint32_t v, size_t count)
+{
+        uint32_t *xs = s;
+
+        while (count--)
+                *xs++ = v;
+        return s;
+}
+EXPORT_SYMBOL(memset32);
+
+/**
+ *      sysfs_emit - scnprintf equivalent, aware of PAGE_SIZE buffer.
+ *      @buf:   start of PAGE_SIZE buffer.
+ *      @fmt:   format
+ *      @...:   optional arguments to @format
+ *
+ *
+ * Returns number of characters written to @buf.
+ */
+int sysfs_emit(char *buf, const char *fmt, ...)
+{
+        va_list args;
+        int len;
+
+#ifdef NOT_USED
+        if (WARN(!buf || offset_in_page(buf),
+                 "invalid sysfs_emit: buf:%p\n", buf))
+                return 0;
+#endif
+
+        va_start(args, fmt);
+        len = vscnprintf(buf, PAGE_SIZE, fmt, args);
+        va_end(args);
+
+        return len;
+}
+EXPORT_SYMBOL_GPL(sysfs_emit);
+
+/**
+ *      sysfs_emit_at - scnprintf equivalent, aware of PAGE_SIZE buffer.
+ *      @buf:   start of PAGE_SIZE buffer.
+ *      @at:    offset in @buf to start write in bytes
+ *              @at must be >= 0 && < PAGE_SIZE
+ *      @fmt:   format
+ *      @...:   optional arguments to @fmt
+ *
+ *
+ * Returns number of characters written starting at &@buf[@at].
+ */
+int sysfs_emit_at(char *buf, int at, const char *fmt, ...)
+{
+        va_list args;
+        int len;
+
+#ifdef NOT_USED
+        if (WARN(!buf || offset_in_page(buf) || at < 0 || at >= PAGE_SIZE,
+                 "invalid sysfs_emit_at: buf:%p at:%d\n", buf, at))
+                return 0;
+#endif
+
+        va_start(args, fmt);
+        len = vscnprintf(buf + at, PAGE_SIZE - at, fmt, args);
+        va_end(args);
+
+        return len;
+}
+EXPORT_SYMBOL_GPL(sysfs_emit_at);

GPL/trunk/lib32/ossidc.c

@@ -64 +64 @@
 
 cardcalls_t cardcalls[CARDS_NUM] = {
+        { CARD_AZX,      &name_module_init(azx_driver_init),            &name_module_exit(azx_driver_exit)        },
         { CARD_ICH,      &name_module_init(intel8x0_driver_init),       &name_module_exit(intel8x0_driver_exit)   },
         { CARD_VIA82XX,  &name_module_init(via82xx_driver_init),        &name_module_exit(via82xx_driver_exit)    },
@@ -89 +90 @@
         { CARD_ATIIXP,   &name_module_init(atiixp_driver_init),         &name_module_exit(atiixp_driver_exit)     },
         { CARD_AUDIGYLS, &name_module_init(ca0106_driver_init),         &name_module_exit(ca0106_driver_exit)     },
-        { CARD_AZX,      &name_module_init(azx_driver_init),            &name_module_exit(azx_driver_exit)        },
         { CARD_BT87X,    &name_module_init(alsa_card_bt87x_init),       &name_module_exit(alsa_card_bt87x_exit)   },
 };

GPL/trunk/lib32/pci.c

@@ -30 +30 @@
 #include <linux/poll.h>
 #include <linux/dma-mapping.h>
+#include <linux/gfp.h>
 #include <asm/uaccess.h>
 #include <asm/hardirq.h>
@@ -205 +206 @@
         pcidev->dev.dma_mask = &pcidev->dma_mask;
         pcidev->dev.coherent_dma_mask = 0xffffffffull;
+        INIT_LIST_HEAD(&pcidev->dev.devres_head);
 
         // Subsystem ID
@@ -800 +802 @@
 }
 
-/**
- */
-void pci_set_driver_data (struct pci_dev *dev, void *driver_data)
-{
-  if (dev)
-    dev->driver_data = driver_data;
-}
-
-/**
- */
-void *pci_get_driver_data (struct pci_dev *dev)
-{
-  if (dev)
-    return dev->driver_data;
-  return 0;
-}
 
 /**
@@ -1038 +1024 @@
 }
 
-struct pci_driver_mapping {
-  struct pci_dev *dev;
-  struct pci_driver *drv;
-  unsigned long dma_mask;
-  void *driver_data;
-  u32 saved_config[16];
-};
-
-#define PCI_MAX_MAPPINGS 64
-static struct pci_driver_mapping drvmap [PCI_MAX_MAPPINGS] = { { NULL, } , };
-
-
-static struct pci_driver_mapping *get_pci_driver_mapping(struct pci_dev *dev)
-{
-  int i;
-
-  for (i = 0; i < PCI_MAX_MAPPINGS; i++)
-    if (drvmap[i].dev == dev)
-      return &drvmap[i];
-  return NULL;
-}
-
-struct pci_driver *snd_pci_compat_get_pci_driver(struct pci_dev *dev)
-{
-  struct pci_driver_mapping *map = get_pci_driver_mapping(dev);
-  if (map)
-    return map->drv;
-  return NULL;
-}
-#if 0
-void * pci_get_drvdata (struct pci_dev *dev)
-{
-  struct pci_driver_mapping *map = get_pci_driver_mapping(dev);
-  if (map)
-    return map->driver_data;
-  return NULL;
-}
-
-
-void pci_set_drvdata (struct pci_dev *dev, void *driver_data)
-{
-  struct pci_driver_mapping *map = get_pci_driver_mapping(dev);
-  if (map)
-    map->driver_data = driver_data;
-}
-#endif
-
-
 //******************************************************************************
 //******************************************************************************
@@ -1180 +1118 @@
 }
 
+struct region_devres {
+        struct resource *parent;
+        resource_size_t start;
+        resource_size_t n;
+};
+
+static void devm_region_release(struct device *dev, void *res)
+{
+        struct region_devres *this = res;
+
+        __release_region(this->parent, this->start, this->n);
+}
+
+struct resource *
+__devm_request_region(struct device *dev, struct resource *parent,
+                      resource_size_t start, resource_size_t n, const char *name)
+{
+        struct region_devres *dr = NULL;
+        struct resource *res;
+
+        dr = devres_alloc(devm_region_release, sizeof(struct region_devres),
+                          GFP_KERNEL);
+        if (!dr)
+                return NULL;
+
+        dr->parent = parent;
+        dr->start = start;
+        dr->n = n;
+
+        res = __request_region(parent, start, n, name);
+        if (res)
+                devres_add(dev, dr);
+        else
+                devres_free(dr);
+
+        return res;
+}
+EXPORT_SYMBOL(__devm_request_region);
+
+/*
+ * Managed PCI resources.  This manages device on/off, INTx/MSI/MSI-X
+ * on/off and BAR regions.  pci_dev itself records MSI/MSI-X status, so
+ * there's no need to track it separately.  pci_devres is initialized
+ * when a device is enabled using managed PCI device enable interface.
+ */
+struct pci_devres {
+        unsigned int enabled:1;
+        unsigned int pinned:1;
+        unsigned int orig_intx:1;
+        unsigned int restore_intx:1;
+        unsigned int mwi:1;
+        u32 region_mask;
+};
+
+static void pcim_release(struct device *gendev, void *res)
+{
+}
+
+static struct pci_devres *find_pci_dr(struct pci_dev *pdev)
+{
+        if (pci_is_managed(pdev))
+                return devres_find(&pdev->dev, pcim_release, NULL, NULL);
+        return NULL;
+}
+
+/**
+ * pci_intx - enables/disables PCI INTx for device dev
+ * @pdev: the PCI device to operate on
+ * @enable: boolean: whether to enable or disable PCI INTx
+ *
+ * Enables/disables PCI INTx for device @pdev
+ */
+void pci_intx(struct pci_dev *pdev, int enable)
+{
+        u16 pci_command, new;
+
+        pci_read_config_word(pdev, PCI_COMMAND, &pci_command);
+
+        if (enable)
+                new = pci_command & ~PCI_COMMAND_INTX_DISABLE;
+        else
+                new = pci_command | PCI_COMMAND_INTX_DISABLE;
+
+        if (new != pci_command) {
+                struct pci_devres *dr;
+
+                pci_write_config_word(pdev, PCI_COMMAND, new);
+
+                dr = find_pci_dr(pdev);
+                if (dr && !dr->restore_intx) {
+                        dr->restore_intx = 1;
+                        dr->orig_intx = !enable;
+                }
+        }
+}
+EXPORT_SYMBOL_GPL(pci_intx);

GPL/trunk/lib32/regcache-rbtree.c

@@ -170 +170 @@
                 average = 0;
 
-        seq_printf(s, "%d nodes, %d registers, average %d registers, used %zu bytes\n",
+        seq_printf(s, "%d nodes, %d registers, average %d registers, used %lu bytes\n",
                    nodes, registers, average, mem_size);
 

GPL/trunk/lib32/regcache.c

@@ -24 +24 @@
 static const struct regcache_ops *cache_types[] = {
         &regcache_rbtree_ops,
-#if IS_ENABLED(CONFIG_REGCACHE_COMPRESSED)
-        &regcache_lzo_ops,
+#ifndef TARGET_OS2 // Not (yet?) supported
+        &regcache_maple_ops,
 #endif
         &regcache_flat_ops,
@@ -562 +562 @@
 EXPORT_SYMBOL_GPL(regcache_cache_bypass);
 
+/**
+ * regcache_reg_cached - Check if a register is cached
+ *
+ * @map: map to check
+ * @reg: register to check
+ *
+ * Reports if a register is cached.
+ */
+bool regcache_reg_cached(struct regmap *map, unsigned int reg)
+{
+        unsigned int val;
+        int ret;
+
+        map->lock(map->lock_arg);
+
+        ret = regcache_read(map, reg, &val);
+
+        map->unlock(map->lock_arg);
+
+        return ret == 0;
+}
+EXPORT_SYMBOL_GPL(regcache_reg_cached);
+
 bool regcache_set_val(struct regmap *map, void *base, unsigned int idx,
                       unsigned int val)
@@ -729 +752 @@
         count = (cur - base) / map->reg_stride;
 
-        dev_dbg(map->dev, "Writing %zu bytes for %d registers from 0x%x-0x%x\n",
+        dev_dbg(map->dev, "Writing %lu bytes for %d registers from 0x%x-0x%x\n",
                 count * val_bytes, count, base, cur - map->reg_stride);
 

GPL/trunk/lib32/regmap.c

@@ -652 +652 @@
                 return ret;
 
+        regmap_debugfs_exit(map);
         regmap_debugfs_init(map);
 
@@ -1731 +1732 @@
                 /* If the write goes beyond the end of the window split it */
                 while (val_num > win_residue) {
-                        dev_dbg(map->dev, "Writing window %d/%zu\n",
+                        dev_dbg(map->dev, "Writing window %d/%lu\n",
                                 win_residue, val_len / map->format.val_bytes);
                         ret = _regmap_raw_write_impl(map, reg, val,

GPL/trunk/lib32/soundmixer.c

@@ -409 +409 @@
       idxMute = pHandle->controls[OSS_MIXER_FRONT].idxMute;
     }
-    /* HDA codecs workaround from Andy */
-    if (idx == -1)
-    {
-      idx = pHandle->controls[OSS_MIXER_SPEAKER].idxVolume;
-      idxMute = pHandle->controls[OSS_MIXER_SPEAKER].idxMute;
-    }
-    /* HDA codecs workaround from Andy */
     break;
   case OSS32_MIX_VOLUME_MIDI:

GPL/trunk/lib32/vsprintf.c

@@ -32 +32 @@
 
 #include <stdarg.h>
-
+#include <linux/kernel.h>
 
 
@@ -366 +366 @@
 }
 
+/**
+ * vscnprintf - Format a string and place it in a buffer
+ * @buf: The buffer to place the result into
+ * @size: The size of the buffer, including the trailing null space
+ * @fmt: The format string to use
+ * @args: Arguments for the format string
+ *
+ * The return value is the number of characters which have been written into
+ * the @buf not including the trailing '\0'. If @size is == 0 the function
+ * returns 0.
+ *
+ * If you're not already dealing with a va_list consider using scnprintf().
+ *
+ * See the vsnprintf() documentation for format string extensions over C99.
+ */
+int vscnprintf(char *buf, size_t size, const char *fmt, va_list args)
+{
+        int i;
+
+        if (unlikely(!size))
+                return 0;
+
+        i = vsnprintf(buf, size, fmt, args);
+
+        if (likely(i < size))
+                return i;
+
+        return size - 1;
+}