2017-11-07 23:30:07 +07:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
/*
|
|
|
|
* Componentized device handling.
|
|
|
|
*
|
|
|
|
* This is work in progress. We gather up the component devices into a list,
|
|
|
|
* and bind them when instructed. At the moment, we're specific to the DRM
|
|
|
|
* subsystem, and only handles one master device, but this doesn't have to be
|
|
|
|
* the case.
|
|
|
|
*/
|
|
|
|
#include <linux/component.h>
|
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/kref.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/mutex.h>
|
|
|
|
#include <linux/slab.h>
|
2017-12-01 20:23:16 +07:00
|
|
|
#include <linux/debugfs.h>
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
|
2019-02-08 06:27:56 +07:00
|
|
|
/**
|
|
|
|
* DOC: overview
|
|
|
|
*
|
|
|
|
* The component helper allows drivers to collect a pile of sub-devices,
|
|
|
|
* including their bound drivers, into an aggregate driver. Various subsystems
|
|
|
|
* already provide functions to get hold of such components, e.g.
|
|
|
|
* of_clk_get_by_name(). The component helper can be used when such a
|
|
|
|
* subsystem-specific way to find a device is not available: The component
|
|
|
|
* helper fills the niche of aggregate drivers for specific hardware, where
|
|
|
|
* further standardization into a subsystem would not be practical. The common
|
|
|
|
* example is when a logical device (e.g. a DRM display driver) is spread around
|
2019-02-18 23:36:48 +07:00
|
|
|
* the SoC on various components (scanout engines, blending blocks, transcoders
|
2019-02-08 06:27:56 +07:00
|
|
|
* for various outputs and so on).
|
|
|
|
*
|
|
|
|
* The component helper also doesn't solve runtime dependencies, e.g. for system
|
|
|
|
* suspend and resume operations. See also :ref:`device links<device_link>`.
|
|
|
|
*
|
|
|
|
* Components are registered using component_add() and unregistered with
|
|
|
|
* component_del(), usually from the driver's probe and disconnect functions.
|
|
|
|
*
|
|
|
|
* Aggregate drivers first assemble a component match list of what they need
|
|
|
|
* using component_match_add(). This is then registered as an aggregate driver
|
|
|
|
* using component_master_add_with_match(), and unregistered using
|
|
|
|
* component_master_del().
|
|
|
|
*/
|
|
|
|
|
2014-04-19 05:05:53 +07:00
|
|
|
struct component;
|
|
|
|
|
2015-11-17 19:08:01 +07:00
|
|
|
struct component_match_array {
|
|
|
|
void *data;
|
|
|
|
int (*compare)(struct device *, void *);
|
2019-02-08 06:27:57 +07:00
|
|
|
int (*compare_typed)(struct device *, int, void *);
|
2015-11-17 19:08:01 +07:00
|
|
|
void (*release)(struct device *, void *);
|
|
|
|
struct component *component;
|
|
|
|
bool duplicate;
|
|
|
|
};
|
|
|
|
|
2014-04-19 17:18:01 +07:00
|
|
|
struct component_match {
|
|
|
|
size_t alloc;
|
|
|
|
size_t num;
|
2015-11-17 19:08:01 +07:00
|
|
|
struct component_match_array *compare;
|
2014-04-19 17:18:01 +07:00
|
|
|
};
|
|
|
|
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
struct master {
|
|
|
|
struct list_head node;
|
|
|
|
bool bound;
|
|
|
|
|
|
|
|
const struct component_master_ops *ops;
|
|
|
|
struct device *dev;
|
2014-04-19 17:18:01 +07:00
|
|
|
struct component_match *match;
|
2017-12-01 20:23:16 +07:00
|
|
|
struct dentry *dentry;
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
struct component {
|
|
|
|
struct list_head node;
|
|
|
|
struct master *master;
|
|
|
|
bool bound;
|
|
|
|
|
|
|
|
const struct component_ops *ops;
|
2019-02-08 06:27:57 +07:00
|
|
|
int subcomponent;
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
struct device *dev;
|
|
|
|
};
|
|
|
|
|
|
|
|
static DEFINE_MUTEX(component_mutex);
|
|
|
|
static LIST_HEAD(component_list);
|
|
|
|
static LIST_HEAD(masters);
|
|
|
|
|
2017-12-01 20:23:16 +07:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
|
|
|
|
|
|
|
static struct dentry *component_debugfs_dir;
|
|
|
|
|
|
|
|
static int component_devices_show(struct seq_file *s, void *data)
|
|
|
|
{
|
|
|
|
struct master *m = s->private;
|
|
|
|
struct component_match *match = m->match;
|
|
|
|
size_t i;
|
|
|
|
|
|
|
|
mutex_lock(&component_mutex);
|
|
|
|
seq_printf(s, "%-40s %20s\n", "master name", "status");
|
|
|
|
seq_puts(s, "-------------------------------------------------------------\n");
|
|
|
|
seq_printf(s, "%-40s %20s\n\n",
|
|
|
|
dev_name(m->dev), m->bound ? "bound" : "not bound");
|
|
|
|
|
|
|
|
seq_printf(s, "%-40s %20s\n", "device name", "status");
|
|
|
|
seq_puts(s, "-------------------------------------------------------------\n");
|
|
|
|
for (i = 0; i < match->num; i++) {
|
2019-11-18 18:54:31 +07:00
|
|
|
struct component *component = match->compare[i].component;
|
2017-12-01 20:23:16 +07:00
|
|
|
|
2019-11-18 18:54:31 +07:00
|
|
|
seq_printf(s, "%-40s %20s\n",
|
|
|
|
component ? dev_name(component->dev) : "(unknown)",
|
|
|
|
component ? (component->bound ? "bound" : "not bound") : "not registered");
|
2017-12-01 20:23:16 +07:00
|
|
|
}
|
|
|
|
mutex_unlock(&component_mutex);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-12-15 15:36:36 +07:00
|
|
|
DEFINE_SHOW_ATTRIBUTE(component_devices);
|
2017-12-01 20:23:16 +07:00
|
|
|
|
|
|
|
static int __init component_debug_init(void)
|
|
|
|
{
|
|
|
|
component_debugfs_dir = debugfs_create_dir("device_component", NULL);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
core_initcall(component_debug_init);
|
|
|
|
|
|
|
|
static void component_master_debugfs_add(struct master *m)
|
|
|
|
{
|
|
|
|
m->dentry = debugfs_create_file(dev_name(m->dev), 0444,
|
|
|
|
component_debugfs_dir,
|
|
|
|
m, &component_devices_fops);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void component_master_debugfs_del(struct master *m)
|
|
|
|
{
|
|
|
|
debugfs_remove(m->dentry);
|
|
|
|
m->dentry = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
static void component_master_debugfs_add(struct master *m)
|
|
|
|
{ }
|
|
|
|
|
|
|
|
static void component_master_debugfs_del(struct master *m)
|
|
|
|
{ }
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
static struct master *__master_find(struct device *dev,
|
|
|
|
const struct component_master_ops *ops)
|
|
|
|
{
|
|
|
|
struct master *m;
|
|
|
|
|
|
|
|
list_for_each_entry(m, &masters, node)
|
|
|
|
if (m->dev == dev && (!ops || m->ops == ops))
|
|
|
|
return m;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-04-19 05:05:53 +07:00
|
|
|
static struct component *find_component(struct master *master,
|
2019-02-08 06:27:57 +07:00
|
|
|
struct component_match_array *mc)
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
{
|
|
|
|
struct component *c;
|
|
|
|
|
|
|
|
list_for_each_entry(c, &component_list, node) {
|
2014-04-19 02:16:22 +07:00
|
|
|
if (c->master && c->master != master)
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
continue;
|
|
|
|
|
2019-02-08 06:27:57 +07:00
|
|
|
if (mc->compare && mc->compare(c->dev, mc->data))
|
|
|
|
return c;
|
|
|
|
|
|
|
|
if (mc->compare_typed &&
|
|
|
|
mc->compare_typed(c->dev, c->subcomponent, mc->data))
|
2014-04-19 05:05:53 +07:00
|
|
|
return c;
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
}
|
|
|
|
|
2014-04-19 05:05:53 +07:00
|
|
|
return NULL;
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
}
|
|
|
|
|
2014-04-19 17:18:01 +07:00
|
|
|
static int find_components(struct master *master)
|
|
|
|
{
|
|
|
|
struct component_match *match = master->match;
|
|
|
|
size_t i;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Scan the array of match functions and attach
|
|
|
|
* any components which are found to this master.
|
|
|
|
*/
|
|
|
|
for (i = 0; i < match->num; i++) {
|
2015-11-17 19:08:01 +07:00
|
|
|
struct component_match_array *mc = &match->compare[i];
|
2014-04-19 05:05:53 +07:00
|
|
|
struct component *c;
|
|
|
|
|
|
|
|
dev_dbg(master->dev, "Looking for component %zu\n", i);
|
|
|
|
|
|
|
|
if (match->compare[i].component)
|
|
|
|
continue;
|
|
|
|
|
2019-02-08 06:27:57 +07:00
|
|
|
c = find_component(master, mc);
|
2014-04-19 05:05:53 +07:00
|
|
|
if (!c) {
|
|
|
|
ret = -ENXIO;
|
2014-04-19 17:18:01 +07:00
|
|
|
break;
|
2014-04-19 05:05:53 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
dev_dbg(master->dev, "found component %s, duplicate %u\n", dev_name(c->dev), !!c->master);
|
|
|
|
|
|
|
|
/* Attach this component to the master */
|
|
|
|
match->compare[i].duplicate = !!c->master;
|
|
|
|
match->compare[i].component = c;
|
|
|
|
c->master = master;
|
2014-04-19 17:18:01 +07:00
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-04-19 05:05:53 +07:00
|
|
|
/* Detach component from associated master */
|
|
|
|
static void remove_component(struct master *master, struct component *c)
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
{
|
2014-04-19 05:05:53 +07:00
|
|
|
size_t i;
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
|
2014-04-19 05:05:53 +07:00
|
|
|
/* Detach the component from this master. */
|
|
|
|
for (i = 0; i < master->match->num; i++)
|
|
|
|
if (master->match->compare[i].component == c)
|
|
|
|
master->match->compare[i].component = NULL;
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try to bring up a master. If component is NULL, we're interested in
|
|
|
|
* this master, otherwise it's a component which must be present to try
|
|
|
|
* and bring up the master.
|
|
|
|
*
|
|
|
|
* Returns 1 for successful bringup, 0 if not ready, or -ve errno.
|
|
|
|
*/
|
|
|
|
static int try_to_bring_up_master(struct master *master,
|
|
|
|
struct component *component)
|
|
|
|
{
|
2014-04-23 16:52:17 +07:00
|
|
|
int ret;
|
|
|
|
|
2014-04-19 05:05:53 +07:00
|
|
|
dev_dbg(master->dev, "trying to bring up master\n");
|
|
|
|
|
2014-04-19 17:18:01 +07:00
|
|
|
if (find_components(master)) {
|
2014-04-19 05:05:53 +07:00
|
|
|
dev_dbg(master->dev, "master has incomplete components\n");
|
|
|
|
return 0;
|
2014-04-23 16:52:17 +07:00
|
|
|
}
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
|
2014-04-23 16:52:17 +07:00
|
|
|
if (component && component->master != master) {
|
2014-04-19 05:05:53 +07:00
|
|
|
dev_dbg(master->dev, "master is not for this component (%s)\n",
|
|
|
|
dev_name(component->dev));
|
|
|
|
return 0;
|
2014-04-23 16:52:17 +07:00
|
|
|
}
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
|
2014-04-19 05:05:53 +07:00
|
|
|
if (!devres_open_group(master->dev, NULL, GFP_KERNEL))
|
|
|
|
return -ENOMEM;
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
|
2014-04-23 16:52:17 +07:00
|
|
|
/* Found all components */
|
|
|
|
ret = master->ops->bind(master->dev);
|
|
|
|
if (ret < 0) {
|
|
|
|
devres_release_group(master->dev, NULL);
|
|
|
|
dev_info(master->dev, "master bind failed: %d\n", ret);
|
2014-04-19 05:05:53 +07:00
|
|
|
return ret;
|
2014-04-23 16:52:17 +07:00
|
|
|
}
|
2014-02-08 03:09:27 +07:00
|
|
|
|
2014-04-23 16:52:17 +07:00
|
|
|
master->bound = true;
|
|
|
|
return 1;
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
static int try_to_bring_up_masters(struct component *component)
|
|
|
|
{
|
|
|
|
struct master *m;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
list_for_each_entry(m, &masters, node) {
|
2014-04-23 16:46:11 +07:00
|
|
|
if (!m->bound) {
|
|
|
|
ret = try_to_bring_up_master(m, component);
|
|
|
|
if (ret != 0)
|
|
|
|
break;
|
|
|
|
}
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void take_down_master(struct master *master)
|
|
|
|
{
|
|
|
|
if (master->bound) {
|
|
|
|
master->ops->unbind(master->dev);
|
2014-02-08 03:09:27 +07:00
|
|
|
devres_release_group(master->dev, NULL);
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
master->bound = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-11-17 19:08:01 +07:00
|
|
|
static void component_match_release(struct device *master,
|
|
|
|
struct component_match *match)
|
2014-04-19 17:18:01 +07:00
|
|
|
{
|
2015-11-17 19:08:01 +07:00
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for (i = 0; i < match->num; i++) {
|
|
|
|
struct component_match_array *mc = &match->compare[i];
|
|
|
|
|
|
|
|
if (mc->release)
|
|
|
|
mc->release(master, mc->data);
|
|
|
|
}
|
2016-01-26 21:49:22 +07:00
|
|
|
|
|
|
|
kfree(match->compare);
|
2014-04-19 17:18:01 +07:00
|
|
|
}
|
|
|
|
|
2015-11-17 19:08:01 +07:00
|
|
|
static void devm_component_match_release(struct device *dev, void *res)
|
|
|
|
{
|
|
|
|
component_match_release(dev, res);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int component_match_realloc(struct device *dev,
|
2014-04-19 17:18:01 +07:00
|
|
|
struct component_match *match, size_t num)
|
|
|
|
{
|
2015-11-17 19:08:01 +07:00
|
|
|
struct component_match_array *new;
|
2014-04-19 17:18:01 +07:00
|
|
|
|
2015-11-17 19:08:01 +07:00
|
|
|
if (match->alloc == num)
|
|
|
|
return 0;
|
2014-04-19 17:18:01 +07:00
|
|
|
|
2016-01-26 21:49:22 +07:00
|
|
|
new = kmalloc_array(num, sizeof(*new), GFP_KERNEL);
|
2014-04-19 17:18:01 +07:00
|
|
|
if (!new)
|
2015-11-17 19:08:01 +07:00
|
|
|
return -ENOMEM;
|
2014-04-19 17:18:01 +07:00
|
|
|
|
2015-11-17 19:08:01 +07:00
|
|
|
if (match->compare) {
|
|
|
|
memcpy(new, match->compare, sizeof(*new) *
|
|
|
|
min(match->num, num));
|
2016-01-26 21:49:22 +07:00
|
|
|
kfree(match->compare);
|
2014-04-19 17:18:01 +07:00
|
|
|
}
|
2015-11-17 19:08:01 +07:00
|
|
|
match->compare = new;
|
|
|
|
match->alloc = num;
|
2014-04-19 17:18:01 +07:00
|
|
|
|
2015-11-17 19:08:01 +07:00
|
|
|
return 0;
|
2014-04-19 17:18:01 +07:00
|
|
|
}
|
|
|
|
|
2019-02-08 06:27:57 +07:00
|
|
|
static void __component_match_add(struct device *master,
|
2015-11-17 19:08:01 +07:00
|
|
|
struct component_match **matchptr,
|
|
|
|
void (*release)(struct device *, void *),
|
2019-02-08 06:27:57 +07:00
|
|
|
int (*compare)(struct device *, void *),
|
|
|
|
int (*compare_typed)(struct device *, int, void *),
|
|
|
|
void *compare_data)
|
2014-04-19 17:18:01 +07:00
|
|
|
{
|
|
|
|
struct component_match *match = *matchptr;
|
|
|
|
|
|
|
|
if (IS_ERR(match))
|
|
|
|
return;
|
|
|
|
|
2015-11-17 19:08:01 +07:00
|
|
|
if (!match) {
|
|
|
|
match = devres_alloc(devm_component_match_release,
|
|
|
|
sizeof(*match), GFP_KERNEL);
|
|
|
|
if (!match) {
|
|
|
|
*matchptr = ERR_PTR(-ENOMEM);
|
|
|
|
return;
|
|
|
|
}
|
2014-04-19 17:18:01 +07:00
|
|
|
|
2015-11-17 19:08:01 +07:00
|
|
|
devres_add(master, match);
|
2014-04-19 17:18:01 +07:00
|
|
|
|
|
|
|
*matchptr = match;
|
2015-11-17 19:08:01 +07:00
|
|
|
}
|
2014-04-19 17:18:01 +07:00
|
|
|
|
2015-11-17 19:08:01 +07:00
|
|
|
if (match->num == match->alloc) {
|
2016-02-02 14:27:53 +07:00
|
|
|
size_t new_size = match->alloc + 16;
|
2015-11-17 19:08:01 +07:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = component_match_realloc(master, match, new_size);
|
|
|
|
if (ret) {
|
|
|
|
*matchptr = ERR_PTR(ret);
|
2014-04-19 17:18:01 +07:00
|
|
|
return;
|
2015-11-17 19:08:01 +07:00
|
|
|
}
|
2014-04-19 17:18:01 +07:00
|
|
|
}
|
|
|
|
|
2015-11-17 19:08:01 +07:00
|
|
|
match->compare[match->num].compare = compare;
|
2019-02-08 06:27:57 +07:00
|
|
|
match->compare[match->num].compare_typed = compare_typed;
|
2015-11-17 19:08:01 +07:00
|
|
|
match->compare[match->num].release = release;
|
2014-04-19 17:18:01 +07:00
|
|
|
match->compare[match->num].data = compare_data;
|
2014-04-19 05:05:53 +07:00
|
|
|
match->compare[match->num].component = NULL;
|
2014-04-19 17:18:01 +07:00
|
|
|
match->num++;
|
|
|
|
}
|
2019-02-08 06:27:57 +07:00
|
|
|
|
|
|
|
/**
|
2019-02-18 23:36:48 +07:00
|
|
|
* component_match_add_release - add a component match entry with release callback
|
2019-02-08 06:27:57 +07:00
|
|
|
* @master: device with the aggregate driver
|
|
|
|
* @matchptr: pointer to the list of component matches
|
|
|
|
* @release: release function for @compare_data
|
|
|
|
* @compare: compare function to match against all components
|
|
|
|
* @compare_data: opaque pointer passed to the @compare function
|
|
|
|
*
|
|
|
|
* Adds a new component match to the list stored in @matchptr, which the @master
|
|
|
|
* aggregate driver needs to function. The list of component matches pointed to
|
|
|
|
* by @matchptr must be initialized to NULL before adding the first match. This
|
|
|
|
* only matches against components added with component_add().
|
|
|
|
*
|
|
|
|
* The allocated match list in @matchptr is automatically released using devm
|
|
|
|
* actions, where upon @release will be called to free any references held by
|
|
|
|
* @compare_data, e.g. when @compare_data is a &device_node that must be
|
|
|
|
* released with of_node_put().
|
|
|
|
*
|
|
|
|
* See also component_match_add() and component_match_add_typed().
|
|
|
|
*/
|
|
|
|
void component_match_add_release(struct device *master,
|
|
|
|
struct component_match **matchptr,
|
|
|
|
void (*release)(struct device *, void *),
|
|
|
|
int (*compare)(struct device *, void *), void *compare_data)
|
|
|
|
{
|
|
|
|
__component_match_add(master, matchptr, release, compare, NULL,
|
|
|
|
compare_data);
|
|
|
|
}
|
2015-11-17 19:08:01 +07:00
|
|
|
EXPORT_SYMBOL(component_match_add_release);
|
2014-04-19 17:18:01 +07:00
|
|
|
|
2019-02-08 06:27:57 +07:00
|
|
|
/**
|
2019-02-18 23:36:48 +07:00
|
|
|
* component_match_add_typed - add a component match entry for a typed component
|
2019-02-08 06:27:57 +07:00
|
|
|
* @master: device with the aggregate driver
|
|
|
|
* @matchptr: pointer to the list of component matches
|
|
|
|
* @compare_typed: compare function to match against all typed components
|
|
|
|
* @compare_data: opaque pointer passed to the @compare function
|
|
|
|
*
|
|
|
|
* Adds a new component match to the list stored in @matchptr, which the @master
|
|
|
|
* aggregate driver needs to function. The list of component matches pointed to
|
|
|
|
* by @matchptr must be initialized to NULL before adding the first match. This
|
|
|
|
* only matches against components added with component_add_typed().
|
|
|
|
*
|
|
|
|
* The allocated match list in @matchptr is automatically released using devm
|
|
|
|
* actions.
|
|
|
|
*
|
|
|
|
* See also component_match_add_release() and component_match_add_typed().
|
|
|
|
*/
|
|
|
|
void component_match_add_typed(struct device *master,
|
|
|
|
struct component_match **matchptr,
|
|
|
|
int (*compare_typed)(struct device *, int, void *), void *compare_data)
|
|
|
|
{
|
|
|
|
__component_match_add(master, matchptr, NULL, NULL, compare_typed,
|
|
|
|
compare_data);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(component_match_add_typed);
|
|
|
|
|
2016-01-27 00:59:13 +07:00
|
|
|
static void free_master(struct master *master)
|
|
|
|
{
|
|
|
|
struct component_match *match = master->match;
|
|
|
|
int i;
|
|
|
|
|
2017-12-01 20:23:16 +07:00
|
|
|
component_master_debugfs_del(master);
|
2016-01-27 00:59:13 +07:00
|
|
|
list_del(&master->node);
|
|
|
|
|
|
|
|
if (match) {
|
|
|
|
for (i = 0; i < match->num; i++) {
|
|
|
|
struct component *c = match->compare[i].component;
|
|
|
|
if (c)
|
|
|
|
c->master = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
kfree(master);
|
|
|
|
}
|
|
|
|
|
2019-02-08 06:27:56 +07:00
|
|
|
/**
|
|
|
|
* component_master_add_with_match - register an aggregate driver
|
|
|
|
* @dev: device with the aggregate driver
|
|
|
|
* @ops: callbacks for the aggregate driver
|
|
|
|
* @match: component match list for the aggregate driver
|
|
|
|
*
|
|
|
|
* Registers a new aggregate driver consisting of the components added to @match
|
|
|
|
* by calling one of the component_match_add() functions. Once all components in
|
|
|
|
* @match are available, it will be assembled by calling
|
|
|
|
* &component_master_ops.bind from @ops. Must be unregistered by calling
|
|
|
|
* component_master_del().
|
|
|
|
*/
|
2014-04-19 17:18:01 +07:00
|
|
|
int component_master_add_with_match(struct device *dev,
|
|
|
|
const struct component_master_ops *ops,
|
|
|
|
struct component_match *match)
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
{
|
|
|
|
struct master *master;
|
|
|
|
int ret;
|
|
|
|
|
2014-04-19 04:10:32 +07:00
|
|
|
/* Reallocate the match array for its true size */
|
2015-11-17 19:08:01 +07:00
|
|
|
ret = component_match_realloc(dev, match, match->num);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
2014-04-19 17:18:01 +07:00
|
|
|
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
master = kzalloc(sizeof(*master), GFP_KERNEL);
|
|
|
|
if (!master)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
master->dev = dev;
|
|
|
|
master->ops = ops;
|
2014-04-19 17:18:01 +07:00
|
|
|
master->match = match;
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
|
2017-12-01 20:23:16 +07:00
|
|
|
component_master_debugfs_add(master);
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
/* Add to the list of available masters. */
|
|
|
|
mutex_lock(&component_mutex);
|
|
|
|
list_add(&master->node, &masters);
|
|
|
|
|
|
|
|
ret = try_to_bring_up_master(master, NULL);
|
|
|
|
|
2016-01-27 00:59:13 +07:00
|
|
|
if (ret < 0)
|
|
|
|
free_master(master);
|
|
|
|
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
mutex_unlock(&component_mutex);
|
|
|
|
|
|
|
|
return ret < 0 ? ret : 0;
|
|
|
|
}
|
2014-04-19 17:18:01 +07:00
|
|
|
EXPORT_SYMBOL_GPL(component_master_add_with_match);
|
|
|
|
|
2019-02-08 06:27:56 +07:00
|
|
|
/**
|
|
|
|
* component_master_del - unregister an aggregate driver
|
|
|
|
* @dev: device with the aggregate driver
|
|
|
|
* @ops: callbacks for the aggregate driver
|
|
|
|
*
|
|
|
|
* Unregisters an aggregate driver registered with
|
|
|
|
* component_master_add_with_match(). If necessary the aggregate driver is first
|
|
|
|
* disassembled by calling &component_master_ops.unbind from @ops.
|
|
|
|
*/
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
void component_master_del(struct device *dev,
|
|
|
|
const struct component_master_ops *ops)
|
|
|
|
{
|
|
|
|
struct master *master;
|
|
|
|
|
|
|
|
mutex_lock(&component_mutex);
|
|
|
|
master = __master_find(dev, ops);
|
|
|
|
if (master) {
|
|
|
|
take_down_master(master);
|
2016-01-27 00:59:13 +07:00
|
|
|
free_master(master);
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
}
|
|
|
|
mutex_unlock(&component_mutex);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(component_master_del);
|
|
|
|
|
|
|
|
static void component_unbind(struct component *component,
|
|
|
|
struct master *master, void *data)
|
|
|
|
{
|
|
|
|
WARN_ON(!component->bound);
|
|
|
|
|
2020-02-27 17:45:47 +07:00
|
|
|
if (component->ops && component->ops->unbind)
|
|
|
|
component->ops->unbind(component->dev, master->dev, data);
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
component->bound = false;
|
|
|
|
|
|
|
|
/* Release all resources claimed in the binding of this component */
|
|
|
|
devres_release_group(component->dev, component);
|
|
|
|
}
|
|
|
|
|
2019-02-08 06:27:56 +07:00
|
|
|
/**
|
2019-02-18 23:36:48 +07:00
|
|
|
* component_unbind_all - unbind all components of an aggregate driver
|
2019-02-08 06:27:56 +07:00
|
|
|
* @master_dev: device with the aggregate driver
|
|
|
|
* @data: opaque pointer, passed to all components
|
|
|
|
*
|
2019-02-18 23:36:48 +07:00
|
|
|
* Unbinds all components of the aggregate @dev by passing @data to their
|
2019-02-08 06:27:56 +07:00
|
|
|
* &component_ops.unbind functions. Should be called from
|
|
|
|
* &component_master_ops.unbind.
|
|
|
|
*/
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
void component_unbind_all(struct device *master_dev, void *data)
|
|
|
|
{
|
|
|
|
struct master *master;
|
|
|
|
struct component *c;
|
2014-04-19 05:05:53 +07:00
|
|
|
size_t i;
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
|
|
|
|
WARN_ON(!mutex_is_locked(&component_mutex));
|
|
|
|
|
|
|
|
master = __master_find(master_dev, NULL);
|
|
|
|
if (!master)
|
|
|
|
return;
|
|
|
|
|
2014-04-19 05:05:53 +07:00
|
|
|
/* Unbind components in reverse order */
|
|
|
|
for (i = master->match->num; i--; )
|
|
|
|
if (!master->match->compare[i].duplicate) {
|
|
|
|
c = master->match->compare[i].component;
|
|
|
|
component_unbind(c, master, data);
|
|
|
|
}
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(component_unbind_all);
|
|
|
|
|
|
|
|
static int component_bind(struct component *component, struct master *master,
|
|
|
|
void *data)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Each component initialises inside its own devres group.
|
|
|
|
* This allows us to roll-back a failed component without
|
|
|
|
* affecting anything else.
|
|
|
|
*/
|
|
|
|
if (!devres_open_group(master->dev, NULL, GFP_KERNEL))
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Also open a group for the device itself: this allows us
|
|
|
|
* to release the resources claimed against the sub-device
|
|
|
|
* at the appropriate moment.
|
|
|
|
*/
|
|
|
|
if (!devres_open_group(component->dev, component, GFP_KERNEL)) {
|
|
|
|
devres_release_group(master->dev, NULL);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_dbg(master->dev, "binding %s (ops %ps)\n",
|
|
|
|
dev_name(component->dev), component->ops);
|
|
|
|
|
|
|
|
ret = component->ops->bind(component->dev, master->dev, data);
|
|
|
|
if (!ret) {
|
|
|
|
component->bound = true;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Close the component device's group so that resources
|
|
|
|
* allocated in the binding are encapsulated for removal
|
|
|
|
* at unbind. Remove the group on the DRM device as we
|
|
|
|
* can clean those resources up independently.
|
|
|
|
*/
|
|
|
|
devres_close_group(component->dev, NULL);
|
|
|
|
devres_remove_group(master->dev, NULL);
|
|
|
|
|
|
|
|
dev_info(master->dev, "bound %s (ops %ps)\n",
|
|
|
|
dev_name(component->dev), component->ops);
|
|
|
|
} else {
|
|
|
|
devres_release_group(component->dev, NULL);
|
|
|
|
devres_release_group(master->dev, NULL);
|
|
|
|
|
|
|
|
dev_err(master->dev, "failed to bind %s (ops %ps): %d\n",
|
|
|
|
dev_name(component->dev), component->ops, ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2019-02-08 06:27:56 +07:00
|
|
|
/**
|
2019-02-18 23:36:48 +07:00
|
|
|
* component_bind_all - bind all components of an aggregate driver
|
2019-02-08 06:27:56 +07:00
|
|
|
* @master_dev: device with the aggregate driver
|
|
|
|
* @data: opaque pointer, passed to all components
|
|
|
|
*
|
2019-02-18 23:36:48 +07:00
|
|
|
* Binds all components of the aggregate @dev by passing @data to their
|
2019-02-08 06:27:56 +07:00
|
|
|
* &component_ops.bind functions. Should be called from
|
|
|
|
* &component_master_ops.bind.
|
|
|
|
*/
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
int component_bind_all(struct device *master_dev, void *data)
|
|
|
|
{
|
|
|
|
struct master *master;
|
|
|
|
struct component *c;
|
2014-04-19 05:05:53 +07:00
|
|
|
size_t i;
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
WARN_ON(!mutex_is_locked(&component_mutex));
|
|
|
|
|
|
|
|
master = __master_find(master_dev, NULL);
|
|
|
|
if (!master)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2014-04-19 05:05:53 +07:00
|
|
|
/* Bind components in match order */
|
|
|
|
for (i = 0; i < master->match->num; i++)
|
|
|
|
if (!master->match->compare[i].duplicate) {
|
|
|
|
c = master->match->compare[i].component;
|
|
|
|
ret = component_bind(c, master, data);
|
|
|
|
if (ret)
|
|
|
|
break;
|
|
|
|
}
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
|
|
|
|
if (ret != 0) {
|
2018-08-28 11:15:39 +07:00
|
|
|
for (; i > 0; i--)
|
|
|
|
if (!master->match->compare[i - 1].duplicate) {
|
|
|
|
c = master->match->compare[i - 1].component;
|
2014-04-19 05:05:53 +07:00
|
|
|
component_unbind(c, master, data);
|
|
|
|
}
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(component_bind_all);
|
|
|
|
|
2019-02-08 06:27:57 +07:00
|
|
|
static int __component_add(struct device *dev, const struct component_ops *ops,
|
|
|
|
int subcomponent)
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
{
|
|
|
|
struct component *component;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
component = kzalloc(sizeof(*component), GFP_KERNEL);
|
|
|
|
if (!component)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
component->ops = ops;
|
|
|
|
component->dev = dev;
|
2019-02-08 06:27:57 +07:00
|
|
|
component->subcomponent = subcomponent;
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
|
|
|
|
dev_dbg(dev, "adding component (ops %ps)\n", ops);
|
|
|
|
|
|
|
|
mutex_lock(&component_mutex);
|
|
|
|
list_add_tail(&component->node, &component_list);
|
|
|
|
|
|
|
|
ret = try_to_bring_up_masters(component);
|
|
|
|
if (ret < 0) {
|
component: remove device from master match list on failed add
Calling component_add() may result in the completion of a set of
devices, which will try to bring up a master. In bringing the master
up, we populate its match array with the current set of children.
If binding any of the devices fails, component_add() itself will fail,
free the struct component entry, and return to the caller. The
now-freed entry is never removed from the master's match array, and
will later be used in a futile attempt to bind to freed memory.
Bring component_add's behaviour on failure to bring up a master into
line with component_del by removing the (to-be-freed) component from
the master's match array.
The specific case which broke was:
- rockchip_drm_drv adds a component master
- dwhdmi_rockchip adds a child component in probe (master incomplete)
- rockchip_drm_vop adds two children in probe, which completes the
set
- inside component_add, we try to bring up the master, having
populated the master's match array, and fail with EPROBE_DEFER from
dwhdmi_rockchip; we delete the putative component
- rockchip_drm_vop's probe fails and returns EPROBE_DEFER
- we later re-probe rockchip_drm_vop and add the component; the
master is complete, so we attempt to bring it up again
- walking the match array, we find the previous child, whose master
pointer doesn't match (as it has been freed in the meantime)
- rockchip_drm_vop probe fails, and will never be attempted again
Fixes: ffc30b74fd6d01588bd3fdebc3b1acc0857e6fc8
Signed-off-by: Daniel Stone <daniels@collabora.com>
Cc: Russell King <rmk+kernel@arm.linux.org.uk>
Cc: Thierry Reding <treding@nvidia.com>
Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
2016-02-09 04:12:58 +07:00
|
|
|
if (component->master)
|
|
|
|
remove_component(component->master, component);
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
list_del(&component->node);
|
|
|
|
|
|
|
|
kfree(component);
|
|
|
|
}
|
|
|
|
mutex_unlock(&component_mutex);
|
|
|
|
|
|
|
|
return ret < 0 ? ret : 0;
|
|
|
|
}
|
2019-02-08 06:27:57 +07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* component_add_typed - register a component
|
|
|
|
* @dev: component device
|
|
|
|
* @ops: component callbacks
|
|
|
|
* @subcomponent: nonzero identifier for subcomponents
|
|
|
|
*
|
|
|
|
* Register a new component for @dev. Functions in @ops will be call when the
|
|
|
|
* aggregate driver is ready to bind the overall driver by calling
|
|
|
|
* component_bind_all(). See also &struct component_ops.
|
|
|
|
*
|
|
|
|
* @subcomponent must be nonzero and is used to differentiate between multiple
|
|
|
|
* components registerd on the same device @dev. These components are match
|
|
|
|
* using component_match_add_typed().
|
|
|
|
*
|
|
|
|
* The component needs to be unregistered at driver unload/disconnect by
|
|
|
|
* calling component_del().
|
|
|
|
*
|
|
|
|
* See also component_add().
|
|
|
|
*/
|
|
|
|
int component_add_typed(struct device *dev, const struct component_ops *ops,
|
|
|
|
int subcomponent)
|
|
|
|
{
|
|
|
|
if (WARN_ON(subcomponent == 0))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
return __component_add(dev, ops, subcomponent);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(component_add_typed);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* component_add - register a component
|
|
|
|
* @dev: component device
|
|
|
|
* @ops: component callbacks
|
|
|
|
*
|
|
|
|
* Register a new component for @dev. Functions in @ops will be called when the
|
|
|
|
* aggregate driver is ready to bind the overall driver by calling
|
|
|
|
* component_bind_all(). See also &struct component_ops.
|
|
|
|
*
|
|
|
|
* The component needs to be unregistered at driver unload/disconnect by
|
|
|
|
* calling component_del().
|
|
|
|
*
|
|
|
|
* See also component_add_typed() for a variant that allows multipled different
|
|
|
|
* components on the same device.
|
|
|
|
*/
|
|
|
|
int component_add(struct device *dev, const struct component_ops *ops)
|
|
|
|
{
|
|
|
|
return __component_add(dev, ops, 0);
|
|
|
|
}
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
EXPORT_SYMBOL_GPL(component_add);
|
|
|
|
|
2019-02-08 06:27:56 +07:00
|
|
|
/**
|
|
|
|
* component_del - unregister a component
|
|
|
|
* @dev: component device
|
|
|
|
* @ops: component callbacks
|
|
|
|
*
|
|
|
|
* Unregister a component added with component_add(). If the component is bound
|
|
|
|
* into an aggregate driver, this will force the entire aggregate driver, including
|
|
|
|
* all its components, to be unbound.
|
|
|
|
*/
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
void component_del(struct device *dev, const struct component_ops *ops)
|
|
|
|
{
|
|
|
|
struct component *c, *component = NULL;
|
|
|
|
|
|
|
|
mutex_lock(&component_mutex);
|
|
|
|
list_for_each_entry(c, &component_list, node)
|
|
|
|
if (c->dev == dev && c->ops == ops) {
|
|
|
|
list_del(&c->node);
|
|
|
|
component = c;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2014-04-19 05:05:53 +07:00
|
|
|
if (component && component->master) {
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
take_down_master(component->master);
|
2014-04-19 05:05:53 +07:00
|
|
|
remove_component(component->master, component);
|
|
|
|
}
|
drivers/base: provide an infrastructure for componentised subsystems
Subsystems such as ALSA, DRM and others require a single card-level
device structure to represent a subsystem. However, firmware tends to
describe the individual devices and the connections between them.
Therefore, we need a way to gather up the individual component devices
together, and indicate when we have all the component devices.
We do this in DT by providing a "superdevice" node which specifies
the components, eg:
imx-drm {
compatible = "fsl,drm";
crtcs = <&ipu1>;
connectors = <&hdmi>;
};
The superdevice is declared into the component support, along with the
subcomponents. The superdevice receives callbacks to locate the
subcomponents, and identify when all components are present. At this
point, we bind the superdevice, which causes the appropriate subsystem
to be initialised in the conventional way.
When any of the components or superdevice are removed from the system,
we unbind the superdevice, thereby taking the subsystem down.
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-01-11 06:23:37 +07:00
|
|
|
|
|
|
|
mutex_unlock(&component_mutex);
|
|
|
|
|
|
|
|
WARN_ON(!component);
|
|
|
|
kfree(component);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(component_del);
|