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>
19 #include <linux/version.h>
21 #include <linux/videodev2.h>
23 #include <media/v4l2-common.h>
24 #include <media/v4l2-ioctl.h>
25 #include <media/v4l2-ctrls.h>
26 #include <media/v4l2-fh.h>
27 #include <media/v4l2-event.h>
28 #include <media/v4l2-device.h>
29 #include <media/v4l2-chip-ident.h>
30 #include <media/videobuf2-core.h>
32 /* Zero out the end of the struct pointed to by p. Everything after, but
33 * not including, the specified field is cleared. */
34 #define CLEAR_AFTER_FIELD(p, field) \
35 memset((u8 *)(p) + offsetof(typeof(*(p)), field) + sizeof((p)->field), \
36 0, sizeof(*(p)) - offsetof(typeof(*(p)), field) - sizeof((p)->field))
43 static const struct std_descr standards
[] = {
44 { V4L2_STD_NTSC
, "NTSC" },
45 { V4L2_STD_NTSC_M
, "NTSC-M" },
46 { V4L2_STD_NTSC_M_JP
, "NTSC-M-JP" },
47 { V4L2_STD_NTSC_M_KR
, "NTSC-M-KR" },
48 { V4L2_STD_NTSC_443
, "NTSC-443" },
49 { V4L2_STD_PAL
, "PAL" },
50 { V4L2_STD_PAL_BG
, "PAL-BG" },
51 { V4L2_STD_PAL_B
, "PAL-B" },
52 { V4L2_STD_PAL_B1
, "PAL-B1" },
53 { V4L2_STD_PAL_G
, "PAL-G" },
54 { V4L2_STD_PAL_H
, "PAL-H" },
55 { V4L2_STD_PAL_I
, "PAL-I" },
56 { V4L2_STD_PAL_DK
, "PAL-DK" },
57 { V4L2_STD_PAL_D
, "PAL-D" },
58 { V4L2_STD_PAL_D1
, "PAL-D1" },
59 { V4L2_STD_PAL_K
, "PAL-K" },
60 { V4L2_STD_PAL_M
, "PAL-M" },
61 { V4L2_STD_PAL_N
, "PAL-N" },
62 { V4L2_STD_PAL_Nc
, "PAL-Nc" },
63 { V4L2_STD_PAL_60
, "PAL-60" },
64 { V4L2_STD_SECAM
, "SECAM" },
65 { V4L2_STD_SECAM_B
, "SECAM-B" },
66 { V4L2_STD_SECAM_G
, "SECAM-G" },
67 { V4L2_STD_SECAM_H
, "SECAM-H" },
68 { V4L2_STD_SECAM_DK
, "SECAM-DK" },
69 { V4L2_STD_SECAM_D
, "SECAM-D" },
70 { V4L2_STD_SECAM_K
, "SECAM-K" },
71 { V4L2_STD_SECAM_K1
, "SECAM-K1" },
72 { V4L2_STD_SECAM_L
, "SECAM-L" },
73 { V4L2_STD_SECAM_LC
, "SECAM-Lc" },
77 /* video4linux standard ID conversion to standard name
79 const char *v4l2_norm_to_name(v4l2_std_id id
)
84 /* HACK: ppc32 architecture doesn't have __ucmpdi2 function to handle
85 64 bit comparations. So, on that architecture, with some gcc
86 variants, compilation fails. Currently, the max value is 30bit wide.
90 for (i
= 0; standards
[i
].std
; i
++)
91 if (myid
== standards
[i
].std
)
93 return standards
[i
].descr
;
95 EXPORT_SYMBOL(v4l2_norm_to_name
);
97 /* Returns frame period for the given standard */
98 void v4l2_video_std_frame_period(int id
, struct v4l2_fract
*frameperiod
)
100 if (id
& V4L2_STD_525_60
) {
101 frameperiod
->numerator
= 1001;
102 frameperiod
->denominator
= 30000;
104 frameperiod
->numerator
= 1;
105 frameperiod
->denominator
= 25;
108 EXPORT_SYMBOL(v4l2_video_std_frame_period
);
110 /* Fill in the fields of a v4l2_standard structure according to the
111 'id' and 'transmission' parameters. Returns negative on error. */
112 int v4l2_video_std_construct(struct v4l2_standard
*vs
,
113 int id
, const char *name
)
116 v4l2_video_std_frame_period(id
, &vs
->frameperiod
);
117 vs
->framelines
= (id
& V4L2_STD_525_60
) ? 525 : 625;
118 strlcpy(vs
->name
, name
, sizeof(vs
->name
));
121 EXPORT_SYMBOL(v4l2_video_std_construct
);
123 /* ----------------------------------------------------------------- */
124 /* some arrays for pretty-printing debug messages of enum types */
126 const char *v4l2_field_names
[] = {
127 [V4L2_FIELD_ANY
] = "any",
128 [V4L2_FIELD_NONE
] = "none",
129 [V4L2_FIELD_TOP
] = "top",
130 [V4L2_FIELD_BOTTOM
] = "bottom",
131 [V4L2_FIELD_INTERLACED
] = "interlaced",
132 [V4L2_FIELD_SEQ_TB
] = "seq-tb",
133 [V4L2_FIELD_SEQ_BT
] = "seq-bt",
134 [V4L2_FIELD_ALTERNATE
] = "alternate",
135 [V4L2_FIELD_INTERLACED_TB
] = "interlaced-tb",
136 [V4L2_FIELD_INTERLACED_BT
] = "interlaced-bt",
138 EXPORT_SYMBOL(v4l2_field_names
);
140 const char *v4l2_type_names
[] = {
141 [V4L2_BUF_TYPE_VIDEO_CAPTURE
] = "vid-cap",
142 [V4L2_BUF_TYPE_VIDEO_OVERLAY
] = "vid-overlay",
143 [V4L2_BUF_TYPE_VIDEO_OUTPUT
] = "vid-out",
144 [V4L2_BUF_TYPE_VBI_CAPTURE
] = "vbi-cap",
145 [V4L2_BUF_TYPE_VBI_OUTPUT
] = "vbi-out",
146 [V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
] = "sliced-vbi-cap",
147 [V4L2_BUF_TYPE_SLICED_VBI_OUTPUT
] = "sliced-vbi-out",
148 [V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY
] = "vid-out-overlay",
149 [V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
] = "vid-cap-mplane",
150 [V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
] = "vid-out-mplane",
152 EXPORT_SYMBOL(v4l2_type_names
);
154 static const char *v4l2_memory_names
[] = {
155 [V4L2_MEMORY_MMAP
] = "mmap",
156 [V4L2_MEMORY_USERPTR
] = "userptr",
157 [V4L2_MEMORY_OVERLAY
] = "overlay",
160 #define prt_names(a, arr) ((((a) >= 0) && ((a) < ARRAY_SIZE(arr))) ? \
163 /* ------------------------------------------------------------------ */
164 /* debug help functions */
166 static void v4l_print_querycap(const void *arg
, bool write_only
)
168 const struct v4l2_capability
*p
= arg
;
170 pr_cont("driver=%s, card=%s, bus=%s, version=0x%08x, "
171 "capabilities=0x%08x, device_caps=0x%08x\n",
172 p
->driver
, p
->card
, p
->bus_info
,
173 p
->version
, p
->capabilities
, p
->device_caps
);
176 static void v4l_print_enuminput(const void *arg
, bool write_only
)
178 const struct v4l2_input
*p
= arg
;
180 pr_cont("index=%u, name=%s, type=%u, audioset=0x%x, tuner=%u, "
181 "std=0x%08Lx, status=0x%x, capabilities=0x%x\n",
182 p
->index
, p
->name
, p
->type
, p
->audioset
, p
->tuner
,
183 (unsigned long long)p
->std
, p
->status
, p
->capabilities
);
186 static void v4l_print_enumoutput(const void *arg
, bool write_only
)
188 const struct v4l2_output
*p
= arg
;
190 pr_cont("index=%u, name=%s, type=%u, audioset=0x%x, "
191 "modulator=%u, std=0x%08Lx, capabilities=0x%x\n",
192 p
->index
, p
->name
, p
->type
, p
->audioset
, p
->modulator
,
193 (unsigned long long)p
->std
, p
->capabilities
);
196 static void v4l_print_audio(const void *arg
, bool write_only
)
198 const struct v4l2_audio
*p
= arg
;
201 pr_cont("index=%u, mode=0x%x\n", p
->index
, p
->mode
);
203 pr_cont("index=%u, name=%s, capability=0x%x, mode=0x%x\n",
204 p
->index
, p
->name
, p
->capability
, p
->mode
);
207 static void v4l_print_audioout(const void *arg
, bool write_only
)
209 const struct v4l2_audioout
*p
= arg
;
212 pr_cont("index=%u\n", p
->index
);
214 pr_cont("index=%u, name=%s, capability=0x%x, mode=0x%x\n",
215 p
->index
, p
->name
, p
->capability
, p
->mode
);
218 static void v4l_print_fmtdesc(const void *arg
, bool write_only
)
220 const struct v4l2_fmtdesc
*p
= arg
;
222 pr_cont("index=%u, type=%s, flags=0x%x, pixelformat=%c%c%c%c, description='%s'\n",
223 p
->index
, prt_names(p
->type
, v4l2_type_names
),
224 p
->flags
, (p
->pixelformat
& 0xff),
225 (p
->pixelformat
>> 8) & 0xff,
226 (p
->pixelformat
>> 16) & 0xff,
227 (p
->pixelformat
>> 24) & 0xff,
231 static void v4l_print_format(const void *arg
, bool write_only
)
233 const struct v4l2_format
*p
= arg
;
234 const struct v4l2_pix_format
*pix
;
235 const struct v4l2_pix_format_mplane
*mp
;
236 const struct v4l2_vbi_format
*vbi
;
237 const struct v4l2_sliced_vbi_format
*sliced
;
238 const struct v4l2_window
*win
;
239 const struct v4l2_clip
*clip
;
242 pr_cont("type=%s", prt_names(p
->type
, v4l2_type_names
));
244 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
245 case V4L2_BUF_TYPE_VIDEO_OUTPUT
:
247 pr_cont(", width=%u, height=%u, "
248 "pixelformat=%c%c%c%c, field=%s, "
249 "bytesperline=%u sizeimage=%u, colorspace=%d\n",
250 pix
->width
, pix
->height
,
251 (pix
->pixelformat
& 0xff),
252 (pix
->pixelformat
>> 8) & 0xff,
253 (pix
->pixelformat
>> 16) & 0xff,
254 (pix
->pixelformat
>> 24) & 0xff,
255 prt_names(pix
->field
, v4l2_field_names
),
256 pix
->bytesperline
, pix
->sizeimage
,
259 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
:
260 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
:
262 pr_cont(", width=%u, height=%u, "
263 "format=%c%c%c%c, field=%s, "
264 "colorspace=%d, num_planes=%u\n",
265 mp
->width
, mp
->height
,
266 (mp
->pixelformat
& 0xff),
267 (mp
->pixelformat
>> 8) & 0xff,
268 (mp
->pixelformat
>> 16) & 0xff,
269 (mp
->pixelformat
>> 24) & 0xff,
270 prt_names(mp
->field
, v4l2_field_names
),
271 mp
->colorspace
, mp
->num_planes
);
272 for (i
= 0; i
< mp
->num_planes
; i
++)
273 printk(KERN_DEBUG
"plane %u: bytesperline=%u sizeimage=%u\n", i
,
274 mp
->plane_fmt
[i
].bytesperline
,
275 mp
->plane_fmt
[i
].sizeimage
);
277 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
278 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY
:
280 pr_cont(", wxh=%dx%d, x,y=%d,%d, field=%s, "
281 "chromakey=0x%08x, bitmap=%p, "
282 "global_alpha=0x%02x\n",
283 win
->w
.width
, win
->w
.height
,
284 win
->w
.left
, win
->w
.top
,
285 prt_names(win
->field
, v4l2_field_names
),
286 win
->chromakey
, win
->bitmap
, win
->global_alpha
);
288 for (i
= 0; i
< win
->clipcount
; i
++) {
289 printk(KERN_DEBUG
"clip %u: wxh=%dx%d, x,y=%d,%d\n",
290 i
, clip
->c
.width
, clip
->c
.height
,
291 clip
->c
.left
, clip
->c
.top
);
295 case V4L2_BUF_TYPE_VBI_CAPTURE
:
296 case V4L2_BUF_TYPE_VBI_OUTPUT
:
298 pr_cont(", sampling_rate=%u, offset=%u, samples_per_line=%u, "
299 "sample_format=%c%c%c%c, start=%u,%u, count=%u,%u\n",
300 vbi
->sampling_rate
, vbi
->offset
,
301 vbi
->samples_per_line
,
302 (vbi
->sample_format
& 0xff),
303 (vbi
->sample_format
>> 8) & 0xff,
304 (vbi
->sample_format
>> 16) & 0xff,
305 (vbi
->sample_format
>> 24) & 0xff,
306 vbi
->start
[0], vbi
->start
[1],
307 vbi
->count
[0], vbi
->count
[1]);
309 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
:
310 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT
:
311 sliced
= &p
->fmt
.sliced
;
312 pr_cont(", service_set=0x%08x, io_size=%d\n",
313 sliced
->service_set
, sliced
->io_size
);
314 for (i
= 0; i
< 24; i
++)
315 printk(KERN_DEBUG
"line[%02u]=0x%04x, 0x%04x\n", i
,
316 sliced
->service_lines
[0][i
],
317 sliced
->service_lines
[1][i
]);
319 case V4L2_BUF_TYPE_PRIVATE
:
325 static void v4l_print_framebuffer(const void *arg
, bool write_only
)
327 const struct v4l2_framebuffer
*p
= arg
;
329 pr_cont("capability=0x%x, flags=0x%x, base=0x%p, width=%u, "
330 "height=%u, pixelformat=%c%c%c%c, "
331 "bytesperline=%u sizeimage=%u, colorspace=%d\n",
332 p
->capability
, p
->flags
, p
->base
,
333 p
->fmt
.width
, p
->fmt
.height
,
334 (p
->fmt
.pixelformat
& 0xff),
335 (p
->fmt
.pixelformat
>> 8) & 0xff,
336 (p
->fmt
.pixelformat
>> 16) & 0xff,
337 (p
->fmt
.pixelformat
>> 24) & 0xff,
338 p
->fmt
.bytesperline
, p
->fmt
.sizeimage
,
342 static void v4l_print_buftype(const void *arg
, bool write_only
)
344 pr_cont("type=%s\n", prt_names(*(u32
*)arg
, v4l2_type_names
));
347 static void v4l_print_modulator(const void *arg
, bool write_only
)
349 const struct v4l2_modulator
*p
= arg
;
352 pr_cont("index=%u, txsubchans=0x%x", p
->index
, p
->txsubchans
);
354 pr_cont("index=%u, name=%s, capability=0x%x, "
355 "rangelow=%u, rangehigh=%u, txsubchans=0x%x\n",
356 p
->index
, p
->name
, p
->capability
,
357 p
->rangelow
, p
->rangehigh
, p
->txsubchans
);
360 static void v4l_print_tuner(const void *arg
, bool write_only
)
362 const struct v4l2_tuner
*p
= arg
;
365 pr_cont("index=%u, audmode=%u\n", p
->index
, p
->audmode
);
367 pr_cont("index=%u, name=%s, type=%u, capability=0x%x, "
368 "rangelow=%u, rangehigh=%u, signal=%u, afc=%d, "
369 "rxsubchans=0x%x, audmode=%u\n",
370 p
->index
, p
->name
, p
->type
,
371 p
->capability
, p
->rangelow
,
372 p
->rangehigh
, p
->signal
, p
->afc
,
373 p
->rxsubchans
, p
->audmode
);
376 static void v4l_print_frequency(const void *arg
, bool write_only
)
378 const struct v4l2_frequency
*p
= arg
;
380 pr_cont("tuner=%u, type=%u, frequency=%u\n",
381 p
->tuner
, p
->type
, p
->frequency
);
384 static void v4l_print_standard(const void *arg
, bool write_only
)
386 const struct v4l2_standard
*p
= arg
;
388 pr_cont("index=%u, id=0x%Lx, name=%s, fps=%u/%u, "
389 "framelines=%u\n", p
->index
,
390 (unsigned long long)p
->id
, p
->name
,
391 p
->frameperiod
.numerator
,
392 p
->frameperiod
.denominator
,
396 static void v4l_print_std(const void *arg
, bool write_only
)
398 pr_cont("std=0x%08Lx\n", *(const long long unsigned *)arg
);
401 static void v4l_print_hw_freq_seek(const void *arg
, bool write_only
)
403 const struct v4l2_hw_freq_seek
*p
= arg
;
405 pr_cont("tuner=%u, type=%u, seek_upward=%u, wrap_around=%u, spacing=%u\n",
406 p
->tuner
, p
->type
, p
->seek_upward
, p
->wrap_around
, p
->spacing
);
409 static void v4l_print_requestbuffers(const void *arg
, bool write_only
)
411 const struct v4l2_requestbuffers
*p
= arg
;
413 pr_cont("count=%d, type=%s, memory=%s\n",
415 prt_names(p
->type
, v4l2_type_names
),
416 prt_names(p
->memory
, v4l2_memory_names
));
419 static void v4l_print_buffer(const void *arg
, bool write_only
)
421 const struct v4l2_buffer
*p
= arg
;
422 const struct v4l2_timecode
*tc
= &p
->timecode
;
423 const struct v4l2_plane
*plane
;
426 pr_cont("%02ld:%02d:%02d.%08ld index=%d, type=%s, "
427 "flags=0x%08x, field=%s, sequence=%d, memory=%s",
428 p
->timestamp
.tv_sec
/ 3600,
429 (int)(p
->timestamp
.tv_sec
/ 60) % 60,
430 (int)(p
->timestamp
.tv_sec
% 60),
431 (long)p
->timestamp
.tv_usec
,
433 prt_names(p
->type
, v4l2_type_names
),
434 p
->flags
, prt_names(p
->field
, v4l2_field_names
),
435 p
->sequence
, prt_names(p
->memory
, v4l2_memory_names
));
437 if (V4L2_TYPE_IS_MULTIPLANAR(p
->type
) && p
->m
.planes
) {
439 for (i
= 0; i
< p
->length
; ++i
) {
440 plane
= &p
->m
.planes
[i
];
442 "plane %d: bytesused=%d, data_offset=0x%08x "
443 "offset/userptr=0x%lx, length=%d\n",
444 i
, plane
->bytesused
, plane
->data_offset
,
445 plane
->m
.userptr
, plane
->length
);
448 pr_cont("bytesused=%d, offset/userptr=0x%lx, length=%d\n",
449 p
->bytesused
, p
->m
.userptr
, p
->length
);
452 printk(KERN_DEBUG
"timecode=%02d:%02d:%02d type=%d, "
453 "flags=0x%08x, frames=%d, userbits=0x%08x\n",
454 tc
->hours
, tc
->minutes
, tc
->seconds
,
455 tc
->type
, tc
->flags
, tc
->frames
, *(__u32
*)tc
->userbits
);
458 static void v4l_print_create_buffers(const void *arg
, bool write_only
)
460 const struct v4l2_create_buffers
*p
= arg
;
462 pr_cont("index=%d, count=%d, memory=%s, ",
464 prt_names(p
->memory
, v4l2_memory_names
));
465 v4l_print_format(&p
->format
, write_only
);
468 static void v4l_print_streamparm(const void *arg
, bool write_only
)
470 const struct v4l2_streamparm
*p
= arg
;
472 pr_cont("type=%s", prt_names(p
->type
, v4l2_type_names
));
474 if (p
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
||
475 p
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
476 const struct v4l2_captureparm
*c
= &p
->parm
.capture
;
478 pr_cont(", capability=0x%x, capturemode=0x%x, timeperframe=%d/%d, "
479 "extendedmode=%d, readbuffers=%d\n",
480 c
->capability
, c
->capturemode
,
481 c
->timeperframe
.numerator
, c
->timeperframe
.denominator
,
482 c
->extendedmode
, c
->readbuffers
);
483 } else if (p
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
||
484 p
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
485 const struct v4l2_outputparm
*c
= &p
->parm
.output
;
487 pr_cont(", capability=0x%x, outputmode=0x%x, timeperframe=%d/%d, "
488 "extendedmode=%d, writebuffers=%d\n",
489 c
->capability
, c
->outputmode
,
490 c
->timeperframe
.numerator
, c
->timeperframe
.denominator
,
491 c
->extendedmode
, c
->writebuffers
);
495 static void v4l_print_queryctrl(const void *arg
, bool write_only
)
497 const struct v4l2_queryctrl
*p
= arg
;
499 pr_cont("id=0x%x, type=%d, name=%s, min/max=%d/%d, "
500 "step=%d, default=%d, flags=0x%08x\n",
501 p
->id
, p
->type
, p
->name
,
502 p
->minimum
, p
->maximum
,
503 p
->step
, p
->default_value
, p
->flags
);
506 static void v4l_print_querymenu(const void *arg
, bool write_only
)
508 const struct v4l2_querymenu
*p
= arg
;
510 pr_cont("id=0x%x, index=%d\n", p
->id
, p
->index
);
513 static void v4l_print_control(const void *arg
, bool write_only
)
515 const struct v4l2_control
*p
= arg
;
517 pr_cont("id=0x%x, value=%d\n", p
->id
, p
->value
);
520 static void v4l_print_ext_controls(const void *arg
, bool write_only
)
522 const struct v4l2_ext_controls
*p
= arg
;
525 pr_cont("class=0x%x, count=%d, error_idx=%d",
526 p
->ctrl_class
, p
->count
, p
->error_idx
);
527 for (i
= 0; i
< p
->count
; i
++) {
528 if (p
->controls
[i
].size
)
529 pr_cont(", id/val=0x%x/0x%x",
530 p
->controls
[i
].id
, p
->controls
[i
].value
);
532 pr_cont(", id/size=0x%x/%u",
533 p
->controls
[i
].id
, p
->controls
[i
].size
);
538 static void v4l_print_cropcap(const void *arg
, bool write_only
)
540 const struct v4l2_cropcap
*p
= arg
;
542 pr_cont("type=%s, bounds wxh=%dx%d, x,y=%d,%d, "
543 "defrect wxh=%dx%d, x,y=%d,%d\n, "
544 "pixelaspect %d/%d\n",
545 prt_names(p
->type
, v4l2_type_names
),
546 p
->bounds
.width
, p
->bounds
.height
,
547 p
->bounds
.left
, p
->bounds
.top
,
548 p
->defrect
.width
, p
->defrect
.height
,
549 p
->defrect
.left
, p
->defrect
.top
,
550 p
->pixelaspect
.numerator
, p
->pixelaspect
.denominator
);
553 static void v4l_print_crop(const void *arg
, bool write_only
)
555 const struct v4l2_crop
*p
= arg
;
557 pr_cont("type=%s, wxh=%dx%d, x,y=%d,%d\n",
558 prt_names(p
->type
, v4l2_type_names
),
559 p
->c
.width
, p
->c
.height
,
560 p
->c
.left
, p
->c
.top
);
563 static void v4l_print_selection(const void *arg
, bool write_only
)
565 const struct v4l2_selection
*p
= arg
;
567 pr_cont("type=%s, target=%d, flags=0x%x, wxh=%dx%d, x,y=%d,%d\n",
568 prt_names(p
->type
, v4l2_type_names
),
570 p
->r
.width
, p
->r
.height
, p
->r
.left
, p
->r
.top
);
573 static void v4l_print_jpegcompression(const void *arg
, bool write_only
)
575 const struct v4l2_jpegcompression
*p
= arg
;
577 pr_cont("quality=%d, APPn=%d, APP_len=%d, "
578 "COM_len=%d, jpeg_markers=0x%x\n",
579 p
->quality
, p
->APPn
, p
->APP_len
,
580 p
->COM_len
, p
->jpeg_markers
);
583 static void v4l_print_enc_idx(const void *arg
, bool write_only
)
585 const struct v4l2_enc_idx
*p
= arg
;
587 pr_cont("entries=%d, entries_cap=%d\n",
588 p
->entries
, p
->entries_cap
);
591 static void v4l_print_encoder_cmd(const void *arg
, bool write_only
)
593 const struct v4l2_encoder_cmd
*p
= arg
;
595 pr_cont("cmd=%d, flags=0x%x\n",
599 static void v4l_print_decoder_cmd(const void *arg
, bool write_only
)
601 const struct v4l2_decoder_cmd
*p
= arg
;
603 pr_cont("cmd=%d, flags=0x%x\n", p
->cmd
, p
->flags
);
605 if (p
->cmd
== V4L2_DEC_CMD_START
)
606 pr_info("speed=%d, format=%u\n",
607 p
->start
.speed
, p
->start
.format
);
608 else if (p
->cmd
== V4L2_DEC_CMD_STOP
)
609 pr_info("pts=%llu\n", p
->stop
.pts
);
612 static void v4l_print_dbg_chip_ident(const void *arg
, bool write_only
)
614 const struct v4l2_dbg_chip_ident
*p
= arg
;
616 pr_cont("type=%u, ", p
->match
.type
);
617 if (p
->match
.type
== V4L2_CHIP_MATCH_I2C_DRIVER
)
618 pr_cont("name=%s, ", p
->match
.name
);
620 pr_cont("addr=%u, ", p
->match
.addr
);
621 pr_cont("chip_ident=%u, revision=0x%x\n",
622 p
->ident
, p
->revision
);
625 static void v4l_print_dbg_register(const void *arg
, bool write_only
)
627 const struct v4l2_dbg_register
*p
= arg
;
629 pr_cont("type=%u, ", p
->match
.type
);
630 if (p
->match
.type
== V4L2_CHIP_MATCH_I2C_DRIVER
)
631 pr_cont("name=%s, ", p
->match
.name
);
633 pr_cont("addr=%u, ", p
->match
.addr
);
634 pr_cont("reg=0x%llx, val=0x%llx\n",
638 static void v4l_print_dv_enum_presets(const void *arg
, bool write_only
)
640 const struct v4l2_dv_enum_preset
*p
= arg
;
642 pr_cont("index=%u, preset=%u, name=%s, width=%u, height=%u\n",
643 p
->index
, p
->preset
, p
->name
, p
->width
, p
->height
);
646 static void v4l_print_dv_preset(const void *arg
, bool write_only
)
648 const struct v4l2_dv_preset
*p
= arg
;
650 pr_cont("preset=%u\n", p
->preset
);
653 static void v4l_print_dv_timings(const void *arg
, bool write_only
)
655 const struct v4l2_dv_timings
*p
= arg
;
658 case V4L2_DV_BT_656_1120
:
659 pr_cont("type=bt-656/1120, interlaced=%u, "
661 "width=%u, height=%u, polarities=0x%x, "
662 "hfrontporch=%u, hsync=%u, "
663 "hbackporch=%u, vfrontporch=%u, "
664 "vsync=%u, vbackporch=%u, "
665 "il_vfrontporch=%u, il_vsync=%u, "
666 "il_vbackporch=%u, standards=0x%x, flags=0x%x\n",
667 p
->bt
.interlaced
, p
->bt
.pixelclock
,
668 p
->bt
.width
, p
->bt
.height
,
669 p
->bt
.polarities
, p
->bt
.hfrontporch
,
670 p
->bt
.hsync
, p
->bt
.hbackporch
,
671 p
->bt
.vfrontporch
, p
->bt
.vsync
,
672 p
->bt
.vbackporch
, p
->bt
.il_vfrontporch
,
673 p
->bt
.il_vsync
, p
->bt
.il_vbackporch
,
674 p
->bt
.standards
, p
->bt
.flags
);
677 pr_cont("type=%d\n", p
->type
);
682 static void v4l_print_enum_dv_timings(const void *arg
, bool write_only
)
684 const struct v4l2_enum_dv_timings
*p
= arg
;
686 pr_cont("index=%u, ", p
->index
);
687 v4l_print_dv_timings(&p
->timings
, write_only
);
690 static void v4l_print_dv_timings_cap(const void *arg
, bool write_only
)
692 const struct v4l2_dv_timings_cap
*p
= arg
;
695 case V4L2_DV_BT_656_1120
:
696 pr_cont("type=bt-656/1120, width=%u-%u, height=%u-%u, "
697 "pixelclock=%llu-%llu, standards=0x%x, capabilities=0x%x\n",
698 p
->bt
.min_width
, p
->bt
.max_width
,
699 p
->bt
.min_height
, p
->bt
.max_height
,
700 p
->bt
.min_pixelclock
, p
->bt
.max_pixelclock
,
701 p
->bt
.standards
, p
->bt
.capabilities
);
704 pr_cont("type=%u\n", p
->type
);
709 static void v4l_print_frmsizeenum(const void *arg
, bool write_only
)
711 const struct v4l2_frmsizeenum
*p
= arg
;
713 pr_cont("index=%u, pixelformat=%c%c%c%c, type=%u",
715 (p
->pixel_format
& 0xff),
716 (p
->pixel_format
>> 8) & 0xff,
717 (p
->pixel_format
>> 16) & 0xff,
718 (p
->pixel_format
>> 24) & 0xff,
721 case V4L2_FRMSIZE_TYPE_DISCRETE
:
722 pr_cont(" wxh=%ux%u\n",
723 p
->discrete
.width
, p
->discrete
.height
);
725 case V4L2_FRMSIZE_TYPE_STEPWISE
:
726 pr_cont(" min=%ux%u, max=%ux%u, step=%ux%u\n",
727 p
->stepwise
.min_width
, p
->stepwise
.min_height
,
728 p
->stepwise
.step_width
, p
->stepwise
.step_height
,
729 p
->stepwise
.max_width
, p
->stepwise
.max_height
);
731 case V4L2_FRMSIZE_TYPE_CONTINUOUS
:
739 static void v4l_print_frmivalenum(const void *arg
, bool write_only
)
741 const struct v4l2_frmivalenum
*p
= arg
;
743 pr_cont("index=%u, pixelformat=%c%c%c%c, wxh=%ux%u, type=%u",
745 (p
->pixel_format
& 0xff),
746 (p
->pixel_format
>> 8) & 0xff,
747 (p
->pixel_format
>> 16) & 0xff,
748 (p
->pixel_format
>> 24) & 0xff,
749 p
->width
, p
->height
, p
->type
);
751 case V4L2_FRMIVAL_TYPE_DISCRETE
:
752 pr_cont(" fps=%d/%d\n",
753 p
->discrete
.numerator
,
754 p
->discrete
.denominator
);
756 case V4L2_FRMIVAL_TYPE_STEPWISE
:
757 pr_cont(" min=%d/%d, max=%d/%d, step=%d/%d\n",
758 p
->stepwise
.min
.numerator
,
759 p
->stepwise
.min
.denominator
,
760 p
->stepwise
.max
.numerator
,
761 p
->stepwise
.max
.denominator
,
762 p
->stepwise
.step
.numerator
,
763 p
->stepwise
.step
.denominator
);
765 case V4L2_FRMIVAL_TYPE_CONTINUOUS
:
773 static void v4l_print_event(const void *arg
, bool write_only
)
775 const struct v4l2_event
*p
= arg
;
776 const struct v4l2_event_ctrl
*c
;
778 pr_cont("type=0x%x, pending=%u, sequence=%u, id=%u, "
779 "timestamp=%lu.%9.9lu\n",
780 p
->type
, p
->pending
, p
->sequence
, p
->id
,
781 p
->timestamp
.tv_sec
, p
->timestamp
.tv_nsec
);
783 case V4L2_EVENT_VSYNC
:
784 printk(KERN_DEBUG
"field=%s\n",
785 prt_names(p
->u
.vsync
.field
, v4l2_field_names
));
787 case V4L2_EVENT_CTRL
:
789 printk(KERN_DEBUG
"changes=0x%x, type=%u, ",
790 c
->changes
, c
->type
);
791 if (c
->type
== V4L2_CTRL_TYPE_INTEGER64
)
792 pr_cont("value64=%lld, ", c
->value64
);
794 pr_cont("value=%d, ", c
->value
);
795 pr_cont("flags=0x%x, minimum=%d, maximum=%d, step=%d,"
796 " default_value=%d\n",
797 c
->flags
, c
->minimum
, c
->maximum
,
798 c
->step
, c
->default_value
);
800 case V4L2_EVENT_FRAME_SYNC
:
801 pr_cont("frame_sequence=%u\n",
802 p
->u
.frame_sync
.frame_sequence
);
807 static void v4l_print_event_subscription(const void *arg
, bool write_only
)
809 const struct v4l2_event_subscription
*p
= arg
;
811 pr_cont("type=0x%x, id=0x%x, flags=0x%x\n",
812 p
->type
, p
->id
, p
->flags
);
815 static void v4l_print_sliced_vbi_cap(const void *arg
, bool write_only
)
817 const struct v4l2_sliced_vbi_cap
*p
= arg
;
820 pr_cont("type=%s, service_set=0x%08x\n",
821 prt_names(p
->type
, v4l2_type_names
), p
->service_set
);
822 for (i
= 0; i
< 24; i
++)
823 printk(KERN_DEBUG
"line[%02u]=0x%04x, 0x%04x\n", i
,
824 p
->service_lines
[0][i
],
825 p
->service_lines
[1][i
]);
828 static void v4l_print_u32(const void *arg
, bool write_only
)
830 pr_cont("value=%u\n", *(const u32
*)arg
);
833 static void v4l_print_newline(const void *arg
, bool write_only
)
838 static void v4l_print_default(const void *arg
, bool write_only
)
840 pr_cont("driver-specific ioctl\n");
843 static int check_ext_ctrls(struct v4l2_ext_controls
*c
, int allow_priv
)
847 /* zero the reserved fields */
848 c
->reserved
[0] = c
->reserved
[1] = 0;
849 for (i
= 0; i
< c
->count
; i
++)
850 c
->controls
[i
].reserved2
[0] = 0;
852 /* V4L2_CID_PRIVATE_BASE cannot be used as control class
853 when using extended controls.
854 Only when passed in through VIDIOC_G_CTRL and VIDIOC_S_CTRL
855 is it allowed for backwards compatibility.
857 if (!allow_priv
&& c
->ctrl_class
== V4L2_CID_PRIVATE_BASE
)
859 /* Check that all controls are from the same control class. */
860 for (i
= 0; i
< c
->count
; i
++) {
861 if (V4L2_CTRL_ID2CLASS(c
->controls
[i
].id
) != c
->ctrl_class
) {
869 static int check_fmt(const struct v4l2_ioctl_ops
*ops
, enum v4l2_buf_type type
)
875 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
876 if (ops
->vidioc_g_fmt_vid_cap
||
877 ops
->vidioc_g_fmt_vid_cap_mplane
)
880 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
:
881 if (ops
->vidioc_g_fmt_vid_cap_mplane
)
884 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
885 if (ops
->vidioc_g_fmt_vid_overlay
)
888 case V4L2_BUF_TYPE_VIDEO_OUTPUT
:
889 if (ops
->vidioc_g_fmt_vid_out
||
890 ops
->vidioc_g_fmt_vid_out_mplane
)
893 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
:
894 if (ops
->vidioc_g_fmt_vid_out_mplane
)
897 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY
:
898 if (ops
->vidioc_g_fmt_vid_out_overlay
)
901 case V4L2_BUF_TYPE_VBI_CAPTURE
:
902 if (ops
->vidioc_g_fmt_vbi_cap
)
905 case V4L2_BUF_TYPE_VBI_OUTPUT
:
906 if (ops
->vidioc_g_fmt_vbi_out
)
909 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
:
910 if (ops
->vidioc_g_fmt_sliced_vbi_cap
)
913 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT
:
914 if (ops
->vidioc_g_fmt_sliced_vbi_out
)
917 case V4L2_BUF_TYPE_PRIVATE
:
918 if (ops
->vidioc_g_fmt_type_private
)
925 static int v4l_querycap(const struct v4l2_ioctl_ops
*ops
,
926 struct file
*file
, void *fh
, void *arg
)
928 struct v4l2_capability
*cap
= (struct v4l2_capability
*)arg
;
930 cap
->version
= LINUX_VERSION_CODE
;
931 return ops
->vidioc_querycap(file
, fh
, cap
);
934 static int v4l_s_input(const struct v4l2_ioctl_ops
*ops
,
935 struct file
*file
, void *fh
, void *arg
)
937 return ops
->vidioc_s_input(file
, fh
, *(unsigned int *)arg
);
940 static int v4l_s_output(const struct v4l2_ioctl_ops
*ops
,
941 struct file
*file
, void *fh
, void *arg
)
943 return ops
->vidioc_s_output(file
, fh
, *(unsigned int *)arg
);
946 static int v4l_g_priority(const struct v4l2_ioctl_ops
*ops
,
947 struct file
*file
, void *fh
, void *arg
)
949 struct video_device
*vfd
;
952 if (ops
->vidioc_g_priority
)
953 return ops
->vidioc_g_priority(file
, fh
, arg
);
954 vfd
= video_devdata(file
);
955 *p
= v4l2_prio_max(&vfd
->v4l2_dev
->prio
);
959 static int v4l_s_priority(const struct v4l2_ioctl_ops
*ops
,
960 struct file
*file
, void *fh
, void *arg
)
962 struct video_device
*vfd
;
966 if (ops
->vidioc_s_priority
)
967 return ops
->vidioc_s_priority(file
, fh
, *p
);
968 vfd
= video_devdata(file
);
969 vfh
= file
->private_data
;
970 return v4l2_prio_change(&vfd
->v4l2_dev
->prio
, &vfh
->prio
, *p
);
973 static int v4l_enuminput(const struct v4l2_ioctl_ops
*ops
,
974 struct file
*file
, void *fh
, void *arg
)
976 struct v4l2_input
*p
= arg
;
979 * We set the flags for CAP_PRESETS, CAP_CUSTOM_TIMINGS &
980 * CAP_STD here based on ioctl handler provided by the
981 * driver. If the driver doesn't support these
982 * for a specific input, it must override these flags.
984 if (ops
->vidioc_s_std
)
985 p
->capabilities
|= V4L2_IN_CAP_STD
;
986 if (ops
->vidioc_s_dv_preset
)
987 p
->capabilities
|= V4L2_IN_CAP_PRESETS
;
988 if (ops
->vidioc_s_dv_timings
)
989 p
->capabilities
|= V4L2_IN_CAP_CUSTOM_TIMINGS
;
991 return ops
->vidioc_enum_input(file
, fh
, p
);
994 static int v4l_enumoutput(const struct v4l2_ioctl_ops
*ops
,
995 struct file
*file
, void *fh
, void *arg
)
997 struct v4l2_output
*p
= arg
;
1000 * We set the flags for CAP_PRESETS, CAP_CUSTOM_TIMINGS &
1001 * CAP_STD here based on ioctl handler provided by the
1002 * driver. If the driver doesn't support these
1003 * for a specific output, it must override these flags.
1005 if (ops
->vidioc_s_std
)
1006 p
->capabilities
|= V4L2_OUT_CAP_STD
;
1007 if (ops
->vidioc_s_dv_preset
)
1008 p
->capabilities
|= V4L2_OUT_CAP_PRESETS
;
1009 if (ops
->vidioc_s_dv_timings
)
1010 p
->capabilities
|= V4L2_OUT_CAP_CUSTOM_TIMINGS
;
1012 return ops
->vidioc_enum_output(file
, fh
, p
);
1015 static int v4l_enum_fmt(const struct v4l2_ioctl_ops
*ops
,
1016 struct file
*file
, void *fh
, void *arg
)
1018 struct v4l2_fmtdesc
*p
= arg
;
1021 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
1022 if (unlikely(!ops
->vidioc_enum_fmt_vid_cap
))
1024 return ops
->vidioc_enum_fmt_vid_cap(file
, fh
, arg
);
1025 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
:
1026 if (unlikely(!ops
->vidioc_enum_fmt_vid_cap_mplane
))
1028 return ops
->vidioc_enum_fmt_vid_cap_mplane(file
, fh
, arg
);
1029 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
1030 if (unlikely(!ops
->vidioc_enum_fmt_vid_overlay
))
1032 return ops
->vidioc_enum_fmt_vid_overlay(file
, fh
, arg
);
1033 case V4L2_BUF_TYPE_VIDEO_OUTPUT
:
1034 if (unlikely(!ops
->vidioc_enum_fmt_vid_out
))
1036 return ops
->vidioc_enum_fmt_vid_out(file
, fh
, arg
);
1037 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
:
1038 if (unlikely(!ops
->vidioc_enum_fmt_vid_out_mplane
))
1040 return ops
->vidioc_enum_fmt_vid_out_mplane(file
, fh
, arg
);
1041 case V4L2_BUF_TYPE_PRIVATE
:
1042 if (unlikely(!ops
->vidioc_enum_fmt_type_private
))
1044 return ops
->vidioc_enum_fmt_type_private(file
, fh
, arg
);
1049 static int v4l_g_fmt(const struct v4l2_ioctl_ops
*ops
,
1050 struct file
*file
, void *fh
, void *arg
)
1052 struct v4l2_format
*p
= arg
;
1055 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
1056 if (unlikely(!ops
->vidioc_g_fmt_vid_cap
))
1058 return ops
->vidioc_g_fmt_vid_cap(file
, fh
, arg
);
1059 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
:
1060 if (unlikely(!ops
->vidioc_g_fmt_vid_cap_mplane
))
1062 return ops
->vidioc_g_fmt_vid_cap_mplane(file
, fh
, arg
);
1063 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
1064 if (unlikely(!ops
->vidioc_g_fmt_vid_overlay
))
1066 return ops
->vidioc_g_fmt_vid_overlay(file
, fh
, arg
);
1067 case V4L2_BUF_TYPE_VIDEO_OUTPUT
:
1068 if (unlikely(!ops
->vidioc_g_fmt_vid_out
))
1070 return ops
->vidioc_g_fmt_vid_out(file
, fh
, arg
);
1071 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
:
1072 if (unlikely(!ops
->vidioc_g_fmt_vid_out_mplane
))
1074 return ops
->vidioc_g_fmt_vid_out_mplane(file
, fh
, arg
);
1075 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY
:
1076 if (unlikely(!ops
->vidioc_g_fmt_vid_out_overlay
))
1078 return ops
->vidioc_g_fmt_vid_out_overlay(file
, fh
, arg
);
1079 case V4L2_BUF_TYPE_VBI_CAPTURE
:
1080 if (unlikely(!ops
->vidioc_g_fmt_vbi_cap
))
1082 return ops
->vidioc_g_fmt_vbi_cap(file
, fh
, arg
);
1083 case V4L2_BUF_TYPE_VBI_OUTPUT
:
1084 if (unlikely(!ops
->vidioc_g_fmt_vbi_out
))
1086 return ops
->vidioc_g_fmt_vbi_out(file
, fh
, arg
);
1087 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
:
1088 if (unlikely(!ops
->vidioc_g_fmt_sliced_vbi_cap
))
1090 return ops
->vidioc_g_fmt_sliced_vbi_cap(file
, fh
, arg
);
1091 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT
:
1092 if (unlikely(!ops
->vidioc_g_fmt_sliced_vbi_out
))
1094 return ops
->vidioc_g_fmt_sliced_vbi_out(file
, fh
, arg
);
1095 case V4L2_BUF_TYPE_PRIVATE
:
1096 if (unlikely(!ops
->vidioc_g_fmt_type_private
))
1098 return ops
->vidioc_g_fmt_type_private(file
, fh
, arg
);
1103 static int v4l_s_fmt(const struct v4l2_ioctl_ops
*ops
,
1104 struct file
*file
, void *fh
, void *arg
)
1106 struct v4l2_format
*p
= arg
;
1109 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
1110 if (unlikely(!ops
->vidioc_s_fmt_vid_cap
))
1112 CLEAR_AFTER_FIELD(p
, fmt
.pix
);
1113 return ops
->vidioc_s_fmt_vid_cap(file
, fh
, arg
);
1114 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
:
1115 if (unlikely(!ops
->vidioc_s_fmt_vid_cap_mplane
))
1117 CLEAR_AFTER_FIELD(p
, fmt
.pix_mp
);
1118 return ops
->vidioc_s_fmt_vid_cap_mplane(file
, fh
, arg
);
1119 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
1120 if (unlikely(!ops
->vidioc_s_fmt_vid_overlay
))
1122 CLEAR_AFTER_FIELD(p
, fmt
.win
);
1123 return ops
->vidioc_s_fmt_vid_overlay(file
, fh
, arg
);
1124 case V4L2_BUF_TYPE_VIDEO_OUTPUT
:
1125 if (unlikely(!ops
->vidioc_s_fmt_vid_out
))
1127 CLEAR_AFTER_FIELD(p
, fmt
.pix
);
1128 return ops
->vidioc_s_fmt_vid_out(file
, fh
, arg
);
1129 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
:
1130 if (unlikely(!ops
->vidioc_s_fmt_vid_out_mplane
))
1132 CLEAR_AFTER_FIELD(p
, fmt
.pix_mp
);
1133 return ops
->vidioc_s_fmt_vid_out_mplane(file
, fh
, arg
);
1134 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY
:
1135 if (unlikely(!ops
->vidioc_s_fmt_vid_out_overlay
))
1137 CLEAR_AFTER_FIELD(p
, fmt
.win
);
1138 return ops
->vidioc_s_fmt_vid_out_overlay(file
, fh
, arg
);
1139 case V4L2_BUF_TYPE_VBI_CAPTURE
:
1140 if (unlikely(!ops
->vidioc_s_fmt_vbi_cap
))
1142 CLEAR_AFTER_FIELD(p
, fmt
.vbi
);
1143 return ops
->vidioc_s_fmt_vbi_cap(file
, fh
, arg
);
1144 case V4L2_BUF_TYPE_VBI_OUTPUT
:
1145 if (unlikely(!ops
->vidioc_s_fmt_vbi_out
))
1147 CLEAR_AFTER_FIELD(p
, fmt
.vbi
);
1148 return ops
->vidioc_s_fmt_vbi_out(file
, fh
, arg
);
1149 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
:
1150 if (unlikely(!ops
->vidioc_s_fmt_sliced_vbi_cap
))
1152 CLEAR_AFTER_FIELD(p
, fmt
.sliced
);
1153 return ops
->vidioc_s_fmt_sliced_vbi_cap(file
, fh
, arg
);
1154 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT
:
1155 if (unlikely(!ops
->vidioc_s_fmt_sliced_vbi_out
))
1157 CLEAR_AFTER_FIELD(p
, fmt
.sliced
);
1158 return ops
->vidioc_s_fmt_sliced_vbi_out(file
, fh
, arg
);
1159 case V4L2_BUF_TYPE_PRIVATE
:
1160 if (unlikely(!ops
->vidioc_s_fmt_type_private
))
1162 return ops
->vidioc_s_fmt_type_private(file
, fh
, arg
);
1167 static int v4l_try_fmt(const struct v4l2_ioctl_ops
*ops
,
1168 struct file
*file
, void *fh
, void *arg
)
1170 struct v4l2_format
*p
= arg
;
1173 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
1174 if (unlikely(!ops
->vidioc_try_fmt_vid_cap
))
1176 CLEAR_AFTER_FIELD(p
, fmt
.pix
);
1177 return ops
->vidioc_try_fmt_vid_cap(file
, fh
, arg
);
1178 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
:
1179 if (unlikely(!ops
->vidioc_try_fmt_vid_cap_mplane
))
1181 CLEAR_AFTER_FIELD(p
, fmt
.pix_mp
);
1182 return ops
->vidioc_try_fmt_vid_cap_mplane(file
, fh
, arg
);
1183 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
1184 if (unlikely(!ops
->vidioc_try_fmt_vid_overlay
))
1186 CLEAR_AFTER_FIELD(p
, fmt
.win
);
1187 return ops
->vidioc_try_fmt_vid_overlay(file
, fh
, arg
);
1188 case V4L2_BUF_TYPE_VIDEO_OUTPUT
:
1189 if (unlikely(!ops
->vidioc_try_fmt_vid_out
))
1191 CLEAR_AFTER_FIELD(p
, fmt
.pix
);
1192 return ops
->vidioc_try_fmt_vid_out(file
, fh
, arg
);
1193 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
:
1194 if (unlikely(!ops
->vidioc_try_fmt_vid_out_mplane
))
1196 CLEAR_AFTER_FIELD(p
, fmt
.pix_mp
);
1197 return ops
->vidioc_try_fmt_vid_out_mplane(file
, fh
, arg
);
1198 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY
:
1199 if (unlikely(!ops
->vidioc_try_fmt_vid_out_overlay
))
1201 CLEAR_AFTER_FIELD(p
, fmt
.win
);
1202 return ops
->vidioc_try_fmt_vid_out_overlay(file
, fh
, arg
);
1203 case V4L2_BUF_TYPE_VBI_CAPTURE
:
1204 if (unlikely(!ops
->vidioc_try_fmt_vbi_cap
))
1206 CLEAR_AFTER_FIELD(p
, fmt
.vbi
);
1207 return ops
->vidioc_try_fmt_vbi_cap(file
, fh
, arg
);
1208 case V4L2_BUF_TYPE_VBI_OUTPUT
:
1209 if (unlikely(!ops
->vidioc_try_fmt_vbi_out
))
1211 CLEAR_AFTER_FIELD(p
, fmt
.vbi
);
1212 return ops
->vidioc_try_fmt_vbi_out(file
, fh
, arg
);
1213 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
:
1214 if (unlikely(!ops
->vidioc_try_fmt_sliced_vbi_cap
))
1216 CLEAR_AFTER_FIELD(p
, fmt
.sliced
);
1217 return ops
->vidioc_try_fmt_sliced_vbi_cap(file
, fh
, arg
);
1218 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT
:
1219 if (unlikely(!ops
->vidioc_try_fmt_sliced_vbi_out
))
1221 CLEAR_AFTER_FIELD(p
, fmt
.sliced
);
1222 return ops
->vidioc_try_fmt_sliced_vbi_out(file
, fh
, arg
);
1223 case V4L2_BUF_TYPE_PRIVATE
:
1224 if (unlikely(!ops
->vidioc_try_fmt_type_private
))
1226 return ops
->vidioc_try_fmt_type_private(file
, fh
, arg
);
1231 static int v4l_streamon(const struct v4l2_ioctl_ops
*ops
,
1232 struct file
*file
, void *fh
, void *arg
)
1234 return ops
->vidioc_streamon(file
, fh
, *(unsigned int *)arg
);
1237 static int v4l_streamoff(const struct v4l2_ioctl_ops
*ops
,
1238 struct file
*file
, void *fh
, void *arg
)
1240 return ops
->vidioc_streamoff(file
, fh
, *(unsigned int *)arg
);
1243 static int v4l_g_tuner(const struct v4l2_ioctl_ops
*ops
,
1244 struct file
*file
, void *fh
, void *arg
)
1246 struct video_device
*vfd
= video_devdata(file
);
1247 struct v4l2_tuner
*p
= arg
;
1249 p
->type
= (vfd
->vfl_type
== VFL_TYPE_RADIO
) ?
1250 V4L2_TUNER_RADIO
: V4L2_TUNER_ANALOG_TV
;
1251 return ops
->vidioc_g_tuner(file
, fh
, p
);
1254 static int v4l_s_tuner(const struct v4l2_ioctl_ops
*ops
,
1255 struct file
*file
, void *fh
, void *arg
)
1257 struct video_device
*vfd
= video_devdata(file
);
1258 struct v4l2_tuner
*p
= arg
;
1260 p
->type
= (vfd
->vfl_type
== VFL_TYPE_RADIO
) ?
1261 V4L2_TUNER_RADIO
: V4L2_TUNER_ANALOG_TV
;
1262 return ops
->vidioc_s_tuner(file
, fh
, p
);
1265 static int v4l_g_frequency(const struct v4l2_ioctl_ops
*ops
,
1266 struct file
*file
, void *fh
, void *arg
)
1268 struct video_device
*vfd
= video_devdata(file
);
1269 struct v4l2_frequency
*p
= arg
;
1271 p
->type
= (vfd
->vfl_type
== VFL_TYPE_RADIO
) ?
1272 V4L2_TUNER_RADIO
: V4L2_TUNER_ANALOG_TV
;
1273 return ops
->vidioc_g_frequency(file
, fh
, p
);
1276 static int v4l_s_frequency(const struct v4l2_ioctl_ops
*ops
,
1277 struct file
*file
, void *fh
, void *arg
)
1279 struct video_device
*vfd
= video_devdata(file
);
1280 struct v4l2_frequency
*p
= arg
;
1281 enum v4l2_tuner_type type
;
1283 type
= (vfd
->vfl_type
== VFL_TYPE_RADIO
) ?
1284 V4L2_TUNER_RADIO
: V4L2_TUNER_ANALOG_TV
;
1285 if (p
->type
!= type
)
1287 return ops
->vidioc_s_frequency(file
, fh
, p
);
1290 static int v4l_enumstd(const struct v4l2_ioctl_ops
*ops
,
1291 struct file
*file
, void *fh
, void *arg
)
1293 struct video_device
*vfd
= video_devdata(file
);
1294 struct v4l2_standard
*p
= arg
;
1295 v4l2_std_id id
= vfd
->tvnorms
, curr_id
= 0;
1296 unsigned int index
= p
->index
, i
, j
= 0;
1297 const char *descr
= "";
1299 /* Return norm array in a canonical way */
1300 for (i
= 0; i
<= index
&& id
; i
++) {
1301 /* last std value in the standards array is 0, so this
1302 while always ends there since (id & 0) == 0. */
1303 while ((id
& standards
[j
].std
) != standards
[j
].std
)
1305 curr_id
= standards
[j
].std
;
1306 descr
= standards
[j
].descr
;
1310 if (curr_id
!= V4L2_STD_PAL
&&
1311 curr_id
!= V4L2_STD_SECAM
&&
1312 curr_id
!= V4L2_STD_NTSC
)
1318 v4l2_video_std_construct(p
, curr_id
, descr
);
1322 static int v4l_g_std(const struct v4l2_ioctl_ops
*ops
,
1323 struct file
*file
, void *fh
, void *arg
)
1325 struct video_device
*vfd
= video_devdata(file
);
1326 v4l2_std_id
*id
= arg
;
1328 /* Calls the specific handler */
1329 if (ops
->vidioc_g_std
)
1330 return ops
->vidioc_g_std(file
, fh
, arg
);
1331 if (vfd
->current_norm
) {
1332 *id
= vfd
->current_norm
;
1338 static int v4l_s_std(const struct v4l2_ioctl_ops
*ops
,
1339 struct file
*file
, void *fh
, void *arg
)
1341 struct video_device
*vfd
= video_devdata(file
);
1342 v4l2_std_id
*id
= arg
, norm
;
1345 norm
= (*id
) & vfd
->tvnorms
;
1346 if (vfd
->tvnorms
&& !norm
) /* Check if std is supported */
1349 /* Calls the specific handler */
1350 ret
= ops
->vidioc_s_std(file
, fh
, &norm
);
1352 /* Updates standard information */
1354 vfd
->current_norm
= norm
;
1358 static int v4l_querystd(const struct v4l2_ioctl_ops
*ops
,
1359 struct file
*file
, void *fh
, void *arg
)
1361 struct video_device
*vfd
= video_devdata(file
);
1362 v4l2_std_id
*p
= arg
;
1365 * If nothing detected, it should return all supported
1367 * Drivers just need to mask the std argument, in order
1368 * to remove the standards that don't apply from the mask.
1369 * This means that tuners, audio and video decoders can join
1370 * their efforts to improve the standards detection.
1373 return ops
->vidioc_querystd(file
, fh
, arg
);
1376 static int v4l_s_hw_freq_seek(const struct v4l2_ioctl_ops
*ops
,
1377 struct file
*file
, void *fh
, void *arg
)
1379 struct video_device
*vfd
= video_devdata(file
);
1380 struct v4l2_hw_freq_seek
*p
= arg
;
1381 enum v4l2_tuner_type type
;
1383 type
= (vfd
->vfl_type
== VFL_TYPE_RADIO
) ?
1384 V4L2_TUNER_RADIO
: V4L2_TUNER_ANALOG_TV
;
1385 if (p
->type
!= type
)
1387 return ops
->vidioc_s_hw_freq_seek(file
, fh
, p
);
1390 static int v4l_reqbufs(const struct v4l2_ioctl_ops
*ops
,
1391 struct file
*file
, void *fh
, void *arg
)
1393 struct v4l2_requestbuffers
*p
= arg
;
1394 int ret
= check_fmt(ops
, p
->type
);
1399 if (p
->type
< V4L2_BUF_TYPE_PRIVATE
)
1400 CLEAR_AFTER_FIELD(p
, memory
);
1402 return ops
->vidioc_reqbufs(file
, fh
, p
);
1405 static int v4l_querybuf(const struct v4l2_ioctl_ops
*ops
,
1406 struct file
*file
, void *fh
, void *arg
)
1408 struct v4l2_buffer
*p
= arg
;
1409 int ret
= check_fmt(ops
, p
->type
);
1411 return ret
? ret
: ops
->vidioc_querybuf(file
, fh
, p
);
1414 static int v4l_qbuf(const struct v4l2_ioctl_ops
*ops
,
1415 struct file
*file
, void *fh
, void *arg
)
1417 struct v4l2_buffer
*p
= arg
;
1418 int ret
= check_fmt(ops
, p
->type
);
1420 return ret
? ret
: ops
->vidioc_qbuf(file
, fh
, p
);
1423 static int v4l_dqbuf(const struct v4l2_ioctl_ops
*ops
,
1424 struct file
*file
, void *fh
, void *arg
)
1426 struct v4l2_buffer
*p
= arg
;
1427 int ret
= check_fmt(ops
, p
->type
);
1429 return ret
? ret
: ops
->vidioc_dqbuf(file
, fh
, p
);
1432 static int v4l_create_bufs(const struct v4l2_ioctl_ops
*ops
,
1433 struct file
*file
, void *fh
, void *arg
)
1435 struct v4l2_create_buffers
*create
= arg
;
1436 int ret
= check_fmt(ops
, create
->format
.type
);
1438 return ret
? ret
: ops
->vidioc_create_bufs(file
, fh
, create
);
1441 static int v4l_prepare_buf(const struct v4l2_ioctl_ops
*ops
,
1442 struct file
*file
, void *fh
, void *arg
)
1444 struct v4l2_buffer
*b
= arg
;
1445 int ret
= check_fmt(ops
, b
->type
);
1447 return ret
? ret
: ops
->vidioc_prepare_buf(file
, fh
, b
);
1450 static int v4l_g_parm(const struct v4l2_ioctl_ops
*ops
,
1451 struct file
*file
, void *fh
, void *arg
)
1453 struct video_device
*vfd
= video_devdata(file
);
1454 struct v4l2_streamparm
*p
= arg
;
1456 int ret
= check_fmt(ops
, p
->type
);
1460 if (ops
->vidioc_g_parm
)
1461 return ops
->vidioc_g_parm(file
, fh
, p
);
1462 std
= vfd
->current_norm
;
1463 if (p
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
&&
1464 p
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
1466 p
->parm
.capture
.readbuffers
= 2;
1467 if (ops
->vidioc_g_std
)
1468 ret
= ops
->vidioc_g_std(file
, fh
, &std
);
1470 v4l2_video_std_frame_period(std
,
1471 &p
->parm
.capture
.timeperframe
);
1475 static int v4l_s_parm(const struct v4l2_ioctl_ops
*ops
,
1476 struct file
*file
, void *fh
, void *arg
)
1478 struct v4l2_streamparm
*p
= arg
;
1479 int ret
= check_fmt(ops
, p
->type
);
1481 return ret
? ret
: ops
->vidioc_s_parm(file
, fh
, p
);
1484 static int v4l_queryctrl(const struct v4l2_ioctl_ops
*ops
,
1485 struct file
*file
, void *fh
, void *arg
)
1487 struct video_device
*vfd
= video_devdata(file
);
1488 struct v4l2_queryctrl
*p
= arg
;
1489 struct v4l2_fh
*vfh
=
1490 test_bit(V4L2_FL_USES_V4L2_FH
, &vfd
->flags
) ? fh
: NULL
;
1492 if (vfh
&& vfh
->ctrl_handler
)
1493 return v4l2_queryctrl(vfh
->ctrl_handler
, p
);
1494 if (vfd
->ctrl_handler
)
1495 return v4l2_queryctrl(vfd
->ctrl_handler
, p
);
1496 if (ops
->vidioc_queryctrl
)
1497 return ops
->vidioc_queryctrl(file
, fh
, p
);
1501 static int v4l_querymenu(const struct v4l2_ioctl_ops
*ops
,
1502 struct file
*file
, void *fh
, void *arg
)
1504 struct video_device
*vfd
= video_devdata(file
);
1505 struct v4l2_querymenu
*p
= arg
;
1506 struct v4l2_fh
*vfh
=
1507 test_bit(V4L2_FL_USES_V4L2_FH
, &vfd
->flags
) ? fh
: NULL
;
1509 if (vfh
&& vfh
->ctrl_handler
)
1510 return v4l2_querymenu(vfh
->ctrl_handler
, p
);
1511 if (vfd
->ctrl_handler
)
1512 return v4l2_querymenu(vfd
->ctrl_handler
, p
);
1513 if (ops
->vidioc_querymenu
)
1514 return ops
->vidioc_querymenu(file
, fh
, p
);
1518 static int v4l_g_ctrl(const struct v4l2_ioctl_ops
*ops
,
1519 struct file
*file
, void *fh
, void *arg
)
1521 struct video_device
*vfd
= video_devdata(file
);
1522 struct v4l2_control
*p
= arg
;
1523 struct v4l2_fh
*vfh
=
1524 test_bit(V4L2_FL_USES_V4L2_FH
, &vfd
->flags
) ? fh
: NULL
;
1525 struct v4l2_ext_controls ctrls
;
1526 struct v4l2_ext_control ctrl
;
1528 if (vfh
&& vfh
->ctrl_handler
)
1529 return v4l2_g_ctrl(vfh
->ctrl_handler
, p
);
1530 if (vfd
->ctrl_handler
)
1531 return v4l2_g_ctrl(vfd
->ctrl_handler
, p
);
1532 if (ops
->vidioc_g_ctrl
)
1533 return ops
->vidioc_g_ctrl(file
, fh
, p
);
1534 if (ops
->vidioc_g_ext_ctrls
== NULL
)
1537 ctrls
.ctrl_class
= V4L2_CTRL_ID2CLASS(p
->id
);
1539 ctrls
.controls
= &ctrl
;
1541 ctrl
.value
= p
->value
;
1542 if (check_ext_ctrls(&ctrls
, 1)) {
1543 int ret
= ops
->vidioc_g_ext_ctrls(file
, fh
, &ctrls
);
1546 p
->value
= ctrl
.value
;
1552 static int v4l_s_ctrl(const struct v4l2_ioctl_ops
*ops
,
1553 struct file
*file
, void *fh
, void *arg
)
1555 struct video_device
*vfd
= video_devdata(file
);
1556 struct v4l2_control
*p
= arg
;
1557 struct v4l2_fh
*vfh
=
1558 test_bit(V4L2_FL_USES_V4L2_FH
, &vfd
->flags
) ? fh
: NULL
;
1559 struct v4l2_ext_controls ctrls
;
1560 struct v4l2_ext_control ctrl
;
1562 if (vfh
&& vfh
->ctrl_handler
)
1563 return v4l2_s_ctrl(vfh
, vfh
->ctrl_handler
, p
);
1564 if (vfd
->ctrl_handler
)
1565 return v4l2_s_ctrl(NULL
, vfd
->ctrl_handler
, p
);
1566 if (ops
->vidioc_s_ctrl
)
1567 return ops
->vidioc_s_ctrl(file
, fh
, p
);
1568 if (ops
->vidioc_s_ext_ctrls
== NULL
)
1571 ctrls
.ctrl_class
= V4L2_CTRL_ID2CLASS(p
->id
);
1573 ctrls
.controls
= &ctrl
;
1575 ctrl
.value
= p
->value
;
1576 if (check_ext_ctrls(&ctrls
, 1))
1577 return ops
->vidioc_s_ext_ctrls(file
, fh
, &ctrls
);
1581 static int v4l_g_ext_ctrls(const struct v4l2_ioctl_ops
*ops
,
1582 struct file
*file
, void *fh
, void *arg
)
1584 struct video_device
*vfd
= video_devdata(file
);
1585 struct v4l2_ext_controls
*p
= arg
;
1586 struct v4l2_fh
*vfh
=
1587 test_bit(V4L2_FL_USES_V4L2_FH
, &vfd
->flags
) ? fh
: NULL
;
1589 p
->error_idx
= p
->count
;
1590 if (vfh
&& vfh
->ctrl_handler
)
1591 return v4l2_g_ext_ctrls(vfh
->ctrl_handler
, p
);
1592 if (vfd
->ctrl_handler
)
1593 return v4l2_g_ext_ctrls(vfd
->ctrl_handler
, p
);
1594 if (ops
->vidioc_g_ext_ctrls
== NULL
)
1596 return check_ext_ctrls(p
, 0) ? ops
->vidioc_g_ext_ctrls(file
, fh
, p
) :
1600 static int v4l_s_ext_ctrls(const struct v4l2_ioctl_ops
*ops
,
1601 struct file
*file
, void *fh
, void *arg
)
1603 struct video_device
*vfd
= video_devdata(file
);
1604 struct v4l2_ext_controls
*p
= arg
;
1605 struct v4l2_fh
*vfh
=
1606 test_bit(V4L2_FL_USES_V4L2_FH
, &vfd
->flags
) ? fh
: NULL
;
1608 p
->error_idx
= p
->count
;
1609 if (vfh
&& vfh
->ctrl_handler
)
1610 return v4l2_s_ext_ctrls(vfh
, vfh
->ctrl_handler
, p
);
1611 if (vfd
->ctrl_handler
)
1612 return v4l2_s_ext_ctrls(NULL
, vfd
->ctrl_handler
, p
);
1613 if (ops
->vidioc_s_ext_ctrls
== NULL
)
1615 return check_ext_ctrls(p
, 0) ? ops
->vidioc_s_ext_ctrls(file
, fh
, p
) :
1619 static int v4l_try_ext_ctrls(const struct v4l2_ioctl_ops
*ops
,
1620 struct file
*file
, void *fh
, void *arg
)
1622 struct video_device
*vfd
= video_devdata(file
);
1623 struct v4l2_ext_controls
*p
= arg
;
1624 struct v4l2_fh
*vfh
=
1625 test_bit(V4L2_FL_USES_V4L2_FH
, &vfd
->flags
) ? fh
: NULL
;
1627 p
->error_idx
= p
->count
;
1628 if (vfh
&& vfh
->ctrl_handler
)
1629 return v4l2_try_ext_ctrls(vfh
->ctrl_handler
, p
);
1630 if (vfd
->ctrl_handler
)
1631 return v4l2_try_ext_ctrls(vfd
->ctrl_handler
, p
);
1632 if (ops
->vidioc_try_ext_ctrls
== NULL
)
1634 return check_ext_ctrls(p
, 0) ? ops
->vidioc_try_ext_ctrls(file
, fh
, p
) :
1638 static int v4l_g_crop(const struct v4l2_ioctl_ops
*ops
,
1639 struct file
*file
, void *fh
, void *arg
)
1641 struct v4l2_crop
*p
= arg
;
1642 struct v4l2_selection s
= {
1647 if (ops
->vidioc_g_crop
)
1648 return ops
->vidioc_g_crop(file
, fh
, p
);
1649 /* simulate capture crop using selection api */
1651 /* crop means compose for output devices */
1652 if (V4L2_TYPE_IS_OUTPUT(p
->type
))
1653 s
.target
= V4L2_SEL_TGT_COMPOSE_ACTIVE
;
1655 s
.target
= V4L2_SEL_TGT_CROP_ACTIVE
;
1657 ret
= ops
->vidioc_g_selection(file
, fh
, &s
);
1659 /* copying results to old structure on success */
1665 static int v4l_s_crop(const struct v4l2_ioctl_ops
*ops
,
1666 struct file
*file
, void *fh
, void *arg
)
1668 struct v4l2_crop
*p
= arg
;
1669 struct v4l2_selection s
= {
1674 if (ops
->vidioc_s_crop
)
1675 return ops
->vidioc_s_crop(file
, fh
, p
);
1676 /* simulate capture crop using selection api */
1678 /* crop means compose for output devices */
1679 if (V4L2_TYPE_IS_OUTPUT(p
->type
))
1680 s
.target
= V4L2_SEL_TGT_COMPOSE_ACTIVE
;
1682 s
.target
= V4L2_SEL_TGT_CROP_ACTIVE
;
1684 return ops
->vidioc_s_selection(file
, fh
, &s
);
1687 static int v4l_cropcap(const struct v4l2_ioctl_ops
*ops
,
1688 struct file
*file
, void *fh
, void *arg
)
1690 struct v4l2_cropcap
*p
= arg
;
1691 struct v4l2_selection s
= { .type
= p
->type
};
1694 if (ops
->vidioc_cropcap
)
1695 return ops
->vidioc_cropcap(file
, fh
, p
);
1697 /* obtaining bounds */
1698 if (V4L2_TYPE_IS_OUTPUT(p
->type
))
1699 s
.target
= V4L2_SEL_TGT_COMPOSE_BOUNDS
;
1701 s
.target
= V4L2_SEL_TGT_CROP_BOUNDS
;
1703 ret
= ops
->vidioc_g_selection(file
, fh
, &s
);
1708 /* obtaining defrect */
1709 if (V4L2_TYPE_IS_OUTPUT(p
->type
))
1710 s
.target
= V4L2_SEL_TGT_COMPOSE_DEFAULT
;
1712 s
.target
= V4L2_SEL_TGT_CROP_DEFAULT
;
1714 ret
= ops
->vidioc_g_selection(file
, fh
, &s
);
1719 /* setting trivial pixelaspect */
1720 p
->pixelaspect
.numerator
= 1;
1721 p
->pixelaspect
.denominator
= 1;
1725 static int v4l_log_status(const struct v4l2_ioctl_ops
*ops
,
1726 struct file
*file
, void *fh
, void *arg
)
1728 struct video_device
*vfd
= video_devdata(file
);
1732 pr_info("%s: ================= START STATUS =================\n",
1733 vfd
->v4l2_dev
->name
);
1734 ret
= ops
->vidioc_log_status(file
, fh
);
1736 pr_info("%s: ================== END STATUS ==================\n",
1737 vfd
->v4l2_dev
->name
);
1741 static int v4l_dbg_g_register(const struct v4l2_ioctl_ops
*ops
,
1742 struct file
*file
, void *fh
, void *arg
)
1744 #ifdef CONFIG_VIDEO_ADV_DEBUG
1745 struct v4l2_dbg_register
*p
= arg
;
1747 if (!capable(CAP_SYS_ADMIN
))
1749 return ops
->vidioc_g_register(file
, fh
, p
);
1755 static int v4l_dbg_s_register(const struct v4l2_ioctl_ops
*ops
,
1756 struct file
*file
, void *fh
, void *arg
)
1758 #ifdef CONFIG_VIDEO_ADV_DEBUG
1759 struct v4l2_dbg_register
*p
= arg
;
1761 if (!capable(CAP_SYS_ADMIN
))
1763 return ops
->vidioc_s_register(file
, fh
, p
);
1769 static int v4l_dbg_g_chip_ident(const struct v4l2_ioctl_ops
*ops
,
1770 struct file
*file
, void *fh
, void *arg
)
1772 struct v4l2_dbg_chip_ident
*p
= arg
;
1774 p
->ident
= V4L2_IDENT_NONE
;
1776 return ops
->vidioc_g_chip_ident(file
, fh
, p
);
1779 static int v4l_dqevent(const struct v4l2_ioctl_ops
*ops
,
1780 struct file
*file
, void *fh
, void *arg
)
1782 return v4l2_event_dequeue(fh
, arg
, file
->f_flags
& O_NONBLOCK
);
1785 static int v4l_subscribe_event(const struct v4l2_ioctl_ops
*ops
,
1786 struct file
*file
, void *fh
, void *arg
)
1788 return ops
->vidioc_subscribe_event(fh
, arg
);
1791 static int v4l_unsubscribe_event(const struct v4l2_ioctl_ops
*ops
,
1792 struct file
*file
, void *fh
, void *arg
)
1794 return ops
->vidioc_unsubscribe_event(fh
, arg
);
1797 static int v4l_g_sliced_vbi_cap(const struct v4l2_ioctl_ops
*ops
,
1798 struct file
*file
, void *fh
, void *arg
)
1800 struct v4l2_sliced_vbi_cap
*p
= arg
;
1802 /* Clear up to type, everything after type is zeroed already */
1803 memset(p
, 0, offsetof(struct v4l2_sliced_vbi_cap
, type
));
1805 return ops
->vidioc_g_sliced_vbi_cap(file
, fh
, p
);
1808 struct v4l2_ioctl_info
{
1811 const char * const name
;
1814 int (*func
)(const struct v4l2_ioctl_ops
*ops
,
1815 struct file
*file
, void *fh
, void *p
);
1817 void (*debug
)(const void *arg
, bool write_only
);
1820 /* This control needs a priority check */
1821 #define INFO_FL_PRIO (1 << 0)
1822 /* This control can be valid if the filehandle passes a control handler. */
1823 #define INFO_FL_CTRL (1 << 1)
1824 /* This is a standard ioctl, no need for special code */
1825 #define INFO_FL_STD (1 << 2)
1826 /* This is ioctl has its own function */
1827 #define INFO_FL_FUNC (1 << 3)
1829 #define INFO_FL_QUEUE (1 << 4)
1830 /* Zero struct from after the field to the end */
1831 #define INFO_FL_CLEAR(v4l2_struct, field) \
1832 ((offsetof(struct v4l2_struct, field) + \
1833 sizeof(((struct v4l2_struct *)0)->field)) << 16)
1834 #define INFO_FL_CLEAR_MASK (_IOC_SIZEMASK << 16)
1836 #define IOCTL_INFO_STD(_ioctl, _vidioc, _debug, _flags) \
1837 [_IOC_NR(_ioctl)] = { \
1839 .flags = _flags | INFO_FL_STD, \
1841 .offset = offsetof(struct v4l2_ioctl_ops, _vidioc), \
1845 #define IOCTL_INFO_FNC(_ioctl, _func, _debug, _flags) \
1846 [_IOC_NR(_ioctl)] = { \
1848 .flags = _flags | INFO_FL_FUNC, \
1854 static struct v4l2_ioctl_info v4l2_ioctls
[] = {
1855 IOCTL_INFO_FNC(VIDIOC_QUERYCAP
, v4l_querycap
, v4l_print_querycap
, 0),
1856 IOCTL_INFO_FNC(VIDIOC_ENUM_FMT
, v4l_enum_fmt
, v4l_print_fmtdesc
, INFO_FL_CLEAR(v4l2_fmtdesc
, type
)),
1857 IOCTL_INFO_FNC(VIDIOC_G_FMT
, v4l_g_fmt
, v4l_print_format
, INFO_FL_CLEAR(v4l2_format
, type
)),
1858 IOCTL_INFO_FNC(VIDIOC_S_FMT
, v4l_s_fmt
, v4l_print_format
, INFO_FL_PRIO
),
1859 IOCTL_INFO_FNC(VIDIOC_REQBUFS
, v4l_reqbufs
, v4l_print_requestbuffers
, INFO_FL_PRIO
| INFO_FL_QUEUE
),
1860 IOCTL_INFO_FNC(VIDIOC_QUERYBUF
, v4l_querybuf
, v4l_print_buffer
, INFO_FL_QUEUE
| INFO_FL_CLEAR(v4l2_buffer
, length
)),
1861 IOCTL_INFO_STD(VIDIOC_G_FBUF
, vidioc_g_fbuf
, v4l_print_framebuffer
, 0),
1862 IOCTL_INFO_STD(VIDIOC_S_FBUF
, vidioc_s_fbuf
, v4l_print_framebuffer
, INFO_FL_PRIO
),
1863 IOCTL_INFO_STD(VIDIOC_OVERLAY
, vidioc_overlay
, v4l_print_u32
, INFO_FL_PRIO
),
1864 IOCTL_INFO_FNC(VIDIOC_QBUF
, v4l_qbuf
, v4l_print_buffer
, INFO_FL_QUEUE
),
1865 IOCTL_INFO_FNC(VIDIOC_DQBUF
, v4l_dqbuf
, v4l_print_buffer
, INFO_FL_QUEUE
),
1866 IOCTL_INFO_FNC(VIDIOC_STREAMON
, v4l_streamon
, v4l_print_buftype
, INFO_FL_PRIO
| INFO_FL_QUEUE
),
1867 IOCTL_INFO_FNC(VIDIOC_STREAMOFF
, v4l_streamoff
, v4l_print_buftype
, INFO_FL_PRIO
| INFO_FL_QUEUE
),
1868 IOCTL_INFO_FNC(VIDIOC_G_PARM
, v4l_g_parm
, v4l_print_streamparm
, INFO_FL_CLEAR(v4l2_streamparm
, type
)),
1869 IOCTL_INFO_FNC(VIDIOC_S_PARM
, v4l_s_parm
, v4l_print_streamparm
, INFO_FL_PRIO
),
1870 IOCTL_INFO_FNC(VIDIOC_G_STD
, v4l_g_std
, v4l_print_std
, 0),
1871 IOCTL_INFO_FNC(VIDIOC_S_STD
, v4l_s_std
, v4l_print_std
, INFO_FL_PRIO
),
1872 IOCTL_INFO_FNC(VIDIOC_ENUMSTD
, v4l_enumstd
, v4l_print_standard
, INFO_FL_CLEAR(v4l2_standard
, index
)),
1873 IOCTL_INFO_FNC(VIDIOC_ENUMINPUT
, v4l_enuminput
, v4l_print_enuminput
, INFO_FL_CLEAR(v4l2_input
, index
)),
1874 IOCTL_INFO_FNC(VIDIOC_G_CTRL
, v4l_g_ctrl
, v4l_print_control
, INFO_FL_CTRL
| INFO_FL_CLEAR(v4l2_control
, id
)),
1875 IOCTL_INFO_FNC(VIDIOC_S_CTRL
, v4l_s_ctrl
, v4l_print_control
, INFO_FL_PRIO
| INFO_FL_CTRL
),
1876 IOCTL_INFO_FNC(VIDIOC_G_TUNER
, v4l_g_tuner
, v4l_print_tuner
, INFO_FL_CLEAR(v4l2_tuner
, index
)),
1877 IOCTL_INFO_FNC(VIDIOC_S_TUNER
, v4l_s_tuner
, v4l_print_tuner
, INFO_FL_PRIO
),
1878 IOCTL_INFO_STD(VIDIOC_G_AUDIO
, vidioc_g_audio
, v4l_print_audio
, 0),
1879 IOCTL_INFO_STD(VIDIOC_S_AUDIO
, vidioc_s_audio
, v4l_print_audio
, INFO_FL_PRIO
),
1880 IOCTL_INFO_FNC(VIDIOC_QUERYCTRL
, v4l_queryctrl
, v4l_print_queryctrl
, INFO_FL_CTRL
| INFO_FL_CLEAR(v4l2_queryctrl
, id
)),
1881 IOCTL_INFO_FNC(VIDIOC_QUERYMENU
, v4l_querymenu
, v4l_print_querymenu
, INFO_FL_CTRL
| INFO_FL_CLEAR(v4l2_querymenu
, index
)),
1882 IOCTL_INFO_STD(VIDIOC_G_INPUT
, vidioc_g_input
, v4l_print_u32
, 0),
1883 IOCTL_INFO_FNC(VIDIOC_S_INPUT
, v4l_s_input
, v4l_print_u32
, INFO_FL_PRIO
),
1884 IOCTL_INFO_STD(VIDIOC_G_OUTPUT
, vidioc_g_output
, v4l_print_u32
, 0),
1885 IOCTL_INFO_FNC(VIDIOC_S_OUTPUT
, v4l_s_output
, v4l_print_u32
, INFO_FL_PRIO
),
1886 IOCTL_INFO_FNC(VIDIOC_ENUMOUTPUT
, v4l_enumoutput
, v4l_print_enumoutput
, INFO_FL_CLEAR(v4l2_output
, index
)),
1887 IOCTL_INFO_STD(VIDIOC_G_AUDOUT
, vidioc_g_audout
, v4l_print_audioout
, 0),
1888 IOCTL_INFO_STD(VIDIOC_S_AUDOUT
, vidioc_s_audout
, v4l_print_audioout
, INFO_FL_PRIO
),
1889 IOCTL_INFO_STD(VIDIOC_G_MODULATOR
, vidioc_g_modulator
, v4l_print_modulator
, INFO_FL_CLEAR(v4l2_modulator
, index
)),
1890 IOCTL_INFO_STD(VIDIOC_S_MODULATOR
, vidioc_s_modulator
, v4l_print_modulator
, INFO_FL_PRIO
),
1891 IOCTL_INFO_FNC(VIDIOC_G_FREQUENCY
, v4l_g_frequency
, v4l_print_frequency
, INFO_FL_CLEAR(v4l2_frequency
, tuner
)),
1892 IOCTL_INFO_FNC(VIDIOC_S_FREQUENCY
, v4l_s_frequency
, v4l_print_frequency
, INFO_FL_PRIO
),
1893 IOCTL_INFO_FNC(VIDIOC_CROPCAP
, v4l_cropcap
, v4l_print_cropcap
, INFO_FL_CLEAR(v4l2_cropcap
, type
)),
1894 IOCTL_INFO_FNC(VIDIOC_G_CROP
, v4l_g_crop
, v4l_print_crop
, INFO_FL_CLEAR(v4l2_crop
, type
)),
1895 IOCTL_INFO_FNC(VIDIOC_S_CROP
, v4l_s_crop
, v4l_print_crop
, INFO_FL_PRIO
),
1896 IOCTL_INFO_STD(VIDIOC_G_SELECTION
, vidioc_g_selection
, v4l_print_selection
, 0),
1897 IOCTL_INFO_STD(VIDIOC_S_SELECTION
, vidioc_s_selection
, v4l_print_selection
, INFO_FL_PRIO
),
1898 IOCTL_INFO_STD(VIDIOC_G_JPEGCOMP
, vidioc_g_jpegcomp
, v4l_print_jpegcompression
, 0),
1899 IOCTL_INFO_STD(VIDIOC_S_JPEGCOMP
, vidioc_s_jpegcomp
, v4l_print_jpegcompression
, INFO_FL_PRIO
),
1900 IOCTL_INFO_FNC(VIDIOC_QUERYSTD
, v4l_querystd
, v4l_print_std
, 0),
1901 IOCTL_INFO_FNC(VIDIOC_TRY_FMT
, v4l_try_fmt
, v4l_print_format
, 0),
1902 IOCTL_INFO_STD(VIDIOC_ENUMAUDIO
, vidioc_enumaudio
, v4l_print_audio
, INFO_FL_CLEAR(v4l2_audio
, index
)),
1903 IOCTL_INFO_STD(VIDIOC_ENUMAUDOUT
, vidioc_enumaudout
, v4l_print_audioout
, INFO_FL_CLEAR(v4l2_audioout
, index
)),
1904 IOCTL_INFO_FNC(VIDIOC_G_PRIORITY
, v4l_g_priority
, v4l_print_u32
, 0),
1905 IOCTL_INFO_FNC(VIDIOC_S_PRIORITY
, v4l_s_priority
, v4l_print_u32
, INFO_FL_PRIO
),
1906 IOCTL_INFO_FNC(VIDIOC_G_SLICED_VBI_CAP
, v4l_g_sliced_vbi_cap
, v4l_print_sliced_vbi_cap
, INFO_FL_CLEAR(v4l2_sliced_vbi_cap
, type
)),
1907 IOCTL_INFO_FNC(VIDIOC_LOG_STATUS
, v4l_log_status
, v4l_print_newline
, 0),
1908 IOCTL_INFO_FNC(VIDIOC_G_EXT_CTRLS
, v4l_g_ext_ctrls
, v4l_print_ext_controls
, INFO_FL_CTRL
),
1909 IOCTL_INFO_FNC(VIDIOC_S_EXT_CTRLS
, v4l_s_ext_ctrls
, v4l_print_ext_controls
, INFO_FL_PRIO
| INFO_FL_CTRL
),
1910 IOCTL_INFO_FNC(VIDIOC_TRY_EXT_CTRLS
, v4l_try_ext_ctrls
, v4l_print_ext_controls
, INFO_FL_CTRL
),
1911 IOCTL_INFO_STD(VIDIOC_ENUM_FRAMESIZES
, vidioc_enum_framesizes
, v4l_print_frmsizeenum
, INFO_FL_CLEAR(v4l2_frmsizeenum
, pixel_format
)),
1912 IOCTL_INFO_STD(VIDIOC_ENUM_FRAMEINTERVALS
, vidioc_enum_frameintervals
, v4l_print_frmivalenum
, INFO_FL_CLEAR(v4l2_frmivalenum
, height
)),
1913 IOCTL_INFO_STD(VIDIOC_G_ENC_INDEX
, vidioc_g_enc_index
, v4l_print_enc_idx
, 0),
1914 IOCTL_INFO_STD(VIDIOC_ENCODER_CMD
, vidioc_encoder_cmd
, v4l_print_encoder_cmd
, INFO_FL_PRIO
| INFO_FL_CLEAR(v4l2_encoder_cmd
, flags
)),
1915 IOCTL_INFO_STD(VIDIOC_TRY_ENCODER_CMD
, vidioc_try_encoder_cmd
, v4l_print_encoder_cmd
, INFO_FL_CLEAR(v4l2_encoder_cmd
, flags
)),
1916 IOCTL_INFO_STD(VIDIOC_DECODER_CMD
, vidioc_decoder_cmd
, v4l_print_decoder_cmd
, INFO_FL_PRIO
),
1917 IOCTL_INFO_STD(VIDIOC_TRY_DECODER_CMD
, vidioc_try_decoder_cmd
, v4l_print_decoder_cmd
, 0),
1918 IOCTL_INFO_FNC(VIDIOC_DBG_S_REGISTER
, v4l_dbg_s_register
, v4l_print_dbg_register
, 0),
1919 IOCTL_INFO_FNC(VIDIOC_DBG_G_REGISTER
, v4l_dbg_g_register
, v4l_print_dbg_register
, 0),
1920 IOCTL_INFO_FNC(VIDIOC_DBG_G_CHIP_IDENT
, v4l_dbg_g_chip_ident
, v4l_print_dbg_chip_ident
, 0),
1921 IOCTL_INFO_FNC(VIDIOC_S_HW_FREQ_SEEK
, v4l_s_hw_freq_seek
, v4l_print_hw_freq_seek
, INFO_FL_PRIO
),
1922 IOCTL_INFO_STD(VIDIOC_ENUM_DV_PRESETS
, vidioc_enum_dv_presets
, v4l_print_dv_enum_presets
, 0),
1923 IOCTL_INFO_STD(VIDIOC_S_DV_PRESET
, vidioc_s_dv_preset
, v4l_print_dv_preset
, INFO_FL_PRIO
),
1924 IOCTL_INFO_STD(VIDIOC_G_DV_PRESET
, vidioc_g_dv_preset
, v4l_print_dv_preset
, 0),
1925 IOCTL_INFO_STD(VIDIOC_QUERY_DV_PRESET
, vidioc_query_dv_preset
, v4l_print_dv_preset
, 0),
1926 IOCTL_INFO_STD(VIDIOC_S_DV_TIMINGS
, vidioc_s_dv_timings
, v4l_print_dv_timings
, INFO_FL_PRIO
),
1927 IOCTL_INFO_STD(VIDIOC_G_DV_TIMINGS
, vidioc_g_dv_timings
, v4l_print_dv_timings
, 0),
1928 IOCTL_INFO_FNC(VIDIOC_DQEVENT
, v4l_dqevent
, v4l_print_event
, 0),
1929 IOCTL_INFO_FNC(VIDIOC_SUBSCRIBE_EVENT
, v4l_subscribe_event
, v4l_print_event_subscription
, 0),
1930 IOCTL_INFO_FNC(VIDIOC_UNSUBSCRIBE_EVENT
, v4l_unsubscribe_event
, v4l_print_event_subscription
, 0),
1931 IOCTL_INFO_FNC(VIDIOC_CREATE_BUFS
, v4l_create_bufs
, v4l_print_create_buffers
, INFO_FL_PRIO
| INFO_FL_QUEUE
),
1932 IOCTL_INFO_FNC(VIDIOC_PREPARE_BUF
, v4l_prepare_buf
, v4l_print_buffer
, INFO_FL_QUEUE
),
1933 IOCTL_INFO_STD(VIDIOC_ENUM_DV_TIMINGS
, vidioc_enum_dv_timings
, v4l_print_enum_dv_timings
, 0),
1934 IOCTL_INFO_STD(VIDIOC_QUERY_DV_TIMINGS
, vidioc_query_dv_timings
, v4l_print_dv_timings
, 0),
1935 IOCTL_INFO_STD(VIDIOC_DV_TIMINGS_CAP
, vidioc_dv_timings_cap
, v4l_print_dv_timings_cap
, INFO_FL_CLEAR(v4l2_dv_timings_cap
, type
)),
1937 #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
1939 bool v4l2_is_known_ioctl(unsigned int cmd
)
1941 if (_IOC_NR(cmd
) >= V4L2_IOCTLS
)
1943 return v4l2_ioctls
[_IOC_NR(cmd
)].ioctl
== cmd
;
1946 struct mutex
*v4l2_ioctl_get_lock(struct video_device
*vdev
, unsigned cmd
)
1948 if (_IOC_NR(cmd
) >= V4L2_IOCTLS
)
1950 if (test_bit(_IOC_NR(cmd
), vdev
->disable_locking
))
1952 if (vdev
->queue
&& vdev
->queue
->lock
&&
1953 (v4l2_ioctls
[_IOC_NR(cmd
)].flags
& INFO_FL_QUEUE
))
1954 return vdev
->queue
->lock
;
1958 /* Common ioctl debug function. This function can be used by
1959 external ioctl messages as well as internal V4L ioctl */
1960 void v4l_printk_ioctl(const char *prefix
, unsigned int cmd
)
1962 const char *dir
, *type
;
1965 printk(KERN_DEBUG
"%s: ", prefix
);
1967 switch (_IOC_TYPE(cmd
)) {
1972 if (_IOC_NR(cmd
) >= V4L2_IOCTLS
) {
1976 pr_cont("%s", v4l2_ioctls
[_IOC_NR(cmd
)].name
);
1983 switch (_IOC_DIR(cmd
)) {
1984 case _IOC_NONE
: dir
= "--"; break;
1985 case _IOC_READ
: dir
= "r-"; break;
1986 case _IOC_WRITE
: dir
= "-w"; break;
1987 case _IOC_READ
| _IOC_WRITE
: dir
= "rw"; break;
1988 default: dir
= "*ERR*"; break;
1990 pr_cont("%s ioctl '%c', dir=%s, #%d (0x%08x)",
1991 type
, _IOC_TYPE(cmd
), dir
, _IOC_NR(cmd
), cmd
);
1993 EXPORT_SYMBOL(v4l_printk_ioctl
);
1995 static long __video_do_ioctl(struct file
*file
,
1996 unsigned int cmd
, void *arg
)
1998 struct video_device
*vfd
= video_devdata(file
);
1999 const struct v4l2_ioctl_ops
*ops
= vfd
->ioctl_ops
;
2000 bool write_only
= false;
2001 struct v4l2_ioctl_info default_info
;
2002 const struct v4l2_ioctl_info
*info
;
2003 void *fh
= file
->private_data
;
2004 struct v4l2_fh
*vfh
= NULL
;
2005 int use_fh_prio
= 0;
2006 int debug
= vfd
->debug
;
2010 pr_warn("%s: has no ioctl_ops.\n",
2011 video_device_node_name(vfd
));
2015 if (test_bit(V4L2_FL_USES_V4L2_FH
, &vfd
->flags
)) {
2016 vfh
= file
->private_data
;
2017 use_fh_prio
= test_bit(V4L2_FL_USE_FH_PRIO
, &vfd
->flags
);
2020 if (v4l2_is_known_ioctl(cmd
)) {
2021 info
= &v4l2_ioctls
[_IOC_NR(cmd
)];
2023 if (!test_bit(_IOC_NR(cmd
), vfd
->valid_ioctls
) &&
2024 !((info
->flags
& INFO_FL_CTRL
) && vfh
&& vfh
->ctrl_handler
))
2027 if (use_fh_prio
&& (info
->flags
& INFO_FL_PRIO
)) {
2028 ret
= v4l2_prio_check(vfd
->prio
, vfh
->prio
);
2033 default_info
.ioctl
= cmd
;
2034 default_info
.flags
= 0;
2035 default_info
.debug
= v4l_print_default
;
2036 info
= &default_info
;
2039 write_only
= _IOC_DIR(cmd
) == _IOC_WRITE
;
2040 if (write_only
&& debug
> V4L2_DEBUG_IOCTL
) {
2041 v4l_printk_ioctl(video_device_node_name(vfd
), cmd
);
2043 info
->debug(arg
, write_only
);
2045 if (info
->flags
& INFO_FL_STD
) {
2046 typedef int (*vidioc_op
)(struct file
*file
, void *fh
, void *p
);
2047 const void *p
= vfd
->ioctl_ops
;
2048 const vidioc_op
*vidioc
= p
+ info
->offset
;
2050 ret
= (*vidioc
)(file
, fh
, arg
);
2051 } else if (info
->flags
& INFO_FL_FUNC
) {
2052 ret
= info
->func(ops
, file
, fh
, arg
);
2053 } else if (!ops
->vidioc_default
) {
2056 ret
= ops
->vidioc_default(file
, fh
,
2057 use_fh_prio
? v4l2_prio_check(vfd
->prio
, vfh
->prio
) >= 0 : 0,
2063 if (write_only
&& debug
> V4L2_DEBUG_IOCTL
) {
2065 printk(KERN_DEBUG
"%s: error %ld\n",
2066 video_device_node_name(vfd
), ret
);
2069 v4l_printk_ioctl(video_device_node_name(vfd
), cmd
);
2071 pr_cont(": error %ld\n", ret
);
2072 else if (debug
== V4L2_DEBUG_IOCTL
)
2074 else if (_IOC_DIR(cmd
) == _IOC_NONE
)
2075 info
->debug(arg
, write_only
);
2078 info
->debug(arg
, write_only
);
2085 static int check_array_args(unsigned int cmd
, void *parg
, size_t *array_size
,
2086 void * __user
*user_ptr
, void ***kernel_ptr
)
2091 case VIDIOC_QUERYBUF
:
2093 case VIDIOC_DQBUF
: {
2094 struct v4l2_buffer
*buf
= parg
;
2096 if (V4L2_TYPE_IS_MULTIPLANAR(buf
->type
) && buf
->length
> 0) {
2097 if (buf
->length
> VIDEO_MAX_PLANES
) {
2101 *user_ptr
= (void __user
*)buf
->m
.planes
;
2102 *kernel_ptr
= (void *)&buf
->m
.planes
;
2103 *array_size
= sizeof(struct v4l2_plane
) * buf
->length
;
2109 case VIDIOC_S_EXT_CTRLS
:
2110 case VIDIOC_G_EXT_CTRLS
:
2111 case VIDIOC_TRY_EXT_CTRLS
: {
2112 struct v4l2_ext_controls
*ctrls
= parg
;
2114 if (ctrls
->count
!= 0) {
2115 if (ctrls
->count
> V4L2_CID_MAX_CTRLS
) {
2119 *user_ptr
= (void __user
*)ctrls
->controls
;
2120 *kernel_ptr
= (void *)&ctrls
->controls
;
2121 *array_size
= sizeof(struct v4l2_ext_control
)
2133 video_usercopy(struct file
*file
, unsigned int cmd
, unsigned long arg
,
2138 void *parg
= (void *)arg
;
2140 bool has_array_args
;
2141 size_t array_size
= 0;
2142 void __user
*user_ptr
= NULL
;
2143 void **kernel_ptr
= NULL
;
2145 /* Copy arguments into temp kernel buffer */
2146 if (_IOC_DIR(cmd
) != _IOC_NONE
) {
2147 if (_IOC_SIZE(cmd
) <= sizeof(sbuf
)) {
2150 /* too big to allocate from stack */
2151 mbuf
= kmalloc(_IOC_SIZE(cmd
), GFP_KERNEL
);
2158 if (_IOC_DIR(cmd
) & _IOC_WRITE
) {
2159 unsigned int n
= _IOC_SIZE(cmd
);
2162 * In some cases, only a few fields are used as input,
2163 * i.e. when the app sets "index" and then the driver
2164 * fills in the rest of the structure for the thing
2165 * with that index. We only need to copy up the first
2168 if (v4l2_is_known_ioctl(cmd
)) {
2169 u32 flags
= v4l2_ioctls
[_IOC_NR(cmd
)].flags
;
2170 if (flags
& INFO_FL_CLEAR_MASK
)
2171 n
= (flags
& INFO_FL_CLEAR_MASK
) >> 16;
2174 if (copy_from_user(parg
, (void __user
*)arg
, n
))
2177 /* zero out anything we don't copy from userspace */
2178 if (n
< _IOC_SIZE(cmd
))
2179 memset((u8
*)parg
+ n
, 0, _IOC_SIZE(cmd
) - n
);
2181 /* read-only ioctl */
2182 memset(parg
, 0, _IOC_SIZE(cmd
));
2186 err
= check_array_args(cmd
, parg
, &array_size
, &user_ptr
, &kernel_ptr
);
2189 has_array_args
= err
;
2191 if (has_array_args
) {
2193 * When adding new types of array args, make sure that the
2194 * parent argument to ioctl (which contains the pointer to the
2195 * array) fits into sbuf (so that mbuf will still remain
2196 * unused up to here).
2198 mbuf
= kmalloc(array_size
, GFP_KERNEL
);
2201 goto out_array_args
;
2203 if (copy_from_user(mbuf
, user_ptr
, array_size
))
2204 goto out_array_args
;
2209 err
= func(file
, cmd
, parg
);
2210 if (err
== -ENOIOCTLCMD
)
2213 if (has_array_args
) {
2214 *kernel_ptr
= user_ptr
;
2215 if (copy_to_user(user_ptr
, mbuf
, array_size
))
2217 goto out_array_args
;
2219 /* VIDIOC_QUERY_DV_TIMINGS can return an error, but still have valid
2220 results that must be returned. */
2221 if (err
< 0 && cmd
!= VIDIOC_QUERY_DV_TIMINGS
)
2225 /* Copy results into user buffer */
2226 switch (_IOC_DIR(cmd
)) {
2228 case (_IOC_WRITE
| _IOC_READ
):
2229 if (copy_to_user((void __user
*)arg
, parg
, _IOC_SIZE(cmd
)))
2238 EXPORT_SYMBOL(video_usercopy
);
2240 long video_ioctl2(struct file
*file
,
2241 unsigned int cmd
, unsigned long arg
)
2243 return video_usercopy(file
, cmd
, arg
, __video_do_ioctl
);
2245 EXPORT_SYMBOL(video_ioctl2
);