2 * V4L2 asynchronous subdevice registration API
4 * Copyright (C) 2012-2013, Guennadi Liakhovetski <g.liakhovetski@gmx.de>
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.
11 #include <linux/device.h>
12 #include <linux/err.h>
13 #include <linux/i2c.h>
14 #include <linux/list.h>
15 #include <linux/module.h>
16 #include <linux/mutex.h>
17 #include <linux/platform_device.h>
18 #include <linux/slab.h>
19 #include <linux/types.h>
21 #include <media/v4l2-async.h>
22 #include <media/v4l2-device.h>
23 #include <media/v4l2-subdev.h>
25 static bool match_i2c(struct v4l2_subdev *sd, struct v4l2_async_subdev *asd)
27 #if IS_ENABLED(CONFIG_I2C)
28 struct i2c_client *client = i2c_verify_client(sd->dev);
30 asd->match.i2c.adapter_id == client->adapter->nr &&
31 asd->match.i2c.address == client->addr;
37 static bool match_devname(struct v4l2_subdev *sd,
38 struct v4l2_async_subdev *asd)
40 return !strcmp(asd->match.device_name.name, dev_name(sd->dev));
43 static bool match_of(struct v4l2_subdev *sd, struct v4l2_async_subdev *asd)
45 return sd->of_node == asd->match.of.node;
48 static bool match_custom(struct v4l2_subdev *sd, struct v4l2_async_subdev *asd)
50 if (!asd->match.custom.match)
54 return asd->match.custom.match(sd->dev, asd);
57 static LIST_HEAD(subdev_list);
58 static LIST_HEAD(notifier_list);
59 static DEFINE_MUTEX(list_lock);
61 static struct v4l2_async_subdev *v4l2_async_belongs(struct v4l2_async_notifier *notifier,
62 struct v4l2_subdev *sd)
64 bool (*match)(struct v4l2_subdev *, struct v4l2_async_subdev *);
65 struct v4l2_async_subdev *asd;
67 list_for_each_entry(asd, ¬ifier->waiting, list) {
68 /* bus_type has been verified valid before */
69 switch (asd->match_type) {
70 case V4L2_ASYNC_MATCH_CUSTOM:
73 case V4L2_ASYNC_MATCH_DEVNAME:
74 match = match_devname;
76 case V4L2_ASYNC_MATCH_I2C:
79 case V4L2_ASYNC_MATCH_OF:
83 /* Cannot happen, unless someone breaks us */
88 /* match cannot be NULL here */
96 static int v4l2_async_test_notify(struct v4l2_async_notifier *notifier,
97 struct v4l2_subdev *sd,
98 struct v4l2_async_subdev *asd)
102 /* Remove from the waiting list */
103 list_del(&asd->list);
105 sd->notifier = notifier;
107 if (notifier->bound) {
108 ret = notifier->bound(notifier, sd, asd);
112 /* Move from the global subdevice list to notifier's done */
113 list_move(&sd->async_list, ¬ifier->done);
115 ret = v4l2_device_register_subdev(notifier->v4l2_dev, sd);
117 if (notifier->unbind)
118 notifier->unbind(notifier, sd, asd);
122 ret = v4l2_subdev_call(sd, core, registered_async);
123 if (ret < 0 && ret != -ENOIOCTLCMD) {
124 if (notifier->unbind)
125 notifier->unbind(notifier, sd, asd);
129 if (list_empty(¬ifier->waiting) && notifier->complete)
130 return notifier->complete(notifier);
135 static void v4l2_async_cleanup(struct v4l2_subdev *sd)
137 v4l2_device_unregister_subdev(sd);
138 /* Subdevice driver will reprobe and put the subdev back onto the list */
139 list_del_init(&sd->async_list);
144 int v4l2_async_notifier_register(struct v4l2_device *v4l2_dev,
145 struct v4l2_async_notifier *notifier)
147 struct v4l2_subdev *sd, *tmp;
148 struct v4l2_async_subdev *asd;
151 if (!notifier->num_subdevs || notifier->num_subdevs > V4L2_MAX_SUBDEVS)
154 notifier->v4l2_dev = v4l2_dev;
155 INIT_LIST_HEAD(¬ifier->waiting);
156 INIT_LIST_HEAD(¬ifier->done);
158 for (i = 0; i < notifier->num_subdevs; i++) {
159 asd = notifier->subdevs[i];
161 switch (asd->match_type) {
162 case V4L2_ASYNC_MATCH_CUSTOM:
163 case V4L2_ASYNC_MATCH_DEVNAME:
164 case V4L2_ASYNC_MATCH_I2C:
165 case V4L2_ASYNC_MATCH_OF:
168 dev_err(notifier->v4l2_dev ? notifier->v4l2_dev->dev : NULL,
169 "Invalid match type %u on %p\n",
170 asd->match_type, asd);
173 list_add_tail(&asd->list, ¬ifier->waiting);
176 mutex_lock(&list_lock);
178 /* Keep also completed notifiers on the list */
179 list_add(¬ifier->list, ¬ifier_list);
181 list_for_each_entry_safe(sd, tmp, &subdev_list, async_list) {
184 asd = v4l2_async_belongs(notifier, sd);
188 ret = v4l2_async_test_notify(notifier, sd, asd);
190 mutex_unlock(&list_lock);
195 mutex_unlock(&list_lock);
199 EXPORT_SYMBOL(v4l2_async_notifier_register);
201 void v4l2_async_notifier_unregister(struct v4l2_async_notifier *notifier)
203 struct v4l2_subdev *sd, *tmp;
204 unsigned int notif_n_subdev = notifier->num_subdevs;
205 unsigned int n_subdev = min(notif_n_subdev, V4L2_MAX_SUBDEVS);
209 if (!notifier->v4l2_dev)
212 dev = kmalloc(n_subdev * sizeof(*dev), GFP_KERNEL);
214 dev_err(notifier->v4l2_dev->dev,
215 "Failed to allocate device cache!\n");
218 mutex_lock(&list_lock);
220 list_del(¬ifier->list);
222 list_for_each_entry_safe(sd, tmp, ¬ifier->done, async_list) {
225 d = get_device(sd->dev);
227 v4l2_async_cleanup(sd);
229 /* If we handled USB devices, we'd have to lock the parent too */
230 device_release_driver(d);
232 if (notifier->unbind)
233 notifier->unbind(notifier, sd, sd->asd);
236 * Store device at the device cache, in order to call
237 * put_device() on the final step
245 mutex_unlock(&list_lock);
248 * Call device_attach() to reprobe devices
250 * NOTE: If dev allocation fails, i is 0, and the whole loop won't be
254 struct device *d = dev[i];
256 if (d && device_attach(d) < 0) {
257 const char *name = "(none)";
258 int lock = device_trylock(d);
260 if (lock && d->driver)
261 name = d->driver->name;
262 dev_err(d, "Failed to re-probe to %s\n", name);
270 notifier->v4l2_dev = NULL;
273 * Don't care about the waiting list, it is initialised and populated
274 * upon notifier registration.
277 EXPORT_SYMBOL(v4l2_async_notifier_unregister);
279 int v4l2_async_register_subdev(struct v4l2_subdev *sd)
281 struct v4l2_async_notifier *notifier;
284 * No reference taken. The reference is held by the device
285 * (struct v4l2_subdev.dev), and async sub-device does not
286 * exist independently of the device at any point of time.
288 if (!sd->of_node && sd->dev)
289 sd->of_node = sd->dev->of_node;
291 mutex_lock(&list_lock);
293 INIT_LIST_HEAD(&sd->async_list);
295 list_for_each_entry(notifier, ¬ifier_list, list) {
296 struct v4l2_async_subdev *asd = v4l2_async_belongs(notifier, sd);
298 int ret = v4l2_async_test_notify(notifier, sd, asd);
299 mutex_unlock(&list_lock);
304 /* None matched, wait for hot-plugging */
305 list_add(&sd->async_list, &subdev_list);
307 mutex_unlock(&list_lock);
311 EXPORT_SYMBOL(v4l2_async_register_subdev);
313 void v4l2_async_unregister_subdev(struct v4l2_subdev *sd)
315 struct v4l2_async_notifier *notifier = sd->notifier;
318 if (!list_empty(&sd->async_list))
319 v4l2_async_cleanup(sd);
323 mutex_lock(&list_lock);
325 list_add(&sd->asd->list, ¬ifier->waiting);
327 v4l2_async_cleanup(sd);
329 if (notifier->unbind)
330 notifier->unbind(notifier, sd, sd->asd);
332 mutex_unlock(&list_lock);
334 EXPORT_SYMBOL(v4l2_async_unregister_subdev);