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