drivers/media/v4l2-core/v4l2-ioctl.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Video capture interface for Linux version 2
   4  *
   5  * A generic framework to process V4L2 ioctl commands.
   6  *
   7  * Authors:     Alan Cox, <alan@lxorguk.ukuu.org.uk> (version 1)
   8  *              Mauro Carvalho Chehab <mchehab@kernel.org> (version 2)
   9  */
  10
  11 #include <linux/compat.h>
  12 #include <linux/mm.h>
  13 #include <linux/module.h>
  14 #include <linux/slab.h>
  15 #include <linux/types.h>
  16 #include <linux/kernel.h>
  17 #include <linux/version.h>
  18
  19 #include <linux/videodev2.h>
  20
  21 #include <media/v4l2-common.h>
  22 #include <media/v4l2-ioctl.h>
  23 #include <media/v4l2-ctrls.h>
  24 #include <media/v4l2-fh.h>
  25 #include <media/v4l2-event.h>
  26 #include <media/v4l2-device.h>
  27 #include <media/videobuf2-v4l2.h>
  28 #include <media/v4l2-mc.h>
  29 #include <media/v4l2-mem2mem.h>
  30
  31 #include <trace/events/v4l2.h>
  32
  33 /* Zero out the end of the struct pointed to by p.  Everything after, but
  34  * not including, the specified field is cleared. */
  35 #define CLEAR_AFTER_FIELD(p, field) \
  36         memset((u8 *)(p) + offsetof(typeof(*(p)), field) + sizeof((p)->field), \
  37         0, sizeof(*(p)) - offsetof(typeof(*(p)), field) - sizeof((p)->field))
  38
  39 #define is_valid_ioctl(vfd, cmd) test_bit(_IOC_NR(cmd), (vfd)->valid_ioctls)
  40
  41 struct std_descr {
  42         v4l2_std_id std;
  43         const char *descr;
  44 };
  45
  46 static const struct std_descr standards[] = {
  47         { V4L2_STD_NTSC,        "NTSC"      },
  48         { V4L2_STD_NTSC_M,      "NTSC-M"    },
  49         { V4L2_STD_NTSC_M_JP,   "NTSC-M-JP" },
  50         { V4L2_STD_NTSC_M_KR,   "NTSC-M-KR" },
  51         { V4L2_STD_NTSC_443,    "NTSC-443"  },
  52         { V4L2_STD_PAL,         "PAL"       },
  53         { V4L2_STD_PAL_BG,      "PAL-BG"    },
  54         { V4L2_STD_PAL_B,       "PAL-B"     },
  55         { V4L2_STD_PAL_B1,      "PAL-B1"    },
  56         { V4L2_STD_PAL_G,       "PAL-G"     },
  57         { V4L2_STD_PAL_H,       "PAL-H"     },
  58         { V4L2_STD_PAL_I,       "PAL-I"     },
  59         { V4L2_STD_PAL_DK,      "PAL-DK"    },
  60         { V4L2_STD_PAL_D,       "PAL-D"     },
  61         { V4L2_STD_PAL_D1,      "PAL-D1"    },
  62         { V4L2_STD_PAL_K,       "PAL-K"     },
  63         { V4L2_STD_PAL_M,       "PAL-M"     },
  64         { V4L2_STD_PAL_N,       "PAL-N"     },
  65         { V4L2_STD_PAL_Nc,      "PAL-Nc"    },
  66         { V4L2_STD_PAL_60,      "PAL-60"    },
  67         { V4L2_STD_SECAM,       "SECAM"     },
  68         { V4L2_STD_SECAM_B,     "SECAM-B"   },
  69         { V4L2_STD_SECAM_G,     "SECAM-G"   },
  70         { V4L2_STD_SECAM_H,     "SECAM-H"   },
  71         { V4L2_STD_SECAM_DK,    "SECAM-DK"  },
  72         { V4L2_STD_SECAM_D,     "SECAM-D"   },
  73         { V4L2_STD_SECAM_K,     "SECAM-K"   },
  74         { V4L2_STD_SECAM_K1,    "SECAM-K1"  },
  75         { V4L2_STD_SECAM_L,     "SECAM-L"   },
  76         { V4L2_STD_SECAM_LC,    "SECAM-Lc"  },
  77         { 0,                    "Unknown"   }
  78 };
  79
  80 /* video4linux standard ID conversion to standard name
  81  */
  82 const char *v4l2_norm_to_name(v4l2_std_id id)
  83 {
  84         u32 myid = id;
  85         int i;
  86
  87         /* HACK: ppc32 architecture doesn't have __ucmpdi2 function to handle
  88            64 bit comparisons. So, on that architecture, with some gcc
  89            variants, compilation fails. Currently, the max value is 30bit wide.
  90          */
  91         BUG_ON(myid != id);
  92
  93         for (i = 0; standards[i].std; i++)
  94                 if (myid == standards[i].std)
  95                         break;
  96         return standards[i].descr;
  97 }
  98 EXPORT_SYMBOL(v4l2_norm_to_name);
  99
 100 /* Returns frame period for the given standard */
 101 void v4l2_video_std_frame_period(int id, struct v4l2_fract *frameperiod)
 102 {
 103         if (id & V4L2_STD_525_60) {
 104                 frameperiod->numerator = 1001;
 105                 frameperiod->denominator = 30000;
 106         } else {
 107                 frameperiod->numerator = 1;
 108                 frameperiod->denominator = 25;
 109         }
 110 }
 111 EXPORT_SYMBOL(v4l2_video_std_frame_period);
 112
 113 /* Fill in the fields of a v4l2_standard structure according to the
 114    'id' and 'transmission' parameters.  Returns negative on error.  */
 115 int v4l2_video_std_construct(struct v4l2_standard *vs,
 116                              int id, const char *name)
 117 {
 118         vs->id = id;
 119         v4l2_video_std_frame_period(id, &vs->frameperiod);
 120         vs->framelines = (id & V4L2_STD_525_60) ? 525 : 625;
 121         strscpy(vs->name, name, sizeof(vs->name));
 122         return 0;
 123 }
 124 EXPORT_SYMBOL(v4l2_video_std_construct);
 125
 126 /* Fill in the fields of a v4l2_standard structure according to the
 127  * 'id' and 'vs->index' parameters. Returns negative on error. */
 128 int v4l_video_std_enumstd(struct v4l2_standard *vs, v4l2_std_id id)
 129 {
 130         v4l2_std_id curr_id = 0;
 131         unsigned int index = vs->index, i, j = 0;
 132         const char *descr = "";
 133
 134         /* Return -ENODATA if the id for the current input
 135            or output is 0, meaning that it doesn't support this API. */
 136         if (id == 0)
 137                 return -ENODATA;
 138
 139         /* Return norm array in a canonical way */
 140         for (i = 0; i <= index && id; i++) {
 141                 /* last std value in the standards array is 0, so this
 142                    while always ends there since (id & 0) == 0. */
 143                 while ((id & standards[j].std) != standards[j].std)
 144                         j++;
 145                 curr_id = standards[j].std;
 146                 descr = standards[j].descr;
 147                 j++;
 148                 if (curr_id == 0)
 149                         break;
 150                 if (curr_id != V4L2_STD_PAL &&
 151                                 curr_id != V4L2_STD_SECAM &&
 152                                 curr_id != V4L2_STD_NTSC)
 153                         id &= ~curr_id;
 154         }
 155         if (i <= index)
 156                 return -EINVAL;
 157
 158         v4l2_video_std_construct(vs, curr_id, descr);
 159         return 0;
 160 }
 161
 162 /* ----------------------------------------------------------------- */
 163 /* some arrays for pretty-printing debug messages of enum types      */
 164
 165 const char *v4l2_field_names[] = {
 166         [V4L2_FIELD_ANY]        = "any",
 167         [V4L2_FIELD_NONE]       = "none",
 168         [V4L2_FIELD_TOP]        = "top",
 169         [V4L2_FIELD_BOTTOM]     = "bottom",
 170         [V4L2_FIELD_INTERLACED] = "interlaced",
 171         [V4L2_FIELD_SEQ_TB]     = "seq-tb",
 172         [V4L2_FIELD_SEQ_BT]     = "seq-bt",
 173         [V4L2_FIELD_ALTERNATE]  = "alternate",
 174         [V4L2_FIELD_INTERLACED_TB] = "interlaced-tb",
 175         [V4L2_FIELD_INTERLACED_BT] = "interlaced-bt",
 176 };
 177 EXPORT_SYMBOL(v4l2_field_names);
 178
 179 const char *v4l2_type_names[] = {
 180         [0]                                = "0",
 181         [V4L2_BUF_TYPE_VIDEO_CAPTURE]      = "vid-cap",
 182         [V4L2_BUF_TYPE_VIDEO_OVERLAY]      = "vid-overlay",
 183         [V4L2_BUF_TYPE_VIDEO_OUTPUT]       = "vid-out",
 184         [V4L2_BUF_TYPE_VBI_CAPTURE]        = "vbi-cap",
 185         [V4L2_BUF_TYPE_VBI_OUTPUT]         = "vbi-out",
 186         [V4L2_BUF_TYPE_SLICED_VBI_CAPTURE] = "sliced-vbi-cap",
 187         [V4L2_BUF_TYPE_SLICED_VBI_OUTPUT]  = "sliced-vbi-out",
 188         [V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY] = "vid-out-overlay",
 189         [V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE] = "vid-cap-mplane",
 190         [V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE] = "vid-out-mplane",
 191         [V4L2_BUF_TYPE_SDR_CAPTURE]        = "sdr-cap",
 192         [V4L2_BUF_TYPE_SDR_OUTPUT]         = "sdr-out",
 193         [V4L2_BUF_TYPE_META_CAPTURE]       = "meta-cap",
 194         [V4L2_BUF_TYPE_META_OUTPUT]        = "meta-out",
 195 };
 196 EXPORT_SYMBOL(v4l2_type_names);
 197
 198 static const char *v4l2_memory_names[] = {
 199         [V4L2_MEMORY_MMAP]    = "mmap",
 200         [V4L2_MEMORY_USERPTR] = "userptr",
 201         [V4L2_MEMORY_OVERLAY] = "overlay",
 202         [V4L2_MEMORY_DMABUF] = "dmabuf",
 203 };
 204
 205 #define prt_names(a, arr) (((unsigned)(a)) < ARRAY_SIZE(arr) ? arr[a] : "unknown")
 206
 207 /* ------------------------------------------------------------------ */
 208 /* debug help functions                                               */
 209
 210 static void v4l_print_querycap(const void *arg, bool write_only)
 211 {
 212         const struct v4l2_capability *p = arg;
 213
 214         pr_cont("driver=%.*s, card=%.*s, bus=%.*s, version=0x%08x, capabilities=0x%08x, device_caps=0x%08x\n",
 215                 (int)sizeof(p->driver), p->driver,
 216                 (int)sizeof(p->card), p->card,
 217                 (int)sizeof(p->bus_info), p->bus_info,
 218                 p->version, p->capabilities, p->device_caps);
 219 }
 220
 221 static void v4l_print_enuminput(const void *arg, bool write_only)
 222 {
 223         const struct v4l2_input *p = arg;
 224
 225         pr_cont("index=%u, name=%.*s, type=%u, audioset=0x%x, tuner=%u, std=0x%08Lx, status=0x%x, capabilities=0x%x\n",
 226                 p->index, (int)sizeof(p->name), p->name, p->type, p->audioset,
 227                 p->tuner, (unsigned long long)p->std, p->status,
 228                 p->capabilities);
 229 }
 230
 231 static void v4l_print_enumoutput(const void *arg, bool write_only)
 232 {
 233         const struct v4l2_output *p = arg;
 234
 235         pr_cont("index=%u, name=%.*s, type=%u, audioset=0x%x, modulator=%u, std=0x%08Lx, capabilities=0x%x\n",
 236                 p->index, (int)sizeof(p->name), p->name, p->type, p->audioset,
 237                 p->modulator, (unsigned long long)p->std, p->capabilities);
 238 }
 239
 240 static void v4l_print_audio(const void *arg, bool write_only)
 241 {
 242         const struct v4l2_audio *p = arg;
 243
 244         if (write_only)
 245                 pr_cont("index=%u, mode=0x%x\n", p->index, p->mode);
 246         else
 247                 pr_cont("index=%u, name=%.*s, capability=0x%x, mode=0x%x\n",
 248                         p->index, (int)sizeof(p->name), p->name,
 249                         p->capability, p->mode);
 250 }
 251
 252 static void v4l_print_audioout(const void *arg, bool write_only)
 253 {
 254         const struct v4l2_audioout *p = arg;
 255
 256         if (write_only)
 257                 pr_cont("index=%u\n", p->index);
 258         else
 259                 pr_cont("index=%u, name=%.*s, capability=0x%x, mode=0x%x\n",
 260                         p->index, (int)sizeof(p->name), p->name,
 261                         p->capability, p->mode);
 262 }
 263
 264 static void v4l_print_fmtdesc(const void *arg, bool write_only)
 265 {
 266         const struct v4l2_fmtdesc *p = arg;
 267
 268         pr_cont("index=%u, type=%s, flags=0x%x, pixelformat=%p4cc, mbus_code=0x%04x, description='%.*s'\n",
 269                 p->index, prt_names(p->type, v4l2_type_names),
 270                 p->flags, &p->pixelformat, p->mbus_code,
 271                 (int)sizeof(p->description), p->description);
 272 }
 273
 274 static void v4l_print_format(const void *arg, bool write_only)
 275 {
 276         const struct v4l2_format *p = arg;
 277         const struct v4l2_pix_format *pix;
 278         const struct v4l2_pix_format_mplane *mp;
 279         const struct v4l2_vbi_format *vbi;
 280         const struct v4l2_sliced_vbi_format *sliced;
 281         const struct v4l2_window *win;
 282         const struct v4l2_meta_format *meta;
 283         u32 pixelformat;
 284         u32 planes;
 285         unsigned i;
 286
 287         pr_cont("type=%s", prt_names(p->type, v4l2_type_names));
 288         switch (p->type) {
 289         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 290         case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 291                 pix = &p->fmt.pix;
 292                 pr_cont(", width=%u, height=%u, pixelformat=%p4cc, field=%s, bytesperline=%u, sizeimage=%u, colorspace=%d, flags=0x%x, ycbcr_enc=%u, quantization=%u, xfer_func=%u\n",
 293                         pix->width, pix->height, &pix->pixelformat,
 294                         prt_names(pix->field, v4l2_field_names),
 295                         pix->bytesperline, pix->sizeimage,
 296                         pix->colorspace, pix->flags, pix->ycbcr_enc,
 297                         pix->quantization, pix->xfer_func);
 298                 break;
 299         case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
 300         case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
 301                 mp = &p->fmt.pix_mp;
 302                 pixelformat = mp->pixelformat;
 303                 pr_cont(", width=%u, height=%u, format=%p4cc, field=%s, colorspace=%d, num_planes=%u, flags=0x%x, ycbcr_enc=%u, quantization=%u, xfer_func=%u\n",
 304                         mp->width, mp->height, &pixelformat,
 305                         prt_names(mp->field, v4l2_field_names),
 306                         mp->colorspace, mp->num_planes, mp->flags,
 307                         mp->ycbcr_enc, mp->quantization, mp->xfer_func);
 308                 planes = min_t(u32, mp->num_planes, VIDEO_MAX_PLANES);
 309                 for (i = 0; i < planes; i++)
 310                         printk(KERN_DEBUG "plane %u: bytesperline=%u sizeimage=%u\n", i,
 311                                         mp->plane_fmt[i].bytesperline,
 312                                         mp->plane_fmt[i].sizeimage);
 313                 break;
 314         case V4L2_BUF_TYPE_VIDEO_OVERLAY:
 315         case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
 316                 win = &p->fmt.win;
 317                 /* Note: we can't print the clip list here since the clips
 318                  * pointer is a userspace pointer, not a kernelspace
 319                  * pointer. */
 320                 pr_cont(", wxh=%dx%d, x,y=%d,%d, field=%s, chromakey=0x%08x, clipcount=%u, clips=%p, bitmap=%p, global_alpha=0x%02x\n",
 321                         win->w.width, win->w.height, win->w.left, win->w.top,
 322                         prt_names(win->field, v4l2_field_names),
 323                         win->chromakey, win->clipcount, win->clips,
 324                         win->bitmap, win->global_alpha);
 325                 break;
 326         case V4L2_BUF_TYPE_VBI_CAPTURE:
 327         case V4L2_BUF_TYPE_VBI_OUTPUT:
 328                 vbi = &p->fmt.vbi;
 329                 pr_cont(", sampling_rate=%u, offset=%u, samples_per_line=%u, sample_format=%p4cc, start=%u,%u, count=%u,%u\n",
 330                         vbi->sampling_rate, vbi->offset,
 331                         vbi->samples_per_line, &vbi->sample_format,
 332                         vbi->start[0], vbi->start[1],
 333                         vbi->count[0], vbi->count[1]);
 334                 break;
 335         case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
 336         case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
 337                 sliced = &p->fmt.sliced;
 338                 pr_cont(", service_set=0x%08x, io_size=%d\n",
 339                                 sliced->service_set, sliced->io_size);
 340                 for (i = 0; i < 24; i++)
 341                         printk(KERN_DEBUG "line[%02u]=0x%04x, 0x%04x\n", i,
 342                                 sliced->service_lines[0][i],
 343                                 sliced->service_lines[1][i]);
 344                 break;
 345         case V4L2_BUF_TYPE_SDR_CAPTURE:
 346         case V4L2_BUF_TYPE_SDR_OUTPUT:
 347                 pixelformat = p->fmt.sdr.pixelformat;
 348                 pr_cont(", pixelformat=%p4cc\n", &pixelformat);
 349                 break;
 350         case V4L2_BUF_TYPE_META_CAPTURE:
 351         case V4L2_BUF_TYPE_META_OUTPUT:
 352                 meta = &p->fmt.meta;
 353                 pixelformat = meta->dataformat;
 354                 pr_cont(", dataformat=%p4cc, buffersize=%u\n",
 355                         &pixelformat, meta->buffersize);
 356                 break;
 357         }
 358 }
 359
 360 static void v4l_print_framebuffer(const void *arg, bool write_only)
 361 {
 362         const struct v4l2_framebuffer *p = arg;
 363
 364         pr_cont("capability=0x%x, flags=0x%x, base=0x%p, width=%u, height=%u, pixelformat=%p4cc, bytesperline=%u, sizeimage=%u, colorspace=%d\n",
 365                 p->capability, p->flags, p->base, p->fmt.width, p->fmt.height,
 366                 &p->fmt.pixelformat, p->fmt.bytesperline, p->fmt.sizeimage,
 367                 p->fmt.colorspace);
 368 }
 369
 370 static void v4l_print_buftype(const void *arg, bool write_only)
 371 {
 372         pr_cont("type=%s\n", prt_names(*(u32 *)arg, v4l2_type_names));
 373 }
 374
 375 static void v4l_print_modulator(const void *arg, bool write_only)
 376 {
 377         const struct v4l2_modulator *p = arg;
 378
 379         if (write_only)
 380                 pr_cont("index=%u, txsubchans=0x%x\n", p->index, p->txsubchans);
 381         else
 382                 pr_cont("index=%u, name=%.*s, capability=0x%x, rangelow=%u, rangehigh=%u, txsubchans=0x%x\n",
 383                         p->index, (int)sizeof(p->name), p->name, p->capability,
 384                         p->rangelow, p->rangehigh, p->txsubchans);
 385 }
 386
 387 static void v4l_print_tuner(const void *arg, bool write_only)
 388 {
 389         const struct v4l2_tuner *p = arg;
 390
 391         if (write_only)
 392                 pr_cont("index=%u, audmode=%u\n", p->index, p->audmode);
 393         else
 394                 pr_cont("index=%u, name=%.*s, type=%u, capability=0x%x, rangelow=%u, rangehigh=%u, signal=%u, afc=%d, rxsubchans=0x%x, audmode=%u\n",
 395                         p->index, (int)sizeof(p->name), p->name, p->type,
 396                         p->capability, p->rangelow,
 397                         p->rangehigh, p->signal, p->afc,
 398                         p->rxsubchans, p->audmode);
 399 }
 400
 401 static void v4l_print_frequency(const void *arg, bool write_only)
 402 {
 403         const struct v4l2_frequency *p = arg;
 404
 405         pr_cont("tuner=%u, type=%u, frequency=%u\n",
 406                                 p->tuner, p->type, p->frequency);
 407 }
 408
 409 static void v4l_print_standard(const void *arg, bool write_only)
 410 {
 411         const struct v4l2_standard *p = arg;
 412
 413         pr_cont("index=%u, id=0x%Lx, name=%.*s, fps=%u/%u, framelines=%u\n",
 414                 p->index,
 415                 (unsigned long long)p->id, (int)sizeof(p->name), p->name,
 416                 p->frameperiod.numerator,
 417                 p->frameperiod.denominator,
 418                 p->framelines);
 419 }
 420
 421 static void v4l_print_std(const void *arg, bool write_only)
 422 {
 423         pr_cont("std=0x%08Lx\n", *(const long long unsigned *)arg);
 424 }
 425
 426 static void v4l_print_hw_freq_seek(const void *arg, bool write_only)
 427 {
 428         const struct v4l2_hw_freq_seek *p = arg;
 429
 430         pr_cont("tuner=%u, type=%u, seek_upward=%u, wrap_around=%u, spacing=%u, rangelow=%u, rangehigh=%u\n",
 431                 p->tuner, p->type, p->seek_upward, p->wrap_around, p->spacing,
 432                 p->rangelow, p->rangehigh);
 433 }
 434
 435 static void v4l_print_requestbuffers(const void *arg, bool write_only)
 436 {
 437         const struct v4l2_requestbuffers *p = arg;
 438
 439         pr_cont("count=%d, type=%s, memory=%s\n",
 440                 p->count,
 441                 prt_names(p->type, v4l2_type_names),
 442                 prt_names(p->memory, v4l2_memory_names));
 443 }
 444
 445 static void v4l_print_buffer(const void *arg, bool write_only)
 446 {
 447         const struct v4l2_buffer *p = arg;
 448         const struct v4l2_timecode *tc = &p->timecode;
 449         const struct v4l2_plane *plane;
 450         int i;
 451
 452         pr_cont("%02d:%02d:%02d.%06ld index=%d, type=%s, request_fd=%d, flags=0x%08x, field=%s, sequence=%d, memory=%s",
 453                         (int)p->timestamp.tv_sec / 3600,
 454                         ((int)p->timestamp.tv_sec / 60) % 60,
 455                         ((int)p->timestamp.tv_sec % 60),
 456                         (long)p->timestamp.tv_usec,
 457                         p->index,
 458                         prt_names(p->type, v4l2_type_names), p->request_fd,
 459                         p->flags, prt_names(p->field, v4l2_field_names),
 460                         p->sequence, prt_names(p->memory, v4l2_memory_names));
 461
 462         if (V4L2_TYPE_IS_MULTIPLANAR(p->type) && p->m.planes) {
 463                 pr_cont("\n");
 464                 for (i = 0; i < p->length; ++i) {
 465                         plane = &p->m.planes[i];
 466                         printk(KERN_DEBUG
 467                                 "plane %d: bytesused=%d, data_offset=0x%08x, offset/userptr=0x%lx, length=%d\n",
 468                                 i, plane->bytesused, plane->data_offset,
 469                                 plane->m.userptr, plane->length);
 470                 }
 471         } else {
 472                 pr_cont(", bytesused=%d, offset/userptr=0x%lx, length=%d\n",
 473                         p->bytesused, p->m.userptr, p->length);
 474         }
 475
 476         printk(KERN_DEBUG "timecode=%02d:%02d:%02d type=%d, flags=0x%08x, frames=%d, userbits=0x%08x\n",
 477                         tc->hours, tc->minutes, tc->seconds,
 478                         tc->type, tc->flags, tc->frames, *(__u32 *)tc->userbits);
 479 }
 480
 481 static void v4l_print_exportbuffer(const void *arg, bool write_only)
 482 {
 483         const struct v4l2_exportbuffer *p = arg;
 484
 485         pr_cont("fd=%d, type=%s, index=%u, plane=%u, flags=0x%08x\n",
 486                 p->fd, prt_names(p->type, v4l2_type_names),
 487                 p->index, p->plane, p->flags);
 488 }
 489
 490 static void v4l_print_create_buffers(const void *arg, bool write_only)
 491 {
 492         const struct v4l2_create_buffers *p = arg;
 493
 494         pr_cont("index=%d, count=%d, memory=%s, capabilities=0x%08x, ",
 495                 p->index, p->count, prt_names(p->memory, v4l2_memory_names),
 496                 p->capabilities);
 497         v4l_print_format(&p->format, write_only);
 498 }
 499
 500 static void v4l_print_streamparm(const void *arg, bool write_only)
 501 {
 502         const struct v4l2_streamparm *p = arg;
 503
 504         pr_cont("type=%s", prt_names(p->type, v4l2_type_names));
 505
 506         if (p->type == V4L2_BUF_TYPE_VIDEO_CAPTURE ||
 507             p->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
 508                 const struct v4l2_captureparm *c = &p->parm.capture;
 509
 510                 pr_cont(", capability=0x%x, capturemode=0x%x, timeperframe=%d/%d, extendedmode=%d, readbuffers=%d\n",
 511                         c->capability, c->capturemode,
 512                         c->timeperframe.numerator, c->timeperframe.denominator,
 513                         c->extendedmode, c->readbuffers);
 514         } else if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT ||
 515                    p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
 516                 const struct v4l2_outputparm *c = &p->parm.output;
 517
 518                 pr_cont(", capability=0x%x, outputmode=0x%x, timeperframe=%d/%d, extendedmode=%d, writebuffers=%d\n",
 519                         c->capability, c->outputmode,
 520                         c->timeperframe.numerator, c->timeperframe.denominator,
 521                         c->extendedmode, c->writebuffers);
 522         } else {
 523                 pr_cont("\n");
 524         }
 525 }
 526
 527 static void v4l_print_queryctrl(const void *arg, bool write_only)
 528 {
 529         const struct v4l2_queryctrl *p = arg;
 530
 531         pr_cont("id=0x%x, type=%d, name=%.*s, min/max=%d/%d, step=%d, default=%d, flags=0x%08x\n",
 532                         p->id, p->type, (int)sizeof(p->name), p->name,
 533                         p->minimum, p->maximum,
 534                         p->step, p->default_value, p->flags);
 535 }
 536
 537 static void v4l_print_query_ext_ctrl(const void *arg, bool write_only)
 538 {
 539         const struct v4l2_query_ext_ctrl *p = arg;
 540
 541         pr_cont("id=0x%x, type=%d, name=%.*s, min/max=%lld/%lld, step=%lld, default=%lld, flags=0x%08x, elem_size=%u, elems=%u, nr_of_dims=%u, dims=%u,%u,%u,%u\n",
 542                         p->id, p->type, (int)sizeof(p->name), p->name,
 543                         p->minimum, p->maximum,
 544                         p->step, p->default_value, p->flags,
 545                         p->elem_size, p->elems, p->nr_of_dims,
 546                         p->dims[0], p->dims[1], p->dims[2], p->dims[3]);
 547 }
 548
 549 static void v4l_print_querymenu(const void *arg, bool write_only)
 550 {
 551         const struct v4l2_querymenu *p = arg;
 552
 553         pr_cont("id=0x%x, index=%d\n", p->id, p->index);
 554 }
 555
 556 static void v4l_print_control(const void *arg, bool write_only)
 557 {
 558         const struct v4l2_control *p = arg;
 559         const char *name = v4l2_ctrl_get_name(p->id);
 560
 561         if (name)
 562                 pr_cont("name=%s, ", name);
 563         pr_cont("id=0x%x, value=%d\n", p->id, p->value);
 564 }
 565
 566 static void v4l_print_ext_controls(const void *arg, bool write_only)
 567 {
 568         const struct v4l2_ext_controls *p = arg;
 569         int i;
 570
 571         pr_cont("which=0x%x, count=%d, error_idx=%d, request_fd=%d",
 572                         p->which, p->count, p->error_idx, p->request_fd);
 573         for (i = 0; i < p->count; i++) {
 574                 unsigned int id = p->controls[i].id;
 575                 const char *name = v4l2_ctrl_get_name(id);
 576
 577                 if (name)
 578                         pr_cont(", name=%s", name);
 579                 if (!p->controls[i].size)
 580                         pr_cont(", id/val=0x%x/0x%x", id, p->controls[i].value);
 581                 else
 582                         pr_cont(", id/size=0x%x/%u", id, p->controls[i].size);
 583         }
 584         pr_cont("\n");
 585 }
 586
 587 static void v4l_print_cropcap(const void *arg, bool write_only)
 588 {
 589         const struct v4l2_cropcap *p = arg;
 590
 591         pr_cont("type=%s, bounds wxh=%dx%d, x,y=%d,%d, defrect wxh=%dx%d, x,y=%d,%d, pixelaspect %d/%d\n",
 592                 prt_names(p->type, v4l2_type_names),
 593                 p->bounds.width, p->bounds.height,
 594                 p->bounds.left, p->bounds.top,
 595                 p->defrect.width, p->defrect.height,
 596                 p->defrect.left, p->defrect.top,
 597                 p->pixelaspect.numerator, p->pixelaspect.denominator);
 598 }
 599
 600 static void v4l_print_crop(const void *arg, bool write_only)
 601 {
 602         const struct v4l2_crop *p = arg;
 603
 604         pr_cont("type=%s, wxh=%dx%d, x,y=%d,%d\n",
 605                 prt_names(p->type, v4l2_type_names),
 606                 p->c.width, p->c.height,
 607                 p->c.left, p->c.top);
 608 }
 609
 610 static void v4l_print_selection(const void *arg, bool write_only)
 611 {
 612         const struct v4l2_selection *p = arg;
 613
 614         pr_cont("type=%s, target=%d, flags=0x%x, wxh=%dx%d, x,y=%d,%d\n",
 615                 prt_names(p->type, v4l2_type_names),
 616                 p->target, p->flags,
 617                 p->r.width, p->r.height, p->r.left, p->r.top);
 618 }
 619
 620 static void v4l_print_jpegcompression(const void *arg, bool write_only)
 621 {
 622         const struct v4l2_jpegcompression *p = arg;
 623
 624         pr_cont("quality=%d, APPn=%d, APP_len=%d, COM_len=%d, jpeg_markers=0x%x\n",
 625                 p->quality, p->APPn, p->APP_len,
 626                 p->COM_len, p->jpeg_markers);
 627 }
 628
 629 static void v4l_print_enc_idx(const void *arg, bool write_only)
 630 {
 631         const struct v4l2_enc_idx *p = arg;
 632
 633         pr_cont("entries=%d, entries_cap=%d\n",
 634                         p->entries, p->entries_cap);
 635 }
 636
 637 static void v4l_print_encoder_cmd(const void *arg, bool write_only)
 638 {
 639         const struct v4l2_encoder_cmd *p = arg;
 640
 641         pr_cont("cmd=%d, flags=0x%x\n",
 642                         p->cmd, p->flags);
 643 }
 644
 645 static void v4l_print_decoder_cmd(const void *arg, bool write_only)
 646 {
 647         const struct v4l2_decoder_cmd *p = arg;
 648
 649         pr_cont("cmd=%d, flags=0x%x\n", p->cmd, p->flags);
 650
 651         if (p->cmd == V4L2_DEC_CMD_START)
 652                 pr_info("speed=%d, format=%u\n",
 653                                 p->start.speed, p->start.format);
 654         else if (p->cmd == V4L2_DEC_CMD_STOP)
 655                 pr_info("pts=%llu\n", p->stop.pts);
 656 }
 657
 658 static void v4l_print_dbg_chip_info(const void *arg, bool write_only)
 659 {
 660         const struct v4l2_dbg_chip_info *p = arg;
 661
 662         pr_cont("type=%u, ", p->match.type);
 663         if (p->match.type == V4L2_CHIP_MATCH_I2C_DRIVER)
 664                 pr_cont("name=%.*s, ",
 665                                 (int)sizeof(p->match.name), p->match.name);
 666         else
 667                 pr_cont("addr=%u, ", p->match.addr);
 668         pr_cont("name=%.*s\n", (int)sizeof(p->name), p->name);
 669 }
 670
 671 static void v4l_print_dbg_register(const void *arg, bool write_only)
 672 {
 673         const struct v4l2_dbg_register *p = arg;
 674
 675         pr_cont("type=%u, ", p->match.type);
 676         if (p->match.type == V4L2_CHIP_MATCH_I2C_DRIVER)
 677                 pr_cont("name=%.*s, ",
 678                                 (int)sizeof(p->match.name), p->match.name);
 679         else
 680                 pr_cont("addr=%u, ", p->match.addr);
 681         pr_cont("reg=0x%llx, val=0x%llx\n",
 682                         p->reg, p->val);
 683 }
 684
 685 static void v4l_print_dv_timings(const void *arg, bool write_only)
 686 {
 687         const struct v4l2_dv_timings *p = arg;
 688
 689         switch (p->type) {
 690         case V4L2_DV_BT_656_1120:
 691                 pr_cont("type=bt-656/1120, interlaced=%u, pixelclock=%llu, width=%u, height=%u, polarities=0x%x, hfrontporch=%u, hsync=%u, hbackporch=%u, vfrontporch=%u, vsync=%u, vbackporch=%u, il_vfrontporch=%u, il_vsync=%u, il_vbackporch=%u, standards=0x%x, flags=0x%x\n",
 692                                 p->bt.interlaced, p->bt.pixelclock,
 693                                 p->bt.width, p->bt.height,
 694                                 p->bt.polarities, p->bt.hfrontporch,
 695                                 p->bt.hsync, p->bt.hbackporch,
 696                                 p->bt.vfrontporch, p->bt.vsync,
 697                                 p->bt.vbackporch, p->bt.il_vfrontporch,
 698                                 p->bt.il_vsync, p->bt.il_vbackporch,
 699                                 p->bt.standards, p->bt.flags);
 700                 break;
 701         default:
 702                 pr_cont("type=%d\n", p->type);
 703                 break;
 704         }
 705 }
 706
 707 static void v4l_print_enum_dv_timings(const void *arg, bool write_only)
 708 {
 709         const struct v4l2_enum_dv_timings *p = arg;
 710
 711         pr_cont("index=%u, ", p->index);
 712         v4l_print_dv_timings(&p->timings, write_only);
 713 }
 714
 715 static void v4l_print_dv_timings_cap(const void *arg, bool write_only)
 716 {
 717         const struct v4l2_dv_timings_cap *p = arg;
 718
 719         switch (p->type) {
 720         case V4L2_DV_BT_656_1120:
 721                 pr_cont("type=bt-656/1120, width=%u-%u, height=%u-%u, pixelclock=%llu-%llu, standards=0x%x, capabilities=0x%x\n",
 722                         p->bt.min_width, p->bt.max_width,
 723                         p->bt.min_height, p->bt.max_height,
 724                         p->bt.min_pixelclock, p->bt.max_pixelclock,
 725                         p->bt.standards, p->bt.capabilities);
 726                 break;
 727         default:
 728                 pr_cont("type=%u\n", p->type);
 729                 break;
 730         }
 731 }
 732
 733 static void v4l_print_frmsizeenum(const void *arg, bool write_only)
 734 {
 735         const struct v4l2_frmsizeenum *p = arg;
 736
 737         pr_cont("index=%u, pixelformat=%p4cc, type=%u",
 738                 p->index, &p->pixel_format, p->type);
 739         switch (p->type) {
 740         case V4L2_FRMSIZE_TYPE_DISCRETE:
 741                 pr_cont(", wxh=%ux%u\n",
 742                         p->discrete.width, p->discrete.height);
 743                 break;
 744         case V4L2_FRMSIZE_TYPE_STEPWISE:
 745                 pr_cont(", min=%ux%u, max=%ux%u, step=%ux%u\n",
 746                                 p->stepwise.min_width,
 747                                 p->stepwise.min_height,
 748                                 p->stepwise.max_width,
 749                                 p->stepwise.max_height,
 750                                 p->stepwise.step_width,
 751                                 p->stepwise.step_height);
 752                 break;
 753         case V4L2_FRMSIZE_TYPE_CONTINUOUS:
 754         default:
 755                 pr_cont("\n");
 756                 break;
 757         }
 758 }
 759
 760 static void v4l_print_frmivalenum(const void *arg, bool write_only)
 761 {
 762         const struct v4l2_frmivalenum *p = arg;
 763
 764         pr_cont("index=%u, pixelformat=%p4cc, wxh=%ux%u, type=%u",
 765                 p->index, &p->pixel_format, p->width, p->height, p->type);
 766         switch (p->type) {
 767         case V4L2_FRMIVAL_TYPE_DISCRETE:
 768                 pr_cont(", fps=%d/%d\n",
 769                                 p->discrete.numerator,
 770                                 p->discrete.denominator);
 771                 break;
 772         case V4L2_FRMIVAL_TYPE_STEPWISE:
 773                 pr_cont(", min=%d/%d, max=%d/%d, step=%d/%d\n",
 774                                 p->stepwise.min.numerator,
 775                                 p->stepwise.min.denominator,
 776                                 p->stepwise.max.numerator,
 777                                 p->stepwise.max.denominator,
 778                                 p->stepwise.step.numerator,
 779                                 p->stepwise.step.denominator);
 780                 break;
 781         case V4L2_FRMIVAL_TYPE_CONTINUOUS:
 782         default:
 783                 pr_cont("\n");
 784                 break;
 785         }
 786 }
 787
 788 static void v4l_print_event(const void *arg, bool write_only)
 789 {
 790         const struct v4l2_event *p = arg;
 791         const struct v4l2_event_ctrl *c;
 792
 793         pr_cont("type=0x%x, pending=%u, sequence=%u, id=%u, timestamp=%llu.%9.9llu\n",
 794                         p->type, p->pending, p->sequence, p->id,
 795                         p->timestamp.tv_sec, p->timestamp.tv_nsec);
 796         switch (p->type) {
 797         case V4L2_EVENT_VSYNC:
 798                 printk(KERN_DEBUG "field=%s\n",
 799                         prt_names(p->u.vsync.field, v4l2_field_names));
 800                 break;
 801         case V4L2_EVENT_CTRL:
 802                 c = &p->u.ctrl;
 803                 printk(KERN_DEBUG "changes=0x%x, type=%u, ",
 804                         c->changes, c->type);
 805                 if (c->type == V4L2_CTRL_TYPE_INTEGER64)
 806                         pr_cont("value64=%lld, ", c->value64);
 807                 else
 808                         pr_cont("value=%d, ", c->value);
 809                 pr_cont("flags=0x%x, minimum=%d, maximum=%d, step=%d, default_value=%d\n",
 810                         c->flags, c->minimum, c->maximum,
 811                         c->step, c->default_value);
 812                 break;
 813         case V4L2_EVENT_FRAME_SYNC:
 814                 pr_cont("frame_sequence=%u\n",
 815                         p->u.frame_sync.frame_sequence);
 816                 break;
 817         }
 818 }
 819
 820 static void v4l_print_event_subscription(const void *arg, bool write_only)
 821 {
 822         const struct v4l2_event_subscription *p = arg;
 823
 824         pr_cont("type=0x%x, id=0x%x, flags=0x%x\n",
 825                         p->type, p->id, p->flags);
 826 }
 827
 828 static void v4l_print_sliced_vbi_cap(const void *arg, bool write_only)
 829 {
 830         const struct v4l2_sliced_vbi_cap *p = arg;
 831         int i;
 832
 833         pr_cont("type=%s, service_set=0x%08x\n",
 834                         prt_names(p->type, v4l2_type_names), p->service_set);
 835         for (i = 0; i < 24; i++)
 836                 printk(KERN_DEBUG "line[%02u]=0x%04x, 0x%04x\n", i,
 837                                 p->service_lines[0][i],
 838                                 p->service_lines[1][i]);
 839 }
 840
 841 static void v4l_print_freq_band(const void *arg, bool write_only)
 842 {
 843         const struct v4l2_frequency_band *p = arg;
 844
 845         pr_cont("tuner=%u, type=%u, index=%u, capability=0x%x, rangelow=%u, rangehigh=%u, modulation=0x%x\n",
 846                         p->tuner, p->type, p->index,
 847                         p->capability, p->rangelow,
 848                         p->rangehigh, p->modulation);
 849 }
 850
 851 static void v4l_print_edid(const void *arg, bool write_only)
 852 {
 853         const struct v4l2_edid *p = arg;
 854
 855         pr_cont("pad=%u, start_block=%u, blocks=%u\n",
 856                 p->pad, p->start_block, p->blocks);
 857 }
 858
 859 static void v4l_print_u32(const void *arg, bool write_only)
 860 {
 861         pr_cont("value=%u\n", *(const u32 *)arg);
 862 }
 863
 864 static void v4l_print_newline(const void *arg, bool write_only)
 865 {
 866         pr_cont("\n");
 867 }
 868
 869 static void v4l_print_default(const void *arg, bool write_only)
 870 {
 871         pr_cont("driver-specific ioctl\n");
 872 }
 873
 874 static bool check_ext_ctrls(struct v4l2_ext_controls *c, unsigned long ioctl)
 875 {
 876         __u32 i;
 877
 878         /* zero the reserved fields */
 879         c->reserved[0] = 0;
 880         for (i = 0; i < c->count; i++)
 881                 c->controls[i].reserved2[0] = 0;
 882
 883         switch (c->which) {
 884         case V4L2_CID_PRIVATE_BASE:
 885                 /*
 886                  * V4L2_CID_PRIVATE_BASE cannot be used as control class
 887                  * when using extended controls.
 888                  * Only when passed in through VIDIOC_G_CTRL and VIDIOC_S_CTRL
 889                  * is it allowed for backwards compatibility.
 890                  */
 891                 if (ioctl == VIDIOC_G_CTRL || ioctl == VIDIOC_S_CTRL)
 892                         return false;
 893                 break;
 894         case V4L2_CTRL_WHICH_DEF_VAL:
 895                 /* Default value cannot be changed */
 896                 if (ioctl == VIDIOC_S_EXT_CTRLS ||
 897                     ioctl == VIDIOC_TRY_EXT_CTRLS) {
 898                         c->error_idx = c->count;
 899                         return false;
 900                 }
 901                 return true;
 902         case V4L2_CTRL_WHICH_CUR_VAL:
 903                 return true;
 904         case V4L2_CTRL_WHICH_REQUEST_VAL:
 905                 c->error_idx = c->count;
 906                 return false;
 907         }
 908
 909         /* Check that all controls are from the same control class. */
 910         for (i = 0; i < c->count; i++) {
 911                 if (V4L2_CTRL_ID2WHICH(c->controls[i].id) != c->which) {
 912                         c->error_idx = ioctl == VIDIOC_TRY_EXT_CTRLS ? i :
 913                                                                       c->count;
 914                         return false;
 915                 }
 916         }
 917         return true;
 918 }
 919
 920 static int check_fmt(struct file *file, enum v4l2_buf_type type)
 921 {
 922         const u32 vid_caps = V4L2_CAP_VIDEO_CAPTURE |
 923                              V4L2_CAP_VIDEO_CAPTURE_MPLANE |
 924                              V4L2_CAP_VIDEO_OUTPUT |
 925                              V4L2_CAP_VIDEO_OUTPUT_MPLANE |
 926                              V4L2_CAP_VIDEO_M2M | V4L2_CAP_VIDEO_M2M_MPLANE;
 927         const u32 meta_caps = V4L2_CAP_META_CAPTURE |
 928                               V4L2_CAP_META_OUTPUT;
 929         struct video_device *vfd = video_devdata(file);
 930         const struct v4l2_ioctl_ops *ops = vfd->ioctl_ops;
 931         bool is_vid = vfd->vfl_type == VFL_TYPE_VIDEO &&
 932                       (vfd->device_caps & vid_caps);
 933         bool is_vbi = vfd->vfl_type == VFL_TYPE_VBI;
 934         bool is_sdr = vfd->vfl_type == VFL_TYPE_SDR;
 935         bool is_tch = vfd->vfl_type == VFL_TYPE_TOUCH;
 936         bool is_meta = vfd->vfl_type == VFL_TYPE_VIDEO &&
 937                        (vfd->device_caps & meta_caps);
 938         bool is_rx = vfd->vfl_dir != VFL_DIR_TX;
 939         bool is_tx = vfd->vfl_dir != VFL_DIR_RX;
 940
 941         if (ops == NULL)
 942                 return -EINVAL;
 943
 944         switch (type) {
 945         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 946                 if ((is_vid || is_tch) && is_rx &&
 947                     (ops->vidioc_g_fmt_vid_cap || ops->vidioc_g_fmt_vid_cap_mplane))
 948                         return 0;
 949                 break;
 950         case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
 951                 if ((is_vid || is_tch) && is_rx && ops->vidioc_g_fmt_vid_cap_mplane)
 952                         return 0;
 953                 break;
 954         case V4L2_BUF_TYPE_VIDEO_OVERLAY:
 955                 if (is_vid && is_rx && ops->vidioc_g_fmt_vid_overlay)
 956                         return 0;
 957                 break;
 958         case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 959                 if (is_vid && is_tx &&
 960                     (ops->vidioc_g_fmt_vid_out || ops->vidioc_g_fmt_vid_out_mplane))
 961                         return 0;
 962                 break;
 963         case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
 964                 if (is_vid && is_tx && ops->vidioc_g_fmt_vid_out_mplane)
 965                         return 0;
 966                 break;
 967         case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
 968                 if (is_vid && is_tx && ops->vidioc_g_fmt_vid_out_overlay)
 969                         return 0;
 970                 break;
 971         case V4L2_BUF_TYPE_VBI_CAPTURE:
 972                 if (is_vbi && is_rx && ops->vidioc_g_fmt_vbi_cap)
 973                         return 0;
 974                 break;
 975         case V4L2_BUF_TYPE_VBI_OUTPUT:
 976                 if (is_vbi && is_tx && ops->vidioc_g_fmt_vbi_out)
 977                         return 0;
 978                 break;
 979         case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
 980                 if (is_vbi && is_rx && ops->vidioc_g_fmt_sliced_vbi_cap)
 981                         return 0;
 982                 break;
 983         case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
 984                 if (is_vbi && is_tx && ops->vidioc_g_fmt_sliced_vbi_out)
 985                         return 0;
 986                 break;
 987         case V4L2_BUF_TYPE_SDR_CAPTURE:
 988                 if (is_sdr && is_rx && ops->vidioc_g_fmt_sdr_cap)
 989                         return 0;
 990                 break;
 991         case V4L2_BUF_TYPE_SDR_OUTPUT:
 992                 if (is_sdr && is_tx && ops->vidioc_g_fmt_sdr_out)
 993                         return 0;
 994                 break;
 995         case V4L2_BUF_TYPE_META_CAPTURE:
 996                 if (is_meta && is_rx && ops->vidioc_g_fmt_meta_cap)
 997                         return 0;
 998                 break;
 999         case V4L2_BUF_TYPE_META_OUTPUT:
1000                 if (is_meta && is_tx && ops->vidioc_g_fmt_meta_out)
1001                         return 0;
1002                 break;
1003         default:
1004                 break;
1005         }
1006         return -EINVAL;
1007 }
1008
1009 static void v4l_sanitize_format(struct v4l2_format *fmt)
1010 {
1011         unsigned int offset;
1012
1013         /* Make sure num_planes is not bogus */
1014         if (fmt->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE ||
1015             fmt->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
1016                 fmt->fmt.pix_mp.num_planes = min_t(u32, fmt->fmt.pix_mp.num_planes,
1017                                                VIDEO_MAX_PLANES);
1018
1019         /*
1020          * The v4l2_pix_format structure has been extended with fields that were
1021          * not previously required to be set to zero by applications. The priv
1022          * field, when set to a magic value, indicates the the extended fields
1023          * are valid. Otherwise they will contain undefined values. To simplify
1024          * the API towards drivers zero the extended fields and set the priv
1025          * field to the magic value when the extended pixel format structure
1026          * isn't used by applications.
1027          */
1028
1029         if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1030             fmt->type != V4L2_BUF_TYPE_VIDEO_OUTPUT)
1031                 return;
1032
1033         if (fmt->fmt.pix.priv == V4L2_PIX_FMT_PRIV_MAGIC)
1034                 return;
1035
1036         fmt->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
1037
1038         offset = offsetof(struct v4l2_pix_format, priv)
1039                + sizeof(fmt->fmt.pix.priv);
1040         memset(((void *)&fmt->fmt.pix) + offset, 0,
1041                sizeof(fmt->fmt.pix) - offset);
1042 }
1043
1044 static int v4l_querycap(const struct v4l2_ioctl_ops *ops,
1045                                 struct file *file, void *fh, void *arg)
1046 {
1047         struct v4l2_capability *cap = (struct v4l2_capability *)arg;
1048         struct video_device *vfd = video_devdata(file);
1049         int ret;
1050
1051         cap->version = LINUX_VERSION_CODE;
1052         cap->device_caps = vfd->device_caps;
1053         cap->capabilities = vfd->device_caps | V4L2_CAP_DEVICE_CAPS;
1054
1055         ret = ops->vidioc_querycap(file, fh, cap);
1056
1057         /*
1058          * Drivers must not change device_caps, so check for this and
1059          * warn if this happened.
1060          */
1061         WARN_ON(cap->device_caps != vfd->device_caps);
1062         /*
1063          * Check that capabilities is a superset of
1064          * vfd->device_caps | V4L2_CAP_DEVICE_CAPS
1065          */
1066         WARN_ON((cap->capabilities &
1067                  (vfd->device_caps | V4L2_CAP_DEVICE_CAPS)) !=
1068                 (vfd->device_caps | V4L2_CAP_DEVICE_CAPS));
1069         cap->capabilities |= V4L2_CAP_EXT_PIX_FORMAT;
1070         cap->device_caps |= V4L2_CAP_EXT_PIX_FORMAT;
1071
1072         return ret;
1073 }
1074
1075 static int v4l_g_input(const struct v4l2_ioctl_ops *ops,
1076                        struct file *file, void *fh, void *arg)
1077 {
1078         struct video_device *vfd = video_devdata(file);
1079
1080         if (vfd->device_caps & V4L2_CAP_IO_MC) {
1081                 *(int *)arg = 0;
1082                 return 0;
1083         }
1084
1085         return ops->vidioc_g_input(file, fh, arg);
1086 }
1087
1088 static int v4l_g_output(const struct v4l2_ioctl_ops *ops,
1089                         struct file *file, void *fh, void *arg)
1090 {
1091         struct video_device *vfd = video_devdata(file);
1092
1093         if (vfd->device_caps & V4L2_CAP_IO_MC) {
1094                 *(int *)arg = 0;
1095                 return 0;
1096         }
1097
1098         return ops->vidioc_g_output(file, fh, arg);
1099 }
1100
1101 static int v4l_s_input(const struct v4l2_ioctl_ops *ops,
1102                                 struct file *file, void *fh, void *arg)
1103 {
1104         struct video_device *vfd = video_devdata(file);
1105         int ret;
1106
1107         ret = v4l_enable_media_source(vfd);
1108         if (ret)
1109                 return ret;
1110
1111         if (vfd->device_caps & V4L2_CAP_IO_MC)
1112                 return  *(int *)arg ? -EINVAL : 0;
1113
1114         return ops->vidioc_s_input(file, fh, *(unsigned int *)arg);
1115 }
1116
1117 static int v4l_s_output(const struct v4l2_ioctl_ops *ops,
1118                                 struct file *file, void *fh, void *arg)
1119 {
1120         struct video_device *vfd = video_devdata(file);
1121
1122         if (vfd->device_caps & V4L2_CAP_IO_MC)
1123                 return  *(int *)arg ? -EINVAL : 0;
1124
1125         return ops->vidioc_s_output(file, fh, *(unsigned int *)arg);
1126 }
1127
1128 static int v4l_g_priority(const struct v4l2_ioctl_ops *ops,
1129                                 struct file *file, void *fh, void *arg)
1130 {
1131         struct video_device *vfd;
1132         u32 *p = arg;
1133
1134         vfd = video_devdata(file);
1135         *p = v4l2_prio_max(vfd->prio);
1136         return 0;
1137 }
1138
1139 static int v4l_s_priority(const struct v4l2_ioctl_ops *ops,
1140                                 struct file *file, void *fh, void *arg)
1141 {
1142         struct video_device *vfd;
1143         struct v4l2_fh *vfh;
1144         u32 *p = arg;
1145
1146         vfd = video_devdata(file);
1147         if (!test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags))
1148                 return -ENOTTY;
1149         vfh = file->private_data;
1150         return v4l2_prio_change(vfd->prio, &vfh->prio, *p);
1151 }
1152
1153 static int v4l_enuminput(const struct v4l2_ioctl_ops *ops,
1154                                 struct file *file, void *fh, void *arg)
1155 {
1156         struct video_device *vfd = video_devdata(file);
1157         struct v4l2_input *p = arg;
1158
1159         /*
1160          * We set the flags for CAP_DV_TIMINGS &
1161          * CAP_STD here based on ioctl handler provided by the
1162          * driver. If the driver doesn't support these
1163          * for a specific input, it must override these flags.
1164          */
1165         if (is_valid_ioctl(vfd, VIDIOC_S_STD))
1166                 p->capabilities |= V4L2_IN_CAP_STD;
1167
1168         if (vfd->device_caps & V4L2_CAP_IO_MC) {
1169                 if (p->index)
1170                         return -EINVAL;
1171                 strscpy(p->name, vfd->name, sizeof(p->name));
1172                 p->type = V4L2_INPUT_TYPE_CAMERA;
1173                 return 0;
1174         }
1175
1176         return ops->vidioc_enum_input(file, fh, p);
1177 }
1178
1179 static int v4l_enumoutput(const struct v4l2_ioctl_ops *ops,
1180                                 struct file *file, void *fh, void *arg)
1181 {
1182         struct video_device *vfd = video_devdata(file);
1183         struct v4l2_output *p = arg;
1184
1185         /*
1186          * We set the flags for CAP_DV_TIMINGS &
1187          * CAP_STD here based on ioctl handler provided by the
1188          * driver. If the driver doesn't support these
1189          * for a specific output, it must override these flags.
1190          */
1191         if (is_valid_ioctl(vfd, VIDIOC_S_STD))
1192                 p->capabilities |= V4L2_OUT_CAP_STD;
1193
1194         if (vfd->device_caps & V4L2_CAP_IO_MC) {
1195                 if (p->index)
1196                         return -EINVAL;
1197                 strscpy(p->name, vfd->name, sizeof(p->name));
1198                 p->type = V4L2_OUTPUT_TYPE_ANALOG;
1199                 return 0;
1200         }
1201
1202         return ops->vidioc_enum_output(file, fh, p);
1203 }
1204
1205 static void v4l_fill_fmtdesc(struct v4l2_fmtdesc *fmt)
1206 {
1207         const unsigned sz = sizeof(fmt->description);
1208         const char *descr = NULL;
1209         u32 flags = 0;
1210
1211         /*
1212          * We depart from the normal coding style here since the descriptions
1213          * should be aligned so it is easy to see which descriptions will be
1214          * longer than 31 characters (the max length for a description).
1215          * And frankly, this is easier to read anyway.
1216          *
1217          * Note that gcc will use O(log N) comparisons to find the right case.
1218          */
1219         switch (fmt->pixelformat) {
1220         /* Max description length mask: descr = "0123456789012345678901234567890" */
1221         case V4L2_PIX_FMT_RGB332:       descr = "8-bit RGB 3-3-2"; break;
1222         case V4L2_PIX_FMT_RGB444:       descr = "16-bit A/XRGB 4-4-4-4"; break;
1223         case V4L2_PIX_FMT_ARGB444:      descr = "16-bit ARGB 4-4-4-4"; break;
1224         case V4L2_PIX_FMT_XRGB444:      descr = "16-bit XRGB 4-4-4-4"; break;
1225         case V4L2_PIX_FMT_RGBA444:      descr = "16-bit RGBA 4-4-4-4"; break;
1226         case V4L2_PIX_FMT_RGBX444:      descr = "16-bit RGBX 4-4-4-4"; break;
1227         case V4L2_PIX_FMT_ABGR444:      descr = "16-bit ABGR 4-4-4-4"; break;
1228         case V4L2_PIX_FMT_XBGR444:      descr = "16-bit XBGR 4-4-4-4"; break;
1229         case V4L2_PIX_FMT_BGRA444:      descr = "16-bit BGRA 4-4-4-4"; break;
1230         case V4L2_PIX_FMT_BGRX444:      descr = "16-bit BGRX 4-4-4-4"; break;
1231         case V4L2_PIX_FMT_RGB555:       descr = "16-bit A/XRGB 1-5-5-5"; break;
1232         case V4L2_PIX_FMT_ARGB555:      descr = "16-bit ARGB 1-5-5-5"; break;
1233         case V4L2_PIX_FMT_XRGB555:      descr = "16-bit XRGB 1-5-5-5"; break;
1234         case V4L2_PIX_FMT_ABGR555:      descr = "16-bit ABGR 1-5-5-5"; break;
1235         case V4L2_PIX_FMT_XBGR555:      descr = "16-bit XBGR 1-5-5-5"; break;
1236         case V4L2_PIX_FMT_RGBA555:      descr = "16-bit RGBA 5-5-5-1"; break;
1237         case V4L2_PIX_FMT_RGBX555:      descr = "16-bit RGBX 5-5-5-1"; break;
1238         case V4L2_PIX_FMT_BGRA555:      descr = "16-bit BGRA 5-5-5-1"; break;
1239         case V4L2_PIX_FMT_BGRX555:      descr = "16-bit BGRX 5-5-5-1"; break;
1240         case V4L2_PIX_FMT_RGB565:       descr = "16-bit RGB 5-6-5"; break;
1241         case V4L2_PIX_FMT_RGB555X:      descr = "16-bit A/XRGB 1-5-5-5 BE"; break;
1242         case V4L2_PIX_FMT_ARGB555X:     descr = "16-bit ARGB 1-5-5-5 BE"; break;
1243         case V4L2_PIX_FMT_XRGB555X:     descr = "16-bit XRGB 1-5-5-5 BE"; break;
1244         case V4L2_PIX_FMT_RGB565X:      descr = "16-bit RGB 5-6-5 BE"; break;
1245         case V4L2_PIX_FMT_BGR666:       descr = "18-bit BGRX 6-6-6-14"; break;
1246         case V4L2_PIX_FMT_BGR24:        descr = "24-bit BGR 8-8-8"; break;
1247         case V4L2_PIX_FMT_RGB24:        descr = "24-bit RGB 8-8-8"; break;
1248         case V4L2_PIX_FMT_BGR32:        descr = "32-bit BGRA/X 8-8-8-8"; break;
1249         case V4L2_PIX_FMT_ABGR32:       descr = "32-bit BGRA 8-8-8-8"; break;
1250         case V4L2_PIX_FMT_XBGR32:       descr = "32-bit BGRX 8-8-8-8"; break;
1251         case V4L2_PIX_FMT_RGB32:        descr = "32-bit A/XRGB 8-8-8-8"; break;
1252         case V4L2_PIX_FMT_ARGB32:       descr = "32-bit ARGB 8-8-8-8"; break;
1253         case V4L2_PIX_FMT_XRGB32:       descr = "32-bit XRGB 8-8-8-8"; break;
1254         case V4L2_PIX_FMT_BGRA32:       descr = "32-bit ABGR 8-8-8-8"; break;
1255         case V4L2_PIX_FMT_BGRX32:       descr = "32-bit XBGR 8-8-8-8"; break;
1256         case V4L2_PIX_FMT_RGBA32:       descr = "32-bit RGBA 8-8-8-8"; break;
1257         case V4L2_PIX_FMT_RGBX32:       descr = "32-bit RGBX 8-8-8-8"; break;
1258         case V4L2_PIX_FMT_GREY:         descr = "8-bit Greyscale"; break;
1259         case V4L2_PIX_FMT_Y4:           descr = "4-bit Greyscale"; break;
1260         case V4L2_PIX_FMT_Y6:           descr = "6-bit Greyscale"; break;
1261         case V4L2_PIX_FMT_Y10:          descr = "10-bit Greyscale"; break;
1262         case V4L2_PIX_FMT_Y12:          descr = "12-bit Greyscale"; break;
1263         case V4L2_PIX_FMT_Y14:          descr = "14-bit Greyscale"; break;
1264         case V4L2_PIX_FMT_Y16:          descr = "16-bit Greyscale"; break;
1265         case V4L2_PIX_FMT_Y16_BE:       descr = "16-bit Greyscale BE"; break;
1266         case V4L2_PIX_FMT_Y10BPACK:     descr = "10-bit Greyscale (Packed)"; break;
1267         case V4L2_PIX_FMT_Y10P:         descr = "10-bit Greyscale (MIPI Packed)"; break;
1268         case V4L2_PIX_FMT_Y12P:         descr = "12-bit Greyscale (MIPI Packed)"; break;
1269         case V4L2_PIX_FMT_Y14P:         descr = "14-bit Greyscale (MIPI Packed)"; break;
1270         case V4L2_PIX_FMT_Y8I:          descr = "Interleaved 8-bit Greyscale"; break;
1271         case V4L2_PIX_FMT_Y12I:         descr = "Interleaved 12-bit Greyscale"; break;
1272         case V4L2_PIX_FMT_Z16:          descr = "16-bit Depth"; break;
1273         case V4L2_PIX_FMT_INZI:         descr = "Planar 10:16 Greyscale Depth"; break;
1274         case V4L2_PIX_FMT_CNF4:         descr = "4-bit Depth Confidence (Packed)"; break;
1275         case V4L2_PIX_FMT_PAL8:         descr = "8-bit Palette"; break;
1276         case V4L2_PIX_FMT_UV8:          descr = "8-bit Chrominance UV 4-4"; break;
1277         case V4L2_PIX_FMT_YVU410:       descr = "Planar YVU 4:1:0"; break;
1278         case V4L2_PIX_FMT_YVU420:       descr = "Planar YVU 4:2:0"; break;
1279         case V4L2_PIX_FMT_YUYV:         descr = "YUYV 4:2:2"; break;
1280         case V4L2_PIX_FMT_YYUV:         descr = "YYUV 4:2:2"; break;
1281         case V4L2_PIX_FMT_YVYU:         descr = "YVYU 4:2:2"; break;
1282         case V4L2_PIX_FMT_UYVY:         descr = "UYVY 4:2:2"; break;
1283         case V4L2_PIX_FMT_VYUY:         descr = "VYUY 4:2:2"; break;
1284         case V4L2_PIX_FMT_YUV422P:      descr = "Planar YUV 4:2:2"; break;
1285         case V4L2_PIX_FMT_YUV411P:      descr = "Planar YUV 4:1:1"; break;
1286         case V4L2_PIX_FMT_Y41P:         descr = "YUV 4:1:1 (Packed)"; break;
1287         case V4L2_PIX_FMT_YUV444:       descr = "16-bit A/XYUV 4-4-4-4"; break;
1288         case V4L2_PIX_FMT_YUV555:       descr = "16-bit A/XYUV 1-5-5-5"; break;
1289         case V4L2_PIX_FMT_YUV565:       descr = "16-bit YUV 5-6-5"; break;
1290         case V4L2_PIX_FMT_YUV24:        descr = "24-bit YUV 4:4:4 8-8-8"; break;
1291         case V4L2_PIX_FMT_YUV32:        descr = "32-bit A/XYUV 8-8-8-8"; break;
1292         case V4L2_PIX_FMT_AYUV32:       descr = "32-bit AYUV 8-8-8-8"; break;
1293         case V4L2_PIX_FMT_XYUV32:       descr = "32-bit XYUV 8-8-8-8"; break;
1294         case V4L2_PIX_FMT_VUYA32:       descr = "32-bit VUYA 8-8-8-8"; break;
1295         case V4L2_PIX_FMT_VUYX32:       descr = "32-bit VUYX 8-8-8-8"; break;
1296         case V4L2_PIX_FMT_YUV410:       descr = "Planar YUV 4:1:0"; break;
1297         case V4L2_PIX_FMT_YUV420:       descr = "Planar YUV 4:2:0"; break;
1298         case V4L2_PIX_FMT_HI240:        descr = "8-bit Dithered RGB (BTTV)"; break;
1299         case V4L2_PIX_FMT_HM12:         descr = "YUV 4:2:0 (16x16 Macroblocks)"; break;
1300         case V4L2_PIX_FMT_M420:         descr = "YUV 4:2:0 (M420)"; break;
1301         case V4L2_PIX_FMT_NV12:         descr = "Y/CbCr 4:2:0"; break;
1302         case V4L2_PIX_FMT_NV21:         descr = "Y/CrCb 4:2:0"; break;
1303         case V4L2_PIX_FMT_NV16:         descr = "Y/CbCr 4:2:2"; break;
1304         case V4L2_PIX_FMT_NV61:         descr = "Y/CrCb 4:2:2"; break;
1305         case V4L2_PIX_FMT_NV24:         descr = "Y/CbCr 4:4:4"; break;
1306         case V4L2_PIX_FMT_NV42:         descr = "Y/CrCb 4:4:4"; break;
1307         case V4L2_PIX_FMT_NV12M:        descr = "Y/CbCr 4:2:0 (N-C)"; break;
1308         case V4L2_PIX_FMT_NV21M:        descr = "Y/CrCb 4:2:0 (N-C)"; break;
1309         case V4L2_PIX_FMT_NV16M:        descr = "Y/CbCr 4:2:2 (N-C)"; break;
1310         case V4L2_PIX_FMT_NV61M:        descr = "Y/CrCb 4:2:2 (N-C)"; break;
1311         case V4L2_PIX_FMT_NV12MT:       descr = "Y/CbCr 4:2:0 (64x32 MB, N-C)"; break;
1312         case V4L2_PIX_FMT_NV12MT_16X16: descr = "Y/CbCr 4:2:0 (16x16 MB, N-C)"; break;
1313         case V4L2_PIX_FMT_NV12_COL128:  descr = "Y/CbCr 4:2:0 (128b cols)"; break;
1314         case V4L2_PIX_FMT_NV12_10_COL128: descr = "10-bit Y/CbCr 4:2:0 (128b cols)"; break;
1315         case V4L2_PIX_FMT_YUV420M:      descr = "Planar YUV 4:2:0 (N-C)"; break;
1316         case V4L2_PIX_FMT_YVU420M:      descr = "Planar YVU 4:2:0 (N-C)"; break;
1317         case V4L2_PIX_FMT_YUV422M:      descr = "Planar YUV 4:2:2 (N-C)"; break;
1318         case V4L2_PIX_FMT_YVU422M:      descr = "Planar YVU 4:2:2 (N-C)"; break;
1319         case V4L2_PIX_FMT_YUV444M:      descr = "Planar YUV 4:4:4 (N-C)"; break;
1320         case V4L2_PIX_FMT_YVU444M:      descr = "Planar YVU 4:4:4 (N-C)"; break;
1321         case V4L2_PIX_FMT_SBGGR8:       descr = "8-bit Bayer BGBG/GRGR"; break;
1322         case V4L2_PIX_FMT_SGBRG8:       descr = "8-bit Bayer GBGB/RGRG"; break;
1323         case V4L2_PIX_FMT_SGRBG8:       descr = "8-bit Bayer GRGR/BGBG"; break;
1324         case V4L2_PIX_FMT_SRGGB8:       descr = "8-bit Bayer RGRG/GBGB"; break;
1325         case V4L2_PIX_FMT_SBGGR10:      descr = "10-bit Bayer BGBG/GRGR"; break;
1326         case V4L2_PIX_FMT_SGBRG10:      descr = "10-bit Bayer GBGB/RGRG"; break;
1327         case V4L2_PIX_FMT_SGRBG10:      descr = "10-bit Bayer GRGR/BGBG"; break;
1328         case V4L2_PIX_FMT_SRGGB10:      descr = "10-bit Bayer RGRG/GBGB"; break;
1329         case V4L2_PIX_FMT_SBGGR10P:     descr = "10-bit Bayer BGBG/GRGR Packed"; break;
1330         case V4L2_PIX_FMT_SGBRG10P:     descr = "10-bit Bayer GBGB/RGRG Packed"; break;
1331         case V4L2_PIX_FMT_SGRBG10P:     descr = "10-bit Bayer GRGR/BGBG Packed"; break;
1332         case V4L2_PIX_FMT_SRGGB10P:     descr = "10-bit Bayer RGRG/GBGB Packed"; break;
1333         case V4L2_PIX_FMT_IPU3_SBGGR10: descr = "10-bit bayer BGGR IPU3 Packed"; break;
1334         case V4L2_PIX_FMT_IPU3_SGBRG10: descr = "10-bit bayer GBRG IPU3 Packed"; break;
1335         case V4L2_PIX_FMT_IPU3_SGRBG10: descr = "10-bit bayer GRBG IPU3 Packed"; break;
1336         case V4L2_PIX_FMT_IPU3_SRGGB10: descr = "10-bit bayer RGGB IPU3 Packed"; break;
1337         case V4L2_PIX_FMT_SBGGR10ALAW8: descr = "8-bit Bayer BGBG/GRGR (A-law)"; break;
1338         case V4L2_PIX_FMT_SGBRG10ALAW8: descr = "8-bit Bayer GBGB/RGRG (A-law)"; break;
1339         case V4L2_PIX_FMT_SGRBG10ALAW8: descr = "8-bit Bayer GRGR/BGBG (A-law)"; break;
1340         case V4L2_PIX_FMT_SRGGB10ALAW8: descr = "8-bit Bayer RGRG/GBGB (A-law)"; break;
1341         case V4L2_PIX_FMT_SBGGR10DPCM8: descr = "8-bit Bayer BGBG/GRGR (DPCM)"; break;
1342         case V4L2_PIX_FMT_SGBRG10DPCM8: descr = "8-bit Bayer GBGB/RGRG (DPCM)"; break;
1343         case V4L2_PIX_FMT_SGRBG10DPCM8: descr = "8-bit Bayer GRGR/BGBG (DPCM)"; break;
1344         case V4L2_PIX_FMT_SRGGB10DPCM8: descr = "8-bit Bayer RGRG/GBGB (DPCM)"; break;
1345         case V4L2_PIX_FMT_SBGGR12:      descr = "12-bit Bayer BGBG/GRGR"; break;
1346         case V4L2_PIX_FMT_SGBRG12:      descr = "12-bit Bayer GBGB/RGRG"; break;
1347         case V4L2_PIX_FMT_SGRBG12:      descr = "12-bit Bayer GRGR/BGBG"; break;
1348         case V4L2_PIX_FMT_SRGGB12:      descr = "12-bit Bayer RGRG/GBGB"; break;
1349         case V4L2_PIX_FMT_SBGGR12P:     descr = "12-bit Bayer BGBG/GRGR Packed"; break;
1350         case V4L2_PIX_FMT_SGBRG12P:     descr = "12-bit Bayer GBGB/RGRG Packed"; break;
1351         case V4L2_PIX_FMT_SGRBG12P:     descr = "12-bit Bayer GRGR/BGBG Packed"; break;
1352         case V4L2_PIX_FMT_SRGGB12P:     descr = "12-bit Bayer RGRG/GBGB Packed"; break;
1353         case V4L2_PIX_FMT_SBGGR14:      descr = "14-bit Bayer BGBG/GRGR"; break;
1354         case V4L2_PIX_FMT_SGBRG14:      descr = "14-bit Bayer GBGB/RGRG"; break;
1355         case V4L2_PIX_FMT_SGRBG14:      descr = "14-bit Bayer GRGR/BGBG"; break;
1356         case V4L2_PIX_FMT_SRGGB14:      descr = "14-bit Bayer RGRG/GBGB"; break;
1357         case V4L2_PIX_FMT_SBGGR14P:     descr = "14-bit Bayer BGBG/GRGR Packed"; break;
1358         case V4L2_PIX_FMT_SGBRG14P:     descr = "14-bit Bayer GBGB/RGRG Packed"; break;
1359         case V4L2_PIX_FMT_SGRBG14P:     descr = "14-bit Bayer GRGR/BGBG Packed"; break;
1360         case V4L2_PIX_FMT_SRGGB14P:     descr = "14-bit Bayer RGRG/GBGB Packed"; break;
1361         case V4L2_PIX_FMT_SBGGR16:      descr = "16-bit Bayer BGBG/GRGR"; break;
1362         case V4L2_PIX_FMT_SGBRG16:      descr = "16-bit Bayer GBGB/RGRG"; break;
1363         case V4L2_PIX_FMT_SGRBG16:      descr = "16-bit Bayer GRGR/BGBG"; break;
1364         case V4L2_PIX_FMT_SRGGB16:      descr = "16-bit Bayer RGRG/GBGB"; break;
1365         case V4L2_PIX_FMT_SN9C20X_I420: descr = "GSPCA SN9C20X I420"; break;
1366         case V4L2_PIX_FMT_SPCA501:      descr = "GSPCA SPCA501"; break;
1367         case V4L2_PIX_FMT_SPCA505:      descr = "GSPCA SPCA505"; break;
1368         case V4L2_PIX_FMT_SPCA508:      descr = "GSPCA SPCA508"; break;
1369         case V4L2_PIX_FMT_STV0680:      descr = "GSPCA STV0680"; break;
1370         case V4L2_PIX_FMT_TM6000:       descr = "A/V + VBI Mux Packet"; break;
1371         case V4L2_PIX_FMT_CIT_YYVYUY:   descr = "GSPCA CIT YYVYUY"; break;
1372         case V4L2_PIX_FMT_KONICA420:    descr = "GSPCA KONICA420"; break;
1373         case V4L2_PIX_FMT_HSV24:        descr = "24-bit HSV 8-8-8"; break;
1374         case V4L2_PIX_FMT_HSV32:        descr = "32-bit XHSV 8-8-8-8"; break;
1375         case V4L2_SDR_FMT_CU8:          descr = "Complex U8"; break;
1376         case V4L2_SDR_FMT_CU16LE:       descr = "Complex U16LE"; break;
1377         case V4L2_SDR_FMT_CS8:          descr = "Complex S8"; break;
1378         case V4L2_SDR_FMT_CS14LE:       descr = "Complex S14LE"; break;
1379         case V4L2_SDR_FMT_RU12LE:       descr = "Real U12LE"; break;
1380         case V4L2_SDR_FMT_PCU16BE:      descr = "Planar Complex U16BE"; break;
1381         case V4L2_SDR_FMT_PCU18BE:      descr = "Planar Complex U18BE"; break;
1382         case V4L2_SDR_FMT_PCU20BE:      descr = "Planar Complex U20BE"; break;
1383         case V4L2_TCH_FMT_DELTA_TD16:   descr = "16-bit Signed Deltas"; break;
1384         case V4L2_TCH_FMT_DELTA_TD08:   descr = "8-bit Signed Deltas"; break;
1385         case V4L2_TCH_FMT_TU16:         descr = "16-bit Unsigned Touch Data"; break;
1386         case V4L2_TCH_FMT_TU08:         descr = "8-bit Unsigned Touch Data"; break;
1387         case V4L2_META_FMT_VSP1_HGO:    descr = "R-Car VSP1 1-D Histogram"; break;
1388         case V4L2_META_FMT_VSP1_HGT:    descr = "R-Car VSP1 2-D Histogram"; break;
1389         case V4L2_META_FMT_UVC:         descr = "UVC Payload Header Metadata"; break;
1390         case V4L2_META_FMT_D4XX:        descr = "Intel D4xx UVC Metadata"; break;
1391         case V4L2_META_FMT_VIVID:       descr = "Vivid Metadata"; break;
1392         case V4L2_META_FMT_RK_ISP1_PARAMS:      descr = "Rockchip ISP1 3A Parameters"; break;
1393         case V4L2_META_FMT_RK_ISP1_STAT_3A:     descr = "Rockchip ISP1 3A Statistics"; break;
1394         case V4L2_META_FMT_SENSOR_DATA: descr = "Sensor Ancillary Metadata"; break;
1395         case V4L2_META_FMT_BCM2835_ISP_STATS: descr = "BCM2835 ISP Image Statistics"; break;
1396
1397         default:
1398                 /* Compressed formats */
1399                 flags = V4L2_FMT_FLAG_COMPRESSED;
1400                 switch (fmt->pixelformat) {
1401                 /* Max description length mask: descr = "0123456789012345678901234567890" */
1402                 case V4L2_PIX_FMT_MJPEG:        descr = "Motion-JPEG"; break;
1403                 case V4L2_PIX_FMT_JPEG:         descr = "JFIF JPEG"; break;
1404                 case V4L2_PIX_FMT_DV:           descr = "1394"; break;
1405                 case V4L2_PIX_FMT_MPEG:         descr = "MPEG-1/2/4"; break;
1406                 case V4L2_PIX_FMT_H264:         descr = "H.264"; break;
1407                 case V4L2_PIX_FMT_H264_NO_SC:   descr = "H.264 (No Start Codes)"; break;
1408                 case V4L2_PIX_FMT_H264_MVC:     descr = "H.264 MVC"; break;
1409                 case V4L2_PIX_FMT_H264_SLICE:   descr = "H.264 Parsed Slice Data"; break;
1410                 case V4L2_PIX_FMT_H263:         descr = "H.263"; break;
1411                 case V4L2_PIX_FMT_MPEG1:        descr = "MPEG-1 ES"; break;
1412                 case V4L2_PIX_FMT_MPEG2:        descr = "MPEG-2 ES"; break;
1413                 case V4L2_PIX_FMT_MPEG2_SLICE:  descr = "MPEG-2 Parsed Slice Data"; break;
1414                 case V4L2_PIX_FMT_MPEG4:        descr = "MPEG-4 Part 2 ES"; break;
1415                 case V4L2_PIX_FMT_XVID:         descr = "Xvid"; break;
1416                 case V4L2_PIX_FMT_VC1_ANNEX_G:  descr = "VC-1 (SMPTE 412M Annex G)"; break;
1417                 case V4L2_PIX_FMT_VC1_ANNEX_L:  descr = "VC-1 (SMPTE 412M Annex L)"; break;
1418                 case V4L2_PIX_FMT_VP8:          descr = "VP8"; break;
1419                 case V4L2_PIX_FMT_VP8_FRAME:    descr = "VP8 Frame"; break;
1420                 case V4L2_PIX_FMT_VP9:          descr = "VP9"; break;
1421                 case V4L2_PIX_FMT_HEVC:         descr = "HEVC"; break; /* aka H.265 */
1422                 case V4L2_PIX_FMT_HEVC_SLICE:   descr = "HEVC Parsed Slice Data"; break;
1423                 case V4L2_PIX_FMT_FWHT:         descr = "FWHT"; break; /* used in vicodec */
1424                 case V4L2_PIX_FMT_FWHT_STATELESS:       descr = "FWHT Stateless"; break; /* used in vicodec */
1425                 case V4L2_PIX_FMT_CPIA1:        descr = "GSPCA CPiA YUV"; break;
1426                 case V4L2_PIX_FMT_WNVA:         descr = "WNVA"; break;
1427                 case V4L2_PIX_FMT_SN9C10X:      descr = "GSPCA SN9C10X"; break;
1428                 case V4L2_PIX_FMT_PWC1:         descr = "Raw Philips Webcam Type (Old)"; break;
1429                 case V4L2_PIX_FMT_PWC2:         descr = "Raw Philips Webcam Type (New)"; break;
1430                 case V4L2_PIX_FMT_ET61X251:     descr = "GSPCA ET61X251"; break;
1431                 case V4L2_PIX_FMT_SPCA561:      descr = "GSPCA SPCA561"; break;
1432                 case V4L2_PIX_FMT_PAC207:       descr = "GSPCA PAC207"; break;
1433                 case V4L2_PIX_FMT_MR97310A:     descr = "GSPCA MR97310A"; break;
1434                 case V4L2_PIX_FMT_JL2005BCD:    descr = "GSPCA JL2005BCD"; break;
1435                 case V4L2_PIX_FMT_SN9C2028:     descr = "GSPCA SN9C2028"; break;
1436                 case V4L2_PIX_FMT_SQ905C:       descr = "GSPCA SQ905C"; break;
1437                 case V4L2_PIX_FMT_PJPG:         descr = "GSPCA PJPG"; break;
1438                 case V4L2_PIX_FMT_OV511:        descr = "GSPCA OV511"; break;
1439                 case V4L2_PIX_FMT_OV518:        descr = "GSPCA OV518"; break;
1440                 case V4L2_PIX_FMT_JPGL:         descr = "JPEG Lite"; break;
1441                 case V4L2_PIX_FMT_SE401:        descr = "GSPCA SE401"; break;
1442                 case V4L2_PIX_FMT_S5C_UYVY_JPG: descr = "S5C73MX interleaved UYVY/JPEG"; break;
1443                 case V4L2_PIX_FMT_MT21C:        descr = "Mediatek Compressed Format"; break;
1444                 case V4L2_PIX_FMT_SUNXI_TILED_NV12: descr = "Sunxi Tiled NV12 Format"; break;
1445                 default:
1446                         if (fmt->description[0])
1447                                 return;
1448                         WARN(1, "Unknown pixelformat 0x%08x\n", fmt->pixelformat);
1449                         flags = 0;
1450                         snprintf(fmt->description, sz, "%p4cc",
1451                                  &fmt->pixelformat);
1452                         break;
1453                 }
1454         }
1455
1456         if (descr)
1457                 WARN_ON(strscpy(fmt->description, descr, sz) < 0);
1458         fmt->flags |= flags;
1459 }
1460
1461 static int v4l_enum_fmt(const struct v4l2_ioctl_ops *ops,
1462                                 struct file *file, void *fh, void *arg)
1463 {
1464         struct video_device *vdev = video_devdata(file);
1465         struct v4l2_fmtdesc *p = arg;
1466         int ret = check_fmt(file, p->type);
1467         u32 mbus_code;
1468         u32 cap_mask;
1469
1470         if (ret)
1471                 return ret;
1472         ret = -EINVAL;
1473
1474         if (!(vdev->device_caps & V4L2_CAP_IO_MC))
1475                 p->mbus_code = 0;
1476
1477         mbus_code = p->mbus_code;
1478         CLEAR_AFTER_FIELD(p, type);
1479         p->mbus_code = mbus_code;
1480
1481         switch (p->type) {
1482         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1483         case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
1484                 cap_mask = V4L2_CAP_VIDEO_CAPTURE_MPLANE |
1485                            V4L2_CAP_VIDEO_M2M_MPLANE;
1486                 if (!!(vdev->device_caps & cap_mask) !=
1487                     (p->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE))
1488                         break;
1489
1490                 if (unlikely(!ops->vidioc_enum_fmt_vid_cap))
1491                         break;
1492                 ret = ops->vidioc_enum_fmt_vid_cap(file, fh, arg);
1493                 break;
1494         case V4L2_BUF_TYPE_VIDEO_OVERLAY:
1495                 if (unlikely(!ops->vidioc_enum_fmt_vid_overlay))
1496                         break;
1497                 ret = ops->vidioc_enum_fmt_vid_overlay(file, fh, arg);
1498                 break;
1499         case V4L2_BUF_TYPE_VIDEO_OUTPUT:
1500         case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
1501                 cap_mask = V4L2_CAP_VIDEO_OUTPUT_MPLANE |
1502                            V4L2_CAP_VIDEO_M2M_MPLANE;
1503                 if (!!(vdev->device_caps & cap_mask) !=
1504                     (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE))
1505                         break;
1506
1507                 if (unlikely(!ops->vidioc_enum_fmt_vid_out))
1508                         break;
1509                 ret = ops->vidioc_enum_fmt_vid_out(file, fh, arg);
1510                 break;
1511         case V4L2_BUF_TYPE_SDR_CAPTURE:
1512                 if (unlikely(!ops->vidioc_enum_fmt_sdr_cap))
1513                         break;
1514                 ret = ops->vidioc_enum_fmt_sdr_cap(file, fh, arg);
1515                 break;
1516         case V4L2_BUF_TYPE_SDR_OUTPUT:
1517                 if (unlikely(!ops->vidioc_enum_fmt_sdr_out))
1518                         break;
1519                 ret = ops->vidioc_enum_fmt_sdr_out(file, fh, arg);
1520                 break;
1521         case V4L2_BUF_TYPE_META_CAPTURE:
1522                 if (unlikely(!ops->vidioc_enum_fmt_meta_cap))
1523                         break;
1524                 ret = ops->vidioc_enum_fmt_meta_cap(file, fh, arg);
1525                 break;
1526         case V4L2_BUF_TYPE_META_OUTPUT:
1527                 if (unlikely(!ops->vidioc_enum_fmt_meta_out))
1528                         break;
1529                 ret = ops->vidioc_enum_fmt_meta_out(file, fh, arg);
1530                 break;
1531         }
1532         if (ret == 0)
1533                 v4l_fill_fmtdesc(p);
1534         return ret;
1535 }
1536
1537 static void v4l_pix_format_touch(struct v4l2_pix_format *p)
1538 {
1539         /*
1540          * The v4l2_pix_format structure contains fields that make no sense for
1541          * touch. Set them to default values in this case.
1542          */
1543
1544         p->field = V4L2_FIELD_NONE;
1545         p->colorspace = V4L2_COLORSPACE_RAW;
1546         p->flags = 0;
1547         p->ycbcr_enc = 0;
1548         p->quantization = 0;
1549         p->xfer_func = 0;
1550 }
1551
1552 static int v4l_g_fmt(const struct v4l2_ioctl_ops *ops,
1553                                 struct file *file, void *fh, void *arg)
1554 {
1555         struct v4l2_format *p = arg;
1556         struct video_device *vfd = video_devdata(file);
1557         int ret = check_fmt(file, p->type);
1558
1559         if (ret)
1560                 return ret;
1561
1562         /*
1563          * fmt can't be cleared for these overlay types due to the 'clips'
1564          * 'clipcount' and 'bitmap' pointers in struct v4l2_window.
1565          * Those are provided by the user. So handle these two overlay types
1566          * first, and then just do a simple memset for the other types.
1567          */
1568         switch (p->type) {
1569         case V4L2_BUF_TYPE_VIDEO_OVERLAY:
1570         case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY: {
1571                 struct v4l2_clip *clips = p->fmt.win.clips;
1572                 u32 clipcount = p->fmt.win.clipcount;
1573                 void __user *bitmap = p->fmt.win.bitmap;
1574
1575                 memset(&p->fmt, 0, sizeof(p->fmt));
1576                 p->fmt.win.clips = clips;
1577                 p->fmt.win.clipcount = clipcount;
1578                 p->fmt.win.bitmap = bitmap;
1579                 break;
1580         }
1581         default:
1582                 memset(&p->fmt, 0, sizeof(p->fmt));
1583                 break;
1584         }
1585
1586         switch (p->type) {
1587         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1588                 if (unlikely(!ops->vidioc_g_fmt_vid_cap))
1589                         break;
1590                 p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
1591                 ret = ops->vidioc_g_fmt_vid_cap(file, fh, arg);
1592                 /* just in case the driver zeroed it again */
1593                 p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
1594                 if (vfd->vfl_type == VFL_TYPE_TOUCH)
1595                         v4l_pix_format_touch(&p->fmt.pix);
1596                 return ret;
1597         case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
1598                 return ops->vidioc_g_fmt_vid_cap_mplane(file, fh, arg);
1599         case V4L2_BUF_TYPE_VIDEO_OVERLAY:
1600                 return ops->vidioc_g_fmt_vid_overlay(file, fh, arg);
1601         case V4L2_BUF_TYPE_VBI_CAPTURE:
1602                 return ops->vidioc_g_fmt_vbi_cap(file, fh, arg);
1603         case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
1604                 return ops->vidioc_g_fmt_sliced_vbi_cap(file, fh, arg);
1605         case V4L2_BUF_TYPE_VIDEO_OUTPUT:
1606                 if (unlikely(!ops->vidioc_g_fmt_vid_out))
1607                         break;
1608                 p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
1609                 ret = ops->vidioc_g_fmt_vid_out(file, fh, arg);
1610                 /* just in case the driver zeroed it again */
1611                 p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
1612                 return ret;
1613         case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
1614                 return ops->vidioc_g_fmt_vid_out_mplane(file, fh, arg);
1615         case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
1616                 return ops->vidioc_g_fmt_vid_out_overlay(file, fh, arg);
1617         case V4L2_BUF_TYPE_VBI_OUTPUT:
1618                 return ops->vidioc_g_fmt_vbi_out(file, fh, arg);
1619         case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
1620                 return ops->vidioc_g_fmt_sliced_vbi_out(file, fh, arg);
1621         case V4L2_BUF_TYPE_SDR_CAPTURE:
1622                 return ops->vidioc_g_fmt_sdr_cap(file, fh, arg);
1623         case V4L2_BUF_TYPE_SDR_OUTPUT:
1624                 return ops->vidioc_g_fmt_sdr_out(file, fh, arg);
1625         case V4L2_BUF_TYPE_META_CAPTURE:
1626                 return ops->vidioc_g_fmt_meta_cap(file, fh, arg);
1627         case V4L2_BUF_TYPE_META_OUTPUT:
1628                 return ops->vidioc_g_fmt_meta_out(file, fh, arg);
1629         }
1630         return -EINVAL;
1631 }
1632
1633 static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops,
1634                                 struct file *file, void *fh, void *arg)
1635 {
1636         struct v4l2_format *p = arg;
1637         struct video_device *vfd = video_devdata(file);
1638         int ret = check_fmt(file, p->type);
1639         unsigned int i;
1640
1641         if (ret)
1642                 return ret;
1643
1644         ret = v4l_enable_media_source(vfd);
1645         if (ret)
1646                 return ret;
1647         v4l_sanitize_format(p);
1648
1649         switch (p->type) {
1650         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1651                 if (unlikely(!ops->vidioc_s_fmt_vid_cap))
1652                         break;
1653                 CLEAR_AFTER_FIELD(p, fmt.pix);
1654                 ret = ops->vidioc_s_fmt_vid_cap(file, fh, arg);
1655                 /* just in case the driver zeroed it again */
1656                 p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
1657                 if (vfd->vfl_type == VFL_TYPE_TOUCH)
1658                         v4l_pix_format_touch(&p->fmt.pix);
1659                 return ret;
1660         case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
1661                 if (unlikely(!ops->vidioc_s_fmt_vid_cap_mplane))
1662                         break;
1663                 CLEAR_AFTER_FIELD(p, fmt.pix_mp.xfer_func);
1664                 for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
1665                         CLEAR_AFTER_FIELD(&p->fmt.pix_mp.plane_fmt[i],
1666                                           bytesperline);
1667                 return ops->vidioc_s_fmt_vid_cap_mplane(file, fh, arg);
1668         case V4L2_BUF_TYPE_VIDEO_OVERLAY:
1669                 if (unlikely(!ops->vidioc_s_fmt_vid_overlay))
1670                         break;
1671                 CLEAR_AFTER_FIELD(p, fmt.win);
1672                 return ops->vidioc_s_fmt_vid_overlay(file, fh, arg);
1673         case V4L2_BUF_TYPE_VBI_CAPTURE:
1674                 if (unlikely(!ops->vidioc_s_fmt_vbi_cap))
1675                         break;
1676                 CLEAR_AFTER_FIELD(p, fmt.vbi.flags);
1677                 return ops->vidioc_s_fmt_vbi_cap(file, fh, arg);
1678         case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
1679                 if (unlikely(!ops->vidioc_s_fmt_sliced_vbi_cap))
1680                         break;
1681                 CLEAR_AFTER_FIELD(p, fmt.sliced.io_size);
1682                 return ops->vidioc_s_fmt_sliced_vbi_cap(file, fh, arg);
1683         case V4L2_BUF_TYPE_VIDEO_OUTPUT:
1684                 if (unlikely(!ops->vidioc_s_fmt_vid_out))
1685                         break;
1686                 CLEAR_AFTER_FIELD(p, fmt.pix);
1687                 ret = ops->vidioc_s_fmt_vid_out(file, fh, arg);
1688                 /* just in case the driver zeroed it again */
1689                 p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
1690                 return ret;
1691         case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
1692                 if (unlikely(!ops->vidioc_s_fmt_vid_out_mplane))
1693                         break;
1694                 CLEAR_AFTER_FIELD(p, fmt.pix_mp.xfer_func);
1695                 for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
1696                         CLEAR_AFTER_FIELD(&p->fmt.pix_mp.plane_fmt[i],
1697                                           bytesperline);
1698                 return ops->vidioc_s_fmt_vid_out_mplane(file, fh, arg);
1699         case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
1700                 if (unlikely(!ops->vidioc_s_fmt_vid_out_overlay))
1701                         break;
1702                 CLEAR_AFTER_FIELD(p, fmt.win);
1703                 return ops->vidioc_s_fmt_vid_out_overlay(file, fh, arg);
1704         case V4L2_BUF_TYPE_VBI_OUTPUT:
1705                 if (unlikely(!ops->vidioc_s_fmt_vbi_out))
1706                         break;
1707                 CLEAR_AFTER_FIELD(p, fmt.vbi.flags);
1708                 return ops->vidioc_s_fmt_vbi_out(file, fh, arg);
1709         case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
1710                 if (unlikely(!ops->vidioc_s_fmt_sliced_vbi_out))
1711                         break;
1712                 CLEAR_AFTER_FIELD(p, fmt.sliced.io_size);
1713                 return ops->vidioc_s_fmt_sliced_vbi_out(file, fh, arg);
1714         case V4L2_BUF_TYPE_SDR_CAPTURE:
1715                 if (unlikely(!ops->vidioc_s_fmt_sdr_cap))
1716                         break;
1717                 CLEAR_AFTER_FIELD(p, fmt.sdr.buffersize);
1718                 return ops->vidioc_s_fmt_sdr_cap(file, fh, arg);
1719         case V4L2_BUF_TYPE_SDR_OUTPUT:
1720                 if (unlikely(!ops->vidioc_s_fmt_sdr_out))
1721                         break;
1722                 CLEAR_AFTER_FIELD(p, fmt.sdr.buffersize);
1723                 return ops->vidioc_s_fmt_sdr_out(file, fh, arg);
1724         case V4L2_BUF_TYPE_META_CAPTURE:
1725                 if (unlikely(!ops->vidioc_s_fmt_meta_cap))
1726                         break;
1727                 CLEAR_AFTER_FIELD(p, fmt.meta);
1728                 return ops->vidioc_s_fmt_meta_cap(file, fh, arg);
1729         case V4L2_BUF_TYPE_META_OUTPUT:
1730                 if (unlikely(!ops->vidioc_s_fmt_meta_out))
1731                         break;
1732                 CLEAR_AFTER_FIELD(p, fmt.meta);
1733                 return ops->vidioc_s_fmt_meta_out(file, fh, arg);
1734         }
1735         return -EINVAL;
1736 }
1737
1738 static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops,
1739                                 struct file *file, void *fh, void *arg)
1740 {
1741         struct v4l2_format *p = arg;
1742         struct video_device *vfd = video_devdata(file);
1743         int ret = check_fmt(file, p->type);
1744         unsigned int i;
1745
1746         if (ret)
1747                 return ret;
1748
1749         v4l_sanitize_format(p);
1750
1751         switch (p->type) {
1752         case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1753                 if (unlikely(!ops->vidioc_try_fmt_vid_cap))
1754                         break;
1755                 CLEAR_AFTER_FIELD(p, fmt.pix);
1756                 ret = ops->vidioc_try_fmt_vid_cap(file, fh, arg);
1757                 /* just in case the driver zeroed it again */
1758                 p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
1759                 if (vfd->vfl_type == VFL_TYPE_TOUCH)
1760                         v4l_pix_format_touch(&p->fmt.pix);
1761                 return ret;
1762         case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
1763                 if (unlikely(!ops->vidioc_try_fmt_vid_cap_mplane))
1764                         break;
1765                 CLEAR_AFTER_FIELD(p, fmt.pix_mp.xfer_func);
1766                 for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
1767                         CLEAR_AFTER_FIELD(&p->fmt.pix_mp.plane_fmt[i],
1768                                           bytesperline);
1769                 return ops->vidioc_try_fmt_vid_cap_mplane(file, fh, arg);
1770         case V4L2_BUF_TYPE_VIDEO_OVERLAY:
1771                 if (unlikely(!ops->vidioc_try_fmt_vid_overlay))
1772                         break;
1773                 CLEAR_AFTER_FIELD(p, fmt.win);
1774                 return ops->vidioc_try_fmt_vid_overlay(file, fh, arg);
1775         case V4L2_BUF_TYPE_VBI_CAPTURE:
1776                 if (unlikely(!ops->vidioc_try_fmt_vbi_cap))
1777                         break;
1778                 CLEAR_AFTER_FIELD(p, fmt.vbi.flags);
1779                 return ops->vidioc_try_fmt_vbi_cap(file, fh, arg);
1780         case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
1781                 if (unlikely(!ops->vidioc_try_fmt_sliced_vbi_cap))
1782                         break;
1783                 CLEAR_AFTER_FIELD(p, fmt.sliced.io_size);
1784                 return ops->vidioc_try_fmt_sliced_vbi_cap(file, fh, arg);
1785         case V4L2_BUF_TYPE_VIDEO_OUTPUT:
1786                 if (unlikely(!ops->vidioc_try_fmt_vid_out))
1787                         break;
1788                 CLEAR_AFTER_FIELD(p, fmt.pix);
1789                 ret = ops->vidioc_try_fmt_vid_out(file, fh, arg);
1790                 /* just in case the driver zeroed it again */
1791                 p->fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
1792                 return ret;
1793         case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
1794                 if (unlikely(!ops->vidioc_try_fmt_vid_out_mplane))
1795                         break;
1796                 CLEAR_AFTER_FIELD(p, fmt.pix_mp.xfer_func);
1797                 for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
1798                         CLEAR_AFTER_FIELD(&p->fmt.pix_mp.plane_fmt[i],
1799                                           bytesperline);
1800                 return ops->vidioc_try_fmt_vid_out_mplane(file, fh, arg);
1801         case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
1802                 if (unlikely(!ops->vidioc_try_fmt_vid_out_overlay))
1803                         break;
1804                 CLEAR_AFTER_FIELD(p, fmt.win);
1805                 return ops->vidioc_try_fmt_vid_out_overlay(file, fh, arg);
1806         case V4L2_BUF_TYPE_VBI_OUTPUT:
1807                 if (unlikely(!ops->vidioc_try_fmt_vbi_out))
1808                         break;
1809                 CLEAR_AFTER_FIELD(p, fmt.vbi.flags);
1810                 return ops->vidioc_try_fmt_vbi_out(file, fh, arg);
1811         case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
1812                 if (unlikely(!ops->vidioc_try_fmt_sliced_vbi_out))
1813                         break;
1814                 CLEAR_AFTER_FIELD(p, fmt.sliced.io_size);
1815                 return ops->vidioc_try_fmt_sliced_vbi_out(file, fh, arg);
1816         case V4L2_BUF_TYPE_SDR_CAPTURE:
1817                 if (unlikely(!ops->vidioc_try_fmt_sdr_cap))
1818                         break;
1819                 CLEAR_AFTER_FIELD(p, fmt.sdr.buffersize);
1820                 return ops->vidioc_try_fmt_sdr_cap(file, fh, arg);
1821         case V4L2_BUF_TYPE_SDR_OUTPUT:
1822                 if (unlikely(!ops->vidioc_try_fmt_sdr_out))
1823                         break;
1824                 CLEAR_AFTER_FIELD(p, fmt.sdr.buffersize);
1825                 return ops->vidioc_try_fmt_sdr_out(file, fh, arg);
1826         case V4L2_BUF_TYPE_META_CAPTURE:
1827                 if (unlikely(!ops->vidioc_try_fmt_meta_cap))
1828                         break;
1829                 CLEAR_AFTER_FIELD(p, fmt.meta);
1830                 return ops->vidioc_try_fmt_meta_cap(file, fh, arg);
1831         case V4L2_BUF_TYPE_META_OUTPUT:
1832                 if (unlikely(!ops->vidioc_try_fmt_meta_out))
1833                         break;
1834                 CLEAR_AFTER_FIELD(p, fmt.meta);
1835                 return ops->vidioc_try_fmt_meta_out(file, fh, arg);
1836         }
1837         return -EINVAL;
1838 }
1839
1840 static int v4l_streamon(const struct v4l2_ioctl_ops *ops,
1841                                 struct file *file, void *fh, void *arg)
1842 {
1843         return ops->vidioc_streamon(file, fh, *(unsigned int *)arg);
1844 }
1845
1846 static int v4l_streamoff(const struct v4l2_ioctl_ops *ops,
1847                                 struct file *file, void *fh, void *arg)
1848 {
1849         return ops->vidioc_streamoff(file, fh, *(unsigned int *)arg);
1850 }
1851
1852 static int v4l_g_tuner(const struct v4l2_ioctl_ops *ops,
1853                                 struct file *file, void *fh, void *arg)
1854 {
1855         struct video_device *vfd = video_devdata(file);
1856         struct v4l2_tuner *p = arg;
1857         int err;
1858
1859         p->type = (vfd->vfl_type == VFL_TYPE_RADIO) ?
1860                         V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
1861         err = ops->vidioc_g_tuner(file, fh, p);
1862         if (!err)
1863                 p->capability |= V4L2_TUNER_CAP_FREQ_BANDS;
1864         return err;
1865 }
1866
1867 static int v4l_s_tuner(const struct v4l2_ioctl_ops *ops,
1868                                 struct file *file, void *fh, void *arg)
1869 {
1870         struct video_device *vfd = video_devdata(file);
1871         struct v4l2_tuner *p = arg;
1872         int ret;
1873
1874         ret = v4l_enable_media_source(vfd);
1875         if (ret)
1876                 return ret;
1877         p->type = (vfd->vfl_type == VFL_TYPE_RADIO) ?
1878                         V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
1879         return ops->vidioc_s_tuner(file, fh, p);
1880 }
1881
1882 static int v4l_g_modulator(const struct v4l2_ioctl_ops *ops,
1883                                 struct file *file, void *fh, void *arg)
1884 {
1885         struct video_device *vfd = video_devdata(file);
1886         struct v4l2_modulator *p = arg;
1887         int err;
1888
1889         if (vfd->vfl_type == VFL_TYPE_RADIO)
1890                 p->type = V4L2_TUNER_RADIO;
1891
1892         err = ops->vidioc_g_modulator(file, fh, p);
1893         if (!err)
1894                 p->capability |= V4L2_TUNER_CAP_FREQ_BANDS;
1895         return err;
1896 }
1897
1898 static int v4l_s_modulator(const struct v4l2_ioctl_ops *ops,
1899                                 struct file *file, void *fh, void *arg)
1900 {
1901         struct video_device *vfd = video_devdata(file);
1902         struct v4l2_modulator *p = arg;
1903
1904         if (vfd->vfl_type == VFL_TYPE_RADIO)
1905                 p->type = V4L2_TUNER_RADIO;
1906
1907         return ops->vidioc_s_modulator(file, fh, p);
1908 }
1909
1910 static int v4l_g_frequency(const struct v4l2_ioctl_ops *ops,
1911                                 struct file *file, void *fh, void *arg)
1912 {
1913         struct video_device *vfd = video_devdata(file);
1914         struct v4l2_frequency *p = arg;
1915
1916         if (vfd->vfl_type == VFL_TYPE_SDR)
1917                 p->type = V4L2_TUNER_SDR;
1918         else
1919                 p->type = (vfd->vfl_type == VFL_TYPE_RADIO) ?
1920                                 V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
1921         return ops->vidioc_g_frequency(file, fh, p);
1922 }
1923
1924 static int v4l_s_frequency(const struct v4l2_ioctl_ops *ops,
1925                                 struct file *file, void *fh, void *arg)
1926 {
1927         struct video_device *vfd = video_devdata(file);
1928         const struct v4l2_frequency *p = arg;
1929         enum v4l2_tuner_type type;
1930         int ret;
1931
1932         ret = v4l_enable_media_source(vfd);
1933         if (ret)
1934                 return ret;
1935         if (vfd->vfl_type == VFL_TYPE_SDR) {
1936                 if (p->type != V4L2_TUNER_SDR && p->type != V4L2_TUNER_RF)
1937                         return -EINVAL;
1938         } else {
1939                 type = (vfd->vfl_type == VFL_TYPE_RADIO) ?
1940                                 V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
1941                 if (type != p->type)
1942                         return -EINVAL;
1943         }
1944         return ops->vidioc_s_frequency(file, fh, p);
1945 }
1946
1947 static int v4l_enumstd(const struct v4l2_ioctl_ops *ops,
1948                                 struct file *file, void *fh, void *arg)
1949 {
1950         struct video_device *vfd = video_devdata(file);
1951         struct v4l2_standard *p = arg;
1952
1953         return v4l_video_std_enumstd(p, vfd->tvnorms);
1954 }
1955
1956 static int v4l_s_std(const struct v4l2_ioctl_ops *ops,
1957                                 struct file *file, void *fh, void *arg)
1958 {
1959         struct video_device *vfd = video_devdata(file);
1960         v4l2_std_id id = *(v4l2_std_id *)arg, norm;
1961         int ret;
1962
1963         ret = v4l_enable_media_source(vfd);
1964         if (ret)
1965                 return ret;
1966         norm = id & vfd->tvnorms;
1967         if (vfd->tvnorms && !norm)      /* Check if std is supported */
1968                 return -EINVAL;
1969
1970         /* Calls the specific handler */
1971         return ops->vidioc_s_std(file, fh, norm);
1972 }
1973
1974 static int v4l_querystd(const struct v4l2_ioctl_ops *ops,
1975                                 struct file *file, void *fh, void *arg)
1976 {
1977         struct video_device *vfd = video_devdata(file);
1978         v4l2_std_id *p = arg;
1979         int ret;
1980
1981         ret = v4l_enable_media_source(vfd);
1982         if (ret)
1983                 return ret;
1984         /*
1985          * If no signal is detected, then the driver should return
1986          * V4L2_STD_UNKNOWN. Otherwise it should return tvnorms with
1987          * any standards that do not apply removed.
1988          *
1989          * This means that tuners, audio and video decoders can join
1990          * their efforts to improve the standards detection.
1991          */
1992         *p = vfd->tvnorms;
1993         return ops->vidioc_querystd(file, fh, arg);
1994 }
1995
1996 static int v4l_s_hw_freq_seek(const struct v4l2_ioctl_ops *ops,
1997                                 struct file *file, void *fh, void *arg)
1998 {
1999         struct video_device *vfd = video_devdata(file);
2000         struct v4l2_hw_freq_seek *p = arg;
2001         enum v4l2_tuner_type type;
2002         int ret;
2003
2004         ret = v4l_enable_media_source(vfd);
2005         if (ret)
2006                 return ret;
2007         /* s_hw_freq_seek is not supported for SDR for now */
2008         if (vfd->vfl_type == VFL_TYPE_SDR)
2009                 return -EINVAL;
2010
2011         type = (vfd->vfl_type == VFL_TYPE_RADIO) ?
2012                 V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
2013         if (p->type != type)
2014                 return -EINVAL;
2015         return ops->vidioc_s_hw_freq_seek(file, fh, p);
2016 }
2017
2018 static int v4l_overlay(const struct v4l2_ioctl_ops *ops,
2019                                 struct file *file, void *fh, void *arg)
2020 {
2021         return ops->vidioc_overlay(file, fh, *(unsigned int *)arg);
2022 }
2023
2024 static int v4l_reqbufs(const struct v4l2_ioctl_ops *ops,
2025                                 struct file *file, void *fh, void *arg)
2026 {
2027         struct v4l2_requestbuffers *p = arg;
2028         int ret = check_fmt(file, p->type);
2029
2030         if (ret)
2031                 return ret;
2032
2033         CLEAR_AFTER_FIELD(p, capabilities);
2034
2035         return ops->vidioc_reqbufs(file, fh, p);
2036 }
2037
2038 static int v4l_querybuf(const struct v4l2_ioctl_ops *ops,
2039                                 struct file *file, void *fh, void *arg)
2040 {
2041         struct v4l2_buffer *p = arg;
2042         int ret = check_fmt(file, p->type);
2043
2044         return ret ? ret : ops->vidioc_querybuf(file, fh, p);
2045 }
2046
2047 static int v4l_qbuf(const struct v4l2_ioctl_ops *ops,
2048                                 struct file *file, void *fh, void *arg)
2049 {
2050         struct v4l2_buffer *p = arg;
2051         int ret = check_fmt(file, p->type);
2052
2053         return ret ? ret : ops->vidioc_qbuf(file, fh, p);
2054 }
2055
2056 static int v4l_dqbuf(const struct v4l2_ioctl_ops *ops,
2057                                 struct file *file, void *fh, void *arg)
2058 {
2059         struct v4l2_buffer *p = arg;
2060         int ret = check_fmt(file, p->type);
2061
2062         return ret ? ret : ops->vidioc_dqbuf(file, fh, p);
2063 }
2064
2065 static int v4l_create_bufs(const struct v4l2_ioctl_ops *ops,
2066                                 struct file *file, void *fh, void *arg)
2067 {
2068         struct v4l2_create_buffers *create = arg;
2069         int ret = check_fmt(file, create->format.type);
2070
2071         if (ret)
2072                 return ret;
2073
2074         CLEAR_AFTER_FIELD(create, capabilities);
2075
2076         v4l_sanitize_format(&create->format);
2077
2078         ret = ops->vidioc_create_bufs(file, fh, create);
2079
2080         if (create->format.type == V4L2_BUF_TYPE_VIDEO_CAPTURE ||
2081             create->format.type == V4L2_BUF_TYPE_VIDEO_OUTPUT)
2082                 create->format.fmt.pix.priv = V4L2_PIX_FMT_PRIV_MAGIC;
2083
2084         return ret;
2085 }
2086
2087 static int v4l_prepare_buf(const struct v4l2_ioctl_ops *ops,
2088                                 struct file *file, void *fh, void *arg)
2089 {
2090         struct v4l2_buffer *b = arg;
2091         int ret = check_fmt(file, b->type);
2092
2093         return ret ? ret : ops->vidioc_prepare_buf(file, fh, b);
2094 }
2095
2096 static int v4l_g_parm(const struct v4l2_ioctl_ops *ops,
2097                                 struct file *file, void *fh, void *arg)
2098 {
2099         struct video_device *vfd = video_devdata(file);
2100         struct v4l2_streamparm *p = arg;
2101         v4l2_std_id std;
2102         int ret = check_fmt(file, p->type);
2103
2104         if (ret)
2105                 return ret;
2106         if (ops->vidioc_g_parm)
2107                 return ops->vidioc_g_parm(file, fh, p);
2108         if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
2109             p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
2110                 return -EINVAL;
2111         if (vfd->device_caps & V4L2_CAP_READWRITE)
2112                 p->parm.capture.readbuffers = 2;
2113         ret = ops->vidioc_g_std(file, fh, &std);
2114         if (ret == 0)
2115                 v4l2_video_std_frame_period(std, &p->parm.capture.timeperframe);
2116         return ret;
2117 }
2118
2119 static int v4l_s_parm(const struct v4l2_ioctl_ops *ops,
2120                                 struct file *file, void *fh, void *arg)
2121 {
2122         struct v4l2_streamparm *p = arg;
2123         int ret = check_fmt(file, p->type);
2124
2125         if (ret)
2126                 return ret;
2127
2128         /* Note: extendedmode is never used in drivers */
2129         if (V4L2_TYPE_IS_OUTPUT(p->type)) {
2130                 memset(p->parm.output.reserved, 0,
2131                        sizeof(p->parm.output.reserved));
2132                 p->parm.output.extendedmode = 0;
2133                 p->parm.output.outputmode &= V4L2_MODE_HIGHQUALITY;
2134         } else {
2135                 memset(p->parm.capture.reserved, 0,
2136                        sizeof(p->parm.capture.reserved));
2137                 p->parm.capture.extendedmode = 0;
2138                 p->parm.capture.capturemode &= V4L2_MODE_HIGHQUALITY;
2139         }
2140         return ops->vidioc_s_parm(file, fh, p);
2141 }
2142
2143 static int v4l_queryctrl(const struct v4l2_ioctl_ops *ops,
2144                                 struct file *file, void *fh, void *arg)
2145 {
2146         struct video_device *vfd = video_devdata(file);
2147         struct v4l2_queryctrl *p = arg;
2148         struct v4l2_fh *vfh =
2149                 test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) ? fh : NULL;
2150
2151         if (vfh && vfh->ctrl_handler)
2152                 return v4l2_queryctrl(vfh->ctrl_handler, p);
2153         if (vfd->ctrl_handler)
2154                 return v4l2_queryctrl(vfd->ctrl_handler, p);
2155         if (ops->vidioc_queryctrl)
2156                 return ops->vidioc_queryctrl(file, fh, p);
2157         return -ENOTTY;
2158 }
2159
2160 static int v4l_query_ext_ctrl(const struct v4l2_ioctl_ops *ops,
2161                                 struct file *file, void *fh, void *arg)
2162 {
2163         struct video_device *vfd = video_devdata(file);
2164         struct v4l2_query_ext_ctrl *p = arg;
2165         struct v4l2_fh *vfh =
2166                 test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) ? fh : NULL;
2167
2168         if (vfh && vfh->ctrl_handler)
2169                 return v4l2_query_ext_ctrl(vfh->ctrl_handler, p);
2170         if (vfd->ctrl_handler)
2171                 return v4l2_query_ext_ctrl(vfd->ctrl_handler, p);
2172         if (ops->vidioc_query_ext_ctrl)
2173                 return ops->vidioc_query_ext_ctrl(file, fh, p);
2174         return -ENOTTY;
2175 }
2176
2177 static int v4l_querymenu(const struct v4l2_ioctl_ops *ops,
2178                                 struct file *file, void *fh, void *arg)
2179 {
2180         struct video_device *vfd = video_devdata(file);
2181         struct v4l2_querymenu *p = arg;
2182         struct v4l2_fh *vfh =
2183                 test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) ? fh : NULL;
2184
2185         if (vfh && vfh->ctrl_handler)
2186                 return v4l2_querymenu(vfh->ctrl_handler, p);
2187         if (vfd->ctrl_handler)
2188                 return v4l2_querymenu(vfd->ctrl_handler, p);
2189         if (ops->vidioc_querymenu)
2190                 return ops->vidioc_querymenu(file, fh, p);
2191         return -ENOTTY;
2192 }
2193
2194 static int v4l_g_ctrl(const struct v4l2_ioctl_ops *ops,
2195                                 struct file *file, void *fh, void *arg)
2196 {
2197         struct video_device *vfd = video_devdata(file);
2198         struct v4l2_control *p = arg;
2199         struct v4l2_fh *vfh =
2200                 test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) ? fh : NULL;
2201         struct v4l2_ext_controls ctrls;
2202         struct v4l2_ext_control ctrl;
2203
2204         if (vfh && vfh->ctrl_handler)
2205                 return v4l2_g_ctrl(vfh->ctrl_handler, p);
2206         if (vfd->ctrl_handler)
2207                 return v4l2_g_ctrl(vfd->ctrl_handler, p);
2208         if (ops->vidioc_g_ctrl)
2209                 return ops->vidioc_g_ctrl(file, fh, p);
2210         if (ops->vidioc_g_ext_ctrls == NULL)
2211                 return -ENOTTY;
2212
2213         ctrls.which = V4L2_CTRL_ID2WHICH(p->id);
2214         ctrls.count = 1;
2215         ctrls.controls = &ctrl;
2216         ctrl.id = p->id;
2217         ctrl.value = p->value;
2218         if (check_ext_ctrls(&ctrls, VIDIOC_G_CTRL)) {
2219                 int ret = ops->vidioc_g_ext_ctrls(file, fh, &ctrls);
2220
2221                 if (ret == 0)
2222                         p->value = ctrl.value;
2223                 return ret;
2224         }
2225         return -EINVAL;
2226 }
2227
2228 static int v4l_s_ctrl(const struct v4l2_ioctl_ops *ops,
2229                                 struct file *file, void *fh, void *arg)
2230 {
2231         struct video_device *vfd = video_devdata(file);
2232         struct v4l2_control *p = arg;
2233         struct v4l2_fh *vfh =
2234                 test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) ? fh : NULL;
2235         struct v4l2_ext_controls ctrls;
2236         struct v4l2_ext_control ctrl;
2237         int ret;
2238
2239         if (vfh && vfh->ctrl_handler)
2240                 return v4l2_s_ctrl(vfh, vfh->ctrl_handler, p);
2241         if (vfd->ctrl_handler)
2242                 return v4l2_s_ctrl(NULL, vfd->ctrl_handler, p);
2243         if (ops->vidioc_s_ctrl)
2244                 return ops->vidioc_s_ctrl(file, fh, p);
2245         if (ops->vidioc_s_ext_ctrls == NULL)
2246                 return -ENOTTY;
2247
2248         ctrls.which = V4L2_CTRL_ID2WHICH(p->id);
2249         ctrls.count = 1;
2250         ctrls.controls = &ctrl;
2251         ctrl.id = p->id;
2252         ctrl.value = p->value;
2253         if (!check_ext_ctrls(&ctrls, VIDIOC_S_CTRL))
2254                 return -EINVAL;
2255         ret = ops->vidioc_s_ext_ctrls(file, fh, &ctrls);
2256         p->value = ctrl.value;
2257         return ret;
2258 }
2259
2260 static int v4l_g_ext_ctrls(const struct v4l2_ioctl_ops *ops,
2261                                 struct file *file, void *fh, void *arg)
2262 {
2263         struct video_device *vfd = video_devdata(file);
2264         struct v4l2_ext_controls *p = arg;
2265         struct v4l2_fh *vfh =
2266                 test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) ? fh : NULL;
2267
2268         p->error_idx = p->count;
2269         if (vfh && vfh->ctrl_handler)
2270                 return v4l2_g_ext_ctrls(vfh->ctrl_handler,
2271                                         vfd, vfd->v4l2_dev->mdev, p);
2272         if (vfd->ctrl_handler)
2273                 return v4l2_g_ext_ctrls(vfd->ctrl_handler,
2274                                         vfd, vfd->v4l2_dev->mdev, p);
2275         if (ops->vidioc_g_ext_ctrls == NULL)
2276                 return -ENOTTY;
2277         return check_ext_ctrls(p, VIDIOC_G_EXT_CTRLS) ?
2278                                 ops->vidioc_g_ext_ctrls(file, fh, p) : -EINVAL;
2279 }
2280
2281 static int v4l_s_ext_ctrls(const struct v4l2_ioctl_ops *ops,
2282                                 struct file *file, void *fh, void *arg)
2283 {
2284         struct video_device *vfd = video_devdata(file);
2285         struct v4l2_ext_controls *p = arg;
2286         struct v4l2_fh *vfh =
2287                 test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) ? fh : NULL;
2288
2289         p->error_idx = p->count;
2290         if (vfh && vfh->ctrl_handler)
2291                 return v4l2_s_ext_ctrls(vfh, vfh->ctrl_handler,
2292                                         vfd, vfd->v4l2_dev->mdev, p);
2293         if (vfd->ctrl_handler)
2294                 return v4l2_s_ext_ctrls(NULL, vfd->ctrl_handler,
2295                                         vfd, vfd->v4l2_dev->mdev, p);
2296         if (ops->vidioc_s_ext_ctrls == NULL)
2297                 return -ENOTTY;
2298         return check_ext_ctrls(p, VIDIOC_S_EXT_CTRLS) ?
2299                                 ops->vidioc_s_ext_ctrls(file, fh, p) : -EINVAL;
2300 }
2301
2302 static int v4l_try_ext_ctrls(const struct v4l2_ioctl_ops *ops,
2303                                 struct file *file, void *fh, void *arg)
2304 {
2305         struct video_device *vfd = video_devdata(file);
2306         struct v4l2_ext_controls *p = arg;
2307         struct v4l2_fh *vfh =
2308                 test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) ? fh : NULL;
2309
2310         p->error_idx = p->count;
2311         if (vfh && vfh->ctrl_handler)
2312                 return v4l2_try_ext_ctrls(vfh->ctrl_handler,
2313                                           vfd, vfd->v4l2_dev->mdev, p);
2314         if (vfd->ctrl_handler)
2315                 return v4l2_try_ext_ctrls(vfd->ctrl_handler,
2316                                           vfd, vfd->v4l2_dev->mdev, p);
2317         if (ops->vidioc_try_ext_ctrls == NULL)
2318                 return -ENOTTY;
2319         return check_ext_ctrls(p, VIDIOC_TRY_EXT_CTRLS) ?
2320                         ops->vidioc_try_ext_ctrls(file, fh, p) : -EINVAL;
2321 }
2322
2323 /*
2324  * The selection API specified originally that the _MPLANE buffer types
2325  * shouldn't be used. The reasons for this are lost in the mists of time
2326  * (or just really crappy memories). Regardless, this is really annoying
2327  * for userspace. So to keep things simple we map _MPLANE buffer types
2328  * to their 'regular' counterparts before calling the driver. And we
2329  * restore it afterwards. This way applications can use either buffer
2330  * type and drivers don't need to check for both.
2331  */
2332 static int v4l_g_selection(const struct v4l2_ioctl_ops *ops,
2333                            struct file *file, void *fh, void *arg)
2334 {
2335         struct v4l2_selection *p = arg;
2336         u32 old_type = p->type;
2337         int ret;
2338
2339         if (p->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
2340                 p->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2341         else if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
2342                 p->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
2343         ret = ops->vidioc_g_selection(file, fh, p);
2344         p->type = old_type;
2345         return ret;
2346 }
2347
2348 static int v4l_s_selection(const struct v4l2_ioctl_ops *ops,
2349                            struct file *file, void *fh, void *arg)
2350 {
2351         struct v4l2_selection *p = arg;
2352         u32 old_type = p->type;
2353         int ret;
2354
2355         if (p->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
2356                 p->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2357         else if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
2358                 p->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
2359         ret = ops->vidioc_s_selection(file, fh, p);
2360         p->type = old_type;
2361         return ret;
2362 }
2363
2364 static int v4l_g_crop(const struct v4l2_ioctl_ops *ops,
2365                                 struct file *file, void *fh, void *arg)
2366 {
2367         struct video_device *vfd = video_devdata(file);
2368         struct v4l2_crop *p = arg;
2369         struct v4l2_selection s = {
2370                 .type = p->type,
2371         };
2372         int ret;
2373
2374         /* simulate capture crop using selection api */
2375
2376         /* crop means compose for output devices */
2377         if (V4L2_TYPE_IS_OUTPUT(p->type))
2378                 s.target = V4L2_SEL_TGT_COMPOSE;
2379         else
2380                 s.target = V4L2_SEL_TGT_CROP;
2381
2382         if (test_bit(V4L2_FL_QUIRK_INVERTED_CROP, &vfd->flags))
2383                 s.target = s.target == V4L2_SEL_TGT_COMPOSE ?
2384                         V4L2_SEL_TGT_CROP : V4L2_SEL_TGT_COMPOSE;
2385
2386         ret = v4l_g_selection(ops, file, fh, &s);
2387
2388         /* copying results to old structure on success */
2389         if (!ret)
2390                 p->c = s.r;
2391         return ret;
2392 }
2393
2394 static int v4l_s_crop(const struct v4l2_ioctl_ops *ops,
2395                                 struct file *file, void *fh, void *arg)
2396 {
2397         struct video_device *vfd = video_devdata(file);
2398         struct v4l2_crop *p = arg;
2399         struct v4l2_selection s = {
2400                 .type = p->type,
2401                 .r = p->c,
2402         };
2403
2404         /* simulate capture crop using selection api */
2405
2406         /* crop means compose for output devices */
2407         if (V4L2_TYPE_IS_OUTPUT(p->type))
2408                 s.target = V4L2_SEL_TGT_COMPOSE;
2409         else
2410                 s.target = V4L2_SEL_TGT_CROP;
2411
2412         if (test_bit(V4L2_FL_QUIRK_INVERTED_CROP, &vfd->flags))
2413                 s.target = s.target == V4L2_SEL_TGT_COMPOSE ?
2414                         V4L2_SEL_TGT_CROP : V4L2_SEL_TGT_COMPOSE;
2415
2416         return v4l_s_selection(ops, file, fh, &s);
2417 }
2418
2419 static int v4l_cropcap(const struct v4l2_ioctl_ops *ops,
2420                                 struct file *file, void *fh, void *arg)
2421 {
2422         struct video_device *vfd = video_devdata(file);
2423         struct v4l2_cropcap *p = arg;
2424         struct v4l2_selection s = { .type = p->type };
2425         int ret = 0;
2426
2427         /* setting trivial pixelaspect */
2428         p->pixelaspect.numerator = 1;
2429         p->pixelaspect.denominator = 1;
2430
2431         if (s.type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
2432                 s.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2433         else if (s.type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
2434                 s.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
2435
2436         /*
2437          * The determine_valid_ioctls() call already should ensure
2438          * that this can never happen, but just in case...
2439          */
2440         if (WARN_ON(!ops->vidioc_g_selection))
2441                 return -ENOTTY;
2442
2443         if (ops->vidioc_g_pixelaspect)
2444                 ret = ops->vidioc_g_pixelaspect(file, fh, s.type,
2445                                                 &p->pixelaspect);
2446
2447         /*
2448          * Ignore ENOTTY or ENOIOCTLCMD error returns, just use the
2449          * square pixel aspect ratio in that case.
2450          */
2451         if (ret && ret != -ENOTTY && ret != -ENOIOCTLCMD)
2452                 return ret;
2453
2454         /* Use g_selection() to fill in the bounds and defrect rectangles */
2455
2456         /* obtaining bounds */
2457         if (V4L2_TYPE_IS_OUTPUT(p->type))
2458                 s.target = V4L2_SEL_TGT_COMPOSE_BOUNDS;
2459         else
2460                 s.target = V4L2_SEL_TGT_CROP_BOUNDS;
2461
2462         if (test_bit(V4L2_FL_QUIRK_INVERTED_CROP, &vfd->flags))
2463                 s.target = s.target == V4L2_SEL_TGT_COMPOSE_BOUNDS ?
2464                         V4L2_SEL_TGT_CROP_BOUNDS : V4L2_SEL_TGT_COMPOSE_BOUNDS;
2465
2466         ret = v4l_g_selection(ops, file, fh, &s);
2467         if (ret)
2468                 return ret;
2469         p->bounds = s.r;
2470
2471         /* obtaining defrect */
2472         if (s.target == V4L2_SEL_TGT_COMPOSE_BOUNDS)
2473                 s.target = V4L2_SEL_TGT_COMPOSE_DEFAULT;
2474         else
2475                 s.target = V4L2_SEL_TGT_CROP_DEFAULT;
2476
2477         ret = v4l_g_selection(ops, file, fh, &s);
2478         if (ret)
2479                 return ret;
2480         p->defrect = s.r;
2481
2482         return 0;
2483 }
2484
2485 static int v4l_log_status(const struct v4l2_ioctl_ops *ops,
2486                                 struct file *file, void *fh, void *arg)
2487 {
2488         struct video_device *vfd = video_devdata(file);
2489         int ret;
2490
2491         if (vfd->v4l2_dev)
2492                 pr_info("%s: =================  START STATUS  =================\n",
2493                         vfd->v4l2_dev->name);
2494         ret = ops->vidioc_log_status(file, fh);
2495         if (vfd->v4l2_dev)
2496                 pr_info("%s: ==================  END STATUS  ==================\n",
2497                         vfd->v4l2_dev->name);
2498         return ret;
2499 }
2500
2501 static int v4l_dbg_g_register(const struct v4l2_ioctl_ops *ops,
2502                                 struct file *file, void *fh, void *arg)
2503 {
2504 #ifdef CONFIG_VIDEO_ADV_DEBUG
2505         struct v4l2_dbg_register *p = arg;
2506         struct video_device *vfd = video_devdata(file);
2507         struct v4l2_subdev *sd;
2508         int idx = 0;
2509
2510         if (!capable(CAP_SYS_ADMIN))
2511                 return -EPERM;
2512         if (p->match.type == V4L2_CHIP_MATCH_SUBDEV) {
2513                 if (vfd->v4l2_dev == NULL)
2514                         return -EINVAL;
2515                 v4l2_device_for_each_subdev(sd, vfd->v4l2_dev)
2516                         if (p->match.addr == idx++)
2517                                 return v4l2_subdev_call(sd, core, g_register, p);
2518                 return -EINVAL;
2519         }
2520         if (ops->vidioc_g_register && p->match.type == V4L2_CHIP_MATCH_BRIDGE &&
2521             (ops->vidioc_g_chip_info || p->match.addr == 0))
2522                 return ops->vidioc_g_register(file, fh, p);
2523         return -EINVAL;
2524 #else
2525         return -ENOTTY;
2526 #endif
2527 }
2528
2529 static int v4l_dbg_s_register(const struct v4l2_ioctl_ops *ops,
2530                                 struct file *file, void *fh, void *arg)
2531 {
2532 #ifdef CONFIG_VIDEO_ADV_DEBUG
2533         const struct v4l2_dbg_register *p = arg;
2534         struct video_device *vfd = video_devdata(file);
2535         struct v4l2_subdev *sd;
2536         int idx = 0;
2537
2538         if (!capable(CAP_SYS_ADMIN))
2539                 return -EPERM;
2540         if (p->match.type == V4L2_CHIP_MATCH_SUBDEV) {
2541                 if (vfd->v4l2_dev == NULL)
2542                         return -EINVAL;
2543                 v4l2_device_for_each_subdev(sd, vfd->v4l2_dev)
2544                         if (p->match.addr == idx++)
2545                                 return v4l2_subdev_call(sd, core, s_register, p);
2546                 return -EINVAL;
2547         }
2548         if (ops->vidioc_s_register && p->match.type == V4L2_CHIP_MATCH_BRIDGE &&
2549             (ops->vidioc_g_chip_info || p->match.addr == 0))
2550                 return ops->vidioc_s_register(file, fh, p);
2551         return -EINVAL;
2552 #else
2553         return -ENOTTY;
2554 #endif
2555 }
2556
2557 static int v4l_dbg_g_chip_info(const struct v4l2_ioctl_ops *ops,
2558                                 struct file *file, void *fh, void *arg)
2559 {
2560 #ifdef CONFIG_VIDEO_ADV_DEBUG
2561         struct video_device *vfd = video_devdata(file);
2562         struct v4l2_dbg_chip_info *p = arg;
2563         struct v4l2_subdev *sd;
2564         int idx = 0;
2565
2566         switch (p->match.type) {
2567         case V4L2_CHIP_MATCH_BRIDGE:
2568                 if (ops->vidioc_s_register)
2569                         p->flags |= V4L2_CHIP_FL_WRITABLE;
2570                 if (ops->vidioc_g_register)
2571                         p->flags |= V4L2_CHIP_FL_READABLE;
2572                 strscpy(p->name, vfd->v4l2_dev->name, sizeof(p->name));
2573                 if (ops->vidioc_g_chip_info)
2574                         return ops->vidioc_g_chip_info(file, fh, arg);
2575                 if (p->match.addr)
2576                         return -EINVAL;
2577                 return 0;
2578
2579         case V4L2_CHIP_MATCH_SUBDEV:
2580                 if (vfd->v4l2_dev == NULL)
2581                         break;
2582                 v4l2_device_for_each_subdev(sd, vfd->v4l2_dev) {
2583                         if (p->match.addr != idx++)
2584                                 continue;
2585                         if (sd->ops->core && sd->ops->core->s_register)
2586                                 p->flags |= V4L2_CHIP_FL_WRITABLE;
2587                         if (sd->ops->core && sd->ops->core->g_register)
2588                                 p->flags |= V4L2_CHIP_FL_READABLE;
2589                         strscpy(p->name, sd->name, sizeof(p->name));
2590                         return 0;
2591                 }
2592                 break;
2593         }
2594         return -EINVAL;
2595 #else
2596         return -ENOTTY;
2597 #endif
2598 }
2599
2600 static int v4l_dqevent(const struct v4l2_ioctl_ops *ops,
2601                                 struct file *file, void *fh, void *arg)
2602 {
2603         return v4l2_event_dequeue(fh, arg, file->f_flags & O_NONBLOCK);
2604 }
2605
2606 static int v4l_subscribe_event(const struct v4l2_ioctl_ops *ops,
2607                                 struct file *file, void *fh, void *arg)
2608 {
2609         return ops->vidioc_subscribe_event(fh, arg);
2610 }
2611
2612 static int v4l_unsubscribe_event(const struct v4l2_ioctl_ops *ops,
2613                                 struct file *file, void *fh, void *arg)
2614 {
2615         return ops->vidioc_unsubscribe_event(fh, arg);
2616 }
2617
2618 static int v4l_g_sliced_vbi_cap(const struct v4l2_ioctl_ops *ops,
2619                                 struct file *file, void *fh, void *arg)
2620 {
2621         struct v4l2_sliced_vbi_cap *p = arg;
2622         int ret = check_fmt(file, p->type);
2623
2624         if (ret)
2625                 return ret;
2626
2627         /* Clear up to type, everything after type is zeroed already */
2628         memset(p, 0, offsetof(struct v4l2_sliced_vbi_cap, type));
2629
2630         return ops->vidioc_g_sliced_vbi_cap(file, fh, p);
2631 }
2632
2633 static int v4l_enum_freq_bands(const struct v4l2_ioctl_ops *ops,
2634                                 struct file *file, void *fh, void *arg)
2635 {
2636         struct video_device *vfd = video_devdata(file);
2637         struct v4l2_frequency_band *p = arg;
2638         enum v4l2_tuner_type type;
2639         int err;
2640
2641         if (vfd->vfl_type == VFL_TYPE_SDR) {
2642                 if (p->type != V4L2_TUNER_SDR && p->type != V4L2_TUNER_RF)
2643                         return -EINVAL;
2644                 type = p->type;
2645         } else {
2646                 type = (vfd->vfl_type == VFL_TYPE_RADIO) ?
2647                                 V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
2648                 if (type != p->type)
2649                         return -EINVAL;
2650         }
2651         if (ops->vidioc_enum_freq_bands) {
2652                 err = ops->vidioc_enum_freq_bands(file, fh, p);
2653                 if (err != -ENOTTY)
2654                         return err;
2655         }
2656         if (is_valid_ioctl(vfd, VIDIOC_G_TUNER)) {
2657                 struct v4l2_tuner t = {
2658                         .index = p->tuner,
2659                         .type = type,
2660                 };
2661
2662                 if (p->index)
2663                         return -EINVAL;
2664                 err = ops->vidioc_g_tuner(file, fh, &t);
2665                 if (err)
2666                         return err;
2667                 p->capability = t.capability | V4L2_TUNER_CAP_FREQ_BANDS;
2668                 p->rangelow = t.rangelow;
2669                 p->rangehigh = t.rangehigh;
2670                 p->modulation = (type == V4L2_TUNER_RADIO) ?
2671                         V4L2_BAND_MODULATION_FM : V4L2_BAND_MODULATION_VSB;
2672                 return 0;
2673         }
2674         if (is_valid_ioctl(vfd, VIDIOC_G_MODULATOR)) {
2675                 struct v4l2_modulator m = {
2676                         .index = p->tuner,
2677                 };
2678
2679                 if (type != V4L2_TUNER_RADIO)
2680                         return -EINVAL;
2681                 if (p->index)
2682                         return -EINVAL;
2683                 err = ops->vidioc_g_modulator(file, fh, &m);
2684                 if (err)
2685                         return err;
2686                 p->capability = m.capability | V4L2_TUNER_CAP_FREQ_BANDS;
2687                 p->rangelow = m.rangelow;
2688                 p->rangehigh = m.rangehigh;
2689                 p->modulation = (type == V4L2_TUNER_RADIO) ?
2690                         V4L2_BAND_MODULATION_FM : V4L2_BAND_MODULATION_VSB;
2691                 return 0;
2692         }
2693         return -ENOTTY;
2694 }
2695
2696 struct v4l2_ioctl_info {
2697         unsigned int ioctl;
2698         u32 flags;
2699         const char * const name;
2700         int (*func)(const struct v4l2_ioctl_ops *ops, struct file *file,
2701                     void *fh, void *p);
2702         void (*debug)(const void *arg, bool write_only);
2703 };
2704
2705 /* This control needs a priority check */
2706 #define INFO_FL_PRIO            (1 << 0)
2707 /* This control can be valid if the filehandle passes a control handler. */
2708 #define INFO_FL_CTRL            (1 << 1)
2709 /* Queuing ioctl */
2710 #define INFO_FL_QUEUE           (1 << 2)
2711 /* Always copy back result, even on error */
2712 #define INFO_FL_ALWAYS_COPY     (1 << 3)
2713 /* Zero struct from after the field to the end */
2714 #define INFO_FL_CLEAR(v4l2_struct, field)                       \
2715         ((offsetof(struct v4l2_struct, field) +                 \
2716           sizeof_field(struct v4l2_struct, field)) << 16)
2717 #define INFO_FL_CLEAR_MASK      (_IOC_SIZEMASK << 16)
2718
2719 #define DEFINE_V4L_STUB_FUNC(_vidioc)                           \
2720         static int v4l_stub_ ## _vidioc(                        \
2721                         const struct v4l2_ioctl_ops *ops,       \
2722                         struct file *file, void *fh, void *p)   \
2723         {                                                       \
2724                 return ops->vidioc_ ## _vidioc(file, fh, p);    \
2725         }
2726
2727 #define IOCTL_INFO(_ioctl, _func, _debug, _flags)               \
2728         [_IOC_NR(_ioctl)] = {                                   \
2729                 .ioctl = _ioctl,                                \
2730                 .flags = _flags,                                \
2731                 .name = #_ioctl,                                \
2732                 .func = _func,                                  \
2733                 .debug = _debug,                                \
2734         }
2735
2736 DEFINE_V4L_STUB_FUNC(g_fbuf)
2737 DEFINE_V4L_STUB_FUNC(s_fbuf)
2738 DEFINE_V4L_STUB_FUNC(expbuf)
2739 DEFINE_V4L_STUB_FUNC(g_std)
2740 DEFINE_V4L_STUB_FUNC(g_audio)
2741 DEFINE_V4L_STUB_FUNC(s_audio)
2742 DEFINE_V4L_STUB_FUNC(g_edid)
2743 DEFINE_V4L_STUB_FUNC(s_edid)
2744 DEFINE_V4L_STUB_FUNC(g_audout)
2745 DEFINE_V4L_STUB_FUNC(s_audout)
2746 DEFINE_V4L_STUB_FUNC(g_jpegcomp)
2747 DEFINE_V4L_STUB_FUNC(s_jpegcomp)
2748 DEFINE_V4L_STUB_FUNC(enumaudio)
2749 DEFINE_V4L_STUB_FUNC(enumaudout)
2750 DEFINE_V4L_STUB_FUNC(enum_framesizes)
2751 DEFINE_V4L_STUB_FUNC(enum_frameintervals)
2752 DEFINE_V4L_STUB_FUNC(g_enc_index)
2753 DEFINE_V4L_STUB_FUNC(encoder_cmd)
2754 DEFINE_V4L_STUB_FUNC(try_encoder_cmd)
2755 DEFINE_V4L_STUB_FUNC(decoder_cmd)
2756 DEFINE_V4L_STUB_FUNC(try_decoder_cmd)
2757 DEFINE_V4L_STUB_FUNC(s_dv_timings)
2758 DEFINE_V4L_STUB_FUNC(g_dv_timings)
2759 DEFINE_V4L_STUB_FUNC(enum_dv_timings)
2760 DEFINE_V4L_STUB_FUNC(query_dv_timings)
2761 DEFINE_V4L_STUB_FUNC(dv_timings_cap)
2762
2763 static const struct v4l2_ioctl_info v4l2_ioctls[] = {
2764         IOCTL_INFO(VIDIOC_QUERYCAP, v4l_querycap, v4l_print_querycap, 0),
2765         IOCTL_INFO(VIDIOC_ENUM_FMT, v4l_enum_fmt, v4l_print_fmtdesc, 0),
2766         IOCTL_INFO(VIDIOC_G_FMT, v4l_g_fmt, v4l_print_format, 0),
2767         IOCTL_INFO(VIDIOC_S_FMT, v4l_s_fmt, v4l_print_format, INFO_FL_PRIO),
2768         IOCTL_INFO(VIDIOC_REQBUFS, v4l_reqbufs, v4l_print_requestbuffers, INFO_FL_PRIO | INFO_FL_QUEUE),
2769         IOCTL_INFO(VIDIOC_QUERYBUF, v4l_querybuf, v4l_print_buffer, INFO_FL_QUEUE | INFO_FL_CLEAR(v4l2_buffer, length)),
2770         IOCTL_INFO(VIDIOC_G_FBUF, v4l_stub_g_fbuf, v4l_print_framebuffer, 0),
2771         IOCTL_INFO(VIDIOC_S_FBUF, v4l_stub_s_fbuf, v4l_print_framebuffer, INFO_FL_PRIO),
2772         IOCTL_INFO(VIDIOC_OVERLAY, v4l_overlay, v4l_print_u32, INFO_FL_PRIO),
2773         IOCTL_INFO(VIDIOC_QBUF, v4l_qbuf, v4l_print_buffer, INFO_FL_QUEUE),
2774         IOCTL_INFO(VIDIOC_EXPBUF, v4l_stub_expbuf, v4l_print_exportbuffer, INFO_FL_QUEUE | INFO_FL_CLEAR(v4l2_exportbuffer, flags)),
2775         IOCTL_INFO(VIDIOC_DQBUF, v4l_dqbuf, v4l_print_buffer, INFO_FL_QUEUE),
2776         IOCTL_INFO(VIDIOC_STREAMON, v4l_streamon, v4l_print_buftype, INFO_FL_PRIO | INFO_FL_QUEUE),
2777         IOCTL_INFO(VIDIOC_STREAMOFF, v4l_streamoff, v4l_print_buftype, INFO_FL_PRIO | INFO_FL_QUEUE),
2778         IOCTL_INFO(VIDIOC_G_PARM, v4l_g_parm, v4l_print_streamparm, INFO_FL_CLEAR(v4l2_streamparm, type)),
2779         IOCTL_INFO(VIDIOC_S_PARM, v4l_s_parm, v4l_print_streamparm, INFO_FL_PRIO),
2780         IOCTL_INFO(VIDIOC_G_STD, v4l_stub_g_std, v4l_print_std, 0),
2781         IOCTL_INFO(VIDIOC_S_STD, v4l_s_std, v4l_print_std, INFO_FL_PRIO),
2782         IOCTL_INFO(VIDIOC_ENUMSTD, v4l_enumstd, v4l_print_standard, INFO_FL_CLEAR(v4l2_standard, index)),
2783         IOCTL_INFO(VIDIOC_ENUMINPUT, v4l_enuminput, v4l_print_enuminput, INFO_FL_CLEAR(v4l2_input, index)),
2784         IOCTL_INFO(VIDIOC_G_CTRL, v4l_g_ctrl, v4l_print_control, INFO_FL_CTRL | INFO_FL_CLEAR(v4l2_control, id)),
2785         IOCTL_INFO(VIDIOC_S_CTRL, v4l_s_ctrl, v4l_print_control, INFO_FL_PRIO | INFO_FL_CTRL),
2786         IOCTL_INFO(VIDIOC_G_TUNER, v4l_g_tuner, v4l_print_tuner, INFO_FL_CLEAR(v4l2_tuner, index)),
2787         IOCTL_INFO(VIDIOC_S_TUNER, v4l_s_tuner, v4l_print_tuner, INFO_FL_PRIO),
2788         IOCTL_INFO(VIDIOC_G_AUDIO, v4l_stub_g_audio, v4l_print_audio, 0),
2789         IOCTL_INFO(VIDIOC_S_AUDIO, v4l_stub_s_audio, v4l_print_audio, INFO_FL_PRIO),
2790         IOCTL_INFO(VIDIOC_QUERYCTRL, v4l_queryctrl, v4l_print_queryctrl, INFO_FL_CTRL | INFO_FL_CLEAR(v4l2_queryctrl, id)),
2791         IOCTL_INFO(VIDIOC_QUERYMENU, v4l_querymenu, v4l_print_querymenu, INFO_FL_CTRL | INFO_FL_CLEAR(v4l2_querymenu, index)),
2792         IOCTL_INFO(VIDIOC_G_INPUT, v4l_g_input, v4l_print_u32, 0),
2793         IOCTL_INFO(VIDIOC_S_INPUT, v4l_s_input, v4l_print_u32, INFO_FL_PRIO),
2794         IOCTL_INFO(VIDIOC_G_EDID, v4l_stub_g_edid, v4l_print_edid, INFO_FL_ALWAYS_COPY),
2795         IOCTL_INFO(VIDIOC_S_EDID, v4l_stub_s_edid, v4l_print_edid, INFO_FL_PRIO | INFO_FL_ALWAYS_COPY),
2796         IOCTL_INFO(VIDIOC_G_OUTPUT, v4l_g_output, v4l_print_u32, 0),
2797         IOCTL_INFO(VIDIOC_S_OUTPUT, v4l_s_output, v4l_print_u32, INFO_FL_PRIO),
2798         IOCTL_INFO(VIDIOC_ENUMOUTPUT, v4l_enumoutput, v4l_print_enumoutput, INFO_FL_CLEAR(v4l2_output, index)),
2799         IOCTL_INFO(VIDIOC_G_AUDOUT, v4l_stub_g_audout, v4l_print_audioout, 0),
2800         IOCTL_INFO(VIDIOC_S_AUDOUT, v4l_stub_s_audout, v4l_print_audioout, INFO_FL_PRIO),
2801         IOCTL_INFO(VIDIOC_G_MODULATOR, v4l_g_modulator, v4l_print_modulator, INFO_FL_CLEAR(v4l2_modulator, index)),
2802         IOCTL_INFO(VIDIOC_S_MODULATOR, v4l_s_modulator, v4l_print_modulator, INFO_FL_PRIO),
2803         IOCTL_INFO(VIDIOC_G_FREQUENCY, v4l_g_frequency, v4l_print_frequency, INFO_FL_CLEAR(v4l2_frequency, tuner)),
2804         IOCTL_INFO(VIDIOC_S_FREQUENCY, v4l_s_frequency, v4l_print_frequency, INFO_FL_PRIO),
2805         IOCTL_INFO(VIDIOC_CROPCAP, v4l_cropcap, v4l_print_cropcap, INFO_FL_CLEAR(v4l2_cropcap, type)),
2806         IOCTL_INFO(VIDIOC_G_CROP, v4l_g_crop, v4l_print_crop, INFO_FL_CLEAR(v4l2_crop, type)),
2807         IOCTL_INFO(VIDIOC_S_CROP, v4l_s_crop, v4l_print_crop, INFO_FL_PRIO),
2808         IOCTL_INFO(VIDIOC_G_SELECTION, v4l_g_selection, v4l_print_selection, INFO_FL_CLEAR(v4l2_selection, r)),
2809         IOCTL_INFO(VIDIOC_S_SELECTION, v4l_s_selection, v4l_print_selection, INFO_FL_PRIO | INFO_FL_CLEAR(v4l2_selection, r)),
2810         IOCTL_INFO(VIDIOC_G_JPEGCOMP, v4l_stub_g_jpegcomp, v4l_print_jpegcompression, 0),
2811         IOCTL_INFO(VIDIOC_S_JPEGCOMP, v4l_stub_s_jpegcomp, v4l_print_jpegcompression, INFO_FL_PRIO),
2812         IOCTL_INFO(VIDIOC_QUERYSTD, v4l_querystd, v4l_print_std, 0),
2813         IOCTL_INFO(VIDIOC_TRY_FMT, v4l_try_fmt, v4l_print_format, 0),
2814         IOCTL_INFO(VIDIOC_ENUMAUDIO, v4l_stub_enumaudio, v4l_print_audio, INFO_FL_CLEAR(v4l2_audio, index)),
2815         IOCTL_INFO(VIDIOC_ENUMAUDOUT, v4l_stub_enumaudout, v4l_print_audioout, INFO_FL_CLEAR(v4l2_audioout, index)),
2816         IOCTL_INFO(VIDIOC_G_PRIORITY, v4l_g_priority, v4l_print_u32, 0),
2817         IOCTL_INFO(VIDIOC_S_PRIORITY, v4l_s_priority, v4l_print_u32, INFO_FL_PRIO),
2818         IOCTL_INFO(VIDIOC_G_SLICED_VBI_CAP, v4l_g_sliced_vbi_cap, v4l_print_sliced_vbi_cap, INFO_FL_CLEAR(v4l2_sliced_vbi_cap, type)),
2819         IOCTL_INFO(VIDIOC_LOG_STATUS, v4l_log_status, v4l_print_newline, 0),
2820         IOCTL_INFO(VIDIOC_G_EXT_CTRLS, v4l_g_ext_ctrls, v4l_print_ext_controls, INFO_FL_CTRL),
2821         IOCTL_INFO(VIDIOC_S_EXT_CTRLS, v4l_s_ext_ctrls, v4l_print_ext_controls, INFO_FL_PRIO | INFO_FL_CTRL),
2822         IOCTL_INFO(VIDIOC_TRY_EXT_CTRLS, v4l_try_ext_ctrls, v4l_print_ext_controls, INFO_FL_CTRL),
2823         IOCTL_INFO(VIDIOC_ENUM_FRAMESIZES, v4l_stub_enum_framesizes, v4l_print_frmsizeenum, INFO_FL_CLEAR(v4l2_frmsizeenum, pixel_format)),
2824         IOCTL_INFO(VIDIOC_ENUM_FRAMEINTERVALS, v4l_stub_enum_frameintervals, v4l_print_frmivalenum, INFO_FL_CLEAR(v4l2_frmivalenum, height)),
2825         IOCTL_INFO(VIDIOC_G_ENC_INDEX, v4l_stub_g_enc_index, v4l_print_enc_idx, 0),
2826         IOCTL_INFO(VIDIOC_ENCODER_CMD, v4l_stub_encoder_cmd, v4l_print_encoder_cmd, INFO_FL_PRIO | INFO_FL_CLEAR(v4l2_encoder_cmd, flags)),
2827         IOCTL_INFO(VIDIOC_TRY_ENCODER_CMD, v4l_stub_try_encoder_cmd, v4l_print_encoder_cmd, INFO_FL_CLEAR(v4l2_encoder_cmd, flags)),
2828         IOCTL_INFO(VIDIOC_DECODER_CMD, v4l_stub_decoder_cmd, v4l_print_decoder_cmd, INFO_FL_PRIO),
2829         IOCTL_INFO(VIDIOC_TRY_DECODER_CMD, v4l_stub_try_decoder_cmd, v4l_print_decoder_cmd, 0),
2830         IOCTL_INFO(VIDIOC_DBG_S_REGISTER, v4l_dbg_s_register, v4l_print_dbg_register, 0),
2831         IOCTL_INFO(VIDIOC_DBG_G_REGISTER, v4l_dbg_g_register, v4l_print_dbg_register, 0),
2832         IOCTL_INFO(VIDIOC_S_HW_FREQ_SEEK, v4l_s_hw_freq_seek, v4l_print_hw_freq_seek, INFO_FL_PRIO),
2833         IOCTL_INFO(VIDIOC_S_DV_TIMINGS, v4l_stub_s_dv_timings, v4l_print_dv_timings, INFO_FL_PRIO | INFO_FL_CLEAR(v4l2_dv_timings, bt.flags)),
2834         IOCTL_INFO(VIDIOC_G_DV_TIMINGS, v4l_stub_g_dv_timings, v4l_print_dv_timings, 0),
2835         IOCTL_INFO(VIDIOC_DQEVENT, v4l_dqevent, v4l_print_event, 0),
2836         IOCTL_INFO(VIDIOC_SUBSCRIBE_EVENT, v4l_subscribe_event, v4l_print_event_subscription, 0),
2837         IOCTL_INFO(VIDIOC_UNSUBSCRIBE_EVENT, v4l_unsubscribe_event, v4l_print_event_subscription, 0),
2838         IOCTL_INFO(VIDIOC_CREATE_BUFS, v4l_create_bufs, v4l_print_create_buffers, INFO_FL_PRIO | INFO_FL_QUEUE),
2839         IOCTL_INFO(VIDIOC_PREPARE_BUF, v4l_prepare_buf, v4l_print_buffer, INFO_FL_QUEUE),
2840         IOCTL_INFO(VIDIOC_ENUM_DV_TIMINGS, v4l_stub_enum_dv_timings, v4l_print_enum_dv_timings, INFO_FL_CLEAR(v4l2_enum_dv_timings, pad)),
2841         IOCTL_INFO(VIDIOC_QUERY_DV_TIMINGS, v4l_stub_query_dv_timings, v4l_print_dv_timings, INFO_FL_ALWAYS_COPY),
2842         IOCTL_INFO(VIDIOC_DV_TIMINGS_CAP, v4l_stub_dv_timings_cap, v4l_print_dv_timings_cap, INFO_FL_CLEAR(v4l2_dv_timings_cap, pad)),
2843         IOCTL_INFO(VIDIOC_ENUM_FREQ_BANDS, v4l_enum_freq_bands, v4l_print_freq_band, 0),
2844         IOCTL_INFO(VIDIOC_DBG_G_CHIP_INFO, v4l_dbg_g_chip_info, v4l_print_dbg_chip_info, INFO_FL_CLEAR(v4l2_dbg_chip_info, match)),
2845         IOCTL_INFO(VIDIOC_QUERY_EXT_CTRL, v4l_query_ext_ctrl, v4l_print_query_ext_ctrl, INFO_FL_CTRL | INFO_FL_CLEAR(v4l2_query_ext_ctrl, id)),
2846 };
2847 #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
2848
2849 static bool v4l2_is_known_ioctl(unsigned int cmd)
2850 {
2851         if (_IOC_NR(cmd) >= V4L2_IOCTLS)
2852                 return false;
2853         return v4l2_ioctls[_IOC_NR(cmd)].ioctl == cmd;
2854 }
2855
2856 static struct mutex *v4l2_ioctl_get_lock(struct video_device *vdev,
2857                                          struct v4l2_fh *vfh, unsigned int cmd,
2858                                          void *arg)
2859 {
2860         if (_IOC_NR(cmd) >= V4L2_IOCTLS)
2861                 return vdev->lock;
2862         if (vfh && vfh->m2m_ctx &&
2863             (v4l2_ioctls[_IOC_NR(cmd)].flags & INFO_FL_QUEUE)) {
2864                 if (vfh->m2m_ctx->q_lock)
2865                         return vfh->m2m_ctx->q_lock;
2866         }
2867         if (vdev->queue && vdev->queue->lock &&
2868                         (v4l2_ioctls[_IOC_NR(cmd)].flags & INFO_FL_QUEUE))
2869                 return vdev->queue->lock;
2870         return vdev->lock;
2871 }
2872
2873 /* Common ioctl debug function. This function can be used by
2874    external ioctl messages as well as internal V4L ioctl */
2875 void v4l_printk_ioctl(const char *prefix, unsigned int cmd)
2876 {
2877         const char *dir, *type;
2878
2879         if (prefix)
2880                 printk(KERN_DEBUG "%s: ", prefix);
2881
2882         switch (_IOC_TYPE(cmd)) {
2883         case 'd':
2884                 type = "v4l2_int";
2885                 break;
2886         case 'V':
2887                 if (_IOC_NR(cmd) >= V4L2_IOCTLS) {
2888                         type = "v4l2";
2889                         break;
2890                 }
2891                 pr_cont("%s", v4l2_ioctls[_IOC_NR(cmd)].name);
2892                 return;
2893         default:
2894                 type = "unknown";
2895                 break;
2896         }
2897
2898         switch (_IOC_DIR(cmd)) {
2899         case _IOC_NONE:              dir = "--"; break;
2900         case _IOC_READ:              dir = "r-"; break;
2901         case _IOC_WRITE:             dir = "-w"; break;
2902         case _IOC_READ | _IOC_WRITE: dir = "rw"; break;
2903         default:                     dir = "*ERR*"; break;
2904         }
2905         pr_cont("%s ioctl '%c', dir=%s, #%d (0x%08x)",
2906                 type, _IOC_TYPE(cmd), dir, _IOC_NR(cmd), cmd);
2907 }
2908 EXPORT_SYMBOL(v4l_printk_ioctl);
2909
2910 static long __video_do_ioctl(struct file *file,
2911                 unsigned int cmd, void *arg)
2912 {
2913         struct video_device *vfd = video_devdata(file);
2914         struct mutex *req_queue_lock = NULL;
2915         struct mutex *lock; /* ioctl serialization mutex */
2916         const struct v4l2_ioctl_ops *ops = vfd->ioctl_ops;
2917         bool write_only = false;
2918         struct v4l2_ioctl_info default_info;
2919         const struct v4l2_ioctl_info *info;
2920         void *fh = file->private_data;
2921         struct v4l2_fh *vfh = NULL;
2922         int dev_debug = vfd->dev_debug;
2923         long ret = -ENOTTY;
2924
2925         if (ops == NULL) {
2926                 pr_warn("%s: has no ioctl_ops.\n",
2927                                 video_device_node_name(vfd));
2928                 return ret;
2929         }
2930
2931         if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags))
2932                 vfh = file->private_data;
2933
2934         /*
2935          * We need to serialize streamon/off with queueing new requests.
2936          * These ioctls may trigger the cancellation of a streaming
2937          * operation, and that should not be mixed with queueing a new
2938          * request at the same time.
2939          */
2940         if (v4l2_device_supports_requests(vfd->v4l2_dev) &&
2941             (cmd == VIDIOC_STREAMON || cmd == VIDIOC_STREAMOFF)) {
2942                 req_queue_lock = &vfd->v4l2_dev->mdev->req_queue_mutex;
2943
2944                 if (mutex_lock_interruptible(req_queue_lock))
2945                         return -ERESTARTSYS;
2946         }
2947
2948         lock = v4l2_ioctl_get_lock(vfd, vfh, cmd, arg);
2949
2950         if (lock && mutex_lock_interruptible(lock)) {
2951                 if (req_queue_lock)
2952                         mutex_unlock(req_queue_lock);
2953                 return -ERESTARTSYS;
2954         }
2955
2956         if (!video_is_registered(vfd)) {
2957                 ret = -ENODEV;
2958                 goto unlock;
2959         }
2960
2961         if (v4l2_is_known_ioctl(cmd)) {
2962                 info = &v4l2_ioctls[_IOC_NR(cmd)];
2963
2964                 if (!test_bit(_IOC_NR(cmd), vfd->valid_ioctls) &&
2965                     !((info->flags & INFO_FL_CTRL) && vfh && vfh->ctrl_handler))
2966                         goto done;
2967
2968                 if (vfh && (info->flags & INFO_FL_PRIO)) {
2969                         ret = v4l2_prio_check(vfd->prio, vfh->prio);
2970                         if (ret)
2971                                 goto done;
2972                 }
2973         } else {
2974                 default_info.ioctl = cmd;
2975                 default_info.flags = 0;
2976                 default_info.debug = v4l_print_default;
2977                 info = &default_info;
2978         }
2979
2980         write_only = _IOC_DIR(cmd) == _IOC_WRITE;
2981         if (info != &default_info) {
2982                 ret = info->func(ops, file, fh, arg);
2983         } else if (!ops->vidioc_default) {
2984                 ret = -ENOTTY;
2985         } else {
2986                 ret = ops->vidioc_default(file, fh,
2987                         vfh ? v4l2_prio_check(vfd->prio, vfh->prio) >= 0 : 0,
2988                         cmd, arg);
2989         }
2990
2991 done:
2992         if (dev_debug & (V4L2_DEV_DEBUG_IOCTL | V4L2_DEV_DEBUG_IOCTL_ARG)) {
2993                 if (!(dev_debug & V4L2_DEV_DEBUG_STREAMING) &&
2994                     (cmd == VIDIOC_QBUF || cmd == VIDIOC_DQBUF))
2995                         goto unlock;
2996
2997                 v4l_printk_ioctl(video_device_node_name(vfd), cmd);
2998                 if (ret < 0)
2999                         pr_cont(": error %ld", ret);
3000                 if (!(dev_debug & V4L2_DEV_DEBUG_IOCTL_ARG))
3001                         pr_cont("\n");
3002                 else if (_IOC_DIR(cmd) == _IOC_NONE)
3003                         info->debug(arg, write_only);
3004                 else {
3005                         pr_cont(": ");
3006                         info->debug(arg, write_only);
3007                 }
3008         }
3009
3010 unlock:
3011         if (lock)
3012                 mutex_unlock(lock);
3013         if (req_queue_lock)
3014                 mutex_unlock(req_queue_lock);
3015         return ret;
3016 }
3017
3018 static int check_array_args(unsigned int cmd, void *parg, size_t *array_size,
3019                             void __user **user_ptr, void ***kernel_ptr)
3020 {
3021         int ret = 0;
3022
3023         switch (cmd) {
3024         case VIDIOC_PREPARE_BUF:
3025         case VIDIOC_QUERYBUF:
3026         case VIDIOC_QBUF:
3027         case VIDIOC_DQBUF: {
3028                 struct v4l2_buffer *buf = parg;
3029
3030                 if (V4L2_TYPE_IS_MULTIPLANAR(buf->type) && buf->length > 0) {
3031                         if (buf->length > VIDEO_MAX_PLANES) {
3032                                 ret = -EINVAL;
3033                                 break;
3034                         }
3035                         *user_ptr = (void __user *)buf->m.planes;
3036                         *kernel_ptr = (void **)&buf->m.planes;
3037                         *array_size = sizeof(struct v4l2_plane) * buf->length;
3038                         ret = 1;
3039                 }
3040                 break;
3041         }
3042
3043         case VIDIOC_G_EDID:
3044         case VIDIOC_S_EDID: {
3045                 struct v4l2_edid *edid = parg;
3046
3047                 if (edid->blocks) {
3048                         if (edid->blocks > 256) {
3049                                 ret = -EINVAL;
3050                                 break;
3051                         }
3052                         *user_ptr = (void __user *)edid->edid;
3053                         *kernel_ptr = (void **)&edid->edid;
3054                         *array_size = edid->blocks * 128;
3055                         ret = 1;
3056                 }
3057                 break;
3058         }
3059
3060         case VIDIOC_S_EXT_CTRLS:
3061         case VIDIOC_G_EXT_CTRLS:
3062         case VIDIOC_TRY_EXT_CTRLS: {
3063                 struct v4l2_ext_controls *ctrls = parg;
3064
3065                 if (ctrls->count != 0) {
3066                         if (ctrls->count > V4L2_CID_MAX_CTRLS) {
3067                                 ret = -EINVAL;
3068                                 break;
3069                         }
3070                         *user_ptr = (void __user *)ctrls->controls;
3071                         *kernel_ptr = (void **)&ctrls->controls;
3072                         *array_size = sizeof(struct v4l2_ext_control)
3073                                     * ctrls->count;
3074                         ret = 1;
3075                 }
3076                 break;
3077         }
3078         case VIDIOC_G_FMT:
3079         case VIDIOC_S_FMT:
3080         case VIDIOC_TRY_FMT: {
3081                 struct v4l2_format *fmt = parg;
3082
3083                 if (fmt->type != V4L2_BUF_TYPE_VIDEO_OVERLAY &&
3084                     fmt->type != V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY)
3085                         break;
3086                 if (fmt->fmt.win.clipcount > 2048)
3087                         return -EINVAL;
3088                 if (!fmt->fmt.win.clipcount)
3089                         break;
3090
3091                 *user_ptr = (void __user *)fmt->fmt.win.clips;
3092                 *kernel_ptr = (void **)&fmt->fmt.win.clips;
3093                 *array_size = sizeof(struct v4l2_clip)
3094                                 * fmt->fmt.win.clipcount;
3095
3096                 ret = 1;
3097                 break;
3098         }
3099         }
3100
3101         return ret;
3102 }
3103
3104 static unsigned int video_translate_cmd(unsigned int cmd)
3105 {
3106 #if !defined(CONFIG_64BIT) && defined(CONFIG_COMPAT_32BIT_TIME)
3107         switch (cmd) {
3108         case VIDIOC_DQEVENT_TIME32:
3109                 return VIDIOC_DQEVENT;
3110         case VIDIOC_QUERYBUF_TIME32:
3111                 return VIDIOC_QUERYBUF;
3112         case VIDIOC_QBUF_TIME32:
3113                 return VIDIOC_QBUF;
3114         case VIDIOC_DQBUF_TIME32:
3115                 return VIDIOC_DQBUF;
3116         case VIDIOC_PREPARE_BUF_TIME32:
3117                 return VIDIOC_PREPARE_BUF;
3118         }
3119 #endif
3120         if (in_compat_syscall())
3121                 return v4l2_compat_translate_cmd(cmd);
3122
3123         return cmd;
3124 }
3125
3126 static int video_get_user(void __user *arg, void *parg,
3127                           unsigned int real_cmd, unsigned int cmd,
3128                           bool *always_copy)
3129 {
3130         unsigned int n = _IOC_SIZE(real_cmd);
3131         int err = 0;
3132
3133         if (!(_IOC_DIR(cmd) & _IOC_WRITE)) {
3134                 /* read-only ioctl */
3135                 memset(parg, 0, n);
3136                 return 0;
3137         }
3138
3139         /*
3140          * In some cases, only a few fields are used as input,
3141          * i.e. when the app sets "index" and then the driver
3142          * fills in the rest of the structure for the thing
3143          * with that index.  We only need to copy up the first
3144          * non-input field.
3145          */
3146         if (v4l2_is_known_ioctl(real_cmd)) {
3147                 u32 flags = v4l2_ioctls[_IOC_NR(real_cmd)].flags;
3148
3149                 if (flags & INFO_FL_CLEAR_MASK)
3150                         n = (flags & INFO_FL_CLEAR_MASK) >> 16;
3151                 *always_copy = flags & INFO_FL_ALWAYS_COPY;
3152         }
3153
3154         if (cmd == real_cmd) {
3155                 if (copy_from_user(parg, (void __user *)arg, n))
3156                         err = -EFAULT;
3157         } else if (in_compat_syscall()) {
3158                 memset(parg, 0, n);
3159                 err = v4l2_compat_get_user(arg, parg, cmd);
3160         } else {
3161                 memset(parg, 0, n);
3162 #if !defined(CONFIG_64BIT) && defined(CONFIG_COMPAT_32BIT_TIME)
3163                 switch (cmd) {
3164                 case VIDIOC_QUERYBUF_TIME32:
3165                 case VIDIOC_QBUF_TIME32:
3166                 case VIDIOC_DQBUF_TIME32:
3167                 case VIDIOC_PREPARE_BUF_TIME32: {
3168                         struct v4l2_buffer_time32 vb32;
3169                         struct v4l2_buffer *vb = parg;
3170
3171                         if (copy_from_user(&vb32, arg, sizeof(vb32)))
3172                                 return -EFAULT;
3173
3174                         *vb = (struct v4l2_buffer) {
3175                                 .index          = vb32.index,
3176                                 .type           = vb32.type,
3177                                 .bytesused      = vb32.bytesused,
3178                                 .flags          = vb32.flags,
3179                                 .field          = vb32.field,
3180                                 .timestamp.tv_sec       = vb32.timestamp.tv_sec,
3181                                 .timestamp.tv_usec      = vb32.timestamp.tv_usec,
3182                                 .timecode       = vb32.timecode,
3183                                 .sequence       = vb32.sequence,
3184                                 .memory         = vb32.memory,
3185                                 .m.userptr      = vb32.m.userptr,
3186                                 .length         = vb32.length,
3187                                 .request_fd     = vb32.request_fd,
3188                         };
3189                         break;
3190                 }
3191                 }
3192 #endif
3193         }
3194
3195         /* zero out anything we don't copy from userspace */
3196         if (!err && n < _IOC_SIZE(real_cmd))
3197                 memset((u8 *)parg + n, 0, _IOC_SIZE(real_cmd) - n);
3198         return err;
3199 }
3200
3201 static int video_put_user(void __user *arg, void *parg,
3202                           unsigned int real_cmd, unsigned int cmd)
3203 {
3204         if (!(_IOC_DIR(cmd) & _IOC_READ))
3205                 return 0;
3206
3207         if (cmd == real_cmd) {
3208                 /*  Copy results into user buffer  */
3209                 if (copy_to_user(arg, parg, _IOC_SIZE(cmd)))
3210                         return -EFAULT;
3211                 return 0;
3212         }
3213
3214         if (in_compat_syscall())
3215                 return v4l2_compat_put_user(arg, parg, cmd);
3216
3217 #if !defined(CONFIG_64BIT) && defined(CONFIG_COMPAT_32BIT_TIME)
3218         switch (cmd) {
3219         case VIDIOC_DQEVENT_TIME32: {
3220                 struct v4l2_event *ev = parg;
3221                 struct v4l2_event_time32 ev32;
3222
3223                 memset(&ev32, 0, sizeof(ev32));
3224
3225                 ev32.type       = ev->type;
3226                 ev32.pending    = ev->pending;
3227                 ev32.sequence   = ev->sequence;
3228                 ev32.timestamp.tv_sec   = ev->timestamp.tv_sec;
3229                 ev32.timestamp.tv_nsec  = ev->timestamp.tv_nsec;
3230                 ev32.id         = ev->id;
3231
3232                 memcpy(&ev32.u, &ev->u, sizeof(ev->u));
3233                 memcpy(&ev32.reserved, &ev->reserved, sizeof(ev->reserved));
3234
3235                 if (copy_to_user(arg, &ev32, sizeof(ev32)))
3236                         return -EFAULT;
3237                 break;
3238         }
3239         case VIDIOC_QUERYBUF_TIME32:
3240         case VIDIOC_QBUF_TIME32:
3241         case VIDIOC_DQBUF_TIME32:
3242         case VIDIOC_PREPARE_BUF_TIME32: {
3243                 struct v4l2_buffer *vb = parg;
3244                 struct v4l2_buffer_time32 vb32;
3245
3246                 memset(&vb32, 0, sizeof(vb32));
3247
3248                 vb32.index      = vb->index;
3249                 vb32.type       = vb->type;
3250                 vb32.bytesused  = vb->bytesused;
3251                 vb32.flags      = vb->flags;
3252                 vb32.field      = vb->field;
3253                 vb32.timestamp.tv_sec   = vb->timestamp.tv_sec;
3254                 vb32.timestamp.tv_usec  = vb->timestamp.tv_usec;
3255                 vb32.timecode   = vb->timecode;
3256                 vb32.sequence   = vb->sequence;
3257                 vb32.memory     = vb->memory;
3258                 vb32.m.userptr  = vb->m.userptr;
3259                 vb32.length     = vb->length;
3260                 vb32.request_fd = vb->request_fd;
3261
3262                 if (copy_to_user(arg, &vb32, sizeof(vb32)))
3263                         return -EFAULT;
3264                 break;
3265         }
3266         }
3267 #endif
3268
3269         return 0;
3270 }
3271
3272 long
3273 video_usercopy(struct file *file, unsigned int orig_cmd, unsigned long arg,
3274                v4l2_kioctl func)
3275 {
3276         char    sbuf[128];
3277         void    *mbuf = NULL, *array_buf = NULL;
3278         void    *parg = (void *)arg;
3279         long    err  = -EINVAL;
3280         bool    has_array_args;
3281         bool    always_copy = false;
3282         size_t  array_size = 0;
3283         void __user *user_ptr = NULL;
3284         void    **kernel_ptr = NULL;
3285         unsigned int cmd = video_translate_cmd(orig_cmd);
3286         const size_t ioc_size = _IOC_SIZE(cmd);
3287
3288         /*  Copy arguments into temp kernel buffer  */
3289         if (_IOC_DIR(cmd) != _IOC_NONE) {
3290                 if (ioc_size <= sizeof(sbuf)) {
3291                         parg = sbuf;
3292                 } else {
3293                         /* too big to allocate from stack */
3294                         mbuf = kmalloc(ioc_size, GFP_KERNEL);
3295                         if (NULL == mbuf)
3296                                 return -ENOMEM;
3297                         parg = mbuf;
3298                 }
3299
3300                 err = video_get_user((void __user *)arg, parg, cmd,
3301                                      orig_cmd, &always_copy);
3302                 if (err)
3303                         goto out;
3304         }
3305
3306         err = check_array_args(cmd, parg, &array_size, &user_ptr, &kernel_ptr);
3307         if (err < 0)
3308                 goto out;
3309         has_array_args = err;
3310
3311         if (has_array_args) {
3312                 array_buf = kvmalloc(array_size, GFP_KERNEL);
3313                 err = -ENOMEM;
3314                 if (array_buf == NULL)
3315                         goto out_array_args;
3316                 err = -EFAULT;
3317                 if (in_compat_syscall())
3318                         err = v4l2_compat_get_array_args(file, array_buf,
3319                                                          user_ptr, array_size,
3320                                                          orig_cmd, parg);
3321                 else
3322                         err = copy_from_user(array_buf, user_ptr, array_size) ?
3323                                                                 -EFAULT : 0;
3324                 if (err)
3325                         goto out_array_args;
3326                 *kernel_ptr = array_buf;
3327         }
3328
3329         /* Handles IOCTL */
3330         err = func(file, cmd, parg);
3331         if (err == -ENOTTY || err == -ENOIOCTLCMD) {
3332                 err = -ENOTTY;
3333                 goto out;
3334         }
3335
3336         if (err == 0) {
3337                 if (cmd == VIDIOC_DQBUF)
3338                         trace_v4l2_dqbuf(video_devdata(file)->minor, parg);
3339                 else if (cmd == VIDIOC_QBUF)
3340                         trace_v4l2_qbuf(video_devdata(file)->minor, parg);
3341         }
3342
3343         if (has_array_args) {
3344                 *kernel_ptr = (void __force *)user_ptr;
3345                 if (in_compat_syscall()) {
3346                         int put_err;
3347
3348                         put_err = v4l2_compat_put_array_args(file, user_ptr,
3349                                                              array_buf,
3350                                                              array_size,
3351                                                              orig_cmd, parg);
3352                         if (put_err)
3353                                 err = put_err;
3354                 } else if (copy_to_user(user_ptr, array_buf, array_size)) {
3355                         err = -EFAULT;
3356                 }
3357                 goto out_array_args;
3358         }
3359         /*
3360          * Some ioctls can return an error, but still have valid
3361          * results that must be returned.
3362          */
3363         if (err < 0 && !always_copy)
3364                 goto out;
3365
3366 out_array_args:
3367         if (video_put_user((void __user *)arg, parg, cmd, orig_cmd))
3368                 err = -EFAULT;
3369 out:
3370         kvfree(array_buf);
3371         kfree(mbuf);
3372         return err;
3373 }
3374
3375 long video_ioctl2(struct file *file,
3376                unsigned int cmd, unsigned long arg)
3377 {
3378         return video_usercopy(file, cmd, arg, __video_do_ioctl);
3379 }
3380 EXPORT_SYMBOL(video_ioctl2);