ACPI: hotkey.c fixes, fix for potential crash of hotkey.c
[linux-2.6.git] / drivers / media / video / compat_ioctl32.c
1 /*
2  * ioctl32.c: Conversion between 32bit and 64bit native ioctls.
3  *      Separated from fs stuff by Arnd Bergmann <arnd@arndb.de>
4  *
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)
10  *
11  * These routines maintain argument size conversion between 32bit and 64bit
12  * ioctls.
13  */
14
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>
21
22 #ifdef CONFIG_COMPAT
23
24
25 struct video_tuner32 {
26         compat_int_t tuner;
27         char name[32];
28         compat_ulong_t rangelow, rangehigh;
29         u32 flags;      /* It is really u32 in videodev.h */
30         u16 mode, signal;
31 };
32
33 static int get_video_tuner32(struct video_tuner *kp, struct video_tuner32 __user *up)
34 {
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))
43                 return -EFAULT;
44         return 0;
45 }
46
47 static int put_video_tuner32(struct video_tuner *kp, struct video_tuner32 __user *up)
48 {
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))
57                         return -EFAULT;
58         return 0;
59 }
60
61 struct video_buffer32 {
62         compat_caddr_t base;
63         compat_int_t height, width, depth, bytesperline;
64 };
65
66 static int get_video_buffer32(struct video_buffer *kp, struct video_buffer32 __user *up)
67 {
68         u32 tmp;
69
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))
76                         return -EFAULT;
77
78         /* This is actually a physical address stored
79          * as a void pointer.
80          */
81         kp->base = (void *)(unsigned long) tmp;
82
83         return 0;
84 }
85
86 static int put_video_buffer32(struct video_buffer *kp, struct video_buffer32 __user *up)
87 {
88         u32 tmp = (u32)((unsigned long)kp->base);
89
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))
96                         return -EFAULT;
97         return 0;
98 }
99
100 struct video_clip32 {
101         s32 x, y, width, height;        /* Its really s32 in videodev.h */
102         compat_caddr_t next;
103 };
104
105 struct video_window32 {
106         u32 x, y, width, height, chromakey, flags;
107         compat_caddr_t clips;
108         compat_int_t clipcount;
109 };
110
111 static int native_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
112 {
113         int ret = -ENOIOCTLCMD;
114
115         if (file->f_op->unlocked_ioctl)
116                 ret = file->f_op->unlocked_ioctl(file, cmd, arg);
117         else if (file->f_op->ioctl) {
118                 lock_kernel();
119                 ret = file->f_op->ioctl(file->f_dentry->d_inode, file, cmd, arg);
120                 unlock_kernel();
121         }
122
123         return ret;
124 }
125
126
127 /* You get back everything except the clips... */
128 static int put_video_window32(struct video_window *kp, struct video_window32 __user *up)
129 {
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))
138                         return -EFAULT;
139         return 0;
140 }
141
142 struct v4l2_clip32
143 {
144         struct v4l2_rect        c;
145         compat_caddr_t          next;
146 };
147
148 struct v4l2_window32
149 {
150         struct v4l2_rect        w;
151         enum v4l2_field         field;
152         __u32                   chromakey;
153         compat_caddr_t          clips; /* actually struct v4l2_clip32 * */
154         __u32                   clipcount;
155         compat_caddr_t          bitmap;
156 };
157
158 static int get_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user *up)
159 {
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))
165                         return -EFAULT;
166         if (kp->clipcount > 2048)
167                 return -EINVAL;
168         if (kp->clipcount) {
169                 struct v4l2_clip32 __user *uclips;
170                 struct v4l2_clip __user *kclips;
171                 int n = kp->clipcount;
172                 compat_caddr_t p;
173
174                 if (get_user(p, &up->clips))
175                         return -EFAULT;
176                 uclips = compat_ptr(p);
177                 kclips = compat_alloc_user_space(n * sizeof(struct v4l2_clip));
178                 kp->clips = kclips;
179                 while (--n >= 0) {
180                         if (copy_in_user(&kclips->c, &uclips->c, sizeof(uclips->c)))
181                                 return -EFAULT;
182                         if (put_user(n ? kclips + 1 : NULL, &kclips->next))
183                                 return -EFAULT;
184                         uclips += 1;
185                         kclips += 1;
186                 }
187         } else
188                 kp->clips = NULL;
189         return 0;
190 }
191
192 static int put_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user *up)
193 {
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))
198                         return -EFAULT;
199         return 0;
200 }
201
202 static inline int get_v4l2_pix_format(struct v4l2_pix_format *kp, struct v4l2_pix_format __user *up)
203 {
204         if (copy_from_user(kp, up, sizeof(struct v4l2_pix_format)))
205                 return -EFAULT;
206         return 0;
207 }
208
209 static inline int put_v4l2_pix_format(struct v4l2_pix_format *kp, struct v4l2_pix_format __user *up)
210 {
211         if (copy_to_user(up, kp, sizeof(struct v4l2_pix_format)))
212                 return -EFAULT;
213         return 0;
214 }
215
216 static inline int get_v4l2_vbi_format(struct v4l2_vbi_format *kp, struct v4l2_vbi_format __user *up)
217 {
218         if (copy_from_user(kp, up, sizeof(struct v4l2_vbi_format)))
219                 return -EFAULT;
220         return 0;
221 }
222
223 static inline int put_v4l2_vbi_format(struct v4l2_vbi_format *kp, struct v4l2_vbi_format __user *up)
224 {
225         if (copy_to_user(up, kp, sizeof(struct v4l2_vbi_format)))
226                 return -EFAULT;
227         return 0;
228 }
229
230 struct v4l2_format32
231 {
232         enum v4l2_buf_type type;
233         union
234         {
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
239         } fmt;
240 };
241
242 static int get_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user *up)
243 {
244         if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_format32)) ||
245                         get_user(kp->type, &up->type))
246                         return -EFAULT;
247         switch (kp->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);
254         default:
255                 printk("compat_ioctl : unexpected VIDIOC_FMT type %d\n",
256                                                                 kp->type);
257                 return -ENXIO;
258         }
259 }
260
261 static int put_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user *up)
262 {
263         if(!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_format32)) ||
264                 put_user(kp->type, &up->type))
265                 return -EFAULT;
266         switch (kp->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);
273         default:
274                 return -ENXIO;
275         }
276 }
277
278 static inline int get_v4l2_standard(struct v4l2_standard *kp, struct v4l2_standard __user *up)
279 {
280         if (copy_from_user(kp, up, sizeof(struct v4l2_standard)))
281                 return -EFAULT;
282         return 0;
283
284 }
285
286 static inline int put_v4l2_standard(struct v4l2_standard *kp, struct v4l2_standard __user *up)
287 {
288         if (copy_to_user(up, kp, sizeof(struct v4l2_standard)))
289                 return -EFAULT;
290         return 0;
291 }
292
293 struct v4l2_standard32
294 {
295         __u32                index;
296         __u32                id[2]; /* __u64 would get the alignment wrong */
297         __u8                 name[24];
298         struct v4l2_fract    frameperiod; /* Frames, not fields */
299         __u32                framelines;
300         __u32                reserved[4];
301 };
302
303 static int get_v4l2_standard32(struct v4l2_standard *kp, struct v4l2_standard32 __user *up)
304 {
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))
308                 return -EFAULT;
309         return 0;
310 }
311
312 static int put_v4l2_standard32(struct v4l2_standard *kp, struct v4l2_standard32 __user *up)
313 {
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)))
321                         return -EFAULT;
322         return 0;
323 }
324
325 static inline int get_v4l2_tuner(struct v4l2_tuner *kp, struct v4l2_tuner __user *up)
326 {
327         if (copy_from_user(kp, up, sizeof(struct v4l2_tuner)))
328                 return -EFAULT;
329         return 0;
330
331 }
332
333 static inline int put_v4l2_tuner(struct v4l2_tuner *kp, struct v4l2_tuner __user *up)
334 {
335         if (copy_to_user(up, kp, sizeof(struct v4l2_tuner)))
336                 return -EFAULT;
337         return 0;
338 }
339
340 struct v4l2_buffer32
341 {
342         __u32                   index;
343         enum v4l2_buf_type      type;
344         __u32                   bytesused;
345         __u32                   flags;
346         enum v4l2_field         field;
347         struct compat_timeval   timestamp;
348         struct v4l2_timecode    timecode;
349         __u32                   sequence;
350
351         /* memory location */
352         enum v4l2_memory        memory;
353         union {
354                 __u32           offset;
355                 compat_long_t   userptr;
356         } m;
357         __u32                   length;
358         __u32                   input;
359         __u32                   reserved;
360 };
361
362 static int get_v4l2_buffer32(struct v4l2_buffer *kp, struct v4l2_buffer32 __user *up)
363 {
364
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))
371                         return -EFAULT;
372         switch(kp->memory) {
373         case V4L2_MEMORY_MMAP:
374                 break;
375         case V4L2_MEMORY_USERPTR:
376                 {
377                 compat_long_t tmp;
378
379                 if (get_user(kp->length, &up->length) ||
380                     get_user(tmp, &up->m.userptr))
381                         return -EFAULT;
382
383                 kp->m.userptr = (unsigned long)compat_ptr(tmp);
384                 }
385                 break;
386         case V4L2_MEMORY_OVERLAY:
387                 if(get_user(kp->m.offset, &up->m.offset))
388                         return -EFAULT;
389                 break;
390         }
391         return 0;
392 }
393
394 static int put_v4l2_buffer32(struct v4l2_buffer *kp, struct v4l2_buffer32 __user *up)
395 {
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))
402                         return -EFAULT;
403         switch(kp->memory) {
404         case V4L2_MEMORY_MMAP:
405                 if (put_user(kp->length, &up->length) ||
406                         put_user(kp->m.offset, &up->m.offset))
407                         return -EFAULT;
408                 break;
409         case V4L2_MEMORY_USERPTR:
410                 if (put_user(kp->length, &up->length) ||
411                         put_user(kp->m.userptr, &up->m.userptr))
412                         return -EFAULT;
413                 break;
414         case V4L2_MEMORY_OVERLAY:
415                 if (put_user(kp->m.offset, &up->m.offset))
416                         return -EFAULT;
417                 break;
418         }
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))
426                         return -EFAULT;
427         return 0;
428 }
429
430 struct v4l2_framebuffer32
431 {
432         __u32                   capability;
433         __u32                   flags;
434         compat_caddr_t          base;
435         struct v4l2_pix_format  fmt;
436 };
437
438 static int get_v4l2_framebuffer32(struct v4l2_framebuffer *kp, struct v4l2_framebuffer32 __user *up)
439 {
440         u32 tmp;
441
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))
446                         return -EFAULT;
447         kp->base = compat_ptr(tmp);
448         get_v4l2_pix_format(&kp->fmt, &up->fmt);
449         return 0;
450 }
451
452 static int put_v4l2_framebuffer32(struct v4l2_framebuffer *kp, struct v4l2_framebuffer32 __user *up)
453 {
454         u32 tmp = (u32)((unsigned long)kp->base);
455
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))
460                         return -EFAULT;
461         put_v4l2_pix_format(&kp->fmt, &up->fmt);
462         return 0;
463 }
464
465 static inline int get_v4l2_input32(struct v4l2_input *kp, struct v4l2_input __user *up)
466 {
467         if (copy_from_user(kp, up, sizeof(struct v4l2_input) - 4))
468                 return -EFAULT;
469         return 0;
470 }
471
472 static inline int put_v4l2_input32(struct v4l2_input *kp, struct v4l2_input __user *up)
473 {
474         if (copy_to_user(up, kp, sizeof(struct v4l2_input) - 4))
475                 return -EFAULT;
476         return 0;
477 }
478
479 static inline int get_v4l2_input(struct v4l2_input *kp, struct v4l2_input __user *up)
480 {
481         if (copy_from_user(kp, up, sizeof(struct v4l2_input)))
482                 return -EFAULT;
483         return 0;
484 }
485
486 static inline int put_v4l2_input(struct v4l2_input *kp, struct v4l2_input __user *up)
487 {
488         if (copy_to_user(up, kp, sizeof(struct v4l2_input)))
489                 return -EFAULT;
490         return 0;
491 }
492
493 struct video_code32
494 {
495         char            loadwhat[16];   /* name or tag of file being passed */
496         compat_int_t    datasize;
497         unsigned char   *data;
498 };
499
500 static inline int microcode32(struct video_code *kp, struct video_code32 __user *up)
501 {
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))
506                         return -EFAULT;
507         return 0;
508 }
509
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)
519
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)
539
540 enum {
541         MaxClips = (~0U-sizeof(struct video_window))/sizeof(struct video_clip)
542 };
543
544 static int do_set_window(struct file *file, unsigned int cmd, unsigned long arg)
545 {
546         struct video_window32 __user *up = compat_ptr(arg);
547         struct video_window __user *vw;
548         struct video_clip __user *p;
549         int nclips;
550         u32 n;
551
552         if (!access_ok(VERIFY_READ, up, sizeof(struct video_window32)))
553                 return -EFAULT;
554
555         if (get_user(nclips, &up->clipcount))
556                 return -EFAULT;
557
558         /* Peculiar interface... */
559         if (nclips < 0)
560                 nclips = VIDEO_CLIPMAP_SIZE;
561
562         if (nclips > MaxClips)
563                 return -ENOMEM;
564
565         vw = compat_alloc_user_space(sizeof(struct video_window) +
566                                     nclips * sizeof(struct video_clip));
567
568         p = nclips ? (struct video_clip __user *)(vw + 1) : NULL;
569
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))
578                 return -EFAULT;
579
580         if (nclips) {
581                 struct video_clip32 __user *u = compat_ptr(n);
582                 int i;
583                 if (!u)
584                         return -EINVAL;
585                 for (i = 0; i < nclips; i++, u++, p++) {
586                         s32 v;
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))
598                                 return -EFAULT;
599                 }
600         }
601
602         return native_ioctl(file, VIDIOCSWIN, (unsigned long)vw);
603 }
604
605 static int do_video_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
606 {
607         union {
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;
618                 unsigned long vx;
619         } karg;
620         void __user *up = compat_ptr(arg);
621         int compatible_arg = 1;
622         int err = 0;
623         int realcmd = cmd;
624
625         /* First, convert the command. */
626         switch(cmd) {
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;
651         };
652
653         switch(cmd) {
654         case VIDIOCSTUNER:
655         case VIDIOCGTUNER:
656                 err = get_video_tuner32(&karg.vt, up);
657                 compatible_arg = 0;
658
659                 break;
660
661         case VIDIOCSFBUF:
662                 err = get_video_buffer32(&karg.vb, up);
663                 compatible_arg = 0;
664                 break;
665
666         case VIDIOCSFREQ:
667         case VIDIOC_S_INPUT:
668         case VIDIOC_OVERLAY:
669         case VIDIOC_STREAMON:
670         case VIDIOC_STREAMOFF:
671                 err = get_user(karg.vx, (u32 __user *)up);
672                 compatible_arg = 0;
673                 break;
674
675         case VIDIOC_S_FBUF:
676                 err = get_v4l2_framebuffer32(&karg.v2fb, up);
677                 compatible_arg = 0;
678                 break;
679
680         case VIDIOC_G_FMT:
681         case VIDIOC_S_FMT:
682         case VIDIOC_TRY_FMT:
683                 err = get_v4l2_format32(&karg.v2f, up);
684                 compatible_arg = 0;
685                 break;
686
687         case VIDIOC_QUERYBUF:
688         case VIDIOC_QBUF:
689         case VIDIOC_DQBUF:
690                 err = get_v4l2_buffer32(&karg.v2b, up);
691                 compatible_arg = 0;
692                 break;
693
694         case VIDIOC_ENUMSTD:
695                 err = get_v4l2_standard(&karg.v2s, up);
696                 compatible_arg = 0;
697                 break;
698
699         case VIDIOC_ENUMSTD32:
700                 err = get_v4l2_standard32(&karg.v2s, up);
701                 compatible_arg = 0;
702                 break;
703
704         case VIDIOC_ENUMINPUT:
705                 err = get_v4l2_input(&karg.v2i, up);
706                 compatible_arg = 0;
707                 break;
708
709         case VIDIOC_ENUMINPUT32:
710                 err = get_v4l2_input32(&karg.v2i, up);
711                 compatible_arg = 0;
712                 break;
713
714         case VIDIOC_G_TUNER:
715         case VIDIOC_S_TUNER:
716                 err = get_v4l2_tuner(&karg.v2t, up);
717                 compatible_arg = 0;
718                 break;
719
720         case VIDIOCGWIN:
721         case VIDIOCGFBUF:
722         case VIDIOCGFREQ:
723         case VIDIOC_G_FBUF:
724         case VIDIOC_G_INPUT:
725                 compatible_arg = 0;
726         case VIDIOCSMICROCODE:
727                 err = microcode32(&karg.vc, up);
728                 compatible_arg = 0;
729                 break;
730         };
731
732         if(err)
733                 goto out;
734
735         if(compatible_arg)
736                 err = native_ioctl(file, realcmd, (unsigned long)up);
737         else {
738                 mm_segment_t old_fs = get_fs();
739
740                 set_fs(KERNEL_DS);
741                 err = native_ioctl(file, realcmd, (unsigned long)&karg);
742                 set_fs(old_fs);
743         }
744         if(err == 0) {
745                 switch(cmd) {
746                 case VIDIOCGTUNER:
747                         err = put_video_tuner32(&karg.vt, up);
748                         break;
749
750                 case VIDIOCGWIN:
751                         err = put_video_window32(&karg.vw, up);
752                         break;
753
754                 case VIDIOCGFBUF:
755                         err = put_video_buffer32(&karg.vb, up);
756                         break;
757
758                 case VIDIOC_G_FBUF:
759                         err = put_v4l2_framebuffer32(&karg.v2fb, up);
760                         break;
761
762                 case VIDIOC_G_FMT:
763                 case VIDIOC_S_FMT:
764                 case VIDIOC_TRY_FMT:
765                         err = put_v4l2_format32(&karg.v2f, up);
766                         break;
767
768                 case VIDIOC_QUERYBUF:
769                 case VIDIOC_QBUF:
770                 case VIDIOC_DQBUF:
771                         err = put_v4l2_buffer32(&karg.v2b, up);
772                         break;
773
774                 case VIDIOC_ENUMSTD:
775                         err = put_v4l2_standard(&karg.v2s, up);
776                         break;
777
778                 case VIDIOC_ENUMSTD32:
779                         err = put_v4l2_standard32(&karg.v2s, up);
780                         break;
781
782                 case VIDIOC_G_TUNER:
783                 case VIDIOC_S_TUNER:
784                         err = put_v4l2_tuner(&karg.v2t, up);
785                         break;
786
787                 case VIDIOC_ENUMINPUT:
788                         err = put_v4l2_input(&karg.v2i, up);
789                         break;
790
791                 case VIDIOC_ENUMINPUT32:
792                         err = put_v4l2_input32(&karg.v2i, up);
793                         break;
794
795                 case VIDIOCGFREQ:
796                 case VIDIOC_G_INPUT:
797                         err = put_user(((u32)karg.vx), (u32 __user *)up);
798                         break;
799                 };
800         }
801 out:
802         return err;
803 }
804
805 long v4l_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
806 {
807         int ret = -ENOIOCTLCMD;
808
809         if (!file->f_op->ioctl)
810                 return ret;
811
812         switch (cmd) {
813         case VIDIOCSWIN32:
814                 ret = do_set_window(file, cmd, arg);
815                 break;
816         case VIDIOCGTUNER32:
817         case VIDIOCSTUNER32:
818         case VIDIOCGWIN32:
819         case VIDIOCGFBUF32:
820         case VIDIOCSFBUF32:
821         case VIDIOCGFREQ32:
822         case VIDIOCSFREQ32:
823         case VIDIOC_QUERYCAP:
824         case VIDIOC_ENUM_FMT:
825         case VIDIOC_G_FMT32:
826         case VIDIOC_S_FMT32:
827         case VIDIOC_REQBUFS:
828         case VIDIOC_QUERYBUF32:
829         case VIDIOC_G_FBUF32:
830         case VIDIOC_S_FBUF32:
831         case VIDIOC_OVERLAY32:
832         case VIDIOC_QBUF32:
833         case VIDIOC_DQBUF32:
834         case VIDIOC_STREAMON32:
835         case VIDIOC_STREAMOFF32:
836         case VIDIOC_G_PARM:
837         case VIDIOC_G_STD:
838         case VIDIOC_S_STD:
839         case VIDIOC_G_TUNER:
840         case VIDIOC_S_TUNER:
841         case VIDIOC_ENUMSTD:
842         case VIDIOC_ENUMSTD32:
843         case VIDIOC_ENUMINPUT:
844         case VIDIOC_ENUMINPUT32:
845         case VIDIOC_G_CTRL:
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);
852                 break;
853
854         /* Little v, the video4linux ioctls (conflict?) */
855         case VIDIOCGCAP:
856         case VIDIOCGCHAN:
857         case VIDIOCSCHAN:
858         case VIDIOCGPICT:
859         case VIDIOCSPICT:
860         case VIDIOCCAPTURE:
861         case VIDIOCKEY:
862         case VIDIOCGAUDIO:
863         case VIDIOCSAUDIO:
864         case VIDIOCSYNC:
865         case VIDIOCMCAPTURE:
866         case VIDIOCGMBUF:
867         case VIDIOCGUNIT:
868         case VIDIOCGCAPTURE:
869         case VIDIOCSCAPTURE:
870
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));
881                 break;
882         default:
883                 v4l_print_ioctl("compat_ioctl32", cmd);
884         }
885         return ret;
886 }
887 #else
888 long v4l_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
889 {
890         return -ENOIOCTLCMD;
891 }
892 #endif
893 EXPORT_SYMBOL_GPL(v4l_compat_ioctl32);
894
895 MODULE_LICENSE("GPL");