2 * Video capture interface for Linux version 2
4 * A generic framework to process V4L2 ioctl commands.
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
11 * Authors: Alan Cox, <alan@lxorguk.ukuu.org.uk> (version 1)
12 * Mauro Carvalho Chehab <mchehab@infradead.org> (version 2)
15 #include <linux/module.h>
16 #include <linux/types.h>
17 #include <linux/kernel.h>
19 #define __OLD_VIDIOC_ /* To allow fixing old calls */
20 #include <linux/videodev2.h>
22 #ifdef CONFIG_VIDEO_V4L1
23 #include <linux/videodev.h>
25 #include <media/v4l2-common.h>
26 #include <media/v4l2-ioctl.h>
27 #include <media/v4l2-chip-ident.h>
28 #include <linux/video_decoder.h>
30 #define dbgarg(cmd, fmt, arg...) \
32 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) { \
33 printk(KERN_DEBUG "%s: ", vfd->name); \
34 v4l_printk_ioctl(cmd); \
35 printk(" " fmt, ## arg); \
39 #define dbgarg2(fmt, arg...) \
41 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) \
42 printk(KERN_DEBUG "%s: " fmt, vfd->name, ## arg);\
50 static const struct std_descr standards[] = {
51 { V4L2_STD_NTSC, "NTSC" },
52 { V4L2_STD_NTSC_M, "NTSC-M" },
53 { V4L2_STD_NTSC_M_JP, "NTSC-M-JP" },
54 { V4L2_STD_NTSC_M_KR, "NTSC-M-KR" },
55 { V4L2_STD_NTSC_443, "NTSC-443" },
56 { V4L2_STD_PAL, "PAL" },
57 { V4L2_STD_PAL_BG, "PAL-BG" },
58 { V4L2_STD_PAL_B, "PAL-B" },
59 { V4L2_STD_PAL_B1, "PAL-B1" },
60 { V4L2_STD_PAL_G, "PAL-G" },
61 { V4L2_STD_PAL_H, "PAL-H" },
62 { V4L2_STD_PAL_I, "PAL-I" },
63 { V4L2_STD_PAL_DK, "PAL-DK" },
64 { V4L2_STD_PAL_D, "PAL-D" },
65 { V4L2_STD_PAL_D1, "PAL-D1" },
66 { V4L2_STD_PAL_K, "PAL-K" },
67 { V4L2_STD_PAL_M, "PAL-M" },
68 { V4L2_STD_PAL_N, "PAL-N" },
69 { V4L2_STD_PAL_Nc, "PAL-Nc" },
70 { V4L2_STD_PAL_60, "PAL-60" },
71 { V4L2_STD_SECAM, "SECAM" },
72 { V4L2_STD_SECAM_B, "SECAM-B" },
73 { V4L2_STD_SECAM_G, "SECAM-G" },
74 { V4L2_STD_SECAM_H, "SECAM-H" },
75 { V4L2_STD_SECAM_DK, "SECAM-DK" },
76 { V4L2_STD_SECAM_D, "SECAM-D" },
77 { V4L2_STD_SECAM_K, "SECAM-K" },
78 { V4L2_STD_SECAM_K1, "SECAM-K1" },
79 { V4L2_STD_SECAM_L, "SECAM-L" },
80 { V4L2_STD_SECAM_LC, "SECAM-Lc" },
84 /* video4linux standard ID conversion to standard name
86 const char *v4l2_norm_to_name(v4l2_std_id id)
91 /* HACK: ppc32 architecture doesn't have __ucmpdi2 function to handle
92 64 bit comparations. So, on that architecture, with some gcc
93 variants, compilation fails. Currently, the max value is 30bit wide.
97 for (i = 0; standards[i].std; i++)
98 if (myid == standards[i].std)
100 return standards[i].descr;
102 EXPORT_SYMBOL(v4l2_norm_to_name);
104 /* Fill in the fields of a v4l2_standard structure according to the
105 'id' and 'transmission' parameters. Returns negative on error. */
106 int v4l2_video_std_construct(struct v4l2_standard *vs,
107 int id, const char *name)
109 u32 index = vs->index;
111 memset(vs, 0, sizeof(struct v4l2_standard));
114 if (id & V4L2_STD_525_60) {
115 vs->frameperiod.numerator = 1001;
116 vs->frameperiod.denominator = 30000;
117 vs->framelines = 525;
119 vs->frameperiod.numerator = 1;
120 vs->frameperiod.denominator = 25;
121 vs->framelines = 625;
123 strlcpy(vs->name, name, sizeof(vs->name));
126 EXPORT_SYMBOL(v4l2_video_std_construct);
128 /* ----------------------------------------------------------------- */
129 /* some arrays for pretty-printing debug messages of enum types */
131 const char *v4l2_field_names[] = {
132 [V4L2_FIELD_ANY] = "any",
133 [V4L2_FIELD_NONE] = "none",
134 [V4L2_FIELD_TOP] = "top",
135 [V4L2_FIELD_BOTTOM] = "bottom",
136 [V4L2_FIELD_INTERLACED] = "interlaced",
137 [V4L2_FIELD_SEQ_TB] = "seq-tb",
138 [V4L2_FIELD_SEQ_BT] = "seq-bt",
139 [V4L2_FIELD_ALTERNATE] = "alternate",
140 [V4L2_FIELD_INTERLACED_TB] = "interlaced-tb",
141 [V4L2_FIELD_INTERLACED_BT] = "interlaced-bt",
143 EXPORT_SYMBOL(v4l2_field_names);
145 const char *v4l2_type_names[] = {
146 [V4L2_BUF_TYPE_VIDEO_CAPTURE] = "vid-cap",
147 [V4L2_BUF_TYPE_VIDEO_OVERLAY] = "vid-overlay",
148 [V4L2_BUF_TYPE_VIDEO_OUTPUT] = "vid-out",
149 [V4L2_BUF_TYPE_VBI_CAPTURE] = "vbi-cap",
150 [V4L2_BUF_TYPE_VBI_OUTPUT] = "vbi-out",
151 [V4L2_BUF_TYPE_SLICED_VBI_CAPTURE] = "sliced-vbi-cap",
152 [V4L2_BUF_TYPE_SLICED_VBI_OUTPUT] = "sliced-vbi-out",
153 [V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY] = "vid-out-overlay",
155 EXPORT_SYMBOL(v4l2_type_names);
157 static const char *v4l2_memory_names[] = {
158 [V4L2_MEMORY_MMAP] = "mmap",
159 [V4L2_MEMORY_USERPTR] = "userptr",
160 [V4L2_MEMORY_OVERLAY] = "overlay",
163 #define prt_names(a, arr) ((((a) >= 0) && ((a) < ARRAY_SIZE(arr))) ? \
166 /* ------------------------------------------------------------------ */
167 /* debug help functions */
169 #ifdef CONFIG_VIDEO_V4L1_COMPAT
170 static const char *v4l1_ioctls[] = {
171 [_IOC_NR(VIDIOCGCAP)] = "VIDIOCGCAP",
172 [_IOC_NR(VIDIOCGCHAN)] = "VIDIOCGCHAN",
173 [_IOC_NR(VIDIOCSCHAN)] = "VIDIOCSCHAN",
174 [_IOC_NR(VIDIOCGTUNER)] = "VIDIOCGTUNER",
175 [_IOC_NR(VIDIOCSTUNER)] = "VIDIOCSTUNER",
176 [_IOC_NR(VIDIOCGPICT)] = "VIDIOCGPICT",
177 [_IOC_NR(VIDIOCSPICT)] = "VIDIOCSPICT",
178 [_IOC_NR(VIDIOCCAPTURE)] = "VIDIOCCAPTURE",
179 [_IOC_NR(VIDIOCGWIN)] = "VIDIOCGWIN",
180 [_IOC_NR(VIDIOCSWIN)] = "VIDIOCSWIN",
181 [_IOC_NR(VIDIOCGFBUF)] = "VIDIOCGFBUF",
182 [_IOC_NR(VIDIOCSFBUF)] = "VIDIOCSFBUF",
183 [_IOC_NR(VIDIOCKEY)] = "VIDIOCKEY",
184 [_IOC_NR(VIDIOCGFREQ)] = "VIDIOCGFREQ",
185 [_IOC_NR(VIDIOCSFREQ)] = "VIDIOCSFREQ",
186 [_IOC_NR(VIDIOCGAUDIO)] = "VIDIOCGAUDIO",
187 [_IOC_NR(VIDIOCSAUDIO)] = "VIDIOCSAUDIO",
188 [_IOC_NR(VIDIOCSYNC)] = "VIDIOCSYNC",
189 [_IOC_NR(VIDIOCMCAPTURE)] = "VIDIOCMCAPTURE",
190 [_IOC_NR(VIDIOCGMBUF)] = "VIDIOCGMBUF",
191 [_IOC_NR(VIDIOCGUNIT)] = "VIDIOCGUNIT",
192 [_IOC_NR(VIDIOCGCAPTURE)] = "VIDIOCGCAPTURE",
193 [_IOC_NR(VIDIOCSCAPTURE)] = "VIDIOCSCAPTURE",
194 [_IOC_NR(VIDIOCSPLAYMODE)] = "VIDIOCSPLAYMODE",
195 [_IOC_NR(VIDIOCSWRITEMODE)] = "VIDIOCSWRITEMODE",
196 [_IOC_NR(VIDIOCGPLAYINFO)] = "VIDIOCGPLAYINFO",
197 [_IOC_NR(VIDIOCSMICROCODE)] = "VIDIOCSMICROCODE",
198 [_IOC_NR(VIDIOCGVBIFMT)] = "VIDIOCGVBIFMT",
199 [_IOC_NR(VIDIOCSVBIFMT)] = "VIDIOCSVBIFMT"
201 #define V4L1_IOCTLS ARRAY_SIZE(v4l1_ioctls)
204 static const char *v4l2_ioctls[] = {
205 [_IOC_NR(VIDIOC_QUERYCAP)] = "VIDIOC_QUERYCAP",
206 [_IOC_NR(VIDIOC_RESERVED)] = "VIDIOC_RESERVED",
207 [_IOC_NR(VIDIOC_ENUM_FMT)] = "VIDIOC_ENUM_FMT",
208 [_IOC_NR(VIDIOC_G_FMT)] = "VIDIOC_G_FMT",
209 [_IOC_NR(VIDIOC_S_FMT)] = "VIDIOC_S_FMT",
210 [_IOC_NR(VIDIOC_REQBUFS)] = "VIDIOC_REQBUFS",
211 [_IOC_NR(VIDIOC_QUERYBUF)] = "VIDIOC_QUERYBUF",
212 [_IOC_NR(VIDIOC_G_FBUF)] = "VIDIOC_G_FBUF",
213 [_IOC_NR(VIDIOC_S_FBUF)] = "VIDIOC_S_FBUF",
214 [_IOC_NR(VIDIOC_OVERLAY)] = "VIDIOC_OVERLAY",
215 [_IOC_NR(VIDIOC_QBUF)] = "VIDIOC_QBUF",
216 [_IOC_NR(VIDIOC_DQBUF)] = "VIDIOC_DQBUF",
217 [_IOC_NR(VIDIOC_STREAMON)] = "VIDIOC_STREAMON",
218 [_IOC_NR(VIDIOC_STREAMOFF)] = "VIDIOC_STREAMOFF",
219 [_IOC_NR(VIDIOC_G_PARM)] = "VIDIOC_G_PARM",
220 [_IOC_NR(VIDIOC_S_PARM)] = "VIDIOC_S_PARM",
221 [_IOC_NR(VIDIOC_G_STD)] = "VIDIOC_G_STD",
222 [_IOC_NR(VIDIOC_S_STD)] = "VIDIOC_S_STD",
223 [_IOC_NR(VIDIOC_ENUMSTD)] = "VIDIOC_ENUMSTD",
224 [_IOC_NR(VIDIOC_ENUMINPUT)] = "VIDIOC_ENUMINPUT",
225 [_IOC_NR(VIDIOC_G_CTRL)] = "VIDIOC_G_CTRL",
226 [_IOC_NR(VIDIOC_S_CTRL)] = "VIDIOC_S_CTRL",
227 [_IOC_NR(VIDIOC_G_TUNER)] = "VIDIOC_G_TUNER",
228 [_IOC_NR(VIDIOC_S_TUNER)] = "VIDIOC_S_TUNER",
229 [_IOC_NR(VIDIOC_G_AUDIO)] = "VIDIOC_G_AUDIO",
230 [_IOC_NR(VIDIOC_S_AUDIO)] = "VIDIOC_S_AUDIO",
231 [_IOC_NR(VIDIOC_QUERYCTRL)] = "VIDIOC_QUERYCTRL",
232 [_IOC_NR(VIDIOC_QUERYMENU)] = "VIDIOC_QUERYMENU",
233 [_IOC_NR(VIDIOC_G_INPUT)] = "VIDIOC_G_INPUT",
234 [_IOC_NR(VIDIOC_S_INPUT)] = "VIDIOC_S_INPUT",
235 [_IOC_NR(VIDIOC_G_OUTPUT)] = "VIDIOC_G_OUTPUT",
236 [_IOC_NR(VIDIOC_S_OUTPUT)] = "VIDIOC_S_OUTPUT",
237 [_IOC_NR(VIDIOC_ENUMOUTPUT)] = "VIDIOC_ENUMOUTPUT",
238 [_IOC_NR(VIDIOC_G_AUDOUT)] = "VIDIOC_G_AUDOUT",
239 [_IOC_NR(VIDIOC_S_AUDOUT)] = "VIDIOC_S_AUDOUT",
240 [_IOC_NR(VIDIOC_G_MODULATOR)] = "VIDIOC_G_MODULATOR",
241 [_IOC_NR(VIDIOC_S_MODULATOR)] = "VIDIOC_S_MODULATOR",
242 [_IOC_NR(VIDIOC_G_FREQUENCY)] = "VIDIOC_G_FREQUENCY",
243 [_IOC_NR(VIDIOC_S_FREQUENCY)] = "VIDIOC_S_FREQUENCY",
244 [_IOC_NR(VIDIOC_CROPCAP)] = "VIDIOC_CROPCAP",
245 [_IOC_NR(VIDIOC_G_CROP)] = "VIDIOC_G_CROP",
246 [_IOC_NR(VIDIOC_S_CROP)] = "VIDIOC_S_CROP",
247 [_IOC_NR(VIDIOC_G_JPEGCOMP)] = "VIDIOC_G_JPEGCOMP",
248 [_IOC_NR(VIDIOC_S_JPEGCOMP)] = "VIDIOC_S_JPEGCOMP",
249 [_IOC_NR(VIDIOC_QUERYSTD)] = "VIDIOC_QUERYSTD",
250 [_IOC_NR(VIDIOC_TRY_FMT)] = "VIDIOC_TRY_FMT",
251 [_IOC_NR(VIDIOC_ENUMAUDIO)] = "VIDIOC_ENUMAUDIO",
252 [_IOC_NR(VIDIOC_ENUMAUDOUT)] = "VIDIOC_ENUMAUDOUT",
253 [_IOC_NR(VIDIOC_G_PRIORITY)] = "VIDIOC_G_PRIORITY",
254 [_IOC_NR(VIDIOC_S_PRIORITY)] = "VIDIOC_S_PRIORITY",
255 [_IOC_NR(VIDIOC_G_SLICED_VBI_CAP)] = "VIDIOC_G_SLICED_VBI_CAP",
256 [_IOC_NR(VIDIOC_LOG_STATUS)] = "VIDIOC_LOG_STATUS",
257 [_IOC_NR(VIDIOC_G_EXT_CTRLS)] = "VIDIOC_G_EXT_CTRLS",
258 [_IOC_NR(VIDIOC_S_EXT_CTRLS)] = "VIDIOC_S_EXT_CTRLS",
259 [_IOC_NR(VIDIOC_TRY_EXT_CTRLS)] = "VIDIOC_TRY_EXT_CTRLS",
261 [_IOC_NR(VIDIOC_ENUM_FRAMESIZES)] = "VIDIOC_ENUM_FRAMESIZES",
262 [_IOC_NR(VIDIOC_ENUM_FRAMEINTERVALS)] = "VIDIOC_ENUM_FRAMEINTERVALS",
263 [_IOC_NR(VIDIOC_G_ENC_INDEX)] = "VIDIOC_G_ENC_INDEX",
264 [_IOC_NR(VIDIOC_ENCODER_CMD)] = "VIDIOC_ENCODER_CMD",
265 [_IOC_NR(VIDIOC_TRY_ENCODER_CMD)] = "VIDIOC_TRY_ENCODER_CMD",
267 [_IOC_NR(VIDIOC_DBG_S_REGISTER)] = "VIDIOC_DBG_S_REGISTER",
268 [_IOC_NR(VIDIOC_DBG_G_REGISTER)] = "VIDIOC_DBG_G_REGISTER",
270 [_IOC_NR(VIDIOC_DBG_G_CHIP_IDENT)] = "VIDIOC_DBG_G_CHIP_IDENT",
271 [_IOC_NR(VIDIOC_S_HW_FREQ_SEEK)] = "VIDIOC_S_HW_FREQ_SEEK",
274 #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
276 static const char *v4l2_int_ioctls[] = {
277 #ifdef CONFIG_VIDEO_V4L1_COMPAT
278 [_IOC_NR(DECODER_GET_CAPABILITIES)] = "DECODER_GET_CAPABILITIES",
279 [_IOC_NR(DECODER_GET_STATUS)] = "DECODER_GET_STATUS",
280 [_IOC_NR(DECODER_SET_NORM)] = "DECODER_SET_NORM",
281 [_IOC_NR(DECODER_SET_INPUT)] = "DECODER_SET_INPUT",
282 [_IOC_NR(DECODER_SET_OUTPUT)] = "DECODER_SET_OUTPUT",
283 [_IOC_NR(DECODER_ENABLE_OUTPUT)] = "DECODER_ENABLE_OUTPUT",
284 [_IOC_NR(DECODER_SET_PICTURE)] = "DECODER_SET_PICTURE",
285 [_IOC_NR(DECODER_SET_GPIO)] = "DECODER_SET_GPIO",
286 [_IOC_NR(DECODER_INIT)] = "DECODER_INIT",
287 [_IOC_NR(DECODER_SET_VBI_BYPASS)] = "DECODER_SET_VBI_BYPASS",
288 [_IOC_NR(DECODER_DUMP)] = "DECODER_DUMP",
290 [_IOC_NR(AUDC_SET_RADIO)] = "AUDC_SET_RADIO",
292 [_IOC_NR(TUNER_SET_TYPE_ADDR)] = "TUNER_SET_TYPE_ADDR",
293 [_IOC_NR(TUNER_SET_STANDBY)] = "TUNER_SET_STANDBY",
294 [_IOC_NR(TUNER_SET_CONFIG)] = "TUNER_SET_CONFIG",
296 [_IOC_NR(VIDIOC_INT_S_TUNER_MODE)] = "VIDIOC_INT_S_TUNER_MODE",
297 [_IOC_NR(VIDIOC_INT_RESET)] = "VIDIOC_INT_RESET",
298 [_IOC_NR(VIDIOC_INT_AUDIO_CLOCK_FREQ)] = "VIDIOC_INT_AUDIO_CLOCK_FREQ",
299 [_IOC_NR(VIDIOC_INT_DECODE_VBI_LINE)] = "VIDIOC_INT_DECODE_VBI_LINE",
300 [_IOC_NR(VIDIOC_INT_S_VBI_DATA)] = "VIDIOC_INT_S_VBI_DATA",
301 [_IOC_NR(VIDIOC_INT_G_VBI_DATA)] = "VIDIOC_INT_G_VBI_DATA",
302 [_IOC_NR(VIDIOC_INT_I2S_CLOCK_FREQ)] = "VIDIOC_INT_I2S_CLOCK_FREQ",
303 [_IOC_NR(VIDIOC_INT_S_STANDBY)] = "VIDIOC_INT_S_STANDBY",
304 [_IOC_NR(VIDIOC_INT_S_AUDIO_ROUTING)] = "VIDIOC_INT_S_AUDIO_ROUTING",
305 [_IOC_NR(VIDIOC_INT_G_AUDIO_ROUTING)] = "VIDIOC_INT_G_AUDIO_ROUTING",
306 [_IOC_NR(VIDIOC_INT_S_VIDEO_ROUTING)] = "VIDIOC_INT_S_VIDEO_ROUTING",
307 [_IOC_NR(VIDIOC_INT_G_VIDEO_ROUTING)] = "VIDIOC_INT_G_VIDEO_ROUTING",
308 [_IOC_NR(VIDIOC_INT_S_CRYSTAL_FREQ)] = "VIDIOC_INT_S_CRYSTAL_FREQ",
309 [_IOC_NR(VIDIOC_INT_INIT)] = "VIDIOC_INT_INIT",
310 [_IOC_NR(VIDIOC_INT_G_STD_OUTPUT)] = "VIDIOC_INT_G_STD_OUTPUT",
311 [_IOC_NR(VIDIOC_INT_S_STD_OUTPUT)] = "VIDIOC_INT_S_STD_OUTPUT",
313 #define V4L2_INT_IOCTLS ARRAY_SIZE(v4l2_int_ioctls)
315 /* Common ioctl debug function. This function can be used by
316 external ioctl messages as well as internal V4L ioctl */
317 void v4l_printk_ioctl(unsigned int cmd)
321 switch (_IOC_TYPE(cmd)) {
323 if (_IOC_NR(cmd) >= V4L2_INT_IOCTLS) {
327 printk("%s", v4l2_int_ioctls[_IOC_NR(cmd)]);
329 #ifdef CONFIG_VIDEO_V4L1_COMPAT
331 if (_IOC_NR(cmd) >= V4L1_IOCTLS) {
335 printk("%s", v4l1_ioctls[_IOC_NR(cmd)]);
339 if (_IOC_NR(cmd) >= V4L2_IOCTLS) {
343 printk("%s", v4l2_ioctls[_IOC_NR(cmd)]);
349 switch (_IOC_DIR(cmd)) {
350 case _IOC_NONE: dir = "--"; break;
351 case _IOC_READ: dir = "r-"; break;
352 case _IOC_WRITE: dir = "-w"; break;
353 case _IOC_READ | _IOC_WRITE: dir = "rw"; break;
354 default: dir = "*ERR*"; break;
356 printk("%s ioctl '%c', dir=%s, #%d (0x%08x)",
357 type, _IOC_TYPE(cmd), dir, _IOC_NR(cmd), cmd);
359 EXPORT_SYMBOL(v4l_printk_ioctl);
362 * helper function -- handles userspace copying for ioctl arguments
367 video_fix_command(unsigned int cmd)
370 case VIDIOC_OVERLAY_OLD:
371 cmd = VIDIOC_OVERLAY;
373 case VIDIOC_S_PARM_OLD:
376 case VIDIOC_S_CTRL_OLD:
379 case VIDIOC_G_AUDIO_OLD:
380 cmd = VIDIOC_G_AUDIO;
382 case VIDIOC_G_AUDOUT_OLD:
383 cmd = VIDIOC_G_AUDOUT;
385 case VIDIOC_CROPCAP_OLD:
386 cmd = VIDIOC_CROPCAP;
394 * Obsolete usercopy function - Should be removed soon
397 video_usercopy(struct file *file, unsigned int cmd, unsigned long arg,
405 size_t ctrls_size = 0;
406 void __user *user_ptr = NULL;
409 cmd = video_fix_command(cmd);
411 is_ext_ctrl = (cmd == VIDIOC_S_EXT_CTRLS || cmd == VIDIOC_G_EXT_CTRLS ||
412 cmd == VIDIOC_TRY_EXT_CTRLS);
414 /* Copy arguments into temp kernel buffer */
415 switch (_IOC_DIR(cmd)) {
421 case (_IOC_WRITE | _IOC_READ):
422 if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
425 /* too big to allocate from stack */
426 mbuf = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
433 if (_IOC_DIR(cmd) & _IOC_WRITE)
434 if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
439 struct v4l2_ext_controls *p = parg;
441 /* In case of an error, tell the caller that it wasn't
442 a specific control that caused it. */
443 p->error_idx = p->count;
444 user_ptr = (void __user *)p->controls;
446 ctrls_size = sizeof(struct v4l2_ext_control) * p->count;
447 /* Note: v4l2_ext_controls fits in sbuf[] so mbuf is still NULL. */
448 mbuf = kmalloc(ctrls_size, GFP_KERNEL);
453 if (copy_from_user(mbuf, user_ptr, ctrls_size))
460 err = func(file, cmd, parg);
461 if (err == -ENOIOCTLCMD)
464 struct v4l2_ext_controls *p = parg;
466 p->controls = (void *)user_ptr;
467 if (p->count && err == 0 && copy_to_user(user_ptr, mbuf, ctrls_size))
475 /* Copy results into user buffer */
476 switch (_IOC_DIR(cmd)) {
478 case (_IOC_WRITE | _IOC_READ):
479 if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
488 EXPORT_SYMBOL(video_usercopy);
490 static void dbgbuf(unsigned int cmd, struct video_device *vfd,
491 struct v4l2_buffer *p)
493 struct v4l2_timecode *tc = &p->timecode;
495 dbgarg(cmd, "%02ld:%02d:%02d.%08ld index=%d, type=%s, "
496 "bytesused=%d, flags=0x%08d, "
497 "field=%0d, sequence=%d, memory=%s, offset/userptr=0x%08lx, length=%d\n",
498 p->timestamp.tv_sec / 3600,
499 (int)(p->timestamp.tv_sec / 60) % 60,
500 (int)(p->timestamp.tv_sec % 60),
501 (long)p->timestamp.tv_usec,
503 prt_names(p->type, v4l2_type_names),
504 p->bytesused, p->flags,
505 p->field, p->sequence,
506 prt_names(p->memory, v4l2_memory_names),
507 p->m.userptr, p->length);
508 dbgarg2("timecode=%02d:%02d:%02d type=%d, "
509 "flags=0x%08d, frames=%d, userbits=0x%08x\n",
510 tc->hours, tc->minutes, tc->seconds,
511 tc->type, tc->flags, tc->frames, *(__u32 *)tc->userbits);
514 static inline void dbgrect(struct video_device *vfd, char *s,
517 dbgarg2("%sRect start at %dx%d, size=%dx%d\n", s, r->left, r->top,
518 r->width, r->height);
521 static inline void v4l_print_pix_fmt(struct video_device *vfd,
522 struct v4l2_pix_format *fmt)
524 dbgarg2("width=%d, height=%d, format=%c%c%c%c, field=%s, "
525 "bytesperline=%d sizeimage=%d, colorspace=%d\n",
526 fmt->width, fmt->height,
527 (fmt->pixelformat & 0xff),
528 (fmt->pixelformat >> 8) & 0xff,
529 (fmt->pixelformat >> 16) & 0xff,
530 (fmt->pixelformat >> 24) & 0xff,
531 prt_names(fmt->field, v4l2_field_names),
532 fmt->bytesperline, fmt->sizeimage, fmt->colorspace);
535 static inline void v4l_print_ext_ctrls(unsigned int cmd,
536 struct video_device *vfd, struct v4l2_ext_controls *c, int show_vals)
540 if (!(vfd->debug & V4L2_DEBUG_IOCTL_ARG))
543 printk(KERN_CONT "class=0x%x", c->ctrl_class);
544 for (i = 0; i < c->count; i++) {
546 printk(KERN_CONT " id/val=0x%x/0x%x",
547 c->controls[i].id, c->controls[i].value);
549 printk(KERN_CONT " id=0x%x", c->controls[i].id);
551 printk(KERN_CONT "\n");
554 static inline int check_ext_ctrls(struct v4l2_ext_controls *c, int allow_priv)
558 /* zero the reserved fields */
559 c->reserved[0] = c->reserved[1] = 0;
560 for (i = 0; i < c->count; i++) {
561 c->controls[i].reserved2[0] = 0;
562 c->controls[i].reserved2[1] = 0;
564 /* V4L2_CID_PRIVATE_BASE cannot be used as control class
565 when using extended controls.
566 Only when passed in through VIDIOC_G_CTRL and VIDIOC_S_CTRL
567 is it allowed for backwards compatibility.
569 if (!allow_priv && c->ctrl_class == V4L2_CID_PRIVATE_BASE)
571 /* Check that all controls are from the same control class. */
572 for (i = 0; i < c->count; i++) {
573 if (V4L2_CTRL_ID2CLASS(c->controls[i].id) != c->ctrl_class) {
581 static int check_fmt(const struct v4l2_ioctl_ops *ops, enum v4l2_buf_type type)
587 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
588 if (ops->vidioc_try_fmt_vid_cap)
591 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
592 if (ops->vidioc_try_fmt_vid_overlay)
595 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
596 if (ops->vidioc_try_fmt_vid_out)
599 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
600 if (ops->vidioc_try_fmt_vid_out_overlay)
603 case V4L2_BUF_TYPE_VBI_CAPTURE:
604 if (ops->vidioc_try_fmt_vbi_cap)
607 case V4L2_BUF_TYPE_VBI_OUTPUT:
608 if (ops->vidioc_try_fmt_vbi_out)
611 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
612 if (ops->vidioc_try_fmt_sliced_vbi_cap)
615 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
616 if (ops->vidioc_try_fmt_sliced_vbi_out)
619 case V4L2_BUF_TYPE_PRIVATE:
620 if (ops->vidioc_try_fmt_type_private)
627 static long __video_do_ioctl(struct file *file,
628 unsigned int cmd, void *arg)
630 struct video_device *vfd = video_devdata(file);
631 const struct v4l2_ioctl_ops *ops = vfd->ioctl_ops;
632 void *fh = file->private_data;
635 if ((vfd->debug & V4L2_DEBUG_IOCTL) &&
636 !(vfd->debug & V4L2_DEBUG_IOCTL_ARG)) {
637 v4l_print_ioctl(vfd->name, cmd);
638 printk(KERN_CONT "\n");
642 printk(KERN_WARNING "videodev: \"%s\" has no ioctl_ops.\n",
647 #ifdef CONFIG_VIDEO_V4L1_COMPAT
648 /***********************************************************
649 Handles calls to the obsoleted V4L1 API
650 Due to the nature of VIDIOCGMBUF, each driver that supports
651 V4L1 should implement its own handler for this ioctl.
652 ***********************************************************/
654 /* --- streaming capture ------------------------------------- */
655 if (cmd == VIDIOCGMBUF) {
656 struct video_mbuf *p = arg;
658 memset(p, 0, sizeof(*p));
660 if (!ops->vidiocgmbuf)
662 ret = ops->vidiocgmbuf(file, fh, p);
664 dbgarg(cmd, "size=%d, frames=%d, offsets=0x%08lx\n",
666 (unsigned long)p->offsets);
670 /********************************************************
671 All other V4L1 calls are handled by v4l1_compat module.
672 Those calls will be translated into V4L2 calls, and
673 __video_do_ioctl will be called again, with one or more
675 ********************************************************/
676 if (_IOC_TYPE(cmd) == 'v' && _IOC_NR(cmd) < BASE_VIDIOCPRIVATE)
677 return v4l_compat_translate_ioctl(file, cmd, arg,
682 /* --- capabilities ------------------------------------------ */
683 case VIDIOC_QUERYCAP:
685 struct v4l2_capability *cap = (struct v4l2_capability *)arg;
686 memset(cap, 0, sizeof(*cap));
688 if (!ops->vidioc_querycap)
691 ret = ops->vidioc_querycap(file, fh, cap);
693 dbgarg(cmd, "driver=%s, card=%s, bus=%s, "
695 "capabilities=0x%08x\n",
696 cap->driver, cap->card, cap->bus_info,
702 /* --- priority ------------------------------------------ */
703 case VIDIOC_G_PRIORITY:
705 enum v4l2_priority *p = arg;
707 if (!ops->vidioc_g_priority)
709 ret = ops->vidioc_g_priority(file, fh, p);
711 dbgarg(cmd, "priority is %d\n", *p);
714 case VIDIOC_S_PRIORITY:
716 enum v4l2_priority *p = arg;
718 if (!ops->vidioc_s_priority)
720 dbgarg(cmd, "setting priority to %d\n", *p);
721 ret = ops->vidioc_s_priority(file, fh, *p);
725 /* --- capture ioctls ---------------------------------------- */
726 case VIDIOC_ENUM_FMT:
728 struct v4l2_fmtdesc *f = arg;
729 enum v4l2_buf_type type;
734 memset(f, 0, sizeof(*f));
739 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
740 if (ops->vidioc_enum_fmt_vid_cap)
741 ret = ops->vidioc_enum_fmt_vid_cap(file, fh, f);
743 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
744 if (ops->vidioc_enum_fmt_vid_overlay)
745 ret = ops->vidioc_enum_fmt_vid_overlay(file,
748 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
749 if (ops->vidioc_enum_fmt_vid_out)
750 ret = ops->vidioc_enum_fmt_vid_out(file, fh, f);
752 case V4L2_BUF_TYPE_PRIVATE:
753 if (ops->vidioc_enum_fmt_type_private)
754 ret = ops->vidioc_enum_fmt_type_private(file,
761 dbgarg(cmd, "index=%d, type=%d, flags=%d, "
762 "pixelformat=%c%c%c%c, description='%s'\n",
763 f->index, f->type, f->flags,
764 (f->pixelformat & 0xff),
765 (f->pixelformat >> 8) & 0xff,
766 (f->pixelformat >> 16) & 0xff,
767 (f->pixelformat >> 24) & 0xff,
773 struct v4l2_format *f = (struct v4l2_format *)arg;
775 memset(f->fmt.raw_data, 0, sizeof(f->fmt.raw_data));
777 /* FIXME: Should be one dump per type */
778 dbgarg(cmd, "type=%s\n", prt_names(f->type, v4l2_type_names));
781 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
782 if (ops->vidioc_g_fmt_vid_cap)
783 ret = ops->vidioc_g_fmt_vid_cap(file, fh, f);
785 v4l_print_pix_fmt(vfd, &f->fmt.pix);
787 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
788 if (ops->vidioc_g_fmt_vid_overlay)
789 ret = ops->vidioc_g_fmt_vid_overlay(file,
792 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
793 if (ops->vidioc_g_fmt_vid_out)
794 ret = ops->vidioc_g_fmt_vid_out(file, fh, f);
796 v4l_print_pix_fmt(vfd, &f->fmt.pix);
798 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
799 if (ops->vidioc_g_fmt_vid_out_overlay)
800 ret = ops->vidioc_g_fmt_vid_out_overlay(file,
803 case V4L2_BUF_TYPE_VBI_CAPTURE:
804 if (ops->vidioc_g_fmt_vbi_cap)
805 ret = ops->vidioc_g_fmt_vbi_cap(file, fh, f);
807 case V4L2_BUF_TYPE_VBI_OUTPUT:
808 if (ops->vidioc_g_fmt_vbi_out)
809 ret = ops->vidioc_g_fmt_vbi_out(file, fh, f);
811 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
812 if (ops->vidioc_g_fmt_sliced_vbi_cap)
813 ret = ops->vidioc_g_fmt_sliced_vbi_cap(file,
816 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
817 if (ops->vidioc_g_fmt_sliced_vbi_out)
818 ret = ops->vidioc_g_fmt_sliced_vbi_out(file,
821 case V4L2_BUF_TYPE_PRIVATE:
822 if (ops->vidioc_g_fmt_type_private)
823 ret = ops->vidioc_g_fmt_type_private(file,
832 struct v4l2_format *f = (struct v4l2_format *)arg;
834 /* FIXME: Should be one dump per type */
835 dbgarg(cmd, "type=%s\n", prt_names(f->type, v4l2_type_names));
838 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
839 v4l_print_pix_fmt(vfd, &f->fmt.pix);
840 if (ops->vidioc_s_fmt_vid_cap)
841 ret = ops->vidioc_s_fmt_vid_cap(file, fh, f);
843 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
844 if (ops->vidioc_s_fmt_vid_overlay)
845 ret = ops->vidioc_s_fmt_vid_overlay(file,
848 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
849 v4l_print_pix_fmt(vfd, &f->fmt.pix);
850 if (ops->vidioc_s_fmt_vid_out)
851 ret = ops->vidioc_s_fmt_vid_out(file, fh, f);
853 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
854 if (ops->vidioc_s_fmt_vid_out_overlay)
855 ret = ops->vidioc_s_fmt_vid_out_overlay(file,
858 case V4L2_BUF_TYPE_VBI_CAPTURE:
859 if (ops->vidioc_s_fmt_vbi_cap)
860 ret = ops->vidioc_s_fmt_vbi_cap(file, fh, f);
862 case V4L2_BUF_TYPE_VBI_OUTPUT:
863 if (ops->vidioc_s_fmt_vbi_out)
864 ret = ops->vidioc_s_fmt_vbi_out(file, fh, f);
866 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
867 if (ops->vidioc_s_fmt_sliced_vbi_cap)
868 ret = ops->vidioc_s_fmt_sliced_vbi_cap(file,
871 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
872 if (ops->vidioc_s_fmt_sliced_vbi_out)
873 ret = ops->vidioc_s_fmt_sliced_vbi_out(file,
876 case V4L2_BUF_TYPE_PRIVATE:
877 if (ops->vidioc_s_fmt_type_private)
878 ret = ops->vidioc_s_fmt_type_private(file,
886 struct v4l2_format *f = (struct v4l2_format *)arg;
888 /* FIXME: Should be one dump per type */
889 dbgarg(cmd, "type=%s\n", prt_names(f->type,
892 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
893 if (ops->vidioc_try_fmt_vid_cap)
894 ret = ops->vidioc_try_fmt_vid_cap(file, fh, f);
896 v4l_print_pix_fmt(vfd, &f->fmt.pix);
898 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
899 if (ops->vidioc_try_fmt_vid_overlay)
900 ret = ops->vidioc_try_fmt_vid_overlay(file,
903 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
904 if (ops->vidioc_try_fmt_vid_out)
905 ret = ops->vidioc_try_fmt_vid_out(file, fh, f);
907 v4l_print_pix_fmt(vfd, &f->fmt.pix);
909 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
910 if (ops->vidioc_try_fmt_vid_out_overlay)
911 ret = ops->vidioc_try_fmt_vid_out_overlay(file,
914 case V4L2_BUF_TYPE_VBI_CAPTURE:
915 if (ops->vidioc_try_fmt_vbi_cap)
916 ret = ops->vidioc_try_fmt_vbi_cap(file, fh, f);
918 case V4L2_BUF_TYPE_VBI_OUTPUT:
919 if (ops->vidioc_try_fmt_vbi_out)
920 ret = ops->vidioc_try_fmt_vbi_out(file, fh, f);
922 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
923 if (ops->vidioc_try_fmt_sliced_vbi_cap)
924 ret = ops->vidioc_try_fmt_sliced_vbi_cap(file,
927 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
928 if (ops->vidioc_try_fmt_sliced_vbi_out)
929 ret = ops->vidioc_try_fmt_sliced_vbi_out(file,
932 case V4L2_BUF_TYPE_PRIVATE:
933 if (ops->vidioc_try_fmt_type_private)
934 ret = ops->vidioc_try_fmt_type_private(file,
941 /* FIXME: Those buf reqs could be handled here,
942 with some changes on videobuf to allow its header to be included at
943 videodev2.h or being merged at videodev2.
947 struct v4l2_requestbuffers *p = arg;
949 if (!ops->vidioc_reqbufs)
951 ret = check_fmt(ops, p->type);
955 ret = ops->vidioc_reqbufs(file, fh, p);
956 dbgarg(cmd, "count=%d, type=%s, memory=%s\n",
958 prt_names(p->type, v4l2_type_names),
959 prt_names(p->memory, v4l2_memory_names));
962 case VIDIOC_QUERYBUF:
964 struct v4l2_buffer *p = arg;
966 if (!ops->vidioc_querybuf)
968 ret = check_fmt(ops, p->type);
972 /* Zero out all fields starting with bytesysed, which is
973 * everything but index and type. */
974 memset(0, &p->bytesused,
975 sizeof(*p) - offsetof(typeof(*p), bytesused));
977 ret = ops->vidioc_querybuf(file, fh, p);
984 struct v4l2_buffer *p = arg;
986 if (!ops->vidioc_qbuf)
988 ret = check_fmt(ops, p->type);
992 ret = ops->vidioc_qbuf(file, fh, p);
999 struct v4l2_buffer *p = arg;
1001 if (!ops->vidioc_dqbuf)
1003 ret = check_fmt(ops, p->type);
1007 ret = ops->vidioc_dqbuf(file, fh, p);
1009 dbgbuf(cmd, vfd, p);
1012 case VIDIOC_OVERLAY:
1016 if (!ops->vidioc_overlay)
1018 dbgarg(cmd, "value=%d\n", *i);
1019 ret = ops->vidioc_overlay(file, fh, *i);
1024 struct v4l2_framebuffer *p = arg;
1026 if (!ops->vidioc_g_fbuf)
1028 ret = ops->vidioc_g_fbuf(file, fh, arg);
1030 dbgarg(cmd, "capability=0x%x, flags=%d, base=0x%08lx\n",
1031 p->capability, p->flags,
1032 (unsigned long)p->base);
1033 v4l_print_pix_fmt(vfd, &p->fmt);
1039 struct v4l2_framebuffer *p = arg;
1041 if (!ops->vidioc_s_fbuf)
1043 dbgarg(cmd, "capability=0x%x, flags=%d, base=0x%08lx\n",
1044 p->capability, p->flags, (unsigned long)p->base);
1045 v4l_print_pix_fmt(vfd, &p->fmt);
1046 ret = ops->vidioc_s_fbuf(file, fh, arg);
1049 case VIDIOC_STREAMON:
1051 enum v4l2_buf_type i = *(int *)arg;
1053 if (!ops->vidioc_streamon)
1055 dbgarg(cmd, "type=%s\n", prt_names(i, v4l2_type_names));
1056 ret = ops->vidioc_streamon(file, fh, i);
1059 case VIDIOC_STREAMOFF:
1061 enum v4l2_buf_type i = *(int *)arg;
1063 if (!ops->vidioc_streamoff)
1065 dbgarg(cmd, "type=%s\n", prt_names(i, v4l2_type_names));
1066 ret = ops->vidioc_streamoff(file, fh, i);
1069 /* ---------- tv norms ---------- */
1070 case VIDIOC_ENUMSTD:
1072 struct v4l2_standard *p = arg;
1073 v4l2_std_id id = vfd->tvnorms, curr_id = 0;
1074 unsigned int index = p->index, i, j = 0;
1075 const char *descr = "";
1077 /* Return norm array in a canonical way */
1078 for (i = 0; i <= index && id; i++) {
1079 /* last std value in the standards array is 0, so this
1080 while always ends there since (id & 0) == 0. */
1081 while ((id & standards[j].std) != standards[j].std)
1083 curr_id = standards[j].std;
1084 descr = standards[j].descr;
1088 if (curr_id != V4L2_STD_PAL &&
1089 curr_id != V4L2_STD_SECAM &&
1090 curr_id != V4L2_STD_NTSC)
1096 v4l2_video_std_construct(p, curr_id, descr);
1099 dbgarg(cmd, "index=%d, id=0x%Lx, name=%s, fps=%d/%d, "
1100 "framelines=%d\n", p->index,
1101 (unsigned long long)p->id, p->name,
1102 p->frameperiod.numerator,
1103 p->frameperiod.denominator,
1111 v4l2_std_id *id = arg;
1114 /* Calls the specific handler */
1115 if (ops->vidioc_g_std)
1116 ret = ops->vidioc_g_std(file, fh, id);
1118 *id = vfd->current_norm;
1121 dbgarg(cmd, "std=0x%08Lx\n", (long long unsigned)*id);
1126 v4l2_std_id *id = arg, norm;
1128 dbgarg(cmd, "std=%08Lx\n", (long long unsigned)*id);
1130 norm = (*id) & vfd->tvnorms;
1131 if (vfd->tvnorms && !norm) /* Check if std is supported */
1134 /* Calls the specific handler */
1135 if (ops->vidioc_s_std)
1136 ret = ops->vidioc_s_std(file, fh, &norm);
1140 /* Updates standard information */
1142 vfd->current_norm = norm;
1145 case VIDIOC_QUERYSTD:
1147 v4l2_std_id *p = arg;
1149 if (!ops->vidioc_querystd)
1151 ret = ops->vidioc_querystd(file, fh, arg);
1153 dbgarg(cmd, "detected std=%08Lx\n",
1154 (unsigned long long)*p);
1157 /* ------ input switching ---------- */
1158 /* FIXME: Inputs can be handled inside videodev2 */
1159 case VIDIOC_ENUMINPUT:
1161 struct v4l2_input *p = arg;
1164 if (!ops->vidioc_enum_input)
1166 memset(p, 0, sizeof(*p));
1169 ret = ops->vidioc_enum_input(file, fh, p);
1171 dbgarg(cmd, "index=%d, name=%s, type=%d, "
1173 "tuner=%d, std=%08Lx, status=%d\n",
1174 p->index, p->name, p->type, p->audioset,
1176 (unsigned long long)p->std,
1180 case VIDIOC_G_INPUT:
1182 unsigned int *i = arg;
1184 if (!ops->vidioc_g_input)
1186 ret = ops->vidioc_g_input(file, fh, i);
1188 dbgarg(cmd, "value=%d\n", *i);
1191 case VIDIOC_S_INPUT:
1193 unsigned int *i = arg;
1195 if (!ops->vidioc_s_input)
1197 dbgarg(cmd, "value=%d\n", *i);
1198 ret = ops->vidioc_s_input(file, fh, *i);
1202 /* ------ output switching ---------- */
1203 case VIDIOC_ENUMOUTPUT:
1205 struct v4l2_output *p = arg;
1208 if (!ops->vidioc_enum_output)
1210 memset(p, 0, sizeof(*p));
1213 ret = ops->vidioc_enum_output(file, fh, p);
1215 dbgarg(cmd, "index=%d, name=%s, type=%d, "
1217 "modulator=%d, std=0x%08Lx\n",
1218 p->index, p->name, p->type, p->audioset,
1219 p->modulator, (unsigned long long)p->std);
1222 case VIDIOC_G_OUTPUT:
1224 unsigned int *i = arg;
1226 if (!ops->vidioc_g_output)
1228 ret = ops->vidioc_g_output(file, fh, i);
1230 dbgarg(cmd, "value=%d\n", *i);
1233 case VIDIOC_S_OUTPUT:
1235 unsigned int *i = arg;
1237 if (!ops->vidioc_s_output)
1239 dbgarg(cmd, "value=%d\n", *i);
1240 ret = ops->vidioc_s_output(file, fh, *i);
1244 /* --- controls ---------------------------------------------- */
1245 case VIDIOC_QUERYCTRL:
1247 struct v4l2_queryctrl *p = arg;
1249 if (!ops->vidioc_queryctrl)
1251 ret = ops->vidioc_queryctrl(file, fh, p);
1253 dbgarg(cmd, "id=0x%x, type=%d, name=%s, min/max=%d/%d, "
1254 "step=%d, default=%d, flags=0x%08x\n",
1255 p->id, p->type, p->name,
1256 p->minimum, p->maximum,
1257 p->step, p->default_value, p->flags);
1259 dbgarg(cmd, "id=0x%x\n", p->id);
1264 struct v4l2_control *p = arg;
1266 if (ops->vidioc_g_ctrl)
1267 ret = ops->vidioc_g_ctrl(file, fh, p);
1268 else if (ops->vidioc_g_ext_ctrls) {
1269 struct v4l2_ext_controls ctrls;
1270 struct v4l2_ext_control ctrl;
1272 ctrls.ctrl_class = V4L2_CTRL_ID2CLASS(p->id);
1274 ctrls.controls = &ctrl;
1276 ctrl.value = p->value;
1277 if (check_ext_ctrls(&ctrls, 1)) {
1278 ret = ops->vidioc_g_ext_ctrls(file, fh, &ctrls);
1280 p->value = ctrl.value;
1285 dbgarg(cmd, "id=0x%x, value=%d\n", p->id, p->value);
1287 dbgarg(cmd, "id=0x%x\n", p->id);
1292 struct v4l2_control *p = arg;
1293 struct v4l2_ext_controls ctrls;
1294 struct v4l2_ext_control ctrl;
1296 if (!ops->vidioc_s_ctrl && !ops->vidioc_s_ext_ctrls)
1299 dbgarg(cmd, "id=0x%x, value=%d\n", p->id, p->value);
1301 if (ops->vidioc_s_ctrl) {
1302 ret = ops->vidioc_s_ctrl(file, fh, p);
1305 if (!ops->vidioc_s_ext_ctrls)
1308 ctrls.ctrl_class = V4L2_CTRL_ID2CLASS(p->id);
1310 ctrls.controls = &ctrl;
1312 ctrl.value = p->value;
1313 if (check_ext_ctrls(&ctrls, 1))
1314 ret = ops->vidioc_s_ext_ctrls(file, fh, &ctrls);
1317 case VIDIOC_G_EXT_CTRLS:
1319 struct v4l2_ext_controls *p = arg;
1321 p->error_idx = p->count;
1322 if (!ops->vidioc_g_ext_ctrls)
1324 if (check_ext_ctrls(p, 0))
1325 ret = ops->vidioc_g_ext_ctrls(file, fh, p);
1326 v4l_print_ext_ctrls(cmd, vfd, p, !ret);
1329 case VIDIOC_S_EXT_CTRLS:
1331 struct v4l2_ext_controls *p = arg;
1333 p->error_idx = p->count;
1334 if (!ops->vidioc_s_ext_ctrls)
1336 v4l_print_ext_ctrls(cmd, vfd, p, 1);
1337 if (check_ext_ctrls(p, 0))
1338 ret = ops->vidioc_s_ext_ctrls(file, fh, p);
1341 case VIDIOC_TRY_EXT_CTRLS:
1343 struct v4l2_ext_controls *p = arg;
1345 p->error_idx = p->count;
1346 if (!ops->vidioc_try_ext_ctrls)
1348 v4l_print_ext_ctrls(cmd, vfd, p, 1);
1349 if (check_ext_ctrls(p, 0))
1350 ret = ops->vidioc_try_ext_ctrls(file, fh, p);
1353 case VIDIOC_QUERYMENU:
1355 struct v4l2_querymenu *p = arg;
1357 if (!ops->vidioc_querymenu)
1359 ret = ops->vidioc_querymenu(file, fh, p);
1361 dbgarg(cmd, "id=0x%x, index=%d, name=%s\n",
1362 p->id, p->index, p->name);
1364 dbgarg(cmd, "id=0x%x, index=%d\n",
1368 /* --- audio ---------------------------------------------- */
1369 case VIDIOC_ENUMAUDIO:
1371 struct v4l2_audio *p = arg;
1373 if (!ops->vidioc_enumaudio)
1375 ret = ops->vidioc_enumaudio(file, fh, p);
1377 dbgarg(cmd, "index=%d, name=%s, capability=0x%x, "
1378 "mode=0x%x\n", p->index, p->name,
1379 p->capability, p->mode);
1381 dbgarg(cmd, "index=%d\n", p->index);
1384 case VIDIOC_G_AUDIO:
1386 struct v4l2_audio *p = arg;
1387 __u32 index = p->index;
1389 if (!ops->vidioc_g_audio)
1392 memset(p, 0, sizeof(*p));
1394 ret = ops->vidioc_g_audio(file, fh, p);
1396 dbgarg(cmd, "index=%d, name=%s, capability=0x%x, "
1397 "mode=0x%x\n", p->index,
1398 p->name, p->capability, p->mode);
1400 dbgarg(cmd, "index=%d\n", p->index);
1403 case VIDIOC_S_AUDIO:
1405 struct v4l2_audio *p = arg;
1407 if (!ops->vidioc_s_audio)
1409 dbgarg(cmd, "index=%d, name=%s, capability=0x%x, "
1410 "mode=0x%x\n", p->index, p->name,
1411 p->capability, p->mode);
1412 ret = ops->vidioc_s_audio(file, fh, p);
1415 case VIDIOC_ENUMAUDOUT:
1417 struct v4l2_audioout *p = arg;
1419 if (!ops->vidioc_enumaudout)
1421 dbgarg(cmd, "Enum for index=%d\n", p->index);
1422 ret = ops->vidioc_enumaudout(file, fh, p);
1424 dbgarg2("index=%d, name=%s, capability=%d, "
1425 "mode=%d\n", p->index, p->name,
1426 p->capability, p->mode);
1429 case VIDIOC_G_AUDOUT:
1431 struct v4l2_audioout *p = arg;
1433 if (!ops->vidioc_g_audout)
1435 dbgarg(cmd, "Enum for index=%d\n", p->index);
1436 ret = ops->vidioc_g_audout(file, fh, p);
1438 dbgarg2("index=%d, name=%s, capability=%d, "
1439 "mode=%d\n", p->index, p->name,
1440 p->capability, p->mode);
1443 case VIDIOC_S_AUDOUT:
1445 struct v4l2_audioout *p = arg;
1447 if (!ops->vidioc_s_audout)
1449 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1450 "mode=%d\n", p->index, p->name,
1451 p->capability, p->mode);
1453 ret = ops->vidioc_s_audout(file, fh, p);
1456 case VIDIOC_G_MODULATOR:
1458 struct v4l2_modulator *p = arg;
1460 if (!ops->vidioc_g_modulator)
1462 ret = ops->vidioc_g_modulator(file, fh, p);
1464 dbgarg(cmd, "index=%d, name=%s, "
1465 "capability=%d, rangelow=%d,"
1466 " rangehigh=%d, txsubchans=%d\n",
1467 p->index, p->name, p->capability,
1468 p->rangelow, p->rangehigh,
1472 case VIDIOC_S_MODULATOR:
1474 struct v4l2_modulator *p = arg;
1476 if (!ops->vidioc_s_modulator)
1478 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1479 "rangelow=%d, rangehigh=%d, txsubchans=%d\n",
1480 p->index, p->name, p->capability, p->rangelow,
1481 p->rangehigh, p->txsubchans);
1482 ret = ops->vidioc_s_modulator(file, fh, p);
1487 struct v4l2_crop *p = arg;
1490 if (!ops->vidioc_g_crop)
1494 memset(p, 0, sizeof(*p));
1497 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
1498 ret = ops->vidioc_g_crop(file, fh, p);
1500 dbgrect(vfd, "", &p->c);
1505 struct v4l2_crop *p = arg;
1507 if (!ops->vidioc_s_crop)
1509 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
1510 dbgrect(vfd, "", &p->c);
1511 ret = ops->vidioc_s_crop(file, fh, p);
1514 case VIDIOC_CROPCAP:
1516 struct v4l2_cropcap *p = arg;
1519 /*FIXME: Should also show v4l2_fract pixelaspect */
1520 if (!ops->vidioc_cropcap)
1524 memset(p, 0, sizeof(*p));
1527 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
1528 ret = ops->vidioc_cropcap(file, fh, p);
1530 dbgrect(vfd, "bounds ", &p->bounds);
1531 dbgrect(vfd, "defrect ", &p->defrect);
1535 case VIDIOC_G_JPEGCOMP:
1537 struct v4l2_jpegcompression *p = arg;
1539 if (!ops->vidioc_g_jpegcomp)
1542 memset(p, 0, sizeof(*p));
1544 ret = ops->vidioc_g_jpegcomp(file, fh, p);
1546 dbgarg(cmd, "quality=%d, APPn=%d, "
1547 "APP_len=%d, COM_len=%d, "
1548 "jpeg_markers=%d\n",
1549 p->quality, p->APPn, p->APP_len,
1550 p->COM_len, p->jpeg_markers);
1553 case VIDIOC_S_JPEGCOMP:
1555 struct v4l2_jpegcompression *p = arg;
1557 if (!ops->vidioc_g_jpegcomp)
1559 dbgarg(cmd, "quality=%d, APPn=%d, APP_len=%d, "
1560 "COM_len=%d, jpeg_markers=%d\n",
1561 p->quality, p->APPn, p->APP_len,
1562 p->COM_len, p->jpeg_markers);
1563 ret = ops->vidioc_s_jpegcomp(file, fh, p);
1566 case VIDIOC_G_ENC_INDEX:
1568 struct v4l2_enc_idx *p = arg;
1570 if (!ops->vidioc_g_enc_index)
1572 ret = ops->vidioc_g_enc_index(file, fh, p);
1574 dbgarg(cmd, "entries=%d, entries_cap=%d\n",
1575 p->entries, p->entries_cap);
1578 case VIDIOC_ENCODER_CMD:
1580 struct v4l2_encoder_cmd *p = arg;
1582 if (!ops->vidioc_encoder_cmd)
1584 memset(&p->raw, 0, sizeof(p->raw));
1585 ret = ops->vidioc_encoder_cmd(file, fh, p);
1587 dbgarg(cmd, "cmd=%d, flags=%x\n", p->cmd, p->flags);
1590 case VIDIOC_TRY_ENCODER_CMD:
1592 struct v4l2_encoder_cmd *p = arg;
1594 if (!ops->vidioc_try_encoder_cmd)
1596 memset(&p->raw, 0, sizeof(p->raw));
1597 ret = ops->vidioc_try_encoder_cmd(file, fh, p);
1599 dbgarg(cmd, "cmd=%d, flags=%x\n", p->cmd, p->flags);
1604 struct v4l2_streamparm *p = arg;
1605 __u32 type = p->type;
1607 memset(p, 0, sizeof(*p));
1610 if (ops->vidioc_g_parm) {
1611 ret = ops->vidioc_g_parm(file, fh, p);
1613 struct v4l2_standard s;
1615 if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1618 v4l2_video_std_construct(&s, vfd->current_norm,
1619 v4l2_norm_to_name(vfd->current_norm));
1621 p->parm.capture.timeperframe = s.frameperiod;
1625 dbgarg(cmd, "type=%d\n", p->type);
1630 struct v4l2_streamparm *p = arg;
1632 if (!ops->vidioc_s_parm)
1634 dbgarg(cmd, "type=%d\n", p->type);
1635 ret = ops->vidioc_s_parm(file, fh, p);
1638 case VIDIOC_G_TUNER:
1640 struct v4l2_tuner *p = arg;
1641 __u32 index = p->index;
1643 if (!ops->vidioc_g_tuner)
1646 memset(p, 0, sizeof(*p));
1649 ret = ops->vidioc_g_tuner(file, fh, p);
1651 dbgarg(cmd, "index=%d, name=%s, type=%d, "
1652 "capability=0x%x, rangelow=%d, "
1653 "rangehigh=%d, signal=%d, afc=%d, "
1654 "rxsubchans=0x%x, audmode=%d\n",
1655 p->index, p->name, p->type,
1656 p->capability, p->rangelow,
1657 p->rangehigh, p->signal, p->afc,
1658 p->rxsubchans, p->audmode);
1661 case VIDIOC_S_TUNER:
1663 struct v4l2_tuner *p = arg;
1665 if (!ops->vidioc_s_tuner)
1667 dbgarg(cmd, "index=%d, name=%s, type=%d, "
1668 "capability=0x%x, rangelow=%d, "
1669 "rangehigh=%d, signal=%d, afc=%d, "
1670 "rxsubchans=0x%x, audmode=%d\n",
1671 p->index, p->name, p->type,
1672 p->capability, p->rangelow,
1673 p->rangehigh, p->signal, p->afc,
1674 p->rxsubchans, p->audmode);
1675 ret = ops->vidioc_s_tuner(file, fh, p);
1678 case VIDIOC_G_FREQUENCY:
1680 struct v4l2_frequency *p = arg;
1682 if (!ops->vidioc_g_frequency)
1685 memset(p->reserved, 0, sizeof(p->reserved));
1687 ret = ops->vidioc_g_frequency(file, fh, p);
1689 dbgarg(cmd, "tuner=%d, type=%d, frequency=%d\n",
1690 p->tuner, p->type, p->frequency);
1693 case VIDIOC_S_FREQUENCY:
1695 struct v4l2_frequency *p = arg;
1697 if (!ops->vidioc_s_frequency)
1699 dbgarg(cmd, "tuner=%d, type=%d, frequency=%d\n",
1700 p->tuner, p->type, p->frequency);
1701 ret = ops->vidioc_s_frequency(file, fh, p);
1704 case VIDIOC_G_SLICED_VBI_CAP:
1706 struct v4l2_sliced_vbi_cap *p = arg;
1707 __u32 type = p->type;
1709 if (!ops->vidioc_g_sliced_vbi_cap)
1711 memset(p, 0, sizeof(*p));
1713 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
1714 ret = ops->vidioc_g_sliced_vbi_cap(file, fh, p);
1716 dbgarg2("service_set=%d\n", p->service_set);
1719 case VIDIOC_LOG_STATUS:
1721 if (!ops->vidioc_log_status)
1723 ret = ops->vidioc_log_status(file, fh);
1726 #ifdef CONFIG_VIDEO_ADV_DEBUG
1727 case VIDIOC_DBG_G_REGISTER:
1729 struct v4l2_dbg_register *p = arg;
1731 if (!capable(CAP_SYS_ADMIN))
1733 else if (ops->vidioc_g_register)
1734 ret = ops->vidioc_g_register(file, fh, p);
1737 case VIDIOC_DBG_S_REGISTER:
1739 struct v4l2_dbg_register *p = arg;
1741 if (!capable(CAP_SYS_ADMIN))
1743 else if (ops->vidioc_s_register)
1744 ret = ops->vidioc_s_register(file, fh, p);
1748 case VIDIOC_DBG_G_CHIP_IDENT:
1750 struct v4l2_dbg_chip_ident *p = arg;
1752 if (!ops->vidioc_g_chip_ident)
1754 p->ident = V4L2_IDENT_NONE;
1756 ret = ops->vidioc_g_chip_ident(file, fh, p);
1758 dbgarg(cmd, "chip_ident=%u, revision=0x%x\n", p->ident, p->revision);
1761 case VIDIOC_G_CHIP_IDENT_OLD:
1762 printk(KERN_ERR "VIDIOC_G_CHIP_IDENT has been deprecated and will disappear in 2.6.30.\n");
1763 printk(KERN_ERR "It is a debugging ioctl and must not be used in applications!\n");
1766 case VIDIOC_S_HW_FREQ_SEEK:
1768 struct v4l2_hw_freq_seek *p = arg;
1770 if (!ops->vidioc_s_hw_freq_seek)
1773 "tuner=%d, type=%d, seek_upward=%d, wrap_around=%d\n",
1774 p->tuner, p->type, p->seek_upward, p->wrap_around);
1775 ret = ops->vidioc_s_hw_freq_seek(file, fh, p);
1778 case VIDIOC_ENUM_FRAMESIZES:
1780 struct v4l2_frmsizeenum *p = arg;
1782 if (!ops->vidioc_enum_framesizes)
1785 memset(p, 0, sizeof(*p));
1787 ret = ops->vidioc_enum_framesizes(file, fh, p);
1789 "index=%d, pixelformat=%d, type=%d ",
1790 p->index, p->pixel_format, p->type);
1792 case V4L2_FRMSIZE_TYPE_DISCRETE:
1793 dbgarg2("width = %d, height=%d\n",
1794 p->discrete.width, p->discrete.height);
1796 case V4L2_FRMSIZE_TYPE_STEPWISE:
1797 dbgarg2("min %dx%d, max %dx%d, step %dx%d\n",
1798 p->stepwise.min_width, p->stepwise.min_height,
1799 p->stepwise.step_width, p->stepwise.step_height,
1800 p->stepwise.max_width, p->stepwise.max_height);
1802 case V4L2_FRMSIZE_TYPE_CONTINUOUS:
1803 dbgarg2("continuous\n");
1806 dbgarg2("- Unknown type!\n");
1811 case VIDIOC_ENUM_FRAMEINTERVALS:
1813 struct v4l2_frmivalenum *p = arg;
1815 if (!ops->vidioc_enum_frameintervals)
1818 memset(p, 0, sizeof(*p));
1820 ret = ops->vidioc_enum_frameintervals(file, fh, p);
1822 "index=%d, pixelformat=%d, width=%d, height=%d, type=%d ",
1823 p->index, p->pixel_format,
1824 p->width, p->height, p->type);
1826 case V4L2_FRMIVAL_TYPE_DISCRETE:
1827 dbgarg2("fps=%d/%d\n",
1828 p->discrete.numerator,
1829 p->discrete.denominator);
1831 case V4L2_FRMIVAL_TYPE_STEPWISE:
1832 dbgarg2("min=%d/%d, max=%d/%d, step=%d/%d\n",
1833 p->stepwise.min.numerator,
1834 p->stepwise.min.denominator,
1835 p->stepwise.max.numerator,
1836 p->stepwise.max.denominator,
1837 p->stepwise.step.numerator,
1838 p->stepwise.step.denominator);
1840 case V4L2_FRMIVAL_TYPE_CONTINUOUS:
1841 dbgarg2("continuous\n");
1844 dbgarg2("- Unknown type!\n");
1851 if (!ops->vidioc_default)
1853 ret = ops->vidioc_default(file, fh, cmd, arg);
1858 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) {
1860 v4l_print_ioctl(vfd->name, cmd);
1861 printk(KERN_CONT " error %ld\n", ret);
1868 long video_ioctl2(struct file *file,
1869 unsigned int cmd, unsigned long arg)
1876 size_t ctrls_size = 0;
1877 void __user *user_ptr = NULL;
1879 #ifdef __OLD_VIDIOC_
1880 cmd = video_fix_command(cmd);
1882 is_ext_ctrl = (cmd == VIDIOC_S_EXT_CTRLS || cmd == VIDIOC_G_EXT_CTRLS ||
1883 cmd == VIDIOC_TRY_EXT_CTRLS);
1885 /* Copy arguments into temp kernel buffer */
1886 switch (_IOC_DIR(cmd)) {
1892 case (_IOC_WRITE | _IOC_READ):
1893 if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
1896 /* too big to allocate from stack */
1897 mbuf = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
1904 if (_IOC_DIR(cmd) & _IOC_WRITE)
1905 if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
1911 struct v4l2_ext_controls *p = parg;
1913 /* In case of an error, tell the caller that it wasn't
1914 a specific control that caused it. */
1915 p->error_idx = p->count;
1916 user_ptr = (void __user *)p->controls;
1918 ctrls_size = sizeof(struct v4l2_ext_control) * p->count;
1919 /* Note: v4l2_ext_controls fits in sbuf[] so mbuf is still NULL. */
1920 mbuf = kmalloc(ctrls_size, GFP_KERNEL);
1925 if (copy_from_user(mbuf, user_ptr, ctrls_size))
1932 err = __video_do_ioctl(file, cmd, parg);
1933 if (err == -ENOIOCTLCMD)
1936 struct v4l2_ext_controls *p = parg;
1938 p->controls = (void *)user_ptr;
1939 if (p->count && err == 0 && copy_to_user(user_ptr, mbuf, ctrls_size))
1947 /* Copy results into user buffer */
1948 switch (_IOC_DIR(cmd)) {
1950 case (_IOC_WRITE | _IOC_READ):
1951 if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
1960 EXPORT_SYMBOL(video_ioctl2);