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/slab.h>
17 #include <linux/types.h>
18 #include <linux/kernel.h>
20 #define __OLD_VIDIOC_ /* To allow fixing old calls */
21 #include <linux/videodev.h>
22 #include <linux/videodev2.h>
24 #ifdef CONFIG_VIDEO_V4L1
25 #include <linux/videodev.h>
27 #include <media/v4l2-common.h>
28 #include <media/v4l2-ioctl.h>
29 #include <media/v4l2-chip-ident.h>
31 #define dbgarg(cmd, fmt, arg...) \
33 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) { \
34 printk(KERN_DEBUG "%s: ", vfd->name); \
35 v4l_printk_ioctl(cmd); \
36 printk(" " fmt, ## arg); \
40 #define dbgarg2(fmt, arg...) \
42 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) \
43 printk(KERN_DEBUG "%s: " fmt, vfd->name, ## arg);\
46 #define dbgarg3(fmt, arg...) \
48 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) \
49 printk(KERN_CONT "%s: " fmt, vfd->name, ## arg);\
52 /* Zero out the end of the struct pointed to by p. Everthing after, but
53 * not including, the specified field is cleared. */
54 #define CLEAR_AFTER_FIELD(p, field) \
55 memset((u8 *)(p) + offsetof(typeof(*(p)), field) + sizeof((p)->field), \
56 0, sizeof(*(p)) - offsetof(typeof(*(p)), field) - sizeof((p)->field))
63 static const struct std_descr standards[] = {
64 { V4L2_STD_NTSC, "NTSC" },
65 { V4L2_STD_NTSC_M, "NTSC-M" },
66 { V4L2_STD_NTSC_M_JP, "NTSC-M-JP" },
67 { V4L2_STD_NTSC_M_KR, "NTSC-M-KR" },
68 { V4L2_STD_NTSC_443, "NTSC-443" },
69 { V4L2_STD_PAL, "PAL" },
70 { V4L2_STD_PAL_BG, "PAL-BG" },
71 { V4L2_STD_PAL_B, "PAL-B" },
72 { V4L2_STD_PAL_B1, "PAL-B1" },
73 { V4L2_STD_PAL_G, "PAL-G" },
74 { V4L2_STD_PAL_H, "PAL-H" },
75 { V4L2_STD_PAL_I, "PAL-I" },
76 { V4L2_STD_PAL_DK, "PAL-DK" },
77 { V4L2_STD_PAL_D, "PAL-D" },
78 { V4L2_STD_PAL_D1, "PAL-D1" },
79 { V4L2_STD_PAL_K, "PAL-K" },
80 { V4L2_STD_PAL_M, "PAL-M" },
81 { V4L2_STD_PAL_N, "PAL-N" },
82 { V4L2_STD_PAL_Nc, "PAL-Nc" },
83 { V4L2_STD_PAL_60, "PAL-60" },
84 { V4L2_STD_SECAM, "SECAM" },
85 { V4L2_STD_SECAM_B, "SECAM-B" },
86 { V4L2_STD_SECAM_G, "SECAM-G" },
87 { V4L2_STD_SECAM_H, "SECAM-H" },
88 { V4L2_STD_SECAM_DK, "SECAM-DK" },
89 { V4L2_STD_SECAM_D, "SECAM-D" },
90 { V4L2_STD_SECAM_K, "SECAM-K" },
91 { V4L2_STD_SECAM_K1, "SECAM-K1" },
92 { V4L2_STD_SECAM_L, "SECAM-L" },
93 { V4L2_STD_SECAM_LC, "SECAM-Lc" },
97 /* video4linux standard ID conversion to standard name
99 const char *v4l2_norm_to_name(v4l2_std_id id)
104 /* HACK: ppc32 architecture doesn't have __ucmpdi2 function to handle
105 64 bit comparations. So, on that architecture, with some gcc
106 variants, compilation fails. Currently, the max value is 30bit wide.
110 for (i = 0; standards[i].std; i++)
111 if (myid == standards[i].std)
113 return standards[i].descr;
115 EXPORT_SYMBOL(v4l2_norm_to_name);
117 /* Returns frame period for the given standard */
118 void v4l2_video_std_frame_period(int id, struct v4l2_fract *frameperiod)
120 if (id & V4L2_STD_525_60) {
121 frameperiod->numerator = 1001;
122 frameperiod->denominator = 30000;
124 frameperiod->numerator = 1;
125 frameperiod->denominator = 25;
128 EXPORT_SYMBOL(v4l2_video_std_frame_period);
130 /* Fill in the fields of a v4l2_standard structure according to the
131 'id' and 'transmission' parameters. Returns negative on error. */
132 int v4l2_video_std_construct(struct v4l2_standard *vs,
133 int id, const char *name)
136 v4l2_video_std_frame_period(id, &vs->frameperiod);
137 vs->framelines = (id & V4L2_STD_525_60) ? 525 : 625;
138 strlcpy(vs->name, name, sizeof(vs->name));
141 EXPORT_SYMBOL(v4l2_video_std_construct);
143 /* ----------------------------------------------------------------- */
144 /* some arrays for pretty-printing debug messages of enum types */
146 const char *v4l2_field_names[] = {
147 [V4L2_FIELD_ANY] = "any",
148 [V4L2_FIELD_NONE] = "none",
149 [V4L2_FIELD_TOP] = "top",
150 [V4L2_FIELD_BOTTOM] = "bottom",
151 [V4L2_FIELD_INTERLACED] = "interlaced",
152 [V4L2_FIELD_SEQ_TB] = "seq-tb",
153 [V4L2_FIELD_SEQ_BT] = "seq-bt",
154 [V4L2_FIELD_ALTERNATE] = "alternate",
155 [V4L2_FIELD_INTERLACED_TB] = "interlaced-tb",
156 [V4L2_FIELD_INTERLACED_BT] = "interlaced-bt",
158 EXPORT_SYMBOL(v4l2_field_names);
160 const char *v4l2_type_names[] = {
161 [V4L2_BUF_TYPE_VIDEO_CAPTURE] = "vid-cap",
162 [V4L2_BUF_TYPE_VIDEO_OVERLAY] = "vid-overlay",
163 [V4L2_BUF_TYPE_VIDEO_OUTPUT] = "vid-out",
164 [V4L2_BUF_TYPE_VBI_CAPTURE] = "vbi-cap",
165 [V4L2_BUF_TYPE_VBI_OUTPUT] = "vbi-out",
166 [V4L2_BUF_TYPE_SLICED_VBI_CAPTURE] = "sliced-vbi-cap",
167 [V4L2_BUF_TYPE_SLICED_VBI_OUTPUT] = "sliced-vbi-out",
168 [V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY] = "vid-out-overlay",
170 EXPORT_SYMBOL(v4l2_type_names);
172 static const char *v4l2_memory_names[] = {
173 [V4L2_MEMORY_MMAP] = "mmap",
174 [V4L2_MEMORY_USERPTR] = "userptr",
175 [V4L2_MEMORY_OVERLAY] = "overlay",
178 #define prt_names(a, arr) ((((a) >= 0) && ((a) < ARRAY_SIZE(arr))) ? \
181 /* ------------------------------------------------------------------ */
182 /* debug help functions */
184 #ifdef CONFIG_VIDEO_V4L1_COMPAT
185 static const char *v4l1_ioctls[] = {
186 [_IOC_NR(VIDIOCGCAP)] = "VIDIOCGCAP",
187 [_IOC_NR(VIDIOCGCHAN)] = "VIDIOCGCHAN",
188 [_IOC_NR(VIDIOCSCHAN)] = "VIDIOCSCHAN",
189 [_IOC_NR(VIDIOCGTUNER)] = "VIDIOCGTUNER",
190 [_IOC_NR(VIDIOCSTUNER)] = "VIDIOCSTUNER",
191 [_IOC_NR(VIDIOCGPICT)] = "VIDIOCGPICT",
192 [_IOC_NR(VIDIOCSPICT)] = "VIDIOCSPICT",
193 [_IOC_NR(VIDIOCCAPTURE)] = "VIDIOCCAPTURE",
194 [_IOC_NR(VIDIOCGWIN)] = "VIDIOCGWIN",
195 [_IOC_NR(VIDIOCSWIN)] = "VIDIOCSWIN",
196 [_IOC_NR(VIDIOCGFBUF)] = "VIDIOCGFBUF",
197 [_IOC_NR(VIDIOCSFBUF)] = "VIDIOCSFBUF",
198 [_IOC_NR(VIDIOCKEY)] = "VIDIOCKEY",
199 [_IOC_NR(VIDIOCGFREQ)] = "VIDIOCGFREQ",
200 [_IOC_NR(VIDIOCSFREQ)] = "VIDIOCSFREQ",
201 [_IOC_NR(VIDIOCGAUDIO)] = "VIDIOCGAUDIO",
202 [_IOC_NR(VIDIOCSAUDIO)] = "VIDIOCSAUDIO",
203 [_IOC_NR(VIDIOCSYNC)] = "VIDIOCSYNC",
204 [_IOC_NR(VIDIOCMCAPTURE)] = "VIDIOCMCAPTURE",
205 [_IOC_NR(VIDIOCGMBUF)] = "VIDIOCGMBUF",
206 [_IOC_NR(VIDIOCGUNIT)] = "VIDIOCGUNIT",
207 [_IOC_NR(VIDIOCGCAPTURE)] = "VIDIOCGCAPTURE",
208 [_IOC_NR(VIDIOCSCAPTURE)] = "VIDIOCSCAPTURE",
209 [_IOC_NR(VIDIOCSPLAYMODE)] = "VIDIOCSPLAYMODE",
210 [_IOC_NR(VIDIOCSWRITEMODE)] = "VIDIOCSWRITEMODE",
211 [_IOC_NR(VIDIOCGPLAYINFO)] = "VIDIOCGPLAYINFO",
212 [_IOC_NR(VIDIOCSMICROCODE)] = "VIDIOCSMICROCODE",
213 [_IOC_NR(VIDIOCGVBIFMT)] = "VIDIOCGVBIFMT",
214 [_IOC_NR(VIDIOCSVBIFMT)] = "VIDIOCSVBIFMT"
216 #define V4L1_IOCTLS ARRAY_SIZE(v4l1_ioctls)
219 static const char *v4l2_ioctls[] = {
220 [_IOC_NR(VIDIOC_QUERYCAP)] = "VIDIOC_QUERYCAP",
221 [_IOC_NR(VIDIOC_RESERVED)] = "VIDIOC_RESERVED",
222 [_IOC_NR(VIDIOC_ENUM_FMT)] = "VIDIOC_ENUM_FMT",
223 [_IOC_NR(VIDIOC_G_FMT)] = "VIDIOC_G_FMT",
224 [_IOC_NR(VIDIOC_S_FMT)] = "VIDIOC_S_FMT",
225 [_IOC_NR(VIDIOC_REQBUFS)] = "VIDIOC_REQBUFS",
226 [_IOC_NR(VIDIOC_QUERYBUF)] = "VIDIOC_QUERYBUF",
227 [_IOC_NR(VIDIOC_G_FBUF)] = "VIDIOC_G_FBUF",
228 [_IOC_NR(VIDIOC_S_FBUF)] = "VIDIOC_S_FBUF",
229 [_IOC_NR(VIDIOC_OVERLAY)] = "VIDIOC_OVERLAY",
230 [_IOC_NR(VIDIOC_QBUF)] = "VIDIOC_QBUF",
231 [_IOC_NR(VIDIOC_DQBUF)] = "VIDIOC_DQBUF",
232 [_IOC_NR(VIDIOC_STREAMON)] = "VIDIOC_STREAMON",
233 [_IOC_NR(VIDIOC_STREAMOFF)] = "VIDIOC_STREAMOFF",
234 [_IOC_NR(VIDIOC_G_PARM)] = "VIDIOC_G_PARM",
235 [_IOC_NR(VIDIOC_S_PARM)] = "VIDIOC_S_PARM",
236 [_IOC_NR(VIDIOC_G_STD)] = "VIDIOC_G_STD",
237 [_IOC_NR(VIDIOC_S_STD)] = "VIDIOC_S_STD",
238 [_IOC_NR(VIDIOC_ENUMSTD)] = "VIDIOC_ENUMSTD",
239 [_IOC_NR(VIDIOC_ENUMINPUT)] = "VIDIOC_ENUMINPUT",
240 [_IOC_NR(VIDIOC_G_CTRL)] = "VIDIOC_G_CTRL",
241 [_IOC_NR(VIDIOC_S_CTRL)] = "VIDIOC_S_CTRL",
242 [_IOC_NR(VIDIOC_G_TUNER)] = "VIDIOC_G_TUNER",
243 [_IOC_NR(VIDIOC_S_TUNER)] = "VIDIOC_S_TUNER",
244 [_IOC_NR(VIDIOC_G_AUDIO)] = "VIDIOC_G_AUDIO",
245 [_IOC_NR(VIDIOC_S_AUDIO)] = "VIDIOC_S_AUDIO",
246 [_IOC_NR(VIDIOC_QUERYCTRL)] = "VIDIOC_QUERYCTRL",
247 [_IOC_NR(VIDIOC_QUERYMENU)] = "VIDIOC_QUERYMENU",
248 [_IOC_NR(VIDIOC_G_INPUT)] = "VIDIOC_G_INPUT",
249 [_IOC_NR(VIDIOC_S_INPUT)] = "VIDIOC_S_INPUT",
250 [_IOC_NR(VIDIOC_G_OUTPUT)] = "VIDIOC_G_OUTPUT",
251 [_IOC_NR(VIDIOC_S_OUTPUT)] = "VIDIOC_S_OUTPUT",
252 [_IOC_NR(VIDIOC_ENUMOUTPUT)] = "VIDIOC_ENUMOUTPUT",
253 [_IOC_NR(VIDIOC_G_AUDOUT)] = "VIDIOC_G_AUDOUT",
254 [_IOC_NR(VIDIOC_S_AUDOUT)] = "VIDIOC_S_AUDOUT",
255 [_IOC_NR(VIDIOC_G_MODULATOR)] = "VIDIOC_G_MODULATOR",
256 [_IOC_NR(VIDIOC_S_MODULATOR)] = "VIDIOC_S_MODULATOR",
257 [_IOC_NR(VIDIOC_G_FREQUENCY)] = "VIDIOC_G_FREQUENCY",
258 [_IOC_NR(VIDIOC_S_FREQUENCY)] = "VIDIOC_S_FREQUENCY",
259 [_IOC_NR(VIDIOC_CROPCAP)] = "VIDIOC_CROPCAP",
260 [_IOC_NR(VIDIOC_G_CROP)] = "VIDIOC_G_CROP",
261 [_IOC_NR(VIDIOC_S_CROP)] = "VIDIOC_S_CROP",
262 [_IOC_NR(VIDIOC_G_JPEGCOMP)] = "VIDIOC_G_JPEGCOMP",
263 [_IOC_NR(VIDIOC_S_JPEGCOMP)] = "VIDIOC_S_JPEGCOMP",
264 [_IOC_NR(VIDIOC_QUERYSTD)] = "VIDIOC_QUERYSTD",
265 [_IOC_NR(VIDIOC_TRY_FMT)] = "VIDIOC_TRY_FMT",
266 [_IOC_NR(VIDIOC_ENUMAUDIO)] = "VIDIOC_ENUMAUDIO",
267 [_IOC_NR(VIDIOC_ENUMAUDOUT)] = "VIDIOC_ENUMAUDOUT",
268 [_IOC_NR(VIDIOC_G_PRIORITY)] = "VIDIOC_G_PRIORITY",
269 [_IOC_NR(VIDIOC_S_PRIORITY)] = "VIDIOC_S_PRIORITY",
270 [_IOC_NR(VIDIOC_G_SLICED_VBI_CAP)] = "VIDIOC_G_SLICED_VBI_CAP",
271 [_IOC_NR(VIDIOC_LOG_STATUS)] = "VIDIOC_LOG_STATUS",
272 [_IOC_NR(VIDIOC_G_EXT_CTRLS)] = "VIDIOC_G_EXT_CTRLS",
273 [_IOC_NR(VIDIOC_S_EXT_CTRLS)] = "VIDIOC_S_EXT_CTRLS",
274 [_IOC_NR(VIDIOC_TRY_EXT_CTRLS)] = "VIDIOC_TRY_EXT_CTRLS",
276 [_IOC_NR(VIDIOC_ENUM_FRAMESIZES)] = "VIDIOC_ENUM_FRAMESIZES",
277 [_IOC_NR(VIDIOC_ENUM_FRAMEINTERVALS)] = "VIDIOC_ENUM_FRAMEINTERVALS",
278 [_IOC_NR(VIDIOC_G_ENC_INDEX)] = "VIDIOC_G_ENC_INDEX",
279 [_IOC_NR(VIDIOC_ENCODER_CMD)] = "VIDIOC_ENCODER_CMD",
280 [_IOC_NR(VIDIOC_TRY_ENCODER_CMD)] = "VIDIOC_TRY_ENCODER_CMD",
282 [_IOC_NR(VIDIOC_DBG_S_REGISTER)] = "VIDIOC_DBG_S_REGISTER",
283 [_IOC_NR(VIDIOC_DBG_G_REGISTER)] = "VIDIOC_DBG_G_REGISTER",
285 [_IOC_NR(VIDIOC_DBG_G_CHIP_IDENT)] = "VIDIOC_DBG_G_CHIP_IDENT",
286 [_IOC_NR(VIDIOC_S_HW_FREQ_SEEK)] = "VIDIOC_S_HW_FREQ_SEEK",
288 [_IOC_NR(VIDIOC_ENUM_DV_PRESETS)] = "VIDIOC_ENUM_DV_PRESETS",
289 [_IOC_NR(VIDIOC_S_DV_PRESET)] = "VIDIOC_S_DV_PRESET",
290 [_IOC_NR(VIDIOC_G_DV_PRESET)] = "VIDIOC_G_DV_PRESET",
291 [_IOC_NR(VIDIOC_QUERY_DV_PRESET)] = "VIDIOC_QUERY_DV_PRESET",
292 [_IOC_NR(VIDIOC_S_DV_TIMINGS)] = "VIDIOC_S_DV_TIMINGS",
293 [_IOC_NR(VIDIOC_G_DV_TIMINGS)] = "VIDIOC_G_DV_TIMINGS",
294 [_IOC_NR(VIDIOC_DQEVENT)] = "VIDIOC_DQEVENT",
295 [_IOC_NR(VIDIOC_SUBSCRIBE_EVENT)] = "VIDIOC_SUBSCRIBE_EVENT",
296 [_IOC_NR(VIDIOC_UNSUBSCRIBE_EVENT)] = "VIDIOC_UNSUBSCRIBE_EVENT",
298 #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
300 /* Common ioctl debug function. This function can be used by
301 external ioctl messages as well as internal V4L ioctl */
302 void v4l_printk_ioctl(unsigned int cmd)
306 switch (_IOC_TYPE(cmd)) {
310 #ifdef CONFIG_VIDEO_V4L1_COMPAT
312 if (_IOC_NR(cmd) >= V4L1_IOCTLS) {
316 printk("%s", v4l1_ioctls[_IOC_NR(cmd)]);
320 if (_IOC_NR(cmd) >= V4L2_IOCTLS) {
324 printk("%s", v4l2_ioctls[_IOC_NR(cmd)]);
330 switch (_IOC_DIR(cmd)) {
331 case _IOC_NONE: dir = "--"; break;
332 case _IOC_READ: dir = "r-"; break;
333 case _IOC_WRITE: dir = "-w"; break;
334 case _IOC_READ | _IOC_WRITE: dir = "rw"; break;
335 default: dir = "*ERR*"; break;
337 printk("%s ioctl '%c', dir=%s, #%d (0x%08x)",
338 type, _IOC_TYPE(cmd), dir, _IOC_NR(cmd), cmd);
340 EXPORT_SYMBOL(v4l_printk_ioctl);
343 * helper function -- handles userspace copying for ioctl arguments
348 video_fix_command(unsigned int cmd)
351 case VIDIOC_OVERLAY_OLD:
352 cmd = VIDIOC_OVERLAY;
354 case VIDIOC_S_PARM_OLD:
357 case VIDIOC_S_CTRL_OLD:
360 case VIDIOC_G_AUDIO_OLD:
361 cmd = VIDIOC_G_AUDIO;
363 case VIDIOC_G_AUDOUT_OLD:
364 cmd = VIDIOC_G_AUDOUT;
366 case VIDIOC_CROPCAP_OLD:
367 cmd = VIDIOC_CROPCAP;
375 * Obsolete usercopy function - Should be removed soon
378 video_usercopy(struct file *file, unsigned int cmd, unsigned long arg,
386 size_t ctrls_size = 0;
387 void __user *user_ptr = NULL;
390 cmd = video_fix_command(cmd);
392 is_ext_ctrl = (cmd == VIDIOC_S_EXT_CTRLS || cmd == VIDIOC_G_EXT_CTRLS ||
393 cmd == VIDIOC_TRY_EXT_CTRLS);
395 /* Copy arguments into temp kernel buffer */
396 switch (_IOC_DIR(cmd)) {
402 case (_IOC_WRITE | _IOC_READ):
403 if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
406 /* too big to allocate from stack */
407 mbuf = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
414 if (_IOC_DIR(cmd) & _IOC_WRITE)
415 if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
420 struct v4l2_ext_controls *p = parg;
422 /* In case of an error, tell the caller that it wasn't
423 a specific control that caused it. */
424 p->error_idx = p->count;
425 user_ptr = (void __user *)p->controls;
427 ctrls_size = sizeof(struct v4l2_ext_control) * p->count;
428 /* Note: v4l2_ext_controls fits in sbuf[] so mbuf is still NULL. */
429 mbuf = kmalloc(ctrls_size, GFP_KERNEL);
434 if (copy_from_user(mbuf, user_ptr, ctrls_size))
441 err = func(file, cmd, parg);
442 if (err == -ENOIOCTLCMD)
445 struct v4l2_ext_controls *p = parg;
447 p->controls = (void *)user_ptr;
448 if (p->count && err == 0 && copy_to_user(user_ptr, mbuf, ctrls_size))
456 /* Copy results into user buffer */
457 switch (_IOC_DIR(cmd)) {
459 case (_IOC_WRITE | _IOC_READ):
460 if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
469 EXPORT_SYMBOL(video_usercopy);
471 static void dbgbuf(unsigned int cmd, struct video_device *vfd,
472 struct v4l2_buffer *p)
474 struct v4l2_timecode *tc = &p->timecode;
476 dbgarg(cmd, "%02ld:%02d:%02d.%08ld index=%d, type=%s, "
477 "bytesused=%d, flags=0x%08d, "
478 "field=%0d, sequence=%d, memory=%s, offset/userptr=0x%08lx, length=%d\n",
479 p->timestamp.tv_sec / 3600,
480 (int)(p->timestamp.tv_sec / 60) % 60,
481 (int)(p->timestamp.tv_sec % 60),
482 (long)p->timestamp.tv_usec,
484 prt_names(p->type, v4l2_type_names),
485 p->bytesused, p->flags,
486 p->field, p->sequence,
487 prt_names(p->memory, v4l2_memory_names),
488 p->m.userptr, p->length);
489 dbgarg2("timecode=%02d:%02d:%02d type=%d, "
490 "flags=0x%08d, frames=%d, userbits=0x%08x\n",
491 tc->hours, tc->minutes, tc->seconds,
492 tc->type, tc->flags, tc->frames, *(__u32 *)tc->userbits);
495 static inline void dbgrect(struct video_device *vfd, char *s,
498 dbgarg2("%sRect start at %dx%d, size=%dx%d\n", s, r->left, r->top,
499 r->width, r->height);
502 static inline void v4l_print_pix_fmt(struct video_device *vfd,
503 struct v4l2_pix_format *fmt)
505 dbgarg2("width=%d, height=%d, format=%c%c%c%c, field=%s, "
506 "bytesperline=%d sizeimage=%d, colorspace=%d\n",
507 fmt->width, fmt->height,
508 (fmt->pixelformat & 0xff),
509 (fmt->pixelformat >> 8) & 0xff,
510 (fmt->pixelformat >> 16) & 0xff,
511 (fmt->pixelformat >> 24) & 0xff,
512 prt_names(fmt->field, v4l2_field_names),
513 fmt->bytesperline, fmt->sizeimage, fmt->colorspace);
516 static inline void v4l_print_ext_ctrls(unsigned int cmd,
517 struct video_device *vfd, struct v4l2_ext_controls *c, int show_vals)
521 if (!(vfd->debug & V4L2_DEBUG_IOCTL_ARG))
524 printk(KERN_CONT "class=0x%x", c->ctrl_class);
525 for (i = 0; i < c->count; i++) {
526 if (show_vals && !c->controls[i].size)
527 printk(KERN_CONT " id/val=0x%x/0x%x",
528 c->controls[i].id, c->controls[i].value);
530 printk(KERN_CONT " id=0x%x,size=%u",
531 c->controls[i].id, c->controls[i].size);
533 printk(KERN_CONT "\n");
536 static inline int check_ext_ctrls(struct v4l2_ext_controls *c, int allow_priv)
540 /* zero the reserved fields */
541 c->reserved[0] = c->reserved[1] = 0;
542 for (i = 0; i < c->count; i++)
543 c->controls[i].reserved2[0] = 0;
545 /* V4L2_CID_PRIVATE_BASE cannot be used as control class
546 when using extended controls.
547 Only when passed in through VIDIOC_G_CTRL and VIDIOC_S_CTRL
548 is it allowed for backwards compatibility.
550 if (!allow_priv && c->ctrl_class == V4L2_CID_PRIVATE_BASE)
552 /* Check that all controls are from the same control class. */
553 for (i = 0; i < c->count; i++) {
554 if (V4L2_CTRL_ID2CLASS(c->controls[i].id) != c->ctrl_class) {
562 static int check_fmt(const struct v4l2_ioctl_ops *ops, enum v4l2_buf_type type)
568 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
569 if (ops->vidioc_g_fmt_vid_cap)
572 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
573 if (ops->vidioc_g_fmt_vid_overlay)
576 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
577 if (ops->vidioc_g_fmt_vid_out)
580 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
581 if (ops->vidioc_g_fmt_vid_out_overlay)
584 case V4L2_BUF_TYPE_VBI_CAPTURE:
585 if (ops->vidioc_g_fmt_vbi_cap)
588 case V4L2_BUF_TYPE_VBI_OUTPUT:
589 if (ops->vidioc_g_fmt_vbi_out)
592 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
593 if (ops->vidioc_g_fmt_sliced_vbi_cap)
596 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
597 if (ops->vidioc_g_fmt_sliced_vbi_out)
600 case V4L2_BUF_TYPE_PRIVATE:
601 if (ops->vidioc_g_fmt_type_private)
608 static long __video_do_ioctl(struct file *file,
609 unsigned int cmd, void *arg)
611 struct video_device *vfd = video_devdata(file);
612 const struct v4l2_ioctl_ops *ops = vfd->ioctl_ops;
613 void *fh = file->private_data;
617 printk(KERN_WARNING "videodev: \"%s\" has no ioctl_ops.\n",
622 #ifdef CONFIG_VIDEO_V4L1_COMPAT
623 /********************************************************
624 All other V4L1 calls are handled by v4l1_compat module.
625 Those calls will be translated into V4L2 calls, and
626 __video_do_ioctl will be called again, with one or more
628 ********************************************************/
629 if (_IOC_TYPE(cmd) == 'v' && cmd != VIDIOCGMBUF &&
630 _IOC_NR(cmd) < BASE_VIDIOCPRIVATE) {
631 return v4l_compat_translate_ioctl(file, cmd, arg,
636 if ((vfd->debug & V4L2_DEBUG_IOCTL) &&
637 !(vfd->debug & V4L2_DEBUG_IOCTL_ARG)) {
638 v4l_print_ioctl(vfd->name, cmd);
639 printk(KERN_CONT "\n");
644 #ifdef CONFIG_VIDEO_V4L1_COMPAT
645 /***********************************************************
646 Handles calls to the obsoleted V4L1 API
647 Due to the nature of VIDIOCGMBUF, each driver that supports
648 V4L1 should implement its own handler for this ioctl.
649 ***********************************************************/
651 /* --- streaming capture ------------------------------------- */
654 struct video_mbuf *p = arg;
656 if (!ops->vidiocgmbuf)
658 ret = ops->vidiocgmbuf(file, fh, p);
660 dbgarg(cmd, "size=%d, frames=%d, offsets=0x%08lx\n",
662 (unsigned long)p->offsets);
667 /* --- capabilities ------------------------------------------ */
668 case VIDIOC_QUERYCAP:
670 struct v4l2_capability *cap = (struct v4l2_capability *)arg;
672 if (!ops->vidioc_querycap)
675 ret = ops->vidioc_querycap(file, fh, cap);
677 dbgarg(cmd, "driver=%s, card=%s, bus=%s, "
679 "capabilities=0x%08x\n",
680 cap->driver, cap->card, cap->bus_info,
686 /* --- priority ------------------------------------------ */
687 case VIDIOC_G_PRIORITY:
689 enum v4l2_priority *p = arg;
691 if (!ops->vidioc_g_priority)
693 ret = ops->vidioc_g_priority(file, fh, p);
695 dbgarg(cmd, "priority is %d\n", *p);
698 case VIDIOC_S_PRIORITY:
700 enum v4l2_priority *p = arg;
702 if (!ops->vidioc_s_priority)
704 dbgarg(cmd, "setting priority to %d\n", *p);
705 ret = ops->vidioc_s_priority(file, fh, *p);
709 /* --- capture ioctls ---------------------------------------- */
710 case VIDIOC_ENUM_FMT:
712 struct v4l2_fmtdesc *f = arg;
715 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
716 if (ops->vidioc_enum_fmt_vid_cap)
717 ret = ops->vidioc_enum_fmt_vid_cap(file, fh, f);
719 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
720 if (ops->vidioc_enum_fmt_vid_overlay)
721 ret = ops->vidioc_enum_fmt_vid_overlay(file,
724 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
725 if (ops->vidioc_enum_fmt_vid_out)
726 ret = ops->vidioc_enum_fmt_vid_out(file, fh, f);
728 case V4L2_BUF_TYPE_PRIVATE:
729 if (ops->vidioc_enum_fmt_type_private)
730 ret = ops->vidioc_enum_fmt_type_private(file,
737 dbgarg(cmd, "index=%d, type=%d, flags=%d, "
738 "pixelformat=%c%c%c%c, description='%s'\n",
739 f->index, f->type, f->flags,
740 (f->pixelformat & 0xff),
741 (f->pixelformat >> 8) & 0xff,
742 (f->pixelformat >> 16) & 0xff,
743 (f->pixelformat >> 24) & 0xff,
749 struct v4l2_format *f = (struct v4l2_format *)arg;
751 /* FIXME: Should be one dump per type */
752 dbgarg(cmd, "type=%s\n", prt_names(f->type, v4l2_type_names));
755 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
756 if (ops->vidioc_g_fmt_vid_cap)
757 ret = ops->vidioc_g_fmt_vid_cap(file, fh, f);
759 v4l_print_pix_fmt(vfd, &f->fmt.pix);
761 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
762 if (ops->vidioc_g_fmt_vid_overlay)
763 ret = ops->vidioc_g_fmt_vid_overlay(file,
766 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
767 if (ops->vidioc_g_fmt_vid_out)
768 ret = ops->vidioc_g_fmt_vid_out(file, fh, f);
770 v4l_print_pix_fmt(vfd, &f->fmt.pix);
772 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
773 if (ops->vidioc_g_fmt_vid_out_overlay)
774 ret = ops->vidioc_g_fmt_vid_out_overlay(file,
777 case V4L2_BUF_TYPE_VBI_CAPTURE:
778 if (ops->vidioc_g_fmt_vbi_cap)
779 ret = ops->vidioc_g_fmt_vbi_cap(file, fh, f);
781 case V4L2_BUF_TYPE_VBI_OUTPUT:
782 if (ops->vidioc_g_fmt_vbi_out)
783 ret = ops->vidioc_g_fmt_vbi_out(file, fh, f);
785 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
786 if (ops->vidioc_g_fmt_sliced_vbi_cap)
787 ret = ops->vidioc_g_fmt_sliced_vbi_cap(file,
790 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
791 if (ops->vidioc_g_fmt_sliced_vbi_out)
792 ret = ops->vidioc_g_fmt_sliced_vbi_out(file,
795 case V4L2_BUF_TYPE_PRIVATE:
796 if (ops->vidioc_g_fmt_type_private)
797 ret = ops->vidioc_g_fmt_type_private(file,
806 struct v4l2_format *f = (struct v4l2_format *)arg;
808 /* FIXME: Should be one dump per type */
809 dbgarg(cmd, "type=%s\n", prt_names(f->type, v4l2_type_names));
812 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
813 CLEAR_AFTER_FIELD(f, fmt.pix);
814 v4l_print_pix_fmt(vfd, &f->fmt.pix);
815 if (ops->vidioc_s_fmt_vid_cap)
816 ret = ops->vidioc_s_fmt_vid_cap(file, fh, f);
818 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
819 CLEAR_AFTER_FIELD(f, fmt.win);
820 if (ops->vidioc_s_fmt_vid_overlay)
821 ret = ops->vidioc_s_fmt_vid_overlay(file,
824 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
825 CLEAR_AFTER_FIELD(f, fmt.pix);
826 v4l_print_pix_fmt(vfd, &f->fmt.pix);
827 if (ops->vidioc_s_fmt_vid_out)
828 ret = ops->vidioc_s_fmt_vid_out(file, fh, f);
830 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
831 CLEAR_AFTER_FIELD(f, fmt.win);
832 if (ops->vidioc_s_fmt_vid_out_overlay)
833 ret = ops->vidioc_s_fmt_vid_out_overlay(file,
836 case V4L2_BUF_TYPE_VBI_CAPTURE:
837 CLEAR_AFTER_FIELD(f, fmt.vbi);
838 if (ops->vidioc_s_fmt_vbi_cap)
839 ret = ops->vidioc_s_fmt_vbi_cap(file, fh, f);
841 case V4L2_BUF_TYPE_VBI_OUTPUT:
842 CLEAR_AFTER_FIELD(f, fmt.vbi);
843 if (ops->vidioc_s_fmt_vbi_out)
844 ret = ops->vidioc_s_fmt_vbi_out(file, fh, f);
846 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
847 CLEAR_AFTER_FIELD(f, fmt.sliced);
848 if (ops->vidioc_s_fmt_sliced_vbi_cap)
849 ret = ops->vidioc_s_fmt_sliced_vbi_cap(file,
852 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
853 CLEAR_AFTER_FIELD(f, fmt.sliced);
854 if (ops->vidioc_s_fmt_sliced_vbi_out)
855 ret = ops->vidioc_s_fmt_sliced_vbi_out(file,
858 case V4L2_BUF_TYPE_PRIVATE:
859 /* CLEAR_AFTER_FIELD(f, fmt.raw_data); <- does nothing */
860 if (ops->vidioc_s_fmt_type_private)
861 ret = ops->vidioc_s_fmt_type_private(file,
869 struct v4l2_format *f = (struct v4l2_format *)arg;
871 /* FIXME: Should be one dump per type */
872 dbgarg(cmd, "type=%s\n", prt_names(f->type,
875 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
876 CLEAR_AFTER_FIELD(f, fmt.pix);
877 if (ops->vidioc_try_fmt_vid_cap)
878 ret = ops->vidioc_try_fmt_vid_cap(file, fh, f);
880 v4l_print_pix_fmt(vfd, &f->fmt.pix);
882 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
883 CLEAR_AFTER_FIELD(f, fmt.win);
884 if (ops->vidioc_try_fmt_vid_overlay)
885 ret = ops->vidioc_try_fmt_vid_overlay(file,
888 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
889 CLEAR_AFTER_FIELD(f, fmt.pix);
890 if (ops->vidioc_try_fmt_vid_out)
891 ret = ops->vidioc_try_fmt_vid_out(file, fh, f);
893 v4l_print_pix_fmt(vfd, &f->fmt.pix);
895 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
896 CLEAR_AFTER_FIELD(f, fmt.win);
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 CLEAR_AFTER_FIELD(f, fmt.vbi);
903 if (ops->vidioc_try_fmt_vbi_cap)
904 ret = ops->vidioc_try_fmt_vbi_cap(file, fh, f);
906 case V4L2_BUF_TYPE_VBI_OUTPUT:
907 CLEAR_AFTER_FIELD(f, fmt.vbi);
908 if (ops->vidioc_try_fmt_vbi_out)
909 ret = ops->vidioc_try_fmt_vbi_out(file, fh, f);
911 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
912 CLEAR_AFTER_FIELD(f, fmt.sliced);
913 if (ops->vidioc_try_fmt_sliced_vbi_cap)
914 ret = ops->vidioc_try_fmt_sliced_vbi_cap(file,
917 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
918 CLEAR_AFTER_FIELD(f, fmt.sliced);
919 if (ops->vidioc_try_fmt_sliced_vbi_out)
920 ret = ops->vidioc_try_fmt_sliced_vbi_out(file,
923 case V4L2_BUF_TYPE_PRIVATE:
924 /* CLEAR_AFTER_FIELD(f, fmt.raw_data); <- does nothing */
925 if (ops->vidioc_try_fmt_type_private)
926 ret = ops->vidioc_try_fmt_type_private(file,
933 /* FIXME: Those buf reqs could be handled here,
934 with some changes on videobuf to allow its header to be included at
935 videodev2.h or being merged at videodev2.
939 struct v4l2_requestbuffers *p = arg;
941 if (!ops->vidioc_reqbufs)
943 ret = check_fmt(ops, p->type);
947 if (p->type < V4L2_BUF_TYPE_PRIVATE)
948 CLEAR_AFTER_FIELD(p, memory);
950 ret = ops->vidioc_reqbufs(file, fh, p);
951 dbgarg(cmd, "count=%d, type=%s, memory=%s\n",
953 prt_names(p->type, v4l2_type_names),
954 prt_names(p->memory, v4l2_memory_names));
957 case VIDIOC_QUERYBUF:
959 struct v4l2_buffer *p = arg;
961 if (!ops->vidioc_querybuf)
963 ret = check_fmt(ops, p->type);
967 ret = ops->vidioc_querybuf(file, fh, p);
974 struct v4l2_buffer *p = arg;
976 if (!ops->vidioc_qbuf)
978 ret = check_fmt(ops, p->type);
982 ret = ops->vidioc_qbuf(file, fh, p);
989 struct v4l2_buffer *p = arg;
991 if (!ops->vidioc_dqbuf)
993 ret = check_fmt(ops, p->type);
997 ret = ops->vidioc_dqbuf(file, fh, p);
1002 case VIDIOC_OVERLAY:
1006 if (!ops->vidioc_overlay)
1008 dbgarg(cmd, "value=%d\n", *i);
1009 ret = ops->vidioc_overlay(file, fh, *i);
1014 struct v4l2_framebuffer *p = arg;
1016 if (!ops->vidioc_g_fbuf)
1018 ret = ops->vidioc_g_fbuf(file, fh, arg);
1020 dbgarg(cmd, "capability=0x%x, flags=%d, base=0x%08lx\n",
1021 p->capability, p->flags,
1022 (unsigned long)p->base);
1023 v4l_print_pix_fmt(vfd, &p->fmt);
1029 struct v4l2_framebuffer *p = arg;
1031 if (!ops->vidioc_s_fbuf)
1033 dbgarg(cmd, "capability=0x%x, flags=%d, base=0x%08lx\n",
1034 p->capability, p->flags, (unsigned long)p->base);
1035 v4l_print_pix_fmt(vfd, &p->fmt);
1036 ret = ops->vidioc_s_fbuf(file, fh, arg);
1039 case VIDIOC_STREAMON:
1041 enum v4l2_buf_type i = *(int *)arg;
1043 if (!ops->vidioc_streamon)
1045 dbgarg(cmd, "type=%s\n", prt_names(i, v4l2_type_names));
1046 ret = ops->vidioc_streamon(file, fh, i);
1049 case VIDIOC_STREAMOFF:
1051 enum v4l2_buf_type i = *(int *)arg;
1053 if (!ops->vidioc_streamoff)
1055 dbgarg(cmd, "type=%s\n", prt_names(i, v4l2_type_names));
1056 ret = ops->vidioc_streamoff(file, fh, i);
1059 /* ---------- tv norms ---------- */
1060 case VIDIOC_ENUMSTD:
1062 struct v4l2_standard *p = arg;
1063 v4l2_std_id id = vfd->tvnorms, curr_id = 0;
1064 unsigned int index = p->index, i, j = 0;
1065 const char *descr = "";
1067 /* Return norm array in a canonical way */
1068 for (i = 0; i <= index && id; i++) {
1069 /* last std value in the standards array is 0, so this
1070 while always ends there since (id & 0) == 0. */
1071 while ((id & standards[j].std) != standards[j].std)
1073 curr_id = standards[j].std;
1074 descr = standards[j].descr;
1078 if (curr_id != V4L2_STD_PAL &&
1079 curr_id != V4L2_STD_SECAM &&
1080 curr_id != V4L2_STD_NTSC)
1086 v4l2_video_std_construct(p, curr_id, descr);
1088 dbgarg(cmd, "index=%d, id=0x%Lx, name=%s, fps=%d/%d, "
1089 "framelines=%d\n", p->index,
1090 (unsigned long long)p->id, p->name,
1091 p->frameperiod.numerator,
1092 p->frameperiod.denominator,
1100 v4l2_std_id *id = arg;
1103 /* Calls the specific handler */
1104 if (ops->vidioc_g_std)
1105 ret = ops->vidioc_g_std(file, fh, id);
1106 else if (vfd->current_norm)
1107 *id = vfd->current_norm;
1112 dbgarg(cmd, "std=0x%08Lx\n", (long long unsigned)*id);
1117 v4l2_std_id *id = arg, norm;
1119 dbgarg(cmd, "std=%08Lx\n", (long long unsigned)*id);
1121 norm = (*id) & vfd->tvnorms;
1122 if (vfd->tvnorms && !norm) /* Check if std is supported */
1125 /* Calls the specific handler */
1126 if (ops->vidioc_s_std)
1127 ret = ops->vidioc_s_std(file, fh, &norm);
1131 /* Updates standard information */
1133 vfd->current_norm = norm;
1136 case VIDIOC_QUERYSTD:
1138 v4l2_std_id *p = arg;
1140 if (!ops->vidioc_querystd)
1142 ret = ops->vidioc_querystd(file, fh, arg);
1144 dbgarg(cmd, "detected std=%08Lx\n",
1145 (unsigned long long)*p);
1148 /* ------ input switching ---------- */
1149 /* FIXME: Inputs can be handled inside videodev2 */
1150 case VIDIOC_ENUMINPUT:
1152 struct v4l2_input *p = arg;
1155 * We set the flags for CAP_PRESETS, CAP_CUSTOM_TIMINGS &
1156 * CAP_STD here based on ioctl handler provided by the
1157 * driver. If the driver doesn't support these
1158 * for a specific input, it must override these flags.
1160 if (ops->vidioc_s_std)
1161 p->capabilities |= V4L2_IN_CAP_STD;
1162 if (ops->vidioc_s_dv_preset)
1163 p->capabilities |= V4L2_IN_CAP_PRESETS;
1164 if (ops->vidioc_s_dv_timings)
1165 p->capabilities |= V4L2_IN_CAP_CUSTOM_TIMINGS;
1167 if (!ops->vidioc_enum_input)
1170 ret = ops->vidioc_enum_input(file, fh, p);
1172 dbgarg(cmd, "index=%d, name=%s, type=%d, "
1174 "tuner=%d, std=%08Lx, status=%d\n",
1175 p->index, p->name, p->type, p->audioset,
1177 (unsigned long long)p->std,
1181 case VIDIOC_G_INPUT:
1183 unsigned int *i = arg;
1185 if (!ops->vidioc_g_input)
1187 ret = ops->vidioc_g_input(file, fh, i);
1189 dbgarg(cmd, "value=%d\n", *i);
1192 case VIDIOC_S_INPUT:
1194 unsigned int *i = arg;
1196 if (!ops->vidioc_s_input)
1198 dbgarg(cmd, "value=%d\n", *i);
1199 ret = ops->vidioc_s_input(file, fh, *i);
1203 /* ------ output switching ---------- */
1204 case VIDIOC_ENUMOUTPUT:
1206 struct v4l2_output *p = arg;
1208 if (!ops->vidioc_enum_output)
1212 * We set the flags for CAP_PRESETS, CAP_CUSTOM_TIMINGS &
1213 * CAP_STD here based on ioctl handler provided by the
1214 * driver. If the driver doesn't support these
1215 * for a specific output, it must override these flags.
1217 if (ops->vidioc_s_std)
1218 p->capabilities |= V4L2_OUT_CAP_STD;
1219 if (ops->vidioc_s_dv_preset)
1220 p->capabilities |= V4L2_OUT_CAP_PRESETS;
1221 if (ops->vidioc_s_dv_timings)
1222 p->capabilities |= V4L2_OUT_CAP_CUSTOM_TIMINGS;
1224 ret = ops->vidioc_enum_output(file, fh, p);
1226 dbgarg(cmd, "index=%d, name=%s, type=%d, "
1228 "modulator=%d, std=0x%08Lx\n",
1229 p->index, p->name, p->type, p->audioset,
1230 p->modulator, (unsigned long long)p->std);
1233 case VIDIOC_G_OUTPUT:
1235 unsigned int *i = arg;
1237 if (!ops->vidioc_g_output)
1239 ret = ops->vidioc_g_output(file, fh, i);
1241 dbgarg(cmd, "value=%d\n", *i);
1244 case VIDIOC_S_OUTPUT:
1246 unsigned int *i = arg;
1248 if (!ops->vidioc_s_output)
1250 dbgarg(cmd, "value=%d\n", *i);
1251 ret = ops->vidioc_s_output(file, fh, *i);
1255 /* --- controls ---------------------------------------------- */
1256 case VIDIOC_QUERYCTRL:
1258 struct v4l2_queryctrl *p = arg;
1260 if (!ops->vidioc_queryctrl)
1262 ret = ops->vidioc_queryctrl(file, fh, p);
1264 dbgarg(cmd, "id=0x%x, type=%d, name=%s, min/max=%d/%d, "
1265 "step=%d, default=%d, flags=0x%08x\n",
1266 p->id, p->type, p->name,
1267 p->minimum, p->maximum,
1268 p->step, p->default_value, p->flags);
1270 dbgarg(cmd, "id=0x%x\n", p->id);
1275 struct v4l2_control *p = arg;
1277 if (ops->vidioc_g_ctrl)
1278 ret = ops->vidioc_g_ctrl(file, fh, p);
1279 else if (ops->vidioc_g_ext_ctrls) {
1280 struct v4l2_ext_controls ctrls;
1281 struct v4l2_ext_control ctrl;
1283 ctrls.ctrl_class = V4L2_CTRL_ID2CLASS(p->id);
1285 ctrls.controls = &ctrl;
1287 ctrl.value = p->value;
1288 if (check_ext_ctrls(&ctrls, 1)) {
1289 ret = ops->vidioc_g_ext_ctrls(file, fh, &ctrls);
1291 p->value = ctrl.value;
1296 dbgarg(cmd, "id=0x%x, value=%d\n", p->id, p->value);
1298 dbgarg(cmd, "id=0x%x\n", p->id);
1303 struct v4l2_control *p = arg;
1304 struct v4l2_ext_controls ctrls;
1305 struct v4l2_ext_control ctrl;
1307 if (!ops->vidioc_s_ctrl && !ops->vidioc_s_ext_ctrls)
1310 dbgarg(cmd, "id=0x%x, value=%d\n", p->id, p->value);
1312 if (ops->vidioc_s_ctrl) {
1313 ret = ops->vidioc_s_ctrl(file, fh, p);
1316 if (!ops->vidioc_s_ext_ctrls)
1319 ctrls.ctrl_class = V4L2_CTRL_ID2CLASS(p->id);
1321 ctrls.controls = &ctrl;
1323 ctrl.value = p->value;
1324 if (check_ext_ctrls(&ctrls, 1))
1325 ret = ops->vidioc_s_ext_ctrls(file, fh, &ctrls);
1328 case VIDIOC_G_EXT_CTRLS:
1330 struct v4l2_ext_controls *p = arg;
1332 p->error_idx = p->count;
1333 if (!ops->vidioc_g_ext_ctrls)
1335 if (check_ext_ctrls(p, 0))
1336 ret = ops->vidioc_g_ext_ctrls(file, fh, p);
1337 v4l_print_ext_ctrls(cmd, vfd, p, !ret);
1340 case VIDIOC_S_EXT_CTRLS:
1342 struct v4l2_ext_controls *p = arg;
1344 p->error_idx = p->count;
1345 if (!ops->vidioc_s_ext_ctrls)
1347 v4l_print_ext_ctrls(cmd, vfd, p, 1);
1348 if (check_ext_ctrls(p, 0))
1349 ret = ops->vidioc_s_ext_ctrls(file, fh, p);
1352 case VIDIOC_TRY_EXT_CTRLS:
1354 struct v4l2_ext_controls *p = arg;
1356 p->error_idx = p->count;
1357 if (!ops->vidioc_try_ext_ctrls)
1359 v4l_print_ext_ctrls(cmd, vfd, p, 1);
1360 if (check_ext_ctrls(p, 0))
1361 ret = ops->vidioc_try_ext_ctrls(file, fh, p);
1364 case VIDIOC_QUERYMENU:
1366 struct v4l2_querymenu *p = arg;
1368 if (!ops->vidioc_querymenu)
1370 ret = ops->vidioc_querymenu(file, fh, p);
1372 dbgarg(cmd, "id=0x%x, index=%d, name=%s\n",
1373 p->id, p->index, p->name);
1375 dbgarg(cmd, "id=0x%x, index=%d\n",
1379 /* --- audio ---------------------------------------------- */
1380 case VIDIOC_ENUMAUDIO:
1382 struct v4l2_audio *p = arg;
1384 if (!ops->vidioc_enumaudio)
1386 ret = ops->vidioc_enumaudio(file, fh, p);
1388 dbgarg(cmd, "index=%d, name=%s, capability=0x%x, "
1389 "mode=0x%x\n", p->index, p->name,
1390 p->capability, p->mode);
1392 dbgarg(cmd, "index=%d\n", p->index);
1395 case VIDIOC_G_AUDIO:
1397 struct v4l2_audio *p = arg;
1399 if (!ops->vidioc_g_audio)
1402 ret = ops->vidioc_g_audio(file, fh, p);
1404 dbgarg(cmd, "index=%d, name=%s, capability=0x%x, "
1405 "mode=0x%x\n", p->index,
1406 p->name, p->capability, p->mode);
1408 dbgarg(cmd, "index=%d\n", p->index);
1411 case VIDIOC_S_AUDIO:
1413 struct v4l2_audio *p = arg;
1415 if (!ops->vidioc_s_audio)
1417 dbgarg(cmd, "index=%d, name=%s, capability=0x%x, "
1418 "mode=0x%x\n", p->index, p->name,
1419 p->capability, p->mode);
1420 ret = ops->vidioc_s_audio(file, fh, p);
1423 case VIDIOC_ENUMAUDOUT:
1425 struct v4l2_audioout *p = arg;
1427 if (!ops->vidioc_enumaudout)
1429 dbgarg(cmd, "Enum for index=%d\n", p->index);
1430 ret = ops->vidioc_enumaudout(file, fh, p);
1432 dbgarg2("index=%d, name=%s, capability=%d, "
1433 "mode=%d\n", p->index, p->name,
1434 p->capability, p->mode);
1437 case VIDIOC_G_AUDOUT:
1439 struct v4l2_audioout *p = arg;
1441 if (!ops->vidioc_g_audout)
1444 ret = ops->vidioc_g_audout(file, fh, p);
1446 dbgarg2("index=%d, name=%s, capability=%d, "
1447 "mode=%d\n", p->index, p->name,
1448 p->capability, p->mode);
1451 case VIDIOC_S_AUDOUT:
1453 struct v4l2_audioout *p = arg;
1455 if (!ops->vidioc_s_audout)
1457 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1458 "mode=%d\n", p->index, p->name,
1459 p->capability, p->mode);
1461 ret = ops->vidioc_s_audout(file, fh, p);
1464 case VIDIOC_G_MODULATOR:
1466 struct v4l2_modulator *p = arg;
1468 if (!ops->vidioc_g_modulator)
1470 ret = ops->vidioc_g_modulator(file, fh, p);
1472 dbgarg(cmd, "index=%d, name=%s, "
1473 "capability=%d, rangelow=%d,"
1474 " rangehigh=%d, txsubchans=%d\n",
1475 p->index, p->name, p->capability,
1476 p->rangelow, p->rangehigh,
1480 case VIDIOC_S_MODULATOR:
1482 struct v4l2_modulator *p = arg;
1484 if (!ops->vidioc_s_modulator)
1486 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1487 "rangelow=%d, rangehigh=%d, txsubchans=%d\n",
1488 p->index, p->name, p->capability, p->rangelow,
1489 p->rangehigh, p->txsubchans);
1490 ret = ops->vidioc_s_modulator(file, fh, p);
1495 struct v4l2_crop *p = arg;
1497 if (!ops->vidioc_g_crop)
1500 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
1501 ret = ops->vidioc_g_crop(file, fh, p);
1503 dbgrect(vfd, "", &p->c);
1508 struct v4l2_crop *p = arg;
1510 if (!ops->vidioc_s_crop)
1512 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
1513 dbgrect(vfd, "", &p->c);
1514 ret = ops->vidioc_s_crop(file, fh, p);
1517 case VIDIOC_CROPCAP:
1519 struct v4l2_cropcap *p = arg;
1521 /*FIXME: Should also show v4l2_fract pixelaspect */
1522 if (!ops->vidioc_cropcap)
1525 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
1526 ret = ops->vidioc_cropcap(file, fh, p);
1528 dbgrect(vfd, "bounds ", &p->bounds);
1529 dbgrect(vfd, "defrect ", &p->defrect);
1533 case VIDIOC_G_JPEGCOMP:
1535 struct v4l2_jpegcompression *p = arg;
1537 if (!ops->vidioc_g_jpegcomp)
1540 ret = ops->vidioc_g_jpegcomp(file, fh, p);
1542 dbgarg(cmd, "quality=%d, APPn=%d, "
1543 "APP_len=%d, COM_len=%d, "
1544 "jpeg_markers=%d\n",
1545 p->quality, p->APPn, p->APP_len,
1546 p->COM_len, p->jpeg_markers);
1549 case VIDIOC_S_JPEGCOMP:
1551 struct v4l2_jpegcompression *p = arg;
1553 if (!ops->vidioc_g_jpegcomp)
1555 dbgarg(cmd, "quality=%d, APPn=%d, APP_len=%d, "
1556 "COM_len=%d, jpeg_markers=%d\n",
1557 p->quality, p->APPn, p->APP_len,
1558 p->COM_len, p->jpeg_markers);
1559 ret = ops->vidioc_s_jpegcomp(file, fh, p);
1562 case VIDIOC_G_ENC_INDEX:
1564 struct v4l2_enc_idx *p = arg;
1566 if (!ops->vidioc_g_enc_index)
1568 ret = ops->vidioc_g_enc_index(file, fh, p);
1570 dbgarg(cmd, "entries=%d, entries_cap=%d\n",
1571 p->entries, p->entries_cap);
1574 case VIDIOC_ENCODER_CMD:
1576 struct v4l2_encoder_cmd *p = arg;
1578 if (!ops->vidioc_encoder_cmd)
1580 ret = ops->vidioc_encoder_cmd(file, fh, p);
1582 dbgarg(cmd, "cmd=%d, flags=%x\n", p->cmd, p->flags);
1585 case VIDIOC_TRY_ENCODER_CMD:
1587 struct v4l2_encoder_cmd *p = arg;
1589 if (!ops->vidioc_try_encoder_cmd)
1591 ret = ops->vidioc_try_encoder_cmd(file, fh, p);
1593 dbgarg(cmd, "cmd=%d, flags=%x\n", p->cmd, p->flags);
1598 struct v4l2_streamparm *p = arg;
1600 if (ops->vidioc_g_parm) {
1601 ret = check_fmt(ops, p->type);
1604 ret = ops->vidioc_g_parm(file, fh, p);
1606 v4l2_std_id std = vfd->current_norm;
1608 if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1612 if (ops->vidioc_g_std)
1613 ret = ops->vidioc_g_std(file, fh, &std);
1617 v4l2_video_std_frame_period(std,
1618 &p->parm.capture.timeperframe);
1621 dbgarg(cmd, "type=%d\n", p->type);
1626 struct v4l2_streamparm *p = arg;
1628 if (!ops->vidioc_s_parm)
1630 ret = check_fmt(ops, p->type);
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;
1642 if (!ops->vidioc_g_tuner)
1645 ret = ops->vidioc_g_tuner(file, fh, p);
1647 dbgarg(cmd, "index=%d, name=%s, type=%d, "
1648 "capability=0x%x, rangelow=%d, "
1649 "rangehigh=%d, signal=%d, afc=%d, "
1650 "rxsubchans=0x%x, audmode=%d\n",
1651 p->index, p->name, p->type,
1652 p->capability, p->rangelow,
1653 p->rangehigh, p->signal, p->afc,
1654 p->rxsubchans, p->audmode);
1657 case VIDIOC_S_TUNER:
1659 struct v4l2_tuner *p = arg;
1661 if (!ops->vidioc_s_tuner)
1663 dbgarg(cmd, "index=%d, name=%s, type=%d, "
1664 "capability=0x%x, rangelow=%d, "
1665 "rangehigh=%d, signal=%d, afc=%d, "
1666 "rxsubchans=0x%x, audmode=%d\n",
1667 p->index, p->name, p->type,
1668 p->capability, p->rangelow,
1669 p->rangehigh, p->signal, p->afc,
1670 p->rxsubchans, p->audmode);
1671 ret = ops->vidioc_s_tuner(file, fh, p);
1674 case VIDIOC_G_FREQUENCY:
1676 struct v4l2_frequency *p = arg;
1678 if (!ops->vidioc_g_frequency)
1681 ret = ops->vidioc_g_frequency(file, fh, p);
1683 dbgarg(cmd, "tuner=%d, type=%d, frequency=%d\n",
1684 p->tuner, p->type, p->frequency);
1687 case VIDIOC_S_FREQUENCY:
1689 struct v4l2_frequency *p = arg;
1691 if (!ops->vidioc_s_frequency)
1693 dbgarg(cmd, "tuner=%d, type=%d, frequency=%d\n",
1694 p->tuner, p->type, p->frequency);
1695 ret = ops->vidioc_s_frequency(file, fh, p);
1698 case VIDIOC_G_SLICED_VBI_CAP:
1700 struct v4l2_sliced_vbi_cap *p = arg;
1702 if (!ops->vidioc_g_sliced_vbi_cap)
1705 /* Clear up to type, everything after type is zerod already */
1706 memset(p, 0, offsetof(struct v4l2_sliced_vbi_cap, type));
1708 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
1709 ret = ops->vidioc_g_sliced_vbi_cap(file, fh, p);
1711 dbgarg2("service_set=%d\n", p->service_set);
1714 case VIDIOC_LOG_STATUS:
1716 if (!ops->vidioc_log_status)
1718 ret = ops->vidioc_log_status(file, fh);
1721 #ifdef CONFIG_VIDEO_ADV_DEBUG
1722 case VIDIOC_DBG_G_REGISTER:
1724 struct v4l2_dbg_register *p = arg;
1726 if (!capable(CAP_SYS_ADMIN))
1728 else if (ops->vidioc_g_register)
1729 ret = ops->vidioc_g_register(file, fh, p);
1732 case VIDIOC_DBG_S_REGISTER:
1734 struct v4l2_dbg_register *p = arg;
1736 if (!capable(CAP_SYS_ADMIN))
1738 else if (ops->vidioc_s_register)
1739 ret = ops->vidioc_s_register(file, fh, p);
1743 case VIDIOC_DBG_G_CHIP_IDENT:
1745 struct v4l2_dbg_chip_ident *p = arg;
1747 if (!ops->vidioc_g_chip_ident)
1749 p->ident = V4L2_IDENT_NONE;
1751 ret = ops->vidioc_g_chip_ident(file, fh, p);
1753 dbgarg(cmd, "chip_ident=%u, revision=0x%x\n", p->ident, p->revision);
1756 case VIDIOC_S_HW_FREQ_SEEK:
1758 struct v4l2_hw_freq_seek *p = arg;
1760 if (!ops->vidioc_s_hw_freq_seek)
1763 "tuner=%d, type=%d, seek_upward=%d, wrap_around=%d\n",
1764 p->tuner, p->type, p->seek_upward, p->wrap_around);
1765 ret = ops->vidioc_s_hw_freq_seek(file, fh, p);
1768 case VIDIOC_ENUM_FRAMESIZES:
1770 struct v4l2_frmsizeenum *p = arg;
1772 if (!ops->vidioc_enum_framesizes)
1775 ret = ops->vidioc_enum_framesizes(file, fh, p);
1777 "index=%d, pixelformat=%c%c%c%c, type=%d ",
1779 (p->pixel_format & 0xff),
1780 (p->pixel_format >> 8) & 0xff,
1781 (p->pixel_format >> 16) & 0xff,
1782 (p->pixel_format >> 24) & 0xff,
1785 case V4L2_FRMSIZE_TYPE_DISCRETE:
1786 dbgarg3("width = %d, height=%d\n",
1787 p->discrete.width, p->discrete.height);
1789 case V4L2_FRMSIZE_TYPE_STEPWISE:
1790 dbgarg3("min %dx%d, max %dx%d, step %dx%d\n",
1791 p->stepwise.min_width, p->stepwise.min_height,
1792 p->stepwise.step_width, p->stepwise.step_height,
1793 p->stepwise.max_width, p->stepwise.max_height);
1795 case V4L2_FRMSIZE_TYPE_CONTINUOUS:
1796 dbgarg3("continuous\n");
1799 dbgarg3("- Unknown type!\n");
1804 case VIDIOC_ENUM_FRAMEINTERVALS:
1806 struct v4l2_frmivalenum *p = arg;
1808 if (!ops->vidioc_enum_frameintervals)
1811 ret = ops->vidioc_enum_frameintervals(file, fh, p);
1813 "index=%d, pixelformat=%d, width=%d, height=%d, type=%d ",
1814 p->index, p->pixel_format,
1815 p->width, p->height, p->type);
1817 case V4L2_FRMIVAL_TYPE_DISCRETE:
1818 dbgarg2("fps=%d/%d\n",
1819 p->discrete.numerator,
1820 p->discrete.denominator);
1822 case V4L2_FRMIVAL_TYPE_STEPWISE:
1823 dbgarg2("min=%d/%d, max=%d/%d, step=%d/%d\n",
1824 p->stepwise.min.numerator,
1825 p->stepwise.min.denominator,
1826 p->stepwise.max.numerator,
1827 p->stepwise.max.denominator,
1828 p->stepwise.step.numerator,
1829 p->stepwise.step.denominator);
1831 case V4L2_FRMIVAL_TYPE_CONTINUOUS:
1832 dbgarg2("continuous\n");
1835 dbgarg2("- Unknown type!\n");
1839 case VIDIOC_ENUM_DV_PRESETS:
1841 struct v4l2_dv_enum_preset *p = arg;
1843 if (!ops->vidioc_enum_dv_presets)
1846 ret = ops->vidioc_enum_dv_presets(file, fh, p);
1849 "index=%d, preset=%d, name=%s, width=%d,"
1851 p->index, p->preset, p->name, p->width,
1855 case VIDIOC_S_DV_PRESET:
1857 struct v4l2_dv_preset *p = arg;
1859 if (!ops->vidioc_s_dv_preset)
1862 dbgarg(cmd, "preset=%d\n", p->preset);
1863 ret = ops->vidioc_s_dv_preset(file, fh, p);
1866 case VIDIOC_G_DV_PRESET:
1868 struct v4l2_dv_preset *p = arg;
1870 if (!ops->vidioc_g_dv_preset)
1873 ret = ops->vidioc_g_dv_preset(file, fh, p);
1875 dbgarg(cmd, "preset=%d\n", p->preset);
1878 case VIDIOC_QUERY_DV_PRESET:
1880 struct v4l2_dv_preset *p = arg;
1882 if (!ops->vidioc_query_dv_preset)
1885 ret = ops->vidioc_query_dv_preset(file, fh, p);
1887 dbgarg(cmd, "preset=%d\n", p->preset);
1890 case VIDIOC_S_DV_TIMINGS:
1892 struct v4l2_dv_timings *p = arg;
1894 if (!ops->vidioc_s_dv_timings)
1898 case V4L2_DV_BT_656_1120:
1899 dbgarg2("bt-656/1120:interlaced=%d, pixelclock=%lld,"
1900 " width=%d, height=%d, polarities=%x,"
1901 " hfrontporch=%d, hsync=%d, hbackporch=%d,"
1902 " vfrontporch=%d, vsync=%d, vbackporch=%d,"
1903 " il_vfrontporch=%d, il_vsync=%d,"
1904 " il_vbackporch=%d\n",
1905 p->bt.interlaced, p->bt.pixelclock,
1906 p->bt.width, p->bt.height, p->bt.polarities,
1907 p->bt.hfrontporch, p->bt.hsync,
1908 p->bt.hbackporch, p->bt.vfrontporch,
1909 p->bt.vsync, p->bt.vbackporch,
1910 p->bt.il_vfrontporch, p->bt.il_vsync,
1911 p->bt.il_vbackporch);
1912 ret = ops->vidioc_s_dv_timings(file, fh, p);
1915 dbgarg2("Unknown type %d!\n", p->type);
1920 case VIDIOC_G_DV_TIMINGS:
1922 struct v4l2_dv_timings *p = arg;
1924 if (!ops->vidioc_g_dv_timings)
1927 ret = ops->vidioc_g_dv_timings(file, fh, p);
1930 case V4L2_DV_BT_656_1120:
1931 dbgarg2("bt-656/1120:interlaced=%d,"
1933 " width=%d, height=%d, polarities=%x,"
1934 " hfrontporch=%d, hsync=%d,"
1935 " hbackporch=%d, vfrontporch=%d,"
1936 " vsync=%d, vbackporch=%d,"
1937 " il_vfrontporch=%d, il_vsync=%d,"
1938 " il_vbackporch=%d\n",
1939 p->bt.interlaced, p->bt.pixelclock,
1940 p->bt.width, p->bt.height,
1941 p->bt.polarities, p->bt.hfrontporch,
1942 p->bt.hsync, p->bt.hbackporch,
1943 p->bt.vfrontporch, p->bt.vsync,
1944 p->bt.vbackporch, p->bt.il_vfrontporch,
1945 p->bt.il_vsync, p->bt.il_vbackporch);
1948 dbgarg2("Unknown type %d!\n", p->type);
1957 if (!ops->vidioc_default)
1959 ret = ops->vidioc_default(file, fh, cmd, arg);
1964 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) {
1966 v4l_print_ioctl(vfd->name, cmd);
1967 printk(KERN_CONT " error %ld\n", ret);
1974 /* In some cases, only a few fields are used as input, i.e. when the app sets
1975 * "index" and then the driver fills in the rest of the structure for the thing
1976 * with that index. We only need to copy up the first non-input field. */
1977 static unsigned long cmd_input_size(unsigned int cmd)
1979 /* Size of structure up to and including 'field' */
1980 #define CMDINSIZE(cmd, type, field) \
1981 case VIDIOC_##cmd: \
1982 return offsetof(struct v4l2_##type, field) + \
1983 sizeof(((struct v4l2_##type *)0)->field);
1986 CMDINSIZE(ENUM_FMT, fmtdesc, type);
1987 CMDINSIZE(G_FMT, format, type);
1988 CMDINSIZE(QUERYBUF, buffer, type);
1989 CMDINSIZE(G_PARM, streamparm, type);
1990 CMDINSIZE(ENUMSTD, standard, index);
1991 CMDINSIZE(ENUMINPUT, input, index);
1992 CMDINSIZE(G_CTRL, control, id);
1993 CMDINSIZE(G_TUNER, tuner, index);
1994 CMDINSIZE(QUERYCTRL, queryctrl, id);
1995 CMDINSIZE(QUERYMENU, querymenu, index);
1996 CMDINSIZE(ENUMOUTPUT, output, index);
1997 CMDINSIZE(G_MODULATOR, modulator, index);
1998 CMDINSIZE(G_FREQUENCY, frequency, tuner);
1999 CMDINSIZE(CROPCAP, cropcap, type);
2000 CMDINSIZE(G_CROP, crop, type);
2001 CMDINSIZE(ENUMAUDIO, audio, index);
2002 CMDINSIZE(ENUMAUDOUT, audioout, index);
2003 CMDINSIZE(ENCODER_CMD, encoder_cmd, flags);
2004 CMDINSIZE(TRY_ENCODER_CMD, encoder_cmd, flags);
2005 CMDINSIZE(G_SLICED_VBI_CAP, sliced_vbi_cap, type);
2006 CMDINSIZE(ENUM_FRAMESIZES, frmsizeenum, pixel_format);
2007 CMDINSIZE(ENUM_FRAMEINTERVALS, frmivalenum, height);
2009 return _IOC_SIZE(cmd);
2013 long video_ioctl2(struct file *file,
2014 unsigned int cmd, unsigned long arg)
2018 void *parg = (void *)arg;
2021 size_t ctrls_size = 0;
2022 void __user *user_ptr = NULL;
2024 #ifdef __OLD_VIDIOC_
2025 cmd = video_fix_command(cmd);
2027 is_ext_ctrl = (cmd == VIDIOC_S_EXT_CTRLS || cmd == VIDIOC_G_EXT_CTRLS ||
2028 cmd == VIDIOC_TRY_EXT_CTRLS);
2030 /* Copy arguments into temp kernel buffer */
2031 if (_IOC_DIR(cmd) != _IOC_NONE) {
2032 if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
2035 /* too big to allocate from stack */
2036 mbuf = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
2043 if (_IOC_DIR(cmd) & _IOC_WRITE) {
2044 unsigned long n = cmd_input_size(cmd);
2046 if (copy_from_user(parg, (void __user *)arg, n))
2049 /* zero out anything we don't copy from userspace */
2050 if (n < _IOC_SIZE(cmd))
2051 memset((u8 *)parg + n, 0, _IOC_SIZE(cmd) - n);
2053 /* read-only ioctl */
2054 memset(parg, 0, _IOC_SIZE(cmd));
2059 struct v4l2_ext_controls *p = parg;
2061 /* In case of an error, tell the caller that it wasn't
2062 a specific control that caused it. */
2063 p->error_idx = p->count;
2064 user_ptr = (void __user *)p->controls;
2066 ctrls_size = sizeof(struct v4l2_ext_control) * p->count;
2067 /* Note: v4l2_ext_controls fits in sbuf[] so mbuf is still NULL. */
2068 mbuf = kmalloc(ctrls_size, GFP_KERNEL);
2073 if (copy_from_user(mbuf, user_ptr, ctrls_size))
2080 err = __video_do_ioctl(file, cmd, parg);
2081 if (err == -ENOIOCTLCMD)
2084 struct v4l2_ext_controls *p = parg;
2086 p->controls = (void *)user_ptr;
2087 if (p->count && err == 0 && copy_to_user(user_ptr, mbuf, ctrls_size))
2095 /* Copy results into user buffer */
2096 switch (_IOC_DIR(cmd)) {
2098 case (_IOC_WRITE | _IOC_READ):
2099 if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
2108 EXPORT_SYMBOL(video_ioctl2);