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