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)))
493 #define VIDIOCGTUNER32 _IOWR('v',4, struct video_tuner32)
494 #define VIDIOCSTUNER32 _IOW('v',5, struct video_tuner32)
495 #define VIDIOCGWIN32 _IOR('v',9, struct video_window32)
496 #define VIDIOCSWIN32 _IOW('v',10, struct video_window32)
497 #define VIDIOCGFBUF32 _IOR('v',11, struct video_buffer32)
498 #define VIDIOCSFBUF32 _IOW('v',12, struct video_buffer32)
499 #define VIDIOCGFREQ32 _IOR('v',14, u32)
500 #define VIDIOCSFREQ32 _IOW('v',15, u32)
502 /* VIDIOC_ENUMINPUT32 is VIDIOC_ENUMINPUT minus 4 bytes of padding alignement */
503 #define VIDIOC_ENUMINPUT32 VIDIOC_ENUMINPUT - _IOC(0, 0, 0, 4)
504 #define VIDIOC_G_FMT32 _IOWR ('V', 4, struct v4l2_format32)
505 #define VIDIOC_S_FMT32 _IOWR ('V', 5, struct v4l2_format32)
506 #define VIDIOC_QUERYBUF32 _IOWR ('V', 9, struct v4l2_buffer32)
507 #define VIDIOC_G_FBUF32 _IOR ('V', 10, struct v4l2_framebuffer32)
508 #define VIDIOC_S_FBUF32 _IOW ('V', 11, struct v4l2_framebuffer32)
509 /* VIDIOC_OVERLAY is now _IOW, but was _IOWR */
510 #define VIDIOC_OVERLAY32 _IOWR ('V', 14, compat_int_t)
511 #define VIDIOC_QBUF32 _IOWR ('V', 15, struct v4l2_buffer32)
512 #define VIDIOC_DQBUF32 _IOWR ('V', 17, struct v4l2_buffer32)
513 #define VIDIOC_STREAMON32 _IOW ('V', 18, compat_int_t)
514 #define VIDIOC_STREAMOFF32 _IOW ('V', 19, compat_int_t)
515 #define VIDIOC_ENUMSTD32 _IOWR ('V', 25, struct v4l2_standard32)
516 /* VIDIOC_S_CTRL is now _IOWR, but was _IOW */
517 #define VIDIOC_S_CTRL32 _IOW ('V', 28, struct v4l2_control)
518 #define VIDIOC_G_INPUT32 _IOR ('V', 38, compat_int_t)
519 #define VIDIOC_S_INPUT32 _IOWR ('V', 39, compat_int_t)
520 #define VIDIOC_TRY_FMT32 _IOWR ('V', 64, struct v4l2_format32)
523 MaxClips = (~0U-sizeof(struct video_window))/sizeof(struct video_clip)
526 static int do_set_window(struct file *file, unsigned int cmd, unsigned long arg)
528 struct video_window32 __user *up = compat_ptr(arg);
529 struct video_window __user *vw;
530 struct video_clip __user *p;
534 if (!access_ok(VERIFY_READ, up, sizeof(struct video_window32)))
537 if (get_user(nclips, &up->clipcount))
540 /* Peculiar interface... */
542 nclips = VIDEO_CLIPMAP_SIZE;
544 if (nclips > MaxClips)
547 vw = compat_alloc_user_space(sizeof(struct video_window) +
548 nclips * sizeof(struct video_clip));
550 p = nclips ? (struct video_clip __user *)(vw + 1) : NULL;
552 if (get_user(n, &up->x) || put_user(n, &vw->x) ||
553 get_user(n, &up->y) || put_user(n, &vw->y) ||
554 get_user(n, &up->width) || put_user(n, &vw->width) ||
555 get_user(n, &up->height) || put_user(n, &vw->height) ||
556 get_user(n, &up->chromakey) || put_user(n, &vw->chromakey) ||
557 get_user(n, &up->flags) || put_user(n, &vw->flags) ||
558 get_user(n, &up->clipcount) || put_user(n, &vw->clipcount) ||
559 get_user(n, &up->clips) || put_user(p, &vw->clips))
563 struct video_clip32 __user *u = compat_ptr(n);
567 for (i = 0; i < nclips; i++, u++, p++) {
569 if (!access_ok(VERIFY_READ, u, sizeof(struct video_clip32)) ||
570 !access_ok(VERIFY_WRITE, p, sizeof(struct video_clip32)) ||
571 get_user(v, &u->x) ||
572 put_user(v, &p->x) ||
573 get_user(v, &u->y) ||
574 put_user(v, &p->y) ||
575 get_user(v, &u->width) ||
576 put_user(v, &p->width) ||
577 get_user(v, &u->height) ||
578 put_user(v, &p->height) ||
579 put_user(NULL, &p->next))
584 return native_ioctl(file, VIDIOCSWIN, (unsigned long)vw);
587 static int do_video_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
590 struct video_tuner vt;
591 struct video_buffer vb;
592 struct video_window vw;
593 struct v4l2_format v2f;
594 struct v4l2_buffer v2b;
595 struct v4l2_framebuffer v2fb;
596 struct v4l2_standard v2s;
597 struct v4l2_input v2i;
598 struct v4l2_tuner v2t;
601 void __user *up = compat_ptr(arg);
602 int compatible_arg = 1;
606 /* First, convert the command. */
608 case VIDIOCGTUNER32: cmd = VIDIOCGTUNER; break;
609 case VIDIOCSTUNER32: cmd = VIDIOCSTUNER; break;
610 case VIDIOCGWIN32: cmd = VIDIOCGWIN; break;
611 case VIDIOCGFBUF32: cmd = VIDIOCGFBUF; break;
612 case VIDIOCSFBUF32: cmd = VIDIOCSFBUF; break;
613 case VIDIOCGFREQ32: cmd = VIDIOCGFREQ; break;
614 case VIDIOCSFREQ32: cmd = VIDIOCSFREQ; break;
615 case VIDIOC_G_FMT32: cmd = VIDIOC_G_FMT; break;
616 case VIDIOC_S_FMT32: cmd = VIDIOC_S_FMT; break;
617 case VIDIOC_QUERYBUF32: cmd = VIDIOC_QUERYBUF; break;
618 case VIDIOC_QBUF32: cmd = VIDIOC_QBUF; break;
619 case VIDIOC_DQBUF32: cmd = VIDIOC_DQBUF; break;
620 case VIDIOC_STREAMON32: cmd = VIDIOC_STREAMON; break;
621 case VIDIOC_STREAMOFF32: cmd = VIDIOC_STREAMOFF; break;
622 case VIDIOC_G_FBUF32: cmd = VIDIOC_G_FBUF; break;
623 case VIDIOC_S_FBUF32: cmd = VIDIOC_S_FBUF; break;
624 case VIDIOC_OVERLAY32: cmd = VIDIOC_OVERLAY; break;
625 case VIDIOC_ENUMSTD32: realcmd = VIDIOC_ENUMSTD; break;
626 case VIDIOC_ENUMINPUT32: realcmd = VIDIOC_ENUMINPUT; break;
627 case VIDIOC_S_CTRL32: cmd = VIDIOC_S_CTRL; break;
628 case VIDIOC_G_INPUT32: cmd = VIDIOC_G_INPUT; break;
629 case VIDIOC_S_INPUT32: cmd = VIDIOC_S_INPUT; break;
630 case VIDIOC_TRY_FMT32: cmd = VIDIOC_TRY_FMT; break;
636 err = get_video_tuner32(&karg.vt, up);
642 err = get_video_buffer32(&karg.vb, up);
649 case VIDIOC_STREAMON:
650 case VIDIOC_STREAMOFF:
651 err = get_user(karg.vx, (u32 __user *)up);
656 err = get_v4l2_framebuffer32(&karg.v2fb, up);
663 err = get_v4l2_format32(&karg.v2f, up);
667 case VIDIOC_QUERYBUF:
670 err = get_v4l2_buffer32(&karg.v2b, up);
675 err = get_v4l2_standard(&karg.v2s, up);
679 case VIDIOC_ENUMSTD32:
680 err = get_v4l2_standard32(&karg.v2s, up);
684 case VIDIOC_ENUMINPUT:
685 err = get_v4l2_input(&karg.v2i, up);
689 case VIDIOC_ENUMINPUT32:
690 err = get_v4l2_input32(&karg.v2i, up);
696 err = get_v4l2_tuner(&karg.v2t, up);
712 err = native_ioctl(file, realcmd, (unsigned long)up);
714 mm_segment_t old_fs = get_fs();
717 err = native_ioctl(file, realcmd, (unsigned long)&karg);
723 err = put_video_tuner32(&karg.vt, up);
727 err = put_video_window32(&karg.vw, up);
731 err = put_video_buffer32(&karg.vb, up);
735 err = put_v4l2_framebuffer32(&karg.v2fb, up);
741 err = put_v4l2_format32(&karg.v2f, up);
744 case VIDIOC_QUERYBUF:
747 err = put_v4l2_buffer32(&karg.v2b, up);
751 err = put_v4l2_standard(&karg.v2s, up);
754 case VIDIOC_ENUMSTD32:
755 err = put_v4l2_standard32(&karg.v2s, up);
760 err = put_v4l2_tuner(&karg.v2t, up);
763 case VIDIOC_ENUMINPUT:
764 err = put_v4l2_input(&karg.v2i, up);
767 case VIDIOC_ENUMINPUT32:
768 err = put_v4l2_input32(&karg.v2i, up);
773 err = put_user(((u32)karg.vx), (u32 __user *)up);
781 long v4l_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
783 int ret = -ENOIOCTLCMD;
785 if (!file->f_op->ioctl)
790 ret = do_set_window(file, cmd, arg);
799 case VIDIOC_QUERYCAP:
800 case VIDIOC_ENUM_FMT:
804 case VIDIOC_QUERYBUF32:
805 case VIDIOC_G_FBUF32:
806 case VIDIOC_S_FBUF32:
807 case VIDIOC_OVERLAY32:
810 case VIDIOC_STREAMON32:
811 case VIDIOC_STREAMOFF32:
818 case VIDIOC_ENUMSTD32:
819 case VIDIOC_ENUMINPUT:
820 case VIDIOC_ENUMINPUT32:
822 case VIDIOC_S_CTRL32:
823 case VIDIOC_QUERYCTRL:
824 case VIDIOC_G_INPUT32:
825 case VIDIOC_S_INPUT32:
826 case VIDIOC_TRY_FMT32:
827 ret = do_video_ioctl(file, cmd, arg);
830 /* Little v, the video4linux ioctls (conflict?) */
847 /* BTTV specific... */
848 case _IOW('v', BASE_VIDIOCPRIVATE+0, char [256]):
849 case _IOR('v', BASE_VIDIOCPRIVATE+1, char [256]):
850 case _IOR('v' , BASE_VIDIOCPRIVATE+2, unsigned int):
851 case _IOW('v' , BASE_VIDIOCPRIVATE+3, char [16]): /* struct bttv_pll_info */
852 case _IOR('v' , BASE_VIDIOCPRIVATE+4, int):
853 case _IOR('v' , BASE_VIDIOCPRIVATE+5, int):
854 case _IOR('v' , BASE_VIDIOCPRIVATE+6, int):
855 case _IOR('v' , BASE_VIDIOCPRIVATE+7, int):
856 ret = native_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
859 v4l_print_ioctl("compat_ioctl32", cmd);
864 long v4l_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
869 EXPORT_SYMBOL_GPL(v4l_compat_ioctl32);
871 MODULE_LICENSE("GPL");