?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Pull platform-drivers into test branch
[linux-2.6/x86.git] / drivers / media / video / v4l2-common.c
blob752c82c37f558277d14e36f4a150e98e2c9f9e81
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 <bdirks@pacbell.net>
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/sched.h>
51 #include <linux/smp_lock.h>
52 #include <linux/mm.h>
53 #include <linux/string.h>
54 #include <linux/errno.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
64 #ifdef CONFIG_KMOD
65 #include <linux/kmod.h>
66 #endif
67
68 #if defined(CONFIG_UST) || defined(CONFIG_UST_MODULE)
69 #include <linux/ust.h>
70 #endif
71
72
73 #include <linux/videodev.h>
74
75 MODULE_AUTHOR("Bill Dirks, Justin Schoeman, Gerd Knorr");
76 MODULE_DESCRIPTION("misc helper functions for v4l2 device drivers");
77 MODULE_LICENSE("GPL");
78
79 /*
80 *
81 * V 4 L 2 D R I V E R H E L P E R A P I
82 *
83 */
84
85 /*
86 * Video Standard Operations (contributed by Michael Schimek)
87 */
88
89
90 char *v4l2_norm_to_name(v4l2_std_id id)
91 {
92 char *name;
93
94 switch (id) {
95 case V4L2_STD_PAL:
96 name="PAL"; break;
97 case V4L2_STD_PAL_BG:
98 name="PAL-BG"; break;
99 case V4L2_STD_PAL_DK:
100 name="PAL-DK"; break;
101 case V4L2_STD_PAL_B:
102 name="PAL-B"; break;
103 case V4L2_STD_PAL_B1:
104 name="PAL-B1"; break;
105 case V4L2_STD_PAL_G:
106 name="PAL-G"; break;
107 case V4L2_STD_PAL_H:
108 name="PAL-H"; break;
109 case V4L2_STD_PAL_I:
110 name="PAL-I"; break;
111 case V4L2_STD_PAL_D:
112 name="PAL-D"; break;
113 case V4L2_STD_PAL_D1:
114 name="PAL-D1"; break;
115 case V4L2_STD_PAL_K:
116 name="PAL-K"; break;
117 case V4L2_STD_PAL_M:
118 name="PAL-M"; break;
119 case V4L2_STD_PAL_N:
120 name="PAL-N"; break;
121 case V4L2_STD_PAL_Nc:
122 name="PAL-Nc"; break;
123 case V4L2_STD_PAL_60:
124 name="PAL-60"; break;
125 case V4L2_STD_NTSC:
126 name="NTSC"; break;
127 case V4L2_STD_NTSC_M:
128 name="NTSC-M"; break;
129 case V4L2_STD_NTSC_M_JP:
130 name="NTSC-M-JP"; break;
131 case V4L2_STD_NTSC_443:
132 name="NTSC-443"; break;
133 case V4L2_STD_NTSC_M_KR:
134 name="NTSC-M-KR"; break;
135 case V4L2_STD_SECAM:
136 name="SECAM"; break;
137 case V4L2_STD_SECAM_DK:
138 name="SECAM-DK"; break;
139 case V4L2_STD_SECAM_B:
140 name="SECAM-B"; break;
141 case V4L2_STD_SECAM_D:
142 name="SECAM-D"; break;
143 case V4L2_STD_SECAM_G:
144 name="SECAM-G"; break;
145 case V4L2_STD_SECAM_H:
146 name="SECAM-H"; break;
147 case V4L2_STD_SECAM_K:
148 name="SECAM-K"; break;
149 case V4L2_STD_SECAM_K1:
150 name="SECAM-K1"; break;
151 case V4L2_STD_SECAM_L:
152 name="SECAM-L"; break;
153 case V4L2_STD_SECAM_LC:
154 name="SECAM-LC"; break;
155 default:
156 name="Unknown"; break;
157 }
158
159 return name;
160 }
161
162 /* Fill in the fields of a v4l2_standard structure according to the
163 'id' and 'transmission' parameters. Returns negative on error. */
164 int v4l2_video_std_construct(struct v4l2_standard *vs,
165 int id, char *name)
166 {
167 u32 index = vs->index;
168
169 memset(vs, 0, sizeof(struct v4l2_standard));
170 vs->index = index;
171 vs->id = id;
172 if (id & V4L2_STD_525_60) {
173 vs->frameperiod.numerator = 1001;
174 vs->frameperiod.denominator = 30000;
175 vs->framelines = 525;
176 } else {
177 vs->frameperiod.numerator = 1;
178 vs->frameperiod.denominator = 25;
179 vs->framelines = 625;
180 }
181 strlcpy(vs->name,name,sizeof(vs->name));
182 return 0;
183 }
184
185 /* ----------------------------------------------------------------- */
186 /* priority handling */
187
188 #define V4L2_PRIO_VALID(val) (val == V4L2_PRIORITY_BACKGROUND || \
189 val == V4L2_PRIORITY_INTERACTIVE || \
190 val == V4L2_PRIORITY_RECORD)
191
192 int v4l2_prio_init(struct v4l2_prio_state *global)
193 {
194 memset(global,0,sizeof(*global));
195 return 0;
196 }
197
198 int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local,
199 enum v4l2_priority new)
200 {
201 if (!V4L2_PRIO_VALID(new))
202 return -EINVAL;
203 if (*local == new)
204 return 0;
205
206 atomic_inc(&global->prios[new]);
207 if (V4L2_PRIO_VALID(*local))
208 atomic_dec(&global->prios[*local]);
209 *local = new;
210 return 0;
211 }
212
213 int v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local)
214 {
215 return v4l2_prio_change(global,local,V4L2_PRIORITY_DEFAULT);
216 }
217
218 int v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority *local)
219 {
220 if (V4L2_PRIO_VALID(*local))
221 atomic_dec(&global->prios[*local]);
222 return 0;
223 }
224
225 enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global)
226 {
227 if (atomic_read(&global->prios[V4L2_PRIORITY_RECORD]) > 0)
228 return V4L2_PRIORITY_RECORD;
229 if (atomic_read(&global->prios[V4L2_PRIORITY_INTERACTIVE]) > 0)
230 return V4L2_PRIORITY_INTERACTIVE;
231 if (atomic_read(&global->prios[V4L2_PRIORITY_BACKGROUND]) > 0)
232 return V4L2_PRIORITY_BACKGROUND;
233 return V4L2_PRIORITY_UNSET;
234 }
235
236 int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority *local)
237 {
238 if (*local < v4l2_prio_max(global))
239 return -EBUSY;
240 return 0;
241 }
242
243
244 /* ----------------------------------------------------------------- */
245 /* some arrays for pretty-printing debug messages of enum types */
246
247 char *v4l2_field_names[] = {
248 [V4L2_FIELD_ANY] = "any",
249 [V4L2_FIELD_NONE] = "none",
250 [V4L2_FIELD_TOP] = "top",
251 [V4L2_FIELD_BOTTOM] = "bottom",
252 [V4L2_FIELD_INTERLACED] = "interlaced",
253 [V4L2_FIELD_SEQ_TB] = "seq-tb",
254 [V4L2_FIELD_SEQ_BT] = "seq-bt",
255 [V4L2_FIELD_ALTERNATE] = "alternate",
256 };
257
258 char *v4l2_type_names[] = {
259 [V4L2_BUF_TYPE_VIDEO_CAPTURE] = "video-cap",
260 [V4L2_BUF_TYPE_VIDEO_OVERLAY] = "video-over",
261 [V4L2_BUF_TYPE_VIDEO_OUTPUT] = "video-out",
262 [V4L2_BUF_TYPE_VBI_CAPTURE] = "vbi-cap",
263 [V4L2_BUF_TYPE_VBI_OUTPUT] = "vbi-out",
264 [V4L2_BUF_TYPE_SLICED_VBI_CAPTURE] = "sliced-vbi-cap",
265 [V4L2_BUF_TYPE_SLICED_VBI_OUTPUT] = "slicec-vbi-out",
266 };
267
268 static char *v4l2_memory_names[] = {
269 [V4L2_MEMORY_MMAP] = "mmap",
270 [V4L2_MEMORY_USERPTR] = "userptr",
271 [V4L2_MEMORY_OVERLAY] = "overlay",
272 };
273
274 #define prt_names(a,arr) (((a)>=0)&&((a)<ARRAY_SIZE(arr)))?arr[a]:"unknown"
275
276 /* ------------------------------------------------------------------ */
277 /* debug help functions */
278
279 #ifdef CONFIG_VIDEO_V4L1_COMPAT
280 static const char *v4l1_ioctls[] = {
281 [_IOC_NR(VIDIOCGCAP)] = "VIDIOCGCAP",
282 [_IOC_NR(VIDIOCGCHAN)] = "VIDIOCGCHAN",
283 [_IOC_NR(VIDIOCSCHAN)] = "VIDIOCSCHAN",
284 [_IOC_NR(VIDIOCGTUNER)] = "VIDIOCGTUNER",
285 [_IOC_NR(VIDIOCSTUNER)] = "VIDIOCSTUNER",
286 [_IOC_NR(VIDIOCGPICT)] = "VIDIOCGPICT",
287 [_IOC_NR(VIDIOCSPICT)] = "VIDIOCSPICT",
288 [_IOC_NR(VIDIOCCAPTURE)] = "VIDIOCCAPTURE",
289 [_IOC_NR(VIDIOCGWIN)] = "VIDIOCGWIN",
290 [_IOC_NR(VIDIOCSWIN)] = "VIDIOCSWIN",
291 [_IOC_NR(VIDIOCGFBUF)] = "VIDIOCGFBUF",
292 [_IOC_NR(VIDIOCSFBUF)] = "VIDIOCSFBUF",
293 [_IOC_NR(VIDIOCKEY)] = "VIDIOCKEY",
294 [_IOC_NR(VIDIOCGFREQ)] = "VIDIOCGFREQ",
295 [_IOC_NR(VIDIOCSFREQ)] = "VIDIOCSFREQ",
296 [_IOC_NR(VIDIOCGAUDIO)] = "VIDIOCGAUDIO",
297 [_IOC_NR(VIDIOCSAUDIO)] = "VIDIOCSAUDIO",
298 [_IOC_NR(VIDIOCSYNC)] = "VIDIOCSYNC",
299 [_IOC_NR(VIDIOCMCAPTURE)] = "VIDIOCMCAPTURE",
300 [_IOC_NR(VIDIOCGMBUF)] = "VIDIOCGMBUF",
301 [_IOC_NR(VIDIOCGUNIT)] = "VIDIOCGUNIT",
302 [_IOC_NR(VIDIOCGCAPTURE)] = "VIDIOCGCAPTURE",
303 [_IOC_NR(VIDIOCSCAPTURE)] = "VIDIOCSCAPTURE",
304 [_IOC_NR(VIDIOCSPLAYMODE)] = "VIDIOCSPLAYMODE",
305 [_IOC_NR(VIDIOCSWRITEMODE)] = "VIDIOCSWRITEMODE",
306 [_IOC_NR(VIDIOCGPLAYINFO)] = "VIDIOCGPLAYINFO",
307 [_IOC_NR(VIDIOCSMICROCODE)] = "VIDIOCSMICROCODE",
308 [_IOC_NR(VIDIOCGVBIFMT)] = "VIDIOCGVBIFMT",
309 [_IOC_NR(VIDIOCSVBIFMT)] = "VIDIOCSVBIFMT"
310 };
311 #define V4L1_IOCTLS ARRAY_SIZE(v4l1_ioctls)
312 #endif
313
314 static const char *v4l2_ioctls[] = {
315 [_IOC_NR(VIDIOC_QUERYCAP)] = "VIDIOC_QUERYCAP",
316 [_IOC_NR(VIDIOC_RESERVED)] = "VIDIOC_RESERVED",
317 [_IOC_NR(VIDIOC_ENUM_FMT)] = "VIDIOC_ENUM_FMT",
318 [_IOC_NR(VIDIOC_G_FMT)] = "VIDIOC_G_FMT",
319 [_IOC_NR(VIDIOC_S_FMT)] = "VIDIOC_S_FMT",
320 [_IOC_NR(VIDIOC_G_MPEGCOMP)] = "VIDIOC_G_MPEGCOMP",
321 [_IOC_NR(VIDIOC_S_MPEGCOMP)] = "VIDIOC_S_MPEGCOMP",
322 [_IOC_NR(VIDIOC_REQBUFS)] = "VIDIOC_REQBUFS",
323 [_IOC_NR(VIDIOC_QUERYBUF)] = "VIDIOC_QUERYBUF",
324 [_IOC_NR(VIDIOC_G_FBUF)] = "VIDIOC_G_FBUF",
325 [_IOC_NR(VIDIOC_S_FBUF)] = "VIDIOC_S_FBUF",
326 [_IOC_NR(VIDIOC_OVERLAY)] = "VIDIOC_OVERLAY",
327 [_IOC_NR(VIDIOC_QBUF)] = "VIDIOC_QBUF",
328 [_IOC_NR(VIDIOC_DQBUF)] = "VIDIOC_DQBUF",
329 [_IOC_NR(VIDIOC_STREAMON)] = "VIDIOC_STREAMON",
330 [_IOC_NR(VIDIOC_STREAMOFF)] = "VIDIOC_STREAMOFF",
331 [_IOC_NR(VIDIOC_G_PARM)] = "VIDIOC_G_PARM",
332 [_IOC_NR(VIDIOC_S_PARM)] = "VIDIOC_S_PARM",
333 [_IOC_NR(VIDIOC_G_STD)] = "VIDIOC_G_STD",
334 [_IOC_NR(VIDIOC_S_STD)] = "VIDIOC_S_STD",
335 [_IOC_NR(VIDIOC_ENUMSTD)] = "VIDIOC_ENUMSTD",
336 [_IOC_NR(VIDIOC_ENUMINPUT)] = "VIDIOC_ENUMINPUT",
337 [_IOC_NR(VIDIOC_G_CTRL)] = "VIDIOC_G_CTRL",
338 [_IOC_NR(VIDIOC_S_CTRL)] = "VIDIOC_S_CTRL",
339 [_IOC_NR(VIDIOC_G_TUNER)] = "VIDIOC_G_TUNER",
340 [_IOC_NR(VIDIOC_S_TUNER)] = "VIDIOC_S_TUNER",
341 [_IOC_NR(VIDIOC_G_AUDIO)] = "VIDIOC_G_AUDIO",
342 [_IOC_NR(VIDIOC_S_AUDIO)] = "VIDIOC_S_AUDIO",
343 [_IOC_NR(VIDIOC_QUERYCTRL)] = "VIDIOC_QUERYCTRL",
344 [_IOC_NR(VIDIOC_QUERYMENU)] = "VIDIOC_QUERYMENU",
345 [_IOC_NR(VIDIOC_G_INPUT)] = "VIDIOC_G_INPUT",
346 [_IOC_NR(VIDIOC_S_INPUT)] = "VIDIOC_S_INPUT",
347 [_IOC_NR(VIDIOC_G_OUTPUT)] = "VIDIOC_G_OUTPUT",
348 [_IOC_NR(VIDIOC_S_OUTPUT)] = "VIDIOC_S_OUTPUT",
349 [_IOC_NR(VIDIOC_ENUMOUTPUT)] = "VIDIOC_ENUMOUTPUT",
350 [_IOC_NR(VIDIOC_G_AUDOUT)] = "VIDIOC_G_AUDOUT",
351 [_IOC_NR(VIDIOC_S_AUDOUT)] = "VIDIOC_S_AUDOUT",
352 [_IOC_NR(VIDIOC_G_MODULATOR)] = "VIDIOC_G_MODULATOR",
353 [_IOC_NR(VIDIOC_S_MODULATOR)] = "VIDIOC_S_MODULATOR",
354 [_IOC_NR(VIDIOC_G_FREQUENCY)] = "VIDIOC_G_FREQUENCY",
355 [_IOC_NR(VIDIOC_S_FREQUENCY)] = "VIDIOC_S_FREQUENCY",
356 [_IOC_NR(VIDIOC_CROPCAP)] = "VIDIOC_CROPCAP",
357 [_IOC_NR(VIDIOC_G_CROP)] = "VIDIOC_G_CROP",
358 [_IOC_NR(VIDIOC_S_CROP)] = "VIDIOC_S_CROP",
359 [_IOC_NR(VIDIOC_G_JPEGCOMP)] = "VIDIOC_G_JPEGCOMP",
360 [_IOC_NR(VIDIOC_S_JPEGCOMP)] = "VIDIOC_S_JPEGCOMP",
361 [_IOC_NR(VIDIOC_QUERYSTD)] = "VIDIOC_QUERYSTD",
362 [_IOC_NR(VIDIOC_TRY_FMT)] = "VIDIOC_TRY_FMT",
363 [_IOC_NR(VIDIOC_ENUMAUDIO)] = "VIDIOC_ENUMAUDIO",
364 [_IOC_NR(VIDIOC_ENUMAUDOUT)] = "VIDIOC_ENUMAUDOUT",
365 [_IOC_NR(VIDIOC_G_PRIORITY)] = "VIDIOC_G_PRIORITY",
366 [_IOC_NR(VIDIOC_S_PRIORITY)] = "VIDIOC_S_PRIORITY",
367 #if 1
368 [_IOC_NR(VIDIOC_G_SLICED_VBI_CAP)] = "VIDIOC_G_SLICED_VBI_CAP",
369 #endif
370 [_IOC_NR(VIDIOC_LOG_STATUS)] = "VIDIOC_LOG_STATUS",
371 [_IOC_NR(VIDIOC_G_EXT_CTRLS)] = "VIDIOC_G_EXT_CTRLS",
372 [_IOC_NR(VIDIOC_S_EXT_CTRLS)] = "VIDIOC_S_EXT_CTRLS",
373 [_IOC_NR(VIDIOC_TRY_EXT_CTRLS)] = "VIDIOC_TRY_EXT_CTRLS"
374 };
375 #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
376
377 static const char *v4l2_int_ioctls[] = {
378 #ifdef CONFIG_VIDEO_V4L1_COMPAT
379 [_IOC_NR(DECODER_GET_CAPABILITIES)] = "DECODER_GET_CAPABILITIES",
380 [_IOC_NR(DECODER_GET_STATUS)] = "DECODER_GET_STATUS",
381 [_IOC_NR(DECODER_SET_NORM)] = "DECODER_SET_NORM",
382 [_IOC_NR(DECODER_SET_INPUT)] = "DECODER_SET_INPUT",
383 [_IOC_NR(DECODER_SET_OUTPUT)] = "DECODER_SET_OUTPUT",
384 [_IOC_NR(DECODER_ENABLE_OUTPUT)] = "DECODER_ENABLE_OUTPUT",
385 [_IOC_NR(DECODER_SET_PICTURE)] = "DECODER_SET_PICTURE",
386 [_IOC_NR(DECODER_SET_GPIO)] = "DECODER_SET_GPIO",
387 [_IOC_NR(DECODER_INIT)] = "DECODER_INIT",
388 [_IOC_NR(DECODER_SET_VBI_BYPASS)] = "DECODER_SET_VBI_BYPASS",
389 [_IOC_NR(DECODER_DUMP)] = "DECODER_DUMP",
390 #endif
391 [_IOC_NR(AUDC_SET_RADIO)] = "AUDC_SET_RADIO",
392
393 [_IOC_NR(TUNER_SET_TYPE_ADDR)] = "TUNER_SET_TYPE_ADDR",
394 [_IOC_NR(TUNER_SET_STANDBY)] = "TUNER_SET_STANDBY",
395 [_IOC_NR(TDA9887_SET_CONFIG)] = "TDA9887_SET_CONFIG",
396
397 [_IOC_NR(VIDIOC_INT_S_TUNER_MODE)] = "VIDIOC_INT_S_TUNER_MODE",
398 [_IOC_NR(VIDIOC_INT_S_REGISTER)] = "VIDIOC_INT_S_REGISTER",
399 [_IOC_NR(VIDIOC_INT_G_REGISTER)] = "VIDIOC_INT_G_REGISTER",
400 [_IOC_NR(VIDIOC_INT_RESET)] = "VIDIOC_INT_RESET",
401 [_IOC_NR(VIDIOC_INT_AUDIO_CLOCK_FREQ)] = "VIDIOC_INT_AUDIO_CLOCK_FREQ",
402 [_IOC_NR(VIDIOC_INT_DECODE_VBI_LINE)] = "VIDIOC_INT_DECODE_VBI_LINE",
403 [_IOC_NR(VIDIOC_INT_S_VBI_DATA)] = "VIDIOC_INT_S_VBI_DATA",
404 [_IOC_NR(VIDIOC_INT_G_VBI_DATA)] = "VIDIOC_INT_G_VBI_DATA",
405 [_IOC_NR(VIDIOC_INT_G_CHIP_IDENT)] = "VIDIOC_INT_G_CHIP_IDENT",
406 [_IOC_NR(VIDIOC_INT_I2S_CLOCK_FREQ)] = "VIDIOC_INT_I2S_CLOCK_FREQ",
407 [_IOC_NR(VIDIOC_INT_S_STANDBY)] = "VIDIOC_INT_S_STANDBY",
408 [_IOC_NR(VIDIOC_INT_S_AUDIO_ROUTING)] = "VIDIOC_INT_S_AUDIO_ROUTING",
409 [_IOC_NR(VIDIOC_INT_G_AUDIO_ROUTING)] = "VIDIOC_INT_G_AUDIO_ROUTING",
410 [_IOC_NR(VIDIOC_INT_S_VIDEO_ROUTING)] = "VIDIOC_INT_S_VIDEO_ROUTING",
411 [_IOC_NR(VIDIOC_INT_G_VIDEO_ROUTING)] = "VIDIOC_INT_G_VIDEO_ROUTING",
412 [_IOC_NR(VIDIOC_INT_S_CRYSTAL_FREQ)] = "VIDIOC_INT_S_CRYSTAL_FREQ"
413 };
414 #define V4L2_INT_IOCTLS ARRAY_SIZE(v4l2_int_ioctls)
415
416 static void v4l_print_pix_fmt (char *s, struct v4l2_pix_format *fmt)
417 {
418 printk ("%s: width=%d, height=%d, format=%d, field=%s, "
419 "bytesperline=%d sizeimage=%d, colorspace=%d\n", s,
420 fmt->width,fmt->height,fmt->pixelformat,
421 prt_names(fmt->field,v4l2_field_names),
422 fmt->bytesperline,fmt->sizeimage,fmt->colorspace);
423 };
424
425 /* Common ioctl debug function. This function can be used by
426 external ioctl messages as well as internal V4L ioctl */
427 void v4l_printk_ioctl(unsigned int cmd)
428 {
429 char *dir;
430
431 switch (_IOC_DIR(cmd)) {
432 case _IOC_NONE: dir = "--"; break;
433 case _IOC_READ: dir = "r-"; break;
434 case _IOC_WRITE: dir = "-w"; break;
435 case _IOC_READ | _IOC_WRITE: dir = "rw"; break;
436 default: dir = "*ERR*"; break;
437 }
438 switch (_IOC_TYPE(cmd)) {
439 case 'd':
440 printk("v4l2_int ioctl %s, dir=%s (0x%08x)\n",
441 (_IOC_NR(cmd) < V4L2_INT_IOCTLS) ?
442 v4l2_int_ioctls[_IOC_NR(cmd)] : "UNKNOWN", dir, cmd);
443 break;
444 #ifdef CONFIG_VIDEO_V4L1_COMPAT
445 case 'v':
446 printk("v4l1 ioctl %s, dir=%s (0x%08x)\n",
447 (_IOC_NR(cmd) < V4L1_IOCTLS) ?
448 v4l1_ioctls[_IOC_NR(cmd)] : "UNKNOWN", dir, cmd);
449 break;
450 #endif
451 case 'V':
452 printk("v4l2 ioctl %s, dir=%s (0x%08x)\n",
453 (_IOC_NR(cmd) < V4L2_IOCTLS) ?
454 v4l2_ioctls[_IOC_NR(cmd)] : "UNKNOWN", dir, cmd);
455 break;
456
457 default:
458 printk("unknown ioctl '%c', dir=%s, #%d (0x%08x)\n",
459 _IOC_TYPE(cmd), dir, _IOC_NR(cmd), cmd);
460 }
461 }
462
463 /* Common ioctl debug function. This function can be used by
464 external ioctl messages as well as internal V4L ioctl and its
465 arguments */
466 void v4l_printk_ioctl_arg(char *s,unsigned int cmd, void *arg)
467 {
468 printk(s);
469 printk(": ");
470 v4l_printk_ioctl(cmd);
471 switch (cmd) {
472 case VIDIOC_INT_G_CHIP_IDENT:
473 {
474 enum v4l2_chip_ident *p=arg;
475 printk ("%s: chip ident=%d\n", s, *p);
476 break;
477 }
478 case VIDIOC_G_PRIORITY:
479 case VIDIOC_S_PRIORITY:
480 {
481 enum v4l2_priority *p=arg;
482 printk ("%s: priority=%d\n", s, *p);
483 break;
484 }
485 case VIDIOC_INT_S_TUNER_MODE:
486 {
487 enum v4l2_tuner_type *p=arg;
488 printk ("%s: tuner type=%d\n", s, *p);
489 break;
490 }
491 #ifdef CONFIG_VIDEO_V4L1_COMPAT
492 case DECODER_SET_VBI_BYPASS:
493 case DECODER_ENABLE_OUTPUT:
494 case DECODER_GET_STATUS:
495 case DECODER_SET_OUTPUT:
496 case DECODER_SET_INPUT:
497 case DECODER_SET_GPIO:
498 case DECODER_SET_NORM:
499 case VIDIOCCAPTURE:
500 case VIDIOCSYNC:
501 case VIDIOCSWRITEMODE:
502 #endif
503 case TUNER_SET_TYPE_ADDR:
504 case TUNER_SET_STANDBY:
505 case TDA9887_SET_CONFIG:
506 #ifdef __OLD_VIDIOC_
507 case VIDIOC_OVERLAY_OLD:
508 #endif
509 case VIDIOC_STREAMOFF:
510 case VIDIOC_G_OUTPUT:
511 case VIDIOC_S_OUTPUT:
512 case VIDIOC_STREAMON:
513 case VIDIOC_G_INPUT:
514 case VIDIOC_OVERLAY:
515 case VIDIOC_S_INPUT:
516 {
517 int *p=arg;
518 printk ("%s: value=%d\n", s, *p);
519 break;
520 }
521 case VIDIOC_G_AUDIO:
522 case VIDIOC_S_AUDIO:
523 case VIDIOC_ENUMAUDIO:
524 #ifdef __OLD_VIDIOC_
525 case VIDIOC_G_AUDIO_OLD:
526 #endif
527 {
528 struct v4l2_audio *p=arg;
529
530 printk ("%s: index=%d, name=%s, capability=%d, mode=%d\n",
531 s,p->index, p->name,p->capability, p->mode);
532 break;
533 }
534 case VIDIOC_G_AUDOUT:
535 case VIDIOC_S_AUDOUT:
536 case VIDIOC_ENUMAUDOUT:
537 #ifdef __OLD_VIDIOC_
538 case VIDIOC_G_AUDOUT_OLD:
539 #endif
540 {
541 struct v4l2_audioout *p=arg;
542 printk ("%s: index=%d, name=%s, capability=%d, mode=%d\n", s,
543 p->index, p->name, p->capability,p->mode);
544 break;
545 }
546 case VIDIOC_QBUF:
547 case VIDIOC_DQBUF:
548 case VIDIOC_QUERYBUF:
549 {
550 struct v4l2_buffer *p=arg;
551 struct v4l2_timecode *tc=&p->timecode;
552 printk ("%s: %02ld:%02d:%02d.%08ld index=%d, type=%s, "
553 "bytesused=%d, flags=0x%08x, "
554 "field=%0d, sequence=%d, memory=%s, offset/userptr=0x%08lx\n",
555 s,
556 (p->timestamp.tv_sec/3600),
557 (int)(p->timestamp.tv_sec/60)%60,
558 (int)(p->timestamp.tv_sec%60),
559 p->timestamp.tv_usec,
560 p->index,
561 prt_names(p->type,v4l2_type_names),
562 p->bytesused,p->flags,
563 p->field,p->sequence,
564 prt_names(p->memory,v4l2_memory_names),
565 p->m.userptr);
566 printk ("%s: timecode= %02d:%02d:%02d type=%d, "
567 "flags=0x%08x, frames=%d, userbits=0x%08x\n",
568 s,tc->hours,tc->minutes,tc->seconds,
569 tc->type, tc->flags, tc->frames, *(__u32 *) tc->userbits);
570 break;
571 }
572 case VIDIOC_QUERYCAP:
573 {
574 struct v4l2_capability *p=arg;
575 printk ("%s: driver=%s, card=%s, bus=%s, version=0x%08x, "
576 "capabilities=0x%08x\n", s,
577 p->driver,p->card,p->bus_info,
578 p->version,
579 p->capabilities);
580 break;
581 }
582 case VIDIOC_G_CTRL:
583 case VIDIOC_S_CTRL:
584 #ifdef __OLD_VIDIOC_
585 case VIDIOC_S_CTRL_OLD:
586 #endif
587 {
588 struct v4l2_control *p=arg;
589 printk ("%s: id=%d, value=%d\n", s, p->id, p->value);
590 break;
591 }
592 case VIDIOC_G_EXT_CTRLS:
593 case VIDIOC_S_EXT_CTRLS:
594 case VIDIOC_TRY_EXT_CTRLS:
595 {
596 struct v4l2_ext_controls *p = arg;
597 int i;
598
599 printk("%s: ctrl_class=%d, count=%d\n", s, p->ctrl_class, p->count);
600 for (i = 0; i < p->count; i++) {
601 struct v4l2_ext_control *c = &p->controls[i];
602 if (cmd == VIDIOC_G_EXT_CTRLS)
603 printk("%s: id=%d\n", s, c->id);
604 else
605 printk("%s: id=%d, value=%d\n", s, c->id, c->value);
606 }
607 break;
608 }
609 case VIDIOC_G_CROP:
610 case VIDIOC_S_CROP:
611 {
612 struct v4l2_crop *p=arg;
613 /*FIXME: Should also show rect structs */
614 printk ("%s: type=%d\n", s, p->type);
615 break;
616 }
617 case VIDIOC_CROPCAP:
618 #ifdef __OLD_VIDIOC_
619 case VIDIOC_CROPCAP_OLD:
620 #endif
621 {
622 struct v4l2_cropcap *p=arg;
623 /*FIXME: Should also show rect structs */
624 printk ("%s: type=%d\n", s, p->type);
625 break;
626 }
627 case VIDIOC_INT_DECODE_VBI_LINE:
628 {
629 struct v4l2_decode_vbi_line *p=arg;
630 printk ("%s: is_second_field=%d, ptr=0x%08lx, line=%d, "
631 "type=%d\n", s,
632 p->is_second_field,(unsigned long)p->p,p->line,p->type);
633 break;
634 }
635 case VIDIOC_ENUM_FMT:
636 {
637 struct v4l2_fmtdesc *p=arg;
638 printk ("%s: index=%d, type=%d, flags=%d, description=%s,"
639 " pixelformat=%d\n", s,
640 p->index, p->type, p->flags,p->description,
641 p->pixelformat);
642
643 break;
644 }
645 case VIDIOC_G_FMT:
646 case VIDIOC_S_FMT:
647 case VIDIOC_TRY_FMT:
648 {
649 struct v4l2_format *p=arg;
650 printk ("%s: type=%s\n", s,
651 prt_names(p->type,v4l2_type_names));
652 switch (p->type) {
653 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
654 v4l_print_pix_fmt (s, &p->fmt.pix);
655 break;
656 default:
657 break;
658 }
659 }
660 case VIDIOC_G_FBUF:
661 case VIDIOC_S_FBUF:
662 {
663 struct v4l2_framebuffer *p=arg;
664 printk ("%s: capability=%d, flags=%d, base=0x%08lx\n", s,
665 p->capability,p->flags, (unsigned long)p->base);
666 v4l_print_pix_fmt (s, &p->fmt);
667 break;
668 }
669 case VIDIOC_G_FREQUENCY:
670 case VIDIOC_S_FREQUENCY:
671 {
672 struct v4l2_frequency *p=arg;
673 printk ("%s: tuner=%d, type=%d, frequency=%d\n", s,
674 p->tuner,p->type,p->frequency);
675 break;
676 }
677 case VIDIOC_ENUMINPUT:
678 {
679 struct v4l2_input *p=arg;
680 printk ("%s: index=%d, name=%s, type=%d, audioset=%d, "
681 "tuner=%d, std=%Ld, status=%d\n", s,
682 p->index,p->name,p->type,p->audioset,
683 p->tuner,
684 (unsigned long long)p->std,
685 p->status);
686 break;
687 }
688 case VIDIOC_G_JPEGCOMP:
689 case VIDIOC_S_JPEGCOMP:
690 {
691 struct v4l2_jpegcompression *p=arg;
692 printk ("%s: quality=%d, APPn=%d, APP_len=%d, COM_len=%d,"
693 " jpeg_markers=%d\n", s,
694 p->quality,p->APPn,p->APP_len,
695 p->COM_len,p->jpeg_markers);
696 break;
697 }
698 case VIDIOC_G_MODULATOR:
699 case VIDIOC_S_MODULATOR:
700 {
701 struct v4l2_modulator *p=arg;
702 printk ("%s: index=%d, name=%s, capability=%d, rangelow=%d,"
703 " rangehigh=%d, txsubchans=%d\n", s,
704 p->index, p->name,p->capability,p->rangelow,
705 p->rangehigh,p->txsubchans);
706 break;
707 }
708 case VIDIOC_G_MPEGCOMP:
709 case VIDIOC_S_MPEGCOMP:
710 {
711 struct v4l2_mpeg_compression *p=arg;
712 /*FIXME: Several fields not shown */
713 printk ("%s: ts_pid_pmt=%d, ts_pid_audio=%d, ts_pid_video=%d, "
714 "ts_pid_pcr=%d, ps_size=%d, au_sample_rate=%d, "
715 "au_pesid=%c, vi_frame_rate=%d, vi_frames_per_gop=%d, "
716 "vi_bframes_count=%d, vi_pesid=%c\n", s,
717 p->ts_pid_pmt,p->ts_pid_audio, p->ts_pid_video,
718 p->ts_pid_pcr, p->ps_size, p->au_sample_rate,
719 p->au_pesid, p->vi_frame_rate,
720 p->vi_frames_per_gop, p->vi_bframes_count,
721 p->vi_pesid);
722 break;
723 }
724 case VIDIOC_ENUMOUTPUT:
725 {
726 struct v4l2_output *p=arg;
727 printk ("%s: index=%d, name=%s,type=%d, audioset=%d, "
728 "modulator=%d, std=%Ld\n",
729 s,p->index,p->name,p->type,p->audioset,
730 p->modulator,
731 (unsigned long long)p->std);
732 break;
733 }
734 case VIDIOC_QUERYCTRL:
735 {
736 struct v4l2_queryctrl *p=arg;
737 printk ("%s: id=%d, type=%d, name=%s, min/max=%d/%d,"
738 " step=%d, default=%d, flags=0x%08x\n", s,
739 p->id,p->type,p->name,p->minimum,p->maximum,
740 p->step,p->default_value,p->flags);
741 break;
742 }
743 case VIDIOC_QUERYMENU:
744 {
745 struct v4l2_querymenu *p=arg;
746 printk ("%s: id=%d, index=%d, name=%s\n", s,
747 p->id,p->index,p->name);
748 break;
749 }
750 case VIDIOC_INT_G_REGISTER:
751 case VIDIOC_INT_S_REGISTER:
752 {
753 struct v4l2_register *p=arg;
754 printk ("%s: i2c_id=%d, reg=%lu, val=%d\n", s,
755 p->i2c_id,p->reg,p->val);
756
757 break;
758 }
759 case VIDIOC_REQBUFS:
760 {
761 struct v4l2_requestbuffers *p=arg;
762 printk ("%s: count=%d, type=%s, memory=%s\n", s,
763 p->count,
764 prt_names(p->type,v4l2_type_names),
765 prt_names(p->memory,v4l2_memory_names));
766 break;
767 }
768 case VIDIOC_INT_S_AUDIO_ROUTING:
769 case VIDIOC_INT_S_VIDEO_ROUTING:
770 case VIDIOC_INT_G_AUDIO_ROUTING:
771 case VIDIOC_INT_G_VIDEO_ROUTING:
772 {
773 struct v4l2_routing *p=arg;
774 printk ("%s: input=0x%x, output=0x%x\n", s, p->input, p->output);
775 break;
776 }
777 case VIDIOC_INT_S_CRYSTAL_FREQ:
778 {
779 struct v4l2_crystal_freq *p=arg;
780 printk ("%s: freq=%u, flags=0x%x\n", s, p->freq, p->flags);
781 break;
782 }
783 case VIDIOC_G_SLICED_VBI_CAP:
784 {
785 struct v4l2_sliced_vbi_cap *p=arg;
786 printk ("%s: service_set=%d\n", s,
787 p->service_set);
788 break;
789 }
790 case VIDIOC_INT_S_VBI_DATA:
791 case VIDIOC_INT_G_VBI_DATA:
792 {
793 struct v4l2_sliced_vbi_data *p=arg;
794 printk ("%s: id=%d, field=%d, line=%d\n", s,
795 p->id, p->field, p->line);
796 break;
797 }
798 case VIDIOC_ENUMSTD:
799 {
800 struct v4l2_standard *p=arg;
801 printk ("%s: index=%d, id=%Ld, name=%s, fps=%d/%d, "
802 "framelines=%d\n", s, p->index,
803 (unsigned long long)p->id, p->name,
804 p->frameperiod.numerator,
805 p->frameperiod.denominator,
806 p->framelines);
807
808 break;
809 }
810 case VIDIOC_G_PARM:
811 case VIDIOC_S_PARM:
812 #ifdef __OLD_VIDIOC_
813 case VIDIOC_S_PARM_OLD:
814 #endif
815 {
816 struct v4l2_streamparm *p=arg;
817 printk ("%s: type=%d\n", s, p->type);
818
819 break;
820 }
821 case VIDIOC_G_TUNER:
822 case VIDIOC_S_TUNER:
823 {
824 struct v4l2_tuner *p=arg;
825 printk ("%s: index=%d, name=%s, type=%d, capability=%d, "
826 "rangelow=%d, rangehigh=%d, signal=%d, afc=%d, "
827 "rxsubchans=%d, audmode=%d\n", s,
828 p->index, p->name, p->type,
829 p->capability, p->rangelow,p->rangehigh,
830 p->rxsubchans, p->audmode, p->signal,
831 p->afc);
832 break;
833 }
834 #ifdef CONFIG_VIDEO_V4L1_COMPAT
835 case VIDIOCGVBIFMT:
836 case VIDIOCSVBIFMT:
837 {
838 struct vbi_format *p=arg;
839 printk ("%s: sampling_rate=%d, samples_per_line=%d, "
840 "sample_format=%d, start=%d/%d, count=%d/%d, flags=%d\n", s,
841 p->sampling_rate,p->samples_per_line,
842 p->sample_format,p->start[0],p->start[1],
843 p->count[0],p->count[1],p->flags);
844 break;
845 }
846 case VIDIOCGAUDIO:
847 case VIDIOCSAUDIO:
848 {
849 struct video_audio *p=arg;
850 printk ("%s: audio=%d, volume=%d, bass=%d, treble=%d, "
851 "flags=%d, name=%s, mode=%d, balance=%d, step=%d\n",
852 s,p->audio,p->volume,p->bass, p->treble,
853 p->flags,p->name,p->mode,p->balance,p->step);
854 break;
855 }
856 case VIDIOCGFBUF:
857 case VIDIOCSFBUF:
858 {
859 struct video_buffer *p=arg;
860 printk ("%s: base=%08lx, height=%d, width=%d, depth=%d, "
861 "bytesperline=%d\n", s,
862 (unsigned long) p->base, p->height, p->width,
863 p->depth,p->bytesperline);
864 break;
865 }
866 case VIDIOCGCAP:
867 {
868 struct video_capability *p=arg;
869 printk ("%s: name=%s, type=%d, channels=%d, audios=%d, "
870 "maxwidth=%d, maxheight=%d, minwidth=%d, minheight=%d\n",
871 s,p->name,p->type,p->channels,p->audios,
872 p->maxwidth,p->maxheight,p->minwidth,
873 p->minheight);
874
875 break;
876 }
877 case VIDIOCGCAPTURE:
878 case VIDIOCSCAPTURE:
879 {
880 struct video_capture *p=arg;
881 printk ("%s: x=%d, y=%d, width=%d, height=%d, decimation=%d,"
882 " flags=%d\n", s,
883 p->x, p->y,p->width, p->height,
884 p->decimation,p->flags);
885 break;
886 }
887 case VIDIOCGCHAN:
888 case VIDIOCSCHAN:
889 {
890 struct video_channel *p=arg;
891 printk ("%s: channel=%d, name=%s, tuners=%d, flags=%d, "
892 "type=%d, norm=%d\n", s,
893 p->channel,p->name,p->tuners,
894 p->flags,p->type,p->norm);
895
896 break;
897 }
898 case VIDIOCSMICROCODE:
899 {
900 struct video_code *p=arg;
901 printk ("%s: loadwhat=%s, datasize=%d\n", s,
902 p->loadwhat,p->datasize);
903 break;
904 }
905 case DECODER_GET_CAPABILITIES:
906 {
907 struct video_decoder_capability *p=arg;
908 printk ("%s: flags=%d, inputs=%d, outputs=%d\n", s,
909 p->flags,p->inputs,p->outputs);
910 break;
911 }
912 case DECODER_INIT:
913 {
914 struct video_decoder_init *p=arg;
915 printk ("%s: len=%c\n", s, p->len);
916 break;
917 }
918 case VIDIOCGPLAYINFO:
919 {
920 struct video_info *p=arg;
921 printk ("%s: frame_count=%d, h_size=%d, v_size=%d, "
922 "smpte_timecode=%d, picture_type=%d, "
923 "temporal_reference=%d, user_data=%s\n", s,
924 p->frame_count, p->h_size,
925 p->v_size, p->smpte_timecode,
926 p->picture_type, p->temporal_reference,
927 p->user_data);
928 break;
929 }
930 case VIDIOCKEY:
931 {
932 struct video_key *p=arg;
933 printk ("%s: key=%s, flags=%d\n", s,
934 p->key, p->flags);
935 break;
936 }
937 case VIDIOCGMBUF:
938 {
939 struct video_mbuf *p=arg;
940 printk ("%s: size=%d, frames=%d, offsets=0x%08lx\n", s,
941 p->size,
942 p->frames,
943 (unsigned long)p->offsets);
944 break;
945 }
946 case VIDIOCMCAPTURE:
947 {
948 struct video_mmap *p=arg;
949 printk ("%s: frame=%d, height=%d, width=%d, format=%d\n", s,
950 p->frame,
951 p->height, p->width,
952 p->format);
953 break;
954 }
955 case VIDIOCGPICT:
956 case VIDIOCSPICT:
957 case DECODER_SET_PICTURE:
958 {
959 struct video_picture *p=arg;
960
961 printk ("%s: brightness=%d, hue=%d, colour=%d, contrast=%d,"
962 " whiteness=%d, depth=%d, palette=%d\n", s,
963 p->brightness, p->hue, p->colour,
964 p->contrast, p->whiteness, p->depth,
965 p->palette);
966 break;
967 }
968 case VIDIOCSPLAYMODE:
969 {
970 struct video_play_mode *p=arg;
971 printk ("%s: mode=%d, p1=%d, p2=%d\n", s,
972 p->mode,p->p1,p->p2);
973 break;
974 }
975 case VIDIOCGTUNER:
976 case VIDIOCSTUNER:
977 {
978 struct video_tuner *p=arg;
979 printk ("%s: tuner=%d, name=%s, rangelow=%ld, rangehigh=%ld, "
980 "flags=%d, mode=%d, signal=%d\n", s,
981 p->tuner, p->name,p->rangelow, p->rangehigh,
982 p->flags,p->mode, p->signal);
983 break;
984 }
985 case VIDIOCGUNIT:
986 {
987 struct video_unit *p=arg;
988 printk ("%s: video=%d, vbi=%d, radio=%d, audio=%d, "
989 "teletext=%d\n", s,
990 p->video,p->vbi,p->radio,p->audio,p->teletext);
991 break;
992 }
993 case VIDIOCGWIN:
994 case VIDIOCSWIN:
995 {
996 struct video_window *p=arg;
997 printk ("%s: x=%d, y=%d, width=%d, height=%d, chromakey=%d,"
998 " flags=%d, clipcount=%d\n", s,
999 p->x, p->y,p->width, p->height,
1000 p->chromakey,p->flags,
1001 p->clipcount);
1002 break;
1003 }
1004 case VIDIOCGFREQ:
1005 case VIDIOCSFREQ:
1006 {
1007 unsigned long *p=arg;
1008 printk ("%s: value=%lu\n", s, *p);
1009 break;
1010 }
1011 #endif
1012 case VIDIOC_INT_AUDIO_CLOCK_FREQ:
1013 case VIDIOC_INT_I2S_CLOCK_FREQ:
1014 case VIDIOC_INT_S_STANDBY:
1015 case VIDIOC_INT_RESET:
1016 {
1017 u32 *p=arg;
1018
1019 printk ("%s: value=%d\n", s, *p);
1020 break;
1021 }
1022 case VIDIOC_G_STD:
1023 case VIDIOC_S_STD:
1024 case VIDIOC_QUERYSTD:
1025 {
1026 v4l2_std_id *p=arg;
1027
1028 printk ("%s: value=%Lu\n", s, (unsigned long long)*p);
1029 break;
1030 }
1031 }
1032 }
1033
1034 /* ----------------------------------------------------------------- */
1035
1036 /* Helper functions for control handling */
1037
1038 /* Check for correctness of the ctrl's value based on the data from
1039 struct v4l2_queryctrl and the available menu items. Note that
1040 menu_items may be NULL, in that case it is ignored. */
1041 int v4l2_ctrl_check(struct v4l2_ext_control *ctrl, struct v4l2_queryctrl *qctrl,
1042 const char **menu_items)
1043 {
1044 if (qctrl->flags & V4L2_CTRL_FLAG_DISABLED)
1045 return -EINVAL;
1046 if (qctrl->flags & V4L2_CTRL_FLAG_GRABBED)
1047 return -EBUSY;
1048 if (qctrl->type == V4L2_CTRL_TYPE_BUTTON ||
1049 qctrl->type == V4L2_CTRL_TYPE_INTEGER64 ||
1050 qctrl->type == V4L2_CTRL_TYPE_CTRL_CLASS)
1051 return 0;
1052 if (ctrl->value < qctrl->minimum || ctrl->value > qctrl->maximum)
1053 return -ERANGE;
1054 if (qctrl->type == V4L2_CTRL_TYPE_MENU && menu_items != NULL) {
1055 if (menu_items[ctrl->value] == NULL ||
1056 menu_items[ctrl->value][0] == '\0')
1057 return -EINVAL;
1058 }
1059 return 0;
1060 }
1061
1062 /* Returns NULL or a character pointer array containing the menu for
1063 the given control ID. The pointer array ends with a NULL pointer.
1064 An empty string signifies a menu entry that is invalid. This allows
1065 drivers to disable certain options if it is not supported. */
1066 const char **v4l2_ctrl_get_menu(u32 id)
1067 {
1068 static const char *mpeg_audio_sampling_freq[] = {
1069 "44.1 kHz",
1070 "48 kHz",
1071 "32 kHz",
1072 NULL
1073 };
1074 static const char *mpeg_audio_encoding[] = {
1075 "Layer I",
1076 "Layer II",
1077 "Layer III",
1078 NULL
1079 };
1080 static const char *mpeg_audio_l1_bitrate[] = {
1081 "32 kbps",
1082 "64 kbps",
1083 "96 kbps",
1084 "128 kbps",
1085 "160 kbps",
1086 "192 kbps",
1087 "224 kbps",
1088 "256 kbps",
1089 "288 kbps",
1090 "320 kbps",
1091 "352 kbps",
1092 "384 kbps",
1093 "416 kbps",
1094 "448 kbps",
1095 NULL
1096 };
1097 static const char *mpeg_audio_l2_bitrate[] = {
1098 "32 kbps",
1099 "48 kbps",
1100 "56 kbps",
1101 "64 kbps",
1102 "80 kbps",
1103 "96 kbps",
1104 "112 kbps",
1105 "128 kbps",
1106 "160 kbps",
1107 "192 kbps",
1108 "224 kbps",
1109 "256 kbps",
1110 "320 kbps",
1111 "384 kbps",
1112 NULL
1113 };
1114 static const char *mpeg_audio_l3_bitrate[] = {
1115 "32 kbps",
1116 "40 kbps",
1117 "48 kbps",
1118 "56 kbps",
1119 "64 kbps",
1120 "80 kbps",
1121 "96 kbps",
1122 "112 kbps",
1123 "128 kbps",
1124 "160 kbps",
1125 "192 kbps",
1126 "224 kbps",
1127 "256 kbps",
1128 "320 kbps",
1129 NULL
1130 };
1131 static const char *mpeg_audio_mode[] = {
1132 "Stereo",
1133 "Joint Stereo",
1134 "Dual",
1135 "Mono",
1136 NULL
1137 };
1138 static const char *mpeg_audio_mode_extension[] = {
1139 "Bound 4",
1140 "Bound 8",
1141 "Bound 12",
1142 "Bound 16",
1143 NULL
1144 };
1145 static const char *mpeg_audio_emphasis[] = {
1146 "No Emphasis",
1147 "50/15 us",
1148 "CCITT J17",
1149 NULL
1150 };
1151 static const char *mpeg_audio_crc[] = {
1152 "No CRC",
1153 "16-bit CRC",
1154 NULL
1155 };
1156 static const char *mpeg_video_encoding[] = {
1157 "MPEG-1",
1158 "MPEG-2",
1159 NULL
1160 };
1161 static const char *mpeg_video_aspect[] = {
1162 "1x1",
1163 "4x3",
1164 "16x9",
1165 "2.21x1",
1166 NULL
1167 };
1168 static const char *mpeg_video_bitrate_mode[] = {
1169 "Variable Bitrate",
1170 "Constant Bitrate",
1171 NULL
1172 };
1173 static const char *mpeg_stream_type[] = {
1174 "MPEG-2 Program Stream",
1175 "MPEG-2 Transport Stream",
1176 "MPEG-1 System Stream",
1177 "MPEG-2 DVD-compatible Stream",
1178 "MPEG-1 VCD-compatible Stream",
1179 "MPEG-2 SVCD-compatible Stream",
1180 NULL
1181 };
1182 static const char *mpeg_stream_vbi_fmt[] = {
1183 "No VBI",
1184 "Private packet, IVTV format",
1185 NULL
1186 };
1187
1188 switch (id) {
1189 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
1190 return mpeg_audio_sampling_freq;
1191 case V4L2_CID_MPEG_AUDIO_ENCODING:
1192 return mpeg_audio_encoding;
1193 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
1194 return mpeg_audio_l1_bitrate;
1195 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
1196 return mpeg_audio_l2_bitrate;
1197 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
1198 return mpeg_audio_l3_bitrate;
1199 case V4L2_CID_MPEG_AUDIO_MODE:
1200 return mpeg_audio_mode;
1201 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
1202 return mpeg_audio_mode_extension;
1203 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
1204 return mpeg_audio_emphasis;
1205 case V4L2_CID_MPEG_AUDIO_CRC:
1206 return mpeg_audio_crc;
1207 case V4L2_CID_MPEG_VIDEO_ENCODING:
1208 return mpeg_video_encoding;
1209 case V4L2_CID_MPEG_VIDEO_ASPECT:
1210 return mpeg_video_aspect;
1211 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1212 return mpeg_video_bitrate_mode;
1213 case V4L2_CID_MPEG_STREAM_TYPE:
1214 return mpeg_stream_type;
1215 case V4L2_CID_MPEG_STREAM_VBI_FMT:
1216 return mpeg_stream_vbi_fmt;
1217 default:
1218 return NULL;
1219 }
1220 }
1221
1222 /* Fill in a struct v4l2_queryctrl */
1223 int v4l2_ctrl_query_fill(struct v4l2_queryctrl *qctrl, s32 min, s32 max, s32 step, s32 def)
1224 {
1225 const char *name;
1226
1227 qctrl->flags = 0;
1228 switch (qctrl->id) {
1229 /* USER controls */
1230 case V4L2_CID_USER_CLASS: name = "User Controls"; break;
1231 case V4L2_CID_AUDIO_VOLUME: name = "Volume"; break;
1232 case V4L2_CID_AUDIO_MUTE: name = "Mute"; break;
1233 case V4L2_CID_AUDIO_BALANCE: name = "Balance"; break;
1234 case V4L2_CID_AUDIO_BASS: name = "Bass"; break;
1235 case V4L2_CID_AUDIO_TREBLE: name = "Treble"; break;
1236 case V4L2_CID_AUDIO_LOUDNESS: name = "Loudness"; break;
1237 case V4L2_CID_BRIGHTNESS: name = "Brightness"; break;
1238 case V4L2_CID_CONTRAST: name = "Contrast"; break;
1239 case V4L2_CID_SATURATION: name = "Saturation"; break;
1240 case V4L2_CID_HUE: name = "Hue"; break;
1241
1242 /* MPEG controls */
1243 case V4L2_CID_MPEG_CLASS: name = "MPEG Encoder Controls"; break;
1244 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ: name = "Audio Sampling Frequency"; break;
1245 case V4L2_CID_MPEG_AUDIO_ENCODING: name = "Audio Encoding Layer"; break;
1246 case V4L2_CID_MPEG_AUDIO_L1_BITRATE: name = "Audio Layer I Bitrate"; break;
1247 case V4L2_CID_MPEG_AUDIO_L2_BITRATE: name = "Audio Layer II Bitrate"; break;
1248 case V4L2_CID_MPEG_AUDIO_L3_BITRATE: name = "Audio Layer III Bitrate"; break;
1249 case V4L2_CID_MPEG_AUDIO_MODE: name = "Audio Stereo Mode"; break;
1250 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION: name = "Audio Stereo Mode Extension"; break;
1251 case V4L2_CID_MPEG_AUDIO_EMPHASIS: name = "Audio Emphasis"; break;
1252 case V4L2_CID_MPEG_AUDIO_CRC: name = "Audio CRC"; break;
1253 case V4L2_CID_MPEG_VIDEO_ENCODING: name = "Video Encoding"; break;
1254 case V4L2_CID_MPEG_VIDEO_ASPECT: name = "Video Aspect"; break;
1255 case V4L2_CID_MPEG_VIDEO_B_FRAMES: name = "Video B Frames"; break;
1256 case V4L2_CID_MPEG_VIDEO_GOP_SIZE: name = "Video GOP Size"; break;
1257 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE: name = "Video GOP Closure"; break;
1258 case V4L2_CID_MPEG_VIDEO_PULLDOWN: name = "Video Pulldown"; break;
1259 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE: name = "Video Bitrate Mode"; break;
1260 case V4L2_CID_MPEG_VIDEO_BITRATE: name = "Video Bitrate"; break;
1261 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK: name = "Video Peak Bitrate"; break;
1262 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION: name = "Video Temporal Decimation"; break;
1263 case V4L2_CID_MPEG_STREAM_TYPE: name = "Stream Type"; break;
1264 case V4L2_CID_MPEG_STREAM_PID_PMT: name = "Stream PMT Program ID"; break;
1265 case V4L2_CID_MPEG_STREAM_PID_AUDIO: name = "Stream Audio Program ID"; break;
1266 case V4L2_CID_MPEG_STREAM_PID_VIDEO: name = "Stream Video Program ID"; break;
1267 case V4L2_CID_MPEG_STREAM_PID_PCR: name = "Stream PCR Program ID"; break;
1268 case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO: name = "Stream PES Audio ID"; break;
1269 case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO: name = "Stream PES Video ID"; break;
1270 case V4L2_CID_MPEG_STREAM_VBI_FMT: name = "Stream VBI Format"; break;
1271
1272 default:
1273 return -EINVAL;
1274 }
1275 switch (qctrl->id) {
1276 case V4L2_CID_AUDIO_MUTE:
1277 case V4L2_CID_AUDIO_LOUDNESS:
1278 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
1279 case V4L2_CID_MPEG_VIDEO_PULLDOWN:
1280 qctrl->type = V4L2_CTRL_TYPE_BOOLEAN;
1281 min = 0;
1282 max = step = 1;
1283 break;
1284 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
1285 case V4L2_CID_MPEG_AUDIO_ENCODING:
1286 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
1287 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
1288 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
1289 case V4L2_CID_MPEG_AUDIO_MODE:
1290 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
1291 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
1292 case V4L2_CID_MPEG_AUDIO_CRC:
1293 case V4L2_CID_MPEG_VIDEO_ENCODING:
1294 case V4L2_CID_MPEG_VIDEO_ASPECT:
1295 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1296 case V4L2_CID_MPEG_STREAM_TYPE:
1297 case V4L2_CID_MPEG_STREAM_VBI_FMT:
1298 qctrl->type = V4L2_CTRL_TYPE_MENU;
1299 step = 1;
1300 break;
1301 case V4L2_CID_USER_CLASS:
1302 case V4L2_CID_MPEG_CLASS:
1303 qctrl->type = V4L2_CTRL_TYPE_CTRL_CLASS;
1304 qctrl->flags |= V4L2_CTRL_FLAG_READ_ONLY;
1305 min = max = step = def = 0;
1306 break;
1307 default:
1308 qctrl->type = V4L2_CTRL_TYPE_INTEGER;
1309 break;
1310 }
1311 switch (qctrl->id) {
1312 case V4L2_CID_MPEG_AUDIO_ENCODING:
1313 case V4L2_CID_MPEG_AUDIO_MODE:
1314 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1315 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1316 case V4L2_CID_MPEG_STREAM_TYPE:
1317 qctrl->flags |= V4L2_CTRL_FLAG_UPDATE;
1318 break;
1319 case V4L2_CID_AUDIO_VOLUME:
1320 case V4L2_CID_AUDIO_BALANCE:
1321 case V4L2_CID_AUDIO_BASS:
1322 case V4L2_CID_AUDIO_TREBLE:
1323 case V4L2_CID_BRIGHTNESS:
1324 case V4L2_CID_CONTRAST:
1325 case V4L2_CID_SATURATION:
1326 case V4L2_CID_HUE:
1327 qctrl->flags |= V4L2_CTRL_FLAG_SLIDER;
1328 break;
1329 }
1330 qctrl->minimum = min;
1331 qctrl->maximum = max;
1332 qctrl->step = step;
1333 qctrl->default_value = def;
1334 qctrl->reserved[0] = qctrl->reserved[1] = 0;
1335 snprintf(qctrl->name, sizeof(qctrl->name), name);
1336 return 0;
1337 }
1338
1339 /* Fill in a struct v4l2_queryctrl with standard values based on
1340 the control ID. */
1341 int v4l2_ctrl_query_fill_std(struct v4l2_queryctrl *qctrl)
1342 {
1343 switch (qctrl->id) {
1344 /* USER controls */
1345 case V4L2_CID_USER_CLASS:
1346 case V4L2_CID_MPEG_CLASS:
1347 return v4l2_ctrl_query_fill(qctrl, 0, 0, 0, 0);
1348 case V4L2_CID_AUDIO_VOLUME:
1349 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 58880);
1350 case V4L2_CID_AUDIO_MUTE:
1351 case V4L2_CID_AUDIO_LOUDNESS:
1352 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
1353 case V4L2_CID_AUDIO_BALANCE:
1354 case V4L2_CID_AUDIO_BASS:
1355 case V4L2_CID_AUDIO_TREBLE:
1356 return v4l2_ctrl_query_fill(qctrl, 0, 65535, 65535 / 100, 32768);
1357 case V4L2_CID_BRIGHTNESS:
1358 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 128);
1359 case V4L2_CID_CONTRAST:
1360 case V4L2_CID_SATURATION:
1361 return v4l2_ctrl_query_fill(qctrl, 0, 127, 1, 64);
1362 case V4L2_CID_HUE:
1363 return v4l2_ctrl_query_fill(qctrl, -128, 127, 1, 0);
1364
1365 /* MPEG controls */
1366 case V4L2_CID_MPEG_AUDIO_SAMPLING_FREQ:
1367 return v4l2_ctrl_query_fill(qctrl,
1368 V4L2_MPEG_AUDIO_SAMPLING_FREQ_44100,
1369 V4L2_MPEG_AUDIO_SAMPLING_FREQ_32000, 1,
1370 V4L2_MPEG_AUDIO_SAMPLING_FREQ_48000);
1371 case V4L2_CID_MPEG_AUDIO_ENCODING:
1372 return v4l2_ctrl_query_fill(qctrl,
1373 V4L2_MPEG_AUDIO_ENCODING_LAYER_1,
1374 V4L2_MPEG_AUDIO_ENCODING_LAYER_3, 1,
1375 V4L2_MPEG_AUDIO_ENCODING_LAYER_2);
1376 case V4L2_CID_MPEG_AUDIO_L1_BITRATE:
1377 return v4l2_ctrl_query_fill(qctrl,
1378 V4L2_MPEG_AUDIO_L1_BITRATE_32K,
1379 V4L2_MPEG_AUDIO_L1_BITRATE_448K, 1,
1380 V4L2_MPEG_AUDIO_L1_BITRATE_256K);
1381 case V4L2_CID_MPEG_AUDIO_L2_BITRATE:
1382 return v4l2_ctrl_query_fill(qctrl,
1383 V4L2_MPEG_AUDIO_L2_BITRATE_32K,
1384 V4L2_MPEG_AUDIO_L2_BITRATE_384K, 1,
1385 V4L2_MPEG_AUDIO_L2_BITRATE_224K);
1386 case V4L2_CID_MPEG_AUDIO_L3_BITRATE:
1387 return v4l2_ctrl_query_fill(qctrl,
1388 V4L2_MPEG_AUDIO_L3_BITRATE_32K,
1389 V4L2_MPEG_AUDIO_L3_BITRATE_320K, 1,
1390 V4L2_MPEG_AUDIO_L3_BITRATE_192K);
1391 case V4L2_CID_MPEG_AUDIO_MODE:
1392 return v4l2_ctrl_query_fill(qctrl,
1393 V4L2_MPEG_AUDIO_MODE_STEREO,
1394 V4L2_MPEG_AUDIO_MODE_MONO, 1,
1395 V4L2_MPEG_AUDIO_MODE_STEREO);
1396 case V4L2_CID_MPEG_AUDIO_MODE_EXTENSION:
1397 return v4l2_ctrl_query_fill(qctrl,
1398 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4,
1399 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_16, 1,
1400 V4L2_MPEG_AUDIO_MODE_EXTENSION_BOUND_4);
1401 case V4L2_CID_MPEG_AUDIO_EMPHASIS:
1402 return v4l2_ctrl_query_fill(qctrl,
1403 V4L2_MPEG_AUDIO_EMPHASIS_NONE,
1404 V4L2_MPEG_AUDIO_EMPHASIS_CCITT_J17, 1,
1405 V4L2_MPEG_AUDIO_EMPHASIS_NONE);
1406 case V4L2_CID_MPEG_AUDIO_CRC:
1407 return v4l2_ctrl_query_fill(qctrl,
1408 V4L2_MPEG_AUDIO_CRC_NONE,
1409 V4L2_MPEG_AUDIO_CRC_CRC16, 1,
1410 V4L2_MPEG_AUDIO_CRC_NONE);
1411 case V4L2_CID_MPEG_VIDEO_ENCODING:
1412 return v4l2_ctrl_query_fill(qctrl,
1413 V4L2_MPEG_VIDEO_ENCODING_MPEG_1,
1414 V4L2_MPEG_VIDEO_ENCODING_MPEG_2, 1,
1415 V4L2_MPEG_VIDEO_ENCODING_MPEG_2);
1416 case V4L2_CID_MPEG_VIDEO_ASPECT:
1417 return v4l2_ctrl_query_fill(qctrl,
1418 V4L2_MPEG_VIDEO_ASPECT_1x1,
1419 V4L2_MPEG_VIDEO_ASPECT_221x100, 1,
1420 V4L2_MPEG_VIDEO_ASPECT_4x3);
1421 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
1422 return v4l2_ctrl_query_fill(qctrl, 0, 33, 1, 2);
1423 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
1424 return v4l2_ctrl_query_fill(qctrl, 1, 34, 1, 12);
1425 case V4L2_CID_MPEG_VIDEO_GOP_CLOSURE:
1426 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 1);
1427 case V4L2_CID_MPEG_VIDEO_PULLDOWN:
1428 return v4l2_ctrl_query_fill(qctrl, 0, 1, 1, 0);
1429 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
1430 return v4l2_ctrl_query_fill(qctrl,
1431 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
1432 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 1,
1433 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
1434 case V4L2_CID_MPEG_VIDEO_BITRATE:
1435 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 6000000);
1436 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
1437 return v4l2_ctrl_query_fill(qctrl, 0, 27000000, 1, 8000000);
1438 case V4L2_CID_MPEG_VIDEO_TEMPORAL_DECIMATION:
1439 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
1440 case V4L2_CID_MPEG_STREAM_TYPE:
1441 return v4l2_ctrl_query_fill(qctrl,
1442 V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
1443 V4L2_MPEG_STREAM_TYPE_MPEG2_SVCD, 1,
1444 V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
1445 case V4L2_CID_MPEG_STREAM_PID_PMT:
1446 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 16);
1447 case V4L2_CID_MPEG_STREAM_PID_AUDIO:
1448 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 260);
1449 case V4L2_CID_MPEG_STREAM_PID_VIDEO:
1450 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 256);
1451 case V4L2_CID_MPEG_STREAM_PID_PCR:
1452 return v4l2_ctrl_query_fill(qctrl, 0, (1 << 14) - 1, 1, 259);
1453 case V4L2_CID_MPEG_STREAM_PES_ID_AUDIO:
1454 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
1455 case V4L2_CID_MPEG_STREAM_PES_ID_VIDEO:
1456 return v4l2_ctrl_query_fill(qctrl, 0, 255, 1, 0);
1457 case V4L2_CID_MPEG_STREAM_VBI_FMT:
1458 return v4l2_ctrl_query_fill(qctrl,
1459 V4L2_MPEG_STREAM_VBI_FMT_NONE,
1460 V4L2_MPEG_STREAM_VBI_FMT_IVTV, 1,
1461 V4L2_MPEG_STREAM_VBI_FMT_NONE);
1462 default:
1463 return -EINVAL;
1464 }
1465 }
1466
1467 /* Fill in a struct v4l2_querymenu based on the struct v4l2_queryctrl and
1468 the menu. The qctrl pointer may be NULL, in which case it is ignored. */
1469 int v4l2_ctrl_query_menu(struct v4l2_querymenu *qmenu, struct v4l2_queryctrl *qctrl,
1470 const char **menu_items)
1471 {
1472 int i;
1473
1474 if (menu_items == NULL ||
1475 (qctrl && (qmenu->index < qctrl->minimum || qmenu->index > qctrl->maximum)))
1476 return -EINVAL;
1477 for (i = 0; i < qmenu->index && menu_items[i]; i++) ;
1478 if (menu_items[i] == NULL || menu_items[i][0] == '\0')
1479 return -EINVAL;
1480 snprintf(qmenu->name, sizeof(qmenu->name), menu_items[qmenu->index]);
1481 qmenu->reserved = 0;
1482 return 0;
1483 }
1484
1485 /* ctrl_classes points to an array of u32 pointers, the last element is
1486 a NULL pointer. Each u32 array is a 0-terminated array of control IDs.
1487 Each array must be sorted low to high and belong to the same control
1488 class. The array of u32 pointer must also be sorted, from low class IDs
1489 to high class IDs.
1490
1491 This function returns the first ID that follows after the given ID.
1492 When no more controls are available 0 is returned. */
1493 u32 v4l2_ctrl_next(const u32 * const * ctrl_classes, u32 id)
1494 {
1495 u32 ctrl_class;
1496 const u32 *pctrl;
1497
1498 /* if no query is desired, then just return the control ID */
1499 if ((id & V4L2_CTRL_FLAG_NEXT_CTRL) == 0)
1500 return id;
1501 if (ctrl_classes == NULL)
1502 return 0;
1503 id &= V4L2_CTRL_ID_MASK;
1504 ctrl_class = V4L2_CTRL_ID2CLASS(id);
1505 id++; /* select next control */
1506 /* find first class that matches (or is greater than) the class of
1507 the ID */
1508 while (*ctrl_classes && V4L2_CTRL_ID2CLASS(**ctrl_classes) < ctrl_class)
1509 ctrl_classes++;
1510 /* no more classes */
1511 if (*ctrl_classes == NULL)
1512 return 0;
1513 pctrl = *ctrl_classes;
1514 /* find first ctrl within the class that is >= ID */
1515 while (*pctrl && *pctrl < id) pctrl++;
1516 if (*pctrl)
1517 return *pctrl;
1518 /* we are at the end of the controls of the current class. */
1519 /* continue with next class if available */
1520 ctrl_classes++;
1521 if (*ctrl_classes == NULL)
1522 return 0;
1523 return **ctrl_classes;
1524 }
1525
1526 /* ----------------------------------------------------------------- */
1527
1528 EXPORT_SYMBOL(v4l2_norm_to_name);
1529 EXPORT_SYMBOL(v4l2_video_std_construct);
1530
1531 EXPORT_SYMBOL(v4l2_prio_init);
1532 EXPORT_SYMBOL(v4l2_prio_change);
1533 EXPORT_SYMBOL(v4l2_prio_open);
1534 EXPORT_SYMBOL(v4l2_prio_close);
1535 EXPORT_SYMBOL(v4l2_prio_max);
1536 EXPORT_SYMBOL(v4l2_prio_check);
1537
1538 EXPORT_SYMBOL(v4l2_field_names);
1539 EXPORT_SYMBOL(v4l2_type_names);
1540 EXPORT_SYMBOL(v4l_printk_ioctl);
1541 EXPORT_SYMBOL(v4l_printk_ioctl_arg);
1542
1543 EXPORT_SYMBOL(v4l2_ctrl_next);
1544 EXPORT_SYMBOL(v4l2_ctrl_check);
1545 EXPORT_SYMBOL(v4l2_ctrl_get_menu);
1546 EXPORT_SYMBOL(v4l2_ctrl_query_menu);
1547 EXPORT_SYMBOL(v4l2_ctrl_query_fill);
1548 EXPORT_SYMBOL(v4l2_ctrl_query_fill_std);
1549
1550 /*
1551 * Local variables:
1552 * c-basic-offset: 8
1553 * End:
1554 */
x86 "subsystem" repository