]> git.proxmox.com Git - mirror_ubuntu-focal-kernel.git/blob - drivers/media/video/v4l2-common.c
projects / mirror_ubuntu-focal-kernel.git / blob
? search:


49f1df74aa21d9f008717d598be1ae8a87a9c7bc
[mirror_ubuntu-focal-kernel.git] / drivers / media / video / v4l2-common.c
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@redhat.com>
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/smp_lock.h>
51 #include <linux/mm.h>
52 #include <linux/string.h>
53 #include <linux/errno.h>
54 #include <linux/i2c.h>
55 #include <asm/uaccess.h>
56 #include <asm/system.h>
57 #include <asm/pgtable.h>
58 #include <asm/io.h>
59 #include <asm/div64.h>
60 #include <linux/video_decoder.h>
61 #define __OLD_VIDIOC_ /* To allow fixing old calls*/
62 #include <media/v4l2-common.h>
63 #include <media/v4l2-chip-ident.h>
64
65 #ifdef CONFIG_KMOD
66 #include <linux/kmod.h>
67 #endif
68
69 #if defined(CONFIG_UST) || defined(CONFIG_UST_MODULE)
70 #include <linux/ust.h>
71 #endif
72
73
74 #include <linux/videodev.h>
75
76 MODULE_AUTHOR("Bill Dirks, Justin Schoeman, Gerd Knorr");
77 MODULE_DESCRIPTION("misc helper functions for v4l2 device drivers");
78 MODULE_LICENSE("GPL");
79
80 /*
81 *
82 * V 4 L 2 D R I V E R H E L P E R A P I
83 *
84 */
85
86 /*
87 * Video Standard Operations (contributed by Michael Schimek)
88 */
89
90
91 char *v4l2_norm_to_name(v4l2_std_id id)
92 {
93 char *name;
94 u32 myid = id;
95
96 /* HACK: ppc32 architecture doesn't have __ucmpdi2 function to handle
97 64 bit comparations. So, on that architecture, with some gcc variants,
98 compilation fails. Currently, the max value is 30bit wide.
99 */
100 BUG_ON(myid != id);
101
102 switch (myid) {
103 case V4L2_STD_PAL:
104 name="PAL"; break;
105 case V4L2_STD_PAL_BG:
106 name="PAL-BG"; break;
107 case V4L2_STD_PAL_DK:
108 name="PAL-DK"; break;
109 case V4L2_STD_PAL_B:
110 name="PAL-B"; break;
111 case V4L2_STD_PAL_B1:
112 name="PAL-B1"; break;
113 case V4L2_STD_PAL_G:
114 name="PAL-G"; break;
115 case V4L2_STD_PAL_H:
116 name="PAL-H"; break;
117 case V4L2_STD_PAL_I:
118 name="PAL-I"; break;
119 case V4L2_STD_PAL_D:
120 name="PAL-D"; break;
121 case V4L2_STD_PAL_D1:
122 name="PAL-D1"; break;
123 case V4L2_STD_PAL_K:
124 name="PAL-K"; break;
125 case V4L2_STD_PAL_M:
126 name="PAL-M"; break;
127 case V4L2_STD_PAL_N:
128 name="PAL-N"; break;
129 case V4L2_STD_PAL_Nc:
130 name="PAL-Nc"; break;
131 case V4L2_STD_PAL_60:
132 name="PAL-60"; break;
133 case V4L2_STD_NTSC:
134 name="NTSC"; break;
135 case V4L2_STD_NTSC_M:
136 name="NTSC-M"; break;
137 case V4L2_STD_NTSC_M_JP:
138 name="NTSC-M-JP"; break;
139 case V4L2_STD_NTSC_443:
140 name="NTSC-443"; break;
141 case V4L2_STD_NTSC_M_KR:
142 name="NTSC-M-KR"; break;
143 case V4L2_STD_SECAM:
144 name="SECAM"; break;
145 case V4L2_STD_SECAM_DK:
146 name="SECAM-DK"; break;
147 case V4L2_STD_SECAM_B:
148 name="SECAM-B"; break;
149 case V4L2_STD_SECAM_D:
150 name="SECAM-D"; break;
151 case V4L2_STD_SECAM_G:
152 name="SECAM-G"; break;
153 case V4L2_STD_SECAM_H:
154 name="SECAM-H"; break;
155 case V4L2_STD_SECAM_K:
156 name="SECAM-K"; break;
157 case V4L2_STD_SECAM_K1:
158 name="SECAM-K1"; break;
159 case V4L2_STD_SECAM_L:
160 name="SECAM-L"; break;
161 case V4L2_STD_SECAM_LC:
162 name="SECAM-LC"; break;
163 default:
164 name="Unknown"; break;
165 }
166
167 return name;
168 }
169
170 /* Fill in the fields of a v4l2_standard structure according to the
171 'id' and 'transmission' parameters. Returns negative on error. */
172 int v4l2_video_std_construct(struct v4l2_standard *vs,
173 int id, char *name)
174 {
175 u32 index = vs->index;
176
177 memset(vs, 0, sizeof(struct v4l2_standard));
178 vs->index = index;
179 vs->id = id;
180 if (id & V4L2_STD_525_60) {
181 vs->frameperiod.numerator = 1001;
182 vs->frameperiod.denominator = 30000;
183 vs->framelines = 525;
184 } else {
185 vs->frameperiod.numerator = 1;
186 vs->frameperiod.denominator = 25;
187 vs->framelines = 625;
188 }
189 strlcpy(vs->name,name,sizeof(vs->name));
190 return 0;
191 }
192
193 /* ----------------------------------------------------------------- */
194 /* priority handling */
195
196 #define V4L2_PRIO_VALID(val) (val == V4L2_PRIORITY_BACKGROUND || \
197 val == V4L2_PRIORITY_INTERACTIVE || \
198 val == V4L2_PRIORITY_RECORD)
199
200 int v4l2_prio_init(struct v4l2_prio_state *global)
201 {
202 memset(global,0,sizeof(*global));
203 return 0;
204 }
205
206 int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
207 enum v4l2_priority new)
208 {
209 if (!V4L2_PRIO_VALID(new))
210 return -EINVAL;
211 if (*local == new)
212 return 0;
213
214 atomic_inc(&global->prios[new]);
215 if (V4L2_PRIO_VALID(*local))
216 atomic_dec(&global->prios[*local]);
217 *local = new;
218 return 0;
219 }
220
221 int v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local)
222 {
223 return v4l2_prio_change(global,local,V4L2_PRIORITY_DEFAULT);
224 }
225
226 int v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority *local)
227 {
228 if (V4L2_PRIO_VALID(*local))
229 atomic_dec(&global->prios[*local]);
230 return 0;
231 }
232
233 enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global)
234 {
235 if (atomic_read(&global->prios[V4L2_PRIORITY_RECORD]) > 0)
236 return V4L2_PRIORITY_RECORD;
237 if (atomic_read(&global->prios[V4L2_PRIORITY_INTERACTIVE]) > 0)
238 return V4L2_PRIORITY_INTERACTIVE;
239 if (atomic_read(&global->prios[V4L2_PRIORITY_BACKGROUND]) > 0)
240 return V4L2_PRIORITY_BACKGROUND;
241 return V4L2_PRIORITY_UNSET;
242 }
243
244 int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority *local)
245 {
246 if (*local < v4l2_prio_max(global))
247 return -EBUSY;
248 return 0;
249 }
250
251
252 /* ----------------------------------------------------------------- */
253 /* some arrays for pretty-printing debug messages of enum types */
254
255 char *v4l2_field_names[] = {
256 [V4L2_FIELD_ANY] = "any",
257 [V4L2_FIELD_NONE] = "none",
258 [V4L2_FIELD_TOP] = "top",
259 [V4L2_FIELD_BOTTOM] = "bottom",
260 [V4L2_FIELD_INTERLACED] = "interlaced",
261 [V4L2_FIELD_SEQ_TB] = "seq-tb",
262 [V4L2_FIELD_SEQ_BT] = "seq-bt",
263 [V4L2_FIELD_ALTERNATE] = "alternate",
264 [V4L2_FIELD_INTERLACED_TB] = "interlaced-tb",
265 [V4L2_FIELD_INTERLACED_BT] = "interlaced-bt",
266 };
267
268 char *v4l2_type_names[] = {
269 [V4L2_BUF_TYPE_VIDEO_CAPTURE] = "video-cap",
270 [V4L2_BUF_TYPE_VIDEO_OVERLAY] = "video-over",
271 [V4L2_BUF_TYPE_VIDEO_OUTPUT] = "video-out",
272 [V4L2_BUF_TYPE_VBI_CAPTURE] = "vbi-cap",
273 [V4L2_BUF_TYPE_VBI_OUTPUT] = "vbi-out",
274 [V4L2_BUF_TYPE_SLICED_VBI_CAPTURE] = "sliced-vbi-cap",
275 [V4L2_BUF_TYPE_SLICED_VBI_OUTPUT] = "sliced-vbi-out",
276 [V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY] = "video-out-over",
277 };
278
279
280 #define prt_names(a,arr) (((a)>=0)&&((a)<ARRAY_SIZE(arr)))?arr[a]:"unknown"
281
282 /* ------------------------------------------------------------------ */
283 /* debug help functions */
284
285 #ifdef CONFIG_VIDEO_V4L1_COMPAT
286 static const char *v4l1_ioctls[] = {
287 [_IOC_NR(VIDIOCGCAP)] = "VIDIOCGCAP",
288 [_IOC_NR(VIDIOCGCHAN)] = "VIDIOCGCHAN",
289 [_IOC_NR(VIDIOCSCHAN)] = "VIDIOCSCHAN",
290 [_IOC_NR(VIDIOCGTUNER)] = "VIDIOCGTUNER",
291 [_IOC_NR(VIDIOCSTUNER)] = "VIDIOCSTUNER",
292 [_IOC_NR(VIDIOCGPICT)] = "VIDIOCGPICT",
293 [_IOC_NR(VIDIOCSPICT)] = "VIDIOCSPICT",
294 [_IOC_NR(VIDIOCCAPTURE)] = "VIDIOCCAPTURE",
295 [_IOC_NR(VIDIOCGWIN)] = "VIDIOCGWIN",
296 [_IOC_NR(VIDIOCSWIN)] = "VIDIOCSWIN",
297 [_IOC_NR(VIDIOCGFBUF)] = "VIDIOCGFBUF",
298 [_IOC_NR(VIDIOCSFBUF)] = "VIDIOCSFBUF",
299 [_IOC_NR(VIDIOCKEY)] = "VIDIOCKEY",
300 [_IOC_NR(VIDIOCGFREQ)] = "VIDIOCGFREQ",
301 [_IOC_NR(VIDIOCSFREQ)] = "VIDIOCSFREQ",
302 [_IOC_NR(VIDIOCGAUDIO)] = "VIDIOCGAUDIO",
303 [_IOC_NR(VIDIOCSAUDIO)] = "VIDIOCSAUDIO",
304 [_IOC_NR(VIDIOCSYNC)] = "VIDIOCSYNC",
305 [_IOC_NR(VIDIOCMCAPTURE)] = "VIDIOCMCAPTURE",
306 [_IOC_NR(VIDIOCGMBUF)] = "VIDIOCGMBUF",
307 [_IOC_NR(VIDIOCGUNIT)] = "VIDIOCGUNIT",
308 [_IOC_NR(VIDIOCGCAPTURE)] = "VIDIOCGCAPTURE",
309 [_IOC_NR(VIDIOCSCAPTURE)] = "VIDIOCSCAPTURE",
310 [_IOC_NR(VIDIOCSPLAYMODE)] = "VIDIOCSPLAYMODE",
311 [_IOC_NR(VIDIOCSWRITEMODE)] = "VIDIOCSWRITEMODE",
312 [_IOC_NR(VIDIOCGPLAYINFO)] = "VIDIOCGPLAYINFO",
313 [_IOC_NR(VIDIOCSMICROCODE)] = "VIDIOCSMICROCODE",
314 [_IOC_NR(VIDIOCGVBIFMT)] = "VIDIOCGVBIFMT",
315 [_IOC_NR(VIDIOCSVBIFMT)] = "VIDIOCSVBIFMT"
316 };
317 #define V4L1_IOCTLS ARRAY_SIZE(v4l1_ioctls)
318 #endif
319
320 static const char *v4l2_ioctls[] = {
321 [_IOC_NR(VIDIOC_QUERYCAP)] = "VIDIOC_QUERYCAP",
322 [_IOC_NR(VIDIOC_RESERVED)] = "VIDIOC_RESERVED",
323 [_IOC_NR(VIDIOC_ENUM_FMT)] = "VIDIOC_ENUM_FMT",
324 [_IOC_NR(VIDIOC_G_FMT)] = "VIDIOC_G_FMT",
325 [_IOC_NR(VIDIOC_S_FMT)] = "VIDIOC_S_FMT",
326 [_IOC_NR(VIDIOC_G_MPEGCOMP)] = "VIDIOC_G_MPEGCOMP",
327 [_IOC_NR(VIDIOC_S_MPEGCOMP)] = "VIDIOC_S_MPEGCOMP",
328 [_IOC_NR(VIDIOC_REQBUFS)] = "VIDIOC_REQBUFS",
329 [_IOC_NR(VIDIOC_QUERYBUF)] = "VIDIOC_QUERYBUF",
330 [_IOC_NR(VIDIOC_G_FBUF)] = "VIDIOC_G_FBUF",
331 [_IOC_NR(VIDIOC_S_FBUF)] = "VIDIOC_S_FBUF",
332 [_IOC_NR(VIDIOC_OVERLAY)] = "VIDIOC_OVERLAY",
333 [_IOC_NR(VIDIOC_QBUF)] = "VIDIOC_QBUF",
334 [_IOC_NR(VIDIOC_DQBUF)] = "VIDIOC_DQBUF",
335 [_IOC_NR(VIDIOC_STREAMON)] = "VIDIOC_STREAMON",
336 [_IOC_NR(VIDIOC_STREAMOFF)] = "VIDIOC_STREAMOFF",
337 [_IOC_NR(VIDIOC_G_PARM)] = "VIDIOC_G_PARM",
338 [_IOC_NR(VIDIOC_S_PARM)] = "VIDIOC_S_PARM",
339 [_IOC_NR(VIDIOC_G_STD)] = "VIDIOC_G_STD",
340 [_IOC_NR(VIDIOC_S_STD)] = "VIDIOC_S_STD",
341 [_IOC_NR(VIDIOC_ENUMSTD)] = "VIDIOC_ENUMSTD",
342 [_IOC_NR(VIDIOC_ENUMINPUT)] = "VIDIOC_ENUMINPUT",
343 [_IOC_NR(VIDIOC_G_CTRL)] = "VIDIOC_G_CTRL",
344 [_IOC_NR(VIDIOC_S_CTRL)] = "VIDIOC_S_CTRL",
345 [_IOC_NR(VIDIOC_G_TUNER)] = "VIDIOC_G_TUNER",
346 [_IOC_NR(VIDIOC_S_TUNER)] = "VIDIOC_S_TUNER",
347 [_IOC_NR(VIDIOC_G_AUDIO)] = "VIDIOC_G_AUDIO",
348 [_IOC_NR(VIDIOC_S_AUDIO)] = "VIDIOC_S_AUDIO",
349 [_IOC_NR(VIDIOC_QUERYCTRL)] = "VIDIOC_QUERYCTRL",
350 [_IOC_NR(VIDIOC_QUERYMENU)] = "VIDIOC_QUERYMENU",
351 [_IOC_NR(VIDIOC_G_INPUT)] = "VIDIOC_G_INPUT",
352 [_IOC_NR(VIDIOC_S_INPUT)] = "VIDIOC_S_INPUT",
353 [_IOC_NR(VIDIOC_G_OUTPUT)] = "VIDIOC_G_OUTPUT",
354 [_IOC_NR(VIDIOC_S_OUTPUT)] = "VIDIOC_S_OUTPUT",
355 [_IOC_NR(VIDIOC_ENUMOUTPUT)] = "VIDIOC_ENUMOUTPUT",
356 [_IOC_NR(VIDIOC_G_AUDOUT)] = "VIDIOC_G_AUDOUT",
357 [_IOC_NR(VIDIOC_S_AUDOUT)] = "VIDIOC_S_AUDOUT",
358 [_IOC_NR(VIDIOC_G_MODULATOR)] = "VIDIOC_G_MODULATOR",
359 [_IOC_NR(VIDIOC_S_MODULATOR)] = "VIDIOC_S_MODULATOR",
360 [_IOC_NR(VIDIOC_G_FREQUENCY)] = "VIDIOC_G_FREQUENCY",
361 [_IOC_NR(VIDIOC_S_FREQUENCY)] = "VIDIOC_S_FREQUENCY",
362 [_IOC_NR(VIDIOC_CROPCAP)] = "VIDIOC_CROPCAP",
363 [_IOC_NR(VIDIOC_G_CROP)] = "VIDIOC_G_CROP",
364 [_IOC_NR(VIDIOC_S_CROP)] = "VIDIOC_S_CROP",
365 [_IOC_NR(VIDIOC_G_JPEGCOMP)] = "VIDIOC_G_JPEGCOMP",
366 [_IOC_NR(VIDIOC_S_JPEGCOMP)] = "VIDIOC_S_JPEGCOMP",
367 [_IOC_NR(VIDIOC_QUERYSTD)] = "VIDIOC_QUERYSTD",
368 [_IOC_NR(VIDIOC_TRY_FMT)] = "VIDIOC_TRY_FMT",
369 [_IOC_NR(VIDIOC_ENUMAUDIO)] = "VIDIOC_ENUMAUDIO",
370 [_IOC_NR(VIDIOC_ENUMAUDOUT)] = "VIDIOC_ENUMAUDOUT",
371 [_IOC_NR(VIDIOC_G_PRIORITY)] = "VIDIOC_G_PRIORITY",
372 [_IOC_NR(VIDIOC_S_PRIORITY)] = "VIDIOC_S_PRIORITY",
373 [_IOC_NR(VIDIOC_G_SLICED_VBI_CAP)] = "VIDIOC_G_SLICED_VBI_CAP",
374 [_IOC_NR(VIDIOC_LOG_STATUS)] = "VIDIOC_LOG_STATUS",
375 [_IOC_NR(VIDIOC_G_EXT_CTRLS)] = "VIDIOC_G_EXT_CTRLS",
376 [_IOC_NR(VIDIOC_S_EXT_CTRLS)] = "VIDIOC_S_EXT_CTRLS",
377 [_IOC_NR(VIDIOC_TRY_EXT_CTRLS)] = "VIDIOC_TRY_EXT_CTRLS",
378 #if 1
379 [_IOC_NR(VIDIOC_ENUM_FRAMESIZES)] = "VIDIOC_ENUM_FRAMESIZES",
380 [_IOC_NR(VIDIOC_ENUM_FRAMEINTERVALS)] = "VIDIOC_ENUM_FRAMEINTERVALS",
381 [_IOC_NR(VIDIOC_G_ENC_INDEX)] = "VIDIOC_G_ENC_INDEX",
382 [_IOC_NR(VIDIOC_ENCODER_CMD)] = "VIDIOC_ENCODER_CMD",
383 [_IOC_NR(VIDIOC_TRY_ENCODER_CMD)] = "VIDIOC_TRY_ENCODER_CMD",
384
385 [_IOC_NR(VIDIOC_DBG_S_REGISTER)] = "VIDIOC_DBG_S_REGISTER",
386 [_IOC_NR(VIDIOC_DBG_G_REGISTER)] = "VIDIOC_DBG_G_REGISTER",
387
388 [_IOC_NR(VIDIOC_G_CHIP_IDENT)] = "VIDIOC_G_CHIP_IDENT",
389 #endif
390 };
391 #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
392
393 static const char *v4l2_int_ioctls[] = {
394 #ifdef CONFIG_VIDEO_V4L1_COMPAT
395 [_IOC_NR(DECODER_GET_CAPABILITIES)] = "DECODER_GET_CAPABILITIES",
396 [_IOC_NR(DECODER_GET_STATUS)] = "DECODER_GET_STATUS",
397 [_IOC_NR(DECODER_SET_NORM)] = "DECODER_SET_NORM",
398 [_IOC_NR(DECODER_SET_INPUT)] = "DECODER_SET_INPUT",
399 [_IOC_NR(DECODER_SET_OUTPUT)] = "DECODER_SET_OUTPUT",
400 [_IOC_NR(DECODER_ENABLE_OUTPUT)] = "DECODER_ENABLE_OUTPUT",
401 [_IOC_NR(DECODER_SET_PICTURE)] = "DECODER_SET_PICTURE",
402 [_IOC_NR(DECODER_SET_GPIO)] = "DECODER_SET_GPIO",
403 [_IOC_NR(DECODER_INIT)] = "DECODER_INIT",
404 [_IOC_NR(DECODER_SET_VBI_BYPASS)] = "DECODER_SET_VBI_BYPASS",
405 [_IOC_NR(DECODER_DUMP)] = "DECODER_DUMP",
406 #endif
407 [_IOC_NR(AUDC_SET_RADIO)] = "AUDC_SET_RADIO",
408
409 [_IOC_NR(TUNER_SET_TYPE_ADDR)] = "TUNER_SET_TYPE_ADDR",
410 [_IOC_NR(TUNER_SET_STANDBY)] = "TUNER_SET_STANDBY",
411 [_IOC_NR(TDA9887_SET_CONFIG)] = "TDA9887_SET_CONFIG",
412
413 [_IOC_NR(VIDIOC_INT_S_TUNER_MODE)] = "VIDIOC_INT_S_TUNER_MODE",
414 [_IOC_NR(VIDIOC_INT_RESET)] = "VIDIOC_INT_RESET",
415 [_IOC_NR(VIDIOC_INT_AUDIO_CLOCK_FREQ)] = "VIDIOC_INT_AUDIO_CLOCK_FREQ",
416 [_IOC_NR(VIDIOC_INT_DECODE_VBI_LINE)] = "VIDIOC_INT_DECODE_VBI_LINE",
417 [_IOC_NR(VIDIOC_INT_S_VBI_DATA)] = "VIDIOC_INT_S_VBI_DATA",
418 [_IOC_NR(VIDIOC_INT_G_VBI_DATA)] = "VIDIOC_INT_G_VBI_DATA",
419 [_IOC_NR(VIDIOC_INT_I2S_CLOCK_FREQ)] = "VIDIOC_INT_I2S_CLOCK_FREQ",
420 [_IOC_NR(VIDIOC_INT_S_STANDBY)] = "VIDIOC_INT_S_STANDBY",
421 [_IOC_NR(VIDIOC_INT_S_AUDIO_ROUTING)] = "VIDIOC_INT_S_AUDIO_ROUTING",
422 [_IOC_NR(VIDIOC_INT_G_AUDIO_ROUTING)] = "VIDIOC_INT_G_AUDIO_ROUTING",
423 [_IOC_NR(VIDIOC_INT_S_VIDEO_ROUTING)] = "VIDIOC_INT_S_VIDEO_ROUTING",
424 [_IOC_NR(VIDIOC_INT_G_VIDEO_ROUTING)] = "VIDIOC_INT_G_VIDEO_ROUTING",
425 [_IOC_NR(VIDIOC_INT_S_CRYSTAL_FREQ)] = "VIDIOC_INT_S_CRYSTAL_FREQ",
426 [_IOC_NR(VIDIOC_INT_INIT)] = "VIDIOC_INT_INIT",
427 [_IOC_NR(VIDIOC_INT_G_STD_OUTPUT)] = "VIDIOC_INT_G_STD_OUTPUT",
428 [_IOC_NR(VIDIOC_INT_S_STD_OUTPUT)] = "VIDIOC_INT_S_STD_OUTPUT",
429 };
430 #define V4L2_INT_IOCTLS ARRAY_SIZE(v4l2_int_ioctls)
431
432
433 /* Common ioctl debug function. This function can be used by
434 external ioctl messages as well as internal V4L ioctl */
435 void v4l_printk_ioctl(unsigned int cmd)
436 {
437 char *dir;
438
439 switch (_IOC_DIR(cmd)) {
440 case _IOC_NONE: dir = "--"; break;
441 case _IOC_READ: dir = "r-"; break;
442 case _IOC_WRITE: dir = "-w"; break;
443 case _IOC_READ | _IOC_WRITE: dir = "rw"; break;
444 default: dir = "*ERR*"; break;
445 }
446 switch (_IOC_TYPE(cmd)) {
447 case 'd':
448 printk("v4l2_int ioctl %s, dir=%s (0x%08x)\n",
449 (_IOC_NR(cmd) < V4L2_INT_IOCTLS) ?
450 v4l2_int_ioctls[_IOC_NR(cmd)] : "UNKNOWN", dir, cmd);
451 break;
452 #ifdef CONFIG_VIDEO_V4L1_COMPAT
453 case 'v':
454 printk("v4l1 ioctl %s, dir=%s (0x%08x)\n",
455 (_IOC_NR(cmd) < V4L1_IOCTLS) ?
456 v4l1_ioctls[_IOC_NR(cmd)] : "UNKNOWN", dir, cmd);
457 break;
458 #endif
459 case 'V':
460 printk("v4l2 ioctl %s, dir=%s (0x%08x)\n",
461 (_IOC_NR(cmd) < V4L2_IOCTLS) ?
462 v4l2_ioctls[_IOC_NR(cmd)] : "UNKNOWN", dir, cmd);
463 break;
464
465 default:
466 printk("unknown ioctl '%c', dir=%s, #%d (0x%08x)\n",
467 _IOC_TYPE(cmd), dir, _IOC_NR(cmd), cmd);
468 }
469 }
470
471
472 /* ----------------------------------------------------------------- */
473
474 /* Helper functions for control handling */
475
476 /* Check for correctness of the ctrl's value based on the data from
477 struct v4l2_queryctrl and the available menu items. Note that
478 menu_items may be NULL, in that case it is ignored. */
479 int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl,
480 const char **menu_items)
481 {
482 if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)
483 return -EINVAL;
484 if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED)
485 return -EBUSY;
486 if (qctrl->type == V4L2_CTRL_TYPE_BUTTON ||
487 qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
488 qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
489 return 0;
490 if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum)
491 return -ERANGE;
492 if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) {
493 if (menu_items[ctrl->value] == NULL ||
494 menu_items[ctrl->value][0] == '\0')
495 return -EINVAL;
496 }
497 return 0;
498 }
499
500 /* Returns NULL or a character pointer array containing the menu for
501 the given control ID. The pointer array ends with a NULL pointer.
502 An empty string signifies a menu entry that is invalid. This allows
503 drivers to disable certain options if it is not supported. */
504 const char **v4l2_ctrl_get_menu(u32 id)
505 {
506 static const char *mpeg_audio_sampling_freq[] = {
507 "44.1 kHz",
508 "48 kHz",
509 "32 kHz",
510 NULL
511 };
512 static const char *mpeg_audio_encoding[] = {
513 "Layer I",
514 "Layer II",
515 "Layer III",
516 NULL
517 };
518 static const char *mpeg_audio_l1_bitrate[] = {
519 "32 kbps",
520 "64 kbps",
521 "96 kbps",
522 "128 kbps",
523 "160 kbps",
524 "192 kbps",
525 "224 kbps",
526 "256 kbps",
527 "288 kbps",
528 "320 kbps",
529 "352 kbps",
530 "384 kbps",
531 "416 kbps",
532 "448 kbps",
533 NULL
534 };
535 static const char *mpeg_audio_l2_bitrate[] = {
536 "32 kbps",
537 "48 kbps",
538 "56 kbps",
539 "64 kbps",
540 "80 kbps",
541 "96 kbps",
542 "112 kbps",
543 "128 kbps",
544 "160 kbps",
545 "192 kbps",
546 "224 kbps",
547 "256 kbps",
548 "320 kbps",
549 "384 kbps",
550 NULL
551 };
552 static const char *mpeg_audio_l3_bitrate[] = {
553 "32 kbps",
554 "40 kbps",
555 "48 kbps",
556 "56 kbps",
557 "64 kbps",
558 "80 kbps",
559 "96 kbps",
560 "112 kbps",
561 "128 kbps",
562 "160 kbps",
563 "192 kbps",
564 "224 kbps",
565 "256 kbps",
566 "320 kbps",
567 NULL
568 };
569 static const char *mpeg_audio_mode[] = {
570 "Stereo",
571 "Joint Stereo",
572 "Dual",
573 "Mono",
574 NULL
575 };
576 static const char *mpeg_audio_mode_extension[] = {
577 "Bound 4",
578 "Bound 8",
579 "Bound 12",
580 "Bound 16",
581 NULL
582 };
583 static const char *mpeg_audio_emphasis[] = {
584 "No Emphasis",
585 "50/15 us",
586 "CCITT J17",
587 NULL
588 };
589 static const char *mpeg_audio_crc[] = {
590 "No CRC",
591 "16-bit CRC",
592 NULL
593 };
594 static const char *mpeg_video_encoding[] = {
595 "MPEG-1",
596 "MPEG-2",
597 NULL
598 };
599 static const char *mpeg_video_aspect[] = {
600 "1x1",
601 "4x3",
602 "16x9",
603 "2.21x1",
604 NULL
605 };
606 static const char *mpeg_video_bitrate_mode[] = {
607 "Variable Bitrate",
608 "Constant Bitrate",
609 NULL
610 };
611 static const char *mpeg_stream_type[] = {
612 "MPEG-2 Program Stream",
613 "MPEG-2 Transport Stream",
614 "MPEG-1 System Stream",
615 "MPEG-2 DVD-compatible Stream",
616 "MPEG-1 VCD-compatible Stream",
617 "MPEG-2 SVCD-compatible Stream",
618 NULL
619 };
620 static const char *mpeg_stream_vbi_fmt[] = {
621 "No VBI",
622 "Private packet, IVTV format",
623 NULL
624 };
625
626 switch (id) {
627 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
628 return mpeg_audio_sampling_freq;
629 case V4L2_CID_MPEG_AUDIO_ENCODING:
630 return mpeg_audio_encoding;
631 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
632 return mpeg_audio_l1_bitrate;
633 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
634 return mpeg_audio_l2_bitrate;
635 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
636 return mpeg_audio_l3_bitrate;
637 case V4L2_CID_MPEG_AUDIO_MODE:
638 return mpeg_audio_mode;
639 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
640 return mpeg_audio_mode_extension;
641 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
642 return mpeg_audio_emphasis;
643 case V4L2_CID_MPEG_AUDIO_CRC:
644 return mpeg_audio_crc;
645 case V4L2_CID_MPEG_VIDEO_ENCODING:
646 return mpeg_video_encoding;
647 case V4L2_CID_MPEG_VIDEO_ASPECT:
648 return mpeg_video_aspect;
649 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
650 return mpeg_video_bitrate_mode;
651 case V4L2_CID_MPEG_STREAM_TYPE:
652 return mpeg_stream_type;
653 case V4L2_CID_MPEG_STREAM_VBI_FMT:
654 return mpeg_stream_vbi_fmt;
655 default:
656 return NULL;
657 }
658 }
659
660 /* Fill in a struct v4l2_queryctrl */
661 int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def)
662 {
663 const char *name;
664
665 qctrl->flags = 0;
666 switch (qctrl->id) {
667 /* USER controls */
668 case V4L2_CID_USER_CLASS: name = "User Controls"; break;
669 case V4L2_CID_AUDIO_VOLUME: name = "Volume"; break;
670 case V4L2_CID_AUDIO_MUTE: name = "Mute"; break;
671 case V4L2_CID_AUDIO_BALANCE: name = "Balance"; break;
672 case V4L2_CID_AUDIO_BASS: name = "Bass"; break;
673 case V4L2_CID_AUDIO_TREBLE: name = "Treble"; break;
674 case V4L2_CID_AUDIO_LOUDNESS: name = "Loudness"; break;
675 case V4L2_CID_BRIGHTNESS: name = "Brightness"; break;
676 case V4L2_CID_CONTRAST: name = "Contrast"; break;
677 case V4L2_CID_SATURATION: name = "Saturation"; break;
678 case V4L2_CID_HUE: name = "Hue"; break;
679
680 /* MPEG controls */
681 case V4L2_CID_MPEG_CLASS: name = "MPEG Encoder Controls"; break;
682 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: name = "Audio Sampling Frequency"; break;
683 case V4L2_CID_MPEG_AUDIO_ENCODING: name = "Audio Encoding Layer"; break;
684 case V4L2_CID_MPEG_AUDIO_L1_BITRATE: name = "Audio Layer I Bitrate"; break;
685 case V4L2_CID_MPEG_AUDIO_L2_BITRATE: name = "Audio Layer II Bitrate"; break;
686 case V4L2_CID_MPEG_AUDIO_L3_BITRATE: name = "Audio Layer III Bitrate"; break;
687 case V4L2_CID_MPEG_AUDIO_MODE: name = "Audio Stereo Mode"; break;
688 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: name = "Audio Stereo Mode Extension"; break;
689 case V4L2_CID_MPEG_AUDIO_EMPHASIS: name = "Audio Emphasis"; break;
690 case V4L2_CID_MPEG_AUDIO_CRC: name = "Audio CRC"; break;
691 case V4L2_CID_MPEG_AUDIO_MUTE: name = "Audio Mute"; break;
692 case V4L2_CID_MPEG_VIDEO_ENCODING: name = "Video Encoding"; break;
693 case V4L2_CID_MPEG_VIDEO_ASPECT: name = "Video Aspect"; break;
694 case V4L2_CID_MPEG_VIDEO_B_FRAMES: name = "Video B Frames"; break;
695 case V4L2_CID_MPEG_VIDEO_GOP_SIZE: name = "Video GOP Size"; break;
696 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE: name = "Video GOP Closure"; break;
697 case V4L2_CID_MPEG_VIDEO_PULLDOWN: name = "Video Pulldown"; break;
698 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: name = "Video Bitrate Mode"; break;
699 case V4L2_CID_MPEG_VIDEO_BITRATE: name = "Video Bitrate"; break;
700 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK: name = "Video Peak Bitrate"; break;
701 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: name = "Video Temporal Decimation"; break;
702 case V4L2_CID_MPEG_VIDEO_MUTE: name = "Video Mute"; break;
703 case V4L2_CID_MPEG_VIDEO_MUTE_YUV: name = "Video Mute YUV"; break;
704 case V4L2_CID_MPEG_STREAM_TYPE: name = "Stream Type"; break;
705 case V4L2_CID_MPEG_STREAM_PID_PMT: name = "Stream PMT Program ID"; break;
706 case V4L2_CID_MPEG_STREAM_PID_AUDIO: name = "Stream Audio Program ID"; break;
707 case V4L2_CID_MPEG_STREAM_PID_VIDEO: name = "Stream Video Program ID"; break;
708 case V4L2_CID_MPEG_STREAM_PID_PCR: name = "Stream PCR Program ID"; break;
709 case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: name = "Stream PES Audio ID"; break;
710 case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: name = "Stream PES Video ID"; break;
711 case V4L2_CID_MPEG_STREAM_VBI_FMT: name = "Stream VBI Format"; break;
712
713 default:
714 return -EINVAL;
715 }
716 switch (qctrl->id) {
717 case V4L2_CID_AUDIO_MUTE:
718 case V4L2_CID_AUDIO_LOUDNESS:
719 case V4L2_CID_MPEG_AUDIO_MUTE:
720 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
721 case V4L2_CID_MPEG_VIDEO_PULLDOWN:
722 qctrl->type = V4L2_CTRL_TYPE_BOOLEAN;
723 min = 0;
724 max = step = 1;
725 break;
726 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
727 case V4L2_CID_MPEG_AUDIO_ENCODING:
728 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
729 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
730 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
731 case V4L2_CID_MPEG_AUDIO_MODE:
732 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
733 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
734 case V4L2_CID_MPEG_AUDIO_CRC:
735 case V4L2_CID_MPEG_VIDEO_ENCODING:
736 case V4L2_CID_MPEG_VIDEO_ASPECT:
737 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
738 case V4L2_CID_MPEG_STREAM_TYPE:
739 case V4L2_CID_MPEG_STREAM_VBI_FMT:
740 qctrl->type = V4L2_CTRL_TYPE_MENU;
741 step = 1;
742 break;
743 case V4L2_CID_USER_CLASS:
744 case V4L2_CID_MPEG_CLASS:
745 qctrl->type = V4L2_CTRL_TYPE_CTRL_CLASS;
746 qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
747 min = max = step = def = 0;
748 break;
749 default:
750 qctrl->type = V4L2_CTRL_TYPE_INTEGER;
751 break;
752 }
753 switch (qctrl->id) {
754 case V4L2_CID_MPEG_AUDIO_ENCODING:
755 case V4L2_CID_MPEG_AUDIO_MODE:
756 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
757 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
758 case V4L2_CID_MPEG_STREAM_TYPE:
759 qctrl->flags |= V4L2_CTRL_FLAG_UPDATE;
760 break;
761 case V4L2_CID_AUDIO_VOLUME:
762 case V4L2_CID_AUDIO_BALANCE:
763 case V4L2_CID_AUDIO_BASS:
764 case V4L2_CID_AUDIO_TREBLE:
765 case V4L2_CID_BRIGHTNESS:
766 case V4L2_CID_CONTRAST:
767 case V4L2_CID_SATURATION:
768 case V4L2_CID_HUE:
769 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
770 break;
771 }
772 qctrl->minimum = min;
773 qctrl->maximum = max;
774 qctrl->step = step;
775 qctrl->default_value = def;
776 qctrl->reserved[0] = qctrl->reserved[1] = 0;
777 snprintf(qctrl->name, sizeof(qctrl->name), name);
778 return 0;
779 }
780
781 /* Fill in a struct v4l2_queryctrl with standard values based on
782 the control ID. */
783 int v4l2_ctrl_query_fill_std(struct v4l2_queryctrl *qctrl)
784 {
785 switch (qctrl->id) {
786 /* USER controls */
787 case V4L2_CID_USER_CLASS:
788 case V4L2_CID_MPEG_CLASS:
789 return v4l2_ctrl_query_fill(qctrl, 0, 0, 0, 0);
790 case V4L2_CID_AUDIO_VOLUME:
791 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 58880);
792 case V4L2_CID_AUDIO_MUTE:
793 case V4L2_CID_AUDIO_LOUDNESS:
794 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
795 case V4L2_CID_AUDIO_BALANCE:
796 case V4L2_CID_AUDIO_BASS:
797 case V4L2_CID_AUDIO_TREBLE:
798 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 32768);
799 case V4L2_CID_BRIGHTNESS:
800 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 128);
801 case V4L2_CID_CONTRAST:
802 case V4L2_CID_SATURATION:
803 return v4l2_ctrl_query_fill(qctrl, 0, 127, 1, 64);
804 case V4L2_CID_HUE:
805 return v4l2_ctrl_query_fill(qctrl, -128, 127, 1, 0);
806
807 /* MPEG controls */
808 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
809 return v4l2_ctrl_query_fill(qctrl,
810 V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100,
811 V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000, 1,
812 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000);
813 case V4L2_CID_MPEG_AUDIO_ENCODING:
814 return v4l2_ctrl_query_fill(qctrl,
815 V4L2_MPEG_AUDIO_ENCODING_LAYER_1,
816 V4L2_MPEG_AUDIO_ENCODING_LAYER_3, 1,
817 V4L2_MPEG_AUDIO_ENCODING_LAYER_2);
818 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
819 return v4l2_ctrl_query_fill(qctrl,
820 V4L2_MPEG_AUDIO_L1_BITRATE_32K,
821 V4L2_MPEG_AUDIO_L1_BITRATE_448K, 1,
822 V4L2_MPEG_AUDIO_L1_BITRATE_256K);
823 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
824 return v4l2_ctrl_query_fill(qctrl,
825 V4L2_MPEG_AUDIO_L2_BITRATE_32K,
826 V4L2_MPEG_AUDIO_L2_BITRATE_384K, 1,
827 V4L2_MPEG_AUDIO_L2_BITRATE_224K);
828 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
829 return v4l2_ctrl_query_fill(qctrl,
830 V4L2_MPEG_AUDIO_L3_BITRATE_32K,
831 V4L2_MPEG_AUDIO_L3_BITRATE_320K, 1,
832 V4L2_MPEG_AUDIO_L3_BITRATE_192K);
833 case V4L2_CID_MPEG_AUDIO_MODE:
834 return v4l2_ctrl_query_fill(qctrl,
835 V4L2_MPEG_AUDIO_MODE_STEREO,
836 V4L2_MPEG_AUDIO_MODE_MONO, 1,
837 V4L2_MPEG_AUDIO_MODE_STEREO);
838 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
839 return v4l2_ctrl_query_fill(qctrl,
840 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4,
841 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16, 1,
842 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4);
843 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
844 return v4l2_ctrl_query_fill(qctrl,
845 V4L2_MPEG_AUDIO_EMPHASIS_NONE,
846 V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17, 1,
847 V4L2_MPEG_AUDIO_EMPHASIS_NONE);
848 case V4L2_CID_MPEG_AUDIO_CRC:
849 return v4l2_ctrl_query_fill(qctrl,
850 V4L2_MPEG_AUDIO_CRC_NONE,
851 V4L2_MPEG_AUDIO_CRC_CRC16, 1,
852 V4L2_MPEG_AUDIO_CRC_NONE);
853 case V4L2_CID_MPEG_AUDIO_MUTE:
854 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
855 case V4L2_CID_MPEG_VIDEO_ENCODING:
856 return v4l2_ctrl_query_fill(qctrl,
857 V4L2_MPEG_VIDEO_ENCODING_MPEG_1,
858 V4L2_MPEG_VIDEO_ENCODING_MPEG_2, 1,
859 V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
860 case V4L2_CID_MPEG_VIDEO_ASPECT:
861 return v4l2_ctrl_query_fill(qctrl,
862 V4L2_MPEG_VIDEO_ASPECT_1x1,
863 V4L2_MPEG_VIDEO_ASPECT_221x100, 1,
864 V4L2_MPEG_VIDEO_ASPECT_4x3);
865 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
866 return v4l2_ctrl_query_fill(qctrl, 0, 33, 1, 2);
867 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
868 return v4l2_ctrl_query_fill(qctrl, 1, 34, 1, 12);
869 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
870 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 1);
871 case V4L2_CID_MPEG_VIDEO_PULLDOWN:
872 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
873 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
874 return v4l2_ctrl_query_fill(qctrl,
875 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
876 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 1,
877 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
878 case V4L2_CID_MPEG_VIDEO_BITRATE:
879 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 6000000);
880 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
881 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 8000000);
882 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
883 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
884 case V4L2_CID_MPEG_VIDEO_MUTE:
885 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
886 case V4L2_CID_MPEG_VIDEO_MUTE_YUV: /* Init YUV (really YCbCr) to black */
887 return v4l2_ctrl_query_fill(qctrl, 0, 0xffffff, 1, 0x008080);
888 case V4L2_CID_MPEG_STREAM_TYPE:
889 return v4l2_ctrl_query_fill(qctrl,
890 V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
891 V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD, 1,
892 V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
893 case V4L2_CID_MPEG_STREAM_PID_PMT:
894 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 16);
895 case V4L2_CID_MPEG_STREAM_PID_AUDIO:
896 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 260);
897 case V4L2_CID_MPEG_STREAM_PID_VIDEO:
898 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 256);
899 case V4L2_CID_MPEG_STREAM_PID_PCR:
900 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 259);
901 case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO:
902 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
903 case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO:
904 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
905 case V4L2_CID_MPEG_STREAM_VBI_FMT:
906 return v4l2_ctrl_query_fill(qctrl,
907 V4L2_MPEG_STREAM_VBI_FMT_NONE,
908 V4L2_MPEG_STREAM_VBI_FMT_IVTV, 1,
909 V4L2_MPEG_STREAM_VBI_FMT_NONE);
910 default:
911 return -EINVAL;
912 }
913 }
914
915 /* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and
916 the menu. The qctrl pointer may be NULL, in which case it is ignored. */
917 int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl,
918 const char **menu_items)
919 {
920 int i;
921
922 if (menu_items == NULL ||
923 (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum)))
924 return -EINVAL;
925 for (i = 0; i < qmenu->index && menu_items[i]; i++) ;
926 if (menu_items[i] == NULL || menu_items[i][0] == '\0')
927 return -EINVAL;
928 snprintf(qmenu->name, sizeof(qmenu->name), menu_items[qmenu->index]);
929 qmenu->reserved = 0;
930 return 0;
931 }
932
933 /* ctrl_classes points to an array of u32 pointers, the last element is
934 a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
935 Each array must be sorted low to high and belong to the same control
936 class. The array of u32 pointer must also be sorted, from low class IDs
937 to high class IDs.
938
939 This function returns the first ID that follows after the given ID.
940 When no more controls are available 0 is returned. */
941 u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
942 {
943 u32 ctrl_class;
944 const u32 *pctrl;
945
946 /* if no query is desired, then just return the control ID */
947 if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0)
948 return id;
949 if (ctrl_classes == NULL)
950 return 0;
951 id &= V4L2_CTRL_ID_MASK;
952 ctrl_class = V4L2_CTRL_ID2CLASS(id);
953 id++; /* select next control */
954 /* find first class that matches (or is greater than) the class of
955 the ID */
956 while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
957 ctrl_classes++;
958 /* no more classes */
959 if (*ctrl_classes == NULL)
960 return 0;
961 pctrl = *ctrl_classes;
962 /* find first ctrl within the class that is >= ID */
963 while (*pctrl && *pctrl < id) pctrl++;
964 if (*pctrl)
965 return *pctrl;
966 /* we are at the end of the controls of the current class. */
967 /* continue with next class if available */
968 ctrl_classes++;
969 if (*ctrl_classes == NULL)
970 return 0;
971 return **ctrl_classes;
972 }
973
974 int v4l2_chip_match_i2c_client(struct i2c_client *c, u32 match_type, u32 match_chip)
975 {
976 switch (match_type) {
977 case V4L2_CHIP_MATCH_I2C_DRIVER:
978 return (c != NULL && c->driver != NULL && c->driver->id == match_chip);
979 case V4L2_CHIP_MATCH_I2C_ADDR:
980 return (c != NULL && c->addr == match_chip);
981 default:
982 return 0;
983 }
984 }
985
986 int v4l2_chip_ident_i2c_client(struct i2c_client *c, struct v4l2_chip_ident *chip,
987 u32 ident, u32 revision)
988 {
989 if (!v4l2_chip_match_i2c_client(c, chip->match_type, chip->match_chip))
990 return 0;
991 if (chip->ident == V4L2_IDENT_NONE) {
992 chip->ident = ident;
993 chip->revision = revision;
994 }
995 else {
996 chip->ident = V4L2_IDENT_AMBIGUOUS;
997 chip->revision = 0;
998 }
999 return 0;
1000 }
1001
1002 int v4l2_chip_match_host(u32 match_type, u32 match_chip)
1003 {
1004 switch (match_type) {
1005 case V4L2_CHIP_MATCH_HOST:
1006 return match_chip == 0;
1007 default:
1008 return 0;
1009 }
1010 }
1011
1012 /* ----------------------------------------------------------------- */
1013
1014 EXPORT_SYMBOL(v4l2_norm_to_name);
1015 EXPORT_SYMBOL(v4l2_video_std_construct);
1016
1017 EXPORT_SYMBOL(v4l2_prio_init);
1018 EXPORT_SYMBOL(v4l2_prio_change);
1019 EXPORT_SYMBOL(v4l2_prio_open);
1020 EXPORT_SYMBOL(v4l2_prio_close);
1021 EXPORT_SYMBOL(v4l2_prio_max);
1022 EXPORT_SYMBOL(v4l2_prio_check);
1023
1024 EXPORT_SYMBOL(v4l2_field_names);
1025 EXPORT_SYMBOL(v4l2_type_names);
1026 EXPORT_SYMBOL(v4l_printk_ioctl);
1027
1028 EXPORT_SYMBOL(v4l2_ctrl_next);
1029 EXPORT_SYMBOL(v4l2_ctrl_check);
1030 EXPORT_SYMBOL(v4l2_ctrl_get_menu);
1031 EXPORT_SYMBOL(v4l2_ctrl_query_menu);
1032 EXPORT_SYMBOL(v4l2_ctrl_query_fill);
1033 EXPORT_SYMBOL(v4l2_ctrl_query_fill_std);
1034
1035 EXPORT_SYMBOL(v4l2_chip_match_i2c_client);
1036 EXPORT_SYMBOL(v4l2_chip_ident_i2c_client);
1037 EXPORT_SYMBOL(v4l2_chip_match_host);
1038
1039 /*
1040 * Local variables:
1041 * c-basic-offset: 8
1042 * End:
1043 */
Ubuntu Focal Linux kernel mirror