2 * ioctl32.c: Conversion between 32bit and 64bit native ioctls.
3 * Separated from fs stuff by Arnd Bergmann <arnd@arndb.de>
5 * Copyright (C) 1997-2000 Jakub Jelinek (jakub@redhat.com)
6 * Copyright (C) 1998 Eddie C. Dost (ecd@skynet.be)
7 * Copyright (C) 2001,2002 Andi Kleen, SuSE Labs
8 * Copyright (C) 2003 Pavel Machek (pavel@suse.cz)
9 * Copyright (C) 2005 Philippe De Muyter (phdm@macqel.be)
11 * These routines maintain argument size conversion between 32bit and 64bit
15 #include <linux/compat.h>
16 #include <linux/videodev.h>
17 #include <linux/videodev2.h>
18 #include <linux/module.h>
19 #include <linux/smp_lock.h>
20 #include <media/v4l2-common.h>
25 struct video_tuner32 {
28 compat_ulong_t rangelow, rangehigh;
29 u32 flags; /* It is really u32 in videodev.h */
33 static int get_video_tuner32(struct video_tuner *kp, struct video_tuner32 __user *up)
35 if(!access_ok(VERIFY_READ, up, sizeof(struct video_tuner32)) ||
36 get_user(kp->tuner, &up->tuner) ||
37 copy_from_user(kp->name, up->name, 32) ||
38 get_user(kp->rangelow, &up->rangelow) ||
39 get_user(kp->rangehigh, &up->rangehigh) ||
40 get_user(kp->flags, &up->flags) ||
41 get_user(kp->mode, &up->mode) ||
42 get_user(kp->signal, &up->signal))
47 static int put_video_tuner32(struct video_tuner *kp, struct video_tuner32 __user *up)
49 if(!access_ok(VERIFY_WRITE, up, sizeof(struct video_tuner32)) ||
50 put_user(kp->tuner, &up->tuner) ||
51 copy_to_user(up->name, kp->name, 32) ||
52 put_user(kp->rangelow, &up->rangelow) ||
53 put_user(kp->rangehigh, &up->rangehigh) ||
54 put_user(kp->flags, &up->flags) ||
55 put_user(kp->mode, &up->mode) ||
56 put_user(kp->signal, &up->signal))
61 struct video_buffer32 {
63 compat_int_t height, width, depth, bytesperline;
66 static int get_video_buffer32(struct video_buffer *kp, struct video_buffer32 __user *up)
70 if (!access_ok(VERIFY_READ, up, sizeof(struct video_buffer32)) ||
71 get_user(tmp, &up->base) ||
72 get_user(kp->height, &up->height) ||
73 get_user(kp->width, &up->width) ||
74 get_user(kp->depth, &up->depth) ||
75 get_user(kp->bytesperline, &up->bytesperline))
78 /* This is actually a physical address stored
81 kp->base = (void *)(unsigned long) tmp;
86 static int put_video_buffer32(struct video_buffer *kp, struct video_buffer32 __user *up)
88 u32 tmp = (u32)((unsigned long)kp->base);
90 if(!access_ok(VERIFY_WRITE, up, sizeof(struct video_buffer32)) ||
91 put_user(tmp, &up->base) ||
92 put_user(kp->height, &up->height) ||
93 put_user(kp->width, &up->width) ||
94 put_user(kp->depth, &up->depth) ||
95 put_user(kp->bytesperline, &up->bytesperline))
100 struct video_clip32 {
101 s32 x, y, width, height; /* Its really s32 in videodev.h */
105 struct video_window32 {
106 u32 x, y, width, height, chromakey, flags;
107 compat_caddr_t clips;
108 compat_int_t clipcount;
111 static int native_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
113 int ret = -ENOIOCTLCMD;
115 if (file->f_op->unlocked_ioctl)
116 ret = file->f_op->unlocked_ioctl(file, cmd, arg);
117 else if (file->f_op->ioctl) {
119 ret = file->f_op->ioctl(file->f_dentry->d_inode, file, cmd, arg);
127 /* You get back everything except the clips... */
128 static int put_video_window32(struct video_window *kp, struct video_window32 __user *up)
130 if(!access_ok(VERIFY_WRITE, up, sizeof(struct video_window32)) ||
131 put_user(kp->x, &up->x) ||
132 put_user(kp->y, &up->y) ||
133 put_user(kp->width, &up->width) ||
134 put_user(kp->height, &up->height) ||
135 put_user(kp->chromakey, &up->chromakey) ||
136 put_user(kp->flags, &up->flags) ||
137 put_user(kp->clipcount, &up->clipcount))
151 enum v4l2_field field;
153 compat_caddr_t clips; /* actually struct v4l2_clip32 * */
155 compat_caddr_t bitmap;
158 static int get_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user *up)
160 if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_window32)) ||
161 copy_from_user(&kp->w, &up->w, sizeof(up->w)) ||
162 get_user(kp->field, &up->field) ||
163 get_user(kp->chromakey, &up->chromakey) ||
164 get_user(kp->clipcount, &up->clipcount))
166 if (kp->clipcount > 2048)
169 struct v4l2_clip32 __user *uclips;
170 struct v4l2_clip __user *kclips;
171 int n = kp->clipcount;
174 if (get_user(p, &up->clips))
176 uclips = compat_ptr(p);
177 kclips = compat_alloc_user_space(n * sizeof(struct v4l2_clip));
180 if (copy_in_user(&kclips->c, &uclips->c, sizeof(uclips->c)))
182 if (put_user(n ? kclips + 1 : NULL, &kclips->next))
192 static int put_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user *up)
194 if (copy_to_user(&up->w, &kp->w, sizeof(up->w)) ||
195 put_user(kp->field, &up->field) ||
196 put_user(kp->chromakey, &up->chromakey) ||
197 put_user(kp->clipcount, &up->clipcount))
202 static inline int get_v4l2_pix_format(struct v4l2_pix_format *kp, struct v4l2_pix_format __user *up)
204 if (copy_from_user(kp, up, sizeof(struct v4l2_pix_format)))
209 static inline int put_v4l2_pix_format(struct v4l2_pix_format *kp, struct v4l2_pix_format __user *up)
211 if (copy_to_user(up, kp, sizeof(struct v4l2_pix_format)))
216 static inline int get_v4l2_vbi_format(struct v4l2_vbi_format *kp, struct v4l2_vbi_format __user *up)
218 if (copy_from_user(kp, up, sizeof(struct v4l2_vbi_format)))
223 static inline int put_v4l2_vbi_format(struct v4l2_vbi_format *kp, struct v4l2_vbi_format __user *up)
225 if (copy_to_user(up, kp, sizeof(struct v4l2_vbi_format)))
232 enum v4l2_buf_type type;
235 struct v4l2_pix_format pix; // V4L2_BUF_TYPE_VIDEO_CAPTURE
236 struct v4l2_window32 win; // V4L2_BUF_TYPE_VIDEO_OVERLAY
237 struct v4l2_vbi_format vbi; // V4L2_BUF_TYPE_VBI_CAPTURE
238 __u8 raw_data[200]; // user-defined
242 static int get_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user *up)
244 if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_format32)) ||
245 get_user(kp->type, &up->type))
248 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
249 return get_v4l2_pix_format(&kp->fmt.pix, &up->fmt.pix);
250 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
251 return get_v4l2_window32(&kp->fmt.win, &up->fmt.win);
252 case V4L2_BUF_TYPE_VBI_CAPTURE:
253 return get_v4l2_vbi_format(&kp->fmt.vbi, &up->fmt.vbi);
255 printk("compat_ioctl : unexpected VIDIOC_FMT type %d\n",
261 static int put_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user *up)
263 if(!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_format32)) ||
264 put_user(kp->type, &up->type))
267 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
268 return put_v4l2_pix_format(&kp->fmt.pix, &up->fmt.pix);
269 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
270 return put_v4l2_window32(&kp->fmt.win, &up->fmt.win);
271 case V4L2_BUF_TYPE_VBI_CAPTURE:
272 return put_v4l2_vbi_format(&kp->fmt.vbi, &up->fmt.vbi);
278 static inline int get_v4l2_standard(struct v4l2_standard *kp, struct v4l2_standard __user *up)
280 if (copy_from_user(kp, up, sizeof(struct v4l2_standard)))
286 static inline int put_v4l2_standard(struct v4l2_standard *kp, struct v4l2_standard __user *up)
288 if (copy_to_user(up, kp, sizeof(struct v4l2_standard)))
293 struct v4l2_standard32
296 __u32 id[2]; /* __u64 would get the alignment wrong */
298 struct v4l2_fract frameperiod; /* Frames, not fields */
303 static int get_v4l2_standard32(struct v4l2_standard *kp, struct v4l2_standard32 __user *up)
305 /* other fields are not set by the user, nor used by the driver */
306 if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_standard32)) ||
307 get_user(kp->index, &up->index))
312 static int put_v4l2_standard32(struct v4l2_standard *kp, struct v4l2_standard32 __user *up)
314 if(!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_standard32)) ||
315 put_user(kp->index, &up->index) ||
316 copy_to_user(up->id, &kp->id, sizeof(__u64)) ||
317 copy_to_user(up->name, kp->name, 24) ||
318 copy_to_user(&up->frameperiod, &kp->frameperiod, sizeof(kp->frameperiod)) ||
319 put_user(kp->framelines, &up->framelines) ||
320 copy_to_user(up->reserved, kp->reserved, 4 * sizeof(__u32)))
325 static inline int get_v4l2_tuner(struct v4l2_tuner *kp, struct v4l2_tuner __user *up)
327 if (copy_from_user(kp, up, sizeof(struct v4l2_tuner)))
333 static inline int put_v4l2_tuner(struct v4l2_tuner *kp, struct v4l2_tuner __user *up)
335 if (copy_to_user(up, kp, sizeof(struct v4l2_tuner)))
343 enum v4l2_buf_type type;
346 enum v4l2_field field;
347 struct compat_timeval timestamp;
348 struct v4l2_timecode timecode;
351 /* memory location */
352 enum v4l2_memory memory;
355 compat_long_t userptr;
362 static int get_v4l2_buffer32(struct v4l2_buffer *kp, struct v4l2_buffer32 __user *up)
365 if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_buffer32)) ||
366 get_user(kp->index, &up->index) ||
367 get_user(kp->type, &up->type) ||
368 get_user(kp->flags, &up->flags) ||
369 get_user(kp->memory, &up->memory) ||
370 get_user(kp->input, &up->input))
373 case V4L2_MEMORY_MMAP:
375 case V4L2_MEMORY_USERPTR:
379 if (get_user(kp->length, &up->length) ||
380 get_user(tmp, &up->m.userptr))
383 kp->m.userptr = (unsigned long)compat_ptr(tmp);
386 case V4L2_MEMORY_OVERLAY:
387 if(get_user(kp->m.offset, &up->m.offset))
394 static int put_v4l2_buffer32(struct v4l2_buffer *kp, struct v4l2_buffer32 __user *up)
396 if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_buffer32)) ||
397 put_user(kp->index, &up->index) ||
398 put_user(kp->type, &up->type) ||
399 put_user(kp->flags, &up->flags) ||
400 put_user(kp->memory, &up->memory) ||
401 put_user(kp->input, &up->input))
404 case V4L2_MEMORY_MMAP:
405 if (put_user(kp->length, &up->length) ||
406 put_user(kp->m.offset, &up->m.offset))
409 case V4L2_MEMORY_USERPTR:
410 if (put_user(kp->length, &up->length) ||
411 put_user(kp->m.userptr, &up->m.userptr))
414 case V4L2_MEMORY_OVERLAY:
415 if (put_user(kp->m.offset, &up->m.offset))
419 if (put_user(kp->bytesused, &up->bytesused) ||
420 put_user(kp->field, &up->field) ||
421 put_user(kp->timestamp.tv_sec, &up->timestamp.tv_sec) ||
422 put_user(kp->timestamp.tv_usec, &up->timestamp.tv_usec) ||
423 copy_to_user(&up->timecode, &kp->timecode, sizeof(struct v4l2_timecode)) ||
424 put_user(kp->sequence, &up->sequence) ||
425 put_user(kp->reserved, &up->reserved))
430 struct v4l2_framebuffer32
435 struct v4l2_pix_format fmt;
438 static int get_v4l2_framebuffer32(struct v4l2_framebuffer *kp, struct v4l2_framebuffer32 __user *up)
442 if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_framebuffer32)) ||
443 get_user(tmp, &up->base) ||
444 get_user(kp->capability, &up->capability) ||
445 get_user(kp->flags, &up->flags))
447 kp->base = compat_ptr(tmp);
448 get_v4l2_pix_format(&kp->fmt, &up->fmt);
452 static int put_v4l2_framebuffer32(struct v4l2_framebuffer *kp, struct v4l2_framebuffer32 __user *up)
454 u32 tmp = (u32)((unsigned long)kp->base);
456 if(!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_framebuffer32)) ||
457 put_user(tmp, &up->base) ||
458 put_user(kp->capability, &up->capability) ||
459 put_user(kp->flags, &up->flags))
461 put_v4l2_pix_format(&kp->fmt, &up->fmt);
465 static inline int get_v4l2_input32(struct v4l2_input *kp, struct v4l2_input __user *up)
467 if (copy_from_user(kp, up, sizeof(struct v4l2_input) - 4))
472 static inline int put_v4l2_input32(struct v4l2_input *kp, struct v4l2_input __user *up)
474 if (copy_to_user(up, kp, sizeof(struct v4l2_input) - 4))
479 static inline int get_v4l2_input(struct v4l2_input *kp, struct v4l2_input __user *up)
481 if (copy_from_user(kp, up, sizeof(struct v4l2_input)))
486 static inline int put_v4l2_input(struct v4l2_input *kp, struct v4l2_input __user *up)
488 if (copy_to_user(up, kp, sizeof(struct v4l2_input)))
495 char loadwhat[16]; /* name or tag of file being passed */
496 compat_int_t datasize;
500 static inline int microcode32(struct video_code *kp, struct video_code32 __user *up)
502 if(!access_ok(VERIFY_READ, up, sizeof(struct video_code32)) ||
503 copy_from_user(kp->loadwhat, up->loadwhat, sizeof (up->loadwhat)) ||
504 get_user(kp->datasize, &up->datasize) ||
505 copy_from_user(kp->data, up->data, up->datasize))
510 #define VIDIOCGTUNER32 _IOWR('v',4, struct video_tuner32)
511 #define VIDIOCSTUNER32 _IOW('v',5, struct video_tuner32)
512 #define VIDIOCGWIN32 _IOR('v',9, struct video_window32)
513 #define VIDIOCSWIN32 _IOW('v',10, struct video_window32)
514 #define VIDIOCGFBUF32 _IOR('v',11, struct video_buffer32)
515 #define VIDIOCSFBUF32 _IOW('v',12, struct video_buffer32)
516 #define VIDIOCGFREQ32 _IOR('v',14, u32)
517 #define VIDIOCSFREQ32 _IOW('v',15, u32)
518 #define VIDIOCSMICROCODE32 _IOW('v',27, struct video_code32)
520 /* VIDIOC_ENUMINPUT32 is VIDIOC_ENUMINPUT minus 4 bytes of padding alignement */
521 #define VIDIOC_ENUMINPUT32 VIDIOC_ENUMINPUT - _IOC(0, 0, 0, 4)
522 #define VIDIOC_G_FMT32 _IOWR ('V', 4, struct v4l2_format32)
523 #define VIDIOC_S_FMT32 _IOWR ('V', 5, struct v4l2_format32)
524 #define VIDIOC_QUERYBUF32 _IOWR ('V', 9, struct v4l2_buffer32)
525 #define VIDIOC_G_FBUF32 _IOR ('V', 10, struct v4l2_framebuffer32)
526 #define VIDIOC_S_FBUF32 _IOW ('V', 11, struct v4l2_framebuffer32)
527 /* VIDIOC_OVERLAY is now _IOW, but was _IOWR */
528 #define VIDIOC_OVERLAY32 _IOWR ('V', 14, compat_int_t)
529 #define VIDIOC_QBUF32 _IOWR ('V', 15, struct v4l2_buffer32)
530 #define VIDIOC_DQBUF32 _IOWR ('V', 17, struct v4l2_buffer32)
531 #define VIDIOC_STREAMON32 _IOW ('V', 18, compat_int_t)
532 #define VIDIOC_STREAMOFF32 _IOW ('V', 19, compat_int_t)
533 #define VIDIOC_ENUMSTD32 _IOWR ('V', 25, struct v4l2_standard32)
534 /* VIDIOC_S_CTRL is now _IOWR, but was _IOW */
535 #define VIDIOC_S_CTRL32 _IOW ('V', 28, struct v4l2_control)
536 #define VIDIOC_G_INPUT32 _IOR ('V', 38, compat_int_t)
537 #define VIDIOC_S_INPUT32 _IOWR ('V', 39, compat_int_t)
538 #define VIDIOC_TRY_FMT32 _IOWR ('V', 64, struct v4l2_format32)
541 MaxClips = (~0U-sizeof(struct video_window))/sizeof(struct video_clip)
544 static int do_set_window(struct file *file, unsigned int cmd, unsigned long arg)
546 struct video_window32 __user *up = compat_ptr(arg);
547 struct video_window __user *vw;
548 struct video_clip __user *p;
552 if (!access_ok(VERIFY_READ, up, sizeof(struct video_window32)))
555 if (get_user(nclips, &up->clipcount))
558 /* Peculiar interface... */
560 nclips = VIDEO_CLIPMAP_SIZE;
562 if (nclips > MaxClips)
565 vw = compat_alloc_user_space(sizeof(struct video_window) +
566 nclips * sizeof(struct video_clip));
568 p = nclips ? (struct video_clip __user *)(vw + 1) : NULL;
570 if (get_user(n, &up->x) || put_user(n, &vw->x) ||
571 get_user(n, &up->y) || put_user(n, &vw->y) ||
572 get_user(n, &up->width) || put_user(n, &vw->width) ||
573 get_user(n, &up->height) || put_user(n, &vw->height) ||
574 get_user(n, &up->chromakey) || put_user(n, &vw->chromakey) ||
575 get_user(n, &up->flags) || put_user(n, &vw->flags) ||
576 get_user(n, &up->clipcount) || put_user(n, &vw->clipcount) ||
577 get_user(n, &up->clips) || put_user(p, &vw->clips))
581 struct video_clip32 __user *u = compat_ptr(n);
585 for (i = 0; i < nclips; i++, u++, p++) {
587 if (!access_ok(VERIFY_READ, u, sizeof(struct video_clip32)) ||
588 !access_ok(VERIFY_WRITE, p, sizeof(struct video_clip32)) ||
589 get_user(v, &u->x) ||
590 put_user(v, &p->x) ||
591 get_user(v, &u->y) ||
592 put_user(v, &p->y) ||
593 get_user(v, &u->width) ||
594 put_user(v, &p->width) ||
595 get_user(v, &u->height) ||
596 put_user(v, &p->height) ||
597 put_user(NULL, &p->next))
602 return native_ioctl(file, VIDIOCSWIN, (unsigned long)vw);
605 static int do_video_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
608 struct video_tuner vt;
609 struct video_buffer vb;
610 struct video_window vw;
611 struct video_code vc;
612 struct v4l2_format v2f;
613 struct v4l2_buffer v2b;
614 struct v4l2_framebuffer v2fb;
615 struct v4l2_standard v2s;
616 struct v4l2_input v2i;
617 struct v4l2_tuner v2t;
620 void __user *up = compat_ptr(arg);
621 int compatible_arg = 1;
625 /* First, convert the command. */
627 case VIDIOCGTUNER32: cmd = VIDIOCGTUNER; break;
628 case VIDIOCSTUNER32: cmd = VIDIOCSTUNER; break;
629 case VIDIOCGWIN32: cmd = VIDIOCGWIN; break;
630 case VIDIOCGFBUF32: cmd = VIDIOCGFBUF; break;
631 case VIDIOCSFBUF32: cmd = VIDIOCSFBUF; break;
632 case VIDIOCGFREQ32: cmd = VIDIOCGFREQ; break;
633 case VIDIOCSFREQ32: cmd = VIDIOCSFREQ; break;
634 case VIDIOC_G_FMT32: cmd = VIDIOC_G_FMT; break;
635 case VIDIOC_S_FMT32: cmd = VIDIOC_S_FMT; break;
636 case VIDIOC_QUERYBUF32: cmd = VIDIOC_QUERYBUF; break;
637 case VIDIOC_QBUF32: cmd = VIDIOC_QBUF; break;
638 case VIDIOC_DQBUF32: cmd = VIDIOC_DQBUF; break;
639 case VIDIOC_STREAMON32: cmd = VIDIOC_STREAMON; break;
640 case VIDIOC_STREAMOFF32: cmd = VIDIOC_STREAMOFF; break;
641 case VIDIOC_G_FBUF32: cmd = VIDIOC_G_FBUF; break;
642 case VIDIOC_S_FBUF32: cmd = VIDIOC_S_FBUF; break;
643 case VIDIOC_OVERLAY32: cmd = VIDIOC_OVERLAY; break;
644 case VIDIOC_ENUMSTD32: realcmd = VIDIOC_ENUMSTD; break;
645 case VIDIOC_ENUMINPUT32: realcmd = VIDIOC_ENUMINPUT; break;
646 case VIDIOC_S_CTRL32: cmd = VIDIOC_S_CTRL; break;
647 case VIDIOC_G_INPUT32: cmd = VIDIOC_G_INPUT; break;
648 case VIDIOC_S_INPUT32: cmd = VIDIOC_S_INPUT; break;
649 case VIDIOC_TRY_FMT32: cmd = VIDIOC_TRY_FMT; break;
650 case VIDIOCSMICROCODE32: cmd = VIDIOCSMICROCODE; break;
656 err = get_video_tuner32(&karg.vt, up);
662 err = get_video_buffer32(&karg.vb, up);
669 case VIDIOC_STREAMON:
670 case VIDIOC_STREAMOFF:
671 err = get_user(karg.vx, (u32 __user *)up);
676 err = get_v4l2_framebuffer32(&karg.v2fb, up);
683 err = get_v4l2_format32(&karg.v2f, up);
687 case VIDIOC_QUERYBUF:
690 err = get_v4l2_buffer32(&karg.v2b, up);
695 err = get_v4l2_standard(&karg.v2s, up);
699 case VIDIOC_ENUMSTD32:
700 err = get_v4l2_standard32(&karg.v2s, up);
704 case VIDIOC_ENUMINPUT:
705 err = get_v4l2_input(&karg.v2i, up);
709 case VIDIOC_ENUMINPUT32:
710 err = get_v4l2_input32(&karg.v2i, up);
716 err = get_v4l2_tuner(&karg.v2t, up);
726 case VIDIOCSMICROCODE:
727 err = microcode32(&karg.vc, up);
736 err = native_ioctl(file, realcmd, (unsigned long)up);
738 mm_segment_t old_fs = get_fs();
741 err = native_ioctl(file, realcmd, (unsigned long)&karg);
747 err = put_video_tuner32(&karg.vt, up);
751 err = put_video_window32(&karg.vw, up);
755 err = put_video_buffer32(&karg.vb, up);
759 err = put_v4l2_framebuffer32(&karg.v2fb, up);
765 err = put_v4l2_format32(&karg.v2f, up);
768 case VIDIOC_QUERYBUF:
771 err = put_v4l2_buffer32(&karg.v2b, up);
775 err = put_v4l2_standard(&karg.v2s, up);
778 case VIDIOC_ENUMSTD32:
779 err = put_v4l2_standard32(&karg.v2s, up);
784 err = put_v4l2_tuner(&karg.v2t, up);
787 case VIDIOC_ENUMINPUT:
788 err = put_v4l2_input(&karg.v2i, up);
791 case VIDIOC_ENUMINPUT32:
792 err = put_v4l2_input32(&karg.v2i, up);
797 err = put_user(((u32)karg.vx), (u32 __user *)up);
805 long v4l_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
807 int ret = -ENOIOCTLCMD;
809 if (!file->f_op->ioctl)
814 ret = do_set_window(file, cmd, arg);
823 case VIDIOC_QUERYCAP:
824 case VIDIOC_ENUM_FMT:
828 case VIDIOC_QUERYBUF32:
829 case VIDIOC_G_FBUF32:
830 case VIDIOC_S_FBUF32:
831 case VIDIOC_OVERLAY32:
834 case VIDIOC_STREAMON32:
835 case VIDIOC_STREAMOFF32:
842 case VIDIOC_ENUMSTD32:
843 case VIDIOC_ENUMINPUT:
844 case VIDIOC_ENUMINPUT32:
846 case VIDIOC_S_CTRL32:
847 case VIDIOC_QUERYCTRL:
848 case VIDIOC_G_INPUT32:
849 case VIDIOC_S_INPUT32:
850 case VIDIOC_TRY_FMT32:
851 ret = do_video_ioctl(file, cmd, arg);
854 /* Little v, the video4linux ioctls (conflict?) */
871 /* BTTV specific... */
872 case _IOW('v', BASE_VIDIOCPRIVATE+0, char [256]):
873 case _IOR('v', BASE_VIDIOCPRIVATE+1, char [256]):
874 case _IOR('v' , BASE_VIDIOCPRIVATE+2, unsigned int):
875 case _IOW('v' , BASE_VIDIOCPRIVATE+3, char [16]): /* struct bttv_pll_info */
876 case _IOR('v' , BASE_VIDIOCPRIVATE+4, int):
877 case _IOR('v' , BASE_VIDIOCPRIVATE+5, int):
878 case _IOR('v' , BASE_VIDIOCPRIVATE+6, int):
879 case _IOR('v' , BASE_VIDIOCPRIVATE+7, int):
880 ret = native_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
883 v4l_print_ioctl("compat_ioctl32", cmd);
888 long v4l_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
893 EXPORT_SYMBOL_GPL(v4l_compat_ioctl32);
895 MODULE_LICENSE("GPL");