blob: 7925875d09b76b83d49905f116812d818ac410be [file] [log] [blame]
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -03001/*
2 * V4L2 asynchronous subdevice registration API
3 *
4 * Copyright (C) 2012-2013, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 */
10
11#include <linux/device.h>
12#include <linux/err.h>
13#include <linux/i2c.h>
14#include <linux/list.h>
Tomasz Figa758d90e2017-06-19 00:53:43 -030015#include <linux/mm.h>
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -030016#include <linux/module.h>
17#include <linux/mutex.h>
Sakari Ailusecdf0cf2016-08-16 06:54:59 -030018#include <linux/of.h>
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -030019#include <linux/platform_device.h>
20#include <linux/slab.h>
21#include <linux/types.h>
22
23#include <media/v4l2-async.h>
24#include <media/v4l2-device.h>
Sakari Ailus9ca46532017-08-17 11:28:21 -040025#include <media/v4l2-fwnode.h>
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -030026#include <media/v4l2-subdev.h>
27
Sakari Ailusddddc182017-09-01 08:27:32 -040028static int v4l2_async_notifier_call_bound(struct v4l2_async_notifier *n,
29 struct v4l2_subdev *subdev,
30 struct v4l2_async_subdev *asd)
31{
32 if (!n->ops || !n->ops->bound)
33 return 0;
34
35 return n->ops->bound(n, subdev, asd);
36}
37
38static void v4l2_async_notifier_call_unbind(struct v4l2_async_notifier *n,
39 struct v4l2_subdev *subdev,
40 struct v4l2_async_subdev *asd)
41{
42 if (!n->ops || !n->ops->unbind)
43 return;
44
45 n->ops->unbind(n, subdev, asd);
46}
47
48static int v4l2_async_notifier_call_complete(struct v4l2_async_notifier *n)
49{
50 if (!n->ops || !n->ops->complete)
51 return 0;
52
53 return n->ops->complete(n);
54}
55
Sakari Ailus86217652015-06-11 12:18:01 -070056static bool match_i2c(struct v4l2_subdev *sd, struct v4l2_async_subdev *asd)
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -030057{
Guennadi Liakhovetskife05e142013-06-24 05:13:51 -030058#if IS_ENABLED(CONFIG_I2C)
Sakari Ailus86217652015-06-11 12:18:01 -070059 struct i2c_client *client = i2c_verify_client(sd->dev);
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -030060 return client &&
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -030061 asd->match.i2c.adapter_id == client->adapter->nr &&
62 asd->match.i2c.address == client->addr;
Guennadi Liakhovetskife05e142013-06-24 05:13:51 -030063#else
64 return false;
65#endif
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -030066}
67
Sakari Ailus86217652015-06-11 12:18:01 -070068static bool match_devname(struct v4l2_subdev *sd,
69 struct v4l2_async_subdev *asd)
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -030070{
Mauro Carvalho Chehab4e48afe2017-09-27 10:12:00 -040071 return !strcmp(asd->match.device_name, dev_name(sd->dev));
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -030072}
73
Sakari Ailusecdf0cf2016-08-16 06:54:59 -030074static bool match_fwnode(struct v4l2_subdev *sd, struct v4l2_async_subdev *asd)
75{
Mauro Carvalho Chehab4e48afe2017-09-27 10:12:00 -040076 return sd->fwnode == asd->match.fwnode;
Sakari Ailusecdf0cf2016-08-16 06:54:59 -030077}
78
Sakari Ailus86217652015-06-11 12:18:01 -070079static bool match_custom(struct v4l2_subdev *sd, struct v4l2_async_subdev *asd)
80{
81 if (!asd->match.custom.match)
82 /* Match always */
83 return true;
84
85 return asd->match.custom.match(sd->dev, asd);
Sylwester Nawrockie7359f82013-07-19 12:21:29 -030086}
87
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -030088static LIST_HEAD(subdev_list);
89static LIST_HEAD(notifier_list);
90static DEFINE_MUTEX(list_lock);
91
Sakari Ailusc8114d92017-09-04 12:44:39 -040092static struct v4l2_async_subdev *v4l2_async_find_match(
93 struct v4l2_async_notifier *notifier, struct v4l2_subdev *sd)
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -030094{
Sakari Ailus86217652015-06-11 12:18:01 -070095 bool (*match)(struct v4l2_subdev *, struct v4l2_async_subdev *);
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -030096 struct v4l2_async_subdev *asd;
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -030097
98 list_for_each_entry(asd, &notifier->waiting, list) {
99 /* bus_type has been verified valid before */
Sylwester Nawrockicfca7642013-07-19 12:14:46 -0300100 switch (asd->match_type) {
101 case V4L2_ASYNC_MATCH_CUSTOM:
Sakari Ailus86217652015-06-11 12:18:01 -0700102 match = match_custom;
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300103 break;
Sylwester Nawrockicfca7642013-07-19 12:14:46 -0300104 case V4L2_ASYNC_MATCH_DEVNAME:
105 match = match_devname;
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300106 break;
Sylwester Nawrockicfca7642013-07-19 12:14:46 -0300107 case V4L2_ASYNC_MATCH_I2C:
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300108 match = match_i2c;
109 break;
Sakari Ailusecdf0cf2016-08-16 06:54:59 -0300110 case V4L2_ASYNC_MATCH_FWNODE:
111 match = match_fwnode;
112 break;
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300113 default:
114 /* Cannot happen, unless someone breaks us */
115 WARN_ON(true);
116 return NULL;
117 }
118
119 /* match cannot be NULL here */
Sakari Ailus86217652015-06-11 12:18:01 -0700120 if (match(sd, asd))
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300121 return asd;
122 }
123
124 return NULL;
125}
126
Steve Longerbeama6e70032018-09-29 15:54:05 -0400127/* Compare two async sub-device descriptors for equivalence */
128static bool asd_equal(struct v4l2_async_subdev *asd_x,
129 struct v4l2_async_subdev *asd_y)
130{
131 if (asd_x->match_type != asd_y->match_type)
132 return false;
133
134 switch (asd_x->match_type) {
135 case V4L2_ASYNC_MATCH_DEVNAME:
136 return strcmp(asd_x->match.device_name,
137 asd_y->match.device_name) == 0;
138 case V4L2_ASYNC_MATCH_I2C:
139 return asd_x->match.i2c.adapter_id ==
140 asd_y->match.i2c.adapter_id &&
141 asd_x->match.i2c.address ==
142 asd_y->match.i2c.address;
143 case V4L2_ASYNC_MATCH_FWNODE:
144 return asd_x->match.fwnode == asd_y->match.fwnode;
145 default:
146 break;
147 }
148
149 return false;
150}
151
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400152/* Find the sub-device notifier registered by a sub-device driver. */
153static struct v4l2_async_notifier *v4l2_async_find_subdev_notifier(
154 struct v4l2_subdev *sd)
155{
156 struct v4l2_async_notifier *n;
157
158 list_for_each_entry(n, &notifier_list, list)
159 if (n->sd == sd)
160 return n;
161
162 return NULL;
163}
164
165/* Get v4l2_device related to the notifier if one can be found. */
166static struct v4l2_device *v4l2_async_notifier_find_v4l2_dev(
167 struct v4l2_async_notifier *notifier)
168{
169 while (notifier->parent)
170 notifier = notifier->parent;
171
172 return notifier->v4l2_dev;
173}
174
175/*
176 * Return true if all child sub-device notifiers are complete, false otherwise.
177 */
178static bool v4l2_async_notifier_can_complete(
179 struct v4l2_async_notifier *notifier)
180{
181 struct v4l2_subdev *sd;
182
183 if (!list_empty(&notifier->waiting))
184 return false;
185
186 list_for_each_entry(sd, &notifier->done, async_list) {
187 struct v4l2_async_notifier *subdev_notifier =
188 v4l2_async_find_subdev_notifier(sd);
189
190 if (subdev_notifier &&
191 !v4l2_async_notifier_can_complete(subdev_notifier))
192 return false;
193 }
194
195 return true;
196}
197
198/*
199 * Complete the master notifier if possible. This is done when all async
200 * sub-devices have been bound; v4l2_device is also available then.
201 */
202static int v4l2_async_notifier_try_complete(
203 struct v4l2_async_notifier *notifier)
204{
205 /* Quick check whether there are still more sub-devices here. */
206 if (!list_empty(&notifier->waiting))
207 return 0;
208
209 /* Check the entire notifier tree; find the root notifier first. */
210 while (notifier->parent)
211 notifier = notifier->parent;
212
213 /* This is root if it has v4l2_dev. */
214 if (!notifier->v4l2_dev)
215 return 0;
216
217 /* Is everything ready? */
218 if (!v4l2_async_notifier_can_complete(notifier))
219 return 0;
220
221 return v4l2_async_notifier_call_complete(notifier);
222}
223
224static int v4l2_async_notifier_try_all_subdevs(
225 struct v4l2_async_notifier *notifier);
226
Sakari Ailusc8114d92017-09-04 12:44:39 -0400227static int v4l2_async_match_notify(struct v4l2_async_notifier *notifier,
Sakari Ailusa3620cb2017-09-24 20:48:08 -0400228 struct v4l2_device *v4l2_dev,
Sakari Ailusc8114d92017-09-04 12:44:39 -0400229 struct v4l2_subdev *sd,
230 struct v4l2_async_subdev *asd)
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300231{
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400232 struct v4l2_async_notifier *subdev_notifier;
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300233 int ret;
234
Sakari Ailusa3620cb2017-09-24 20:48:08 -0400235 ret = v4l2_device_register_subdev(v4l2_dev, sd);
Sakari Ailusddddc182017-09-01 08:27:32 -0400236 if (ret < 0)
237 return ret;
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300238
Sakari Ailus24def9b2017-07-17 10:04:20 -0400239 ret = v4l2_async_notifier_call_bound(notifier, sd, asd);
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300240 if (ret < 0) {
Sakari Ailus24def9b2017-07-17 10:04:20 -0400241 v4l2_device_unregister_subdev(sd);
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300242 return ret;
243 }
244
Tuukka Toivonen47b037a2017-01-27 08:32:56 -0200245 /* Remove from the waiting list */
246 list_del(&asd->list);
247 sd->asd = asd;
248 sd->notifier = notifier;
249
250 /* Move from the global subdevice list to notifier's done */
251 list_move(&sd->async_list, &notifier->done);
252
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400253 /*
254 * See if the sub-device has a notifier. If not, return here.
255 */
256 subdev_notifier = v4l2_async_find_subdev_notifier(sd);
257 if (!subdev_notifier || subdev_notifier->parent)
258 return 0;
259
260 /*
261 * Proceed with checking for the sub-device notifier's async
262 * sub-devices, and return the result. The error will be handled by the
263 * caller.
264 */
265 subdev_notifier->parent = notifier;
266
267 return v4l2_async_notifier_try_all_subdevs(subdev_notifier);
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300268}
269
Sakari Ailusa3620cb2017-09-24 20:48:08 -0400270/* Test all async sub-devices in a notifier for a match. */
271static int v4l2_async_notifier_try_all_subdevs(
272 struct v4l2_async_notifier *notifier)
273{
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400274 struct v4l2_device *v4l2_dev =
275 v4l2_async_notifier_find_v4l2_dev(notifier);
276 struct v4l2_subdev *sd;
Sakari Ailusa3620cb2017-09-24 20:48:08 -0400277
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400278 if (!v4l2_dev)
279 return 0;
280
281again:
282 list_for_each_entry(sd, &subdev_list, async_list) {
Sakari Ailusa3620cb2017-09-24 20:48:08 -0400283 struct v4l2_async_subdev *asd;
284 int ret;
285
286 asd = v4l2_async_find_match(notifier, sd);
287 if (!asd)
288 continue;
289
290 ret = v4l2_async_match_notify(notifier, v4l2_dev, sd, asd);
291 if (ret < 0)
292 return ret;
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400293
294 /*
295 * v4l2_async_match_notify() may lead to registering a
296 * new notifier and thus changing the async subdevs
297 * list. In order to proceed safely from here, restart
298 * parsing the list from the beginning.
299 */
300 goto again;
Sakari Ailusa3620cb2017-09-24 20:48:08 -0400301 }
302
303 return 0;
304}
305
Sylwester Nawrockib426b3a2013-07-22 08:01:33 -0300306static void v4l2_async_cleanup(struct v4l2_subdev *sd)
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300307{
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300308 v4l2_device_unregister_subdev(sd);
Sylwester Nawrockib426b3a2013-07-22 08:01:33 -0300309 /* Subdevice driver will reprobe and put the subdev back onto the list */
310 list_del_init(&sd->async_list);
311 sd->asd = NULL;
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300312}
313
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400314/* Unbind all sub-devices in the notifier tree. */
Sakari Ailusfb45f432017-10-02 06:24:54 -0400315static void v4l2_async_notifier_unbind_all_subdevs(
316 struct v4l2_async_notifier *notifier)
317{
318 struct v4l2_subdev *sd, *tmp;
319
320 list_for_each_entry_safe(sd, tmp, &notifier->done, async_list) {
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400321 struct v4l2_async_notifier *subdev_notifier =
322 v4l2_async_find_subdev_notifier(sd);
323
324 if (subdev_notifier)
325 v4l2_async_notifier_unbind_all_subdevs(subdev_notifier);
326
Sakari Ailusddddc182017-09-01 08:27:32 -0400327 v4l2_async_notifier_call_unbind(notifier, sd, sd->asd);
Sakari Ailusfb45f432017-10-02 06:24:54 -0400328 v4l2_async_cleanup(sd);
329
330 list_move(&sd->async_list, &subdev_list);
331 }
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400332
333 notifier->parent = NULL;
Sakari Ailusfb45f432017-10-02 06:24:54 -0400334}
335
Steve Longerbeama6e70032018-09-29 15:54:05 -0400336/* See if an async sub-device can be found in a notifier's lists. */
337static bool
338__v4l2_async_notifier_has_async_subdev(struct v4l2_async_notifier *notifier,
339 struct v4l2_async_subdev *asd)
Sakari Ailus466cae62017-09-20 03:51:54 -0400340{
Steve Longerbeama6e70032018-09-29 15:54:05 -0400341 struct v4l2_async_subdev *asd_y;
Sakari Ailus466cae62017-09-20 03:51:54 -0400342 struct v4l2_subdev *sd;
343
Steve Longerbeama6e70032018-09-29 15:54:05 -0400344 list_for_each_entry(asd_y, &notifier->waiting, list)
345 if (asd_equal(asd, asd_y))
Sakari Ailus466cae62017-09-20 03:51:54 -0400346 return true;
Sakari Ailus466cae62017-09-20 03:51:54 -0400347
348 list_for_each_entry(sd, &notifier->done, async_list) {
349 if (WARN_ON(!sd->asd))
350 continue;
351
Steve Longerbeama6e70032018-09-29 15:54:05 -0400352 if (asd_equal(asd, sd->asd))
Sakari Ailus466cae62017-09-20 03:51:54 -0400353 return true;
354 }
355
356 return false;
357}
358
359/*
Steve Longerbeama6e70032018-09-29 15:54:05 -0400360 * Find out whether an async sub-device was set up already or
Sakari Ailus466cae62017-09-20 03:51:54 -0400361 * whether it exists in a given notifier before @this_index.
362 */
Steve Longerbeama6e70032018-09-29 15:54:05 -0400363static bool
364v4l2_async_notifier_has_async_subdev(struct v4l2_async_notifier *notifier,
365 struct v4l2_async_subdev *asd,
366 unsigned int this_index)
Sakari Ailus466cae62017-09-20 03:51:54 -0400367{
Steve Longerbeamb47d7ff2018-09-29 15:54:06 -0400368 struct v4l2_async_subdev *asd_y;
Sakari Ailus466cae62017-09-20 03:51:54 -0400369 unsigned int j;
370
371 lockdep_assert_held(&list_lock);
372
Steve Longerbeama6e70032018-09-29 15:54:05 -0400373 /* Check that an asd is not being added more than once. */
Steve Longerbeamb47d7ff2018-09-29 15:54:06 -0400374 if (notifier->subdevs) {
375 for (j = 0; j < this_index; j++) {
376 asd_y = notifier->subdevs[j];
377 if (asd_equal(asd, asd_y))
378 return true;
379 }
380 } else {
381 j = 0;
382 list_for_each_entry(asd_y, &notifier->asd_list, asd_list) {
383 if (j++ >= this_index)
384 break;
385 if (asd_equal(asd, asd_y))
386 return true;
387 }
Sakari Ailus466cae62017-09-20 03:51:54 -0400388 }
389
Steve Longerbeama6e70032018-09-29 15:54:05 -0400390 /* Check that an asd does not exist in other notifiers. */
Sakari Ailus466cae62017-09-20 03:51:54 -0400391 list_for_each_entry(notifier, &notifier_list, list)
Steve Longerbeama6e70032018-09-29 15:54:05 -0400392 if (__v4l2_async_notifier_has_async_subdev(notifier, asd))
Sakari Ailus466cae62017-09-20 03:51:54 -0400393 return true;
394
395 return false;
396}
397
Steve Longerbeamb47d7ff2018-09-29 15:54:06 -0400398static int v4l2_async_notifier_asd_valid(struct v4l2_async_notifier *notifier,
399 struct v4l2_async_subdev *asd,
400 unsigned int this_index)
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300401{
Sakari Ailus466cae62017-09-20 03:51:54 -0400402 struct device *dev =
403 notifier->v4l2_dev ? notifier->v4l2_dev->dev : NULL;
Steve Longerbeamb47d7ff2018-09-29 15:54:06 -0400404
405 if (!asd)
406 return -EINVAL;
407
408 switch (asd->match_type) {
409 case V4L2_ASYNC_MATCH_CUSTOM:
410 case V4L2_ASYNC_MATCH_DEVNAME:
411 case V4L2_ASYNC_MATCH_I2C:
412 case V4L2_ASYNC_MATCH_FWNODE:
413 if (v4l2_async_notifier_has_async_subdev(notifier, asd,
414 this_index)) {
415 dev_dbg(dev, "subdev descriptor already listed in this or other notifiers\n");
416 return -EEXIST;
417 }
418 break;
419 default:
420 dev_err(dev, "Invalid match type %u on %p\n",
421 asd->match_type, asd);
422 return -EINVAL;
423 }
424
425 return 0;
426}
427
428void v4l2_async_notifier_init(struct v4l2_async_notifier *notifier)
429{
430 mutex_lock(&list_lock);
431
432 INIT_LIST_HEAD(&notifier->asd_list);
433
434 mutex_unlock(&list_lock);
435}
436EXPORT_SYMBOL(v4l2_async_notifier_init);
437
438static int __v4l2_async_notifier_register(struct v4l2_async_notifier *notifier)
439{
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300440 struct v4l2_async_subdev *asd;
Sakari Ailusfb45f432017-10-02 06:24:54 -0400441 int ret;
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300442 int i;
443
Sakari Ailusa3620cb2017-09-24 20:48:08 -0400444 if (notifier->num_subdevs > V4L2_MAX_SUBDEVS)
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300445 return -EINVAL;
446
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300447 INIT_LIST_HEAD(&notifier->waiting);
448 INIT_LIST_HEAD(&notifier->done);
449
Sakari Ailus466cae62017-09-20 03:51:54 -0400450 mutex_lock(&list_lock);
451
Steve Longerbeamb47d7ff2018-09-29 15:54:06 -0400452 if (notifier->subdevs) {
453 for (i = 0; i < notifier->num_subdevs; i++) {
454 asd = notifier->subdevs[i];
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300455
Steve Longerbeamb47d7ff2018-09-29 15:54:06 -0400456 ret = v4l2_async_notifier_asd_valid(notifier, asd, i);
457 if (ret)
Sakari Ailus466cae62017-09-20 03:51:54 -0400458 goto err_unlock;
Steve Longerbeamb47d7ff2018-09-29 15:54:06 -0400459
460 list_add_tail(&asd->list, &notifier->waiting);
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300461 }
Steve Longerbeamb47d7ff2018-09-29 15:54:06 -0400462 } else {
463 i = 0;
464 list_for_each_entry(asd, &notifier->asd_list, asd_list) {
465 ret = v4l2_async_notifier_asd_valid(notifier, asd, i++);
466 if (ret)
467 goto err_unlock;
468
469 list_add_tail(&asd->list, &notifier->waiting);
470 }
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300471 }
472
Sakari Ailusa3620cb2017-09-24 20:48:08 -0400473 ret = v4l2_async_notifier_try_all_subdevs(notifier);
Sakari Ailus466cae62017-09-20 03:51:54 -0400474 if (ret < 0)
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400475 goto err_unbind;
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300476
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400477 ret = v4l2_async_notifier_try_complete(notifier);
Sakari Ailus466cae62017-09-20 03:51:54 -0400478 if (ret < 0)
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400479 goto err_unbind;
Sakari Ailusfb45f432017-10-02 06:24:54 -0400480
Tuukka Toivonen47b037a2017-01-27 08:32:56 -0200481 /* Keep also completed notifiers on the list */
482 list_add(&notifier->list, &notifier_list);
483
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300484 mutex_unlock(&list_lock);
485
486 return 0;
Sakari Ailusfb45f432017-10-02 06:24:54 -0400487
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400488err_unbind:
489 /*
490 * On failure, unbind all sub-devices registered through this notifier.
491 */
Sakari Ailusfb45f432017-10-02 06:24:54 -0400492 v4l2_async_notifier_unbind_all_subdevs(notifier);
493
Sakari Ailus466cae62017-09-20 03:51:54 -0400494err_unlock:
Sakari Ailusfb45f432017-10-02 06:24:54 -0400495 mutex_unlock(&list_lock);
496
497 return ret;
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300498}
Sakari Ailusa3620cb2017-09-24 20:48:08 -0400499
500int v4l2_async_notifier_register(struct v4l2_device *v4l2_dev,
501 struct v4l2_async_notifier *notifier)
502{
503 int ret;
504
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400505 if (WARN_ON(!v4l2_dev || notifier->sd))
Sakari Ailusa3620cb2017-09-24 20:48:08 -0400506 return -EINVAL;
507
508 notifier->v4l2_dev = v4l2_dev;
509
510 ret = __v4l2_async_notifier_register(notifier);
511 if (ret)
512 notifier->v4l2_dev = NULL;
513
514 return ret;
515}
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300516EXPORT_SYMBOL(v4l2_async_notifier_register);
517
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400518int v4l2_async_subdev_notifier_register(struct v4l2_subdev *sd,
519 struct v4l2_async_notifier *notifier)
520{
521 int ret;
522
523 if (WARN_ON(!sd || notifier->v4l2_dev))
524 return -EINVAL;
525
526 notifier->sd = sd;
527
528 ret = __v4l2_async_notifier_register(notifier);
529 if (ret)
530 notifier->sd = NULL;
531
532 return ret;
533}
534EXPORT_SYMBOL(v4l2_async_subdev_notifier_register);
535
Sakari Ailusaef69d52017-09-24 18:47:44 -0400536static void __v4l2_async_notifier_unregister(
537 struct v4l2_async_notifier *notifier)
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300538{
Sakari Ailusaef69d52017-09-24 18:47:44 -0400539 if (!notifier || (!notifier->v4l2_dev && !notifier->sd))
Laurent Pinchart8e3fbfe2013-07-03 07:49:06 -0300540 return;
541
Sakari Ailusfb45f432017-10-02 06:24:54 -0400542 v4l2_async_notifier_unbind_all_subdevs(notifier);
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300543
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400544 notifier->sd = NULL;
Laurent Pinchart8e3fbfe2013-07-03 07:49:06 -0300545 notifier->v4l2_dev = NULL;
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400546
547 list_del(&notifier->list);
Sakari Ailusaef69d52017-09-24 18:47:44 -0400548}
549
550void v4l2_async_notifier_unregister(struct v4l2_async_notifier *notifier)
551{
552 mutex_lock(&list_lock);
553
554 __v4l2_async_notifier_unregister(notifier);
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400555
556 mutex_unlock(&list_lock);
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300557}
558EXPORT_SYMBOL(v4l2_async_notifier_unregister);
559
Steve Longerbeamb47d7ff2018-09-29 15:54:06 -0400560static void __v4l2_async_notifier_cleanup(struct v4l2_async_notifier *notifier)
Sakari Ailus9ca46532017-08-17 11:28:21 -0400561{
Steve Longerbeamb47d7ff2018-09-29 15:54:06 -0400562 struct v4l2_async_subdev *asd, *tmp;
Sakari Ailus9ca46532017-08-17 11:28:21 -0400563 unsigned int i;
564
Steve Longerbeamb47d7ff2018-09-29 15:54:06 -0400565 if (!notifier)
Sakari Ailus9ca46532017-08-17 11:28:21 -0400566 return;
567
Steve Longerbeamb47d7ff2018-09-29 15:54:06 -0400568 if (notifier->subdevs) {
569 if (!notifier->max_subdevs)
570 return;
Sakari Ailus9ca46532017-08-17 11:28:21 -0400571
Steve Longerbeamb47d7ff2018-09-29 15:54:06 -0400572 for (i = 0; i < notifier->num_subdevs; i++) {
573 asd = notifier->subdevs[i];
574
575 switch (asd->match_type) {
576 case V4L2_ASYNC_MATCH_FWNODE:
577 fwnode_handle_put(asd->match.fwnode);
578 break;
579 default:
580 break;
581 }
582
583 kfree(asd);
Sakari Ailus9ca46532017-08-17 11:28:21 -0400584 }
585
Steve Longerbeamb47d7ff2018-09-29 15:54:06 -0400586 notifier->max_subdevs = 0;
587 kvfree(notifier->subdevs);
588 notifier->subdevs = NULL;
589 } else {
590 list_for_each_entry_safe(asd, tmp,
591 &notifier->asd_list, asd_list) {
592 switch (asd->match_type) {
593 case V4L2_ASYNC_MATCH_FWNODE:
594 fwnode_handle_put(asd->match.fwnode);
595 break;
596 default:
597 break;
598 }
599
600 list_del(&asd->asd_list);
601 kfree(asd);
602 }
Sakari Ailus9ca46532017-08-17 11:28:21 -0400603 }
604
Sakari Ailus9ca46532017-08-17 11:28:21 -0400605 notifier->num_subdevs = 0;
Steve Longerbeamb47d7ff2018-09-29 15:54:06 -0400606}
Sakari Ailus9ca46532017-08-17 11:28:21 -0400607
Steve Longerbeamb47d7ff2018-09-29 15:54:06 -0400608void v4l2_async_notifier_cleanup(struct v4l2_async_notifier *notifier)
609{
610 mutex_lock(&list_lock);
611
612 __v4l2_async_notifier_cleanup(notifier);
613
614 mutex_unlock(&list_lock);
Sakari Ailus9ca46532017-08-17 11:28:21 -0400615}
616EXPORT_SYMBOL_GPL(v4l2_async_notifier_cleanup);
617
Steve Longerbeamb47d7ff2018-09-29 15:54:06 -0400618int v4l2_async_notifier_add_subdev(struct v4l2_async_notifier *notifier,
619 struct v4l2_async_subdev *asd)
620{
621 int ret;
622
623 mutex_lock(&list_lock);
624
625 if (notifier->num_subdevs >= V4L2_MAX_SUBDEVS) {
626 ret = -EINVAL;
627 goto unlock;
628 }
629
630 /*
631 * If caller uses this function, it cannot also allocate and
632 * place asd's in the notifier->subdevs array.
633 */
634 if (WARN_ON(notifier->subdevs)) {
635 ret = -EINVAL;
636 goto unlock;
637 }
638
639 ret = v4l2_async_notifier_asd_valid(notifier, asd,
640 notifier->num_subdevs);
641 if (ret)
642 goto unlock;
643
644 list_add_tail(&asd->asd_list, &notifier->asd_list);
645 notifier->num_subdevs++;
646
647unlock:
648 mutex_unlock(&list_lock);
649 return ret;
650}
651EXPORT_SYMBOL_GPL(v4l2_async_notifier_add_subdev);
652
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300653int v4l2_async_register_subdev(struct v4l2_subdev *sd)
654{
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400655 struct v4l2_async_notifier *subdev_notifier;
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300656 struct v4l2_async_notifier *notifier;
Sakari Ailusfb45f432017-10-02 06:24:54 -0400657 int ret;
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300658
Sakari Ailus86217652015-06-11 12:18:01 -0700659 /*
660 * No reference taken. The reference is held by the device
661 * (struct v4l2_subdev.dev), and async sub-device does not
662 * exist independently of the device at any point of time.
663 */
Sakari Ailus859969b2016-08-26 20:17:25 -0300664 if (!sd->fwnode && sd->dev)
665 sd->fwnode = dev_fwnode(sd->dev);
Sakari Ailus86217652015-06-11 12:18:01 -0700666
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300667 mutex_lock(&list_lock);
668
Sylwester Nawrockib426b3a2013-07-22 08:01:33 -0300669 INIT_LIST_HEAD(&sd->async_list);
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300670
671 list_for_each_entry(notifier, &notifier_list, list) {
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400672 struct v4l2_device *v4l2_dev =
673 v4l2_async_notifier_find_v4l2_dev(notifier);
674 struct v4l2_async_subdev *asd;
Sakari Ailusfb45f432017-10-02 06:24:54 -0400675
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400676 if (!v4l2_dev)
677 continue;
678
679 asd = v4l2_async_find_match(notifier, sd);
Sakari Ailusfb45f432017-10-02 06:24:54 -0400680 if (!asd)
681 continue;
682
Niklas Söderlund487cc852017-11-15 10:43:58 -0500683 ret = v4l2_async_match_notify(notifier, v4l2_dev, sd, asd);
Sakari Ailusfb45f432017-10-02 06:24:54 -0400684 if (ret)
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400685 goto err_unbind;
Sakari Ailusfb45f432017-10-02 06:24:54 -0400686
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400687 ret = v4l2_async_notifier_try_complete(notifier);
Sakari Ailusfb45f432017-10-02 06:24:54 -0400688 if (ret)
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400689 goto err_unbind;
Sakari Ailusfb45f432017-10-02 06:24:54 -0400690
691 goto out_unlock;
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300692 }
693
694 /* None matched, wait for hot-plugging */
Sylwester Nawrockib426b3a2013-07-22 08:01:33 -0300695 list_add(&sd->async_list, &subdev_list);
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300696
Sakari Ailusfb45f432017-10-02 06:24:54 -0400697out_unlock:
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300698 mutex_unlock(&list_lock);
699
700 return 0;
Sakari Ailusfb45f432017-10-02 06:24:54 -0400701
Sakari Ailus2cab00b2017-09-24 20:54:31 -0400702err_unbind:
703 /*
704 * Complete failed. Unbind the sub-devices bound through registering
705 * this async sub-device.
706 */
707 subdev_notifier = v4l2_async_find_subdev_notifier(sd);
708 if (subdev_notifier)
709 v4l2_async_notifier_unbind_all_subdevs(subdev_notifier);
710
711 if (sd->asd)
712 v4l2_async_notifier_call_unbind(notifier, sd, sd->asd);
Sakari Ailusfb45f432017-10-02 06:24:54 -0400713 v4l2_async_cleanup(sd);
714
Sakari Ailusfb45f432017-10-02 06:24:54 -0400715 mutex_unlock(&list_lock);
716
717 return ret;
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300718}
719EXPORT_SYMBOL(v4l2_async_register_subdev);
720
721void v4l2_async_unregister_subdev(struct v4l2_subdev *sd)
722{
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300723 mutex_lock(&list_lock);
724
Sakari Ailusaef69d52017-09-24 18:47:44 -0400725 __v4l2_async_notifier_unregister(sd->subdev_notifier);
Steve Longerbeamb47d7ff2018-09-29 15:54:06 -0400726 __v4l2_async_notifier_cleanup(sd->subdev_notifier);
Sakari Ailusaef69d52017-09-24 18:47:44 -0400727 kfree(sd->subdev_notifier);
728 sd->subdev_notifier = NULL;
729
Sakari Ailus7fc4fdb2017-10-03 02:26:32 -0400730 if (sd->asd) {
731 struct v4l2_async_notifier *notifier = sd->notifier;
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300732
Sakari Ailus7fc4fdb2017-10-03 02:26:32 -0400733 list_add(&sd->asd->list, &notifier->waiting);
734
Sakari Ailusddddc182017-09-01 08:27:32 -0400735 v4l2_async_notifier_call_unbind(notifier, sd, sd->asd);
Sakari Ailus7fc4fdb2017-10-03 02:26:32 -0400736 }
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300737
Niklas Söderlund633d1852017-10-02 16:16:52 -0400738 v4l2_async_cleanup(sd);
739
Guennadi Liakhovetskie9e31042013-01-08 07:06:31 -0300740 mutex_unlock(&list_lock);
741}
742EXPORT_SYMBOL(v4l2_async_unregister_subdev);