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)
16 #include <linux/module.h>
17 #include <linux/slab.h>
18 #include <linux/types.h>
19 #include <linux/kernel.h>
20 #include <linux/version.h>
22 #include <linux/videodev2.h>
24 #include <media/v4l2-common.h>
25 #include <media/v4l2-ioctl.h>
26 #include <media/v4l2-ctrls.h>
27 #include <media/v4l2-fh.h>
28 #include <media/v4l2-event.h>
29 #include <media/v4l2-device.h>
30 #include <media/videobuf2-v4l2.h>
31 #include <media/v4l2-mc.h>
33 #include <trace/events/v4l2.h>
35 /* Zero out the end of the struct pointed to by p. Everything after, but
36 * not including, the specified field is cleared. */
37 #define CLEAR_AFTER_FIELD(p, field) \
38 memset((u8 *)(p) + offsetof(typeof(*(p)), field) + sizeof((p)->field), \
39 0, sizeof(*(p)) - offsetof(typeof(*(p)), field) - sizeof((p)->field))
41 #define is_valid_ioctl(vfd, cmd) test_bit(_IOC_NR(cmd), (vfd)->valid_ioctls)
48 static const struct std_descr standards
[] = {
49 { V4L2_STD_NTSC
, "NTSC" },
50 { V4L2_STD_NTSC_M
, "NTSC-M" },
51 { V4L2_STD_NTSC_M_JP
, "NTSC-M-JP" },
52 { V4L2_STD_NTSC_M_KR
, "NTSC-M-KR" },
53 { V4L2_STD_NTSC_443
, "NTSC-443" },
54 { V4L2_STD_PAL
, "PAL" },
55 { V4L2_STD_PAL_BG
, "PAL-BG" },
56 { V4L2_STD_PAL_B
, "PAL-B" },
57 { V4L2_STD_PAL_B1
, "PAL-B1" },
58 { V4L2_STD_PAL_G
, "PAL-G" },
59 { V4L2_STD_PAL_H
, "PAL-H" },
60 { V4L2_STD_PAL_I
, "PAL-I" },
61 { V4L2_STD_PAL_DK
, "PAL-DK" },
62 { V4L2_STD_PAL_D
, "PAL-D" },
63 { V4L2_STD_PAL_D1
, "PAL-D1" },
64 { V4L2_STD_PAL_K
, "PAL-K" },
65 { V4L2_STD_PAL_M
, "PAL-M" },
66 { V4L2_STD_PAL_N
, "PAL-N" },
67 { V4L2_STD_PAL_Nc
, "PAL-Nc" },
68 { V4L2_STD_PAL_60
, "PAL-60" },
69 { V4L2_STD_SECAM
, "SECAM" },
70 { V4L2_STD_SECAM_B
, "SECAM-B" },
71 { V4L2_STD_SECAM_G
, "SECAM-G" },
72 { V4L2_STD_SECAM_H
, "SECAM-H" },
73 { V4L2_STD_SECAM_DK
, "SECAM-DK" },
74 { V4L2_STD_SECAM_D
, "SECAM-D" },
75 { V4L2_STD_SECAM_K
, "SECAM-K" },
76 { V4L2_STD_SECAM_K1
, "SECAM-K1" },
77 { V4L2_STD_SECAM_L
, "SECAM-L" },
78 { V4L2_STD_SECAM_LC
, "SECAM-Lc" },
82 /* video4linux standard ID conversion to standard name
84 const char *v4l2_norm_to_name(v4l2_std_id id
)
89 /* HACK: ppc32 architecture doesn't have __ucmpdi2 function to handle
90 64 bit comparations. So, on that architecture, with some gcc
91 variants, compilation fails. Currently, the max value is 30bit wide.
95 for (i
= 0; standards
[i
].std
; i
++)
96 if (myid
== standards
[i
].std
)
98 return standards
[i
].descr
;
100 EXPORT_SYMBOL(v4l2_norm_to_name
);
102 /* Returns frame period for the given standard */
103 void v4l2_video_std_frame_period(int id
, struct v4l2_fract
*frameperiod
)
105 if (id
& V4L2_STD_525_60
) {
106 frameperiod
->numerator
= 1001;
107 frameperiod
->denominator
= 30000;
109 frameperiod
->numerator
= 1;
110 frameperiod
->denominator
= 25;
113 EXPORT_SYMBOL(v4l2_video_std_frame_period
);
115 /* Fill in the fields of a v4l2_standard structure according to the
116 'id' and 'transmission' parameters. Returns negative on error. */
117 int v4l2_video_std_construct(struct v4l2_standard
*vs
,
118 int id
, const char *name
)
121 v4l2_video_std_frame_period(id
, &vs
->frameperiod
);
122 vs
->framelines
= (id
& V4L2_STD_525_60
) ? 525 : 625;
123 strlcpy(vs
->name
, name
, sizeof(vs
->name
));
126 EXPORT_SYMBOL(v4l2_video_std_construct
);
128 /* ----------------------------------------------------------------- */
129 /* some arrays for pretty-printing debug messages of enum types */
131 const char *v4l2_field_names
[] = {
132 [V4L2_FIELD_ANY
] = "any",
133 [V4L2_FIELD_NONE
] = "none",
134 [V4L2_FIELD_TOP
] = "top",
135 [V4L2_FIELD_BOTTOM
] = "bottom",
136 [V4L2_FIELD_INTERLACED
] = "interlaced",
137 [V4L2_FIELD_SEQ_TB
] = "seq-tb",
138 [V4L2_FIELD_SEQ_BT
] = "seq-bt",
139 [V4L2_FIELD_ALTERNATE
] = "alternate",
140 [V4L2_FIELD_INTERLACED_TB
] = "interlaced-tb",
141 [V4L2_FIELD_INTERLACED_BT
] = "interlaced-bt",
143 EXPORT_SYMBOL(v4l2_field_names
);
145 const char *v4l2_type_names
[] = {
147 [V4L2_BUF_TYPE_VIDEO_CAPTURE
] = "vid-cap",
148 [V4L2_BUF_TYPE_VIDEO_OVERLAY
] = "vid-overlay",
149 [V4L2_BUF_TYPE_VIDEO_OUTPUT
] = "vid-out",
150 [V4L2_BUF_TYPE_VBI_CAPTURE
] = "vbi-cap",
151 [V4L2_BUF_TYPE_VBI_OUTPUT
] = "vbi-out",
152 [V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
] = "sliced-vbi-cap",
153 [V4L2_BUF_TYPE_SLICED_VBI_OUTPUT
] = "sliced-vbi-out",
154 [V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY
] = "vid-out-overlay",
155 [V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
] = "vid-cap-mplane",
156 [V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
] = "vid-out-mplane",
157 [V4L2_BUF_TYPE_SDR_CAPTURE
] = "sdr-cap",
158 [V4L2_BUF_TYPE_SDR_OUTPUT
] = "sdr-out",
159 [V4L2_BUF_TYPE_META_CAPTURE
] = "meta-cap",
161 EXPORT_SYMBOL(v4l2_type_names
);
163 static const char *v4l2_memory_names
[] = {
164 [V4L2_MEMORY_MMAP
] = "mmap",
165 [V4L2_MEMORY_USERPTR
] = "userptr",
166 [V4L2_MEMORY_OVERLAY
] = "overlay",
167 [V4L2_MEMORY_DMABUF
] = "dmabuf",
170 #define prt_names(a, arr) (((unsigned)(a)) < ARRAY_SIZE(arr) ? arr[a] : "unknown")
172 /* ------------------------------------------------------------------ */
173 /* debug help functions */
175 static void v4l_print_querycap(const void *arg
, bool write_only
)
177 const struct v4l2_capability
*p
= arg
;
179 pr_cont("driver=%.*s, card=%.*s, bus=%.*s, version=0x%08x, capabilities=0x%08x, device_caps=0x%08x\n",
180 (int)sizeof(p
->driver
), p
->driver
,
181 (int)sizeof(p
->card
), p
->card
,
182 (int)sizeof(p
->bus_info
), p
->bus_info
,
183 p
->version
, p
->capabilities
, p
->device_caps
);
186 static void v4l_print_enuminput(const void *arg
, bool write_only
)
188 const struct v4l2_input
*p
= arg
;
190 pr_cont("index=%u, name=%.*s, type=%u, audioset=0x%x, tuner=%u, std=0x%08Lx, status=0x%x, capabilities=0x%x\n",
191 p
->index
, (int)sizeof(p
->name
), p
->name
, p
->type
, p
->audioset
,
192 p
->tuner
, (unsigned long long)p
->std
, p
->status
,
196 static void v4l_print_enumoutput(const void *arg
, bool write_only
)
198 const struct v4l2_output
*p
= arg
;
200 pr_cont("index=%u, name=%.*s, type=%u, audioset=0x%x, modulator=%u, std=0x%08Lx, capabilities=0x%x\n",
201 p
->index
, (int)sizeof(p
->name
), p
->name
, p
->type
, p
->audioset
,
202 p
->modulator
, (unsigned long long)p
->std
, p
->capabilities
);
205 static void v4l_print_audio(const void *arg
, bool write_only
)
207 const struct v4l2_audio
*p
= arg
;
210 pr_cont("index=%u, mode=0x%x\n", p
->index
, p
->mode
);
212 pr_cont("index=%u, name=%.*s, capability=0x%x, mode=0x%x\n",
213 p
->index
, (int)sizeof(p
->name
), p
->name
,
214 p
->capability
, p
->mode
);
217 static void v4l_print_audioout(const void *arg
, bool write_only
)
219 const struct v4l2_audioout
*p
= arg
;
222 pr_cont("index=%u\n", p
->index
);
224 pr_cont("index=%u, name=%.*s, capability=0x%x, mode=0x%x\n",
225 p
->index
, (int)sizeof(p
->name
), p
->name
,
226 p
->capability
, p
->mode
);
229 static void v4l_print_fmtdesc(const void *arg
, bool write_only
)
231 const struct v4l2_fmtdesc
*p
= arg
;
233 pr_cont("index=%u, type=%s, flags=0x%x, pixelformat=%c%c%c%c, description='%.*s'\n",
234 p
->index
, prt_names(p
->type
, v4l2_type_names
),
235 p
->flags
, (p
->pixelformat
& 0xff),
236 (p
->pixelformat
>> 8) & 0xff,
237 (p
->pixelformat
>> 16) & 0xff,
238 (p
->pixelformat
>> 24) & 0xff,
239 (int)sizeof(p
->description
), p
->description
);
242 static void v4l_print_format(const void *arg
, bool write_only
)
244 const struct v4l2_format
*p
= arg
;
245 const struct v4l2_pix_format
*pix
;
246 const struct v4l2_pix_format_mplane
*mp
;
247 const struct v4l2_vbi_format
*vbi
;
248 const struct v4l2_sliced_vbi_format
*sliced
;
249 const struct v4l2_window
*win
;
250 const struct v4l2_sdr_format
*sdr
;
251 const struct v4l2_meta_format
*meta
;
255 pr_cont("type=%s", prt_names(p
->type
, v4l2_type_names
));
257 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
258 case V4L2_BUF_TYPE_VIDEO_OUTPUT
:
260 pr_cont(", width=%u, height=%u, pixelformat=%c%c%c%c, field=%s, bytesperline=%u, sizeimage=%u, colorspace=%d, flags=0x%x, ycbcr_enc=%u, quantization=%u, xfer_func=%u\n",
261 pix
->width
, pix
->height
,
262 (pix
->pixelformat
& 0xff),
263 (pix
->pixelformat
>> 8) & 0xff,
264 (pix
->pixelformat
>> 16) & 0xff,
265 (pix
->pixelformat
>> 24) & 0xff,
266 prt_names(pix
->field
, v4l2_field_names
),
267 pix
->bytesperline
, pix
->sizeimage
,
268 pix
->colorspace
, pix
->flags
, pix
->ycbcr_enc
,
269 pix
->quantization
, pix
->xfer_func
);
271 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
:
272 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
:
274 pr_cont(", width=%u, height=%u, format=%c%c%c%c, field=%s, colorspace=%d, num_planes=%u, flags=0x%x, ycbcr_enc=%u, quantization=%u, xfer_func=%u\n",
275 mp
->width
, mp
->height
,
276 (mp
->pixelformat
& 0xff),
277 (mp
->pixelformat
>> 8) & 0xff,
278 (mp
->pixelformat
>> 16) & 0xff,
279 (mp
->pixelformat
>> 24) & 0xff,
280 prt_names(mp
->field
, v4l2_field_names
),
281 mp
->colorspace
, mp
->num_planes
, mp
->flags
,
282 mp
->ycbcr_enc
, mp
->quantization
, mp
->xfer_func
);
283 planes
= min_t(u32
, mp
->num_planes
, VIDEO_MAX_PLANES
);
284 for (i
= 0; i
< planes
; i
++)
285 printk(KERN_DEBUG
"plane %u: bytesperline=%u sizeimage=%u\n", i
,
286 mp
->plane_fmt
[i
].bytesperline
,
287 mp
->plane_fmt
[i
].sizeimage
);
289 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
290 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY
:
292 /* Note: we can't print the clip list here since the clips
293 * pointer is a userspace pointer, not a kernelspace
295 pr_cont(", wxh=%dx%d, x,y=%d,%d, field=%s, chromakey=0x%08x, clipcount=%u, clips=%p, bitmap=%p, global_alpha=0x%02x\n",
296 win
->w
.width
, win
->w
.height
, win
->w
.left
, win
->w
.top
,
297 prt_names(win
->field
, v4l2_field_names
),
298 win
->chromakey
, win
->clipcount
, win
->clips
,
299 win
->bitmap
, win
->global_alpha
);
301 case V4L2_BUF_TYPE_VBI_CAPTURE
:
302 case V4L2_BUF_TYPE_VBI_OUTPUT
:
304 pr_cont(", sampling_rate=%u, offset=%u, samples_per_line=%u, sample_format=%c%c%c%c, start=%u,%u, count=%u,%u\n",
305 vbi
->sampling_rate
, vbi
->offset
,
306 vbi
->samples_per_line
,
307 (vbi
->sample_format
& 0xff),
308 (vbi
->sample_format
>> 8) & 0xff,
309 (vbi
->sample_format
>> 16) & 0xff,
310 (vbi
->sample_format
>> 24) & 0xff,
311 vbi
->start
[0], vbi
->start
[1],
312 vbi
->count
[0], vbi
->count
[1]);
314 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
:
315 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT
:
316 sliced
= &p
->fmt
.sliced
;
317 pr_cont(", service_set=0x%08x, io_size=%d\n",
318 sliced
->service_set
, sliced
->io_size
);
319 for (i
= 0; i
< 24; i
++)
320 printk(KERN_DEBUG
"line[%02u]=0x%04x, 0x%04x\n", i
,
321 sliced
->service_lines
[0][i
],
322 sliced
->service_lines
[1][i
]);
324 case V4L2_BUF_TYPE_SDR_CAPTURE
:
325 case V4L2_BUF_TYPE_SDR_OUTPUT
:
327 pr_cont(", pixelformat=%c%c%c%c\n",
328 (sdr
->pixelformat
>> 0) & 0xff,
329 (sdr
->pixelformat
>> 8) & 0xff,
330 (sdr
->pixelformat
>> 16) & 0xff,
331 (sdr
->pixelformat
>> 24) & 0xff);
333 case V4L2_BUF_TYPE_META_CAPTURE
:
335 pr_cont(", dataformat=%c%c%c%c, buffersize=%u\n",
336 (meta
->dataformat
>> 0) & 0xff,
337 (meta
->dataformat
>> 8) & 0xff,
338 (meta
->dataformat
>> 16) & 0xff,
339 (meta
->dataformat
>> 24) & 0xff,
345 static void v4l_print_framebuffer(const void *arg
, bool write_only
)
347 const struct v4l2_framebuffer
*p
= arg
;
349 pr_cont("capability=0x%x, flags=0x%x, base=0x%p, width=%u, height=%u, pixelformat=%c%c%c%c, bytesperline=%u, sizeimage=%u, colorspace=%d\n",
350 p
->capability
, p
->flags
, p
->base
,
351 p
->fmt
.width
, p
->fmt
.height
,
352 (p
->fmt
.pixelformat
& 0xff),
353 (p
->fmt
.pixelformat
>> 8) & 0xff,
354 (p
->fmt
.pixelformat
>> 16) & 0xff,
355 (p
->fmt
.pixelformat
>> 24) & 0xff,
356 p
->fmt
.bytesperline
, p
->fmt
.sizeimage
,
360 static void v4l_print_buftype(const void *arg
, bool write_only
)
362 pr_cont("type=%s\n", prt_names(*(u32
*)arg
, v4l2_type_names
));
365 static void v4l_print_modulator(const void *arg
, bool write_only
)
367 const struct v4l2_modulator
*p
= arg
;
370 pr_cont("index=%u, txsubchans=0x%x\n", p
->index
, p
->txsubchans
);
372 pr_cont("index=%u, name=%.*s, capability=0x%x, rangelow=%u, rangehigh=%u, txsubchans=0x%x\n",
373 p
->index
, (int)sizeof(p
->name
), p
->name
, p
->capability
,
374 p
->rangelow
, p
->rangehigh
, p
->txsubchans
);
377 static void v4l_print_tuner(const void *arg
, bool write_only
)
379 const struct v4l2_tuner
*p
= arg
;
382 pr_cont("index=%u, audmode=%u\n", p
->index
, p
->audmode
);
384 pr_cont("index=%u, name=%.*s, type=%u, capability=0x%x, rangelow=%u, rangehigh=%u, signal=%u, afc=%d, rxsubchans=0x%x, audmode=%u\n",
385 p
->index
, (int)sizeof(p
->name
), p
->name
, p
->type
,
386 p
->capability
, p
->rangelow
,
387 p
->rangehigh
, p
->signal
, p
->afc
,
388 p
->rxsubchans
, p
->audmode
);
391 static void v4l_print_frequency(const void *arg
, bool write_only
)
393 const struct v4l2_frequency
*p
= arg
;
395 pr_cont("tuner=%u, type=%u, frequency=%u\n",
396 p
->tuner
, p
->type
, p
->frequency
);
399 static void v4l_print_standard(const void *arg
, bool write_only
)
401 const struct v4l2_standard
*p
= arg
;
403 pr_cont("index=%u, id=0x%Lx, name=%.*s, fps=%u/%u, framelines=%u\n",
405 (unsigned long long)p
->id
, (int)sizeof(p
->name
), p
->name
,
406 p
->frameperiod
.numerator
,
407 p
->frameperiod
.denominator
,
411 static void v4l_print_std(const void *arg
, bool write_only
)
413 pr_cont("std=0x%08Lx\n", *(const long long unsigned *)arg
);
416 static void v4l_print_hw_freq_seek(const void *arg
, bool write_only
)
418 const struct v4l2_hw_freq_seek
*p
= arg
;
420 pr_cont("tuner=%u, type=%u, seek_upward=%u, wrap_around=%u, spacing=%u, rangelow=%u, rangehigh=%u\n",
421 p
->tuner
, p
->type
, p
->seek_upward
, p
->wrap_around
, p
->spacing
,
422 p
->rangelow
, p
->rangehigh
);
425 static void v4l_print_requestbuffers(const void *arg
, bool write_only
)
427 const struct v4l2_requestbuffers
*p
= arg
;
429 pr_cont("count=%d, type=%s, memory=%s\n",
431 prt_names(p
->type
, v4l2_type_names
),
432 prt_names(p
->memory
, v4l2_memory_names
));
435 static void v4l_print_buffer(const void *arg
, bool write_only
)
437 const struct v4l2_buffer
*p
= arg
;
438 const struct v4l2_timecode
*tc
= &p
->timecode
;
439 const struct v4l2_plane
*plane
;
442 pr_cont("%02ld:%02d:%02d.%08ld index=%d, type=%s, flags=0x%08x, field=%s, sequence=%d, memory=%s",
443 p
->timestamp
.tv_sec
/ 3600,
444 (int)(p
->timestamp
.tv_sec
/ 60) % 60,
445 (int)(p
->timestamp
.tv_sec
% 60),
446 (long)p
->timestamp
.tv_usec
,
448 prt_names(p
->type
, v4l2_type_names
),
449 p
->flags
, prt_names(p
->field
, v4l2_field_names
),
450 p
->sequence
, prt_names(p
->memory
, v4l2_memory_names
));
452 if (V4L2_TYPE_IS_MULTIPLANAR(p
->type
) && p
->m
.planes
) {
454 for (i
= 0; i
< p
->length
; ++i
) {
455 plane
= &p
->m
.planes
[i
];
457 "plane %d: bytesused=%d, data_offset=0x%08x, offset/userptr=0x%lx, length=%d\n",
458 i
, plane
->bytesused
, plane
->data_offset
,
459 plane
->m
.userptr
, plane
->length
);
462 pr_cont(", bytesused=%d, offset/userptr=0x%lx, length=%d\n",
463 p
->bytesused
, p
->m
.userptr
, p
->length
);
466 printk(KERN_DEBUG
"timecode=%02d:%02d:%02d type=%d, flags=0x%08x, frames=%d, userbits=0x%08x\n",
467 tc
->hours
, tc
->minutes
, tc
->seconds
,
468 tc
->type
, tc
->flags
, tc
->frames
, *(__u32
*)tc
->userbits
);
471 static void v4l_print_exportbuffer(const void *arg
, bool write_only
)
473 const struct v4l2_exportbuffer
*p
= arg
;
475 pr_cont("fd=%d, type=%s, index=%u, plane=%u, flags=0x%08x\n",
476 p
->fd
, prt_names(p
->type
, v4l2_type_names
),
477 p
->index
, p
->plane
, p
->flags
);
480 static void v4l_print_create_buffers(const void *arg
, bool write_only
)
482 const struct v4l2_create_buffers
*p
= arg
;
484 pr_cont("index=%d, count=%d, memory=%s, ",
486 prt_names(p
->memory
, v4l2_memory_names
));
487 v4l_print_format(&p
->format
, write_only
);
490 static void v4l_print_streamparm(const void *arg
, bool write_only
)
492 const struct v4l2_streamparm
*p
= arg
;
494 pr_cont("type=%s", prt_names(p
->type
, v4l2_type_names
));
496 if (p
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
||
497 p
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
) {
498 const struct v4l2_captureparm
*c
= &p
->parm
.capture
;
500 pr_cont(", capability=0x%x, capturemode=0x%x, timeperframe=%d/%d, extendedmode=%d, readbuffers=%d\n",
501 c
->capability
, c
->capturemode
,
502 c
->timeperframe
.numerator
, c
->timeperframe
.denominator
,
503 c
->extendedmode
, c
->readbuffers
);
504 } else if (p
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
||
505 p
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
) {
506 const struct v4l2_outputparm
*c
= &p
->parm
.output
;
508 pr_cont(", capability=0x%x, outputmode=0x%x, timeperframe=%d/%d, extendedmode=%d, writebuffers=%d\n",
509 c
->capability
, c
->outputmode
,
510 c
->timeperframe
.numerator
, c
->timeperframe
.denominator
,
511 c
->extendedmode
, c
->writebuffers
);
517 static void v4l_print_queryctrl(const void *arg
, bool write_only
)
519 const struct v4l2_queryctrl
*p
= arg
;
521 pr_cont("id=0x%x, type=%d, name=%.*s, min/max=%d/%d, step=%d, default=%d, flags=0x%08x\n",
522 p
->id
, p
->type
, (int)sizeof(p
->name
), p
->name
,
523 p
->minimum
, p
->maximum
,
524 p
->step
, p
->default_value
, p
->flags
);
527 static void v4l_print_query_ext_ctrl(const void *arg
, bool write_only
)
529 const struct v4l2_query_ext_ctrl
*p
= arg
;
531 pr_cont("id=0x%x, type=%d, name=%.*s, min/max=%lld/%lld, step=%lld, default=%lld, flags=0x%08x, elem_size=%u, elems=%u, nr_of_dims=%u, dims=%u,%u,%u,%u\n",
532 p
->id
, p
->type
, (int)sizeof(p
->name
), p
->name
,
533 p
->minimum
, p
->maximum
,
534 p
->step
, p
->default_value
, p
->flags
,
535 p
->elem_size
, p
->elems
, p
->nr_of_dims
,
536 p
->dims
[0], p
->dims
[1], p
->dims
[2], p
->dims
[3]);
539 static void v4l_print_querymenu(const void *arg
, bool write_only
)
541 const struct v4l2_querymenu
*p
= arg
;
543 pr_cont("id=0x%x, index=%d\n", p
->id
, p
->index
);
546 static void v4l_print_control(const void *arg
, bool write_only
)
548 const struct v4l2_control
*p
= arg
;
550 pr_cont("id=0x%x, value=%d\n", p
->id
, p
->value
);
553 static void v4l_print_ext_controls(const void *arg
, bool write_only
)
555 const struct v4l2_ext_controls
*p
= arg
;
558 pr_cont("which=0x%x, count=%d, error_idx=%d",
559 p
->which
, p
->count
, p
->error_idx
);
560 for (i
= 0; i
< p
->count
; i
++) {
561 if (!p
->controls
[i
].size
)
562 pr_cont(", id/val=0x%x/0x%x",
563 p
->controls
[i
].id
, p
->controls
[i
].value
);
565 pr_cont(", id/size=0x%x/%u",
566 p
->controls
[i
].id
, p
->controls
[i
].size
);
571 static void v4l_print_cropcap(const void *arg
, bool write_only
)
573 const struct v4l2_cropcap
*p
= arg
;
575 pr_cont("type=%s, bounds wxh=%dx%d, x,y=%d,%d, defrect wxh=%dx%d, x,y=%d,%d, pixelaspect %d/%d\n",
576 prt_names(p
->type
, v4l2_type_names
),
577 p
->bounds
.width
, p
->bounds
.height
,
578 p
->bounds
.left
, p
->bounds
.top
,
579 p
->defrect
.width
, p
->defrect
.height
,
580 p
->defrect
.left
, p
->defrect
.top
,
581 p
->pixelaspect
.numerator
, p
->pixelaspect
.denominator
);
584 static void v4l_print_crop(const void *arg
, bool write_only
)
586 const struct v4l2_crop
*p
= arg
;
588 pr_cont("type=%s, wxh=%dx%d, x,y=%d,%d\n",
589 prt_names(p
->type
, v4l2_type_names
),
590 p
->c
.width
, p
->c
.height
,
591 p
->c
.left
, p
->c
.top
);
594 static void v4l_print_selection(const void *arg
, bool write_only
)
596 const struct v4l2_selection
*p
= arg
;
598 pr_cont("type=%s, target=%d, flags=0x%x, wxh=%dx%d, x,y=%d,%d\n",
599 prt_names(p
->type
, v4l2_type_names
),
601 p
->r
.width
, p
->r
.height
, p
->r
.left
, p
->r
.top
);
604 static void v4l_print_jpegcompression(const void *arg
, bool write_only
)
606 const struct v4l2_jpegcompression
*p
= arg
;
608 pr_cont("quality=%d, APPn=%d, APP_len=%d, COM_len=%d, jpeg_markers=0x%x\n",
609 p
->quality
, p
->APPn
, p
->APP_len
,
610 p
->COM_len
, p
->jpeg_markers
);
613 static void v4l_print_enc_idx(const void *arg
, bool write_only
)
615 const struct v4l2_enc_idx
*p
= arg
;
617 pr_cont("entries=%d, entries_cap=%d\n",
618 p
->entries
, p
->entries_cap
);
621 static void v4l_print_encoder_cmd(const void *arg
, bool write_only
)
623 const struct v4l2_encoder_cmd
*p
= arg
;
625 pr_cont("cmd=%d, flags=0x%x\n",
629 static void v4l_print_decoder_cmd(const void *arg
, bool write_only
)
631 const struct v4l2_decoder_cmd
*p
= arg
;
633 pr_cont("cmd=%d, flags=0x%x\n", p
->cmd
, p
->flags
);
635 if (p
->cmd
== V4L2_DEC_CMD_START
)
636 pr_info("speed=%d, format=%u\n",
637 p
->start
.speed
, p
->start
.format
);
638 else if (p
->cmd
== V4L2_DEC_CMD_STOP
)
639 pr_info("pts=%llu\n", p
->stop
.pts
);
642 static void v4l_print_dbg_chip_info(const void *arg
, bool write_only
)
644 const struct v4l2_dbg_chip_info
*p
= arg
;
646 pr_cont("type=%u, ", p
->match
.type
);
647 if (p
->match
.type
== V4L2_CHIP_MATCH_I2C_DRIVER
)
648 pr_cont("name=%.*s, ",
649 (int)sizeof(p
->match
.name
), p
->match
.name
);
651 pr_cont("addr=%u, ", p
->match
.addr
);
652 pr_cont("name=%.*s\n", (int)sizeof(p
->name
), p
->name
);
655 static void v4l_print_dbg_register(const void *arg
, bool write_only
)
657 const struct v4l2_dbg_register
*p
= arg
;
659 pr_cont("type=%u, ", p
->match
.type
);
660 if (p
->match
.type
== V4L2_CHIP_MATCH_I2C_DRIVER
)
661 pr_cont("name=%.*s, ",
662 (int)sizeof(p
->match
.name
), p
->match
.name
);
664 pr_cont("addr=%u, ", p
->match
.addr
);
665 pr_cont("reg=0x%llx, val=0x%llx\n",
669 static void v4l_print_dv_timings(const void *arg
, bool write_only
)
671 const struct v4l2_dv_timings
*p
= arg
;
674 case V4L2_DV_BT_656_1120
:
675 pr_cont("type=bt-656/1120, interlaced=%u, pixelclock=%llu, width=%u, height=%u, polarities=0x%x, hfrontporch=%u, hsync=%u, hbackporch=%u, vfrontporch=%u, vsync=%u, vbackporch=%u, il_vfrontporch=%u, il_vsync=%u, il_vbackporch=%u, standards=0x%x, flags=0x%x\n",
676 p
->bt
.interlaced
, p
->bt
.pixelclock
,
677 p
->bt
.width
, p
->bt
.height
,
678 p
->bt
.polarities
, p
->bt
.hfrontporch
,
679 p
->bt
.hsync
, p
->bt
.hbackporch
,
680 p
->bt
.vfrontporch
, p
->bt
.vsync
,
681 p
->bt
.vbackporch
, p
->bt
.il_vfrontporch
,
682 p
->bt
.il_vsync
, p
->bt
.il_vbackporch
,
683 p
->bt
.standards
, p
->bt
.flags
);
686 pr_cont("type=%d\n", p
->type
);
691 static void v4l_print_enum_dv_timings(const void *arg
, bool write_only
)
693 const struct v4l2_enum_dv_timings
*p
= arg
;
695 pr_cont("index=%u, ", p
->index
);
696 v4l_print_dv_timings(&p
->timings
, write_only
);
699 static void v4l_print_dv_timings_cap(const void *arg
, bool write_only
)
701 const struct v4l2_dv_timings_cap
*p
= arg
;
704 case V4L2_DV_BT_656_1120
:
705 pr_cont("type=bt-656/1120, width=%u-%u, height=%u-%u, pixelclock=%llu-%llu, standards=0x%x, capabilities=0x%x\n",
706 p
->bt
.min_width
, p
->bt
.max_width
,
707 p
->bt
.min_height
, p
->bt
.max_height
,
708 p
->bt
.min_pixelclock
, p
->bt
.max_pixelclock
,
709 p
->bt
.standards
, p
->bt
.capabilities
);
712 pr_cont("type=%u\n", p
->type
);
717 static void v4l_print_frmsizeenum(const void *arg
, bool write_only
)
719 const struct v4l2_frmsizeenum
*p
= arg
;
721 pr_cont("index=%u, pixelformat=%c%c%c%c, type=%u",
723 (p
->pixel_format
& 0xff),
724 (p
->pixel_format
>> 8) & 0xff,
725 (p
->pixel_format
>> 16) & 0xff,
726 (p
->pixel_format
>> 24) & 0xff,
729 case V4L2_FRMSIZE_TYPE_DISCRETE
:
730 pr_cont(", wxh=%ux%u\n",
731 p
->discrete
.width
, p
->discrete
.height
);
733 case V4L2_FRMSIZE_TYPE_STEPWISE
:
734 pr_cont(", min=%ux%u, max=%ux%u, step=%ux%u\n",
735 p
->stepwise
.min_width
,
736 p
->stepwise
.min_height
,
737 p
->stepwise
.max_width
,
738 p
->stepwise
.max_height
,
739 p
->stepwise
.step_width
,
740 p
->stepwise
.step_height
);
742 case V4L2_FRMSIZE_TYPE_CONTINUOUS
:
750 static void v4l_print_frmivalenum(const void *arg
, bool write_only
)
752 const struct v4l2_frmivalenum
*p
= arg
;
754 pr_cont("index=%u, pixelformat=%c%c%c%c, wxh=%ux%u, type=%u",
756 (p
->pixel_format
& 0xff),
757 (p
->pixel_format
>> 8) & 0xff,
758 (p
->pixel_format
>> 16) & 0xff,
759 (p
->pixel_format
>> 24) & 0xff,
760 p
->width
, p
->height
, p
->type
);
762 case V4L2_FRMIVAL_TYPE_DISCRETE
:
763 pr_cont(", fps=%d/%d\n",
764 p
->discrete
.numerator
,
765 p
->discrete
.denominator
);
767 case V4L2_FRMIVAL_TYPE_STEPWISE
:
768 pr_cont(", min=%d/%d, max=%d/%d, step=%d/%d\n",
769 p
->stepwise
.min
.numerator
,
770 p
->stepwise
.min
.denominator
,
771 p
->stepwise
.max
.numerator
,
772 p
->stepwise
.max
.denominator
,
773 p
->stepwise
.step
.numerator
,
774 p
->stepwise
.step
.denominator
);
776 case V4L2_FRMIVAL_TYPE_CONTINUOUS
:
784 static void v4l_print_event(const void *arg
, bool write_only
)
786 const struct v4l2_event
*p
= arg
;
787 const struct v4l2_event_ctrl
*c
;
789 pr_cont("type=0x%x, pending=%u, sequence=%u, id=%u, timestamp=%lu.%9.9lu\n",
790 p
->type
, p
->pending
, p
->sequence
, p
->id
,
791 p
->timestamp
.tv_sec
, p
->timestamp
.tv_nsec
);
793 case V4L2_EVENT_VSYNC
:
794 printk(KERN_DEBUG
"field=%s\n",
795 prt_names(p
->u
.vsync
.field
, v4l2_field_names
));
797 case V4L2_EVENT_CTRL
:
799 printk(KERN_DEBUG
"changes=0x%x, type=%u, ",
800 c
->changes
, c
->type
);
801 if (c
->type
== V4L2_CTRL_TYPE_INTEGER64
)
802 pr_cont("value64=%lld, ", c
->value64
);
804 pr_cont("value=%d, ", c
->value
);
805 pr_cont("flags=0x%x, minimum=%d, maximum=%d, step=%d, default_value=%d\n",
806 c
->flags
, c
->minimum
, c
->maximum
,
807 c
->step
, c
->default_value
);
809 case V4L2_EVENT_FRAME_SYNC
:
810 pr_cont("frame_sequence=%u\n",
811 p
->u
.frame_sync
.frame_sequence
);
816 static void v4l_print_event_subscription(const void *arg
, bool write_only
)
818 const struct v4l2_event_subscription
*p
= arg
;
820 pr_cont("type=0x%x, id=0x%x, flags=0x%x\n",
821 p
->type
, p
->id
, p
->flags
);
824 static void v4l_print_sliced_vbi_cap(const void *arg
, bool write_only
)
826 const struct v4l2_sliced_vbi_cap
*p
= arg
;
829 pr_cont("type=%s, service_set=0x%08x\n",
830 prt_names(p
->type
, v4l2_type_names
), p
->service_set
);
831 for (i
= 0; i
< 24; i
++)
832 printk(KERN_DEBUG
"line[%02u]=0x%04x, 0x%04x\n", i
,
833 p
->service_lines
[0][i
],
834 p
->service_lines
[1][i
]);
837 static void v4l_print_freq_band(const void *arg
, bool write_only
)
839 const struct v4l2_frequency_band
*p
= arg
;
841 pr_cont("tuner=%u, type=%u, index=%u, capability=0x%x, rangelow=%u, rangehigh=%u, modulation=0x%x\n",
842 p
->tuner
, p
->type
, p
->index
,
843 p
->capability
, p
->rangelow
,
844 p
->rangehigh
, p
->modulation
);
847 static void v4l_print_edid(const void *arg
, bool write_only
)
849 const struct v4l2_edid
*p
= arg
;
851 pr_cont("pad=%u, start_block=%u, blocks=%u\n",
852 p
->pad
, p
->start_block
, p
->blocks
);
855 static void v4l_print_u32(const void *arg
, bool write_only
)
857 pr_cont("value=%u\n", *(const u32
*)arg
);
860 static void v4l_print_newline(const void *arg
, bool write_only
)
865 static void v4l_print_default(const void *arg
, bool write_only
)
867 pr_cont("driver-specific ioctl\n");
870 static int check_ext_ctrls(struct v4l2_ext_controls
*c
, int allow_priv
)
874 /* zero the reserved fields */
875 c
->reserved
[0] = c
->reserved
[1] = 0;
876 for (i
= 0; i
< c
->count
; i
++)
877 c
->controls
[i
].reserved2
[0] = 0;
879 /* V4L2_CID_PRIVATE_BASE cannot be used as control class
880 when using extended controls.
881 Only when passed in through VIDIOC_G_CTRL and VIDIOC_S_CTRL
882 is it allowed for backwards compatibility.
884 if (!allow_priv
&& c
->which
== V4L2_CID_PRIVATE_BASE
)
888 /* Check that all controls are from the same control class. */
889 for (i
= 0; i
< c
->count
; i
++) {
890 if (V4L2_CTRL_ID2WHICH(c
->controls
[i
].id
) != c
->which
) {
898 static int check_fmt(struct file
*file
, enum v4l2_buf_type type
)
900 struct video_device
*vfd
= video_devdata(file
);
901 const struct v4l2_ioctl_ops
*ops
= vfd
->ioctl_ops
;
902 bool is_vid
= vfd
->vfl_type
== VFL_TYPE_GRABBER
;
903 bool is_vbi
= vfd
->vfl_type
== VFL_TYPE_VBI
;
904 bool is_sdr
= vfd
->vfl_type
== VFL_TYPE_SDR
;
905 bool is_tch
= vfd
->vfl_type
== VFL_TYPE_TOUCH
;
906 bool is_rx
= vfd
->vfl_dir
!= VFL_DIR_TX
;
907 bool is_tx
= vfd
->vfl_dir
!= VFL_DIR_RX
;
913 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
914 if ((is_vid
|| is_tch
) && is_rx
&&
915 (ops
->vidioc_g_fmt_vid_cap
|| ops
->vidioc_g_fmt_vid_cap_mplane
))
918 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
:
919 if (is_vid
&& is_rx
&& ops
->vidioc_g_fmt_vid_cap_mplane
)
922 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
923 if (is_vid
&& is_rx
&& ops
->vidioc_g_fmt_vid_overlay
)
926 case V4L2_BUF_TYPE_VIDEO_OUTPUT
:
927 if (is_vid
&& is_tx
&&
928 (ops
->vidioc_g_fmt_vid_out
|| ops
->vidioc_g_fmt_vid_out_mplane
))
931 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
:
932 if (is_vid
&& is_tx
&& ops
->vidioc_g_fmt_vid_out_mplane
)
935 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY
:
936 if (is_vid
&& is_tx
&& ops
->vidioc_g_fmt_vid_out_overlay
)
939 case V4L2_BUF_TYPE_VBI_CAPTURE
:
940 if (is_vbi
&& is_rx
&& ops
->vidioc_g_fmt_vbi_cap
)
943 case V4L2_BUF_TYPE_VBI_OUTPUT
:
944 if (is_vbi
&& is_tx
&& ops
->vidioc_g_fmt_vbi_out
)
947 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
:
948 if (is_vbi
&& is_rx
&& ops
->vidioc_g_fmt_sliced_vbi_cap
)
951 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT
:
952 if (is_vbi
&& is_tx
&& ops
->vidioc_g_fmt_sliced_vbi_out
)
955 case V4L2_BUF_TYPE_SDR_CAPTURE
:
956 if (is_sdr
&& is_rx
&& ops
->vidioc_g_fmt_sdr_cap
)
959 case V4L2_BUF_TYPE_SDR_OUTPUT
:
960 if (is_sdr
&& is_tx
&& ops
->vidioc_g_fmt_sdr_out
)
963 case V4L2_BUF_TYPE_META_CAPTURE
:
964 if (is_vid
&& is_rx
&& ops
->vidioc_g_fmt_meta_cap
)
973 static void v4l_sanitize_format(struct v4l2_format
*fmt
)
978 * The v4l2_pix_format structure has been extended with fields that were
979 * not previously required to be set to zero by applications. The priv
980 * field, when set to a magic value, indicates the the extended fields
981 * are valid. Otherwise they will contain undefined values. To simplify
982 * the API towards drivers zero the extended fields and set the priv
983 * field to the magic value when the extended pixel format structure
984 * isn't used by applications.
987 if (fmt
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
&&
988 fmt
->type
!= V4L2_BUF_TYPE_VIDEO_OUTPUT
)
991 if (fmt
->fmt
.pix
.priv
== V4L2_PIX_FMT_PRIV_MAGIC
)
994 fmt
->fmt
.pix
.priv
= V4L2_PIX_FMT_PRIV_MAGIC
;
996 offset
= offsetof(struct v4l2_pix_format
, priv
)
997 + sizeof(fmt
->fmt
.pix
.priv
);
998 memset(((void *)&fmt
->fmt
.pix
) + offset
, 0,
999 sizeof(fmt
->fmt
.pix
) - offset
);
1002 static int v4l_querycap(const struct v4l2_ioctl_ops
*ops
,
1003 struct file
*file
, void *fh
, void *arg
)
1005 struct v4l2_capability
*cap
= (struct v4l2_capability
*)arg
;
1006 struct video_device
*vfd
= video_devdata(file
);
1009 cap
->version
= LINUX_VERSION_CODE
;
1010 cap
->device_caps
= vfd
->device_caps
;
1011 cap
->capabilities
= vfd
->device_caps
| V4L2_CAP_DEVICE_CAPS
;
1013 ret
= ops
->vidioc_querycap(file
, fh
, cap
);
1015 cap
->capabilities
|= V4L2_CAP_EXT_PIX_FORMAT
;
1017 * Drivers MUST fill in device_caps, so check for this and
1018 * warn if it was forgotten.
1020 WARN(!(cap
->capabilities
& V4L2_CAP_DEVICE_CAPS
) ||
1021 !cap
->device_caps
, "Bad caps for driver %s, %x %x",
1022 cap
->driver
, cap
->capabilities
, cap
->device_caps
);
1023 cap
->device_caps
|= V4L2_CAP_EXT_PIX_FORMAT
;
1028 static int v4l_s_input(const struct v4l2_ioctl_ops
*ops
,
1029 struct file
*file
, void *fh
, void *arg
)
1031 struct video_device
*vfd
= video_devdata(file
);
1034 ret
= v4l_enable_media_source(vfd
);
1037 return ops
->vidioc_s_input(file
, fh
, *(unsigned int *)arg
);
1040 static int v4l_s_output(const struct v4l2_ioctl_ops
*ops
,
1041 struct file
*file
, void *fh
, void *arg
)
1043 return ops
->vidioc_s_output(file
, fh
, *(unsigned int *)arg
);
1046 static int v4l_g_priority(const struct v4l2_ioctl_ops
*ops
,
1047 struct file
*file
, void *fh
, void *arg
)
1049 struct video_device
*vfd
;
1052 vfd
= video_devdata(file
);
1053 *p
= v4l2_prio_max(vfd
->prio
);
1057 static int v4l_s_priority(const struct v4l2_ioctl_ops
*ops
,
1058 struct file
*file
, void *fh
, void *arg
)
1060 struct video_device
*vfd
;
1061 struct v4l2_fh
*vfh
;
1064 vfd
= video_devdata(file
);
1065 if (!test_bit(V4L2_FL_USES_V4L2_FH
, &vfd
->flags
))
1067 vfh
= file
->private_data
;
1068 return v4l2_prio_change(vfd
->prio
, &vfh
->prio
, *p
);
1071 static int v4l_enuminput(const struct v4l2_ioctl_ops
*ops
,
1072 struct file
*file
, void *fh
, void *arg
)
1074 struct video_device
*vfd
= video_devdata(file
);
1075 struct v4l2_input
*p
= arg
;
1078 * We set the flags for CAP_DV_TIMINGS &
1079 * CAP_STD here based on ioctl handler provided by the
1080 * driver. If the driver doesn't support these
1081 * for a specific input, it must override these flags.
1083 if (is_valid_ioctl(vfd
, VIDIOC_S_STD
))
1084 p
->capabilities
|= V4L2_IN_CAP_STD
;
1086 return ops
->vidioc_enum_input(file
, fh
, p
);
1089 static int v4l_enumoutput(const struct v4l2_ioctl_ops
*ops
,
1090 struct file
*file
, void *fh
, void *arg
)
1092 struct video_device
*vfd
= video_devdata(file
);
1093 struct v4l2_output
*p
= arg
;
1096 * We set the flags for CAP_DV_TIMINGS &
1097 * CAP_STD here based on ioctl handler provided by the
1098 * driver. If the driver doesn't support these
1099 * for a specific output, it must override these flags.
1101 if (is_valid_ioctl(vfd
, VIDIOC_S_STD
))
1102 p
->capabilities
|= V4L2_OUT_CAP_STD
;
1104 return ops
->vidioc_enum_output(file
, fh
, p
);
1107 static void v4l_fill_fmtdesc(struct v4l2_fmtdesc
*fmt
)
1109 const unsigned sz
= sizeof(fmt
->description
);
1110 const char *descr
= NULL
;
1114 * We depart from the normal coding style here since the descriptions
1115 * should be aligned so it is easy to see which descriptions will be
1116 * longer than 31 characters (the max length for a description).
1117 * And frankly, this is easier to read anyway.
1119 * Note that gcc will use O(log N) comparisons to find the right case.
1121 switch (fmt
->pixelformat
) {
1122 /* Max description length mask: descr = "0123456789012345678901234567890" */
1123 case V4L2_PIX_FMT_RGB332
: descr
= "8-bit RGB 3-3-2"; break;
1124 case V4L2_PIX_FMT_RGB444
: descr
= "16-bit A/XRGB 4-4-4-4"; break;
1125 case V4L2_PIX_FMT_ARGB444
: descr
= "16-bit ARGB 4-4-4-4"; break;
1126 case V4L2_PIX_FMT_XRGB444
: descr
= "16-bit XRGB 4-4-4-4"; break;
1127 case V4L2_PIX_FMT_RGB555
: descr
= "16-bit A/XRGB 1-5-5-5"; break;
1128 case V4L2_PIX_FMT_ARGB555
: descr
= "16-bit ARGB 1-5-5-5"; break;
1129 case V4L2_PIX_FMT_XRGB555
: descr
= "16-bit XRGB 1-5-5-5"; break;
1130 case V4L2_PIX_FMT_RGB565
: descr
= "16-bit RGB 5-6-5"; break;
1131 case V4L2_PIX_FMT_RGB555X
: descr
= "16-bit A/XRGB 1-5-5-5 BE"; break;
1132 case V4L2_PIX_FMT_ARGB555X
: descr
= "16-bit ARGB 1-5-5-5 BE"; break;
1133 case V4L2_PIX_FMT_XRGB555X
: descr
= "16-bit XRGB 1-5-5-5 BE"; break;
1134 case V4L2_PIX_FMT_RGB565X
: descr
= "16-bit RGB 5-6-5 BE"; break;
1135 case V4L2_PIX_FMT_BGR666
: descr
= "18-bit BGRX 6-6-6-14"; break;
1136 case V4L2_PIX_FMT_BGR24
: descr
= "24-bit BGR 8-8-8"; break;
1137 case V4L2_PIX_FMT_RGB24
: descr
= "24-bit RGB 8-8-8"; break;
1138 case V4L2_PIX_FMT_BGR32
: descr
= "32-bit BGRA/X 8-8-8-8"; break;
1139 case V4L2_PIX_FMT_ABGR32
: descr
= "32-bit BGRA 8-8-8-8"; break;
1140 case V4L2_PIX_FMT_XBGR32
: descr
= "32-bit BGRX 8-8-8-8"; break;
1141 case V4L2_PIX_FMT_RGB32
: descr
= "32-bit A/XRGB 8-8-8-8"; break;
1142 case V4L2_PIX_FMT_ARGB32
: descr
= "32-bit ARGB 8-8-8-8"; break;
1143 case V4L2_PIX_FMT_XRGB32
: descr
= "32-bit XRGB 8-8-8-8"; break;
1144 case V4L2_PIX_FMT_GREY
: descr
= "8-bit Greyscale"; break;
1145 case V4L2_PIX_FMT_Y4
: descr
= "4-bit Greyscale"; break;
1146 case V4L2_PIX_FMT_Y6
: descr
= "6-bit Greyscale"; break;
1147 case V4L2_PIX_FMT_Y10
: descr
= "10-bit Greyscale"; break;
1148 case V4L2_PIX_FMT_Y12
: descr
= "12-bit Greyscale"; break;
1149 case V4L2_PIX_FMT_Y16
: descr
= "16-bit Greyscale"; break;
1150 case V4L2_PIX_FMT_Y16_BE
: descr
= "16-bit Greyscale BE"; break;
1151 case V4L2_PIX_FMT_Y10BPACK
: descr
= "10-bit Greyscale (Packed)"; break;
1152 case V4L2_PIX_FMT_Y8I
: descr
= "Interleaved 8-bit Greyscale"; break;
1153 case V4L2_PIX_FMT_Y12I
: descr
= "Interleaved 12-bit Greyscale"; break;
1154 case V4L2_PIX_FMT_Z16
: descr
= "16-bit Depth"; break;
1155 case V4L2_PIX_FMT_INZI
: descr
= "Planar 10:16 Greyscale Depth"; break;
1156 case V4L2_PIX_FMT_PAL8
: descr
= "8-bit Palette"; break;
1157 case V4L2_PIX_FMT_UV8
: descr
= "8-bit Chrominance UV 4-4"; break;
1158 case V4L2_PIX_FMT_YVU410
: descr
= "Planar YVU 4:1:0"; break;
1159 case V4L2_PIX_FMT_YVU420
: descr
= "Planar YVU 4:2:0"; break;
1160 case V4L2_PIX_FMT_YUYV
: descr
= "YUYV 4:2:2"; break;
1161 case V4L2_PIX_FMT_YYUV
: descr
= "YYUV 4:2:2"; break;
1162 case V4L2_PIX_FMT_YVYU
: descr
= "YVYU 4:2:2"; break;
1163 case V4L2_PIX_FMT_UYVY
: descr
= "UYVY 4:2:2"; break;
1164 case V4L2_PIX_FMT_VYUY
: descr
= "VYUY 4:2:2"; break;
1165 case V4L2_PIX_FMT_YUV422P
: descr
= "Planar YUV 4:2:2"; break;
1166 case V4L2_PIX_FMT_YUV411P
: descr
= "Planar YUV 4:1:1"; break;
1167 case V4L2_PIX_FMT_Y41P
: descr
= "YUV 4:1:1 (Packed)"; break;
1168 case V4L2_PIX_FMT_YUV444
: descr
= "16-bit A/XYUV 4-4-4-4"; break;
1169 case V4L2_PIX_FMT_YUV555
: descr
= "16-bit A/XYUV 1-5-5-5"; break;
1170 case V4L2_PIX_FMT_YUV565
: descr
= "16-bit YUV 5-6-5"; break;
1171 case V4L2_PIX_FMT_YUV32
: descr
= "32-bit A/XYUV 8-8-8-8"; break;
1172 case V4L2_PIX_FMT_YUV410
: descr
= "Planar YUV 4:1:0"; break;
1173 case V4L2_PIX_FMT_YUV420
: descr
= "Planar YUV 4:2:0"; break;
1174 case V4L2_PIX_FMT_HI240
: descr
= "8-bit Dithered RGB (BTTV)"; break;
1175 case V4L2_PIX_FMT_HM12
: descr
= "YUV 4:2:0 (16x16 Macroblocks)"; break;
1176 case V4L2_PIX_FMT_M420
: descr
= "YUV 4:2:0 (M420)"; break;
1177 case V4L2_PIX_FMT_NV12
: descr
= "Y/CbCr 4:2:0"; break;
1178 case V4L2_PIX_FMT_NV21
: descr
= "Y/CrCb 4:2:0"; break;
1179 case V4L2_PIX_FMT_NV16
: descr
= "Y/CbCr 4:2:2"; break;
1180 case V4L2_PIX_FMT_NV61
: descr
= "Y/CrCb 4:2:2"; break;
1181 case V4L2_PIX_FMT_NV24
: descr
= "Y/CbCr 4:4:4"; break;
1182 case V4L2_PIX_FMT_NV42
: descr
= "Y/CrCb 4:4:4"; break;
1183 case V4L2_PIX_FMT_NV12M
: descr
= "Y/CbCr 4:2:0 (N-C)"; break;
1184 case V4L2_PIX_FMT_NV21M
: descr
= "Y/CrCb 4:2:0 (N-C)"; break;
1185 case V4L2_PIX_FMT_NV16M
: descr
= "Y/CbCr 4:2:2 (N-C)"; break;
1186 case V4L2_PIX_FMT_NV61M
: descr
= "Y/CrCb 4:2:2 (N-C)"; break;
1187 case V4L2_PIX_FMT_NV12MT
: descr
= "Y/CbCr 4:2:0 (64x32 MB, N-C)"; break;
1188 case V4L2_PIX_FMT_NV12MT_16X16
: descr
= "Y/CbCr 4:2:0 (16x16 MB, N-C)"; break;
1189 case V4L2_PIX_FMT_YUV420M
: descr
= "Planar YUV 4:2:0 (N-C)"; break;
1190 case V4L2_PIX_FMT_YVU420M
: descr
= "Planar YVU 4:2:0 (N-C)"; break;
1191 case V4L2_PIX_FMT_YUV422M
: descr
= "Planar YUV 4:2:2 (N-C)"; break;
1192 case V4L2_PIX_FMT_YVU422M
: descr
= "Planar YVU 4:2:2 (N-C)"; break;
1193 case V4L2_PIX_FMT_YUV444M
: descr
= "Planar YUV 4:4:4 (N-C)"; break;
1194 case V4L2_PIX_FMT_YVU444M
: descr
= "Planar YVU 4:4:4 (N-C)"; break;
1195 case V4L2_PIX_FMT_SBGGR8
: descr
= "8-bit Bayer BGBG/GRGR"; break;
1196 case V4L2_PIX_FMT_SGBRG8
: descr
= "8-bit Bayer GBGB/RGRG"; break;
1197 case V4L2_PIX_FMT_SGRBG8
: descr
= "8-bit Bayer GRGR/BGBG"; break;
1198 case V4L2_PIX_FMT_SRGGB8
: descr
= "8-bit Bayer RGRG/GBGB"; break;
1199 case V4L2_PIX_FMT_SBGGR10
: descr
= "10-bit Bayer BGBG/GRGR"; break;
1200 case V4L2_PIX_FMT_SGBRG10
: descr
= "10-bit Bayer GBGB/RGRG"; break;
1201 case V4L2_PIX_FMT_SGRBG10
: descr
= "10-bit Bayer GRGR/BGBG"; break;
1202 case V4L2_PIX_FMT_SRGGB10
: descr
= "10-bit Bayer RGRG/GBGB"; break;
1203 case V4L2_PIX_FMT_SBGGR10P
: descr
= "10-bit Bayer BGBG/GRGR Packed"; break;
1204 case V4L2_PIX_FMT_SGBRG10P
: descr
= "10-bit Bayer GBGB/RGRG Packed"; break;
1205 case V4L2_PIX_FMT_SGRBG10P
: descr
= "10-bit Bayer GRGR/BGBG Packed"; break;
1206 case V4L2_PIX_FMT_SRGGB10P
: descr
= "10-bit Bayer RGRG/GBGB Packed"; break;
1207 case V4L2_PIX_FMT_SBGGR10ALAW8
: descr
= "8-bit Bayer BGBG/GRGR (A-law)"; break;
1208 case V4L2_PIX_FMT_SGBRG10ALAW8
: descr
= "8-bit Bayer GBGB/RGRG (A-law)"; break;
1209 case V4L2_PIX_FMT_SGRBG10ALAW8
: descr
= "8-bit Bayer GRGR/BGBG (A-law)"; break;
1210 case V4L2_PIX_FMT_SRGGB10ALAW8
: descr
= "8-bit Bayer RGRG/GBGB (A-law)"; break;
1211 case V4L2_PIX_FMT_SBGGR10DPCM8
: descr
= "8-bit Bayer BGBG/GRGR (DPCM)"; break;
1212 case V4L2_PIX_FMT_SGBRG10DPCM8
: descr
= "8-bit Bayer GBGB/RGRG (DPCM)"; break;
1213 case V4L2_PIX_FMT_SGRBG10DPCM8
: descr
= "8-bit Bayer GRGR/BGBG (DPCM)"; break;
1214 case V4L2_PIX_FMT_SRGGB10DPCM8
: descr
= "8-bit Bayer RGRG/GBGB (DPCM)"; break;
1215 case V4L2_PIX_FMT_SBGGR12
: descr
= "12-bit Bayer BGBG/GRGR"; break;
1216 case V4L2_PIX_FMT_SGBRG12
: descr
= "12-bit Bayer GBGB/RGRG"; break;
1217 case V4L2_PIX_FMT_SGRBG12
: descr
= "12-bit Bayer GRGR/BGBG"; break;
1218 case V4L2_PIX_FMT_SRGGB12
: descr
= "12-bit Bayer RGRG/GBGB"; break;
1219 case V4L2_PIX_FMT_SBGGR12P
: descr
= "12-bit Bayer BGBG/GRGR Packed"; break;
1220 case V4L2_PIX_FMT_SGBRG12P
: descr
= "12-bit Bayer GBGB/RGRG Packed"; break;
1221 case V4L2_PIX_FMT_SGRBG12P
: descr
= "12-bit Bayer GRGR/BGBG Packed"; break;
1222 case V4L2_PIX_FMT_SRGGB12P
: descr
= "12-bit Bayer RGRG/GBGB Packed"; break;
1223 case V4L2_PIX_FMT_SBGGR16
: descr
= "16-bit Bayer BGBG/GRGR"; break;
1224 case V4L2_PIX_FMT_SGBRG16
: descr
= "16-bit Bayer GBGB/RGRG"; break;
1225 case V4L2_PIX_FMT_SGRBG16
: descr
= "16-bit Bayer GRGR/BGBG"; break;
1226 case V4L2_PIX_FMT_SRGGB16
: descr
= "16-bit Bayer RGRG/GBGB"; break;
1227 case V4L2_PIX_FMT_SN9C20X_I420
: descr
= "GSPCA SN9C20X I420"; break;
1228 case V4L2_PIX_FMT_SPCA501
: descr
= "GSPCA SPCA501"; break;
1229 case V4L2_PIX_FMT_SPCA505
: descr
= "GSPCA SPCA505"; break;
1230 case V4L2_PIX_FMT_SPCA508
: descr
= "GSPCA SPCA508"; break;
1231 case V4L2_PIX_FMT_STV0680
: descr
= "GSPCA STV0680"; break;
1232 case V4L2_PIX_FMT_TM6000
: descr
= "A/V + VBI Mux Packet"; break;
1233 case V4L2_PIX_FMT_CIT_YYVYUY
: descr
= "GSPCA CIT YYVYUY"; break;
1234 case V4L2_PIX_FMT_KONICA420
: descr
= "GSPCA KONICA420"; break;
1235 case V4L2_PIX_FMT_HSV24
: descr
= "24-bit HSV 8-8-8"; break;
1236 case V4L2_PIX_FMT_HSV32
: descr
= "32-bit XHSV 8-8-8-8"; break;
1237 case V4L2_SDR_FMT_CU8
: descr
= "Complex U8"; break;
1238 case V4L2_SDR_FMT_CU16LE
: descr
= "Complex U16LE"; break;
1239 case V4L2_SDR_FMT_CS8
: descr
= "Complex S8"; break;
1240 case V4L2_SDR_FMT_CS14LE
: descr
= "Complex S14LE"; break;
1241 case V4L2_SDR_FMT_RU12LE
: descr
= "Real U12LE"; break;
1242 case V4L2_SDR_FMT_PCU16BE
: descr
= "Planar Complex U16BE"; break;
1243 case V4L2_SDR_FMT_PCU18BE
: descr
= "Planar Complex U18BE"; break;
1244 case V4L2_SDR_FMT_PCU20BE
: descr
= "Planar Complex U20BE"; break;
1245 case V4L2_TCH_FMT_DELTA_TD16
: descr
= "16-bit signed deltas"; break;
1246 case V4L2_TCH_FMT_DELTA_TD08
: descr
= "8-bit signed deltas"; break;
1247 case V4L2_TCH_FMT_TU16
: descr
= "16-bit unsigned touch data"; break;
1248 case V4L2_TCH_FMT_TU08
: descr
= "8-bit unsigned touch data"; break;
1249 case V4L2_META_FMT_VSP1_HGO
: descr
= "R-Car VSP1 1-D Histogram"; break;
1250 case V4L2_META_FMT_VSP1_HGT
: descr
= "R-Car VSP1 2-D Histogram"; break;
1253 /* Compressed formats */
1254 flags
= V4L2_FMT_FLAG_COMPRESSED
;
1255 switch (fmt
->pixelformat
) {
1256 /* Max description length mask: descr = "0123456789012345678901234567890" */
1257 case V4L2_PIX_FMT_MJPEG
: descr
= "Motion-JPEG"; break;
1258 case V4L2_PIX_FMT_JPEG
: descr
= "JFIF JPEG"; break;
1259 case V4L2_PIX_FMT_DV
: descr
= "1394"; break;
1260 case V4L2_PIX_FMT_MPEG
: descr
= "MPEG-1/2/4"; break;
1261 case V4L2_PIX_FMT_H264
: descr
= "H.264"; break;
1262 case V4L2_PIX_FMT_H264_NO_SC
: descr
= "H.264 (No Start Codes)"; break;
1263 case V4L2_PIX_FMT_H264_MVC
: descr
= "H.264 MVC"; break;
1264 case V4L2_PIX_FMT_H263
: descr
= "H.263"; break;
1265 case V4L2_PIX_FMT_MPEG1
: descr
= "MPEG-1 ES"; break;
1266 case V4L2_PIX_FMT_MPEG2
: descr
= "MPEG-2 ES"; break;
1267 case V4L2_PIX_FMT_MPEG4
: descr
= "MPEG-4 part 2 ES"; break;
1268 case V4L2_PIX_FMT_XVID
: descr
= "Xvid"; break;
1269 case V4L2_PIX_FMT_VC1_ANNEX_G
: descr
= "VC-1 (SMPTE 412M Annex G)"; break;
1270 case V4L2_PIX_FMT_VC1_ANNEX_L
: descr
= "VC-1 (SMPTE 412M Annex L)"; break;
1271 case V4L2_PIX_FMT_VP8
: descr
= "VP8"; break;
1272 case V4L2_PIX_FMT_VP9
: descr
= "VP9"; break;
1273 case V4L2_PIX_FMT_CPIA1
: descr
= "GSPCA CPiA YUV"; break;
1274 case V4L2_PIX_FMT_WNVA
: descr
= "WNVA"; break;
1275 case V4L2_PIX_FMT_SN9C10X
: descr
= "GSPCA SN9C10X"; break;
1276 case V4L2_PIX_FMT_PWC1
: descr
= "Raw Philips Webcam Type (Old)"; break;
1277 case V4L2_PIX_FMT_PWC2
: descr
= "Raw Philips Webcam Type (New)"; break;
1278 case V4L2_PIX_FMT_ET61X251
: descr
= "GSPCA ET61X251"; break;
1279 case V4L2_PIX_FMT_SPCA561
: descr
= "GSPCA SPCA561"; break;
1280 case V4L2_PIX_FMT_PAC207
: descr
= "GSPCA PAC207"; break;
1281 case V4L2_PIX_FMT_MR97310A
: descr
= "GSPCA MR97310A"; break;
1282 case V4L2_PIX_FMT_JL2005BCD
: descr
= "GSPCA JL2005BCD"; break;
1283 case V4L2_PIX_FMT_SN9C2028
: descr
= "GSPCA SN9C2028"; break;
1284 case V4L2_PIX_FMT_SQ905C
: descr
= "GSPCA SQ905C"; break;
1285 case V4L2_PIX_FMT_PJPG
: descr
= "GSPCA PJPG"; break;
1286 case V4L2_PIX_FMT_OV511
: descr
= "GSPCA OV511"; break;
1287 case V4L2_PIX_FMT_OV518
: descr
= "GSPCA OV518"; break;
1288 case V4L2_PIX_FMT_JPGL
: descr
= "JPEG Lite"; break;
1289 case V4L2_PIX_FMT_SE401
: descr
= "GSPCA SE401"; break;
1290 case V4L2_PIX_FMT_S5C_UYVY_JPG
: descr
= "S5C73MX interleaved UYVY/JPEG"; break;
1291 case V4L2_PIX_FMT_MT21C
: descr
= "Mediatek Compressed Format"; break;
1293 WARN(1, "Unknown pixelformat 0x%08x\n", fmt
->pixelformat
);
1294 if (fmt
->description
[0])
1297 snprintf(fmt
->description
, sz
, "%c%c%c%c%s",
1298 (char)(fmt
->pixelformat
& 0x7f),
1299 (char)((fmt
->pixelformat
>> 8) & 0x7f),
1300 (char)((fmt
->pixelformat
>> 16) & 0x7f),
1301 (char)((fmt
->pixelformat
>> 24) & 0x7f),
1302 (fmt
->pixelformat
& (1 << 31)) ? "-BE" : "");
1308 WARN_ON(strlcpy(fmt
->description
, descr
, sz
) >= sz
);
1312 static int v4l_enum_fmt(const struct v4l2_ioctl_ops
*ops
,
1313 struct file
*file
, void *fh
, void *arg
)
1315 struct v4l2_fmtdesc
*p
= arg
;
1316 int ret
= check_fmt(file
, p
->type
);
1323 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
1324 if (unlikely(!ops
->vidioc_enum_fmt_vid_cap
))
1326 ret
= ops
->vidioc_enum_fmt_vid_cap(file
, fh
, arg
);
1328 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
:
1329 if (unlikely(!ops
->vidioc_enum_fmt_vid_cap_mplane
))
1331 ret
= ops
->vidioc_enum_fmt_vid_cap_mplane(file
, fh
, arg
);
1333 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
1334 if (unlikely(!ops
->vidioc_enum_fmt_vid_overlay
))
1336 ret
= ops
->vidioc_enum_fmt_vid_overlay(file
, fh
, arg
);
1338 case V4L2_BUF_TYPE_VIDEO_OUTPUT
:
1339 if (unlikely(!ops
->vidioc_enum_fmt_vid_out
))
1341 ret
= ops
->vidioc_enum_fmt_vid_out(file
, fh
, arg
);
1343 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
:
1344 if (unlikely(!ops
->vidioc_enum_fmt_vid_out_mplane
))
1346 ret
= ops
->vidioc_enum_fmt_vid_out_mplane(file
, fh
, arg
);
1348 case V4L2_BUF_TYPE_SDR_CAPTURE
:
1349 if (unlikely(!ops
->vidioc_enum_fmt_sdr_cap
))
1351 ret
= ops
->vidioc_enum_fmt_sdr_cap(file
, fh
, arg
);
1353 case V4L2_BUF_TYPE_SDR_OUTPUT
:
1354 if (unlikely(!ops
->vidioc_enum_fmt_sdr_out
))
1356 ret
= ops
->vidioc_enum_fmt_sdr_out(file
, fh
, arg
);
1358 case V4L2_BUF_TYPE_META_CAPTURE
:
1359 if (unlikely(!ops
->vidioc_enum_fmt_meta_cap
))
1361 ret
= ops
->vidioc_enum_fmt_meta_cap(file
, fh
, arg
);
1365 v4l_fill_fmtdesc(p
);
1369 static void v4l_pix_format_touch(struct v4l2_pix_format
*p
)
1372 * The v4l2_pix_format structure contains fields that make no sense for
1373 * touch. Set them to default values in this case.
1376 p
->field
= V4L2_FIELD_NONE
;
1377 p
->colorspace
= V4L2_COLORSPACE_RAW
;
1380 p
->quantization
= 0;
1384 static int v4l_g_fmt(const struct v4l2_ioctl_ops
*ops
,
1385 struct file
*file
, void *fh
, void *arg
)
1387 struct v4l2_format
*p
= arg
;
1388 struct video_device
*vfd
= video_devdata(file
);
1389 int ret
= check_fmt(file
, p
->type
);
1395 * fmt can't be cleared for these overlay types due to the 'clips'
1396 * 'clipcount' and 'bitmap' pointers in struct v4l2_window.
1397 * Those are provided by the user. So handle these two overlay types
1398 * first, and then just do a simple memset for the other types.
1401 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
1402 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY
: {
1403 struct v4l2_clip __user
*clips
= p
->fmt
.win
.clips
;
1404 u32 clipcount
= p
->fmt
.win
.clipcount
;
1405 void __user
*bitmap
= p
->fmt
.win
.bitmap
;
1407 memset(&p
->fmt
, 0, sizeof(p
->fmt
));
1408 p
->fmt
.win
.clips
= clips
;
1409 p
->fmt
.win
.clipcount
= clipcount
;
1410 p
->fmt
.win
.bitmap
= bitmap
;
1414 memset(&p
->fmt
, 0, sizeof(p
->fmt
));
1419 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
1420 if (unlikely(!ops
->vidioc_g_fmt_vid_cap
))
1422 p
->fmt
.pix
.priv
= V4L2_PIX_FMT_PRIV_MAGIC
;
1423 ret
= ops
->vidioc_g_fmt_vid_cap(file
, fh
, arg
);
1424 /* just in case the driver zeroed it again */
1425 p
->fmt
.pix
.priv
= V4L2_PIX_FMT_PRIV_MAGIC
;
1426 if (vfd
->vfl_type
== VFL_TYPE_TOUCH
)
1427 v4l_pix_format_touch(&p
->fmt
.pix
);
1429 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
:
1430 return ops
->vidioc_g_fmt_vid_cap_mplane(file
, fh
, arg
);
1431 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
1432 return ops
->vidioc_g_fmt_vid_overlay(file
, fh
, arg
);
1433 case V4L2_BUF_TYPE_VBI_CAPTURE
:
1434 return ops
->vidioc_g_fmt_vbi_cap(file
, fh
, arg
);
1435 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
:
1436 return ops
->vidioc_g_fmt_sliced_vbi_cap(file
, fh
, arg
);
1437 case V4L2_BUF_TYPE_VIDEO_OUTPUT
:
1438 if (unlikely(!ops
->vidioc_g_fmt_vid_out
))
1440 p
->fmt
.pix
.priv
= V4L2_PIX_FMT_PRIV_MAGIC
;
1441 ret
= ops
->vidioc_g_fmt_vid_out(file
, fh
, arg
);
1442 /* just in case the driver zeroed it again */
1443 p
->fmt
.pix
.priv
= V4L2_PIX_FMT_PRIV_MAGIC
;
1445 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
:
1446 return ops
->vidioc_g_fmt_vid_out_mplane(file
, fh
, arg
);
1447 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY
:
1448 return ops
->vidioc_g_fmt_vid_out_overlay(file
, fh
, arg
);
1449 case V4L2_BUF_TYPE_VBI_OUTPUT
:
1450 return ops
->vidioc_g_fmt_vbi_out(file
, fh
, arg
);
1451 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT
:
1452 return ops
->vidioc_g_fmt_sliced_vbi_out(file
, fh
, arg
);
1453 case V4L2_BUF_TYPE_SDR_CAPTURE
:
1454 return ops
->vidioc_g_fmt_sdr_cap(file
, fh
, arg
);
1455 case V4L2_BUF_TYPE_SDR_OUTPUT
:
1456 return ops
->vidioc_g_fmt_sdr_out(file
, fh
, arg
);
1457 case V4L2_BUF_TYPE_META_CAPTURE
:
1458 return ops
->vidioc_g_fmt_meta_cap(file
, fh
, arg
);
1463 static int v4l_s_fmt(const struct v4l2_ioctl_ops
*ops
,
1464 struct file
*file
, void *fh
, void *arg
)
1466 struct v4l2_format
*p
= arg
;
1467 struct video_device
*vfd
= video_devdata(file
);
1468 int ret
= check_fmt(file
, p
->type
);
1473 ret
= v4l_enable_media_source(vfd
);
1476 v4l_sanitize_format(p
);
1479 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
1480 if (unlikely(!ops
->vidioc_s_fmt_vid_cap
))
1482 CLEAR_AFTER_FIELD(p
, fmt
.pix
);
1483 ret
= ops
->vidioc_s_fmt_vid_cap(file
, fh
, arg
);
1484 /* just in case the driver zeroed it again */
1485 p
->fmt
.pix
.priv
= V4L2_PIX_FMT_PRIV_MAGIC
;
1486 if (vfd
->vfl_type
== VFL_TYPE_TOUCH
)
1487 v4l_pix_format_touch(&p
->fmt
.pix
);
1489 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
:
1490 if (unlikely(!ops
->vidioc_s_fmt_vid_cap_mplane
))
1492 CLEAR_AFTER_FIELD(p
, fmt
.pix_mp
.xfer_func
);
1493 return ops
->vidioc_s_fmt_vid_cap_mplane(file
, fh
, arg
);
1494 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
1495 if (unlikely(!ops
->vidioc_s_fmt_vid_overlay
))
1497 CLEAR_AFTER_FIELD(p
, fmt
.win
);
1498 return ops
->vidioc_s_fmt_vid_overlay(file
, fh
, arg
);
1499 case V4L2_BUF_TYPE_VBI_CAPTURE
:
1500 if (unlikely(!ops
->vidioc_s_fmt_vbi_cap
))
1502 CLEAR_AFTER_FIELD(p
, fmt
.vbi
);
1503 return ops
->vidioc_s_fmt_vbi_cap(file
, fh
, arg
);
1504 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
:
1505 if (unlikely(!ops
->vidioc_s_fmt_sliced_vbi_cap
))
1507 CLEAR_AFTER_FIELD(p
, fmt
.sliced
);
1508 return ops
->vidioc_s_fmt_sliced_vbi_cap(file
, fh
, arg
);
1509 case V4L2_BUF_TYPE_VIDEO_OUTPUT
:
1510 if (unlikely(!ops
->vidioc_s_fmt_vid_out
))
1512 CLEAR_AFTER_FIELD(p
, fmt
.pix
);
1513 ret
= ops
->vidioc_s_fmt_vid_out(file
, fh
, arg
);
1514 /* just in case the driver zeroed it again */
1515 p
->fmt
.pix
.priv
= V4L2_PIX_FMT_PRIV_MAGIC
;
1517 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
:
1518 if (unlikely(!ops
->vidioc_s_fmt_vid_out_mplane
))
1520 CLEAR_AFTER_FIELD(p
, fmt
.pix_mp
.xfer_func
);
1521 return ops
->vidioc_s_fmt_vid_out_mplane(file
, fh
, arg
);
1522 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY
:
1523 if (unlikely(!ops
->vidioc_s_fmt_vid_out_overlay
))
1525 CLEAR_AFTER_FIELD(p
, fmt
.win
);
1526 return ops
->vidioc_s_fmt_vid_out_overlay(file
, fh
, arg
);
1527 case V4L2_BUF_TYPE_VBI_OUTPUT
:
1528 if (unlikely(!ops
->vidioc_s_fmt_vbi_out
))
1530 CLEAR_AFTER_FIELD(p
, fmt
.vbi
);
1531 return ops
->vidioc_s_fmt_vbi_out(file
, fh
, arg
);
1532 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT
:
1533 if (unlikely(!ops
->vidioc_s_fmt_sliced_vbi_out
))
1535 CLEAR_AFTER_FIELD(p
, fmt
.sliced
);
1536 return ops
->vidioc_s_fmt_sliced_vbi_out(file
, fh
, arg
);
1537 case V4L2_BUF_TYPE_SDR_CAPTURE
:
1538 if (unlikely(!ops
->vidioc_s_fmt_sdr_cap
))
1540 CLEAR_AFTER_FIELD(p
, fmt
.sdr
);
1541 return ops
->vidioc_s_fmt_sdr_cap(file
, fh
, arg
);
1542 case V4L2_BUF_TYPE_SDR_OUTPUT
:
1543 if (unlikely(!ops
->vidioc_s_fmt_sdr_out
))
1545 CLEAR_AFTER_FIELD(p
, fmt
.sdr
);
1546 return ops
->vidioc_s_fmt_sdr_out(file
, fh
, arg
);
1547 case V4L2_BUF_TYPE_META_CAPTURE
:
1548 if (unlikely(!ops
->vidioc_s_fmt_meta_cap
))
1550 CLEAR_AFTER_FIELD(p
, fmt
.meta
);
1551 return ops
->vidioc_s_fmt_meta_cap(file
, fh
, arg
);
1556 static int v4l_try_fmt(const struct v4l2_ioctl_ops
*ops
,
1557 struct file
*file
, void *fh
, void *arg
)
1559 struct v4l2_format
*p
= arg
;
1560 int ret
= check_fmt(file
, p
->type
);
1565 v4l_sanitize_format(p
);
1568 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
1569 if (unlikely(!ops
->vidioc_try_fmt_vid_cap
))
1571 CLEAR_AFTER_FIELD(p
, fmt
.pix
);
1572 ret
= ops
->vidioc_try_fmt_vid_cap(file
, fh
, arg
);
1573 /* just in case the driver zeroed it again */
1574 p
->fmt
.pix
.priv
= V4L2_PIX_FMT_PRIV_MAGIC
;
1576 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
:
1577 if (unlikely(!ops
->vidioc_try_fmt_vid_cap_mplane
))
1579 CLEAR_AFTER_FIELD(p
, fmt
.pix_mp
.xfer_func
);
1580 return ops
->vidioc_try_fmt_vid_cap_mplane(file
, fh
, arg
);
1581 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
1582 if (unlikely(!ops
->vidioc_try_fmt_vid_overlay
))
1584 CLEAR_AFTER_FIELD(p
, fmt
.win
);
1585 return ops
->vidioc_try_fmt_vid_overlay(file
, fh
, arg
);
1586 case V4L2_BUF_TYPE_VBI_CAPTURE
:
1587 if (unlikely(!ops
->vidioc_try_fmt_vbi_cap
))
1589 CLEAR_AFTER_FIELD(p
, fmt
.vbi
);
1590 return ops
->vidioc_try_fmt_vbi_cap(file
, fh
, arg
);
1591 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE
:
1592 if (unlikely(!ops
->vidioc_try_fmt_sliced_vbi_cap
))
1594 CLEAR_AFTER_FIELD(p
, fmt
.sliced
);
1595 return ops
->vidioc_try_fmt_sliced_vbi_cap(file
, fh
, arg
);
1596 case V4L2_BUF_TYPE_VIDEO_OUTPUT
:
1597 if (unlikely(!ops
->vidioc_try_fmt_vid_out
))
1599 CLEAR_AFTER_FIELD(p
, fmt
.pix
);
1600 ret
= ops
->vidioc_try_fmt_vid_out(file
, fh
, arg
);
1601 /* just in case the driver zeroed it again */
1602 p
->fmt
.pix
.priv
= V4L2_PIX_FMT_PRIV_MAGIC
;
1604 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
:
1605 if (unlikely(!ops
->vidioc_try_fmt_vid_out_mplane
))
1607 CLEAR_AFTER_FIELD(p
, fmt
.pix_mp
.xfer_func
);
1608 return ops
->vidioc_try_fmt_vid_out_mplane(file
, fh
, arg
);
1609 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY
:
1610 if (unlikely(!ops
->vidioc_try_fmt_vid_out_overlay
))
1612 CLEAR_AFTER_FIELD(p
, fmt
.win
);
1613 return ops
->vidioc_try_fmt_vid_out_overlay(file
, fh
, arg
);
1614 case V4L2_BUF_TYPE_VBI_OUTPUT
:
1615 if (unlikely(!ops
->vidioc_try_fmt_vbi_out
))
1617 CLEAR_AFTER_FIELD(p
, fmt
.vbi
);
1618 return ops
->vidioc_try_fmt_vbi_out(file
, fh
, arg
);
1619 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT
:
1620 if (unlikely(!ops
->vidioc_try_fmt_sliced_vbi_out
))
1622 CLEAR_AFTER_FIELD(p
, fmt
.sliced
);
1623 return ops
->vidioc_try_fmt_sliced_vbi_out(file
, fh
, arg
);
1624 case V4L2_BUF_TYPE_SDR_CAPTURE
:
1625 if (unlikely(!ops
->vidioc_try_fmt_sdr_cap
))
1627 CLEAR_AFTER_FIELD(p
, fmt
.sdr
);
1628 return ops
->vidioc_try_fmt_sdr_cap(file
, fh
, arg
);
1629 case V4L2_BUF_TYPE_SDR_OUTPUT
:
1630 if (unlikely(!ops
->vidioc_try_fmt_sdr_out
))
1632 CLEAR_AFTER_FIELD(p
, fmt
.sdr
);
1633 return ops
->vidioc_try_fmt_sdr_out(file
, fh
, arg
);
1634 case V4L2_BUF_TYPE_META_CAPTURE
:
1635 if (unlikely(!ops
->vidioc_try_fmt_meta_cap
))
1637 CLEAR_AFTER_FIELD(p
, fmt
.meta
);
1638 return ops
->vidioc_try_fmt_meta_cap(file
, fh
, arg
);
1643 static int v4l_streamon(const struct v4l2_ioctl_ops
*ops
,
1644 struct file
*file
, void *fh
, void *arg
)
1646 return ops
->vidioc_streamon(file
, fh
, *(unsigned int *)arg
);
1649 static int v4l_streamoff(const struct v4l2_ioctl_ops
*ops
,
1650 struct file
*file
, void *fh
, void *arg
)
1652 return ops
->vidioc_streamoff(file
, fh
, *(unsigned int *)arg
);
1655 static int v4l_g_tuner(const struct v4l2_ioctl_ops
*ops
,
1656 struct file
*file
, void *fh
, void *arg
)
1658 struct video_device
*vfd
= video_devdata(file
);
1659 struct v4l2_tuner
*p
= arg
;
1662 p
->type
= (vfd
->vfl_type
== VFL_TYPE_RADIO
) ?
1663 V4L2_TUNER_RADIO
: V4L2_TUNER_ANALOG_TV
;
1664 err
= ops
->vidioc_g_tuner(file
, fh
, p
);
1666 p
->capability
|= V4L2_TUNER_CAP_FREQ_BANDS
;
1670 static int v4l_s_tuner(const struct v4l2_ioctl_ops
*ops
,
1671 struct file
*file
, void *fh
, void *arg
)
1673 struct video_device
*vfd
= video_devdata(file
);
1674 struct v4l2_tuner
*p
= arg
;
1677 ret
= v4l_enable_media_source(vfd
);
1680 p
->type
= (vfd
->vfl_type
== VFL_TYPE_RADIO
) ?
1681 V4L2_TUNER_RADIO
: V4L2_TUNER_ANALOG_TV
;
1682 return ops
->vidioc_s_tuner(file
, fh
, p
);
1685 static int v4l_g_modulator(const struct v4l2_ioctl_ops
*ops
,
1686 struct file
*file
, void *fh
, void *arg
)
1688 struct video_device
*vfd
= video_devdata(file
);
1689 struct v4l2_modulator
*p
= arg
;
1692 if (vfd
->vfl_type
== VFL_TYPE_RADIO
)
1693 p
->type
= V4L2_TUNER_RADIO
;
1695 err
= ops
->vidioc_g_modulator(file
, fh
, p
);
1697 p
->capability
|= V4L2_TUNER_CAP_FREQ_BANDS
;
1701 static int v4l_s_modulator(const struct v4l2_ioctl_ops
*ops
,
1702 struct file
*file
, void *fh
, void *arg
)
1704 struct video_device
*vfd
= video_devdata(file
);
1705 struct v4l2_modulator
*p
= arg
;
1707 if (vfd
->vfl_type
== VFL_TYPE_RADIO
)
1708 p
->type
= V4L2_TUNER_RADIO
;
1710 return ops
->vidioc_s_modulator(file
, fh
, p
);
1713 static int v4l_g_frequency(const struct v4l2_ioctl_ops
*ops
,
1714 struct file
*file
, void *fh
, void *arg
)
1716 struct video_device
*vfd
= video_devdata(file
);
1717 struct v4l2_frequency
*p
= arg
;
1719 if (vfd
->vfl_type
== VFL_TYPE_SDR
)
1720 p
->type
= V4L2_TUNER_SDR
;
1722 p
->type
= (vfd
->vfl_type
== VFL_TYPE_RADIO
) ?
1723 V4L2_TUNER_RADIO
: V4L2_TUNER_ANALOG_TV
;
1724 return ops
->vidioc_g_frequency(file
, fh
, p
);
1727 static int v4l_s_frequency(const struct v4l2_ioctl_ops
*ops
,
1728 struct file
*file
, void *fh
, void *arg
)
1730 struct video_device
*vfd
= video_devdata(file
);
1731 const struct v4l2_frequency
*p
= arg
;
1732 enum v4l2_tuner_type type
;
1735 ret
= v4l_enable_media_source(vfd
);
1738 if (vfd
->vfl_type
== VFL_TYPE_SDR
) {
1739 if (p
->type
!= V4L2_TUNER_SDR
&& p
->type
!= V4L2_TUNER_RF
)
1742 type
= (vfd
->vfl_type
== VFL_TYPE_RADIO
) ?
1743 V4L2_TUNER_RADIO
: V4L2_TUNER_ANALOG_TV
;
1744 if (type
!= p
->type
)
1747 return ops
->vidioc_s_frequency(file
, fh
, p
);
1750 static int v4l_enumstd(const struct v4l2_ioctl_ops
*ops
,
1751 struct file
*file
, void *fh
, void *arg
)
1753 struct video_device
*vfd
= video_devdata(file
);
1754 struct v4l2_standard
*p
= arg
;
1755 v4l2_std_id id
= vfd
->tvnorms
, curr_id
= 0;
1756 unsigned int index
= p
->index
, i
, j
= 0;
1757 const char *descr
= "";
1759 /* Return -ENODATA if the tvnorms for the current input
1760 or output is 0, meaning that it doesn't support this API. */
1764 /* Return norm array in a canonical way */
1765 for (i
= 0; i
<= index
&& id
; i
++) {
1766 /* last std value in the standards array is 0, so this
1767 while always ends there since (id & 0) == 0. */
1768 while ((id
& standards
[j
].std
) != standards
[j
].std
)
1770 curr_id
= standards
[j
].std
;
1771 descr
= standards
[j
].descr
;
1775 if (curr_id
!= V4L2_STD_PAL
&&
1776 curr_id
!= V4L2_STD_SECAM
&&
1777 curr_id
!= V4L2_STD_NTSC
)
1783 v4l2_video_std_construct(p
, curr_id
, descr
);
1787 static int v4l_s_std(const struct v4l2_ioctl_ops
*ops
,
1788 struct file
*file
, void *fh
, void *arg
)
1790 struct video_device
*vfd
= video_devdata(file
);
1791 v4l2_std_id id
= *(v4l2_std_id
*)arg
, norm
;
1794 ret
= v4l_enable_media_source(vfd
);
1797 norm
= id
& vfd
->tvnorms
;
1798 if (vfd
->tvnorms
&& !norm
) /* Check if std is supported */
1801 /* Calls the specific handler */
1802 return ops
->vidioc_s_std(file
, fh
, norm
);
1805 static int v4l_querystd(const struct v4l2_ioctl_ops
*ops
,
1806 struct file
*file
, void *fh
, void *arg
)
1808 struct video_device
*vfd
= video_devdata(file
);
1809 v4l2_std_id
*p
= arg
;
1812 ret
= v4l_enable_media_source(vfd
);
1816 * If no signal is detected, then the driver should return
1817 * V4L2_STD_UNKNOWN. Otherwise it should return tvnorms with
1818 * any standards that do not apply removed.
1820 * This means that tuners, audio and video decoders can join
1821 * their efforts to improve the standards detection.
1824 return ops
->vidioc_querystd(file
, fh
, arg
);
1827 static int v4l_s_hw_freq_seek(const struct v4l2_ioctl_ops
*ops
,
1828 struct file
*file
, void *fh
, void *arg
)
1830 struct video_device
*vfd
= video_devdata(file
);
1831 struct v4l2_hw_freq_seek
*p
= arg
;
1832 enum v4l2_tuner_type type
;
1835 ret
= v4l_enable_media_source(vfd
);
1838 /* s_hw_freq_seek is not supported for SDR for now */
1839 if (vfd
->vfl_type
== VFL_TYPE_SDR
)
1842 type
= (vfd
->vfl_type
== VFL_TYPE_RADIO
) ?
1843 V4L2_TUNER_RADIO
: V4L2_TUNER_ANALOG_TV
;
1844 if (p
->type
!= type
)
1846 return ops
->vidioc_s_hw_freq_seek(file
, fh
, p
);
1849 static int v4l_overlay(const struct v4l2_ioctl_ops
*ops
,
1850 struct file
*file
, void *fh
, void *arg
)
1852 return ops
->vidioc_overlay(file
, fh
, *(unsigned int *)arg
);
1855 static int v4l_reqbufs(const struct v4l2_ioctl_ops
*ops
,
1856 struct file
*file
, void *fh
, void *arg
)
1858 struct v4l2_requestbuffers
*p
= arg
;
1859 int ret
= check_fmt(file
, p
->type
);
1864 CLEAR_AFTER_FIELD(p
, memory
);
1866 return ops
->vidioc_reqbufs(file
, fh
, p
);
1869 static int v4l_querybuf(const struct v4l2_ioctl_ops
*ops
,
1870 struct file
*file
, void *fh
, void *arg
)
1872 struct v4l2_buffer
*p
= arg
;
1873 int ret
= check_fmt(file
, p
->type
);
1875 return ret
? ret
: ops
->vidioc_querybuf(file
, fh
, p
);
1878 static int v4l_qbuf(const struct v4l2_ioctl_ops
*ops
,
1879 struct file
*file
, void *fh
, void *arg
)
1881 struct v4l2_buffer
*p
= arg
;
1882 int ret
= check_fmt(file
, p
->type
);
1884 return ret
? ret
: ops
->vidioc_qbuf(file
, fh
, p
);
1887 static int v4l_dqbuf(const struct v4l2_ioctl_ops
*ops
,
1888 struct file
*file
, void *fh
, void *arg
)
1890 struct v4l2_buffer
*p
= arg
;
1891 int ret
= check_fmt(file
, p
->type
);
1893 return ret
? ret
: ops
->vidioc_dqbuf(file
, fh
, p
);
1896 static int v4l_create_bufs(const struct v4l2_ioctl_ops
*ops
,
1897 struct file
*file
, void *fh
, void *arg
)
1899 struct v4l2_create_buffers
*create
= arg
;
1900 int ret
= check_fmt(file
, create
->format
.type
);
1905 CLEAR_AFTER_FIELD(create
, format
);
1907 v4l_sanitize_format(&create
->format
);
1909 ret
= ops
->vidioc_create_bufs(file
, fh
, create
);
1911 if (create
->format
.type
== V4L2_BUF_TYPE_VIDEO_CAPTURE
||
1912 create
->format
.type
== V4L2_BUF_TYPE_VIDEO_OUTPUT
)
1913 create
->format
.fmt
.pix
.priv
= V4L2_PIX_FMT_PRIV_MAGIC
;
1918 static int v4l_prepare_buf(const struct v4l2_ioctl_ops
*ops
,
1919 struct file
*file
, void *fh
, void *arg
)
1921 struct v4l2_buffer
*b
= arg
;
1922 int ret
= check_fmt(file
, b
->type
);
1924 return ret
? ret
: ops
->vidioc_prepare_buf(file
, fh
, b
);
1927 static int v4l_g_parm(const struct v4l2_ioctl_ops
*ops
,
1928 struct file
*file
, void *fh
, void *arg
)
1930 struct v4l2_streamparm
*p
= arg
;
1932 int ret
= check_fmt(file
, p
->type
);
1936 if (ops
->vidioc_g_parm
)
1937 return ops
->vidioc_g_parm(file
, fh
, p
);
1938 if (p
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
&&
1939 p
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
1941 p
->parm
.capture
.readbuffers
= 2;
1942 ret
= ops
->vidioc_g_std(file
, fh
, &std
);
1944 v4l2_video_std_frame_period(std
, &p
->parm
.capture
.timeperframe
);
1948 static int v4l_s_parm(const struct v4l2_ioctl_ops
*ops
,
1949 struct file
*file
, void *fh
, void *arg
)
1951 struct v4l2_streamparm
*p
= arg
;
1952 int ret
= check_fmt(file
, p
->type
);
1957 /* Note: extendedmode is never used in drivers */
1958 if (V4L2_TYPE_IS_OUTPUT(p
->type
)) {
1959 memset(p
->parm
.output
.reserved
, 0,
1960 sizeof(p
->parm
.output
.reserved
));
1961 p
->parm
.output
.extendedmode
= 0;
1962 p
->parm
.output
.outputmode
&= V4L2_MODE_HIGHQUALITY
;
1964 memset(p
->parm
.capture
.reserved
, 0,
1965 sizeof(p
->parm
.capture
.reserved
));
1966 p
->parm
.capture
.extendedmode
= 0;
1967 p
->parm
.capture
.capturemode
&= V4L2_MODE_HIGHQUALITY
;
1969 return ops
->vidioc_s_parm(file
, fh
, p
);
1972 static int v4l_queryctrl(const struct v4l2_ioctl_ops
*ops
,
1973 struct file
*file
, void *fh
, void *arg
)
1975 struct video_device
*vfd
= video_devdata(file
);
1976 struct v4l2_queryctrl
*p
= arg
;
1977 struct v4l2_fh
*vfh
=
1978 test_bit(V4L2_FL_USES_V4L2_FH
, &vfd
->flags
) ? fh
: NULL
;
1980 if (vfh
&& vfh
->ctrl_handler
)
1981 return v4l2_queryctrl(vfh
->ctrl_handler
, p
);
1982 if (vfd
->ctrl_handler
)
1983 return v4l2_queryctrl(vfd
->ctrl_handler
, p
);
1984 if (ops
->vidioc_queryctrl
)
1985 return ops
->vidioc_queryctrl(file
, fh
, p
);
1989 static int v4l_query_ext_ctrl(const struct v4l2_ioctl_ops
*ops
,
1990 struct file
*file
, void *fh
, void *arg
)
1992 struct video_device
*vfd
= video_devdata(file
);
1993 struct v4l2_query_ext_ctrl
*p
= arg
;
1994 struct v4l2_fh
*vfh
=
1995 test_bit(V4L2_FL_USES_V4L2_FH
, &vfd
->flags
) ? fh
: NULL
;
1997 if (vfh
&& vfh
->ctrl_handler
)
1998 return v4l2_query_ext_ctrl(vfh
->ctrl_handler
, p
);
1999 if (vfd
->ctrl_handler
)
2000 return v4l2_query_ext_ctrl(vfd
->ctrl_handler
, p
);
2001 if (ops
->vidioc_query_ext_ctrl
)
2002 return ops
->vidioc_query_ext_ctrl(file
, fh
, p
);
2006 static int v4l_querymenu(const struct v4l2_ioctl_ops
*ops
,
2007 struct file
*file
, void *fh
, void *arg
)
2009 struct video_device
*vfd
= video_devdata(file
);
2010 struct v4l2_querymenu
*p
= arg
;
2011 struct v4l2_fh
*vfh
=
2012 test_bit(V4L2_FL_USES_V4L2_FH
, &vfd
->flags
) ? fh
: NULL
;
2014 if (vfh
&& vfh
->ctrl_handler
)
2015 return v4l2_querymenu(vfh
->ctrl_handler
, p
);
2016 if (vfd
->ctrl_handler
)
2017 return v4l2_querymenu(vfd
->ctrl_handler
, p
);
2018 if (ops
->vidioc_querymenu
)
2019 return ops
->vidioc_querymenu(file
, fh
, p
);
2023 static int v4l_g_ctrl(const struct v4l2_ioctl_ops
*ops
,
2024 struct file
*file
, void *fh
, void *arg
)
2026 struct video_device
*vfd
= video_devdata(file
);
2027 struct v4l2_control
*p
= arg
;
2028 struct v4l2_fh
*vfh
=
2029 test_bit(V4L2_FL_USES_V4L2_FH
, &vfd
->flags
) ? fh
: NULL
;
2030 struct v4l2_ext_controls ctrls
;
2031 struct v4l2_ext_control ctrl
;
2033 if (vfh
&& vfh
->ctrl_handler
)
2034 return v4l2_g_ctrl(vfh
->ctrl_handler
, p
);
2035 if (vfd
->ctrl_handler
)
2036 return v4l2_g_ctrl(vfd
->ctrl_handler
, p
);
2037 if (ops
->vidioc_g_ctrl
)
2038 return ops
->vidioc_g_ctrl(file
, fh
, p
);
2039 if (ops
->vidioc_g_ext_ctrls
== NULL
)
2042 ctrls
.which
= V4L2_CTRL_ID2WHICH(p
->id
);
2044 ctrls
.controls
= &ctrl
;
2046 ctrl
.value
= p
->value
;
2047 if (check_ext_ctrls(&ctrls
, 1)) {
2048 int ret
= ops
->vidioc_g_ext_ctrls(file
, fh
, &ctrls
);
2051 p
->value
= ctrl
.value
;
2057 static int v4l_s_ctrl(const struct v4l2_ioctl_ops
*ops
,
2058 struct file
*file
, void *fh
, void *arg
)
2060 struct video_device
*vfd
= video_devdata(file
);
2061 struct v4l2_control
*p
= arg
;
2062 struct v4l2_fh
*vfh
=
2063 test_bit(V4L2_FL_USES_V4L2_FH
, &vfd
->flags
) ? fh
: NULL
;
2064 struct v4l2_ext_controls ctrls
;
2065 struct v4l2_ext_control ctrl
;
2067 if (vfh
&& vfh
->ctrl_handler
)
2068 return v4l2_s_ctrl(vfh
, vfh
->ctrl_handler
, p
);
2069 if (vfd
->ctrl_handler
)
2070 return v4l2_s_ctrl(NULL
, vfd
->ctrl_handler
, p
);
2071 if (ops
->vidioc_s_ctrl
)
2072 return ops
->vidioc_s_ctrl(file
, fh
, p
);
2073 if (ops
->vidioc_s_ext_ctrls
== NULL
)
2076 ctrls
.which
= V4L2_CTRL_ID2WHICH(p
->id
);
2078 ctrls
.controls
= &ctrl
;
2080 ctrl
.value
= p
->value
;
2081 if (check_ext_ctrls(&ctrls
, 1))
2082 return ops
->vidioc_s_ext_ctrls(file
, fh
, &ctrls
);
2086 static int v4l_g_ext_ctrls(const struct v4l2_ioctl_ops
*ops
,
2087 struct file
*file
, void *fh
, void *arg
)
2089 struct video_device
*vfd
= video_devdata(file
);
2090 struct v4l2_ext_controls
*p
= arg
;
2091 struct v4l2_fh
*vfh
=
2092 test_bit(V4L2_FL_USES_V4L2_FH
, &vfd
->flags
) ? fh
: NULL
;
2094 p
->error_idx
= p
->count
;
2095 if (vfh
&& vfh
->ctrl_handler
)
2096 return v4l2_g_ext_ctrls(vfh
->ctrl_handler
, p
);
2097 if (vfd
->ctrl_handler
)
2098 return v4l2_g_ext_ctrls(vfd
->ctrl_handler
, p
);
2099 if (ops
->vidioc_g_ext_ctrls
== NULL
)
2101 return check_ext_ctrls(p
, 0) ? ops
->vidioc_g_ext_ctrls(file
, fh
, p
) :
2105 static int v4l_s_ext_ctrls(const struct v4l2_ioctl_ops
*ops
,
2106 struct file
*file
, void *fh
, void *arg
)
2108 struct video_device
*vfd
= video_devdata(file
);
2109 struct v4l2_ext_controls
*p
= arg
;
2110 struct v4l2_fh
*vfh
=
2111 test_bit(V4L2_FL_USES_V4L2_FH
, &vfd
->flags
) ? fh
: NULL
;
2113 p
->error_idx
= p
->count
;
2114 if (vfh
&& vfh
->ctrl_handler
)
2115 return v4l2_s_ext_ctrls(vfh
, vfh
->ctrl_handler
, p
);
2116 if (vfd
->ctrl_handler
)
2117 return v4l2_s_ext_ctrls(NULL
, vfd
->ctrl_handler
, p
);
2118 if (ops
->vidioc_s_ext_ctrls
== NULL
)
2120 return check_ext_ctrls(p
, 0) ? ops
->vidioc_s_ext_ctrls(file
, fh
, p
) :
2124 static int v4l_try_ext_ctrls(const struct v4l2_ioctl_ops
*ops
,
2125 struct file
*file
, void *fh
, void *arg
)
2127 struct video_device
*vfd
= video_devdata(file
);
2128 struct v4l2_ext_controls
*p
= arg
;
2129 struct v4l2_fh
*vfh
=
2130 test_bit(V4L2_FL_USES_V4L2_FH
, &vfd
->flags
) ? fh
: NULL
;
2132 p
->error_idx
= p
->count
;
2133 if (vfh
&& vfh
->ctrl_handler
)
2134 return v4l2_try_ext_ctrls(vfh
->ctrl_handler
, p
);
2135 if (vfd
->ctrl_handler
)
2136 return v4l2_try_ext_ctrls(vfd
->ctrl_handler
, p
);
2137 if (ops
->vidioc_try_ext_ctrls
== NULL
)
2139 return check_ext_ctrls(p
, 0) ? ops
->vidioc_try_ext_ctrls(file
, fh
, p
) :
2144 * The selection API specified originally that the _MPLANE buffer types
2145 * shouldn't be used. The reasons for this are lost in the mists of time
2146 * (or just really crappy memories). Regardless, this is really annoying
2147 * for userspace. So to keep things simple we map _MPLANE buffer types
2148 * to their 'regular' counterparts before calling the driver. And we
2149 * restore it afterwards. This way applications can use either buffer
2150 * type and drivers don't need to check for both.
2152 static int v4l_g_selection(const struct v4l2_ioctl_ops
*ops
,
2153 struct file
*file
, void *fh
, void *arg
)
2155 struct v4l2_selection
*p
= arg
;
2156 u32 old_type
= p
->type
;
2159 if (p
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
2160 p
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
2161 else if (p
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
)
2162 p
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
2163 ret
= ops
->vidioc_g_selection(file
, fh
, p
);
2168 static int v4l_s_selection(const struct v4l2_ioctl_ops
*ops
,
2169 struct file
*file
, void *fh
, void *arg
)
2171 struct v4l2_selection
*p
= arg
;
2172 u32 old_type
= p
->type
;
2175 if (p
->type
== V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE
)
2176 p
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
2177 else if (p
->type
== V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE
)
2178 p
->type
= V4L2_BUF_TYPE_VIDEO_OUTPUT
;
2179 ret
= ops
->vidioc_s_selection(file
, fh
, p
);
2184 static int v4l_g_crop(const struct v4l2_ioctl_ops
*ops
,
2185 struct file
*file
, void *fh
, void *arg
)
2187 struct v4l2_crop
*p
= arg
;
2188 struct v4l2_selection s
= {
2193 if (ops
->vidioc_g_crop
)
2194 return ops
->vidioc_g_crop(file
, fh
, p
);
2195 /* simulate capture crop using selection api */
2197 /* crop means compose for output devices */
2198 if (V4L2_TYPE_IS_OUTPUT(p
->type
))
2199 s
.target
= V4L2_SEL_TGT_COMPOSE_ACTIVE
;
2201 s
.target
= V4L2_SEL_TGT_CROP_ACTIVE
;
2203 ret
= v4l_g_selection(ops
, file
, fh
, &s
);
2205 /* copying results to old structure on success */
2211 static int v4l_s_crop(const struct v4l2_ioctl_ops
*ops
,
2212 struct file
*file
, void *fh
, void *arg
)
2214 struct v4l2_crop
*p
= arg
;
2215 struct v4l2_selection s
= {
2220 if (ops
->vidioc_s_crop
)
2221 return ops
->vidioc_s_crop(file
, fh
, p
);
2222 /* simulate capture crop using selection api */
2224 /* crop means compose for output devices */
2225 if (V4L2_TYPE_IS_OUTPUT(p
->type
))
2226 s
.target
= V4L2_SEL_TGT_COMPOSE_ACTIVE
;
2228 s
.target
= V4L2_SEL_TGT_CROP_ACTIVE
;
2230 return v4l_s_selection(ops
, file
, fh
, &s
);
2233 static int v4l_cropcap(const struct v4l2_ioctl_ops
*ops
,
2234 struct file
*file
, void *fh
, void *arg
)
2236 struct v4l2_cropcap
*p
= arg
;
2237 struct v4l2_selection s
= { .type
= p
->type
};
2240 /* setting trivial pixelaspect */
2241 p
->pixelaspect
.numerator
= 1;
2242 p
->pixelaspect
.denominator
= 1;
2245 * The determine_valid_ioctls() call already should ensure
2246 * that this can never happen, but just in case...
2248 if (WARN_ON(!ops
->vidioc_cropcap
&& !ops
->vidioc_g_selection
))
2251 if (ops
->vidioc_cropcap
)
2252 ret
= ops
->vidioc_cropcap(file
, fh
, p
);
2254 if (!ops
->vidioc_g_selection
)
2258 * Ignore ENOTTY or ENOIOCTLCMD error returns, just use the
2259 * square pixel aspect ratio in that case.
2261 if (ret
&& ret
!= -ENOTTY
&& ret
!= -ENOIOCTLCMD
)
2264 /* Use g_selection() to fill in the bounds and defrect rectangles */
2266 /* obtaining bounds */
2267 if (V4L2_TYPE_IS_OUTPUT(p
->type
))
2268 s
.target
= V4L2_SEL_TGT_COMPOSE_BOUNDS
;
2270 s
.target
= V4L2_SEL_TGT_CROP_BOUNDS
;
2272 ret
= v4l_g_selection(ops
, file
, fh
, &s
);
2277 /* obtaining defrect */
2278 if (V4L2_TYPE_IS_OUTPUT(p
->type
))
2279 s
.target
= V4L2_SEL_TGT_COMPOSE_DEFAULT
;
2281 s
.target
= V4L2_SEL_TGT_CROP_DEFAULT
;
2283 ret
= v4l_g_selection(ops
, file
, fh
, &s
);
2291 static int v4l_log_status(const struct v4l2_ioctl_ops
*ops
,
2292 struct file
*file
, void *fh
, void *arg
)
2294 struct video_device
*vfd
= video_devdata(file
);
2298 pr_info("%s: ================= START STATUS =================\n",
2299 vfd
->v4l2_dev
->name
);
2300 ret
= ops
->vidioc_log_status(file
, fh
);
2302 pr_info("%s: ================== END STATUS ==================\n",
2303 vfd
->v4l2_dev
->name
);
2307 static int v4l_dbg_g_register(const struct v4l2_ioctl_ops
*ops
,
2308 struct file
*file
, void *fh
, void *arg
)
2310 #ifdef CONFIG_VIDEO_ADV_DEBUG
2311 struct v4l2_dbg_register
*p
= arg
;
2312 struct video_device
*vfd
= video_devdata(file
);
2313 struct v4l2_subdev
*sd
;
2316 if (!capable(CAP_SYS_ADMIN
))
2318 if (p
->match
.type
== V4L2_CHIP_MATCH_SUBDEV
) {
2319 if (vfd
->v4l2_dev
== NULL
)
2321 v4l2_device_for_each_subdev(sd
, vfd
->v4l2_dev
)
2322 if (p
->match
.addr
== idx
++)
2323 return v4l2_subdev_call(sd
, core
, g_register
, p
);
2326 if (ops
->vidioc_g_register
&& p
->match
.type
== V4L2_CHIP_MATCH_BRIDGE
&&
2327 (ops
->vidioc_g_chip_info
|| p
->match
.addr
== 0))
2328 return ops
->vidioc_g_register(file
, fh
, p
);
2335 static int v4l_dbg_s_register(const struct v4l2_ioctl_ops
*ops
,
2336 struct file
*file
, void *fh
, void *arg
)
2338 #ifdef CONFIG_VIDEO_ADV_DEBUG
2339 const struct v4l2_dbg_register
*p
= arg
;
2340 struct video_device
*vfd
= video_devdata(file
);
2341 struct v4l2_subdev
*sd
;
2344 if (!capable(CAP_SYS_ADMIN
))
2346 if (p
->match
.type
== V4L2_CHIP_MATCH_SUBDEV
) {
2347 if (vfd
->v4l2_dev
== NULL
)
2349 v4l2_device_for_each_subdev(sd
, vfd
->v4l2_dev
)
2350 if (p
->match
.addr
== idx
++)
2351 return v4l2_subdev_call(sd
, core
, s_register
, p
);
2354 if (ops
->vidioc_s_register
&& p
->match
.type
== V4L2_CHIP_MATCH_BRIDGE
&&
2355 (ops
->vidioc_g_chip_info
|| p
->match
.addr
== 0))
2356 return ops
->vidioc_s_register(file
, fh
, p
);
2363 static int v4l_dbg_g_chip_info(const struct v4l2_ioctl_ops
*ops
,
2364 struct file
*file
, void *fh
, void *arg
)
2366 #ifdef CONFIG_VIDEO_ADV_DEBUG
2367 struct video_device
*vfd
= video_devdata(file
);
2368 struct v4l2_dbg_chip_info
*p
= arg
;
2369 struct v4l2_subdev
*sd
;
2372 switch (p
->match
.type
) {
2373 case V4L2_CHIP_MATCH_BRIDGE
:
2374 if (ops
->vidioc_s_register
)
2375 p
->flags
|= V4L2_CHIP_FL_WRITABLE
;
2376 if (ops
->vidioc_g_register
)
2377 p
->flags
|= V4L2_CHIP_FL_READABLE
;
2378 strlcpy(p
->name
, vfd
->v4l2_dev
->name
, sizeof(p
->name
));
2379 if (ops
->vidioc_g_chip_info
)
2380 return ops
->vidioc_g_chip_info(file
, fh
, arg
);
2385 case V4L2_CHIP_MATCH_SUBDEV
:
2386 if (vfd
->v4l2_dev
== NULL
)
2388 v4l2_device_for_each_subdev(sd
, vfd
->v4l2_dev
) {
2389 if (p
->match
.addr
!= idx
++)
2391 if (sd
->ops
->core
&& sd
->ops
->core
->s_register
)
2392 p
->flags
|= V4L2_CHIP_FL_WRITABLE
;
2393 if (sd
->ops
->core
&& sd
->ops
->core
->g_register
)
2394 p
->flags
|= V4L2_CHIP_FL_READABLE
;
2395 strlcpy(p
->name
, sd
->name
, sizeof(p
->name
));
2406 static int v4l_dqevent(const struct v4l2_ioctl_ops
*ops
,
2407 struct file
*file
, void *fh
, void *arg
)
2409 return v4l2_event_dequeue(fh
, arg
, file
->f_flags
& O_NONBLOCK
);
2412 static int v4l_subscribe_event(const struct v4l2_ioctl_ops
*ops
,
2413 struct file
*file
, void *fh
, void *arg
)
2415 return ops
->vidioc_subscribe_event(fh
, arg
);
2418 static int v4l_unsubscribe_event(const struct v4l2_ioctl_ops
*ops
,
2419 struct file
*file
, void *fh
, void *arg
)
2421 return ops
->vidioc_unsubscribe_event(fh
, arg
);
2424 static int v4l_g_sliced_vbi_cap(const struct v4l2_ioctl_ops
*ops
,
2425 struct file
*file
, void *fh
, void *arg
)
2427 struct v4l2_sliced_vbi_cap
*p
= arg
;
2428 int ret
= check_fmt(file
, p
->type
);
2433 /* Clear up to type, everything after type is zeroed already */
2434 memset(p
, 0, offsetof(struct v4l2_sliced_vbi_cap
, type
));
2436 return ops
->vidioc_g_sliced_vbi_cap(file
, fh
, p
);
2439 static int v4l_enum_freq_bands(const struct v4l2_ioctl_ops
*ops
,
2440 struct file
*file
, void *fh
, void *arg
)
2442 struct video_device
*vfd
= video_devdata(file
);
2443 struct v4l2_frequency_band
*p
= arg
;
2444 enum v4l2_tuner_type type
;
2447 if (vfd
->vfl_type
== VFL_TYPE_SDR
) {
2448 if (p
->type
!= V4L2_TUNER_SDR
&& p
->type
!= V4L2_TUNER_RF
)
2452 type
= (vfd
->vfl_type
== VFL_TYPE_RADIO
) ?
2453 V4L2_TUNER_RADIO
: V4L2_TUNER_ANALOG_TV
;
2454 if (type
!= p
->type
)
2457 if (ops
->vidioc_enum_freq_bands
) {
2458 err
= ops
->vidioc_enum_freq_bands(file
, fh
, p
);
2462 if (is_valid_ioctl(vfd
, VIDIOC_G_TUNER
)) {
2463 struct v4l2_tuner t
= {
2470 err
= ops
->vidioc_g_tuner(file
, fh
, &t
);
2473 p
->capability
= t
.capability
| V4L2_TUNER_CAP_FREQ_BANDS
;
2474 p
->rangelow
= t
.rangelow
;
2475 p
->rangehigh
= t
.rangehigh
;
2476 p
->modulation
= (type
== V4L2_TUNER_RADIO
) ?
2477 V4L2_BAND_MODULATION_FM
: V4L2_BAND_MODULATION_VSB
;
2480 if (is_valid_ioctl(vfd
, VIDIOC_G_MODULATOR
)) {
2481 struct v4l2_modulator m
= {
2485 if (type
!= V4L2_TUNER_RADIO
)
2489 err
= ops
->vidioc_g_modulator(file
, fh
, &m
);
2492 p
->capability
= m
.capability
| V4L2_TUNER_CAP_FREQ_BANDS
;
2493 p
->rangelow
= m
.rangelow
;
2494 p
->rangehigh
= m
.rangehigh
;
2495 p
->modulation
= (type
== V4L2_TUNER_RADIO
) ?
2496 V4L2_BAND_MODULATION_FM
: V4L2_BAND_MODULATION_VSB
;
2502 struct v4l2_ioctl_info
{
2505 const char * const name
;
2508 int (*func
)(const struct v4l2_ioctl_ops
*ops
,
2509 struct file
*file
, void *fh
, void *p
);
2511 void (*debug
)(const void *arg
, bool write_only
);
2514 /* This control needs a priority check */
2515 #define INFO_FL_PRIO (1 << 0)
2516 /* This control can be valid if the filehandle passes a control handler. */
2517 #define INFO_FL_CTRL (1 << 1)
2518 /* This is a standard ioctl, no need for special code */
2519 #define INFO_FL_STD (1 << 2)
2520 /* This is ioctl has its own function */
2521 #define INFO_FL_FUNC (1 << 3)
2523 #define INFO_FL_QUEUE (1 << 4)
2524 /* Always copy back result, even on error */
2525 #define INFO_FL_ALWAYS_COPY (1 << 5)
2526 /* Zero struct from after the field to the end */
2527 #define INFO_FL_CLEAR(v4l2_struct, field) \
2528 ((offsetof(struct v4l2_struct, field) + \
2529 sizeof(((struct v4l2_struct *)0)->field)) << 16)
2530 #define INFO_FL_CLEAR_MASK (_IOC_SIZEMASK << 16)
2532 #define IOCTL_INFO_STD(_ioctl, _vidioc, _debug, _flags) \
2533 [_IOC_NR(_ioctl)] = { \
2535 .flags = _flags | INFO_FL_STD, \
2537 .u.offset = offsetof(struct v4l2_ioctl_ops, _vidioc), \
2541 #define IOCTL_INFO_FNC(_ioctl, _func, _debug, _flags) \
2542 [_IOC_NR(_ioctl)] = { \
2544 .flags = _flags | INFO_FL_FUNC, \
2550 static struct v4l2_ioctl_info v4l2_ioctls
[] = {
2551 IOCTL_INFO_FNC(VIDIOC_QUERYCAP
, v4l_querycap
, v4l_print_querycap
, 0),
2552 IOCTL_INFO_FNC(VIDIOC_ENUM_FMT
, v4l_enum_fmt
, v4l_print_fmtdesc
, INFO_FL_CLEAR(v4l2_fmtdesc
, type
)),
2553 IOCTL_INFO_FNC(VIDIOC_G_FMT
, v4l_g_fmt
, v4l_print_format
, 0),
2554 IOCTL_INFO_FNC(VIDIOC_S_FMT
, v4l_s_fmt
, v4l_print_format
, INFO_FL_PRIO
),
2555 IOCTL_INFO_FNC(VIDIOC_REQBUFS
, v4l_reqbufs
, v4l_print_requestbuffers
, INFO_FL_PRIO
| INFO_FL_QUEUE
),
2556 IOCTL_INFO_FNC(VIDIOC_QUERYBUF
, v4l_querybuf
, v4l_print_buffer
, INFO_FL_QUEUE
| INFO_FL_CLEAR(v4l2_buffer
, length
)),
2557 IOCTL_INFO_STD(VIDIOC_G_FBUF
, vidioc_g_fbuf
, v4l_print_framebuffer
, 0),
2558 IOCTL_INFO_STD(VIDIOC_S_FBUF
, vidioc_s_fbuf
, v4l_print_framebuffer
, INFO_FL_PRIO
),
2559 IOCTL_INFO_FNC(VIDIOC_OVERLAY
, v4l_overlay
, v4l_print_u32
, INFO_FL_PRIO
),
2560 IOCTL_INFO_FNC(VIDIOC_QBUF
, v4l_qbuf
, v4l_print_buffer
, INFO_FL_QUEUE
),
2561 IOCTL_INFO_STD(VIDIOC_EXPBUF
, vidioc_expbuf
, v4l_print_exportbuffer
, INFO_FL_QUEUE
| INFO_FL_CLEAR(v4l2_exportbuffer
, flags
)),
2562 IOCTL_INFO_FNC(VIDIOC_DQBUF
, v4l_dqbuf
, v4l_print_buffer
, INFO_FL_QUEUE
),
2563 IOCTL_INFO_FNC(VIDIOC_STREAMON
, v4l_streamon
, v4l_print_buftype
, INFO_FL_PRIO
| INFO_FL_QUEUE
),
2564 IOCTL_INFO_FNC(VIDIOC_STREAMOFF
, v4l_streamoff
, v4l_print_buftype
, INFO_FL_PRIO
| INFO_FL_QUEUE
),
2565 IOCTL_INFO_FNC(VIDIOC_G_PARM
, v4l_g_parm
, v4l_print_streamparm
, INFO_FL_CLEAR(v4l2_streamparm
, type
)),
2566 IOCTL_INFO_FNC(VIDIOC_S_PARM
, v4l_s_parm
, v4l_print_streamparm
, INFO_FL_PRIO
),
2567 IOCTL_INFO_STD(VIDIOC_G_STD
, vidioc_g_std
, v4l_print_std
, 0),
2568 IOCTL_INFO_FNC(VIDIOC_S_STD
, v4l_s_std
, v4l_print_std
, INFO_FL_PRIO
),
2569 IOCTL_INFO_FNC(VIDIOC_ENUMSTD
, v4l_enumstd
, v4l_print_standard
, INFO_FL_CLEAR(v4l2_standard
, index
)),
2570 IOCTL_INFO_FNC(VIDIOC_ENUMINPUT
, v4l_enuminput
, v4l_print_enuminput
, INFO_FL_CLEAR(v4l2_input
, index
)),
2571 IOCTL_INFO_FNC(VIDIOC_G_CTRL
, v4l_g_ctrl
, v4l_print_control
, INFO_FL_CTRL
| INFO_FL_CLEAR(v4l2_control
, id
)),
2572 IOCTL_INFO_FNC(VIDIOC_S_CTRL
, v4l_s_ctrl
, v4l_print_control
, INFO_FL_PRIO
| INFO_FL_CTRL
),
2573 IOCTL_INFO_FNC(VIDIOC_G_TUNER
, v4l_g_tuner
, v4l_print_tuner
, INFO_FL_CLEAR(v4l2_tuner
, index
)),
2574 IOCTL_INFO_FNC(VIDIOC_S_TUNER
, v4l_s_tuner
, v4l_print_tuner
, INFO_FL_PRIO
),
2575 IOCTL_INFO_STD(VIDIOC_G_AUDIO
, vidioc_g_audio
, v4l_print_audio
, 0),
2576 IOCTL_INFO_STD(VIDIOC_S_AUDIO
, vidioc_s_audio
, v4l_print_audio
, INFO_FL_PRIO
),
2577 IOCTL_INFO_FNC(VIDIOC_QUERYCTRL
, v4l_queryctrl
, v4l_print_queryctrl
, INFO_FL_CTRL
| INFO_FL_CLEAR(v4l2_queryctrl
, id
)),
2578 IOCTL_INFO_FNC(VIDIOC_QUERYMENU
, v4l_querymenu
, v4l_print_querymenu
, INFO_FL_CTRL
| INFO_FL_CLEAR(v4l2_querymenu
, index
)),
2579 IOCTL_INFO_STD(VIDIOC_G_INPUT
, vidioc_g_input
, v4l_print_u32
, 0),
2580 IOCTL_INFO_FNC(VIDIOC_S_INPUT
, v4l_s_input
, v4l_print_u32
, INFO_FL_PRIO
),
2581 IOCTL_INFO_STD(VIDIOC_G_EDID
, vidioc_g_edid
, v4l_print_edid
, INFO_FL_ALWAYS_COPY
),
2582 IOCTL_INFO_STD(VIDIOC_S_EDID
, vidioc_s_edid
, v4l_print_edid
, INFO_FL_PRIO
| INFO_FL_ALWAYS_COPY
),
2583 IOCTL_INFO_STD(VIDIOC_G_OUTPUT
, vidioc_g_output
, v4l_print_u32
, 0),
2584 IOCTL_INFO_FNC(VIDIOC_S_OUTPUT
, v4l_s_output
, v4l_print_u32
, INFO_FL_PRIO
),
2585 IOCTL_INFO_FNC(VIDIOC_ENUMOUTPUT
, v4l_enumoutput
, v4l_print_enumoutput
, INFO_FL_CLEAR(v4l2_output
, index
)),
2586 IOCTL_INFO_STD(VIDIOC_G_AUDOUT
, vidioc_g_audout
, v4l_print_audioout
, 0),
2587 IOCTL_INFO_STD(VIDIOC_S_AUDOUT
, vidioc_s_audout
, v4l_print_audioout
, INFO_FL_PRIO
),
2588 IOCTL_INFO_FNC(VIDIOC_G_MODULATOR
, v4l_g_modulator
, v4l_print_modulator
, INFO_FL_CLEAR(v4l2_modulator
, index
)),
2589 IOCTL_INFO_FNC(VIDIOC_S_MODULATOR
, v4l_s_modulator
, v4l_print_modulator
, INFO_FL_PRIO
),
2590 IOCTL_INFO_FNC(VIDIOC_G_FREQUENCY
, v4l_g_frequency
, v4l_print_frequency
, INFO_FL_CLEAR(v4l2_frequency
, tuner
)),
2591 IOCTL_INFO_FNC(VIDIOC_S_FREQUENCY
, v4l_s_frequency
, v4l_print_frequency
, INFO_FL_PRIO
),
2592 IOCTL_INFO_FNC(VIDIOC_CROPCAP
, v4l_cropcap
, v4l_print_cropcap
, INFO_FL_CLEAR(v4l2_cropcap
, type
)),
2593 IOCTL_INFO_FNC(VIDIOC_G_CROP
, v4l_g_crop
, v4l_print_crop
, INFO_FL_CLEAR(v4l2_crop
, type
)),
2594 IOCTL_INFO_FNC(VIDIOC_S_CROP
, v4l_s_crop
, v4l_print_crop
, INFO_FL_PRIO
),
2595 IOCTL_INFO_FNC(VIDIOC_G_SELECTION
, v4l_g_selection
, v4l_print_selection
, INFO_FL_CLEAR(v4l2_selection
, r
)),
2596 IOCTL_INFO_FNC(VIDIOC_S_SELECTION
, v4l_s_selection
, v4l_print_selection
, INFO_FL_PRIO
| INFO_FL_CLEAR(v4l2_selection
, r
)),
2597 IOCTL_INFO_STD(VIDIOC_G_JPEGCOMP
, vidioc_g_jpegcomp
, v4l_print_jpegcompression
, 0),
2598 IOCTL_INFO_STD(VIDIOC_S_JPEGCOMP
, vidioc_s_jpegcomp
, v4l_print_jpegcompression
, INFO_FL_PRIO
),
2599 IOCTL_INFO_FNC(VIDIOC_QUERYSTD
, v4l_querystd
, v4l_print_std
, 0),
2600 IOCTL_INFO_FNC(VIDIOC_TRY_FMT
, v4l_try_fmt
, v4l_print_format
, 0),
2601 IOCTL_INFO_STD(VIDIOC_ENUMAUDIO
, vidioc_enumaudio
, v4l_print_audio
, INFO_FL_CLEAR(v4l2_audio
, index
)),
2602 IOCTL_INFO_STD(VIDIOC_ENUMAUDOUT
, vidioc_enumaudout
, v4l_print_audioout
, INFO_FL_CLEAR(v4l2_audioout
, index
)),
2603 IOCTL_INFO_FNC(VIDIOC_G_PRIORITY
, v4l_g_priority
, v4l_print_u32
, 0),
2604 IOCTL_INFO_FNC(VIDIOC_S_PRIORITY
, v4l_s_priority
, v4l_print_u32
, INFO_FL_PRIO
),
2605 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
)),
2606 IOCTL_INFO_FNC(VIDIOC_LOG_STATUS
, v4l_log_status
, v4l_print_newline
, 0),
2607 IOCTL_INFO_FNC(VIDIOC_G_EXT_CTRLS
, v4l_g_ext_ctrls
, v4l_print_ext_controls
, INFO_FL_CTRL
),
2608 IOCTL_INFO_FNC(VIDIOC_S_EXT_CTRLS
, v4l_s_ext_ctrls
, v4l_print_ext_controls
, INFO_FL_PRIO
| INFO_FL_CTRL
),
2609 IOCTL_INFO_FNC(VIDIOC_TRY_EXT_CTRLS
, v4l_try_ext_ctrls
, v4l_print_ext_controls
, INFO_FL_CTRL
),
2610 IOCTL_INFO_STD(VIDIOC_ENUM_FRAMESIZES
, vidioc_enum_framesizes
, v4l_print_frmsizeenum
, INFO_FL_CLEAR(v4l2_frmsizeenum
, pixel_format
)),
2611 IOCTL_INFO_STD(VIDIOC_ENUM_FRAMEINTERVALS
, vidioc_enum_frameintervals
, v4l_print_frmivalenum
, INFO_FL_CLEAR(v4l2_frmivalenum
, height
)),
2612 IOCTL_INFO_STD(VIDIOC_G_ENC_INDEX
, vidioc_g_enc_index
, v4l_print_enc_idx
, 0),
2613 IOCTL_INFO_STD(VIDIOC_ENCODER_CMD
, vidioc_encoder_cmd
, v4l_print_encoder_cmd
, INFO_FL_PRIO
| INFO_FL_CLEAR(v4l2_encoder_cmd
, flags
)),
2614 IOCTL_INFO_STD(VIDIOC_TRY_ENCODER_CMD
, vidioc_try_encoder_cmd
, v4l_print_encoder_cmd
, INFO_FL_CLEAR(v4l2_encoder_cmd
, flags
)),
2615 IOCTL_INFO_STD(VIDIOC_DECODER_CMD
, vidioc_decoder_cmd
, v4l_print_decoder_cmd
, INFO_FL_PRIO
),
2616 IOCTL_INFO_STD(VIDIOC_TRY_DECODER_CMD
, vidioc_try_decoder_cmd
, v4l_print_decoder_cmd
, 0),
2617 IOCTL_INFO_FNC(VIDIOC_DBG_S_REGISTER
, v4l_dbg_s_register
, v4l_print_dbg_register
, 0),
2618 IOCTL_INFO_FNC(VIDIOC_DBG_G_REGISTER
, v4l_dbg_g_register
, v4l_print_dbg_register
, 0),
2619 IOCTL_INFO_FNC(VIDIOC_S_HW_FREQ_SEEK
, v4l_s_hw_freq_seek
, v4l_print_hw_freq_seek
, INFO_FL_PRIO
),
2620 IOCTL_INFO_STD(VIDIOC_S_DV_TIMINGS
, vidioc_s_dv_timings
, v4l_print_dv_timings
, INFO_FL_PRIO
| INFO_FL_CLEAR(v4l2_dv_timings
, bt
.flags
)),
2621 IOCTL_INFO_STD(VIDIOC_G_DV_TIMINGS
, vidioc_g_dv_timings
, v4l_print_dv_timings
, 0),
2622 IOCTL_INFO_FNC(VIDIOC_DQEVENT
, v4l_dqevent
, v4l_print_event
, 0),
2623 IOCTL_INFO_FNC(VIDIOC_SUBSCRIBE_EVENT
, v4l_subscribe_event
, v4l_print_event_subscription
, 0),
2624 IOCTL_INFO_FNC(VIDIOC_UNSUBSCRIBE_EVENT
, v4l_unsubscribe_event
, v4l_print_event_subscription
, 0),
2625 IOCTL_INFO_FNC(VIDIOC_CREATE_BUFS
, v4l_create_bufs
, v4l_print_create_buffers
, INFO_FL_PRIO
| INFO_FL_QUEUE
),
2626 IOCTL_INFO_FNC(VIDIOC_PREPARE_BUF
, v4l_prepare_buf
, v4l_print_buffer
, INFO_FL_QUEUE
),
2627 IOCTL_INFO_STD(VIDIOC_ENUM_DV_TIMINGS
, vidioc_enum_dv_timings
, v4l_print_enum_dv_timings
, INFO_FL_CLEAR(v4l2_enum_dv_timings
, pad
)),
2628 IOCTL_INFO_STD(VIDIOC_QUERY_DV_TIMINGS
, vidioc_query_dv_timings
, v4l_print_dv_timings
, INFO_FL_ALWAYS_COPY
),
2629 IOCTL_INFO_STD(VIDIOC_DV_TIMINGS_CAP
, vidioc_dv_timings_cap
, v4l_print_dv_timings_cap
, INFO_FL_CLEAR(v4l2_dv_timings_cap
, type
)),
2630 IOCTL_INFO_FNC(VIDIOC_ENUM_FREQ_BANDS
, v4l_enum_freq_bands
, v4l_print_freq_band
, 0),
2631 IOCTL_INFO_FNC(VIDIOC_DBG_G_CHIP_INFO
, v4l_dbg_g_chip_info
, v4l_print_dbg_chip_info
, INFO_FL_CLEAR(v4l2_dbg_chip_info
, match
)),
2632 IOCTL_INFO_FNC(VIDIOC_QUERY_EXT_CTRL
, v4l_query_ext_ctrl
, v4l_print_query_ext_ctrl
, INFO_FL_CTRL
| INFO_FL_CLEAR(v4l2_query_ext_ctrl
, id
)),
2634 #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
2636 bool v4l2_is_known_ioctl(unsigned int cmd
)
2638 if (_IOC_NR(cmd
) >= V4L2_IOCTLS
)
2640 return v4l2_ioctls
[_IOC_NR(cmd
)].ioctl
== cmd
;
2643 struct mutex
*v4l2_ioctl_get_lock(struct video_device
*vdev
, unsigned cmd
)
2645 if (_IOC_NR(cmd
) >= V4L2_IOCTLS
)
2647 if (test_bit(_IOC_NR(cmd
), vdev
->disable_locking
))
2649 if (vdev
->queue
&& vdev
->queue
->lock
&&
2650 (v4l2_ioctls
[_IOC_NR(cmd
)].flags
& INFO_FL_QUEUE
))
2651 return vdev
->queue
->lock
;
2655 /* Common ioctl debug function. This function can be used by
2656 external ioctl messages as well as internal V4L ioctl */
2657 void v4l_printk_ioctl(const char *prefix
, unsigned int cmd
)
2659 const char *dir
, *type
;
2662 printk(KERN_DEBUG
"%s: ", prefix
);
2664 switch (_IOC_TYPE(cmd
)) {
2669 if (_IOC_NR(cmd
) >= V4L2_IOCTLS
) {
2673 pr_cont("%s", v4l2_ioctls
[_IOC_NR(cmd
)].name
);
2680 switch (_IOC_DIR(cmd
)) {
2681 case _IOC_NONE
: dir
= "--"; break;
2682 case _IOC_READ
: dir
= "r-"; break;
2683 case _IOC_WRITE
: dir
= "-w"; break;
2684 case _IOC_READ
| _IOC_WRITE
: dir
= "rw"; break;
2685 default: dir
= "*ERR*"; break;
2687 pr_cont("%s ioctl '%c', dir=%s, #%d (0x%08x)",
2688 type
, _IOC_TYPE(cmd
), dir
, _IOC_NR(cmd
), cmd
);
2690 EXPORT_SYMBOL(v4l_printk_ioctl
);
2692 static long __video_do_ioctl(struct file
*file
,
2693 unsigned int cmd
, void *arg
)
2695 struct video_device
*vfd
= video_devdata(file
);
2696 const struct v4l2_ioctl_ops
*ops
= vfd
->ioctl_ops
;
2697 bool write_only
= false;
2698 struct v4l2_ioctl_info default_info
;
2699 const struct v4l2_ioctl_info
*info
;
2700 void *fh
= file
->private_data
;
2701 struct v4l2_fh
*vfh
= NULL
;
2702 int dev_debug
= vfd
->dev_debug
;
2706 pr_warn("%s: has no ioctl_ops.\n",
2707 video_device_node_name(vfd
));
2711 if (test_bit(V4L2_FL_USES_V4L2_FH
, &vfd
->flags
))
2712 vfh
= file
->private_data
;
2714 if (v4l2_is_known_ioctl(cmd
)) {
2715 info
= &v4l2_ioctls
[_IOC_NR(cmd
)];
2717 if (!test_bit(_IOC_NR(cmd
), vfd
->valid_ioctls
) &&
2718 !((info
->flags
& INFO_FL_CTRL
) && vfh
&& vfh
->ctrl_handler
))
2721 if (vfh
&& (info
->flags
& INFO_FL_PRIO
)) {
2722 ret
= v4l2_prio_check(vfd
->prio
, vfh
->prio
);
2727 default_info
.ioctl
= cmd
;
2728 default_info
.flags
= 0;
2729 default_info
.debug
= v4l_print_default
;
2730 info
= &default_info
;
2733 write_only
= _IOC_DIR(cmd
) == _IOC_WRITE
;
2734 if (info
->flags
& INFO_FL_STD
) {
2735 typedef int (*vidioc_op
)(struct file
*file
, void *fh
, void *p
);
2736 const void *p
= vfd
->ioctl_ops
;
2737 const vidioc_op
*vidioc
= p
+ info
->u
.offset
;
2739 ret
= (*vidioc
)(file
, fh
, arg
);
2740 } else if (info
->flags
& INFO_FL_FUNC
) {
2741 ret
= info
->u
.func(ops
, file
, fh
, arg
);
2742 } else if (!ops
->vidioc_default
) {
2745 ret
= ops
->vidioc_default(file
, fh
,
2746 vfh
? v4l2_prio_check(vfd
->prio
, vfh
->prio
) >= 0 : 0,
2751 if (dev_debug
& (V4L2_DEV_DEBUG_IOCTL
| V4L2_DEV_DEBUG_IOCTL_ARG
)) {
2752 if (!(dev_debug
& V4L2_DEV_DEBUG_STREAMING
) &&
2753 (cmd
== VIDIOC_QBUF
|| cmd
== VIDIOC_DQBUF
))
2756 v4l_printk_ioctl(video_device_node_name(vfd
), cmd
);
2758 pr_cont(": error %ld", ret
);
2759 if (!(dev_debug
& V4L2_DEV_DEBUG_IOCTL_ARG
))
2761 else if (_IOC_DIR(cmd
) == _IOC_NONE
)
2762 info
->debug(arg
, write_only
);
2765 info
->debug(arg
, write_only
);
2772 static int check_array_args(unsigned int cmd
, void *parg
, size_t *array_size
,
2773 void __user
**user_ptr
, void ***kernel_ptr
)
2778 case VIDIOC_PREPARE_BUF
:
2779 case VIDIOC_QUERYBUF
:
2781 case VIDIOC_DQBUF
: {
2782 struct v4l2_buffer
*buf
= parg
;
2784 if (V4L2_TYPE_IS_MULTIPLANAR(buf
->type
) && buf
->length
> 0) {
2785 if (buf
->length
> VIDEO_MAX_PLANES
) {
2789 *user_ptr
= (void __user
*)buf
->m
.planes
;
2790 *kernel_ptr
= (void **)&buf
->m
.planes
;
2791 *array_size
= sizeof(struct v4l2_plane
) * buf
->length
;
2798 case VIDIOC_S_EDID
: {
2799 struct v4l2_edid
*edid
= parg
;
2802 if (edid
->blocks
> 256) {
2806 *user_ptr
= (void __user
*)edid
->edid
;
2807 *kernel_ptr
= (void **)&edid
->edid
;
2808 *array_size
= edid
->blocks
* 128;
2814 case VIDIOC_S_EXT_CTRLS
:
2815 case VIDIOC_G_EXT_CTRLS
:
2816 case VIDIOC_TRY_EXT_CTRLS
: {
2817 struct v4l2_ext_controls
*ctrls
= parg
;
2819 if (ctrls
->count
!= 0) {
2820 if (ctrls
->count
> V4L2_CID_MAX_CTRLS
) {
2824 *user_ptr
= (void __user
*)ctrls
->controls
;
2825 *kernel_ptr
= (void **)&ctrls
->controls
;
2826 *array_size
= sizeof(struct v4l2_ext_control
)
2838 video_usercopy(struct file
*file
, unsigned int cmd
, unsigned long arg
,
2843 void *parg
= (void *)arg
;
2845 bool has_array_args
;
2846 bool always_copy
= false;
2847 size_t array_size
= 0;
2848 void __user
*user_ptr
= NULL
;
2849 void **kernel_ptr
= NULL
;
2851 /* Copy arguments into temp kernel buffer */
2852 if (_IOC_DIR(cmd
) != _IOC_NONE
) {
2853 if (_IOC_SIZE(cmd
) <= sizeof(sbuf
)) {
2856 /* too big to allocate from stack */
2857 mbuf
= kvmalloc(_IOC_SIZE(cmd
), GFP_KERNEL
);
2864 if (_IOC_DIR(cmd
) & _IOC_WRITE
) {
2865 unsigned int n
= _IOC_SIZE(cmd
);
2868 * In some cases, only a few fields are used as input,
2869 * i.e. when the app sets "index" and then the driver
2870 * fills in the rest of the structure for the thing
2871 * with that index. We only need to copy up the first
2874 if (v4l2_is_known_ioctl(cmd
)) {
2875 u32 flags
= v4l2_ioctls
[_IOC_NR(cmd
)].flags
;
2877 if (flags
& INFO_FL_CLEAR_MASK
)
2878 n
= (flags
& INFO_FL_CLEAR_MASK
) >> 16;
2879 always_copy
= flags
& INFO_FL_ALWAYS_COPY
;
2882 if (copy_from_user(parg
, (void __user
*)arg
, n
))
2885 /* zero out anything we don't copy from userspace */
2886 if (n
< _IOC_SIZE(cmd
))
2887 memset((u8
*)parg
+ n
, 0, _IOC_SIZE(cmd
) - n
);
2889 /* read-only ioctl */
2890 memset(parg
, 0, _IOC_SIZE(cmd
));
2894 err
= check_array_args(cmd
, parg
, &array_size
, &user_ptr
, &kernel_ptr
);
2897 has_array_args
= err
;
2899 if (has_array_args
) {
2901 * When adding new types of array args, make sure that the
2902 * parent argument to ioctl (which contains the pointer to the
2903 * array) fits into sbuf (so that mbuf will still remain
2904 * unused up to here).
2906 mbuf
= kvmalloc(array_size
, GFP_KERNEL
);
2909 goto out_array_args
;
2911 if (copy_from_user(mbuf
, user_ptr
, array_size
))
2912 goto out_array_args
;
2917 err
= func(file
, cmd
, parg
);
2918 if (err
== -ENOTTY
|| err
== -ENOIOCTLCMD
) {
2924 if (cmd
== VIDIOC_DQBUF
)
2925 trace_v4l2_dqbuf(video_devdata(file
)->minor
, parg
);
2926 else if (cmd
== VIDIOC_QBUF
)
2927 trace_v4l2_qbuf(video_devdata(file
)->minor
, parg
);
2930 if (has_array_args
) {
2931 *kernel_ptr
= (void __force
*)user_ptr
;
2932 if (copy_to_user(user_ptr
, mbuf
, array_size
))
2934 goto out_array_args
;
2937 * Some ioctls can return an error, but still have valid
2938 * results that must be returned.
2940 if (err
< 0 && !always_copy
)
2944 /* Copy results into user buffer */
2945 switch (_IOC_DIR(cmd
)) {
2947 case (_IOC_WRITE
| _IOC_READ
):
2948 if (copy_to_user((void __user
*)arg
, parg
, _IOC_SIZE(cmd
)))
2957 EXPORT_SYMBOL(video_usercopy
);
2959 long video_ioctl2(struct file
*file
,
2960 unsigned int cmd
, unsigned long arg
)
2962 return video_usercopy(file
, cmd
, arg
, __video_do_ioctl
);
2964 EXPORT_SYMBOL(video_ioctl2
);