1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *	Video for Linux Two
4  *
5  *	A generic video device interface for the LINUX operating system
6  *	using a set of device structures/vectors for low level operations.
7  *
8  *	This file replaces the videodev.c file that comes with the
9  *	regular kernel distribution.
10  *
11  * Author:	Bill Dirks <bill@thedirks.org>
12  *		based on code by Alan Cox, <alan@cymru.net>
13  */
14 
15 /*
16  * Video capture interface for Linux
17  *
18  *	A generic video device interface for the LINUX operating system
19  *	using a set of device structures/vectors for low level operations.
20  *
21  * Author:	Alan Cox, <alan@lxorguk.ukuu.org.uk>
22  *
23  * Fixes:
24  */
25 
26 /*
27  * Video4linux 1/2 integration by Justin Schoeman
28  * <justin@suntiger.ee.up.ac.za>
29  * 2.4 PROCFS support ported from 2.4 kernels by
30  *  Iñaki García Etxebarria <garetxe@euskalnet.net>
31  * Makefile fix by "W. Michael Petullo" <mike@flyn.org>
32  * 2.4 devfs support ported from 2.4 kernels by
33  *  Dan Merillat <dan@merillat.org>
34  * Added Gerd Knorrs v4l1 enhancements (Justin Schoeman)
35  */
36 
37 #include <linux/module.h>
38 #include <linux/types.h>
39 #include <linux/kernel.h>
40 #include <linux/mm.h>
41 #include <linux/string.h>
42 #include <linux/errno.h>
43 #include <linux/uaccess.h>
44 #include <asm/io.h>
45 #include <asm/div64.h>
46 #include <media/v4l2-common.h>
47 #include <media/v4l2-device.h>
48 #include <media/v4l2-ctrls.h>
49 
50 #include <linux/videodev2.h>
51 
52 /*
53  *
54  *	V 4 L 2   D R I V E R   H E L P E R   A P I
55  *
56  */
57 
58 /*
59  *  Video Standard Operations (contributed by Michael Schimek)
60  */
61 
62 /* Helper functions for control handling			     */
63 
64 /* Fill in a struct v4l2_queryctrl */
65 int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 _min, s32 _max, s32 _step, s32 _def)
66 {
67 	const char *name;
68 	s64 min = _min;
69 	s64 max = _max;
70 	u64 step = _step;
71 	s64 def = _def;
72 
73 	v4l2_ctrl_fill(qctrl->id, &name, &qctrl->type,
74 		       &min, &max, &step, &def, &qctrl->flags);
75 
76 	if (name == NULL)
77 		return -EINVAL;
78 
79 	qctrl->minimum = min;
80 	qctrl->maximum = max;
81 	qctrl->step = step;
82 	qctrl->default_value = def;
83 	qctrl->reserved[0] = qctrl->reserved[1] = 0;
84 	strscpy(qctrl->name, name, sizeof(qctrl->name));
85 	return 0;
86 }
87 EXPORT_SYMBOL(v4l2_ctrl_query_fill);
88 
89 /* Clamp x to be between min and max, aligned to a multiple of 2^align.  min
90  * and max don't have to be aligned, but there must be at least one valid
91  * value.  E.g., min=17,max=31,align=4 is not allowed as there are no multiples
92  * of 16 between 17 and 31.  */
93 static unsigned int clamp_align(unsigned int x, unsigned int min,
94 				unsigned int max, unsigned int align)
95 {
96 	/* Bits that must be zero to be aligned */
97 	unsigned int mask = ~((1 << align) - 1);
98 
99 	/* Clamp to aligned min and max */
100 	x = clamp(x, (min + ~mask) & mask, max & mask);
101 
102 	/* Round to nearest aligned value */
103 	if (align)
104 		x = (x + (1 << (align - 1))) & mask;
105 
106 	return x;
107 }
108 
109 static unsigned int clamp_roundup(unsigned int x, unsigned int min,
110 				   unsigned int max, unsigned int alignment)
111 {
112 	x = clamp(x, min, max);
113 	if (alignment)
114 		x = round_up(x, alignment);
115 
116 	return x;
117 }
118 
119 void v4l_bound_align_image(u32 *w, unsigned int wmin, unsigned int wmax,
120 			   unsigned int walign,
121 			   u32 *h, unsigned int hmin, unsigned int hmax,
122 			   unsigned int halign, unsigned int salign)
123 {
124 	*w = clamp_align(*w, wmin, wmax, walign);
125 	*h = clamp_align(*h, hmin, hmax, halign);
126 
127 	/* Usually we don't need to align the size and are done now. */
128 	if (!salign)
129 		return;
130 
131 	/* How much alignment do we have? */
132 	walign = __ffs(*w);
133 	halign = __ffs(*h);
134 	/* Enough to satisfy the image alignment? */
135 	if (walign + halign < salign) {
136 		/* Max walign where there is still a valid width */
137 		unsigned int wmaxa = __fls(wmax ^ (wmin - 1));
138 		/* Max halign where there is still a valid height */
139 		unsigned int hmaxa = __fls(hmax ^ (hmin - 1));
140 
141 		/* up the smaller alignment until we have enough */
142 		do {
143 			if (halign >= hmaxa ||
144 			    (walign <= halign && walign < wmaxa)) {
145 				*w = clamp_align(*w, wmin, wmax, walign + 1);
146 				walign = __ffs(*w);
147 			} else {
148 				*h = clamp_align(*h, hmin, hmax, halign + 1);
149 				halign = __ffs(*h);
150 			}
151 		} while (halign + walign < salign);
152 	}
153 }
154 EXPORT_SYMBOL_GPL(v4l_bound_align_image);
155 
156 const void *
157 __v4l2_find_nearest_size(const void *array, size_t array_size,
158 			 size_t entry_size, size_t width_offset,
159 			 size_t height_offset, s32 width, s32 height)
160 {
161 	u32 error, min_error = U32_MAX;
162 	const void *best = NULL;
163 	unsigned int i;
164 
165 	if (!array)
166 		return NULL;
167 
168 	for (i = 0; i < array_size; i++, array += entry_size) {
169 		const u32 *entry_width = array + width_offset;
170 		const u32 *entry_height = array + height_offset;
171 
172 		error = abs(*entry_width - width) + abs(*entry_height - height);
173 		if (error > min_error)
174 			continue;
175 
176 		min_error = error;
177 		best = array;
178 		if (!error)
179 			break;
180 	}
181 
182 	return best;
183 }
184 EXPORT_SYMBOL_GPL(__v4l2_find_nearest_size);
185 
186 int v4l2_g_parm_cap(struct video_device *vdev,
187 		    struct v4l2_subdev *sd, struct v4l2_streamparm *a)
188 {
189 	struct v4l2_subdev_frame_interval ival = { 0 };
190 	int ret;
191 
192 	if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
193 	    a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
194 		return -EINVAL;
195 
196 	if (vdev->device_caps & V4L2_CAP_READWRITE)
197 		a->parm.capture.readbuffers = 2;
198 	if (v4l2_subdev_has_op(sd, video, g_frame_interval))
199 		a->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
200 	ret = v4l2_subdev_call(sd, video, g_frame_interval, &ival);
201 	if (!ret)
202 		a->parm.capture.timeperframe = ival.interval;
203 	return ret;
204 }
205 EXPORT_SYMBOL_GPL(v4l2_g_parm_cap);
206 
207 int v4l2_s_parm_cap(struct video_device *vdev,
208 		    struct v4l2_subdev *sd, struct v4l2_streamparm *a)
209 {
210 	struct v4l2_subdev_frame_interval ival = {
211 		.interval = a->parm.capture.timeperframe
212 	};
213 	int ret;
214 
215 	if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
216 	    a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
217 		return -EINVAL;
218 
219 	memset(&a->parm, 0, sizeof(a->parm));
220 	if (vdev->device_caps & V4L2_CAP_READWRITE)
221 		a->parm.capture.readbuffers = 2;
222 	else
223 		a->parm.capture.readbuffers = 0;
224 
225 	if (v4l2_subdev_has_op(sd, video, g_frame_interval))
226 		a->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
227 	ret = v4l2_subdev_call(sd, video, s_frame_interval, &ival);
228 	if (!ret)
229 		a->parm.capture.timeperframe = ival.interval;
230 	return ret;
231 }
232 EXPORT_SYMBOL_GPL(v4l2_s_parm_cap);
233 
234 const struct v4l2_format_info *v4l2_format_info(u32 format)
235 {
236 	static const struct v4l2_format_info formats[] = {
237 		/* RGB formats */
238 		{ .format = V4L2_PIX_FMT_BGR24,   .pixel_enc = V4L2_PIXEL_ENC_RGB, .mem_planes = 1, .comp_planes = 1, .bpp = { 3, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
239 		{ .format = V4L2_PIX_FMT_RGB24,   .pixel_enc = V4L2_PIXEL_ENC_RGB, .mem_planes = 1, .comp_planes = 1, .bpp = { 3, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
240 		{ .format = V4L2_PIX_FMT_HSV24,   .pixel_enc = V4L2_PIXEL_ENC_RGB, .mem_planes = 1, .comp_planes = 1, .bpp = { 3, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
241 		{ .format = V4L2_PIX_FMT_BGR32,   .pixel_enc = V4L2_PIXEL_ENC_RGB, .mem_planes = 1, .comp_planes = 1, .bpp = { 4, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
242 		{ .format = V4L2_PIX_FMT_XBGR32,  .pixel_enc = V4L2_PIXEL_ENC_RGB, .mem_planes = 1, .comp_planes = 1, .bpp = { 4, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
243 		{ .format = V4L2_PIX_FMT_BGRX32,  .pixel_enc = V4L2_PIXEL_ENC_RGB, .mem_planes = 1, .comp_planes = 1, .bpp = { 4, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
244 		{ .format = V4L2_PIX_FMT_RGB32,   .pixel_enc = V4L2_PIXEL_ENC_RGB, .mem_planes = 1, .comp_planes = 1, .bpp = { 4, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
245 		{ .format = V4L2_PIX_FMT_XRGB32,  .pixel_enc = V4L2_PIXEL_ENC_RGB, .mem_planes = 1, .comp_planes = 1, .bpp = { 4, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
246 		{ .format = V4L2_PIX_FMT_RGBX32,  .pixel_enc = V4L2_PIXEL_ENC_RGB, .mem_planes = 1, .comp_planes = 1, .bpp = { 4, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
247 		{ .format = V4L2_PIX_FMT_HSV32,   .pixel_enc = V4L2_PIXEL_ENC_RGB, .mem_planes = 1, .comp_planes = 1, .bpp = { 4, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
248 		{ .format = V4L2_PIX_FMT_ARGB32,  .pixel_enc = V4L2_PIXEL_ENC_RGB, .mem_planes = 1, .comp_planes = 1, .bpp = { 4, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
249 		{ .format = V4L2_PIX_FMT_RGBA32,  .pixel_enc = V4L2_PIXEL_ENC_RGB, .mem_planes = 1, .comp_planes = 1, .bpp = { 4, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
250 		{ .format = V4L2_PIX_FMT_ABGR32,  .pixel_enc = V4L2_PIXEL_ENC_RGB, .mem_planes = 1, .comp_planes = 1, .bpp = { 4, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
251 		{ .format = V4L2_PIX_FMT_BGRA32,  .pixel_enc = V4L2_PIXEL_ENC_RGB, .mem_planes = 1, .comp_planes = 1, .bpp = { 4, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
252 		{ .format = V4L2_PIX_FMT_RGB565,  .pixel_enc = V4L2_PIXEL_ENC_RGB, .mem_planes = 1, .comp_planes = 1, .bpp = { 2, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
253 		{ .format = V4L2_PIX_FMT_RGB555,  .pixel_enc = V4L2_PIXEL_ENC_RGB, .mem_planes = 1, .comp_planes = 1, .bpp = { 2, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
254 		{ .format = V4L2_PIX_FMT_BGR666,  .pixel_enc = V4L2_PIXEL_ENC_RGB, .mem_planes = 1, .comp_planes = 1, .bpp = { 4, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
255 		{ .format = V4L2_PIX_FMT_BGR48_12, .pixel_enc = V4L2_PIXEL_ENC_RGB, .mem_planes = 1, .comp_planes = 1, .bpp = { 6, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
256 		{ .format = V4L2_PIX_FMT_ABGR64_12, .pixel_enc = V4L2_PIXEL_ENC_RGB, .mem_planes = 1, .comp_planes = 1, .bpp = { 8, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
257 
258 		/* YUV packed formats */
259 		{ .format = V4L2_PIX_FMT_YUYV,    .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 1, .bpp = { 2, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 1 },
260 		{ .format = V4L2_PIX_FMT_YVYU,    .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 1, .bpp = { 2, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 1 },
261 		{ .format = V4L2_PIX_FMT_UYVY,    .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 1, .bpp = { 2, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 1 },
262 		{ .format = V4L2_PIX_FMT_VYUY,    .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 1, .bpp = { 2, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 1 },
263 		{ .format = V4L2_PIX_FMT_Y212,    .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 1, .bpp = { 4, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 1 },
264 		{ .format = V4L2_PIX_FMT_YUV48_12, .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 1, .bpp = { 6, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
265 
266 		/* YUV planar formats */
267 		{ .format = V4L2_PIX_FMT_NV12,    .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 2, .bpp = { 1, 2, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 2 },
268 		{ .format = V4L2_PIX_FMT_NV21,    .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 2, .bpp = { 1, 2, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 2 },
269 		{ .format = V4L2_PIX_FMT_NV16,    .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 2, .bpp = { 1, 2, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 1 },
270 		{ .format = V4L2_PIX_FMT_NV61,    .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 2, .bpp = { 1, 2, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 1 },
271 		{ .format = V4L2_PIX_FMT_NV24,    .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 2, .bpp = { 1, 2, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
272 		{ .format = V4L2_PIX_FMT_NV42,    .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 2, .bpp = { 1, 2, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
273 		{ .format = V4L2_PIX_FMT_P010,    .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 2, .bpp = { 2, 2, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 1 },
274 		{ .format = V4L2_PIX_FMT_P012,    .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 2, .bpp = { 2, 4, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 2 },
275 
276 		{ .format = V4L2_PIX_FMT_YUV410,  .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 3, .bpp = { 1, 1, 1, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 4, .vdiv = 4 },
277 		{ .format = V4L2_PIX_FMT_YVU410,  .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 3, .bpp = { 1, 1, 1, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 4, .vdiv = 4 },
278 		{ .format = V4L2_PIX_FMT_YUV411P, .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 3, .bpp = { 1, 1, 1, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 4, .vdiv = 1 },
279 		{ .format = V4L2_PIX_FMT_YUV420,  .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 3, .bpp = { 1, 1, 1, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 2 },
280 		{ .format = V4L2_PIX_FMT_YVU420,  .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 3, .bpp = { 1, 1, 1, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 2 },
281 		{ .format = V4L2_PIX_FMT_YUV422P, .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 3, .bpp = { 1, 1, 1, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 1 },
282 		{ .format = V4L2_PIX_FMT_GREY,    .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 1, .bpp = { 1, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
283 
284 		/* Tiled YUV formats */
285 		{ .format = V4L2_PIX_FMT_NV12_4L4, .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 2, .bpp = { 1, 2, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 2 },
286 		{ .format = V4L2_PIX_FMT_NV15_4L4, .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 2, .bpp = { 5, 10, 0, 0 }, .bpp_div = { 4, 4, 1, 1 }, .hdiv = 2, .vdiv = 2,
287 		  .block_w = { 4, 2, 0, 0 }, .block_h = { 1, 1, 0, 0 }},
288 		{ .format = V4L2_PIX_FMT_P010_4L4, .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 1, .comp_planes = 2, .bpp = { 2, 4, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 2 },
289 
290 		/* YUV planar formats, non contiguous variant */
291 		{ .format = V4L2_PIX_FMT_YUV420M, .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 3, .comp_planes = 3, .bpp = { 1, 1, 1, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 2 },
292 		{ .format = V4L2_PIX_FMT_YVU420M, .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 3, .comp_planes = 3, .bpp = { 1, 1, 1, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 2 },
293 		{ .format = V4L2_PIX_FMT_YUV422M, .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 3, .comp_planes = 3, .bpp = { 1, 1, 1, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 1 },
294 		{ .format = V4L2_PIX_FMT_YVU422M, .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 3, .comp_planes = 3, .bpp = { 1, 1, 1, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 1 },
295 		{ .format = V4L2_PIX_FMT_YUV444M, .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 3, .comp_planes = 3, .bpp = { 1, 1, 1, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
296 		{ .format = V4L2_PIX_FMT_YVU444M, .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 3, .comp_planes = 3, .bpp = { 1, 1, 1, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
297 
298 		{ .format = V4L2_PIX_FMT_NV12M,   .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 2, .comp_planes = 2, .bpp = { 1, 2, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 2 },
299 		{ .format = V4L2_PIX_FMT_NV21M,   .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 2, .comp_planes = 2, .bpp = { 1, 2, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 2 },
300 		{ .format = V4L2_PIX_FMT_NV16M,   .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 2, .comp_planes = 2, .bpp = { 1, 2, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 1 },
301 		{ .format = V4L2_PIX_FMT_NV61M,   .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 2, .comp_planes = 2, .bpp = { 1, 2, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 1 },
302 		{ .format = V4L2_PIX_FMT_P012M,   .pixel_enc = V4L2_PIXEL_ENC_YUV, .mem_planes = 2, .comp_planes = 2, .bpp = { 2, 4, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 2, .vdiv = 2 },
303 
304 		/* Bayer RGB formats */
305 		{ .format = V4L2_PIX_FMT_SBGGR8,	.pixel_enc = V4L2_PIXEL_ENC_BAYER, .mem_planes = 1, .comp_planes = 1, .bpp = { 1, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
306 		{ .format = V4L2_PIX_FMT_SGBRG8,	.pixel_enc = V4L2_PIXEL_ENC_BAYER, .mem_planes = 1, .comp_planes = 1, .bpp = { 1, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
307 		{ .format = V4L2_PIX_FMT_SGRBG8,	.pixel_enc = V4L2_PIXEL_ENC_BAYER, .mem_planes = 1, .comp_planes = 1, .bpp = { 1, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
308 		{ .format = V4L2_PIX_FMT_SRGGB8,	.pixel_enc = V4L2_PIXEL_ENC_BAYER, .mem_planes = 1, .comp_planes = 1, .bpp = { 1, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
309 		{ .format = V4L2_PIX_FMT_SBGGR10,	.pixel_enc = V4L2_PIXEL_ENC_BAYER, .mem_planes = 1, .comp_planes = 1, .bpp = { 2, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
310 		{ .format = V4L2_PIX_FMT_SGBRG10,	.pixel_enc = V4L2_PIXEL_ENC_BAYER, .mem_planes = 1, .comp_planes = 1, .bpp = { 2, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
311 		{ .format = V4L2_PIX_FMT_SGRBG10,	.pixel_enc = V4L2_PIXEL_ENC_BAYER, .mem_planes = 1, .comp_planes = 1, .bpp = { 2, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
312 		{ .format = V4L2_PIX_FMT_SRGGB10,	.pixel_enc = V4L2_PIXEL_ENC_BAYER, .mem_planes = 1, .comp_planes = 1, .bpp = { 2, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
313 		{ .format = V4L2_PIX_FMT_SBGGR10ALAW8,	.pixel_enc = V4L2_PIXEL_ENC_BAYER, .mem_planes = 1, .comp_planes = 1, .bpp = { 1, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
314 		{ .format = V4L2_PIX_FMT_SGBRG10ALAW8,	.pixel_enc = V4L2_PIXEL_ENC_BAYER, .mem_planes = 1, .comp_planes = 1, .bpp = { 1, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
315 		{ .format = V4L2_PIX_FMT_SGRBG10ALAW8,	.pixel_enc = V4L2_PIXEL_ENC_BAYER, .mem_planes = 1, .comp_planes = 1, .bpp = { 1, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
316 		{ .format = V4L2_PIX_FMT_SRGGB10ALAW8,	.pixel_enc = V4L2_PIXEL_ENC_BAYER, .mem_planes = 1, .comp_planes = 1, .bpp = { 1, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
317 		{ .format = V4L2_PIX_FMT_SBGGR10DPCM8,	.pixel_enc = V4L2_PIXEL_ENC_BAYER, .mem_planes = 1, .comp_planes = 1, .bpp = { 1, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
318 		{ .format = V4L2_PIX_FMT_SGBRG10DPCM8,	.pixel_enc = V4L2_PIXEL_ENC_BAYER, .mem_planes = 1, .comp_planes = 1, .bpp = { 1, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
319 		{ .format = V4L2_PIX_FMT_SGRBG10DPCM8,	.pixel_enc = V4L2_PIXEL_ENC_BAYER, .mem_planes = 1, .comp_planes = 1, .bpp = { 1, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
320 		{ .format = V4L2_PIX_FMT_SRGGB10DPCM8,	.pixel_enc = V4L2_PIXEL_ENC_BAYER, .mem_planes = 1, .comp_planes = 1, .bpp = { 1, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
321 		{ .format = V4L2_PIX_FMT_SBGGR12,	.pixel_enc = V4L2_PIXEL_ENC_BAYER, .mem_planes = 1, .comp_planes = 1, .bpp = { 2, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
322 		{ .format = V4L2_PIX_FMT_SGBRG12,	.pixel_enc = V4L2_PIXEL_ENC_BAYER, .mem_planes = 1, .comp_planes = 1, .bpp = { 2, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
323 		{ .format = V4L2_PIX_FMT_SGRBG12,	.pixel_enc = V4L2_PIXEL_ENC_BAYER, .mem_planes = 1, .comp_planes = 1, .bpp = { 2, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
324 		{ .format = V4L2_PIX_FMT_SRGGB12,	.pixel_enc = V4L2_PIXEL_ENC_BAYER, .mem_planes = 1, .comp_planes = 1, .bpp = { 2, 0, 0, 0 }, .bpp_div = { 1, 1, 1, 1 }, .hdiv = 1, .vdiv = 1 },
325 	};
326 	unsigned int i;
327 
328 	for (i = 0; i < ARRAY_SIZE(formats); ++i)
329 		if (formats[i].format == format)
330 			return &formats[i];
331 	return NULL;
332 }
333 EXPORT_SYMBOL(v4l2_format_info);
334 
335 static inline unsigned int v4l2_format_block_width(const struct v4l2_format_info *info, int plane)
336 {
337 	if (!info->block_w[plane])
338 		return 1;
339 	return info->block_w[plane];
340 }
341 
342 static inline unsigned int v4l2_format_block_height(const struct v4l2_format_info *info, int plane)
343 {
344 	if (!info->block_h[plane])
345 		return 1;
346 	return info->block_h[plane];
347 }
348 
349 void v4l2_apply_frmsize_constraints(u32 *width, u32 *height,
350 				    const struct v4l2_frmsize_stepwise *frmsize)
351 {
352 	if (!frmsize)
353 		return;
354 
355 	/*
356 	 * Clamp width/height to meet min/max constraints and round it up to
357 	 * macroblock alignment.
358 	 */
359 	*width = clamp_roundup(*width, frmsize->min_width, frmsize->max_width,
360 			       frmsize->step_width);
361 	*height = clamp_roundup(*height, frmsize->min_height, frmsize->max_height,
362 				frmsize->step_height);
363 }
364 EXPORT_SYMBOL_GPL(v4l2_apply_frmsize_constraints);
365 
366 int v4l2_fill_pixfmt_mp(struct v4l2_pix_format_mplane *pixfmt,
367 			u32 pixelformat, u32 width, u32 height)
368 {
369 	const struct v4l2_format_info *info;
370 	struct v4l2_plane_pix_format *plane;
371 	int i;
372 
373 	info = v4l2_format_info(pixelformat);
374 	if (!info)
375 		return -EINVAL;
376 
377 	pixfmt->width = width;
378 	pixfmt->height = height;
379 	pixfmt->pixelformat = pixelformat;
380 	pixfmt->num_planes = info->mem_planes;
381 
382 	if (info->mem_planes == 1) {
383 		plane = &pixfmt->plane_fmt[0];
384 		plane->bytesperline = ALIGN(width, v4l2_format_block_width(info, 0)) * info->bpp[0] / info->bpp_div[0];
385 		plane->sizeimage = 0;
386 
387 		for (i = 0; i < info->comp_planes; i++) {
388 			unsigned int hdiv = (i == 0) ? 1 : info->hdiv;
389 			unsigned int vdiv = (i == 0) ? 1 : info->vdiv;
390 			unsigned int aligned_width;
391 			unsigned int aligned_height;
392 
393 			aligned_width = ALIGN(width, v4l2_format_block_width(info, i));
394 			aligned_height = ALIGN(height, v4l2_format_block_height(info, i));
395 
396 			plane->sizeimage += info->bpp[i] *
397 				DIV_ROUND_UP(aligned_width, hdiv) *
398 				DIV_ROUND_UP(aligned_height, vdiv) / info->bpp_div[i];
399 		}
400 	} else {
401 		for (i = 0; i < info->comp_planes; i++) {
402 			unsigned int hdiv = (i == 0) ? 1 : info->hdiv;
403 			unsigned int vdiv = (i == 0) ? 1 : info->vdiv;
404 			unsigned int aligned_width;
405 			unsigned int aligned_height;
406 
407 			aligned_width = ALIGN(width, v4l2_format_block_width(info, i));
408 			aligned_height = ALIGN(height, v4l2_format_block_height(info, i));
409 
410 			plane = &pixfmt->plane_fmt[i];
411 			plane->bytesperline =
412 				info->bpp[i] * DIV_ROUND_UP(aligned_width, hdiv) / info->bpp_div[i];
413 			plane->sizeimage =
414 				plane->bytesperline * DIV_ROUND_UP(aligned_height, vdiv);
415 		}
416 	}
417 	return 0;
418 }
419 EXPORT_SYMBOL_GPL(v4l2_fill_pixfmt_mp);
420 
421 int v4l2_fill_pixfmt(struct v4l2_pix_format *pixfmt, u32 pixelformat,
422 		     u32 width, u32 height)
423 {
424 	const struct v4l2_format_info *info;
425 	int i;
426 
427 	info = v4l2_format_info(pixelformat);
428 	if (!info)
429 		return -EINVAL;
430 
431 	/* Single planar API cannot be used for multi plane formats. */
432 	if (info->mem_planes > 1)
433 		return -EINVAL;
434 
435 	pixfmt->width = width;
436 	pixfmt->height = height;
437 	pixfmt->pixelformat = pixelformat;
438 	pixfmt->bytesperline = ALIGN(width, v4l2_format_block_width(info, 0)) * info->bpp[0] / info->bpp_div[0];
439 	pixfmt->sizeimage = 0;
440 
441 	for (i = 0; i < info->comp_planes; i++) {
442 		unsigned int hdiv = (i == 0) ? 1 : info->hdiv;
443 		unsigned int vdiv = (i == 0) ? 1 : info->vdiv;
444 		unsigned int aligned_width;
445 		unsigned int aligned_height;
446 
447 		aligned_width = ALIGN(width, v4l2_format_block_width(info, i));
448 		aligned_height = ALIGN(height, v4l2_format_block_height(info, i));
449 
450 		pixfmt->sizeimage += info->bpp[i] *
451 			DIV_ROUND_UP(aligned_width, hdiv) *
452 			DIV_ROUND_UP(aligned_height, vdiv) / info->bpp_div[i];
453 	}
454 	return 0;
455 }
456 EXPORT_SYMBOL_GPL(v4l2_fill_pixfmt);
457 
458 s64 v4l2_get_link_freq(struct v4l2_ctrl_handler *handler, unsigned int mul,
459 		       unsigned int div)
460 {
461 	struct v4l2_ctrl *ctrl;
462 	s64 freq;
463 
464 	ctrl = v4l2_ctrl_find(handler, V4L2_CID_LINK_FREQ);
465 	if (ctrl) {
466 		struct v4l2_querymenu qm = { .id = V4L2_CID_LINK_FREQ };
467 		int ret;
468 
469 		qm.index = v4l2_ctrl_g_ctrl(ctrl);
470 
471 		ret = v4l2_querymenu(handler, &qm);
472 		if (ret)
473 			return -ENOENT;
474 
475 		freq = qm.value;
476 	} else {
477 		if (!mul || !div)
478 			return -ENOENT;
479 
480 		ctrl = v4l2_ctrl_find(handler, V4L2_CID_PIXEL_RATE);
481 		if (!ctrl)
482 			return -ENOENT;
483 
484 		freq = div_u64(v4l2_ctrl_g_ctrl_int64(ctrl) * mul, div);
485 
486 		pr_warn("%s: Link frequency estimated using pixel rate: result might be inaccurate\n",
487 			__func__);
488 		pr_warn("%s: Consider implementing support for V4L2_CID_LINK_FREQ in the transmitter driver\n",
489 			__func__);
490 	}
491 
492 	return freq > 0 ? freq : -EINVAL;
493 }
494 EXPORT_SYMBOL_GPL(v4l2_get_link_freq);
495 
496 /*
497  * Simplify a fraction using a simple continued fraction decomposition. The
498  * idea here is to convert fractions such as 333333/10000000 to 1/30 using
499  * 32 bit arithmetic only. The algorithm is not perfect and relies upon two
500  * arbitrary parameters to remove non-significative terms from the simple
501  * continued fraction decomposition. Using 8 and 333 for n_terms and threshold
502  * respectively seems to give nice results.
503  */
504 void v4l2_simplify_fraction(u32 *numerator, u32 *denominator,
505 		unsigned int n_terms, unsigned int threshold)
506 {
507 	u32 *an;
508 	u32 x, y, r;
509 	unsigned int i, n;
510 
511 	an = kmalloc_array(n_terms, sizeof(*an), GFP_KERNEL);
512 	if (an == NULL)
513 		return;
514 
515 	/*
516 	 * Convert the fraction to a simple continued fraction. See
517 	 * https://en.wikipedia.org/wiki/Continued_fraction
518 	 * Stop if the current term is bigger than or equal to the given
519 	 * threshold.
520 	 */
521 	x = *numerator;
522 	y = *denominator;
523 
524 	for (n = 0; n < n_terms && y != 0; ++n) {
525 		an[n] = x / y;
526 		if (an[n] >= threshold) {
527 			if (n < 2)
528 				n++;
529 			break;
530 		}
531 
532 		r = x - an[n] * y;
533 		x = y;
534 		y = r;
535 	}
536 
537 	/* Expand the simple continued fraction back to an integer fraction. */
538 	x = 0;
539 	y = 1;
540 
541 	for (i = n; i > 0; --i) {
542 		r = y;
543 		y = an[i-1] * y + x;
544 		x = r;
545 	}
546 
547 	*numerator = y;
548 	*denominator = x;
549 	kfree(an);
550 }
551 EXPORT_SYMBOL_GPL(v4l2_simplify_fraction);
552 
553 /*
554  * Convert a fraction to a frame interval in 100ns multiples. The idea here is
555  * to compute numerator / denominator * 10000000 using 32 bit fixed point
556  * arithmetic only.
557  */
558 u32 v4l2_fraction_to_interval(u32 numerator, u32 denominator)
559 {
560 	u32 multiplier;
561 
562 	/* Saturate the result if the operation would overflow. */
563 	if (denominator == 0 ||
564 	    numerator/denominator >= ((u32)-1)/10000000)
565 		return (u32)-1;
566 
567 	/*
568 	 * Divide both the denominator and the multiplier by two until
569 	 * numerator * multiplier doesn't overflow. If anyone knows a better
570 	 * algorithm please let me know.
571 	 */
572 	multiplier = 10000000;
573 	while (numerator > ((u32)-1)/multiplier) {
574 		multiplier /= 2;
575 		denominator /= 2;
576 	}
577 
578 	return denominator ? numerator * multiplier / denominator : 0;
579 }
580 EXPORT_SYMBOL_GPL(v4l2_fraction_to_interval);
581