projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (9296): Patch to remove warning message during cx88-dvb compilation
[deliverable/linux.git] / drivers / media / video / v4l2-ioctl.c
CommitLineData
35ea11ff
HV		 1/*
2 * Video capture interface for Linux version 2
3 *
4 * A generic framework to process V4L2 ioctl commands.
5 *
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.
10 *
11 * Authors: Alan Cox, <alan@redhat.com> (version 1)
12 * Mauro Carvalho Chehab <mchehab@infradead.org> (version 2)
13 */
14
15#include <linux/module.h>
16#include <linux/types.h>
17#include <linux/kernel.h>
18
19#define __OLD_VIDIOC_ /* To allow fixing old calls */
20#include <linux/videodev2.h>
21
22#ifdef CONFIG_VIDEO_V4L1
23#include <linux/videodev.h>
24#endif
25#include <media/v4l2-common.h>
26#include <media/v4l2-ioctl.h>
27#include <linux/video_decoder.h>
28
29#define dbgarg(cmd, fmt, arg...) \
30 do { \
31 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) { \
32 printk(KERN_DEBUG "%s: ", vfd->name); \
33 v4l_printk_ioctl(cmd); \
34 printk(" " fmt, ## arg); \
35 } \
36 } while (0)
37
38#define dbgarg2(fmt, arg...) \
39 do { \
40 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) \
41 printk(KERN_DEBUG "%s: " fmt, vfd->name, ## arg);\
42 } while (0)
43
44struct std_descr {
45 v4l2_std_id std;
46 const char *descr;
47};
48
49static const struct std_descr standards[] = {
50 { V4L2_STD_NTSC, "NTSC" },
51 { V4L2_STD_NTSC_M, "NTSC-M" },
52 { V4L2_STD_NTSC_M_JP, "NTSC-M-JP" },
53 { V4L2_STD_NTSC_M_KR, "NTSC-M-KR" },
54 { V4L2_STD_NTSC_443, "NTSC-443" },
55 { V4L2_STD_PAL, "PAL" },
56 { V4L2_STD_PAL_BG, "PAL-BG" },
57 { V4L2_STD_PAL_B, "PAL-B" },
58 { V4L2_STD_PAL_B1, "PAL-B1" },
59 { V4L2_STD_PAL_G, "PAL-G" },
60 { V4L2_STD_PAL_H, "PAL-H" },
61 { V4L2_STD_PAL_I, "PAL-I" },
62 { V4L2_STD_PAL_DK, "PAL-DK" },
63 { V4L2_STD_PAL_D, "PAL-D" },
64 { V4L2_STD_PAL_D1, "PAL-D1" },
65 { V4L2_STD_PAL_K, "PAL-K" },
66 { V4L2_STD_PAL_M, "PAL-M" },
67 { V4L2_STD_PAL_N, "PAL-N" },
68 { V4L2_STD_PAL_Nc, "PAL-Nc" },
69 { V4L2_STD_PAL_60, "PAL-60" },
70 { V4L2_STD_SECAM, "SECAM" },
71 { V4L2_STD_SECAM_B, "SECAM-B" },
72 { V4L2_STD_SECAM_G, "SECAM-G" },
73 { V4L2_STD_SECAM_H, "SECAM-H" },
74 { V4L2_STD_SECAM_DK, "SECAM-DK" },
75 { V4L2_STD_SECAM_D, "SECAM-D" },
76 { V4L2_STD_SECAM_K, "SECAM-K" },
77 { V4L2_STD_SECAM_K1, "SECAM-K1" },
78 { V4L2_STD_SECAM_L, "SECAM-L" },
79 { V4L2_STD_SECAM_LC, "SECAM-Lc" },
80 { 0, "Unknown" }
81};
82
83/* video4linux standard ID conversion to standard name
84 */
85const char *v4l2_norm_to_name(v4l2_std_id id)
86{
87 u32 myid = id;
88 int i;
89
90 /* HACK: ppc32 architecture doesn't have __ucmpdi2 function to handle
91 64 bit comparations. So, on that architecture, with some gcc
92 variants, compilation fails. Currently, the max value is 30bit wide.
93 */
94 BUG_ON(myid != id);
95
96 for (i = 0; standards[i].std; i++)
97 if (myid == standards[i].std)
98 break;
99 return standards[i].descr;
100}
101EXPORT_SYMBOL(v4l2_norm_to_name);
102
103/* Fill in the fields of a v4l2_standard structure according to the
104 'id' and 'transmission' parameters. Returns negative on error. */
105int v4l2_video_std_construct(struct v4l2_standard *vs,
106 int id, const char *name)
107{
108 u32 index = vs->index;
109
110 memset(vs, 0, sizeof(struct v4l2_standard));
111 vs->index = index;
112 vs->id = id;
113 if (id & V4L2_STD_525_60) {
114 vs->frameperiod.numerator = 1001;
115 vs->frameperiod.denominator = 30000;
116 vs->framelines = 525;
117 } else {
118 vs->frameperiod.numerator = 1;
119 vs->frameperiod.denominator = 25;
120 vs->framelines = 625;
121 }
122 strlcpy(vs->name, name, sizeof(vs->name));
123 return 0;
124}
125EXPORT_SYMBOL(v4l2_video_std_construct);
126
127/* ----------------------------------------------------------------- */
128/* some arrays for pretty-printing debug messages of enum types */
129
130const char *v4l2_field_names[] = {
131 [V4L2_FIELD_ANY] = "any",
132 [V4L2_FIELD_NONE] = "none",
133 [V4L2_FIELD_TOP] = "top",
134 [V4L2_FIELD_BOTTOM] = "bottom",
135 [V4L2_FIELD_INTERLACED] = "interlaced",
136 [V4L2_FIELD_SEQ_TB] = "seq-tb",
137 [V4L2_FIELD_SEQ_BT] = "seq-bt",
138 [V4L2_FIELD_ALTERNATE] = "alternate",
139 [V4L2_FIELD_INTERLACED_TB] = "interlaced-tb",
140 [V4L2_FIELD_INTERLACED_BT] = "interlaced-bt",
141};
142EXPORT_SYMBOL(v4l2_field_names);
143
144const char *v4l2_type_names[] = {
145 [V4L2_BUF_TYPE_VIDEO_CAPTURE] = "vid-cap",
146 [V4L2_BUF_TYPE_VIDEO_OVERLAY] = "vid-overlay",
147 [V4L2_BUF_TYPE_VIDEO_OUTPUT] = "vid-out",
148 [V4L2_BUF_TYPE_VBI_CAPTURE] = "vbi-cap",
149 [V4L2_BUF_TYPE_VBI_OUTPUT] = "vbi-out",
150 [V4L2_BUF_TYPE_SLICED_VBI_CAPTURE] = "sliced-vbi-cap",
151 [V4L2_BUF_TYPE_SLICED_VBI_OUTPUT] = "sliced-vbi-out",
152 [V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY] = "vid-out-overlay",
153};
154EXPORT_SYMBOL(v4l2_type_names);
155
156static const char *v4l2_memory_names[] = {
157 [V4L2_MEMORY_MMAP] = "mmap",
158 [V4L2_MEMORY_USERPTR] = "userptr",
159 [V4L2_MEMORY_OVERLAY] = "overlay",
160};
161
162#define prt_names(a, arr) ((((a) >= 0) && ((a) < ARRAY_SIZE(arr))) ? \
163 arr[a] : "unknown")
164
165/* ------------------------------------------------------------------ */
166/* debug help functions */
167
168#ifdef CONFIG_VIDEO_V4L1_COMPAT
169static const char *v4l1_ioctls[] = {
170 [_IOC_NR(VIDIOCGCAP)] = "VIDIOCGCAP",
171 [_IOC_NR(VIDIOCGCHAN)] = "VIDIOCGCHAN",
172 [_IOC_NR(VIDIOCSCHAN)] = "VIDIOCSCHAN",
173 [_IOC_NR(VIDIOCGTUNER)] = "VIDIOCGTUNER",
174 [_IOC_NR(VIDIOCSTUNER)] = "VIDIOCSTUNER",
175 [_IOC_NR(VIDIOCGPICT)] = "VIDIOCGPICT",
176 [_IOC_NR(VIDIOCSPICT)] = "VIDIOCSPICT",
177 [_IOC_NR(VIDIOCCAPTURE)] = "VIDIOCCAPTURE",
178 [_IOC_NR(VIDIOCGWIN)] = "VIDIOCGWIN",
179 [_IOC_NR(VIDIOCSWIN)] = "VIDIOCSWIN",
180 [_IOC_NR(VIDIOCGFBUF)] = "VIDIOCGFBUF",
181 [_IOC_NR(VIDIOCSFBUF)] = "VIDIOCSFBUF",
182 [_IOC_NR(VIDIOCKEY)] = "VIDIOCKEY",
183 [_IOC_NR(VIDIOCGFREQ)] = "VIDIOCGFREQ",
184 [_IOC_NR(VIDIOCSFREQ)] = "VIDIOCSFREQ",
185 [_IOC_NR(VIDIOCGAUDIO)] = "VIDIOCGAUDIO",
186 [_IOC_NR(VIDIOCSAUDIO)] = "VIDIOCSAUDIO",
187 [_IOC_NR(VIDIOCSYNC)] = "VIDIOCSYNC",
188 [_IOC_NR(VIDIOCMCAPTURE)] = "VIDIOCMCAPTURE",
189 [_IOC_NR(VIDIOCGMBUF)] = "VIDIOCGMBUF",
190 [_IOC_NR(VIDIOCGUNIT)] = "VIDIOCGUNIT",
191 [_IOC_NR(VIDIOCGCAPTURE)] = "VIDIOCGCAPTURE",
192 [_IOC_NR(VIDIOCSCAPTURE)] = "VIDIOCSCAPTURE",
193 [_IOC_NR(VIDIOCSPLAYMODE)] = "VIDIOCSPLAYMODE",
194 [_IOC_NR(VIDIOCSWRITEMODE)] = "VIDIOCSWRITEMODE",
195 [_IOC_NR(VIDIOCGPLAYINFO)] = "VIDIOCGPLAYINFO",
196 [_IOC_NR(VIDIOCSMICROCODE)] = "VIDIOCSMICROCODE",
197 [_IOC_NR(VIDIOCGVBIFMT)] = "VIDIOCGVBIFMT",
198 [_IOC_NR(VIDIOCSVBIFMT)] = "VIDIOCSVBIFMT"
199};
200#define V4L1_IOCTLS ARRAY_SIZE(v4l1_ioctls)
201#endif
202
203static const char *v4l2_ioctls[] = {
204 [_IOC_NR(VIDIOC_QUERYCAP)] = "VIDIOC_QUERYCAP",
205 [_IOC_NR(VIDIOC_RESERVED)] = "VIDIOC_RESERVED",
206 [_IOC_NR(VIDIOC_ENUM_FMT)] = "VIDIOC_ENUM_FMT",
207 [_IOC_NR(VIDIOC_G_FMT)] = "VIDIOC_G_FMT",
208 [_IOC_NR(VIDIOC_S_FMT)] = "VIDIOC_S_FMT",
209 [_IOC_NR(VIDIOC_REQBUFS)] = "VIDIOC_REQBUFS",
210 [_IOC_NR(VIDIOC_QUERYBUF)] = "VIDIOC_QUERYBUF",
211 [_IOC_NR(VIDIOC_G_FBUF)] = "VIDIOC_G_FBUF",
212 [_IOC_NR(VIDIOC_S_FBUF)] = "VIDIOC_S_FBUF",
213 [_IOC_NR(VIDIOC_OVERLAY)] = "VIDIOC_OVERLAY",
214 [_IOC_NR(VIDIOC_QBUF)] = "VIDIOC_QBUF",
215 [_IOC_NR(VIDIOC_DQBUF)] = "VIDIOC_DQBUF",
216 [_IOC_NR(VIDIOC_STREAMON)] = "VIDIOC_STREAMON",
217 [_IOC_NR(VIDIOC_STREAMOFF)] = "VIDIOC_STREAMOFF",
218 [_IOC_NR(VIDIOC_G_PARM)] = "VIDIOC_G_PARM",
219 [_IOC_NR(VIDIOC_S_PARM)] = "VIDIOC_S_PARM",
220 [_IOC_NR(VIDIOC_G_STD)] = "VIDIOC_G_STD",
221 [_IOC_NR(VIDIOC_S_STD)] = "VIDIOC_S_STD",
222 [_IOC_NR(VIDIOC_ENUMSTD)] = "VIDIOC_ENUMSTD",
223 [_IOC_NR(VIDIOC_ENUMINPUT)] = "VIDIOC_ENUMINPUT",
224 [_IOC_NR(VIDIOC_G_CTRL)] = "VIDIOC_G_CTRL",
225 [_IOC_NR(VIDIOC_S_CTRL)] = "VIDIOC_S_CTRL",
226 [_IOC_NR(VIDIOC_G_TUNER)] = "VIDIOC_G_TUNER",
227 [_IOC_NR(VIDIOC_S_TUNER)] = "VIDIOC_S_TUNER",
228 [_IOC_NR(VIDIOC_G_AUDIO)] = "VIDIOC_G_AUDIO",
229 [_IOC_NR(VIDIOC_S_AUDIO)] = "VIDIOC_S_AUDIO",
230 [_IOC_NR(VIDIOC_QUERYCTRL)] = "VIDIOC_QUERYCTRL",
231 [_IOC_NR(VIDIOC_QUERYMENU)] = "VIDIOC_QUERYMENU",
232 [_IOC_NR(VIDIOC_G_INPUT)] = "VIDIOC_G_INPUT",
233 [_IOC_NR(VIDIOC_S_INPUT)] = "VIDIOC_S_INPUT",
234 [_IOC_NR(VIDIOC_G_OUTPUT)] = "VIDIOC_G_OUTPUT",
235 [_IOC_NR(VIDIOC_S_OUTPUT)] = "VIDIOC_S_OUTPUT",
236 [_IOC_NR(VIDIOC_ENUMOUTPUT)] = "VIDIOC_ENUMOUTPUT",
237 [_IOC_NR(VIDIOC_G_AUDOUT)] = "VIDIOC_G_AUDOUT",
238 [_IOC_NR(VIDIOC_S_AUDOUT)] = "VIDIOC_S_AUDOUT",
239 [_IOC_NR(VIDIOC_G_MODULATOR)] = "VIDIOC_G_MODULATOR",
240 [_IOC_NR(VIDIOC_S_MODULATOR)] = "VIDIOC_S_MODULATOR",
241 [_IOC_NR(VIDIOC_G_FREQUENCY)] = "VIDIOC_G_FREQUENCY",
242 [_IOC_NR(VIDIOC_S_FREQUENCY)] = "VIDIOC_S_FREQUENCY",
243 [_IOC_NR(VIDIOC_CROPCAP)] = "VIDIOC_CROPCAP",
244 [_IOC_NR(VIDIOC_G_CROP)] = "VIDIOC_G_CROP",
245 [_IOC_NR(VIDIOC_S_CROP)] = "VIDIOC_S_CROP",
246 [_IOC_NR(VIDIOC_G_JPEGCOMP)] = "VIDIOC_G_JPEGCOMP",
247 [_IOC_NR(VIDIOC_S_JPEGCOMP)] = "VIDIOC_S_JPEGCOMP",
248 [_IOC_NR(VIDIOC_QUERYSTD)] = "VIDIOC_QUERYSTD",
249 [_IOC_NR(VIDIOC_TRY_FMT)] = "VIDIOC_TRY_FMT",
250 [_IOC_NR(VIDIOC_ENUMAUDIO)] = "VIDIOC_ENUMAUDIO",
251 [_IOC_NR(VIDIOC_ENUMAUDOUT)] = "VIDIOC_ENUMAUDOUT",
252 [_IOC_NR(VIDIOC_G_PRIORITY)] = "VIDIOC_G_PRIORITY",
253 [_IOC_NR(VIDIOC_S_PRIORITY)] = "VIDIOC_S_PRIORITY",
254 [_IOC_NR(VIDIOC_G_SLICED_VBI_CAP)] = "VIDIOC_G_SLICED_VBI_CAP",
255 [_IOC_NR(VIDIOC_LOG_STATUS)] = "VIDIOC_LOG_STATUS",
256 [_IOC_NR(VIDIOC_G_EXT_CTRLS)] = "VIDIOC_G_EXT_CTRLS",
257 [_IOC_NR(VIDIOC_S_EXT_CTRLS)] = "VIDIOC_S_EXT_CTRLS",
258 [_IOC_NR(VIDIOC_TRY_EXT_CTRLS)] = "VIDIOC_TRY_EXT_CTRLS",
259#if 1
260 [_IOC_NR(VIDIOC_ENUM_FRAMESIZES)] = "VIDIOC_ENUM_FRAMESIZES",
261 [_IOC_NR(VIDIOC_ENUM_FRAMEINTERVALS)] = "VIDIOC_ENUM_FRAMEINTERVALS",
262 [_IOC_NR(VIDIOC_G_ENC_INDEX)] = "VIDIOC_G_ENC_INDEX",
263 [_IOC_NR(VIDIOC_ENCODER_CMD)] = "VIDIOC_ENCODER_CMD",
264 [_IOC_NR(VIDIOC_TRY_ENCODER_CMD)] = "VIDIOC_TRY_ENCODER_CMD",
265
266 [_IOC_NR(VIDIOC_DBG_S_REGISTER)] = "VIDIOC_DBG_S_REGISTER",
267 [_IOC_NR(VIDIOC_DBG_G_REGISTER)] = "VIDIOC_DBG_G_REGISTER",
268
269 [_IOC_NR(VIDIOC_G_CHIP_IDENT)] = "VIDIOC_G_CHIP_IDENT",
270 [_IOC_NR(VIDIOC_S_HW_FREQ_SEEK)] = "VIDIOC_S_HW_FREQ_SEEK",
271#endif
272};
273#define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
274
275static const char *v4l2_int_ioctls[] = {
276#ifdef CONFIG_VIDEO_V4L1_COMPAT
277 [_IOC_NR(DECODER_GET_CAPABILITIES)] = "DECODER_GET_CAPABILITIES",
278 [_IOC_NR(DECODER_GET_STATUS)] = "DECODER_GET_STATUS",
279 [_IOC_NR(DECODER_SET_NORM)] = "DECODER_SET_NORM",
280 [_IOC_NR(DECODER_SET_INPUT)] = "DECODER_SET_INPUT",
281 [_IOC_NR(DECODER_SET_OUTPUT)] = "DECODER_SET_OUTPUT",
282 [_IOC_NR(DECODER_ENABLE_OUTPUT)] = "DECODER_ENABLE_OUTPUT",
283 [_IOC_NR(DECODER_SET_PICTURE)] = "DECODER_SET_PICTURE",
284 [_IOC_NR(DECODER_SET_GPIO)] = "DECODER_SET_GPIO",
285 [_IOC_NR(DECODER_INIT)] = "DECODER_INIT",
286 [_IOC_NR(DECODER_SET_VBI_BYPASS)] = "DECODER_SET_VBI_BYPASS",
287 [_IOC_NR(DECODER_DUMP)] = "DECODER_DUMP",
288#endif
289 [_IOC_NR(AUDC_SET_RADIO)] = "AUDC_SET_RADIO",
290
291 [_IOC_NR(TUNER_SET_TYPE_ADDR)] = "TUNER_SET_TYPE_ADDR",
292 [_IOC_NR(TUNER_SET_STANDBY)] = "TUNER_SET_STANDBY",
293 [_IOC_NR(TUNER_SET_CONFIG)] = "TUNER_SET_CONFIG",
294
295 [_IOC_NR(VIDIOC_INT_S_TUNER_MODE)] = "VIDIOC_INT_S_TUNER_MODE",
296 [_IOC_NR(VIDIOC_INT_RESET)] = "VIDIOC_INT_RESET",
297 [_IOC_NR(VIDIOC_INT_AUDIO_CLOCK_FREQ)] = "VIDIOC_INT_AUDIO_CLOCK_FREQ",
298 [_IOC_NR(VIDIOC_INT_DECODE_VBI_LINE)] = "VIDIOC_INT_DECODE_VBI_LINE",
299 [_IOC_NR(VIDIOC_INT_S_VBI_DATA)] = "VIDIOC_INT_S_VBI_DATA",
300 [_IOC_NR(VIDIOC_INT_G_VBI_DATA)] = "VIDIOC_INT_G_VBI_DATA",
301 [_IOC_NR(VIDIOC_INT_I2S_CLOCK_FREQ)] = "VIDIOC_INT_I2S_CLOCK_FREQ",
302 [_IOC_NR(VIDIOC_INT_S_STANDBY)] = "VIDIOC_INT_S_STANDBY",
303 [_IOC_NR(VIDIOC_INT_S_AUDIO_ROUTING)] = "VIDIOC_INT_S_AUDIO_ROUTING",
304 [_IOC_NR(VIDIOC_INT_G_AUDIO_ROUTING)] = "VIDIOC_INT_G_AUDIO_ROUTING",
305 [_IOC_NR(VIDIOC_INT_S_VIDEO_ROUTING)] = "VIDIOC_INT_S_VIDEO_ROUTING",
306 [_IOC_NR(VIDIOC_INT_G_VIDEO_ROUTING)] = "VIDIOC_INT_G_VIDEO_ROUTING",
307 [_IOC_NR(VIDIOC_INT_S_CRYSTAL_FREQ)] = "VIDIOC_INT_S_CRYSTAL_FREQ",
308 [_IOC_NR(VIDIOC_INT_INIT)] = "VIDIOC_INT_INIT",
309 [_IOC_NR(VIDIOC_INT_G_STD_OUTPUT)] = "VIDIOC_INT_G_STD_OUTPUT",
310 [_IOC_NR(VIDIOC_INT_S_STD_OUTPUT)] = "VIDIOC_INT_S_STD_OUTPUT",
311};
312#define V4L2_INT_IOCTLS ARRAY_SIZE(v4l2_int_ioctls)
313
314/* Common ioctl debug function. This function can be used by
315 external ioctl messages as well as internal V4L ioctl */
316void v4l_printk_ioctl(unsigned int cmd)
317{
318 char *dir, *type;
319
320 switch (_IOC_TYPE(cmd)) {
321 case 'd':
322 if (_IOC_NR(cmd) >= V4L2_INT_IOCTLS) {
323 type = "v4l2_int";
324 break;
325 }
326 printk("%s", v4l2_int_ioctls[_IOC_NR(cmd)]);
327 return;
328#ifdef CONFIG_VIDEO_V4L1_COMPAT
329 case 'v':
330 if (_IOC_NR(cmd) >= V4L1_IOCTLS) {
331 type = "v4l1";
332 break;
333 }
334 printk("%s", v4l1_ioctls[_IOC_NR(cmd)]);
335 return;
336#endif
337 case 'V':
338 if (_IOC_NR(cmd) >= V4L2_IOCTLS) {
339 type = "v4l2";
340 break;
341 }
342 printk("%s", v4l2_ioctls[_IOC_NR(cmd)]);
343 return;
344 default:
345 type = "unknown";
346 }
347
348 switch (_IOC_DIR(cmd)) {
349 case _IOC_NONE: dir = "--"; break;
350 case _IOC_READ: dir = "r-"; break;
351 case _IOC_WRITE: dir = "-w"; break;
352 case _IOC_READ | _IOC_WRITE: dir = "rw"; break;
353 default: dir = "*ERR*"; break;
354 }
355 printk("%s ioctl '%c', dir=%s, #%d (0x%08x)",
356 type, _IOC_TYPE(cmd), dir, _IOC_NR(cmd), cmd);
357}
358EXPORT_SYMBOL(v4l_printk_ioctl);
359
360/*
361 * helper function -- handles userspace copying for ioctl arguments
362 */
363
364#ifdef __OLD_VIDIOC_
365static unsigned int
366video_fix_command(unsigned int cmd)
367{
368 switch (cmd) {
369 case VIDIOC_OVERLAY_OLD:
370 cmd = VIDIOC_OVERLAY;
371 break;
372 case VIDIOC_S_PARM_OLD:
373 cmd = VIDIOC_S_PARM;
374 break;
375 case VIDIOC_S_CTRL_OLD:
376 cmd = VIDIOC_S_CTRL;
377 break;
378 case VIDIOC_G_AUDIO_OLD:
379 cmd = VIDIOC_G_AUDIO;
380 break;
381 case VIDIOC_G_AUDOUT_OLD:
382 cmd = VIDIOC_G_AUDOUT;
383 break;
384 case VIDIOC_CROPCAP_OLD:
385 cmd = VIDIOC_CROPCAP;
386 break;
387 }
388 return cmd;
389}
390#endif
391
392/*
393 * Obsolete usercopy function - Should be removed soon
394 */
395int
396video_usercopy(struct inode *inode, struct file *file,
397 unsigned int cmd, unsigned long arg,
398 int (*func)(struct inode *inode, struct file *file,
399 unsigned int cmd, void *arg))
400{
401 char sbuf[128];
402 void *mbuf = NULL;
403 void *parg = NULL;
404 int err = -EINVAL;
405 int is_ext_ctrl;
406 size_t ctrls_size = 0;
407 void __user *user_ptr = NULL;
408
409#ifdef __OLD_VIDIOC_
410 cmd = video_fix_command(cmd);
411#endif
412 is_ext_ctrl = (cmd == VIDIOC_S_EXT_CTRLS || cmd == VIDIOC_G_EXT_CTRLS ||
413 cmd == VIDIOC_TRY_EXT_CTRLS);
414
415 /* Copy arguments into temp kernel buffer */
416 switch (_IOC_DIR(cmd)) {
417 case _IOC_NONE:
418 parg = NULL;
419 break;
420 case _IOC_READ:
421 case _IOC_WRITE:
422 case (_IOC_WRITE | _IOC_READ):
423 if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
424 parg = sbuf;
425 } else {
426 /* too big to allocate from stack */
427 mbuf = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
428 if (NULL == mbuf)
429 return -ENOMEM;
430 parg = mbuf;
431 }
432
433 err = -EFAULT;
434 if (_IOC_DIR(cmd) & _IOC_WRITE)
435 if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
436 goto out;
437 break;
438 }
439 if (is_ext_ctrl) {
440 struct v4l2_ext_controls *p = parg;
441
442 /* In case of an error, tell the caller that it wasn't
443 a specific control that caused it. */
444 p->error_idx = p->count;
445 user_ptr = (void __user *)p->controls;
446 if (p->count) {
447 ctrls_size = sizeof(struct v4l2_ext_control) * p->count;
448 /* Note: v4l2_ext_controls fits in sbuf[] so mbuf is still NULL. */
449 mbuf = kmalloc(ctrls_size, GFP_KERNEL);
450 err = -ENOMEM;
451 if (NULL == mbuf)
452 goto out_ext_ctrl;
453 err = -EFAULT;
454 if (copy_from_user(mbuf, user_ptr, ctrls_size))
455 goto out_ext_ctrl;
456 p->controls = mbuf;
457 }
458 }
459
460 /* call driver */
461 err = func(inode, file, cmd, parg);
462 if (err == -ENOIOCTLCMD)
463 err = -EINVAL;
464 if (is_ext_ctrl) {
465 struct v4l2_ext_controls *p = parg;
466
467 p->controls = (void *)user_ptr;
468 if (p->count && err == 0 && copy_to_user(user_ptr, mbuf, ctrls_size))
469 err = -EFAULT;
470 goto out_ext_ctrl;
471 }
472 if (err < 0)
473 goto out;
474
475out_ext_ctrl:
476 /* Copy results into user buffer */
477 switch (_IOC_DIR(cmd)) {
478 case _IOC_READ:
479 case (_IOC_WRITE | _IOC_READ):
480 if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
481 err = -EFAULT;
482 break;
483 }
484
485out:
486 kfree(mbuf);
487 return err;
488}
489EXPORT_SYMBOL(video_usercopy);
490
491static void dbgbuf(unsigned int cmd, struct video_device *vfd,
492 struct v4l2_buffer *p)
493{
494 struct v4l2_timecode *tc = &p->timecode;
495
496 dbgarg(cmd, "%02ld:%02d:%02d.%08ld index=%d, type=%s, "
497 "bytesused=%d, flags=0x%08d, "
498 "field=%0d, sequence=%d, memory=%s, offset/userptr=0x%08lx, length=%d\n",
499 p->timestamp.tv_sec / 3600,
500 (int)(p->timestamp.tv_sec / 60) % 60,
501 (int)(p->timestamp.tv_sec % 60),
b045979d 502 (long)p->timestamp.tv_usec,
35ea11ff
HV		 503 p->index,
504 prt_names(p->type, v4l2_type_names),
505 p->bytesused, p->flags,
506 p->field, p->sequence,
507 prt_names(p->memory, v4l2_memory_names),
508 p->m.userptr, p->length);
509 dbgarg2("timecode=%02d:%02d:%02d type=%d, "
510 "flags=0x%08d, frames=%d, userbits=0x%08x\n",
511 tc->hours, tc->minutes, tc->seconds,
512 tc->type, tc->flags, tc->frames, *(__u32 *)tc->userbits);
513}
514
515static inline void dbgrect(struct video_device *vfd, char *s,
516 struct v4l2_rect *r)
517{
518 dbgarg2("%sRect start at %dx%d, size=%dx%d\n", s, r->left, r->top,
519 r->width, r->height);
520};
521
522static inline void v4l_print_pix_fmt(struct video_device *vfd,
523 struct v4l2_pix_format *fmt)
524{
525 dbgarg2("width=%d, height=%d, format=%c%c%c%c, field=%s, "
526 "bytesperline=%d sizeimage=%d, colorspace=%d\n",
527 fmt->width, fmt->height,
528 (fmt->pixelformat & 0xff),
529 (fmt->pixelformat >> 8) & 0xff,
530 (fmt->pixelformat >> 16) & 0xff,
531 (fmt->pixelformat >> 24) & 0xff,
532 prt_names(fmt->field, v4l2_field_names),
533 fmt->bytesperline, fmt->sizeimage, fmt->colorspace);
534};
535
536static inline void v4l_print_ext_ctrls(unsigned int cmd,
537 struct video_device *vfd, struct v4l2_ext_controls *c, int show_vals)
538{
539 __u32 i;
540
541 if (!(vfd->debug & V4L2_DEBUG_IOCTL_ARG))
542 return;
543 dbgarg(cmd, "");
544 printk(KERN_CONT "class=0x%x", c->ctrl_class);
545 for (i = 0; i < c->count; i++) {
546 if (show_vals)
547 printk(KERN_CONT " id/val=0x%x/0x%x",
548 c->controls[i].id, c->controls[i].value);
549 else
550 printk(KERN_CONT " id=0x%x", c->controls[i].id);
551 }
552 printk(KERN_CONT "\n");
553};
554
555static inline int check_ext_ctrls(struct v4l2_ext_controls *c, int allow_priv)
556{
557 __u32 i;
558
559 /* zero the reserved fields */
560 c->reserved[0] = c->reserved[1] = 0;
561 for (i = 0; i < c->count; i++) {
562 c->controls[i].reserved2[0] = 0;
563 c->controls[i].reserved2[1] = 0;
564 }
565 /* V4L2_CID_PRIVATE_BASE cannot be used as control class
566 when using extended controls.
567 Only when passed in through VIDIOC_G_CTRL and VIDIOC_S_CTRL
568 is it allowed for backwards compatibility.
569 */
570 if (!allow_priv && c->ctrl_class == V4L2_CID_PRIVATE_BASE)
571 return 0;
572 /* Check that all controls are from the same control class. */
573 for (i = 0; i < c->count; i++) {
574 if (V4L2_CTRL_ID2CLASS(c->controls[i].id) != c->ctrl_class) {
575 c->error_idx = i;
576 return 0;
577 }
578 }
579 return 1;
580}
581
a399810c 582static int check_fmt(const struct v4l2_ioctl_ops *ops, enum v4l2_buf_type type)
35ea11ff 583{
a399810c
HV		 584 if (ops == NULL)
585 return -EINVAL;
586
35ea11ff
HV		 587 switch (type) {
588 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
a399810c 589 if (ops->vidioc_try_fmt_vid_cap)
35ea11ff
HV		 590 return 0;
591 break;
592 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
a399810c 593 if (ops->vidioc_try_fmt_vid_overlay)
35ea11ff
HV		 594 return 0;
595 break;
596 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
a399810c 597 if (ops->vidioc_try_fmt_vid_out)
35ea11ff
HV		 598 return 0;
599 break;
600 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
a399810c 601 if (ops->vidioc_try_fmt_vid_out_overlay)
35ea11ff
HV		 602 return 0;
603 break;
604 case V4L2_BUF_TYPE_VBI_CAPTURE:
a399810c 605 if (ops->vidioc_try_fmt_vbi_cap)
35ea11ff
HV		 606 return 0;
607 break;
608 case V4L2_BUF_TYPE_VBI_OUTPUT:
a399810c 609 if (ops->vidioc_try_fmt_vbi_out)
35ea11ff
HV		 610 return 0;
611 break;
612 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
a399810c 613 if (ops->vidioc_try_fmt_sliced_vbi_cap)
35ea11ff
HV		 614 return 0;
615 break;
616 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
a399810c 617 if (ops->vidioc_try_fmt_sliced_vbi_out)
35ea11ff
HV		 618 return 0;
619 break;
620 case V4L2_BUF_TYPE_PRIVATE:
a399810c 621 if (ops->vidioc_try_fmt_type_private)
35ea11ff
HV		 622 return 0;
623 break;
624 }
625 return -EINVAL;
626}
627
628static int __video_do_ioctl(struct inode *inode, struct file *file,
629 unsigned int cmd, void *arg)
630{
631 struct video_device *vfd = video_devdata(file);
a399810c 632 const struct v4l2_ioctl_ops *ops = vfd->ioctl_ops;
35ea11ff
HV		 633 void *fh = file->private_data;
634 int ret = -EINVAL;
635
636 if ((vfd->debug & V4L2_DEBUG_IOCTL) &&
637 !(vfd->debug & V4L2_DEBUG_IOCTL_ARG)) {
638 v4l_print_ioctl(vfd->name, cmd);
639 printk(KERN_CONT "\n");
640 }
641
a399810c
HV		 642 if (ops == NULL) {
643 printk(KERN_WARNING "videodev: \"%s\" has no ioctl_ops.\n",
644 vfd->name);
645 return -EINVAL;
646 }
647
35ea11ff
HV		 648#ifdef CONFIG_VIDEO_V4L1_COMPAT
649 /***********************************************************
650 Handles calls to the obsoleted V4L1 API
651 Due to the nature of VIDIOCGMBUF, each driver that supports
652 V4L1 should implement its own handler for this ioctl.
653 ***********************************************************/
654
655 /* --- streaming capture ------------------------------------- */
656 if (cmd == VIDIOCGMBUF) {
657 struct video_mbuf *p = arg;
658
659 memset(p, 0, sizeof(*p));
660
a399810c 661 if (!ops->vidiocgmbuf)
35ea11ff 662 return ret;
a399810c 663 ret = ops->vidiocgmbuf(file, fh, p);
35ea11ff
HV		 664 if (!ret)
665 dbgarg(cmd, "size=%d, frames=%d, offsets=0x%08lx\n",
666 p->size, p->frames,
667 (unsigned long)p->offsets);
668 return ret;
669 }
670
671 /********************************************************
672 All other V4L1 calls are handled by v4l1_compat module.
673 Those calls will be translated into V4L2 calls, and
674 __video_do_ioctl will be called again, with one or more
675 V4L2 ioctls.
676 ********************************************************/
888fe747 677 if (_IOC_TYPE(cmd) == 'v' && _IOC_NR(cmd) < BASE_VIDIOCPRIVATE)
35ea11ff
HV		 678 return v4l_compat_translate_ioctl(inode, file, cmd, arg,
679 __video_do_ioctl);
680#endif
681
682 switch (cmd) {
683 /* --- capabilities ------------------------------------------ */
684 case VIDIOC_QUERYCAP:
685 {
686 struct v4l2_capability *cap = (struct v4l2_capability *)arg;
687 memset(cap, 0, sizeof(*cap));
688
a399810c 689 if (!ops->vidioc_querycap)
35ea11ff
HV		 690 break;
691
a399810c 692 ret = ops->vidioc_querycap(file, fh, cap);
35ea11ff
HV		 693 if (!ret)
694 dbgarg(cmd, "driver=%s, card=%s, bus=%s, "
695 "version=0x%08x, "
696 "capabilities=0x%08x\n",
697 cap->driver, cap->card, cap->bus_info,
698 cap->version,
699 cap->capabilities);
700 break;
701 }
702
703 /* --- priority ------------------------------------------ */
704 case VIDIOC_G_PRIORITY:
705 {
706 enum v4l2_priority *p = arg;
707
a399810c 708 if (!ops->vidioc_g_priority)
35ea11ff 709 break;
a399810c 710 ret = ops->vidioc_g_priority(file, fh, p);
35ea11ff
HV		 711 if (!ret)
712 dbgarg(cmd, "priority is %d\n", *p);
713 break;
714 }
715 case VIDIOC_S_PRIORITY:
716 {
717 enum v4l2_priority *p = arg;
718
a399810c 719 if (!ops->vidioc_s_priority)
35ea11ff
HV		 720 break;
721 dbgarg(cmd, "setting priority to %d\n", *p);
a399810c 722 ret = ops->vidioc_s_priority(file, fh, *p);
35ea11ff
HV		 723 break;
724 }
725
726 /* --- capture ioctls ---------------------------------------- */
727 case VIDIOC_ENUM_FMT:
728 {
729 struct v4l2_fmtdesc *f = arg;
730 enum v4l2_buf_type type;
731 unsigned int index;
732
733 index = f->index;
734 type = f->type;
735 memset(f, 0, sizeof(*f));
736 f->index = index;
737 f->type = type;
738
739 switch (type) {
740 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
a399810c
HV		 741 if (ops->vidioc_enum_fmt_vid_cap)
742 ret = ops->vidioc_enum_fmt_vid_cap(file, fh, f);
35ea11ff
HV		 743 break;
744 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
a399810c
HV		 745 if (ops->vidioc_enum_fmt_vid_overlay)
746 ret = ops->vidioc_enum_fmt_vid_overlay(file,
35ea11ff
HV		 747 fh, f);
748 break;
35ea11ff 749 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
a399810c
HV		 750 if (ops->vidioc_enum_fmt_vid_out)
751 ret = ops->vidioc_enum_fmt_vid_out(file, fh, f);
35ea11ff
HV		 752 break;
753 case V4L2_BUF_TYPE_PRIVATE:
a399810c
HV		 754 if (ops->vidioc_enum_fmt_type_private)
755 ret = ops->vidioc_enum_fmt_type_private(file,
35ea11ff
HV		 756 fh, f);
757 break;
758 default:
759 break;
760 }
761 if (!ret)
762 dbgarg(cmd, "index=%d, type=%d, flags=%d, "
763 "pixelformat=%c%c%c%c, description='%s'\n",
764 f->index, f->type, f->flags,
765 (f->pixelformat & 0xff),
766 (f->pixelformat >> 8) & 0xff,
767 (f->pixelformat >> 16) & 0xff,
768 (f->pixelformat >> 24) & 0xff,
769 f->description);
770 break;
771 }
772 case VIDIOC_G_FMT:
773 {
774 struct v4l2_format *f = (struct v4l2_format *)arg;
775
776 memset(f->fmt.raw_data, 0, sizeof(f->fmt.raw_data));
777
778 /* FIXME: Should be one dump per type */
779 dbgarg(cmd, "type=%s\n", prt_names(f->type, v4l2_type_names));
780
781 switch (f->type) {
782 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
a399810c
HV		 783 if (ops->vidioc_g_fmt_vid_cap)
784 ret = ops->vidioc_g_fmt_vid_cap(file, fh, f);
35ea11ff
HV		 785 if (!ret)
786 v4l_print_pix_fmt(vfd, &f->fmt.pix);
787 break;
788 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
a399810c
HV		 789 if (ops->vidioc_g_fmt_vid_overlay)
790 ret = ops->vidioc_g_fmt_vid_overlay(file,
35ea11ff
HV		 791 fh, f);
792 break;
793 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
a399810c
HV		 794 if (ops->vidioc_g_fmt_vid_out)
795 ret = ops->vidioc_g_fmt_vid_out(file, fh, f);
35ea11ff
HV		 796 if (!ret)
797 v4l_print_pix_fmt(vfd, &f->fmt.pix);
798 break;
799 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
a399810c
HV		 800 if (ops->vidioc_g_fmt_vid_out_overlay)
801 ret = ops->vidioc_g_fmt_vid_out_overlay(file,
35ea11ff
HV		 802 fh, f);
803 break;
804 case V4L2_BUF_TYPE_VBI_CAPTURE:
a399810c
HV		 805 if (ops->vidioc_g_fmt_vbi_cap)
806 ret = ops->vidioc_g_fmt_vbi_cap(file, fh, f);
35ea11ff
HV		 807 break;
808 case V4L2_BUF_TYPE_VBI_OUTPUT:
a399810c
HV		 809 if (ops->vidioc_g_fmt_vbi_out)
810 ret = ops->vidioc_g_fmt_vbi_out(file, fh, f);
35ea11ff
HV		 811 break;
812 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
a399810c
HV		 813 if (ops->vidioc_g_fmt_sliced_vbi_cap)
814 ret = ops->vidioc_g_fmt_sliced_vbi_cap(file,
35ea11ff
HV		 815 fh, f);
816 break;
817 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
a399810c
HV		 818 if (ops->vidioc_g_fmt_sliced_vbi_out)
819 ret = ops->vidioc_g_fmt_sliced_vbi_out(file,
35ea11ff
HV		 820 fh, f);
821 break;
822 case V4L2_BUF_TYPE_PRIVATE:
a399810c
HV		 823 if (ops->vidioc_g_fmt_type_private)
824 ret = ops->vidioc_g_fmt_type_private(file,
35ea11ff
HV		 825 fh, f);
826 break;
827 }
828
829 break;
830 }
831 case VIDIOC_S_FMT:
832 {
833 struct v4l2_format *f = (struct v4l2_format *)arg;
834
835 /* FIXME: Should be one dump per type */
836 dbgarg(cmd, "type=%s\n", prt_names(f->type, v4l2_type_names));
837
838 switch (f->type) {
839 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
840 v4l_print_pix_fmt(vfd, &f->fmt.pix);
a399810c
HV		 841 if (ops->vidioc_s_fmt_vid_cap)
842 ret = ops->vidioc_s_fmt_vid_cap(file, fh, f);
35ea11ff
HV		 843 break;
844 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
a399810c
HV		 845 if (ops->vidioc_s_fmt_vid_overlay)
846 ret = ops->vidioc_s_fmt_vid_overlay(file,
35ea11ff
HV		 847 fh, f);
848 break;
849 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
850 v4l_print_pix_fmt(vfd, &f->fmt.pix);
a399810c
HV		 851 if (ops->vidioc_s_fmt_vid_out)
852 ret = ops->vidioc_s_fmt_vid_out(file, fh, f);
35ea11ff
HV		 853 break;
854 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
a399810c
HV		 855 if (ops->vidioc_s_fmt_vid_out_overlay)
856 ret = ops->vidioc_s_fmt_vid_out_overlay(file,
35ea11ff
HV		 857 fh, f);
858 break;
859 case V4L2_BUF_TYPE_VBI_CAPTURE:
a399810c
HV		 860 if (ops->vidioc_s_fmt_vbi_cap)
861 ret = ops->vidioc_s_fmt_vbi_cap(file, fh, f);
35ea11ff
HV		 862 break;
863 case V4L2_BUF_TYPE_VBI_OUTPUT:
a399810c
HV		 864 if (ops->vidioc_s_fmt_vbi_out)
865 ret = ops->vidioc_s_fmt_vbi_out(file, fh, f);
35ea11ff
HV		 866 break;
867 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
a399810c
HV		 868 if (ops->vidioc_s_fmt_sliced_vbi_cap)
869 ret = ops->vidioc_s_fmt_sliced_vbi_cap(file,
35ea11ff
HV		 870 fh, f);
871 break;
872 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
a399810c
HV		 873 if (ops->vidioc_s_fmt_sliced_vbi_out)
874 ret = ops->vidioc_s_fmt_sliced_vbi_out(file,
35ea11ff
HV		 875 fh, f);
876 break;
877 case V4L2_BUF_TYPE_PRIVATE:
a399810c
HV		 878 if (ops->vidioc_s_fmt_type_private)
879 ret = ops->vidioc_s_fmt_type_private(file,
35ea11ff
HV		 880 fh, f);
881 break;
882 }
883 break;
884 }
885 case VIDIOC_TRY_FMT:
886 {
887 struct v4l2_format *f = (struct v4l2_format *)arg;
888
889 /* FIXME: Should be one dump per type */
890 dbgarg(cmd, "type=%s\n", prt_names(f->type,
891 v4l2_type_names));
892 switch (f->type) {
893 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
a399810c
HV		 894 if (ops->vidioc_try_fmt_vid_cap)
895 ret = ops->vidioc_try_fmt_vid_cap(file, fh, f);
35ea11ff
HV		 896 if (!ret)
897 v4l_print_pix_fmt(vfd, &f->fmt.pix);
898 break;
899 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
a399810c
HV		 900 if (ops->vidioc_try_fmt_vid_overlay)
901 ret = ops->vidioc_try_fmt_vid_overlay(file,
35ea11ff
HV		 902 fh, f);
903 break;
904 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
a399810c
HV		 905 if (ops->vidioc_try_fmt_vid_out)
906 ret = ops->vidioc_try_fmt_vid_out(file, fh, f);
35ea11ff
HV		 907 if (!ret)
908 v4l_print_pix_fmt(vfd, &f->fmt.pix);
909 break;
910 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
a399810c
HV		 911 if (ops->vidioc_try_fmt_vid_out_overlay)
912 ret = ops->vidioc_try_fmt_vid_out_overlay(file,
35ea11ff
HV		 913 fh, f);
914 break;
915 case V4L2_BUF_TYPE_VBI_CAPTURE:
a399810c
HV		 916 if (ops->vidioc_try_fmt_vbi_cap)
917 ret = ops->vidioc_try_fmt_vbi_cap(file, fh, f);
35ea11ff
HV		 918 break;
919 case V4L2_BUF_TYPE_VBI_OUTPUT:
a399810c
HV		 920 if (ops->vidioc_try_fmt_vbi_out)
921 ret = ops->vidioc_try_fmt_vbi_out(file, fh, f);
35ea11ff
HV		 922 break;
923 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
a399810c
HV		 924 if (ops->vidioc_try_fmt_sliced_vbi_cap)
925 ret = ops->vidioc_try_fmt_sliced_vbi_cap(file,
35ea11ff
HV		 926 fh, f);
927 break;
928 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
a399810c
HV		 929 if (ops->vidioc_try_fmt_sliced_vbi_out)
930 ret = ops->vidioc_try_fmt_sliced_vbi_out(file,
35ea11ff
HV		 931 fh, f);
932 break;
933 case V4L2_BUF_TYPE_PRIVATE:
a399810c
HV		 934 if (ops->vidioc_try_fmt_type_private)
935 ret = ops->vidioc_try_fmt_type_private(file,
35ea11ff
HV		 936 fh, f);
937 break;
938 }
939
940 break;
941 }
942 /* FIXME: Those buf reqs could be handled here,
943 with some changes on videobuf to allow its header to be included at
944 videodev2.h or being merged at videodev2.
945 */
946 case VIDIOC_REQBUFS:
947 {
948 struct v4l2_requestbuffers *p = arg;
949
a399810c 950 if (!ops->vidioc_reqbufs)
35ea11ff 951 break;
a399810c 952 ret = check_fmt(ops, p->type);
35ea11ff
HV		 953 if (ret)
954 break;
955
a399810c 956 ret = ops->vidioc_reqbufs(file, fh, p);
35ea11ff
HV		 957 dbgarg(cmd, "count=%d, type=%s, memory=%s\n",
958 p->count,
959 prt_names(p->type, v4l2_type_names),
960 prt_names(p->memory, v4l2_memory_names));
961 break;
962 }
963 case VIDIOC_QUERYBUF:
964 {
965 struct v4l2_buffer *p = arg;
966
a399810c 967 if (!ops->vidioc_querybuf)
35ea11ff 968 break;
a399810c 969 ret = check_fmt(ops, p->type);
35ea11ff
HV		 970 if (ret)
971 break;
972
a399810c 973 ret = ops->vidioc_querybuf(file, fh, p);
35ea11ff
HV		 974 if (!ret)
975 dbgbuf(cmd, vfd, p);
976 break;
977 }
978 case VIDIOC_QBUF:
979 {
980 struct v4l2_buffer *p = arg;
981
a399810c 982 if (!ops->vidioc_qbuf)
35ea11ff 983 break;
a399810c 984 ret = check_fmt(ops, p->type);
35ea11ff
HV		 985 if (ret)
986 break;
987
a399810c 988 ret = ops->vidioc_qbuf(file, fh, p);
35ea11ff
HV		 989 if (!ret)
990 dbgbuf(cmd, vfd, p);
991 break;
992 }
993 case VIDIOC_DQBUF:
994 {
995 struct v4l2_buffer *p = arg;
996
a399810c 997 if (!ops->vidioc_dqbuf)
35ea11ff 998 break;
a399810c 999 ret = check_fmt(ops, p->type);
35ea11ff
HV		 1000 if (ret)
1001 break;
1002
a399810c 1003 ret = ops->vidioc_dqbuf(file, fh, p);
35ea11ff
HV		 1004 if (!ret)
1005 dbgbuf(cmd, vfd, p);
1006 break;
1007 }
1008 case VIDIOC_OVERLAY:
1009 {
1010 int *i = arg;
1011
a399810c 1012 if (!ops->vidioc_overlay)
35ea11ff
HV		 1013 break;
1014 dbgarg(cmd, "value=%d\n", *i);
a399810c 1015 ret = ops->vidioc_overlay(file, fh, *i);
35ea11ff
HV		 1016 break;
1017 }
1018 case VIDIOC_G_FBUF:
1019 {
1020 struct v4l2_framebuffer *p = arg;
1021
a399810c 1022 if (!ops->vidioc_g_fbuf)
35ea11ff 1023 break;
a399810c 1024 ret = ops->vidioc_g_fbuf(file, fh, arg);
35ea11ff
HV		 1025 if (!ret) {
1026 dbgarg(cmd, "capability=0x%x, flags=%d, base=0x%08lx\n",
1027 p->capability, p->flags,
1028 (unsigned long)p->base);
1029 v4l_print_pix_fmt(vfd, &p->fmt);
1030 }
1031 break;
1032 }
1033 case VIDIOC_S_FBUF:
1034 {
1035 struct v4l2_framebuffer *p = arg;
1036
a399810c 1037 if (!ops->vidioc_s_fbuf)
35ea11ff
HV		 1038 break;
1039 dbgarg(cmd, "capability=0x%x, flags=%d, base=0x%08lx\n",
1040 p->capability, p->flags, (unsigned long)p->base);
1041 v4l_print_pix_fmt(vfd, &p->fmt);
a399810c 1042 ret = ops->vidioc_s_fbuf(file, fh, arg);
35ea11ff
HV		 1043 break;
1044 }
1045 case VIDIOC_STREAMON:
1046 {
1047 enum v4l2_buf_type i = *(int *)arg;
1048
a399810c 1049 if (!ops->vidioc_streamon)
35ea11ff
HV		 1050 break;
1051 dbgarg(cmd, "type=%s\n", prt_names(i, v4l2_type_names));
a399810c 1052 ret = ops->vidioc_streamon(file, fh, i);
35ea11ff
HV		 1053 break;
1054 }
1055 case VIDIOC_STREAMOFF:
1056 {
1057 enum v4l2_buf_type i = *(int *)arg;
1058
a399810c 1059 if (!ops->vidioc_streamoff)
35ea11ff
HV		 1060 break;
1061 dbgarg(cmd, "type=%s\n", prt_names(i, v4l2_type_names));
a399810c 1062 ret = ops->vidioc_streamoff(file, fh, i);
35ea11ff
HV		 1063 break;
1064 }
1065 /* ---------- tv norms ---------- */
1066 case VIDIOC_ENUMSTD:
1067 {
1068 struct v4l2_standard *p = arg;
1069 v4l2_std_id id = vfd->tvnorms, curr_id = 0;
1070 unsigned int index = p->index, i, j = 0;
1071 const char *descr = "";
1072
1073 /* Return norm array in a canonical way */
1074 for (i = 0; i <= index && id; i++) {
1075 /* last std value in the standards array is 0, so this
1076 while always ends there since (id & 0) == 0. */
1077 while ((id & standards[j].std) != standards[j].std)
1078 j++;
1079 curr_id = standards[j].std;
1080 descr = standards[j].descr;
1081 j++;
1082 if (curr_id == 0)
1083 break;
1084 if (curr_id != V4L2_STD_PAL &&
1085 curr_id != V4L2_STD_SECAM &&
1086 curr_id != V4L2_STD_NTSC)
1087 id &= ~curr_id;
1088 }
1089 if (i <= index)
1090 return -EINVAL;
1091
1092 v4l2_video_std_construct(p, curr_id, descr);
1093 p->index = index;
1094
1095 dbgarg(cmd, "index=%d, id=0x%Lx, name=%s, fps=%d/%d, "
1096 "framelines=%d\n", p->index,
1097 (unsigned long long)p->id, p->name,
1098 p->frameperiod.numerator,
1099 p->frameperiod.denominator,
1100 p->framelines);
1101
1102 ret = 0;
1103 break;
1104 }
1105 case VIDIOC_G_STD:
1106 {
1107 v4l2_std_id *id = arg;
1108
1109 ret = 0;
1110 /* Calls the specific handler */
a399810c
HV		 1111 if (ops->vidioc_g_std)
1112 ret = ops->vidioc_g_std(file, fh, id);
35ea11ff
HV		 1113 else
1114 *id = vfd->current_norm;
1115
1116 if (!ret)
1117 dbgarg(cmd, "std=0x%08Lx\n", (long long unsigned)*id);
1118 break;
1119 }
1120 case VIDIOC_S_STD:
1121 {
1122 v4l2_std_id *id = arg, norm;
1123
1124 dbgarg(cmd, "std=%08Lx\n", (long long unsigned)*id);
1125
1126 norm = (*id) & vfd->tvnorms;
1127 if (vfd->tvnorms && !norm) /* Check if std is supported */
1128 break;
1129
1130 /* Calls the specific handler */
a399810c
HV		 1131 if (ops->vidioc_s_std)
1132 ret = ops->vidioc_s_std(file, fh, &norm);
35ea11ff
HV		 1133 else
1134 ret = -EINVAL;
1135
1136 /* Updates standard information */
1137 if (ret >= 0)
1138 vfd->current_norm = norm;
1139 break;
1140 }
1141 case VIDIOC_QUERYSTD:
1142 {
1143 v4l2_std_id *p = arg;
1144
a399810c 1145 if (!ops->vidioc_querystd)
35ea11ff 1146 break;
a399810c 1147 ret = ops->vidioc_querystd(file, fh, arg);
35ea11ff
HV		 1148 if (!ret)
1149 dbgarg(cmd, "detected std=%08Lx\n",
1150 (unsigned long long)*p);
1151 break;
1152 }
1153 /* ------ input switching ---------- */
1154 /* FIXME: Inputs can be handled inside videodev2 */
1155 case VIDIOC_ENUMINPUT:
1156 {
1157 struct v4l2_input *p = arg;
1158 int i = p->index;
1159
a399810c 1160 if (!ops->vidioc_enum_input)
35ea11ff
HV		 1161 break;
1162 memset(p, 0, sizeof(*p));
1163 p->index = i;
1164
a399810c 1165 ret = ops->vidioc_enum_input(file, fh, p);
35ea11ff
HV		 1166 if (!ret)
1167 dbgarg(cmd, "index=%d, name=%s, type=%d, "
1168 "audioset=%d, "
1169 "tuner=%d, std=%08Lx, status=%d\n",
1170 p->index, p->name, p->type, p->audioset,
1171 p->tuner,
1172 (unsigned long long)p->std,
1173 p->status);
1174 break;
1175 }
1176 case VIDIOC_G_INPUT:
1177 {
1178 unsigned int *i = arg;
1179
a399810c 1180 if (!ops->vidioc_g_input)
35ea11ff 1181 break;
a399810c 1182 ret = ops->vidioc_g_input(file, fh, i);
35ea11ff
HV		 1183 if (!ret)
1184 dbgarg(cmd, "value=%d\n", *i);
1185 break;
1186 }
1187 case VIDIOC_S_INPUT:
1188 {
1189 unsigned int *i = arg;
1190
a399810c 1191 if (!ops->vidioc_s_input)
35ea11ff
HV		 1192 break;
1193 dbgarg(cmd, "value=%d\n", *i);
a399810c 1194 ret = ops->vidioc_s_input(file, fh, *i);
35ea11ff
HV		 1195 break;
1196 }
1197
1198 /* ------ output switching ---------- */
1199 case VIDIOC_ENUMOUTPUT:
1200 {
1201 struct v4l2_output *p = arg;
1202 int i = p->index;
1203
a399810c 1204 if (!ops->vidioc_enum_output)
35ea11ff
HV		 1205 break;
1206 memset(p, 0, sizeof(*p));
1207 p->index = i;
1208
a399810c 1209 ret = ops->vidioc_enum_output(file, fh, p);
35ea11ff
HV		 1210 if (!ret)
1211 dbgarg(cmd, "index=%d, name=%s, type=%d, "
1212 "audioset=0x%x, "
1213 "modulator=%d, std=0x%08Lx\n",
1214 p->index, p->name, p->type, p->audioset,
1215 p->modulator, (unsigned long long)p->std);
1216 break;
1217 }
1218 case VIDIOC_G_OUTPUT:
1219 {
1220 unsigned int *i = arg;
1221
a399810c 1222 if (!ops->vidioc_g_output)
35ea11ff 1223 break;
a399810c 1224 ret = ops->vidioc_g_output(file, fh, i);
35ea11ff
HV		 1225 if (!ret)
1226 dbgarg(cmd, "value=%d\n", *i);
1227 break;
1228 }
1229 case VIDIOC_S_OUTPUT:
1230 {
1231 unsigned int *i = arg;
1232
a399810c 1233 if (!ops->vidioc_s_output)
35ea11ff
HV		 1234 break;
1235 dbgarg(cmd, "value=%d\n", *i);
a399810c 1236 ret = ops->vidioc_s_output(file, fh, *i);
35ea11ff
HV		 1237 break;
1238 }
1239
1240 /* --- controls ---------------------------------------------- */
1241 case VIDIOC_QUERYCTRL:
1242 {
1243 struct v4l2_queryctrl *p = arg;
1244
a399810c 1245 if (!ops->vidioc_queryctrl)
35ea11ff 1246 break;
a399810c 1247 ret = ops->vidioc_queryctrl(file, fh, p);
35ea11ff
HV		 1248 if (!ret)
1249 dbgarg(cmd, "id=0x%x, type=%d, name=%s, min/max=%d/%d, "
1250 "step=%d, default=%d, flags=0x%08x\n",
1251 p->id, p->type, p->name,
1252 p->minimum, p->maximum,
1253 p->step, p->default_value, p->flags);
1254 else
1255 dbgarg(cmd, "id=0x%x\n", p->id);
1256 break;
1257 }
1258 case VIDIOC_G_CTRL:
1259 {
1260 struct v4l2_control *p = arg;
1261
a399810c
HV		 1262 if (ops->vidioc_g_ctrl)
1263 ret = ops->vidioc_g_ctrl(file, fh, p);
1264 else if (ops->vidioc_g_ext_ctrls) {
35ea11ff
HV		 1265 struct v4l2_ext_controls ctrls;
1266 struct v4l2_ext_control ctrl;
1267
1268 ctrls.ctrl_class = V4L2_CTRL_ID2CLASS(p->id);
1269 ctrls.count = 1;
1270 ctrls.controls = &ctrl;
1271 ctrl.id = p->id;
1272 ctrl.value = p->value;
1273 if (check_ext_ctrls(&ctrls, 1)) {
a399810c 1274 ret = ops->vidioc_g_ext_ctrls(file, fh, &ctrls);
35ea11ff
HV		 1275 if (ret == 0)
1276 p->value = ctrl.value;
1277 }
1278 } else
1279 break;
1280 if (!ret)
1281 dbgarg(cmd, "id=0x%x, value=%d\n", p->id, p->value);
1282 else
1283 dbgarg(cmd, "id=0x%x\n", p->id);
1284 break;
1285 }
1286 case VIDIOC_S_CTRL:
1287 {
1288 struct v4l2_control *p = arg;
1289 struct v4l2_ext_controls ctrls;
1290 struct v4l2_ext_control ctrl;
1291
a399810c 1292 if (!ops->vidioc_s_ctrl && !ops->vidioc_s_ext_ctrls)
35ea11ff
HV		 1293 break;
1294
1295 dbgarg(cmd, "id=0x%x, value=%d\n", p->id, p->value);
1296
a399810c
HV		 1297 if (ops->vidioc_s_ctrl) {
1298 ret = ops->vidioc_s_ctrl(file, fh, p);
35ea11ff
HV		 1299 break;
1300 }
a399810c 1301 if (!ops->vidioc_s_ext_ctrls)
35ea11ff
HV		 1302 break;
1303
1304 ctrls.ctrl_class = V4L2_CTRL_ID2CLASS(p->id);
1305 ctrls.count = 1;
1306 ctrls.controls = &ctrl;
1307 ctrl.id = p->id;
1308 ctrl.value = p->value;
1309 if (check_ext_ctrls(&ctrls, 1))
a399810c 1310 ret = ops->vidioc_s_ext_ctrls(file, fh, &ctrls);
35ea11ff
HV		 1311 break;
1312 }
1313 case VIDIOC_G_EXT_CTRLS:
1314 {
1315 struct v4l2_ext_controls *p = arg;
1316
1317 p->error_idx = p->count;
a399810c 1318 if (!ops->vidioc_g_ext_ctrls)
35ea11ff
HV		 1319 break;
1320 if (check_ext_ctrls(p, 0))
a399810c 1321 ret = ops->vidioc_g_ext_ctrls(file, fh, p);
35ea11ff
HV		 1322 v4l_print_ext_ctrls(cmd, vfd, p, !ret);
1323 break;
1324 }
1325 case VIDIOC_S_EXT_CTRLS:
1326 {
1327 struct v4l2_ext_controls *p = arg;
1328
1329 p->error_idx = p->count;
a399810c 1330 if (!ops->vidioc_s_ext_ctrls)
35ea11ff
HV		 1331 break;
1332 v4l_print_ext_ctrls(cmd, vfd, p, 1);
1333 if (check_ext_ctrls(p, 0))
a399810c 1334 ret = ops->vidioc_s_ext_ctrls(file, fh, p);
35ea11ff
HV		 1335 break;
1336 }
1337 case VIDIOC_TRY_EXT_CTRLS:
1338 {
1339 struct v4l2_ext_controls *p = arg;
1340
1341 p->error_idx = p->count;
a399810c 1342 if (!ops->vidioc_try_ext_ctrls)
35ea11ff
HV		 1343 break;
1344 v4l_print_ext_ctrls(cmd, vfd, p, 1);
1345 if (check_ext_ctrls(p, 0))
a399810c 1346 ret = ops->vidioc_try_ext_ctrls(file, fh, p);
35ea11ff
HV		 1347 break;
1348 }
1349 case VIDIOC_QUERYMENU:
1350 {
1351 struct v4l2_querymenu *p = arg;
1352
a399810c 1353 if (!ops->vidioc_querymenu)
35ea11ff 1354 break;
a399810c 1355 ret = ops->vidioc_querymenu(file, fh, p);
35ea11ff
HV		 1356 if (!ret)
1357 dbgarg(cmd, "id=0x%x, index=%d, name=%s\n",
1358 p->id, p->index, p->name);
1359 else
1360 dbgarg(cmd, "id=0x%x, index=%d\n",
1361 p->id, p->index);
1362 break;
1363 }
1364 /* --- audio ---------------------------------------------- */
1365 case VIDIOC_ENUMAUDIO:
1366 {
1367 struct v4l2_audio *p = arg;
1368
a399810c 1369 if (!ops->vidioc_enumaudio)
35ea11ff 1370 break;
a399810c 1371 ret = ops->vidioc_enumaudio(file, fh, p);
35ea11ff
HV		 1372 if (!ret)
1373 dbgarg(cmd, "index=%d, name=%s, capability=0x%x, "
1374 "mode=0x%x\n", p->index, p->name,
1375 p->capability, p->mode);
1376 else
1377 dbgarg(cmd, "index=%d\n", p->index);
1378 break;
1379 }
1380 case VIDIOC_G_AUDIO:
1381 {
1382 struct v4l2_audio *p = arg;
1383 __u32 index = p->index;
1384
a399810c 1385 if (!ops->vidioc_g_audio)
35ea11ff
HV		 1386 break;
1387
1388 memset(p, 0, sizeof(*p));
1389 p->index = index;
a399810c 1390 ret = ops->vidioc_g_audio(file, fh, p);
35ea11ff
HV		 1391 if (!ret)
1392 dbgarg(cmd, "index=%d, name=%s, capability=0x%x, "
1393 "mode=0x%x\n", p->index,
1394 p->name, p->capability, p->mode);
1395 else
1396 dbgarg(cmd, "index=%d\n", p->index);
1397 break;
1398 }
1399 case VIDIOC_S_AUDIO:
1400 {
1401 struct v4l2_audio *p = arg;
1402
a399810c 1403 if (!ops->vidioc_s_audio)
35ea11ff
HV		 1404 break;
1405 dbgarg(cmd, "index=%d, name=%s, capability=0x%x, "
1406 "mode=0x%x\n", p->index, p->name,
1407 p->capability, p->mode);
a399810c 1408 ret = ops->vidioc_s_audio(file, fh, p);
35ea11ff
HV		 1409 break;
1410 }
1411 case VIDIOC_ENUMAUDOUT:
1412 {
1413 struct v4l2_audioout *p = arg;
1414
a399810c 1415 if (!ops->vidioc_enumaudout)
35ea11ff
HV		 1416 break;
1417 dbgarg(cmd, "Enum for index=%d\n", p->index);
a399810c 1418 ret = ops->vidioc_enumaudout(file, fh, p);
35ea11ff
HV		 1419 if (!ret)
1420 dbgarg2("index=%d, name=%s, capability=%d, "
1421 "mode=%d\n", p->index, p->name,
1422 p->capability, p->mode);
1423 break;
1424 }
1425 case VIDIOC_G_AUDOUT:
1426 {
1427 struct v4l2_audioout *p = arg;
1428
a399810c 1429 if (!ops->vidioc_g_audout)
35ea11ff
HV		 1430 break;
1431 dbgarg(cmd, "Enum for index=%d\n", p->index);
a399810c 1432 ret = ops->vidioc_g_audout(file, fh, p);
35ea11ff
HV		 1433 if (!ret)
1434 dbgarg2("index=%d, name=%s, capability=%d, "
1435 "mode=%d\n", p->index, p->name,
1436 p->capability, p->mode);
1437 break;
1438 }
1439 case VIDIOC_S_AUDOUT:
1440 {
1441 struct v4l2_audioout *p = arg;
1442
a399810c 1443 if (!ops->vidioc_s_audout)
35ea11ff
HV		 1444 break;
1445 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1446 "mode=%d\n", p->index, p->name,
1447 p->capability, p->mode);
1448
a399810c 1449 ret = ops->vidioc_s_audout(file, fh, p);
35ea11ff
HV		 1450 break;
1451 }
1452 case VIDIOC_G_MODULATOR:
1453 {
1454 struct v4l2_modulator *p = arg;
1455
a399810c 1456 if (!ops->vidioc_g_modulator)
35ea11ff 1457 break;
a399810c 1458 ret = ops->vidioc_g_modulator(file, fh, p);
35ea11ff
HV		 1459 if (!ret)
1460 dbgarg(cmd, "index=%d, name=%s, "
1461 "capability=%d, rangelow=%d,"
1462 " rangehigh=%d, txsubchans=%d\n",
1463 p->index, p->name, p->capability,
1464 p->rangelow, p->rangehigh,
1465 p->txsubchans);
1466 break;
1467 }
1468 case VIDIOC_S_MODULATOR:
1469 {
1470 struct v4l2_modulator *p = arg;
1471
a399810c 1472 if (!ops->vidioc_s_modulator)
35ea11ff
HV		 1473 break;
1474 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1475 "rangelow=%d, rangehigh=%d, txsubchans=%d\n",
1476 p->index, p->name, p->capability, p->rangelow,
1477 p->rangehigh, p->txsubchans);
a399810c 1478 ret = ops->vidioc_s_modulator(file, fh, p);
35ea11ff
HV		 1479 break;
1480 }
1481 case VIDIOC_G_CROP:
1482 {
1483 struct v4l2_crop *p = arg;
1484
a399810c 1485 if (!ops->vidioc_g_crop)
35ea11ff
HV		 1486 break;
1487 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
a399810c 1488 ret = ops->vidioc_g_crop(file, fh, p);
35ea11ff
HV		 1489 if (!ret)
1490 dbgrect(vfd, "", &p->c);
1491 break;
1492 }
1493 case VIDIOC_S_CROP:
1494 {
1495 struct v4l2_crop *p = arg;
1496
a399810c 1497 if (!ops->vidioc_s_crop)
35ea11ff
HV		 1498 break;
1499 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
1500 dbgrect(vfd, "", &p->c);
a399810c 1501 ret = ops->vidioc_s_crop(file, fh, p);
35ea11ff
HV		 1502 break;
1503 }
1504 case VIDIOC_CROPCAP:
1505 {
1506 struct v4l2_cropcap *p = arg;
1507
1508 /*FIXME: Should also show v4l2_fract pixelaspect */
a399810c 1509 if (!ops->vidioc_cropcap)
35ea11ff
HV		 1510 break;
1511 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
a399810c 1512 ret = ops->vidioc_cropcap(file, fh, p);
35ea11ff
HV		 1513 if (!ret) {
1514 dbgrect(vfd, "bounds ", &p->bounds);
1515 dbgrect(vfd, "defrect ", &p->defrect);
1516 }
1517 break;
1518 }
1519 case VIDIOC_G_JPEGCOMP:
1520 {
1521 struct v4l2_jpegcompression *p = arg;
1522
a399810c 1523 if (!ops->vidioc_g_jpegcomp)
35ea11ff 1524 break;
a399810c 1525 ret = ops->vidioc_g_jpegcomp(file, fh, p);
35ea11ff
HV		 1526 if (!ret)
1527 dbgarg(cmd, "quality=%d, APPn=%d, "
1528 "APP_len=%d, COM_len=%d, "
1529 "jpeg_markers=%d\n",
1530 p->quality, p->APPn, p->APP_len,
1531 p->COM_len, p->jpeg_markers);
1532 break;
1533 }
1534 case VIDIOC_S_JPEGCOMP:
1535 {
1536 struct v4l2_jpegcompression *p = arg;
1537
a399810c 1538 if (!ops->vidioc_g_jpegcomp)
35ea11ff
HV		 1539 break;
1540 dbgarg(cmd, "quality=%d, APPn=%d, APP_len=%d, "
1541 "COM_len=%d, jpeg_markers=%d\n",
1542 p->quality, p->APPn, p->APP_len,
1543 p->COM_len, p->jpeg_markers);
a399810c 1544 ret = ops->vidioc_s_jpegcomp(file, fh, p);
35ea11ff
HV		 1545 break;
1546 }
1547 case VIDIOC_G_ENC_INDEX:
1548 {
1549 struct v4l2_enc_idx *p = arg;
1550
a399810c 1551 if (!ops->vidioc_g_enc_index)
35ea11ff 1552 break;
a399810c 1553 ret = ops->vidioc_g_enc_index(file, fh, p);
35ea11ff
HV		 1554 if (!ret)
1555 dbgarg(cmd, "entries=%d, entries_cap=%d\n",
1556 p->entries, p->entries_cap);
1557 break;
1558 }
1559 case VIDIOC_ENCODER_CMD:
1560 {
1561 struct v4l2_encoder_cmd *p = arg;
1562
a399810c 1563 if (!ops->vidioc_encoder_cmd)
35ea11ff
HV		 1564 break;
1565 memset(&p->raw, 0, sizeof(p->raw));
a399810c 1566 ret = ops->vidioc_encoder_cmd(file, fh, p);
35ea11ff
HV		 1567 if (!ret)
1568 dbgarg(cmd, "cmd=%d, flags=%x\n", p->cmd, p->flags);
1569 break;
1570 }
1571 case VIDIOC_TRY_ENCODER_CMD:
1572 {
1573 struct v4l2_encoder_cmd *p = arg;
1574
a399810c 1575 if (!ops->vidioc_try_encoder_cmd)
35ea11ff
HV		 1576 break;
1577 memset(&p->raw, 0, sizeof(p->raw));
a399810c 1578 ret = ops->vidioc_try_encoder_cmd(file, fh, p);
35ea11ff
HV		 1579 if (!ret)
1580 dbgarg(cmd, "cmd=%d, flags=%x\n", p->cmd, p->flags);
1581 break;
1582 }
1583 case VIDIOC_G_PARM:
1584 {
1585 struct v4l2_streamparm *p = arg;
1586 __u32 type = p->type;
1587
1588 memset(p, 0, sizeof(*p));
1589 p->type = type;
1590
a399810c
HV		 1591 if (ops->vidioc_g_parm) {
1592 ret = ops->vidioc_g_parm(file, fh, p);
35ea11ff
HV		 1593 } else {
1594 struct v4l2_standard s;
1595
1596 if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1597 return -EINVAL;
1598
1599 v4l2_video_std_construct(&s, vfd->current_norm,
1600 v4l2_norm_to_name(vfd->current_norm));
1601
1602 p->parm.capture.timeperframe = s.frameperiod;
1603 ret = 0;
1604 }
1605
1606 dbgarg(cmd, "type=%d\n", p->type);
1607 break;
1608 }
1609 case VIDIOC_S_PARM:
1610 {
1611 struct v4l2_streamparm *p = arg;
1612
a399810c 1613 if (!ops->vidioc_s_parm)
35ea11ff
HV		 1614 break;
1615 dbgarg(cmd, "type=%d\n", p->type);
a399810c 1616 ret = ops->vidioc_s_parm(file, fh, p);
35ea11ff
HV		 1617 break;
1618 }
1619 case VIDIOC_G_TUNER:
1620 {
1621 struct v4l2_tuner *p = arg;
1622 __u32 index = p->index;
1623
a399810c 1624 if (!ops->vidioc_g_tuner)
35ea11ff
HV		 1625 break;
1626
1627 memset(p, 0, sizeof(*p));
1628 p->index = index;
1629
a399810c 1630 ret = ops->vidioc_g_tuner(file, fh, p);
35ea11ff
HV		 1631 if (!ret)
1632 dbgarg(cmd, "index=%d, name=%s, type=%d, "
1633 "capability=0x%x, rangelow=%d, "
1634 "rangehigh=%d, signal=%d, afc=%d, "
1635 "rxsubchans=0x%x, audmode=%d\n",
1636 p->index, p->name, p->type,
1637 p->capability, p->rangelow,
1638 p->rangehigh, p->signal, p->afc,
1639 p->rxsubchans, p->audmode);
1640 break;
1641 }
1642 case VIDIOC_S_TUNER:
1643 {
1644 struct v4l2_tuner *p = arg;
1645
a399810c 1646 if (!ops->vidioc_s_tuner)
35ea11ff
HV		 1647 break;
1648 dbgarg(cmd, "index=%d, name=%s, type=%d, "
1649 "capability=0x%x, rangelow=%d, "
1650 "rangehigh=%d, signal=%d, afc=%d, "
1651 "rxsubchans=0x%x, audmode=%d\n",
1652 p->index, p->name, p->type,
1653 p->capability, p->rangelow,
1654 p->rangehigh, p->signal, p->afc,
1655 p->rxsubchans, p->audmode);
a399810c 1656 ret = ops->vidioc_s_tuner(file, fh, p);
35ea11ff
HV		 1657 break;
1658 }
1659 case VIDIOC_G_FREQUENCY:
1660 {
1661 struct v4l2_frequency *p = arg;
1662
a399810c 1663 if (!ops->vidioc_g_frequency)
35ea11ff
HV		 1664 break;
1665
1666 memset(p->reserved, 0, sizeof(p->reserved));
1667
a399810c 1668 ret = ops->vidioc_g_frequency(file, fh, p);
35ea11ff
HV		 1669 if (!ret)
1670 dbgarg(cmd, "tuner=%d, type=%d, frequency=%d\n",
1671 p->tuner, p->type, p->frequency);
1672 break;
1673 }
1674 case VIDIOC_S_FREQUENCY:
1675 {
1676 struct v4l2_frequency *p = arg;
1677
a399810c 1678 if (!ops->vidioc_s_frequency)
35ea11ff
HV		 1679 break;
1680 dbgarg(cmd, "tuner=%d, type=%d, frequency=%d\n",
1681 p->tuner, p->type, p->frequency);
a399810c 1682 ret = ops->vidioc_s_frequency(file, fh, p);
35ea11ff
HV		 1683 break;
1684 }
1685 case VIDIOC_G_SLICED_VBI_CAP:
1686 {
1687 struct v4l2_sliced_vbi_cap *p = arg;
1688 __u32 type = p->type;
1689
a399810c 1690 if (!ops->vidioc_g_sliced_vbi_cap)
35ea11ff
HV		 1691 break;
1692 memset(p, 0, sizeof(*p));
1693 p->type = type;
1694 dbgarg(cmd, "type=%s\n", prt_names(p->type, v4l2_type_names));
a399810c 1695 ret = ops->vidioc_g_sliced_vbi_cap(file, fh, p);
35ea11ff
HV		 1696 if (!ret)
1697 dbgarg2("service_set=%d\n", p->service_set);
1698 break;
1699 }
1700 case VIDIOC_LOG_STATUS:
1701 {
a399810c 1702 if (!ops->vidioc_log_status)
35ea11ff 1703 break;
a399810c 1704 ret = ops->vidioc_log_status(file, fh);
35ea11ff
HV		 1705 break;
1706 }
1707#ifdef CONFIG_VIDEO_ADV_DEBUG
1708 case VIDIOC_DBG_G_REGISTER:
1709 {
1710 struct v4l2_register *p = arg;
1711
1712 if (!capable(CAP_SYS_ADMIN))
1713 ret = -EPERM;
a399810c
HV		 1714 else if (ops->vidioc_g_register)
1715 ret = ops->vidioc_g_register(file, fh, p);
35ea11ff
HV		 1716 break;
1717 }
1718 case VIDIOC_DBG_S_REGISTER:
1719 {
1720 struct v4l2_register *p = arg;
1721
1722 if (!capable(CAP_SYS_ADMIN))
1723 ret = -EPERM;
a399810c
HV		 1724 else if (ops->vidioc_s_register)
1725 ret = ops->vidioc_s_register(file, fh, p);
35ea11ff
HV		 1726 break;
1727 }
1728#endif
1729 case VIDIOC_G_CHIP_IDENT:
1730 {
1731 struct v4l2_chip_ident *p = arg;
1732
a399810c 1733 if (!ops->vidioc_g_chip_ident)
35ea11ff 1734 break;
a399810c 1735 ret = ops->vidioc_g_chip_ident(file, fh, p);
35ea11ff
HV		 1736 if (!ret)
1737 dbgarg(cmd, "chip_ident=%u, revision=0x%x\n", p->ident, p->revision);
1738 break;
1739 }
35ea11ff
HV		 1740 case VIDIOC_S_HW_FREQ_SEEK:
1741 {
1742 struct v4l2_hw_freq_seek *p = arg;
1743
a399810c 1744 if (!ops->vidioc_s_hw_freq_seek)
35ea11ff
HV		 1745 break;
1746 dbgarg(cmd,
1747 "tuner=%d, type=%d, seek_upward=%d, wrap_around=%d\n",
1748 p->tuner, p->type, p->seek_upward, p->wrap_around);
a399810c
HV		 1749 ret = ops->vidioc_s_hw_freq_seek(file, fh, p);
1750 break;
1751 }
1752 default:
1753 {
1754 if (!ops->vidioc_default)
1755 break;
1756 ret = ops->vidioc_default(file, fh, cmd, arg);
35ea11ff
HV		 1757 break;
1758 }
1759 } /* switch */
1760
1761 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) {
1762 if (ret < 0) {
1763 v4l_print_ioctl(vfd->name, cmd);
1764 printk(KERN_CONT " error %d\n", ret);
1765 }
1766 }
1767
1768 return ret;
1769}
1770
1771int video_ioctl2(struct inode *inode, struct file *file,
1772 unsigned int cmd, unsigned long arg)
1773{
1774 char sbuf[128];
1775 void *mbuf = NULL;
1776 void *parg = NULL;
1777 int err = -EINVAL;
1778 int is_ext_ctrl;
1779 size_t ctrls_size = 0;
1780 void __user *user_ptr = NULL;
1781
1782#ifdef __OLD_VIDIOC_
1783 cmd = video_fix_command(cmd);
1784#endif
1785 is_ext_ctrl = (cmd == VIDIOC_S_EXT_CTRLS || cmd == VIDIOC_G_EXT_CTRLS ||
1786 cmd == VIDIOC_TRY_EXT_CTRLS);
1787
1788 /* Copy arguments into temp kernel buffer */
1789 switch (_IOC_DIR(cmd)) {
1790 case _IOC_NONE:
1791 parg = NULL;
1792 break;
1793 case _IOC_READ:
1794 case _IOC_WRITE:
1795 case (_IOC_WRITE | _IOC_READ):
1796 if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
1797 parg = sbuf;
1798 } else {
1799 /* too big to allocate from stack */
1800 mbuf = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
1801 if (NULL == mbuf)
1802 return -ENOMEM;
1803 parg = mbuf;
1804 }
1805
1806 err = -EFAULT;
1807 if (_IOC_DIR(cmd) & _IOC_WRITE)
1808 if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
1809 goto out;
1810 break;
1811 }
1812
1813 if (is_ext_ctrl) {
1814 struct v4l2_ext_controls *p = parg;
1815
1816 /* In case of an error, tell the caller that it wasn't
1817 a specific control that caused it. */
1818 p->error_idx = p->count;
1819 user_ptr = (void __user *)p->controls;
1820 if (p->count) {
1821 ctrls_size = sizeof(struct v4l2_ext_control) * p->count;
1822 /* Note: v4l2_ext_controls fits in sbuf[] so mbuf is still NULL. */
1823 mbuf = kmalloc(ctrls_size, GFP_KERNEL);
1824 err = -ENOMEM;
1825 if (NULL == mbuf)
1826 goto out_ext_ctrl;
1827 err = -EFAULT;
1828 if (copy_from_user(mbuf, user_ptr, ctrls_size))
1829 goto out_ext_ctrl;
1830 p->controls = mbuf;
1831 }
1832 }
1833
1834 /* Handles IOCTL */
1835 err = __video_do_ioctl(inode, file, cmd, parg);
1836 if (err == -ENOIOCTLCMD)
1837 err = -EINVAL;
1838 if (is_ext_ctrl) {
1839 struct v4l2_ext_controls *p = parg;
1840
1841 p->controls = (void *)user_ptr;
1842 if (p->count && err == 0 && copy_to_user(user_ptr, mbuf, ctrls_size))
1843 err = -EFAULT;
1844 goto out_ext_ctrl;
1845 }
1846 if (err < 0)
1847 goto out;
1848
1849out_ext_ctrl:
1850 /* Copy results into user buffer */
1851 switch (_IOC_DIR(cmd)) {
1852 case _IOC_READ:
1853 case (_IOC_WRITE | _IOC_READ):
1854 if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
1855 err = -EFAULT;
1856 break;
1857 }
1858
1859out:
1860 kfree(mbuf);
1861 return err;
1862}
1863EXPORT_SYMBOL(video_ioctl2);
Linux kernel - Deliverables
This page took 0.368174 seconds and 5 git commands to generate.