The macro cpu_relax() is defined by several headers in different ways.

arch/{arm,avr32,mips}/include/asm/processor.h defines it as follows: #define cpu_relax() barrier()

On the other hand, include/linux/compat.h defines it as follows: #define cpu_relax() do {} while (0)

If both headers are included from the same source file, the warning warning: "cpu_relax" redefined [enabled by default] is displayed.

It effectively makes it impossible to include <linux/compat.h> from some sources. Drop the latter.

Signed-off-by: Masahiro Yamada yamada.masahiro@socionext.com ---

drivers/usb/musb-new/musb_gadget_ep0.c | 1 + include/linux/compat.h | 2 -- 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/drivers/usb/musb-new/musb_gadget_ep0.c b/drivers/usb/musb-new/musb_gadget_ep0.c index 5a71501..415a9f2 100644 --- a/drivers/usb/musb-new/musb_gadget_ep0.c +++ b/drivers/usb/musb-new/musb_gadget_ep0.c @@ -43,6 +43,7 @@ #else #include <common.h> #include "linux-compat.h" +#include <asm/processor.h> #endif

#include "musb_core.h" diff --git a/include/linux/compat.h b/include/linux/compat.h index 6ff3915..da1420f 100644 --- a/include/linux/compat.h +++ b/include/linux/compat.h @@ -315,8 +315,6 @@ struct notifier_block {};

typedef unsigned long dmaaddr_t;

-#define cpu_relax() do {} while (0) - #define pm_runtime_get_sync(dev) do {} while (0) #define pm_runtime_put(dev) do {} while (0) #define pm_runtime_put_sync(dev) do {} while (0)

The vzalloc(size) is equivalent to kzalloc(size, 0). Move it to include/linux/compat.h as an inline function in order to avoid the function call overhead.

Signed-off-by: Masahiro Yamada yamada.masahiro@socionext.com ---

include/linux/compat.h | 6 ++++-- lib/linux_compat.c | 5 ----- 2 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/include/linux/compat.h b/include/linux/compat.h index da1420f..a3d136b 100644 --- a/include/linux/compat.h +++ b/include/linux/compat.h @@ -40,6 +40,10 @@ void *kmalloc(size_t size, int flags); void *kzalloc(size_t size, int flags); #define vmalloc(size) kmalloc(size, 0) #define __vmalloc(size, flags, pgsz) kmalloc(size, flags) +static inline void *vzalloc(unsigned long size) +{ + return kzalloc(size, 0); +} #define kfree(ptr) free(ptr) #define vfree(ptr) free(ptr)

@@ -189,8 +193,6 @@ struct work_struct {}; unsigned long copy_from_user(void *dest, const void *src, unsigned long count);

-void *vzalloc(unsigned long size); - typedef unused_t spinlock_t; typedef int wait_queue_head_t;

diff --git a/lib/linux_compat.c b/lib/linux_compat.c index a3d4675..8c7a7b5 100644 --- a/lib/linux_compat.c +++ b/lib/linux_compat.c @@ -26,11 +26,6 @@ void *kzalloc(size_t size, int flags) return ptr; }

