4 * Backward Compatibility Layer
6 * Support subroutines for providing V4L2 drivers with backward
7 * compatibility with applications using the old API.
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version
12 * 2 of the License, or (at your option) any later version.
14 * Author: Bill Dirks <bdirks@pacbell.net>
20 #include <linux/init.h>
21 #include <linux/module.h>
22 #include <linux/moduleparam.h>
23 #include <linux/types.h>
24 #include <linux/kernel.h>
25 #include <linux/sched.h>
26 #include <linux/smp_lock.h>
29 #include <linux/file.h>
30 #include <linux/string.h>
31 #include <linux/errno.h>
32 #include <linux/slab.h>
33 #include <linux/videodev.h>
34 #include <media/v4l2-common.h>
36 #include <asm/uaccess.h>
37 #include <asm/system.h>
38 #include <asm/pgtable.h>
41 #include <linux/kmod.h>
44 static unsigned int debug
= 0;
45 module_param(debug
, int, 0644);
46 MODULE_PARM_DESC(debug
,"enable debug messages");
47 MODULE_AUTHOR("Bill Dirks");
48 MODULE_DESCRIPTION("v4l(1) compatibility layer for v4l2 drivers.");
49 MODULE_LICENSE("GPL");
51 #define dprintk(fmt, arg...) if (debug) \
52 printk(KERN_DEBUG "v4l1-compat: " fmt , ## arg)
55 * I O C T L T R A N S L A T I O N
57 * From here on down is the code for translating the numerous
58 * ioctl commands from the old API to the new API.
62 get_v4l_control(struct inode
*inode
,
67 struct v4l2_queryctrl qctrl2
;
68 struct v4l2_control ctrl2
;
72 err
= drv(inode
, file
, VIDIOC_QUERYCTRL
, &qctrl2
);
74 dprintk("VIDIOC_QUERYCTRL: %d\n",err
);
76 !(qctrl2
.flags
& V4L2_CTRL_FLAG_DISABLED
))
79 err
= drv(inode
, file
, VIDIOC_G_CTRL
, &ctrl2
);
81 dprintk("VIDIOC_G_CTRL: %d\n",err
);
84 return ((ctrl2
.value
- qctrl2
.minimum
) * 65535
85 + (qctrl2
.maximum
- qctrl2
.minimum
) / 2)
86 / (qctrl2
.maximum
- qctrl2
.minimum
);
92 set_v4l_control(struct inode
*inode
,
98 struct v4l2_queryctrl qctrl2
;
99 struct v4l2_control ctrl2
;
103 err
= drv(inode
, file
, VIDIOC_QUERYCTRL
, &qctrl2
);
105 dprintk("VIDIOC_QUERYCTRL: %d\n",err
);
107 !(qctrl2
.flags
& V4L2_CTRL_FLAG_DISABLED
) &&
108 !(qctrl2
.flags
& V4L2_CTRL_FLAG_GRABBED
))
114 if (value
&& qctrl2
.type
== V4L2_CTRL_TYPE_BOOLEAN
)
116 ctrl2
.id
= qctrl2
.id
;
118 (value
* (qctrl2
.maximum
- qctrl2
.minimum
)
121 ctrl2
.value
+= qctrl2
.minimum
;
122 err
= drv(inode
, file
, VIDIOC_S_CTRL
, &ctrl2
);
124 dprintk("VIDIOC_S_CTRL: %d\n",err
);
129 /* ----------------------------------------------------------------- */
131 static int palette2pixelformat
[] = {
132 [VIDEO_PALETTE_GREY
] = V4L2_PIX_FMT_GREY
,
133 [VIDEO_PALETTE_RGB555
] = V4L2_PIX_FMT_RGB555
,
134 [VIDEO_PALETTE_RGB565
] = V4L2_PIX_FMT_RGB565
,
135 [VIDEO_PALETTE_RGB24
] = V4L2_PIX_FMT_BGR24
,
136 [VIDEO_PALETTE_RGB32
] = V4L2_PIX_FMT_BGR32
,
137 /* yuv packed pixel */
138 [VIDEO_PALETTE_YUYV
] = V4L2_PIX_FMT_YUYV
,
139 [VIDEO_PALETTE_YUV422
] = V4L2_PIX_FMT_YUYV
,
140 [VIDEO_PALETTE_UYVY
] = V4L2_PIX_FMT_UYVY
,
142 [VIDEO_PALETTE_YUV410P
] = V4L2_PIX_FMT_YUV410
,
143 [VIDEO_PALETTE_YUV420
] = V4L2_PIX_FMT_YUV420
,
144 [VIDEO_PALETTE_YUV420P
] = V4L2_PIX_FMT_YUV420
,
145 [VIDEO_PALETTE_YUV411P
] = V4L2_PIX_FMT_YUV411P
,
146 [VIDEO_PALETTE_YUV422P
] = V4L2_PIX_FMT_YUV422P
,
150 palette_to_pixelformat(unsigned int palette
)
152 if (palette
< ARRAY_SIZE(palette2pixelformat
))
153 return palette2pixelformat
[palette
];
159 pixelformat_to_palette(int pixelformat
)
164 case V4L2_PIX_FMT_GREY
:
165 palette
= VIDEO_PALETTE_GREY
;
167 case V4L2_PIX_FMT_RGB555
:
168 palette
= VIDEO_PALETTE_RGB555
;
170 case V4L2_PIX_FMT_RGB565
:
171 palette
= VIDEO_PALETTE_RGB565
;
173 case V4L2_PIX_FMT_BGR24
:
174 palette
= VIDEO_PALETTE_RGB24
;
176 case V4L2_PIX_FMT_BGR32
:
177 palette
= VIDEO_PALETTE_RGB32
;
179 /* yuv packed pixel */
180 case V4L2_PIX_FMT_YUYV
:
181 palette
= VIDEO_PALETTE_YUYV
;
183 case V4L2_PIX_FMT_UYVY
:
184 palette
= VIDEO_PALETTE_UYVY
;
187 case V4L2_PIX_FMT_YUV410
:
188 palette
= VIDEO_PALETTE_YUV420
;
190 case V4L2_PIX_FMT_YUV420
:
191 palette
= VIDEO_PALETTE_YUV420
;
193 case V4L2_PIX_FMT_YUV411P
:
194 palette
= VIDEO_PALETTE_YUV411P
;
196 case V4L2_PIX_FMT_YUV422P
:
197 palette
= VIDEO_PALETTE_YUV422P
;
203 /* ----------------------------------------------------------------- */
205 static int poll_one(struct file
*file
)
209 struct poll_wqueues pwq
;
215 set_current_state(TASK_INTERRUPTIBLE
);
216 mask
= file
->f_op
->poll(file
, table
);
220 if (signal_pending(current
)) {
221 retval
= -ERESTARTSYS
;
226 set_current_state(TASK_RUNNING
);
231 static int count_inputs(struct inode
*inode
,
235 struct v4l2_input input2
;
239 memset(&input2
,0,sizeof(input2
));
241 if (0 != drv(inode
,file
,VIDIOC_ENUMINPUT
, &input2
))
247 static int check_size(struct inode
*inode
,
250 int *maxw
, int *maxh
)
252 struct v4l2_fmtdesc desc2
;
253 struct v4l2_format fmt2
;
255 memset(&desc2
,0,sizeof(desc2
));
256 memset(&fmt2
,0,sizeof(fmt2
));
258 desc2
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
259 if (0 != drv(inode
,file
,VIDIOC_ENUM_FMT
, &desc2
))
262 fmt2
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
263 fmt2
.fmt
.pix
.width
= 10000;
264 fmt2
.fmt
.pix
.height
= 10000;
265 fmt2
.fmt
.pix
.pixelformat
= desc2
.pixelformat
;
266 if (0 != drv(inode
,file
,VIDIOC_TRY_FMT
, &fmt2
))
269 *maxw
= fmt2
.fmt
.pix
.width
;
270 *maxh
= fmt2
.fmt
.pix
.height
;
276 /* ----------------------------------------------------------------- */
279 * This function is exported.
282 v4l_compat_translate_ioctl(struct inode
*inode
,
288 struct v4l2_capability
*cap2
= NULL
;
289 struct v4l2_format
*fmt2
= NULL
;
290 enum v4l2_buf_type captype
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
292 struct v4l2_framebuffer fbuf2
;
293 struct v4l2_input input2
;
294 struct v4l2_tuner tun2
;
295 struct v4l2_standard std2
;
296 struct v4l2_frequency freq2
;
297 struct v4l2_audio aud2
;
298 struct v4l2_queryctrl qctrl2
;
299 struct v4l2_buffer buf2
;
304 case VIDIOCGCAP
: /* capability */
306 struct video_capability
*cap
= arg
;
308 cap2
= kzalloc(sizeof(*cap2
),GFP_KERNEL
);
309 memset(cap
, 0, sizeof(*cap
));
310 memset(&fbuf2
, 0, sizeof(fbuf2
));
312 err
= drv(inode
, file
, VIDIOC_QUERYCAP
, cap2
);
314 dprintk("VIDIOCGCAP / VIDIOC_QUERYCAP: %d\n",err
);
317 if (cap2
->capabilities
& V4L2_CAP_VIDEO_OVERLAY
) {
318 err
= drv(inode
, file
, VIDIOC_G_FBUF
, &fbuf2
);
320 dprintk("VIDIOCGCAP / VIDIOC_G_FBUF: %d\n",err
);
321 memset(&fbuf2
, 0, sizeof(fbuf2
));
326 memcpy(cap
->name
, cap2
->card
,
327 min(sizeof(cap
->name
), sizeof(cap2
->card
)));
328 cap
->name
[sizeof(cap
->name
) - 1] = 0;
329 if (cap2
->capabilities
& V4L2_CAP_VIDEO_CAPTURE
)
330 cap
->type
|= VID_TYPE_CAPTURE
;
331 if (cap2
->capabilities
& V4L2_CAP_TUNER
)
332 cap
->type
|= VID_TYPE_TUNER
;
333 if (cap2
->capabilities
& V4L2_CAP_VBI_CAPTURE
)
334 cap
->type
|= VID_TYPE_TELETEXT
;
335 if (cap2
->capabilities
& V4L2_CAP_VIDEO_OVERLAY
)
336 cap
->type
|= VID_TYPE_OVERLAY
;
337 if (fbuf2
.capability
& V4L2_FBUF_CAP_LIST_CLIPPING
)
338 cap
->type
|= VID_TYPE_CLIPPING
;
340 cap
->channels
= count_inputs(inode
,file
,drv
);
341 check_size(inode
,file
,drv
,
342 &cap
->maxwidth
,&cap
->maxheight
);
343 cap
->audios
= 0; /* FIXME */
344 cap
->minwidth
= 48; /* FIXME */
345 cap
->minheight
= 32; /* FIXME */
348 case VIDIOCGFBUF
: /* get frame buffer */
350 struct video_buffer
*buffer
= arg
;
352 memset(buffer
, 0, sizeof(*buffer
));
354 err
= drv(inode
, file
, VIDIOC_G_FBUF
, &fbuf2
);
356 dprintk("VIDIOCGFBUF / VIDIOC_G_FBUF: %d\n",err
);
359 buffer
->base
= fbuf2
.base
;
360 buffer
->height
= fbuf2
.fmt
.height
;
361 buffer
->width
= fbuf2
.fmt
.width
;
363 switch (fbuf2
.fmt
.pixelformat
) {
364 case V4L2_PIX_FMT_RGB332
:
367 case V4L2_PIX_FMT_RGB555
:
370 case V4L2_PIX_FMT_RGB565
:
373 case V4L2_PIX_FMT_BGR24
:
376 case V4L2_PIX_FMT_BGR32
:
382 if (fbuf2
.fmt
.bytesperline
) {
383 buffer
->bytesperline
= fbuf2
.fmt
.bytesperline
;
384 if (!buffer
->depth
&& buffer
->width
)
385 buffer
->depth
= ((fbuf2
.fmt
.bytesperline
<<3)
386 + (buffer
->width
-1) )
389 buffer
->bytesperline
=
390 (buffer
->width
* buffer
->depth
+ 7) & 7;
391 buffer
->bytesperline
>>= 3;
395 case VIDIOCSFBUF
: /* set frame buffer */
397 struct video_buffer
*buffer
= arg
;
399 memset(&fbuf2
, 0, sizeof(fbuf2
));
400 fbuf2
.base
= buffer
->base
;
401 fbuf2
.fmt
.height
= buffer
->height
;
402 fbuf2
.fmt
.width
= buffer
->width
;
403 switch (buffer
->depth
) {
405 fbuf2
.fmt
.pixelformat
= V4L2_PIX_FMT_RGB332
;
408 fbuf2
.fmt
.pixelformat
= V4L2_PIX_FMT_RGB555
;
411 fbuf2
.fmt
.pixelformat
= V4L2_PIX_FMT_RGB565
;
414 fbuf2
.fmt
.pixelformat
= V4L2_PIX_FMT_BGR24
;
417 fbuf2
.fmt
.pixelformat
= V4L2_PIX_FMT_BGR32
;
420 fbuf2
.fmt
.bytesperline
= buffer
->bytesperline
;
421 err
= drv(inode
, file
, VIDIOC_S_FBUF
, &fbuf2
);
423 dprintk("VIDIOCSFBUF / VIDIOC_S_FBUF: %d\n",err
);
426 case VIDIOCGWIN
: /* get window or capture dimensions */
428 struct video_window
*win
= arg
;
430 fmt2
= kzalloc(sizeof(*fmt2
),GFP_KERNEL
);
431 memset(win
,0,sizeof(*win
));
433 fmt2
->type
= V4L2_BUF_TYPE_VIDEO_OVERLAY
;
434 err
= drv(inode
, file
, VIDIOC_G_FMT
, fmt2
);
436 dprintk("VIDIOCGWIN / VIDIOC_G_WIN: %d\n",err
);
438 win
->x
= fmt2
->fmt
.win
.w
.left
;
439 win
->y
= fmt2
->fmt
.win
.w
.top
;
440 win
->width
= fmt2
->fmt
.win
.w
.width
;
441 win
->height
= fmt2
->fmt
.win
.w
.height
;
442 win
->chromakey
= fmt2
->fmt
.win
.chromakey
;
448 fmt2
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
449 err
= drv(inode
, file
, VIDIOC_G_FMT
, fmt2
);
451 dprintk("VIDIOCGWIN / VIDIOC_G_FMT: %d\n",err
);
456 win
->width
= fmt2
->fmt
.pix
.width
;
457 win
->height
= fmt2
->fmt
.pix
.height
;
463 case VIDIOCSWIN
: /* set window and/or capture dimensions */
465 struct video_window
*win
= arg
;
468 fmt2
= kzalloc(sizeof(*fmt2
),GFP_KERNEL
);
469 fmt2
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
470 drv(inode
, file
, VIDIOC_STREAMOFF
, &fmt2
->type
);
471 err1
= drv(inode
, file
, VIDIOC_G_FMT
, fmt2
);
473 dprintk("VIDIOCSWIN / VIDIOC_G_FMT: %d\n",err
);
475 fmt2
->fmt
.pix
.width
= win
->width
;
476 fmt2
->fmt
.pix
.height
= win
->height
;
477 fmt2
->fmt
.pix
.field
= V4L2_FIELD_ANY
;
478 fmt2
->fmt
.pix
.bytesperline
= 0;
479 err
= drv(inode
, file
, VIDIOC_S_FMT
, fmt2
);
481 dprintk("VIDIOCSWIN / VIDIOC_S_FMT #1: %d\n",
483 win
->width
= fmt2
->fmt
.pix
.width
;
484 win
->height
= fmt2
->fmt
.pix
.height
;
487 memset(fmt2
,0,sizeof(*fmt2
));
488 fmt2
->type
= V4L2_BUF_TYPE_VIDEO_OVERLAY
;
489 fmt2
->fmt
.win
.w
.left
= win
->x
;
490 fmt2
->fmt
.win
.w
.top
= win
->y
;
491 fmt2
->fmt
.win
.w
.width
= win
->width
;
492 fmt2
->fmt
.win
.w
.height
= win
->height
;
493 fmt2
->fmt
.win
.chromakey
= win
->chromakey
;
494 fmt2
->fmt
.win
.clips
= (void __user
*)win
->clips
;
495 fmt2
->fmt
.win
.clipcount
= win
->clipcount
;
496 err2
= drv(inode
, file
, VIDIOC_S_FMT
, fmt2
);
498 dprintk("VIDIOCSWIN / VIDIOC_S_FMT #2: %d\n",err
);
500 if (err1
!= 0 && err2
!= 0)
504 case VIDIOCCAPTURE
: /* turn on/off preview */
509 /* dirty hack time. But v4l1 has no STREAMOFF
510 * equivalent in the API, and this one at
511 * least comes close ... */
512 drv(inode
, file
, VIDIOC_STREAMOFF
, &captype
);
514 err
= drv(inode
, file
, VIDIOC_OVERLAY
, arg
);
516 dprintk("VIDIOCCAPTURE / VIDIOC_PREVIEW: %d\n",err
);
519 case VIDIOCGCHAN
: /* get input information */
521 struct video_channel
*chan
= arg
;
523 memset(&input2
,0,sizeof(input2
));
524 input2
.index
= chan
->channel
;
525 err
= drv(inode
, file
, VIDIOC_ENUMINPUT
, &input2
);
527 dprintk("VIDIOCGCHAN / VIDIOC_ENUMINPUT: "
528 "channel=%d err=%d\n",chan
->channel
,err
);
531 chan
->channel
= input2
.index
;
532 memcpy(chan
->name
, input2
.name
,
533 min(sizeof(chan
->name
), sizeof(input2
.name
)));
534 chan
->name
[sizeof(chan
->name
) - 1] = 0;
535 chan
->tuners
= (input2
.type
== V4L2_INPUT_TYPE_TUNER
) ? 1 : 0;
536 chan
->flags
= (chan
->tuners
) ? VIDEO_VC_TUNER
: 0;
537 switch (input2
.type
) {
538 case V4L2_INPUT_TYPE_TUNER
:
539 chan
->type
= VIDEO_TYPE_TV
;
542 case V4L2_INPUT_TYPE_CAMERA
:
543 chan
->type
= VIDEO_TYPE_CAMERA
;
547 err
= drv(inode
, file
, VIDIOC_G_STD
, &sid
);
549 dprintk("VIDIOCGCHAN / VIDIOC_G_STD: %d\n",err
);
551 if (sid
& V4L2_STD_PAL
)
552 chan
->norm
= VIDEO_MODE_PAL
;
553 if (sid
& V4L2_STD_NTSC
)
554 chan
->norm
= VIDEO_MODE_NTSC
;
555 if (sid
& V4L2_STD_SECAM
)
556 chan
->norm
= VIDEO_MODE_SECAM
;
560 case VIDIOCSCHAN
: /* set input */
562 struct video_channel
*chan
= arg
;
565 err
= drv(inode
, file
, VIDIOC_S_INPUT
, &chan
->channel
);
567 dprintk("VIDIOCSCHAN / VIDIOC_S_INPUT: %d\n",err
);
568 switch (chan
->norm
) {
572 case VIDEO_MODE_NTSC
:
575 case VIDEO_MODE_SECAM
:
576 sid
= V4L2_STD_SECAM
;
580 err
= drv(inode
, file
, VIDIOC_S_STD
, &sid
);
582 dprintk("VIDIOCSCHAN / VIDIOC_S_STD: %d\n",err
);
586 case VIDIOCGPICT
: /* get tone controls & partial capture format */
588 struct video_picture
*pict
= arg
;
590 pict
->brightness
= get_v4l_control(inode
, file
,
591 V4L2_CID_BRIGHTNESS
,drv
);
592 pict
->hue
= get_v4l_control(inode
, file
,
594 pict
->contrast
= get_v4l_control(inode
, file
,
595 V4L2_CID_CONTRAST
, drv
);
596 pict
->colour
= get_v4l_control(inode
, file
,
597 V4L2_CID_SATURATION
, drv
);
598 pict
->whiteness
= get_v4l_control(inode
, file
,
599 V4L2_CID_WHITENESS
, drv
);
601 fmt2
= kzalloc(sizeof(*fmt2
),GFP_KERNEL
);
602 fmt2
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
603 err
= drv(inode
, file
, VIDIOC_G_FMT
, fmt2
);
605 dprintk("VIDIOCGPICT / VIDIOC_G_FMT: %d\n",err
);
609 pict
->depth
= ((fmt2
->fmt
.pix
.bytesperline
<<3)
610 + (fmt2
->fmt
.pix
.width
-1) )
611 /fmt2
->fmt
.pix
.width
;
612 pict
->palette
= pixelformat_to_palette(
613 fmt2
->fmt
.pix
.pixelformat
);
616 case VIDIOCSPICT
: /* set tone controls & partial capture format */
618 struct video_picture
*pict
= arg
;
620 set_v4l_control(inode
, file
,
621 V4L2_CID_BRIGHTNESS
, pict
->brightness
, drv
);
622 set_v4l_control(inode
, file
,
623 V4L2_CID_HUE
, pict
->hue
, drv
);
624 set_v4l_control(inode
, file
,
625 V4L2_CID_CONTRAST
, pict
->contrast
, drv
);
626 set_v4l_control(inode
, file
,
627 V4L2_CID_SATURATION
, pict
->colour
, drv
);
628 set_v4l_control(inode
, file
,
629 V4L2_CID_WHITENESS
, pict
->whiteness
, drv
);
631 fmt2
= kzalloc(sizeof(*fmt2
),GFP_KERNEL
);
632 fmt2
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
633 err
= drv(inode
, file
, VIDIOC_G_FMT
, fmt2
);
635 dprintk("VIDIOCSPICT / VIDIOC_G_FMT: %d\n",err
);
636 if (fmt2
->fmt
.pix
.pixelformat
!=
637 palette_to_pixelformat(pict
->palette
)) {
638 fmt2
->fmt
.pix
.pixelformat
= palette_to_pixelformat(
640 err
= drv(inode
, file
, VIDIOC_S_FMT
, fmt2
);
642 dprintk("VIDIOCSPICT / VIDIOC_S_FMT: %d\n",err
);
645 err
= drv(inode
, file
, VIDIOC_G_FBUF
, &fbuf2
);
647 dprintk("VIDIOCSPICT / VIDIOC_G_FBUF: %d\n",err
);
648 if (fbuf2
.fmt
.pixelformat
!=
649 palette_to_pixelformat(pict
->palette
)) {
650 fbuf2
.fmt
.pixelformat
= palette_to_pixelformat(
652 err
= drv(inode
, file
, VIDIOC_S_FBUF
, &fbuf2
);
654 dprintk("VIDIOCSPICT / VIDIOC_S_FBUF: %d\n",err
);
655 err
= 0; /* likely fails for non-root */
659 case VIDIOCGTUNER
: /* get tuner information */
661 struct video_tuner
*tun
= arg
;
663 memset(&tun2
,0,sizeof(tun2
));
664 err
= drv(inode
, file
, VIDIOC_G_TUNER
, &tun2
);
666 dprintk("VIDIOCGTUNER / VIDIOC_G_TUNER: %d\n",err
);
669 memcpy(tun
->name
, tun2
.name
,
670 min(sizeof(tun
->name
), sizeof(tun2
.name
)));
671 tun
->name
[sizeof(tun
->name
) - 1] = 0;
672 tun
->rangelow
= tun2
.rangelow
;
673 tun
->rangehigh
= tun2
.rangehigh
;
675 tun
->mode
= VIDEO_MODE_AUTO
;
677 for (i
= 0; i
< 64; i
++) {
678 memset(&std2
,0,sizeof(std2
));
680 if (0 != drv(inode
, file
, VIDIOC_ENUMSTD
, &std2
))
682 if (std2
.id
& V4L2_STD_PAL
)
683 tun
->flags
|= VIDEO_TUNER_PAL
;
684 if (std2
.id
& V4L2_STD_NTSC
)
685 tun
->flags
|= VIDEO_TUNER_NTSC
;
686 if (std2
.id
& V4L2_STD_SECAM
)
687 tun
->flags
|= VIDEO_TUNER_SECAM
;
690 err
= drv(inode
, file
, VIDIOC_G_STD
, &sid
);
692 dprintk("VIDIOCGTUNER / VIDIOC_G_STD: %d\n",err
);
694 if (sid
& V4L2_STD_PAL
)
695 tun
->mode
= VIDEO_MODE_PAL
;
696 if (sid
& V4L2_STD_NTSC
)
697 tun
->mode
= VIDEO_MODE_NTSC
;
698 if (sid
& V4L2_STD_SECAM
)
699 tun
->mode
= VIDEO_MODE_SECAM
;
702 if (tun2
.capability
& V4L2_TUNER_CAP_LOW
)
703 tun
->flags
|= VIDEO_TUNER_LOW
;
704 if (tun2
.rxsubchans
& V4L2_TUNER_SUB_STEREO
)
705 tun
->flags
|= VIDEO_TUNER_STEREO_ON
;
706 tun
->signal
= tun2
.signal
;
709 case VIDIOCSTUNER
: /* select a tuner input */
714 case VIDIOCGFREQ
: /* get frequency */
716 unsigned long *freq
= arg
;
719 err
= drv(inode
, file
, VIDIOC_G_FREQUENCY
, &freq2
);
721 dprintk("VIDIOCGFREQ / VIDIOC_G_FREQUENCY: %d\n",err
);
723 *freq
= freq2
.frequency
;
726 case VIDIOCSFREQ
: /* set frequency */
728 unsigned long *freq
= arg
;
731 drv(inode
, file
, VIDIOC_G_FREQUENCY
, &freq2
);
732 freq2
.frequency
= *freq
;
733 err
= drv(inode
, file
, VIDIOC_S_FREQUENCY
, &freq2
);
735 dprintk("VIDIOCSFREQ / VIDIOC_S_FREQUENCY: %d\n",err
);
738 case VIDIOCGAUDIO
: /* get audio properties/controls */
740 struct video_audio
*aud
= arg
;
742 err
= drv(inode
, file
, VIDIOC_G_AUDIO
, &aud2
);
744 dprintk("VIDIOCGAUDIO / VIDIOC_G_AUDIO: %d\n",err
);
747 memcpy(aud
->name
, aud2
.name
,
748 min(sizeof(aud
->name
), sizeof(aud2
.name
)));
749 aud
->name
[sizeof(aud
->name
) - 1] = 0;
750 aud
->audio
= aud2
.index
;
752 i
= get_v4l_control(inode
, file
, V4L2_CID_AUDIO_VOLUME
, drv
);
755 aud
->flags
|= VIDEO_AUDIO_VOLUME
;
757 i
= get_v4l_control(inode
, file
, V4L2_CID_AUDIO_BASS
, drv
);
760 aud
->flags
|= VIDEO_AUDIO_BASS
;
762 i
= get_v4l_control(inode
, file
, V4L2_CID_AUDIO_TREBLE
, drv
);
765 aud
->flags
|= VIDEO_AUDIO_TREBLE
;
767 i
= get_v4l_control(inode
, file
, V4L2_CID_AUDIO_BALANCE
, drv
);
770 aud
->flags
|= VIDEO_AUDIO_BALANCE
;
772 i
= get_v4l_control(inode
, file
, V4L2_CID_AUDIO_MUTE
, drv
);
775 aud
->flags
|= VIDEO_AUDIO_MUTE
;
776 aud
->flags
|= VIDEO_AUDIO_MUTABLE
;
779 qctrl2
.id
= V4L2_CID_AUDIO_VOLUME
;
780 if (drv(inode
, file
, VIDIOC_QUERYCTRL
, &qctrl2
) == 0 &&
781 !(qctrl2
.flags
& V4L2_CTRL_FLAG_DISABLED
))
782 aud
->step
= qctrl2
.step
;
785 memset(&tun2
,0,sizeof(tun2
));
786 err
= drv(inode
, file
, VIDIOC_G_TUNER
, &tun2
);
788 dprintk("VIDIOCGAUDIO / VIDIOC_G_TUNER: %d\n",err
);
793 if (tun2
.rxsubchans
& V4L2_TUNER_SUB_LANG2
)
794 aud
->mode
= VIDEO_SOUND_LANG1
| VIDEO_SOUND_LANG2
;
795 else if (tun2
.rxsubchans
& V4L2_TUNER_SUB_STEREO
)
796 aud
->mode
= VIDEO_SOUND_STEREO
;
797 else if (tun2
.rxsubchans
& V4L2_TUNER_SUB_MONO
)
798 aud
->mode
= VIDEO_SOUND_MONO
;
801 case VIDIOCSAUDIO
: /* set audio controls */
803 struct video_audio
*aud
= arg
;
805 memset(&aud2
,0,sizeof(aud2
));
806 memset(&tun2
,0,sizeof(tun2
));
808 aud2
.index
= aud
->audio
;
809 err
= drv(inode
, file
, VIDIOC_S_AUDIO
, &aud2
);
811 dprintk("VIDIOCSAUDIO / VIDIOC_S_AUDIO: %d\n",err
);
815 set_v4l_control(inode
, file
, V4L2_CID_AUDIO_VOLUME
,
817 set_v4l_control(inode
, file
, V4L2_CID_AUDIO_BASS
,
819 set_v4l_control(inode
, file
, V4L2_CID_AUDIO_TREBLE
,
821 set_v4l_control(inode
, file
, V4L2_CID_AUDIO_BALANCE
,
823 set_v4l_control(inode
, file
, V4L2_CID_AUDIO_MUTE
,
824 !!(aud
->flags
& VIDEO_AUDIO_MUTE
), drv
);
826 err
= drv(inode
, file
, VIDIOC_G_TUNER
, &tun2
);
828 dprintk("VIDIOCSAUDIO / VIDIOC_G_TUNER: %d\n",err
);
832 case VIDEO_SOUND_MONO
:
833 case VIDEO_SOUND_LANG1
:
834 tun2
.audmode
= V4L2_TUNER_MODE_MONO
;
836 case VIDEO_SOUND_STEREO
:
837 tun2
.audmode
= V4L2_TUNER_MODE_STEREO
;
839 case VIDEO_SOUND_LANG2
:
840 tun2
.audmode
= V4L2_TUNER_MODE_LANG2
;
843 err
= drv(inode
, file
, VIDIOC_S_TUNER
, &tun2
);
845 dprintk("VIDIOCSAUDIO / VIDIOC_S_TUNER: %d\n",err
);
850 case VIDIOCMCAPTURE
: /* capture a frame */
852 struct video_mmap
*mm
= arg
;
854 fmt2
= kzalloc(sizeof(*fmt2
),GFP_KERNEL
);
855 memset(&buf2
,0,sizeof(buf2
));
857 fmt2
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
858 err
= drv(inode
, file
, VIDIOC_G_FMT
, fmt2
);
860 dprintk("VIDIOCMCAPTURE / VIDIOC_G_FMT: %d\n",err
);
863 if (mm
->width
!= fmt2
->fmt
.pix
.width
||
864 mm
->height
!= fmt2
->fmt
.pix
.height
||
865 palette_to_pixelformat(mm
->format
) !=
866 fmt2
->fmt
.pix
.pixelformat
)
867 {/* New capture format... */
868 fmt2
->fmt
.pix
.width
= mm
->width
;
869 fmt2
->fmt
.pix
.height
= mm
->height
;
870 fmt2
->fmt
.pix
.pixelformat
=
871 palette_to_pixelformat(mm
->format
);
872 fmt2
->fmt
.pix
.field
= V4L2_FIELD_ANY
;
873 fmt2
->fmt
.pix
.bytesperline
= 0;
874 err
= drv(inode
, file
, VIDIOC_S_FMT
, fmt2
);
876 dprintk("VIDIOCMCAPTURE / VIDIOC_S_FMT: %d\n",err
);
880 buf2
.index
= mm
->frame
;
881 buf2
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
882 err
= drv(inode
, file
, VIDIOC_QUERYBUF
, &buf2
);
884 dprintk("VIDIOCMCAPTURE / VIDIOC_QUERYBUF: %d\n",err
);
887 err
= drv(inode
, file
, VIDIOC_QBUF
, &buf2
);
889 dprintk("VIDIOCMCAPTURE / VIDIOC_QBUF: %d\n",err
);
892 err
= drv(inode
, file
, VIDIOC_STREAMON
, &captype
);
894 dprintk("VIDIOCMCAPTURE / VIDIOC_STREAMON: %d\n",err
);
897 case VIDIOCSYNC
: /* wait for a frame */
902 buf2
.type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
903 err
= drv(inode
, file
, VIDIOC_QUERYBUF
, &buf2
);
906 dprintk("VIDIOCSYNC / VIDIOC_QUERYBUF: %d\n",err
);
909 if (!(buf2
.flags
& V4L2_BUF_FLAG_MAPPED
)) {
910 /* Buffer is not mapped */
915 /* make sure capture actually runs so we don't block forever */
916 err
= drv(inode
, file
, VIDIOC_STREAMON
, &captype
);
918 dprintk("VIDIOCSYNC / VIDIOC_STREAMON: %d\n",err
);
922 /* Loop as long as the buffer is queued, but not done */
924 (V4L2_BUF_FLAG_QUEUED
| V4L2_BUF_FLAG_DONE
))
925 == V4L2_BUF_FLAG_QUEUED
)
927 err
= poll_one(file
);
928 if (err
< 0 || /* error or sleep was interrupted */
929 err
== 0) /* timeout? Shouldn't occur. */
931 err
= drv(inode
, file
, VIDIOC_QUERYBUF
, &buf2
);
933 dprintk("VIDIOCSYNC / VIDIOC_QUERYBUF: %d\n",err
);
935 if (!(buf2
.flags
& V4L2_BUF_FLAG_DONE
)) /* not done */
938 err
= drv(inode
, file
, VIDIOC_DQBUF
, &buf2
);
940 dprintk("VIDIOCSYNC / VIDIOC_DQBUF: %d\n",err
);
941 } while (err
== 0 && buf2
.index
!= *i
);
945 case VIDIOCGVBIFMT
: /* query VBI data capture format */
947 struct vbi_format
*fmt
= arg
;
949 fmt2
= kzalloc(sizeof(*fmt2
),GFP_KERNEL
);
950 fmt2
->type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
952 err
= drv(inode
, file
, VIDIOC_G_FMT
, fmt2
);
954 dprintk("VIDIOCGVBIFMT / VIDIOC_G_FMT: %d\n", err
);
957 if (fmt2
->fmt
.vbi
.sample_format
!= V4L2_PIX_FMT_GREY
) {
961 memset(fmt
, 0, sizeof(*fmt
));
962 fmt
->samples_per_line
= fmt2
->fmt
.vbi
.samples_per_line
;
963 fmt
->sampling_rate
= fmt2
->fmt
.vbi
.sampling_rate
;
964 fmt
->sample_format
= VIDEO_PALETTE_RAW
;
965 fmt
->start
[0] = fmt2
->fmt
.vbi
.start
[0];
966 fmt
->count
[0] = fmt2
->fmt
.vbi
.count
[0];
967 fmt
->start
[1] = fmt2
->fmt
.vbi
.start
[1];
968 fmt
->count
[1] = fmt2
->fmt
.vbi
.count
[1];
969 fmt
->flags
= fmt2
->fmt
.vbi
.flags
& 0x03;
974 struct vbi_format
*fmt
= arg
;
976 if (VIDEO_PALETTE_RAW
!= fmt
->sample_format
) {
981 fmt2
= kzalloc(sizeof(*fmt2
),GFP_KERNEL
);
983 fmt2
->type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
984 fmt2
->fmt
.vbi
.samples_per_line
= fmt
->samples_per_line
;
985 fmt2
->fmt
.vbi
.sampling_rate
= fmt
->sampling_rate
;
986 fmt2
->fmt
.vbi
.sample_format
= V4L2_PIX_FMT_GREY
;
987 fmt2
->fmt
.vbi
.start
[0] = fmt
->start
[0];
988 fmt2
->fmt
.vbi
.count
[0] = fmt
->count
[0];
989 fmt2
->fmt
.vbi
.start
[1] = fmt
->start
[1];
990 fmt2
->fmt
.vbi
.count
[1] = fmt
->count
[1];
991 fmt2
->fmt
.vbi
.flags
= fmt
->flags
;
992 err
= drv(inode
, file
, VIDIOC_TRY_FMT
, fmt2
);
994 dprintk("VIDIOCSVBIFMT / VIDIOC_TRY_FMT: %d\n", err
);
998 if (fmt2
->fmt
.vbi
.samples_per_line
!= fmt
->samples_per_line
||
999 fmt2
->fmt
.vbi
.sampling_rate
!= fmt
->sampling_rate
||
1000 fmt2
->fmt
.vbi
.sample_format
!= V4L2_PIX_FMT_GREY
||
1001 fmt2
->fmt
.vbi
.start
[0] != fmt
->start
[0] ||
1002 fmt2
->fmt
.vbi
.count
[0] != fmt
->count
[0] ||
1003 fmt2
->fmt
.vbi
.start
[1] != fmt
->start
[1] ||
1004 fmt2
->fmt
.vbi
.count
[1] != fmt
->count
[1] ||
1005 fmt2
->fmt
.vbi
.flags
!= fmt
->flags
) {
1009 err
= drv(inode
, file
, VIDIOC_S_FMT
, fmt2
);
1011 dprintk("VIDIOCSVBIFMT / VIDIOC_S_FMT: %d\n", err
);
1025 EXPORT_SYMBOL(v4l_compat_translate_ioctl
);