[PATCH] mv643xx_eth: Fix transmit skb accounting
[linux-2.6] / 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/config.h>
16 #include <linux/compat.h>
17 #include <linux/videodev.h>
18 #include <linux/videodev2.h>
19 #include <linux/module.h>
20 #include <linux/smp_lock.h>
21 #include <media/v4l2-common.h>
22
23 #ifdef CONFIG_COMPAT
24
25
26 struct video_tuner32 {
27         compat_int_t tuner;
28         char name[32];
29         compat_ulong_t rangelow, rangehigh;
30         u32 flags;      /* It is really u32 in videodev.h */
31         u16 mode, signal;
32 };
33
34 static int get_video_tuner32(struct video_tuner *kp, struct video_tuner32 __user *up)
35 {
36         if(!access_ok(VERIFY_READ, up, sizeof(struct video_tuner32)) ||
37                 get_user(kp->tuner, &up->tuner) ||
38                 copy_from_user(kp->name, up->name, 32) ||
39                 get_user(kp->rangelow, &up->rangelow) ||
40                 get_user(kp->rangehigh, &up->rangehigh) ||
41                 get_user(kp->flags, &up->flags) ||
42                 get_user(kp->mode, &up->mode) ||
43                 get_user(kp->signal, &up->signal))
44                 return -EFAULT;
45         return 0;
46 }
47
48 static int put_video_tuner32(struct video_tuner *kp, struct video_tuner32 __user *up)
49 {
50         if(!access_ok(VERIFY_WRITE, up, sizeof(struct video_tuner32)) ||
51                 put_user(kp->tuner, &up->tuner) ||
52                 copy_to_user(up->name, kp->name, 32) ||
53                 put_user(kp->rangelow, &up->rangelow) ||
54                 put_user(kp->rangehigh, &up->rangehigh) ||
55                 put_user(kp->flags, &up->flags) ||
56                 put_user(kp->mode, &up->mode) ||
57                 put_user(kp->signal, &up->signal))
58                         return -EFAULT;
59         return 0;
60 }
61
62 struct video_buffer32 {
63         compat_caddr_t base;
64         compat_int_t height, width, depth, bytesperline;
65 };
66
67 static int get_video_buffer32(struct video_buffer *kp, struct video_buffer32 __user *up)
68 {
69         u32 tmp;
70
71         if (!access_ok(VERIFY_READ, up, sizeof(struct video_buffer32)) ||
72                 get_user(tmp, &up->base) ||
73                 get_user(kp->height, &up->height) ||
74                 get_user(kp->width, &up->width) ||
75                 get_user(kp->depth, &up->depth) ||
76                 get_user(kp->bytesperline, &up->bytesperline))
77                         return -EFAULT;
78
79         /* This is actually a physical address stored
80          * as a void pointer.
81          */
82         kp->base = (void *)(unsigned long) tmp;
83
84         return 0;
85 }
86
87 static int put_video_buffer32(struct video_buffer *kp, struct video_buffer32 __user *up)
88 {
89         u32 tmp = (u32)((unsigned long)kp->base);
90
91         if(!access_ok(VERIFY_WRITE, up, sizeof(struct video_buffer32)) ||
92                 put_user(tmp, &up->base) ||
93                 put_user(kp->height, &up->height) ||
94                 put_user(kp->width, &up->width) ||
95                 put_user(kp->depth, &up->depth) ||
96                 put_user(kp->bytesperline, &up->bytesperline))
97                         return -EFAULT;
98         return 0;
99 }
100
101 struct video_clip32 {
102         s32 x, y, width, height;        /* Its really s32 in videodev.h */
103         compat_caddr_t next;
104 };
105
106 struct video_window32 {
107         u32 x, y, width, height, chromakey, flags;
108         compat_caddr_t clips;
109         compat_int_t clipcount;
110 };
111
112 static int native_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
113 {
114         int ret = -ENOIOCTLCMD;
115
116         if (file->f_op->unlocked_ioctl)
117                 ret = file->f_op->unlocked_ioctl(file, cmd, arg);
118         else if (file->f_op->ioctl) {
119                 lock_kernel();
120                 ret = file->f_op->ioctl(file->f_dentry->d_inode, file, cmd, arg);
121                 unlock_kernel();
122         }
123
124         return ret;
125 }
126
127
128 /* You get back everything except the clips... */
129 static int put_video_window32(struct video_window *kp, struct video_window32 __user *up)
130 {
131         if(!access_ok(VERIFY_WRITE, up, sizeof(struct video_window32)) ||
132                 put_user(kp->x, &up->x) ||
133                 put_user(kp->y, &up->y) ||
134                 put_user(kp->width, &up->width) ||
135                 put_user(kp->height, &up->height) ||
136                 put_user(kp->chromakey, &up->chromakey) ||
137                 put_user(kp->flags, &up->flags) ||
138                 put_user(kp->clipcount, &up->clipcount))
139                         return -EFAULT;
140         return 0;
141 }
142
143 struct v4l2_clip32
144 {
145         struct v4l2_rect        c;
146         compat_caddr_t          next;
147 };
148
149 struct v4l2_window32
150 {
151         struct v4l2_rect        w;
152         enum v4l2_field         field;
153         __u32                   chromakey;
154         compat_caddr_t          clips; /* actually struct v4l2_clip32 * */
155         __u32                   clipcount;
156         compat_caddr_t          bitmap;
157 };
158
159 static int get_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user *up)
160 {
161         if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_window32)) ||
162                 copy_from_user(&kp->w, &up->w, sizeof(up->w)) ||
163                 get_user(kp->field, &up->field) ||
164                 get_user(kp->chromakey, &up->chromakey) ||
165                 get_user(kp->clipcount, &up->clipcount))
166                         return -EFAULT;
167         if (kp->clipcount > 2048)
168                 return -EINVAL;
169         if (kp->clipcount) {
170                 struct v4l2_clip32 *uclips = compat_ptr(up->clips);
171                 struct v4l2_clip *kclips;
172                 int n = kp->clipcount;
173
174                 kclips = compat_alloc_user_space(n * sizeof(struct v4l2_clip));
175                 kp->clips = kclips;
176                 while (--n >= 0) {
177                         if (!access_ok(VERIFY_READ, &uclips->c, sizeof(uclips->c)) ||
178                                 copy_from_user(&kclips->c, &uclips->c, sizeof(uclips->c)))
179                                 return -EFAULT;
180                         kclips->next = n ? kclips + 1 : 0;
181                         uclips += 1;
182                         kclips += 1;
183                 }
184         } else
185                 kp->clips = 0;
186         return 0;
187 }
188
189 static int put_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user *up)
190 {
191         if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_window32)) ||
192                 copy_to_user(&up->w, &kp->w, sizeof(up->w)) ||
193                 put_user(kp->field, &up->field) ||
194                 put_user(kp->chromakey, &up->chromakey) ||
195                 put_user(kp->clipcount, &up->clipcount))
196                         return -EFAULT;
197         return 0;
198 }
199
200 static inline int get_v4l2_pix_format(struct v4l2_pix_format *kp, struct v4l2_pix_format __user *up)
201 {
202         if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_pix_format)) ||
203                 copy_from_user(kp, up, sizeof(struct v4l2_pix_format)))
204                         return -EFAULT;
205         return 0;
206 }
207
208 static inline int put_v4l2_pix_format(struct v4l2_pix_format *kp, struct v4l2_pix_format __user *up)
209 {
210         if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_pix_format)) ||
211                 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 (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_vbi_format)) ||
219                 copy_from_user(kp, up, sizeof(struct v4l2_vbi_format)))
220                         return -EFAULT;
221         return 0;
222 }
223
224 static inline int put_v4l2_vbi_format(struct v4l2_vbi_format *kp, struct v4l2_vbi_format __user *up)
225 {
226         if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_vbi_format)) ||
227                 copy_to_user(up, kp, sizeof(struct v4l2_vbi_format)))
228                         return -EFAULT;
229         return 0;
230 }
231
232 struct v4l2_format32
233 {
234         enum v4l2_buf_type type;
235         union
236         {
237                 struct v4l2_pix_format  pix;  // V4L2_BUF_TYPE_VIDEO_CAPTURE
238                 struct v4l2_window32    win;  // V4L2_BUF_TYPE_VIDEO_OVERLAY
239                 struct v4l2_vbi_format  vbi;  // V4L2_BUF_TYPE_VBI_CAPTURE
240                 __u8    raw_data[200];        // user-defined
241         } fmt;
242 };
243
244 static int get_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user *up)
245 {
246         if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_format32)) ||
247                         get_user(kp->type, &up->type))
248                         return -EFAULT;
249         switch (kp->type) {
250         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
251                 return get_v4l2_pix_format(&kp->fmt.pix, &up->fmt.pix);
252         case V4L2_BUF_TYPE_VIDEO_OVERLAY:
253                 return get_v4l2_window32(&kp->fmt.win, &up->fmt.win);
254         case V4L2_BUF_TYPE_VBI_CAPTURE:
255                 return get_v4l2_vbi_format(&kp->fmt.vbi, &up->fmt.vbi);
256         default:
257                 printk("compat_ioctl : unexpected VIDIOC_FMT type %d\n",
258                                                                 kp->type);
259                 return -ENXIO;
260         }
261 }
262
263 static int put_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user *up)
264 {
265         if(!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_format32)) ||
266                 put_user(kp->type, &up->type))
267                 return -EFAULT;
268         switch (kp->type) {
269         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
270                 return put_v4l2_pix_format(&kp->fmt.pix, &up->fmt.pix);
271         case V4L2_BUF_TYPE_VIDEO_OVERLAY:
272                 return put_v4l2_window32(&kp->fmt.win, &up->fmt.win);
273         case V4L2_BUF_TYPE_VBI_CAPTURE:
274                 return put_v4l2_vbi_format(&kp->fmt.vbi, &up->fmt.vbi);
275         default:
276                 return -ENXIO;
277         }
278 }
279
280 static inline int get_v4l2_standard(struct v4l2_standard *kp, struct v4l2_standard __user *up)
281 {
282         if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_standard)) ||
283                 copy_from_user(kp, up, sizeof(struct v4l2_standard)))
284                         return -EFAULT;
285         return 0;
286
287 }
288
289 static inline int put_v4l2_standard(struct v4l2_standard *kp, struct v4l2_standard __user *up)
290 {
291         if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_standard)) ||
292                 copy_to_user(up, kp, sizeof(struct v4l2_standard)))
293                         return -EFAULT;
294         return 0;
295 }
296
297 struct v4l2_standard32
298 {
299         __u32                index;
300         __u32                id[2]; /* __u64 would get the alignment wrong */
301         __u8                 name[24];
302         struct v4l2_fract    frameperiod; /* Frames, not fields */
303         __u32                framelines;
304         __u32                reserved[4];
305 };
306
307 static int get_v4l2_standard32(struct v4l2_standard *kp, struct v4l2_standard32 __user *up)
308 {
309         /* other fields are not set by the user, nor used by the driver */
310         if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_standard32)) ||
311                 get_user(kp->index, &up->index))
312                 return -EFAULT;
313         return 0;
314 }
315
316 static int put_v4l2_standard32(struct v4l2_standard *kp, struct v4l2_standard32 __user *up)
317 {
318         if(!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_standard32)) ||
319                 put_user(kp->index, &up->index) ||
320                 copy_to_user(up->id, &kp->id, sizeof(__u64)) ||
321                 copy_to_user(up->name, kp->name, 24) ||
322                 copy_to_user(&up->frameperiod, &kp->frameperiod, sizeof(kp->frameperiod)) ||
323                 put_user(kp->framelines, &up->framelines) ||
324                 copy_to_user(up->reserved, kp->reserved, 4 * sizeof(__u32)))
325                         return -EFAULT;
326         return 0;
327 }
328
329 static inline int get_v4l2_tuner(struct v4l2_tuner *kp, struct v4l2_tuner __user *up)
330 {
331         if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_tuner)) ||
332                 copy_from_user(kp, up, sizeof(struct v4l2_tuner)))
333                         return -EFAULT;
334         return 0;
335
336 }
337
338 static inline int put_v4l2_tuner(struct v4l2_tuner *kp, struct v4l2_tuner __user *up)
339 {
340         if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_tuner)) ||
341                 copy_to_user(up, kp, sizeof(struct v4l2_tuner)))
342                         return -EFAULT;
343         return 0;
344 }
345
346 struct v4l2_buffer32
347 {
348         __u32                   index;
349         enum v4l2_buf_type      type;
350         __u32                   bytesused;
351         __u32                   flags;
352         enum v4l2_field         field;
353         struct compat_timeval   timestamp;
354         struct v4l2_timecode    timecode;
355         __u32                   sequence;
356
357         /* memory location */
358         enum v4l2_memory        memory;
359         union {
360                 __u32           offset;
361                 compat_long_t   userptr;
362         } m;
363         __u32                   length;
364         __u32                   input;
365         __u32                   reserved;
366 };
367
368 static int get_v4l2_buffer32(struct v4l2_buffer *kp, struct v4l2_buffer32 __user *up)
369 {
370
371         if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_buffer32)) ||
372                 get_user(kp->index, &up->index) ||
373                 get_user(kp->type, &up->type) ||
374                 get_user(kp->flags, &up->flags) ||
375                 get_user(kp->memory, &up->memory) ||
376                 get_user(kp->input, &up->input))
377                         return -EFAULT;
378         switch(kp->memory) {
379         case V4L2_MEMORY_MMAP:
380                 break;
381         case V4L2_MEMORY_USERPTR:
382                 {
383                 unsigned long tmp = (unsigned long)compat_ptr(up->m.userptr);
384
385                 if(get_user(kp->length, &up->length) ||
386                         get_user(kp->m.userptr, &tmp))
387                                 return -EFAULT;
388                 }
389                 break;
390         case V4L2_MEMORY_OVERLAY:
391                 if(get_user(kp->m.offset, &up->m.offset))
392                         return -EFAULT;
393                 break;
394         }
395         return 0;
396 }
397
398 static int put_v4l2_buffer32(struct v4l2_buffer *kp, struct v4l2_buffer32 __user *up)
399 {
400         if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_buffer32)) ||
401                 put_user(kp->index, &up->index) ||
402                 put_user(kp->type, &up->type) ||
403                 put_user(kp->flags, &up->flags) ||
404                 put_user(kp->memory, &up->memory) ||
405                 put_user(kp->input, &up->input))
406                         return -EFAULT;
407         switch(kp->memory) {
408         case V4L2_MEMORY_MMAP:
409                 if (put_user(kp->length, &up->length) ||
410                         put_user(kp->m.offset, &up->m.offset))
411                         return -EFAULT;
412                 break;
413         case V4L2_MEMORY_USERPTR:
414                 if (put_user(kp->length, &up->length) ||
415                         put_user(kp->m.userptr, &up->m.userptr))
416                         return -EFAULT;
417                 break;
418         case V4L2_MEMORY_OVERLAY:
419                 if (put_user(kp->m.offset, &up->m.offset))
420                         return -EFAULT;
421                 break;
422         }
423         if (put_user(kp->bytesused, &up->bytesused) ||
424                 put_user(kp->field, &up->field) ||
425                 put_user(kp->timestamp.tv_sec, &up->timestamp.tv_sec) ||
426                 put_user(kp->timestamp.tv_usec, &up->timestamp.tv_usec) ||
427                 copy_to_user(&up->timecode, &kp->timecode, sizeof(struct v4l2_timecode)) ||
428                 put_user(kp->sequence, &up->sequence) ||
429                 put_user(kp->reserved, &up->reserved))
430                         return -EFAULT;
431         return 0;
432 }
433
434 struct v4l2_framebuffer32
435 {
436         __u32                   capability;
437         __u32                   flags;
438         compat_caddr_t          base;
439         struct v4l2_pix_format  fmt;
440 };
441
442 static int get_v4l2_framebuffer32(struct v4l2_framebuffer *kp, struct v4l2_framebuffer32 __user *up)
443 {
444         u32 tmp;
445
446         if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_framebuffer32)) ||
447                 get_user(tmp, &up->base) ||
448                 get_user(kp->capability, &up->capability) ||
449                 get_user(kp->flags, &up->flags))
450                         return -EFAULT;
451         kp->base = compat_ptr(tmp);
452         get_v4l2_pix_format(&kp->fmt, &up->fmt);
453         return 0;
454 }
455
456 static int put_v4l2_framebuffer32(struct v4l2_framebuffer *kp, struct v4l2_framebuffer32 __user *up)
457 {
458         u32 tmp = (u32)((unsigned long)kp->base);
459
460         if(!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_framebuffer32)) ||
461                 put_user(tmp, &up->base) ||
462                 put_user(kp->capability, &up->capability) ||
463                 put_user(kp->flags, &up->flags))
464                         return -EFAULT;
465         put_v4l2_pix_format(&kp->fmt, &up->fmt);
466         return 0;
467 }
468
469 static inline int get_v4l2_input32(struct v4l2_input *kp, struct v4l2_input __user *up)
470 {
471         if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_input) - 4) ||
472                 copy_from_user(kp, up, sizeof(struct v4l2_input) - 4))
473                         return -EFAULT;
474         return 0;
475 }
476
477 static inline int put_v4l2_input32(struct v4l2_input *kp, struct v4l2_input __user *up)
478 {
479         if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_input) - 4) ||
480                 copy_to_user(up, kp, sizeof(struct v4l2_input) - 4))
481                         return -EFAULT;
482         return 0;
483 }
484
485 static inline int get_v4l2_input(struct v4l2_input *kp, struct v4l2_input __user *up)
486 {
487         if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_input)) ||
488                 copy_from_user(kp, up, sizeof(struct v4l2_input)))
489                         return -EFAULT;
490         return 0;
491 }
492
493 static inline int put_v4l2_input(struct v4l2_input *kp, struct v4l2_input __user *up)
494 {
495         if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_input)) ||
496                 copy_to_user(up, kp, sizeof(struct v4l2_input)))
497                         return -EFAULT;
498         return 0;
499 }
500
501 #define VIDIOCGTUNER32          _IOWR('v',4, struct video_tuner32)
502 #define VIDIOCSTUNER32          _IOW('v',5, struct video_tuner32)
503 #define VIDIOCGWIN32            _IOR('v',9, struct video_window32)
504 #define VIDIOCSWIN32            _IOW('v',10, struct video_window32)
505 #define VIDIOCGFBUF32           _IOR('v',11, struct video_buffer32)
506 #define VIDIOCSFBUF32           _IOW('v',12, struct video_buffer32)
507 #define VIDIOCGFREQ32           _IOR('v',14, u32)
508 #define VIDIOCSFREQ32           _IOW('v',15, u32)
509
510 /* VIDIOC_ENUMINPUT32 is VIDIOC_ENUMINPUT minus 4 bytes of padding alignement */
511 #define VIDIOC_ENUMINPUT32      VIDIOC_ENUMINPUT - _IOC(0, 0, 0, 4)
512 #define VIDIOC_G_FMT32          _IOWR ('V',  4, struct v4l2_format32)
513 #define VIDIOC_S_FMT32          _IOWR ('V',  5, struct v4l2_format32)
514 #define VIDIOC_QUERYBUF32       _IOWR ('V',  9, struct v4l2_buffer32)
515 #define VIDIOC_G_FBUF32         _IOR  ('V', 10, struct v4l2_framebuffer32)
516 #define VIDIOC_S_FBUF32         _IOW  ('V', 11, struct v4l2_framebuffer32)
517 /* VIDIOC_OVERLAY is now _IOW, but was _IOWR */
518 #define VIDIOC_OVERLAY32        _IOWR ('V', 14, compat_int_t)
519 #define VIDIOC_QBUF32           _IOWR ('V', 15, struct v4l2_buffer32)
520 #define VIDIOC_DQBUF32          _IOWR ('V', 17, struct v4l2_buffer32)
521 #define VIDIOC_STREAMON32       _IOW  ('V', 18, compat_int_t)
522 #define VIDIOC_STREAMOFF32      _IOW  ('V', 19, compat_int_t)
523 #define VIDIOC_ENUMSTD32        _IOWR ('V', 25, struct v4l2_standard32)
524 /* VIDIOC_S_CTRL is now _IOWR, but was _IOW */
525 #define VIDIOC_S_CTRL32         _IOW  ('V', 28, struct v4l2_control)
526 #define VIDIOC_G_INPUT32        _IOR  ('V', 38, compat_int_t)
527 #define VIDIOC_S_INPUT32        _IOWR ('V', 39, compat_int_t)
528 #define VIDIOC_TRY_FMT32        _IOWR ('V', 64, struct v4l2_format32)
529
530 enum {
531         MaxClips = (~0U-sizeof(struct video_window))/sizeof(struct video_clip)
532 };
533
534 static int do_set_window(struct file *file, unsigned int cmd, unsigned long arg)
535 {
536         struct video_window32 __user *up = compat_ptr(arg);
537         struct video_window __user *vw;
538         struct video_clip __user *p;
539         int nclips;
540         u32 n;
541
542         if (!access_ok(VERIFY_READ, up, sizeof(struct video_window32)))
543                 return -EFAULT;
544
545         if (get_user(nclips, &up->clipcount))
546                 return -EFAULT;
547
548         /* Peculiar interface... */
549         if (nclips < 0)
550                 nclips = VIDEO_CLIPMAP_SIZE;
551
552         if (nclips > MaxClips)
553                 return -ENOMEM;
554
555         vw = compat_alloc_user_space(sizeof(struct video_window) +
556                                     nclips * sizeof(struct video_clip));
557
558         p = nclips ? (struct video_clip __user *)(vw + 1) : NULL;
559
560         if (get_user(n, &up->x) || put_user(n, &vw->x) ||
561             get_user(n, &up->y) || put_user(n, &vw->y) ||
562             get_user(n, &up->width) || put_user(n, &vw->width) ||
563             get_user(n, &up->height) || put_user(n, &vw->height) ||
564             get_user(n, &up->chromakey) || put_user(n, &vw->chromakey) ||
565             get_user(n, &up->flags) || put_user(n, &vw->flags) ||
566             get_user(n, &up->clipcount) || put_user(n, &vw->clipcount) ||
567             get_user(n, &up->clips) || put_user(p, &vw->clips))
568                 return -EFAULT;
569
570         if (nclips) {
571                 struct video_clip32 __user *u = compat_ptr(n);
572                 int i;
573                 if (!u)
574                         return -EINVAL;
575                 for (i = 0; i < nclips; i++, u++, p++) {
576                         s32 v;
577                         if (!access_ok(VERIFY_READ, u, sizeof(struct video_clip32)) ||
578                             !access_ok(VERIFY_WRITE, p, sizeof(struct video_clip32)) ||
579                             get_user(v, &u->x) ||
580                             put_user(v, &p->x) ||
581                             get_user(v, &u->y) ||
582                             put_user(v, &p->y) ||
583                             get_user(v, &u->width) ||
584                             put_user(v, &p->width) ||
585                             get_user(v, &u->height) ||
586                             put_user(v, &p->height) ||
587                             put_user(NULL, &p->next))
588                                 return -EFAULT;
589                 }
590         }
591
592         return native_ioctl(file, VIDIOCSWIN, (unsigned long)vw);
593 }
594
595 static int do_video_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
596 {
597         union {
598                 struct video_tuner vt;
599                 struct video_buffer vb;
600                 struct video_window vw;
601                 struct v4l2_format v2f;
602                 struct v4l2_buffer v2b;
603                 struct v4l2_framebuffer v2fb;
604                 struct v4l2_standard v2s;
605                 struct v4l2_input v2i;
606                 struct v4l2_tuner v2t;
607                 unsigned long vx;
608         } karg;
609         void __user *up = compat_ptr(arg);
610         int compatible_arg = 1;
611         int err = 0;
612         int realcmd = cmd;
613
614         /* First, convert the command. */
615         switch(cmd) {
616         case VIDIOCGTUNER32: cmd = VIDIOCGTUNER; break;
617         case VIDIOCSTUNER32: cmd = VIDIOCSTUNER; break;
618         case VIDIOCGWIN32: cmd = VIDIOCGWIN; break;
619         case VIDIOCGFBUF32: cmd = VIDIOCGFBUF; break;
620         case VIDIOCSFBUF32: cmd = VIDIOCSFBUF; break;
621         case VIDIOCGFREQ32: cmd = VIDIOCGFREQ; break;
622         case VIDIOCSFREQ32: cmd = VIDIOCSFREQ; break;
623         case VIDIOC_G_FMT32: cmd = VIDIOC_G_FMT; break;
624         case VIDIOC_S_FMT32: cmd = VIDIOC_S_FMT; break;
625         case VIDIOC_QUERYBUF32: cmd = VIDIOC_QUERYBUF; break;
626         case VIDIOC_QBUF32: cmd = VIDIOC_QBUF; break;
627         case VIDIOC_DQBUF32: cmd = VIDIOC_DQBUF; break;
628         case VIDIOC_STREAMON32: cmd = VIDIOC_STREAMON; break;
629         case VIDIOC_STREAMOFF32: cmd = VIDIOC_STREAMOFF; break;
630         case VIDIOC_G_FBUF32: cmd = VIDIOC_G_FBUF; break;
631         case VIDIOC_S_FBUF32: cmd = VIDIOC_S_FBUF; break;
632         case VIDIOC_OVERLAY32: cmd = VIDIOC_OVERLAY; break;
633         case VIDIOC_ENUMSTD32: realcmd = VIDIOC_ENUMSTD; break;
634         case VIDIOC_ENUMINPUT32: realcmd = VIDIOC_ENUMINPUT; break;
635         case VIDIOC_S_CTRL32: cmd = VIDIOC_S_CTRL; break;
636         case VIDIOC_G_INPUT32: cmd = VIDIOC_G_INPUT; break;
637         case VIDIOC_S_INPUT32: cmd = VIDIOC_S_INPUT; break;
638         case VIDIOC_TRY_FMT32: cmd = VIDIOC_TRY_FMT; break;
639         };
640
641         switch(cmd) {
642         case VIDIOCSTUNER:
643         case VIDIOCGTUNER:
644                 err = get_video_tuner32(&karg.vt, up);
645                 compatible_arg = 0;
646
647                 break;
648
649         case VIDIOCSFBUF:
650                 err = get_video_buffer32(&karg.vb, up);
651                 compatible_arg = 0;
652                 break;
653
654         case VIDIOCSFREQ:
655         case VIDIOC_S_INPUT:
656         case VIDIOC_OVERLAY:
657         case VIDIOC_STREAMON:
658         case VIDIOC_STREAMOFF:
659                 err = get_user(karg.vx, (u32 __user *)up);
660                 compatible_arg = 0;
661                 break;
662
663         case VIDIOC_S_FBUF:
664                 err = get_v4l2_framebuffer32(&karg.v2fb, up);
665                 compatible_arg = 0;
666                 break;
667
668         case VIDIOC_G_FMT:
669         case VIDIOC_S_FMT:
670         case VIDIOC_TRY_FMT:
671                 err = get_v4l2_format32(&karg.v2f, up);
672                 compatible_arg = 0;
673                 break;
674
675         case VIDIOC_QUERYBUF:
676         case VIDIOC_QBUF:
677         case VIDIOC_DQBUF:
678                 err = get_v4l2_buffer32(&karg.v2b, up);
679                 compatible_arg = 0;
680                 break;
681
682         case VIDIOC_ENUMSTD:
683                 err = get_v4l2_standard(&karg.v2s, up);
684                 compatible_arg = 0;
685                 break;
686
687         case VIDIOC_ENUMSTD32:
688                 err = get_v4l2_standard32(&karg.v2s, up);
689                 compatible_arg = 0;
690                 break;
691
692         case VIDIOC_ENUMINPUT:
693                 err = get_v4l2_input(&karg.v2i, up);
694                 compatible_arg = 0;
695                 break;
696
697         case VIDIOC_ENUMINPUT32:
698                 err = get_v4l2_input32(&karg.v2i, up);
699                 compatible_arg = 0;
700                 break;
701
702         case VIDIOC_G_TUNER:
703         case VIDIOC_S_TUNER:
704                 err = get_v4l2_tuner(&karg.v2t, up);
705                 compatible_arg = 0;
706                 break;
707
708         case VIDIOCGWIN:
709         case VIDIOCGFBUF:
710         case VIDIOCGFREQ:
711         case VIDIOC_G_FBUF:
712         case VIDIOC_G_INPUT:
713                 compatible_arg = 0;
714         };
715
716         if(err)
717                 goto out;
718
719         if(compatible_arg)
720                 err = native_ioctl(file, realcmd, (unsigned long)up);
721         else {
722                 mm_segment_t old_fs = get_fs();
723
724                 set_fs(KERNEL_DS);
725                 err = native_ioctl(file, realcmd, (unsigned long)&karg);
726                 set_fs(old_fs);
727         }
728         if(err == 0) {
729                 switch(cmd) {
730                 case VIDIOCGTUNER:
731                         err = put_video_tuner32(&karg.vt, up);
732                         break;
733
734                 case VIDIOCGWIN:
735                         err = put_video_window32(&karg.vw, up);
736                         break;
737
738                 case VIDIOCGFBUF:
739                         err = put_video_buffer32(&karg.vb, up);
740                         break;
741
742                 case VIDIOC_G_FBUF:
743                         err = put_v4l2_framebuffer32(&karg.v2fb, up);
744                         break;
745
746                 case VIDIOC_G_FMT:
747                 case VIDIOC_S_FMT:
748                 case VIDIOC_TRY_FMT:
749                         err = put_v4l2_format32(&karg.v2f, up);
750                         break;
751
752                 case VIDIOC_QUERYBUF:
753                 case VIDIOC_QBUF:
754                 case VIDIOC_DQBUF:
755                         err = put_v4l2_buffer32(&karg.v2b, up);
756                         break;
757
758                 case VIDIOC_ENUMSTD:
759                         err = put_v4l2_standard(&karg.v2s, up);
760                         break;
761
762                 case VIDIOC_ENUMSTD32:
763                         err = put_v4l2_standard32(&karg.v2s, up);
764                         break;
765
766                 case VIDIOC_G_TUNER:
767                 case VIDIOC_S_TUNER:
768                         err = put_v4l2_tuner(&karg.v2t, up);
769                         break;
770
771                 case VIDIOC_ENUMINPUT:
772                         err = put_v4l2_input(&karg.v2i, up);
773                         break;
774
775                 case VIDIOC_ENUMINPUT32:
776                         err = put_v4l2_input32(&karg.v2i, up);
777                         break;
778
779                 case VIDIOCGFREQ:
780                 case VIDIOC_G_INPUT:
781                         err = put_user(((u32)karg.vx), (u32 __user *)up);
782                         break;
783                 };
784         }
785 out:
786         return err;
787 }
788
789 long v4l_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
790 {
791         int ret = -ENOIOCTLCMD;
792
793         if (!file->f_op->ioctl)
794                 return ret;
795
796         switch (cmd) {
797         case VIDIOCSWIN32:
798                 ret = do_set_window(file, cmd, arg);
799                 break;
800         case VIDIOCGTUNER32:
801         case VIDIOCSTUNER32:
802         case VIDIOCGWIN32:
803         case VIDIOCGFBUF32:
804         case VIDIOCSFBUF32:
805         case VIDIOCGFREQ32:
806         case VIDIOCSFREQ32:
807         case VIDIOC_QUERYCAP:
808         case VIDIOC_ENUM_FMT:
809         case VIDIOC_G_FMT32:
810         case VIDIOC_S_FMT32:
811         case VIDIOC_REQBUFS:
812         case VIDIOC_QUERYBUF32:
813         case VIDIOC_G_FBUF32:
814         case VIDIOC_S_FBUF32:
815         case VIDIOC_OVERLAY32:
816         case VIDIOC_QBUF32:
817         case VIDIOC_DQBUF32:
818         case VIDIOC_STREAMON32:
819         case VIDIOC_STREAMOFF32:
820         case VIDIOC_G_PARM:
821         case VIDIOC_G_STD:
822         case VIDIOC_S_STD:
823         case VIDIOC_G_TUNER:
824         case VIDIOC_S_TUNER:
825         case VIDIOC_ENUMSTD:
826         case VIDIOC_ENUMSTD32:
827         case VIDIOC_ENUMINPUT:
828         case VIDIOC_ENUMINPUT32:
829         case VIDIOC_G_CTRL:
830         case VIDIOC_S_CTRL32:
831         case VIDIOC_QUERYCTRL:
832         case VIDIOC_G_INPUT32:
833         case VIDIOC_S_INPUT32:
834         case VIDIOC_TRY_FMT32:
835                 ret = do_video_ioctl(file, cmd, arg);
836                 break;
837
838         /* Little v, the video4linux ioctls (conflict?) */
839         case VIDIOCGCAP:
840         case VIDIOCGCHAN:
841         case VIDIOCSCHAN:
842         case VIDIOCGPICT:
843         case VIDIOCSPICT:
844         case VIDIOCCAPTURE:
845         case VIDIOCKEY:
846         case VIDIOCGAUDIO:
847         case VIDIOCSAUDIO:
848         case VIDIOCSYNC:
849         case VIDIOCMCAPTURE:
850         case VIDIOCGMBUF:
851         case VIDIOCGUNIT:
852         case VIDIOCGCAPTURE:
853         case VIDIOCSCAPTURE:
854
855         /* BTTV specific... */
856         case _IOW('v',  BASE_VIDIOCPRIVATE+0, char [256]):
857         case _IOR('v',  BASE_VIDIOCPRIVATE+1, char [256]):
858         case _IOR('v' , BASE_VIDIOCPRIVATE+2, unsigned int):
859         case _IOW('v' , BASE_VIDIOCPRIVATE+3, char [16]): /* struct bttv_pll_info */
860         case _IOR('v' , BASE_VIDIOCPRIVATE+4, int):
861         case _IOR('v' , BASE_VIDIOCPRIVATE+5, int):
862         case _IOR('v' , BASE_VIDIOCPRIVATE+6, int):
863         case _IOR('v' , BASE_VIDIOCPRIVATE+7, int):
864                 ret = native_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
865                 break;
866         default:
867                 v4l_print_ioctl("compat_ioctl32", cmd);
868         }
869         return ret;
870 }
871 #else
872 long v4l_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
873 {
874         return -ENOIOCTLCMD;
875 }
876 #endif
877 EXPORT_SYMBOL_GPL(v4l_compat_ioctl32);
878
879 MODULE_LICENSE("GPL");