-void *vzalloc(unsigned long size) -{ - return kzalloc(size, 0); -} - struct kmem_cache *get_mem(int element_sz) { struct kmem_cache *ret;

Currently, we only have DM_FLAG_ACTIVATED to indicate the device status, but we still cannot know in which stage is in progress, binding or probing.

This commit introduces a new flag, DM_FLAG_BOUND, which is set when the device is really bound, and cleared when it is unbound.

Signed-off-by: Masahiro Yamada yamada.masahiro@socionext.com ---

drivers/core/device-remove.c | 3 +++ drivers/core/device.c | 2 ++ include/dm/device.h | 3 +++ 3 files changed, 8 insertions(+)

diff --git a/drivers/core/device-remove.c b/drivers/core/device-remove.c index 6a16b4f..20b56f9 100644 --- a/drivers/core/device-remove.c +++ b/drivers/core/device-remove.c @@ -75,6 +75,9 @@ int device_unbind(struct udevice *dev) if (dev->flags & DM_FLAG_ACTIVATED) return -EINVAL;

+ if (!(dev->flags & DM_FLAG_BOUND)) + return -EINVAL; + drv = dev->driver; assert(drv);

diff --git a/drivers/core/device.c b/drivers/core/device.c index 85fd1fc..b954974 100644 --- a/drivers/core/device.c +++ b/drivers/core/device.c @@ -132,6 +132,8 @@ int device_bind(struct udevice *parent, const struct driver *drv, dm_dbg("Bound device %s to %s\n", dev->name, parent->name); *devp = dev;

+ dev->flags |= DM_FLAG_BOUND; + return 0;

fail_child_post_bind: diff --git a/include/dm/device.h b/include/dm/device.h index 18296bb..3674d19 100644 --- a/include/dm/device.h +++ b/include/dm/device.h @@ -36,6 +36,9 @@ struct driver_info; /* Allocate driver private data on a DMA boundary */ #define DM_FLAG_ALLOC_PRIV_DMA (1 << 5)

+/* Device is bound */ +#define DM_FLAG_BOUND (1 << 6) + /** * struct udevice - An instance of a driver *

In U-Boot's driver model, memory is basically allocated and freed in the core framework. So, low level drivers generally only have to specify the size of needed memory with .priv_auto_alloc_size, .platdata_auto_alloc_size, etc. Nevertheless, some drivers still need to allocate memory on their own in case they cannot statically know how much memory is needed. Moreover, I am afraid the failure paths of driver model core parts are getting messier as more and more memory size members are supported, .per_child_auto_alloc_size, .per_child_platdata_auto_alloc_size... So, I believe it is reasonable enough to port Devres into U-boot.

As you know, Devres, which originates in Linux, manages device resources for each device and automatically releases them on driver detach. With devres, device resources are guaranteed to be freed whether initialization fails half-way or the device gets detached.

The basic idea is totally the same to that of Linux, but I tweaked it a bit so that it fits in U-Boot's driver model.

In U-Boot, drivers are activated in two steps: binding and probing. Binding puts a driver and a device together. It is just data manipulation on the system memory, so nothing has happened on the hardware device at this moment. When the device is really used, it is probed. Probing initializes the real hardware device to make it really ready for use.

So, the resources acquired during the probing process must be freed when the device is removed. Likewise, what has been allocated in binding should be released when the device is unbound. The struct devres has a member "probe" to remember when the resource was allocated.

CONFIG_DEBUG_DEVRES is also supported for easier debugging. If enabled, debug messages are printed each time a resource is allocated/freed.

Signed-off-by: Masahiro Yamada yamada.masahiro@socionext.com ---

drivers/core/Kconfig | 10 ++++ drivers/core/Makefile | 2 +- drivers/core/device-remove.c | 5 ++ drivers/core/device.c | 3 + drivers/core/devres.c | 137 +++++++++++++++++++++++++++++++++++++++++++ include/dm/device.h | 17 ++++++ 6 files changed, 173 insertions(+), 1 deletion(-) create mode 100644 drivers/core/devres.c

diff --git a/drivers/core/Kconfig b/drivers/core/Kconfig index 2861b43..5966801 100644 --- a/drivers/core/Kconfig +++ b/drivers/core/Kconfig @@ -55,3 +55,13 @@ config DM_SEQ_ALIAS Most boards will have a '/aliases' node containing the path to numbered devices (e.g. serial0 = &serial0). This feature can be disabled if it is not required, to save code space in SPL. + +config DEBUG_DEVRES + bool "Managed device resources verbose debug messages" + depends on DM + help + If this option is enabled, devres debug messages are printed. + Select this if you are having a problem with devres or want to + debug resource management for a managed device. + + If you are unsure about this, Say N here. diff --git a/drivers/core/Makefile b/drivers/core/Makefile index a3fec38..cd8c104 100644 --- a/drivers/core/Makefile +++ b/drivers/core/Makefile @@ -4,7 +4,7 @@ # SPDX-License-Identifier: GPL-2.0+ #

-obj-$(CONFIG_DM) += device.o lists.o root.o uclass.o util.o +obj-$(CONFIG_DM) += device.o lists.o root.o uclass.o util.o devres.o ifndef CONFIG_SPL_BUILD obj-$(CONFIG_OF_CONTROL) += simple-bus.o endif diff --git a/drivers/core/device-remove.c b/drivers/core/device-remove.c index 20b56f9..e1714b2 100644 --- a/drivers/core/device-remove.c +++ b/drivers/core/device-remove.c @@ -109,6 +109,9 @@ int device_unbind(struct udevice *dev)

if (dev->parent) list_del(&dev->sibling_node); + + devres_release_all(dev); + free(dev);

return 0; @@ -142,6 +145,8 @@ void device_free(struct udevice *dev) dev->parent_priv = NULL; } } + + devres_release_probe(dev); }

