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
25static 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
37static 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
42static bool match_of(struct device *dev, struct v4l2_async_subdev *asd)
43{
44	return dev->of_node == asd->match.of.node;
45}
46
47static LIST_HEAD(subdev_list);
48static LIST_HEAD(notifier_list);
49static DEFINE_MUTEX(list_lock);
50
51static 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
89static 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
121static 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
130int 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}
185EXPORT_SYMBOL(v4l2_async_notifier_register);
186
187void 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}
263EXPORT_SYMBOL(v4l2_async_notifier_unregister);
264
265int 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}
289EXPORT_SYMBOL(v4l2_async_register_subdev);
290
291void 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}
312EXPORT_SYMBOL(v4l2_async_unregister_subdev);
313