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