int device_remove(struct udevice *dev) diff --git a/drivers/core/device.c b/drivers/core/device.c index b954974..ac2c4f8 100644 --- a/drivers/core/device.c +++ b/drivers/core/device.c @@ -47,6 +47,7 @@ int device_bind(struct udevice *parent, const struct driver *drv, INIT_LIST_HEAD(&dev->sibling_node); INIT_LIST_HEAD(&dev->child_head); INIT_LIST_HEAD(&dev->uclass_node); + INIT_LIST_HEAD(&dev->devres_head); dev->platdata = platdata; dev->name = name; dev->of_offset = of_offset; @@ -170,6 +171,8 @@ fail_alloc2: dev->platdata = NULL; } fail_alloc1: + devres_release_all(dev); + free(dev);

return ret; diff --git a/drivers/core/devres.c b/drivers/core/devres.c new file mode 100644 index 0000000..2e967bf --- /dev/null +++ b/drivers/core/devres.c @@ -0,0 +1,137 @@ +/* + * Copyright (C) 2015 Masahiro Yamada yamada.masahiro@socionext.com + * + * Based on the original work in Linux by + * Copyright (c) 2006 SUSE Linux Products GmbH + * Copyright (c) 2006 Tejun Heo teheo@suse.de + * + * SPDX-License-Identifier: GPL-2.0+ + */ + +#include <common.h> +#include <linux/compat.h> +#include <linux/kernel.h> +#include <linux/list.h> +#include <dm/device.h> + +struct devres { + struct list_head entry; + dr_release_t release; + bool probe; +#ifdef CONFIG_DEBUG_DEVRES + const char *name; + size_t size; +#endif + unsigned long long data[]; +}; + +#ifdef CONFIG_DEBUG_DEVRES + +static void set_node_dbginfo(struct devres *dr, const char *name, size_t size) +{ + dr->name = name; + dr->size = size; +} + +static void devres_log(struct udevice *dev, struct devres *dr, + const char *op) +{ + printf("%s: DEVRES %3s %p %s (%lu bytes)\n", + dev->name, op, dr, dr->name, (unsigned long)dr->size); +} +#else /* CONFIG_DEBUG_DEVRES */ +#define set_node_dbginfo(dr, n, s) do {} while (0) +#define devres_log(dev, dr, op) do {} while (0) +#endif + +/** + * devres_alloc - Allocate device resource data + * @release: Release function devres will be associated with + * @size: Allocation size + * @gfp: Allocation flags + * + * Allocate devres of @size bytes. The allocated area is zeroed, then + * associated with @release. The returned pointer can be passed to + * other devres_*() functions. + * + * RETURNS: + * Pointer to allocated devres on success, NULL on failure. + */ +#if CONFIG_DEBUG_DEVRES +void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp, + const char *name) +#else +void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp) +#endif +{ + size_t tot_size = sizeof(struct devres) + size; + struct devres *dr; + + dr = kmalloc(tot_size, gfp); + if (unlikely(!dr)) + return NULL; + + INIT_LIST_HEAD(&dr->entry); + dr->release = release; + set_node_dbginfo(dr, name, size); + + return dr->data; +} + +/** + * devres_add - Register device resource + * @dev: Device to add resource to + * @res: Resource to register + * + * Register devres @res to @dev. @res should have been allocated + * using devres_alloc(). On driver detach, the associated release + * function will be invoked and devres will be freed automatically. + */ +void devres_add(struct udevice *dev, void *res) +{ + struct devres *dr = container_of(res, struct devres, data); + + devres_log(dev, dr, "ADD"); + BUG_ON(!list_empty(&dr->entry)); + dr->probe = dev->flags & DM_FLAG_BOUND ? true : false; + list_add_tail(&dr->entry, &dev->devres_head); +} + +static void release_nodes(struct udevice *dev, struct list_head *head, + bool probe_only) +{ + struct devres *dr, *tmp; + + list_for_each_entry_safe_reverse(dr, tmp, head, entry) { + if (probe_only && !dr->probe) + break; + devres_log(dev, dr, "REL"); + dr->release(dev, dr->data); + list_del(&dr->entry); + kfree(dr); + } +} + +/** + * devres_release_probe - Release managed resources allocated after probing + * @dev: Device to release resources for + * + * Release all resources allocated for @dev when it was probed or later. + * This function is called on driver removal. + */ +void devres_release_probe(struct udevice *dev) +{ + release_nodes(dev, &dev->devres_head, true); +} + +/** + * devres_release_all - Release all managed resources + * @dev: Device to release resources for + * + * Release all resources associated with @dev. This function is + * called on driver unbinding. + */ +void devres_release_all(struct udevice *dev) +{ + release_nodes(dev, &dev->devres_head, false); +} diff --git a/include/dm/device.h b/include/dm/device.h index 3674d19..7b39659 100644 --- a/include/dm/device.h +++ b/include/dm/device.h @@ -96,6 +96,7 @@ struct udevice { uint32_t flags; int req_seq; int seq; + struct list_head devres_head; };

