Changeset 718

Timestamp:

Sep 2, 2022, 4:26:36 AM (3 years ago)

Author:

Paul Smedley

Message:

WIP trying to fix non-HDA Hardware

Location:

GPL/branches/uniaud32-next

Files:

• include/linux/device.h (modified) (4 diffs)
• include/linux/interrupt.h (modified) (1 diff)
• include/linux/io.h (modified) (1 diff)
• include/linux/ioport.h (modified) (1 diff)
• include/linux/types.h (modified) (1 diff)
• lib32/devres.c (modified) (12 diffs)
• lib32/driver.c (modified) (1 diff)
• lib32/drivers_base.c (modified) (1 diff)
• lib32/driversbase.c (deleted)
• lib32/irq.c (modified) (1 diff)
• lib32/pci.c (modified) (1 diff)
• lib32/regcache.c (modified) (9 diffs)
• lib32/regmap.c (modified) (61 diffs)

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

@@ -92 +92 @@
 static inline const char *dev_name(const struct device *dev)
 {
+#if 0
         /* Use the init name until the kobject becomes available */
         if (dev->init_name)
@@ -97 +98 @@
 
         return kobject_name(&dev->kobj);
+#else
+        return "uniaud32";
+#endif
 }
 
@@ -218 +222 @@
 typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
 
+#define NUMA_NO_NODE    (-1)
+#if 0
 extern void *devres_alloc_node(dr_release_t release, size_t size, gfp_t gfp,
                                int nid);
-#define NUMA_NO_NODE    (-1)
 static inline void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp)
 {
         return devres_alloc_node(release, size, gfp, NUMA_NO_NODE);
 }
-
+#else
+void *__devres_alloc_node(dr_release_t release, size_t size, gfp_t gfp,
+                          int nid, const char *name);
+#define devres_alloc(release, size, gfp) \
+        __devres_alloc_node(release, size, gfp, NUMA_NO_NODE, #release)
+#endif
 /**
  * struct class - device classes
@@ -290 +300 @@
 /* debugging and troubleshooting/diagnostic helpers. */
 extern const char *dev_driver_string(const struct device *dev);
-#define devm_kzalloc(A, B, C) kzalloc(B, C)
-#define devm_kmalloc(A, B, C) kmalloc(B, C)
-#define devm_kcalloc(A, B, C, D) kmalloc(B, C)
-#define devm_kmalloc_array(A, B, C, D) kmalloc_array(B, C, D)
-
+void *devm_kmalloc(struct device *dev, size_t size, gfp_t gfp);
+
+static inline void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp)
+{
+        return devm_kmalloc(dev, size, gfp | __GFP_ZERO);
+}
+
+static inline void *devm_kmalloc_array(struct device *dev,
+                                       size_t n, size_t size, gfp_t flags)
+{
+//      size_t bytes;
+
+//      if (unlikely(check_mul_overflow(n, size, &bytes)))
+//              return NULL;
+
+        return devm_kmalloc(dev, n * size, flags);
+}
+static inline void *devm_kcalloc(struct device *dev,
+                                 size_t n, size_t size, gfp_t flags)
+{
+        return devm_kmalloc_array(dev, n, size, flags | __GFP_ZERO);
+}
 
 /* allows to add/remove a custom action to devres stack */
 int devm_add_action(struct device *dev, void (*action)(void *), void *data);
 void devm_remove_action(struct device *dev, void (*action)(void *), void *data);
+
+static inline int dev_to_node(struct device *dev)
+{
+        return NUMA_NO_NODE;
+}
 #endif /* _LINUX_DEVICE_H */
 

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

@@ -154 +154 @@
 
 static inline void devm_free_irq(struct device *dev, unsigned int irq, void *dev_id) {}
-#define devm_request_irq(A, B, C, D, E, F) request_irq(B, C, D, E, F)
 
+extern int __must_check
+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);
+
+static inline int __must_check
+devm_request_irq(struct device *dev, unsigned int irq, irq_handler_t handler,
+                 unsigned long irqflags, const char *devname, void *dev_id)
+{
+        return devm_request_threaded_irq(dev, irq, handler, NULL, irqflags,
+                                         devname, dev_id);
+}
 #endif

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

