?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ia64/kvm: compilation fix. export account_system_vtime.
[pv_ops_mirror.git] / drivers / media / video / videodev.c
blob31e8af0ba2785e105e60587b8153602b948f55eb
1 /*
2 * Video capture interface for Linux version 2
3 *
4 * A generic video device interface for the LINUX operating system
5 * using a set of device structures/vectors for low level operations.
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
11 *
12 * Authors: Alan Cox, <alan@redhat.com> (version 1)
13 * Mauro Carvalho Chehab <mchehab@infradead.org> (version 2)
14 *
15 * Fixes: 20000516 Claudio Matsuoka <claudio@conectiva.com>
16 * - Added procfs support
17 */
18
19 #define dbgarg(cmd, fmt, arg...) \
20 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) { \
21 printk(KERN_DEBUG "%s: ", vfd->name); \
22 v4l_printk_ioctl(cmd); \
23 printk(" " fmt, ## arg); \
24 }
25
26 #define dbgarg2(fmt, arg...) \
27 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) \
28 printk(KERN_DEBUG "%s: " fmt, vfd->name, ## arg);
29
30 #include <linux/module.h>
31 #include <linux/types.h>
32 #include <linux/kernel.h>
33 #include <linux/mm.h>
34 #include <linux/string.h>
35 #include <linux/errno.h>
36 #include <linux/init.h>
37 #include <linux/kmod.h>
38 #include <linux/slab.h>
39 #include <asm/uaccess.h>
40 #include <asm/system.h>
41
42 #define __OLD_VIDIOC_ /* To allow fixing old calls*/
43 #include <linux/videodev2.h>
44
45 #ifdef CONFIG_VIDEO_V4L1
46 #include <linux/videodev.h>
47 #endif
48 #include <media/v4l2-common.h>
49 #include <linux/video_decoder.h>
50
51 #define VIDEO_NUM_DEVICES 256
52 #define VIDEO_NAME "video4linux"
53
54 /* video4linux standard ID conversion to standard name
55 */
56 char *v4l2_norm_to_name(v4l2_std_id id)
57 {
58 char *name;
59 u32 myid = id;
60
61 /* HACK: ppc32 architecture doesn't have __ucmpdi2 function to handle
62 64 bit comparations. So, on that architecture, with some gcc
63 variants, compilation fails. Currently, the max value is 30bit wide.
64 */
65 BUG_ON(myid != id);
66
67 switch (myid) {
68 case V4L2_STD_PAL:
69 name = "PAL";
70 break;
71 case V4L2_STD_PAL_BG:
72 name = "PAL-BG";
73 break;
74 case V4L2_STD_PAL_DK:
75 name = "PAL-DK";
76 break;
77 case V4L2_STD_PAL_B:
78 name = "PAL-B";
79 break;
80 case V4L2_STD_PAL_B1:
81 name = "PAL-B1";
82 break;
83 case V4L2_STD_PAL_G:
84 name = "PAL-G";
85 break;
86 case V4L2_STD_PAL_H:
87 name = "PAL-H";
88 break;
89 case V4L2_STD_PAL_I:
90 name = "PAL-I";
91 break;
92 case V4L2_STD_PAL_D:
93 name = "PAL-D";
94 break;
95 case V4L2_STD_PAL_D1:
96 name = "PAL-D1";
97 break;
98 case V4L2_STD_PAL_K:
99 name = "PAL-K";
100 break;
101 case V4L2_STD_PAL_M:
102 name = "PAL-M";
103 break;
104 case V4L2_STD_PAL_N:
105 name = "PAL-N";
106 break;
107 case V4L2_STD_PAL_Nc:
108 name = "PAL-Nc";
109 break;
110 case V4L2_STD_PAL_60:
111 name = "PAL-60";
112 break;
113 case V4L2_STD_NTSC:
114 name = "NTSC";
115 break;
116 case V4L2_STD_NTSC_M:
117 name = "NTSC-M";
118 break;
119 case V4L2_STD_NTSC_M_JP:
120 name = "NTSC-M-JP";
121 break;
122 case V4L2_STD_NTSC_443:
123 name = "NTSC-443";
124 break;
125 case V4L2_STD_NTSC_M_KR:
126 name = "NTSC-M-KR";
127 break;
128 case V4L2_STD_SECAM:
129 name = "SECAM";
130 break;
131 case V4L2_STD_SECAM_DK:
132 name = "SECAM-DK";
133 break;
134 case V4L2_STD_SECAM_B:
135 name = "SECAM-B";
136 break;
137 case V4L2_STD_SECAM_D:
138 name = "SECAM-D";
139 break;
140 case V4L2_STD_SECAM_G:
141 name = "SECAM-G";
142 break;
143 case V4L2_STD_SECAM_H:
144 name = "SECAM-H";
145 break;
146 case V4L2_STD_SECAM_K:
147 name = "SECAM-K";
148 break;
149 case V4L2_STD_SECAM_K1:
150 name = "SECAM-K1";
151 break;
152 case V4L2_STD_SECAM_L:
153 name = "SECAM-L";
154 break;
155 case V4L2_STD_SECAM_LC:
156 name = "SECAM-LC";
157 break;
158 default:
159 name = "Unknown";
160 break;
161 }
162
163 return name;
164 }
165 EXPORT_SYMBOL(v4l2_norm_to_name);
166
167 /* Fill in the fields of a v4l2_standard structure according to the
168 'id' and 'transmission' parameters. Returns negative on error. */
169 int v4l2_video_std_construct(struct v4l2_standard *vs,
170 int id, char *name)
171 {
172 u32 index = vs->index;
173
174 memset(vs, 0, sizeof(struct v4l2_standard));
175 vs->index = index;
176 vs->id = id;
177 if (id & V4L2_STD_525_60) {
178 vs->frameperiod.numerator = 1001;
179 vs->frameperiod.denominator = 30000;
180 vs->framelines = 525;
181 } else {
182 vs->frameperiod.numerator = 1;
183 vs->frameperiod.denominator = 25;
184 vs->framelines = 625;
185 }
186 strlcpy(vs->name, name, sizeof(vs->name));
187 return 0;
188 }
189 EXPORT_SYMBOL(v4l2_video_std_construct);
190
191 /* ----------------------------------------------------------------- */
192 /* some arrays for pretty-printing debug messages of enum types */
193
194 char *v4l2_field_names[] = {
195 [V4L2_FIELD_ANY] = "any",
196 [V4L2_FIELD_NONE] = "none",
197 [V4L2_FIELD_TOP] = "top",
198 [V4L2_FIELD_BOTTOM] = "bottom",
199 [V4L2_FIELD_INTERLACED] = "interlaced",
200 [V4L2_FIELD_SEQ_TB] = "seq-tb",
201 [V4L2_FIELD_SEQ_BT] = "seq-bt",
202 [V4L2_FIELD_ALTERNATE] = "alternate",
203 [V4L2_FIELD_INTERLACED_TB] = "interlaced-tb",
204 [V4L2_FIELD_INTERLACED_BT] = "interlaced-bt",
205 };
206 EXPORT_SYMBOL(v4l2_field_names);
207
208 char *v4l2_type_names[] = {
209 [V4L2_BUF_TYPE_VIDEO_CAPTURE] = "video-cap",
210 [V4L2_BUF_TYPE_VIDEO_OVERLAY] = "video-over",
211 [V4L2_BUF_TYPE_VIDEO_OUTPUT] = "video-out",
212 [V4L2_BUF_TYPE_VBI_CAPTURE] = "vbi-cap",
213 [V4L2_BUF_TYPE_VBI_OUTPUT] = "vbi-out",
214 [V4L2_BUF_TYPE_SLICED_VBI_CAPTURE] = "sliced-vbi-cap",
215 [V4L2_BUF_TYPE_SLICED_VBI_OUTPUT] = "sliced-vbi-out",
216 [V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY] = "video-out-over",
217 };
218 EXPORT_SYMBOL(v4l2_type_names);
219
220 static char *v4l2_memory_names[] = {
221 [V4L2_MEMORY_MMAP] = "mmap",
222 [V4L2_MEMORY_USERPTR] = "userptr",
223 [V4L2_MEMORY_OVERLAY] = "overlay",
224 };
225
226 #define prt_names(a, arr) ((((a) >= 0) && ((a) < ARRAY_SIZE(arr))) ? \
227 arr[a] : "unknown")
228
229 /* ------------------------------------------------------------------ */
230 /* debug help functions */
231
232 #ifdef CONFIG_VIDEO_V4L1_COMPAT
233 static const char *v4l1_ioctls[] = {
234 [_IOC_NR(VIDIOCGCAP)] = "VIDIOCGCAP",
235 [_IOC_NR(VIDIOCGCHAN)] = "VIDIOCGCHAN",
236 [_IOC_NR(VIDIOCSCHAN)] = "VIDIOCSCHAN",
237 [_IOC_NR(VIDIOCGTUNER)] = "VIDIOCGTUNER",
238 [_IOC_NR(VIDIOCSTUNER)] = "VIDIOCSTUNER",
239 [_IOC_NR(VIDIOCGPICT)] = "VIDIOCGPICT",
240 [_IOC_NR(VIDIOCSPICT)] = "VIDIOCSPICT",
241 [_IOC_NR(VIDIOCCAPTURE)] = "VIDIOCCAPTURE",
242 [_IOC_NR(VIDIOCGWIN)] = "VIDIOCGWIN",
243 [_IOC_NR(VIDIOCSWIN)] = "VIDIOCSWIN",
244 [_IOC_NR(VIDIOCGFBUF)] = "VIDIOCGFBUF",
245 [_IOC_NR(VIDIOCSFBUF)] = "VIDIOCSFBUF",
246 [_IOC_NR(VIDIOCKEY)] = "VIDIOCKEY",
247 [_IOC_NR(VIDIOCGFREQ)] = "VIDIOCGFREQ",
248 [_IOC_NR(VIDIOCSFREQ)] = "VIDIOCSFREQ",
249 [_IOC_NR(VIDIOCGAUDIO)] = "VIDIOCGAUDIO",
250 [_IOC_NR(VIDIOCSAUDIO)] = "VIDIOCSAUDIO",
251 [_IOC_NR(VIDIOCSYNC)] = "VIDIOCSYNC",
252 [_IOC_NR(VIDIOCMCAPTURE)] = "VIDIOCMCAPTURE",
253 [_IOC_NR(VIDIOCGMBUF)] = "VIDIOCGMBUF",
254 [_IOC_NR(VIDIOCGUNIT)] = "VIDIOCGUNIT",
255 [_IOC_NR(VIDIOCGCAPTURE)] = "VIDIOCGCAPTURE",
256 [_IOC_NR(VIDIOCSCAPTURE)] = "VIDIOCSCAPTURE",
257 [_IOC_NR(VIDIOCSPLAYMODE)] = "VIDIOCSPLAYMODE",
258 [_IOC_NR(VIDIOCSWRITEMODE)] = "VIDIOCSWRITEMODE",
259 [_IOC_NR(VIDIOCGPLAYINFO)] = "VIDIOCGPLAYINFO",
260 [_IOC_NR(VIDIOCSMICROCODE)] = "VIDIOCSMICROCODE",
261 [_IOC_NR(VIDIOCGVBIFMT)] = "VIDIOCGVBIFMT",
262 [_IOC_NR(VIDIOCSVBIFMT)] = "VIDIOCSVBIFMT"
263 };
264 #define V4L1_IOCTLS ARRAY_SIZE(v4l1_ioctls)
265 #endif
266
267 static const char *v4l2_ioctls[] = {
268 [_IOC_NR(VIDIOC_QUERYCAP)] = "VIDIOC_QUERYCAP",
269 [_IOC_NR(VIDIOC_RESERVED)] = "VIDIOC_RESERVED",
270 [_IOC_NR(VIDIOC_ENUM_FMT)] = "VIDIOC_ENUM_FMT",
271 [_IOC_NR(VIDIOC_G_FMT)] = "VIDIOC_G_FMT",
272 [_IOC_NR(VIDIOC_S_FMT)] = "VIDIOC_S_FMT",
273 [_IOC_NR(VIDIOC_REQBUFS)] = "VIDIOC_REQBUFS",
274 [_IOC_NR(VIDIOC_QUERYBUF)] = "VIDIOC_QUERYBUF",
275 [_IOC_NR(VIDIOC_G_FBUF)] = "VIDIOC_G_FBUF",
276 [_IOC_NR(VIDIOC_S_FBUF)] = "VIDIOC_S_FBUF",
277 [_IOC_NR(VIDIOC_OVERLAY)] = "VIDIOC_OVERLAY",
278 [_IOC_NR(VIDIOC_QBUF)] = "VIDIOC_QBUF",
279 [_IOC_NR(VIDIOC_DQBUF)] = "VIDIOC_DQBUF",
280 [_IOC_NR(VIDIOC_STREAMON)] = "VIDIOC_STREAMON",
281 [_IOC_NR(VIDIOC_STREAMOFF)] = "VIDIOC_STREAMOFF",
282 [_IOC_NR(VIDIOC_G_PARM)] = "VIDIOC_G_PARM",
283 [_IOC_NR(VIDIOC_S_PARM)] = "VIDIOC_S_PARM",
284 [_IOC_NR(VIDIOC_G_STD)] = "VIDIOC_G_STD",
285 [_IOC_NR(VIDIOC_S_STD)] = "VIDIOC_S_STD",
286 [_IOC_NR(VIDIOC_ENUMSTD)] = "VIDIOC_ENUMSTD",
287 [_IOC_NR(VIDIOC_ENUMINPUT)] = "VIDIOC_ENUMINPUT",
288 [_IOC_NR(VIDIOC_G_CTRL)] = "VIDIOC_G_CTRL",
289 [_IOC_NR(VIDIOC_S_CTRL)] = "VIDIOC_S_CTRL",
290 [_IOC_NR(VIDIOC_G_TUNER)] = "VIDIOC_G_TUNER",
291 [_IOC_NR(VIDIOC_S_TUNER)] = "VIDIOC_S_TUNER",
292 [_IOC_NR(VIDIOC_G_AUDIO)] = "VIDIOC_G_AUDIO",
293 [_IOC_NR(VIDIOC_S_AUDIO)] = "VIDIOC_S_AUDIO",
294 [_IOC_NR(VIDIOC_QUERYCTRL)] = "VIDIOC_QUERYCTRL",
295 [_IOC_NR(VIDIOC_QUERYMENU)] = "VIDIOC_QUERYMENU",
296 [_IOC_NR(VIDIOC_G_INPUT)] = "VIDIOC_G_INPUT",
297 [_IOC_NR(VIDIOC_S_INPUT)] = "VIDIOC_S_INPUT",
298 [_IOC_NR(VIDIOC_G_OUTPUT)] = "VIDIOC_G_OUTPUT",
299 [_IOC_NR(VIDIOC_S_OUTPUT)] = "VIDIOC_S_OUTPUT",
300 [_IOC_NR(VIDIOC_ENUMOUTPUT)] = "VIDIOC_ENUMOUTPUT",
301 [_IOC_NR(VIDIOC_G_AUDOUT)] = "VIDIOC_G_AUDOUT",
302 [_IOC_NR(VIDIOC_S_AUDOUT)] = "VIDIOC_S_AUDOUT",
303 [_IOC_NR(VIDIOC_G_MODULATOR)] = "VIDIOC_G_MODULATOR",
304 [_IOC_NR(VIDIOC_S_MODULATOR)] = "VIDIOC_S_MODULATOR",
305 [_IOC_NR(VIDIOC_G_FREQUENCY)] = "VIDIOC_G_FREQUENCY",
306 [_IOC_NR(VIDIOC_S_FREQUENCY)] = "VIDIOC_S_FREQUENCY",
307 [_IOC_NR(VIDIOC_CROPCAP)] = "VIDIOC_CROPCAP",
308 [_IOC_NR(VIDIOC_G_CROP)] = "VIDIOC_G_CROP",
309 [_IOC_NR(VIDIOC_S_CROP)] = "VIDIOC_S_CROP",
310 [_IOC_NR(VIDIOC_G_JPEGCOMP)] = "VIDIOC_G_JPEGCOMP",
311 [_IOC_NR(VIDIOC_S_JPEGCOMP)] = "VIDIOC_S_JPEGCOMP",
312 [_IOC_NR(VIDIOC_QUERYSTD)] = "VIDIOC_QUERYSTD",
313 [_IOC_NR(VIDIOC_TRY_FMT)] = "VIDIOC_TRY_FMT",
314 [_IOC_NR(VIDIOC_ENUMAUDIO)] = "VIDIOC_ENUMAUDIO",
315 [_IOC_NR(VIDIOC_ENUMAUDOUT)] = "VIDIOC_ENUMAUDOUT",
316 [_IOC_NR(VIDIOC_G_PRIORITY)] = "VIDIOC_G_PRIORITY",
317 [_IOC_NR(VIDIOC_S_PRIORITY)] = "VIDIOC_S_PRIORITY",
318 [_IOC_NR(VIDIOC_G_SLICED_VBI_CAP)] = "VIDIOC_G_SLICED_VBI_CAP",
319 [_IOC_NR(VIDIOC_LOG_STATUS)] = "VIDIOC_LOG_STATUS",
320 [_IOC_NR(VIDIOC_G_EXT_CTRLS)] = "VIDIOC_G_EXT_CTRLS",
321 [_IOC_NR(VIDIOC_S_EXT_CTRLS)] = "VIDIOC_S_EXT_CTRLS",
322 [_IOC_NR(VIDIOC_TRY_EXT_CTRLS)] = "VIDIOC_TRY_EXT_CTRLS",
323 #if 1
324 [_IOC_NR(VIDIOC_ENUM_FRAMESIZES)] = "VIDIOC_ENUM_FRAMESIZES",
325 [_IOC_NR(VIDIOC_ENUM_FRAMEINTERVALS)] = "VIDIOC_ENUM_FRAMEINTERVALS",
326 [_IOC_NR(VIDIOC_G_ENC_INDEX)] = "VIDIOC_G_ENC_INDEX",
327 [_IOC_NR(VIDIOC_ENCODER_CMD)] = "VIDIOC_ENCODER_CMD",
328 [_IOC_NR(VIDIOC_TRY_ENCODER_CMD)] = "VIDIOC_TRY_ENCODER_CMD",
329
330 [_IOC_NR(VIDIOC_DBG_S_REGISTER)] = "VIDIOC_DBG_S_REGISTER",
331 [_IOC_NR(VIDIOC_DBG_G_REGISTER)] = "VIDIOC_DBG_G_REGISTER",
332
333 [_IOC_NR(VIDIOC_G_CHIP_IDENT)] = "VIDIOC_G_CHIP_IDENT",
334 #endif
335 };
336 #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
337
338 static const char *v4l2_int_ioctls[] = {
339 #ifdef CONFIG_VIDEO_V4L1_COMPAT
340 [_IOC_NR(DECODER_GET_CAPABILITIES)] = "DECODER_GET_CAPABILITIES",
341 [_IOC_NR(DECODER_GET_STATUS)] = "DECODER_GET_STATUS",
342 [_IOC_NR(DECODER_SET_NORM)] = "DECODER_SET_NORM",
343 [_IOC_NR(DECODER_SET_INPUT)] = "DECODER_SET_INPUT",
344 [_IOC_NR(DECODER_SET_OUTPUT)] = "DECODER_SET_OUTPUT",
345 [_IOC_NR(DECODER_ENABLE_OUTPUT)] = "DECODER_ENABLE_OUTPUT",
346 [_IOC_NR(DECODER_SET_PICTURE)] = "DECODER_SET_PICTURE",
347 [_IOC_NR(DECODER_SET_GPIO)] = "DECODER_SET_GPIO",
348 [_IOC_NR(DECODER_INIT)] = "DECODER_INIT",
349 [_IOC_NR(DECODER_SET_VBI_BYPASS)] = "DECODER_SET_VBI_BYPASS",
350 [_IOC_NR(DECODER_DUMP)] = "DECODER_DUMP",
351 #endif
352 [_IOC_NR(AUDC_SET_RADIO)] = "AUDC_SET_RADIO",
353
354 [_IOC_NR(TUNER_SET_TYPE_ADDR)] = "TUNER_SET_TYPE_ADDR",
355 [_IOC_NR(TUNER_SET_STANDBY)] = "TUNER_SET_STANDBY",
356 [_IOC_NR(TUNER_SET_CONFIG)] = "TUNER_SET_CONFIG",
357
358 [_IOC_NR(VIDIOC_INT_S_TUNER_MODE)] = "VIDIOC_INT_S_TUNER_MODE",
359 [_IOC_NR(VIDIOC_INT_RESET)] = "VIDIOC_INT_RESET",
360 [_IOC_NR(VIDIOC_INT_AUDIO_CLOCK_FREQ)] = "VIDIOC_INT_AUDIO_CLOCK_FREQ",
361 [_IOC_NR(VIDIOC_INT_DECODE_VBI_LINE)] = "VIDIOC_INT_DECODE_VBI_LINE",
362 [_IOC_NR(VIDIOC_INT_S_VBI_DATA)] = "VIDIOC_INT_S_VBI_DATA",
363 [_IOC_NR(VIDIOC_INT_G_VBI_DATA)] = "VIDIOC_INT_G_VBI_DATA",
364 [_IOC_NR(VIDIOC_INT_I2S_CLOCK_FREQ)] = "VIDIOC_INT_I2S_CLOCK_FREQ",
365 [_IOC_NR(VIDIOC_INT_S_STANDBY)] = "VIDIOC_INT_S_STANDBY",
366 [_IOC_NR(VIDIOC_INT_S_AUDIO_ROUTING)] = "VIDIOC_INT_S_AUDIO_ROUTING",
367 [_IOC_NR(VIDIOC_INT_G_AUDIO_ROUTING)] = "VIDIOC_INT_G_AUDIO_ROUTING",
368 [_IOC_NR(VIDIOC_INT_S_VIDEO_ROUTING)] = "VIDIOC_INT_S_VIDEO_ROUTING",
369 [_IOC_NR(VIDIOC_INT_G_VIDEO_ROUTING)] = "VIDIOC_INT_G_VIDEO_ROUTING",
370 [_IOC_NR(VIDIOC_INT_S_CRYSTAL_FREQ)] = "VIDIOC_INT_S_CRYSTAL_FREQ",
371 [_IOC_NR(VIDIOC_INT_INIT)] = "VIDIOC_INT_INIT",
372 [_IOC_NR(VIDIOC_INT_G_STD_OUTPUT)] = "VIDIOC_INT_G_STD_OUTPUT",
373 [_IOC_NR(VIDIOC_INT_S_STD_OUTPUT)] = "VIDIOC_INT_S_STD_OUTPUT",
374 };
375 #define V4L2_INT_IOCTLS ARRAY_SIZE(v4l2_int_ioctls)
376
377 /* Common ioctl debug function. This function can be used by
378 external ioctl messages as well as internal V4L ioctl */
379 void v4l_printk_ioctl(unsigned int cmd)
380 {
381 char *dir, *type;
382
383 switch (_IOC_TYPE(cmd)) {
384 case 'd':
385 if (_IOC_NR(cmd) >= V4L2_INT_IOCTLS) {
386 type = "v4l2_int";
387 break;
388 }
389 printk("%s", v4l2_int_ioctls[_IOC_NR(cmd)]);
390 return;
391 #ifdef CONFIG_VIDEO_V4L1_COMPAT
392 case 'v':
393 if (_IOC_NR(cmd) >= V4L1_IOCTLS) {
394 type = "v4l1";
395 break;
396 }
397 printk("%s", v4l1_ioctls[_IOC_NR(cmd)]);
398 return;
399 #endif
400 case 'V':
401 if (_IOC_NR(cmd) >= V4L2_IOCTLS) {
402 type = "v4l2";
403 break;
404 }
405 printk("%s", v4l2_ioctls[_IOC_NR(cmd)]);
406 return;
407 default:
408 type = "unknown";
409 }
410
411 switch (_IOC_DIR(cmd)) {
412 case _IOC_NONE: dir = "--"; break;
413 case _IOC_READ: dir = "r-"; break;
414 case _IOC_WRITE: dir = "-w"; break;
415 case _IOC_READ | _IOC_WRITE: dir = "rw"; break;
416 default: dir = "*ERR*"; break;
417 }
418 printk("%s ioctl '%c', dir=%s, #%d (0x%08x)",
419 type, _IOC_TYPE(cmd), dir, _IOC_NR(cmd), cmd);
420 }
421 EXPORT_SYMBOL(v4l_printk_ioctl);
422
423 /*
424 * sysfs stuff
425 */
426
427 static ssize_t show_name(struct device *cd,
428 struct device_attribute *attr, char *buf)
429 {
430 struct video_device *vfd = container_of(cd, struct video_device,
431 class_dev);
432 return sprintf(buf, "%.*s\n", (int)sizeof(vfd->name), vfd->name);
433 }
434
435 struct video_device *video_device_alloc(void)
436 {
437 struct video_device *vfd;
438
439 vfd = kzalloc(sizeof(*vfd),GFP_KERNEL);
440 return vfd;
441 }
442 EXPORT_SYMBOL(video_device_alloc);
443
444 void video_device_release(struct video_device *vfd)
445 {
446 kfree(vfd);
447 }
448 EXPORT_SYMBOL(video_device_release);
449
450 static void video_release(struct device *cd)
451 {
452 struct video_device *vfd = container_of(cd, struct video_device,
453 class_dev);
454
455 #if 1
456 /* needed until all drivers are fixed */
457 if (!vfd->release)
458 return;
459 #endif
460 vfd->release(vfd);
461 }
462
463 static struct device_attribute video_device_attrs[] = {
464 __ATTR(name, S_IRUGO, show_name, NULL),
465 __ATTR_NULL
466 };
467
468 static struct class video_class = {
469 .name = VIDEO_NAME,
470 .dev_attrs = video_device_attrs,
471 .dev_release = video_release,
472 };
473
474 /*
475 * Active devices
476 */
477
478 static struct video_device *video_device[VIDEO_NUM_DEVICES];
479 static DEFINE_MUTEX(videodev_lock);
480
481 struct video_device* video_devdata(struct file *file)
482 {
483 return video_device[iminor(file->f_path.dentry->d_inode)];
484 }
485 EXPORT_SYMBOL(video_devdata);
486
487 /*
488 * Open a video device - FIXME: Obsoleted
489 */
490 static int video_open(struct inode *inode, struct file *file)
491 {
492 unsigned int minor = iminor(inode);
493 int err = 0;
494 struct video_device *vfl;
495 const struct file_operations *old_fops;
496
497 if(minor>=VIDEO_NUM_DEVICES)
498 return -ENODEV;
499 mutex_lock(&videodev_lock);
500 vfl=video_device[minor];
501 if(vfl==NULL) {
502 mutex_unlock(&videodev_lock);
503 request_module("char-major-%d-%d", VIDEO_MAJOR, minor);
504 mutex_lock(&videodev_lock);
505 vfl=video_device[minor];
506 if (vfl==NULL) {
507 mutex_unlock(&videodev_lock);
508 return -ENODEV;
509 }
510 }
511 old_fops = file->f_op;
512 file->f_op = fops_get(vfl->fops);
513 if(file->f_op->open)
514 err = file->f_op->open(inode,file);
515 if (err) {
516 fops_put(file->f_op);
517 file->f_op = fops_get(old_fops);
518 }
519 fops_put(old_fops);
520 mutex_unlock(&videodev_lock);
521 return err;
522 }
523
524 /*
525 * helper function -- handles userspace copying for ioctl arguments
526 */
527
528 #ifdef __OLD_VIDIOC_
529 static unsigned int
530 video_fix_command(unsigned int cmd)
531 {
532 switch (cmd) {
533 case VIDIOC_OVERLAY_OLD:
534 cmd = VIDIOC_OVERLAY;
535 break;
536 case VIDIOC_S_PARM_OLD:
537 cmd = VIDIOC_S_PARM;
538 break;
539 case VIDIOC_S_CTRL_OLD:
540 cmd = VIDIOC_S_CTRL;
541 break;
542 case VIDIOC_G_AUDIO_OLD:
543 cmd = VIDIOC_G_AUDIO;
544 break;
545 case VIDIOC_G_AUDOUT_OLD:
546 cmd = VIDIOC_G_AUDOUT;
547 break;
548 case VIDIOC_CROPCAP_OLD:
549 cmd = VIDIOC_CROPCAP;
550 break;
551 }
552 return cmd;
553 }
554 #endif
555
556 /*
557 * Obsolete usercopy function - Should be removed soon
558 */
559 int
560 video_usercopy(struct inode *inode, struct file *file,
561 unsigned int cmd, unsigned long arg,
562 int (*func)(struct inode *inode, struct file *file,
563 unsigned int cmd, void *arg))
564 {
565 char sbuf[128];
566 void *mbuf = NULL;
567 void *parg = NULL;
568 int err = -EINVAL;
569 int is_ext_ctrl;
570 size_t ctrls_size = 0;
571 void __user *user_ptr = NULL;
572
573 #ifdef __OLD_VIDIOC_
574 cmd = video_fix_command(cmd);
575 #endif
576 is_ext_ctrl = (cmd == VIDIOC_S_EXT_CTRLS || cmd == VIDIOC_G_EXT_CTRLS ||
577 cmd == VIDIOC_TRY_EXT_CTRLS);
578
579 /* Copy arguments into temp kernel buffer */
580 switch (_IOC_DIR(cmd)) {
581 case _IOC_NONE:
582 parg = NULL;
583 break;
584 case _IOC_READ:
585 case _IOC_WRITE:
586 case (_IOC_WRITE | _IOC_READ):
587 if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
588 parg = sbuf;
589 } else {
590 /* too big to allocate from stack */
591 mbuf = kmalloc(_IOC_SIZE(cmd),GFP_KERNEL);
592 if (NULL == mbuf)
593 return -ENOMEM;
594 parg = mbuf;
595 }
596
597 err = -EFAULT;
598 if (_IOC_DIR(cmd) & _IOC_WRITE)
599 if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
600 goto out;
601 break;
602 }
603 if (is_ext_ctrl) {
604 struct v4l2_ext_controls *p = parg;
605
606 /* In case of an error, tell the caller that it wasn't
607 a specific control that caused it. */
608 p->error_idx = p->count;
609 user_ptr = (void __user *)p->controls;
610 if (p->count) {
611 ctrls_size = sizeof(struct v4l2_ext_control) * p->count;
612 /* Note: v4l2_ext_controls fits in sbuf[] so mbuf is still NULL. */
613 mbuf = kmalloc(ctrls_size, GFP_KERNEL);
614 err = -ENOMEM;
615 if (NULL == mbuf)
616 goto out_ext_ctrl;
617 err = -EFAULT;
618 if (copy_from_user(mbuf, user_ptr, ctrls_size))
619 goto out_ext_ctrl;
620 p->controls = mbuf;
621 }
622 }
623
624 /* call driver */
625 err = func(inode, file, cmd, parg);
626 if (err == -ENOIOCTLCMD)
627 err = -EINVAL;
628 if (is_ext_ctrl) {
629 struct v4l2_ext_controls *p = parg;
630
631 p->controls = (void *)user_ptr;
632 if (p->count && err == 0 && copy_to_user(user_ptr, mbuf, ctrls_size))
633 err = -EFAULT;
634 goto out_ext_ctrl;
635 }
636 if (err < 0)
637 goto out;
638
639 out_ext_ctrl:
640 /* Copy results into user buffer */
641 switch (_IOC_DIR(cmd))
642 {
643 case _IOC_READ:
644 case (_IOC_WRITE | _IOC_READ):
645 if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
646 err = -EFAULT;
647 break;
648 }
649
650 out:
651 kfree(mbuf);
652 return err;
653 }
654 EXPORT_SYMBOL(video_usercopy);
655
656 /*
657 * open/release helper functions -- handle exclusive opens
658 * Should be removed soon
659 */
660 int video_exclusive_open(struct inode *inode, struct file *file)
661 {
662 struct video_device *vfl = video_devdata(file);
663 int retval = 0;
664
665 mutex_lock(&vfl->lock);
666 if (vfl->users) {
667 retval = -EBUSY;
668 } else {
669 vfl->users++;
670 }
671 mutex_unlock(&vfl->lock);
672 return retval;
673 }
674 EXPORT_SYMBOL(video_exclusive_open);
675
676 int video_exclusive_release(struct inode *inode, struct file *file)
677 {
678 struct video_device *vfl = video_devdata(file);
679
680 vfl->users--;
681 return 0;
682 }
683 EXPORT_SYMBOL(video_exclusive_release);
684
685 static void dbgbuf(unsigned int cmd, struct video_device *vfd,
686 struct v4l2_buffer *p)
687 {
688 struct v4l2_timecode *tc=&p->timecode;
689
690 dbgarg (cmd, "%02ld:%02d:%02d.%08ld index=%d, type=%s, "
691 "bytesused=%d, flags=0x%08d, "
692 "field=%0d, sequence=%d, memory=%s, offset/userptr=0x%08lx, length=%d\n",
693 (p->timestamp.tv_sec/3600),
694 (int)(p->timestamp.tv_sec/60)%60,
695 (int)(p->timestamp.tv_sec%60),
696 p->timestamp.tv_usec,
697 p->index,
698 prt_names(p->type, v4l2_type_names),
699 p->bytesused, p->flags,
700 p->field, p->sequence,
701 prt_names(p->memory, v4l2_memory_names),
702 p->m.userptr, p->length);
703 dbgarg2 ("timecode= %02d:%02d:%02d type=%d, "
704 "flags=0x%08d, frames=%d, userbits=0x%08x\n",
705 tc->hours,tc->minutes,tc->seconds,
706 tc->type, tc->flags, tc->frames, *(__u32 *) tc->userbits);
707 }
708
709 static inline void dbgrect(struct video_device *vfd, char *s,
710 struct v4l2_rect *r)
711 {
712 dbgarg2 ("%sRect start at %dx%d, size= %dx%d\n", s, r->left, r->top,
713 r->width, r->height);
714 };
715
716 static inline void v4l_print_pix_fmt (struct video_device *vfd,
717 struct v4l2_pix_format *fmt)
718 {
719 dbgarg2 ("width=%d, height=%d, format=%c%c%c%c, field=%s, "
720 "bytesperline=%d sizeimage=%d, colorspace=%d\n",
721 fmt->width,fmt->height,
722 (fmt->pixelformat & 0xff),
723 (fmt->pixelformat >> 8) & 0xff,
724 (fmt->pixelformat >> 16) & 0xff,
725 (fmt->pixelformat >> 24) & 0xff,
726 prt_names(fmt->field, v4l2_field_names),
727 fmt->bytesperline, fmt->sizeimage, fmt->colorspace);
728 };
729
730
731 static int check_fmt (struct video_device *vfd, enum v4l2_buf_type type)
732 {
733 switch (type) {
734 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
735 if (vfd->vidioc_try_fmt_cap)
736 return (0);
737 break;
738 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
739 if (vfd->vidioc_try_fmt_overlay)
740 return (0);
741 break;
742 case V4L2_BUF_TYPE_VBI_CAPTURE:
743 if (vfd->vidioc_try_fmt_vbi)
744 return (0);
745 break;
746 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
747 if (vfd->vidioc_try_fmt_vbi_output)
748 return (0);
749 break;
750 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
751 if (vfd->vidioc_try_fmt_vbi_capture)
752 return (0);
753 break;
754 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
755 if (vfd->vidioc_try_fmt_video_output)
756 return (0);
757 break;
758 case V4L2_BUF_TYPE_VBI_OUTPUT:
759 if (vfd->vidioc_try_fmt_vbi_output)
760 return (0);
761 break;
762 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
763 if (vfd->vidioc_try_fmt_output_overlay)
764 return (0);
765 break;
766 case V4L2_BUF_TYPE_PRIVATE:
767 if (vfd->vidioc_try_fmt_type_private)
768 return (0);
769 break;
770 }
771 return (-EINVAL);
772 }
773
774 static int __video_do_ioctl(struct inode *inode, struct file *file,
775 unsigned int cmd, void *arg)
776 {
777 struct video_device *vfd = video_devdata(file);
778 void *fh = file->private_data;
779 int ret = -EINVAL;
780
781 if ( (vfd->debug & V4L2_DEBUG_IOCTL) &&
782 !(vfd->debug & V4L2_DEBUG_IOCTL_ARG)) {
783 v4l_print_ioctl(vfd->name, cmd);
784 printk("\n");
785 }
786
787 #ifdef CONFIG_VIDEO_V4L1_COMPAT
788 /***********************************************************
789 Handles calls to the obsoleted V4L1 API
790 Due to the nature of VIDIOCGMBUF, each driver that supports
791 V4L1 should implement its own handler for this ioctl.
792 ***********************************************************/
793
794 /* --- streaming capture ------------------------------------- */
795 if (cmd == VIDIOCGMBUF) {
796 struct video_mbuf *p=arg;
797
798 memset(p, 0, sizeof(*p));
799
800 if (!vfd->vidiocgmbuf)
801 return ret;
802 ret=vfd->vidiocgmbuf(file, fh, p);
803 if (!ret)
804 dbgarg (cmd, "size=%d, frames=%d, offsets=0x%08lx\n",
805 p->size, p->frames,
806 (unsigned long)p->offsets);
807 return ret;
808 }
809
810 /********************************************************
811 All other V4L1 calls are handled by v4l1_compat module.
812 Those calls will be translated into V4L2 calls, and
813 __video_do_ioctl will be called again, with one or more
814 V4L2 ioctls.
815 ********************************************************/
816 if (_IOC_TYPE(cmd)=='v')
817 return v4l_compat_translate_ioctl(inode,file,cmd,arg,
818 __video_do_ioctl);
819 #endif
820
821 switch(cmd) {
822 /* --- capabilities ------------------------------------------ */
823 case VIDIOC_QUERYCAP:
824 {
825 struct v4l2_capability *cap = (struct v4l2_capability*)arg;
826 memset(cap, 0, sizeof(*cap));
827
828 if (!vfd->vidioc_querycap)
829 break;
830
831 ret=vfd->vidioc_querycap(file, fh, cap);
832 if (!ret)
833 dbgarg (cmd, "driver=%s, card=%s, bus=%s, "
834 "version=0x%08x, "
835 "capabilities=0x%08x\n",
836 cap->driver,cap->card,cap->bus_info,
837 cap->version,
838 cap->capabilities);
839 break;
840 }
841
842 /* --- priority ------------------------------------------ */
843 case VIDIOC_G_PRIORITY:
844 {
845 enum v4l2_priority *p=arg;
846
847 if (!vfd->vidioc_g_priority)
848 break;
849 ret=vfd->vidioc_g_priority(file, fh, p);
850 if (!ret)
851 dbgarg(cmd, "priority is %d\n", *p);
852 break;
853 }
854 case VIDIOC_S_PRIORITY:
855 {
856 enum v4l2_priority *p=arg;
857
858 if (!vfd->vidioc_s_priority)
859 break;
860 dbgarg(cmd, "setting priority to %d\n", *p);
861 ret=vfd->vidioc_s_priority(file, fh, *p);
862 break;
863 }
864
865 /* --- capture ioctls ---------------------------------------- */
866 case VIDIOC_ENUM_FMT:
867 {
868 struct v4l2_fmtdesc *f = arg;
869 enum v4l2_buf_type type;
870 unsigned int index;
871
872 index = f->index;
873 type = f->type;
874 memset(f,0,sizeof(*f));
875 f->index = index;
876 f->type = type;
877
878 switch (type) {
879 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
880 if (vfd->vidioc_enum_fmt_cap)
881 ret=vfd->vidioc_enum_fmt_cap(file, fh, f);
882 break;
883 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
884 if (vfd->vidioc_enum_fmt_overlay)
885 ret=vfd->vidioc_enum_fmt_overlay(file, fh, f);
886 break;
887 case V4L2_BUF_TYPE_VBI_CAPTURE:
888 if (vfd->vidioc_enum_fmt_vbi)
889 ret=vfd->vidioc_enum_fmt_vbi(file, fh, f);
890 break;
891 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
892 if (vfd->vidioc_enum_fmt_vbi_output)
893 ret=vfd->vidioc_enum_fmt_vbi_output(file,
894 fh, f);
895 break;
896 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
897 if (vfd->vidioc_enum_fmt_vbi_capture)
898 ret=vfd->vidioc_enum_fmt_vbi_capture(file,
899 fh, f);
900 break;
901 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
902 if (vfd->vidioc_enum_fmt_video_output)
903 ret=vfd->vidioc_enum_fmt_video_output(file,
904 fh, f);
905 break;
906 case V4L2_BUF_TYPE_VBI_OUTPUT:
907 if (vfd->vidioc_enum_fmt_vbi_output)
908 ret=vfd->vidioc_enum_fmt_vbi_output(file,
909 fh, f);
910 break;
911 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
912 if (vfd->vidioc_enum_fmt_output_overlay)
913 ret=vfd->vidioc_enum_fmt_output_overlay(file, fh, f);
914 break;
915 case V4L2_BUF_TYPE_PRIVATE:
916 if (vfd->vidioc_enum_fmt_type_private)
917 ret=vfd->vidioc_enum_fmt_type_private(file,
918 fh, f);
919 break;
920 }
921 if (!ret)
922 dbgarg (cmd, "index=%d, type=%d, flags=%d, "
923 "pixelformat=%c%c%c%c, description='%s'\n",
924 f->index, f->type, f->flags,
925 (f->pixelformat & 0xff),
926 (f->pixelformat >> 8) & 0xff,
927 (f->pixelformat >> 16) & 0xff,
928 (f->pixelformat >> 24) & 0xff,
929 f->description);
930 break;
931 }
932 case VIDIOC_G_FMT:
933 {
934 struct v4l2_format *f = (struct v4l2_format *)arg;
935 enum v4l2_buf_type type=f->type;
936
937 memset(&f->fmt.pix,0,sizeof(f->fmt.pix));
938 f->type=type;
939
940 /* FIXME: Should be one dump per type */
941 dbgarg (cmd, "type=%s\n", prt_names(type,
942 v4l2_type_names));
943
944 switch (type) {
945 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
946 if (vfd->vidioc_g_fmt_cap)
947 ret=vfd->vidioc_g_fmt_cap(file, fh, f);
948 if (!ret)
949 v4l_print_pix_fmt(vfd,&f->fmt.pix);
950 break;
951 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
952 if (vfd->vidioc_g_fmt_overlay)
953 ret=vfd->vidioc_g_fmt_overlay(file, fh, f);
954 break;
955 case V4L2_BUF_TYPE_VBI_CAPTURE:
956 if (vfd->vidioc_g_fmt_vbi)
957 ret=vfd->vidioc_g_fmt_vbi(file, fh, f);
958 break;
959 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
960 if (vfd->vidioc_g_fmt_vbi_output)
961 ret=vfd->vidioc_g_fmt_vbi_output(file, fh, f);
962 break;
963 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
964 if (vfd->vidioc_g_fmt_vbi_capture)
965 ret=vfd->vidioc_g_fmt_vbi_capture(file, fh, f);
966 break;
967 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
968 if (vfd->vidioc_g_fmt_video_output)
969 ret=vfd->vidioc_g_fmt_video_output(file,
970 fh, f);
971 break;
972 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
973 if (vfd->vidioc_g_fmt_output_overlay)
974 ret=vfd->vidioc_g_fmt_output_overlay(file, fh, f);
975 break;
976 case V4L2_BUF_TYPE_VBI_OUTPUT:
977 if (vfd->vidioc_g_fmt_vbi_output)
978 ret=vfd->vidioc_g_fmt_vbi_output(file, fh, f);
979 break;
980 case V4L2_BUF_TYPE_PRIVATE:
981 if (vfd->vidioc_g_fmt_type_private)
982 ret=vfd->vidioc_g_fmt_type_private(file,
983 fh, f);
984 break;
985 }
986
987 break;
988 }
989 case VIDIOC_S_FMT:
990 {
991 struct v4l2_format *f = (struct v4l2_format *)arg;
992
993 /* FIXME: Should be one dump per type */
994 dbgarg (cmd, "type=%s\n", prt_names(f->type,
995 v4l2_type_names));
996
997 switch (f->type) {
998 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
999 v4l_print_pix_fmt(vfd,&f->fmt.pix);
1000 if (vfd->vidioc_s_fmt_cap)
1001 ret=vfd->vidioc_s_fmt_cap(file, fh, f);
1002 break;
1003 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
1004 if (vfd->vidioc_s_fmt_overlay)
1005 ret=vfd->vidioc_s_fmt_overlay(file, fh, f);
1006 break;
1007 case V4L2_BUF_TYPE_VBI_CAPTURE:
1008 if (vfd->vidioc_s_fmt_vbi)
1009 ret=vfd->vidioc_s_fmt_vbi(file, fh, f);
1010 break;
1011 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
1012 if (vfd->vidioc_s_fmt_vbi_output)
1013 ret=vfd->vidioc_s_fmt_vbi_output(file, fh, f);
1014 break;
1015 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
1016 if (vfd->vidioc_s_fmt_vbi_capture)
1017 ret=vfd->vidioc_s_fmt_vbi_capture(file, fh, f);
1018 break;
1019 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
1020 if (vfd->vidioc_s_fmt_video_output)
1021 ret=vfd->vidioc_s_fmt_video_output(file,
1022 fh, f);
1023 break;
1024 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
1025 if (vfd->vidioc_s_fmt_output_overlay)
1026 ret=vfd->vidioc_s_fmt_output_overlay(file, fh, f);
1027 break;
1028 case V4L2_BUF_TYPE_VBI_OUTPUT:
1029 if (vfd->vidioc_s_fmt_vbi_output)
1030 ret=vfd->vidioc_s_fmt_vbi_output(file,
1031 fh, f);
1032 break;
1033 case V4L2_BUF_TYPE_PRIVATE:
1034 if (vfd->vidioc_s_fmt_type_private)
1035 ret=vfd->vidioc_s_fmt_type_private(file,
1036 fh, f);
1037 break;
1038 }
1039 break;
1040 }
1041 case VIDIOC_TRY_FMT:
1042 {
1043 struct v4l2_format *f = (struct v4l2_format *)arg;
1044
1045 /* FIXME: Should be one dump per type */
1046 dbgarg (cmd, "type=%s\n", prt_names(f->type,
1047 v4l2_type_names));
1048 switch (f->type) {
1049 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1050 if (vfd->vidioc_try_fmt_cap)
1051 ret=vfd->vidioc_try_fmt_cap(file, fh, f);
1052 if (!ret)
1053 v4l_print_pix_fmt(vfd,&f->fmt.pix);
1054 break;
1055 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
1056 if (vfd->vidioc_try_fmt_overlay)
1057 ret=vfd->vidioc_try_fmt_overlay(file, fh, f);
1058 break;
1059 case V4L2_BUF_TYPE_VBI_CAPTURE:
1060 if (vfd->vidioc_try_fmt_vbi)
1061 ret=vfd->vidioc_try_fmt_vbi(file, fh, f);
1062 break;
1063 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
1064 if (vfd->vidioc_try_fmt_vbi_output)
1065 ret=vfd->vidioc_try_fmt_vbi_output(file,
1066 fh, f);
1067 break;
1068 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
1069 if (vfd->vidioc_try_fmt_vbi_capture)
1070 ret=vfd->vidioc_try_fmt_vbi_capture(file,
1071 fh, f);
1072 break;
1073 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
1074 if (vfd->vidioc_try_fmt_video_output)
1075 ret=vfd->vidioc_try_fmt_video_output(file,
1076 fh, f);
1077 break;
1078 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
1079 if (vfd->vidioc_try_fmt_output_overlay)
1080 ret=vfd->vidioc_try_fmt_output_overlay(file, fh, f);
1081 break;
1082 case V4L2_BUF_TYPE_VBI_OUTPUT:
1083 if (vfd->vidioc_try_fmt_vbi_output)
1084 ret=vfd->vidioc_try_fmt_vbi_output(file,
1085 fh, f);
1086 break;
1087 case V4L2_BUF_TYPE_PRIVATE:
1088 if (vfd->vidioc_try_fmt_type_private)
1089 ret=vfd->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 (!vfd->vidioc_reqbufs)
1105 break;
1106 ret = check_fmt (vfd, p->type);
1107 if (ret)
1108 break;
1109
1110 ret=vfd->vidioc_reqbufs(file, fh, p);
1111 dbgarg (cmd, "count=%d, type=%s, memory=%s\n",
1112 p->count,
1113 prt_names(p->type, v4l2_type_names),
1114 prt_names(p->memory, v4l2_memory_names));
1115 break;
1116 }
1117 case VIDIOC_QUERYBUF:
1118 {
1119 struct v4l2_buffer *p=arg;
1120
1121 if (!vfd->vidioc_querybuf)
1122 break;
1123 ret = check_fmt (vfd, p->type);
1124 if (ret)
1125 break;
1126
1127 ret=vfd->vidioc_querybuf(file, fh, p);
1128 if (!ret)
1129 dbgbuf(cmd,vfd,p);
1130 break;
1131 }
1132 case VIDIOC_QBUF:
1133 {
1134 struct v4l2_buffer *p=arg;
1135
1136 if (!vfd->vidioc_qbuf)
1137 break;
1138 ret = check_fmt (vfd, p->type);
1139 if (ret)
1140 break;
1141
1142 ret=vfd->vidioc_qbuf(file, fh, p);
1143 if (!ret)
1144 dbgbuf(cmd,vfd,p);
1145 break;
1146 }
1147 case VIDIOC_DQBUF:
1148 {
1149 struct v4l2_buffer *p=arg;
1150 if (!vfd->vidioc_dqbuf)
1151 break;
1152 ret = check_fmt (vfd, p->type);
1153 if (ret)
1154 break;
1155
1156 ret=vfd->vidioc_dqbuf(file, fh, p);
1157 if (!ret)
1158 dbgbuf(cmd,vfd,p);
1159 break;
1160 }
1161 case VIDIOC_OVERLAY:
1162 {
1163 int *i = arg;
1164
1165 if (!vfd->vidioc_overlay)
1166 break;
1167 dbgarg (cmd, "value=%d\n",*i);
1168 ret=vfd->vidioc_overlay(file, fh, *i);
1169 break;
1170 }
1171 case VIDIOC_G_FBUF:
1172 {
1173 struct v4l2_framebuffer *p=arg;
1174 if (!vfd->vidioc_g_fbuf)
1175 break;
1176 ret=vfd->vidioc_g_fbuf(file, fh, arg);
1177 if (!ret) {
1178 dbgarg (cmd, "capability=%d, flags=%d, base=0x%08lx\n",
1179 p->capability,p->flags,
1180 (unsigned long)p->base);
1181 v4l_print_pix_fmt (vfd, &p->fmt);
1182 }
1183 break;
1184 }
1185 case VIDIOC_S_FBUF:
1186 {
1187 struct v4l2_framebuffer *p=arg;
1188 if (!vfd->vidioc_s_fbuf)
1189 break;
1190
1191 dbgarg (cmd, "capability=%d, flags=%d, base=0x%08lx\n",
1192 p->capability,p->flags,(unsigned long)p->base);
1193 v4l_print_pix_fmt (vfd, &p->fmt);
1194 ret=vfd->vidioc_s_fbuf(file, fh, arg);
1195
1196 break;
1197 }
1198 case VIDIOC_STREAMON:
1199 {
1200 enum v4l2_buf_type i = *(int *)arg;
1201 if (!vfd->vidioc_streamon)
1202 break;
1203 dbgarg(cmd, "type=%s\n", prt_names(i, v4l2_type_names));
1204 ret=vfd->vidioc_streamon(file, fh,i);
1205 break;
1206 }
1207 case VIDIOC_STREAMOFF:
1208 {
1209 enum v4l2_buf_type i = *(int *)arg;
1210
1211 if (!vfd->vidioc_streamoff)
1212 break;
1213 dbgarg(cmd, "type=%s\n", prt_names(i, v4l2_type_names));
1214 ret=vfd->vidioc_streamoff(file, fh, i);
1215 break;
1216 }
1217 /* ---------- tv norms ---------- */
1218 case VIDIOC_ENUMSTD:
1219 {
1220 struct v4l2_standard *p = arg;
1221 v4l2_std_id id = vfd->tvnorms,curr_id=0;
1222 unsigned int index = p->index,i;
1223
1224 if (index<0) {
1225 ret=-EINVAL;
1226 break;
1227 }
1228
1229 /* Return norm array on a canonical way */
1230 for (i=0;i<= index && id; i++) {
1231 if ( (id & V4L2_STD_PAL) == V4L2_STD_PAL) {
1232 curr_id = V4L2_STD_PAL;
1233 } else if ( (id & V4L2_STD_PAL_BG) == V4L2_STD_PAL_BG) {
1234 curr_id = V4L2_STD_PAL_BG;
1235 } else if ( (id & V4L2_STD_PAL_DK) == V4L2_STD_PAL_DK) {
1236 curr_id = V4L2_STD_PAL_DK;
1237 } else if ( (id & V4L2_STD_PAL_B) == V4L2_STD_PAL_B) {
1238 curr_id = V4L2_STD_PAL_B;
1239 } else if ( (id & V4L2_STD_PAL_B1) == V4L2_STD_PAL_B1) {
1240 curr_id = V4L2_STD_PAL_B1;
1241 } else if ( (id & V4L2_STD_PAL_G) == V4L2_STD_PAL_G) {
1242 curr_id = V4L2_STD_PAL_G;
1243 } else if ( (id & V4L2_STD_PAL_H) == V4L2_STD_PAL_H) {
1244 curr_id = V4L2_STD_PAL_H;
1245 } else if ( (id & V4L2_STD_PAL_I) == V4L2_STD_PAL_I) {
1246 curr_id = V4L2_STD_PAL_I;
1247 } else if ( (id & V4L2_STD_PAL_D) == V4L2_STD_PAL_D) {
1248 curr_id = V4L2_STD_PAL_D;
1249 } else if ( (id & V4L2_STD_PAL_D1) == V4L2_STD_PAL_D1) {
1250 curr_id = V4L2_STD_PAL_D1;
1251 } else if ( (id & V4L2_STD_PAL_K) == V4L2_STD_PAL_K) {
1252 curr_id = V4L2_STD_PAL_K;
1253 } else if ( (id & V4L2_STD_PAL_M) == V4L2_STD_PAL_M) {
1254 curr_id = V4L2_STD_PAL_M;
1255 } else if ( (id & V4L2_STD_PAL_N) == V4L2_STD_PAL_N) {
1256 curr_id = V4L2_STD_PAL_N;
1257 } else if ( (id & V4L2_STD_PAL_Nc) == V4L2_STD_PAL_Nc) {
1258 curr_id = V4L2_STD_PAL_Nc;
1259 } else if ( (id & V4L2_STD_PAL_60) == V4L2_STD_PAL_60) {
1260 curr_id = V4L2_STD_PAL_60;
1261 } else if ( (id & V4L2_STD_NTSC) == V4L2_STD_NTSC) {
1262 curr_id = V4L2_STD_NTSC;
1263 } else if ( (id & V4L2_STD_NTSC_M) == V4L2_STD_NTSC_M) {
1264 curr_id = V4L2_STD_NTSC_M;
1265 } else if ( (id & V4L2_STD_NTSC_M_JP) == V4L2_STD_NTSC_M_JP) {
1266 curr_id = V4L2_STD_NTSC_M_JP;
1267 } else if ( (id & V4L2_STD_NTSC_443) == V4L2_STD_NTSC_443) {
1268 curr_id = V4L2_STD_NTSC_443;
1269 } else if ( (id & V4L2_STD_NTSC_M_KR) == V4L2_STD_NTSC_M_KR) {
1270 curr_id = V4L2_STD_NTSC_M_KR;
1271 } else if ( (id & V4L2_STD_SECAM) == V4L2_STD_SECAM) {
1272 curr_id = V4L2_STD_SECAM;
1273 } else if ( (id & V4L2_STD_SECAM_DK) == V4L2_STD_SECAM_DK) {
1274 curr_id = V4L2_STD_SECAM_DK;
1275 } else if ( (id & V4L2_STD_SECAM_B) == V4L2_STD_SECAM_B) {
1276 curr_id = V4L2_STD_SECAM_B;
1277 } else if ( (id & V4L2_STD_SECAM_D) == V4L2_STD_SECAM_D) {
1278 curr_id = V4L2_STD_SECAM_D;
1279 } else if ( (id & V4L2_STD_SECAM_G) == V4L2_STD_SECAM_G) {
1280 curr_id = V4L2_STD_SECAM_G;
1281 } else if ( (id & V4L2_STD_SECAM_H) == V4L2_STD_SECAM_H) {
1282 curr_id = V4L2_STD_SECAM_H;
1283 } else if ( (id & V4L2_STD_SECAM_K) == V4L2_STD_SECAM_K) {
1284 curr_id = V4L2_STD_SECAM_K;
1285 } else if ( (id & V4L2_STD_SECAM_K1) == V4L2_STD_SECAM_K1) {
1286 curr_id = V4L2_STD_SECAM_K1;
1287 } else if ( (id & V4L2_STD_SECAM_L) == V4L2_STD_SECAM_L) {
1288 curr_id = V4L2_STD_SECAM_L;
1289 } else if ( (id & V4L2_STD_SECAM_LC) == V4L2_STD_SECAM_LC) {
1290 curr_id = V4L2_STD_SECAM_LC;
1291 } else {
1292 break;
1293 }
1294 id &= ~curr_id;
1295 }
1296 if (i<=index)
1297 return -EINVAL;
1298
1299 v4l2_video_std_construct(p, curr_id,v4l2_norm_to_name(curr_id));
1300 p->index = index;
1301
1302 dbgarg (cmd, "index=%d, id=%Ld, name=%s, fps=%d/%d, "
1303 "framelines=%d\n", p->index,
1304 (unsigned long long)p->id, p->name,
1305 p->frameperiod.numerator,
1306 p->frameperiod.denominator,
1307 p->framelines);
1308
1309 ret=0;
1310 break;
1311 }
1312 case VIDIOC_G_STD:
1313 {
1314 v4l2_std_id *id = arg;
1315
1316 *id = vfd->current_norm;
1317
1318 dbgarg (cmd, "value=%08Lx\n", (long long unsigned) *id);
1319
1320 ret=0;
1321 break;
1322 }
1323 case VIDIOC_S_STD:
1324 {
1325 v4l2_std_id *id = arg,norm;
1326
1327 dbgarg (cmd, "value=%08Lx\n", (long long unsigned) *id);
1328
1329 norm = (*id) & vfd->tvnorms;
1330 if ( vfd->tvnorms && !norm) /* Check if std is supported */
1331 break;
1332
1333 /* Calls the specific handler */
1334 if (vfd->vidioc_s_std)
1335 ret=vfd->vidioc_s_std(file, fh, &norm);
1336 else
1337 ret=-EINVAL;
1338
1339 /* Updates standard information */
1340 if (ret>=0)
1341 vfd->current_norm=norm;
1342
1343 break;
1344 }
1345 case VIDIOC_QUERYSTD:
1346 {
1347 v4l2_std_id *p=arg;
1348
1349 if (!vfd->vidioc_querystd)
1350 break;
1351 ret=vfd->vidioc_querystd(file, fh, arg);
1352 if (!ret)
1353 dbgarg (cmd, "detected std=%08Lx\n",
1354 (unsigned long long)*p);
1355 break;
1356 }
1357 /* ------ input switching ---------- */
1358 /* FIXME: Inputs can be handled inside videodev2 */
1359 case VIDIOC_ENUMINPUT:
1360 {
1361 struct v4l2_input *p=arg;
1362 int i=p->index;
1363
1364 if (!vfd->vidioc_enum_input)
1365 break;
1366 memset(p, 0, sizeof(*p));
1367 p->index=i;
1368
1369 ret=vfd->vidioc_enum_input(file, fh, p);
1370 if (!ret)
1371 dbgarg (cmd, "index=%d, name=%s, type=%d, "
1372 "audioset=%d, "
1373 "tuner=%d, std=%08Lx, status=%d\n",
1374 p->index,p->name,p->type,p->audioset,
1375 p->tuner,
1376 (unsigned long long)p->std,
1377 p->status);
1378 break;
1379 }
1380 case VIDIOC_G_INPUT:
1381 {
1382 unsigned int *i = arg;
1383
1384 if (!vfd->vidioc_g_input)
1385 break;
1386 ret=vfd->vidioc_g_input(file, fh, i);
1387 if (!ret)
1388 dbgarg (cmd, "value=%d\n",*i);
1389 break;
1390 }
1391 case VIDIOC_S_INPUT:
1392 {
1393 unsigned int *i = arg;
1394
1395 if (!vfd->vidioc_s_input)
1396 break;
1397 dbgarg (cmd, "value=%d\n",*i);
1398 ret=vfd->vidioc_s_input(file, fh, *i);
1399 break;
1400 }
1401
1402 /* ------ output switching ---------- */
1403 case VIDIOC_G_OUTPUT:
1404 {
1405 unsigned int *i = arg;
1406
1407 if (!vfd->vidioc_g_output)
1408 break;
1409 ret=vfd->vidioc_g_output(file, fh, i);
1410 if (!ret)
1411 dbgarg (cmd, "value=%d\n",*i);
1412 break;
1413 }
1414 case VIDIOC_S_OUTPUT:
1415 {
1416 unsigned int *i = arg;
1417
1418 if (!vfd->vidioc_s_output)
1419 break;
1420 dbgarg (cmd, "value=%d\n",*i);
1421 ret=vfd->vidioc_s_output(file, fh, *i);
1422 break;
1423 }
1424
1425 /* --- controls ---------------------------------------------- */
1426 case VIDIOC_QUERYCTRL:
1427 {
1428 struct v4l2_queryctrl *p=arg;
1429
1430 if (!vfd->vidioc_queryctrl)
1431 break;
1432 ret=vfd->vidioc_queryctrl(file, fh, p);
1433
1434 if (!ret)
1435 dbgarg (cmd, "id=%d, type=%d, name=%s, "
1436 "min/max=%d/%d,"
1437 " step=%d, default=%d, flags=0x%08x\n",
1438 p->id,p->type,p->name,p->minimum,
1439 p->maximum,p->step,p->default_value,
1440 p->flags);
1441 break;
1442 }
1443 case VIDIOC_G_CTRL:
1444 {
1445 struct v4l2_control *p = arg;
1446
1447 if (!vfd->vidioc_g_ctrl)
1448 break;
1449 dbgarg(cmd, "Enum for index=%d\n", p->id);
1450
1451 ret=vfd->vidioc_g_ctrl(file, fh, p);
1452 if (!ret)
1453 dbgarg2 ( "id=%d, value=%d\n", p->id, p->value);
1454 break;
1455 }
1456 case VIDIOC_S_CTRL:
1457 {
1458 struct v4l2_control *p = arg;
1459
1460 if (!vfd->vidioc_s_ctrl)
1461 break;
1462 dbgarg (cmd, "id=%d, value=%d\n", p->id, p->value);
1463
1464 ret=vfd->vidioc_s_ctrl(file, fh, p);
1465 break;
1466 }
1467 case VIDIOC_G_EXT_CTRLS:
1468 {
1469 struct v4l2_ext_controls *p = arg;
1470
1471 if (vfd->vidioc_g_ext_ctrls) {
1472 dbgarg(cmd, "count=%d\n", p->count);
1473
1474 ret=vfd->vidioc_g_ext_ctrls(file, fh, p);
1475 }
1476 break;
1477 }
1478 case VIDIOC_S_EXT_CTRLS:
1479 {
1480 struct v4l2_ext_controls *p = arg;
1481
1482 if (vfd->vidioc_s_ext_ctrls) {
1483 dbgarg(cmd, "count=%d\n", p->count);
1484
1485 ret=vfd->vidioc_s_ext_ctrls(file, fh, p);
1486 }
1487 break;
1488 }
1489 case VIDIOC_TRY_EXT_CTRLS:
1490 {
1491 struct v4l2_ext_controls *p = arg;
1492
1493 if (vfd->vidioc_try_ext_ctrls) {
1494 dbgarg(cmd, "count=%d\n", p->count);
1495
1496 ret=vfd->vidioc_try_ext_ctrls(file, fh, p);
1497 }
1498 break;
1499 }
1500 case VIDIOC_QUERYMENU:
1501 {
1502 struct v4l2_querymenu *p=arg;
1503 if (!vfd->vidioc_querymenu)
1504 break;
1505 ret=vfd->vidioc_querymenu(file, fh, p);
1506 if (!ret)
1507 dbgarg (cmd, "id=%d, index=%d, name=%s\n",
1508 p->id,p->index,p->name);
1509 break;
1510 }
1511 /* --- audio ---------------------------------------------- */
1512 case VIDIOC_ENUMAUDIO:
1513 {
1514 struct v4l2_audio *p=arg;
1515
1516 if (!vfd->vidioc_enumaudio)
1517 break;
1518 dbgarg(cmd, "Enum for index=%d\n", p->index);
1519 ret=vfd->vidioc_enumaudio(file, fh, p);
1520 if (!ret)
1521 dbgarg2("index=%d, name=%s, capability=%d, "
1522 "mode=%d\n",p->index,p->name,
1523 p->capability, p->mode);
1524 break;
1525 }
1526 case VIDIOC_G_AUDIO:
1527 {
1528 struct v4l2_audio *p=arg;
1529 __u32 index=p->index;
1530
1531 if (!vfd->vidioc_g_audio)
1532 break;
1533
1534 memset(p,0,sizeof(*p));
1535 p->index=index;
1536 dbgarg(cmd, "Get for index=%d\n", p->index);
1537 ret=vfd->vidioc_g_audio(file, fh, p);
1538 if (!ret)
1539 dbgarg2("index=%d, name=%s, capability=%d, "
1540 "mode=%d\n",p->index,
1541 p->name,p->capability, p->mode);
1542 break;
1543 }
1544 case VIDIOC_S_AUDIO:
1545 {
1546 struct v4l2_audio *p=arg;
1547
1548 if (!vfd->vidioc_s_audio)
1549 break;
1550 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1551 "mode=%d\n", p->index, p->name,
1552 p->capability, p->mode);
1553 ret=vfd->vidioc_s_audio(file, fh, p);
1554 break;
1555 }
1556 case VIDIOC_ENUMAUDOUT:
1557 {
1558 struct v4l2_audioout *p=arg;
1559
1560 if (!vfd->vidioc_enumaudout)
1561 break;
1562 dbgarg(cmd, "Enum for index=%d\n", p->index);
1563 ret=vfd->vidioc_enumaudout(file, fh, p);
1564 if (!ret)
1565 dbgarg2("index=%d, name=%s, capability=%d, "
1566 "mode=%d\n", p->index, p->name,
1567 p->capability,p->mode);
1568 break;
1569 }
1570 case VIDIOC_G_AUDOUT:
1571 {
1572 struct v4l2_audioout *p=arg;
1573
1574 if (!vfd->vidioc_g_audout)
1575 break;
1576 dbgarg(cmd, "Enum for index=%d\n", p->index);
1577 ret=vfd->vidioc_g_audout(file, fh, p);
1578 if (!ret)
1579 dbgarg2("index=%d, name=%s, capability=%d, "
1580 "mode=%d\n", p->index, p->name,
1581 p->capability,p->mode);
1582 break;
1583 }
1584 case VIDIOC_S_AUDOUT:
1585 {
1586 struct v4l2_audioout *p=arg;
1587
1588 if (!vfd->vidioc_s_audout)
1589 break;
1590 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1591 "mode=%d\n", p->index, p->name,
1592 p->capability,p->mode);
1593
1594 ret=vfd->vidioc_s_audout(file, fh, p);
1595 break;
1596 }
1597 case VIDIOC_G_MODULATOR:
1598 {
1599 struct v4l2_modulator *p=arg;
1600 if (!vfd->vidioc_g_modulator)
1601 break;
1602 ret=vfd->vidioc_g_modulator(file, fh, p);
1603 if (!ret)
1604 dbgarg(cmd, "index=%d, name=%s, "
1605 "capability=%d, rangelow=%d,"
1606 " rangehigh=%d, txsubchans=%d\n",
1607 p->index, p->name,p->capability,
1608 p->rangelow, p->rangehigh,
1609 p->txsubchans);
1610 break;
1611 }
1612 case VIDIOC_S_MODULATOR:
1613 {
1614 struct v4l2_modulator *p=arg;
1615 if (!vfd->vidioc_s_modulator)
1616 break;
1617 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1618 "rangelow=%d, rangehigh=%d, txsubchans=%d\n",
1619 p->index, p->name,p->capability,p->rangelow,
1620 p->rangehigh,p->txsubchans);
1621 ret=vfd->vidioc_s_modulator(file, fh, p);
1622 break;
1623 }
1624 case VIDIOC_G_CROP:
1625 {
1626 struct v4l2_crop *p=arg;
1627 if (!vfd->vidioc_g_crop)
1628 break;
1629 ret=vfd->vidioc_g_crop(file, fh, p);
1630 if (!ret) {
1631 dbgarg(cmd, "type=%d\n", p->type);
1632 dbgrect(vfd, "", &p->c);
1633 }
1634 break;
1635 }
1636 case VIDIOC_S_CROP:
1637 {
1638 struct v4l2_crop *p=arg;
1639 if (!vfd->vidioc_s_crop)
1640 break;
1641 dbgarg(cmd, "type=%d\n", p->type);
1642 dbgrect(vfd, "", &p->c);
1643 ret=vfd->vidioc_s_crop(file, fh, p);
1644 break;
1645 }
1646 case VIDIOC_CROPCAP:
1647 {
1648 struct v4l2_cropcap *p=arg;
1649 /*FIXME: Should also show v4l2_fract pixelaspect */
1650 if (!vfd->vidioc_cropcap)
1651 break;
1652 dbgarg(cmd, "type=%d\n", p->type);
1653 dbgrect(vfd, "bounds ", &p->bounds);
1654 dbgrect(vfd, "defrect ", &p->defrect);
1655 ret=vfd->vidioc_cropcap(file, fh, p);
1656 break;
1657 }
1658 case VIDIOC_G_JPEGCOMP:
1659 {
1660 struct v4l2_jpegcompression *p=arg;
1661 if (!vfd->vidioc_g_jpegcomp)
1662 break;
1663 ret=vfd->vidioc_g_jpegcomp(file, fh, p);
1664 if (!ret)
1665 dbgarg (cmd, "quality=%d, APPn=%d, "
1666 "APP_len=%d, COM_len=%d, "
1667 "jpeg_markers=%d\n",
1668 p->quality,p->APPn,p->APP_len,
1669 p->COM_len,p->jpeg_markers);
1670 break;
1671 }
1672 case VIDIOC_S_JPEGCOMP:
1673 {
1674 struct v4l2_jpegcompression *p=arg;
1675 if (!vfd->vidioc_g_jpegcomp)
1676 break;
1677 dbgarg (cmd, "quality=%d, APPn=%d, APP_len=%d, "
1678 "COM_len=%d, jpeg_markers=%d\n",
1679 p->quality,p->APPn,p->APP_len,
1680 p->COM_len,p->jpeg_markers);
1681 ret=vfd->vidioc_s_jpegcomp(file, fh, p);
1682 break;
1683 }
1684 case VIDIOC_G_ENC_INDEX:
1685 {
1686 struct v4l2_enc_idx *p=arg;
1687
1688 if (!vfd->vidioc_g_enc_index)
1689 break;
1690 ret=vfd->vidioc_g_enc_index(file, fh, p);
1691 if (!ret)
1692 dbgarg (cmd, "entries=%d, entries_cap=%d\n",
1693 p->entries,p->entries_cap);
1694 break;
1695 }
1696 case VIDIOC_ENCODER_CMD:
1697 {
1698 struct v4l2_encoder_cmd *p=arg;
1699
1700 if (!vfd->vidioc_encoder_cmd)
1701 break;
1702 ret=vfd->vidioc_encoder_cmd(file, fh, p);
1703 if (!ret)
1704 dbgarg (cmd, "cmd=%d, flags=%d\n",
1705 p->cmd,p->flags);
1706 break;
1707 }
1708 case VIDIOC_TRY_ENCODER_CMD:
1709 {
1710 struct v4l2_encoder_cmd *p=arg;
1711
1712 if (!vfd->vidioc_try_encoder_cmd)
1713 break;
1714 ret=vfd->vidioc_try_encoder_cmd(file, fh, p);
1715 if (!ret)
1716 dbgarg (cmd, "cmd=%d, flags=%d\n",
1717 p->cmd,p->flags);
1718 break;
1719 }
1720 case VIDIOC_G_PARM:
1721 {
1722 struct v4l2_streamparm *p=arg;
1723 __u32 type=p->type;
1724
1725 memset(p,0,sizeof(*p));
1726 p->type=type;
1727
1728 if (vfd->vidioc_g_parm) {
1729 ret=vfd->vidioc_g_parm(file, fh, p);
1730 } else {
1731 struct v4l2_standard s;
1732
1733 if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1734 return -EINVAL;
1735
1736 v4l2_video_std_construct(&s, vfd->current_norm,
1737 v4l2_norm_to_name(vfd->current_norm));
1738
1739 p->parm.capture.timeperframe = s.frameperiod;
1740 ret=0;
1741 }
1742
1743 dbgarg (cmd, "type=%d\n", p->type);
1744 break;
1745 }
1746 case VIDIOC_S_PARM:
1747 {
1748 struct v4l2_streamparm *p=arg;
1749 if (!vfd->vidioc_s_parm)
1750 break;
1751 dbgarg (cmd, "type=%d\n", p->type);
1752 ret=vfd->vidioc_s_parm(file, fh, p);
1753 break;
1754 }
1755 case VIDIOC_G_TUNER:
1756 {
1757 struct v4l2_tuner *p=arg;
1758 __u32 index=p->index;
1759
1760 if (!vfd->vidioc_g_tuner)
1761 break;
1762
1763 memset(p,0,sizeof(*p));
1764 p->index=index;
1765
1766 ret=vfd->vidioc_g_tuner(file, fh, p);
1767 if (!ret)
1768 dbgarg (cmd, "index=%d, name=%s, type=%d, "
1769 "capability=%d, rangelow=%d, "
1770 "rangehigh=%d, signal=%d, afc=%d, "
1771 "rxsubchans=%d, audmode=%d\n",
1772 p->index, p->name, p->type,
1773 p->capability, p->rangelow,
1774 p->rangehigh, p->rxsubchans,
1775 p->audmode, p->signal, p->afc);
1776 break;
1777 }
1778 case VIDIOC_S_TUNER:
1779 {
1780 struct v4l2_tuner *p=arg;
1781 if (!vfd->vidioc_s_tuner)
1782 break;
1783 dbgarg (cmd, "index=%d, name=%s, type=%d, "
1784 "capability=%d, rangelow=%d, rangehigh=%d, "
1785 "signal=%d, afc=%d, rxsubchans=%d, "
1786 "audmode=%d\n",p->index, p->name, p->type,
1787 p->capability, p->rangelow,p->rangehigh,
1788 p->rxsubchans, p->audmode, p->signal,
1789 p->afc);
1790 ret=vfd->vidioc_s_tuner(file, fh, p);
1791 break;
1792 }
1793 case VIDIOC_G_FREQUENCY:
1794 {
1795 struct v4l2_frequency *p=arg;
1796 if (!vfd->vidioc_g_frequency)
1797 break;
1798
1799 memset(p,0,sizeof(*p));
1800
1801 ret=vfd->vidioc_g_frequency(file, fh, p);
1802 if (!ret)
1803 dbgarg (cmd, "tuner=%d, type=%d, frequency=%d\n",
1804 p->tuner,p->type,p->frequency);
1805 break;
1806 }
1807 case VIDIOC_S_FREQUENCY:
1808 {
1809 struct v4l2_frequency *p=arg;
1810 if (!vfd->vidioc_s_frequency)
1811 break;
1812 dbgarg (cmd, "tuner=%d, type=%d, frequency=%d\n",
1813 p->tuner,p->type,p->frequency);
1814 ret=vfd->vidioc_s_frequency(file, fh, p);
1815 break;
1816 }
1817 case VIDIOC_G_SLICED_VBI_CAP:
1818 {
1819 struct v4l2_sliced_vbi_cap *p=arg;
1820 if (!vfd->vidioc_g_sliced_vbi_cap)
1821 break;
1822 ret=vfd->vidioc_g_sliced_vbi_cap(file, fh, p);
1823 if (!ret)
1824 dbgarg (cmd, "service_set=%d\n", p->service_set);
1825 break;
1826 }
1827 case VIDIOC_LOG_STATUS:
1828 {
1829 if (!vfd->vidioc_log_status)
1830 break;
1831 ret=vfd->vidioc_log_status(file, fh);
1832 break;
1833 }
1834 #ifdef CONFIG_VIDEO_ADV_DEBUG
1835 case VIDIOC_DBG_G_REGISTER:
1836 {
1837 struct v4l2_register *p=arg;
1838 if (!capable(CAP_SYS_ADMIN))
1839 ret=-EPERM;
1840 else if (vfd->vidioc_g_register)
1841 ret=vfd->vidioc_g_register(file, fh, p);
1842 break;
1843 }
1844 case VIDIOC_DBG_S_REGISTER:
1845 {
1846 struct v4l2_register *p=arg;
1847 if (!capable(CAP_SYS_ADMIN))
1848 ret=-EPERM;
1849 else if (vfd->vidioc_s_register)
1850 ret=vfd->vidioc_s_register(file, fh, p);
1851 break;
1852 }
1853 #endif
1854 case VIDIOC_G_CHIP_IDENT:
1855 {
1856 struct v4l2_chip_ident *p=arg;
1857 if (!vfd->vidioc_g_chip_ident)
1858 break;
1859 ret=vfd->vidioc_g_chip_ident(file, fh, p);
1860 if (!ret)
1861 dbgarg (cmd, "chip_ident=%u, revision=0x%x\n", p->ident, p->revision);
1862 break;
1863 }
1864 default:
1865 {
1866 if (!vfd->vidioc_default)
1867 break;
1868 ret = vfd->vidioc_default(file, fh, cmd, arg);
1869 break;
1870 }
1871 } /* switch */
1872
1873 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) {
1874 if (ret<0) {
1875 printk("%s: err: on ", vfd->name);
1876 v4l_print_ioctl(vfd->name, cmd);
1877 printk("\n");
1878 }
1879 }
1880
1881 return ret;
1882 }
1883
1884 int video_ioctl2 (struct inode *inode, struct file *file,
1885 unsigned int cmd, unsigned long arg)
1886 {
1887 char sbuf[128];
1888 void *mbuf = NULL;
1889 void *parg = NULL;
1890 int err = -EINVAL;
1891 int is_ext_ctrl;
1892 size_t ctrls_size = 0;
1893 void __user *user_ptr = NULL;
1894
1895 #ifdef __OLD_VIDIOC_
1896 cmd = video_fix_command(cmd);
1897 #endif
1898 is_ext_ctrl = (cmd == VIDIOC_S_EXT_CTRLS || cmd == VIDIOC_G_EXT_CTRLS ||
1899 cmd == VIDIOC_TRY_EXT_CTRLS);
1900
1901 /* Copy arguments into temp kernel buffer */
1902 switch (_IOC_DIR(cmd)) {
1903 case _IOC_NONE:
1904 parg = NULL;
1905 break;
1906 case _IOC_READ:
1907 case _IOC_WRITE:
1908 case (_IOC_WRITE | _IOC_READ):
1909 if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
1910 parg = sbuf;
1911 } else {
1912 /* too big to allocate from stack */
1913 mbuf = kmalloc(_IOC_SIZE(cmd),GFP_KERNEL);
1914 if (NULL == mbuf)
1915 return -ENOMEM;
1916 parg = mbuf;
1917 }
1918
1919 err = -EFAULT;
1920 if (_IOC_DIR(cmd) & _IOC_WRITE)
1921 if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
1922 goto out;
1923 break;
1924 }
1925
1926 if (is_ext_ctrl) {
1927 struct v4l2_ext_controls *p = parg;
1928
1929 /* In case of an error, tell the caller that it wasn't
1930 a specific control that caused it. */
1931 p->error_idx = p->count;
1932 user_ptr = (void __user *)p->controls;
1933 if (p->count) {
1934 ctrls_size = sizeof(struct v4l2_ext_control) * p->count;
1935 /* Note: v4l2_ext_controls fits in sbuf[] so mbuf is still NULL. */
1936 mbuf = kmalloc(ctrls_size, GFP_KERNEL);
1937 err = -ENOMEM;
1938 if (NULL == mbuf)
1939 goto out_ext_ctrl;
1940 err = -EFAULT;
1941 if (copy_from_user(mbuf, user_ptr, ctrls_size))
1942 goto out_ext_ctrl;
1943 p->controls = mbuf;
1944 }
1945 }
1946
1947 /* Handles IOCTL */
1948 err = __video_do_ioctl(inode, file, cmd, parg);
1949 if (err == -ENOIOCTLCMD)
1950 err = -EINVAL;
1951 if (is_ext_ctrl) {
1952 struct v4l2_ext_controls *p = parg;
1953
1954 p->controls = (void *)user_ptr;
1955 if (p->count && err == 0 && copy_to_user(user_ptr, mbuf, ctrls_size))
1956 err = -EFAULT;
1957 goto out_ext_ctrl;
1958 }
1959 if (err < 0)
1960 goto out;
1961
1962 out_ext_ctrl:
1963 /* Copy results into user buffer */
1964 switch (_IOC_DIR(cmd))
1965 {
1966 case _IOC_READ:
1967 case (_IOC_WRITE | _IOC_READ):
1968 if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
1969 err = -EFAULT;
1970 break;
1971 }
1972
1973 out:
1974 kfree(mbuf);
1975 return err;
1976 }
1977 EXPORT_SYMBOL(video_ioctl2);
1978
1979 static const struct file_operations video_fops;
1980
1981 /**
1982 * video_register_device - register video4linux devices
1983 * @vfd: video device structure we want to register
1984 * @type: type of device to register
1985 * @nr: which device number (0 == /dev/video0, 1 == /dev/video1, ...
1986 * -1 == first free)
1987 *
1988 * The registration code assigns minor numbers based on the type
1989 * requested. -ENFILE is returned in all the device slots for this
1990 * category are full. If not then the minor field is set and the
1991 * driver initialize function is called (if non %NULL).
1992 *
1993 * Zero is returned on success.
1994 *
1995 * Valid types are
1996 *
1997 * %VFL_TYPE_GRABBER - A frame grabber
1998 *
1999 * %VFL_TYPE_VTX - A teletext device
2000 *
2001 * %VFL_TYPE_VBI - Vertical blank data (undecoded)
2002 *
2003 * %VFL_TYPE_RADIO - A radio card
2004 */
2005
2006 int video_register_device(struct video_device *vfd, int type, int nr)
2007 {
2008 int i=0;
2009 int base;
2010 int end;
2011 int ret;
2012 char *name_base;
2013
2014 switch(type)
2015 {
2016 case VFL_TYPE_GRABBER:
2017 base=MINOR_VFL_TYPE_GRABBER_MIN;
2018 end=MINOR_VFL_TYPE_GRABBER_MAX+1;
2019 name_base = "video";
2020 break;
2021 case VFL_TYPE_VTX:
2022 base=MINOR_VFL_TYPE_VTX_MIN;
2023 end=MINOR_VFL_TYPE_VTX_MAX+1;
2024 name_base = "vtx";
2025 break;
2026 case VFL_TYPE_VBI:
2027 base=MINOR_VFL_TYPE_VBI_MIN;
2028 end=MINOR_VFL_TYPE_VBI_MAX+1;
2029 name_base = "vbi";
2030 break;
2031 case VFL_TYPE_RADIO:
2032 base=MINOR_VFL_TYPE_RADIO_MIN;
2033 end=MINOR_VFL_TYPE_RADIO_MAX+1;
2034 name_base = "radio";
2035 break;
2036 default:
2037 printk(KERN_ERR "%s called with unknown type: %d\n",
2038 __func__, type);
2039 return -1;
2040 }
2041
2042 /* pick a minor number */
2043 mutex_lock(&videodev_lock);
2044 if (nr >= 0 && nr < end-base) {
2045 /* use the one the driver asked for */
2046 i = base+nr;
2047 if (NULL != video_device[i]) {
2048 mutex_unlock(&videodev_lock);
2049 return -ENFILE;
2050 }
2051 } else {
2052 /* use first free */
2053 for(i=base;i<end;i++)
2054 if (NULL == video_device[i])
2055 break;
2056 if (i == end) {
2057 mutex_unlock(&videodev_lock);
2058 return -ENFILE;
2059 }
2060 }
2061 video_device[i]=vfd;
2062 vfd->minor=i;
2063 mutex_unlock(&videodev_lock);
2064 mutex_init(&vfd->lock);
2065
2066 /* sysfs class */
2067 memset(&vfd->class_dev, 0x00, sizeof(vfd->class_dev));
2068 if (vfd->dev)
2069 vfd->class_dev.parent = vfd->dev;
2070 vfd->class_dev.class = &video_class;
2071 vfd->class_dev.devt = MKDEV(VIDEO_MAJOR, vfd->minor);
2072 sprintf(vfd->class_dev.bus_id, "%s%d", name_base, i - base);
2073 ret = device_register(&vfd->class_dev);
2074 if (ret < 0) {
2075 printk(KERN_ERR "%s: device_register failed\n",
2076 __func__);
2077 goto fail_minor;
2078 }
2079
2080 #if 1
2081 /* needed until all drivers are fixed */
2082 if (!vfd->release)
2083 printk(KERN_WARNING "videodev: \"%s\" has no release callback. "
2084 "Please fix your driver for proper sysfs support, see "
2085 "http://lwn.net/Articles/36850/\n", vfd->name);
2086 #endif
2087 return 0;
2088
2089 fail_minor:
2090 mutex_lock(&videodev_lock);
2091 video_device[vfd->minor] = NULL;
2092 vfd->minor = -1;
2093 mutex_unlock(&videodev_lock);
2094 return ret;
2095 }
2096 EXPORT_SYMBOL(video_register_device);
2097
2098 /**
2099 * video_unregister_device - unregister a video4linux device
2100 * @vfd: the device to unregister
2101 *
2102 * This unregisters the passed device and deassigns the minor
2103 * number. Future open calls will be met with errors.
2104 */
2105
2106 void video_unregister_device(struct video_device *vfd)
2107 {
2108 mutex_lock(&videodev_lock);
2109 if(video_device[vfd->minor]!=vfd)
2110 panic("videodev: bad unregister");
2111
2112 video_device[vfd->minor]=NULL;
2113 device_unregister(&vfd->class_dev);
2114 mutex_unlock(&videodev_lock);
2115 }
2116 EXPORT_SYMBOL(video_unregister_device);
2117
2118 /*
2119 * Video fs operations
2120 */
2121 static const struct file_operations video_fops=
2122 {
2123 .owner = THIS_MODULE,
2124 .llseek = no_llseek,
2125 .open = video_open,
2126 };
2127
2128 /*
2129 * Initialise video for linux
2130 */
2131
2132 static int __init videodev_init(void)
2133 {
2134 int ret;
2135
2136 printk(KERN_INFO "Linux video capture interface: v2.00\n");
2137 if (register_chrdev(VIDEO_MAJOR, VIDEO_NAME, &video_fops)) {
2138 printk(KERN_WARNING "video_dev: unable to get major %d\n", VIDEO_MAJOR);
2139 return -EIO;
2140 }
2141
2142 ret = class_register(&video_class);
2143 if (ret < 0) {
2144 unregister_chrdev(VIDEO_MAJOR, VIDEO_NAME);
2145 printk(KERN_WARNING "video_dev: class_register failed\n");
2146 return -EIO;
2147 }
2148
2149 return 0;
2150 }
2151
2152 static void __exit videodev_exit(void)
2153 {
2154 class_unregister(&video_class);
2155 unregister_chrdev(VIDEO_MAJOR, VIDEO_NAME);
2156 }
2157
2158 module_init(videodev_init)
2159 module_exit(videodev_exit)
2160
2161 MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@infradead.org>");
2162 MODULE_DESCRIPTION("Device registrar for Video4Linux drivers v2");
2163 MODULE_LICENSE("GPL");
2164
2165
2166 /*
2167 * Local variables:
2168 * c-basic-offset: 8
2169 * End:
2170 */
Mirror for ia64_pv_ops.git