/* Maximum sequence number supported */ @@ -449,4 +450,20 @@ bool device_has_active_children(struct udevice *dev); */ bool device_is_last_sibling(struct udevice *dev);

+/* device resource management */ +typedef void (*dr_release_t)(struct udevice *dev, void *res); + +#ifdef CONFIG_DEBUG_DEVRES +void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp, + const char *name); +#define devres_alloc(release, size, gfp) \ + __devres_alloc(release, size, gfp, #release) +#else +void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp); +#endif +void devres_free(void *res); +void devres_add(struct udevice *dev, void *res); +void devres_release_probe(struct udevice *dev); +void devres_release_all(struct udevice *dev); + #endif

devm_kmalloc() is identical to kmalloc() except that the memory allocated with it is managed and will be automatically released when the device is removed/unbound.

Likewise for the other variants.

Signed-off-by: Masahiro Yamada yamada.masahiro@socionext.com ---

drivers/core/devres.c | 21 +++++++++++++++++++++ include/dm/device.h | 23 +++++++++++++++++++++++ 2 files changed, 44 insertions(+)

diff --git a/drivers/core/devres.c b/drivers/core/devres.c index 2e967bf..f24bcac 100644 --- a/drivers/core/devres.c +++ b/drivers/core/devres.c @@ -135,3 +135,24 @@ void devres_release_all(struct udevice *dev) { release_nodes(dev, &dev->devres_head, false); } + +/* + * Managed kmalloc/kfree + */ +static void devm_kmalloc_release(struct udevice *dev, void *res) +{ + /* noop */ +} + +void *devm_kmalloc(struct udevice *dev, size_t size, gfp_t gfp) +{ + void *data; + + data = devres_alloc(devm_kmalloc_release, size, gfp); + if (unlikely(!data)) + return NULL; + + devres_add(dev, data); + + return data; +} diff --git a/include/dm/device.h b/include/dm/device.h index 7b39659..fac0868 100644 --- a/include/dm/device.h +++ b/include/dm/device.h @@ -14,6 +14,8 @@ #include <dm/uclass-id.h> #include <fdtdec.h> #include <linker_lists.h> +#include <linux/compat.h> +#include <linux/kernel.h> #include <linux/list.h>

