1 /*
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>
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>
20 
21 #include <media/v4l2-async.h>
22 #include <media/v4l2-device.h>
23 #include <media/v4l2-subdev.h>
24 
25 static bool match_i2c(struct device *dev, struct v4l2_async_subdev *asd)
26 {
27 #if IS_ENABLED(CONFIG_I2C)
28 	struct i2c_client *client = i2c_verify_client(dev);
29 	return client &&
30 		asd->match.i2c.adapter_id == client->adapter->nr &&
31 		asd->match.i2c.address == client->addr;
32 #else
33 	return false;
34 #endif
35 }
36 
37 static bool match_devname(struct device *dev, struct v4l2_async_subdev *asd)
38 {
39 	return !strcmp(asd->match.device_name.name, dev_name(dev));
40 }
41 
42 static bool match_of(struct device *dev, struct v4l2_async_subdev *asd)
43 {
44 	return dev->of_node == asd->match.of.node;
45 }
46 
47 static LIST_HEAD(subdev_list);
48 static LIST_HEAD(notifier_list);
49 static DEFINE_MUTEX(list_lock);
50 
51 static struct v4l2_async_subdev *v4l2_async_belongs(struct v4l2_async_notifier *notifier,
52 						    struct v4l2_subdev *sd)
53 {
54 	struct v4l2_async_subdev *asd;
55 	bool (*match)(struct device *, struct v4l2_async_subdev *);
56 
57 	list_for_each_entry(asd, &notifier->waiting, list) {
58 		/* bus_type has been verified valid before */
59 		switch (asd->match_type) {
60 		case V4L2_ASYNC_MATCH_CUSTOM:
61 			match = asd->match.custom.match;
62 			if (!match)
63 				/* Match always */
64 				return asd;
65 			break;
66 		case V4L2_ASYNC_MATCH_DEVNAME:
67 			match = match_devname;
68 			break;
69 		case V4L2_ASYNC_MATCH_I2C:
70 			match = match_i2c;
71 			break;
72 		case V4L2_ASYNC_MATCH_OF:
73 			match = match_of;
74 			break;
75 		default:
76 			/* Cannot happen, unless someone breaks us */
77 			WARN_ON(true);
78 			return NULL;
79 		}
80 
81 		/* match cannot be NULL here */
82 		if (match(sd->dev, asd))
83 			return asd;
84 	}
85 
86 	return NULL;
87 }
88 
89 static int v4l2_async_test_notify(struct v4l2_async_notifier *notifier,
90 				  struct v4l2_subdev *sd,
91 				  struct v4l2_async_subdev *asd)
92 {
93 	int ret;
94 
95 	/* Remove from the waiting list */
96 	list_del(&asd->list);
97 	sd->asd = asd;
98 	sd->notifier = notifier;
99 
100 	if (notifier->bound) {
101 		ret = notifier->bound(notifier, sd, asd);
102 		if (ret < 0)
103 			return ret;
104 	}
105 	/* Move from the global subdevice list to notifier's done */
106 	list_move(&sd->async_list, &notifier->done);
107 
108 	ret = v4l2_device_register_subdev(notifier->v4l2_dev, sd);
109 	if (ret < 0) {
110 		if (notifier->unbind)
111 			notifier->unbind(notifier, sd, asd);
112 		return ret;
113 	}
114 
115 	if (list_empty(&notifier->waiting) && notifier->complete)
116 		return notifier->complete(notifier);
117 
118 	return 0;
119 }
120 
121 static void v4l2_async_cleanup(struct v4l2_subdev *sd)
122 {
123 	v4l2_device_unregister_subdev(sd);
124 	/* Subdevice driver will reprobe and put the subdev back onto the list */
125 	list_del_init(&sd->async_list);
126 	sd->asd = NULL;
127 	sd->dev = NULL;
128 }
129 
130 int v4l2_async_notifier_register(struct v4l2_device *v4l2_dev,
131 				 struct v4l2_async_notifier *notifier)
132 {
133 	struct v4l2_subdev *sd, *tmp;
134 	struct v4l2_async_subdev *asd;
135 	int i;
136 
137 	if (!notifier->num_subdevs || notifier->num_subdevs > V4L2_MAX_SUBDEVS)
138 		return -EINVAL;
139 
140 	notifier->v4l2_dev = v4l2_dev;
141 	INIT_LIST_HEAD(&notifier->waiting);
142 	INIT_LIST_HEAD(&notifier->done);
143 
144 	for (i = 0; i < notifier->num_subdevs; i++) {
145 		asd = notifier->subdevs[i];
146 
147 		switch (asd->match_type) {
148 		case V4L2_ASYNC_MATCH_CUSTOM:
149 		case V4L2_ASYNC_MATCH_DEVNAME:
150 		case V4L2_ASYNC_MATCH_I2C:
151 		case V4L2_ASYNC_MATCH_OF:
152 			break;
153 		default:
154 			dev_err(notifier->v4l2_dev ? notifier->v4l2_dev->dev : NULL,
155 				"Invalid match type %u on %p\n",
156 				asd->match_type, asd);
157 			return -EINVAL;
158 		}
159 		list_add_tail(&asd->list, &notifier->waiting);
160 	}
161 
162 	mutex_lock(&list_lock);
163 
164 	/* Keep also completed notifiers on the list */
165 	list_add(&notifier->list, &notifier_list);
166 
167 	list_for_each_entry_safe(sd, tmp, &subdev_list, async_list) {
168 		int ret;
169 
170 		asd = v4l2_async_belongs(notifier, sd);
171 		if (!asd)
172 			continue;
173 
174 		ret = v4l2_async_test_notify(notifier, sd, asd);
175 		if (ret < 0) {
176 			mutex_unlock(&list_lock);
177 			return ret;
178 		}
179 	}
180 
181 	mutex_unlock(&list_lock);
182 
183 	return 0;
184 }
185 EXPORT_SYMBOL(v4l2_async_notifier_register);
186 
187 void v4l2_async_notifier_unregister(struct v4l2_async_notifier *notifier)
188 {
189 	struct v4l2_subdev *sd, *tmp;
190 	unsigned int notif_n_subdev = notifier->num_subdevs;
191 	unsigned int n_subdev = min(notif_n_subdev, V4L2_MAX_SUBDEVS);
192 	struct device **dev;
193 	int i = 0;
194 
195 	if (!notifier->v4l2_dev)
196 		return;
197 
198 	dev = kmalloc(n_subdev * sizeof(*dev), GFP_KERNEL);
199 	if (!dev) {
200 		dev_err(notifier->v4l2_dev->dev,
201 			"Failed to allocate device cache!\n");
202 	}
203 
204 	mutex_lock(&list_lock);
205 
206 	list_del(&notifier->list);
207 
208 	list_for_each_entry_safe(sd, tmp, &notifier->done, async_list) {
209 		struct device *d;
210 
211 		d = get_device(sd->dev);
212 
213 		v4l2_async_cleanup(sd);
214 
215 		/* If we handled USB devices, we'd have to lock the parent too */
216 		device_release_driver(d);
217 
218 		if (notifier->unbind)
219 			notifier->unbind(notifier, sd, sd->asd);
220 
221 		/*
222 		 * Store device at the device cache, in order to call
223 		 * put_device() on the final step
224 		 */
225 		if (dev)
226 			dev[i++] = d;
227 		else
228 			put_device(d);
229 	}
230 
231 	mutex_unlock(&list_lock);
232 
233 	/*
234 	 * Call device_attach() to reprobe devices
235 	 *
236 	 * NOTE: If dev allocation fails, i is 0, and the whole loop won't be
237 	 * executed.
238 	 */
239 	while (i--) {
240 		struct device *d = dev[i];
241 
242 		if (d && device_attach(d) < 0) {
243 			const char *name = "(none)";
244 			int lock = device_trylock(d);
245 
246 			if (lock && d->driver)
247 				name = d->driver->name;
248 			dev_err(d, "Failed to re-probe to %s\n", name);
249 			if (lock)
250 				device_unlock(d);
251 		}
252 		put_device(d);
253 	}
254 	kfree(dev);
255 
256 	notifier->v4l2_dev = NULL;
257 
258 	/*
259 	 * Don't care about the waiting list, it is initialised and populated
260 	 * upon notifier registration.
261 	 */
262 }
263 EXPORT_SYMBOL(v4l2_async_notifier_unregister);
264 
265 int v4l2_async_register_subdev(struct v4l2_subdev *sd)
266 {
267 	struct v4l2_async_notifier *notifier;
268 
269 	mutex_lock(&list_lock);
270 
271 	INIT_LIST_HEAD(&sd->async_list);
272 
273 	list_for_each_entry(notifier, &notifier_list, list) {
274 		struct v4l2_async_subdev *asd = v4l2_async_belongs(notifier, sd);
275 		if (asd) {
276 			int ret = v4l2_async_test_notify(notifier, sd, asd);
277 			mutex_unlock(&list_lock);
278 			return ret;
279 		}
280 	}
281 
282 	/* None matched, wait for hot-plugging */
283 	list_add(&sd->async_list, &subdev_list);
284 
285 	mutex_unlock(&list_lock);
286 
287 	return 0;
288 }
289 EXPORT_SYMBOL(v4l2_async_register_subdev);
290 
291 void v4l2_async_unregister_subdev(struct v4l2_subdev *sd)
292 {
293 	struct v4l2_async_notifier *notifier = sd->notifier;
294 
295 	if (!sd->asd) {
296 		if (!list_empty(&sd->async_list))
297 			v4l2_async_cleanup(sd);
298 		return;
299 	}
300 
301 	mutex_lock(&list_lock);
302 
303 	list_add(&sd->asd->list, &notifier->waiting);
304 
305 	v4l2_async_cleanup(sd);
306 
307 	if (notifier->unbind)
308 		notifier->unbind(notifier, sd, sd->asd);
309 
310 	mutex_unlock(&list_lock);
311 }
312 EXPORT_SYMBOL(v4l2_async_unregister_subdev);
313