1 /*
2  *	Video for Linux Two
3  *
4  *	A generic video device interface for the LINUX operating system
5  *	using a set of device structures/vectors for low level operations.
6  *
7  *	This file replaces the videodev.c file that comes with the
8  *	regular kernel distribution.
9  *
10  *	This program is free software; you can redistribute it and/or
11  *	modify it under the terms of the GNU General Public License
12  *	as published by the Free Software Foundation; either version
13  *	2 of the License, or (at your option) any later version.
14  *
15  * Author:	Bill Dirks <bill@thedirks.org>
16  *		based on code by Alan Cox, <alan@cymru.net>
17  *
18  */
19 
20 /*
21  * Video capture interface for Linux
22  *
23  *	A generic video device interface for the LINUX operating system
24  *	using a set of device structures/vectors for low level operations.
25  *
26  *		This program is free software; you can redistribute it and/or
27  *		modify it under the terms of the GNU General Public License
28  *		as published by the Free Software Foundation; either version
29  *		2 of the License, or (at your option) any later version.
30  *
31  * Author:	Alan Cox, <alan@lxorguk.ukuu.org.uk>
32  *
33  * Fixes:
34  */
35 
36 /*
37  * Video4linux 1/2 integration by Justin Schoeman
38  * <justin@suntiger.ee.up.ac.za>
39  * 2.4 PROCFS support ported from 2.4 kernels by
40  *  Iñaki García Etxebarria <garetxe@euskalnet.net>
41  * Makefile fix by "W. Michael Petullo" <mike@flyn.org>
42  * 2.4 devfs support ported from 2.4 kernels by
43  *  Dan Merillat <dan@merillat.org>
44  * Added Gerd Knorrs v4l1 enhancements (Justin Schoeman)
45  */
46 
47 #include <linux/module.h>
48 #include <linux/types.h>
49 #include <linux/kernel.h>
50 #include <linux/mm.h>
51 #include <linux/string.h>
52 #include <linux/errno.h>
53 #include <linux/i2c.h>
54 #if defined(CONFIG_SPI)
55 #include <linux/spi/spi.h>
56 #endif
57 #include <linux/uaccess.h>
58 #include <asm/pgtable.h>
59 #include <asm/io.h>
60 #include <asm/div64.h>
61 #include <media/v4l2-common.h>
62 #include <media/v4l2-device.h>
63 #include <media/v4l2-ctrls.h>
64 
65 #include <linux/videodev2.h>
66 
67 MODULE_AUTHOR("Bill Dirks, Justin Schoeman, Gerd Knorr");
68 MODULE_DESCRIPTION("misc helper functions for v4l2 device drivers");
69 MODULE_LICENSE("GPL");
70 
71 /*
72  *
73  *	V 4 L 2   D R I V E R   H E L P E R   A P I
74  *
75  */
76 
77 /*
78  *  Video Standard Operations (contributed by Michael Schimek)
79  */
80 
81 /* Helper functions for control handling			     */
82 
83 /* Fill in a struct v4l2_queryctrl */
v4l2_ctrl_query_fill(struct v4l2_queryctrl * qctrl,s32 _min,s32 _max,s32 _step,s32 _def)84 int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 _min, s32 _max, s32 _step, s32 _def)
85 {
86 	const char *name;
87 	s64 min = _min;
88 	s64 max = _max;
89 	u64 step = _step;
90 	s64 def = _def;
91 
92 	v4l2_ctrl_fill(qctrl->id, &name, &qctrl->type,
93 		       &min, &max, &step, &def, &qctrl->flags);
94 
95 	if (name == NULL)
96 		return -EINVAL;
97 
98 	qctrl->minimum = min;
99 	qctrl->maximum = max;
100 	qctrl->step = step;
101 	qctrl->default_value = def;
102 	qctrl->reserved[0] = qctrl->reserved[1] = 0;
103 	strlcpy(qctrl->name, name, sizeof(qctrl->name));
104 	return 0;
105 }
106 EXPORT_SYMBOL(v4l2_ctrl_query_fill);
107 
108 /* I2C Helper functions */
109 
110 #if IS_ENABLED(CONFIG_I2C)
111 
v4l2_i2c_subdev_init(struct v4l2_subdev * sd,struct i2c_client * client,const struct v4l2_subdev_ops * ops)112 void v4l2_i2c_subdev_init(struct v4l2_subdev *sd, struct i2c_client *client,
113 		const struct v4l2_subdev_ops *ops)
114 {
115 	v4l2_subdev_init(sd, ops);
116 	sd->flags |= V4L2_SUBDEV_FL_IS_I2C;
117 	/* the owner is the same as the i2c_client's driver owner */
118 	sd->owner = client->dev.driver->owner;
119 	sd->dev = &client->dev;
120 	/* i2c_client and v4l2_subdev point to one another */
121 	v4l2_set_subdevdata(sd, client);
122 	i2c_set_clientdata(client, sd);
123 	/* initialize name */
124 	snprintf(sd->name, sizeof(sd->name), "%s %d-%04x",
125 		client->dev.driver->name, i2c_adapter_id(client->adapter),
126 		client->addr);
127 }
128 EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_init);
129 
130 /* Load an i2c sub-device. */
v4l2_i2c_new_subdev_board(struct v4l2_device * v4l2_dev,struct i2c_adapter * adapter,struct i2c_board_info * info,const unsigned short * probe_addrs)131 struct v4l2_subdev *v4l2_i2c_new_subdev_board(struct v4l2_device *v4l2_dev,
132 		struct i2c_adapter *adapter, struct i2c_board_info *info,
133 		const unsigned short *probe_addrs)
134 {
135 	struct v4l2_subdev *sd = NULL;
136 	struct i2c_client *client;
137 
138 	BUG_ON(!v4l2_dev);
139 
140 	request_module(I2C_MODULE_PREFIX "%s", info->type);
141 
142 	/* Create the i2c client */
143 	if (info->addr == 0 && probe_addrs)
144 		client = i2c_new_probed_device(adapter, info, probe_addrs,
145 					       NULL);
146 	else
147 		client = i2c_new_device(adapter, info);
148 
149 	/* Note: by loading the module first we are certain that c->driver
150 	   will be set if the driver was found. If the module was not loaded
151 	   first, then the i2c core tries to delay-load the module for us,
152 	   and then c->driver is still NULL until the module is finally
153 	   loaded. This delay-load mechanism doesn't work if other drivers
154 	   want to use the i2c device, so explicitly loading the module
155 	   is the best alternative. */
156 	if (client == NULL || client->dev.driver == NULL)
157 		goto error;
158 
159 	/* Lock the module so we can safely get the v4l2_subdev pointer */
160 	if (!try_module_get(client->dev.driver->owner))
161 		goto error;
162 	sd = i2c_get_clientdata(client);
163 
164 	/* Register with the v4l2_device which increases the module's
165 	   use count as well. */
166 	if (v4l2_device_register_subdev(v4l2_dev, sd))
167 		sd = NULL;
168 	/* Decrease the module use count to match the first try_module_get. */
169 	module_put(client->dev.driver->owner);
170 
171 error:
172 	/* If we have a client but no subdev, then something went wrong and
173 	   we must unregister the client. */
174 	if (client && sd == NULL)
175 		i2c_unregister_device(client);
176 	return sd;
177 }
178 EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev_board);
179 
v4l2_i2c_new_subdev(struct v4l2_device * v4l2_dev,struct i2c_adapter * adapter,const char * client_type,u8 addr,const unsigned short * probe_addrs)180 struct v4l2_subdev *v4l2_i2c_new_subdev(struct v4l2_device *v4l2_dev,
181 		struct i2c_adapter *adapter, const char *client_type,
182 		u8 addr, const unsigned short *probe_addrs)
183 {
184 	struct i2c_board_info info;
185 
186 	/* Setup the i2c board info with the device type and
187 	   the device address. */
188 	memset(&info, 0, sizeof(info));
189 	strlcpy(info.type, client_type, sizeof(info.type));
190 	info.addr = addr;
191 
192 	return v4l2_i2c_new_subdev_board(v4l2_dev, adapter, &info, probe_addrs);
193 }
194 EXPORT_SYMBOL_GPL(v4l2_i2c_new_subdev);
195 
196 /* Return i2c client address of v4l2_subdev. */
v4l2_i2c_subdev_addr(struct v4l2_subdev * sd)197 unsigned short v4l2_i2c_subdev_addr(struct v4l2_subdev *sd)
198 {
199 	struct i2c_client *client = v4l2_get_subdevdata(sd);
200 
201 	return client ? client->addr : I2C_CLIENT_END;
202 }
203 EXPORT_SYMBOL_GPL(v4l2_i2c_subdev_addr);
204 
205 /* Return a list of I2C tuner addresses to probe. Use only if the tuner
206    addresses are unknown. */
v4l2_i2c_tuner_addrs(enum v4l2_i2c_tuner_type type)207 const unsigned short *v4l2_i2c_tuner_addrs(enum v4l2_i2c_tuner_type type)
208 {
209 	static const unsigned short radio_addrs[] = {
210 #if IS_ENABLED(CONFIG_MEDIA_TUNER_TEA5761)
211 		0x10,
212 #endif
213 		0x60,
214 		I2C_CLIENT_END
215 	};
216 	static const unsigned short demod_addrs[] = {
217 		0x42, 0x43, 0x4a, 0x4b,
218 		I2C_CLIENT_END
219 	};
220 	static const unsigned short tv_addrs[] = {
221 		0x42, 0x43, 0x4a, 0x4b,		/* tda8290 */
222 		0x60, 0x61, 0x62, 0x63, 0x64,
223 		I2C_CLIENT_END
224 	};
225 
226 	switch (type) {
227 	case ADDRS_RADIO:
228 		return radio_addrs;
229 	case ADDRS_DEMOD:
230 		return demod_addrs;
231 	case ADDRS_TV:
232 		return tv_addrs;
233 	case ADDRS_TV_WITH_DEMOD:
234 		return tv_addrs + 4;
235 	}
236 	return NULL;
237 }
238 EXPORT_SYMBOL_GPL(v4l2_i2c_tuner_addrs);
239 
240 #endif /* defined(CONFIG_I2C) */
241 
242 #if defined(CONFIG_SPI)
243 
244 /* Load an spi sub-device. */
245 
v4l2_spi_subdev_init(struct v4l2_subdev * sd,struct spi_device * spi,const struct v4l2_subdev_ops * ops)246 void v4l2_spi_subdev_init(struct v4l2_subdev *sd, struct spi_device *spi,
247 		const struct v4l2_subdev_ops *ops)
248 {
249 	v4l2_subdev_init(sd, ops);
250 	sd->flags |= V4L2_SUBDEV_FL_IS_SPI;
251 	/* the owner is the same as the spi_device's driver owner */
252 	sd->owner = spi->dev.driver->owner;
253 	sd->dev = &spi->dev;
254 	/* spi_device and v4l2_subdev point to one another */
255 	v4l2_set_subdevdata(sd, spi);
256 	spi_set_drvdata(spi, sd);
257 	/* initialize name */
258 	strlcpy(sd->name, spi->dev.driver->name, sizeof(sd->name));
259 }
260 EXPORT_SYMBOL_GPL(v4l2_spi_subdev_init);
261 
v4l2_spi_new_subdev(struct v4l2_device * v4l2_dev,struct spi_master * master,struct spi_board_info * info)262 struct v4l2_subdev *v4l2_spi_new_subdev(struct v4l2_device *v4l2_dev,
263 		struct spi_master *master, struct spi_board_info *info)
264 {
265 	struct v4l2_subdev *sd = NULL;
266 	struct spi_device *spi = NULL;
267 
268 	BUG_ON(!v4l2_dev);
269 
270 	if (info->modalias[0])
271 		request_module(info->modalias);
272 
273 	spi = spi_new_device(master, info);
274 
275 	if (spi == NULL || spi->dev.driver == NULL)
276 		goto error;
277 
278 	if (!try_module_get(spi->dev.driver->owner))
279 		goto error;
280 
281 	sd = spi_get_drvdata(spi);
282 
283 	/* Register with the v4l2_device which increases the module's
284 	   use count as well. */
285 	if (v4l2_device_register_subdev(v4l2_dev, sd))
286 		sd = NULL;
287 
288 	/* Decrease the module use count to match the first try_module_get. */
289 	module_put(spi->dev.driver->owner);
290 
291 error:
292 	/* If we have a client but no subdev, then something went wrong and
293 	   we must unregister the client. */
294 	if (!sd)
295 		spi_unregister_device(spi);
296 
297 	return sd;
298 }
299 EXPORT_SYMBOL_GPL(v4l2_spi_new_subdev);
300 
301 #endif /* defined(CONFIG_SPI) */
302 
303 /* Clamp x to be between min and max, aligned to a multiple of 2^align.  min
304  * and max don't have to be aligned, but there must be at least one valid
305  * value.  E.g., min=17,max=31,align=4 is not allowed as there are no multiples
306  * of 16 between 17 and 31.  */
clamp_align(unsigned int x,unsigned int min,unsigned int max,unsigned int align)307 static unsigned int clamp_align(unsigned int x, unsigned int min,
308 				unsigned int max, unsigned int align)
309 {
310 	/* Bits that must be zero to be aligned */
311 	unsigned int mask = ~((1 << align) - 1);
312 
313 	/* Clamp to aligned min and max */
314 	x = clamp(x, (min + ~mask) & mask, max & mask);
315 
316 	/* Round to nearest aligned value */
317 	if (align)
318 		x = (x + (1 << (align - 1))) & mask;
319 
320 	return x;
321 }
322 
v4l_bound_align_image(u32 * w,unsigned int wmin,unsigned int wmax,unsigned int walign,u32 * h,unsigned int hmin,unsigned int hmax,unsigned int halign,unsigned int salign)323 void v4l_bound_align_image(u32 *w, unsigned int wmin, unsigned int wmax,
324 			   unsigned int walign,
325 			   u32 *h, unsigned int hmin, unsigned int hmax,
326 			   unsigned int halign, unsigned int salign)
327 {
328 	*w = clamp_align(*w, wmin, wmax, walign);
329 	*h = clamp_align(*h, hmin, hmax, halign);
330 
331 	/* Usually we don't need to align the size and are done now. */
332 	if (!salign)
333 		return;
334 
335 	/* How much alignment do we have? */
336 	walign = __ffs(*w);
337 	halign = __ffs(*h);
338 	/* Enough to satisfy the image alignment? */
339 	if (walign + halign < salign) {
340 		/* Max walign where there is still a valid width */
341 		unsigned int wmaxa = __fls(wmax ^ (wmin - 1));
342 		/* Max halign where there is still a valid height */
343 		unsigned int hmaxa = __fls(hmax ^ (hmin - 1));
344 
345 		/* up the smaller alignment until we have enough */
346 		do {
347 			if (halign >= hmaxa ||
348 			    (walign <= halign && walign < wmaxa)) {
349 				*w = clamp_align(*w, wmin, wmax, walign + 1);
350 				walign = __ffs(*w);
351 			} else {
352 				*h = clamp_align(*h, hmin, hmax, halign + 1);
353 				halign = __ffs(*h);
354 			}
355 		} while (halign + walign < salign);
356 	}
357 }
358 EXPORT_SYMBOL_GPL(v4l_bound_align_image);
359 
360 const void *
__v4l2_find_nearest_size(const void * array,size_t array_size,size_t entry_size,size_t width_offset,size_t height_offset,s32 width,s32 height)361 __v4l2_find_nearest_size(const void *array, size_t array_size,
362 			 size_t entry_size, size_t width_offset,
363 			 size_t height_offset, s32 width, s32 height)
364 {
365 	u32 error, min_error = U32_MAX;
366 	const void *best = NULL;
367 	unsigned int i;
368 
369 	if (!array)
370 		return NULL;
371 
372 	for (i = 0; i < array_size; i++, array += entry_size) {
373 		const u32 *entry_width = array + width_offset;
374 		const u32 *entry_height = array + height_offset;
375 
376 		error = abs(*entry_width - width) + abs(*entry_height - height);
377 		if (error > min_error)
378 			continue;
379 
380 		min_error = error;
381 		best = array;
382 		if (!error)
383 			break;
384 	}
385 
386 	return best;
387 }
388 EXPORT_SYMBOL_GPL(__v4l2_find_nearest_size);
389 
v4l2_get_timestamp(struct timeval * tv)390 void v4l2_get_timestamp(struct timeval *tv)
391 {
392 	struct timespec ts;
393 
394 	ktime_get_ts(&ts);
395 	tv->tv_sec = ts.tv_sec;
396 	tv->tv_usec = ts.tv_nsec / NSEC_PER_USEC;
397 }
398 EXPORT_SYMBOL_GPL(v4l2_get_timestamp);
399 
v4l2_g_parm_cap(struct video_device * vdev,struct v4l2_subdev * sd,struct v4l2_streamparm * a)400 int v4l2_g_parm_cap(struct video_device *vdev,
401 		    struct v4l2_subdev *sd, struct v4l2_streamparm *a)
402 {
403 	struct v4l2_subdev_frame_interval ival = { 0 };
404 	int ret;
405 
406 	if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
407 	    a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
408 		return -EINVAL;
409 
410 	if (vdev->device_caps & V4L2_CAP_READWRITE)
411 		a->parm.capture.readbuffers = 2;
412 	if (v4l2_subdev_has_op(sd, video, g_frame_interval))
413 		a->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
414 	ret = v4l2_subdev_call(sd, video, g_frame_interval, &ival);
415 	if (!ret)
416 		a->parm.capture.timeperframe = ival.interval;
417 	return ret;
418 }
419 EXPORT_SYMBOL_GPL(v4l2_g_parm_cap);
420 
v4l2_s_parm_cap(struct video_device * vdev,struct v4l2_subdev * sd,struct v4l2_streamparm * a)421 int v4l2_s_parm_cap(struct video_device *vdev,
422 		    struct v4l2_subdev *sd, struct v4l2_streamparm *a)
423 {
424 	struct v4l2_subdev_frame_interval ival = {
425 		.interval = a->parm.capture.timeperframe
426 	};
427 	int ret;
428 
429 	if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
430 	    a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
431 		return -EINVAL;
432 
433 	memset(&a->parm, 0, sizeof(a->parm));
434 	if (vdev->device_caps & V4L2_CAP_READWRITE)
435 		a->parm.capture.readbuffers = 2;
436 	else
437 		a->parm.capture.readbuffers = 0;
438 
439 	if (v4l2_subdev_has_op(sd, video, g_frame_interval))
440 		a->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
441 	ret = v4l2_subdev_call(sd, video, s_frame_interval, &ival);
442 	if (!ret)
443 		a->parm.capture.timeperframe = ival.interval;
444 	return ret;
445 }
446 EXPORT_SYMBOL_GPL(v4l2_s_parm_cap);
447