1 /*
2     V4L2 device support.
3 
4     Copyright (C) 2008  Hans Verkuil <hverkuil@xs4all.nl>
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 as published by
8     the Free Software Foundation; either version 2 of the License, or
9     (at your option) any later version.
10 
11     This program is distributed in the hope that it will be useful,
12     but WITHOUT ANY WARRANTY; without even the implied warranty of
13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14     GNU General Public License for more details.
15 
16     You should have received a copy of the GNU General Public License
17     along with this program; if not, write to the Free Software
18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20 
21 #include <linux/types.h>
22 #include <linux/ioctl.h>
23 #include <linux/module.h>
24 #include <linux/i2c.h>
25 #include <linux/slab.h>
26 #if defined(CONFIG_SPI)
27 #include <linux/spi/spi.h>
28 #endif
29 #include <linux/videodev2.h>
30 #include <media/v4l2-device.h>
31 #include <media/v4l2-ctrls.h>
32 
33 int v4l2_device_register(struct device *dev, struct v4l2_device *v4l2_dev)
34 {
35 	if (v4l2_dev == NULL)
36 		return -EINVAL;
37 
38 	INIT_LIST_HEAD(&v4l2_dev->subdevs);
39 	spin_lock_init(&v4l2_dev->lock);
40 	v4l2_prio_init(&v4l2_dev->prio);
41 	kref_init(&v4l2_dev->ref);
42 	get_device(dev);
43 	v4l2_dev->dev = dev;
44 	if (dev == NULL) {
45 		/* If dev == NULL, then name must be filled in by the caller */
46 		if (WARN_ON(!v4l2_dev->name[0]))
47 			return -EINVAL;
48 		return 0;
49 	}
50 
51 	/* Set name to driver name + device name if it is empty. */
52 	if (!v4l2_dev->name[0])
53 		snprintf(v4l2_dev->name, sizeof(v4l2_dev->name), "%s %s",
54 			dev->driver->name, dev_name(dev));
55 	if (!dev_get_drvdata(dev))
56 		dev_set_drvdata(dev, v4l2_dev);
57 	return 0;
58 }
59 EXPORT_SYMBOL_GPL(v4l2_device_register);
60 
61 static void v4l2_device_release(struct kref *ref)
62 {
63 	struct v4l2_device *v4l2_dev =
64 		container_of(ref, struct v4l2_device, ref);
65 
66 	if (v4l2_dev->release)
67 		v4l2_dev->release(v4l2_dev);
68 }
69 
70 int v4l2_device_put(struct v4l2_device *v4l2_dev)
71 {
72 	return kref_put(&v4l2_dev->ref, v4l2_device_release);
73 }
74 EXPORT_SYMBOL_GPL(v4l2_device_put);
75 
76 int v4l2_device_set_name(struct v4l2_device *v4l2_dev, const char *basename,
77 						atomic_t *instance)
78 {
79 	int num = atomic_inc_return(instance) - 1;
80 	int len = strlen(basename);
81 
82 	if (basename[len - 1] >= '0' && basename[len - 1] <= '9')
83 		snprintf(v4l2_dev->name, sizeof(v4l2_dev->name),
84 				"%s-%d", basename, num);
85 	else
86 		snprintf(v4l2_dev->name, sizeof(v4l2_dev->name),
87 				"%s%d", basename, num);
88 	return num;
89 }
90 EXPORT_SYMBOL_GPL(v4l2_device_set_name);
91 
92 void v4l2_device_disconnect(struct v4l2_device *v4l2_dev)
93 {
94 	if (v4l2_dev->dev == NULL)
95 		return;
96 
97 	if (dev_get_drvdata(v4l2_dev->dev) == v4l2_dev)
98 		dev_set_drvdata(v4l2_dev->dev, NULL);
99 	put_device(v4l2_dev->dev);
100 	v4l2_dev->dev = NULL;
101 }
102 EXPORT_SYMBOL_GPL(v4l2_device_disconnect);
103 
104 void v4l2_device_unregister(struct v4l2_device *v4l2_dev)
105 {
106 	struct v4l2_subdev *sd, *next;
107 
108 	/* Just return if v4l2_dev is NULL or if it was already
109 	 * unregistered before. */
110 	if (v4l2_dev == NULL || !v4l2_dev->name[0])
111 		return;
112 	v4l2_device_disconnect(v4l2_dev);
113 
114 	/* Unregister subdevs */
115 	list_for_each_entry_safe(sd, next, &v4l2_dev->subdevs, list) {
116 		v4l2_device_unregister_subdev(sd);
117 #if IS_ENABLED(CONFIG_I2C)
118 		if (sd->flags & V4L2_SUBDEV_FL_IS_I2C) {
119 			struct i2c_client *client = v4l2_get_subdevdata(sd);
120 
121 			/*
122 			 * We need to unregister the i2c client
123 			 * explicitly. We cannot rely on
124 			 * i2c_del_adapter to always unregister
125 			 * clients for us, since if the i2c bus is a
126 			 * platform bus, then it is never deleted.
127 			 *
128 			 * Device tree or ACPI based devices must not
129 			 * be unregistered as they have not been
130 			 * registered by us, and would not be
131 			 * re-created by just probing the V4L2 driver.
132 			 */
133 			if (client &&
134 			    !client->dev.of_node && !client->dev.fwnode)
135 				i2c_unregister_device(client);
136 			continue;
137 		}
138 #endif
139 #if defined(CONFIG_SPI)
140 		if (sd->flags & V4L2_SUBDEV_FL_IS_SPI) {
141 			struct spi_device *spi = v4l2_get_subdevdata(sd);
142 
143 			if (spi && !spi->dev.of_node && !spi->dev.fwnode)
144 				spi_unregister_device(spi);
145 			continue;
146 		}
147 #endif
148 	}
149 	/* Mark as unregistered, thus preventing duplicate unregistrations */
150 	v4l2_dev->name[0] = '\0';
151 }
152 EXPORT_SYMBOL_GPL(v4l2_device_unregister);
153 
154 int v4l2_device_register_subdev(struct v4l2_device *v4l2_dev,
155 				struct v4l2_subdev *sd)
156 {
157 #if defined(CONFIG_MEDIA_CONTROLLER)
158 	struct media_entity *entity = &sd->entity;
159 #endif
160 	int err;
161 
162 	/* Check for valid input */
163 	if (!v4l2_dev || !sd || sd->v4l2_dev || !sd->name[0])
164 		return -EINVAL;
165 
166 	/*
167 	 * The reason to acquire the module here is to avoid unloading
168 	 * a module of sub-device which is registered to a media
169 	 * device. To make it possible to unload modules for media
170 	 * devices that also register sub-devices, do not
171 	 * try_module_get() such sub-device owners.
172 	 */
173 	sd->owner_v4l2_dev = v4l2_dev->dev && v4l2_dev->dev->driver &&
174 		sd->owner == v4l2_dev->dev->driver->owner;
175 
176 	if (!sd->owner_v4l2_dev && !try_module_get(sd->owner))
177 		return -ENODEV;
178 
179 	sd->v4l2_dev = v4l2_dev;
180 	/* This just returns 0 if either of the two args is NULL */
181 	err = v4l2_ctrl_add_handler(v4l2_dev->ctrl_handler, sd->ctrl_handler,
182 				    NULL, true);
183 	if (err)
184 		goto error_module;
185 
186 #if defined(CONFIG_MEDIA_CONTROLLER)
187 	/* Register the entity. */
188 	if (v4l2_dev->mdev) {
189 		err = media_device_register_entity(v4l2_dev->mdev, entity);
190 		if (err < 0)
191 			goto error_module;
192 	}
193 #endif
194 
195 	if (sd->internal_ops && sd->internal_ops->registered) {
196 		err = sd->internal_ops->registered(sd);
197 		if (err)
198 			goto error_unregister;
199 	}
200 
201 	spin_lock(&v4l2_dev->lock);
202 	list_add_tail(&sd->list, &v4l2_dev->subdevs);
203 	spin_unlock(&v4l2_dev->lock);
204 
205 	return 0;
206 
207 error_unregister:
208 #if defined(CONFIG_MEDIA_CONTROLLER)
209 	media_device_unregister_entity(entity);
210 #endif
211 error_module:
212 	if (!sd->owner_v4l2_dev)
213 		module_put(sd->owner);
214 	sd->v4l2_dev = NULL;
215 	return err;
216 }
217 EXPORT_SYMBOL_GPL(v4l2_device_register_subdev);
218 
219 static void v4l2_subdev_release(struct v4l2_subdev *sd)
220 {
221 	struct module *owner = !sd->owner_v4l2_dev ? sd->owner : NULL;
222 
223 	if (sd->internal_ops && sd->internal_ops->release)
224 		sd->internal_ops->release(sd);
225 	module_put(owner);
226 }
227 
228 static void v4l2_device_release_subdev_node(struct video_device *vdev)
229 {
230 	v4l2_subdev_release(video_get_drvdata(vdev));
231 	kfree(vdev);
232 }
233 
234 int v4l2_device_register_subdev_nodes(struct v4l2_device *v4l2_dev)
235 {
236 	struct video_device *vdev;
237 	struct v4l2_subdev *sd;
238 	int err;
239 
240 	/* Register a device node for every subdev marked with the
241 	 * V4L2_SUBDEV_FL_HAS_DEVNODE flag.
242 	 */
243 	list_for_each_entry(sd, &v4l2_dev->subdevs, list) {
244 		if (!(sd->flags & V4L2_SUBDEV_FL_HAS_DEVNODE))
245 			continue;
246 
247 		if (sd->devnode)
248 			continue;
249 
250 		vdev = kzalloc(sizeof(*vdev), GFP_KERNEL);
251 		if (!vdev) {
252 			err = -ENOMEM;
253 			goto clean_up;
254 		}
255 
256 		video_set_drvdata(vdev, sd);
257 		strscpy(vdev->name, sd->name, sizeof(vdev->name));
258 		vdev->dev_parent = sd->dev;
259 		vdev->v4l2_dev = v4l2_dev;
260 		vdev->fops = &v4l2_subdev_fops;
261 		vdev->release = v4l2_device_release_subdev_node;
262 		vdev->ctrl_handler = sd->ctrl_handler;
263 		err = __video_register_device(vdev, VFL_TYPE_SUBDEV, -1, 1,
264 					      sd->owner);
265 		if (err < 0) {
266 			kfree(vdev);
267 			goto clean_up;
268 		}
269 		sd->devnode = vdev;
270 #if defined(CONFIG_MEDIA_CONTROLLER)
271 		sd->entity.info.dev.major = VIDEO_MAJOR;
272 		sd->entity.info.dev.minor = vdev->minor;
273 
274 		/* Interface is created by __video_register_device() */
275 		if (vdev->v4l2_dev->mdev) {
276 			struct media_link *link;
277 
278 			link = media_create_intf_link(&sd->entity,
279 						      &vdev->intf_devnode->intf,
280 						      MEDIA_LNK_FL_ENABLED |
281 						      MEDIA_LNK_FL_IMMUTABLE);
282 			if (!link) {
283 				err = -ENOMEM;
284 				goto clean_up;
285 			}
286 		}
287 #endif
288 	}
289 	return 0;
290 
291 clean_up:
292 	list_for_each_entry(sd, &v4l2_dev->subdevs, list) {
293 		if (!sd->devnode)
294 			break;
295 		video_unregister_device(sd->devnode);
296 	}
297 
298 	return err;
299 }
300 EXPORT_SYMBOL_GPL(v4l2_device_register_subdev_nodes);
301 
302 void v4l2_device_unregister_subdev(struct v4l2_subdev *sd)
303 {
304 	struct v4l2_device *v4l2_dev;
305 
306 	/* return if it isn't registered */
307 	if (sd == NULL || sd->v4l2_dev == NULL)
308 		return;
309 
310 	v4l2_dev = sd->v4l2_dev;
311 
312 	spin_lock(&v4l2_dev->lock);
313 	list_del(&sd->list);
314 	spin_unlock(&v4l2_dev->lock);
315 
316 	if (sd->internal_ops && sd->internal_ops->unregistered)
317 		sd->internal_ops->unregistered(sd);
318 	sd->v4l2_dev = NULL;
319 
320 #if defined(CONFIG_MEDIA_CONTROLLER)
321 	if (v4l2_dev->mdev) {
322 		/*
323 		 * No need to explicitly remove links, as both pads and
324 		 * links are removed by the function below, in the right order
325 		 */
326 		media_device_unregister_entity(&sd->entity);
327 	}
328 #endif
329 	if (sd->devnode)
330 		video_unregister_device(sd->devnode);
331 	else
332 		v4l2_subdev_release(sd);
333 }
334 EXPORT_SYMBOL_GPL(v4l2_device_unregister_subdev);
335