drivers/media/video/v4l2-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@ucw.cz)
   9  * Copyright (C) 2005       Philippe De Muyter (phdm@macqel.be)
  10  * Copyright (C) 2008       Hans Verkuil <hverkuil@xs4all.nl>
  11  *
  12  * These routines maintain argument size conversion between 32bit and 64bit
  13  * ioctls.
  14  */
  15
  16 #include <linux/compat.h>
  17 #define __OLD_VIDIOC_ /* To allow fixing old calls*/
  18 #include <linux/videodev.h>
  19 #include <linux/videodev2.h>
  20 #include <linux/module.h>
  21 #include <media/v4l2-ioctl.h>
  22
  23 #ifdef CONFIG_COMPAT
  24
  25 #ifdef CONFIG_VIDEO_V4L1_COMPAT
  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;        /* It's 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 get_video_window32(struct video_window *kp, struct video_window32 __user *up)
 113 {
 114         struct video_clip __user *uclips;
 115         struct video_clip __user *kclips;
 116         compat_caddr_t p;
 117         int nclips;
 118
 119         if (!access_ok(VERIFY_READ, up, sizeof(struct video_window32)))
 120                 return -EFAULT;
 121
 122         if (get_user(nclips, &up->clipcount))
 123                 return -EFAULT;
 124
 125         if (!access_ok(VERIFY_READ, up, sizeof(struct video_window32)) ||
 126             get_user(kp->x, &up->x) ||
 127             get_user(kp->y, &up->y) ||
 128             get_user(kp->width, &up->width) ||
 129             get_user(kp->height, &up->height) ||
 130             get_user(kp->chromakey, &up->chromakey) ||
 131             get_user(kp->flags, &up->flags) ||
 132             get_user(kp->clipcount, &up->clipcount))
 133                 return -EFAULT;
 134
 135         nclips = kp->clipcount;
 136         kp->clips = NULL;
 137
 138         if (nclips == 0)
 139                 return 0;
 140         if (get_user(p, &up->clips))
 141                 return -EFAULT;
 142         uclips = compat_ptr(p);
 143
 144         /* If nclips < 0, then it is a clipping bitmap of size
 145            VIDEO_CLIPMAP_SIZE */
 146         if (nclips < 0) {
 147                 if (!access_ok(VERIFY_READ, uclips, VIDEO_CLIPMAP_SIZE))
 148                         return -EFAULT;
 149                 kp->clips = compat_alloc_user_space(VIDEO_CLIPMAP_SIZE);
 150                 if (copy_in_user(kp->clips, uclips, VIDEO_CLIPMAP_SIZE))
 151                         return -EFAULT;
 152                 return 0;
 153         }
 154
 155         /* Otherwise it is an array of video_clip structs. */
 156         if (!access_ok(VERIFY_READ, uclips, nclips * sizeof(struct video_clip)))
 157                 return -EFAULT;
 158
 159         kp->clips = compat_alloc_user_space(nclips * sizeof(struct video_clip));
 160         kclips = kp->clips;
 161         while (nclips--) {
 162                 int err;
 163
 164                 err = copy_in_user(&kclips->x, &uclips->x, sizeof(kclips->x));
 165                 err |= copy_in_user(&kclips->y, &uclips->y, sizeof(kclips->y));
 166                 err |= copy_in_user(&kclips->width, &uclips->width, sizeof(kclips->width));
 167                 err |= copy_in_user(&kclips->height, &uclips->height, sizeof(kclips->height));
 168                 kclips->next = NULL;
 169                 if (err)
 170                         return -EFAULT;
 171                 kclips++;
 172                 uclips++;
 173         }
 174         return 0;
 175 }
 176
 177 /* You get back everything except the clips... */
 178 static int put_video_window32(struct video_window *kp, struct video_window32 __user *up)
 179 {
 180         if (!access_ok(VERIFY_WRITE, up, sizeof(struct video_window32)) ||
 181                 put_user(kp->x, &up->x) ||
 182                 put_user(kp->y, &up->y) ||
 183                 put_user(kp->width, &up->width) ||
 184                 put_user(kp->height, &up->height) ||
 185                 put_user(kp->chromakey, &up->chromakey) ||
 186                 put_user(kp->flags, &up->flags) ||
 187                 put_user(kp->clipcount, &up->clipcount))
 188                         return -EFAULT;
 189         return 0;
 190 }
 191
 192 struct video_code32 {
 193         char            loadwhat[16];   /* name or tag of file being passed */
 194         compat_int_t    datasize;
 195         compat_uptr_t   data;
 196 };
 197
 198 static struct video_code __user *get_microcode32(struct video_code32 *kp)
 199 {
 200         struct video_code __user *up;
 201
 202         up = compat_alloc_user_space(sizeof(*up));
 203
 204         /*
 205          * NOTE! We don't actually care if these fail. If the
 206          * user address is invalid, the native ioctl will do
 207          * the error handling for us
 208          */
 209         (void) copy_to_user(up->loadwhat, kp->loadwhat, sizeof(up->loadwhat));
 210         (void) put_user(kp->datasize, &up->datasize);
 211         (void) put_user(compat_ptr(kp->data), &up->data);
 212         return up;
 213 }
 214
 215 #define VIDIOCGTUNER32          _IOWR('v', 4, struct video_tuner32)
 216 #define VIDIOCSTUNER32          _IOW('v', 5, struct video_tuner32)
 217 #define VIDIOCGWIN32            _IOR('v', 9, struct video_window32)
 218 #define VIDIOCSWIN32            _IOW('v', 10, struct video_window32)
 219 #define VIDIOCGFBUF32           _IOR('v', 11, struct video_buffer32)
 220 #define VIDIOCSFBUF32           _IOW('v', 12, struct video_buffer32)
 221 #define VIDIOCGFREQ32           _IOR('v', 14, u32)
 222 #define VIDIOCSFREQ32           _IOW('v', 15, u32)
 223 #define VIDIOCSMICROCODE32      _IOW('v', 27, struct video_code32)
 224
 225 #define VIDIOCCAPTURE32         _IOW('v', 8, s32)
 226 #define VIDIOCSYNC32            _IOW('v', 18, s32)
 227 #define VIDIOCSWRITEMODE32      _IOW('v', 25, s32)
 228
 229 #endif
 230
 231 static long native_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 232 {
 233         long ret = -ENOIOCTLCMD;
 234
 235         if (file->f_op->unlocked_ioctl)
 236                 ret = file->f_op->unlocked_ioctl(file, cmd, arg);
 237
 238         return ret;
 239 }
 240
 241
 242 struct v4l2_clip32 {
 243         struct v4l2_rect        c;
 244         compat_caddr_t          next;
 245 };
 246
 247 struct v4l2_window32 {
 248         struct v4l2_rect        w;
 249         enum v4l2_field         field;
 250         __u32                   chromakey;
 251         compat_caddr_t          clips; /* actually struct v4l2_clip32 * */
 252         __u32                   clipcount;
 253         compat_caddr_t          bitmap;
 254 };
 255
 256 static int get_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user *up)
 257 {
 258         if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_window32)) ||
 259                 copy_from_user(&kp->w, &up->w, sizeof(up->w)) ||
 260                 get_user(kp->field, &up->field) ||
 261                 get_user(kp->chromakey, &up->chromakey) ||
 262                 get_user(kp->clipcount, &up->clipcount))
 263                         return -EFAULT;
 264         if (kp->clipcount > 2048)
 265                 return -EINVAL;
 266         if (kp->clipcount) {
 267                 struct v4l2_clip32 __user *uclips;
 268                 struct v4l2_clip __user *kclips;
 269                 int n = kp->clipcount;
 270                 compat_caddr_t p;
 271
 272                 if (get_user(p, &up->clips))
 273                         return -EFAULT;
 274                 uclips = compat_ptr(p);
 275                 kclips = compat_alloc_user_space(n * sizeof(struct v4l2_clip));
 276                 kp->clips = kclips;
 277                 while (--n >= 0) {
 278                         if (copy_in_user(&kclips->c, &uclips->c, sizeof(uclips->c)))
 279                                 return -EFAULT;
 280                         if (put_user(n ? kclips + 1 : NULL, &kclips->next))
 281                                 return -EFAULT;
 282                         uclips += 1;
 283                         kclips += 1;
 284                 }
 285         } else
 286                 kp->clips = NULL;
 287         return 0;
 288 }
 289
 290 static int put_v4l2_window32(struct v4l2_window *kp, struct v4l2_window32 __user *up)
 291 {
 292         if (copy_to_user(&up->w, &kp->w, sizeof(kp->w)) ||
 293                 put_user(kp->field, &up->field) ||
 294                 put_user(kp->chromakey, &up->chromakey) ||
 295                 put_user(kp->clipcount, &up->clipcount))
 296                         return -EFAULT;
 297         return 0;
 298 }
 299
 300 static inline int get_v4l2_pix_format(struct v4l2_pix_format *kp, struct v4l2_pix_format __user *up)
 301 {
 302         if (copy_from_user(kp, up, sizeof(struct v4l2_pix_format)))
 303                 return -EFAULT;
 304         return 0;
 305 }
 306
 307 static inline int put_v4l2_pix_format(struct v4l2_pix_format *kp, struct v4l2_pix_format __user *up)
 308 {
 309         if (copy_to_user(up, kp, sizeof(struct v4l2_pix_format)))
 310                 return -EFAULT;
 311         return 0;
 312 }
 313
 314 static inline int get_v4l2_vbi_format(struct v4l2_vbi_format *kp, struct v4l2_vbi_format __user *up)
 315 {
 316         if (copy_from_user(kp, up, sizeof(struct v4l2_vbi_format)))
 317                 return -EFAULT;
 318         return 0;
 319 }
 320
 321 static inline int put_v4l2_vbi_format(struct v4l2_vbi_format *kp, struct v4l2_vbi_format __user *up)
 322 {
 323         if (copy_to_user(up, kp, sizeof(struct v4l2_vbi_format)))
 324                 return -EFAULT;
 325         return 0;
 326 }
 327
 328 static inline int get_v4l2_sliced_vbi_format(struct v4l2_sliced_vbi_format *kp, struct v4l2_sliced_vbi_format __user *up)
 329 {
 330         if (copy_from_user(kp, up, sizeof(struct v4l2_sliced_vbi_format)))
 331                 return -EFAULT;
 332         return 0;
 333 }
 334
 335 static inline int put_v4l2_sliced_vbi_format(struct v4l2_sliced_vbi_format *kp, struct v4l2_sliced_vbi_format __user *up)
 336 {
 337         if (copy_to_user(up, kp, sizeof(struct v4l2_sliced_vbi_format)))
 338                 return -EFAULT;
 339         return 0;
 340 }
 341
 342 struct v4l2_format32 {
 343         enum v4l2_buf_type type;
 344         union {
 345                 struct v4l2_pix_format  pix;
 346                 struct v4l2_window32    win;
 347                 struct v4l2_vbi_format  vbi;
 348                 struct v4l2_sliced_vbi_format   sliced;
 349                 __u8    raw_data[200];        /* user-defined */
 350         } fmt;
 351 };
 352
 353 static int get_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user *up)
 354 {
 355         if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_format32)) ||
 356                         get_user(kp->type, &up->type))
 357                         return -EFAULT;
 358         switch (kp->type) {
 359         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 360         case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 361                 return get_v4l2_pix_format(&kp->fmt.pix, &up->fmt.pix);
 362         case V4L2_BUF_TYPE_VIDEO_OVERLAY:
 363         case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
 364                 return get_v4l2_window32(&kp->fmt.win, &up->fmt.win);
 365         case V4L2_BUF_TYPE_VBI_CAPTURE:
 366         case V4L2_BUF_TYPE_VBI_OUTPUT:
 367                 return get_v4l2_vbi_format(&kp->fmt.vbi, &up->fmt.vbi);
 368         case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
 369         case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
 370                 return get_v4l2_sliced_vbi_format(&kp->fmt.sliced, &up->fmt.sliced);
 371         case V4L2_BUF_TYPE_PRIVATE:
 372                 if (copy_from_user(kp, up, sizeof(kp->fmt.raw_data)))
 373                         return -EFAULT;
 374                 return 0;
 375         case 0:
 376                 return -EINVAL;
 377         default:
 378                 printk(KERN_INFO "compat_ioctl32: unexpected VIDIOC_FMT type %d\n",
 379                                                                 kp->type);
 380                 return -EINVAL;
 381         }
 382 }
 383
 384 static int put_v4l2_format32(struct v4l2_format *kp, struct v4l2_format32 __user *up)
 385 {
 386         if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_format32)) ||
 387                 put_user(kp->type, &up->type))
 388                 return -EFAULT;
 389         switch (kp->type) {
 390         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 391         case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 392                 return put_v4l2_pix_format(&kp->fmt.pix, &up->fmt.pix);
 393         case V4L2_BUF_TYPE_VIDEO_OVERLAY:
 394         case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
 395                 return put_v4l2_window32(&kp->fmt.win, &up->fmt.win);
 396         case V4L2_BUF_TYPE_VBI_CAPTURE:
 397         case V4L2_BUF_TYPE_VBI_OUTPUT:
 398                 return put_v4l2_vbi_format(&kp->fmt.vbi, &up->fmt.vbi);
 399         case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
 400         case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
 401                 return put_v4l2_sliced_vbi_format(&kp->fmt.sliced, &up->fmt.sliced);
 402         case V4L2_BUF_TYPE_PRIVATE:
 403                 if (copy_to_user(up, kp, sizeof(up->fmt.raw_data)))
 404                         return -EFAULT;
 405                 return 0;
 406         case 0:
 407                 return -EINVAL;
 408         default:
 409                 printk(KERN_INFO "compat_ioctl32: unexpected VIDIOC_FMT type %d\n",
 410                                                                 kp->type);
 411                 return -EINVAL;
 412         }
 413 }
 414
 415 struct v4l2_standard32 {
 416         __u32                index;
 417         __u32                id[2]; /* __u64 would get the alignment wrong */
 418         __u8                 name[24];
 419         struct v4l2_fract    frameperiod; /* Frames, not fields */
 420         __u32                framelines;
 421         __u32                reserved[4];
 422 };
 423
 424 static int get_v4l2_standard32(struct v4l2_standard *kp, struct v4l2_standard32 __user *up)
 425 {
 426         /* other fields are not set by the user, nor used by the driver */
 427         if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_standard32)) ||
 428                 get_user(kp->index, &up->index))
 429                 return -EFAULT;
 430         return 0;
 431 }
 432
 433 static int put_v4l2_standard32(struct v4l2_standard *kp, struct v4l2_standard32 __user *up)
 434 {
 435         if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_standard32)) ||
 436                 put_user(kp->index, &up->index) ||
 437                 copy_to_user(up->id, &kp->id, sizeof(__u64)) ||
 438                 copy_to_user(up->name, kp->name, 24) ||
 439                 copy_to_user(&up->frameperiod, &kp->frameperiod, sizeof(kp->frameperiod)) ||
 440                 put_user(kp->framelines, &up->framelines) ||
 441                 copy_to_user(up->reserved, kp->reserved, 4 * sizeof(__u32)))
 442                         return -EFAULT;
 443         return 0;
 444 }
 445
 446 struct v4l2_buffer32 {
 447         __u32                   index;
 448         enum v4l2_buf_type      type;
 449         __u32                   bytesused;
 450         __u32                   flags;
 451         enum v4l2_field         field;
 452         struct compat_timeval   timestamp;
 453         struct v4l2_timecode    timecode;
 454         __u32                   sequence;
 455
 456         /* memory location */
 457         enum v4l2_memory        memory;
 458         union {
 459                 __u32           offset;
 460                 compat_long_t   userptr;
 461         } m;
 462         __u32                   length;
 463         __u32                   input;
 464         __u32                   reserved;
 465 };
 466
 467 static int get_v4l2_buffer32(struct v4l2_buffer *kp, struct v4l2_buffer32 __user *up)
 468 {
 469
 470         if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_buffer32)) ||
 471                 get_user(kp->index, &up->index) ||
 472                 get_user(kp->type, &up->type) ||
 473                 get_user(kp->flags, &up->flags) ||
 474                 get_user(kp->memory, &up->memory) ||
 475                 get_user(kp->input, &up->input))
 476                         return -EFAULT;
 477         switch (kp->memory) {
 478         case V4L2_MEMORY_MMAP:
 479                 if (get_user(kp->length, &up->length) ||
 480                         get_user(kp->m.offset, &up->m.offset))
 481                         return -EFAULT;
 482                 break;
 483         case V4L2_MEMORY_USERPTR:
 484                 {
 485                 compat_long_t tmp;
 486
 487                 if (get_user(kp->length, &up->length) ||
 488                     get_user(tmp, &up->m.userptr))
 489                         return -EFAULT;
 490
 491                 kp->m.userptr = (unsigned long)compat_ptr(tmp);
 492                 }
 493                 break;
 494         case V4L2_MEMORY_OVERLAY:
 495                 if (get_user(kp->m.offset, &up->m.offset))
 496                         return -EFAULT;
 497                 break;
 498         }
 499         return 0;
 500 }
 501
 502 static int put_v4l2_buffer32(struct v4l2_buffer *kp, struct v4l2_buffer32 __user *up)
 503 {
 504         if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_buffer32)) ||
 505                 put_user(kp->index, &up->index) ||
 506                 put_user(kp->type, &up->type) ||
 507                 put_user(kp->flags, &up->flags) ||
 508                 put_user(kp->memory, &up->memory) ||
 509                 put_user(kp->input, &up->input))
 510                         return -EFAULT;
 511         switch (kp->memory) {
 512         case V4L2_MEMORY_MMAP:
 513                 if (put_user(kp->length, &up->length) ||
 514                         put_user(kp->m.offset, &up->m.offset))
 515                         return -EFAULT;
 516                 break;
 517         case V4L2_MEMORY_USERPTR:
 518                 if (put_user(kp->length, &up->length) ||
 519                         put_user(kp->m.userptr, &up->m.userptr))
 520                         return -EFAULT;
 521                 break;
 522         case V4L2_MEMORY_OVERLAY:
 523                 if (put_user(kp->m.offset, &up->m.offset))
 524                         return -EFAULT;
 525                 break;
 526         }
 527         if (put_user(kp->bytesused, &up->bytesused) ||
 528                 put_user(kp->field, &up->field) ||
 529                 put_user(kp->timestamp.tv_sec, &up->timestamp.tv_sec) ||
 530                 put_user(kp->timestamp.tv_usec, &up->timestamp.tv_usec) ||
 531                 copy_to_user(&up->timecode, &kp->timecode, sizeof(struct v4l2_timecode)) ||
 532                 put_user(kp->sequence, &up->sequence) ||
 533                 put_user(kp->reserved, &up->reserved))
 534                         return -EFAULT;
 535         return 0;
 536 }
 537
 538 struct v4l2_framebuffer32 {
 539         __u32                   capability;
 540         __u32                   flags;
 541         compat_caddr_t          base;
 542         struct v4l2_pix_format  fmt;
 543 };
 544
 545 static int get_v4l2_framebuffer32(struct v4l2_framebuffer *kp, struct v4l2_framebuffer32 __user *up)
 546 {
 547         u32 tmp;
 548
 549         if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_framebuffer32)) ||
 550                 get_user(tmp, &up->base) ||
 551                 get_user(kp->capability, &up->capability) ||
 552                 get_user(kp->flags, &up->flags))
 553                         return -EFAULT;
 554         kp->base = compat_ptr(tmp);
 555         get_v4l2_pix_format(&kp->fmt, &up->fmt);
 556         return 0;
 557 }
 558
 559 static int put_v4l2_framebuffer32(struct v4l2_framebuffer *kp, struct v4l2_framebuffer32 __user *up)
 560 {
 561         u32 tmp = (u32)((unsigned long)kp->base);
 562
 563         if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_framebuffer32)) ||
 564                 put_user(tmp, &up->base) ||
 565                 put_user(kp->capability, &up->capability) ||
 566                 put_user(kp->flags, &up->flags))
 567                         return -EFAULT;
 568         put_v4l2_pix_format(&kp->fmt, &up->fmt);
 569         return 0;
 570 }
 571
 572 struct v4l2_input32 {
 573         __u32        index;             /*  Which input */
 574         __u8         name[32];          /*  Label */
 575         __u32        type;              /*  Type of input */
 576         __u32        audioset;          /*  Associated audios (bitfield) */
 577         __u32        tuner;             /*  Associated tuner */
 578         v4l2_std_id  std;
 579         __u32        status;
 580         __u32        reserved[4];
 581 } __attribute__ ((packed));
 582
 583 /* The 64-bit v4l2_input struct has extra padding at the end of the struct.
 584    Otherwise it is identical to the 32-bit version. */
 585 static inline int get_v4l2_input32(struct v4l2_input *kp, struct v4l2_input32 __user *up)
 586 {
 587         if (copy_from_user(kp, up, sizeof(struct v4l2_input32)))
 588                 return -EFAULT;
 589         return 0;
 590 }
 591
 592 static inline int put_v4l2_input32(struct v4l2_input *kp, struct v4l2_input32 __user *up)
 593 {
 594         if (copy_to_user(up, kp, sizeof(struct v4l2_input32)))
 595                 return -EFAULT;
 596         return 0;
 597 }
 598
 599 struct v4l2_ext_controls32 {
 600        __u32 ctrl_class;
 601        __u32 count;
 602        __u32 error_idx;
 603        __u32 reserved[2];
 604        compat_caddr_t controls; /* actually struct v4l2_ext_control32 * */
 605 };
 606
 607 struct v4l2_ext_control32 {
 608         __u32 id;
 609         __u32 size;
 610         __u32 reserved2[1];
 611         union {
 612                 __s32 value;
 613                 __s64 value64;
 614                 compat_caddr_t string; /* actually char * */
 615         };
 616 } __attribute__ ((packed));
 617
 618 /* The following function really belong in v4l2-common, but that causes
 619    a circular dependency between modules. We need to think about this, but
 620    for now this will do. */
 621
 622 /* Return non-zero if this control is a pointer type. Currently only
 623    type STRING is a pointer type. */
 624 static inline int ctrl_is_pointer(u32 id)
 625 {
 626         switch (id) {
 627         case V4L2_CID_RDS_TX_PS_NAME:
 628         case V4L2_CID_RDS_TX_RADIO_TEXT:
 629                 return 1;
 630         default:
 631                 return 0;
 632         }
 633 }
 634
 635 static int get_v4l2_ext_controls32(struct v4l2_ext_controls *kp, struct v4l2_ext_controls32 __user *up)
 636 {
 637         struct v4l2_ext_control32 __user *ucontrols;
 638         struct v4l2_ext_control __user *kcontrols;
 639         int n;
 640         compat_caddr_t p;
 641
 642         if (!access_ok(VERIFY_READ, up, sizeof(struct v4l2_ext_controls32)) ||
 643                 get_user(kp->ctrl_class, &up->ctrl_class) ||
 644                 get_user(kp->count, &up->count) ||
 645                 get_user(kp->error_idx, &up->error_idx) ||
 646                 copy_from_user(kp->reserved, up->reserved, sizeof(kp->reserved)))
 647                         return -EFAULT;
 648         n = kp->count;
 649         if (n == 0) {
 650                 kp->controls = NULL;
 651                 return 0;
 652         }
 653         if (get_user(p, &up->controls))
 654                 return -EFAULT;
 655         ucontrols = compat_ptr(p);
 656         if (!access_ok(VERIFY_READ, ucontrols, n * sizeof(struct v4l2_ext_control)))
 657                 return -EFAULT;
 658         kcontrols = compat_alloc_user_space(n * sizeof(struct v4l2_ext_control));
 659         kp->controls = kcontrols;
 660         while (--n >= 0) {
 661                 if (copy_in_user(kcontrols, ucontrols, sizeof(*kcontrols)))
 662                         return -EFAULT;
 663                 if (ctrl_is_pointer(kcontrols->id)) {
 664                         void __user *s;
 665
 666                         if (get_user(p, &ucontrols->string))
 667                                 return -EFAULT;
 668                         s = compat_ptr(p);
 669                         if (put_user(s, &kcontrols->string))
 670                                 return -EFAULT;
 671                 }
 672                 ucontrols++;
 673                 kcontrols++;
 674         }
 675         return 0;
 676 }
 677
 678 static int put_v4l2_ext_controls32(struct v4l2_ext_controls *kp, struct v4l2_ext_controls32 __user *up)
 679 {
 680         struct v4l2_ext_control32 __user *ucontrols;
 681         struct v4l2_ext_control __user *kcontrols = kp->controls;
 682         int n = kp->count;
 683         compat_caddr_t p;
 684
 685         if (!access_ok(VERIFY_WRITE, up, sizeof(struct v4l2_ext_controls32)) ||
 686                 put_user(kp->ctrl_class, &up->ctrl_class) ||
 687                 put_user(kp->count, &up->count) ||
 688                 put_user(kp->error_idx, &up->error_idx) ||
 689                 copy_to_user(up->reserved, kp->reserved, sizeof(up->reserved)))
 690                         return -EFAULT;
 691         if (!kp->count)
 692                 return 0;
 693
 694         if (get_user(p, &up->controls))
 695                 return -EFAULT;
 696         ucontrols = compat_ptr(p);
 697         if (!access_ok(VERIFY_WRITE, ucontrols, n * sizeof(struct v4l2_ext_control)))
 698                 return -EFAULT;
 699
 700         while (--n >= 0) {
 701                 unsigned size = sizeof(*ucontrols);
 702
 703                 /* Do not modify the pointer when copying a pointer control.
 704                    The contents of the pointer was changed, not the pointer
 705                    itself. */
 706                 if (ctrl_is_pointer(kcontrols->id))
 707                         size -= sizeof(ucontrols->value64);
 708                 if (copy_in_user(ucontrols, kcontrols, size))
 709                         return -EFAULT;
 710                 ucontrols++;
 711                 kcontrols++;
 712         }
 713         return 0;
 714 }
 715
 716 #define VIDIOC_G_FMT32          _IOWR('V',  4, struct v4l2_format32)
 717 #define VIDIOC_S_FMT32          _IOWR('V',  5, struct v4l2_format32)
 718 #define VIDIOC_QUERYBUF32       _IOWR('V',  9, struct v4l2_buffer32)
 719 #define VIDIOC_G_FBUF32         _IOR ('V', 10, struct v4l2_framebuffer32)
 720 #define VIDIOC_S_FBUF32         _IOW ('V', 11, struct v4l2_framebuffer32)
 721 #define VIDIOC_QBUF32           _IOWR('V', 15, struct v4l2_buffer32)
 722 #define VIDIOC_DQBUF32          _IOWR('V', 17, struct v4l2_buffer32)
 723 #define VIDIOC_ENUMSTD32        _IOWR('V', 25, struct v4l2_standard32)
 724 #define VIDIOC_ENUMINPUT32      _IOWR('V', 26, struct v4l2_input32)
 725 #define VIDIOC_TRY_FMT32        _IOWR('V', 64, struct v4l2_format32)
 726 #define VIDIOC_G_EXT_CTRLS32    _IOWR('V', 71, struct v4l2_ext_controls32)
 727 #define VIDIOC_S_EXT_CTRLS32    _IOWR('V', 72, struct v4l2_ext_controls32)
 728 #define VIDIOC_TRY_EXT_CTRLS32  _IOWR('V', 73, struct v4l2_ext_controls32)
 729
 730 #define VIDIOC_OVERLAY32        _IOW ('V', 14, s32)
 731 #ifdef __OLD_VIDIOC_
 732 #define VIDIOC_OVERLAY32_OLD    _IOWR('V', 14, s32)
 733 #endif
 734 #define VIDIOC_STREAMON32       _IOW ('V', 18, s32)
 735 #define VIDIOC_STREAMOFF32      _IOW ('V', 19, s32)
 736 #define VIDIOC_G_INPUT32        _IOR ('V', 38, s32)
 737 #define VIDIOC_S_INPUT32        _IOWR('V', 39, s32)
 738 #define VIDIOC_G_OUTPUT32       _IOR ('V', 46, s32)
 739 #define VIDIOC_S_OUTPUT32       _IOWR('V', 47, s32)
 740
 741 static long do_video_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 742 {
 743         union {
 744 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 745                 struct video_tuner vt;
 746                 struct video_buffer vb;
 747                 struct video_window vw;
 748                 struct video_code32 vc;
 749                 struct video_audio va;
 750 #endif
 751                 struct v4l2_format v2f;
 752                 struct v4l2_buffer v2b;
 753                 struct v4l2_framebuffer v2fb;
 754                 struct v4l2_input v2i;
 755                 struct v4l2_standard v2s;
 756                 struct v4l2_ext_controls v2ecs;
 757                 unsigned long vx;
 758                 int vi;
 759         } karg;
 760         void __user *up = compat_ptr(arg);
 761         int compatible_arg = 1;
 762         long err = 0;
 763
 764         /* First, convert the command. */
 765         switch (cmd) {
 766 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 767         case VIDIOCGTUNER32: cmd = VIDIOCGTUNER; break;
 768         case VIDIOCSTUNER32: cmd = VIDIOCSTUNER; break;
 769         case VIDIOCGWIN32: cmd = VIDIOCGWIN; break;
 770         case VIDIOCSWIN32: cmd = VIDIOCSWIN; break;
 771         case VIDIOCGFBUF32: cmd = VIDIOCGFBUF; break;
 772         case VIDIOCSFBUF32: cmd = VIDIOCSFBUF; break;
 773         case VIDIOCGFREQ32: cmd = VIDIOCGFREQ; break;
 774         case VIDIOCSFREQ32: cmd = VIDIOCSFREQ; break;
 775         case VIDIOCSMICROCODE32: cmd = VIDIOCSMICROCODE; break;
 776 #endif
 777         case VIDIOC_G_FMT32: cmd = VIDIOC_G_FMT; break;
 778         case VIDIOC_S_FMT32: cmd = VIDIOC_S_FMT; break;
 779         case VIDIOC_QUERYBUF32: cmd = VIDIOC_QUERYBUF; break;
 780         case VIDIOC_G_FBUF32: cmd = VIDIOC_G_FBUF; break;
 781         case VIDIOC_S_FBUF32: cmd = VIDIOC_S_FBUF; break;
 782         case VIDIOC_QBUF32: cmd = VIDIOC_QBUF; break;
 783         case VIDIOC_DQBUF32: cmd = VIDIOC_DQBUF; break;
 784         case VIDIOC_ENUMSTD32: cmd = VIDIOC_ENUMSTD; break;
 785         case VIDIOC_ENUMINPUT32: cmd = VIDIOC_ENUMINPUT; break;
 786         case VIDIOC_TRY_FMT32: cmd = VIDIOC_TRY_FMT; break;
 787         case VIDIOC_G_EXT_CTRLS32: cmd = VIDIOC_G_EXT_CTRLS; break;
 788         case VIDIOC_S_EXT_CTRLS32: cmd = VIDIOC_S_EXT_CTRLS; break;
 789         case VIDIOC_TRY_EXT_CTRLS32: cmd = VIDIOC_TRY_EXT_CTRLS; break;
 790         case VIDIOC_OVERLAY32: cmd = VIDIOC_OVERLAY; break;
 791 #ifdef __OLD_VIDIOC_
 792         case VIDIOC_OVERLAY32_OLD: cmd = VIDIOC_OVERLAY; break;
 793 #endif
 794         case VIDIOC_STREAMON32: cmd = VIDIOC_STREAMON; break;
 795         case VIDIOC_STREAMOFF32: cmd = VIDIOC_STREAMOFF; break;
 796         case VIDIOC_G_INPUT32: cmd = VIDIOC_G_INPUT; break;
 797         case VIDIOC_S_INPUT32: cmd = VIDIOC_S_INPUT; break;
 798         case VIDIOC_G_OUTPUT32: cmd = VIDIOC_G_OUTPUT; break;
 799         case VIDIOC_S_OUTPUT32: cmd = VIDIOC_S_OUTPUT; break;
 800         }
 801
 802         switch (cmd) {
 803 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 804         case VIDIOCSTUNER:
 805         case VIDIOCGTUNER:
 806                 err = get_video_tuner32(&karg.vt, up);
 807                 compatible_arg = 0;
 808                 break;
 809
 810         case VIDIOCSFBUF:
 811                 err = get_video_buffer32(&karg.vb, up);
 812                 compatible_arg = 0;
 813                 break;
 814
 815         case VIDIOCSWIN:
 816                 err = get_video_window32(&karg.vw, up);
 817                 compatible_arg = 0;
 818                 break;
 819
 820         case VIDIOCGWIN:
 821         case VIDIOCGFBUF:
 822         case VIDIOCGFREQ:
 823                 compatible_arg = 0;
 824                 break;
 825
 826         case VIDIOCSMICROCODE:
 827                 /* Copy the 32-bit "video_code32" to kernel space */
 828                 if (copy_from_user(&karg.vc, up, sizeof(karg.vc)))
 829                         return -EFAULT;
 830                 /* Convert the 32-bit version to a 64-bit version in user space */
 831                 up = get_microcode32(&karg.vc);
 832                 break;
 833
 834         case VIDIOCSFREQ:
 835                 err = get_user(karg.vx, (u32 __user *)up);
 836                 compatible_arg = 0;
 837                 break;
 838
 839         case VIDIOCCAPTURE:
 840         case VIDIOCSYNC:
 841         case VIDIOCSWRITEMODE:
 842 #endif
 843         case VIDIOC_OVERLAY:
 844         case VIDIOC_STREAMON:
 845         case VIDIOC_STREAMOFF:
 846         case VIDIOC_S_INPUT:
 847         case VIDIOC_S_OUTPUT:
 848                 err = get_user(karg.vi, (s32 __user *)up);
 849                 compatible_arg = 0;
 850                 break;
 851
 852         case VIDIOC_G_INPUT:
 853         case VIDIOC_G_OUTPUT:
 854                 compatible_arg = 0;
 855                 break;
 856
 857         case VIDIOC_G_FMT:
 858         case VIDIOC_S_FMT:
 859         case VIDIOC_TRY_FMT:
 860                 err = get_v4l2_format32(&karg.v2f, up);
 861                 compatible_arg = 0;
 862                 break;
 863
 864         case VIDIOC_QUERYBUF:
 865         case VIDIOC_QBUF:
 866         case VIDIOC_DQBUF:
 867                 err = get_v4l2_buffer32(&karg.v2b, up);
 868                 compatible_arg = 0;
 869                 break;
 870
 871         case VIDIOC_S_FBUF:
 872                 err = get_v4l2_framebuffer32(&karg.v2fb, up);
 873                 compatible_arg = 0;
 874                 break;
 875
 876         case VIDIOC_G_FBUF:
 877                 compatible_arg = 0;
 878                 break;
 879
 880         case VIDIOC_ENUMSTD:
 881                 err = get_v4l2_standard32(&karg.v2s, up);
 882                 compatible_arg = 0;
 883                 break;
 884
 885         case VIDIOC_ENUMINPUT:
 886                 err = get_v4l2_input32(&karg.v2i, up);
 887                 compatible_arg = 0;
 888                 break;
 889
 890         case VIDIOC_G_EXT_CTRLS:
 891         case VIDIOC_S_EXT_CTRLS:
 892         case VIDIOC_TRY_EXT_CTRLS:
 893                 err = get_v4l2_ext_controls32(&karg.v2ecs, up);
 894                 compatible_arg = 0;
 895                 break;
 896         }
 897         if (err)
 898                 return err;
 899
 900         if (compatible_arg)
 901                 err = native_ioctl(file, cmd, (unsigned long)up);
 902         else {
 903                 mm_segment_t old_fs = get_fs();
 904
 905                 set_fs(KERNEL_DS);
 906                 err = native_ioctl(file, cmd, (unsigned long)&karg);
 907                 set_fs(old_fs);
 908         }
 909
 910         /* Special case: even after an error we need to put the
 911            results back for these ioctls since the error_idx will
 912            contain information on which control failed. */
 913         switch (cmd) {
 914         case VIDIOC_G_EXT_CTRLS:
 915         case VIDIOC_S_EXT_CTRLS:
 916         case VIDIOC_TRY_EXT_CTRLS:
 917                 if (put_v4l2_ext_controls32(&karg.v2ecs, up))
 918                         err = -EFAULT;
 919                 break;
 920         }
 921         if (err)
 922                 return err;
 923
 924         switch (cmd) {
 925 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 926         case VIDIOCGTUNER:
 927                 err = put_video_tuner32(&karg.vt, up);
 928                 break;
 929
 930         case VIDIOCGWIN:
 931                 err = put_video_window32(&karg.vw, up);
 932                 break;
 933
 934         case VIDIOCGFBUF:
 935                 err = put_video_buffer32(&karg.vb, up);
 936                 break;
 937
 938         case VIDIOCGFREQ:
 939                 err = put_user(((u32)karg.vx), (u32 __user *)up);
 940                 break;
 941 #endif
 942         case VIDIOC_S_INPUT:
 943         case VIDIOC_S_OUTPUT:
 944         case VIDIOC_G_INPUT:
 945         case VIDIOC_G_OUTPUT:
 946                 err = put_user(((s32)karg.vi), (s32 __user *)up);
 947                 break;
 948
 949         case VIDIOC_G_FBUF:
 950                 err = put_v4l2_framebuffer32(&karg.v2fb, up);
 951                 break;
 952
 953         case VIDIOC_G_FMT:
 954         case VIDIOC_S_FMT:
 955         case VIDIOC_TRY_FMT:
 956                 err = put_v4l2_format32(&karg.v2f, up);
 957                 break;
 958
 959         case VIDIOC_QUERYBUF:
 960         case VIDIOC_QBUF:
 961         case VIDIOC_DQBUF:
 962                 err = put_v4l2_buffer32(&karg.v2b, up);
 963                 break;
 964
 965         case VIDIOC_ENUMSTD:
 966                 err = put_v4l2_standard32(&karg.v2s, up);
 967                 break;
 968
 969         case VIDIOC_ENUMINPUT:
 970                 err = put_v4l2_input32(&karg.v2i, up);
 971                 break;
 972         }
 973         return err;
 974 }
 975
 976 long v4l2_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
 977 {
 978         long ret = -ENOIOCTLCMD;
 979
 980         if (!file->f_op->unlocked_ioctl)
 981                 return ret;
 982
 983         switch (cmd) {
 984 #ifdef CONFIG_VIDEO_V4L1_COMPAT
 985         case VIDIOCGCAP:
 986         case VIDIOCGCHAN:
 987         case VIDIOCSCHAN:
 988         case VIDIOCGTUNER32:
 989         case VIDIOCSTUNER32:
 990         case VIDIOCGPICT:
 991         case VIDIOCSPICT:
 992         case VIDIOCCAPTURE32:
 993         case VIDIOCGWIN32:
 994         case VIDIOCSWIN32:
 995         case VIDIOCGFBUF32:
 996         case VIDIOCSFBUF32:
 997         case VIDIOCKEY:
 998         case VIDIOCGFREQ32:
 999         case VIDIOCSFREQ32:
1000         case VIDIOCGAUDIO:
1001         case VIDIOCSAUDIO:
1002         case VIDIOCSYNC32:
1003         case VIDIOCMCAPTURE:
1004         case VIDIOCGMBUF:
1005         case VIDIOCGUNIT:
1006         case VIDIOCGCAPTURE:
1007         case VIDIOCSCAPTURE:
1008         case VIDIOCSPLAYMODE:
1009         case VIDIOCSWRITEMODE32:
1010         case VIDIOCGPLAYINFO:
1011         case VIDIOCSMICROCODE32:
1012         case VIDIOCGVBIFMT:
1013         case VIDIOCSVBIFMT:
1014 #endif
1015 #ifdef __OLD_VIDIOC_
1016         case VIDIOC_OVERLAY32_OLD:
1017         case VIDIOC_S_PARM_OLD:
1018         case VIDIOC_S_CTRL_OLD:
1019         case VIDIOC_G_AUDIO_OLD:
1020         case VIDIOC_G_AUDOUT_OLD:
1021         case VIDIOC_CROPCAP_OLD:
1022 #endif
1023         case VIDIOC_QUERYCAP:
1024         case VIDIOC_RESERVED:
1025         case VIDIOC_ENUM_FMT:
1026         case VIDIOC_G_FMT32:
1027         case VIDIOC_S_FMT32:
1028         case VIDIOC_REQBUFS:
1029         case VIDIOC_QUERYBUF32:
1030         case VIDIOC_G_FBUF32:
1031         case VIDIOC_S_FBUF32:
1032         case VIDIOC_OVERLAY32:
1033         case VIDIOC_QBUF32:
1034         case VIDIOC_DQBUF32:
1035         case VIDIOC_STREAMON32:
1036         case VIDIOC_STREAMOFF32:
1037         case VIDIOC_G_PARM:
1038         case VIDIOC_S_PARM:
1039         case VIDIOC_G_STD:
1040         case VIDIOC_S_STD:
1041         case VIDIOC_ENUMSTD32:
1042         case VIDIOC_ENUMINPUT32:
1043         case VIDIOC_G_CTRL:
1044         case VIDIOC_S_CTRL:
1045         case VIDIOC_G_TUNER:
1046         case VIDIOC_S_TUNER:
1047         case VIDIOC_G_AUDIO:
1048         case VIDIOC_S_AUDIO:
1049         case VIDIOC_QUERYCTRL:
1050         case VIDIOC_QUERYMENU:
1051         case VIDIOC_G_INPUT32:
1052         case VIDIOC_S_INPUT32:
1053         case VIDIOC_G_OUTPUT32:
1054         case VIDIOC_S_OUTPUT32:
1055         case VIDIOC_ENUMOUTPUT:
1056         case VIDIOC_G_AUDOUT:
1057         case VIDIOC_S_AUDOUT:
1058         case VIDIOC_G_MODULATOR:
1059         case VIDIOC_S_MODULATOR:
1060         case VIDIOC_S_FREQUENCY:
1061         case VIDIOC_G_FREQUENCY:
1062         case VIDIOC_CROPCAP:
1063         case VIDIOC_G_CROP:
1064         case VIDIOC_S_CROP:
1065         case VIDIOC_G_JPEGCOMP:
1066         case VIDIOC_S_JPEGCOMP:
1067         case VIDIOC_QUERYSTD:
1068         case VIDIOC_TRY_FMT32:
1069         case VIDIOC_ENUMAUDIO:
1070         case VIDIOC_ENUMAUDOUT:
1071         case VIDIOC_G_PRIORITY:
1072         case VIDIOC_S_PRIORITY:
1073         case VIDIOC_G_SLICED_VBI_CAP:
1074         case VIDIOC_LOG_STATUS:
1075         case VIDIOC_G_EXT_CTRLS32:
1076         case VIDIOC_S_EXT_CTRLS32:
1077         case VIDIOC_TRY_EXT_CTRLS32:
1078         case VIDIOC_ENUM_FRAMESIZES:
1079         case VIDIOC_ENUM_FRAMEINTERVALS:
1080         case VIDIOC_G_ENC_INDEX:
1081         case VIDIOC_ENCODER_CMD:
1082         case VIDIOC_TRY_ENCODER_CMD:
1083         case VIDIOC_DBG_S_REGISTER:
1084         case VIDIOC_DBG_G_REGISTER:
1085         case VIDIOC_DBG_G_CHIP_IDENT:
1086         case VIDIOC_S_HW_FREQ_SEEK:
1087         case VIDIOC_ENUM_DV_PRESETS:
1088         case VIDIOC_S_DV_PRESET:
1089         case VIDIOC_G_DV_PRESET:
1090         case VIDIOC_QUERY_DV_PRESET:
1091         case VIDIOC_S_DV_TIMINGS:
1092         case VIDIOC_G_DV_TIMINGS:
1093         case VIDIOC_DQEVENT:
1094         case VIDIOC_SUBSCRIBE_EVENT:
1095         case VIDIOC_UNSUBSCRIBE_EVENT:
1096                 ret = do_video_ioctl(file, cmd, arg);
1097                 break;
1098
1099 #ifdef CONFIG_VIDEO_V4L1_COMPAT
1100         /* BTTV specific... */
1101         case _IOW('v',  BASE_VIDIOCPRIVATE+0, char [256]):
1102         case _IOR('v',  BASE_VIDIOCPRIVATE+1, char [256]):
1103         case _IOR('v' , BASE_VIDIOCPRIVATE+2, unsigned int):
1104         case _IOW('v' , BASE_VIDIOCPRIVATE+3, char [16]): /* struct bttv_pll_info */
1105         case _IOR('v' , BASE_VIDIOCPRIVATE+4, int):
1106         case _IOR('v' , BASE_VIDIOCPRIVATE+5, int):
1107         case _IOR('v' , BASE_VIDIOCPRIVATE+6, int):
1108         case _IOR('v' , BASE_VIDIOCPRIVATE+7, int):
1109                 ret = native_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
1110                 break;
1111 #endif
1112         default:
1113                 printk(KERN_WARNING "compat_ioctl32: "
1114                         "unknown ioctl '%c', dir=%d, #%d (0x%08x)\n",
1115                         _IOC_TYPE(cmd), _IOC_DIR(cmd), _IOC_NR(cmd), cmd);
1116                 break;
1117         }
1118         return ret;
1119 }
1120 EXPORT_SYMBOL_GPL(v4l2_compat_ioctl32);
1121 #endif
1122
1123 MODULE_LICENSE("GPL");