1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * V4L2 asynchronous subdevice registration API
4 *
5 * Copyright (C) 2012-2013, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
6 */
7
8 #include <linux/debugfs.h>
9 #include <linux/device.h>
10 #include <linux/err.h>
11 #include <linux/i2c.h>
12 #include <linux/list.h>
13 #include <linux/mm.h>
14 #include <linux/module.h>
15 #include <linux/mutex.h>
16 #include <linux/of.h>
17 #include <linux/platform_device.h>
18 #include <linux/seq_file.h>
19 #include <linux/slab.h>
20 #include <linux/types.h>
21
22 #include <media/v4l2-async.h>
23 #include <media/v4l2-device.h>
24 #include <media/v4l2-fwnode.h>
25 #include <media/v4l2-subdev.h>
26
27 #include "v4l2-subdev-priv.h"
28
v4l2_async_nf_call_bound(struct v4l2_async_notifier * n,struct v4l2_subdev * subdev,struct v4l2_async_connection * asc)29 static int v4l2_async_nf_call_bound(struct v4l2_async_notifier *n,
30 struct v4l2_subdev *subdev,
31 struct v4l2_async_connection *asc)
32 {
33 if (!n->ops || !n->ops->bound)
34 return 0;
35
36 return n->ops->bound(n, subdev, asc);
37 }
38
v4l2_async_nf_call_unbind(struct v4l2_async_notifier * n,struct v4l2_subdev * subdev,struct v4l2_async_connection * asc)39 static void v4l2_async_nf_call_unbind(struct v4l2_async_notifier *n,
40 struct v4l2_subdev *subdev,
41 struct v4l2_async_connection *asc)
42 {
43 if (!n->ops || !n->ops->unbind)
44 return;
45
46 n->ops->unbind(n, subdev, asc);
47 }
48
v4l2_async_nf_call_complete(struct v4l2_async_notifier * n)49 static int v4l2_async_nf_call_complete(struct v4l2_async_notifier *n)
50 {
51 if (!n->ops || !n->ops->complete)
52 return 0;
53
54 return n->ops->complete(n);
55 }
56
v4l2_async_nf_call_destroy(struct v4l2_async_notifier * n,struct v4l2_async_connection * asc)57 static void v4l2_async_nf_call_destroy(struct v4l2_async_notifier *n,
58 struct v4l2_async_connection *asc)
59 {
60 if (!n->ops || !n->ops->destroy)
61 return;
62
63 n->ops->destroy(asc);
64 }
65
match_i2c(struct v4l2_async_notifier * notifier,struct v4l2_subdev * sd,struct v4l2_async_match_desc * match)66 static bool match_i2c(struct v4l2_async_notifier *notifier,
67 struct v4l2_subdev *sd,
68 struct v4l2_async_match_desc *match)
69 {
70 #if IS_ENABLED(CONFIG_I2C)
71 struct i2c_client *client = i2c_verify_client(sd->dev);
72
73 return client &&
74 match->i2c.adapter_id == client->adapter->nr &&
75 match->i2c.address == client->addr;
76 #else
77 return false;
78 #endif
79 }
80
notifier_dev(struct v4l2_async_notifier * notifier)81 static struct device *notifier_dev(struct v4l2_async_notifier *notifier)
82 {
83 if (notifier->sd)
84 return notifier->sd->dev;
85
86 if (notifier->v4l2_dev)
87 return notifier->v4l2_dev->dev;
88
89 return NULL;
90 }
91
92 static bool
match_fwnode_one(struct v4l2_async_notifier * notifier,struct v4l2_subdev * sd,struct fwnode_handle * sd_fwnode,struct v4l2_async_match_desc * match)93 match_fwnode_one(struct v4l2_async_notifier *notifier,
94 struct v4l2_subdev *sd, struct fwnode_handle *sd_fwnode,
95 struct v4l2_async_match_desc *match)
96 {
97 struct fwnode_handle *asd_dev_fwnode;
98 bool ret;
99
100 dev_dbg(notifier_dev(notifier),
101 "v4l2-async: fwnode match: need %pfw, trying %pfw\n",
102 sd_fwnode, match->fwnode);
103
104 if (sd_fwnode == match->fwnode) {
105 dev_dbg(notifier_dev(notifier),
106 "v4l2-async: direct match found\n");
107 return true;
108 }
109
110 if (!fwnode_graph_is_endpoint(match->fwnode)) {
111 dev_dbg(notifier_dev(notifier),
112 "v4l2-async: direct match not found\n");
113 return false;
114 }
115
116 asd_dev_fwnode = fwnode_graph_get_port_parent(match->fwnode);
117
118 ret = sd_fwnode == asd_dev_fwnode;
119
120 fwnode_handle_put(asd_dev_fwnode);
121
122 dev_dbg(notifier_dev(notifier),
123 "v4l2-async: device--endpoint match %sfound\n",
124 ret ? "" : "not ");
125
126 return ret;
127 }
128
match_fwnode(struct v4l2_async_notifier * notifier,struct v4l2_subdev * sd,struct v4l2_async_match_desc * match)129 static bool match_fwnode(struct v4l2_async_notifier *notifier,
130 struct v4l2_subdev *sd,
131 struct v4l2_async_match_desc *match)
132 {
133 dev_dbg(notifier_dev(notifier),
134 "v4l2-async: matching for notifier %pfw, sd fwnode %pfw\n",
135 dev_fwnode(notifier_dev(notifier)), sd->fwnode);
136
137 if (!list_empty(&sd->async_subdev_endpoint_list)) {
138 struct v4l2_async_subdev_endpoint *ase;
139
140 dev_dbg(sd->dev,
141 "v4l2-async: endpoint fwnode list available, looking for %pfw\n",
142 match->fwnode);
143
144 list_for_each_entry(ase, &sd->async_subdev_endpoint_list,
145 async_subdev_endpoint_entry) {
146 bool matched = ase->endpoint == match->fwnode;
147
148 dev_dbg(sd->dev,
149 "v4l2-async: endpoint-endpoint match %sfound with %pfw\n",
150 matched ? "" : "not ", ase->endpoint);
151
152 if (matched)
153 return true;
154 }
155
156 dev_dbg(sd->dev, "async: no endpoint matched\n");
157
158 return false;
159 }
160
161 if (match_fwnode_one(notifier, sd, sd->fwnode, match))
162 return true;
163
164 /* Also check the secondary fwnode. */
165 if (IS_ERR_OR_NULL(sd->fwnode->secondary))
166 return false;
167
168 dev_dbg(notifier_dev(notifier),
169 "v4l2-async: trying secondary fwnode match\n");
170
171 return match_fwnode_one(notifier, sd, sd->fwnode->secondary, match);
172 }
173
174 static LIST_HEAD(subdev_list);
175 static LIST_HEAD(notifier_list);
176 static DEFINE_MUTEX(list_lock);
177
178 static struct v4l2_async_connection *
v4l2_async_find_match(struct v4l2_async_notifier * notifier,struct v4l2_subdev * sd)179 v4l2_async_find_match(struct v4l2_async_notifier *notifier,
180 struct v4l2_subdev *sd)
181 {
182 bool (*match)(struct v4l2_async_notifier *notifier,
183 struct v4l2_subdev *sd,
184 struct v4l2_async_match_desc *match);
185 struct v4l2_async_connection *asc;
186
187 list_for_each_entry(asc, ¬ifier->waiting_list, asc_entry) {
188 /* bus_type has been verified valid before */
189 switch (asc->match.type) {
190 case V4L2_ASYNC_MATCH_TYPE_I2C:
191 match = match_i2c;
192 break;
193 case V4L2_ASYNC_MATCH_TYPE_FWNODE:
194 match = match_fwnode;
195 break;
196 default:
197 /* Cannot happen, unless someone breaks us */
198 WARN_ON(true);
199 return NULL;
200 }
201
202 /* match cannot be NULL here */
203 if (match(notifier, sd, &asc->match))
204 return asc;
205 }
206
207 return NULL;
208 }
209
210 /* Compare two async match descriptors for equivalence */
v4l2_async_match_equal(struct v4l2_async_match_desc * match1,struct v4l2_async_match_desc * match2)211 static bool v4l2_async_match_equal(struct v4l2_async_match_desc *match1,
212 struct v4l2_async_match_desc *match2)
213 {
214 if (match1->type != match2->type)
215 return false;
216
217 switch (match1->type) {
218 case V4L2_ASYNC_MATCH_TYPE_I2C:
219 return match1->i2c.adapter_id == match2->i2c.adapter_id &&
220 match1->i2c.address == match2->i2c.address;
221 case V4L2_ASYNC_MATCH_TYPE_FWNODE:
222 return match1->fwnode == match2->fwnode;
223 default:
224 break;
225 }
226
227 return false;
228 }
229
230 /* Find the sub-device notifier registered by a sub-device driver. */
231 static struct v4l2_async_notifier *
v4l2_async_find_subdev_notifier(struct v4l2_subdev * sd)232 v4l2_async_find_subdev_notifier(struct v4l2_subdev *sd)
233 {
234 struct v4l2_async_notifier *n;
235
236 list_for_each_entry(n, ¬ifier_list, notifier_entry)
237 if (n->sd == sd)
238 return n;
239
240 return NULL;
241 }
242
243 /* Get v4l2_device related to the notifier if one can be found. */
244 static struct v4l2_device *
v4l2_async_nf_find_v4l2_dev(struct v4l2_async_notifier * notifier)245 v4l2_async_nf_find_v4l2_dev(struct v4l2_async_notifier *notifier)
246 {
247 while (notifier->parent)
248 notifier = notifier->parent;
249
250 return notifier->v4l2_dev;
251 }
252
253 /*
254 * Return true if all child sub-device notifiers are complete, false otherwise.
255 */
256 static bool
v4l2_async_nf_can_complete(struct v4l2_async_notifier * notifier)257 v4l2_async_nf_can_complete(struct v4l2_async_notifier *notifier)
258 {
259 struct v4l2_async_connection *asc;
260
261 if (!list_empty(¬ifier->waiting_list))
262 return false;
263
264 list_for_each_entry(asc, ¬ifier->done_list, asc_entry) {
265 struct v4l2_async_notifier *subdev_notifier =
266 v4l2_async_find_subdev_notifier(asc->sd);
267
268 if (subdev_notifier &&
269 !v4l2_async_nf_can_complete(subdev_notifier))
270 return false;
271 }
272
273 return true;
274 }
275
276 /*
277 * Complete the master notifier if possible. This is done when all async
278 * sub-devices have been bound; v4l2_device is also available then.
279 */
280 static int
v4l2_async_nf_try_complete(struct v4l2_async_notifier * notifier)281 v4l2_async_nf_try_complete(struct v4l2_async_notifier *notifier)
282 {
283 struct v4l2_async_notifier *__notifier = notifier;
284
285 /* Quick check whether there are still more sub-devices here. */
286 if (!list_empty(¬ifier->waiting_list))
287 return 0;
288
289 if (notifier->sd)
290 dev_dbg(notifier_dev(notifier),
291 "v4l2-async: trying to complete\n");
292
293 /* Check the entire notifier tree; find the root notifier first. */
294 while (notifier->parent)
295 notifier = notifier->parent;
296
297 /* This is root if it has v4l2_dev. */
298 if (!notifier->v4l2_dev) {
299 dev_dbg(notifier_dev(__notifier),
300 "v4l2-async: V4L2 device not available\n");
301 return 0;
302 }
303
304 /* Is everything ready? */
305 if (!v4l2_async_nf_can_complete(notifier))
306 return 0;
307
308 dev_dbg(notifier_dev(__notifier), "v4l2-async: complete\n");
309
310 return v4l2_async_nf_call_complete(notifier);
311 }
312
313 static int
314 v4l2_async_nf_try_all_subdevs(struct v4l2_async_notifier *notifier);
315
v4l2_async_create_ancillary_links(struct v4l2_async_notifier * n,struct v4l2_subdev * sd)316 static int v4l2_async_create_ancillary_links(struct v4l2_async_notifier *n,
317 struct v4l2_subdev *sd)
318 {
319 struct media_link *link = NULL;
320
321 #if IS_ENABLED(CONFIG_MEDIA_CONTROLLER)
322
323 if (sd->entity.function != MEDIA_ENT_F_LENS &&
324 sd->entity.function != MEDIA_ENT_F_FLASH)
325 return 0;
326
327 link = media_create_ancillary_link(&n->sd->entity, &sd->entity);
328
329 #endif
330
331 return IS_ERR(link) ? PTR_ERR(link) : 0;
332 }
333
v4l2_async_match_notify(struct v4l2_async_notifier * notifier,struct v4l2_device * v4l2_dev,struct v4l2_subdev * sd,struct v4l2_async_connection * asc)334 static int v4l2_async_match_notify(struct v4l2_async_notifier *notifier,
335 struct v4l2_device *v4l2_dev,
336 struct v4l2_subdev *sd,
337 struct v4l2_async_connection *asc)
338 {
339 struct v4l2_async_notifier *subdev_notifier;
340 bool registered = false;
341 int ret;
342
343 if (list_empty(&sd->asc_list)) {
344 ret = v4l2_device_register_subdev(v4l2_dev, sd);
345 if (ret < 0)
346 return ret;
347 registered = true;
348 }
349
350 ret = v4l2_async_nf_call_bound(notifier, sd, asc);
351 if (ret < 0) {
352 if (asc->match.type == V4L2_ASYNC_MATCH_TYPE_FWNODE)
353 dev_dbg(notifier_dev(notifier),
354 "failed binding %pfw (%d)\n",
355 asc->match.fwnode, ret);
356 goto err_unregister_subdev;
357 }
358
359 if (registered) {
360 /*
361 * Depending of the function of the entities involved, we may
362 * want to create links between them (for example between a
363 * sensor and its lens or between a sensor's source pad and the
364 * connected device's sink pad).
365 */
366 ret = v4l2_async_create_ancillary_links(notifier, sd);
367 if (ret) {
368 if (asc->match.type == V4L2_ASYNC_MATCH_TYPE_FWNODE)
369 dev_dbg(notifier_dev(notifier),
370 "failed creating links for %pfw (%d)\n",
371 asc->match.fwnode, ret);
372 goto err_call_unbind;
373 }
374 }
375
376 list_add(&asc->asc_subdev_entry, &sd->asc_list);
377 asc->sd = sd;
378
379 /* Move from the waiting list to notifier's done */
380 list_move(&asc->asc_entry, ¬ifier->done_list);
381
382 dev_dbg(notifier_dev(notifier), "v4l2-async: %s bound (ret %d)\n",
383 dev_name(sd->dev), ret);
384
385 /*
386 * See if the sub-device has a notifier. If not, return here.
387 */
388 subdev_notifier = v4l2_async_find_subdev_notifier(sd);
389 if (!subdev_notifier || subdev_notifier->parent)
390 return 0;
391
392 /*
393 * Proceed with checking for the sub-device notifier's async
394 * sub-devices, and return the result. The error will be handled by the
395 * caller.
396 */
397 subdev_notifier->parent = notifier;
398
399 return v4l2_async_nf_try_all_subdevs(subdev_notifier);
400
401 err_call_unbind:
402 v4l2_async_nf_call_unbind(notifier, sd, asc);
403 list_del(&asc->asc_subdev_entry);
404
405 err_unregister_subdev:
406 if (registered)
407 v4l2_device_unregister_subdev(sd);
408
409 return ret;
410 }
411
412 /* Test all async sub-devices in a notifier for a match. */
413 static int
v4l2_async_nf_try_all_subdevs(struct v4l2_async_notifier * notifier)414 v4l2_async_nf_try_all_subdevs(struct v4l2_async_notifier *notifier)
415 {
416 struct v4l2_device *v4l2_dev =
417 v4l2_async_nf_find_v4l2_dev(notifier);
418 struct v4l2_subdev *sd;
419
420 if (!v4l2_dev)
421 return 0;
422
423 dev_dbg(notifier_dev(notifier), "v4l2-async: trying all sub-devices\n");
424
425 again:
426 list_for_each_entry(sd, &subdev_list, async_list) {
427 struct v4l2_async_connection *asc;
428 int ret;
429
430 asc = v4l2_async_find_match(notifier, sd);
431 if (!asc)
432 continue;
433
434 dev_dbg(notifier_dev(notifier),
435 "v4l2-async: match found, subdev %s\n", sd->name);
436
437 ret = v4l2_async_match_notify(notifier, v4l2_dev, sd, asc);
438 if (ret < 0)
439 return ret;
440
441 /*
442 * v4l2_async_match_notify() may lead to registering a
443 * new notifier and thus changing the async subdevs
444 * list. In order to proceed safely from here, restart
445 * parsing the list from the beginning.
446 */
447 goto again;
448 }
449
450 return 0;
451 }
452
v4l2_async_unbind_subdev_one(struct v4l2_async_notifier * notifier,struct v4l2_async_connection * asc)453 static void v4l2_async_unbind_subdev_one(struct v4l2_async_notifier *notifier,
454 struct v4l2_async_connection *asc)
455 {
456 list_move_tail(&asc->asc_entry, ¬ifier->waiting_list);
457 if (list_is_singular(&asc->asc_subdev_entry)) {
458 v4l2_async_nf_call_unbind(notifier, asc->sd, asc);
459 v4l2_device_unregister_subdev(asc->sd);
460 asc->sd = NULL;
461 }
462 list_del(&asc->asc_subdev_entry);
463 }
464
465 /* Unbind all sub-devices in the notifier tree. */
466 static void
v4l2_async_nf_unbind_all_subdevs(struct v4l2_async_notifier * notifier)467 v4l2_async_nf_unbind_all_subdevs(struct v4l2_async_notifier *notifier)
468 {
469 struct v4l2_async_connection *asc, *asc_tmp;
470
471 list_for_each_entry_safe(asc, asc_tmp, ¬ifier->done_list,
472 asc_entry) {
473 struct v4l2_async_notifier *subdev_notifier =
474 v4l2_async_find_subdev_notifier(asc->sd);
475
476 if (subdev_notifier)
477 v4l2_async_nf_unbind_all_subdevs(subdev_notifier);
478
479 v4l2_async_unbind_subdev_one(notifier, asc);
480 }
481
482 notifier->parent = NULL;
483 }
484
485 /* See if an async sub-device can be found in a notifier's lists. */
486 static bool
v4l2_async_nf_has_async_match_entry(struct v4l2_async_notifier * notifier,struct v4l2_async_match_desc * match)487 v4l2_async_nf_has_async_match_entry(struct v4l2_async_notifier *notifier,
488 struct v4l2_async_match_desc *match)
489 {
490 struct v4l2_async_connection *asc;
491
492 list_for_each_entry(asc, ¬ifier->waiting_list, asc_entry)
493 if (v4l2_async_match_equal(&asc->match, match))
494 return true;
495
496 list_for_each_entry(asc, ¬ifier->done_list, asc_entry)
497 if (v4l2_async_match_equal(&asc->match, match))
498 return true;
499
500 return false;
501 }
502
503 /*
504 * Find out whether an async sub-device was set up already or whether it exists
505 * in a given notifier.
506 */
507 static bool
v4l2_async_nf_has_async_match(struct v4l2_async_notifier * notifier,struct v4l2_async_match_desc * match)508 v4l2_async_nf_has_async_match(struct v4l2_async_notifier *notifier,
509 struct v4l2_async_match_desc *match)
510 {
511 struct list_head *heads[] = {
512 ¬ifier->waiting_list,
513 ¬ifier->done_list,
514 };
515 unsigned int i;
516
517 lockdep_assert_held(&list_lock);
518
519 /* Check that an asd is not being added more than once. */
520 for (i = 0; i < ARRAY_SIZE(heads); i++) {
521 struct v4l2_async_connection *asc;
522
523 list_for_each_entry(asc, heads[i], asc_entry) {
524 if (&asc->match == match)
525 continue;
526 if (v4l2_async_match_equal(&asc->match, match))
527 return true;
528 }
529 }
530
531 /* Check that an asc does not exist in other notifiers. */
532 list_for_each_entry(notifier, ¬ifier_list, notifier_entry)
533 if (v4l2_async_nf_has_async_match_entry(notifier, match))
534 return true;
535
536 return false;
537 }
538
v4l2_async_nf_match_valid(struct v4l2_async_notifier * notifier,struct v4l2_async_match_desc * match)539 static int v4l2_async_nf_match_valid(struct v4l2_async_notifier *notifier,
540 struct v4l2_async_match_desc *match)
541 {
542 struct device *dev = notifier_dev(notifier);
543
544 switch (match->type) {
545 case V4L2_ASYNC_MATCH_TYPE_I2C:
546 case V4L2_ASYNC_MATCH_TYPE_FWNODE:
547 if (v4l2_async_nf_has_async_match(notifier, match)) {
548 dev_dbg(dev, "v4l2-async: match descriptor already listed in a notifier\n");
549 return -EEXIST;
550 }
551 break;
552 default:
553 dev_err(dev, "v4l2-async: Invalid match type %u on %p\n",
554 match->type, match);
555 return -EINVAL;
556 }
557
558 return 0;
559 }
560
v4l2_async_nf_init(struct v4l2_async_notifier * notifier,struct v4l2_device * v4l2_dev)561 void v4l2_async_nf_init(struct v4l2_async_notifier *notifier,
562 struct v4l2_device *v4l2_dev)
563 {
564 INIT_LIST_HEAD(¬ifier->waiting_list);
565 INIT_LIST_HEAD(¬ifier->done_list);
566 INIT_LIST_HEAD(¬ifier->notifier_entry);
567 notifier->v4l2_dev = v4l2_dev;
568 }
569 EXPORT_SYMBOL(v4l2_async_nf_init);
570
v4l2_async_subdev_nf_init(struct v4l2_async_notifier * notifier,struct v4l2_subdev * sd)571 void v4l2_async_subdev_nf_init(struct v4l2_async_notifier *notifier,
572 struct v4l2_subdev *sd)
573 {
574 INIT_LIST_HEAD(¬ifier->waiting_list);
575 INIT_LIST_HEAD(¬ifier->done_list);
576 INIT_LIST_HEAD(¬ifier->notifier_entry);
577 notifier->sd = sd;
578 }
579 EXPORT_SYMBOL_GPL(v4l2_async_subdev_nf_init);
580
__v4l2_async_nf_register(struct v4l2_async_notifier * notifier)581 static int __v4l2_async_nf_register(struct v4l2_async_notifier *notifier)
582 {
583 struct v4l2_async_connection *asc;
584 int ret;
585
586 mutex_lock(&list_lock);
587
588 list_for_each_entry(asc, ¬ifier->waiting_list, asc_entry) {
589 ret = v4l2_async_nf_match_valid(notifier, &asc->match);
590 if (ret)
591 goto err_unlock;
592 }
593
594 ret = v4l2_async_nf_try_all_subdevs(notifier);
595 if (ret < 0)
596 goto err_unbind;
597
598 ret = v4l2_async_nf_try_complete(notifier);
599 if (ret < 0)
600 goto err_unbind;
601
602 /* Keep also completed notifiers on the list */
603 list_add(¬ifier->notifier_entry, ¬ifier_list);
604
605 mutex_unlock(&list_lock);
606
607 return 0;
608
609 err_unbind:
610 /*
611 * On failure, unbind all sub-devices registered through this notifier.
612 */
613 v4l2_async_nf_unbind_all_subdevs(notifier);
614
615 err_unlock:
616 mutex_unlock(&list_lock);
617
618 return ret;
619 }
620
v4l2_async_nf_register(struct v4l2_async_notifier * notifier)621 int v4l2_async_nf_register(struct v4l2_async_notifier *notifier)
622 {
623 if (WARN_ON(!notifier->v4l2_dev == !notifier->sd))
624 return -EINVAL;
625
626 return __v4l2_async_nf_register(notifier);
627 }
628 EXPORT_SYMBOL(v4l2_async_nf_register);
629
630 static void
__v4l2_async_nf_unregister(struct v4l2_async_notifier * notifier)631 __v4l2_async_nf_unregister(struct v4l2_async_notifier *notifier)
632 {
633 if (!notifier || (!notifier->v4l2_dev && !notifier->sd))
634 return;
635
636 v4l2_async_nf_unbind_all_subdevs(notifier);
637
638 list_del_init(¬ifier->notifier_entry);
639 }
640
v4l2_async_nf_unregister(struct v4l2_async_notifier * notifier)641 void v4l2_async_nf_unregister(struct v4l2_async_notifier *notifier)
642 {
643 mutex_lock(&list_lock);
644
645 __v4l2_async_nf_unregister(notifier);
646
647 mutex_unlock(&list_lock);
648 }
649 EXPORT_SYMBOL(v4l2_async_nf_unregister);
650
__v4l2_async_nf_cleanup(struct v4l2_async_notifier * notifier)651 static void __v4l2_async_nf_cleanup(struct v4l2_async_notifier *notifier)
652 {
653 struct v4l2_async_connection *asc, *tmp;
654
655 if (!notifier || !notifier->waiting_list.next)
656 return;
657
658 WARN_ON(!list_empty(¬ifier->done_list));
659
660 list_for_each_entry_safe(asc, tmp, ¬ifier->waiting_list, asc_entry) {
661 list_del(&asc->asc_entry);
662 v4l2_async_nf_call_destroy(notifier, asc);
663
664 if (asc->match.type == V4L2_ASYNC_MATCH_TYPE_FWNODE)
665 fwnode_handle_put(asc->match.fwnode);
666
667 kfree(asc);
668 }
669
670 notifier->sd = NULL;
671 notifier->v4l2_dev = NULL;
672 }
673
v4l2_async_nf_cleanup(struct v4l2_async_notifier * notifier)674 void v4l2_async_nf_cleanup(struct v4l2_async_notifier *notifier)
675 {
676 mutex_lock(&list_lock);
677
678 __v4l2_async_nf_cleanup(notifier);
679
680 mutex_unlock(&list_lock);
681 }
682 EXPORT_SYMBOL_GPL(v4l2_async_nf_cleanup);
683
__v4l2_async_nf_add_connection(struct v4l2_async_notifier * notifier,struct v4l2_async_connection * asc)684 static void __v4l2_async_nf_add_connection(struct v4l2_async_notifier *notifier,
685 struct v4l2_async_connection *asc)
686 {
687 mutex_lock(&list_lock);
688
689 list_add_tail(&asc->asc_entry, ¬ifier->waiting_list);
690
691 mutex_unlock(&list_lock);
692 }
693
694 struct v4l2_async_connection *
__v4l2_async_nf_add_fwnode(struct v4l2_async_notifier * notifier,struct fwnode_handle * fwnode,unsigned int asc_struct_size)695 __v4l2_async_nf_add_fwnode(struct v4l2_async_notifier *notifier,
696 struct fwnode_handle *fwnode,
697 unsigned int asc_struct_size)
698 {
699 struct v4l2_async_connection *asc;
700
701 asc = kzalloc(asc_struct_size, GFP_KERNEL);
702 if (!asc)
703 return ERR_PTR(-ENOMEM);
704
705 asc->notifier = notifier;
706 asc->match.type = V4L2_ASYNC_MATCH_TYPE_FWNODE;
707 asc->match.fwnode = fwnode_handle_get(fwnode);
708
709 __v4l2_async_nf_add_connection(notifier, asc);
710
711 return asc;
712 }
713 EXPORT_SYMBOL_GPL(__v4l2_async_nf_add_fwnode);
714
715 struct v4l2_async_connection *
__v4l2_async_nf_add_fwnode_remote(struct v4l2_async_notifier * notif,struct fwnode_handle * endpoint,unsigned int asc_struct_size)716 __v4l2_async_nf_add_fwnode_remote(struct v4l2_async_notifier *notif,
717 struct fwnode_handle *endpoint,
718 unsigned int asc_struct_size)
719 {
720 struct v4l2_async_connection *asc;
721 struct fwnode_handle *remote;
722
723 remote = fwnode_graph_get_remote_endpoint(endpoint);
724 if (!remote)
725 return ERR_PTR(-ENOTCONN);
726
727 asc = __v4l2_async_nf_add_fwnode(notif, remote, asc_struct_size);
728 /*
729 * Calling __v4l2_async_nf_add_fwnode grabs a refcount,
730 * so drop the one we got in fwnode_graph_get_remote_port_parent.
731 */
732 fwnode_handle_put(remote);
733 return asc;
734 }
735 EXPORT_SYMBOL_GPL(__v4l2_async_nf_add_fwnode_remote);
736
737 struct v4l2_async_connection *
__v4l2_async_nf_add_i2c(struct v4l2_async_notifier * notifier,int adapter_id,unsigned short address,unsigned int asc_struct_size)738 __v4l2_async_nf_add_i2c(struct v4l2_async_notifier *notifier, int adapter_id,
739 unsigned short address, unsigned int asc_struct_size)
740 {
741 struct v4l2_async_connection *asc;
742
743 asc = kzalloc(asc_struct_size, GFP_KERNEL);
744 if (!asc)
745 return ERR_PTR(-ENOMEM);
746
747 asc->notifier = notifier;
748 asc->match.type = V4L2_ASYNC_MATCH_TYPE_I2C;
749 asc->match.i2c.adapter_id = adapter_id;
750 asc->match.i2c.address = address;
751
752 __v4l2_async_nf_add_connection(notifier, asc);
753
754 return asc;
755 }
756 EXPORT_SYMBOL_GPL(__v4l2_async_nf_add_i2c);
757
v4l2_async_subdev_endpoint_add(struct v4l2_subdev * sd,struct fwnode_handle * fwnode)758 int v4l2_async_subdev_endpoint_add(struct v4l2_subdev *sd,
759 struct fwnode_handle *fwnode)
760 {
761 struct v4l2_async_subdev_endpoint *ase;
762
763 ase = kmalloc(sizeof(*ase), GFP_KERNEL);
764 if (!ase)
765 return -ENOMEM;
766
767 ase->endpoint = fwnode;
768 list_add(&ase->async_subdev_endpoint_entry,
769 &sd->async_subdev_endpoint_list);
770
771 return 0;
772 }
773 EXPORT_SYMBOL_GPL(v4l2_async_subdev_endpoint_add);
774
775 struct v4l2_async_connection *
v4l2_async_connection_unique(struct v4l2_subdev * sd)776 v4l2_async_connection_unique(struct v4l2_subdev *sd)
777 {
778 if (!list_is_singular(&sd->asc_list))
779 return NULL;
780
781 return list_first_entry(&sd->asc_list,
782 struct v4l2_async_connection, asc_subdev_entry);
783 }
784 EXPORT_SYMBOL_GPL(v4l2_async_connection_unique);
785
v4l2_async_register_subdev(struct v4l2_subdev * sd)786 int v4l2_async_register_subdev(struct v4l2_subdev *sd)
787 {
788 struct v4l2_async_notifier *subdev_notifier;
789 struct v4l2_async_notifier *notifier;
790 struct v4l2_async_connection *asc;
791 int ret;
792
793 INIT_LIST_HEAD(&sd->asc_list);
794
795 /*
796 * No reference taken. The reference is held by the device (struct
797 * v4l2_subdev.dev), and async sub-device does not exist independently
798 * of the device at any point of time.
799 *
800 * The async sub-device shall always be registered for its device node,
801 * not the endpoint node.
802 */
803 if (!sd->fwnode && sd->dev) {
804 sd->fwnode = dev_fwnode(sd->dev);
805 } else if (fwnode_graph_is_endpoint(sd->fwnode)) {
806 dev_warn(sd->dev, "sub-device fwnode is an endpoint!\n");
807 return -EINVAL;
808 }
809
810 mutex_lock(&list_lock);
811
812 list_for_each_entry(notifier, ¬ifier_list, notifier_entry) {
813 struct v4l2_device *v4l2_dev =
814 v4l2_async_nf_find_v4l2_dev(notifier);
815
816 if (!v4l2_dev)
817 continue;
818
819 while ((asc = v4l2_async_find_match(notifier, sd))) {
820 ret = v4l2_async_match_notify(notifier, v4l2_dev, sd,
821 asc);
822 if (ret)
823 goto err_unbind;
824
825 ret = v4l2_async_nf_try_complete(notifier);
826 if (ret)
827 goto err_unbind;
828 }
829 }
830
831 /* None matched, wait for hot-plugging */
832 list_add(&sd->async_list, &subdev_list);
833
834 mutex_unlock(&list_lock);
835
836 return 0;
837
838 err_unbind:
839 /*
840 * Complete failed. Unbind the sub-devices bound through registering
841 * this async sub-device.
842 */
843 subdev_notifier = v4l2_async_find_subdev_notifier(sd);
844 if (subdev_notifier)
845 v4l2_async_nf_unbind_all_subdevs(subdev_notifier);
846
847 if (asc)
848 v4l2_async_unbind_subdev_one(notifier, asc);
849
850 mutex_unlock(&list_lock);
851
852 return ret;
853 }
854 EXPORT_SYMBOL(v4l2_async_register_subdev);
855
v4l2_async_unregister_subdev(struct v4l2_subdev * sd)856 void v4l2_async_unregister_subdev(struct v4l2_subdev *sd)
857 {
858 struct v4l2_async_connection *asc, *asc_tmp;
859
860 if (!sd->async_list.next)
861 return;
862
863 v4l2_subdev_put_privacy_led(sd);
864
865 mutex_lock(&list_lock);
866
867 __v4l2_async_nf_unregister(sd->subdev_notifier);
868 __v4l2_async_nf_cleanup(sd->subdev_notifier);
869 kfree(sd->subdev_notifier);
870 sd->subdev_notifier = NULL;
871
872 if (sd->asc_list.next) {
873 list_for_each_entry_safe(asc, asc_tmp, &sd->asc_list,
874 asc_subdev_entry) {
875 list_move(&asc->asc_entry,
876 &asc->notifier->waiting_list);
877
878 v4l2_async_unbind_subdev_one(asc->notifier, asc);
879 }
880 }
881
882 list_del(&sd->async_list);
883 sd->async_list.next = NULL;
884
885 mutex_unlock(&list_lock);
886 }
887 EXPORT_SYMBOL(v4l2_async_unregister_subdev);
888
print_waiting_match(struct seq_file * s,struct v4l2_async_match_desc * match)889 static void print_waiting_match(struct seq_file *s,
890 struct v4l2_async_match_desc *match)
891 {
892 switch (match->type) {
893 case V4L2_ASYNC_MATCH_TYPE_I2C:
894 seq_printf(s, " [i2c] dev=%d-%04x\n", match->i2c.adapter_id,
895 match->i2c.address);
896 break;
897 case V4L2_ASYNC_MATCH_TYPE_FWNODE: {
898 struct fwnode_handle *devnode, *fwnode = match->fwnode;
899
900 devnode = fwnode_graph_is_endpoint(fwnode) ?
901 fwnode_graph_get_port_parent(fwnode) :
902 fwnode_handle_get(fwnode);
903
904 seq_printf(s, " [fwnode] dev=%s, node=%pfw\n",
905 devnode->dev ? dev_name(devnode->dev) : "nil",
906 fwnode);
907
908 fwnode_handle_put(devnode);
909 break;
910 }
911 }
912 }
913
914 static const char *
v4l2_async_nf_name(struct v4l2_async_notifier * notifier)915 v4l2_async_nf_name(struct v4l2_async_notifier *notifier)
916 {
917 if (notifier->v4l2_dev)
918 return notifier->v4l2_dev->name;
919 else if (notifier->sd)
920 return notifier->sd->name;
921 else
922 return "nil";
923 }
924
pending_subdevs_show(struct seq_file * s,void * data)925 static int pending_subdevs_show(struct seq_file *s, void *data)
926 {
927 struct v4l2_async_notifier *notif;
928 struct v4l2_async_connection *asc;
929
930 mutex_lock(&list_lock);
931
932 list_for_each_entry(notif, ¬ifier_list, notifier_entry) {
933 seq_printf(s, "%s:\n", v4l2_async_nf_name(notif));
934 list_for_each_entry(asc, ¬if->waiting_list, asc_entry)
935 print_waiting_match(s, &asc->match);
936 }
937
938 mutex_unlock(&list_lock);
939
940 return 0;
941 }
942 DEFINE_SHOW_ATTRIBUTE(pending_subdevs);
943
944 static struct dentry *v4l2_async_debugfs_dir;
945
v4l2_async_init(void)946 static int __init v4l2_async_init(void)
947 {
948 v4l2_async_debugfs_dir = debugfs_create_dir("v4l2-async", NULL);
949 debugfs_create_file("pending_async_subdevices", 0444,
950 v4l2_async_debugfs_dir, NULL,
951 &pending_subdevs_fops);
952
953 return 0;
954 }
955
v4l2_async_exit(void)956 static void __exit v4l2_async_exit(void)
957 {
958 debugfs_remove_recursive(v4l2_async_debugfs_dir);
959 }
960
961 subsys_initcall(v4l2_async_init);
962 module_exit(v4l2_async_exit);
963
964 MODULE_AUTHOR("Guennadi Liakhovetski <g.liakhovetski@gmx.de>");
965 MODULE_AUTHOR("Sakari Ailus <sakari.ailus@linux.intel.com>");
966 MODULE_AUTHOR("Ezequiel Garcia <ezequiel@collabora.com>");
967 MODULE_LICENSE("GPL");
968