struct driver_info; @@ -466,4 +468,25 @@ void devres_add(struct udevice *dev, void *res); void devres_release_probe(struct udevice *dev); void devres_release_all(struct udevice *dev);

+/* managed devm_k.alloc/kfree for device drivers */ +void *devm_kmalloc(struct udevice *dev, size_t size, gfp_t gfp); +static inline void *devm_kzalloc(struct udevice *dev, size_t size, gfp_t gfp) +{ + return devm_kmalloc(dev, size, gfp | __GFP_ZERO); +} +static inline void *devm_kmalloc_array(struct udevice *dev, + size_t n, size_t size, gfp_t flags) +{ + if (size != 0 && n > SIZE_MAX / size) + return NULL; + return devm_kmalloc(dev, n * size, flags); +} +static inline void *devm_kcalloc(struct udevice *dev, + size_t n, size_t size, gfp_t flags) +{ + return devm_kmalloc_array(dev, n, size, flags | __GFP_ZERO); +} +void devm_kfree(struct udevice *dev, void *p); + + #endif

With devm_kzalloc(), device_unbind() and the failure path in device_bind() can be much cleaner.

We no longer need such flags as DM_FLAG_ALLOC_PDATA etc. because we do not have to remember if the memory has been really allocated.

The memory is freed free when the device is unbind.

Signed-off-by: Masahiro Yamada yamada.masahiro@socionext.com ---

drivers/core/device-remove.c | 12 ------------ drivers/core/device.c | 24 ++++++------------------ include/dm/device.h | 9 --------- 3 files changed, 6 insertions(+), 39 deletions(-)

diff --git a/drivers/core/device-remove.c b/drivers/core/device-remove.c index e1714b2..0417535 100644 --- a/drivers/core/device-remove.c +++ b/drivers/core/device-remove.c @@ -91,18 +91,6 @@ int device_unbind(struct udevice *dev) if (ret) return ret;

- if (dev->flags & DM_FLAG_ALLOC_PDATA) { - free(dev->platdata); - dev->platdata = NULL; - } - if (dev->flags & DM_FLAG_ALLOC_UCLASS_PDATA) { - free(dev->uclass_platdata); - dev->uclass_platdata = NULL; - } - if (dev->flags & DM_FLAG_ALLOC_PARENT_PDATA) { - free(dev->parent_platdata); - dev->parent_platdata = NULL; - } ret = uclass_unbind_device(dev); if (ret) return ret; diff --git a/drivers/core/device.c b/drivers/core/device.c index ac2c4f8..f024aa2 100644 --- a/drivers/core/device.c +++ b/drivers/core/device.c @@ -75,8 +75,9 @@ int device_bind(struct udevice *parent, const struct driver *drv, }

