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 #define VIDIOCGTUNER32          _IOWR('v',4, struct video_tuner32)
 494 #define VIDIOCSTUNER32          _IOW('v',5, struct video_tuner32)
 495 #define VIDIOCGWIN32            _IOR('v',9, struct video_window32)
 496 #define VIDIOCSWIN32            _IOW('v',10, struct video_window32)
 497 #define VIDIOCGFBUF32           _IOR('v',11, struct video_buffer32)
 498 #define VIDIOCSFBUF32           _IOW('v',12, struct video_buffer32)
 499 #define VIDIOCGFREQ32           _IOR('v',14, u32)
 500 #define VIDIOCSFREQ32           _IOW('v',15, u32)
 501
 502 /* VIDIOC_ENUMINPUT32 is VIDIOC_ENUMINPUT minus 4 bytes of padding alignement */
 503 #define VIDIOC_ENUMINPUT32      VIDIOC_ENUMINPUT - _IOC(0, 0, 0, 4)
 504 #define VIDIOC_G_FMT32          _IOWR ('V',  4, struct v4l2_format32)
 505 #define VIDIOC_S_FMT32          _IOWR ('V',  5, struct v4l2_format32)
 506 #define VIDIOC_QUERYBUF32       _IOWR ('V',  9, struct v4l2_buffer32)
 507 #define VIDIOC_G_FBUF32         _IOR  ('V', 10, struct v4l2_framebuffer32)
 508 #define VIDIOC_S_FBUF32         _IOW  ('V', 11, struct v4l2_framebuffer32)
 509 /* VIDIOC_OVERLAY is now _IOW, but was _IOWR */
 510 #define VIDIOC_OVERLAY32        _IOWR ('V', 14, compat_int_t)
 511 #define VIDIOC_QBUF32           _IOWR ('V', 15, struct v4l2_buffer32)
 512 #define VIDIOC_DQBUF32          _IOWR ('V', 17, struct v4l2_buffer32)
 513 #define VIDIOC_STREAMON32       _IOW  ('V', 18, compat_int_t)
 514 #define VIDIOC_STREAMOFF32      _IOW  ('V', 19, compat_int_t)
 515 #define VIDIOC_ENUMSTD32        _IOWR ('V', 25, struct v4l2_standard32)
 516 /* VIDIOC_S_CTRL is now _IOWR, but was _IOW */
 517 #define VIDIOC_S_CTRL32         _IOW  ('V', 28, struct v4l2_control)
 518 #define VIDIOC_G_INPUT32        _IOR  ('V', 38, compat_int_t)
 519 #define VIDIOC_S_INPUT32        _IOWR ('V', 39, compat_int_t)
 520 #define VIDIOC_TRY_FMT32        _IOWR ('V', 64, struct v4l2_format32)
 521
 522 enum {
 523         MaxClips = (~0U-sizeof(struct video_window))/sizeof(struct video_clip)
 524 };
 525
 526 static int do_set_window(struct file *file, unsigned int cmd, unsigned long arg)
 527 {
 528         struct video_window32 __user *up = compat_ptr(arg);
 529         struct video_window __user *vw;
 530         struct video_clip __user *p;
 531         int nclips;
 532         u32 n;
 533
 534         if (!access_ok(VERIFY_READ, up, sizeof(struct video_window32)))
 535                 return -EFAULT;
 536
 537         if (get_user(nclips, &up->clipcount))
 538                 return -EFAULT;
 539
 540         /* Peculiar interface... */
 541         if (nclips < 0)
 542                 nclips = VIDEO_CLIPMAP_SIZE;
 543
 544         if (nclips > MaxClips)
 545                 return -ENOMEM;
 546
 547         vw = compat_alloc_user_space(sizeof(struct video_window) +
 548                                     nclips * sizeof(struct video_clip));
 549
 550         p = nclips ? (struct video_clip __user *)(vw + 1) : NULL;
 551
 552         if (get_user(n, &up->x) || put_user(n, &vw->x) ||
 553             get_user(n, &up->y) || put_user(n, &vw->y) ||
 554             get_user(n, &up->width) || put_user(n, &vw->width) ||
 555             get_user(n, &up->height) || put_user(n, &vw->height) ||
 556             get_user(n, &up->chromakey) || put_user(n, &vw->chromakey) ||
 557             get_user(n, &up->flags) || put_user(n, &vw->flags) ||
 558             get_user(n, &up->clipcount) || put_user(n, &vw->clipcount) ||
 559             get_user(n, &up->clips) || put_user(p, &vw->clips))
 560                 return -EFAULT;
 561
 562         if (nclips) {
 563                 struct video_clip32 __user *u = compat_ptr(n);
 564                 int i;
 565                 if (!u)
 566                         return -EINVAL;
 567                 for (i = 0; i < nclips; i++, u++, p++) {
 568                         s32 v;
 569                         if (!access_ok(VERIFY_READ, u, sizeof(struct video_clip32)) ||
 570                             !access_ok(VERIFY_WRITE, p, sizeof(struct video_clip32)) ||
 571                             get_user(v, &u->x) ||
 572                             put_user(v, &p->x) ||
 573                             get_user(v, &u->y) ||
 574                             put_user(v, &p->y) ||
 575                             get_user(v, &u->width) ||
 576                             put_user(v, &p->width) ||
 577                             get_user(v, &u->height) ||
 578                             put_user(v, &p->height) ||
 579                             put_user(NULL, &p->next))
 580                                 return -EFAULT;
 581                 }
 582         }
 583
 584         return native_ioctl(file, VIDIOCSWIN, (unsigned long)vw);
 585 }
 586
 587 static int do_video_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 588 {
 589         union {
 590                 struct video_tuner vt;
 591                 struct video_buffer vb;
 592                 struct video_window vw;
 593                 struct v4l2_format v2f;
 594                 struct v4l2_buffer v2b;
 595                 struct v4l2_framebuffer v2fb;
 596                 struct v4l2_standard v2s;
 597                 struct v4l2_input v2i;
 598                 struct v4l2_tuner v2t;
 599                 unsigned long vx;
 600         } karg;
 601         void __user *up = compat_ptr(arg);
 602         int compatible_arg = 1;
 603         int err = 0;
 604         int realcmd = cmd;
 605
 606         /* First, convert the command. */
 607         switch(cmd) {
 608         case VIDIOCGTUNER32: cmd = VIDIOCGTUNER; break;
 609         case VIDIOCSTUNER32: cmd = VIDIOCSTUNER; break;
 610         case VIDIOCGWIN32: cmd = VIDIOCGWIN; break;
 611         case VIDIOCGFBUF32: cmd = VIDIOCGFBUF; break;
 612         case VIDIOCSFBUF32: cmd = VIDIOCSFBUF; break;
 613         case VIDIOCGFREQ32: cmd = VIDIOCGFREQ; break;
 614         case VIDIOCSFREQ32: cmd = VIDIOCSFREQ; break;
 615         case VIDIOC_G_FMT32: cmd = VIDIOC_G_FMT; break;
 616         case VIDIOC_S_FMT32: cmd = VIDIOC_S_FMT; break;
 617         case VIDIOC_QUERYBUF32: cmd = VIDIOC_QUERYBUF; break;
 618         case VIDIOC_QBUF32: cmd = VIDIOC_QBUF; break;
 619         case VIDIOC_DQBUF32: cmd = VIDIOC_DQBUF; break;
 620         case VIDIOC_STREAMON32: cmd = VIDIOC_STREAMON; break;
 621         case VIDIOC_STREAMOFF32: cmd = VIDIOC_STREAMOFF; break;
 622         case VIDIOC_G_FBUF32: cmd = VIDIOC_G_FBUF; break;
 623         case VIDIOC_S_FBUF32: cmd = VIDIOC_S_FBUF; break;
 624         case VIDIOC_OVERLAY32: cmd = VIDIOC_OVERLAY; break;
 625         case VIDIOC_ENUMSTD32: realcmd = VIDIOC_ENUMSTD; break;
 626         case VIDIOC_ENUMINPUT32: realcmd = VIDIOC_ENUMINPUT; break;
 627         case VIDIOC_S_CTRL32: cmd = VIDIOC_S_CTRL; break;
 628         case VIDIOC_G_INPUT32: cmd = VIDIOC_G_INPUT; break;
 629         case VIDIOC_S_INPUT32: cmd = VIDIOC_S_INPUT; break;
 630         case VIDIOC_TRY_FMT32: cmd = VIDIOC_TRY_FMT; break;
 631         };
 632
 633         switch(cmd) {
 634         case VIDIOCSTUNER:
 635         case VIDIOCGTUNER:
 636                 err = get_video_tuner32(&karg.vt, up);
 637                 compatible_arg = 0;
 638
 639                 break;
 640
 641         case VIDIOCSFBUF:
 642                 err = get_video_buffer32(&karg.vb, up);
 643                 compatible_arg = 0;
 644                 break;
 645
 646         case VIDIOCSFREQ:
 647         case VIDIOC_S_INPUT:
 648         case VIDIOC_OVERLAY:
 649         case VIDIOC_STREAMON:
 650         case VIDIOC_STREAMOFF:
 651                 err = get_user(karg.vx, (u32 __user *)up);
 652                 compatible_arg = 0;
 653                 break;
 654
 655         case VIDIOC_S_FBUF:
 656                 err = get_v4l2_framebuffer32(&karg.v2fb, up);
 657                 compatible_arg = 0;
 658                 break;
 659
 660         case VIDIOC_G_FMT:
 661         case VIDIOC_S_FMT:
 662         case VIDIOC_TRY_FMT:
 663                 err = get_v4l2_format32(&karg.v2f, up);
 664                 compatible_arg = 0;
 665                 break;
 666
 667         case VIDIOC_QUERYBUF:
 668         case VIDIOC_QBUF:
 669         case VIDIOC_DQBUF:
 670                 err = get_v4l2_buffer32(&karg.v2b, up);
 671                 compatible_arg = 0;
 672                 break;
 673
 674         case VIDIOC_ENUMSTD:
 675                 err = get_v4l2_standard(&karg.v2s, up);
 676                 compatible_arg = 0;
 677                 break;
 678
 679         case VIDIOC_ENUMSTD32:
 680                 err = get_v4l2_standard32(&karg.v2s, up);
 681                 compatible_arg = 0;
 682                 break;
 683
 684         case VIDIOC_ENUMINPUT:
 685                 err = get_v4l2_input(&karg.v2i, up);
 686                 compatible_arg = 0;
 687                 break;
 688
 689         case VIDIOC_ENUMINPUT32:
 690                 err = get_v4l2_input32(&karg.v2i, up);
 691                 compatible_arg = 0;
 692                 break;
 693
 694         case VIDIOC_G_TUNER:
 695         case VIDIOC_S_TUNER:
 696                 err = get_v4l2_tuner(&karg.v2t, up);
 697                 compatible_arg = 0;
 698                 break;
 699
 700         case VIDIOCGWIN:
 701         case VIDIOCGFBUF:
 702         case VIDIOCGFREQ:
 703         case VIDIOC_G_FBUF:
 704         case VIDIOC_G_INPUT:
 705                 compatible_arg = 0;
 706         };
 707
 708         if(err)
 709                 goto out;
 710
 711         if(compatible_arg)
 712                 err = native_ioctl(file, realcmd, (unsigned long)up);
 713         else {
 714                 mm_segment_t old_fs = get_fs();
 715
 716                 set_fs(KERNEL_DS);
 717                 err = native_ioctl(file, realcmd, (unsigned long)&karg);
 718                 set_fs(old_fs);
 719         }
 720         if(err == 0) {
 721                 switch(cmd) {
 722                 case VIDIOCGTUNER:
 723                         err = put_video_tuner32(&karg.vt, up);
 724                         break;
 725
 726                 case VIDIOCGWIN:
 727                         err = put_video_window32(&karg.vw, up);
 728                         break;
 729
 730                 case VIDIOCGFBUF:
 731                         err = put_video_buffer32(&karg.vb, up);
 732                         break;
 733
 734                 case VIDIOC_G_FBUF:
 735                         err = put_v4l2_framebuffer32(&karg.v2fb, up);
 736                         break;
 737
 738                 case VIDIOC_G_FMT:
 739                 case VIDIOC_S_FMT:
 740                 case VIDIOC_TRY_FMT:
 741                         err = put_v4l2_format32(&karg.v2f, up);
 742                         break;
 743
 744                 case VIDIOC_QUERYBUF:
 745                 case VIDIOC_QBUF:
 746                 case VIDIOC_DQBUF:
 747                         err = put_v4l2_buffer32(&karg.v2b, up);
 748                         break;
 749
 750                 case VIDIOC_ENUMSTD:
 751                         err = put_v4l2_standard(&karg.v2s, up);
 752                         break;
 753
 754                 case VIDIOC_ENUMSTD32:
 755                         err = put_v4l2_standard32(&karg.v2s, up);
 756                         break;
 757
 758                 case VIDIOC_G_TUNER:
 759                 case VIDIOC_S_TUNER:
 760                         err = put_v4l2_tuner(&karg.v2t, up);
 761                         break;
 762
 763                 case VIDIOC_ENUMINPUT:
 764                         err = put_v4l2_input(&karg.v2i, up);
 765                         break;
 766
 767                 case VIDIOC_ENUMINPUT32:
 768                         err = put_v4l2_input32(&karg.v2i, up);
 769                         break;
 770
 771                 case VIDIOCGFREQ:
 772                 case VIDIOC_G_INPUT:
 773                         err = put_user(((u32)karg.vx), (u32 __user *)up);
 774                         break;
 775                 };
 776         }
 777 out:
 778         return err;
 779 }
 780
 781 long v4l_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
 782 {
 783         int ret = -ENOIOCTLCMD;
 784
 785         if (!file->f_op->ioctl)
 786                 return ret;
 787
 788         switch (cmd) {
 789         case VIDIOCSWIN32:
 790                 ret = do_set_window(file, cmd, arg);
 791                 break;
 792         case VIDIOCGTUNER32:
 793         case VIDIOCSTUNER32:
 794         case VIDIOCGWIN32:
 795         case VIDIOCGFBUF32:
 796         case VIDIOCSFBUF32:
 797         case VIDIOCGFREQ32:
 798         case VIDIOCSFREQ32:
 799         case VIDIOC_QUERYCAP:
 800         case VIDIOC_ENUM_FMT:
 801         case VIDIOC_G_FMT32:
 802         case VIDIOC_S_FMT32:
 803         case VIDIOC_REQBUFS:
 804         case VIDIOC_QUERYBUF32:
 805         case VIDIOC_G_FBUF32:
 806         case VIDIOC_S_FBUF32:
 807         case VIDIOC_OVERLAY32:
 808         case VIDIOC_QBUF32:
 809         case VIDIOC_DQBUF32:
 810         case VIDIOC_STREAMON32:
 811         case VIDIOC_STREAMOFF32:
 812         case VIDIOC_G_PARM:
 813         case VIDIOC_G_STD:
 814         case VIDIOC_S_STD:
 815         case VIDIOC_G_TUNER:
 816         case VIDIOC_S_TUNER:
 817         case VIDIOC_ENUMSTD:
 818         case VIDIOC_ENUMSTD32:
 819         case VIDIOC_ENUMINPUT:
 820         case VIDIOC_ENUMINPUT32:
 821         case VIDIOC_G_CTRL:
 822         case VIDIOC_S_CTRL32:
 823         case VIDIOC_QUERYCTRL:
 824         case VIDIOC_G_INPUT32:
 825         case VIDIOC_S_INPUT32:
 826         case VIDIOC_TRY_FMT32:
 827                 ret = do_video_ioctl(file, cmd, arg);
 828                 break;
 829
 830         /* Little v, the video4linux ioctls (conflict?) */
 831         case VIDIOCGCAP:
 832         case VIDIOCGCHAN:
 833         case VIDIOCSCHAN:
 834         case VIDIOCGPICT:
 835         case VIDIOCSPICT:
 836         case VIDIOCCAPTURE:
 837         case VIDIOCKEY:
 838         case VIDIOCGAUDIO:
 839         case VIDIOCSAUDIO:
 840         case VIDIOCSYNC:
 841         case VIDIOCMCAPTURE:
 842         case VIDIOCGMBUF:
 843         case VIDIOCGUNIT:
 844         case VIDIOCGCAPTURE:
 845         case VIDIOCSCAPTURE:
 846
 847         /* BTTV specific... */
 848         case _IOW('v',  BASE_VIDIOCPRIVATE+0, char [256]):
 849         case _IOR('v',  BASE_VIDIOCPRIVATE+1, char [256]):
 850         case _IOR('v' , BASE_VIDIOCPRIVATE+2, unsigned int):
 851         case _IOW('v' , BASE_VIDIOCPRIVATE+3, char [16]): /* struct bttv_pll_info */
 852         case _IOR('v' , BASE_VIDIOCPRIVATE+4, int):
 853         case _IOR('v' , BASE_VIDIOCPRIVATE+5, int):
 854         case _IOR('v' , BASE_VIDIOCPRIVATE+6, int):
 855         case _IOR('v' , BASE_VIDIOCPRIVATE+7, int):
 856                 ret = native_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
 857                 break;
 858         default:
 859                 v4l_print_ioctl("compat_ioctl32", cmd);
 860         }
 861         return ret;
 862 }
 863 #else
 864 long v4l_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
 865 {
 866         return -ENOIOCTLCMD;
 867 }
 868 #endif
 869 EXPORT_SYMBOL_GPL(v4l_compat_ioctl32);
 870
 871 MODULE_LICENSE("GPL");