2 * Video capture interface for Linux version 2
4 * A generic video device interface for the LINUX operating system
5 * using a set of device structures/vectors for low level operations.
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.
12 * Authors: Alan Cox, <alan@redhat.com> (version 1)
13 * Mauro Carvalho Chehab <mchehab@infradead.org> (version 2)
15 * Fixes: 20000516 Claudio Matsuoka <claudio@conectiva.com>
16 * - Added procfs support
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); \
26 #define dbgarg2(fmt, arg...) \
27 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) \
28 printk(KERN_DEBUG "%s: " fmt, vfd->name, ## arg);
30 #include <linux/module.h>
31 #include <linux/types.h>
32 #include <linux/kernel.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 <linux/smp_lock.h>
40 #include <asm/uaccess.h>
41 #include <asm/system.h>
43 #define __OLD_VIDIOC_ /* To allow fixing old calls*/
44 #include <linux/videodev2.h>
46 #ifdef CONFIG_VIDEO_V4L1
47 #include <linux/videodev.h>
49 #include <media/v4l2-common.h>
50 #include <linux/video_decoder.h>
52 #define VIDEO_NUM_DEVICES 256
53 #define VIDEO_NAME "video4linux"
60 static const struct std_descr standards[] = {
61 { V4L2_STD_NTSC, "NTSC" },
62 { V4L2_STD_NTSC_M, "NTSC-M" },
63 { V4L2_STD_NTSC_M_JP, "NTSC-M-JP" },
64 { V4L2_STD_NTSC_M_KR, "NTSC-M-KR" },
65 { V4L2_STD_NTSC_443, "NTSC-443" },
66 { V4L2_STD_PAL, "PAL" },
67 { V4L2_STD_PAL_BG, "PAL-BG" },
68 { V4L2_STD_PAL_B, "PAL-B" },
69 { V4L2_STD_PAL_B1, "PAL-B1" },
70 { V4L2_STD_PAL_G, "PAL-G" },
71 { V4L2_STD_PAL_H, "PAL-H" },
72 { V4L2_STD_PAL_I, "PAL-I" },
73 { V4L2_STD_PAL_DK, "PAL-DK" },
74 { V4L2_STD_PAL_D, "PAL-D" },
75 { V4L2_STD_PAL_D1, "PAL-D1" },
76 { V4L2_STD_PAL_K, "PAL-K" },
77 { V4L2_STD_PAL_M, "PAL-M" },
78 { V4L2_STD_PAL_N, "PAL-N" },
79 { V4L2_STD_PAL_Nc, "PAL-Nc" },
80 { V4L2_STD_PAL_60, "PAL-60" },
81 { V4L2_STD_SECAM, "SECAM" },
82 { V4L2_STD_SECAM_B, "SECAM-B" },
83 { V4L2_STD_SECAM_G, "SECAM-G" },
84 { V4L2_STD_SECAM_H, "SECAM-H" },
85 { V4L2_STD_SECAM_DK, "SECAM-DK" },
86 { V4L2_STD_SECAM_D, "SECAM-D" },
87 { V4L2_STD_SECAM_K, "SECAM-K" },
88 { V4L2_STD_SECAM_K1, "SECAM-K1" },
89 { V4L2_STD_SECAM_L, "SECAM-L" },
90 { V4L2_STD_SECAM_LC, "SECAM-Lc" },
94 /* video4linux standard ID conversion to standard name
96 const char *v4l2_norm_to_name(v4l2_std_id id)
101 /* HACK: ppc32 architecture doesn't have __ucmpdi2 function to handle
102 64 bit comparations. So, on that architecture, with some gcc
103 variants, compilation fails. Currently, the max value is 30bit wide.
107 for (i = 0; standards[i].std; i++)
108 if (myid == standards[i].std)
110 return standards[i].descr;
112 EXPORT_SYMBOL(v4l2_norm_to_name);
114 /* Fill in the fields of a v4l2_standard structure according to the
115 'id' and 'transmission' parameters. Returns negative on error. */
116 int v4l2_video_std_construct(struct v4l2_standard *vs,
117 int id, const char *name)
119 u32 index = vs->index;
121 memset(vs, 0, sizeof(struct v4l2_standard));
124 if (id & V4L2_STD_525_60) {
125 vs->frameperiod.numerator = 1001;
126 vs->frameperiod.denominator = 30000;
127 vs->framelines = 525;
129 vs->frameperiod.numerator = 1;
130 vs->frameperiod.denominator = 25;
131 vs->framelines = 625;
133 strlcpy(vs->name, name, sizeof(vs->name));
136 EXPORT_SYMBOL(v4l2_video_std_construct);
138 /* ----------------------------------------------------------------- */
139 /* some arrays for pretty-printing debug messages of enum types */
141 char *v4l2_field_names[] = {
142 [V4L2_FIELD_ANY] = "any",
143 [V4L2_FIELD_NONE] = "none",
144 [V4L2_FIELD_TOP] = "top",
145 [V4L2_FIELD_BOTTOM] = "bottom",
146 [V4L2_FIELD_INTERLACED] = "interlaced",
147 [V4L2_FIELD_SEQ_TB] = "seq-tb",
148 [V4L2_FIELD_SEQ_BT] = "seq-bt",
149 [V4L2_FIELD_ALTERNATE] = "alternate",
150 [V4L2_FIELD_INTERLACED_TB] = "interlaced-tb",
151 [V4L2_FIELD_INTERLACED_BT] = "interlaced-bt",
153 EXPORT_SYMBOL(v4l2_field_names);
155 char *v4l2_type_names[] = {
156 [V4L2_BUF_TYPE_VIDEO_CAPTURE] = "video-cap",
157 [V4L2_BUF_TYPE_VIDEO_OVERLAY] = "video-over",
158 [V4L2_BUF_TYPE_VIDEO_OUTPUT] = "video-out",
159 [V4L2_BUF_TYPE_VBI_CAPTURE] = "vbi-cap",
160 [V4L2_BUF_TYPE_VBI_OUTPUT] = "vbi-out",
161 [V4L2_BUF_TYPE_SLICED_VBI_CAPTURE] = "sliced-vbi-cap",
162 [V4L2_BUF_TYPE_SLICED_VBI_OUTPUT] = "sliced-vbi-out",
163 [V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY] = "video-out-over",
165 EXPORT_SYMBOL(v4l2_type_names);
167 static char *v4l2_memory_names[] = {
168 [V4L2_MEMORY_MMAP] = "mmap",
169 [V4L2_MEMORY_USERPTR] = "userptr",
170 [V4L2_MEMORY_OVERLAY] = "overlay",
173 #define prt_names(a, arr) ((((a) >= 0) && ((a) < ARRAY_SIZE(arr))) ? \
176 /* ------------------------------------------------------------------ */
177 /* debug help functions */
179 #ifdef CONFIG_VIDEO_V4L1_COMPAT
180 static const char *v4l1_ioctls[] = {
181 [_IOC_NR(VIDIOCGCAP)] = "VIDIOCGCAP",
182 [_IOC_NR(VIDIOCGCHAN)] = "VIDIOCGCHAN",
183 [_IOC_NR(VIDIOCSCHAN)] = "VIDIOCSCHAN",
184 [_IOC_NR(VIDIOCGTUNER)] = "VIDIOCGTUNER",
185 [_IOC_NR(VIDIOCSTUNER)] = "VIDIOCSTUNER",
186 [_IOC_NR(VIDIOCGPICT)] = "VIDIOCGPICT",
187 [_IOC_NR(VIDIOCSPICT)] = "VIDIOCSPICT",
188 [_IOC_NR(VIDIOCCAPTURE)] = "VIDIOCCAPTURE",
189 [_IOC_NR(VIDIOCGWIN)] = "VIDIOCGWIN",
190 [_IOC_NR(VIDIOCSWIN)] = "VIDIOCSWIN",
191 [_IOC_NR(VIDIOCGFBUF)] = "VIDIOCGFBUF",
192 [_IOC_NR(VIDIOCSFBUF)] = "VIDIOCSFBUF",
193 [_IOC_NR(VIDIOCKEY)] = "VIDIOCKEY",
194 [_IOC_NR(VIDIOCGFREQ)] = "VIDIOCGFREQ",
195 [_IOC_NR(VIDIOCSFREQ)] = "VIDIOCSFREQ",
196 [_IOC_NR(VIDIOCGAUDIO)] = "VIDIOCGAUDIO",
197 [_IOC_NR(VIDIOCSAUDIO)] = "VIDIOCSAUDIO",
198 [_IOC_NR(VIDIOCSYNC)] = "VIDIOCSYNC",
199 [_IOC_NR(VIDIOCMCAPTURE)] = "VIDIOCMCAPTURE",
200 [_IOC_NR(VIDIOCGMBUF)] = "VIDIOCGMBUF",
201 [_IOC_NR(VIDIOCGUNIT)] = "VIDIOCGUNIT",
202 [_IOC_NR(VIDIOCGCAPTURE)] = "VIDIOCGCAPTURE",
203 [_IOC_NR(VIDIOCSCAPTURE)] = "VIDIOCSCAPTURE",
204 [_IOC_NR(VIDIOCSPLAYMODE)] = "VIDIOCSPLAYMODE",
205 [_IOC_NR(VIDIOCSWRITEMODE)] = "VIDIOCSWRITEMODE",
206 [_IOC_NR(VIDIOCGPLAYINFO)] = "VIDIOCGPLAYINFO",
207 [_IOC_NR(VIDIOCSMICROCODE)] = "VIDIOCSMICROCODE",
208 [_IOC_NR(VIDIOCGVBIFMT)] = "VIDIOCGVBIFMT",
209 [_IOC_NR(VIDIOCSVBIFMT)] = "VIDIOCSVBIFMT"
211 #define V4L1_IOCTLS ARRAY_SIZE(v4l1_ioctls)
214 static const char *v4l2_ioctls[] = {
215 [_IOC_NR(VIDIOC_QUERYCAP)] = "VIDIOC_QUERYCAP",
216 [_IOC_NR(VIDIOC_RESERVED)] = "VIDIOC_RESERVED",
217 [_IOC_NR(VIDIOC_ENUM_FMT)] = "VIDIOC_ENUM_FMT",
218 [_IOC_NR(VIDIOC_G_FMT)] = "VIDIOC_G_FMT",
219 [_IOC_NR(VIDIOC_S_FMT)] = "VIDIOC_S_FMT",
220 [_IOC_NR(VIDIOC_REQBUFS)] = "VIDIOC_REQBUFS",
221 [_IOC_NR(VIDIOC_QUERYBUF)] = "VIDIOC_QUERYBUF",
222 [_IOC_NR(VIDIOC_G_FBUF)] = "VIDIOC_G_FBUF",
223 [_IOC_NR(VIDIOC_S_FBUF)] = "VIDIOC_S_FBUF",
224 [_IOC_NR(VIDIOC_OVERLAY)] = "VIDIOC_OVERLAY",
225 [_IOC_NR(VIDIOC_QBUF)] = "VIDIOC_QBUF",
226 [_IOC_NR(VIDIOC_DQBUF)] = "VIDIOC_DQBUF",
227 [_IOC_NR(VIDIOC_STREAMON)] = "VIDIOC_STREAMON",
228 [_IOC_NR(VIDIOC_STREAMOFF)] = "VIDIOC_STREAMOFF",
229 [_IOC_NR(VIDIOC_G_PARM)] = "VIDIOC_G_PARM",
230 [_IOC_NR(VIDIOC_S_PARM)] = "VIDIOC_S_PARM",
231 [_IOC_NR(VIDIOC_G_STD)] = "VIDIOC_G_STD",
232 [_IOC_NR(VIDIOC_S_STD)] = "VIDIOC_S_STD",
233 [_IOC_NR(VIDIOC_ENUMSTD)] = "VIDIOC_ENUMSTD",
234 [_IOC_NR(VIDIOC_ENUMINPUT)] = "VIDIOC_ENUMINPUT",
235 [_IOC_NR(VIDIOC_G_CTRL)] = "VIDIOC_G_CTRL",
236 [_IOC_NR(VIDIOC_S_CTRL)] = "VIDIOC_S_CTRL",
237 [_IOC_NR(VIDIOC_G_TUNER)] = "VIDIOC_G_TUNER",
238 [_IOC_NR(VIDIOC_S_TUNER)] = "VIDIOC_S_TUNER",
239 [_IOC_NR(VIDIOC_G_AUDIO)] = "VIDIOC_G_AUDIO",
240 [_IOC_NR(VIDIOC_S_AUDIO)] = "VIDIOC_S_AUDIO",
241 [_IOC_NR(VIDIOC_QUERYCTRL)] = "VIDIOC_QUERYCTRL",
242 [_IOC_NR(VIDIOC_QUERYMENU)] = "VIDIOC_QUERYMENU",
243 [_IOC_NR(VIDIOC_G_INPUT)] = "VIDIOC_G_INPUT",
244 [_IOC_NR(VIDIOC_S_INPUT)] = "VIDIOC_S_INPUT",
245 [_IOC_NR(VIDIOC_G_OUTPUT)] = "VIDIOC_G_OUTPUT",
246 [_IOC_NR(VIDIOC_S_OUTPUT)] = "VIDIOC_S_OUTPUT",
247 [_IOC_NR(VIDIOC_ENUMOUTPUT)] = "VIDIOC_ENUMOUTPUT",
248 [_IOC_NR(VIDIOC_G_AUDOUT)] = "VIDIOC_G_AUDOUT",
249 [_IOC_NR(VIDIOC_S_AUDOUT)] = "VIDIOC_S_AUDOUT",
250 [_IOC_NR(VIDIOC_G_MODULATOR)] = "VIDIOC_G_MODULATOR",
251 [_IOC_NR(VIDIOC_S_MODULATOR)] = "VIDIOC_S_MODULATOR",
252 [_IOC_NR(VIDIOC_G_FREQUENCY)] = "VIDIOC_G_FREQUENCY",
253 [_IOC_NR(VIDIOC_S_FREQUENCY)] = "VIDIOC_S_FREQUENCY",
254 [_IOC_NR(VIDIOC_CROPCAP)] = "VIDIOC_CROPCAP",
255 [_IOC_NR(VIDIOC_G_CROP)] = "VIDIOC_G_CROP",
256 [_IOC_NR(VIDIOC_S_CROP)] = "VIDIOC_S_CROP",
257 [_IOC_NR(VIDIOC_G_JPEGCOMP)] = "VIDIOC_G_JPEGCOMP",
258 [_IOC_NR(VIDIOC_S_JPEGCOMP)] = "VIDIOC_S_JPEGCOMP",
259 [_IOC_NR(VIDIOC_QUERYSTD)] = "VIDIOC_QUERYSTD",
260 [_IOC_NR(VIDIOC_TRY_FMT)] = "VIDIOC_TRY_FMT",
261 [_IOC_NR(VIDIOC_ENUMAUDIO)] = "VIDIOC_ENUMAUDIO",
262 [_IOC_NR(VIDIOC_ENUMAUDOUT)] = "VIDIOC_ENUMAUDOUT",
263 [_IOC_NR(VIDIOC_G_PRIORITY)] = "VIDIOC_G_PRIORITY",
264 [_IOC_NR(VIDIOC_S_PRIORITY)] = "VIDIOC_S_PRIORITY",
265 [_IOC_NR(VIDIOC_G_SLICED_VBI_CAP)] = "VIDIOC_G_SLICED_VBI_CAP",
266 [_IOC_NR(VIDIOC_LOG_STATUS)] = "VIDIOC_LOG_STATUS",
267 [_IOC_NR(VIDIOC_G_EXT_CTRLS)] = "VIDIOC_G_EXT_CTRLS",
268 [_IOC_NR(VIDIOC_S_EXT_CTRLS)] = "VIDIOC_S_EXT_CTRLS",
269 [_IOC_NR(VIDIOC_TRY_EXT_CTRLS)] = "VIDIOC_TRY_EXT_CTRLS",
271 [_IOC_NR(VIDIOC_ENUM_FRAMESIZES)] = "VIDIOC_ENUM_FRAMESIZES",
272 [_IOC_NR(VIDIOC_ENUM_FRAMEINTERVALS)] = "VIDIOC_ENUM_FRAMEINTERVALS",
273 [_IOC_NR(VIDIOC_G_ENC_INDEX)] = "VIDIOC_G_ENC_INDEX",
274 [_IOC_NR(VIDIOC_ENCODER_CMD)] = "VIDIOC_ENCODER_CMD",
275 [_IOC_NR(VIDIOC_TRY_ENCODER_CMD)] = "VIDIOC_TRY_ENCODER_CMD",
277 [_IOC_NR(VIDIOC_DBG_S_REGISTER)] = "VIDIOC_DBG_S_REGISTER",
278 [_IOC_NR(VIDIOC_DBG_G_REGISTER)] = "VIDIOC_DBG_G_REGISTER",
280 [_IOC_NR(VIDIOC_G_CHIP_IDENT)] = "VIDIOC_G_CHIP_IDENT",
281 [_IOC_NR(VIDIOC_S_HW_FREQ_SEEK)] = "VIDIOC_S_HW_FREQ_SEEK",
284 #define V4L2_IOCTLS ARRAY_SIZE(v4l2_ioctls)
286 static const char *v4l2_int_ioctls[] = {
287 #ifdef CONFIG_VIDEO_V4L1_COMPAT
288 [_IOC_NR(DECODER_GET_CAPABILITIES)] = "DECODER_GET_CAPABILITIES",
289 [_IOC_NR(DECODER_GET_STATUS)] = "DECODER_GET_STATUS",
290 [_IOC_NR(DECODER_SET_NORM)] = "DECODER_SET_NORM",
291 [_IOC_NR(DECODER_SET_INPUT)] = "DECODER_SET_INPUT",
292 [_IOC_NR(DECODER_SET_OUTPUT)] = "DECODER_SET_OUTPUT",
293 [_IOC_NR(DECODER_ENABLE_OUTPUT)] = "DECODER_ENABLE_OUTPUT",
294 [_IOC_NR(DECODER_SET_PICTURE)] = "DECODER_SET_PICTURE",
295 [_IOC_NR(DECODER_SET_GPIO)] = "DECODER_SET_GPIO",
296 [_IOC_NR(DECODER_INIT)] = "DECODER_INIT",
297 [_IOC_NR(DECODER_SET_VBI_BYPASS)] = "DECODER_SET_VBI_BYPASS",
298 [_IOC_NR(DECODER_DUMP)] = "DECODER_DUMP",
300 [_IOC_NR(AUDC_SET_RADIO)] = "AUDC_SET_RADIO",
302 [_IOC_NR(TUNER_SET_TYPE_ADDR)] = "TUNER_SET_TYPE_ADDR",
303 [_IOC_NR(TUNER_SET_STANDBY)] = "TUNER_SET_STANDBY",
304 [_IOC_NR(TUNER_SET_CONFIG)] = "TUNER_SET_CONFIG",
306 [_IOC_NR(VIDIOC_INT_S_TUNER_MODE)] = "VIDIOC_INT_S_TUNER_MODE",
307 [_IOC_NR(VIDIOC_INT_RESET)] = "VIDIOC_INT_RESET",
308 [_IOC_NR(VIDIOC_INT_AUDIO_CLOCK_FREQ)] = "VIDIOC_INT_AUDIO_CLOCK_FREQ",
309 [_IOC_NR(VIDIOC_INT_DECODE_VBI_LINE)] = "VIDIOC_INT_DECODE_VBI_LINE",
310 [_IOC_NR(VIDIOC_INT_S_VBI_DATA)] = "VIDIOC_INT_S_VBI_DATA",
311 [_IOC_NR(VIDIOC_INT_G_VBI_DATA)] = "VIDIOC_INT_G_VBI_DATA",
312 [_IOC_NR(VIDIOC_INT_I2S_CLOCK_FREQ)] = "VIDIOC_INT_I2S_CLOCK_FREQ",
313 [_IOC_NR(VIDIOC_INT_S_STANDBY)] = "VIDIOC_INT_S_STANDBY",
314 [_IOC_NR(VIDIOC_INT_S_AUDIO_ROUTING)] = "VIDIOC_INT_S_AUDIO_ROUTING",
315 [_IOC_NR(VIDIOC_INT_G_AUDIO_ROUTING)] = "VIDIOC_INT_G_AUDIO_ROUTING",
316 [_IOC_NR(VIDIOC_INT_S_VIDEO_ROUTING)] = "VIDIOC_INT_S_VIDEO_ROUTING",
317 [_IOC_NR(VIDIOC_INT_G_VIDEO_ROUTING)] = "VIDIOC_INT_G_VIDEO_ROUTING",
318 [_IOC_NR(VIDIOC_INT_S_CRYSTAL_FREQ)] = "VIDIOC_INT_S_CRYSTAL_FREQ",
319 [_IOC_NR(VIDIOC_INT_INIT)] = "VIDIOC_INT_INIT",
320 [_IOC_NR(VIDIOC_INT_G_STD_OUTPUT)] = "VIDIOC_INT_G_STD_OUTPUT",
321 [_IOC_NR(VIDIOC_INT_S_STD_OUTPUT)] = "VIDIOC_INT_S_STD_OUTPUT",
323 #define V4L2_INT_IOCTLS ARRAY_SIZE(v4l2_int_ioctls)
325 /* Common ioctl debug function. This function can be used by
326 external ioctl messages as well as internal V4L ioctl */
327 void v4l_printk_ioctl(unsigned int cmd)
331 switch (_IOC_TYPE(cmd)) {
333 if (_IOC_NR(cmd) >= V4L2_INT_IOCTLS) {
337 printk("%s", v4l2_int_ioctls[_IOC_NR(cmd)]);
339 #ifdef CONFIG_VIDEO_V4L1_COMPAT
341 if (_IOC_NR(cmd) >= V4L1_IOCTLS) {
345 printk("%s", v4l1_ioctls[_IOC_NR(cmd)]);
349 if (_IOC_NR(cmd) >= V4L2_IOCTLS) {
353 printk("%s", v4l2_ioctls[_IOC_NR(cmd)]);
359 switch (_IOC_DIR(cmd)) {
360 case _IOC_NONE: dir = "--"; break;
361 case _IOC_READ: dir = "r-"; break;
362 case _IOC_WRITE: dir = "-w"; break;
363 case _IOC_READ | _IOC_WRITE: dir = "rw"; break;
364 default: dir = "*ERR*"; break;
366 printk("%s ioctl '%c', dir=%s, #%d (0x%08x)",
367 type, _IOC_TYPE(cmd), dir, _IOC_NR(cmd), cmd);
369 EXPORT_SYMBOL(v4l_printk_ioctl);
375 static ssize_t show_name(struct device *cd,
376 struct device_attribute *attr, char *buf)
378 struct video_device *vfd = container_of(cd, struct video_device,
380 return sprintf(buf, "%.*s\n", (int)sizeof(vfd->name), vfd->name);
383 struct video_device *video_device_alloc(void)
385 struct video_device *vfd;
387 vfd = kzalloc(sizeof(*vfd),GFP_KERNEL);
390 EXPORT_SYMBOL(video_device_alloc);
392 void video_device_release(struct video_device *vfd)
396 EXPORT_SYMBOL(video_device_release);
398 static void video_release(struct device *cd)
400 struct video_device *vfd = container_of(cd, struct video_device,
404 /* needed until all drivers are fixed */
411 static struct device_attribute video_device_attrs[] = {
412 __ATTR(name, S_IRUGO, show_name, NULL),
416 static struct class video_class = {
418 .dev_attrs = video_device_attrs,
419 .dev_release = video_release,
426 static struct video_device *video_device[VIDEO_NUM_DEVICES];
427 static DEFINE_MUTEX(videodev_lock);
429 struct video_device* video_devdata(struct file *file)
431 return video_device[iminor(file->f_path.dentry->d_inode)];
433 EXPORT_SYMBOL(video_devdata);
436 * Open a video device - FIXME: Obsoleted
438 static int video_open(struct inode *inode, struct file *file)
440 unsigned int minor = iminor(inode);
442 struct video_device *vfl;
443 const struct file_operations *old_fops;
445 if(minor>=VIDEO_NUM_DEVICES)
448 mutex_lock(&videodev_lock);
449 vfl=video_device[minor];
451 mutex_unlock(&videodev_lock);
452 request_module("char-major-%d-%d", VIDEO_MAJOR, minor);
453 mutex_lock(&videodev_lock);
454 vfl=video_device[minor];
456 mutex_unlock(&videodev_lock);
461 old_fops = file->f_op;
462 file->f_op = fops_get(vfl->fops);
464 err = file->f_op->open(inode,file);
466 fops_put(file->f_op);
467 file->f_op = fops_get(old_fops);
470 mutex_unlock(&videodev_lock);
476 * helper function -- handles userspace copying for ioctl arguments
481 video_fix_command(unsigned int cmd)
484 case VIDIOC_OVERLAY_OLD:
485 cmd = VIDIOC_OVERLAY;
487 case VIDIOC_S_PARM_OLD:
490 case VIDIOC_S_CTRL_OLD:
493 case VIDIOC_G_AUDIO_OLD:
494 cmd = VIDIOC_G_AUDIO;
496 case VIDIOC_G_AUDOUT_OLD:
497 cmd = VIDIOC_G_AUDOUT;
499 case VIDIOC_CROPCAP_OLD:
500 cmd = VIDIOC_CROPCAP;
508 * Obsolete usercopy function - Should be removed soon
511 video_usercopy(struct inode *inode, struct file *file,
512 unsigned int cmd, unsigned long arg,
513 int (*func)(struct inode *inode, struct file *file,
514 unsigned int cmd, void *arg))
521 size_t ctrls_size = 0;
522 void __user *user_ptr = NULL;
525 cmd = video_fix_command(cmd);
527 is_ext_ctrl = (cmd == VIDIOC_S_EXT_CTRLS || cmd == VIDIOC_G_EXT_CTRLS ||
528 cmd == VIDIOC_TRY_EXT_CTRLS);
530 /* Copy arguments into temp kernel buffer */
531 switch (_IOC_DIR(cmd)) {
537 case (_IOC_WRITE | _IOC_READ):
538 if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
541 /* too big to allocate from stack */
542 mbuf = kmalloc(_IOC_SIZE(cmd),GFP_KERNEL);
549 if (_IOC_DIR(cmd) & _IOC_WRITE)
550 if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
555 struct v4l2_ext_controls *p = parg;
557 /* In case of an error, tell the caller that it wasn't
558 a specific control that caused it. */
559 p->error_idx = p->count;
560 user_ptr = (void __user *)p->controls;
562 ctrls_size = sizeof(struct v4l2_ext_control) * p->count;
563 /* Note: v4l2_ext_controls fits in sbuf[] so mbuf is still NULL. */
564 mbuf = kmalloc(ctrls_size, GFP_KERNEL);
569 if (copy_from_user(mbuf, user_ptr, ctrls_size))
576 err = func(inode, file, cmd, parg);
577 if (err == -ENOIOCTLCMD)
580 struct v4l2_ext_controls *p = parg;
582 p->controls = (void *)user_ptr;
583 if (p->count && err == 0 && copy_to_user(user_ptr, mbuf, ctrls_size))
591 /* Copy results into user buffer */
592 switch (_IOC_DIR(cmd))
595 case (_IOC_WRITE | _IOC_READ):
596 if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
605 EXPORT_SYMBOL(video_usercopy);
608 * open/release helper functions -- handle exclusive opens
609 * Should be removed soon
611 int video_exclusive_open(struct inode *inode, struct file *file)
613 struct video_device *vfl = video_devdata(file);
616 mutex_lock(&vfl->lock);
622 mutex_unlock(&vfl->lock);
625 EXPORT_SYMBOL(video_exclusive_open);
627 int video_exclusive_release(struct inode *inode, struct file *file)
629 struct video_device *vfl = video_devdata(file);
634 EXPORT_SYMBOL(video_exclusive_release);
636 static void dbgbuf(unsigned int cmd, struct video_device *vfd,
637 struct v4l2_buffer *p)
639 struct v4l2_timecode *tc=&p->timecode;
641 dbgarg (cmd, "%02ld:%02d:%02d.%08ld index=%d, type=%s, "
642 "bytesused=%d, flags=0x%08d, "
643 "field=%0d, sequence=%d, memory=%s, offset/userptr=0x%08lx, length=%d\n",
644 (p->timestamp.tv_sec/3600),
645 (int)(p->timestamp.tv_sec/60)%60,
646 (int)(p->timestamp.tv_sec%60),
647 p->timestamp.tv_usec,
649 prt_names(p->type, v4l2_type_names),
650 p->bytesused, p->flags,
651 p->field, p->sequence,
652 prt_names(p->memory, v4l2_memory_names),
653 p->m.userptr, p->length);
654 dbgarg2 ("timecode= %02d:%02d:%02d type=%d, "
655 "flags=0x%08d, frames=%d, userbits=0x%08x\n",
656 tc->hours,tc->minutes,tc->seconds,
657 tc->type, tc->flags, tc->frames, *(__u32 *) tc->userbits);
660 static inline void dbgrect(struct video_device *vfd, char *s,
663 dbgarg2 ("%sRect start at %dx%d, size= %dx%d\n", s, r->left, r->top,
664 r->width, r->height);
667 static inline void v4l_print_pix_fmt (struct video_device *vfd,
668 struct v4l2_pix_format *fmt)
670 dbgarg2 ("width=%d, height=%d, format=%c%c%c%c, field=%s, "
671 "bytesperline=%d sizeimage=%d, colorspace=%d\n",
672 fmt->width,fmt->height,
673 (fmt->pixelformat & 0xff),
674 (fmt->pixelformat >> 8) & 0xff,
675 (fmt->pixelformat >> 16) & 0xff,
676 (fmt->pixelformat >> 24) & 0xff,
677 prt_names(fmt->field, v4l2_field_names),
678 fmt->bytesperline, fmt->sizeimage, fmt->colorspace);
682 static int check_fmt (struct video_device *vfd, enum v4l2_buf_type type)
685 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
686 if (vfd->vidioc_try_fmt_cap)
689 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
690 if (vfd->vidioc_try_fmt_overlay)
693 case V4L2_BUF_TYPE_VBI_CAPTURE:
694 if (vfd->vidioc_try_fmt_vbi)
697 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
698 if (vfd->vidioc_try_fmt_vbi_output)
701 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
702 if (vfd->vidioc_try_fmt_vbi_capture)
705 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
706 if (vfd->vidioc_try_fmt_video_output)
709 case V4L2_BUF_TYPE_VBI_OUTPUT:
710 if (vfd->vidioc_try_fmt_vbi_output)
713 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
714 if (vfd->vidioc_try_fmt_output_overlay)
717 case V4L2_BUF_TYPE_PRIVATE:
718 if (vfd->vidioc_try_fmt_type_private)
725 static int __video_do_ioctl(struct inode *inode, struct file *file,
726 unsigned int cmd, void *arg)
728 struct video_device *vfd = video_devdata(file);
729 void *fh = file->private_data;
732 if ( (vfd->debug & V4L2_DEBUG_IOCTL) &&
733 !(vfd->debug & V4L2_DEBUG_IOCTL_ARG)) {
734 v4l_print_ioctl(vfd->name, cmd);
738 #ifdef CONFIG_VIDEO_V4L1_COMPAT
739 /***********************************************************
740 Handles calls to the obsoleted V4L1 API
741 Due to the nature of VIDIOCGMBUF, each driver that supports
742 V4L1 should implement its own handler for this ioctl.
743 ***********************************************************/
745 /* --- streaming capture ------------------------------------- */
746 if (cmd == VIDIOCGMBUF) {
747 struct video_mbuf *p=arg;
749 memset(p, 0, sizeof(*p));
751 if (!vfd->vidiocgmbuf)
753 ret=vfd->vidiocgmbuf(file, fh, p);
755 dbgarg (cmd, "size=%d, frames=%d, offsets=0x%08lx\n",
757 (unsigned long)p->offsets);
761 /********************************************************
762 All other V4L1 calls are handled by v4l1_compat module.
763 Those calls will be translated into V4L2 calls, and
764 __video_do_ioctl will be called again, with one or more
766 ********************************************************/
767 if (_IOC_TYPE(cmd)=='v')
768 return v4l_compat_translate_ioctl(inode,file,cmd,arg,
773 /* --- capabilities ------------------------------------------ */
774 case VIDIOC_QUERYCAP:
776 struct v4l2_capability *cap = (struct v4l2_capability*)arg;
777 memset(cap, 0, sizeof(*cap));
779 if (!vfd->vidioc_querycap)
782 ret=vfd->vidioc_querycap(file, fh, cap);
784 dbgarg (cmd, "driver=%s, card=%s, bus=%s, "
786 "capabilities=0x%08x\n",
787 cap->driver,cap->card,cap->bus_info,
793 /* --- priority ------------------------------------------ */
794 case VIDIOC_G_PRIORITY:
796 enum v4l2_priority *p=arg;
798 if (!vfd->vidioc_g_priority)
800 ret=vfd->vidioc_g_priority(file, fh, p);
802 dbgarg(cmd, "priority is %d\n", *p);
805 case VIDIOC_S_PRIORITY:
807 enum v4l2_priority *p=arg;
809 if (!vfd->vidioc_s_priority)
811 dbgarg(cmd, "setting priority to %d\n", *p);
812 ret=vfd->vidioc_s_priority(file, fh, *p);
816 /* --- capture ioctls ---------------------------------------- */
817 case VIDIOC_ENUM_FMT:
819 struct v4l2_fmtdesc *f = arg;
820 enum v4l2_buf_type type;
825 memset(f,0,sizeof(*f));
830 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
831 if (vfd->vidioc_enum_fmt_cap)
832 ret=vfd->vidioc_enum_fmt_cap(file, fh, f);
834 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
835 if (vfd->vidioc_enum_fmt_overlay)
836 ret=vfd->vidioc_enum_fmt_overlay(file, fh, f);
838 case V4L2_BUF_TYPE_VBI_CAPTURE:
839 if (vfd->vidioc_enum_fmt_vbi)
840 ret=vfd->vidioc_enum_fmt_vbi(file, fh, f);
842 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
843 if (vfd->vidioc_enum_fmt_sliced_vbi_output)
844 ret = vfd->vidioc_enum_fmt_sliced_vbi_output(file,
847 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
848 if (vfd->vidioc_enum_fmt_vbi_capture)
849 ret=vfd->vidioc_enum_fmt_vbi_capture(file,
852 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
853 if (vfd->vidioc_enum_fmt_video_output)
854 ret=vfd->vidioc_enum_fmt_video_output(file,
857 case V4L2_BUF_TYPE_VBI_OUTPUT:
858 if (vfd->vidioc_enum_fmt_vbi_output)
859 ret=vfd->vidioc_enum_fmt_vbi_output(file,
862 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
863 if (vfd->vidioc_enum_fmt_output_overlay)
864 ret=vfd->vidioc_enum_fmt_output_overlay(file, fh, f);
866 case V4L2_BUF_TYPE_PRIVATE:
867 if (vfd->vidioc_enum_fmt_type_private)
868 ret=vfd->vidioc_enum_fmt_type_private(file,
873 dbgarg (cmd, "index=%d, type=%d, flags=%d, "
874 "pixelformat=%c%c%c%c, description='%s'\n",
875 f->index, f->type, f->flags,
876 (f->pixelformat & 0xff),
877 (f->pixelformat >> 8) & 0xff,
878 (f->pixelformat >> 16) & 0xff,
879 (f->pixelformat >> 24) & 0xff,
885 struct v4l2_format *f = (struct v4l2_format *)arg;
887 memset(f->fmt.raw_data, 0, sizeof(f->fmt.raw_data));
889 /* FIXME: Should be one dump per type */
890 dbgarg(cmd, "type=%s\n", prt_names(f->type, v4l2_type_names));
893 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
894 if (vfd->vidioc_g_fmt_cap)
895 ret=vfd->vidioc_g_fmt_cap(file, fh, f);
897 v4l_print_pix_fmt(vfd,&f->fmt.pix);
899 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
900 if (vfd->vidioc_g_fmt_overlay)
901 ret=vfd->vidioc_g_fmt_overlay(file, fh, f);
903 case V4L2_BUF_TYPE_VBI_CAPTURE:
904 if (vfd->vidioc_g_fmt_vbi)
905 ret=vfd->vidioc_g_fmt_vbi(file, fh, f);
907 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
908 if (vfd->vidioc_g_fmt_sliced_vbi_output)
909 ret = vfd->vidioc_g_fmt_sliced_vbi_output(file, fh, f);
911 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
912 if (vfd->vidioc_g_fmt_vbi_capture)
913 ret=vfd->vidioc_g_fmt_vbi_capture(file, fh, f);
915 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
916 if (vfd->vidioc_g_fmt_video_output)
917 ret=vfd->vidioc_g_fmt_video_output(file,
920 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
921 if (vfd->vidioc_g_fmt_output_overlay)
922 ret=vfd->vidioc_g_fmt_output_overlay(file, fh, f);
924 case V4L2_BUF_TYPE_VBI_OUTPUT:
925 if (vfd->vidioc_g_fmt_vbi_output)
926 ret=vfd->vidioc_g_fmt_vbi_output(file, fh, f);
928 case V4L2_BUF_TYPE_PRIVATE:
929 if (vfd->vidioc_g_fmt_type_private)
930 ret=vfd->vidioc_g_fmt_type_private(file,
939 struct v4l2_format *f = (struct v4l2_format *)arg;
941 /* FIXME: Should be one dump per type */
942 dbgarg (cmd, "type=%s\n", prt_names(f->type,
946 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
947 v4l_print_pix_fmt(vfd,&f->fmt.pix);
948 if (vfd->vidioc_s_fmt_cap)
949 ret=vfd->vidioc_s_fmt_cap(file, fh, f);
951 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
952 if (vfd->vidioc_s_fmt_overlay)
953 ret=vfd->vidioc_s_fmt_overlay(file, fh, f);
955 case V4L2_BUF_TYPE_VBI_CAPTURE:
956 if (vfd->vidioc_s_fmt_vbi)
957 ret=vfd->vidioc_s_fmt_vbi(file, fh, f);
959 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
960 if (vfd->vidioc_s_fmt_sliced_vbi_output)
961 ret = vfd->vidioc_s_fmt_sliced_vbi_output(file, fh, f);
963 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
964 if (vfd->vidioc_s_fmt_vbi_capture)
965 ret=vfd->vidioc_s_fmt_vbi_capture(file, fh, f);
967 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
968 if (vfd->vidioc_s_fmt_video_output)
969 ret=vfd->vidioc_s_fmt_video_output(file,
972 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
973 if (vfd->vidioc_s_fmt_output_overlay)
974 ret=vfd->vidioc_s_fmt_output_overlay(file, fh, f);
976 case V4L2_BUF_TYPE_VBI_OUTPUT:
977 if (vfd->vidioc_s_fmt_vbi_output)
978 ret=vfd->vidioc_s_fmt_vbi_output(file,
981 case V4L2_BUF_TYPE_PRIVATE:
982 if (vfd->vidioc_s_fmt_type_private)
983 ret=vfd->vidioc_s_fmt_type_private(file,
991 struct v4l2_format *f = (struct v4l2_format *)arg;
993 /* FIXME: Should be one dump per type */
994 dbgarg (cmd, "type=%s\n", prt_names(f->type,
997 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
998 if (vfd->vidioc_try_fmt_cap)
999 ret=vfd->vidioc_try_fmt_cap(file, fh, f);
1001 v4l_print_pix_fmt(vfd,&f->fmt.pix);
1003 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
1004 if (vfd->vidioc_try_fmt_overlay)
1005 ret=vfd->vidioc_try_fmt_overlay(file, fh, f);
1007 case V4L2_BUF_TYPE_VBI_CAPTURE:
1008 if (vfd->vidioc_try_fmt_vbi)
1009 ret=vfd->vidioc_try_fmt_vbi(file, fh, f);
1011 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
1012 if (vfd->vidioc_try_fmt_sliced_vbi_output)
1013 ret = vfd->vidioc_try_fmt_sliced_vbi_output(file,
1016 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
1017 if (vfd->vidioc_try_fmt_vbi_capture)
1018 ret=vfd->vidioc_try_fmt_vbi_capture(file,
1021 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
1022 if (vfd->vidioc_try_fmt_video_output)
1023 ret=vfd->vidioc_try_fmt_video_output(file,
1026 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
1027 if (vfd->vidioc_try_fmt_output_overlay)
1028 ret=vfd->vidioc_try_fmt_output_overlay(file, fh, f);
1030 case V4L2_BUF_TYPE_VBI_OUTPUT:
1031 if (vfd->vidioc_try_fmt_vbi_output)
1032 ret=vfd->vidioc_try_fmt_vbi_output(file,
1035 case V4L2_BUF_TYPE_PRIVATE:
1036 if (vfd->vidioc_try_fmt_type_private)
1037 ret=vfd->vidioc_try_fmt_type_private(file,
1044 /* FIXME: Those buf reqs could be handled here,
1045 with some changes on videobuf to allow its header to be included at
1046 videodev2.h or being merged at videodev2.
1048 case VIDIOC_REQBUFS:
1050 struct v4l2_requestbuffers *p=arg;
1052 if (!vfd->vidioc_reqbufs)
1054 ret = check_fmt (vfd, p->type);
1058 ret=vfd->vidioc_reqbufs(file, fh, p);
1059 dbgarg (cmd, "count=%d, type=%s, memory=%s\n",
1061 prt_names(p->type, v4l2_type_names),
1062 prt_names(p->memory, v4l2_memory_names));
1065 case VIDIOC_QUERYBUF:
1067 struct v4l2_buffer *p=arg;
1069 if (!vfd->vidioc_querybuf)
1071 ret = check_fmt (vfd, p->type);
1075 ret=vfd->vidioc_querybuf(file, fh, p);
1082 struct v4l2_buffer *p=arg;
1084 if (!vfd->vidioc_qbuf)
1086 ret = check_fmt (vfd, p->type);
1090 ret=vfd->vidioc_qbuf(file, fh, p);
1097 struct v4l2_buffer *p=arg;
1098 if (!vfd->vidioc_dqbuf)
1100 ret = check_fmt (vfd, p->type);
1104 ret=vfd->vidioc_dqbuf(file, fh, p);
1109 case VIDIOC_OVERLAY:
1113 if (!vfd->vidioc_overlay)
1115 dbgarg (cmd, "value=%d\n",*i);
1116 ret=vfd->vidioc_overlay(file, fh, *i);
1121 struct v4l2_framebuffer *p=arg;
1122 if (!vfd->vidioc_g_fbuf)
1124 ret=vfd->vidioc_g_fbuf(file, fh, arg);
1126 dbgarg (cmd, "capability=%d, flags=%d, base=0x%08lx\n",
1127 p->capability,p->flags,
1128 (unsigned long)p->base);
1129 v4l_print_pix_fmt (vfd, &p->fmt);
1135 struct v4l2_framebuffer *p=arg;
1136 if (!vfd->vidioc_s_fbuf)
1139 dbgarg (cmd, "capability=%d, flags=%d, base=0x%08lx\n",
1140 p->capability,p->flags,(unsigned long)p->base);
1141 v4l_print_pix_fmt (vfd, &p->fmt);
1142 ret=vfd->vidioc_s_fbuf(file, fh, arg);
1146 case VIDIOC_STREAMON:
1148 enum v4l2_buf_type i = *(int *)arg;
1149 if (!vfd->vidioc_streamon)
1151 dbgarg(cmd, "type=%s\n", prt_names(i, v4l2_type_names));
1152 ret=vfd->vidioc_streamon(file, fh,i);
1155 case VIDIOC_STREAMOFF:
1157 enum v4l2_buf_type i = *(int *)arg;
1159 if (!vfd->vidioc_streamoff)
1161 dbgarg(cmd, "type=%s\n", prt_names(i, v4l2_type_names));
1162 ret=vfd->vidioc_streamoff(file, fh, i);
1165 /* ---------- tv norms ---------- */
1166 case VIDIOC_ENUMSTD:
1168 struct v4l2_standard *p = arg;
1169 v4l2_std_id id = vfd->tvnorms, curr_id = 0;
1170 unsigned int index = p->index, i, j = 0;
1171 const char *descr = "";
1173 /* Return norm array in a canonical way */
1174 for (i = 0; i <= index && id; i++) {
1175 /* last std value in the standards array is 0, so this
1176 while always ends there since (id & 0) == 0. */
1177 while ((id & standards[j].std) != standards[j].std)
1179 curr_id = standards[j].std;
1180 descr = standards[j].descr;
1184 if (curr_id != V4L2_STD_PAL &&
1185 curr_id != V4L2_STD_SECAM &&
1186 curr_id != V4L2_STD_NTSC)
1192 v4l2_video_std_construct(p, curr_id, descr);
1195 dbgarg(cmd, "index=%d, id=%Ld, name=%s, fps=%d/%d, "
1196 "framelines=%d\n", p->index,
1197 (unsigned long long)p->id, p->name,
1198 p->frameperiod.numerator,
1199 p->frameperiod.denominator,
1207 v4l2_std_id *id = arg;
1210 /* Calls the specific handler */
1211 if (vfd->vidioc_g_std)
1212 ret = vfd->vidioc_g_std(file, fh, id);
1214 *id = vfd->current_norm;
1217 dbgarg(cmd, "value=%08Lx\n", (long long unsigned)*id);
1222 v4l2_std_id *id = arg,norm;
1224 dbgarg (cmd, "value=%08Lx\n", (long long unsigned) *id);
1226 norm = (*id) & vfd->tvnorms;
1227 if ( vfd->tvnorms && !norm) /* Check if std is supported */
1230 /* Calls the specific handler */
1231 if (vfd->vidioc_s_std)
1232 ret=vfd->vidioc_s_std(file, fh, &norm);
1236 /* Updates standard information */
1238 vfd->current_norm=norm;
1242 case VIDIOC_QUERYSTD:
1246 if (!vfd->vidioc_querystd)
1248 ret=vfd->vidioc_querystd(file, fh, arg);
1250 dbgarg (cmd, "detected std=%08Lx\n",
1251 (unsigned long long)*p);
1254 /* ------ input switching ---------- */
1255 /* FIXME: Inputs can be handled inside videodev2 */
1256 case VIDIOC_ENUMINPUT:
1258 struct v4l2_input *p=arg;
1261 if (!vfd->vidioc_enum_input)
1263 memset(p, 0, sizeof(*p));
1266 ret=vfd->vidioc_enum_input(file, fh, p);
1268 dbgarg (cmd, "index=%d, name=%s, type=%d, "
1270 "tuner=%d, std=%08Lx, status=%d\n",
1271 p->index,p->name,p->type,p->audioset,
1273 (unsigned long long)p->std,
1277 case VIDIOC_G_INPUT:
1279 unsigned int *i = arg;
1281 if (!vfd->vidioc_g_input)
1283 ret=vfd->vidioc_g_input(file, fh, i);
1285 dbgarg (cmd, "value=%d\n",*i);
1288 case VIDIOC_S_INPUT:
1290 unsigned int *i = arg;
1292 if (!vfd->vidioc_s_input)
1294 dbgarg (cmd, "value=%d\n",*i);
1295 ret=vfd->vidioc_s_input(file, fh, *i);
1299 /* ------ output switching ---------- */
1300 case VIDIOC_ENUMOUTPUT:
1302 struct v4l2_output *p = arg;
1305 if (!vfd->vidioc_enum_output)
1307 memset(p, 0, sizeof(*p));
1310 ret = vfd->vidioc_enum_output(file, fh, p);
1312 dbgarg(cmd, "index=%d, name=%s, type=%d, "
1314 "modulator=%d, std=%08Lx\n",
1315 p->index, p->name, p->type, p->audioset,
1316 p->modulator, (unsigned long long)p->std);
1319 case VIDIOC_G_OUTPUT:
1321 unsigned int *i = arg;
1323 if (!vfd->vidioc_g_output)
1325 ret=vfd->vidioc_g_output(file, fh, i);
1327 dbgarg (cmd, "value=%d\n",*i);
1330 case VIDIOC_S_OUTPUT:
1332 unsigned int *i = arg;
1334 if (!vfd->vidioc_s_output)
1336 dbgarg (cmd, "value=%d\n",*i);
1337 ret=vfd->vidioc_s_output(file, fh, *i);
1341 /* --- controls ---------------------------------------------- */
1342 case VIDIOC_QUERYCTRL:
1344 struct v4l2_queryctrl *p=arg;
1346 if (!vfd->vidioc_queryctrl)
1348 ret=vfd->vidioc_queryctrl(file, fh, p);
1351 dbgarg (cmd, "id=%d, type=%d, name=%s, "
1353 " step=%d, default=%d, flags=0x%08x\n",
1354 p->id,p->type,p->name,p->minimum,
1355 p->maximum,p->step,p->default_value,
1361 struct v4l2_control *p = arg;
1363 if (!vfd->vidioc_g_ctrl)
1365 dbgarg(cmd, "Enum for index=%d\n", p->id);
1367 ret=vfd->vidioc_g_ctrl(file, fh, p);
1369 dbgarg2 ( "id=%d, value=%d\n", p->id, p->value);
1374 struct v4l2_control *p = arg;
1376 if (!vfd->vidioc_s_ctrl)
1378 dbgarg (cmd, "id=%d, value=%d\n", p->id, p->value);
1380 ret=vfd->vidioc_s_ctrl(file, fh, p);
1383 case VIDIOC_G_EXT_CTRLS:
1385 struct v4l2_ext_controls *p = arg;
1387 if (vfd->vidioc_g_ext_ctrls) {
1388 dbgarg(cmd, "count=%d\n", p->count);
1390 ret=vfd->vidioc_g_ext_ctrls(file, fh, p);
1394 case VIDIOC_S_EXT_CTRLS:
1396 struct v4l2_ext_controls *p = arg;
1398 if (vfd->vidioc_s_ext_ctrls) {
1399 dbgarg(cmd, "count=%d\n", p->count);
1401 ret=vfd->vidioc_s_ext_ctrls(file, fh, p);
1405 case VIDIOC_TRY_EXT_CTRLS:
1407 struct v4l2_ext_controls *p = arg;
1409 if (vfd->vidioc_try_ext_ctrls) {
1410 dbgarg(cmd, "count=%d\n", p->count);
1412 ret=vfd->vidioc_try_ext_ctrls(file, fh, p);
1416 case VIDIOC_QUERYMENU:
1418 struct v4l2_querymenu *p=arg;
1419 if (!vfd->vidioc_querymenu)
1421 ret=vfd->vidioc_querymenu(file, fh, p);
1423 dbgarg (cmd, "id=%d, index=%d, name=%s\n",
1424 p->id,p->index,p->name);
1427 /* --- audio ---------------------------------------------- */
1428 case VIDIOC_ENUMAUDIO:
1430 struct v4l2_audio *p=arg;
1432 if (!vfd->vidioc_enumaudio)
1434 dbgarg(cmd, "Enum for index=%d\n", p->index);
1435 ret=vfd->vidioc_enumaudio(file, fh, p);
1437 dbgarg2("index=%d, name=%s, capability=%d, "
1438 "mode=%d\n",p->index,p->name,
1439 p->capability, p->mode);
1442 case VIDIOC_G_AUDIO:
1444 struct v4l2_audio *p=arg;
1445 __u32 index=p->index;
1447 if (!vfd->vidioc_g_audio)
1450 memset(p,0,sizeof(*p));
1452 dbgarg(cmd, "Get for index=%d\n", p->index);
1453 ret=vfd->vidioc_g_audio(file, fh, p);
1455 dbgarg2("index=%d, name=%s, capability=%d, "
1456 "mode=%d\n",p->index,
1457 p->name,p->capability, p->mode);
1460 case VIDIOC_S_AUDIO:
1462 struct v4l2_audio *p=arg;
1464 if (!vfd->vidioc_s_audio)
1466 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1467 "mode=%d\n", p->index, p->name,
1468 p->capability, p->mode);
1469 ret=vfd->vidioc_s_audio(file, fh, p);
1472 case VIDIOC_ENUMAUDOUT:
1474 struct v4l2_audioout *p=arg;
1476 if (!vfd->vidioc_enumaudout)
1478 dbgarg(cmd, "Enum for index=%d\n", p->index);
1479 ret=vfd->vidioc_enumaudout(file, fh, p);
1481 dbgarg2("index=%d, name=%s, capability=%d, "
1482 "mode=%d\n", p->index, p->name,
1483 p->capability,p->mode);
1486 case VIDIOC_G_AUDOUT:
1488 struct v4l2_audioout *p=arg;
1490 if (!vfd->vidioc_g_audout)
1492 dbgarg(cmd, "Enum for index=%d\n", p->index);
1493 ret=vfd->vidioc_g_audout(file, fh, p);
1495 dbgarg2("index=%d, name=%s, capability=%d, "
1496 "mode=%d\n", p->index, p->name,
1497 p->capability,p->mode);
1500 case VIDIOC_S_AUDOUT:
1502 struct v4l2_audioout *p=arg;
1504 if (!vfd->vidioc_s_audout)
1506 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1507 "mode=%d\n", p->index, p->name,
1508 p->capability,p->mode);
1510 ret=vfd->vidioc_s_audout(file, fh, p);
1513 case VIDIOC_G_MODULATOR:
1515 struct v4l2_modulator *p=arg;
1516 if (!vfd->vidioc_g_modulator)
1518 ret=vfd->vidioc_g_modulator(file, fh, p);
1520 dbgarg(cmd, "index=%d, name=%s, "
1521 "capability=%d, rangelow=%d,"
1522 " rangehigh=%d, txsubchans=%d\n",
1523 p->index, p->name,p->capability,
1524 p->rangelow, p->rangehigh,
1528 case VIDIOC_S_MODULATOR:
1530 struct v4l2_modulator *p=arg;
1531 if (!vfd->vidioc_s_modulator)
1533 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1534 "rangelow=%d, rangehigh=%d, txsubchans=%d\n",
1535 p->index, p->name,p->capability,p->rangelow,
1536 p->rangehigh,p->txsubchans);
1537 ret=vfd->vidioc_s_modulator(file, fh, p);
1542 struct v4l2_crop *p=arg;
1543 if (!vfd->vidioc_g_crop)
1545 ret=vfd->vidioc_g_crop(file, fh, p);
1547 dbgarg(cmd, "type=%d\n", p->type);
1548 dbgrect(vfd, "", &p->c);
1554 struct v4l2_crop *p=arg;
1555 if (!vfd->vidioc_s_crop)
1557 dbgarg(cmd, "type=%d\n", p->type);
1558 dbgrect(vfd, "", &p->c);
1559 ret=vfd->vidioc_s_crop(file, fh, p);
1562 case VIDIOC_CROPCAP:
1564 struct v4l2_cropcap *p=arg;
1565 /*FIXME: Should also show v4l2_fract pixelaspect */
1566 if (!vfd->vidioc_cropcap)
1568 dbgarg(cmd, "type=%d\n", p->type);
1569 dbgrect(vfd, "bounds ", &p->bounds);
1570 dbgrect(vfd, "defrect ", &p->defrect);
1571 ret=vfd->vidioc_cropcap(file, fh, p);
1574 case VIDIOC_G_JPEGCOMP:
1576 struct v4l2_jpegcompression *p=arg;
1577 if (!vfd->vidioc_g_jpegcomp)
1579 ret=vfd->vidioc_g_jpegcomp(file, fh, p);
1581 dbgarg (cmd, "quality=%d, APPn=%d, "
1582 "APP_len=%d, COM_len=%d, "
1583 "jpeg_markers=%d\n",
1584 p->quality,p->APPn,p->APP_len,
1585 p->COM_len,p->jpeg_markers);
1588 case VIDIOC_S_JPEGCOMP:
1590 struct v4l2_jpegcompression *p=arg;
1591 if (!vfd->vidioc_g_jpegcomp)
1593 dbgarg (cmd, "quality=%d, APPn=%d, APP_len=%d, "
1594 "COM_len=%d, jpeg_markers=%d\n",
1595 p->quality,p->APPn,p->APP_len,
1596 p->COM_len,p->jpeg_markers);
1597 ret=vfd->vidioc_s_jpegcomp(file, fh, p);
1600 case VIDIOC_G_ENC_INDEX:
1602 struct v4l2_enc_idx *p=arg;
1604 if (!vfd->vidioc_g_enc_index)
1606 ret=vfd->vidioc_g_enc_index(file, fh, p);
1608 dbgarg (cmd, "entries=%d, entries_cap=%d\n",
1609 p->entries,p->entries_cap);
1612 case VIDIOC_ENCODER_CMD:
1614 struct v4l2_encoder_cmd *p=arg;
1616 if (!vfd->vidioc_encoder_cmd)
1618 ret=vfd->vidioc_encoder_cmd(file, fh, p);
1620 dbgarg (cmd, "cmd=%d, flags=%d\n",
1624 case VIDIOC_TRY_ENCODER_CMD:
1626 struct v4l2_encoder_cmd *p=arg;
1628 if (!vfd->vidioc_try_encoder_cmd)
1630 ret=vfd->vidioc_try_encoder_cmd(file, fh, p);
1632 dbgarg (cmd, "cmd=%d, flags=%d\n",
1638 struct v4l2_streamparm *p=arg;
1641 memset(p,0,sizeof(*p));
1644 if (vfd->vidioc_g_parm) {
1645 ret=vfd->vidioc_g_parm(file, fh, p);
1647 struct v4l2_standard s;
1649 if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1652 v4l2_video_std_construct(&s, vfd->current_norm,
1653 v4l2_norm_to_name(vfd->current_norm));
1655 p->parm.capture.timeperframe = s.frameperiod;
1659 dbgarg (cmd, "type=%d\n", p->type);
1664 struct v4l2_streamparm *p=arg;
1665 if (!vfd->vidioc_s_parm)
1667 dbgarg (cmd, "type=%d\n", p->type);
1668 ret=vfd->vidioc_s_parm(file, fh, p);
1671 case VIDIOC_G_TUNER:
1673 struct v4l2_tuner *p=arg;
1674 __u32 index=p->index;
1676 if (!vfd->vidioc_g_tuner)
1679 memset(p,0,sizeof(*p));
1682 ret=vfd->vidioc_g_tuner(file, fh, p);
1684 dbgarg (cmd, "index=%d, name=%s, type=%d, "
1685 "capability=%d, rangelow=%d, "
1686 "rangehigh=%d, signal=%d, afc=%d, "
1687 "rxsubchans=%d, audmode=%d\n",
1688 p->index, p->name, p->type,
1689 p->capability, p->rangelow,
1690 p->rangehigh, p->rxsubchans,
1691 p->audmode, p->signal, p->afc);
1694 case VIDIOC_S_TUNER:
1696 struct v4l2_tuner *p=arg;
1697 if (!vfd->vidioc_s_tuner)
1699 dbgarg (cmd, "index=%d, name=%s, type=%d, "
1700 "capability=%d, rangelow=%d, rangehigh=%d, "
1701 "signal=%d, afc=%d, rxsubchans=%d, "
1702 "audmode=%d\n",p->index, p->name, p->type,
1703 p->capability, p->rangelow,p->rangehigh,
1704 p->rxsubchans, p->audmode, p->signal,
1706 ret=vfd->vidioc_s_tuner(file, fh, p);
1709 case VIDIOC_G_FREQUENCY:
1711 struct v4l2_frequency *p = arg;
1713 if (!vfd->vidioc_g_frequency)
1716 memset(p->reserved, 0, sizeof(p->reserved));
1718 ret = vfd->vidioc_g_frequency(file, fh, p);
1720 dbgarg(cmd, "tuner=%d, type=%d, frequency=%d\n",
1721 p->tuner, p->type, p->frequency);
1724 case VIDIOC_S_FREQUENCY:
1726 struct v4l2_frequency *p=arg;
1727 if (!vfd->vidioc_s_frequency)
1729 dbgarg (cmd, "tuner=%d, type=%d, frequency=%d\n",
1730 p->tuner,p->type,p->frequency);
1731 ret=vfd->vidioc_s_frequency(file, fh, p);
1734 case VIDIOC_G_SLICED_VBI_CAP:
1736 struct v4l2_sliced_vbi_cap *p=arg;
1737 if (!vfd->vidioc_g_sliced_vbi_cap)
1739 ret=vfd->vidioc_g_sliced_vbi_cap(file, fh, p);
1741 dbgarg (cmd, "service_set=%d\n", p->service_set);
1744 case VIDIOC_LOG_STATUS:
1746 if (!vfd->vidioc_log_status)
1748 ret=vfd->vidioc_log_status(file, fh);
1751 #ifdef CONFIG_VIDEO_ADV_DEBUG
1752 case VIDIOC_DBG_G_REGISTER:
1754 struct v4l2_register *p=arg;
1755 if (!capable(CAP_SYS_ADMIN))
1757 else if (vfd->vidioc_g_register)
1758 ret=vfd->vidioc_g_register(file, fh, p);
1761 case VIDIOC_DBG_S_REGISTER:
1763 struct v4l2_register *p=arg;
1764 if (!capable(CAP_SYS_ADMIN))
1766 else if (vfd->vidioc_s_register)
1767 ret=vfd->vidioc_s_register(file, fh, p);
1771 case VIDIOC_G_CHIP_IDENT:
1773 struct v4l2_chip_ident *p=arg;
1774 if (!vfd->vidioc_g_chip_ident)
1776 ret=vfd->vidioc_g_chip_ident(file, fh, p);
1778 dbgarg (cmd, "chip_ident=%u, revision=0x%x\n", p->ident, p->revision);
1783 if (!vfd->vidioc_default)
1785 ret = vfd->vidioc_default(file, fh, cmd, arg);
1788 case VIDIOC_S_HW_FREQ_SEEK:
1790 struct v4l2_hw_freq_seek *p = arg;
1791 if (!vfd->vidioc_s_hw_freq_seek)
1794 "tuner=%d, type=%d, seek_upward=%d, wrap_around=%d\n",
1795 p->tuner, p->type, p->seek_upward, p->wrap_around);
1796 ret = vfd->vidioc_s_hw_freq_seek(file, fh, p);
1801 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) {
1803 printk("%s: err: on ", vfd->name);
1804 v4l_print_ioctl(vfd->name, cmd);
1812 int video_ioctl2 (struct inode *inode, struct file *file,
1813 unsigned int cmd, unsigned long arg)
1820 size_t ctrls_size = 0;
1821 void __user *user_ptr = NULL;
1823 #ifdef __OLD_VIDIOC_
1824 cmd = video_fix_command(cmd);
1826 is_ext_ctrl = (cmd == VIDIOC_S_EXT_CTRLS || cmd == VIDIOC_G_EXT_CTRLS ||
1827 cmd == VIDIOC_TRY_EXT_CTRLS);
1829 /* Copy arguments into temp kernel buffer */
1830 switch (_IOC_DIR(cmd)) {
1836 case (_IOC_WRITE | _IOC_READ):
1837 if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
1840 /* too big to allocate from stack */
1841 mbuf = kmalloc(_IOC_SIZE(cmd),GFP_KERNEL);
1848 if (_IOC_DIR(cmd) & _IOC_WRITE)
1849 if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
1855 struct v4l2_ext_controls *p = parg;
1857 /* In case of an error, tell the caller that it wasn't
1858 a specific control that caused it. */
1859 p->error_idx = p->count;
1860 user_ptr = (void __user *)p->controls;
1862 ctrls_size = sizeof(struct v4l2_ext_control) * p->count;
1863 /* Note: v4l2_ext_controls fits in sbuf[] so mbuf is still NULL. */
1864 mbuf = kmalloc(ctrls_size, GFP_KERNEL);
1869 if (copy_from_user(mbuf, user_ptr, ctrls_size))
1876 err = __video_do_ioctl(inode, file, cmd, parg);
1877 if (err == -ENOIOCTLCMD)
1880 struct v4l2_ext_controls *p = parg;
1882 p->controls = (void *)user_ptr;
1883 if (p->count && err == 0 && copy_to_user(user_ptr, mbuf, ctrls_size))
1891 /* Copy results into user buffer */
1892 switch (_IOC_DIR(cmd))
1895 case (_IOC_WRITE | _IOC_READ):
1896 if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
1905 EXPORT_SYMBOL(video_ioctl2);
1907 static const struct file_operations video_fops;
1910 * video_register_device - register video4linux devices
1911 * @vfd: video device structure we want to register
1912 * @type: type of device to register
1913 * @nr: which device number (0 == /dev/video0, 1 == /dev/video1, ...
1916 * The registration code assigns minor numbers based on the type
1917 * requested. -ENFILE is returned in all the device slots for this
1918 * category are full. If not then the minor field is set and the
1919 * driver initialize function is called (if non %NULL).
1921 * Zero is returned on success.
1925 * %VFL_TYPE_GRABBER - A frame grabber
1927 * %VFL_TYPE_VTX - A teletext device
1929 * %VFL_TYPE_VBI - Vertical blank data (undecoded)
1931 * %VFL_TYPE_RADIO - A radio card
1934 int video_register_device(struct video_device *vfd, int type, int nr)
1944 case VFL_TYPE_GRABBER:
1945 base=MINOR_VFL_TYPE_GRABBER_MIN;
1946 end=MINOR_VFL_TYPE_GRABBER_MAX+1;
1947 name_base = "video";
1950 base=MINOR_VFL_TYPE_VTX_MIN;
1951 end=MINOR_VFL_TYPE_VTX_MAX+1;
1955 base=MINOR_VFL_TYPE_VBI_MIN;
1956 end=MINOR_VFL_TYPE_VBI_MAX+1;
1959 case VFL_TYPE_RADIO:
1960 base=MINOR_VFL_TYPE_RADIO_MIN;
1961 end=MINOR_VFL_TYPE_RADIO_MAX+1;
1962 name_base = "radio";
1965 printk(KERN_ERR "%s called with unknown type: %d\n",
1970 /* pick a minor number */
1971 mutex_lock(&videodev_lock);
1972 if (nr >= 0 && nr < end-base) {
1973 /* use the one the driver asked for */
1975 if (NULL != video_device[i]) {
1976 mutex_unlock(&videodev_lock);
1980 /* use first free */
1981 for(i=base;i<end;i++)
1982 if (NULL == video_device[i])
1985 mutex_unlock(&videodev_lock);
1989 video_device[i]=vfd;
1991 mutex_unlock(&videodev_lock);
1992 mutex_init(&vfd->lock);
1995 memset(&vfd->class_dev, 0x00, sizeof(vfd->class_dev));
1997 vfd->class_dev.parent = vfd->dev;
1998 vfd->class_dev.class = &video_class;
1999 vfd->class_dev.devt = MKDEV(VIDEO_MAJOR, vfd->minor);
2000 sprintf(vfd->class_dev.bus_id, "%s%d", name_base, i - base);
2001 ret = device_register(&vfd->class_dev);
2003 printk(KERN_ERR "%s: device_register failed\n",
2009 /* needed until all drivers are fixed */
2011 printk(KERN_WARNING "videodev: \"%s\" has no release callback. "
2012 "Please fix your driver for proper sysfs support, see "
2013 "http://lwn.net/Articles/36850/\n", vfd->name);
2018 mutex_lock(&videodev_lock);
2019 video_device[vfd->minor] = NULL;
2021 mutex_unlock(&videodev_lock);
2024 EXPORT_SYMBOL(video_register_device);
2027 * video_unregister_device - unregister a video4linux device
2028 * @vfd: the device to unregister
2030 * This unregisters the passed device and deassigns the minor
2031 * number. Future open calls will be met with errors.
2034 void video_unregister_device(struct video_device *vfd)
2036 mutex_lock(&videodev_lock);
2037 if(video_device[vfd->minor]!=vfd)
2038 panic("videodev: bad unregister");
2040 video_device[vfd->minor]=NULL;
2041 device_unregister(&vfd->class_dev);
2042 mutex_unlock(&videodev_lock);
2044 EXPORT_SYMBOL(video_unregister_device);
2047 * Video fs operations
2049 static const struct file_operations video_fops=
2051 .owner = THIS_MODULE,
2052 .llseek = no_llseek,
2057 * Initialise video for linux
2060 static int __init videodev_init(void)
2064 printk(KERN_INFO "Linux video capture interface: v2.00\n");
2065 if (register_chrdev(VIDEO_MAJOR, VIDEO_NAME, &video_fops)) {
2066 printk(KERN_WARNING "video_dev: unable to get major %d\n", VIDEO_MAJOR);
2070 ret = class_register(&video_class);
2072 unregister_chrdev(VIDEO_MAJOR, VIDEO_NAME);
2073 printk(KERN_WARNING "video_dev: class_register failed\n");
2080 static void __exit videodev_exit(void)
2082 class_unregister(&video_class);
2083 unregister_chrdev(VIDEO_MAJOR, VIDEO_NAME);
2086 module_init(videodev_init)
2087 module_exit(videodev_exit)
2089 MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@infradead.org>");
2090 MODULE_DESCRIPTION("Device registrar for Video4Linux drivers v2");
2091 MODULE_LICENSE("GPL");