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 if (!ops->vidiocgmbuf)
660 ret = ops->vidiocgmbuf(file, fh, p);
662 dbgarg(cmd, "size=%d, frames=%d, offsets=0x%08lx\n",
664 (unsigned long)p->offsets);
668 /********************************************************
669 All other V4L1 calls are handled by v4l1_compat module.
670 Those calls will be translated into V4L2 calls, and
671 __video_do_ioctl will be called again, with one or more
673 ********************************************************/
674 if (_IOC_TYPE(cmd) == 'v' && _IOC_NR(cmd) < BASE_VIDIOCPRIVATE)
675 return v4l_compat_translate_ioctl(file, cmd, arg,
680 /* --- capabilities ------------------------------------------ */
681 case VIDIOC_QUERYCAP:
683 struct v4l2_capability *cap = (struct v4l2_capability *)arg;
685 if (!ops->vidioc_querycap)
688 ret = ops->vidioc_querycap(file, fh, cap);
690 dbgarg(cmd, "driver=%s, card=%s, bus=%s, "
692 "capabilities=0x%08x\n",
693 cap->driver, cap->card, cap->bus_info,
699 /* --- priority ------------------------------------------ */
700 case VIDIOC_G_PRIORITY:
702 enum v4l2_priority *p = arg;
704 if (!ops->vidioc_g_priority)
706 ret = ops->vidioc_g_priority(file, fh, p);
708 dbgarg(cmd, "priority is %d\n", *p);
711 case VIDIOC_S_PRIORITY:
713 enum v4l2_priority *p = arg;
715 if (!ops->vidioc_s_priority)
717 dbgarg(cmd, "setting priority to %d\n", *p);
718 ret = ops->vidioc_s_priority(file, fh, *p);
722 /* --- capture ioctls ---------------------------------------- */
723 case VIDIOC_ENUM_FMT:
725 struct v4l2_fmtdesc *f = arg;
728 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
729 if (ops->vidioc_enum_fmt_vid_cap)
730 ret = ops->vidioc_enum_fmt_vid_cap(file, fh, f);
732 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
733 if (ops->vidioc_enum_fmt_vid_overlay)
734 ret = ops->vidioc_enum_fmt_vid_overlay(file,
737 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
738 if (ops->vidioc_enum_fmt_vid_out)
739 ret = ops->vidioc_enum_fmt_vid_out(file, fh, f);
741 case V4L2_BUF_TYPE_PRIVATE:
742 if (ops->vidioc_enum_fmt_type_private)
743 ret = ops->vidioc_enum_fmt_type_private(file,
750 dbgarg(cmd, "index=%d, type=%d, flags=%d, "
751 "pixelformat=%c%c%c%c, description='%s'\n",
752 f->index, f->type, f->flags,
753 (f->pixelformat & 0xff),
754 (f->pixelformat >> 8) & 0xff,
755 (f->pixelformat >> 16) & 0xff,
756 (f->pixelformat >> 24) & 0xff,
762 struct v4l2_format *f = (struct v4l2_format *)arg;
764 /* FIXME: Should be one dump per type */
765 dbgarg(cmd, "type=%s\n", prt_names(f->type, v4l2_type_names));
768 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
769 if (ops->vidioc_g_fmt_vid_cap)
770 ret = ops->vidioc_g_fmt_vid_cap(file, fh, f);
772 v4l_print_pix_fmt(vfd, &f->fmt.pix);
774 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
775 if (ops->vidioc_g_fmt_vid_overlay)
776 ret = ops->vidioc_g_fmt_vid_overlay(file,
779 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
780 if (ops->vidioc_g_fmt_vid_out)
781 ret = ops->vidioc_g_fmt_vid_out(file, fh, f);
783 v4l_print_pix_fmt(vfd, &f->fmt.pix);
785 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
786 if (ops->vidioc_g_fmt_vid_out_overlay)
787 ret = ops->vidioc_g_fmt_vid_out_overlay(file,
790 case V4L2_BUF_TYPE_VBI_CAPTURE:
791 if (ops->vidioc_g_fmt_vbi_cap)
792 ret = ops->vidioc_g_fmt_vbi_cap(file, fh, f);
794 case V4L2_BUF_TYPE_VBI_OUTPUT:
795 if (ops->vidioc_g_fmt_vbi_out)
796 ret = ops->vidioc_g_fmt_vbi_out(file, fh, f);
798 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
799 if (ops->vidioc_g_fmt_sliced_vbi_cap)
800 ret = ops->vidioc_g_fmt_sliced_vbi_cap(file,
803 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
804 if (ops->vidioc_g_fmt_sliced_vbi_out)
805 ret = ops->vidioc_g_fmt_sliced_vbi_out(file,
808 case V4L2_BUF_TYPE_PRIVATE:
809 if (ops->vidioc_g_fmt_type_private)
810 ret = ops->vidioc_g_fmt_type_private(file,
819 struct v4l2_format *f = (struct v4l2_format *)arg;
821 /* FIXME: Should be one dump per type */
822 dbgarg(cmd, "type=%s\n", prt_names(f->type, v4l2_type_names));
825 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
826 v4l_print_pix_fmt(vfd, &f->fmt.pix);
827 if (ops->vidioc_s_fmt_vid_cap)
828 ret = ops->vidioc_s_fmt_vid_cap(file, fh, f);
830 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
831 if (ops->vidioc_s_fmt_vid_overlay)
832 ret = ops->vidioc_s_fmt_vid_overlay(file,
835 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
836 v4l_print_pix_fmt(vfd, &f->fmt.pix);
837 if (ops->vidioc_s_fmt_vid_out)
838 ret = ops->vidioc_s_fmt_vid_out(file, fh, f);
840 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
841 if (ops->vidioc_s_fmt_vid_out_overlay)
842 ret = ops->vidioc_s_fmt_vid_out_overlay(file,
845 case V4L2_BUF_TYPE_VBI_CAPTURE:
846 if (ops->vidioc_s_fmt_vbi_cap)
847 ret = ops->vidioc_s_fmt_vbi_cap(file, fh, f);
849 case V4L2_BUF_TYPE_VBI_OUTPUT:
850 if (ops->vidioc_s_fmt_vbi_out)
851 ret = ops->vidioc_s_fmt_vbi_out(file, fh, f);
853 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
854 if (ops->vidioc_s_fmt_sliced_vbi_cap)
855 ret = ops->vidioc_s_fmt_sliced_vbi_cap(file,
858 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
859 if (ops->vidioc_s_fmt_sliced_vbi_out)
860 ret = ops->vidioc_s_fmt_sliced_vbi_out(file,
863 case V4L2_BUF_TYPE_PRIVATE:
864 if (ops->vidioc_s_fmt_type_private)
865 ret = ops->vidioc_s_fmt_type_private(file,
873 struct v4l2_format *f = (struct v4l2_format *)arg;
875 /* FIXME: Should be one dump per type */
876 dbgarg(cmd, "type=%s\n", prt_names(f->type,
879 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
880 if (ops->vidioc_try_fmt_vid_cap)
881 ret = ops->vidioc_try_fmt_vid_cap(file, fh, f);
883 v4l_print_pix_fmt(vfd, &f->fmt.pix);
885 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
886 if (ops->vidioc_try_fmt_vid_overlay)
887 ret = ops->vidioc_try_fmt_vid_overlay(file,
890 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
891 if (ops->vidioc_try_fmt_vid_out)
892 ret = ops->vidioc_try_fmt_vid_out(file, fh, f);
894 v4l_print_pix_fmt(vfd, &f->fmt.pix);
896 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
897 if (ops->vidioc_try_fmt_vid_out_overlay)
898 ret = ops->vidioc_try_fmt_vid_out_overlay(file,
901 case V4L2_BUF_TYPE_VBI_CAPTURE:
902 if (ops->vidioc_try_fmt_vbi_cap)
903 ret = ops->vidioc_try_fmt_vbi_cap(file, fh, f);
905 case V4L2_BUF_TYPE_VBI_OUTPUT:
906 if (ops->vidioc_try_fmt_vbi_out)
907 ret = ops->vidioc_try_fmt_vbi_out(file, fh, f);
909 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
910 if (ops->vidioc_try_fmt_sliced_vbi_cap)
911 ret = ops->vidioc_try_fmt_sliced_vbi_cap(file,
914 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
915 if (ops->vidioc_try_fmt_sliced_vbi_out)
916 ret = ops->vidioc_try_fmt_sliced_vbi_out(file,
919 case V4L2_BUF_TYPE_PRIVATE:
920 if (ops->vidioc_try_fmt_type_private)
921 ret = ops->vidioc_try_fmt_type_private(file,
928 /* FIXME: Those buf reqs could be handled here,
929 with some changes on videobuf to allow its header to be included at
930 videodev2.h or being merged at videodev2.
934 struct v4l2_requestbuffers *p = arg;
936 if (!ops->vidioc_reqbufs)
938 ret = check_fmt(ops, p->type);
942 ret = ops->vidioc_reqbufs(file, fh, p);
943 dbgarg(cmd, "count=%d, type=%s, memory=%s\n",
945 prt_names(p->type, v4l2_type_names),
946 prt_names(p->memory, v4l2_memory_names));
949 case VIDIOC_QUERYBUF:
951 struct v4l2_buffer *p = arg;
953 if (!ops->vidioc_querybuf)
955 ret = check_fmt(ops, p->type);
959 ret = ops->vidioc_querybuf(file, fh, p);
966 struct v4l2_buffer *p = arg;
968 if (!ops->vidioc_qbuf)
970 ret = check_fmt(ops, p->type);
974 ret = ops->vidioc_qbuf(file, fh, p);
981 struct v4l2_buffer *p = arg;
983 if (!ops->vidioc_dqbuf)
985 ret = check_fmt(ops, p->type);
989 ret = ops->vidioc_dqbuf(file, fh, p);
998 if (!ops->vidioc_overlay)
1000 dbgarg(cmd, "value=%d\n", *i);
1001 ret = ops->vidioc_overlay(file, fh, *i);
1006 struct v4l2_framebuffer *p = arg;
1008 if (!ops->vidioc_g_fbuf)
1010 ret = ops->vidioc_g_fbuf(file, fh, arg);
1012 dbgarg(cmd, "capability=0x%x, flags=%d, base=0x%08lx\n",
1013 p->capability, p->flags,
1014 (unsigned long)p->base);
1015 v4l_print_pix_fmt(vfd, &p->fmt);
1021 struct v4l2_framebuffer *p = arg;
1023 if (!ops->vidioc_s_fbuf)
1025 dbgarg(cmd, "capability=0x%x, flags=%d, base=0x%08lx\n",
1026 p->capability, p->flags, (unsigned long)p->base);
1027 v4l_print_pix_fmt(vfd, &p->fmt);
1028 ret = ops->vidioc_s_fbuf(file, fh, arg);
1031 case VIDIOC_STREAMON:
1033 enum v4l2_buf_type i = *(int *)arg;
1035 if (!ops->vidioc_streamon)
1037 dbgarg(cmd, "type=%s\n", prt_names(i, v4l2_type_names));
1038 ret = ops->vidioc_streamon(file, fh, i);
1041 case VIDIOC_STREAMOFF:
1043 enum v4l2_buf_type i = *(int *)arg;
1045 if (!ops->vidioc_streamoff)
1047 dbgarg(cmd, "type=%s\n", prt_names(i, v4l2_type_names));
1048 ret = ops->vidioc_streamoff(file, fh, i);
1051 /* ---------- tv norms ---------- */
1052 case VIDIOC_ENUMSTD:
1054 struct v4l2_standard *p = arg;
1055 v4l2_std_id id = vfd->tvnorms, curr_id = 0;
1056 unsigned int index = p->index, i, j = 0;
1057 const char *descr = "";
1059 /* Return norm array in a canonical way */
1060 for (i = 0; i <= index && id; i++) {
1061 /* last std value in the standards array is 0, so this
1062 while always ends there since (id & 0) == 0. */
1063 while ((id & standards[j].std) != standards[j].std)
1065 curr_id = standards[j].std;
1066 descr = standards[j].descr;
1070 if (curr_id != V4L2_STD_PAL &&
1071 curr_id != V4L2_STD_SECAM &&
1072 curr_id != V4L2_STD_NTSC)
1078 v4l2_video_std_construct(p, curr_id, descr);
1081 dbgarg(cmd, "index=%d, id=0x%Lx, name=%s, fps=%d/%d, "
1082 "framelines=%d\n", p->index,
1083 (unsigned long long)p->id, p->name,
1084 p->frameperiod.numerator,
1085 p->frameperiod.denominator,
1093 v4l2_std_id *id = arg;
1096 /* Calls the specific handler */
1097 if (ops->vidioc_g_std)
1098 ret = ops->vidioc_g_std(file, fh, id);
1100 *id = vfd->current_norm;
1103 dbgarg(cmd, "std=0x%08Lx\n", (long long unsigned)*id);
1108 v4l2_std_id *id = arg, norm;
1110 dbgarg(cmd, "std=%08Lx\n", (long long unsigned)*id);
1112 norm = (*id) & vfd->tvnorms;
1113 if (vfd->tvnorms && !norm) /* Check if std is supported */
1116 /* Calls the specific handler */
1117 if (ops->vidioc_s_std)
1118 ret = ops->vidioc_s_std(file, fh, &norm);
1122 /* Updates standard information */
1124 vfd->current_norm = norm;
1127 case VIDIOC_QUERYSTD:
1129 v4l2_std_id *p = arg;
1131 if (!ops->vidioc_querystd)
1133 ret = ops->vidioc_querystd(file, fh, arg);
1135 dbgarg(cmd, "detected std=%08Lx\n",
1136 (unsigned long long)*p);
1139 /* ------ input switching ---------- */
1140 /* FIXME: Inputs can be handled inside videodev2 */
1141 case VIDIOC_ENUMINPUT:
1143 struct v4l2_input *p = arg;
1145 if (!ops->vidioc_enum_input)
1148 ret = ops->vidioc_enum_input(file, fh, p);
1150 dbgarg(cmd, "index=%d, name=%s, type=%d, "
1152 "tuner=%d, std=%08Lx, status=%d\n",
1153 p->index, p->name, p->type, p->audioset,
1155 (unsigned long long)p->std,
1159 case VIDIOC_G_INPUT:
1161 unsigned int *i = arg;
1163 if (!ops->vidioc_g_input)
1165 ret = ops->vidioc_g_input(file, fh, i);
1167 dbgarg(cmd, "value=%d\n", *i);
1170 case VIDIOC_S_INPUT:
1172 unsigned int *i = arg;
1174 if (!ops->vidioc_s_input)
1176 dbgarg(cmd, "value=%d\n", *i);
1177 ret = ops->vidioc_s_input(file, fh, *i);
1181 /* ------ output switching ---------- */
1182 case VIDIOC_ENUMOUTPUT:
1184 struct v4l2_output *p = arg;
1186 if (!ops->vidioc_enum_output)
1189 ret = ops->vidioc_enum_output(file, fh, p);
1191 dbgarg(cmd, "index=%d, name=%s, type=%d, "
1193 "modulator=%d, std=0x%08Lx\n",
1194 p->index, p->name, p->type, p->audioset,
1195 p->modulator, (unsigned long long)p->std);
1198 case VIDIOC_G_OUTPUT:
1200 unsigned int *i = arg;
1202 if (!ops->vidioc_g_output)
1204 ret = ops->vidioc_g_output(file, fh, i);
1206 dbgarg(cmd, "value=%d\n", *i);
1209 case VIDIOC_S_OUTPUT:
1211 unsigned int *i = arg;
1213 if (!ops->vidioc_s_output)
1215 dbgarg(cmd, "value=%d\n", *i);
1216 ret = ops->vidioc_s_output(file, fh, *i);
1220 /* --- controls ---------------------------------------------- */
1221 case VIDIOC_QUERYCTRL:
1223 struct v4l2_queryctrl *p = arg;
1225 if (!ops->vidioc_queryctrl)
1227 ret = ops->vidioc_queryctrl(file, fh, p);
1229 dbgarg(cmd, "id=0x%x, type=%d, name=%s, min/max=%d/%d, "
1230 "step=%d, default=%d, flags=0x%08x\n",
1231 p->id, p->type, p->name,
1232 p->minimum, p->maximum,
1233 p->step, p->default_value, p->flags);
1235 dbgarg(cmd, "id=0x%x\n", p->id);
1240 struct v4l2_control *p = arg;
1242 if (ops->vidioc_g_ctrl)
1243 ret = ops->vidioc_g_ctrl(file, fh, p);
1244 else if (ops->vidioc_g_ext_ctrls) {
1245 struct v4l2_ext_controls ctrls;
1246 struct v4l2_ext_control ctrl;
1248 ctrls.ctrl_class = V4L2_CTRL_ID2CLASS(p->id);
1250 ctrls.controls = &ctrl;
1252 ctrl.value = p->value;
1253 if (check_ext_ctrls(&ctrls, 1)) {
1254 ret = ops->vidioc_g_ext_ctrls(file, fh, &ctrls);
1256 p->value = ctrl.value;
1261 dbgarg(cmd, "id=0x%x, value=%d\n", p->id, p->value);
1263 dbgarg(cmd, "id=0x%x\n", p->id);
1268 struct v4l2_control *p = arg;
1269 struct v4l2_ext_controls ctrls;
1270 struct v4l2_ext_control ctrl;
1272 if (!ops->vidioc_s_ctrl && !ops->vidioc_s_ext_ctrls)
1275 dbgarg(cmd, "id=0x%x, value=%d\n", p->id, p->value);
1277 if (ops->vidioc_s_ctrl) {
1278 ret = ops->vidioc_s_ctrl(file, fh, p);
1281 if (!ops->vidioc_s_ext_ctrls)
1284 ctrls.ctrl_class = V4L2_CTRL_ID2CLASS(p->id);
1286 ctrls.controls = &ctrl;
1288 ctrl.value = p->value;
1289 if (check_ext_ctrls(&ctrls, 1))
1290 ret = ops->vidioc_s_ext_ctrls(file, fh, &ctrls);
1293 case VIDIOC_G_EXT_CTRLS:
1295 struct v4l2_ext_controls *p = arg;
1297 p->error_idx = p->count;
1298 if (!ops->vidioc_g_ext_ctrls)
1300 if (check_ext_ctrls(p, 0))
1301 ret = ops->vidioc_g_ext_ctrls(file, fh, p);
1302 v4l_print_ext_ctrls(cmd, vfd, p, !ret);
1305 case VIDIOC_S_EXT_CTRLS:
1307 struct v4l2_ext_controls *p = arg;
1309 p->error_idx = p->count;
1310 if (!ops->vidioc_s_ext_ctrls)
1312 v4l_print_ext_ctrls(cmd, vfd, p, 1);
1313 if (check_ext_ctrls(p, 0))
1314 ret = ops->vidioc_s_ext_ctrls(file, fh, p);
1317 case VIDIOC_TRY_EXT_CTRLS:
1319 struct v4l2_ext_controls *p = arg;
1321 p->error_idx = p->count;
1322 if (!ops->vidioc_try_ext_ctrls)
1324 v4l_print_ext_ctrls(cmd, vfd, p, 1);
1325 if (check_ext_ctrls(p, 0))
1326 ret = ops->vidioc_try_ext_ctrls(file, fh, p);
1329 case VIDIOC_QUERYMENU:
1331 struct v4l2_querymenu *p = arg;
1333 if (!ops->vidioc_querymenu)
1335 ret = ops->vidioc_querymenu(file, fh, p);
1337 dbgarg(cmd, "id=0x%x, index=%d, name=%s\n",
1338 p->id, p->index, p->name);
1340 dbgarg(cmd, "id=0x%x, index=%d\n",
1344 /* --- audio ---------------------------------------------- */
1345 case VIDIOC_ENUMAUDIO:
1347 struct v4l2_audio *p = arg;
1349 if (!ops->vidioc_enumaudio)
1351 ret = ops->vidioc_enumaudio(file, fh, p);
1353 dbgarg(cmd, "index=%d, name=%s, capability=0x%x, "
1354 "mode=0x%x\n", p->index, p->name,
1355 p->capability, p->mode);
1357 dbgarg(cmd, "index=%d\n", p->index);
1360 case VIDIOC_G_AUDIO:
1362 struct v4l2_audio *p = arg;
1364 if (!ops->vidioc_g_audio)
1367 ret = ops->vidioc_g_audio(file, fh, p);
1369 dbgarg(cmd, "index=%d, name=%s, capability=0x%x, "
1370 "mode=0x%x\n", p->index,
1371 p->name, p->capability, p->mode);
1373 dbgarg(cmd, "index=%d\n", p->index);
1376 case VIDIOC_S_AUDIO:
1378 struct v4l2_audio *p = arg;
1380 if (!ops->vidioc_s_audio)
1382 dbgarg(cmd, "index=%d, name=%s, capability=0x%x, "
1383 "mode=0x%x\n", p->index, p->name,
1384 p->capability, p->mode);
1385 ret = ops->vidioc_s_audio(file, fh, p);
1388 case VIDIOC_ENUMAUDOUT:
1390 struct v4l2_audioout *p = arg;
1392 if (!ops->vidioc_enumaudout)
1394 dbgarg(cmd, "Enum for index=%d\n", p->index);
1395 ret = ops->vidioc_enumaudout(file, fh, p);
1397 dbgarg2("index=%d, name=%s, capability=%d, "
1398 "mode=%d\n", p->index, p->name,
1399 p->capability, p->mode);
1402 case VIDIOC_G_AUDOUT:
1404 struct v4l2_audioout *p = arg;
1406 if (!ops->vidioc_g_audout)
1409 ret = ops->vidioc_g_audout(file, fh, p);
1411 dbgarg2("index=%d, name=%s, capability=%d, "
1412 "mode=%d\n", p->index, p->name,
1413 p->capability, p->mode);
1416 case VIDIOC_S_AUDOUT:
1418 struct v4l2_audioout *p = arg;
1420 if (!ops->vidioc_s_audout)
1422 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1423 "mode=%d\n", p->index, p->name,
1424 p->capability, p->mode);
1426 ret = ops->vidioc_s_audout(file, fh, p);
1429 case VIDIOC_G_MODULATOR:
1431 struct v4l2_modulator *p = arg;
1433 if (!ops->vidioc_g_modulator)
1435 ret = ops->vidioc_g_modulator(file, fh, p);
1437 dbgarg(cmd, "index=%d, name=%s, "
1438 "capability=%d, rangelow=%d,"
1439 " rangehigh=%d, txsubchans=%d\n",
1440 p->index, p->name, p->capability,
1441 p->rangelow, p->rangehigh,
1445 case VIDIOC_S_MODULATOR:
1447 struct v4l2_modulator *p = arg;
1449 if (!ops->vidioc_s_modulator)
1451 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1452 "rangelow=%d, rangehigh=%d, txsubchans=%d\n",
1453 p->index, p->name, p->capability, p->rangelow,
1454 p->rangehigh, p->txsubchans);
1455 ret = ops->vidioc_s_modulator(file, fh, p);
1460 struct v4l2_crop *p = arg;
1462 if (!ops->vidioc_g_crop)
1465 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
1466 ret = ops->vidioc_g_crop(file, fh, p);
1468 dbgrect(vfd, "", &p->c);
1473 struct v4l2_crop *p = arg;
1475 if (!ops->vidioc_s_crop)
1477 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
1478 dbgrect(vfd, "", &p->c);
1479 ret = ops->vidioc_s_crop(file, fh, p);
1482 case VIDIOC_CROPCAP:
1484 struct v4l2_cropcap *p = arg;
1486 /*FIXME: Should also show v4l2_fract pixelaspect */
1487 if (!ops->vidioc_cropcap)
1490 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
1491 ret = ops->vidioc_cropcap(file, fh, p);
1493 dbgrect(vfd, "bounds ", &p->bounds);
1494 dbgrect(vfd, "defrect ", &p->defrect);
1498 case VIDIOC_G_JPEGCOMP:
1500 struct v4l2_jpegcompression *p = arg;
1502 if (!ops->vidioc_g_jpegcomp)
1505 ret = ops->vidioc_g_jpegcomp(file, fh, p);
1507 dbgarg(cmd, "quality=%d, APPn=%d, "
1508 "APP_len=%d, COM_len=%d, "
1509 "jpeg_markers=%d\n",
1510 p->quality, p->APPn, p->APP_len,
1511 p->COM_len, p->jpeg_markers);
1514 case VIDIOC_S_JPEGCOMP:
1516 struct v4l2_jpegcompression *p = arg;
1518 if (!ops->vidioc_g_jpegcomp)
1520 dbgarg(cmd, "quality=%d, APPn=%d, APP_len=%d, "
1521 "COM_len=%d, jpeg_markers=%d\n",
1522 p->quality, p->APPn, p->APP_len,
1523 p->COM_len, p->jpeg_markers);
1524 ret = ops->vidioc_s_jpegcomp(file, fh, p);
1527 case VIDIOC_G_ENC_INDEX:
1529 struct v4l2_enc_idx *p = arg;
1531 if (!ops->vidioc_g_enc_index)
1533 ret = ops->vidioc_g_enc_index(file, fh, p);
1535 dbgarg(cmd, "entries=%d, entries_cap=%d\n",
1536 p->entries, p->entries_cap);
1539 case VIDIOC_ENCODER_CMD:
1541 struct v4l2_encoder_cmd *p = arg;
1543 if (!ops->vidioc_encoder_cmd)
1545 ret = ops->vidioc_encoder_cmd(file, fh, p);
1547 dbgarg(cmd, "cmd=%d, flags=%x\n", p->cmd, p->flags);
1550 case VIDIOC_TRY_ENCODER_CMD:
1552 struct v4l2_encoder_cmd *p = arg;
1554 if (!ops->vidioc_try_encoder_cmd)
1556 ret = ops->vidioc_try_encoder_cmd(file, fh, p);
1558 dbgarg(cmd, "cmd=%d, flags=%x\n", p->cmd, p->flags);
1563 struct v4l2_streamparm *p = arg;
1565 if (ops->vidioc_g_parm) {
1566 ret = ops->vidioc_g_parm(file, fh, p);
1568 struct v4l2_standard s;
1570 if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1573 v4l2_video_std_construct(&s, vfd->current_norm,
1574 v4l2_norm_to_name(vfd->current_norm));
1576 p->parm.capture.timeperframe = s.frameperiod;
1580 dbgarg(cmd, "type=%d\n", p->type);
1585 struct v4l2_streamparm *p = arg;
1587 if (!ops->vidioc_s_parm)
1589 dbgarg(cmd, "type=%d\n", p->type);
1590 ret = ops->vidioc_s_parm(file, fh, p);
1593 case VIDIOC_G_TUNER:
1595 struct v4l2_tuner *p = arg;
1597 if (!ops->vidioc_g_tuner)
1600 ret = ops->vidioc_g_tuner(file, fh, p);
1602 dbgarg(cmd, "index=%d, name=%s, type=%d, "
1603 "capability=0x%x, rangelow=%d, "
1604 "rangehigh=%d, signal=%d, afc=%d, "
1605 "rxsubchans=0x%x, audmode=%d\n",
1606 p->index, p->name, p->type,
1607 p->capability, p->rangelow,
1608 p->rangehigh, p->signal, p->afc,
1609 p->rxsubchans, p->audmode);
1612 case VIDIOC_S_TUNER:
1614 struct v4l2_tuner *p = arg;
1616 if (!ops->vidioc_s_tuner)
1618 dbgarg(cmd, "index=%d, name=%s, type=%d, "
1619 "capability=0x%x, rangelow=%d, "
1620 "rangehigh=%d, signal=%d, afc=%d, "
1621 "rxsubchans=0x%x, audmode=%d\n",
1622 p->index, p->name, p->type,
1623 p->capability, p->rangelow,
1624 p->rangehigh, p->signal, p->afc,
1625 p->rxsubchans, p->audmode);
1626 ret = ops->vidioc_s_tuner(file, fh, p);
1629 case VIDIOC_G_FREQUENCY:
1631 struct v4l2_frequency *p = arg;
1633 if (!ops->vidioc_g_frequency)
1636 ret = ops->vidioc_g_frequency(file, fh, p);
1638 dbgarg(cmd, "tuner=%d, type=%d, frequency=%d\n",
1639 p->tuner, p->type, p->frequency);
1642 case VIDIOC_S_FREQUENCY:
1644 struct v4l2_frequency *p = arg;
1646 if (!ops->vidioc_s_frequency)
1648 dbgarg(cmd, "tuner=%d, type=%d, frequency=%d\n",
1649 p->tuner, p->type, p->frequency);
1650 ret = ops->vidioc_s_frequency(file, fh, p);
1653 case VIDIOC_G_SLICED_VBI_CAP:
1655 struct v4l2_sliced_vbi_cap *p = arg;
1657 if (!ops->vidioc_g_sliced_vbi_cap)
1660 /* Clear up to type, everything after type is zerod already */
1661 memset(p, 0, offsetof(struct v4l2_sliced_vbi_cap, type));
1663 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
1664 ret = ops->vidioc_g_sliced_vbi_cap(file, fh, p);
1666 dbgarg2("service_set=%d\n", p->service_set);
1669 case VIDIOC_LOG_STATUS:
1671 if (!ops->vidioc_log_status)
1673 ret = ops->vidioc_log_status(file, fh);
1676 #ifdef CONFIG_VIDEO_ADV_DEBUG
1677 case VIDIOC_DBG_G_REGISTER:
1679 struct v4l2_dbg_register *p = arg;
1681 if (!capable(CAP_SYS_ADMIN))
1683 else if (ops->vidioc_g_register)
1684 ret = ops->vidioc_g_register(file, fh, p);
1687 case VIDIOC_DBG_S_REGISTER:
1689 struct v4l2_dbg_register *p = arg;
1691 if (!capable(CAP_SYS_ADMIN))
1693 else if (ops->vidioc_s_register)
1694 ret = ops->vidioc_s_register(file, fh, p);
1698 case VIDIOC_DBG_G_CHIP_IDENT:
1700 struct v4l2_dbg_chip_ident *p = arg;
1702 if (!ops->vidioc_g_chip_ident)
1704 p->ident = V4L2_IDENT_NONE;
1706 ret = ops->vidioc_g_chip_ident(file, fh, p);
1708 dbgarg(cmd, "chip_ident=%u, revision=0x%x\n", p->ident, p->revision);
1711 case VIDIOC_G_CHIP_IDENT_OLD:
1712 printk(KERN_ERR "VIDIOC_G_CHIP_IDENT has been deprecated and will disappear in 2.6.30.\n");
1713 printk(KERN_ERR "It is a debugging ioctl and must not be used in applications!\n");
1716 case VIDIOC_S_HW_FREQ_SEEK:
1718 struct v4l2_hw_freq_seek *p = arg;
1720 if (!ops->vidioc_s_hw_freq_seek)
1723 "tuner=%d, type=%d, seek_upward=%d, wrap_around=%d\n",
1724 p->tuner, p->type, p->seek_upward, p->wrap_around);
1725 ret = ops->vidioc_s_hw_freq_seek(file, fh, p);
1728 case VIDIOC_ENUM_FRAMESIZES:
1730 struct v4l2_frmsizeenum *p = arg;
1732 if (!ops->vidioc_enum_framesizes)
1735 ret = ops->vidioc_enum_framesizes(file, fh, p);
1737 "index=%d, pixelformat=%d, type=%d ",
1738 p->index, p->pixel_format, p->type);
1740 case V4L2_FRMSIZE_TYPE_DISCRETE:
1741 dbgarg2("width = %d, height=%d\n",
1742 p->discrete.width, p->discrete.height);
1744 case V4L2_FRMSIZE_TYPE_STEPWISE:
1745 dbgarg2("min %dx%d, max %dx%d, step %dx%d\n",
1746 p->stepwise.min_width, p->stepwise.min_height,
1747 p->stepwise.step_width, p->stepwise.step_height,
1748 p->stepwise.max_width, p->stepwise.max_height);
1750 case V4L2_FRMSIZE_TYPE_CONTINUOUS:
1751 dbgarg2("continuous\n");
1754 dbgarg2("- Unknown type!\n");
1759 case VIDIOC_ENUM_FRAMEINTERVALS:
1761 struct v4l2_frmivalenum *p = arg;
1763 if (!ops->vidioc_enum_frameintervals)
1766 ret = ops->vidioc_enum_frameintervals(file, fh, p);
1768 "index=%d, pixelformat=%d, width=%d, height=%d, type=%d ",
1769 p->index, p->pixel_format,
1770 p->width, p->height, p->type);
1772 case V4L2_FRMIVAL_TYPE_DISCRETE:
1773 dbgarg2("fps=%d/%d\n",
1774 p->discrete.numerator,
1775 p->discrete.denominator);
1777 case V4L2_FRMIVAL_TYPE_STEPWISE:
1778 dbgarg2("min=%d/%d, max=%d/%d, step=%d/%d\n",
1779 p->stepwise.min.numerator,
1780 p->stepwise.min.denominator,
1781 p->stepwise.max.numerator,
1782 p->stepwise.max.denominator,
1783 p->stepwise.step.numerator,
1784 p->stepwise.step.denominator);
1786 case V4L2_FRMIVAL_TYPE_CONTINUOUS:
1787 dbgarg2("continuous\n");
1790 dbgarg2("- Unknown type!\n");
1797 if (!ops->vidioc_default)
1799 ret = ops->vidioc_default(file, fh, cmd, arg);
1804 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) {
1806 v4l_print_ioctl(vfd->name, cmd);
1807 printk(KERN_CONT " error %ld\n", ret);
1814 /* In some cases, only a few fields are used as input, i.e. when the app sets
1815 * "index" and then the driver fills in the rest of the structure for the thing
1816 * with that index. We only need to copy up the first non-input field. */
1817 static unsigned long cmd_input_size(unsigned int cmd)
1819 /* Size of structure up to and including 'field' */
1820 #define CMDINSIZE(cmd, type, field) case _IOC_NR(VIDIOC_##cmd): return \
1821 offsetof(struct v4l2_##type, field) + \
1822 sizeof(((struct v4l2_##type *)0)->field);
1824 switch (_IOC_NR(cmd)) {
1825 CMDINSIZE(ENUM_FMT, fmtdesc, type);
1826 CMDINSIZE(G_FMT, format, type);
1827 CMDINSIZE(QUERYBUF, buffer, type);
1828 CMDINSIZE(G_PARM, streamparm, type);
1829 CMDINSIZE(ENUMSTD, standard, index);
1830 CMDINSIZE(ENUMINPUT, input, index);
1831 CMDINSIZE(G_CTRL, control, id);
1832 CMDINSIZE(G_TUNER, tuner, index);
1833 CMDINSIZE(QUERYCTRL, queryctrl, id);
1834 CMDINSIZE(QUERYMENU, querymenu, index);
1835 CMDINSIZE(ENUMOUTPUT, output, index);
1836 CMDINSIZE(G_MODULATOR, modulator, index);
1837 CMDINSIZE(G_FREQUENCY, frequency, tuner);
1838 CMDINSIZE(CROPCAP, cropcap, type);
1839 CMDINSIZE(G_CROP, crop, type);
1840 CMDINSIZE(ENUMAUDIO, audio, index);
1841 CMDINSIZE(ENUMAUDOUT, audioout, index);
1842 CMDINSIZE(ENCODER_CMD, encoder_cmd, flags);
1843 CMDINSIZE(TRY_ENCODER_CMD, encoder_cmd, flags);
1844 CMDINSIZE(G_SLICED_VBI_CAP, sliced_vbi_cap, type);
1845 CMDINSIZE(ENUM_FRAMESIZES, frmsizeenum, pixel_format);
1846 CMDINSIZE(ENUM_FRAMEINTERVALS, frmivalenum, height);
1848 return _IOC_SIZE(cmd);
1852 long video_ioctl2(struct file *file,
1853 unsigned int cmd, unsigned long arg)
1860 size_t ctrls_size = 0;
1861 void __user *user_ptr = NULL;
1863 #ifdef __OLD_VIDIOC_
1864 cmd = video_fix_command(cmd);
1866 is_ext_ctrl = (cmd == VIDIOC_S_EXT_CTRLS || cmd == VIDIOC_G_EXT_CTRLS ||
1867 cmd == VIDIOC_TRY_EXT_CTRLS);
1869 /* Copy arguments into temp kernel buffer */
1870 if (_IOC_DIR(cmd) != _IOC_NONE) {
1871 if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
1874 /* too big to allocate from stack */
1875 mbuf = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
1882 if (_IOC_DIR(cmd) & _IOC_WRITE) {
1883 unsigned long n = cmd_input_size(cmd);
1885 if (copy_from_user(parg, (void __user *)arg, n))
1888 /* zero out anything we don't copy from userspace */
1889 if (n < _IOC_SIZE(cmd))
1890 memset((u8 *)parg + n, 0, _IOC_SIZE(cmd) - n);
1892 /* read-only ioctl */
1893 memset(parg, 0, _IOC_SIZE(cmd));
1898 struct v4l2_ext_controls *p = parg;
1900 /* In case of an error, tell the caller that it wasn't
1901 a specific control that caused it. */
1902 p->error_idx = p->count;
1903 user_ptr = (void __user *)p->controls;
1905 ctrls_size = sizeof(struct v4l2_ext_control) * p->count;
1906 /* Note: v4l2_ext_controls fits in sbuf[] so mbuf is still NULL. */
1907 mbuf = kmalloc(ctrls_size, GFP_KERNEL);
1912 if (copy_from_user(mbuf, user_ptr, ctrls_size))
1919 err = __video_do_ioctl(file, cmd, parg);
1920 if (err == -ENOIOCTLCMD)
1923 struct v4l2_ext_controls *p = parg;
1925 p->controls = (void *)user_ptr;
1926 if (p->count && err == 0 && copy_to_user(user_ptr, mbuf, ctrls_size))
1934 /* Copy results into user buffer */
1935 switch (_IOC_DIR(cmd)) {
1937 case (_IOC_WRITE | _IOC_READ):
1938 if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
1947 EXPORT_SYMBOL(video_ioctl2);