@@ -7 +7 @@
 #include <linux/err.h>
 
-#define devm_ioremap(A, B, C) ioremap(B, C)
 #endif /* _LINUX_IO_H */

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

@@ -111 +111 @@
 extern int autoirq_report(int waittime);
 
-#define devm_request_region(A, B, C, D) request_region(B, C, D)
+extern struct resource * __devm_request_region(struct device *dev,
+                                struct resource *parent, resource_size_t start,
+                                resource_size_t n, const char *name);
+
+#define devm_request_region(dev,start,n,name) \
+        __devm_request_region(dev, &ioport_resource, (start), (n), (name))
 #endif  /* _LINUX_IOPORT_H */

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

@@ -135 +135 @@
         unsigned long name[((bits)+BITS_PER_LONG-1)/BITS_PER_LONG]
 
+typedef u32 phys_addr_t;
+typedef phys_addr_t resource_size_t;
+
 #endif /* _LINUX_TYPES_H */

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

@@ -13 +13 @@
 #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 +25 @@
         struct devres_node              node;
         /* -- 3 pointers */
-        unsigned long long              data[]; /* guarantee ull alignment */
+        u8              data[]; /* guarantee ull alignment */
 };
 
@@ -36 +35 @@
 };
 
+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)
 
@@ -83 +89 @@
         BUG_ON(!list_empty(&node->entry));
 //#ifndef TARGET_OS2
-        /* Traps here on OS/2 */
+        /* Traps here on OS/2 - release builds on non-HDA hardware only */
+        rprintf(("add_dr"));
         list_add_tail(&node->entry, &dev->devres_head);
+        rprintf(("add_dr2"));
 //#endif
 }
@@ -99 +107 @@
 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 +116 @@
 
 /**
- * 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 +130 @@
  * 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;
 }
@@ -145 +158 @@
 }
 
+#if 0 //2022-09-02
 static int remove_nodes(struct device *dev,
                         struct list_head *first, struct list_head *end,
@@ -257 +271 @@
                              flags);
 }
+#endif
 
 static struct devres *find_dr(struct device *dev, dr_release_t release,
@@ -305 +320 @@
 }
 
+/*
+ * 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
@@ -316 +348 @@
 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 +375 @@
 {
 }
+
+/*
+ * Managed kmalloc/kfree
+ */
+static void devm_kmalloc_release(struct device *dev, void *res)
+{
+        /* noop */
+}
+
+static int devm_kmalloc_match(struct device *dev, void *res, void *data)
+{
+        return res == data;
+}
+
+/**
+ * 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 int devm_ioremap_match(struct device *dev, void *res, void *match_data)
+{
+        return *(void **)res == match_data;
+}
+
+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);

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

@@ -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/branches/uniaud32-next/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
 }

GPL/branches/uniaud32-next/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/branches/uniaud32-next/lib32/pci.c

@@ -1180 +1180 @@
 }
 
+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);

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

@@ -22 +22 @@
 #include "internal.h"
 
-static const struct regcache_ops *cache_types[] = {
+/*static*/ const struct regcache_ops *cache_types[] = {
         &regcache_rbtree_ops,
 #if IS_ENABLED(CONFIG_REGCACHE_COMPRESSED)
@@ -30 +30 @@
 };
 
-static int regcache_hw_init(struct regmap *map)
+/*static*/ int regcache_hw_init(struct regmap *map)
 {
         int i, j;
@@ -283 +283 @@
 }
 
