Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * Componentized device handling.
4 : : *
5 : : * This is work in progress. We gather up the component devices into a list,
6 : : * and bind them when instructed. At the moment, we're specific to the DRM
7 : : * subsystem, and only handles one master device, but this doesn't have to be
8 : : * the case.
9 : : */
10 : : #include <linux/component.h>
11 : : #include <linux/device.h>
12 : : #include <linux/kref.h>
13 : : #include <linux/list.h>
14 : : #include <linux/module.h>
15 : : #include <linux/mutex.h>
16 : : #include <linux/slab.h>
17 : : #include <linux/debugfs.h>
18 : :
19 : : /**
20 : : * DOC: overview
21 : : *
22 : : * The component helper allows drivers to collect a pile of sub-devices,
23 : : * including their bound drivers, into an aggregate driver. Various subsystems
24 : : * already provide functions to get hold of such components, e.g.
25 : : * of_clk_get_by_name(). The component helper can be used when such a
26 : : * subsystem-specific way to find a device is not available: The component
27 : : * helper fills the niche of aggregate drivers for specific hardware, where
28 : : * further standardization into a subsystem would not be practical. The common
29 : : * example is when a logical device (e.g. a DRM display driver) is spread around
30 : : * the SoC on various components (scanout engines, blending blocks, transcoders
31 : : * for various outputs and so on).
32 : : *
33 : : * The component helper also doesn't solve runtime dependencies, e.g. for system
34 : : * suspend and resume operations. See also :ref:`device links<device_link>`.
35 : : *
36 : : * Components are registered using component_add() and unregistered with
37 : : * component_del(), usually from the driver's probe and disconnect functions.
38 : : *
39 : : * Aggregate drivers first assemble a component match list of what they need
40 : : * using component_match_add(). This is then registered as an aggregate driver
41 : : * using component_master_add_with_match(), and unregistered using
42 : : * component_master_del().
43 : : */
44 : :
45 : : struct component;
46 : :
47 : : struct component_match_array {
48 : : void *data;
49 : : int (*compare)(struct device *, void *);
50 : : int (*compare_typed)(struct device *, int, void *);
51 : : void (*release)(struct device *, void *);
52 : : struct component *component;
53 : : bool duplicate;
54 : : };
55 : :
56 : : struct component_match {
57 : : size_t alloc;
58 : : size_t num;
59 : : struct component_match_array *compare;
60 : : };
61 : :
62 : : struct master {
63 : : struct list_head node;
64 : : bool bound;
65 : :
66 : : const struct component_master_ops *ops;
67 : : struct device *dev;
68 : : struct component_match *match;
69 : : struct dentry *dentry;
70 : : };
71 : :
72 : : struct component {
73 : : struct list_head node;
74 : : struct master *master;
75 : : bool bound;
76 : :
77 : : const struct component_ops *ops;
78 : : int subcomponent;
79 : : struct device *dev;
80 : : };
81 : :
82 : : static DEFINE_MUTEX(component_mutex);
83 : : static LIST_HEAD(component_list);
84 : : static LIST_HEAD(masters);
85 : :
86 : : #ifdef CONFIG_DEBUG_FS
87 : :
88 : : static struct dentry *component_debugfs_dir;
89 : :
90 : 0 : static int component_devices_show(struct seq_file *s, void *data)
91 : : {
92 : 0 : struct master *m = s->private;
93 : 0 : struct component_match *match = m->match;
94 : : size_t i;
95 : :
96 : 0 : mutex_lock(&component_mutex);
97 : 0 : seq_printf(s, "%-40s %20s\n", "master name", "status");
98 : 0 : seq_puts(s, "-------------------------------------------------------------\n");
99 : 0 : seq_printf(s, "%-40s %20s\n\n",
100 : 0 : dev_name(m->dev), m->bound ? "bound" : "not bound");
101 : :
102 : 0 : seq_printf(s, "%-40s %20s\n", "device name", "status");
103 : 0 : seq_puts(s, "-------------------------------------------------------------\n");
104 : 0 : for (i = 0; i < match->num; i++) {
105 : 0 : struct component *component = match->compare[i].component;
106 : :
107 : 0 : seq_printf(s, "%-40s %20s\n",
108 : 0 : component ? dev_name(component->dev) : "(unknown)",
109 : 0 : component ? (component->bound ? "bound" : "not bound") : "not registered");
110 : : }
111 : 0 : mutex_unlock(&component_mutex);
112 : :
113 : 0 : return 0;
114 : : }
115 : :
116 : 0 : DEFINE_SHOW_ATTRIBUTE(component_devices);
117 : :
118 : 3 : static int __init component_debug_init(void)
119 : : {
120 : 3 : component_debugfs_dir = debugfs_create_dir("device_component", NULL);
121 : :
122 : 3 : return 0;
123 : : }
124 : :
125 : : core_initcall(component_debug_init);
126 : :
127 : 0 : static void component_master_debugfs_add(struct master *m)
128 : : {
129 : 0 : m->dentry = debugfs_create_file(dev_name(m->dev), 0444,
130 : : component_debugfs_dir,
131 : : m, &component_devices_fops);
132 : 0 : }
133 : :
134 : : static void component_master_debugfs_del(struct master *m)
135 : : {
136 : 0 : debugfs_remove(m->dentry);
137 : 0 : m->dentry = NULL;
138 : : }
139 : :
140 : : #else
141 : :
142 : : static void component_master_debugfs_add(struct master *m)
143 : : { }
144 : :
145 : : static void component_master_debugfs_del(struct master *m)
146 : : { }
147 : :
148 : : #endif
149 : :
150 : : static struct master *__master_find(struct device *dev,
151 : : const struct component_master_ops *ops)
152 : : {
153 : : struct master *m;
154 : :
155 : 0 : list_for_each_entry(m, &masters, node)
156 : 0 : if (m->dev == dev && (!ops || m->ops == ops))
157 : 0 : return m;
158 : :
159 : : return NULL;
160 : : }
161 : :
162 : 0 : static struct component *find_component(struct master *master,
163 : : struct component_match_array *mc)
164 : : {
165 : : struct component *c;
166 : :
167 : 0 : list_for_each_entry(c, &component_list, node) {
168 : 0 : if (c->master && c->master != master)
169 : 0 : continue;
170 : :
171 : 0 : if (mc->compare && mc->compare(c->dev, mc->data))
172 : 0 : return c;
173 : :
174 : 0 : if (mc->compare_typed &&
175 : 0 : mc->compare_typed(c->dev, c->subcomponent, mc->data))
176 : 0 : return c;
177 : : }
178 : :
179 : : return NULL;
180 : : }
181 : :
182 : 0 : static int find_components(struct master *master)
183 : : {
184 : 0 : struct component_match *match = master->match;
185 : : size_t i;
186 : : int ret = 0;
187 : :
188 : : /*
189 : : * Scan the array of match functions and attach
190 : : * any components which are found to this master.
191 : : */
192 : 0 : for (i = 0; i < match->num; i++) {
193 : 0 : struct component_match_array *mc = &match->compare[i];
194 : : struct component *c;
195 : :
196 : : dev_dbg(master->dev, "Looking for component %zu\n", i);
197 : :
198 : 0 : if (match->compare[i].component)
199 : 0 : continue;
200 : :
201 : 0 : c = find_component(master, mc);
202 : 0 : if (!c) {
203 : : ret = -ENXIO;
204 : : break;
205 : : }
206 : :
207 : : dev_dbg(master->dev, "found component %s, duplicate %u\n", dev_name(c->dev), !!c->master);
208 : :
209 : : /* Attach this component to the master */
210 : 0 : match->compare[i].duplicate = !!c->master;
211 : 0 : match->compare[i].component = c;
212 : 0 : c->master = master;
213 : : }
214 : 0 : return ret;
215 : : }
216 : :
217 : : /* Detach component from associated master */
218 : : static void remove_component(struct master *master, struct component *c)
219 : : {
220 : : size_t i;
221 : :
222 : : /* Detach the component from this master. */
223 : 0 : for (i = 0; i < master->match->num; i++)
224 : 0 : if (master->match->compare[i].component == c)
225 : 0 : master->match->compare[i].component = NULL;
226 : : }
227 : :
228 : : /*
229 : : * Try to bring up a master. If component is NULL, we're interested in
230 : : * this master, otherwise it's a component which must be present to try
231 : : * and bring up the master.
232 : : *
233 : : * Returns 1 for successful bringup, 0 if not ready, or -ve errno.
234 : : */
235 : 0 : static int try_to_bring_up_master(struct master *master,
236 : : struct component *component)
237 : : {
238 : : int ret;
239 : :
240 : : dev_dbg(master->dev, "trying to bring up master\n");
241 : :
242 : 0 : if (find_components(master)) {
243 : : dev_dbg(master->dev, "master has incomplete components\n");
244 : : return 0;
245 : : }
246 : :
247 : 0 : if (component && component->master != master) {
248 : : dev_dbg(master->dev, "master is not for this component (%s)\n",
249 : : dev_name(component->dev));
250 : : return 0;
251 : : }
252 : :
253 : 0 : if (!devres_open_group(master->dev, NULL, GFP_KERNEL))
254 : : return -ENOMEM;
255 : :
256 : : /* Found all components */
257 : 0 : ret = master->ops->bind(master->dev);
258 : 0 : if (ret < 0) {
259 : 0 : devres_release_group(master->dev, NULL);
260 : 0 : if (ret != -EPROBE_DEFER)
261 : 0 : dev_info(master->dev, "master bind failed: %d\n", ret);
262 : 0 : return ret;
263 : : }
264 : :
265 : 0 : master->bound = true;
266 : 0 : return 1;
267 : : }
268 : :
269 : 0 : static int try_to_bring_up_masters(struct component *component)
270 : : {
271 : : struct master *m;
272 : : int ret = 0;
273 : :
274 : 0 : list_for_each_entry(m, &masters, node) {
275 : 0 : if (!m->bound) {
276 : 0 : ret = try_to_bring_up_master(m, component);
277 : 0 : if (ret != 0)
278 : : break;
279 : : }
280 : : }
281 : :
282 : 0 : return ret;
283 : : }
284 : :
285 : 0 : static void take_down_master(struct master *master)
286 : : {
287 : 0 : if (master->bound) {
288 : 0 : master->ops->unbind(master->dev);
289 : 0 : devres_release_group(master->dev, NULL);
290 : 0 : master->bound = false;
291 : : }
292 : 0 : }
293 : :
294 : 0 : static void component_match_release(struct device *master,
295 : : struct component_match *match)
296 : : {
297 : : unsigned int i;
298 : :
299 : 0 : for (i = 0; i < match->num; i++) {
300 : 0 : struct component_match_array *mc = &match->compare[i];
301 : :
302 : 0 : if (mc->release)
303 : 0 : mc->release(master, mc->data);
304 : : }
305 : :
306 : 0 : kfree(match->compare);
307 : 0 : }
308 : :
309 : 0 : static void devm_component_match_release(struct device *dev, void *res)
310 : : {
311 : 0 : component_match_release(dev, res);
312 : 0 : }
313 : :
314 : 0 : static int component_match_realloc(struct device *dev,
315 : : struct component_match *match, size_t num)
316 : : {
317 : : struct component_match_array *new;
318 : :
319 : 0 : if (match->alloc == num)
320 : : return 0;
321 : :
322 : 0 : new = kmalloc_array(num, sizeof(*new), GFP_KERNEL);
323 : 0 : if (!new)
324 : : return -ENOMEM;
325 : :
326 : 0 : if (match->compare) {
327 : 0 : memcpy(new, match->compare, sizeof(*new) *
328 : 0 : min(match->num, num));
329 : 0 : kfree(match->compare);
330 : : }
331 : 0 : match->compare = new;
332 : 0 : match->alloc = num;
333 : :
334 : 0 : return 0;
335 : : }
336 : :
337 : 0 : static void __component_match_add(struct device *master,
338 : : struct component_match **matchptr,
339 : : void (*release)(struct device *, void *),
340 : : int (*compare)(struct device *, void *),
341 : : int (*compare_typed)(struct device *, int, void *),
342 : : void *compare_data)
343 : : {
344 : 0 : struct component_match *match = *matchptr;
345 : :
346 : 0 : if (IS_ERR(match))
347 : : return;
348 : :
349 : 0 : if (!match) {
350 : : match = devres_alloc(devm_component_match_release,
351 : : sizeof(*match), GFP_KERNEL);
352 : 0 : if (!match) {
353 : 0 : *matchptr = ERR_PTR(-ENOMEM);
354 : 0 : return;
355 : : }
356 : :
357 : 0 : devres_add(master, match);
358 : :
359 : 0 : *matchptr = match;
360 : : }
361 : :
362 : 0 : if (match->num == match->alloc) {
363 : 0 : size_t new_size = match->alloc + 16;
364 : : int ret;
365 : :
366 : 0 : ret = component_match_realloc(master, match, new_size);
367 : 0 : if (ret) {
368 : 0 : *matchptr = ERR_PTR(ret);
369 : 0 : return;
370 : : }
371 : : }
372 : :
373 : 0 : match->compare[match->num].compare = compare;
374 : 0 : match->compare[match->num].compare_typed = compare_typed;
375 : 0 : match->compare[match->num].release = release;
376 : 0 : match->compare[match->num].data = compare_data;
377 : 0 : match->compare[match->num].component = NULL;
378 : 0 : match->num++;
379 : : }
380 : :
381 : : /**
382 : : * component_match_add_release - add a component match entry with release callback
383 : : * @master: device with the aggregate driver
384 : : * @matchptr: pointer to the list of component matches
385 : : * @release: release function for @compare_data
386 : : * @compare: compare function to match against all components
387 : : * @compare_data: opaque pointer passed to the @compare function
388 : : *
389 : : * Adds a new component match to the list stored in @matchptr, which the @master
390 : : * aggregate driver needs to function. The list of component matches pointed to
391 : : * by @matchptr must be initialized to NULL before adding the first match. This
392 : : * only matches against components added with component_add().
393 : : *
394 : : * The allocated match list in @matchptr is automatically released using devm
395 : : * actions, where upon @release will be called to free any references held by
396 : : * @compare_data, e.g. when @compare_data is a &device_node that must be
397 : : * released with of_node_put().
398 : : *
399 : : * See also component_match_add() and component_match_add_typed().
400 : : */
401 : 0 : void component_match_add_release(struct device *master,
402 : : struct component_match **matchptr,
403 : : void (*release)(struct device *, void *),
404 : : int (*compare)(struct device *, void *), void *compare_data)
405 : : {
406 : 0 : __component_match_add(master, matchptr, release, compare, NULL,
407 : : compare_data);
408 : 0 : }
409 : : EXPORT_SYMBOL(component_match_add_release);
410 : :
411 : : /**
412 : : * component_match_add_typed - add a component match entry for a typed component
413 : : * @master: device with the aggregate driver
414 : : * @matchptr: pointer to the list of component matches
415 : : * @compare_typed: compare function to match against all typed components
416 : : * @compare_data: opaque pointer passed to the @compare function
417 : : *
418 : : * Adds a new component match to the list stored in @matchptr, which the @master
419 : : * aggregate driver needs to function. The list of component matches pointed to
420 : : * by @matchptr must be initialized to NULL before adding the first match. This
421 : : * only matches against components added with component_add_typed().
422 : : *
423 : : * The allocated match list in @matchptr is automatically released using devm
424 : : * actions.
425 : : *
426 : : * See also component_match_add_release() and component_match_add_typed().
427 : : */
428 : 0 : void component_match_add_typed(struct device *master,
429 : : struct component_match **matchptr,
430 : : int (*compare_typed)(struct device *, int, void *), void *compare_data)
431 : : {
432 : 0 : __component_match_add(master, matchptr, NULL, NULL, compare_typed,
433 : : compare_data);
434 : 0 : }
435 : : EXPORT_SYMBOL(component_match_add_typed);
436 : :
437 : 0 : static void free_master(struct master *master)
438 : : {
439 : 0 : struct component_match *match = master->match;
440 : : int i;
441 : :
442 : : component_master_debugfs_del(master);
443 : : list_del(&master->node);
444 : :
445 : 0 : if (match) {
446 : 0 : for (i = 0; i < match->num; i++) {
447 : 0 : struct component *c = match->compare[i].component;
448 : 0 : if (c)
449 : 0 : c->master = NULL;
450 : : }
451 : : }
452 : :
453 : 0 : kfree(master);
454 : 0 : }
455 : :
456 : : /**
457 : : * component_master_add_with_match - register an aggregate driver
458 : : * @dev: device with the aggregate driver
459 : : * @ops: callbacks for the aggregate driver
460 : : * @match: component match list for the aggregate driver
461 : : *
462 : : * Registers a new aggregate driver consisting of the components added to @match
463 : : * by calling one of the component_match_add() functions. Once all components in
464 : : * @match are available, it will be assembled by calling
465 : : * &component_master_ops.bind from @ops. Must be unregistered by calling
466 : : * component_master_del().
467 : : */
468 : 0 : int component_master_add_with_match(struct device *dev,
469 : : const struct component_master_ops *ops,
470 : : struct component_match *match)
471 : : {
472 : : struct master *master;
473 : : int ret;
474 : :
475 : : /* Reallocate the match array for its true size */
476 : 0 : ret = component_match_realloc(dev, match, match->num);
477 : 0 : if (ret)
478 : : return ret;
479 : :
480 : 0 : master = kzalloc(sizeof(*master), GFP_KERNEL);
481 : 0 : if (!master)
482 : : return -ENOMEM;
483 : :
484 : 0 : master->dev = dev;
485 : 0 : master->ops = ops;
486 : 0 : master->match = match;
487 : :
488 : 0 : component_master_debugfs_add(master);
489 : : /* Add to the list of available masters. */
490 : 0 : mutex_lock(&component_mutex);
491 : 0 : list_add(&master->node, &masters);
492 : :
493 : 0 : ret = try_to_bring_up_master(master, NULL);
494 : :
495 : 0 : if (ret < 0)
496 : 0 : free_master(master);
497 : :
498 : 0 : mutex_unlock(&component_mutex);
499 : :
500 : 0 : return ret < 0 ? ret : 0;
501 : : }
502 : : EXPORT_SYMBOL_GPL(component_master_add_with_match);
503 : :
504 : : /**
505 : : * component_master_del - unregister an aggregate driver
506 : : * @dev: device with the aggregate driver
507 : : * @ops: callbacks for the aggregate driver
508 : : *
509 : : * Unregisters an aggregate driver registered with
510 : : * component_master_add_with_match(). If necessary the aggregate driver is first
511 : : * disassembled by calling &component_master_ops.unbind from @ops.
512 : : */
513 : 0 : void component_master_del(struct device *dev,
514 : : const struct component_master_ops *ops)
515 : : {
516 : : struct master *master;
517 : :
518 : 0 : mutex_lock(&component_mutex);
519 : : master = __master_find(dev, ops);
520 : 0 : if (master) {
521 : 0 : take_down_master(master);
522 : 0 : free_master(master);
523 : : }
524 : 0 : mutex_unlock(&component_mutex);
525 : 0 : }
526 : : EXPORT_SYMBOL_GPL(component_master_del);
527 : :
528 : 0 : static void component_unbind(struct component *component,
529 : : struct master *master, void *data)
530 : : {
531 : 0 : WARN_ON(!component->bound);
532 : :
533 : 0 : component->ops->unbind(component->dev, master->dev, data);
534 : 0 : component->bound = false;
535 : :
536 : : /* Release all resources claimed in the binding of this component */
537 : 0 : devres_release_group(component->dev, component);
538 : 0 : }
539 : :
540 : : /**
541 : : * component_unbind_all - unbind all components of an aggregate driver
542 : : * @master_dev: device with the aggregate driver
543 : : * @data: opaque pointer, passed to all components
544 : : *
545 : : * Unbinds all components of the aggregate @dev by passing @data to their
546 : : * &component_ops.unbind functions. Should be called from
547 : : * &component_master_ops.unbind.
548 : : */
549 : 0 : void component_unbind_all(struct device *master_dev, void *data)
550 : : {
551 : : struct master *master;
552 : : struct component *c;
553 : : size_t i;
554 : :
555 : 0 : WARN_ON(!mutex_is_locked(&component_mutex));
556 : :
557 : : master = __master_find(master_dev, NULL);
558 : 0 : if (!master)
559 : 0 : return;
560 : :
561 : : /* Unbind components in reverse order */
562 : 0 : for (i = master->match->num; i--; )
563 : 0 : if (!master->match->compare[i].duplicate) {
564 : 0 : c = master->match->compare[i].component;
565 : 0 : component_unbind(c, master, data);
566 : : }
567 : : }
568 : : EXPORT_SYMBOL_GPL(component_unbind_all);
569 : :
570 : 0 : static int component_bind(struct component *component, struct master *master,
571 : : void *data)
572 : : {
573 : : int ret;
574 : :
575 : : /*
576 : : * Each component initialises inside its own devres group.
577 : : * This allows us to roll-back a failed component without
578 : : * affecting anything else.
579 : : */
580 : 0 : if (!devres_open_group(master->dev, NULL, GFP_KERNEL))
581 : : return -ENOMEM;
582 : :
583 : : /*
584 : : * Also open a group for the device itself: this allows us
585 : : * to release the resources claimed against the sub-device
586 : : * at the appropriate moment.
587 : : */
588 : 0 : if (!devres_open_group(component->dev, component, GFP_KERNEL)) {
589 : 0 : devres_release_group(master->dev, NULL);
590 : 0 : return -ENOMEM;
591 : : }
592 : :
593 : : dev_dbg(master->dev, "binding %s (ops %ps)\n",
594 : : dev_name(component->dev), component->ops);
595 : :
596 : 0 : ret = component->ops->bind(component->dev, master->dev, data);
597 : 0 : if (!ret) {
598 : 0 : component->bound = true;
599 : :
600 : : /*
601 : : * Close the component device's group so that resources
602 : : * allocated in the binding are encapsulated for removal
603 : : * at unbind. Remove the group on the DRM device as we
604 : : * can clean those resources up independently.
605 : : */
606 : 0 : devres_close_group(component->dev, NULL);
607 : 0 : devres_remove_group(master->dev, NULL);
608 : :
609 : 0 : dev_info(master->dev, "bound %s (ops %ps)\n",
610 : : dev_name(component->dev), component->ops);
611 : : } else {
612 : 0 : devres_release_group(component->dev, NULL);
613 : 0 : devres_release_group(master->dev, NULL);
614 : :
615 : 0 : if (ret != -EPROBE_DEFER)
616 : 0 : dev_err(master->dev, "failed to bind %s (ops %ps): %d\n",
617 : : dev_name(component->dev), component->ops, ret);
618 : : }
619 : :
620 : 0 : return ret;
621 : : }
622 : :
623 : : /**
624 : : * component_bind_all - bind all components of an aggregate driver
625 : : * @master_dev: device with the aggregate driver
626 : : * @data: opaque pointer, passed to all components
627 : : *
628 : : * Binds all components of the aggregate @dev by passing @data to their
629 : : * &component_ops.bind functions. Should be called from
630 : : * &component_master_ops.bind.
631 : : */
632 : 0 : int component_bind_all(struct device *master_dev, void *data)
633 : : {
634 : : struct master *master;
635 : : struct component *c;
636 : : size_t i;
637 : : int ret = 0;
638 : :
639 : 0 : WARN_ON(!mutex_is_locked(&component_mutex));
640 : :
641 : : master = __master_find(master_dev, NULL);
642 : 0 : if (!master)
643 : : return -EINVAL;
644 : :
645 : : /* Bind components in match order */
646 : 0 : for (i = 0; i < master->match->num; i++)
647 : 0 : if (!master->match->compare[i].duplicate) {
648 : 0 : c = master->match->compare[i].component;
649 : 0 : ret = component_bind(c, master, data);
650 : 0 : if (ret)
651 : : break;
652 : : }
653 : :
654 : 0 : if (ret != 0) {
655 : 0 : for (; i > 0; i--)
656 : 0 : if (!master->match->compare[i - 1].duplicate) {
657 : 0 : c = master->match->compare[i - 1].component;
658 : 0 : component_unbind(c, master, data);
659 : : }
660 : : }
661 : :
662 : 0 : return ret;
663 : : }
664 : : EXPORT_SYMBOL_GPL(component_bind_all);
665 : :
666 : 0 : static int __component_add(struct device *dev, const struct component_ops *ops,
667 : : int subcomponent)
668 : : {
669 : : struct component *component;
670 : : int ret;
671 : :
672 : 0 : component = kzalloc(sizeof(*component), GFP_KERNEL);
673 : 0 : if (!component)
674 : : return -ENOMEM;
675 : :
676 : 0 : component->ops = ops;
677 : 0 : component->dev = dev;
678 : 0 : component->subcomponent = subcomponent;
679 : :
680 : : dev_dbg(dev, "adding component (ops %ps)\n", ops);
681 : :
682 : 0 : mutex_lock(&component_mutex);
683 : 0 : list_add_tail(&component->node, &component_list);
684 : :
685 : 0 : ret = try_to_bring_up_masters(component);
686 : 0 : if (ret < 0) {
687 : 0 : if (component->master)
688 : : remove_component(component->master, component);
689 : : list_del(&component->node);
690 : :
691 : 0 : kfree(component);
692 : : }
693 : 0 : mutex_unlock(&component_mutex);
694 : :
695 : 0 : return ret < 0 ? ret : 0;
696 : : }
697 : :
698 : : /**
699 : : * component_add_typed - register a component
700 : : * @dev: component device
701 : : * @ops: component callbacks
702 : : * @subcomponent: nonzero identifier for subcomponents
703 : : *
704 : : * Register a new component for @dev. Functions in @ops will be call when the
705 : : * aggregate driver is ready to bind the overall driver by calling
706 : : * component_bind_all(). See also &struct component_ops.
707 : : *
708 : : * @subcomponent must be nonzero and is used to differentiate between multiple
709 : : * components registerd on the same device @dev. These components are match
710 : : * using component_match_add_typed().
711 : : *
712 : : * The component needs to be unregistered at driver unload/disconnect by
713 : : * calling component_del().
714 : : *
715 : : * See also component_add().
716 : : */
717 : 0 : int component_add_typed(struct device *dev, const struct component_ops *ops,
718 : : int subcomponent)
719 : : {
720 : 0 : if (WARN_ON(subcomponent == 0))
721 : : return -EINVAL;
722 : :
723 : 0 : return __component_add(dev, ops, subcomponent);
724 : : }
725 : : EXPORT_SYMBOL_GPL(component_add_typed);
726 : :
727 : : /**
728 : : * component_add - register a component
729 : : * @dev: component device
730 : : * @ops: component callbacks
731 : : *
732 : : * Register a new component for @dev. Functions in @ops will be called when the
733 : : * aggregate driver is ready to bind the overall driver by calling
734 : : * component_bind_all(). See also &struct component_ops.
735 : : *
736 : : * The component needs to be unregistered at driver unload/disconnect by
737 : : * calling component_del().
738 : : *
739 : : * See also component_add_typed() for a variant that allows multipled different
740 : : * components on the same device.
741 : : */
742 : 0 : int component_add(struct device *dev, const struct component_ops *ops)
743 : : {
744 : 0 : return __component_add(dev, ops, 0);
745 : : }
746 : : EXPORT_SYMBOL_GPL(component_add);
747 : :
748 : : /**
749 : : * component_del - unregister a component
750 : : * @dev: component device
751 : : * @ops: component callbacks
752 : : *
753 : : * Unregister a component added with component_add(). If the component is bound
754 : : * into an aggregate driver, this will force the entire aggregate driver, including
755 : : * all its components, to be unbound.
756 : : */
757 : 0 : void component_del(struct device *dev, const struct component_ops *ops)
758 : : {
759 : : struct component *c, *component = NULL;
760 : :
761 : 0 : mutex_lock(&component_mutex);
762 : 0 : list_for_each_entry(c, &component_list, node)
763 : 0 : if (c->dev == dev && c->ops == ops) {
764 : : list_del(&c->node);
765 : 0 : component = c;
766 : 0 : break;
767 : : }
768 : :
769 : 0 : if (component && component->master) {
770 : 0 : take_down_master(component->master);
771 : 0 : remove_component(component->master, component);
772 : : }
773 : :
774 : 0 : mutex_unlock(&component_mutex);
775 : :
776 : 0 : WARN_ON(!component);
777 : 0 : kfree(component);
778 : 0 : }
779 : : EXPORT_SYMBOL_GPL(component_del);
780 : :
781 : : MODULE_LICENSE("GPL v2");
|
