drivers/media/v4l2-core/v4l2-compat-ioctl32.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * ioctl32.c: Conversion between 32bit and 64bit native ioctls.
   4  *      Separated from fs stuff by Arnd Bergmann <arnd@arndb.de>
   5  *
   6  * Copyright (C) 1997-2000  Jakub Jelinek  (jakub@redhat.com)
   7  * Copyright (C) 1998  Eddie C. Dost  (ecd@skynet.be)
   8  * Copyright (C) 2001,2002  Andi Kleen, SuSE Labs
   9  * Copyright (C) 2003       Pavel Machek (pavel@ucw.cz)
  10  * Copyright (C) 2005       Philippe De Muyter (phdm@macqel.be)
  11  * Copyright (C) 2008       Hans Verkuil <hverkuil@xs4all.nl>
  12  *
  13  * These routines maintain argument size conversion between 32bit and 64bit
  14  * ioctls.
  15  */
  16
  17 #include <linux/compat.h>
  18 #include <linux/module.h>
  19 #include <linux/videodev2.h>
  20 #include <linux/v4l2-subdev.h>
  21 #include <media/v4l2-dev.h>
  22 #include <media/v4l2-fh.h>
  23 #include <media/v4l2-ctrls.h>
  24 #include <media/v4l2-ioctl.h>
  25
  26 /*
  27  * Per-ioctl data copy handlers.
  28  *
  29  * Those come in pairs, with a get_v4l2_foo() and a put_v4l2_foo() routine,
  30  * where "v4l2_foo" is the name of the V4L2 struct.
  31  *
  32  * They basically get two __user pointers, one with a 32-bits struct that
  33  * came from the userspace call and a 64-bits struct, also allocated as
  34  * userspace, but filled internally by do_video_ioctl().
  35  *
  36  * For ioctls that have pointers inside it, the functions will also
  37  * receive an ancillary buffer with extra space, used to pass extra
  38  * data to the routine.
  39  */
  40
  41 struct v4l2_window32 {
  42         struct v4l2_rect        w;
  43         __u32                   field;  /* enum v4l2_field */
  44         __u32                   chromakey;
  45         compat_caddr_t          clips; /* always NULL */
  46         __u32                   clipcount; /* always 0 */
  47         compat_caddr_t          bitmap; /* always NULL */
  48         __u8                    global_alpha;
  49 };
  50
  51 static int get_v4l2_window32(struct v4l2_window *p64,
  52                              struct v4l2_window32 __user *p32)
  53 {
  54         struct v4l2_window32 w32;
  55
  56         if (copy_from_user(&w32, p32, sizeof(w32)))
  57                 return -EFAULT;
  58
  59         *p64 = (struct v4l2_window) {
  60                 .w              = w32.w,
  61                 .field          = w32.field,
  62                 .chromakey      = w32.chromakey,
  63                 .clips          = NULL,
  64                 .clipcount      = 0,
  65                 .bitmap         = NULL,
  66                 .global_alpha   = w32.global_alpha,
  67         };
  68
  69         return 0;
  70 }
  71
  72 static int put_v4l2_window32(struct v4l2_window *p64,
  73                              struct v4l2_window32 __user *p32)
  74 {
  75         struct v4l2_window32 w32;
  76
  77         memset(&w32, 0, sizeof(w32));
  78         w32 = (struct v4l2_window32) {
  79                 .w              = p64->w,
  80                 .field          = p64->field,
  81                 .chromakey      = p64->chromakey,
  82                 .clips          = 0,
  83                 .clipcount      = 0,
  84                 .bitmap         = 0,
  85                 .global_alpha   = p64->global_alpha,
  86         };
  87
  88         if (copy_to_user(p32, &w32, sizeof(w32)))
  89                 return -EFAULT;
  90
  91         return 0;
  92 }
  93
  94 struct v4l2_format32 {
  95         __u32   type;   /* enum v4l2_buf_type */
  96         union {
  97                 struct v4l2_pix_format  pix;
  98                 struct v4l2_pix_format_mplane   pix_mp;
  99                 struct v4l2_window32    win;
 100                 struct v4l2_vbi_format  vbi;
 101                 struct v4l2_sliced_vbi_format   sliced;
 102                 struct v4l2_sdr_format  sdr;
 103                 struct v4l2_meta_format meta;
 104                 __u8    raw_data[200];        /* user-defined */
 105         } fmt;
 106 };
 107
 108 /**
 109  * struct v4l2_create_buffers32 - VIDIOC_CREATE_BUFS32 argument
 110  * @index:      on return, index of the first created buffer
 111  * @count:      entry: number of requested buffers,
 112  *              return: number of created buffers
 113  * @memory:     buffer memory type
 114  * @format:     frame format, for which buffers are requested
 115  * @capabilities: capabilities of this buffer type.
 116  * @flags:      additional buffer management attributes (ignored unless the
 117  *              queue has V4L2_BUF_CAP_SUPPORTS_MMAP_CACHE_HINTS capability and
 118  *              configured for MMAP streaming I/O).
 119  * @reserved:   future extensions
 120  */
 121 struct v4l2_create_buffers32 {
 122         __u32                   index;
 123         __u32                   count;
 124         __u32                   memory; /* enum v4l2_memory */
 125         struct v4l2_format32    format;
 126         __u32                   capabilities;
 127         __u32                   flags;
 128         __u32                   reserved[6];
 129 };
 130
 131 static int get_v4l2_format32(struct v4l2_format *p64,
 132                              struct v4l2_format32 __user *p32)
 133 {
 134         if (get_user(p64->type, &p32->type))
 135                 return -EFAULT;
 136
 137         switch (p64->type) {
 138         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 139         case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 140                 return copy_from_user(&p64->fmt.pix, &p32->fmt.pix,
 141                                       sizeof(p64->fmt.pix)) ? -EFAULT : 0;
 142         case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
 143         case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
 144                 return copy_from_user(&p64->fmt.pix_mp, &p32->fmt.pix_mp,
 145                                       sizeof(p64->fmt.pix_mp)) ? -EFAULT : 0;
 146         case V4L2_BUF_TYPE_VIDEO_OVERLAY:
 147         case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
 148                 return get_v4l2_window32(&p64->fmt.win, &p32->fmt.win);
 149         case V4L2_BUF_TYPE_VBI_CAPTURE:
 150         case V4L2_BUF_TYPE_VBI_OUTPUT:
 151                 return copy_from_user(&p64->fmt.vbi, &p32->fmt.vbi,
 152                                       sizeof(p64->fmt.vbi)) ? -EFAULT : 0;
 153         case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
 154         case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
 155                 return copy_from_user(&p64->fmt.sliced, &p32->fmt.sliced,
 156                                       sizeof(p64->fmt.sliced)) ? -EFAULT : 0;
 157         case V4L2_BUF_TYPE_SDR_CAPTURE:
 158         case V4L2_BUF_TYPE_SDR_OUTPUT:
 159                 return copy_from_user(&p64->fmt.sdr, &p32->fmt.sdr,
 160                                       sizeof(p64->fmt.sdr)) ? -EFAULT : 0;
 161         case V4L2_BUF_TYPE_META_CAPTURE:
 162         case V4L2_BUF_TYPE_META_OUTPUT:
 163                 return copy_from_user(&p64->fmt.meta, &p32->fmt.meta,
 164                                       sizeof(p64->fmt.meta)) ? -EFAULT : 0;
 165         default:
 166                 return -EINVAL;
 167         }
 168 }
 169
 170 static int get_v4l2_create32(struct v4l2_create_buffers *p64,
 171                              struct v4l2_create_buffers32 __user *p32)
 172 {
 173         if (copy_from_user(p64, p32,
 174                            offsetof(struct v4l2_create_buffers32, format)))
 175                 return -EFAULT;
 176         if (copy_from_user(&p64->flags, &p32->flags, sizeof(p32->flags)))
 177                 return -EFAULT;
 178         return get_v4l2_format32(&p64->format, &p32->format);
 179 }
 180
 181 static int put_v4l2_format32(struct v4l2_format *p64,
 182                              struct v4l2_format32 __user *p32)
 183 {
 184         switch (p64->type) {
 185         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 186         case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 187                 return copy_to_user(&p32->fmt.pix, &p64->fmt.pix,
 188                                     sizeof(p64->fmt.pix)) ? -EFAULT : 0;
 189         case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
 190         case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
 191                 return copy_to_user(&p32->fmt.pix_mp, &p64->fmt.pix_mp,
 192                                     sizeof(p64->fmt.pix_mp)) ? -EFAULT : 0;
 193         case V4L2_BUF_TYPE_VIDEO_OVERLAY:
 194         case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
 195                 return put_v4l2_window32(&p64->fmt.win, &p32->fmt.win);
 196         case V4L2_BUF_TYPE_VBI_CAPTURE:
 197         case V4L2_BUF_TYPE_VBI_OUTPUT:
 198                 return copy_to_user(&p32->fmt.vbi, &p64->fmt.vbi,
 199                                     sizeof(p64->fmt.vbi)) ? -EFAULT : 0;
 200         case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
 201         case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
 202                 return copy_to_user(&p32->fmt.sliced, &p64->fmt.sliced,
 203                                     sizeof(p64->fmt.sliced)) ? -EFAULT : 0;
 204         case V4L2_BUF_TYPE_SDR_CAPTURE:
 205         case V4L2_BUF_TYPE_SDR_OUTPUT:
 206                 return copy_to_user(&p32->fmt.sdr, &p64->fmt.sdr,
 207                                     sizeof(p64->fmt.sdr)) ? -EFAULT : 0;
 208         case V4L2_BUF_TYPE_META_CAPTURE:
 209         case V4L2_BUF_TYPE_META_OUTPUT:
 210                 return copy_to_user(&p32->fmt.meta, &p64->fmt.meta,
 211                                     sizeof(p64->fmt.meta)) ? -EFAULT : 0;
 212         default:
 213                 return -EINVAL;
 214         }
 215 }
 216
 217 static int put_v4l2_create32(struct v4l2_create_buffers *p64,
 218                              struct v4l2_create_buffers32 __user *p32)
 219 {
 220         if (copy_to_user(p32, p64,
 221                          offsetof(struct v4l2_create_buffers32, format)) ||
 222             put_user(p64->capabilities, &p32->capabilities) ||
 223             put_user(p64->flags, &p32->flags) ||
 224             copy_to_user(p32->reserved, p64->reserved, sizeof(p64->reserved)))
 225                 return -EFAULT;
 226         return put_v4l2_format32(&p64->format, &p32->format);
 227 }
 228
 229 struct v4l2_standard32 {
 230         __u32                index;
 231         compat_u64           id;
 232         __u8                 name[24];
 233         struct v4l2_fract    frameperiod; /* Frames, not fields */
 234         __u32                framelines;
 235         __u32                reserved[4];
 236 };
 237
 238 static int get_v4l2_standard32(struct v4l2_standard *p64,
 239                                struct v4l2_standard32 __user *p32)
 240 {
 241         /* other fields are not set by the user, nor used by the driver */
 242         return get_user(p64->index, &p32->index);
 243 }
 244
 245 static int put_v4l2_standard32(struct v4l2_standard *p64,
 246                                struct v4l2_standard32 __user *p32)
 247 {
 248         if (put_user(p64->index, &p32->index) ||
 249             put_user(p64->id, &p32->id) ||
 250             copy_to_user(p32->name, p64->name, sizeof(p32->name)) ||
 251             copy_to_user(&p32->frameperiod, &p64->frameperiod,
 252                          sizeof(p32->frameperiod)) ||
 253             put_user(p64->framelines, &p32->framelines) ||
 254             copy_to_user(p32->reserved, p64->reserved, sizeof(p32->reserved)))
 255                 return -EFAULT;
 256         return 0;
 257 }
 258
 259 struct v4l2_plane32 {
 260         __u32                   bytesused;
 261         __u32                   length;
 262         union {
 263                 __u32           mem_offset;
 264                 compat_long_t   userptr;
 265                 __s32           fd;
 266         } m;
 267         __u32                   data_offset;
 268         __u32                   reserved[11];
 269 };
 270
 271 /*
 272  * This is correct for all architectures including i386, but not x32,
 273  * which has different alignment requirements for timestamp
 274  */
 275 struct v4l2_buffer32 {
 276         __u32                   index;
 277         __u32                   type;   /* enum v4l2_buf_type */
 278         __u32                   bytesused;
 279         __u32                   flags;
 280         __u32                   field;  /* enum v4l2_field */
 281         struct {
 282                 compat_s64      tv_sec;
 283                 compat_s64      tv_usec;
 284         }                       timestamp;
 285         struct v4l2_timecode    timecode;
 286         __u32                   sequence;
 287
 288         /* memory location */
 289         __u32                   memory; /* enum v4l2_memory */
 290         union {
 291                 __u32           offset;
 292                 compat_long_t   userptr;
 293                 compat_caddr_t  planes;
 294                 __s32           fd;
 295         } m;
 296         __u32                   length;
 297         __u32                   reserved2;
 298         __s32                   request_fd;
 299 };
 300
 301 #ifdef CONFIG_COMPAT_32BIT_TIME
 302 struct v4l2_buffer32_time32 {
 303         __u32                   index;
 304         __u32                   type;   /* enum v4l2_buf_type */
 305         __u32                   bytesused;
 306         __u32                   flags;
 307         __u32                   field;  /* enum v4l2_field */
 308         struct old_timeval32    timestamp;
 309         struct v4l2_timecode    timecode;
 310         __u32                   sequence;
 311
 312         /* memory location */
 313         __u32                   memory; /* enum v4l2_memory */
 314         union {
 315                 __u32           offset;
 316                 compat_long_t   userptr;
 317                 compat_caddr_t  planes;
 318                 __s32           fd;
 319         } m;
 320         __u32                   length;
 321         __u32                   reserved2;
 322         __s32                   request_fd;
 323 };
 324 #endif
 325
 326 static int get_v4l2_plane32(struct v4l2_plane *p64,
 327                             struct v4l2_plane32 __user *p32,
 328                             enum v4l2_memory memory)
 329 {
 330         struct v4l2_plane32 plane32;
 331         typeof(p64->m) m = {};
 332
 333         if (copy_from_user(&plane32, p32, sizeof(plane32)))
 334                 return -EFAULT;
 335
 336         switch (memory) {
 337         case V4L2_MEMORY_MMAP:
 338         case V4L2_MEMORY_OVERLAY:
 339                 m.mem_offset = plane32.m.mem_offset;
 340                 break;
 341         case V4L2_MEMORY_USERPTR:
 342                 m.userptr = (unsigned long)compat_ptr(plane32.m.userptr);
 343                 break;
 344         case V4L2_MEMORY_DMABUF:
 345                 m.fd = plane32.m.fd;
 346                 break;
 347         }
 348
 349         memset(p64, 0, sizeof(*p64));
 350         *p64 = (struct v4l2_plane) {
 351                 .bytesused      = plane32.bytesused,
 352                 .length         = plane32.length,
 353                 .m              = m,
 354                 .data_offset    = plane32.data_offset,
 355         };
 356
 357         return 0;
 358 }
 359
 360 static int put_v4l2_plane32(struct v4l2_plane *p64,
 361                             struct v4l2_plane32 __user *p32,
 362                             enum v4l2_memory memory)
 363 {
 364         struct v4l2_plane32 plane32;
 365
 366         memset(&plane32, 0, sizeof(plane32));
 367         plane32 = (struct v4l2_plane32) {
 368                 .bytesused      = p64->bytesused,
 369                 .length         = p64->length,
 370                 .data_offset    = p64->data_offset,
 371         };
 372
 373         switch (memory) {
 374         case V4L2_MEMORY_MMAP:
 375         case V4L2_MEMORY_OVERLAY:
 376                 plane32.m.mem_offset = p64->m.mem_offset;
 377                 break;
 378         case V4L2_MEMORY_USERPTR:
 379                 plane32.m.userptr = (uintptr_t)(p64->m.userptr);
 380                 break;
 381         case V4L2_MEMORY_DMABUF:
 382                 plane32.m.fd = p64->m.fd;
 383                 break;
 384         }
 385
 386         if (copy_to_user(p32, &plane32, sizeof(plane32)))
 387                 return -EFAULT;
 388
 389         return 0;
 390 }
 391
 392 static int get_v4l2_buffer32(struct v4l2_buffer *vb,
 393                              struct v4l2_buffer32 __user *arg)
 394 {
 395         struct v4l2_buffer32 vb32;
 396
 397         if (copy_from_user(&vb32, arg, sizeof(vb32)))
 398                 return -EFAULT;
 399
 400         memset(vb, 0, sizeof(*vb));
 401         *vb = (struct v4l2_buffer) {
 402                 .index          = vb32.index,
 403                 .type           = vb32.type,
 404                 .bytesused      = vb32.bytesused,
 405                 .flags          = vb32.flags,
 406                 .field          = vb32.field,
 407                 .timestamp.tv_sec       = vb32.timestamp.tv_sec,
 408                 .timestamp.tv_usec      = vb32.timestamp.tv_usec,
 409                 .timecode       = vb32.timecode,
 410                 .sequence       = vb32.sequence,
 411                 .memory         = vb32.memory,
 412                 .m.offset       = vb32.m.offset,
 413                 .length         = vb32.length,
 414                 .request_fd     = vb32.request_fd,
 415         };
 416
 417         switch (vb->memory) {
 418         case V4L2_MEMORY_MMAP:
 419         case V4L2_MEMORY_OVERLAY:
 420                 vb->m.offset = vb32.m.offset;
 421                 break;
 422         case V4L2_MEMORY_USERPTR:
 423                 vb->m.userptr = (unsigned long)compat_ptr(vb32.m.userptr);
 424                 break;
 425         case V4L2_MEMORY_DMABUF:
 426                 vb->m.fd = vb32.m.fd;
 427                 break;
 428         }
 429
 430         if (V4L2_TYPE_IS_MULTIPLANAR(vb->type))
 431                 vb->m.planes = (void __force *)
 432                                 compat_ptr(vb32.m.planes);
 433
 434         return 0;
 435 }
 436
 437 #ifdef CONFIG_COMPAT_32BIT_TIME
 438 static int get_v4l2_buffer32_time32(struct v4l2_buffer *vb,
 439                                     struct v4l2_buffer32_time32 __user *arg)
 440 {
 441         struct v4l2_buffer32_time32 vb32;
 442
 443         if (copy_from_user(&vb32, arg, sizeof(vb32)))
 444                 return -EFAULT;
 445
 446         *vb = (struct v4l2_buffer) {
 447                 .index          = vb32.index,
 448                 .type           = vb32.type,
 449                 .bytesused      = vb32.bytesused,
 450                 .flags          = vb32.flags,
 451                 .field          = vb32.field,
 452                 .timestamp.tv_sec       = vb32.timestamp.tv_sec,
 453                 .timestamp.tv_usec      = vb32.timestamp.tv_usec,
 454                 .timecode       = vb32.timecode,
 455                 .sequence       = vb32.sequence,
 456                 .memory         = vb32.memory,
 457                 .m.offset       = vb32.m.offset,
 458                 .length         = vb32.length,
 459                 .request_fd     = vb32.request_fd,
 460         };
 461         switch (vb->memory) {
 462         case V4L2_MEMORY_MMAP:
 463         case V4L2_MEMORY_OVERLAY:
 464                 vb->m.offset = vb32.m.offset;
 465                 break;
 466         case V4L2_MEMORY_USERPTR:
 467                 vb->m.userptr = (unsigned long)compat_ptr(vb32.m.userptr);
 468                 break;
 469         case V4L2_MEMORY_DMABUF:
 470                 vb->m.fd = vb32.m.fd;
 471                 break;
 472         }
 473
 474         if (V4L2_TYPE_IS_MULTIPLANAR(vb->type))
 475                 vb->m.planes = (void __force *)
 476                                 compat_ptr(vb32.m.planes);
 477
 478         return 0;
 479 }
 480 #endif
 481
 482 static int put_v4l2_buffer32(struct v4l2_buffer *vb,
 483                              struct v4l2_buffer32 __user *arg)
 484 {
 485         struct v4l2_buffer32 vb32;
 486
 487         memset(&vb32, 0, sizeof(vb32));
 488         vb32 = (struct v4l2_buffer32) {
 489                 .index          = vb->index,
 490                 .type           = vb->type,
 491                 .bytesused      = vb->bytesused,
 492                 .flags          = vb->flags,
 493                 .field          = vb->field,
 494                 .timestamp.tv_sec       = vb->timestamp.tv_sec,
 495                 .timestamp.tv_usec      = vb->timestamp.tv_usec,
 496                 .timecode       = vb->timecode,
 497                 .sequence       = vb->sequence,
 498                 .memory         = vb->memory,
 499                 .m.offset       = vb->m.offset,
 500                 .length         = vb->length,
 501                 .request_fd     = vb->request_fd,
 502         };
 503
 504         switch (vb->memory) {
 505         case V4L2_MEMORY_MMAP:
 506         case V4L2_MEMORY_OVERLAY:
 507                 vb32.m.offset = vb->m.offset;
 508                 break;
 509         case V4L2_MEMORY_USERPTR:
 510                 vb32.m.userptr = (uintptr_t)(vb->m.userptr);
 511                 break;
 512         case V4L2_MEMORY_DMABUF:
 513                 vb32.m.fd = vb->m.fd;
 514                 break;
 515         }
 516
 517         if (V4L2_TYPE_IS_MULTIPLANAR(vb->type))
 518                 vb32.m.planes = (uintptr_t)vb->m.planes;
 519
 520         if (copy_to_user(arg, &vb32, sizeof(vb32)))
 521                 return -EFAULT;
 522
 523         return 0;
 524 }
 525
 526 #ifdef CONFIG_COMPAT_32BIT_TIME
 527 static int put_v4l2_buffer32_time32(struct v4l2_buffer *vb,
 528                                     struct v4l2_buffer32_time32 __user *arg)
 529 {
 530         struct v4l2_buffer32_time32 vb32;
 531
 532         memset(&vb32, 0, sizeof(vb32));
 533         vb32 = (struct v4l2_buffer32_time32) {
 534                 .index          = vb->index,
 535                 .type           = vb->type,
 536                 .bytesused      = vb->bytesused,
 537                 .flags          = vb->flags,
 538                 .field          = vb->field,
 539                 .timestamp.tv_sec       = vb->timestamp.tv_sec,
 540                 .timestamp.tv_usec      = vb->timestamp.tv_usec,
 541                 .timecode       = vb->timecode,
 542                 .sequence       = vb->sequence,
 543                 .memory         = vb->memory,
 544                 .m.offset       = vb->m.offset,
 545                 .length         = vb->length,
 546                 .request_fd     = vb->request_fd,
 547         };
 548         switch (vb->memory) {
 549         case V4L2_MEMORY_MMAP:
 550         case V4L2_MEMORY_OVERLAY:
 551                 vb32.m.offset = vb->m.offset;
 552                 break;
 553         case V4L2_MEMORY_USERPTR:
 554                 vb32.m.userptr = (uintptr_t)(vb->m.userptr);
 555                 break;
 556         case V4L2_MEMORY_DMABUF:
 557                 vb32.m.fd = vb->m.fd;
 558                 break;
 559         }
 560
 561         if (V4L2_TYPE_IS_MULTIPLANAR(vb->type))
 562                 vb32.m.planes = (uintptr_t)vb->m.planes;
 563
 564         if (copy_to_user(arg, &vb32, sizeof(vb32)))
 565                 return -EFAULT;
 566
 567         return 0;
 568 }
 569 #endif
 570
 571 struct v4l2_framebuffer32 {
 572         __u32                   capability;
 573         __u32                   flags;
 574         compat_caddr_t          base;
 575         struct {
 576                 __u32           width;
 577                 __u32           height;
 578                 __u32           pixelformat;
 579                 __u32           field;
 580                 __u32           bytesperline;
 581                 __u32           sizeimage;
 582                 __u32           colorspace;
 583                 __u32           priv;
 584         } fmt;
 585 };
 586
 587 static int get_v4l2_framebuffer32(struct v4l2_framebuffer *p64,
 588                                   struct v4l2_framebuffer32 __user *p32)
 589 {
 590         if (get_user(p64->capability, &p32->capability) ||
 591             get_user(p64->flags, &p32->flags) ||
 592             copy_from_user(&p64->fmt, &p32->fmt, sizeof(p64->fmt)))
 593                 return -EFAULT;
 594         p64->base = NULL;
 595
 596         return 0;
 597 }
 598
 599 static int put_v4l2_framebuffer32(struct v4l2_framebuffer *p64,
 600                                   struct v4l2_framebuffer32 __user *p32)
 601 {
 602         if (put_user((uintptr_t)p64->base, &p32->base) ||
 603             put_user(p64->capability, &p32->capability) ||
 604             put_user(p64->flags, &p32->flags) ||
 605             copy_to_user(&p32->fmt, &p64->fmt, sizeof(p64->fmt)))
 606                 return -EFAULT;
 607
 608         return 0;
 609 }
 610
 611 struct v4l2_input32 {
 612         __u32        index;             /*  Which input */
 613         __u8         name[32];          /*  Label */
 614         __u32        type;              /*  Type of input */
 615         __u32        audioset;          /*  Associated audios (bitfield) */
 616         __u32        tuner;             /*  Associated tuner */
 617         compat_u64   std;
 618         __u32        status;
 619         __u32        capabilities;
 620         __u32        reserved[3];
 621 };
 622
 623 /*
 624  * The 64-bit v4l2_input struct has extra padding at the end of the struct.
 625  * Otherwise it is identical to the 32-bit version.
 626  */
 627 static inline int get_v4l2_input32(struct v4l2_input *p64,
 628                                    struct v4l2_input32 __user *p32)
 629 {
 630         if (copy_from_user(p64, p32, sizeof(*p32)))
 631                 return -EFAULT;
 632         return 0;
 633 }
 634
 635 static inline int put_v4l2_input32(struct v4l2_input *p64,
 636                                    struct v4l2_input32 __user *p32)
 637 {
 638         if (copy_to_user(p32, p64, sizeof(*p32)))
 639                 return -EFAULT;
 640         return 0;
 641 }
 642
 643 struct v4l2_ext_controls32 {
 644         __u32 which;
 645         __u32 count;
 646         __u32 error_idx;
 647         __s32 request_fd;
 648         __u32 reserved[1];
 649         compat_caddr_t controls; /* actually struct v4l2_ext_control32 * */
 650 };
 651
 652 struct v4l2_ext_control32 {
 653         __u32 id;
 654         __u32 size;
 655         __u32 reserved2[1];
 656         union {
 657                 __s32 value;
 658                 __s64 value64;
 659                 compat_caddr_t string; /* actually char * */
 660         };
 661 } __attribute__ ((packed));
 662
 663 /* Return true if this control is a pointer type. */
 664 static inline bool ctrl_is_pointer(struct file *file, u32 id)
 665 {
 666         struct video_device *vdev = video_devdata(file);
 667         struct v4l2_fh *fh = NULL;
 668         struct v4l2_ctrl_handler *hdl = NULL;
 669         struct v4l2_query_ext_ctrl qec = { id };
 670         const struct v4l2_ioctl_ops *ops = vdev->ioctl_ops;
 671
 672         if (test_bit(V4L2_FL_USES_V4L2_FH, &vdev->flags))
 673                 fh = file->private_data;
 674
 675         if (fh && fh->ctrl_handler)
 676                 hdl = fh->ctrl_handler;
 677         else if (vdev->ctrl_handler)
 678                 hdl = vdev->ctrl_handler;
 679
 680         if (hdl) {
 681                 struct v4l2_ctrl *ctrl = v4l2_ctrl_find(hdl, id);
 682
 683                 return ctrl && ctrl->is_ptr;
 684         }
 685
 686         if (!ops || !ops->vidioc_query_ext_ctrl)
 687                 return false;
 688
 689         return !ops->vidioc_query_ext_ctrl(file, fh, &qec) &&
 690                 (qec.flags & V4L2_CTRL_FLAG_HAS_PAYLOAD);
 691 }
 692
 693 static int get_v4l2_ext_controls32(struct v4l2_ext_controls *p64,
 694                                    struct v4l2_ext_controls32 __user *p32)
 695 {
 696         struct v4l2_ext_controls32 ec32;
 697
 698         if (copy_from_user(&ec32, p32, sizeof(ec32)))
 699                 return -EFAULT;
 700
 701         *p64 = (struct v4l2_ext_controls) {
 702                 .which          = ec32.which,
 703                 .count          = ec32.count,
 704                 .error_idx      = ec32.error_idx,
 705                 .request_fd     = ec32.request_fd,
 706                 .reserved[0]    = ec32.reserved[0],
 707                 .controls       = (void __force *)compat_ptr(ec32.controls),
 708         };
 709
 710         return 0;
 711 }
 712
 713 static int put_v4l2_ext_controls32(struct v4l2_ext_controls *p64,
 714                                    struct v4l2_ext_controls32 __user *p32)
 715 {
 716         struct v4l2_ext_controls32 ec32;
 717
 718         memset(&ec32, 0, sizeof(ec32));
 719         ec32 = (struct v4l2_ext_controls32) {
 720                 .which          = p64->which,
 721                 .count          = p64->count,
 722                 .error_idx      = p64->error_idx,
 723                 .request_fd     = p64->request_fd,
 724                 .reserved[0]    = p64->reserved[0],
 725                 .controls       = (uintptr_t)p64->controls,
 726         };
 727
 728         if (copy_to_user(p32, &ec32, sizeof(ec32)))
 729                 return -EFAULT;
 730
 731         return 0;
 732 }
 733
 734 #ifdef CONFIG_X86_64
 735 /*
 736  * x86 is the only compat architecture with different struct alignment
 737  * between 32-bit and 64-bit tasks.
 738  */
 739 struct v4l2_event32 {
 740         __u32                           type;
 741         union {
 742                 compat_s64              value64;
 743                 __u8                    data[64];
 744         } u;
 745         __u32                           pending;
 746         __u32                           sequence;
 747         struct {
 748                 compat_s64              tv_sec;
 749                 compat_s64              tv_nsec;
 750         } timestamp;
 751         __u32                           id;
 752         __u32                           reserved[8];
 753 };
 754
 755 static int put_v4l2_event32(struct v4l2_event *p64,
 756                             struct v4l2_event32 __user *p32)
 757 {
 758         if (put_user(p64->type, &p32->type) ||
 759             copy_to_user(&p32->u, &p64->u, sizeof(p64->u)) ||
 760             put_user(p64->pending, &p32->pending) ||
 761             put_user(p64->sequence, &p32->sequence) ||
 762             put_user(p64->timestamp.tv_sec, &p32->timestamp.tv_sec) ||
 763             put_user(p64->timestamp.tv_nsec, &p32->timestamp.tv_nsec) ||
 764             put_user(p64->id, &p32->id) ||
 765             copy_to_user(p32->reserved, p64->reserved, sizeof(p32->reserved)))
 766                 return -EFAULT;
 767         return 0;
 768 }
 769
 770 #endif
 771
 772 #ifdef CONFIG_COMPAT_32BIT_TIME
 773 struct v4l2_event32_time32 {
 774         __u32                           type;
 775         union {
 776                 compat_s64              value64;
 777                 __u8                    data[64];
 778         } u;
 779         __u32                           pending;
 780         __u32                           sequence;
 781         struct old_timespec32           timestamp;
 782         __u32                           id;
 783         __u32                           reserved[8];
 784 };
 785
 786 static int put_v4l2_event32_time32(struct v4l2_event *p64,
 787                                    struct v4l2_event32_time32 __user *p32)
 788 {
 789         if (put_user(p64->type, &p32->type) ||
 790             copy_to_user(&p32->u, &p64->u, sizeof(p64->u)) ||
 791             put_user(p64->pending, &p32->pending) ||
 792             put_user(p64->sequence, &p32->sequence) ||
 793             put_user(p64->timestamp.tv_sec, &p32->timestamp.tv_sec) ||
 794             put_user(p64->timestamp.tv_nsec, &p32->timestamp.tv_nsec) ||
 795             put_user(p64->id, &p32->id) ||
 796             copy_to_user(p32->reserved, p64->reserved, sizeof(p32->reserved)))
 797                 return -EFAULT;
 798         return 0;
 799 }
 800 #endif
 801
 802 struct v4l2_edid32 {
 803         __u32 pad;
 804         __u32 start_block;
 805         __u32 blocks;
 806         __u32 reserved[5];
 807         compat_caddr_t edid;
 808 };
 809
 810 static int get_v4l2_edid32(struct v4l2_edid *p64,
 811                            struct v4l2_edid32 __user *p32)
 812 {
 813         compat_uptr_t edid;
 814
 815         if (copy_from_user(p64, p32, offsetof(struct v4l2_edid32, edid)) ||
 816             get_user(edid, &p32->edid))
 817                 return -EFAULT;
 818
 819         p64->edid = (void __force *)compat_ptr(edid);
 820         return 0;
 821 }
 822
 823 static int put_v4l2_edid32(struct v4l2_edid *p64,
 824                            struct v4l2_edid32 __user *p32)
 825 {
 826         if (copy_to_user(p32, p64, offsetof(struct v4l2_edid32, edid)))
 827                 return -EFAULT;
 828         return 0;
 829 }
 830
 831 /*
 832  * List of ioctls that require 32-bits/64-bits conversion
 833  *
 834  * The V4L2 ioctls that aren't listed there don't have pointer arguments
 835  * and the struct size is identical for both 32 and 64 bits versions, so
 836  * they don't need translations.
 837  */
 838
 839 #define VIDIOC_G_FMT32          _IOWR('V',  4, struct v4l2_format32)
 840 #define VIDIOC_S_FMT32          _IOWR('V',  5, struct v4l2_format32)
 841 #define VIDIOC_QUERYBUF32       _IOWR('V',  9, struct v4l2_buffer32)
 842 #define VIDIOC_G_FBUF32         _IOR ('V', 10, struct v4l2_framebuffer32)
 843 #define VIDIOC_S_FBUF32         _IOW ('V', 11, struct v4l2_framebuffer32)
 844 #define VIDIOC_QBUF32           _IOWR('V', 15, struct v4l2_buffer32)
 845 #define VIDIOC_DQBUF32          _IOWR('V', 17, struct v4l2_buffer32)
 846 #define VIDIOC_ENUMSTD32        _IOWR('V', 25, struct v4l2_standard32)
 847 #define VIDIOC_ENUMINPUT32      _IOWR('V', 26, struct v4l2_input32)
 848 #define VIDIOC_G_EDID32         _IOWR('V', 40, struct v4l2_edid32)
 849 #define VIDIOC_S_EDID32         _IOWR('V', 41, struct v4l2_edid32)
 850 #define VIDIOC_TRY_FMT32        _IOWR('V', 64, struct v4l2_format32)
 851 #define VIDIOC_G_EXT_CTRLS32    _IOWR('V', 71, struct v4l2_ext_controls32)
 852 #define VIDIOC_S_EXT_CTRLS32    _IOWR('V', 72, struct v4l2_ext_controls32)
 853 #define VIDIOC_TRY_EXT_CTRLS32  _IOWR('V', 73, struct v4l2_ext_controls32)
 854 #define VIDIOC_DQEVENT32        _IOR ('V', 89, struct v4l2_event32)
 855 #define VIDIOC_CREATE_BUFS32    _IOWR('V', 92, struct v4l2_create_buffers32)
 856 #define VIDIOC_PREPARE_BUF32    _IOWR('V', 93, struct v4l2_buffer32)
 857
 858 #ifdef CONFIG_COMPAT_32BIT_TIME
 859 #define VIDIOC_QUERYBUF32_TIME32        _IOWR('V',  9, struct v4l2_buffer32_time32)
 860 #define VIDIOC_QBUF32_TIME32            _IOWR('V', 15, struct v4l2_buffer32_time32)
 861 #define VIDIOC_DQBUF32_TIME32           _IOWR('V', 17, struct v4l2_buffer32_time32)
 862 #define VIDIOC_DQEVENT32_TIME32         _IOR ('V', 89, struct v4l2_event32_time32)
 863 #define VIDIOC_PREPARE_BUF32_TIME32     _IOWR('V', 93, struct v4l2_buffer32_time32)
 864 #endif
 865
 866 unsigned int v4l2_compat_translate_cmd(unsigned int cmd)
 867 {
 868         switch (cmd) {
 869         case VIDIOC_G_FMT32:
 870                 return VIDIOC_G_FMT;
 871         case VIDIOC_S_FMT32:
 872                 return VIDIOC_S_FMT;
 873         case VIDIOC_TRY_FMT32:
 874                 return VIDIOC_TRY_FMT;
 875         case VIDIOC_G_FBUF32:
 876                 return VIDIOC_G_FBUF;
 877         case VIDIOC_S_FBUF32:
 878                 return VIDIOC_S_FBUF;
 879 #ifdef CONFIG_COMPAT_32BIT_TIME
 880         case VIDIOC_QUERYBUF32_TIME32:
 881                 return VIDIOC_QUERYBUF;
 882         case VIDIOC_QBUF32_TIME32:
 883                 return VIDIOC_QBUF;
 884         case VIDIOC_DQBUF32_TIME32:
 885                 return VIDIOC_DQBUF;
 886         case VIDIOC_PREPARE_BUF32_TIME32:
 887                 return VIDIOC_PREPARE_BUF;
 888 #endif
 889         case VIDIOC_QUERYBUF32:
 890                 return VIDIOC_QUERYBUF;
 891         case VIDIOC_QBUF32:
 892                 return VIDIOC_QBUF;
 893         case VIDIOC_DQBUF32:
 894                 return VIDIOC_DQBUF;
 895         case VIDIOC_CREATE_BUFS32:
 896                 return VIDIOC_CREATE_BUFS;
 897         case VIDIOC_G_EXT_CTRLS32:
 898                 return VIDIOC_G_EXT_CTRLS;
 899         case VIDIOC_S_EXT_CTRLS32:
 900                 return VIDIOC_S_EXT_CTRLS;
 901         case VIDIOC_TRY_EXT_CTRLS32:
 902                 return VIDIOC_TRY_EXT_CTRLS;
 903         case VIDIOC_PREPARE_BUF32:
 904                 return VIDIOC_PREPARE_BUF;
 905         case VIDIOC_ENUMSTD32:
 906                 return VIDIOC_ENUMSTD;
 907         case VIDIOC_ENUMINPUT32:
 908                 return VIDIOC_ENUMINPUT;
 909         case VIDIOC_G_EDID32:
 910                 return VIDIOC_G_EDID;
 911         case VIDIOC_S_EDID32:
 912                 return VIDIOC_S_EDID;
 913 #ifdef CONFIG_X86_64
 914         case VIDIOC_DQEVENT32:
 915                 return VIDIOC_DQEVENT;
 916 #endif
 917 #ifdef CONFIG_COMPAT_32BIT_TIME
 918         case VIDIOC_DQEVENT32_TIME32:
 919                 return VIDIOC_DQEVENT;
 920 #endif
 921         }
 922         return cmd;
 923 }
 924
 925 int v4l2_compat_get_user(void __user *arg, void *parg, unsigned int cmd)
 926 {
 927         switch (cmd) {
 928         case VIDIOC_G_FMT32:
 929         case VIDIOC_S_FMT32:
 930         case VIDIOC_TRY_FMT32:
 931                 return get_v4l2_format32(parg, arg);
 932
 933         case VIDIOC_S_FBUF32:
 934                 return get_v4l2_framebuffer32(parg, arg);
 935 #ifdef CONFIG_COMPAT_32BIT_TIME
 936         case VIDIOC_QUERYBUF32_TIME32:
 937         case VIDIOC_QBUF32_TIME32:
 938         case VIDIOC_DQBUF32_TIME32:
 939         case VIDIOC_PREPARE_BUF32_TIME32:
 940                 return get_v4l2_buffer32_time32(parg, arg);
 941 #endif
 942         case VIDIOC_QUERYBUF32:
 943         case VIDIOC_QBUF32:
 944         case VIDIOC_DQBUF32:
 945         case VIDIOC_PREPARE_BUF32:
 946                 return get_v4l2_buffer32(parg, arg);
 947
 948         case VIDIOC_G_EXT_CTRLS32:
 949         case VIDIOC_S_EXT_CTRLS32:
 950         case VIDIOC_TRY_EXT_CTRLS32:
 951                 return get_v4l2_ext_controls32(parg, arg);
 952
 953         case VIDIOC_CREATE_BUFS32:
 954                 return get_v4l2_create32(parg, arg);
 955
 956         case VIDIOC_ENUMSTD32:
 957                 return get_v4l2_standard32(parg, arg);
 958
 959         case VIDIOC_ENUMINPUT32:
 960                 return get_v4l2_input32(parg, arg);
 961
 962         case VIDIOC_G_EDID32:
 963         case VIDIOC_S_EDID32:
 964                 return get_v4l2_edid32(parg, arg);
 965         }
 966         return 0;
 967 }
 968
 969 int v4l2_compat_put_user(void __user *arg, void *parg, unsigned int cmd)
 970 {
 971         switch (cmd) {
 972         case VIDIOC_G_FMT32:
 973         case VIDIOC_S_FMT32:
 974         case VIDIOC_TRY_FMT32:
 975                 return put_v4l2_format32(parg, arg);
 976
 977         case VIDIOC_G_FBUF32:
 978                 return put_v4l2_framebuffer32(parg, arg);
 979 #ifdef CONFIG_COMPAT_32BIT_TIME
 980         case VIDIOC_QUERYBUF32_TIME32:
 981         case VIDIOC_QBUF32_TIME32:
 982         case VIDIOC_DQBUF32_TIME32:
 983         case VIDIOC_PREPARE_BUF32_TIME32:
 984                 return put_v4l2_buffer32_time32(parg, arg);
 985 #endif
 986         case VIDIOC_QUERYBUF32:
 987         case VIDIOC_QBUF32:
 988         case VIDIOC_DQBUF32:
 989         case VIDIOC_PREPARE_BUF32:
 990                 return put_v4l2_buffer32(parg, arg);
 991
 992         case VIDIOC_G_EXT_CTRLS32:
 993         case VIDIOC_S_EXT_CTRLS32:
 994         case VIDIOC_TRY_EXT_CTRLS32:
 995                 return put_v4l2_ext_controls32(parg, arg);
 996
 997         case VIDIOC_CREATE_BUFS32:
 998                 return put_v4l2_create32(parg, arg);
 999
1000         case VIDIOC_ENUMSTD32:
1001                 return put_v4l2_standard32(parg, arg);
1002
1003         case VIDIOC_ENUMINPUT32:
1004                 return put_v4l2_input32(parg, arg);
1005
1006         case VIDIOC_G_EDID32:
1007         case VIDIOC_S_EDID32:
1008                 return put_v4l2_edid32(parg, arg);
1009 #ifdef CONFIG_X86_64
1010         case VIDIOC_DQEVENT32:
1011                 return put_v4l2_event32(parg, arg);
1012 #endif
1013 #ifdef CONFIG_COMPAT_32BIT_TIME
1014         case VIDIOC_DQEVENT32_TIME32:
1015                 return put_v4l2_event32_time32(parg, arg);
1016 #endif
1017         }
1018         return 0;
1019 }
1020
1021 int v4l2_compat_get_array_args(struct file *file, void *mbuf,
1022                                void __user *user_ptr, size_t array_size,
1023                                unsigned int cmd, void *arg)
1024 {
1025         int err = 0;
1026
1027         memset(mbuf, 0, array_size);
1028
1029         switch (cmd) {
1030 #ifdef CONFIG_COMPAT_32BIT_TIME
1031         case VIDIOC_QUERYBUF32_TIME32:
1032         case VIDIOC_QBUF32_TIME32:
1033         case VIDIOC_DQBUF32_TIME32:
1034         case VIDIOC_PREPARE_BUF32_TIME32:
1035 #endif
1036         case VIDIOC_QUERYBUF32:
1037         case VIDIOC_QBUF32:
1038         case VIDIOC_DQBUF32:
1039         case VIDIOC_PREPARE_BUF32: {
1040                 struct v4l2_buffer *b64 = arg;
1041                 struct v4l2_plane *p64 = mbuf;
1042                 struct v4l2_plane32 __user *p32 = user_ptr;
1043
1044                 if (V4L2_TYPE_IS_MULTIPLANAR(b64->type)) {
1045                         u32 num_planes = b64->length;
1046
1047                         if (num_planes == 0)
1048                                 return 0;
1049
1050                         while (num_planes--) {
1051                                 err = get_v4l2_plane32(p64, p32, b64->memory);
1052                                 if (err)
1053                                         return err;
1054                                 ++p64;
1055                                 ++p32;
1056                         }
1057                 }
1058                 break;
1059         }
1060         case VIDIOC_G_EXT_CTRLS32:
1061         case VIDIOC_S_EXT_CTRLS32:
1062         case VIDIOC_TRY_EXT_CTRLS32: {
1063                 struct v4l2_ext_controls *ecs64 = arg;
1064                 struct v4l2_ext_control *ec64 = mbuf;
1065                 struct v4l2_ext_control32 __user *ec32 = user_ptr;
1066                 int n;
1067
1068                 for (n = 0; n < ecs64->count; n++) {
1069                         if (copy_from_user(ec64, ec32, sizeof(*ec32)))
1070                                 return -EFAULT;
1071
1072                         if (ctrl_is_pointer(file, ec64->id)) {
1073                                 compat_uptr_t p;
1074
1075                                 if (get_user(p, &ec32->string))
1076                                         return -EFAULT;
1077                                 ec64->string = compat_ptr(p);
1078                         }
1079                         ec32++;
1080                         ec64++;
1081                 }
1082                 break;
1083         }
1084         default:
1085                 if (copy_from_user(mbuf, user_ptr, array_size))
1086                         err = -EFAULT;
1087                 break;
1088         }
1089
1090         return err;
1091 }
1092
1093 int v4l2_compat_put_array_args(struct file *file, void __user *user_ptr,
1094                                void *mbuf, size_t array_size,
1095                                unsigned int cmd, void *arg)
1096 {
1097         int err = 0;
1098
1099         switch (cmd) {
1100 #ifdef CONFIG_COMPAT_32BIT_TIME
1101         case VIDIOC_QUERYBUF32_TIME32:
1102         case VIDIOC_QBUF32_TIME32:
1103         case VIDIOC_DQBUF32_TIME32:
1104         case VIDIOC_PREPARE_BUF32_TIME32:
1105 #endif
1106         case VIDIOC_QUERYBUF32:
1107         case VIDIOC_QBUF32:
1108         case VIDIOC_DQBUF32:
1109         case VIDIOC_PREPARE_BUF32: {
1110                 struct v4l2_buffer *b64 = arg;
1111                 struct v4l2_plane *p64 = mbuf;
1112                 struct v4l2_plane32 __user *p32 = user_ptr;
1113
1114                 if (V4L2_TYPE_IS_MULTIPLANAR(b64->type)) {
1115                         u32 num_planes = b64->length;
1116
1117                         if (num_planes == 0)
1118                                 return 0;
1119
1120                         while (num_planes--) {
1121                                 err = put_v4l2_plane32(p64, p32, b64->memory);
1122                                 if (err)
1123                                         return err;
1124                                 ++p64;
1125                                 ++p32;
1126                         }
1127                 }
1128                 break;
1129         }
1130         case VIDIOC_G_EXT_CTRLS32:
1131         case VIDIOC_S_EXT_CTRLS32:
1132         case VIDIOC_TRY_EXT_CTRLS32: {
1133                 struct v4l2_ext_controls *ecs64 = arg;
1134                 struct v4l2_ext_control *ec64 = mbuf;
1135                 struct v4l2_ext_control32 __user *ec32 = user_ptr;
1136                 int n;
1137
1138                 for (n = 0; n < ecs64->count; n++) {
1139                         unsigned int size = sizeof(*ec32);
1140                         /*
1141                          * Do not modify the pointer when copying a pointer
1142                          * control.  The contents of the pointer was changed,
1143                          * not the pointer itself.
1144                          * The structures are otherwise compatible.
1145                          */
1146                         if (ctrl_is_pointer(file, ec64->id))
1147                                 size -= sizeof(ec32->value64);
1148
1149                         if (copy_to_user(ec32, ec64, size))
1150                                 return -EFAULT;
1151
1152                         ec32++;
1153                         ec64++;
1154                 }
1155                 break;
1156         }
1157         default:
1158                 if (copy_to_user(user_ptr, mbuf, array_size))
1159                         err = -EFAULT;
1160                 break;
1161         }
1162
1163         return err;
1164 }
1165
1166 /**
1167  * v4l2_compat_ioctl32() - Handles a compat32 ioctl call
1168  *
1169  * @file: pointer to &struct file with the file handler
1170  * @cmd: ioctl to be called
1171  * @arg: arguments passed from/to the ioctl handler
1172  *
1173  * This function is meant to be used as .compat_ioctl fops at v4l2-dev.c
1174  * in order to deal with 32-bit calls on a 64-bits Kernel.
1175  *
1176  * This function calls do_video_ioctl() for non-private V4L2 ioctls.
1177  * If the function is a private one it calls vdev->fops->compat_ioctl32
1178  * instead.
1179  */
1180 long v4l2_compat_ioctl32(struct file *file, unsigned int cmd, unsigned long arg)
1181 {
1182         struct video_device *vdev = video_devdata(file);
1183         long ret = -ENOIOCTLCMD;
1184
1185         if (!file->f_op->unlocked_ioctl)
1186                 return ret;
1187
1188         if (!video_is_registered(vdev))
1189                 return -ENODEV;
1190
1191         if (_IOC_TYPE(cmd) == 'V' && _IOC_NR(cmd) < BASE_VIDIOC_PRIVATE)
1192                 ret = file->f_op->unlocked_ioctl(file, cmd,
1193                                         (unsigned long)compat_ptr(arg));
1194         else if (vdev->fops->compat_ioctl32)
1195                 ret = vdev->fops->compat_ioctl32(file, cmd, arg);
1196
1197         if (ret == -ENOIOCTLCMD)
1198                 pr_debug("compat_ioctl32: unknown ioctl '%c', dir=%d, #%d (0x%08x)\n",
1199                          _IOC_TYPE(cmd), _IOC_DIR(cmd), _IOC_NR(cmd), cmd);
1200         return ret;
1201 }
1202 EXPORT_SYMBOL_GPL(v4l2_compat_ioctl32);