-static bool regcache_reg_needs_sync(struct regmap *map, unsigned int reg,
+/*static*/ bool regcache_reg_needs_sync(struct regmap *map, unsigned int reg,
                                     unsigned int val)
 {
@@ -299 +299 @@
 }
 
-static int regcache_default_sync(struct regmap *map, unsigned int min,
+/*static*/ int regcache_default_sync(struct regmap *map, unsigned int min,
                                  unsigned int max)
 {
@@ -649 +649 @@
 }
 
-static int regcache_default_cmp(const void *a, const void *b)
+/*static*/ int regcache_default_cmp(const void *a, const void *b)
 {
         const struct reg_default *_a = a;
@@ -674 +674 @@
 }
 
-static bool regcache_reg_present(unsigned long *cache_present, unsigned int idx)
+/*static*/ bool regcache_reg_present(unsigned long *cache_present, unsigned int idx)
 {
         if (!cache_present)
@@ -682 +682 @@
 }
 
-static int regcache_sync_block_single(struct regmap *map, void *block,
+/*static*/ int regcache_sync_block_single(struct regmap *map, void *block,
                                       unsigned long *cache_present,
                                       unsigned int block_base,
@@ -718 +718 @@
 }
 
-static int regcache_sync_block_raw_flush(struct regmap *map, const void **data,
+/*static*/ int regcache_sync_block_raw_flush(struct regmap *map, const void **data,
                                          unsigned int base, unsigned int cur)
 {
@@ -746 +746 @@
 }
 
-static int regcache_sync_block_raw(struct regmap *map, void *block,
+/*static*/ int regcache_sync_block_raw(struct regmap *map, void *block,
                             unsigned long *cache_present,
                             unsigned int block_base, unsigned int start,

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

@@ -45 +45 @@
 
 #ifdef LOG_DEVICE
-static inline bool regmap_should_log(struct regmap *map)
+/*static*/ inline bool regmap_should_log(struct regmap *map)
 {
         return (map->dev && strcmp(dev_name(map->dev), LOG_DEVICE) == 0);
 }
 #else
-static inline bool regmap_should_log(struct regmap *map) { return false; }
-#endif
-
-
-static int _regmap_update_bits(struct regmap *map, unsigned int reg,
+/*static*/ inline bool regmap_should_log(struct regmap *map) { return false; }
+#endif
+
+
+/*static*/ int _regmap_update_bits(struct regmap *map, unsigned int reg,
                                unsigned int mask, unsigned int val,
                                bool *change, bool force_write);
 
-static int _regmap_bus_reg_read(void *context, unsigned int reg,
+/*static*/ int _regmap_bus_reg_read(void *context, unsigned int reg,
                                 unsigned int *val);
-static int _regmap_bus_read(void *context, unsigned int reg,
+/*static*/ int _regmap_bus_read(void *context, unsigned int reg,
                             unsigned int *val);
-static int _regmap_bus_formatted_write(void *context, unsigned int reg,
+/*static*/ int _regmap_bus_formatted_write(void *context, unsigned int reg,
                                        unsigned int val);
-static int _regmap_bus_reg_write(void *context, unsigned int reg,
+/*static*/ int _regmap_bus_reg_write(void *context, unsigned int reg,
                                  unsigned int val);
-static int _regmap_bus_raw_write(void *context, unsigned int reg,
+/*static*/ int _regmap_bus_raw_write(void *context, unsigned int reg,
                                  unsigned int val);
 
@@ -209 +209 @@
 }
 
-static bool regmap_volatile_range(struct regmap *map, unsigned int reg,
+/*static*/ bool regmap_volatile_range(struct regmap *map, unsigned int reg,
         size_t num)
 {
@@ -221 +221 @@
 }
 
-static void regmap_format_12_20_write(struct regmap *map,
+/*static*/ void regmap_format_12_20_write(struct regmap *map,
                                      unsigned int reg, unsigned int val)
 {
@@ -233 +233 @@
 
 
-static void regmap_format_2_6_write(struct regmap *map,
+/*static*/ void regmap_format_2_6_write(struct regmap *map,
                                      unsigned int reg, unsigned int val)
 {
@@ -241 +241 @@
 }
 
-static void regmap_format_4_12_write(struct regmap *map,
+/*static*/ void regmap_format_4_12_write(struct regmap *map,
                                      unsigned int reg, unsigned int val)
 {
@@ -248 +248 @@
 }
 
-static void regmap_format_7_9_write(struct regmap *map,
+/*static*/ void regmap_format_7_9_write(struct regmap *map,
                                     unsigned int reg, unsigned int val)
 {
@@ -255 +255 @@
 }
 
-static void regmap_format_10_14_write(struct regmap *map,
+/*static*/ void regmap_format_10_14_write(struct regmap *map,
                                     unsigned int reg, unsigned int val)
 {
@@ -265 +265 @@
 }
 
-static void regmap_format_8(void *buf, unsigned int val, unsigned int shift)
+/*static*/ void regmap_format_8(void *buf, unsigned int val, unsigned int shift)
 {
         u8 *b = buf;
@@ -272 +272 @@
 }
 
-static void regmap_format_16_be(void *buf, unsigned int val, unsigned int shift)
+/*static*/ void regmap_format_16_be(void *buf, unsigned int val, unsigned int shift)
 {
         put_unaligned_be16(val << shift, buf);
 }
 
-static void regmap_format_16_le(void *buf, unsigned int val, unsigned int shift)
+/*static*/ void regmap_format_16_le(void *buf, unsigned int val, unsigned int shift)
 {
         put_unaligned_le16(val << shift, buf);
 }
 
-static void regmap_format_16_native(void *buf, unsigned int val,
+/*static*/ void regmap_format_16_native(void *buf, unsigned int val,
                                     unsigned int shift)
 {
@@ -290 +290 @@
 }
 
-static void regmap_format_24(void *buf, unsigned int val, unsigned int shift)
+/*static*/ void regmap_format_24(void *buf, unsigned int val, unsigned int shift)
 {
         u8 *b = buf;
@@ -301 +301 @@
 }
 
-static void regmap_format_32_be(void *buf, unsigned int val, unsigned int shift)
+/*static*/ void regmap_format_32_be(void *buf, unsigned int val, unsigned int shift)
 {
         put_unaligned_be32(val << shift, buf);
 }
 
-static void regmap_format_32_le(void *buf, unsigned int val, unsigned int shift)
+/*static*/ void regmap_format_32_le(void *buf, unsigned int val, unsigned int shift)
 {
         put_unaligned_le32(val << shift, buf);
 }
 
-static void regmap_format_32_native(void *buf, unsigned int val,
+/*static*/ void regmap_format_32_native(void *buf, unsigned int val,
                                     unsigned int shift)
 {
@@ -320 +320 @@
 
 #ifdef CONFIG_64BIT
-static void regmap_format_64_be(void *buf, unsigned int val, unsigned int shift)
+/*static*/ void regmap_format_64_be(void *buf, unsigned int val, unsigned int shift)
 {
         put_unaligned_be64((u64) val << shift, buf);
 }
 
-static void regmap_format_64_le(void *buf, unsigned int val, unsigned int shift)
+/*static*/ void regmap_format_64_le(void *buf, unsigned int val, unsigned int shift)
 {
         put_unaligned_le64((u64) val << shift, buf);
 }
 
-static void regmap_format_64_native(void *buf, unsigned int val,
+/*static*/ void regmap_format_64_native(void *buf, unsigned int val,
                                     unsigned int shift)
 {
@@ -339 +339 @@
 #endif
 
-static void regmap_parse_inplace_noop(void *buf)
-{
-}
-
-static unsigned int regmap_parse_8(const void *buf)
+/*static*/ void regmap_parse_inplace_noop(void *buf)
+{
+}
+
+/*static*/ unsigned int regmap_parse_8(const void *buf)
 {
         const u8 *b = buf;
@@ -350 +350 @@
 }
 
-static unsigned int regmap_parse_16_be(const void *buf)
+/*static*/ unsigned int regmap_parse_16_be(const void *buf)
 {
         return get_unaligned_be16(buf);
 }
 
-static unsigned int regmap_parse_16_le(const void *buf)
+/*static*/ unsigned int regmap_parse_16_le(const void *buf)
 {
         return get_unaligned_le16(buf);
 }
 
-static void regmap_parse_16_be_inplace(void *buf)
+/*static*/ void regmap_parse_16_be_inplace(void *buf)
 {
         u16 v = get_unaligned_be16(buf);
@@ -367 +367 @@
 }
 
-static void regmap_parse_16_le_inplace(void *buf)
+/*static*/ void regmap_parse_16_le_inplace(void *buf)
 {
         u16 v = get_unaligned_le16(buf);
@@ -374 +374 @@
 }
 
-static unsigned int regmap_parse_16_native(const void *buf)
+/*static*/ unsigned int regmap_parse_16_native(const void *buf)
 {
         u16 v;
@@ -382 +382 @@
 }
 
-static unsigned int regmap_parse_24(const void *buf)
+/*static*/ unsigned int regmap_parse_24(const void *buf)
 {
         const u8 *b = buf;
@@ -392 +392 @@
 }
 
-static unsigned int regmap_parse_32_be(const void *buf)
+/*static*/ unsigned int regmap_parse_32_be(const void *buf)
 {
         return get_unaligned_be32(buf);
 }
 
-static unsigned int regmap_parse_32_le(const void *buf)
+/*static*/ unsigned int regmap_parse_32_le(const void *buf)
 {
         return get_unaligned_le32(buf);
 }
 
-static void regmap_parse_32_be_inplace(void *buf)
+/*static*/ void regmap_parse_32_be_inplace(void *buf)
 {
         u32 v = get_unaligned_be32(buf);
@@ -409 +409 @@
 }
 
-static void regmap_parse_32_le_inplace(void *buf)
+/*static*/ void regmap_parse_32_le_inplace(void *buf)
 {
         u32 v = get_unaligned_le32(buf);
@@ -416 +416 @@
 }
 
-static unsigned int regmap_parse_32_native(const void *buf)
+/*static*/ unsigned int regmap_parse_32_native(const void *buf)
 {
         u32 v;
@@ -425 +425 @@
 
 #ifdef CONFIG_64BIT
-static unsigned int regmap_parse_64_be(const void *buf)
+/*static*/ unsigned int regmap_parse_64_be(const void *buf)
 {
         return get_unaligned_be64(buf);
 }
 
-static unsigned int regmap_parse_64_le(const void *buf)
+/*static*/ unsigned int regmap_parse_64_le(const void *buf)
 {
         return get_unaligned_le64(buf);
 }
 
-static void regmap_parse_64_be_inplace(void *buf)
+/*static*/ void regmap_parse_64_be_inplace(void *buf)
 {
         u64 v =  get_unaligned_be64(buf);
@@ -442 +442 @@
 }
 
-static void regmap_parse_64_le_inplace(void *buf)
+/*static*/ void regmap_parse_64_le_inplace(void *buf)
 {
         u64 v = get_unaligned_le64(buf);
@@ -449 +449 @@
 }
 
-static unsigned int regmap_parse_64_native(const void *buf)
+/*static*/ unsigned int regmap_parse_64_native(const void *buf)
 {
         u64 v;
@@ -458 +458 @@
 #endif
 
-static void regmap_lock_hwlock(void *__map)
+/*static*/ void regmap_lock_hwlock(void *__map)
 {
 #ifndef TARGET_OS2
@@ -467 +467 @@
 }
 
-static void regmap_lock_hwlock_irq(void *__map)
+/*static*/ void regmap_lock_hwlock_irq(void *__map)
 {
 #ifndef TARGET_OS2
@@ -476 +476 @@
 }
 
-static void regmap_lock_hwlock_irqsave(void *__map)
+/*static*/ void regmap_lock_hwlock_irqsave(void *__map)
 {
 #ifndef TARGET_OS2
@@ -486 +486 @@
 }
 
-static void regmap_unlock_hwlock(void *__map)
+/*static*/ void regmap_unlock_hwlock(void *__map)
 {
 #ifndef TARGET_OS2
@@ -495 +495 @@
 }
 
-static void regmap_unlock_hwlock_irq(void *__map)
+/*static*/ void regmap_unlock_hwlock_irq(void *__map)
 {
 #ifndef TARGET_OS2
@@ -504 +504 @@
 }
 
-static void regmap_unlock_hwlock_irqrestore(void *__map)
+/*static*/ void regmap_unlock_hwlock_irqrestore(void *__map)
 {
 #ifndef TARGET_OS2
@@ -513 +513 @@
 }
 
-static void regmap_lock_unlock_none(void *__map)
-{
-
-}
-
-static void regmap_lock_mutex(void *__map)
+/*static*/ void regmap_lock_unlock_none(void *__map)
+{
+
+}
+
+/*static*/ void regmap_lock_mutex(void *__map)
 {
         struct regmap *map = __map;
@@ -524 +524 @@
 }
 
-static void regmap_unlock_mutex(void *__map)
+/*static*/ void regmap_unlock_mutex(void *__map)
 {
         struct regmap *map = __map;
@@ -530 +530 @@
 }
 
-static void regmap_lock_spinlock(void *__map)
+/*static*/ void regmap_lock_spinlock(void *__map)
 __acquires(&map->spinlock)
 {
@@ -540 +540 @@
 }
 
-static void regmap_unlock_spinlock(void *__map)
+/*static*/ void regmap_unlock_spinlock(void *__map)
 __releases(&map->spinlock)
 {
@@ -547 +547 @@
 }
 
-static void dev_get_regmap_release(struct device *dev, void *res)
+/*static*/ void dev_get_regmap_release(struct device *dev, void *res)
 {
         /*
@@ -556 +556 @@
 }
 
-static bool _regmap_range_add(struct regmap *map,
+/*static*/ bool _regmap_range_add(struct regmap *map,
                               struct regmap_range_node *data)
 {
@@ -581 +581 @@
 }
 
-static struct regmap_range_node *_regmap_range_lookup(struct regmap *map,
+/*static*/ struct regmap_range_node *_regmap_range_lookup(struct regmap *map,
                                                       unsigned int reg)
 {
@@ -601 +601 @@
 }
 
-static void regmap_range_exit(struct regmap *map)
+/*static*/ void regmap_range_exit(struct regmap *map)
 {
         struct rb_node *next;
@@ -617 +617 @@
 }
 
-static int regmap_set_name(struct regmap *map, const struct regmap_config *config)
+/*static*/ int regmap_set_name(struct regmap *map, const struct regmap_config *config)
 {
         if (config->name) {
@@ -652 +652 @@
                 return ret;
 
+        regmap_debugfs_exit(map);
         regmap_debugfs_init(map);
 
@@ -667 +668 @@
 EXPORT_SYMBOL_GPL(regmap_attach_dev);
 
-static enum regmap_endian regmap_get_reg_endian(const struct regmap_bus *bus,
+/*static*/ enum regmap_endian regmap_get_reg_endian(const struct regmap_bus *bus,
                                         const struct regmap_config *config)
 {
@@ -1251 +1252 @@
 
 #ifndef TARGET_OS2
-static void devm_regmap_release(struct device *dev, void *res)
+/*static*/ void devm_regmap_release(struct device *dev, void *res)
 {
         regmap_exit(*(struct regmap **)res);
@@ -1283 +1284 @@
 #endif
 
-static void regmap_field_init(struct regmap_field *rm_field,
+/*static*/ void regmap_field_init(struct regmap_field *rm_field,
         struct regmap *regmap, struct reg_field reg_field)
 {
@@ -1561 +1562 @@
 EXPORT_SYMBOL_GPL(regmap_exit);
 
-static int dev_get_regmap_match(struct device *dev, void *res, void *data)
+/*static*/ int dev_get_regmap_match(struct device *dev, void *res, void *data)
 {
         struct regmap **r = res;
@@ -1612 +1613 @@
 EXPORT_SYMBOL_GPL(regmap_get_device);
 
-static int _regmap_select_page(struct regmap *map, unsigned int *reg,
+/*static*/ int _regmap_select_page(struct regmap *map, unsigned int *reg,
                                struct regmap_range_node *range,
                                unsigned int val_num)
@@ -1660 +1661 @@
 }
 
-static void regmap_set_work_buf_flag_mask(struct regmap *map, int max_bytes,
+/*static*/ void regmap_set_work_buf_flag_mask(struct regmap *map, int max_bytes,
                                           unsigned long mask)
 {
@@ -1675 +1676 @@
 }
 
-static int _regmap_raw_write_impl(struct regmap *map, unsigned int reg,
+/*static*/ int _regmap_raw_write_impl(struct regmap *map, unsigned int reg,
                                   const void *val, size_t val_len, bool noinc)
 {
@@ -1902 +1903 @@
 EXPORT_SYMBOL_GPL(regmap_get_raw_write_max);
 
-static int _regmap_bus_formatted_write(void *context, unsigned int reg,
+/*static*/ int _regmap_bus_formatted_write(void *context, unsigned int reg,
                                        unsigned int val)
 {
@@ -1926 +1927 @@
 }
 
-static int _regmap_bus_reg_write(void *context, unsigned int reg,
+/*static*/ int _regmap_bus_reg_write(void *context, unsigned int reg,
                                  unsigned int val)
 {
@@ -1934 +1935 @@
 }
 
-static int _regmap_bus_raw_write(void *context, unsigned int reg,
+/*static*/ int _regmap_bus_raw_write(void *context, unsigned int reg,
                                  unsigned int val)
 {
@@ -1951 +1952 @@
 }
 
-static inline void *_regmap_map_get_context(struct regmap *map)
+/*static*/ inline void *_regmap_map_get_context(struct regmap *map)
 {
         return (map->bus) ? map : map->bus_context;
@@ -2325 +2326 @@
  * relative. The page register has been written if that was necessary.
  */
-static int _regmap_raw_multi_reg_write(struct regmap *map,
+/*static*/ int _regmap_raw_multi_reg_write(struct regmap *map,
                                        const struct reg_sequence *regs,
                                        size_t num_regs)
@@ -2374 +2375 @@
 }
 
-static unsigned int _regmap_register_page(struct regmap *map,
+/*static*/ unsigned int _regmap_register_page(struct regmap *map,
                                           unsigned int reg,
                                           struct regmap_range_node *range)
@@ -2383 +2384 @@
 }
 
-static int _regmap_range_multi_paged_reg_write(struct regmap *map,
+/*static*/ int _regmap_range_multi_paged_reg_write(struct regmap *map,
                                                struct reg_sequence *regs,
                                                size_t num_regs)
@@ -2466 +2467 @@
 }
 
-static int _regmap_multi_reg_write(struct regmap *map,
+/*static*/ int _regmap_multi_reg_write(struct regmap *map,
                                    const struct reg_sequence *regs,
                                    size_t num_regs)
@@ -2667 +2668 @@
 EXPORT_SYMBOL_GPL(regmap_raw_write_async);
 
-static int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
+/*static*/ int _regmap_raw_read(struct regmap *map, unsigned int reg, void *val,
                             unsigned int val_len, bool noinc)
 {
@@ -2697 +2698 @@
 }
 
-static int _regmap_bus_reg_read(void *context, unsigned int reg,
+/*static*/ int _regmap_bus_reg_read(void *context, unsigned int reg,
                                 unsigned int *val)
 {
@@ -2705 +2706 @@
 }
 
-static int _regmap_bus_read(void *context, unsigned int reg,
+/*static*/ int _regmap_bus_read(void *context, unsigned int reg,
                             unsigned int *val)
 {
@@ -2723 +2724 @@
 }
 
-static int _regmap_read(struct regmap *map, unsigned int reg,
+/*static*/ int _regmap_read(struct regmap *map, unsigned int reg,
                         unsigned int *val)
 {
@@ -3064 +3065 @@
 EXPORT_SYMBOL_GPL(regmap_bulk_read);
 
-static int _regmap_update_bits(struct regmap *map, unsigned int reg,
+/*static*/ int _regmap_update_bits(struct regmap *map, unsigned int reg,
                                unsigned int mask, unsigned int val,
                                bool *change, bool force_write)
@@ -3181 +3182 @@
 
 #ifndef TARGET_OS2
-static int regmap_async_is_done(struct regmap *map)
+/*static*/ int regmap_async_is_done(struct regmap *map)
 {
         unsigned long flags;
@@ -3345 +3346 @@
 EXPORT_SYMBOL_GPL(regmap_parse_val);
 
-static int __init regmap_initcall(void)
+/*static*/ int __init regmap_initcall(void)
 {
         regmap_debugfs_initcall();