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