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