2018-05-07 06:58:06 +09:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
devres: introduce Devres (Managed Device Resource) framework
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/free memory on their own in case they cannot
statically know the necessary memory size. So, I believe it is
reasonable enough to port Devres into U-boot.
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>
Acked-by: Simon Glass <sjg@chromium.org>
2015-07-25 21:52:35 +09:00
|
|
|
/*
|
|
|
|
* 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>
|
|
|
|
*/
|
|
|
|
|
2019-12-30 13:19:24 +09:00
|
|
|
#define LOG_CATEGORY LOGC_DEVRES
|
|
|
|
|
devres: introduce Devres (Managed Device Resource) framework
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/free memory on their own in case they cannot
statically know the necessary memory size. So, I believe it is
reasonable enough to port Devres into U-boot.
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>
Acked-by: Simon Glass <sjg@chromium.org>
2015-07-25 21:52:35 +09:00
|
|
|
#include <common.h>
|
|
|
|
#include <linux/compat.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <dm/device.h>
|
2015-07-25 21:52:38 +09:00
|
|
|
#include <dm/root.h>
|
|
|
|
#include <dm/util.h>
|
devres: introduce Devres (Managed Device Resource) framework
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/free memory on their own in case they cannot
statically know the necessary memory size. So, I believe it is
reasonable enough to port Devres into U-boot.
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>
Acked-by: Simon Glass <sjg@chromium.org>
2015-07-25 21:52:35 +09:00
|
|
|
|
|
|
|
/**
|
|
|
|
* struct devres - Bookkeeping info for managed device resource
|
|
|
|
* @entry: List to associate this structure with a device
|
|
|
|
* @release: Callback invoked when this resource is released
|
|
|
|
* @probe: Flag to show when this resource was allocated
|
|
|
|
(true = probe, false = bind)
|
|
|
|
* @name: Name of release function
|
|
|
|
* @size: Size of resource data
|
|
|
|
* @data: Resource data
|
|
|
|
*/
|
|
|
|
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)
|
|
|
|
{
|
2019-12-30 13:19:24 +09:00
|
|
|
log_debug("%s: DEVRES %3s %p %s (%lu bytes)\n", dev->name, op, dr,
|
|
|
|
dr->name, (unsigned long)dr->size);
|
devres: introduce Devres (Managed Device Resource) framework
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/free memory on their own in case they cannot
statically know the necessary memory size. So, I believe it is
reasonable enough to port Devres into U-boot.
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>
Acked-by: Simon Glass <sjg@chromium.org>
2015-07-25 21:52:35 +09:00
|
|
|
}
|
|
|
|
#else /* CONFIG_DEBUG_DEVRES */
|
|
|
|
#define set_node_dbginfo(dr, n, s) do {} while (0)
|
|
|
|
#define devres_log(dev, dr, op) do {} while (0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#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;
|
|
|
|
}
|
|
|
|
|
|
|
|
void devres_free(void *res)
|
|
|
|
{
|
|
|
|
if (res) {
|
|
|
|
struct devres *dr = container_of(res, struct devres, data);
|
|
|
|
|
2019-12-30 13:19:11 +09:00
|
|
|
assert_noisy(list_empty(&dr->entry));
|
devres: introduce Devres (Managed Device Resource) framework
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/free memory on their own in case they cannot
statically know the necessary memory size. So, I believe it is
reasonable enough to port Devres into U-boot.
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>
Acked-by: Simon Glass <sjg@chromium.org>
2015-07-25 21:52:35 +09:00
|
|
|
kfree(dr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void devres_add(struct udevice *dev, void *res)
|
|
|
|
{
|
|
|
|
struct devres *dr = container_of(res, struct devres, data);
|
|
|
|
|
|
|
|
devres_log(dev, dr, "ADD");
|
2019-12-30 13:19:11 +09:00
|
|
|
assert_noisy(list_empty(&dr->entry));
|
devres: introduce Devres (Managed Device Resource) framework
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/free memory on their own in case they cannot
statically know the necessary memory size. So, I believe it is
reasonable enough to port Devres into U-boot.
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>
Acked-by: Simon Glass <sjg@chromium.org>
2015-07-25 21:52:35 +09:00
|
|
|
dr->probe = dev->flags & DM_FLAG_BOUND ? true : false;
|
|
|
|
list_add_tail(&dr->entry, &dev->devres_head);
|
|
|
|
}
|
|
|
|
|
|
|
|
void *devres_find(struct udevice *dev, dr_release_t release,
|
|
|
|
dr_match_t match, void *match_data)
|
|
|
|
{
|
|
|
|
struct devres *dr;
|
|
|
|
|
|
|
|
list_for_each_entry_reverse(dr, &dev->devres_head, entry) {
|
|
|
|
if (dr->release != release)
|
|
|
|
continue;
|
|
|
|
if (match && !match(dev, dr->data, match_data))
|
|
|
|
continue;
|
|
|
|
return dr->data;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
void *devres_get(struct udevice *dev, void *new_res,
|
|
|
|
dr_match_t match, void *match_data)
|
|
|
|
{
|
|
|
|
struct devres *new_dr = container_of(new_res, struct devres, data);
|
|
|
|
void *res;
|
|
|
|
|
|
|
|
res = devres_find(dev, new_dr->release, match, match_data);
|
|
|
|
if (!res) {
|
|
|
|
devres_add(dev, new_res);
|
|
|
|
res = new_res;
|
|
|
|
new_res = NULL;
|
|
|
|
}
|
|
|
|
devres_free(new_res);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
void *devres_remove(struct udevice *dev, dr_release_t release,
|
|
|
|
dr_match_t match, void *match_data)
|
|
|
|
{
|
|
|
|
void *res;
|
|
|
|
|
|
|
|
res = devres_find(dev, release, match, match_data);
|
|
|
|
if (res) {
|
|
|
|
struct devres *dr = container_of(res, struct devres, data);
|
|
|
|
|
|
|
|
list_del_init(&dr->entry);
|
|
|
|
devres_log(dev, dr, "REM");
|
|
|
|
}
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
int devres_destroy(struct udevice *dev, dr_release_t release,
|
|
|
|
dr_match_t match, void *match_data)
|
|
|
|
{
|
|
|
|
void *res;
|
|
|
|
|
|
|
|
res = devres_remove(dev, release, match, match_data);
|
|
|
|
if (unlikely(!res))
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
devres_free(res);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int devres_release(struct udevice *dev, dr_release_t release,
|
|
|
|
dr_match_t match, void *match_data)
|
|
|
|
{
|
|
|
|
void *res;
|
|
|
|
|
|
|
|
res = devres_remove(dev, release, match, match_data);
|
|
|
|
if (unlikely(!res))
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
(*release)(dev, res);
|
|
|
|
devres_free(res);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void devres_release_probe(struct udevice *dev)
|
|
|
|
{
|
|
|
|
release_nodes(dev, &dev->devres_head, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
void devres_release_all(struct udevice *dev)
|
|
|
|
{
|
|
|
|
release_nodes(dev, &dev->devres_head, false);
|
|
|
|
}
|
2015-07-25 21:52:36 +09:00
|
|
|
|
2015-07-25 21:52:38 +09:00
|
|
|
#ifdef CONFIG_DEBUG_DEVRES
|
|
|
|
static void dump_resources(struct udevice *dev, int depth)
|
|
|
|
{
|
|
|
|
struct devres *dr;
|
|
|
|
struct udevice *child;
|
|
|
|
|
|
|
|
printf("- %s\n", dev->name);
|
|
|
|
|
|
|
|
list_for_each_entry(dr, &dev->devres_head, entry)
|
|
|
|
printf(" %p (%lu byte) %s %s\n", dr,
|
|
|
|
(unsigned long)dr->size, dr->name,
|
|
|
|
dr->probe ? "PROBE" : "BIND");
|
|
|
|
|
|
|
|
list_for_each_entry(child, &dev->child_head, sibling_node)
|
|
|
|
dump_resources(child, depth + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
void dm_dump_devres(void)
|
|
|
|
{
|
|
|
|
struct udevice *root;
|
|
|
|
|
|
|
|
root = dm_root();
|
|
|
|
if (root)
|
|
|
|
dump_resources(root, 0);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-07-25 21:52:36 +09:00
|
|
|
/*
|
|
|
|
* Managed kmalloc/kfree
|
|
|
|
*/
|
|
|
|
static void devm_kmalloc_release(struct udevice *dev, void *res)
|
|
|
|
{
|
|
|
|
/* noop */
|
|
|
|
}
|
|
|
|
|
|
|
|
static int devm_kmalloc_match(struct udevice *dev, void *res, void *data)
|
|
|
|
{
|
|
|
|
return res == data;
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
void devm_kfree(struct udevice *dev, void *p)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
rc = devres_destroy(dev, devm_kmalloc_release, devm_kmalloc_match, p);
|
2019-12-30 13:19:11 +09:00
|
|
|
assert_noisy(!rc);
|
2015-07-25 21:52:36 +09:00
|
|
|
}
|