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_vid_cap)
689 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
690 if (vfd->vidioc_try_fmt_vid_overlay)
693 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
694 if (vfd->vidioc_try_fmt_vid_out)
697 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
698 if (vfd->vidioc_try_fmt_vid_out_overlay)
701 case V4L2_BUF_TYPE_VBI_CAPTURE:
702 if (vfd->vidioc_try_fmt_vbi_cap)
705 case V4L2_BUF_TYPE_VBI_OUTPUT:
706 if (vfd->vidioc_try_fmt_vbi_out)
709 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
710 if (vfd->vidioc_try_fmt_sliced_vbi_cap)
713 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
714 if (vfd->vidioc_try_fmt_sliced_vbi_out)
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_vid_cap)
832 ret = vfd->vidioc_enum_fmt_vid_cap(file, fh, f);
834 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
835 if (vfd->vidioc_enum_fmt_vid_overlay)
836 ret = vfd->vidioc_enum_fmt_vid_overlay(file,
840 /* V4L2_BUF_TYPE_VBI_CAPTURE should not support VIDIOC_ENUM_FMT
841 * according to the spec. The bttv and saa7134 drivers support
842 * it though, so just warn that this is deprecated and will be
843 * removed in the near future. */
844 case V4L2_BUF_TYPE_VBI_CAPTURE:
845 if (vfd->vidioc_enum_fmt_vbi_cap) {
846 printk(KERN_WARNING "vidioc_enum_fmt_vbi_cap will be removed in 2.6.28!\n");
847 ret = vfd->vidioc_enum_fmt_vbi_cap(file, fh, f);
851 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
852 if (vfd->vidioc_enum_fmt_vid_out)
853 ret = vfd->vidioc_enum_fmt_vid_out(file, fh, f);
855 case V4L2_BUF_TYPE_PRIVATE:
856 if (vfd->vidioc_enum_fmt_type_private)
857 ret = vfd->vidioc_enum_fmt_type_private(file,
864 dbgarg (cmd, "index=%d, type=%d, flags=%d, "
865 "pixelformat=%c%c%c%c, description='%s'\n",
866 f->index, f->type, f->flags,
867 (f->pixelformat & 0xff),
868 (f->pixelformat >> 8) & 0xff,
869 (f->pixelformat >> 16) & 0xff,
870 (f->pixelformat >> 24) & 0xff,
876 struct v4l2_format *f = (struct v4l2_format *)arg;
878 memset(f->fmt.raw_data, 0, sizeof(f->fmt.raw_data));
880 /* FIXME: Should be one dump per type */
881 dbgarg(cmd, "type=%s\n", prt_names(f->type, v4l2_type_names));
884 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
885 if (vfd->vidioc_g_fmt_vid_cap)
886 ret = vfd->vidioc_g_fmt_vid_cap(file, fh, f);
888 v4l_print_pix_fmt(vfd,&f->fmt.pix);
890 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
891 if (vfd->vidioc_g_fmt_vid_overlay)
892 ret = vfd->vidioc_g_fmt_vid_overlay(file,
895 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
896 if (vfd->vidioc_g_fmt_vid_out)
897 ret = vfd->vidioc_g_fmt_vid_out(file, fh, f);
899 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
900 if (vfd->vidioc_g_fmt_vid_out_overlay)
901 ret = vfd->vidioc_g_fmt_vid_out_overlay(file,
904 case V4L2_BUF_TYPE_VBI_CAPTURE:
905 if (vfd->vidioc_g_fmt_vbi_cap)
906 ret = vfd->vidioc_g_fmt_vbi_cap(file, fh, f);
908 case V4L2_BUF_TYPE_VBI_OUTPUT:
909 if (vfd->vidioc_g_fmt_vbi_out)
910 ret = vfd->vidioc_g_fmt_vbi_out(file, fh, f);
912 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
913 if (vfd->vidioc_g_fmt_sliced_vbi_cap)
914 ret = vfd->vidioc_g_fmt_sliced_vbi_cap(file,
917 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
918 if (vfd->vidioc_g_fmt_sliced_vbi_out)
919 ret = vfd->vidioc_g_fmt_sliced_vbi_out(file,
922 case V4L2_BUF_TYPE_PRIVATE:
923 if (vfd->vidioc_g_fmt_type_private)
924 ret = vfd->vidioc_g_fmt_type_private(file,
933 struct v4l2_format *f = (struct v4l2_format *)arg;
935 /* FIXME: Should be one dump per type */
936 dbgarg (cmd, "type=%s\n", prt_names(f->type,
940 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
941 v4l_print_pix_fmt(vfd,&f->fmt.pix);
942 if (vfd->vidioc_s_fmt_vid_cap)
943 ret = vfd->vidioc_s_fmt_vid_cap(file, fh, f);
945 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
946 if (vfd->vidioc_s_fmt_vid_overlay)
947 ret = vfd->vidioc_s_fmt_vid_overlay(file,
950 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
951 if (vfd->vidioc_s_fmt_vid_out)
952 ret = vfd->vidioc_s_fmt_vid_out(file, fh, f);
954 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
955 if (vfd->vidioc_s_fmt_vid_out_overlay)
956 ret = vfd->vidioc_s_fmt_vid_out_overlay(file,
959 case V4L2_BUF_TYPE_VBI_CAPTURE:
960 if (vfd->vidioc_s_fmt_vbi_cap)
961 ret = vfd->vidioc_s_fmt_vbi_cap(file, fh, f);
963 case V4L2_BUF_TYPE_VBI_OUTPUT:
964 if (vfd->vidioc_s_fmt_vbi_out)
965 ret = vfd->vidioc_s_fmt_vbi_out(file, fh, f);
967 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
968 if (vfd->vidioc_s_fmt_sliced_vbi_cap)
969 ret = vfd->vidioc_s_fmt_sliced_vbi_cap(file,
972 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
973 if (vfd->vidioc_s_fmt_sliced_vbi_out)
974 ret = vfd->vidioc_s_fmt_sliced_vbi_out(file,
977 case V4L2_BUF_TYPE_PRIVATE:
978 if (vfd->vidioc_s_fmt_type_private)
979 ret = vfd->vidioc_s_fmt_type_private(file,
987 struct v4l2_format *f = (struct v4l2_format *)arg;
989 /* FIXME: Should be one dump per type */
990 dbgarg (cmd, "type=%s\n", prt_names(f->type,
993 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
994 if (vfd->vidioc_try_fmt_vid_cap)
995 ret = vfd->vidioc_try_fmt_vid_cap(file, fh, f);
997 v4l_print_pix_fmt(vfd,&f->fmt.pix);
999 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
1000 if (vfd->vidioc_try_fmt_vid_overlay)
1001 ret = vfd->vidioc_try_fmt_vid_overlay(file,
1004 case V4L2_BUF_TYPE_VIDEO_OUTPUT:
1005 if (vfd->vidioc_try_fmt_vid_out)
1006 ret = vfd->vidioc_try_fmt_vid_out(file, fh, f);
1008 case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
1009 if (vfd->vidioc_try_fmt_vid_out_overlay)
1010 ret = vfd->vidioc_try_fmt_vid_out_overlay(file,
1013 case V4L2_BUF_TYPE_VBI_CAPTURE:
1014 if (vfd->vidioc_try_fmt_vbi_cap)
1015 ret = vfd->vidioc_try_fmt_vbi_cap(file, fh, f);
1017 case V4L2_BUF_TYPE_VBI_OUTPUT:
1018 if (vfd->vidioc_try_fmt_vbi_out)
1019 ret = vfd->vidioc_try_fmt_vbi_out(file, fh, f);
1021 case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
1022 if (vfd->vidioc_try_fmt_sliced_vbi_cap)
1023 ret = vfd->vidioc_try_fmt_sliced_vbi_cap(file,
1026 case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
1027 if (vfd->vidioc_try_fmt_sliced_vbi_out)
1028 ret = vfd->vidioc_try_fmt_sliced_vbi_out(file,
1031 case V4L2_BUF_TYPE_PRIVATE:
1032 if (vfd->vidioc_try_fmt_type_private)
1033 ret = vfd->vidioc_try_fmt_type_private(file,
1040 /* FIXME: Those buf reqs could be handled here,
1041 with some changes on videobuf to allow its header to be included at
1042 videodev2.h or being merged at videodev2.
1044 case VIDIOC_REQBUFS:
1046 struct v4l2_requestbuffers *p=arg;
1048 if (!vfd->vidioc_reqbufs)
1050 ret = check_fmt (vfd, p->type);
1054 ret=vfd->vidioc_reqbufs(file, fh, p);
1055 dbgarg (cmd, "count=%d, type=%s, memory=%s\n",
1057 prt_names(p->type, v4l2_type_names),
1058 prt_names(p->memory, v4l2_memory_names));
1061 case VIDIOC_QUERYBUF:
1063 struct v4l2_buffer *p=arg;
1065 if (!vfd->vidioc_querybuf)
1067 ret = check_fmt (vfd, p->type);
1071 ret=vfd->vidioc_querybuf(file, fh, p);
1078 struct v4l2_buffer *p=arg;
1080 if (!vfd->vidioc_qbuf)
1082 ret = check_fmt (vfd, p->type);
1086 ret=vfd->vidioc_qbuf(file, fh, p);
1093 struct v4l2_buffer *p=arg;
1094 if (!vfd->vidioc_dqbuf)
1096 ret = check_fmt (vfd, p->type);
1100 ret=vfd->vidioc_dqbuf(file, fh, p);
1105 case VIDIOC_OVERLAY:
1109 if (!vfd->vidioc_overlay)
1111 dbgarg (cmd, "value=%d\n",*i);
1112 ret=vfd->vidioc_overlay(file, fh, *i);
1117 struct v4l2_framebuffer *p=arg;
1118 if (!vfd->vidioc_g_fbuf)
1120 ret=vfd->vidioc_g_fbuf(file, fh, arg);
1122 dbgarg (cmd, "capability=%d, flags=%d, base=0x%08lx\n",
1123 p->capability,p->flags,
1124 (unsigned long)p->base);
1125 v4l_print_pix_fmt (vfd, &p->fmt);
1131 struct v4l2_framebuffer *p=arg;
1132 if (!vfd->vidioc_s_fbuf)
1135 dbgarg (cmd, "capability=%d, flags=%d, base=0x%08lx\n",
1136 p->capability,p->flags,(unsigned long)p->base);
1137 v4l_print_pix_fmt (vfd, &p->fmt);
1138 ret=vfd->vidioc_s_fbuf(file, fh, arg);
1142 case VIDIOC_STREAMON:
1144 enum v4l2_buf_type i = *(int *)arg;
1145 if (!vfd->vidioc_streamon)
1147 dbgarg(cmd, "type=%s\n", prt_names(i, v4l2_type_names));
1148 ret=vfd->vidioc_streamon(file, fh,i);
1151 case VIDIOC_STREAMOFF:
1153 enum v4l2_buf_type i = *(int *)arg;
1155 if (!vfd->vidioc_streamoff)
1157 dbgarg(cmd, "type=%s\n", prt_names(i, v4l2_type_names));
1158 ret=vfd->vidioc_streamoff(file, fh, i);
1161 /* ---------- tv norms ---------- */
1162 case VIDIOC_ENUMSTD:
1164 struct v4l2_standard *p = arg;
1165 v4l2_std_id id = vfd->tvnorms, curr_id = 0;
1166 unsigned int index = p->index, i, j = 0;
1167 const char *descr = "";
1169 /* Return norm array in a canonical way */
1170 for (i = 0; i <= index && id; i++) {
1171 /* last std value in the standards array is 0, so this
1172 while always ends there since (id & 0) == 0. */
1173 while ((id & standards[j].std) != standards[j].std)
1175 curr_id = standards[j].std;
1176 descr = standards[j].descr;
1180 if (curr_id != V4L2_STD_PAL &&
1181 curr_id != V4L2_STD_SECAM &&
1182 curr_id != V4L2_STD_NTSC)
1188 v4l2_video_std_construct(p, curr_id, descr);
1191 dbgarg(cmd, "index=%d, id=%Ld, name=%s, fps=%d/%d, "
1192 "framelines=%d\n", p->index,
1193 (unsigned long long)p->id, p->name,
1194 p->frameperiod.numerator,
1195 p->frameperiod.denominator,
1203 v4l2_std_id *id = arg;
1206 /* Calls the specific handler */
1207 if (vfd->vidioc_g_std)
1208 ret = vfd->vidioc_g_std(file, fh, id);
1210 *id = vfd->current_norm;
1213 dbgarg(cmd, "value=%08Lx\n", (long long unsigned)*id);
1218 v4l2_std_id *id = arg,norm;
1220 dbgarg (cmd, "value=%08Lx\n", (long long unsigned) *id);
1222 norm = (*id) & vfd->tvnorms;
1223 if ( vfd->tvnorms && !norm) /* Check if std is supported */
1226 /* Calls the specific handler */
1227 if (vfd->vidioc_s_std)
1228 ret=vfd->vidioc_s_std(file, fh, &norm);
1232 /* Updates standard information */
1234 vfd->current_norm=norm;
1238 case VIDIOC_QUERYSTD:
1242 if (!vfd->vidioc_querystd)
1244 ret=vfd->vidioc_querystd(file, fh, arg);
1246 dbgarg (cmd, "detected std=%08Lx\n",
1247 (unsigned long long)*p);
1250 /* ------ input switching ---------- */
1251 /* FIXME: Inputs can be handled inside videodev2 */
1252 case VIDIOC_ENUMINPUT:
1254 struct v4l2_input *p=arg;
1257 if (!vfd->vidioc_enum_input)
1259 memset(p, 0, sizeof(*p));
1262 ret=vfd->vidioc_enum_input(file, fh, p);
1264 dbgarg (cmd, "index=%d, name=%s, type=%d, "
1266 "tuner=%d, std=%08Lx, status=%d\n",
1267 p->index,p->name,p->type,p->audioset,
1269 (unsigned long long)p->std,
1273 case VIDIOC_G_INPUT:
1275 unsigned int *i = arg;
1277 if (!vfd->vidioc_g_input)
1279 ret=vfd->vidioc_g_input(file, fh, i);
1281 dbgarg (cmd, "value=%d\n",*i);
1284 case VIDIOC_S_INPUT:
1286 unsigned int *i = arg;
1288 if (!vfd->vidioc_s_input)
1290 dbgarg (cmd, "value=%d\n",*i);
1291 ret=vfd->vidioc_s_input(file, fh, *i);
1295 /* ------ output switching ---------- */
1296 case VIDIOC_ENUMOUTPUT:
1298 struct v4l2_output *p = arg;
1301 if (!vfd->vidioc_enum_output)
1303 memset(p, 0, sizeof(*p));
1306 ret = vfd->vidioc_enum_output(file, fh, p);
1308 dbgarg(cmd, "index=%d, name=%s, type=%d, "
1310 "modulator=%d, std=%08Lx\n",
1311 p->index, p->name, p->type, p->audioset,
1312 p->modulator, (unsigned long long)p->std);
1315 case VIDIOC_G_OUTPUT:
1317 unsigned int *i = arg;
1319 if (!vfd->vidioc_g_output)
1321 ret=vfd->vidioc_g_output(file, fh, i);
1323 dbgarg (cmd, "value=%d\n",*i);
1326 case VIDIOC_S_OUTPUT:
1328 unsigned int *i = arg;
1330 if (!vfd->vidioc_s_output)
1332 dbgarg (cmd, "value=%d\n",*i);
1333 ret=vfd->vidioc_s_output(file, fh, *i);
1337 /* --- controls ---------------------------------------------- */
1338 case VIDIOC_QUERYCTRL:
1340 struct v4l2_queryctrl *p=arg;
1342 if (!vfd->vidioc_queryctrl)
1344 ret=vfd->vidioc_queryctrl(file, fh, p);
1347 dbgarg (cmd, "id=%d, type=%d, name=%s, "
1349 " step=%d, default=%d, flags=0x%08x\n",
1350 p->id,p->type,p->name,p->minimum,
1351 p->maximum,p->step,p->default_value,
1357 struct v4l2_control *p = arg;
1359 if (!vfd->vidioc_g_ctrl)
1361 dbgarg(cmd, "Enum for index=%d\n", p->id);
1363 ret=vfd->vidioc_g_ctrl(file, fh, p);
1365 dbgarg2 ( "id=%d, value=%d\n", p->id, p->value);
1370 struct v4l2_control *p = arg;
1372 if (!vfd->vidioc_s_ctrl)
1374 dbgarg (cmd, "id=%d, value=%d\n", p->id, p->value);
1376 ret=vfd->vidioc_s_ctrl(file, fh, p);
1379 case VIDIOC_G_EXT_CTRLS:
1381 struct v4l2_ext_controls *p = arg;
1383 if (vfd->vidioc_g_ext_ctrls) {
1384 dbgarg(cmd, "count=%d\n", p->count);
1386 ret=vfd->vidioc_g_ext_ctrls(file, fh, p);
1390 case VIDIOC_S_EXT_CTRLS:
1392 struct v4l2_ext_controls *p = arg;
1394 if (vfd->vidioc_s_ext_ctrls) {
1395 dbgarg(cmd, "count=%d\n", p->count);
1397 ret=vfd->vidioc_s_ext_ctrls(file, fh, p);
1401 case VIDIOC_TRY_EXT_CTRLS:
1403 struct v4l2_ext_controls *p = arg;
1405 if (vfd->vidioc_try_ext_ctrls) {
1406 dbgarg(cmd, "count=%d\n", p->count);
1408 ret=vfd->vidioc_try_ext_ctrls(file, fh, p);
1412 case VIDIOC_QUERYMENU:
1414 struct v4l2_querymenu *p=arg;
1415 if (!vfd->vidioc_querymenu)
1417 ret=vfd->vidioc_querymenu(file, fh, p);
1419 dbgarg (cmd, "id=%d, index=%d, name=%s\n",
1420 p->id,p->index,p->name);
1423 /* --- audio ---------------------------------------------- */
1424 case VIDIOC_ENUMAUDIO:
1426 struct v4l2_audio *p=arg;
1428 if (!vfd->vidioc_enumaudio)
1430 dbgarg(cmd, "Enum for index=%d\n", p->index);
1431 ret=vfd->vidioc_enumaudio(file, fh, p);
1433 dbgarg2("index=%d, name=%s, capability=%d, "
1434 "mode=%d\n",p->index,p->name,
1435 p->capability, p->mode);
1438 case VIDIOC_G_AUDIO:
1440 struct v4l2_audio *p=arg;
1441 __u32 index=p->index;
1443 if (!vfd->vidioc_g_audio)
1446 memset(p,0,sizeof(*p));
1448 dbgarg(cmd, "Get for index=%d\n", p->index);
1449 ret=vfd->vidioc_g_audio(file, fh, p);
1451 dbgarg2("index=%d, name=%s, capability=%d, "
1452 "mode=%d\n",p->index,
1453 p->name,p->capability, p->mode);
1456 case VIDIOC_S_AUDIO:
1458 struct v4l2_audio *p=arg;
1460 if (!vfd->vidioc_s_audio)
1462 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1463 "mode=%d\n", p->index, p->name,
1464 p->capability, p->mode);
1465 ret=vfd->vidioc_s_audio(file, fh, p);
1468 case VIDIOC_ENUMAUDOUT:
1470 struct v4l2_audioout *p=arg;
1472 if (!vfd->vidioc_enumaudout)
1474 dbgarg(cmd, "Enum for index=%d\n", p->index);
1475 ret=vfd->vidioc_enumaudout(file, fh, p);
1477 dbgarg2("index=%d, name=%s, capability=%d, "
1478 "mode=%d\n", p->index, p->name,
1479 p->capability,p->mode);
1482 case VIDIOC_G_AUDOUT:
1484 struct v4l2_audioout *p=arg;
1486 if (!vfd->vidioc_g_audout)
1488 dbgarg(cmd, "Enum for index=%d\n", p->index);
1489 ret=vfd->vidioc_g_audout(file, fh, p);
1491 dbgarg2("index=%d, name=%s, capability=%d, "
1492 "mode=%d\n", p->index, p->name,
1493 p->capability,p->mode);
1496 case VIDIOC_S_AUDOUT:
1498 struct v4l2_audioout *p=arg;
1500 if (!vfd->vidioc_s_audout)
1502 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1503 "mode=%d\n", p->index, p->name,
1504 p->capability,p->mode);
1506 ret=vfd->vidioc_s_audout(file, fh, p);
1509 case VIDIOC_G_MODULATOR:
1511 struct v4l2_modulator *p=arg;
1512 if (!vfd->vidioc_g_modulator)
1514 ret=vfd->vidioc_g_modulator(file, fh, p);
1516 dbgarg(cmd, "index=%d, name=%s, "
1517 "capability=%d, rangelow=%d,"
1518 " rangehigh=%d, txsubchans=%d\n",
1519 p->index, p->name,p->capability,
1520 p->rangelow, p->rangehigh,
1524 case VIDIOC_S_MODULATOR:
1526 struct v4l2_modulator *p=arg;
1527 if (!vfd->vidioc_s_modulator)
1529 dbgarg(cmd, "index=%d, name=%s, capability=%d, "
1530 "rangelow=%d, rangehigh=%d, txsubchans=%d\n",
1531 p->index, p->name,p->capability,p->rangelow,
1532 p->rangehigh,p->txsubchans);
1533 ret=vfd->vidioc_s_modulator(file, fh, p);
1538 struct v4l2_crop *p=arg;
1539 if (!vfd->vidioc_g_crop)
1541 ret=vfd->vidioc_g_crop(file, fh, p);
1543 dbgarg(cmd, "type=%d\n", p->type);
1544 dbgrect(vfd, "", &p->c);
1550 struct v4l2_crop *p=arg;
1551 if (!vfd->vidioc_s_crop)
1553 dbgarg(cmd, "type=%d\n", p->type);
1554 dbgrect(vfd, "", &p->c);
1555 ret=vfd->vidioc_s_crop(file, fh, p);
1558 case VIDIOC_CROPCAP:
1560 struct v4l2_cropcap *p=arg;
1561 /*FIXME: Should also show v4l2_fract pixelaspect */
1562 if (!vfd->vidioc_cropcap)
1564 dbgarg(cmd, "type=%d\n", p->type);
1565 dbgrect(vfd, "bounds ", &p->bounds);
1566 dbgrect(vfd, "defrect ", &p->defrect);
1567 ret=vfd->vidioc_cropcap(file, fh, p);
1570 case VIDIOC_G_JPEGCOMP:
1572 struct v4l2_jpegcompression *p=arg;
1573 if (!vfd->vidioc_g_jpegcomp)
1575 ret=vfd->vidioc_g_jpegcomp(file, fh, p);
1577 dbgarg (cmd, "quality=%d, APPn=%d, "
1578 "APP_len=%d, COM_len=%d, "
1579 "jpeg_markers=%d\n",
1580 p->quality,p->APPn,p->APP_len,
1581 p->COM_len,p->jpeg_markers);
1584 case VIDIOC_S_JPEGCOMP:
1586 struct v4l2_jpegcompression *p=arg;
1587 if (!vfd->vidioc_g_jpegcomp)
1589 dbgarg (cmd, "quality=%d, APPn=%d, APP_len=%d, "
1590 "COM_len=%d, jpeg_markers=%d\n",
1591 p->quality,p->APPn,p->APP_len,
1592 p->COM_len,p->jpeg_markers);
1593 ret=vfd->vidioc_s_jpegcomp(file, fh, p);
1596 case VIDIOC_G_ENC_INDEX:
1598 struct v4l2_enc_idx *p=arg;
1600 if (!vfd->vidioc_g_enc_index)
1602 ret=vfd->vidioc_g_enc_index(file, fh, p);
1604 dbgarg (cmd, "entries=%d, entries_cap=%d\n",
1605 p->entries,p->entries_cap);
1608 case VIDIOC_ENCODER_CMD:
1610 struct v4l2_encoder_cmd *p=arg;
1612 if (!vfd->vidioc_encoder_cmd)
1614 ret=vfd->vidioc_encoder_cmd(file, fh, p);
1616 dbgarg (cmd, "cmd=%d, flags=%d\n",
1620 case VIDIOC_TRY_ENCODER_CMD:
1622 struct v4l2_encoder_cmd *p=arg;
1624 if (!vfd->vidioc_try_encoder_cmd)
1626 ret=vfd->vidioc_try_encoder_cmd(file, fh, p);
1628 dbgarg (cmd, "cmd=%d, flags=%d\n",
1634 struct v4l2_streamparm *p=arg;
1637 memset(p,0,sizeof(*p));
1640 if (vfd->vidioc_g_parm) {
1641 ret=vfd->vidioc_g_parm(file, fh, p);
1643 struct v4l2_standard s;
1645 if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1648 v4l2_video_std_construct(&s, vfd->current_norm,
1649 v4l2_norm_to_name(vfd->current_norm));
1651 p->parm.capture.timeperframe = s.frameperiod;
1655 dbgarg (cmd, "type=%d\n", p->type);
1660 struct v4l2_streamparm *p=arg;
1661 if (!vfd->vidioc_s_parm)
1663 dbgarg (cmd, "type=%d\n", p->type);
1664 ret=vfd->vidioc_s_parm(file, fh, p);
1667 case VIDIOC_G_TUNER:
1669 struct v4l2_tuner *p=arg;
1670 __u32 index=p->index;
1672 if (!vfd->vidioc_g_tuner)
1675 memset(p,0,sizeof(*p));
1678 ret=vfd->vidioc_g_tuner(file, fh, p);
1680 dbgarg (cmd, "index=%d, name=%s, type=%d, "
1681 "capability=%d, rangelow=%d, "
1682 "rangehigh=%d, signal=%d, afc=%d, "
1683 "rxsubchans=%d, audmode=%d\n",
1684 p->index, p->name, p->type,
1685 p->capability, p->rangelow,
1686 p->rangehigh, p->rxsubchans,
1687 p->audmode, p->signal, p->afc);
1690 case VIDIOC_S_TUNER:
1692 struct v4l2_tuner *p=arg;
1693 if (!vfd->vidioc_s_tuner)
1695 dbgarg (cmd, "index=%d, name=%s, type=%d, "
1696 "capability=%d, rangelow=%d, rangehigh=%d, "
1697 "signal=%d, afc=%d, rxsubchans=%d, "
1698 "audmode=%d\n",p->index, p->name, p->type,
1699 p->capability, p->rangelow,p->rangehigh,
1700 p->rxsubchans, p->audmode, p->signal,
1702 ret=vfd->vidioc_s_tuner(file, fh, p);
1705 case VIDIOC_G_FREQUENCY:
1707 struct v4l2_frequency *p = arg;
1709 if (!vfd->vidioc_g_frequency)
1712 memset(p->reserved, 0, sizeof(p->reserved));
1714 ret = vfd->vidioc_g_frequency(file, fh, p);
1716 dbgarg(cmd, "tuner=%d, type=%d, frequency=%d\n",
1717 p->tuner, p->type, p->frequency);
1720 case VIDIOC_S_FREQUENCY:
1722 struct v4l2_frequency *p=arg;
1723 if (!vfd->vidioc_s_frequency)
1725 dbgarg (cmd, "tuner=%d, type=%d, frequency=%d\n",
1726 p->tuner,p->type,p->frequency);
1727 ret=vfd->vidioc_s_frequency(file, fh, p);
1730 case VIDIOC_G_SLICED_VBI_CAP:
1732 struct v4l2_sliced_vbi_cap *p=arg;
1733 if (!vfd->vidioc_g_sliced_vbi_cap)
1735 ret=vfd->vidioc_g_sliced_vbi_cap(file, fh, p);
1737 dbgarg (cmd, "service_set=%d\n", p->service_set);
1740 case VIDIOC_LOG_STATUS:
1742 if (!vfd->vidioc_log_status)
1744 ret=vfd->vidioc_log_status(file, fh);
1747 #ifdef CONFIG_VIDEO_ADV_DEBUG
1748 case VIDIOC_DBG_G_REGISTER:
1750 struct v4l2_register *p=arg;
1751 if (!capable(CAP_SYS_ADMIN))
1753 else if (vfd->vidioc_g_register)
1754 ret=vfd->vidioc_g_register(file, fh, p);
1757 case VIDIOC_DBG_S_REGISTER:
1759 struct v4l2_register *p=arg;
1760 if (!capable(CAP_SYS_ADMIN))
1762 else if (vfd->vidioc_s_register)
1763 ret=vfd->vidioc_s_register(file, fh, p);
1767 case VIDIOC_G_CHIP_IDENT:
1769 struct v4l2_chip_ident *p=arg;
1770 if (!vfd->vidioc_g_chip_ident)
1772 ret=vfd->vidioc_g_chip_ident(file, fh, p);
1774 dbgarg (cmd, "chip_ident=%u, revision=0x%x\n", p->ident, p->revision);
1779 if (!vfd->vidioc_default)
1781 ret = vfd->vidioc_default(file, fh, cmd, arg);
1784 case VIDIOC_S_HW_FREQ_SEEK:
1786 struct v4l2_hw_freq_seek *p = arg;
1787 if (!vfd->vidioc_s_hw_freq_seek)
1790 "tuner=%d, type=%d, seek_upward=%d, wrap_around=%d\n",
1791 p->tuner, p->type, p->seek_upward, p->wrap_around);
1792 ret = vfd->vidioc_s_hw_freq_seek(file, fh, p);
1797 if (vfd->debug & V4L2_DEBUG_IOCTL_ARG) {
1799 printk("%s: err: on ", vfd->name);
1800 v4l_print_ioctl(vfd->name, cmd);
1808 int video_ioctl2 (struct inode *inode, struct file *file,
1809 unsigned int cmd, unsigned long arg)
1816 size_t ctrls_size = 0;
1817 void __user *user_ptr = NULL;
1819 #ifdef __OLD_VIDIOC_
1820 cmd = video_fix_command(cmd);
1822 is_ext_ctrl = (cmd == VIDIOC_S_EXT_CTRLS || cmd == VIDIOC_G_EXT_CTRLS ||
1823 cmd == VIDIOC_TRY_EXT_CTRLS);
1825 /* Copy arguments into temp kernel buffer */
1826 switch (_IOC_DIR(cmd)) {
1832 case (_IOC_WRITE | _IOC_READ):
1833 if (_IOC_SIZE(cmd) <= sizeof(sbuf)) {
1836 /* too big to allocate from stack */
1837 mbuf = kmalloc(_IOC_SIZE(cmd),GFP_KERNEL);
1844 if (_IOC_DIR(cmd) & _IOC_WRITE)
1845 if (copy_from_user(parg, (void __user *)arg, _IOC_SIZE(cmd)))
1851 struct v4l2_ext_controls *p = parg;
1853 /* In case of an error, tell the caller that it wasn't
1854 a specific control that caused it. */
1855 p->error_idx = p->count;
1856 user_ptr = (void __user *)p->controls;
1858 ctrls_size = sizeof(struct v4l2_ext_control) * p->count;
1859 /* Note: v4l2_ext_controls fits in sbuf[] so mbuf is still NULL. */
1860 mbuf = kmalloc(ctrls_size, GFP_KERNEL);
1865 if (copy_from_user(mbuf, user_ptr, ctrls_size))
1872 err = __video_do_ioctl(inode, file, cmd, parg);
1873 if (err == -ENOIOCTLCMD)
1876 struct v4l2_ext_controls *p = parg;
1878 p->controls = (void *)user_ptr;
1879 if (p->count && err == 0 && copy_to_user(user_ptr, mbuf, ctrls_size))
1887 /* Copy results into user buffer */
1888 switch (_IOC_DIR(cmd))
1891 case (_IOC_WRITE | _IOC_READ):
1892 if (copy_to_user((void __user *)arg, parg, _IOC_SIZE(cmd)))
1901 EXPORT_SYMBOL(video_ioctl2);
1903 static const struct file_operations video_fops;
1906 * video_register_device - register video4linux devices
1907 * @vfd: video device structure we want to register
1908 * @type: type of device to register
1909 * @nr: which device number (0 == /dev/video0, 1 == /dev/video1, ...
1912 * The registration code assigns minor numbers based on the type
1913 * requested. -ENFILE is returned in all the device slots for this
1914 * category are full. If not then the minor field is set and the
1915 * driver initialize function is called (if non %NULL).
1917 * Zero is returned on success.
1921 * %VFL_TYPE_GRABBER - A frame grabber
1923 * %VFL_TYPE_VTX - A teletext device
1925 * %VFL_TYPE_VBI - Vertical blank data (undecoded)
1927 * %VFL_TYPE_RADIO - A radio card
1930 int video_register_device(struct video_device *vfd, int type, int nr)
1940 case VFL_TYPE_GRABBER:
1941 base=MINOR_VFL_TYPE_GRABBER_MIN;
1942 end=MINOR_VFL_TYPE_GRABBER_MAX+1;
1943 name_base = "video";
1946 base=MINOR_VFL_TYPE_VTX_MIN;
1947 end=MINOR_VFL_TYPE_VTX_MAX+1;
1951 base=MINOR_VFL_TYPE_VBI_MIN;
1952 end=MINOR_VFL_TYPE_VBI_MAX+1;
1955 case VFL_TYPE_RADIO:
1956 base=MINOR_VFL_TYPE_RADIO_MIN;
1957 end=MINOR_VFL_TYPE_RADIO_MAX+1;
1958 name_base = "radio";
1961 printk(KERN_ERR "%s called with unknown type: %d\n",
1966 /* pick a minor number */
1967 mutex_lock(&videodev_lock);
1968 if (nr >= 0 && nr < end-base) {
1969 /* use the one the driver asked for */
1971 if (NULL != video_device[i]) {
1972 mutex_unlock(&videodev_lock);
1976 /* use first free */
1977 for(i=base;i<end;i++)
1978 if (NULL == video_device[i])
1981 mutex_unlock(&videodev_lock);
1985 video_device[i]=vfd;
1987 mutex_unlock(&videodev_lock);
1988 mutex_init(&vfd->lock);
1991 memset(&vfd->class_dev, 0x00, sizeof(vfd->class_dev));
1993 vfd->class_dev.parent = vfd->dev;
1994 vfd->class_dev.class = &video_class;
1995 vfd->class_dev.devt = MKDEV(VIDEO_MAJOR, vfd->minor);
1996 sprintf(vfd->class_dev.bus_id, "%s%d", name_base, i - base);
1997 ret = device_register(&vfd->class_dev);
1999 printk(KERN_ERR "%s: device_register failed\n",
2005 /* needed until all drivers are fixed */
2007 printk(KERN_WARNING "videodev: \"%s\" has no release callback. "
2008 "Please fix your driver for proper sysfs support, see "
2009 "http://lwn.net/Articles/36850/\n", vfd->name);
2014 mutex_lock(&videodev_lock);
2015 video_device[vfd->minor] = NULL;
2017 mutex_unlock(&videodev_lock);
2020 EXPORT_SYMBOL(video_register_device);
2023 * video_unregister_device - unregister a video4linux device
2024 * @vfd: the device to unregister
2026 * This unregisters the passed device and deassigns the minor
2027 * number. Future open calls will be met with errors.
2030 void video_unregister_device(struct video_device *vfd)
2032 mutex_lock(&videodev_lock);
2033 if(video_device[vfd->minor]!=vfd)
2034 panic("videodev: bad unregister");
2036 video_device[vfd->minor]=NULL;
2037 device_unregister(&vfd->class_dev);
2038 mutex_unlock(&videodev_lock);
2040 EXPORT_SYMBOL(video_unregister_device);
2043 * Video fs operations
2045 static const struct file_operations video_fops=
2047 .owner = THIS_MODULE,
2048 .llseek = no_llseek,
2053 * Initialise video for linux
2056 static int __init videodev_init(void)
2060 printk(KERN_INFO "Linux video capture interface: v2.00\n");
2061 if (register_chrdev(VIDEO_MAJOR, VIDEO_NAME, &video_fops)) {
2062 printk(KERN_WARNING "video_dev: unable to get major %d\n", VIDEO_MAJOR);
2066 ret = class_register(&video_class);
2068 unregister_chrdev(VIDEO_MAJOR, VIDEO_NAME);
2069 printk(KERN_WARNING "video_dev: class_register failed\n");
2076 static void __exit videodev_exit(void)
2078 class_unregister(&video_class);
2079 unregister_chrdev(VIDEO_MAJOR, VIDEO_NAME);
2082 module_init(videodev_init)
2083 module_exit(videodev_exit)
2085 MODULE_AUTHOR("Alan Cox, Mauro Carvalho Chehab <mchehab@infradead.org>");
2086 MODULE_DESCRIPTION("Device registrar for Video4Linux drivers v2");
2087 MODULE_LICENSE("GPL");