if (!dev->platdata && drv->platdata_auto_alloc_size) { - dev->flags |= DM_FLAG_ALLOC_PDATA; - dev->platdata = calloc(1, drv->platdata_auto_alloc_size); + dev->platdata = devm_kzalloc(dev, + drv->platdata_auto_alloc_size, + GFP_KERNEL); if (!dev->platdata) { ret = -ENOMEM; goto fail_alloc1; @@ -85,8 +86,7 @@ int device_bind(struct udevice *parent, const struct driver *drv,

size = uc->uc_drv->per_device_platdata_auto_alloc_size; if (size) { - dev->flags |= DM_FLAG_ALLOC_UCLASS_PDATA; - dev->uclass_platdata = calloc(1, size); + dev->uclass_platdata = devm_kzalloc(dev, size, GFP_KERNEL); if (!dev->uclass_platdata) { ret = -ENOMEM; goto fail_alloc2; @@ -100,8 +100,8 @@ int device_bind(struct udevice *parent, const struct driver *drv, per_child_platdata_auto_alloc_size; } if (size) { - dev->flags |= DM_FLAG_ALLOC_PARENT_PDATA; - dev->parent_platdata = calloc(1, size); + dev->parent_platdata = devm_kzalloc(dev, size, + GFP_KERNEL); if (!dev->parent_platdata) { ret = -ENOMEM; goto fail_alloc3; @@ -155,21 +155,9 @@ fail_bind: fail_uclass_bind: if (IS_ENABLED(CONFIG_DM_DEVICE_REMOVE)) { list_del(&dev->sibling_node); - if (dev->flags & DM_FLAG_ALLOC_PARENT_PDATA) { - free(dev->parent_platdata); - dev->parent_platdata = NULL; - } } fail_alloc3: - if (dev->flags & DM_FLAG_ALLOC_UCLASS_PDATA) { - free(dev->uclass_platdata); - dev->uclass_platdata = NULL; - } fail_alloc2: - if (dev->flags & DM_FLAG_ALLOC_PDATA) { - free(dev->platdata); - dev->platdata = NULL; - } fail_alloc1: devres_release_all(dev);

diff --git a/include/dm/device.h b/include/dm/device.h index fac0868..9525581 100644 --- a/include/dm/device.h +++ b/include/dm/device.h @@ -23,18 +23,9 @@ struct driver_info; /* Driver is active (probed). Cleared when it is removed */ #define DM_FLAG_ACTIVATED (1 << 0)

-/* DM is responsible for allocating and freeing platdata */ -#define DM_FLAG_ALLOC_PDATA (1 << 1) - /* DM should init this device prior to relocation */ #define DM_FLAG_PRE_RELOC (1 << 2)

-/* DM is responsible for allocating and freeing parent_platdata */ -#define DM_FLAG_ALLOC_PARENT_PDATA (1 << 3) - -/* DM is responsible for allocating and freeing uclass_platdata */ -#define DM_FLAG_ALLOC_UCLASS_PDATA (1 << 4) - /* Allocate driver private data on a DMA boundary */ #define DM_FLAG_ALLOC_PRIV_DMA (1 << 5)

It does not seem efficient to always return cache-aligned memory. Return aligned memory only when GFP_DMA flag is given.

My main motivation for this commit is to refactor device_probe() and device_free() in the next commit. DM_FLAG_ALLOC_PRIV_DMA should be handled more easily.

Signed-off-by: Masahiro Yamada yamada.masahiro@socionext.com ---

include/linux/compat.h | 1 + lib/linux_compat.c | 5 ++++- 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/include/linux/compat.h b/include/linux/compat.h index 64988bf..8b7f8ef 100644 --- a/include/linux/compat.h +++ b/include/linux/compat.h @@ -41,6 +41,7 @@ extern struct p_current *current; #define GFP_NOFS ((gfp_t) 0) #define GFP_USER ((gfp_t) 0) #define __GFP_NOWARN ((gfp_t) 0) +#define GFP_DMA ((__force gfp_t)0x01u) #define __GFP_ZERO ((__force gfp_t)0x8000u) /* Return zeroed page on success */

void *kmalloc(size_t size, int flags); diff --git a/lib/linux_compat.c b/lib/linux_compat.c index a936a7e..6da0cfa 100644 --- a/lib/linux_compat.c +++ b/lib/linux_compat.c @@ -18,7 +18,10 @@ void *kmalloc(size_t size, int flags) { void *p;

- p = memalign(ARCH_DMA_MINALIGN, size); + if (flags & GFP_DMA) + p = memalign(ARCH_DMA_MINALIGN, size); + else + p = malloc(size); if (flags & __GFP_ZERO) memset(p, 0, size);