Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
v4l2-ioctl.c
Go to the documentation of this file.
1 /*
2  * Video capture interface for Linux version 2
3  *
4  * A generic framework to process V4L2 ioctl commands.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version
9  * 2 of the License, or (at your option) any later version.
10  *
11  * Authors: Alan Cox, <[email protected]> (version 1)
12  * Mauro Carvalho Chehab <[email protected]> (version 2)
13  */
14 
15 #include <linux/module.h>
16 #include <linux/slab.h>
17 #include <linux/types.h>
18 #include <linux/kernel.h>
19 #include <linux/version.h>
20 
21 #include <linux/videodev2.h>
22 
23 #include <media/v4l2-common.h>
24 #include <media/v4l2-ioctl.h>
25 #include <media/v4l2-ctrls.h>
26 #include <media/v4l2-fh.h>
27 #include <media/v4l2-event.h>
28 #include <media/v4l2-device.h>
29 #include <media/v4l2-chip-ident.h>
30 #include <media/videobuf2-core.h>
31 
32 /* Zero out the end of the struct pointed to by p. Everything after, but
33  * not including, the specified field is cleared. */
34 #define CLEAR_AFTER_FIELD(p, field) \
35  memset((u8 *)(p) + offsetof(typeof(*(p)), field) + sizeof((p)->field), \
36  0, sizeof(*(p)) - offsetof(typeof(*(p)), field) - sizeof((p)->field))
37 
38 struct std_descr {
39  v4l2_std_id std;
40  const char *descr;
41 };
42 
43 static const struct std_descr standards[] = {
44  { V4L2_STD_NTSC, "NTSC" },
45  { V4L2_STD_NTSC_M, "NTSC-M" },
46  { V4L2_STD_NTSC_M_JP, "NTSC-M-JP" },
47  { V4L2_STD_NTSC_M_KR, "NTSC-M-KR" },
48  { V4L2_STD_NTSC_443, "NTSC-443" },
49  { V4L2_STD_PAL, "PAL" },
50  { V4L2_STD_PAL_BG, "PAL-BG" },
51  { V4L2_STD_PAL_B, "PAL-B" },
52  { V4L2_STD_PAL_B1, "PAL-B1" },
53  { V4L2_STD_PAL_G, "PAL-G" },
54  { V4L2_STD_PAL_H, "PAL-H" },
55  { V4L2_STD_PAL_I, "PAL-I" },
56  { V4L2_STD_PAL_DK, "PAL-DK" },
57  { V4L2_STD_PAL_D, "PAL-D" },
58  { V4L2_STD_PAL_D1, "PAL-D1" },
59  { V4L2_STD_PAL_K, "PAL-K" },
60  { V4L2_STD_PAL_M, "PAL-M" },
61  { V4L2_STD_PAL_N, "PAL-N" },
62  { V4L2_STD_PAL_Nc, "PAL-Nc" },
63  { V4L2_STD_PAL_60, "PAL-60" },
64  { V4L2_STD_SECAM, "SECAM" },
65  { V4L2_STD_SECAM_B, "SECAM-B" },
66  { V4L2_STD_SECAM_G, "SECAM-G" },
67  { V4L2_STD_SECAM_H, "SECAM-H" },
68  { V4L2_STD_SECAM_DK, "SECAM-DK" },
69  { V4L2_STD_SECAM_D, "SECAM-D" },
70  { V4L2_STD_SECAM_K, "SECAM-K" },
71  { V4L2_STD_SECAM_K1, "SECAM-K1" },
72  { V4L2_STD_SECAM_L, "SECAM-L" },
73  { V4L2_STD_SECAM_LC, "SECAM-Lc" },
74  { 0, "Unknown" }
75 };
76 
77 /* video4linux standard ID conversion to standard name
78  */
79 const char *v4l2_norm_to_name(v4l2_std_id id)
80 {
81  u32 myid = id;
82  int i;
83 
84  /* HACK: ppc32 architecture doesn't have __ucmpdi2 function to handle
85  64 bit comparations. So, on that architecture, with some gcc
86  variants, compilation fails. Currently, the max value is 30bit wide.
87  */
88  BUG_ON(myid != id);
89 
90  for (i = 0; standards[i].std; i++)
91  if (myid == standards[i].std)
92  break;
93  return standards[i].descr;
94 }
95 EXPORT_SYMBOL(v4l2_norm_to_name);
96 
97 /* Returns frame period for the given standard */
98 void v4l2_video_std_frame_period(int id, struct v4l2_fract *frameperiod)
99 {
100  if (id & V4L2_STD_525_60) {
101  frameperiod->numerator = 1001;
102  frameperiod->denominator = 30000;
103  } else {
104  frameperiod->numerator = 1;
105  frameperiod->denominator = 25;
106  }
107 }
108 EXPORT_SYMBOL(v4l2_video_std_frame_period);
109 
110 /* Fill in the fields of a v4l2_standard structure according to the
111  'id' and 'transmission' parameters. Returns negative on error. */
112 int v4l2_video_std_construct(struct v4l2_standard *vs,
113  int id, const char *name)
114 {
115  vs->id = id;
116  v4l2_video_std_frame_period(id, &vs->frameperiod);
117  vs->framelines = (id & V4L2_STD_525_60) ? 525 : 625;
118  strlcpy(vs->name, name, sizeof(vs->name));
119  return 0;
120 }
121 EXPORT_SYMBOL(v4l2_video_std_construct);
122 
123 /* ----------------------------------------------------------------- */
124 /* some arrays for pretty-printing debug messages of enum types */
125 
126 const char *v4l2_field_names[] = {
127  [V4L2_FIELD_ANY] = "any",
128  [V4L2_FIELD_NONE] = "none",
129  [V4L2_FIELD_TOP] = "top",
130  [V4L2_FIELD_BOTTOM] = "bottom",
131  [V4L2_FIELD_INTERLACED] = "interlaced",
132  [V4L2_FIELD_SEQ_TB] = "seq-tb",
133  [V4L2_FIELD_SEQ_BT] = "seq-bt",
134  [V4L2_FIELD_ALTERNATE] = "alternate",
135  [V4L2_FIELD_INTERLACED_TB] = "interlaced-tb",
136  [V4L2_FIELD_INTERLACED_BT] = "interlaced-bt",
137 };
138 EXPORT_SYMBOL(v4l2_field_names);
139 
140 const char *v4l2_type_names[] = {
141  [V4L2_BUF_TYPE_VIDEO_CAPTURE] = "vid-cap",
142  [V4L2_BUF_TYPE_VIDEO_OVERLAY] = "vid-overlay",
143  [V4L2_BUF_TYPE_VIDEO_OUTPUT] = "vid-out",
144  [V4L2_BUF_TYPE_VBI_CAPTURE] = "vbi-cap",
145  [V4L2_BUF_TYPE_VBI_OUTPUT] = "vbi-out",
146  [V4L2_BUF_TYPE_SLICED_VBI_CAPTURE] = "sliced-vbi-cap",
147  [V4L2_BUF_TYPE_SLICED_VBI_OUTPUT] = "sliced-vbi-out",
148  [V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY] = "vid-out-overlay",
149  [V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE] = "vid-cap-mplane",
150  [V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE] = "vid-out-mplane",
151 };
152 EXPORT_SYMBOL(v4l2_type_names);
153 
154 static const char *v4l2_memory_names[] = {
155  [V4L2_MEMORY_MMAP] = "mmap",
156  [V4L2_MEMORY_USERPTR] = "userptr",
157  [V4L2_MEMORY_OVERLAY] = "overlay",
158 };
159 
160 #define prt_names(a, arr) (((unsigned)(a)) < ARRAY_SIZE(arr) ? arr[a] : "unknown")
161 
162 /* ------------------------------------------------------------------ */
163 /* debug help functions */
164 
165 static void v4l_print_querycap(const void *arg, bool write_only)
166 {
167  const struct v4l2_capability *p = arg;
168 
169  pr_cont("driver=%s, card=%s, bus=%s, version=0x%08x, "
170  "capabilities=0x%08x, device_caps=0x%08x\n",
171  p->driver, p->card, p->bus_info,
172  p->version, p->capabilities, p->device_caps);
173 }
174 
175 static void v4l_print_enuminput(const void *arg, bool write_only)
176 {
177  const struct v4l2_input *p = arg;
178 
179  pr_cont("index=%u, name=%s, type=%u, audioset=0x%x, tuner=%u, "
180  "std=0x%08Lx, status=0x%x, capabilities=0x%x\n",
181  p->index, p->name, p->type, p->audioset, p->tuner,
182  (unsigned long long)p->std, p->status, p->capabilities);
183 }
184 
185 static void v4l_print_enumoutput(const void *arg, bool write_only)
186 {
187  const struct v4l2_output *p = arg;
188 
189  pr_cont("index=%u, name=%s, type=%u, audioset=0x%x, "
190  "modulator=%u, std=0x%08Lx, capabilities=0x%x\n",
191  p->index, p->name, p->type, p->audioset, p->modulator,
192  (unsigned long long)p->std, p->capabilities);
193 }
194 
195 static void v4l_print_audio(const void *arg, bool write_only)
196 {
197  const struct v4l2_audio *p = arg;
198 
199  if (write_only)
200  pr_cont("index=%u, mode=0x%x\n", p->index, p->mode);
201  else
202  pr_cont("index=%u, name=%s, capability=0x%x, mode=0x%x\n",
203  p->index, p->name, p->capability, p->mode);
204 }
205 
206 static void v4l_print_audioout(const void *arg, bool write_only)
207 {
208  const struct v4l2_audioout *p = arg;
209 
210  if (write_only)
211  pr_cont("index=%u\n", p->index);
212  else
213  pr_cont("index=%u, name=%s, capability=0x%x, mode=0x%x\n",
214  p->index, p->name, p->capability, p->mode);
215 }
216 
217 static void v4l_print_fmtdesc(const void *arg, bool write_only)
218 {
219  const struct v4l2_fmtdesc *p = arg;
220 
221  pr_cont("index=%u, type=%s, flags=0x%x, pixelformat=%c%c%c%c, description='%s'\n",
222  p->index, prt_names(p->type, v4l2_type_names),
223  p->flags, (p->pixelformat & 0xff),
224  (p->pixelformat >> 8) & 0xff,
225  (p->pixelformat >> 16) & 0xff,
226  (p->pixelformat >> 24) & 0xff,
227  p->description);
228 }
229 
230 static void v4l_print_format(const void *arg, bool write_only)
231 {
232  const struct v4l2_format *p = arg;
233  const struct v4l2_pix_format *pix;
234  const struct v4l2_pix_format_mplane *mp;
235  const struct v4l2_vbi_format *vbi;
236  const struct v4l2_sliced_vbi_format *sliced;
237  const struct v4l2_window *win;
238  const struct v4l2_clip *clip;
239  unsigned i;
240 
241  pr_cont("type=%s", prt_names(p->type, v4l2_type_names));
242  switch (p->type) {
243  case V4L2_BUF_TYPE_VIDEO_CAPTURE:
244  case V4L2_BUF_TYPE_VIDEO_OUTPUT:
245  pix = &p->fmt.pix;
246  pr_cont(", width=%u, height=%u, "
247  "pixelformat=%c%c%c%c, field=%s, "
248  "bytesperline=%u sizeimage=%u, colorspace=%d\n",
249  pix->width, pix->height,
250  (pix->pixelformat & 0xff),
251  (pix->pixelformat >> 8) & 0xff,
252  (pix->pixelformat >> 16) & 0xff,
253  (pix->pixelformat >> 24) & 0xff,
254  prt_names(pix->field, v4l2_field_names),
255  pix->bytesperline, pix->sizeimage,
256  pix->colorspace);
257  break;
258  case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
259  case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
260  mp = &p->fmt.pix_mp;
261  pr_cont(", width=%u, height=%u, "
262  "format=%c%c%c%c, field=%s, "
263  "colorspace=%d, num_planes=%u\n",
264  mp->width, mp->height,
265  (mp->pixelformat & 0xff),
266  (mp->pixelformat >> 8) & 0xff,
267  (mp->pixelformat >> 16) & 0xff,
268  (mp->pixelformat >> 24) & 0xff,
269  prt_names(mp->field, v4l2_field_names),
270  mp->colorspace, mp->num_planes);
271  for (i = 0; i < mp->num_planes; i++)
272  printk(KERN_DEBUG "plane %u: bytesperline=%u sizeimage=%u\n", i,
273  mp->plane_fmt[i].bytesperline,
274  mp->plane_fmt[i].sizeimage);
275  break;
276  case V4L2_BUF_TYPE_VIDEO_OVERLAY:
277  case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
278  win = &p->fmt.win;
279  pr_cont(", wxh=%dx%d, x,y=%d,%d, field=%s, "
280  "chromakey=0x%08x, bitmap=%p, "
281  "global_alpha=0x%02x\n",
282  win->w.width, win->w.height,
283  win->w.left, win->w.top,
284  prt_names(win->field, v4l2_field_names),
285  win->chromakey, win->bitmap, win->global_alpha);
286  clip = win->clips;
287  for (i = 0; i < win->clipcount; i++) {
288  printk(KERN_DEBUG "clip %u: wxh=%dx%d, x,y=%d,%d\n",
289  i, clip->c.width, clip->c.height,
290  clip->c.left, clip->c.top);
291  clip = clip->next;
292  }
293  break;
294  case V4L2_BUF_TYPE_VBI_CAPTURE:
295  case V4L2_BUF_TYPE_VBI_OUTPUT:
296  vbi = &p->fmt.vbi;
297  pr_cont(", sampling_rate=%u, offset=%u, samples_per_line=%u, "
298  "sample_format=%c%c%c%c, start=%u,%u, count=%u,%u\n",
299  vbi->sampling_rate, vbi->offset,
300  vbi->samples_per_line,
301  (vbi->sample_format & 0xff),
302  (vbi->sample_format >> 8) & 0xff,
303  (vbi->sample_format >> 16) & 0xff,
304  (vbi->sample_format >> 24) & 0xff,
305  vbi->start[0], vbi->start[1],
306  vbi->count[0], vbi->count[1]);
307  break;
308  case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
309  case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
310  sliced = &p->fmt.sliced;
311  pr_cont(", service_set=0x%08x, io_size=%d\n",
312  sliced->service_set, sliced->io_size);
313  for (i = 0; i < 24; i++)
314  printk(KERN_DEBUG "line[%02u]=0x%04x, 0x%04x\n", i,
315  sliced->service_lines[0][i],
316  sliced->service_lines[1][i]);
317  break;
318  }
319 }
320 
321 static void v4l_print_framebuffer(const void *arg, bool write_only)
322 {
323  const struct v4l2_framebuffer *p = arg;
324 
325  pr_cont("capability=0x%x, flags=0x%x, base=0x%p, width=%u, "
326  "height=%u, pixelformat=%c%c%c%c, "
327  "bytesperline=%u sizeimage=%u, colorspace=%d\n",
328  p->capability, p->flags, p->base,
329  p->fmt.width, p->fmt.height,
330  (p->fmt.pixelformat & 0xff),
331  (p->fmt.pixelformat >> 8) & 0xff,
332  (p->fmt.pixelformat >> 16) & 0xff,
333  (p->fmt.pixelformat >> 24) & 0xff,
334  p->fmt.bytesperline, p->fmt.sizeimage,
335  p->fmt.colorspace);
336 }
337 
338 static void v4l_print_buftype(const void *arg, bool write_only)
339 {
340  pr_cont("type=%s\n", prt_names(*(u32 *)arg, v4l2_type_names));
341 }
342 
343 static void v4l_print_modulator(const void *arg, bool write_only)
344 {
345  const struct v4l2_modulator *p = arg;
346 
347  if (write_only)
348  pr_cont("index=%u, txsubchans=0x%x", p->index, p->txsubchans);
349  else
350  pr_cont("index=%u, name=%s, capability=0x%x, "
351  "rangelow=%u, rangehigh=%u, txsubchans=0x%x\n",
352  p->index, p->name, p->capability,
353  p->rangelow, p->rangehigh, p->txsubchans);
354 }
355 
356 static void v4l_print_tuner(const void *arg, bool write_only)
357 {
358  const struct v4l2_tuner *p = arg;
359 
360  if (write_only)
361  pr_cont("index=%u, audmode=%u\n", p->index, p->audmode);
362  else
363  pr_cont("index=%u, name=%s, type=%u, capability=0x%x, "
364  "rangelow=%u, rangehigh=%u, signal=%u, afc=%d, "
365  "rxsubchans=0x%x, audmode=%u\n",
366  p->index, p->name, p->type,
367  p->capability, p->rangelow,
368  p->rangehigh, p->signal, p->afc,
369  p->rxsubchans, p->audmode);
370 }
371 
372 static void v4l_print_frequency(const void *arg, bool write_only)
373 {
374  const struct v4l2_frequency *p = arg;
375 
376  pr_cont("tuner=%u, type=%u, frequency=%u\n",
377  p->tuner, p->type, p->frequency);
378 }
379 
380 static void v4l_print_standard(const void *arg, bool write_only)
381 {
382  const struct v4l2_standard *p = arg;
383 
384  pr_cont("index=%u, id=0x%Lx, name=%s, fps=%u/%u, "
385  "framelines=%u\n", p->index,
386  (unsigned long long)p->id, p->name,
387  p->frameperiod.numerator,
388  p->frameperiod.denominator,
389  p->framelines);
390 }
391 
392 static void v4l_print_std(const void *arg, bool write_only)
393 {
394  pr_cont("std=0x%08Lx\n", *(const long long unsigned *)arg);
395 }
396 
397 static void v4l_print_hw_freq_seek(const void *arg, bool write_only)
398 {
399  const struct v4l2_hw_freq_seek *p = arg;
400 
401  pr_cont("tuner=%u, type=%u, seek_upward=%u, wrap_around=%u, spacing=%u, "
402  "rangelow=%u, rangehigh=%u\n",
403  p->tuner, p->type, p->seek_upward, p->wrap_around, p->spacing,
404  p->rangelow, p->rangehigh);
405 }
406 
407 static void v4l_print_requestbuffers(const void *arg, bool write_only)
408 {
409  const struct v4l2_requestbuffers *p = arg;
410 
411  pr_cont("count=%d, type=%s, memory=%s\n",
412  p->count,
413  prt_names(p->type, v4l2_type_names),
414  prt_names(p->memory, v4l2_memory_names));
415 }
416 
417 static void v4l_print_buffer(const void *arg, bool write_only)
418 {
419  const struct v4l2_buffer *p = arg;
420  const struct v4l2_timecode *tc = &p->timecode;
421  const struct v4l2_plane *plane;
422  int i;
423 
424  pr_cont("%02ld:%02d:%02d.%08ld index=%d, type=%s, "
425  "flags=0x%08x, field=%s, sequence=%d, memory=%s",
426  p->timestamp.tv_sec / 3600,
427  (int)(p->timestamp.tv_sec / 60) % 60,
428  (int)(p->timestamp.tv_sec % 60),
429  (long)p->timestamp.tv_usec,
430  p->index,
431  prt_names(p->type, v4l2_type_names),
432  p->flags, prt_names(p->field, v4l2_field_names),
433  p->sequence, prt_names(p->memory, v4l2_memory_names));
434 
435  if (V4L2_TYPE_IS_MULTIPLANAR(p->type) && p->m.planes) {
436  pr_cont("\n");
437  for (i = 0; i < p->length; ++i) {
438  plane = &p->m.planes[i];
439  printk(KERN_DEBUG
440  "plane %d: bytesused=%d, data_offset=0x%08x "
441  "offset/userptr=0x%lx, length=%d\n",
442  i, plane->bytesused, plane->data_offset,
443  plane->m.userptr, plane->length);
444  }
445  } else {
446  pr_cont("bytesused=%d, offset/userptr=0x%lx, length=%d\n",
447  p->bytesused, p->m.userptr, p->length);
448  }
449 
450  printk(KERN_DEBUG "timecode=%02d:%02d:%02d type=%d, "
451  "flags=0x%08x, frames=%d, userbits=0x%08x\n",
452  tc->hours, tc->minutes, tc->seconds,
453  tc->type, tc->flags, tc->frames, *(__u32 *)tc->userbits);
454 }
455 
456 static void v4l_print_create_buffers(const void *arg, bool write_only)
457 {
458  const struct v4l2_create_buffers *p = arg;
459 
460  pr_cont("index=%d, count=%d, memory=%s, ",
461  p->index, p->count,
462  prt_names(p->memory, v4l2_memory_names));
463  v4l_print_format(&p->format, write_only);
464 }
465 
466 static void v4l_print_streamparm(const void *arg, bool write_only)
467 {
468  const struct v4l2_streamparm *p = arg;
469 
470  pr_cont("type=%s", prt_names(p->type, v4l2_type_names));
471 
472  if (p->type == V4L2_BUF_TYPE_VIDEO_CAPTURE ||
473  p->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
474  const struct v4l2_captureparm *c = &p->parm.capture;
475 
476  pr_cont(", capability=0x%x, capturemode=0x%x, timeperframe=%d/%d, "
477  "extendedmode=%d, readbuffers=%d\n",
478  c->capability, c->capturemode,
479  c->timeperframe.numerator, c->timeperframe.denominator,
480  c->extendedmode, c->readbuffers);
481  } else if (p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT ||
482  p->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
483  const struct v4l2_outputparm *c = &p->parm.output;
484 
485  pr_cont(", capability=0x%x, outputmode=0x%x, timeperframe=%d/%d, "
486  "extendedmode=%d, writebuffers=%d\n",
487  c->capability, c->outputmode,
488  c->timeperframe.numerator, c->timeperframe.denominator,
489  c->extendedmode, c->writebuffers);
490  }
491 }
492 
493 static void v4l_print_queryctrl(const void *arg, bool write_only)
494 {
495  const struct v4l2_queryctrl *p = arg;
496 
497  pr_cont("id=0x%x, type=%d, name=%s, min/max=%d/%d, "
498  "step=%d, default=%d, flags=0x%08x\n",
499  p->id, p->type, p->name,
500  p->minimum, p->maximum,
501  p->step, p->default_value, p->flags);
502 }
503 
504 static void v4l_print_querymenu(const void *arg, bool write_only)
505 {
506  const struct v4l2_querymenu *p = arg;
507 
508  pr_cont("id=0x%x, index=%d\n", p->id, p->index);
509 }
510 
511 static void v4l_print_control(const void *arg, bool write_only)
512 {
513  const struct v4l2_control *p = arg;
514 
515  pr_cont("id=0x%x, value=%d\n", p->id, p->value);
516 }
517 
518 static void v4l_print_ext_controls(const void *arg, bool write_only)
519 {
520  const struct v4l2_ext_controls *p = arg;
521  int i;
522 
523  pr_cont("class=0x%x, count=%d, error_idx=%d",
524  p->ctrl_class, p->count, p->error_idx);
525  for (i = 0; i < p->count; i++) {
526  if (p->controls[i].size)
527  pr_cont(", id/val=0x%x/0x%x",
528  p->controls[i].id, p->controls[i].value);
529  else
530  pr_cont(", id/size=0x%x/%u",
531  p->controls[i].id, p->controls[i].size);
532  }
533  pr_cont("\n");
534 }
535 
536 static void v4l_print_cropcap(const void *arg, bool write_only)
537 {
538  const struct v4l2_cropcap *p = arg;
539 
540  pr_cont("type=%s, bounds wxh=%dx%d, x,y=%d,%d, "
541  "defrect wxh=%dx%d, x,y=%d,%d\n, "
542  "pixelaspect %d/%d\n",
543  prt_names(p->type, v4l2_type_names),
544  p->bounds.width, p->bounds.height,
545  p->bounds.left, p->bounds.top,
546  p->defrect.width, p->defrect.height,
547  p->defrect.left, p->defrect.top,
548  p->pixelaspect.numerator, p->pixelaspect.denominator);
549 }
550 
551 static void v4l_print_crop(const void *arg, bool write_only)
552 {
553  const struct v4l2_crop *p = arg;
554 
555  pr_cont("type=%s, wxh=%dx%d, x,y=%d,%d\n",
556  prt_names(p->type, v4l2_type_names),
557  p->c.width, p->c.height,
558  p->c.left, p->c.top);
559 }
560 
561 static void v4l_print_selection(const void *arg, bool write_only)
562 {
563  const struct v4l2_selection *p = arg;
564 
565  pr_cont("type=%s, target=%d, flags=0x%x, wxh=%dx%d, x,y=%d,%d\n",
566  prt_names(p->type, v4l2_type_names),
567  p->target, p->flags,
568  p->r.width, p->r.height, p->r.left, p->r.top);
569 }
570 
571 static void v4l_print_jpegcompression(const void *arg, bool write_only)
572 {
573  const struct v4l2_jpegcompression *p = arg;
574 
575  pr_cont("quality=%d, APPn=%d, APP_len=%d, "
576  "COM_len=%d, jpeg_markers=0x%x\n",
577  p->quality, p->APPn, p->APP_len,
578  p->COM_len, p->jpeg_markers);
579 }
580 
581 static void v4l_print_enc_idx(const void *arg, bool write_only)
582 {
583  const struct v4l2_enc_idx *p = arg;
584 
585  pr_cont("entries=%d, entries_cap=%d\n",
586  p->entries, p->entries_cap);
587 }
588 
589 static void v4l_print_encoder_cmd(const void *arg, bool write_only)
590 {
591  const struct v4l2_encoder_cmd *p = arg;
592 
593  pr_cont("cmd=%d, flags=0x%x\n",
594  p->cmd, p->flags);
595 }
596 
597 static void v4l_print_decoder_cmd(const void *arg, bool write_only)
598 {
599  const struct v4l2_decoder_cmd *p = arg;
600 
601  pr_cont("cmd=%d, flags=0x%x\n", p->cmd, p->flags);
602 
603  if (p->cmd == V4L2_DEC_CMD_START)
604  pr_info("speed=%d, format=%u\n",
605  p->start.speed, p->start.format);
606  else if (p->cmd == V4L2_DEC_CMD_STOP)
607  pr_info("pts=%llu\n", p->stop.pts);
608 }
609 
610 static void v4l_print_dbg_chip_ident(const void *arg, bool write_only)
611 {
612  const struct v4l2_dbg_chip_ident *p = arg;
613 
614  pr_cont("type=%u, ", p->match.type);
615  if (p->match.type == V4L2_CHIP_MATCH_I2C_DRIVER)
616  pr_cont("name=%s, ", p->match.name);
617  else
618  pr_cont("addr=%u, ", p->match.addr);
619  pr_cont("chip_ident=%u, revision=0x%x\n",
620  p->ident, p->revision);
621 }
622 
623 static void v4l_print_dbg_register(const void *arg, bool write_only)
624 {
625  const struct v4l2_dbg_register *p = arg;
626 
627  pr_cont("type=%u, ", p->match.type);
628  if (p->match.type == V4L2_CHIP_MATCH_I2C_DRIVER)
629  pr_cont("name=%s, ", p->match.name);
630  else
631  pr_cont("addr=%u, ", p->match.addr);
632  pr_cont("reg=0x%llx, val=0x%llx\n",
633  p->reg, p->val);
634 }
635 
636 static void v4l_print_dv_enum_presets(const void *arg, bool write_only)
637 {
638  const struct v4l2_dv_enum_preset *p = arg;
639 
640  pr_cont("index=%u, preset=%u, name=%s, width=%u, height=%u\n",
641  p->index, p->preset, p->name, p->width, p->height);
642 }
643 
644 static void v4l_print_dv_preset(const void *arg, bool write_only)
645 {
646  const struct v4l2_dv_preset *p = arg;
647 
648  pr_cont("preset=%u\n", p->preset);
649 }
650 
651 static void v4l_print_dv_timings(const void *arg, bool write_only)
652 {
653  const struct v4l2_dv_timings *p = arg;
654 
655  switch (p->type) {
656  case V4L2_DV_BT_656_1120:
657  pr_cont("type=bt-656/1120, interlaced=%u, "
658  "pixelclock=%llu, "
659  "width=%u, height=%u, polarities=0x%x, "
660  "hfrontporch=%u, hsync=%u, "
661  "hbackporch=%u, vfrontporch=%u, "
662  "vsync=%u, vbackporch=%u, "
663  "il_vfrontporch=%u, il_vsync=%u, "
664  "il_vbackporch=%u, standards=0x%x, flags=0x%x\n",
665  p->bt.interlaced, p->bt.pixelclock,
666  p->bt.width, p->bt.height,
667  p->bt.polarities, p->bt.hfrontporch,
668  p->bt.hsync, p->bt.hbackporch,
669  p->bt.vfrontporch, p->bt.vsync,
670  p->bt.vbackporch, p->bt.il_vfrontporch,
671  p->bt.il_vsync, p->bt.il_vbackporch,
672  p->bt.standards, p->bt.flags);
673  break;
674  default:
675  pr_cont("type=%d\n", p->type);
676  break;
677  }
678 }
679 
680 static void v4l_print_enum_dv_timings(const void *arg, bool write_only)
681 {
682  const struct v4l2_enum_dv_timings *p = arg;
683 
684  pr_cont("index=%u, ", p->index);
685  v4l_print_dv_timings(&p->timings, write_only);
686 }
687 
688 static void v4l_print_dv_timings_cap(const void *arg, bool write_only)
689 {
690  const struct v4l2_dv_timings_cap *p = arg;
691 
692  switch (p->type) {
693  case V4L2_DV_BT_656_1120:
694  pr_cont("type=bt-656/1120, width=%u-%u, height=%u-%u, "
695  "pixelclock=%llu-%llu, standards=0x%x, capabilities=0x%x\n",
696  p->bt.min_width, p->bt.max_width,
697  p->bt.min_height, p->bt.max_height,
698  p->bt.min_pixelclock, p->bt.max_pixelclock,
699  p->bt.standards, p->bt.capabilities);
700  break;
701  default:
702  pr_cont("type=%u\n", p->type);
703  break;
704  }
705 }
706 
707 static void v4l_print_frmsizeenum(const void *arg, bool write_only)
708 {
709  const struct v4l2_frmsizeenum *p = arg;
710 
711  pr_cont("index=%u, pixelformat=%c%c%c%c, type=%u",
712  p->index,
713  (p->pixel_format & 0xff),
714  (p->pixel_format >> 8) & 0xff,
715  (p->pixel_format >> 16) & 0xff,
716  (p->pixel_format >> 24) & 0xff,
717  p->type);
718  switch (p->type) {
719  case V4L2_FRMSIZE_TYPE_DISCRETE:
720  pr_cont(" wxh=%ux%u\n",
721  p->discrete.width, p->discrete.height);
722  break;
723  case V4L2_FRMSIZE_TYPE_STEPWISE:
724  pr_cont(" min=%ux%u, max=%ux%u, step=%ux%u\n",
725  p->stepwise.min_width, p->stepwise.min_height,
726  p->stepwise.step_width, p->stepwise.step_height,
727  p->stepwise.max_width, p->stepwise.max_height);
728  break;
729  case V4L2_FRMSIZE_TYPE_CONTINUOUS:
730  /* fall through */
731  default:
732  pr_cont("\n");
733  break;
734  }
735 }
736 
737 static void v4l_print_frmivalenum(const void *arg, bool write_only)
738 {
739  const struct v4l2_frmivalenum *p = arg;
740 
741  pr_cont("index=%u, pixelformat=%c%c%c%c, wxh=%ux%u, type=%u",
742  p->index,
743  (p->pixel_format & 0xff),
744  (p->pixel_format >> 8) & 0xff,
745  (p->pixel_format >> 16) & 0xff,
746  (p->pixel_format >> 24) & 0xff,
747  p->width, p->height, p->type);
748  switch (p->type) {
749  case V4L2_FRMIVAL_TYPE_DISCRETE:
750  pr_cont(" fps=%d/%d\n",
751  p->discrete.numerator,
752  p->discrete.denominator);
753  break;
754  case V4L2_FRMIVAL_TYPE_STEPWISE:
755  pr_cont(" min=%d/%d, max=%d/%d, step=%d/%d\n",
756  p->stepwise.min.numerator,
757  p->stepwise.min.denominator,
758  p->stepwise.max.numerator,
759  p->stepwise.max.denominator,
760  p->stepwise.step.numerator,
761  p->stepwise.step.denominator);
762  break;
763  case V4L2_FRMIVAL_TYPE_CONTINUOUS:
764  /* fall through */
765  default:
766  pr_cont("\n");
767  break;
768  }
769 }
770 
771 static void v4l_print_event(const void *arg, bool write_only)
772 {
773  const struct v4l2_event *p = arg;
774  const struct v4l2_event_ctrl *c;
775 
776  pr_cont("type=0x%x, pending=%u, sequence=%u, id=%u, "
777  "timestamp=%lu.%9.9lu\n",
778  p->type, p->pending, p->sequence, p->id,
779  p->timestamp.tv_sec, p->timestamp.tv_nsec);
780  switch (p->type) {
781  case V4L2_EVENT_VSYNC:
782  printk(KERN_DEBUG "field=%s\n",
783  prt_names(p->u.vsync.field, v4l2_field_names));
784  break;
785  case V4L2_EVENT_CTRL:
786  c = &p->u.ctrl;
787  printk(KERN_DEBUG "changes=0x%x, type=%u, ",
788  c->changes, c->type);
789  if (c->type == V4L2_CTRL_TYPE_INTEGER64)
790  pr_cont("value64=%lld, ", c->value64);
791  else
792  pr_cont("value=%d, ", c->value);
793  pr_cont("flags=0x%x, minimum=%d, maximum=%d, step=%d,"
794  " default_value=%d\n",
795  c->flags, c->minimum, c->maximum,
796  c->step, c->default_value);
797  break;
798  case V4L2_EVENT_FRAME_SYNC:
799  pr_cont("frame_sequence=%u\n",
800  p->u.frame_sync.frame_sequence);
801  break;
802  }
803 }
804 
805 static void v4l_print_event_subscription(const void *arg, bool write_only)
806 {
807  const struct v4l2_event_subscription *p = arg;
808 
809  pr_cont("type=0x%x, id=0x%x, flags=0x%x\n",
810  p->type, p->id, p->flags);
811 }
812 
813 static void v4l_print_sliced_vbi_cap(const void *arg, bool write_only)
814 {
815  const struct v4l2_sliced_vbi_cap *p = arg;
816  int i;
817 
818  pr_cont("type=%s, service_set=0x%08x\n",
819  prt_names(p->type, v4l2_type_names), p->service_set);
820  for (i = 0; i < 24; i++)
821  printk(KERN_DEBUG "line[%02u]=0x%04x, 0x%04x\n", i,
822  p->service_lines[0][i],
823  p->service_lines[1][i]);
824 }
825 
826 static void v4l_print_freq_band(const void *arg, bool write_only)
827 {
828  const struct v4l2_frequency_band *p = arg;
829 
830  pr_cont("tuner=%u, type=%u, index=%u, capability=0x%x, "
831  "rangelow=%u, rangehigh=%u, modulation=0x%x\n",
832  p->tuner, p->type, p->index,
833  p->capability, p->rangelow,
834  p->rangehigh, p->modulation);
835 }
836 
837 static void v4l_print_u32(const void *arg, bool write_only)
838 {
839  pr_cont("value=%u\n", *(const u32 *)arg);
840 }
841 
842 static void v4l_print_newline(const void *arg, bool write_only)
843 {
844  pr_cont("\n");
845 }
846 
847 static void v4l_print_default(const void *arg, bool write_only)
848 {
849  pr_cont("driver-specific ioctl\n");
850 }
851 
852 static int check_ext_ctrls(struct v4l2_ext_controls *c, int allow_priv)
853 {
854  __u32 i;
855 
856  /* zero the reserved fields */
857  c->reserved[0] = c->reserved[1] = 0;
858  for (i = 0; i < c->count; i++)
859  c->controls[i].reserved2[0] = 0;
860 
861  /* V4L2_CID_PRIVATE_BASE cannot be used as control class
862  when using extended controls.
863  Only when passed in through VIDIOC_G_CTRL and VIDIOC_S_CTRL
864  is it allowed for backwards compatibility.
865  */
866  if (!allow_priv && c->ctrl_class == V4L2_CID_PRIVATE_BASE)
867  return 0;
868  /* Check that all controls are from the same control class. */
869  for (i = 0; i < c->count; i++) {
870  if (V4L2_CTRL_ID2CLASS(c->controls[i].id) != c->ctrl_class) {
871  c->error_idx = i;
872  return 0;
873  }
874  }
875  return 1;
876 }
877 
878 static int check_fmt(struct file *file, enum v4l2_buf_type type)
879 {
880  struct video_device *vfd = video_devdata(file);
881  const struct v4l2_ioctl_ops *ops = vfd->ioctl_ops;
882  bool is_vid = vfd->vfl_type == VFL_TYPE_GRABBER;
883  bool is_vbi = vfd->vfl_type == VFL_TYPE_VBI;
884  bool is_rx = vfd->vfl_dir != VFL_DIR_TX;
885  bool is_tx = vfd->vfl_dir != VFL_DIR_RX;
886 
887  if (ops == NULL)
888  return -EINVAL;
889 
890  switch (type) {
891  case V4L2_BUF_TYPE_VIDEO_CAPTURE:
892  if (is_vid && is_rx &&
893  (ops->vidioc_g_fmt_vid_cap || ops->vidioc_g_fmt_vid_cap_mplane))
894  return 0;
895  break;
896  case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
897  if (is_vid && is_rx && ops->vidioc_g_fmt_vid_cap_mplane)
898  return 0;
899  break;
900  case V4L2_BUF_TYPE_VIDEO_OVERLAY:
901  if (is_vid && is_rx && ops->vidioc_g_fmt_vid_overlay)
902  return 0;
903  break;
904  case V4L2_BUF_TYPE_VIDEO_OUTPUT:
905  if (is_vid && is_tx &&
906  (ops->vidioc_g_fmt_vid_out || ops->vidioc_g_fmt_vid_out_mplane))
907  return 0;
908  break;
909  case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
910  if (is_vid && is_tx && ops->vidioc_g_fmt_vid_out_mplane)
911  return 0;
912  break;
913  case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
914  if (is_vid && is_tx && ops->vidioc_g_fmt_vid_out_overlay)
915  return 0;
916  break;
917  case V4L2_BUF_TYPE_VBI_CAPTURE:
918  if (is_vbi && is_rx && ops->vidioc_g_fmt_vbi_cap)
919  return 0;
920  break;
921  case V4L2_BUF_TYPE_VBI_OUTPUT:
922  if (is_vbi && is_tx && ops->vidioc_g_fmt_vbi_out)
923  return 0;
924  break;
925  case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
926  if (is_vbi && is_rx && ops->vidioc_g_fmt_sliced_vbi_cap)
927  return 0;
928  break;
929  case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
930  if (is_vbi && is_tx && ops->vidioc_g_fmt_sliced_vbi_out)
931  return 0;
932  break;
933  default:
934  break;
935  }
936  return -EINVAL;
937 }
938 
939 static int v4l_querycap(const struct v4l2_ioctl_ops *ops,
940  struct file *file, void *fh, void *arg)
941 {
942  struct v4l2_capability *cap = (struct v4l2_capability *)arg;
943 
944  cap->version = LINUX_VERSION_CODE;
945  return ops->vidioc_querycap(file, fh, cap);
946 }
947 
948 static int v4l_s_input(const struct v4l2_ioctl_ops *ops,
949  struct file *file, void *fh, void *arg)
950 {
951  return ops->vidioc_s_input(file, fh, *(unsigned int *)arg);
952 }
953 
954 static int v4l_s_output(const struct v4l2_ioctl_ops *ops,
955  struct file *file, void *fh, void *arg)
956 {
957  return ops->vidioc_s_output(file, fh, *(unsigned int *)arg);
958 }
959 
960 static int v4l_g_priority(const struct v4l2_ioctl_ops *ops,
961  struct file *file, void *fh, void *arg)
962 {
963  struct video_device *vfd;
964  u32 *p = arg;
965 
966  if (ops->vidioc_g_priority)
967  return ops->vidioc_g_priority(file, fh, arg);
968  vfd = video_devdata(file);
969  *p = v4l2_prio_max(&vfd->v4l2_dev->prio);
970  return 0;
971 }
972 
973 static int v4l_s_priority(const struct v4l2_ioctl_ops *ops,
974  struct file *file, void *fh, void *arg)
975 {
976  struct video_device *vfd;
977  struct v4l2_fh *vfh;
978  u32 *p = arg;
979 
980  if (ops->vidioc_s_priority)
981  return ops->vidioc_s_priority(file, fh, *p);
982  vfd = video_devdata(file);
983  vfh = file->private_data;
984  return v4l2_prio_change(&vfd->v4l2_dev->prio, &vfh->prio, *p);
985 }
986 
987 static int v4l_enuminput(const struct v4l2_ioctl_ops *ops,
988  struct file *file, void *fh, void *arg)
989 {
990  struct v4l2_input *p = arg;
991 
992  /*
993  * We set the flags for CAP_PRESETS, CAP_DV_TIMINGS &
994  * CAP_STD here based on ioctl handler provided by the
995  * driver. If the driver doesn't support these
996  * for a specific input, it must override these flags.
997  */
998  if (ops->vidioc_s_std)
999  p->capabilities |= V4L2_IN_CAP_STD;
1000  if (ops->vidioc_s_dv_preset)
1001  p->capabilities |= V4L2_IN_CAP_PRESETS;
1002  if (ops->vidioc_s_dv_timings)
1003  p->capabilities |= V4L2_IN_CAP_DV_TIMINGS;
1004 
1005  return ops->vidioc_enum_input(file, fh, p);
1006 }
1007 
1008 static int v4l_enumoutput(const struct v4l2_ioctl_ops *ops,
1009  struct file *file, void *fh, void *arg)
1010 {
1011  struct v4l2_output *p = arg;
1012 
1013  /*
1014  * We set the flags for CAP_PRESETS, CAP_DV_TIMINGS &
1015  * CAP_STD here based on ioctl handler provided by the
1016  * driver. If the driver doesn't support these
1017  * for a specific output, it must override these flags.
1018  */
1019  if (ops->vidioc_s_std)
1020  p->capabilities |= V4L2_OUT_CAP_STD;
1021  if (ops->vidioc_s_dv_preset)
1022  p->capabilities |= V4L2_OUT_CAP_PRESETS;
1023  if (ops->vidioc_s_dv_timings)
1024  p->capabilities |= V4L2_OUT_CAP_DV_TIMINGS;
1025 
1026  return ops->vidioc_enum_output(file, fh, p);
1027 }
1028 
1029 static int v4l_enum_fmt(const struct v4l2_ioctl_ops *ops,
1030  struct file *file, void *fh, void *arg)
1031 {
1032  struct v4l2_fmtdesc *p = arg;
1033  struct video_device *vfd = video_devdata(file);
1034  bool is_rx = vfd->vfl_dir != VFL_DIR_TX;
1035  bool is_tx = vfd->vfl_dir != VFL_DIR_RX;
1036 
1037  switch (p->type) {
1038  case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1039  if (unlikely(!is_rx || !ops->vidioc_enum_fmt_vid_cap))
1040  break;
1041  return ops->vidioc_enum_fmt_vid_cap(file, fh, arg);
1042  case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
1043  if (unlikely(!is_rx || !ops->vidioc_enum_fmt_vid_cap_mplane))
1044  break;
1045  return ops->vidioc_enum_fmt_vid_cap_mplane(file, fh, arg);
1046  case V4L2_BUF_TYPE_VIDEO_OVERLAY:
1047  if (unlikely(!is_rx || !ops->vidioc_enum_fmt_vid_overlay))
1048  break;
1049  return ops->vidioc_enum_fmt_vid_overlay(file, fh, arg);
1050  case V4L2_BUF_TYPE_VIDEO_OUTPUT:
1051  if (unlikely(!is_tx || !ops->vidioc_enum_fmt_vid_out))
1052  break;
1053  return ops->vidioc_enum_fmt_vid_out(file, fh, arg);
1054  case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
1055  if (unlikely(!is_tx || !ops->vidioc_enum_fmt_vid_out_mplane))
1056  break;
1057  return ops->vidioc_enum_fmt_vid_out_mplane(file, fh, arg);
1058  }
1059  return -EINVAL;
1060 }
1061 
1062 static int v4l_g_fmt(const struct v4l2_ioctl_ops *ops,
1063  struct file *file, void *fh, void *arg)
1064 {
1065  struct v4l2_format *p = arg;
1066  struct video_device *vfd = video_devdata(file);
1067  bool is_vid = vfd->vfl_type == VFL_TYPE_GRABBER;
1068  bool is_rx = vfd->vfl_dir != VFL_DIR_TX;
1069  bool is_tx = vfd->vfl_dir != VFL_DIR_RX;
1070 
1071  switch (p->type) {
1072  case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1073  if (unlikely(!is_rx || !is_vid || !ops->vidioc_g_fmt_vid_cap))
1074  break;
1075  return ops->vidioc_g_fmt_vid_cap(file, fh, arg);
1076  case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
1077  if (unlikely(!is_rx || !is_vid || !ops->vidioc_g_fmt_vid_cap_mplane))
1078  break;
1079  return ops->vidioc_g_fmt_vid_cap_mplane(file, fh, arg);
1080  case V4L2_BUF_TYPE_VIDEO_OVERLAY:
1081  if (unlikely(!is_rx || !is_vid || !ops->vidioc_g_fmt_vid_overlay))
1082  break;
1083  return ops->vidioc_g_fmt_vid_overlay(file, fh, arg);
1084  case V4L2_BUF_TYPE_VBI_CAPTURE:
1085  if (unlikely(!is_rx || is_vid || !ops->vidioc_g_fmt_vbi_cap))
1086  break;
1087  return ops->vidioc_g_fmt_vbi_cap(file, fh, arg);
1088  case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
1089  if (unlikely(!is_rx || is_vid || !ops->vidioc_g_fmt_sliced_vbi_cap))
1090  break;
1091  return ops->vidioc_g_fmt_sliced_vbi_cap(file, fh, arg);
1092  case V4L2_BUF_TYPE_VIDEO_OUTPUT:
1093  if (unlikely(!is_tx || !is_vid || !ops->vidioc_g_fmt_vid_out))
1094  break;
1095  return ops->vidioc_g_fmt_vid_out(file, fh, arg);
1096  case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
1097  if (unlikely(!is_tx || !is_vid || !ops->vidioc_g_fmt_vid_out_mplane))
1098  break;
1099  return ops->vidioc_g_fmt_vid_out_mplane(file, fh, arg);
1100  case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
1101  if (unlikely(!is_tx || !is_vid || !ops->vidioc_g_fmt_vid_out_overlay))
1102  break;
1103  return ops->vidioc_g_fmt_vid_out_overlay(file, fh, arg);
1104  case V4L2_BUF_TYPE_VBI_OUTPUT:
1105  if (unlikely(!is_tx || is_vid || !ops->vidioc_g_fmt_vbi_out))
1106  break;
1107  return ops->vidioc_g_fmt_vbi_out(file, fh, arg);
1108  case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
1109  if (unlikely(!is_tx || is_vid || !ops->vidioc_g_fmt_sliced_vbi_out))
1110  break;
1111  return ops->vidioc_g_fmt_sliced_vbi_out(file, fh, arg);
1112  }
1113  return -EINVAL;
1114 }
1115 
1116 static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops,
1117  struct file *file, void *fh, void *arg)
1118 {
1119  struct v4l2_format *p = arg;
1120  struct video_device *vfd = video_devdata(file);
1121  bool is_vid = vfd->vfl_type == VFL_TYPE_GRABBER;
1122  bool is_rx = vfd->vfl_dir != VFL_DIR_TX;
1123  bool is_tx = vfd->vfl_dir != VFL_DIR_RX;
1124 
1125  switch (p->type) {
1126  case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1127  if (unlikely(!is_rx || !is_vid || !ops->vidioc_s_fmt_vid_cap))
1128  break;
1129  CLEAR_AFTER_FIELD(p, fmt.pix);
1130  return ops->vidioc_s_fmt_vid_cap(file, fh, arg);
1131  case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
1132  if (unlikely(!is_rx || !is_vid || !ops->vidioc_s_fmt_vid_cap_mplane))
1133  break;
1134  CLEAR_AFTER_FIELD(p, fmt.pix_mp);
1135  return ops->vidioc_s_fmt_vid_cap_mplane(file, fh, arg);
1136  case V4L2_BUF_TYPE_VIDEO_OVERLAY:
1137  if (unlikely(!is_rx || !is_vid || !ops->vidioc_s_fmt_vid_overlay))
1138  break;
1139  CLEAR_AFTER_FIELD(p, fmt.win);
1140  return ops->vidioc_s_fmt_vid_overlay(file, fh, arg);
1141  case V4L2_BUF_TYPE_VBI_CAPTURE:
1142  if (unlikely(!is_rx || is_vid || !ops->vidioc_s_fmt_vbi_cap))
1143  break;
1144  CLEAR_AFTER_FIELD(p, fmt.vbi);
1145  return ops->vidioc_s_fmt_vbi_cap(file, fh, arg);
1146  case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
1147  if (unlikely(!is_rx || is_vid || !ops->vidioc_s_fmt_sliced_vbi_cap))
1148  break;
1149  CLEAR_AFTER_FIELD(p, fmt.sliced);
1150  return ops->vidioc_s_fmt_sliced_vbi_cap(file, fh, arg);
1151  case V4L2_BUF_TYPE_VIDEO_OUTPUT:
1152  if (unlikely(!is_tx || !is_vid || !ops->vidioc_s_fmt_vid_out))
1153  break;
1154  CLEAR_AFTER_FIELD(p, fmt.pix);
1155  return ops->vidioc_s_fmt_vid_out(file, fh, arg);
1156  case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
1157  if (unlikely(!is_tx || !is_vid || !ops->vidioc_s_fmt_vid_out_mplane))
1158  break;
1159  CLEAR_AFTER_FIELD(p, fmt.pix_mp);
1160  return ops->vidioc_s_fmt_vid_out_mplane(file, fh, arg);
1161  case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
1162  if (unlikely(!is_tx || !is_vid || !ops->vidioc_s_fmt_vid_out_overlay))
1163  break;
1164  CLEAR_AFTER_FIELD(p, fmt.win);
1165  return ops->vidioc_s_fmt_vid_out_overlay(file, fh, arg);
1166  case V4L2_BUF_TYPE_VBI_OUTPUT:
1167  if (unlikely(!is_tx || is_vid || !ops->vidioc_s_fmt_vbi_out))
1168  break;
1169  CLEAR_AFTER_FIELD(p, fmt.vbi);
1170  return ops->vidioc_s_fmt_vbi_out(file, fh, arg);
1171  case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
1172  if (unlikely(!is_tx || is_vid || !ops->vidioc_s_fmt_sliced_vbi_out))
1173  break;
1174  CLEAR_AFTER_FIELD(p, fmt.sliced);
1175  return ops->vidioc_s_fmt_sliced_vbi_out(file, fh, arg);
1176  }
1177  return -EINVAL;
1178 }
1179 
1180 static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops,
1181  struct file *file, void *fh, void *arg)
1182 {
1183  struct v4l2_format *p = arg;
1184  struct video_device *vfd = video_devdata(file);
1185  bool is_vid = vfd->vfl_type == VFL_TYPE_GRABBER;
1186  bool is_rx = vfd->vfl_dir != VFL_DIR_TX;
1187  bool is_tx = vfd->vfl_dir != VFL_DIR_RX;
1188 
1189  switch (p->type) {
1190  case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1191  if (unlikely(!is_rx || !is_vid || !ops->vidioc_try_fmt_vid_cap))
1192  break;
1193  CLEAR_AFTER_FIELD(p, fmt.pix);
1194  return ops->vidioc_try_fmt_vid_cap(file, fh, arg);
1195  case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
1196  if (unlikely(!is_rx || !is_vid || !ops->vidioc_try_fmt_vid_cap_mplane))
1197  break;
1198  CLEAR_AFTER_FIELD(p, fmt.pix_mp);
1199  return ops->vidioc_try_fmt_vid_cap_mplane(file, fh, arg);
1200  case V4L2_BUF_TYPE_VIDEO_OVERLAY:
1201  if (unlikely(!is_rx || !is_vid || !ops->vidioc_try_fmt_vid_overlay))
1202  break;
1203  CLEAR_AFTER_FIELD(p, fmt.win);
1204  return ops->vidioc_try_fmt_vid_overlay(file, fh, arg);
1205  case V4L2_BUF_TYPE_VBI_CAPTURE:
1206  if (unlikely(!is_rx || is_vid || !ops->vidioc_try_fmt_vbi_cap))
1207  break;
1208  CLEAR_AFTER_FIELD(p, fmt.vbi);
1209  return ops->vidioc_try_fmt_vbi_cap(file, fh, arg);
1210  case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
1211  if (unlikely(!is_rx || is_vid || !ops->vidioc_try_fmt_sliced_vbi_cap))
1212  break;
1213  CLEAR_AFTER_FIELD(p, fmt.sliced);
1214  return ops->vidioc_try_fmt_sliced_vbi_cap(file, fh, arg);
1215  case V4L2_BUF_TYPE_VIDEO_OUTPUT:
1216  if (unlikely(!is_tx || !is_vid || !ops->vidioc_try_fmt_vid_out))
1217  break;
1218  CLEAR_AFTER_FIELD(p, fmt.pix);
1219  return ops->vidioc_try_fmt_vid_out(file, fh, arg);
1220  case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
1221  if (unlikely(!is_tx || !is_vid || !ops->vidioc_try_fmt_vid_out_mplane))
1222  break;
1223  CLEAR_AFTER_FIELD(p, fmt.pix_mp);
1224  return ops->vidioc_try_fmt_vid_out_mplane(file, fh, arg);
1225  case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
1226  if (unlikely(!is_tx || !is_vid || !ops->vidioc_try_fmt_vid_out_overlay))
1227  break;
1228  CLEAR_AFTER_FIELD(p, fmt.win);
1229  return ops->vidioc_try_fmt_vid_out_overlay(file, fh, arg);
1230  case V4L2_BUF_TYPE_VBI_OUTPUT:
1231  if (unlikely(!is_tx || is_vid || !ops->vidioc_try_fmt_vbi_out))
1232  break;
1233  CLEAR_AFTER_FIELD(p, fmt.vbi);
1234  return ops->vidioc_try_fmt_vbi_out(file, fh, arg);
1235  case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
1236  if (unlikely(!is_tx || is_vid || !ops->vidioc_try_fmt_sliced_vbi_out))
1237  break;
1238  CLEAR_AFTER_FIELD(p, fmt.sliced);
1239  return ops->vidioc_try_fmt_sliced_vbi_out(file, fh, arg);
1240  }
1241  return -EINVAL;
1242 }
1243 
1244 static int v4l_streamon(const struct v4l2_ioctl_ops *ops,
1245  struct file *file, void *fh, void *arg)
1246 {
1247  return ops->vidioc_streamon(file, fh, *(unsigned int *)arg);
1248 }
1249 
1250 static int v4l_streamoff(const struct v4l2_ioctl_ops *ops,
1251  struct file *file, void *fh, void *arg)
1252 {
1253  return ops->vidioc_streamoff(file, fh, *(unsigned int *)arg);
1254 }
1255 
1256 static int v4l_g_tuner(const struct v4l2_ioctl_ops *ops,
1257  struct file *file, void *fh, void *arg)
1258 {
1259  struct video_device *vfd = video_devdata(file);
1260  struct v4l2_tuner *p = arg;
1261  int err;
1262 
1263  p->type = (vfd->vfl_type == VFL_TYPE_RADIO) ?
1264  V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
1265  err = ops->vidioc_g_tuner(file, fh, p);
1266  if (!err)
1267  p->capability |= V4L2_TUNER_CAP_FREQ_BANDS;
1268  return err;
1269 }
1270 
1271 static int v4l_s_tuner(const struct v4l2_ioctl_ops *ops,
1272  struct file *file, void *fh, void *arg)
1273 {
1274  struct video_device *vfd = video_devdata(file);
1275  struct v4l2_tuner *p = arg;
1276 
1277  p->type = (vfd->vfl_type == VFL_TYPE_RADIO) ?
1278  V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
1279  return ops->vidioc_s_tuner(file, fh, p);
1280 }
1281 
1282 static int v4l_g_modulator(const struct v4l2_ioctl_ops *ops,
1283  struct file *file, void *fh, void *arg)
1284 {
1285  struct v4l2_modulator *p = arg;
1286  int err;
1287 
1288  err = ops->vidioc_g_modulator(file, fh, p);
1289  if (!err)
1290  p->capability |= V4L2_TUNER_CAP_FREQ_BANDS;
1291  return err;
1292 }
1293 
1294 static int v4l_g_frequency(const struct v4l2_ioctl_ops *ops,
1295  struct file *file, void *fh, void *arg)
1296 {
1297  struct video_device *vfd = video_devdata(file);
1298  struct v4l2_frequency *p = arg;
1299 
1300  p->type = (vfd->vfl_type == VFL_TYPE_RADIO) ?
1301  V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
1302  return ops->vidioc_g_frequency(file, fh, p);
1303 }
1304 
1305 static int v4l_s_frequency(const struct v4l2_ioctl_ops *ops,
1306  struct file *file, void *fh, void *arg)
1307 {
1308  struct video_device *vfd = video_devdata(file);
1309  struct v4l2_frequency *p = arg;
1310  enum v4l2_tuner_type type;
1311 
1312  type = (vfd->vfl_type == VFL_TYPE_RADIO) ?
1313  V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
1314  if (p->type != type)
1315  return -EINVAL;
1316  return ops->vidioc_s_frequency(file, fh, p);
1317 }
1318 
1319 static int v4l_enumstd(const struct v4l2_ioctl_ops *ops,
1320  struct file *file, void *fh, void *arg)
1321 {
1322  struct video_device *vfd = video_devdata(file);
1323  struct v4l2_standard *p = arg;
1324  v4l2_std_id id = vfd->tvnorms, curr_id = 0;
1325  unsigned int index = p->index, i, j = 0;
1326  const char *descr = "";
1327 
1328  /* Return -ENODATA if the tvnorms for the current input
1329  or output is 0, meaning that it doesn't support this API. */
1330  if (id == 0)
1331  return -ENODATA;
1332 
1333  /* Return norm array in a canonical way */
1334  for (i = 0; i <= index && id; i++) {
1335  /* last std value in the standards array is 0, so this
1336  while always ends there since (id & 0) == 0. */
1337  while ((id & standards[j].std) != standards[j].std)
1338  j++;
1339  curr_id = standards[j].std;
1340  descr = standards[j].descr;
1341  j++;
1342  if (curr_id == 0)
1343  break;
1344  if (curr_id != V4L2_STD_PAL &&
1345  curr_id != V4L2_STD_SECAM &&
1346  curr_id != V4L2_STD_NTSC)
1347  id &= ~curr_id;
1348  }
1349  if (i <= index)
1350  return -EINVAL;
1351 
1352  v4l2_video_std_construct(p, curr_id, descr);
1353  return 0;
1354 }
1355 
1356 static int v4l_g_std(const struct v4l2_ioctl_ops *ops,
1357  struct file *file, void *fh, void *arg)
1358 {
1359  struct video_device *vfd = video_devdata(file);
1360  v4l2_std_id *id = arg;
1361 
1362  /* Calls the specific handler */
1363  if (ops->vidioc_g_std)
1364  return ops->vidioc_g_std(file, fh, arg);
1365  if (vfd->current_norm) {
1366  *id = vfd->current_norm;
1367  return 0;
1368  }
1369  return -ENOTTY;
1370 }
1371 
1372 static int v4l_s_std(const struct v4l2_ioctl_ops *ops,
1373  struct file *file, void *fh, void *arg)
1374 {
1375  struct video_device *vfd = video_devdata(file);
1376  v4l2_std_id *id = arg, norm;
1377  int ret;
1378 
1379  norm = (*id) & vfd->tvnorms;
1380  if (vfd->tvnorms && !norm) /* Check if std is supported */
1381  return -EINVAL;
1382 
1383  /* Calls the specific handler */
1384  ret = ops->vidioc_s_std(file, fh, &norm);
1385 
1386  /* Updates standard information */
1387  if (ret >= 0)
1388  vfd->current_norm = norm;
1389  return ret;
1390 }
1391 
1392 static int v4l_querystd(const struct v4l2_ioctl_ops *ops,
1393  struct file *file, void *fh, void *arg)
1394 {
1395  struct video_device *vfd = video_devdata(file);
1396  v4l2_std_id *p = arg;
1397 
1398  /*
1399  * If nothing detected, it should return all supported
1400  * standard.
1401  * Drivers just need to mask the std argument, in order
1402  * to remove the standards that don't apply from the mask.
1403  * This means that tuners, audio and video decoders can join
1404  * their efforts to improve the standards detection.
1405  */
1406  *p = vfd->tvnorms;
1407  return ops->vidioc_querystd(file, fh, arg);
1408 }
1409 
1410 static int v4l_s_hw_freq_seek(const struct v4l2_ioctl_ops *ops,
1411  struct file *file, void *fh, void *arg)
1412 {
1413  struct video_device *vfd = video_devdata(file);
1414  struct v4l2_hw_freq_seek *p = arg;
1415  enum v4l2_tuner_type type;
1416 
1417  type = (vfd->vfl_type == VFL_TYPE_RADIO) ?
1418  V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
1419  if (p->type != type)
1420  return -EINVAL;
1421  return ops->vidioc_s_hw_freq_seek(file, fh, p);
1422 }
1423 
1424 static int v4l_overlay(const struct v4l2_ioctl_ops *ops,
1425  struct file *file, void *fh, void *arg)
1426 {
1427  return ops->vidioc_overlay(file, fh, *(unsigned int *)arg);
1428 }
1429 
1430 static int v4l_reqbufs(const struct v4l2_ioctl_ops *ops,
1431  struct file *file, void *fh, void *arg)
1432 {
1433  struct v4l2_requestbuffers *p = arg;
1434  int ret = check_fmt(file, p->type);
1435 
1436  if (ret)
1437  return ret;
1438 
1439  CLEAR_AFTER_FIELD(p, memory);
1440 
1441  return ops->vidioc_reqbufs(file, fh, p);
1442 }
1443 
1444 static int v4l_querybuf(const struct v4l2_ioctl_ops *ops,
1445  struct file *file, void *fh, void *arg)
1446 {
1447  struct v4l2_buffer *p = arg;
1448  int ret = check_fmt(file, p->type);
1449 
1450  return ret ? ret : ops->vidioc_querybuf(file, fh, p);
1451 }
1452 
1453 static int v4l_qbuf(const struct v4l2_ioctl_ops *ops,
1454  struct file *file, void *fh, void *arg)
1455 {
1456  struct v4l2_buffer *p = arg;
1457  int ret = check_fmt(file, p->type);
1458 
1459  return ret ? ret : ops->vidioc_qbuf(file, fh, p);
1460 }
1461 
1462 static int v4l_dqbuf(const struct v4l2_ioctl_ops *ops,
1463  struct file *file, void *fh, void *arg)
1464 {
1465  struct v4l2_buffer *p = arg;
1466  int ret = check_fmt(file, p->type);
1467 
1468  return ret ? ret : ops->vidioc_dqbuf(file, fh, p);
1469 }
1470 
1471 static int v4l_create_bufs(const struct v4l2_ioctl_ops *ops,
1472  struct file *file, void *fh, void *arg)
1473 {
1474  struct v4l2_create_buffers *create = arg;
1475  int ret = check_fmt(file, create->format.type);
1476 
1477  return ret ? ret : ops->vidioc_create_bufs(file, fh, create);
1478 }
1479 
1480 static int v4l_prepare_buf(const struct v4l2_ioctl_ops *ops,
1481  struct file *file, void *fh, void *arg)
1482 {
1483  struct v4l2_buffer *b = arg;
1484  int ret = check_fmt(file, b->type);
1485 
1486  return ret ? ret : ops->vidioc_prepare_buf(file, fh, b);
1487 }
1488 
1489 static int v4l_g_parm(const struct v4l2_ioctl_ops *ops,
1490  struct file *file, void *fh, void *arg)
1491 {
1492  struct video_device *vfd = video_devdata(file);
1493  struct v4l2_streamparm *p = arg;
1494  v4l2_std_id std;
1495  int ret = check_fmt(file, p->type);
1496 
1497  if (ret)
1498  return ret;
1499  if (ops->vidioc_g_parm)
1500  return ops->vidioc_g_parm(file, fh, p);
1501  std = vfd->current_norm;
1502  if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1503  p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
1504  return -EINVAL;
1505  p->parm.capture.readbuffers = 2;
1506  if (ops->vidioc_g_std)
1507  ret = ops->vidioc_g_std(file, fh, &std);
1508  if (ret == 0)
1509  v4l2_video_std_frame_period(std,
1510  &p->parm.capture.timeperframe);
1511  return ret;
1512 }
1513 
1514 static int v4l_s_parm(const struct v4l2_ioctl_ops *ops,
1515  struct file *file, void *fh, void *arg)
1516 {
1517  struct v4l2_streamparm *p = arg;
1518  int ret = check_fmt(file, p->type);
1519 
1520  return ret ? ret : ops->vidioc_s_parm(file, fh, p);
1521 }
1522 
1523 static int v4l_queryctrl(const struct v4l2_ioctl_ops *ops,
1524  struct file *file, void *fh, void *arg)
1525 {
1526  struct video_device *vfd = video_devdata(file);
1527  struct v4l2_queryctrl *p = arg;
1528  struct v4l2_fh *vfh =
1529  test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) ? fh : NULL;
1530 
1531  if (vfh && vfh->ctrl_handler)
1532  return v4l2_queryctrl(vfh->ctrl_handler, p);
1533  if (vfd->ctrl_handler)
1534  return v4l2_queryctrl(vfd->ctrl_handler, p);
1535  if (ops->vidioc_queryctrl)
1536  return ops->vidioc_queryctrl(file, fh, p);
1537  return -ENOTTY;
1538 }
1539 
1540 static int v4l_querymenu(const struct v4l2_ioctl_ops *ops,
1541  struct file *file, void *fh, void *arg)
1542 {
1543  struct video_device *vfd = video_devdata(file);
1544  struct v4l2_querymenu *p = arg;
1545  struct v4l2_fh *vfh =
1546  test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) ? fh : NULL;
1547 
1548  if (vfh && vfh->ctrl_handler)
1549  return v4l2_querymenu(vfh->ctrl_handler, p);
1550  if (vfd->ctrl_handler)
1551  return v4l2_querymenu(vfd->ctrl_handler, p);
1552  if (ops->vidioc_querymenu)
1553  return ops->vidioc_querymenu(file, fh, p);
1554  return -ENOTTY;
1555 }
1556 
1557 static int v4l_g_ctrl(const struct v4l2_ioctl_ops *ops,
1558  struct file *file, void *fh, void *arg)
1559 {
1560  struct video_device *vfd = video_devdata(file);
1561  struct v4l2_control *p = arg;
1562  struct v4l2_fh *vfh =
1563  test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) ? fh : NULL;
1564  struct v4l2_ext_controls ctrls;
1565  struct v4l2_ext_control ctrl;
1566 
1567  if (vfh && vfh->ctrl_handler)
1568  return v4l2_g_ctrl(vfh->ctrl_handler, p);
1569  if (vfd->ctrl_handler)
1570  return v4l2_g_ctrl(vfd->ctrl_handler, p);
1571  if (ops->vidioc_g_ctrl)
1572  return ops->vidioc_g_ctrl(file, fh, p);
1573  if (ops->vidioc_g_ext_ctrls == NULL)
1574  return -ENOTTY;
1575 
1576  ctrls.ctrl_class = V4L2_CTRL_ID2CLASS(p->id);
1577  ctrls.count = 1;
1578  ctrls.controls = &ctrl;
1579  ctrl.id = p->id;
1580  ctrl.value = p->value;
1581  if (check_ext_ctrls(&ctrls, 1)) {
1582  int ret = ops->vidioc_g_ext_ctrls(file, fh, &ctrls);
1583 
1584  if (ret == 0)
1585  p->value = ctrl.value;
1586  return ret;
1587  }
1588  return -EINVAL;
1589 }
1590 
1591 static int v4l_s_ctrl(const struct v4l2_ioctl_ops *ops,
1592  struct file *file, void *fh, void *arg)
1593 {
1594  struct video_device *vfd = video_devdata(file);
1595  struct v4l2_control *p = arg;
1596  struct v4l2_fh *vfh =
1597  test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) ? fh : NULL;
1598  struct v4l2_ext_controls ctrls;
1599  struct v4l2_ext_control ctrl;
1600 
1601  if (vfh && vfh->ctrl_handler)
1602  return v4l2_s_ctrl(vfh, vfh->ctrl_handler, p);
1603  if (vfd->ctrl_handler)
1604  return v4l2_s_ctrl(NULL, vfd->ctrl_handler, p);
1605  if (ops->vidioc_s_ctrl)
1606  return ops->vidioc_s_ctrl(file, fh, p);
1607  if (ops->vidioc_s_ext_ctrls == NULL)
1608  return -ENOTTY;
1609 
1610  ctrls.ctrl_class = V4L2_CTRL_ID2CLASS(p->id);
1611  ctrls.count = 1;
1612  ctrls.controls = &ctrl;
1613  ctrl.id = p->id;
1614  ctrl.value = p->value;
1615  if (check_ext_ctrls(&ctrls, 1))
1616  return ops->vidioc_s_ext_ctrls(file, fh, &ctrls);
1617  return -EINVAL;
1618 }
1619 
1620 static int v4l_g_ext_ctrls(const struct v4l2_ioctl_ops *ops,
1621  struct file *file, void *fh, void *arg)
1622 {
1623  struct video_device *vfd = video_devdata(file);
1624  struct v4l2_ext_controls *p = arg;
1625  struct v4l2_fh *vfh =
1626  test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) ? fh : NULL;
1627 
1628  p->error_idx = p->count;
1629  if (vfh && vfh->ctrl_handler)
1630  return v4l2_g_ext_ctrls(vfh->ctrl_handler, p);
1631  if (vfd->ctrl_handler)
1632  return v4l2_g_ext_ctrls(vfd->ctrl_handler, p);
1633  if (ops->vidioc_g_ext_ctrls == NULL)
1634  return -ENOTTY;
1635  return check_ext_ctrls(p, 0) ? ops->vidioc_g_ext_ctrls(file, fh, p) :
1636  -EINVAL;
1637 }
1638 
1639 static int v4l_s_ext_ctrls(const struct v4l2_ioctl_ops *ops,
1640  struct file *file, void *fh, void *arg)
1641 {
1642  struct video_device *vfd = video_devdata(file);
1643  struct v4l2_ext_controls *p = arg;
1644  struct v4l2_fh *vfh =
1645  test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) ? fh : NULL;
1646 
1647  p->error_idx = p->count;
1648  if (vfh && vfh->ctrl_handler)
1649  return v4l2_s_ext_ctrls(vfh, vfh->ctrl_handler, p);
1650  if (vfd->ctrl_handler)
1651  return v4l2_s_ext_ctrls(NULL, vfd->ctrl_handler, p);
1652  if (ops->vidioc_s_ext_ctrls == NULL)
1653  return -ENOTTY;
1654  return check_ext_ctrls(p, 0) ? ops->vidioc_s_ext_ctrls(file, fh, p) :
1655  -EINVAL;
1656 }
1657 
1658 static int v4l_try_ext_ctrls(const struct v4l2_ioctl_ops *ops,
1659  struct file *file, void *fh, void *arg)
1660 {
1661  struct video_device *vfd = video_devdata(file);
1662  struct v4l2_ext_controls *p = arg;
1663  struct v4l2_fh *vfh =
1664  test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags) ? fh : NULL;
1665 
1666  p->error_idx = p->count;
1667  if (vfh && vfh->ctrl_handler)
1668  return v4l2_try_ext_ctrls(vfh->ctrl_handler, p);
1669  if (vfd->ctrl_handler)
1670  return v4l2_try_ext_ctrls(vfd->ctrl_handler, p);
1671  if (ops->vidioc_try_ext_ctrls == NULL)
1672  return -ENOTTY;
1673  return check_ext_ctrls(p, 0) ? ops->vidioc_try_ext_ctrls(file, fh, p) :
1674  -EINVAL;
1675 }
1676 
1677 static int v4l_g_crop(const struct v4l2_ioctl_ops *ops,
1678  struct file *file, void *fh, void *arg)
1679 {
1680  struct v4l2_crop *p = arg;
1681  struct v4l2_selection s = {
1682  .type = p->type,
1683  };
1684  int ret;
1685 
1686  if (ops->vidioc_g_crop)
1687  return ops->vidioc_g_crop(file, fh, p);
1688  /* simulate capture crop using selection api */
1689 
1690  /* crop means compose for output devices */
1691  if (V4L2_TYPE_IS_OUTPUT(p->type))
1692  s.target = V4L2_SEL_TGT_COMPOSE_ACTIVE;
1693  else
1694  s.target = V4L2_SEL_TGT_CROP_ACTIVE;
1695 
1696  ret = ops->vidioc_g_selection(file, fh, &s);
1697 
1698  /* copying results to old structure on success */
1699  if (!ret)
1700  p->c = s.r;
1701  return ret;
1702 }
1703 
1704 static int v4l_s_crop(const struct v4l2_ioctl_ops *ops,
1705  struct file *file, void *fh, void *arg)
1706 {
1707  struct v4l2_crop *p = arg;
1708  struct v4l2_selection s = {
1709  .type = p->type,
1710  .r = p->c,
1711  };
1712 
1713  if (ops->vidioc_s_crop)
1714  return ops->vidioc_s_crop(file, fh, p);
1715  /* simulate capture crop using selection api */
1716 
1717  /* crop means compose for output devices */
1718  if (V4L2_TYPE_IS_OUTPUT(p->type))
1719  s.target = V4L2_SEL_TGT_COMPOSE_ACTIVE;
1720  else
1721  s.target = V4L2_SEL_TGT_CROP_ACTIVE;
1722 
1723  return ops->vidioc_s_selection(file, fh, &s);
1724 }
1725 
1726 static int v4l_cropcap(const struct v4l2_ioctl_ops *ops,
1727  struct file *file, void *fh, void *arg)
1728 {
1729  struct v4l2_cropcap *p = arg;
1730  struct v4l2_selection s = { .type = p->type };
1731  int ret;
1732 
1733  if (ops->vidioc_cropcap)
1734  return ops->vidioc_cropcap(file, fh, p);
1735 
1736  /* obtaining bounds */
1737  if (V4L2_TYPE_IS_OUTPUT(p->type))
1738  s.target = V4L2_SEL_TGT_COMPOSE_BOUNDS;
1739  else
1740  s.target = V4L2_SEL_TGT_CROP_BOUNDS;
1741 
1742  ret = ops->vidioc_g_selection(file, fh, &s);
1743  if (ret)
1744  return ret;
1745  p->bounds = s.r;
1746 
1747  /* obtaining defrect */
1748  if (V4L2_TYPE_IS_OUTPUT(p->type))
1749  s.target = V4L2_SEL_TGT_COMPOSE_DEFAULT;
1750  else
1751  s.target = V4L2_SEL_TGT_CROP_DEFAULT;
1752 
1753  ret = ops->vidioc_g_selection(file, fh, &s);
1754  if (ret)
1755  return ret;
1756  p->defrect = s.r;
1757 
1758  /* setting trivial pixelaspect */
1759  p->pixelaspect.numerator = 1;
1760  p->pixelaspect.denominator = 1;
1761  return 0;
1762 }
1763 
1764 static int v4l_log_status(const struct v4l2_ioctl_ops *ops,
1765  struct file *file, void *fh, void *arg)
1766 {
1767  struct video_device *vfd = video_devdata(file);
1768  int ret;
1769 
1770  if (vfd->v4l2_dev)
1771  pr_info("%s: ================= START STATUS =================\n",
1772  vfd->v4l2_dev->name);
1773  ret = ops->vidioc_log_status(file, fh);
1774  if (vfd->v4l2_dev)
1775  pr_info("%s: ================== END STATUS ==================\n",
1776  vfd->v4l2_dev->name);
1777  return ret;
1778 }
1779 
1780 static int v4l_dbg_g_register(const struct v4l2_ioctl_ops *ops,
1781  struct file *file, void *fh, void *arg)
1782 {
1783 #ifdef CONFIG_VIDEO_ADV_DEBUG
1784  struct v4l2_dbg_register *p = arg;
1785 
1786  if (!capable(CAP_SYS_ADMIN))
1787  return -EPERM;
1788  return ops->vidioc_g_register(file, fh, p);
1789 #else
1790  return -ENOTTY;
1791 #endif
1792 }
1793 
1794 static int v4l_dbg_s_register(const struct v4l2_ioctl_ops *ops,
1795  struct file *file, void *fh, void *arg)
1796 {
1797 #ifdef CONFIG_VIDEO_ADV_DEBUG
1798  struct v4l2_dbg_register *p = arg;
1799 
1800  if (!capable(CAP_SYS_ADMIN))
1801  return -EPERM;
1802  return ops->vidioc_s_register(file, fh, p);
1803 #else
1804  return -ENOTTY;
1805 #endif
1806 }
1807 
1808 static int v4l_dbg_g_chip_ident(const struct v4l2_ioctl_ops *ops,
1809  struct file *file, void *fh, void *arg)
1810 {
1811  struct v4l2_dbg_chip_ident *p = arg;
1812 
1813  p->ident = V4L2_IDENT_NONE;
1814  p->revision = 0;
1815  return ops->vidioc_g_chip_ident(file, fh, p);
1816 }
1817 
1818 static int v4l_dqevent(const struct v4l2_ioctl_ops *ops,
1819  struct file *file, void *fh, void *arg)
1820 {
1821  return v4l2_event_dequeue(fh, arg, file->f_flags & O_NONBLOCK);
1822 }
1823 
1824 static int v4l_subscribe_event(const struct v4l2_ioctl_ops *ops,
1825  struct file *file, void *fh, void *arg)
1826 {
1827  return ops->vidioc_subscribe_event(fh, arg);
1828 }
1829 
1830 static int v4l_unsubscribe_event(const struct v4l2_ioctl_ops *ops,
1831  struct file *file, void *fh, void *arg)
1832 {
1833  return ops->vidioc_unsubscribe_event(fh, arg);
1834 }
1835 
1836 static int v4l_g_sliced_vbi_cap(const struct v4l2_ioctl_ops *ops,
1837  struct file *file, void *fh, void *arg)
1838 {
1839  struct v4l2_sliced_vbi_cap *p = arg;
1840  int ret = check_fmt(file, p->type);
1841 
1842  if (ret)
1843  return ret;
1844 
1845  /* Clear up to type, everything after type is zeroed already */
1846  memset(p, 0, offsetof(struct v4l2_sliced_vbi_cap, type));
1847 
1848  return ops->vidioc_g_sliced_vbi_cap(file, fh, p);
1849 }
1850 
1851 static int v4l_enum_freq_bands(const struct v4l2_ioctl_ops *ops,
1852  struct file *file, void *fh, void *arg)
1853 {
1854  struct video_device *vfd = video_devdata(file);
1855  struct v4l2_frequency_band *p = arg;
1856  enum v4l2_tuner_type type;
1857  int err;
1858 
1859  type = (vfd->vfl_type == VFL_TYPE_RADIO) ?
1860  V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
1861 
1862  if (type != p->type)
1863  return -EINVAL;
1864  if (ops->vidioc_enum_freq_bands)
1865  return ops->vidioc_enum_freq_bands(file, fh, p);
1866  if (ops->vidioc_g_tuner) {
1867  struct v4l2_tuner t = {
1868  .index = p->tuner,
1869  .type = type,
1870  };
1871 
1872  if (p->index)
1873  return -EINVAL;
1874  err = ops->vidioc_g_tuner(file, fh, &t);
1875  if (err)
1876  return err;
1877  p->capability = t.capability | V4L2_TUNER_CAP_FREQ_BANDS;
1878  p->rangelow = t.rangelow;
1879  p->rangehigh = t.rangehigh;
1880  p->modulation = (type == V4L2_TUNER_RADIO) ?
1881  V4L2_BAND_MODULATION_FM : V4L2_BAND_MODULATION_VSB;
1882  return 0;
1883  }
1884  if (ops->vidioc_g_modulator) {
1885  struct v4l2_modulator m = {
1886  .index = p->tuner,
1887  };
1888 
1889  if (type != V4L2_TUNER_RADIO)
1890  return -EINVAL;
1891  if (p->index)
1892  return -EINVAL;
1893  err = ops->vidioc_g_modulator(file, fh, &m);
1894  if (err)
1895  return err;
1896  p->capability = m.capability | V4L2_TUNER_CAP_FREQ_BANDS;
1897  p->rangelow = m.rangelow;
1898  p->rangehigh = m.rangehigh;
1899  p->modulation = (type == V4L2_TUNER_RADIO) ?
1900  V4L2_BAND_MODULATION_FM : V4L2_BAND_MODULATION_VSB;
1901  return 0;
1902  }
1903  return -ENOTTY;
1904 }
1905 
1906 struct v4l2_ioctl_info {
1907  unsigned int ioctl;
1908  u32 flags;
1909  const char * const name;
1910  union {
1911  u32 offset;
1912  int (*func)(const struct v4l2_ioctl_ops *ops,
1913  struct file *file, void *fh, void *p);
1914  } u;
1915  void (*debug)(const void *arg, bool write_only);
1916 };
1917 
1918 /* This control needs a priority check */
1919 #define INFO_FL_PRIO (1 << 0)
1920 /* This control can be valid if the filehandle passes a control handler. */
1921 #define INFO_FL_CTRL (1 << 1)
1922 /* This is a standard ioctl, no need for special code */
1923 #define INFO_FL_STD (1 << 2)
1924 /* This is ioctl has its own function */
1925 #define INFO_FL_FUNC (1 << 3)
1926 /* Queuing ioctl */
1927 #define INFO_FL_QUEUE (1 << 4)
1928 /* Zero struct from after the field to the end */
1929 #define INFO_FL_CLEAR(v4l2_struct, field) \
1930  ((offsetof(struct v4l2_struct, field) + \
1931  sizeof(((struct v4l2_struct *)0)->field)) << 16)
1932 #define INFO_FL_CLEAR_MASK (_IOC_SIZEMASK << 16)
1933 
1934 #define IOCTL_INFO_STD(_ioctl, _vidioc, _debug, _flags) \
1935  [_IOC_NR(_ioctl)] = { \
1936  .ioctl = _ioctl, \
1937  .flags = _flags | INFO_FL_STD, \
1938  .name = #_ioctl, \
1939  .u.offset = offsetof(struct v4l2_ioctl_ops, _vidioc), \
1940  .debug = _debug, \
1941  }
1942 
1943 #define IOCTL_INFO_FNC(_ioctl, _func, _debug, _flags) \
1944  [_IOC_NR(_ioctl)] = { \
1945  .ioctl = _ioctl, \
1946  .flags = _flags | INFO_FL_FUNC, \
1947  .name = #_ioctl, \
1948  .u.func = _func, \
1949  .debug = _debug, \
1950  }
1951 
1952 static struct v4l2_ioctl_info v4l2_ioctls[] = {
1953  IOCTL_INFO_FNC(VIDIOC_QUERYCAP, v4l_querycap, v4l_print_querycap, 0),
1954  IOCTL_INFO_FNC(VIDIOC_ENUM_FMT, v4l_enum_fmt, v4l_print_fmtdesc, INFO_FL_CLEAR(v4l2_fmtdesc, type)),
1955  IOCTL_INFO_FNC(VIDIOC_G_FMT, v4l_g_fmt, v4l_print_format, INFO_FL_CLEAR(v4l2_format, type)),
1956  IOCTL_INFO_FNC(VIDIOC_S_FMT, v4l_s_fmt, v4l_print_format, INFO_FL_PRIO),
1957  IOCTL_INFO_FNC(VIDIOC_REQBUFS, v4l_reqbufs, v4l_print_requestbuffers, INFO_FL_PRIO | INFO_FL_QUEUE),
1958  IOCTL_INFO_FNC(VIDIOC_QUERYBUF, v4l_querybuf, v4l_print_buffer, INFO_FL_QUEUE | INFO_FL_CLEAR(v4l2_buffer, length)),
1959  IOCTL_INFO_STD(VIDIOC_G_FBUF, vidioc_g_fbuf, v4l_print_framebuffer, 0),
1960  IOCTL_INFO_STD(VIDIOC_S_FBUF, vidioc_s_fbuf, v4l_print_framebuffer, INFO_FL_PRIO),
1961  IOCTL_INFO_FNC(VIDIOC_OVERLAY, v4l_overlay, v4l_print_u32, INFO_FL_PRIO),
1962  IOCTL_INFO_FNC(VIDIOC_QBUF, v4l_qbuf, v4l_print_buffer, INFO_FL_QUEUE),
1963  IOCTL_INFO_FNC(VIDIOC_DQBUF, v4l_dqbuf, v4l_print_buffer, INFO_FL_QUEUE),
1964  IOCTL_INFO_FNC(VIDIOC_STREAMON, v4l_streamon, v4l_print_buftype, INFO_FL_PRIO | INFO_FL_QUEUE),
1965  IOCTL_INFO_FNC(VIDIOC_STREAMOFF, v4l_streamoff, v4l_print_buftype, INFO_FL_PRIO | INFO_FL_QUEUE),
1966  IOCTL_INFO_FNC(VIDIOC_G_PARM, v4l_g_parm, v4l_print_streamparm, INFO_FL_CLEAR(v4l2_streamparm, type)),
1967  IOCTL_INFO_FNC(VIDIOC_S_PARM, v4l_s_parm, v4l_print_streamparm, INFO_FL_PRIO),
1968  IOCTL_INFO_FNC(VIDIOC_G_STD, v4l_g_std, v4l_print_std, 0),
1969  IOCTL_INFO_FNC(VIDIOC_S_STD, v4l_s_std, v4l_print_std, INFO_FL_PRIO),
1970  IOCTL_INFO_FNC(VIDIOC_ENUMSTD, v4l_enumstd, v4l_print_standard, INFO_FL_CLEAR(v4l2_standard, index)),
1971  IOCTL_INFO_FNC(VIDIOC_ENUMINPUT, v4l_enuminput, v4l_print_enuminput, INFO_FL_CLEAR(v4l2_input, index)),
1972  IOCTL_INFO_FNC(VIDIOC_G_CTRL, v4l_g_ctrl, v4l_print_control, INFO_FL_CTRL | INFO_FL_CLEAR(v4l2_control, id)),
1973  IOCTL_INFO_FNC(VIDIOC_S_CTRL, v4l_s_ctrl, v4l_print_control, INFO_FL_PRIO | INFO_FL_CTRL),
1974  IOCTL_INFO_FNC(VIDIOC_G_TUNER, v4l_g_tuner, v4l_print_tuner, INFO_FL_CLEAR(v4l2_tuner, index)),
1975  IOCTL_INFO_FNC(VIDIOC_S_TUNER, v4l_s_tuner, v4l_print_tuner, INFO_FL_PRIO),
1976  IOCTL_INFO_STD(VIDIOC_G_AUDIO, vidioc_g_audio, v4l_print_audio, 0),
1977  IOCTL_INFO_STD(VIDIOC_S_AUDIO, vidioc_s_audio, v4l_print_audio, INFO_FL_PRIO),
1978  IOCTL_INFO_FNC(VIDIOC_QUERYCTRL, v4l_queryctrl, v4l_print_queryctrl, INFO_FL_CTRL | INFO_FL_CLEAR(v4l2_queryctrl, id)),
1979  IOCTL_INFO_FNC(VIDIOC_QUERYMENU, v4l_querymenu, v4l_print_querymenu, INFO_FL_CTRL | INFO_FL_CLEAR(v4l2_querymenu, index)),
1980  IOCTL_INFO_STD(VIDIOC_G_INPUT, vidioc_g_input, v4l_print_u32, 0),
1981  IOCTL_INFO_FNC(VIDIOC_S_INPUT, v4l_s_input, v4l_print_u32, INFO_FL_PRIO),
1982  IOCTL_INFO_STD(VIDIOC_G_OUTPUT, vidioc_g_output, v4l_print_u32, 0),
1983  IOCTL_INFO_FNC(VIDIOC_S_OUTPUT, v4l_s_output, v4l_print_u32, INFO_FL_PRIO),
1984  IOCTL_INFO_FNC(VIDIOC_ENUMOUTPUT, v4l_enumoutput, v4l_print_enumoutput, INFO_FL_CLEAR(v4l2_output, index)),
1985  IOCTL_INFO_STD(VIDIOC_G_AUDOUT, vidioc_g_audout, v4l_print_audioout, 0),
1986  IOCTL_INFO_STD(VIDIOC_S_AUDOUT, vidioc_s_audout, v4l_print_audioout, INFO_FL_PRIO),
1987  IOCTL_INFO_FNC(VIDIOC_G_MODULATOR, v4l_g_modulator, v4l_print_modulator, INFO_FL_CLEAR(v4l2_modulator, index)),
1988  IOCTL_INFO_STD(VIDIOC_S_MODULATOR, vidioc_s_modulator, v4l_print_modulator, INFO_FL_PRIO),
1989  IOCTL_INFO_FNC(VIDIOC_G_FREQUENCY, v4l_g_frequency, v4l_print_frequency, INFO_FL_CLEAR(v4l2_frequency, tuner)),
1990  IOCTL_INFO_FNC(VIDIOC_S_FREQUENCY, v4l_s_frequency, v4l_print_frequency, INFO_FL_PRIO),
1991  IOCTL_INFO_FNC(VIDIOC_CROPCAP, v4l_cropcap, v4l_print_cropcap, INFO_FL_CLEAR(v4l2_cropcap, type)),
1992  IOCTL_INFO_FNC(VIDIOC_G_CROP, v4l_g_crop, v4l_print_crop, INFO_FL_CLEAR(v4l2_crop, type)),
1993  IOCTL_INFO_FNC(VIDIOC_S_CROP, v4l_s_crop, v4l_print_crop, INFO_FL_PRIO),
1994  IOCTL_INFO_STD(VIDIOC_G_SELECTION, vidioc_g_selection, v4l_print_selection, 0),
1995  IOCTL_INFO_STD(VIDIOC_S_SELECTION, vidioc_s_selection, v4l_print_selection, INFO_FL_PRIO),
1996  IOCTL_INFO_STD(VIDIOC_G_JPEGCOMP, vidioc_g_jpegcomp, v4l_print_jpegcompression, 0),
1997  IOCTL_INFO_STD(VIDIOC_S_JPEGCOMP, vidioc_s_jpegcomp, v4l_print_jpegcompression, INFO_FL_PRIO),
1998  IOCTL_INFO_FNC(VIDIOC_QUERYSTD, v4l_querystd, v4l_print_std, 0),
1999  IOCTL_INFO_FNC(VIDIOC_TRY_FMT, v4l_try_fmt, v4l_print_format, 0),
2000  IOCTL_INFO_STD(VIDIOC_ENUMAUDIO, vidioc_enumaudio, v4l_print_audio, INFO_FL_CLEAR(v4l2_audio, index)),
2001  IOCTL_INFO_STD(VIDIOC_ENUMAUDOUT, vidioc_enumaudout, v4l_print_audioout, INFO_FL_CLEAR(v4l2_audioout, index)),
2002  IOCTL_INFO_FNC(VIDIOC_G_PRIORITY, v4l_g_priority, v4l_print_u32, 0),
2003  IOCTL_INFO_FNC(VIDIOC_S_PRIORITY, v4l_s_priority, v4l_print_u32, INFO_FL_PRIO),
2004  IOCTL_INFO_FNC(VIDIOC_G_SLICED_VBI_CAP, v4l_g_sliced_vbi_cap, v4l_print_sliced_vbi_cap, INFO_FL_CLEAR(v4l2_sliced_vbi_cap, type)),
2005  IOCTL_INFO_FNC(VIDIOC_LOG_STATUS, v4l_log_status, v4l_print_newline, 0),
2006  IOCTL_INFO_FNC(VIDIOC_G_EXT_CTRLS, v4l_g_ext_ctrls, v4l_print_ext_controls, INFO_FL_CTRL),
2007  IOCTL_INFO_FNC(VIDIOC_S_EXT_CTRLS, v4l_s_ext_ctrls, v4l_print_ext_controls, INFO_FL_PRIO | INFO_FL_CTRL),
2008  IOCTL_INFO_FNC(VIDIOC_TRY_EXT_CTRLS, v4l_try_ext_ctrls, v4l_print_ext_controls, INFO_FL_CTRL),
2009  IOCTL_INFO_STD(VIDIOC_ENUM_FRAMESIZES, vidioc_enum_framesizes, v4l_print_frmsizeenum, INFO_FL_CLEAR(v4l2_frmsizeenum, pixel_format)),
2010  IOCTL_INFO_STD(VIDIOC_ENUM_FRAMEINTERVALS, vidioc_enum_frameintervals, v4l_print_frmivalenum, INFO_FL_CLEAR(v4l2_frmivalenum, height)),
2011  IOCTL_INFO_STD(VIDIOC_G_ENC_INDEX, vidioc_g_enc_index, v4l_print_enc_idx, 0),
2012  IOCTL_INFO_STD(VIDIOC_ENCODER_CMD, vidioc_encoder_cmd, v4l_print_encoder_cmd, INFO_FL_PRIO | INFO_FL_CLEAR(v4l2_encoder_cmd, flags)),
2013  IOCTL_INFO_STD(VIDIOC_TRY_ENCODER_CMD, vidioc_try_encoder_cmd, v4l_print_encoder_cmd, INFO_FL_CLEAR(v4l2_encoder_cmd, flags)),
2014  IOCTL_INFO_STD(VIDIOC_DECODER_CMD, vidioc_decoder_cmd, v4l_print_decoder_cmd, INFO_FL_PRIO),
2015  IOCTL_INFO_STD(VIDIOC_TRY_DECODER_CMD, vidioc_try_decoder_cmd, v4l_print_decoder_cmd, 0),
2016  IOCTL_INFO_FNC(VIDIOC_DBG_S_REGISTER, v4l_dbg_s_register, v4l_print_dbg_register, 0),
2017  IOCTL_INFO_FNC(VIDIOC_DBG_G_REGISTER, v4l_dbg_g_register, v4l_print_dbg_register, 0),
2018  IOCTL_INFO_FNC(VIDIOC_DBG_G_CHIP_IDENT, v4l_dbg_g_chip_ident, v4l_print_dbg_chip_ident, 0),
2019  IOCTL_INFO_FNC(VIDIOC_S_HW_FREQ_SEEK, v4l_s_hw_freq_seek, v4l_print_hw_freq_seek, INFO_FL_PRIO),
2020  IOCTL_INFO_STD(VIDIOC_ENUM_DV_PRESETS, vidioc_enum_dv_presets, v4l_print_dv_enum_presets, 0),
2021  IOCTL_INFO_STD(VIDIOC_S_DV_PRESET, vidioc_s_dv_preset, v4l_print_dv_preset, INFO_FL_PRIO),
2022  IOCTL_INFO_STD(VIDIOC_G_DV_PRESET, vidioc_g_dv_preset, v4l_print_dv_preset, 0),
2023  IOCTL_INFO_STD(VIDIOC_QUERY_DV_PRESET, vidioc_query_dv_preset, v4l_print_dv_preset, 0),
2024  IOCTL_INFO_STD(VIDIOC_S_DV_TIMINGS, vidioc_s_dv_timings, v4l_print_dv_timings, INFO_FL_PRIO),
2025  IOCTL_INFO_STD(VIDIOC_G_DV_TIMINGS, vidioc_g_dv_timings, v4l_print_dv_timings, 0),
2026  IOCTL_INFO_FNC(VIDIOC_DQEVENT, v4l_dqevent, v4l_print_event, 0),
2027  IOCTL_INFO_FNC(VIDIOC_SUBSCRIBE_EVENT, v4l_subscribe_event, v4l_print_event_subscription, 0),
2028  IOCTL_INFO_FNC(VIDIOC_UNSUBSCRIBE_EVENT, v4l_unsubscribe_event, v4l_print_event_subscription, 0),
2029  IOCTL_INFO_FNC(VIDIOC_CREATE_BUFS, v4l_create_bufs, v4l_print_create_buffers, INFO_FL_PRIO | INFO_FL_QUEUE),
2030  IOCTL_INFO_FNC(VIDIOC_PREPARE_BUF, v4l_prepare_buf, v4l_print_buffer, INFO_FL_QUEUE),
2031  IOCTL_INFO_STD(VIDIOC_ENUM_DV_TIMINGS, vidioc_enum_dv_timings, v4l_print_enum_dv_timings, 0),
2032  IOCTL_INFO_STD(VIDIOC_QUERY_DV_TIMINGS, vidioc_query_dv_timings, v4l_print_dv_timings, 0),
2033  IOCTL_INFO_STD(VIDIOC_DV_TIMINGS_CAP, vidioc_dv_timings_cap, v4l_print_dv_timings_cap, INFO_FL_CLEAR(v4l2_dv_timings_cap, type)),
2034  IOCTL_INFO_FNC(VIDIOC_ENUM_FREQ_BANDS, v4l_enum_freq_bands, v4l_print_freq_band, 0),
2035 };
2036 #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
2037 
2038 bool v4l2_is_known_ioctl(unsigned int cmd)
2039 {
2040  if (_IOC_NR(cmd) >= V4L2_IOCTLS)
2041  return false;
2042  return v4l2_ioctls[_IOC_NR(cmd)].ioctl == cmd;
2043 }
2044 
2045 struct mutex *v4l2_ioctl_get_lock(struct video_device *vdev, unsigned cmd)
2046 {
2047  if (_IOC_NR(cmd) >= V4L2_IOCTLS)
2048  return vdev->lock;
2049  if (test_bit(_IOC_NR(cmd), vdev->disable_locking))
2050  return NULL;
2051  if (vdev->queue && vdev->queue->lock &&
2052  (v4l2_ioctls[_IOC_NR(cmd)].flags & INFO_FL_QUEUE))
2053  return vdev->queue->lock;
2054  return vdev->lock;
2055 }
2056 
2057 /* Common ioctl debug function. This function can be used by
2058  external ioctl messages as well as internal V4L ioctl */
2059 void v4l_printk_ioctl(const char *prefix, unsigned int cmd)
2060 {
2061  const char *dir, *type;
2062 
2063  if (prefix)
2064  printk(KERN_DEBUG "%s: ", prefix);
2065 
2066  switch (_IOC_TYPE(cmd)) {
2067  case 'd':
2068  type = "v4l2_int";
2069  break;
2070  case 'V':
2071  if (_IOC_NR(cmd) >= V4L2_IOCTLS) {
2072  type = "v4l2";
2073  break;
2074  }
2075  pr_cont("%s", v4l2_ioctls[_IOC_NR(cmd)].name);
2076  return;
2077  default:
2078  type = "unknown";
2079  break;
2080  }
2081 
2082  switch (_IOC_DIR(cmd)) {
2083  case _IOC_NONE: dir = "--"; break;
2084  case _IOC_READ: dir = "r-"; break;
2085  case _IOC_WRITE: dir = "-w"; break;
2086  case _IOC_READ | _IOC_WRITE: dir = "rw"; break;
2087  default: dir = "*ERR*"; break;
2088  }
2089  pr_cont("%s ioctl '%c', dir=%s, #%d (0x%08x)",
2090  type, _IOC_TYPE(cmd), dir, _IOC_NR(cmd), cmd);
2091 }
2092 EXPORT_SYMBOL(v4l_printk_ioctl);
2093 
2094 static long __video_do_ioctl(struct file *file,
2095  unsigned int cmd, void *arg)
2096 {
2097  struct video_device *vfd = video_devdata(file);
2098  const struct v4l2_ioctl_ops *ops = vfd->ioctl_ops;
2099  bool write_only = false;
2100  struct v4l2_ioctl_info default_info;
2101  const struct v4l2_ioctl_info *info;
2102  void *fh = file->private_data;
2103  struct v4l2_fh *vfh = NULL;
2104  int use_fh_prio = 0;
2105  int debug = vfd->debug;
2106  long ret = -ENOTTY;
2107 
2108  if (ops == NULL) {
2109  pr_warn("%s: has no ioctl_ops.\n",
2110  video_device_node_name(vfd));
2111  return ret;
2112  }
2113 
2114  if (test_bit(V4L2_FL_USES_V4L2_FH, &vfd->flags)) {
2115  vfh = file->private_data;
2116  use_fh_prio = test_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags);
2117  }
2118 
2119  if (v4l2_is_known_ioctl(cmd)) {
2120  info = &v4l2_ioctls[_IOC_NR(cmd)];
2121 
2122  if (!test_bit(_IOC_NR(cmd), vfd->valid_ioctls) &&
2123  !((info->flags & INFO_FL_CTRL) && vfh && vfh->ctrl_handler))
2124  goto done;
2125 
2126  if (use_fh_prio && (info->flags & INFO_FL_PRIO)) {
2127  ret = v4l2_prio_check(vfd->prio, vfh->prio);
2128  if (ret)
2129  goto done;
2130  }
2131  } else {
2132  default_info.ioctl = cmd;
2133  default_info.flags = 0;
2134  default_info.debug = v4l_print_default;
2135  info = &default_info;
2136  }
2137 
2138  write_only = _IOC_DIR(cmd) == _IOC_WRITE;
2139  if (write_only && debug > V4L2_DEBUG_IOCTL) {
2140  v4l_printk_ioctl(video_device_node_name(vfd), cmd);
2141  pr_cont(": ");
2142  info->debug(arg, write_only);
2143  }
2144  if (info->flags & INFO_FL_STD) {
2145  typedef int (*vidioc_op)(struct file *file, void *fh, void *p);
2146  const void *p = vfd->ioctl_ops;
2147  const vidioc_op *vidioc = p + info->u.offset;
2148 
2149  ret = (*vidioc)(file, fh, arg);
2150  } else if (info->flags & INFO_FL_FUNC) {
2151  ret = info->u.func(ops, file, fh, arg);
2152  } else if (!ops->vidioc_default) {
2153  ret = -ENOTTY;
2154  } else {
2155  ret = ops->vidioc_default(file, fh,
2156  use_fh_prio ? v4l2_prio_check(vfd->prio, vfh->prio) >= 0 : 0,
2157  cmd, arg);
2158  }
2159 
2160 done:
2161  if (debug) {
2162  if (write_only && debug > V4L2_DEBUG_IOCTL) {
2163  if (ret < 0)
2164  printk(KERN_DEBUG "%s: error %ld\n",
2165  video_device_node_name(vfd), ret);
2166  return ret;
2167  }
2168  v4l_printk_ioctl(video_device_node_name(vfd), cmd);
2169  if (ret < 0)
2170  pr_cont(": error %ld\n", ret);
2171  else if (debug == V4L2_DEBUG_IOCTL)
2172  pr_cont("\n");
2173  else if (_IOC_DIR(cmd) == _IOC_NONE)
2174  info->debug(arg, write_only);
2175  else {
2176  pr_cont(": ");
2177  info->debug(arg, write_only);
2178  }
2179  }
2180 
2181  return ret;
2182 }
2183 
2184 static int check_array_args(unsigned int cmd, void *parg, size_t *array_size,
2185  void * __user *user_ptr, void ***kernel_ptr)
2186 {
2187  int ret = 0;
2188 
2189  switch (cmd) {
2190  case VIDIOC_PREPARE_BUF:
2191  case VIDIOC_QUERYBUF:
2192  case VIDIOC_QBUF:
2193  case VIDIOC_DQBUF: {
2194  struct v4l2_buffer *buf = parg;
2195 
2196  if (V4L2_TYPE_IS_MULTIPLANAR(buf->type) && buf->length > 0) {
2197  if (buf->length > VIDEO_MAX_PLANES) {
2198  ret = -EINVAL;
2199  break;
2200  }
2201  *user_ptr = (void __user *)buf->m.planes;
2202  *kernel_ptr = (void *)&buf->m.planes;
2203  *array_size = sizeof(struct v4l2_plane) * buf->length;
2204  ret = 1;
2205  }
2206  break;
2207  }
2208 
2209  case VIDIOC_SUBDEV_G_EDID:
2210  case VIDIOC_SUBDEV_S_EDID: {
2211  struct v4l2_subdev_edid *edid = parg;
2212 
2213  if (edid->blocks) {
2214  if (edid->blocks > 256) {
2215  ret = -EINVAL;
2216  break;
2217  }
2218  *user_ptr = (void __user *)edid->edid;
2219  *kernel_ptr = (void *)&edid->edid;
2220  *array_size = edid->blocks * 128;
2221  ret = 1;
2222  }
2223  break;
2224  }
2225 
2226  case VIDIOC_S_EXT_CTRLS:
2227  case VIDIOC_G_EXT_CTRLS:
2228  case VIDIOC_TRY_EXT_CTRLS: {
2229  struct v4l2_ext_controls *ctrls = parg;
2230 
2231  if (ctrls->count != 0) {
2232  if (ctrls->count > V4L2_CID_MAX_CTRLS) {
2233  ret = -EINVAL;
2234  break;
2235  }
2236  *user_ptr = (void __user *)ctrls->controls;
2237  *kernel_ptr = (void *)&ctrls->controls;
2238  *array_size = sizeof(struct v4l2_ext_control)
2239  * ctrls->count;
2240  ret = 1;
2241  }
2242  break;
2243  }
2244  }
2245 
2246  return ret;
2247 }
2248 
2249 long
2250 video_usercopy(struct file *file, unsigned int cmd, unsigned long arg,
2251  v4l2_kioctl func)
2252 {
2253  char sbuf[128];
2254  void *mbuf = NULL;
2255  void *parg = (void *)arg;
2256  long err = -EINVAL;
2257  bool has_array_args;
2258  size_t array_size = 0;
2259  void __user *user_ptr = NULL;
2260  void **kernel_ptr = NULL;
2261 
2262  /* Copy arguments into temp kernel buffer */
2263  if (_IOC_DIR(cmd) != _IOC_NONE) {
2264  if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
2265  parg = sbuf;
2266  } else {
2267  /* too big to allocate from stack */
2268  mbuf = kmalloc(_IOC_SIZE(cmd), GFP_KERNEL);
2269  if (NULL == mbuf)
2270  return -ENOMEM;
2271  parg = mbuf;
2272  }
2273 
2274  err = -EFAULT;
2275  if (_IOC_DIR(cmd) & _IOC_WRITE) {
2276  unsigned int n = _IOC_SIZE(cmd);
2277 
2278  /*
2279  * In some cases, only a few fields are used as input,
2280  * i.e. when the app sets "index" and then the driver
2281  * fills in the rest of the structure for the thing
2282  * with that index. We only need to copy up the first
2283  * non-input field.
2284  */
2285  if (v4l2_is_known_ioctl(cmd)) {
2286  u32 flags = v4l2_ioctls[_IOC_NR(cmd)].flags;
2287  if (flags & INFO_FL_CLEAR_MASK)
2288  n = (flags & INFO_FL_CLEAR_MASK) >> 16;
2289  }
2290 
2291  if (copy_from_user(parg, (void __user *)arg, n))
2292  goto out;
2293 
2294  /* zero out anything we don't copy from userspace */
2295  if (n < _IOC_SIZE(cmd))
2296  memset((u8 *)parg + n, 0, _IOC_SIZE(cmd) - n);
2297  } else {
2298  /* read-only ioctl */
2299  memset(parg, 0, _IOC_SIZE(cmd));
2300  }
2301  }
2302 
2303  err = check_array_args(cmd, parg, &array_size, &user_ptr, &kernel_ptr);
2304  if (err < 0)
2305  goto out;
2306  has_array_args = err;
2307 
2308  if (has_array_args) {
2309  /*
2310  * When adding new types of array args, make sure that the
2311  * parent argument to ioctl (which contains the pointer to the
2312  * array) fits into sbuf (so that mbuf will still remain
2313  * unused up to here).
2314  */
2315  mbuf = kmalloc(array_size, GFP_KERNEL);
2316  err = -ENOMEM;
2317  if (NULL == mbuf)
2318  goto out_array_args;
2319  err = -EFAULT;
2320  if (copy_from_user(mbuf, user_ptr, array_size))
2321  goto out_array_args;
2322  *kernel_ptr = mbuf;
2323  }
2324 
2325  /* Handles IOCTL */
2326  err = func(file, cmd, parg);
2327  if (err == -ENOIOCTLCMD)
2328  err = -ENOTTY;
2329 
2330  if (has_array_args) {
2331  *kernel_ptr = user_ptr;
2332  if (copy_to_user(user_ptr, mbuf, array_size))
2333  err = -EFAULT;
2334  goto out_array_args;
2335  }
2336  /* VIDIOC_QUERY_DV_TIMINGS can return an error, but still have valid
2337  results that must be returned. */
2338  if (err < 0 && cmd != VIDIOC_QUERY_DV_TIMINGS)
2339  goto out;
2340 
2341 out_array_args:
2342  /* Copy results into user buffer */
2343  switch (_IOC_DIR(cmd)) {
2344  case _IOC_READ:
2345  case (_IOC_WRITE | _IOC_READ):
2346  if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
2347  err = -EFAULT;
2348  break;
2349  }
2350 
2351 out:
2352  kfree(mbuf);
2353  return err;
2354 }
2355 EXPORT_SYMBOL(video_usercopy);
2356 
2357 long video_ioctl2(struct file *file,
2358  unsigned int cmd, unsigned long arg)
2359 {
2360  return video_usercopy(file, cmd, arg, __video_do_ioctl);
2361 }
2362 EXPORT_SYMBOL(video_ioctl2);
Generated on Thu Jan 10 2013 13:52:56 for Linux Kernel by   doxygen 1.8.2