3 bttv - Bt848 frame grabber driver
5 Copyright (C) 1996,97,98 Ralph Metzler <rjkm@thp.uni-koeln.de>
6 & Marcus Metzler <mocm@thp.uni-koeln.de>
7 (c) 1999-2002 Gerd Knorr <kraxel@bytesex.org>
9 some v4l2 code lines are taken from Justin's bttv2 driver which is
10 (c) 2000 Justin Schoeman <justin@suntiger.ee.up.ac.za>
13 (c) 2005-2006 Nickolay V. Shmyrev <nshmyrev@yandex.ru>
15 Fixes to be fully V4L2 compliant by
16 (c) 2006 Mauro Carvalho Chehab <mchehab@infradead.org>
18 Cropping and overscan support
19 Copyright (C) 2005, 2006 Michael H. Schimek <mschimek@gmx.at>
20 Sponsored by OPQ Systems AB
22 This program is free software; you can redistribute it and/or modify
23 it under the terms of the GNU General Public License as published by
24 the Free Software Foundation; either version 2 of the License, or
25 (at your option) any later version.
27 This program is distributed in the hope that it will be useful,
28 but WITHOUT ANY WARRANTY; without even the implied warranty of
29 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 GNU General Public License for more details.
32 You should have received a copy of the GNU General Public License
33 along with this program; if not, write to the Free Software
34 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
37 #include <linux/init.h>
38 #include <linux/module.h>
39 #include <linux/delay.h>
40 #include <linux/errno.h>
42 #include <linux/kernel.h>
43 #include <linux/sched.h>
44 #include <linux/interrupt.h>
45 #include <linux/kdev_t.h>
47 #include <media/v4l2-common.h>
48 #include <media/v4l2-ioctl.h>
49 #include <media/tvaudio.h>
50 #include <media/msp3400.h>
52 #include <linux/dma-mapping.h>
55 #include <asm/byteorder.h>
57 #include <media/rds.h>
60 unsigned int bttv_num; /* number of Bt848s in use */
61 struct bttv bttvs[BTTV_MAX];
63 unsigned int bttv_debug;
64 unsigned int bttv_verbose = 1;
65 unsigned int bttv_gpio;
67 /* config variables */
69 static unsigned int bigendian=1;
71 static unsigned int bigendian;
73 static unsigned int radio[BTTV_MAX];
74 static unsigned int irq_debug;
75 static unsigned int gbuffers = 8;
76 static unsigned int gbufsize = 0x208000;
77 static unsigned int reset_crop = 1;
79 static int video_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
80 static int radio_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
81 static int vbi_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
82 static int debug_latency;
84 static unsigned int fdsr;
87 static unsigned int combfilter;
88 static unsigned int lumafilter;
89 static unsigned int automute = 1;
90 static unsigned int chroma_agc;
91 static unsigned int adc_crush = 1;
92 static unsigned int whitecrush_upper = 0xCF;
93 static unsigned int whitecrush_lower = 0x7F;
94 static unsigned int vcr_hack;
95 static unsigned int irq_iswitch;
96 static unsigned int uv_ratio = 50;
97 static unsigned int full_luma_range;
98 static unsigned int coring;
100 /* API features (turn on/off stuff for testing) */
101 static unsigned int v4l2 = 1;
104 module_param(bttv_verbose, int, 0644);
105 module_param(bttv_gpio, int, 0644);
106 module_param(bttv_debug, int, 0644);
107 module_param(irq_debug, int, 0644);
108 module_param(debug_latency, int, 0644);
110 module_param(fdsr, int, 0444);
111 module_param(gbuffers, int, 0444);
112 module_param(gbufsize, int, 0444);
113 module_param(reset_crop, int, 0444);
115 module_param(v4l2, int, 0644);
116 module_param(bigendian, int, 0644);
117 module_param(irq_iswitch, int, 0644);
118 module_param(combfilter, int, 0444);
119 module_param(lumafilter, int, 0444);
120 module_param(automute, int, 0444);
121 module_param(chroma_agc, int, 0444);
122 module_param(adc_crush, int, 0444);
123 module_param(whitecrush_upper, int, 0444);
124 module_param(whitecrush_lower, int, 0444);
125 module_param(vcr_hack, int, 0444);
126 module_param(uv_ratio, int, 0444);
127 module_param(full_luma_range, int, 0444);
128 module_param(coring, int, 0444);
130 module_param_array(radio, int, NULL, 0444);
131 module_param_array(video_nr, int, NULL, 0444);
132 module_param_array(radio_nr, int, NULL, 0444);
133 module_param_array(vbi_nr, int, NULL, 0444);
135 MODULE_PARM_DESC(radio,"The TV card supports radio, default is 0 (no)");
136 MODULE_PARM_DESC(bigendian,"byte order of the framebuffer, default is native endian");
137 MODULE_PARM_DESC(bttv_verbose,"verbose startup messages, default is 1 (yes)");
138 MODULE_PARM_DESC(bttv_gpio,"log gpio changes, default is 0 (no)");
139 MODULE_PARM_DESC(bttv_debug,"debug messages, default is 0 (no)");
140 MODULE_PARM_DESC(irq_debug,"irq handler debug messages, default is 0 (no)");
141 MODULE_PARM_DESC(gbuffers,"number of capture buffers. range 2-32, default 8");
142 MODULE_PARM_DESC(gbufsize,"size of the capture buffers, default is 0x208000");
143 MODULE_PARM_DESC(reset_crop,"reset cropping parameters at open(), default "
144 "is 1 (yes) for compatibility with older applications");
145 MODULE_PARM_DESC(automute,"mute audio on bad/missing video signal, default is 1 (yes)");
146 MODULE_PARM_DESC(chroma_agc,"enables the AGC of chroma signal, default is 0 (no)");
147 MODULE_PARM_DESC(adc_crush,"enables the luminance ADC crush, default is 1 (yes)");
148 MODULE_PARM_DESC(whitecrush_upper,"sets the white crush upper value, default is 207");
149 MODULE_PARM_DESC(whitecrush_lower,"sets the white crush lower value, default is 127");
150 MODULE_PARM_DESC(vcr_hack,"enables the VCR hack (improves synch on poor VCR tapes), default is 0 (no)");
151 MODULE_PARM_DESC(irq_iswitch,"switch inputs in irq handler");
152 MODULE_PARM_DESC(uv_ratio,"ratio between u and v gains, default is 50");
153 MODULE_PARM_DESC(full_luma_range,"use the full luma range, default is 0 (no)");
154 MODULE_PARM_DESC(coring,"set the luma coring level, default is 0 (no)");
155 MODULE_PARM_DESC(video_nr, "video device numbers");
156 MODULE_PARM_DESC(vbi_nr, "vbi device numbers");
157 MODULE_PARM_DESC(radio_nr, "radio device numbers");
159 MODULE_DESCRIPTION("bttv - v4l/v4l2 driver module for bt848/878 based cards");
160 MODULE_AUTHOR("Ralph Metzler & Marcus Metzler & Gerd Knorr");
161 MODULE_LICENSE("GPL");
163 /* ----------------------------------------------------------------------- */
166 static ssize_t show_card(struct device *cd,
167 struct device_attribute *attr, char *buf)
169 struct video_device *vfd = container_of(cd, struct video_device, dev);
170 struct bttv *btv = dev_get_drvdata(vfd->parent);
171 return sprintf(buf, "%d\n", btv ? btv->c.type : UNSET);
173 static DEVICE_ATTR(card, S_IRUGO, show_card, NULL);
175 /* ----------------------------------------------------------------------- */
176 /* dvb auto-load setup */
177 #if defined(CONFIG_MODULES) && defined(MODULE)
178 static void request_module_async(struct work_struct *work)
180 request_module("dvb-bt8xx");
183 static void request_modules(struct bttv *dev)
185 INIT_WORK(&dev->request_module_wk, request_module_async);
186 schedule_work(&dev->request_module_wk);
189 #define request_modules(dev)
190 #endif /* CONFIG_MODULES */
193 /* ----------------------------------------------------------------------- */
196 /* special timing tables from conexant... */
197 static u8 SRAM_Table[][60] =
199 /* PAL digital input over GPIO[7:0] */
201 45, // 45 bytes following
202 0x36,0x11,0x01,0x00,0x90,0x02,0x05,0x10,0x04,0x16,
203 0x12,0x05,0x11,0x00,0x04,0x12,0xC0,0x00,0x31,0x00,
204 0x06,0x51,0x08,0x03,0x89,0x08,0x07,0xC0,0x44,0x00,
205 0x81,0x01,0x01,0xA9,0x0D,0x02,0x02,0x50,0x03,0x37,
206 0x37,0x00,0xAF,0x21,0x00
208 /* NTSC digital input over GPIO[7:0] */
210 51, // 51 bytes following
211 0x0C,0xC0,0x00,0x00,0x90,0x02,0x03,0x10,0x03,0x06,
212 0x10,0x04,0x12,0x12,0x05,0x02,0x13,0x04,0x19,0x00,
213 0x04,0x39,0x00,0x06,0x59,0x08,0x03,0x83,0x08,0x07,
214 0x03,0x50,0x00,0xC0,0x40,0x00,0x86,0x01,0x01,0xA6,
215 0x0D,0x02,0x03,0x11,0x01,0x05,0x37,0x00,0xAC,0x21,
218 // TGB_NTSC392 // quartzsight
219 // This table has been modified to be used for Fusion Rev D
221 0x2A, // size of table = 42
222 0x06, 0x08, 0x04, 0x0a, 0xc0, 0x00, 0x18, 0x08, 0x03, 0x24,
223 0x08, 0x07, 0x02, 0x90, 0x02, 0x08, 0x10, 0x04, 0x0c, 0x10,
224 0x05, 0x2c, 0x11, 0x04, 0x55, 0x48, 0x00, 0x05, 0x50, 0x00,
225 0xbf, 0x0c, 0x02, 0x2f, 0x3d, 0x00, 0x2f, 0x3f, 0x00, 0xc3,
230 /* minhdelayx1 first video pixel we can capture on a line and
231 hdelayx1 start of active video, both relative to rising edge of
232 /HRESET pulse (0H) in 1 / fCLKx1.
233 swidth width of active video and
234 totalwidth total line width, both in 1 / fCLKx1.
235 sqwidth total line width in square pixels.
236 vdelay start of active video in 2 * field lines relative to
237 trailing edge of /VRESET pulse (VDELAY register).
238 sheight height of active video in 2 * field lines.
239 videostart0 ITU-R frame line number of the line corresponding
240 to vdelay in the first field. */
241 #define CROPCAP(minhdelayx1, hdelayx1, swidth, totalwidth, sqwidth, \
242 vdelay, sheight, videostart0) \
243 .cropcap.bounds.left = minhdelayx1, \
244 /* * 2 because vertically we count field lines times two, */ \
245 /* e.g. 23 * 2 to 23 * 2 + 576 in PAL-BGHI defrect. */ \
246 .cropcap.bounds.top = (videostart0) * 2 - (vdelay) + MIN_VDELAY, \
247 /* 4 is a safety margin at the end of the line. */ \
248 .cropcap.bounds.width = (totalwidth) - (minhdelayx1) - 4, \
249 .cropcap.bounds.height = (sheight) + (vdelay) - MIN_VDELAY, \
250 .cropcap.defrect.left = hdelayx1, \
251 .cropcap.defrect.top = (videostart0) * 2, \
252 .cropcap.defrect.width = swidth, \
253 .cropcap.defrect.height = sheight, \
254 .cropcap.pixelaspect.numerator = totalwidth, \
255 .cropcap.pixelaspect.denominator = sqwidth,
257 const struct bttv_tvnorm bttv_tvnorms[] = {
259 /* max. active video is actually 922, but 924 is divisible by 4 and 3! */
260 /* actually, max active PAL with HSCALE=0 is 948, NTSC is 768 - nil */
262 .v4l2_id = V4L2_STD_PAL,
270 .iform = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
271 .scaledtwidth = 1135,
275 .vbipack = 255, /* min (2048 / 4, 0x1ff) & 0xff */
277 /* ITU-R frame line number of the first VBI line
278 we can capture, of the first and second field.
279 The last line is determined by cropcap.bounds. */
280 .vbistart = { 7, 320 },
281 CROPCAP(/* minhdelayx1 */ 68,
283 /* Should be (768 * 1135 + 944 / 2) / 944.
284 cropcap.defrect is used for image width
285 checks, so we keep the old value 924. */
287 /* totalwidth */ 1135,
291 /* videostart0 */ 23)
292 /* bt878 (and bt848?) can capture another
293 line below active video. */
294 .cropcap.bounds.height = (576 + 2) + 0x20 - 2,
296 .v4l2_id = V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR,
304 .iform = (BT848_IFORM_NTSC|BT848_IFORM_XT0),
309 .vbipack = 144, /* min (1600 / 4, 0x1ff) & 0xff */
311 .vbistart = { 10, 273 },
312 CROPCAP(/* minhdelayx1 */ 68,
314 /* Should be (640 * 910 + 780 / 2) / 780? */
316 /* totalwidth */ 910,
320 /* videostart0 */ 23)
322 .v4l2_id = V4L2_STD_SECAM,
330 .iform = (BT848_IFORM_SECAM|BT848_IFORM_XT1),
331 .scaledtwidth = 1135,
336 .sram = 0, /* like PAL, correct? */
337 .vbistart = { 7, 320 },
338 CROPCAP(/* minhdelayx1 */ 68,
341 /* totalwidth */ 1135,
345 /* videostart0 */ 23)
347 .v4l2_id = V4L2_STD_PAL_Nc,
355 .iform = (BT848_IFORM_PAL_NC|BT848_IFORM_XT0),
362 .vbistart = { 7, 320 },
363 CROPCAP(/* minhdelayx1 */ 68,
365 /* swidth */ (640 * 910 + 780 / 2) / 780,
366 /* totalwidth */ 910,
370 /* videostart0 */ 23)
372 .v4l2_id = V4L2_STD_PAL_M,
380 .iform = (BT848_IFORM_PAL_M|BT848_IFORM_XT0),
387 .vbistart = { 10, 273 },
388 CROPCAP(/* minhdelayx1 */ 68,
390 /* swidth */ (640 * 910 + 780 / 2) / 780,
391 /* totalwidth */ 910,
395 /* videostart0 */ 23)
397 .v4l2_id = V4L2_STD_PAL_N,
405 .iform = (BT848_IFORM_PAL_N|BT848_IFORM_XT1),
412 .vbistart = { 7, 320 },
413 CROPCAP(/* minhdelayx1 */ 68,
415 /* swidth */ (768 * 1135 + 944 / 2) / 944,
416 /* totalwidth */ 1135,
420 /* videostart0 */ 23)
422 .v4l2_id = V4L2_STD_NTSC_M_JP,
430 .iform = (BT848_IFORM_NTSC_J|BT848_IFORM_XT0),
437 .vbistart = { 10, 273 },
438 CROPCAP(/* minhdelayx1 */ 68,
440 /* swidth */ (640 * 910 + 780 / 2) / 780,
441 /* totalwidth */ 910,
445 /* videostart0 */ 23)
447 /* that one hopefully works with the strange timing
448 * which video recorders produce when playing a NTSC
449 * tape on a PAL TV ... */
450 .v4l2_id = V4L2_STD_PAL_60,
458 .iform = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
459 .scaledtwidth = 1135,
466 .vbistart = { 10, 273 },
467 CROPCAP(/* minhdelayx1 */ 68,
470 /* totalwidth */ 1135,
474 /* videostart0 */ 23)
477 static const unsigned int BTTV_TVNORMS = ARRAY_SIZE(bttv_tvnorms);
479 /* ----------------------------------------------------------------------- */
481 packed pixel formats must come first */
482 static const struct bttv_format formats[] = {
484 .name = "8 bpp, gray",
485 .fourcc = V4L2_PIX_FMT_GREY,
486 .btformat = BT848_COLOR_FMT_Y8,
488 .flags = FORMAT_FLAGS_PACKED,
490 .name = "8 bpp, dithered color",
491 .fourcc = V4L2_PIX_FMT_HI240,
492 .btformat = BT848_COLOR_FMT_RGB8,
494 .flags = FORMAT_FLAGS_PACKED | FORMAT_FLAGS_DITHER,
496 .name = "15 bpp RGB, le",
497 .fourcc = V4L2_PIX_FMT_RGB555,
498 .btformat = BT848_COLOR_FMT_RGB15,
500 .flags = FORMAT_FLAGS_PACKED,
502 .name = "15 bpp RGB, be",
503 .fourcc = V4L2_PIX_FMT_RGB555X,
504 .btformat = BT848_COLOR_FMT_RGB15,
505 .btswap = 0x03, /* byteswap */
507 .flags = FORMAT_FLAGS_PACKED,
509 .name = "16 bpp RGB, le",
510 .fourcc = V4L2_PIX_FMT_RGB565,
511 .btformat = BT848_COLOR_FMT_RGB16,
513 .flags = FORMAT_FLAGS_PACKED,
515 .name = "16 bpp RGB, be",
516 .fourcc = V4L2_PIX_FMT_RGB565X,
517 .btformat = BT848_COLOR_FMT_RGB16,
518 .btswap = 0x03, /* byteswap */
520 .flags = FORMAT_FLAGS_PACKED,
522 .name = "24 bpp RGB, le",
523 .fourcc = V4L2_PIX_FMT_BGR24,
524 .btformat = BT848_COLOR_FMT_RGB24,
526 .flags = FORMAT_FLAGS_PACKED,
528 .name = "32 bpp RGB, le",
529 .fourcc = V4L2_PIX_FMT_BGR32,
530 .btformat = BT848_COLOR_FMT_RGB32,
532 .flags = FORMAT_FLAGS_PACKED,
534 .name = "32 bpp RGB, be",
535 .fourcc = V4L2_PIX_FMT_RGB32,
536 .btformat = BT848_COLOR_FMT_RGB32,
537 .btswap = 0x0f, /* byte+word swap */
539 .flags = FORMAT_FLAGS_PACKED,
541 .name = "4:2:2, packed, YUYV",
542 .fourcc = V4L2_PIX_FMT_YUYV,
543 .btformat = BT848_COLOR_FMT_YUY2,
545 .flags = FORMAT_FLAGS_PACKED,
547 .name = "4:2:2, packed, YUYV",
548 .fourcc = V4L2_PIX_FMT_YUYV,
549 .btformat = BT848_COLOR_FMT_YUY2,
551 .flags = FORMAT_FLAGS_PACKED,
553 .name = "4:2:2, packed, UYVY",
554 .fourcc = V4L2_PIX_FMT_UYVY,
555 .btformat = BT848_COLOR_FMT_YUY2,
556 .btswap = 0x03, /* byteswap */
558 .flags = FORMAT_FLAGS_PACKED,
560 .name = "4:2:2, planar, Y-Cb-Cr",
561 .fourcc = V4L2_PIX_FMT_YUV422P,
562 .btformat = BT848_COLOR_FMT_YCrCb422,
564 .flags = FORMAT_FLAGS_PLANAR,
568 .name = "4:2:0, planar, Y-Cb-Cr",
569 .fourcc = V4L2_PIX_FMT_YUV420,
570 .btformat = BT848_COLOR_FMT_YCrCb422,
572 .flags = FORMAT_FLAGS_PLANAR,
576 .name = "4:2:0, planar, Y-Cr-Cb",
577 .fourcc = V4L2_PIX_FMT_YVU420,
578 .btformat = BT848_COLOR_FMT_YCrCb422,
580 .flags = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
584 .name = "4:1:1, planar, Y-Cb-Cr",
585 .fourcc = V4L2_PIX_FMT_YUV411P,
586 .btformat = BT848_COLOR_FMT_YCrCb411,
588 .flags = FORMAT_FLAGS_PLANAR,
592 .name = "4:1:0, planar, Y-Cb-Cr",
593 .fourcc = V4L2_PIX_FMT_YUV410,
594 .btformat = BT848_COLOR_FMT_YCrCb411,
596 .flags = FORMAT_FLAGS_PLANAR,
600 .name = "4:1:0, planar, Y-Cr-Cb",
601 .fourcc = V4L2_PIX_FMT_YVU410,
602 .btformat = BT848_COLOR_FMT_YCrCb411,
604 .flags = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
608 .name = "raw scanlines",
610 .btformat = BT848_COLOR_FMT_RAW,
612 .flags = FORMAT_FLAGS_RAW,
615 static const unsigned int FORMATS = ARRAY_SIZE(formats);
617 /* ----------------------------------------------------------------------- */
619 #define V4L2_CID_PRIVATE_CHROMA_AGC (V4L2_CID_PRIVATE_BASE + 0)
620 #define V4L2_CID_PRIVATE_COMBFILTER (V4L2_CID_PRIVATE_BASE + 1)
621 #define V4L2_CID_PRIVATE_AUTOMUTE (V4L2_CID_PRIVATE_BASE + 2)
622 #define V4L2_CID_PRIVATE_LUMAFILTER (V4L2_CID_PRIVATE_BASE + 3)
623 #define V4L2_CID_PRIVATE_AGC_CRUSH (V4L2_CID_PRIVATE_BASE + 4)
624 #define V4L2_CID_PRIVATE_VCR_HACK (V4L2_CID_PRIVATE_BASE + 5)
625 #define V4L2_CID_PRIVATE_WHITECRUSH_UPPER (V4L2_CID_PRIVATE_BASE + 6)
626 #define V4L2_CID_PRIVATE_WHITECRUSH_LOWER (V4L2_CID_PRIVATE_BASE + 7)
627 #define V4L2_CID_PRIVATE_UV_RATIO (V4L2_CID_PRIVATE_BASE + 8)
628 #define V4L2_CID_PRIVATE_FULL_LUMA_RANGE (V4L2_CID_PRIVATE_BASE + 9)
629 #define V4L2_CID_PRIVATE_CORING (V4L2_CID_PRIVATE_BASE + 10)
630 #define V4L2_CID_PRIVATE_LASTP1 (V4L2_CID_PRIVATE_BASE + 11)
632 static const struct v4l2_queryctrl no_ctl = {
634 .flags = V4L2_CTRL_FLAG_DISABLED,
636 static const struct v4l2_queryctrl bttv_ctls[] = {
639 .id = V4L2_CID_BRIGHTNESS,
640 .name = "Brightness",
644 .default_value = 32768,
645 .type = V4L2_CTRL_TYPE_INTEGER,
647 .id = V4L2_CID_CONTRAST,
652 .default_value = 32768,
653 .type = V4L2_CTRL_TYPE_INTEGER,
655 .id = V4L2_CID_SATURATION,
656 .name = "Saturation",
660 .default_value = 32768,
661 .type = V4L2_CTRL_TYPE_INTEGER,
668 .default_value = 32768,
669 .type = V4L2_CTRL_TYPE_INTEGER,
673 .id = V4L2_CID_AUDIO_MUTE,
677 .type = V4L2_CTRL_TYPE_BOOLEAN,
679 .id = V4L2_CID_AUDIO_VOLUME,
684 .default_value = 65535,
685 .type = V4L2_CTRL_TYPE_INTEGER,
687 .id = V4L2_CID_AUDIO_BALANCE,
692 .default_value = 32768,
693 .type = V4L2_CTRL_TYPE_INTEGER,
695 .id = V4L2_CID_AUDIO_BASS,
700 .default_value = 32768,
701 .type = V4L2_CTRL_TYPE_INTEGER,
703 .id = V4L2_CID_AUDIO_TREBLE,
708 .default_value = 32768,
709 .type = V4L2_CTRL_TYPE_INTEGER,
711 /* --- private --- */
713 .id = V4L2_CID_PRIVATE_CHROMA_AGC,
714 .name = "chroma agc",
717 .type = V4L2_CTRL_TYPE_BOOLEAN,
719 .id = V4L2_CID_PRIVATE_COMBFILTER,
720 .name = "combfilter",
723 .type = V4L2_CTRL_TYPE_BOOLEAN,
725 .id = V4L2_CID_PRIVATE_AUTOMUTE,
729 .type = V4L2_CTRL_TYPE_BOOLEAN,
731 .id = V4L2_CID_PRIVATE_LUMAFILTER,
732 .name = "luma decimation filter",
735 .type = V4L2_CTRL_TYPE_BOOLEAN,
737 .id = V4L2_CID_PRIVATE_AGC_CRUSH,
741 .type = V4L2_CTRL_TYPE_BOOLEAN,
743 .id = V4L2_CID_PRIVATE_VCR_HACK,
747 .type = V4L2_CTRL_TYPE_BOOLEAN,
749 .id = V4L2_CID_PRIVATE_WHITECRUSH_UPPER,
750 .name = "whitecrush upper",
754 .default_value = 0xCF,
755 .type = V4L2_CTRL_TYPE_INTEGER,
757 .id = V4L2_CID_PRIVATE_WHITECRUSH_LOWER,
758 .name = "whitecrush lower",
762 .default_value = 0x7F,
763 .type = V4L2_CTRL_TYPE_INTEGER,
765 .id = V4L2_CID_PRIVATE_UV_RATIO,
771 .type = V4L2_CTRL_TYPE_INTEGER,
773 .id = V4L2_CID_PRIVATE_FULL_LUMA_RANGE,
774 .name = "full luma range",
777 .type = V4L2_CTRL_TYPE_BOOLEAN,
779 .id = V4L2_CID_PRIVATE_CORING,
785 .type = V4L2_CTRL_TYPE_INTEGER,
792 static const struct v4l2_queryctrl *ctrl_by_id(int id)
796 for (i = 0; i < ARRAY_SIZE(bttv_ctls); i++)
797 if (bttv_ctls[i].id == id)
803 /* ----------------------------------------------------------------------- */
804 /* resource management */
807 RESOURCE_ allocated by freed by
809 VIDEO_READ bttv_read 1) bttv_read 2)
811 VIDEO_STREAM VIDIOC_STREAMON VIDIOC_STREAMOFF
812 VIDIOC_QBUF 1) bttv_release
815 OVERLAY VIDIOCCAPTURE on VIDIOCCAPTURE off
816 VIDIOC_OVERLAY on VIDIOC_OVERLAY off
819 VBI VIDIOC_STREAMON VIDIOC_STREAMOFF
820 VIDIOC_QBUF 1) bttv_release
821 bttv_read, bttv_poll 1) 4)
823 1) The resource must be allocated when we enter buffer prepare functions
824 and remain allocated while buffers are in the DMA queue.
825 2) This is a single frame read.
826 3) VIDIOC_S_FBUF and VIDIOC_S_FMT (OVERLAY) still work when
827 RESOURCE_OVERLAY is allocated.
828 4) This is a continuous read, implies VIDIOC_STREAMON.
830 Note this driver permits video input and standard changes regardless if
831 resources are allocated.
834 #define VBI_RESOURCES (RESOURCE_VBI)
835 #define VIDEO_RESOURCES (RESOURCE_VIDEO_READ | \
836 RESOURCE_VIDEO_STREAM | \
840 int check_alloc_btres(struct bttv *btv, struct bttv_fh *fh, int bit)
842 int xbits; /* mutual exclusive resources */
844 if (fh->resources & bit)
845 /* have it already allocated */
849 if (bit & (RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM))
850 xbits |= RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM;
853 mutex_lock(&btv->lock);
854 if (btv->resources & xbits) {
855 /* no, someone else uses it */
859 if ((bit & VIDEO_RESOURCES)
860 && 0 == (btv->resources & VIDEO_RESOURCES)) {
861 /* Do crop - use current, don't - use default parameters. */
862 __s32 top = btv->crop[!!fh->do_crop].rect.top;
864 if (btv->vbi_end > top)
867 /* We cannot capture the same line as video and VBI data.
868 Claim scan lines crop[].rect.top to bottom. */
869 btv->crop_start = top;
870 } else if (bit & VBI_RESOURCES) {
871 __s32 end = fh->vbi_fmt.end;
873 if (end > btv->crop_start)
876 /* Claim scan lines above fh->vbi_fmt.end. */
880 /* it's free, grab it */
881 fh->resources |= bit;
882 btv->resources |= bit;
883 mutex_unlock(&btv->lock);
887 mutex_unlock(&btv->lock);
892 int check_btres(struct bttv_fh *fh, int bit)
894 return (fh->resources & bit);
898 int locked_btres(struct bttv *btv, int bit)
900 return (btv->resources & bit);
903 /* Call with btv->lock down. */
905 disclaim_vbi_lines(struct bttv *btv)
910 /* Call with btv->lock down. */
912 disclaim_video_lines(struct bttv *btv)
914 const struct bttv_tvnorm *tvnorm;
917 tvnorm = &bttv_tvnorms[btv->tvnorm];
918 btv->crop_start = tvnorm->cropcap.bounds.top
919 + tvnorm->cropcap.bounds.height;
921 /* VBI capturing ends at VDELAY, start of video capturing, no
922 matter how many lines the VBI RISC program expects. When video
923 capturing is off, it shall no longer "preempt" VBI capturing,
924 so we set VDELAY to maximum. */
925 crop = btread(BT848_E_CROP) | 0xc0;
926 btwrite(crop, BT848_E_CROP);
927 btwrite(0xfe, BT848_E_VDELAY_LO);
928 btwrite(crop, BT848_O_CROP);
929 btwrite(0xfe, BT848_O_VDELAY_LO);
933 void free_btres(struct bttv *btv, struct bttv_fh *fh, int bits)
935 if ((fh->resources & bits) != bits) {
936 /* trying to free ressources not allocated by us ... */
937 printk("bttv: BUG! (btres)\n");
939 mutex_lock(&btv->lock);
940 fh->resources &= ~bits;
941 btv->resources &= ~bits;
943 bits = btv->resources;
945 if (0 == (bits & VIDEO_RESOURCES))
946 disclaim_video_lines(btv);
948 if (0 == (bits & VBI_RESOURCES))
949 disclaim_vbi_lines(btv);
951 mutex_unlock(&btv->lock);
954 /* ----------------------------------------------------------------------- */
955 /* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC */
957 /* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C
958 PLL_X = Reference pre-divider (0=1, 1=2)
959 PLL_C = Post divider (0=6, 1=4)
960 PLL_I = Integer input
961 PLL_F = Fractional input
963 F_input = 28.636363 MHz:
964 PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0
967 static void set_pll_freq(struct bttv *btv, unsigned int fin, unsigned int fout)
969 unsigned char fl, fh, fi;
971 /* prevent overflows */
984 btwrite(fl, BT848_PLL_F_LO);
985 btwrite(fh, BT848_PLL_F_HI);
986 btwrite(fi|BT848_PLL_X, BT848_PLL_XCI);
989 static void set_pll(struct bttv *btv)
993 if (!btv->pll.pll_crystal)
996 if (btv->pll.pll_ofreq == btv->pll.pll_current) {
997 dprintk("bttv%d: PLL: no change required\n",btv->c.nr);
1001 if (btv->pll.pll_ifreq == btv->pll.pll_ofreq) {
1003 if (btv->pll.pll_current == 0)
1005 bttv_printk(KERN_INFO "bttv%d: PLL can sleep, using XTAL (%d).\n",
1006 btv->c.nr,btv->pll.pll_ifreq);
1007 btwrite(0x00,BT848_TGCTRL);
1008 btwrite(0x00,BT848_PLL_XCI);
1009 btv->pll.pll_current = 0;
1013 bttv_printk(KERN_INFO "bttv%d: PLL: %d => %d ",btv->c.nr,
1014 btv->pll.pll_ifreq, btv->pll.pll_ofreq);
1015 set_pll_freq(btv, btv->pll.pll_ifreq, btv->pll.pll_ofreq);
1017 for (i=0; i<10; i++) {
1018 /* Let other people run while the PLL stabilizes */
1022 if (btread(BT848_DSTATUS) & BT848_DSTATUS_PLOCK) {
1023 btwrite(0,BT848_DSTATUS);
1025 btwrite(0x08,BT848_TGCTRL);
1026 btv->pll.pll_current = btv->pll.pll_ofreq;
1027 bttv_printk(" ok\n");
1031 btv->pll.pll_current = -1;
1032 bttv_printk("failed\n");
1036 /* used to switch between the bt848's analog/digital video capture modes */
1037 static void bt848A_set_timing(struct bttv *btv)
1040 int table_idx = bttv_tvnorms[btv->tvnorm].sram;
1041 int fsc = bttv_tvnorms[btv->tvnorm].Fsc;
1043 if (UNSET == bttv_tvcards[btv->c.type].muxsel[btv->input]) {
1044 dprintk("bttv%d: load digital timing table (table_idx=%d)\n",
1045 btv->c.nr,table_idx);
1047 /* timing change...reset timing generator address */
1048 btwrite(0x00, BT848_TGCTRL);
1049 btwrite(0x02, BT848_TGCTRL);
1050 btwrite(0x00, BT848_TGCTRL);
1052 len=SRAM_Table[table_idx][0];
1053 for(i = 1; i <= len; i++)
1054 btwrite(SRAM_Table[table_idx][i],BT848_TGLB);
1055 btv->pll.pll_ofreq = 27000000;
1058 btwrite(0x11, BT848_TGCTRL);
1059 btwrite(0x41, BT848_DVSIF);
1061 btv->pll.pll_ofreq = fsc;
1063 btwrite(0x0, BT848_DVSIF);
1067 /* ----------------------------------------------------------------------- */
1069 static void bt848_bright(struct bttv *btv, int bright)
1073 // printk("bttv: set bright: %d\n",bright); // DEBUG
1074 btv->bright = bright;
1076 /* We want -128 to 127 we get 0-65535 */
1077 value = (bright >> 8) - 128;
1078 btwrite(value & 0xff, BT848_BRIGHT);
1081 static void bt848_hue(struct bttv *btv, int hue)
1088 value = (hue >> 8) - 128;
1089 btwrite(value & 0xff, BT848_HUE);
1092 static void bt848_contrast(struct bttv *btv, int cont)
1096 btv->contrast = cont;
1099 value = (cont >> 7);
1100 hibit = (value >> 6) & 4;
1101 btwrite(value & 0xff, BT848_CONTRAST_LO);
1102 btaor(hibit, ~4, BT848_E_CONTROL);
1103 btaor(hibit, ~4, BT848_O_CONTROL);
1106 static void bt848_sat(struct bttv *btv, int color)
1108 int val_u,val_v,hibits;
1110 btv->saturation = color;
1112 /* 0-511 for the color */
1113 val_u = ((color * btv->opt_uv_ratio) / 50) >> 7;
1114 val_v = (((color * (100 - btv->opt_uv_ratio) / 50) >>7)*180L)/254;
1115 hibits = (val_u >> 7) & 2;
1116 hibits |= (val_v >> 8) & 1;
1117 btwrite(val_u & 0xff, BT848_SAT_U_LO);
1118 btwrite(val_v & 0xff, BT848_SAT_V_LO);
1119 btaor(hibits, ~3, BT848_E_CONTROL);
1120 btaor(hibits, ~3, BT848_O_CONTROL);
1123 /* ----------------------------------------------------------------------- */
1126 video_mux(struct bttv *btv, unsigned int input)
1130 if (input >= bttv_tvcards[btv->c.type].video_inputs)
1133 /* needed by RemoteVideo MX */
1134 mask2 = bttv_tvcards[btv->c.type].gpiomask2;
1136 gpio_inout(mask2,mask2);
1138 if (input == btv->svhs) {
1139 btor(BT848_CONTROL_COMP, BT848_E_CONTROL);
1140 btor(BT848_CONTROL_COMP, BT848_O_CONTROL);
1142 btand(~BT848_CONTROL_COMP, BT848_E_CONTROL);
1143 btand(~BT848_CONTROL_COMP, BT848_O_CONTROL);
1145 mux = bttv_tvcards[btv->c.type].muxsel[input] & 3;
1146 btaor(mux<<5, ~(3<<5), BT848_IFORM);
1147 dprintk(KERN_DEBUG "bttv%d: video mux: input=%d mux=%d\n",
1148 btv->c.nr,input,mux);
1150 /* card specific hook */
1151 if(bttv_tvcards[btv->c.type].muxsel_hook)
1152 bttv_tvcards[btv->c.type].muxsel_hook (btv, input);
1156 static char *audio_modes[] = {
1157 "audio: tuner", "audio: radio", "audio: extern",
1158 "audio: intern", "audio: mute"
1162 audio_mux(struct bttv *btv, int input, int mute)
1164 int gpio_val, signal;
1165 struct v4l2_control ctrl;
1166 struct i2c_client *c;
1168 gpio_inout(bttv_tvcards[btv->c.type].gpiomask,
1169 bttv_tvcards[btv->c.type].gpiomask);
1170 signal = btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC;
1176 mute = mute || (btv->opt_automute && !signal && !btv->radio_user);
1179 gpio_val = bttv_tvcards[btv->c.type].gpiomute;
1181 gpio_val = bttv_tvcards[btv->c.type].gpiomux[input];
1183 gpio_bits(bttv_tvcards[btv->c.type].gpiomask, gpio_val);
1185 bttv_gpio_tracking(btv, audio_modes[mute ? 4 : input]);
1189 ctrl.id = V4L2_CID_AUDIO_MUTE;
1190 ctrl.value = btv->mute;
1191 bttv_call_i2c_clients(btv, VIDIOC_S_CTRL, &ctrl);
1192 c = btv->i2c_msp34xx_client;
1194 struct v4l2_routing route;
1196 /* Note: the inputs tuner/radio/extern/intern are translated
1197 to msp routings. This assumes common behavior for all msp3400
1198 based TV cards. When this assumption fails, then the
1199 specific MSP routing must be added to the card table.
1200 For now this is sufficient. */
1202 case TVAUDIO_INPUT_RADIO:
1203 route.input = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1204 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1206 case TVAUDIO_INPUT_EXTERN:
1207 route.input = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER1,
1208 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1210 case TVAUDIO_INPUT_INTERN:
1211 /* Yes, this is the same input as for RADIO. I doubt
1212 if this is ever used. The only board with an INTERN
1213 input is the BTTV_BOARD_AVERMEDIA98. I wonder how
1214 that was tested. My guess is that the whole INTERN
1215 input does not work. */
1216 route.input = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1217 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1219 case TVAUDIO_INPUT_TUNER:
1221 /* This is the only card that uses TUNER2, and afaik,
1222 is the only difference between the VOODOOTV_FM
1224 if (btv->c.type == BTTV_BOARD_VOODOOTV_200)
1225 route.input = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER2, \
1226 MSP_DSP_IN_TUNER, MSP_DSP_IN_TUNER);
1228 route.input = MSP_INPUT_DEFAULT;
1231 route.output = MSP_OUTPUT_DEFAULT;
1232 c->driver->command(c, VIDIOC_INT_S_AUDIO_ROUTING, &route);
1234 c = btv->i2c_tvaudio_client;
1236 struct v4l2_routing route;
1238 route.input = input;
1240 c->driver->command(c, VIDIOC_INT_S_AUDIO_ROUTING, &route);
1246 audio_mute(struct bttv *btv, int mute)
1248 return audio_mux(btv, btv->audio, mute);
1252 audio_input(struct bttv *btv, int input)
1254 return audio_mux(btv, input, btv->mute);
1258 bttv_crop_calc_limits(struct bttv_crop *c)
1260 /* Scale factor min. 1:1, max. 16:1. Min. image size
1261 48 x 32. Scaled width must be a multiple of 4. */
1264 /* For bug compatibility with VIDIOCGCAP and image
1265 size checks in earlier driver versions. */
1266 c->min_scaled_width = 48;
1267 c->min_scaled_height = 32;
1269 c->min_scaled_width =
1270 (max(48, c->rect.width >> 4) + 3) & ~3;
1271 c->min_scaled_height =
1272 max(32, c->rect.height >> 4);
1275 c->max_scaled_width = c->rect.width & ~3;
1276 c->max_scaled_height = c->rect.height;
1280 bttv_crop_reset(struct bttv_crop *c, int norm)
1282 c->rect = bttv_tvnorms[norm].cropcap.defrect;
1283 bttv_crop_calc_limits(c);
1286 /* Call with btv->lock down. */
1288 set_tvnorm(struct bttv *btv, unsigned int norm)
1290 const struct bttv_tvnorm *tvnorm;
1293 if (norm < 0 || norm >= BTTV_TVNORMS)
1296 tvnorm = &bttv_tvnorms[norm];
1298 if (btv->tvnorm < 0 ||
1299 btv->tvnorm >= BTTV_TVNORMS ||
1300 0 != memcmp(&bttv_tvnorms[btv->tvnorm].cropcap,
1302 sizeof (tvnorm->cropcap))) {
1303 bttv_crop_reset(&btv->crop[0], norm);
1304 btv->crop[1] = btv->crop[0]; /* current = default */
1306 if (0 == (btv->resources & VIDEO_RESOURCES)) {
1307 btv->crop_start = tvnorm->cropcap.bounds.top
1308 + tvnorm->cropcap.bounds.height;
1314 btwrite(tvnorm->adelay, BT848_ADELAY);
1315 btwrite(tvnorm->bdelay, BT848_BDELAY);
1316 btaor(tvnorm->iform,~(BT848_IFORM_NORM|BT848_IFORM_XTBOTH),
1318 btwrite(tvnorm->vbipack, BT848_VBI_PACK_SIZE);
1319 btwrite(1, BT848_VBI_PACK_DEL);
1320 bt848A_set_timing(btv);
1322 switch (btv->c.type) {
1323 case BTTV_BOARD_VOODOOTV_FM:
1324 case BTTV_BOARD_VOODOOTV_200:
1325 bttv_tda9880_setnorm(btv,norm);
1328 id = tvnorm->v4l2_id;
1329 bttv_call_i2c_clients(btv, VIDIOC_S_STD, &id);
1334 /* Call with btv->lock down. */
1336 set_input(struct bttv *btv, unsigned int input, unsigned int norm)
1338 unsigned long flags;
1342 spin_lock_irqsave(&btv->s_lock,flags);
1343 if (btv->curr.frame_irq) {
1344 /* active capture -> delayed input switch */
1345 btv->new_input = input;
1347 video_mux(btv,input);
1349 spin_unlock_irqrestore(&btv->s_lock,flags);
1351 video_mux(btv,input);
1353 audio_input(btv,(input == bttv_tvcards[btv->c.type].tuner ?
1354 TVAUDIO_INPUT_TUNER : TVAUDIO_INPUT_EXTERN));
1355 set_tvnorm(btv, norm);
1358 static void init_irqreg(struct bttv *btv)
1361 btwrite(0xfffffUL, BT848_INT_STAT);
1363 if (bttv_tvcards[btv->c.type].no_video) {
1365 btwrite(BT848_INT_I2CDONE,
1369 btwrite((btv->triton1) |
1370 (btv->gpioirq ? BT848_INT_GPINT : 0) |
1372 (fdsr ? BT848_INT_FDSR : 0) |
1373 BT848_INT_RISCI | BT848_INT_OCERR |
1374 BT848_INT_FMTCHG|BT848_INT_HLOCK|
1380 static void init_bt848(struct bttv *btv)
1384 if (bttv_tvcards[btv->c.type].no_video) {
1385 /* very basic init only */
1390 btwrite(0x00, BT848_CAP_CTL);
1391 btwrite(BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL);
1392 btwrite(BT848_IFORM_XTAUTO | BT848_IFORM_AUTO, BT848_IFORM);
1394 /* set planar and packed mode trigger points and */
1395 /* set rising edge of inverted GPINTR pin as irq trigger */
1396 btwrite(BT848_GPIO_DMA_CTL_PKTP_32|
1397 BT848_GPIO_DMA_CTL_PLTP1_16|
1398 BT848_GPIO_DMA_CTL_PLTP23_16|
1399 BT848_GPIO_DMA_CTL_GPINTC|
1400 BT848_GPIO_DMA_CTL_GPINTI,
1401 BT848_GPIO_DMA_CTL);
1403 val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1404 btwrite(val, BT848_E_SCLOOP);
1405 btwrite(val, BT848_O_SCLOOP);
1407 btwrite(0x20, BT848_E_VSCALE_HI);
1408 btwrite(0x20, BT848_O_VSCALE_HI);
1409 btwrite(BT848_ADC_RESERVED | (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1412 btwrite(whitecrush_upper, BT848_WC_UP);
1413 btwrite(whitecrush_lower, BT848_WC_DOWN);
1415 if (btv->opt_lumafilter) {
1416 btwrite(0, BT848_E_CONTROL);
1417 btwrite(0, BT848_O_CONTROL);
1419 btwrite(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1420 btwrite(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1423 bt848_bright(btv, btv->bright);
1424 bt848_hue(btv, btv->hue);
1425 bt848_contrast(btv, btv->contrast);
1426 bt848_sat(btv, btv->saturation);
1432 static void bttv_reinit_bt848(struct bttv *btv)
1434 unsigned long flags;
1437 printk(KERN_INFO "bttv%d: reset, reinitialize\n",btv->c.nr);
1438 spin_lock_irqsave(&btv->s_lock,flags);
1440 bttv_set_dma(btv,0);
1441 spin_unlock_irqrestore(&btv->s_lock,flags);
1444 btv->pll.pll_current = -1;
1445 set_input(btv, btv->input, btv->tvnorm);
1448 static int bttv_g_ctrl(struct file *file, void *priv,
1449 struct v4l2_control *c)
1451 struct bttv_fh *fh = priv;
1452 struct bttv *btv = fh->btv;
1455 case V4L2_CID_BRIGHTNESS:
1456 c->value = btv->bright;
1459 c->value = btv->hue;
1461 case V4L2_CID_CONTRAST:
1462 c->value = btv->contrast;
1464 case V4L2_CID_SATURATION:
1465 c->value = btv->saturation;
1468 case V4L2_CID_AUDIO_MUTE:
1469 case V4L2_CID_AUDIO_VOLUME:
1470 case V4L2_CID_AUDIO_BALANCE:
1471 case V4L2_CID_AUDIO_BASS:
1472 case V4L2_CID_AUDIO_TREBLE:
1473 bttv_call_i2c_clients(btv, VIDIOC_G_CTRL, c);
1476 case V4L2_CID_PRIVATE_CHROMA_AGC:
1477 c->value = btv->opt_chroma_agc;
1479 case V4L2_CID_PRIVATE_COMBFILTER:
1480 c->value = btv->opt_combfilter;
1482 case V4L2_CID_PRIVATE_LUMAFILTER:
1483 c->value = btv->opt_lumafilter;
1485 case V4L2_CID_PRIVATE_AUTOMUTE:
1486 c->value = btv->opt_automute;
1488 case V4L2_CID_PRIVATE_AGC_CRUSH:
1489 c->value = btv->opt_adc_crush;
1491 case V4L2_CID_PRIVATE_VCR_HACK:
1492 c->value = btv->opt_vcr_hack;
1494 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1495 c->value = btv->opt_whitecrush_upper;
1497 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1498 c->value = btv->opt_whitecrush_lower;
1500 case V4L2_CID_PRIVATE_UV_RATIO:
1501 c->value = btv->opt_uv_ratio;
1503 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1504 c->value = btv->opt_full_luma_range;
1506 case V4L2_CID_PRIVATE_CORING:
1507 c->value = btv->opt_coring;
1515 static int bttv_s_ctrl(struct file *file, void *f,
1516 struct v4l2_control *c)
1520 struct bttv_fh *fh = f;
1521 struct bttv *btv = fh->btv;
1523 err = v4l2_prio_check(&btv->prio, &fh->prio);
1528 case V4L2_CID_BRIGHTNESS:
1529 bt848_bright(btv, c->value);
1532 bt848_hue(btv, c->value);
1534 case V4L2_CID_CONTRAST:
1535 bt848_contrast(btv, c->value);
1537 case V4L2_CID_SATURATION:
1538 bt848_sat(btv, c->value);
1540 case V4L2_CID_AUDIO_MUTE:
1541 audio_mute(btv, c->value);
1543 case V4L2_CID_AUDIO_VOLUME:
1544 if (btv->volume_gpio)
1545 btv->volume_gpio(btv, c->value);
1547 bttv_call_i2c_clients(btv, VIDIOC_S_CTRL, c);
1549 case V4L2_CID_AUDIO_BALANCE:
1550 case V4L2_CID_AUDIO_BASS:
1551 case V4L2_CID_AUDIO_TREBLE:
1552 bttv_call_i2c_clients(btv, VIDIOC_S_CTRL, c);
1555 case V4L2_CID_PRIVATE_CHROMA_AGC:
1556 btv->opt_chroma_agc = c->value;
1557 val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1558 btwrite(val, BT848_E_SCLOOP);
1559 btwrite(val, BT848_O_SCLOOP);
1561 case V4L2_CID_PRIVATE_COMBFILTER:
1562 btv->opt_combfilter = c->value;
1564 case V4L2_CID_PRIVATE_LUMAFILTER:
1565 btv->opt_lumafilter = c->value;
1566 if (btv->opt_lumafilter) {
1567 btand(~BT848_CONTROL_LDEC, BT848_E_CONTROL);
1568 btand(~BT848_CONTROL_LDEC, BT848_O_CONTROL);
1570 btor(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1571 btor(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1574 case V4L2_CID_PRIVATE_AUTOMUTE:
1575 btv->opt_automute = c->value;
1577 case V4L2_CID_PRIVATE_AGC_CRUSH:
1578 btv->opt_adc_crush = c->value;
1579 btwrite(BT848_ADC_RESERVED |
1580 (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1583 case V4L2_CID_PRIVATE_VCR_HACK:
1584 btv->opt_vcr_hack = c->value;
1586 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1587 btv->opt_whitecrush_upper = c->value;
1588 btwrite(c->value, BT848_WC_UP);
1590 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1591 btv->opt_whitecrush_lower = c->value;
1592 btwrite(c->value, BT848_WC_DOWN);
1594 case V4L2_CID_PRIVATE_UV_RATIO:
1595 btv->opt_uv_ratio = c->value;
1596 bt848_sat(btv, btv->saturation);
1598 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1599 btv->opt_full_luma_range = c->value;
1600 btaor((c->value<<7), ~BT848_OFORM_RANGE, BT848_OFORM);
1602 case V4L2_CID_PRIVATE_CORING:
1603 btv->opt_coring = c->value;
1604 btaor((c->value<<5), ~BT848_OFORM_CORE32, BT848_OFORM);
1612 /* ----------------------------------------------------------------------- */
1614 void bttv_gpio_tracking(struct bttv *btv, char *comment)
1616 unsigned int outbits, data;
1617 outbits = btread(BT848_GPIO_OUT_EN);
1618 data = btread(BT848_GPIO_DATA);
1619 printk(KERN_DEBUG "bttv%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
1620 btv->c.nr,outbits,data & outbits, data & ~outbits, comment);
1623 static void bttv_field_count(struct bttv *btv)
1631 /* start field counter */
1632 btor(BT848_INT_VSYNC,BT848_INT_MASK);
1634 /* stop field counter */
1635 btand(~BT848_INT_VSYNC,BT848_INT_MASK);
1636 btv->field_count = 0;
1640 static const struct bttv_format*
1641 format_by_fourcc(int fourcc)
1645 for (i = 0; i < FORMATS; i++) {
1646 if (-1 == formats[i].fourcc)
1648 if (formats[i].fourcc == fourcc)
1654 /* ----------------------------------------------------------------------- */
1658 bttv_switch_overlay(struct bttv *btv, struct bttv_fh *fh,
1659 struct bttv_buffer *new)
1661 struct bttv_buffer *old;
1662 unsigned long flags;
1665 dprintk("switch_overlay: enter [new=%p]\n",new);
1667 new->vb.state = VIDEOBUF_DONE;
1668 spin_lock_irqsave(&btv->s_lock,flags);
1672 bttv_set_dma(btv, 0x03);
1673 spin_unlock_irqrestore(&btv->s_lock,flags);
1675 dprintk("switch_overlay: old=%p state is %d\n",old,old->vb.state);
1676 bttv_dma_free(&fh->cap,btv, old);
1680 free_btres(btv,fh,RESOURCE_OVERLAY);
1681 dprintk("switch_overlay: done\n");
1685 /* ----------------------------------------------------------------------- */
1686 /* video4linux (1) interface */
1688 static int bttv_prepare_buffer(struct videobuf_queue *q,struct bttv *btv,
1689 struct bttv_buffer *buf,
1690 const struct bttv_format *fmt,
1691 unsigned int width, unsigned int height,
1692 enum v4l2_field field)
1694 struct bttv_fh *fh = q->priv_data;
1695 int redo_dma_risc = 0;
1700 /* check settings */
1703 if (fmt->btformat == BT848_COLOR_FMT_RAW) {
1705 height = RAW_LINES*2;
1706 if (width*height > buf->vb.bsize)
1708 buf->vb.size = buf->vb.bsize;
1710 /* Make sure tvnorm and vbi_end remain consistent
1711 until we're done. */
1712 mutex_lock(&btv->lock);
1716 /* In this mode capturing always starts at defrect.top
1717 (default VDELAY), ignoring cropping parameters. */
1718 if (btv->vbi_end > bttv_tvnorms[norm].cropcap.defrect.top) {
1719 mutex_unlock(&btv->lock);
1723 mutex_unlock(&btv->lock);
1725 c.rect = bttv_tvnorms[norm].cropcap.defrect;
1727 mutex_lock(&btv->lock);
1730 c = btv->crop[!!fh->do_crop];
1732 mutex_unlock(&btv->lock);
1734 if (width < c.min_scaled_width ||
1735 width > c.max_scaled_width ||
1736 height < c.min_scaled_height)
1740 case V4L2_FIELD_TOP:
1741 case V4L2_FIELD_BOTTOM:
1742 case V4L2_FIELD_ALTERNATE:
1743 /* btv->crop counts frame lines. Max. scale
1744 factor is 16:1 for frames, 8:1 for fields. */
1745 if (height * 2 > c.max_scaled_height)
1750 if (height > c.max_scaled_height)
1755 buf->vb.size = (width * height * fmt->depth) >> 3;
1756 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
1760 /* alloc + fill struct bttv_buffer (if changed) */
1761 if (buf->vb.width != width || buf->vb.height != height ||
1762 buf->vb.field != field ||
1763 buf->tvnorm != norm || buf->fmt != fmt ||
1764 buf->crop.top != c.rect.top ||
1765 buf->crop.left != c.rect.left ||
1766 buf->crop.width != c.rect.width ||
1767 buf->crop.height != c.rect.height) {
1768 buf->vb.width = width;
1769 buf->vb.height = height;
1770 buf->vb.field = field;
1777 /* alloc risc memory */
1778 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
1780 if (0 != (rc = videobuf_iolock(q,&buf->vb,&btv->fbuf)))
1785 if (0 != (rc = bttv_buffer_risc(btv,buf)))
1788 buf->vb.state = VIDEOBUF_PREPARED;
1792 bttv_dma_free(q,btv,buf);
1797 buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
1799 struct bttv_fh *fh = q->priv_data;
1801 *size = fh->fmt->depth*fh->width*fh->height >> 3;
1804 while (*size * *count > gbuffers * gbufsize)
1810 buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
1811 enum v4l2_field field)
1813 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1814 struct bttv_fh *fh = q->priv_data;
1816 return bttv_prepare_buffer(q,fh->btv, buf, fh->fmt,
1817 fh->width, fh->height, field);
1821 buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
1823 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1824 struct bttv_fh *fh = q->priv_data;
1825 struct bttv *btv = fh->btv;
1827 buf->vb.state = VIDEOBUF_QUEUED;
1828 list_add_tail(&buf->vb.queue,&btv->capture);
1829 if (!btv->curr.frame_irq) {
1831 bttv_set_dma(btv, 0x03);
1835 static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
1837 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1838 struct bttv_fh *fh = q->priv_data;
1840 bttv_dma_free(q,fh->btv,buf);
1843 static struct videobuf_queue_ops bttv_video_qops = {
1844 .buf_setup = buffer_setup,
1845 .buf_prepare = buffer_prepare,
1846 .buf_queue = buffer_queue,
1847 .buf_release = buffer_release,
1850 static int bttv_s_std(struct file *file, void *priv, v4l2_std_id *id)
1852 struct bttv_fh *fh = priv;
1853 struct bttv *btv = fh->btv;
1857 err = v4l2_prio_check(&btv->prio, &fh->prio);
1861 for (i = 0; i < BTTV_TVNORMS; i++)
1862 if (*id & bttv_tvnorms[i].v4l2_id)
1864 if (i == BTTV_TVNORMS)
1867 mutex_lock(&btv->lock);
1869 mutex_unlock(&btv->lock);
1874 static int bttv_querystd(struct file *file, void *f, v4l2_std_id *id)
1876 struct bttv_fh *fh = f;
1877 struct bttv *btv = fh->btv;
1879 if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML)
1880 *id = V4L2_STD_625_50;
1882 *id = V4L2_STD_525_60;
1886 static int bttv_enum_input(struct file *file, void *priv,
1887 struct v4l2_input *i)
1889 struct bttv_fh *fh = priv;
1890 struct bttv *btv = fh->btv;
1895 if (n >= bttv_tvcards[btv->c.type].video_inputs)
1898 memset(i, 0, sizeof(*i));
1901 i->type = V4L2_INPUT_TYPE_CAMERA;
1904 if (i->index == bttv_tvcards[btv->c.type].tuner) {
1905 sprintf(i->name, "Television");
1906 i->type = V4L2_INPUT_TYPE_TUNER;
1908 } else if (i->index == btv->svhs) {
1909 sprintf(i->name, "S-Video");
1911 sprintf(i->name, "Composite%d", i->index);
1914 if (i->index == btv->input) {
1915 __u32 dstatus = btread(BT848_DSTATUS);
1916 if (0 == (dstatus & BT848_DSTATUS_PRES))
1917 i->status |= V4L2_IN_ST_NO_SIGNAL;
1918 if (0 == (dstatus & BT848_DSTATUS_HLOC))
1919 i->status |= V4L2_IN_ST_NO_H_LOCK;
1922 for (n = 0; n < BTTV_TVNORMS; n++)
1923 i->std |= bttv_tvnorms[n].v4l2_id;
1928 static int bttv_g_input(struct file *file, void *priv, unsigned int *i)
1930 struct bttv_fh *fh = priv;
1931 struct bttv *btv = fh->btv;
1937 static int bttv_s_input(struct file *file, void *priv, unsigned int i)
1939 struct bttv_fh *fh = priv;
1940 struct bttv *btv = fh->btv;
1944 err = v4l2_prio_check(&btv->prio, &fh->prio);
1948 if (i > bttv_tvcards[btv->c.type].video_inputs)
1951 mutex_lock(&btv->lock);
1952 set_input(btv, i, btv->tvnorm);
1953 mutex_unlock(&btv->lock);
1957 static int bttv_s_tuner(struct file *file, void *priv,
1958 struct v4l2_tuner *t)
1960 struct bttv_fh *fh = priv;
1961 struct bttv *btv = fh->btv;
1964 err = v4l2_prio_check(&btv->prio, &fh->prio);
1968 if (UNSET == bttv_tvcards[btv->c.type].tuner)
1974 mutex_lock(&btv->lock);
1975 bttv_call_i2c_clients(btv, VIDIOC_S_TUNER, t);
1977 if (btv->audio_mode_gpio)
1978 btv->audio_mode_gpio(btv, t, 1);
1980 mutex_unlock(&btv->lock);
1985 static int bttv_g_frequency(struct file *file, void *priv,
1986 struct v4l2_frequency *f)
1988 struct bttv_fh *fh = priv;
1989 struct bttv *btv = fh->btv;
1992 err = v4l2_prio_check(&btv->prio, &fh->prio);
1996 f->type = btv->radio_user ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
1997 f->frequency = btv->freq;
2002 static int bttv_s_frequency(struct file *file, void *priv,
2003 struct v4l2_frequency *f)
2005 struct bttv_fh *fh = priv;
2006 struct bttv *btv = fh->btv;
2009 err = v4l2_prio_check(&btv->prio, &fh->prio);
2013 if (unlikely(f->tuner != 0))
2015 if (unlikely(f->type != (btv->radio_user
2016 ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV)))
2018 mutex_lock(&btv->lock);
2019 btv->freq = f->frequency;
2020 bttv_call_i2c_clients(btv, VIDIOC_S_FREQUENCY, f);
2021 if (btv->has_matchbox && btv->radio_user)
2022 tea5757_set_freq(btv, btv->freq);
2023 mutex_unlock(&btv->lock);
2027 static int bttv_log_status(struct file *file, void *f)
2029 struct bttv_fh *fh = f;
2030 struct bttv *btv = fh->btv;
2032 printk(KERN_INFO "bttv%d: ======== START STATUS CARD #%d ========\n",
2033 btv->c.nr, btv->c.nr);
2034 bttv_call_i2c_clients(btv, VIDIOC_LOG_STATUS, NULL);
2035 printk(KERN_INFO "bttv%d: ======== END STATUS CARD #%d ========\n",
2036 btv->c.nr, btv->c.nr);
2040 #ifdef CONFIG_VIDEO_ADV_DEBUG
2041 static int bttv_g_register(struct file *file, void *f,
2042 struct v4l2_register *reg)
2044 struct bttv_fh *fh = f;
2045 struct bttv *btv = fh->btv;
2047 if (!capable(CAP_SYS_ADMIN))
2050 if (!v4l2_chip_match_host(reg->match_type, reg->match_chip))
2053 /* bt848 has a 12-bit register space */
2055 reg->val = btread(reg->reg);
2060 static int bttv_s_register(struct file *file, void *f,
2061 struct v4l2_register *reg)
2063 struct bttv_fh *fh = f;
2064 struct bttv *btv = fh->btv;
2066 if (!capable(CAP_SYS_ADMIN))
2069 if (!v4l2_chip_match_host(reg->match_type, reg->match_chip))
2072 /* bt848 has a 12-bit register space */
2074 btwrite(reg->val, reg->reg);
2080 /* Given cropping boundaries b and the scaled width and height of a
2081 single field or frame, which must not exceed hardware limits, this
2082 function adjusts the cropping parameters c. */
2084 bttv_crop_adjust (struct bttv_crop * c,
2085 const struct v4l2_rect * b,
2088 enum v4l2_field field)
2090 __s32 frame_height = height << !V4L2_FIELD_HAS_BOTH(field);
2094 if (width < c->min_scaled_width) {
2095 /* Max. hor. scale factor 16:1. */
2096 c->rect.width = width * 16;
2097 } else if (width > c->max_scaled_width) {
2098 /* Min. hor. scale factor 1:1. */
2099 c->rect.width = width;
2101 max_left = b->left + b->width - width;
2102 max_left = min(max_left, (__s32) MAX_HDELAY);
2103 if (c->rect.left > max_left)
2104 c->rect.left = max_left;
2107 if (height < c->min_scaled_height) {
2108 /* Max. vert. scale factor 16:1, single fields 8:1. */
2109 c->rect.height = height * 16;
2110 } else if (frame_height > c->max_scaled_height) {
2111 /* Min. vert. scale factor 1:1.
2112 Top and height count field lines times two. */
2113 c->rect.height = (frame_height + 1) & ~1;
2115 max_top = b->top + b->height - c->rect.height;
2116 if (c->rect.top > max_top)
2117 c->rect.top = max_top;
2120 bttv_crop_calc_limits(c);
2123 /* Returns an error if scaling to a frame or single field with the given
2124 width and height is not possible with the current cropping parameters
2125 and width aligned according to width_mask. If adjust_size is TRUE the
2126 function may adjust the width and/or height instead, rounding width
2127 to (width + width_bias) & width_mask. If adjust_crop is TRUE it may
2128 also adjust the current cropping parameters to get closer to the
2129 desired image size. */
2131 limit_scaled_size (struct bttv_fh * fh,
2134 enum v4l2_field field,
2135 unsigned int width_mask,
2136 unsigned int width_bias,
2140 struct bttv *btv = fh->btv;
2141 const struct v4l2_rect *b;
2142 struct bttv_crop *c;
2149 BUG_ON((int) width_mask >= 0 ||
2150 width_bias >= (unsigned int) -width_mask);
2152 /* Make sure tvnorm, vbi_end and the current cropping parameters
2153 remain consistent until we're done. */
2154 mutex_lock(&btv->lock);
2156 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2158 /* Do crop - use current, don't - use default parameters. */
2159 c = &btv->crop[!!fh->do_crop];
2164 && !locked_btres(btv, VIDEO_RESOURCES)) {
2168 /* We cannot scale up. When the scaled image is larger
2169 than crop.rect we adjust the crop.rect as required
2170 by the V4L2 spec, hence cropcap.bounds are our limit. */
2171 max_width = min(b->width, (__s32) MAX_HACTIVE);
2172 max_height = b->height;
2174 /* We cannot capture the same line as video and VBI data.
2175 Note btv->vbi_end is really a minimum, see
2176 bttv_vbi_try_fmt(). */
2177 if (btv->vbi_end > b->top) {
2178 max_height -= btv->vbi_end - b->top;
2180 if (min_height > max_height)
2185 if (btv->vbi_end > c->rect.top)
2188 min_width = c->min_scaled_width;
2189 min_height = c->min_scaled_height;
2190 max_width = c->max_scaled_width;
2191 max_height = c->max_scaled_height;
2196 min_width = (min_width - width_mask - 1) & width_mask;
2197 max_width = max_width & width_mask;
2199 /* Max. scale factor is 16:1 for frames, 8:1 for fields. */
2200 min_height = min_height;
2201 /* Min. scale factor is 1:1. */
2202 max_height >>= !V4L2_FIELD_HAS_BOTH(field);
2205 *width = clamp(*width, min_width, max_width);
2206 *height = clamp(*height, min_height, max_height);
2208 /* Round after clamping to avoid overflow. */
2209 *width = (*width + width_bias) & width_mask;
2212 bttv_crop_adjust(c, b, *width, *height, field);
2214 if (btv->vbi_end > c->rect.top) {
2215 /* Move the crop window out of the way. */
2216 c->rect.top = btv->vbi_end;
2221 if (*width < min_width ||
2222 *height < min_height ||
2223 *width > max_width ||
2224 *height > max_height ||
2225 0 != (*width & ~width_mask))
2229 rc = 0; /* success */
2232 mutex_unlock(&btv->lock);
2237 /* Returns an error if the given overlay window dimensions are not
2238 possible with the current cropping parameters. If adjust_size is
2239 TRUE the function may adjust the window width and/or height
2240 instead, however it always rounds the horizontal position and
2241 width as btcx_align() does. If adjust_crop is TRUE the function
2242 may also adjust the current cropping parameters to get closer
2243 to the desired window size. */
2245 verify_window (struct bttv_fh * fh,
2246 struct v4l2_window * win,
2250 enum v4l2_field field;
2251 unsigned int width_mask;
2254 if (win->w.width < 48 || win->w.height < 32)
2256 if (win->clipcount > 2048)
2261 if (V4L2_FIELD_ANY == field) {
2264 height2 = fh->btv->crop[!!fh->do_crop].rect.height >> 1;
2265 field = (win->w.height > height2)
2266 ? V4L2_FIELD_INTERLACED
2270 case V4L2_FIELD_TOP:
2271 case V4L2_FIELD_BOTTOM:
2272 case V4L2_FIELD_INTERLACED:
2278 /* 4-byte alignment. */
2279 if (NULL == fh->ovfmt)
2282 switch (fh->ovfmt->depth) {
2296 win->w.width -= win->w.left & ~width_mask;
2297 win->w.left = (win->w.left - width_mask - 1) & width_mask;
2299 rc = limit_scaled_size(fh, &win->w.width, &win->w.height,
2301 /* width_bias: round down */ 0,
2302 adjust_size, adjust_crop);
2310 static int setup_window(struct bttv_fh *fh, struct bttv *btv,
2311 struct v4l2_window *win, int fixup)
2313 struct v4l2_clip *clips = NULL;
2314 int n,size,retval = 0;
2316 if (NULL == fh->ovfmt)
2318 if (!(fh->ovfmt->flags & FORMAT_FLAGS_PACKED))
2320 retval = verify_window(fh, win,
2321 /* adjust_size */ fixup,
2322 /* adjust_crop */ fixup);
2326 /* copy clips -- luckily v4l1 + v4l2 are binary
2327 compatible here ...*/
2329 size = sizeof(*clips)*(n+4);
2330 clips = kmalloc(size,GFP_KERNEL);
2334 if (copy_from_user(clips,win->clips,sizeof(struct v4l2_clip)*n)) {
2339 /* clip against screen */
2340 if (NULL != btv->fbuf.base)
2341 n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height,
2343 btcx_sort_clips(clips,n);
2345 /* 4-byte alignments */
2346 switch (fh->ovfmt->depth) {
2349 btcx_align(&win->w, clips, n, 3);
2352 btcx_align(&win->w, clips, n, 1);
2355 /* no alignment fixups needed */
2361 mutex_lock(&fh->cap.vb_lock);
2362 kfree(fh->ov.clips);
2363 fh->ov.clips = clips;
2367 fh->ov.field = win->field;
2368 fh->ov.setup_ok = 1;
2369 btv->init.ov.w.width = win->w.width;
2370 btv->init.ov.w.height = win->w.height;
2371 btv->init.ov.field = win->field;
2373 /* update overlay if needed */
2375 if (check_btres(fh, RESOURCE_OVERLAY)) {
2376 struct bttv_buffer *new;
2378 new = videobuf_sg_alloc(sizeof(*new));
2379 new->crop = btv->crop[!!fh->do_crop].rect;
2380 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2381 retval = bttv_switch_overlay(btv,fh,new);
2383 mutex_unlock(&fh->cap.vb_lock);
2387 /* ----------------------------------------------------------------------- */
2389 static struct videobuf_queue* bttv_queue(struct bttv_fh *fh)
2391 struct videobuf_queue* q = NULL;
2394 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2397 case V4L2_BUF_TYPE_VBI_CAPTURE:
2406 static int bttv_resource(struct bttv_fh *fh)
2411 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2412 res = RESOURCE_VIDEO_STREAM;
2414 case V4L2_BUF_TYPE_VBI_CAPTURE:
2423 static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type)
2425 struct videobuf_queue *q = bttv_queue(fh);
2426 int res = bttv_resource(fh);
2428 if (check_btres(fh,res))
2430 if (videobuf_queue_is_busy(q))
2437 pix_format_set_size (struct v4l2_pix_format * f,
2438 const struct bttv_format * fmt,
2440 unsigned int height)
2445 if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2446 f->bytesperline = width; /* Y plane */
2447 f->sizeimage = (width * height * fmt->depth) >> 3;
2449 f->bytesperline = (width * fmt->depth) >> 3;
2450 f->sizeimage = height * f->bytesperline;
2454 static int bttv_g_fmt_vid_cap(struct file *file, void *priv,
2455 struct v4l2_format *f)
2457 struct bttv_fh *fh = priv;
2459 pix_format_set_size(&f->fmt.pix, fh->fmt,
2460 fh->width, fh->height);
2461 f->fmt.pix.field = fh->cap.field;
2462 f->fmt.pix.pixelformat = fh->fmt->fourcc;
2467 static int bttv_g_fmt_vid_overlay(struct file *file, void *priv,
2468 struct v4l2_format *f)
2470 struct bttv_fh *fh = priv;
2472 f->fmt.win.w = fh->ov.w;
2473 f->fmt.win.field = fh->ov.field;
2478 static int bttv_try_fmt_vid_cap(struct file *file, void *priv,
2479 struct v4l2_format *f)
2481 const struct bttv_format *fmt;
2482 struct bttv_fh *fh = priv;
2483 struct bttv *btv = fh->btv;
2484 enum v4l2_field field;
2485 __s32 width, height;
2488 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2492 field = f->fmt.pix.field;
2494 if (V4L2_FIELD_ANY == field) {
2497 height2 = btv->crop[!!fh->do_crop].rect.height >> 1;
2498 field = (f->fmt.pix.height > height2)
2499 ? V4L2_FIELD_INTERLACED
2500 : V4L2_FIELD_BOTTOM;
2503 if (V4L2_FIELD_SEQ_BT == field)
2504 field = V4L2_FIELD_SEQ_TB;
2507 case V4L2_FIELD_TOP:
2508 case V4L2_FIELD_BOTTOM:
2509 case V4L2_FIELD_ALTERNATE:
2510 case V4L2_FIELD_INTERLACED:
2512 case V4L2_FIELD_SEQ_TB:
2513 if (fmt->flags & FORMAT_FLAGS_PLANAR)
2520 width = f->fmt.pix.width;
2521 height = f->fmt.pix.height;
2523 rc = limit_scaled_size(fh, &width, &height, field,
2524 /* width_mask: 4 pixels */ ~3,
2525 /* width_bias: nearest */ 2,
2526 /* adjust_size */ 1,
2527 /* adjust_crop */ 0);
2531 /* update data for the application */
2532 f->fmt.pix.field = field;
2533 pix_format_set_size(&f->fmt.pix, fmt, width, height);
2538 static int bttv_try_fmt_vid_overlay(struct file *file, void *priv,
2539 struct v4l2_format *f)
2541 struct bttv_fh *fh = priv;
2543 return verify_window(fh, &f->fmt.win,
2544 /* adjust_size */ 1,
2545 /* adjust_crop */ 0);
2548 static int bttv_s_fmt_vid_cap(struct file *file, void *priv,
2549 struct v4l2_format *f)
2552 const struct bttv_format *fmt;
2553 struct bttv_fh *fh = priv;
2554 struct bttv *btv = fh->btv;
2555 __s32 width, height;
2556 enum v4l2_field field;
2558 retval = bttv_switch_type(fh, f->type);
2562 retval = bttv_try_fmt_vid_cap(file, priv, f);
2566 width = f->fmt.pix.width;
2567 height = f->fmt.pix.height;
2568 field = f->fmt.pix.field;
2570 retval = limit_scaled_size(fh, &width, &height, f->fmt.pix.field,
2571 /* width_mask: 4 pixels */ ~3,
2572 /* width_bias: nearest */ 2,
2573 /* adjust_size */ 1,
2574 /* adjust_crop */ 1);
2578 f->fmt.pix.field = field;
2580 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2582 /* update our state informations */
2583 mutex_lock(&fh->cap.vb_lock);
2585 fh->cap.field = f->fmt.pix.field;
2586 fh->cap.last = V4L2_FIELD_NONE;
2587 fh->width = f->fmt.pix.width;
2588 fh->height = f->fmt.pix.height;
2589 btv->init.fmt = fmt;
2590 btv->init.width = f->fmt.pix.width;
2591 btv->init.height = f->fmt.pix.height;
2592 mutex_unlock(&fh->cap.vb_lock);
2597 static int bttv_s_fmt_vid_overlay(struct file *file, void *priv,
2598 struct v4l2_format *f)
2600 struct bttv_fh *fh = priv;
2601 struct bttv *btv = fh->btv;
2603 if (no_overlay > 0) {
2604 printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2608 return setup_window(fh, btv, &f->fmt.win, 1);
2611 #ifdef CONFIG_VIDEO_V4L1_COMPAT
2612 static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
2616 struct bttv_fh *fh = priv;
2618 mutex_lock(&fh->cap.vb_lock);
2619 retval = __videobuf_mmap_setup(&fh->cap, gbuffers, gbufsize,
2622 mutex_unlock(&fh->cap.vb_lock);
2627 memset(mbuf, 0, sizeof(*mbuf));
2628 mbuf->frames = gbuffers;
2629 mbuf->size = gbuffers * gbufsize;
2631 for (i = 0; i < gbuffers; i++)
2632 mbuf->offsets[i] = i * gbufsize;
2634 mutex_unlock(&fh->cap.vb_lock);
2639 static int bttv_querycap(struct file *file, void *priv,
2640 struct v4l2_capability *cap)
2642 struct bttv_fh *fh = priv;
2643 struct bttv *btv = fh->btv;
2648 strlcpy(cap->driver, "bttv", sizeof(cap->driver));
2649 strlcpy(cap->card, btv->video_dev->name, sizeof(cap->card));
2650 snprintf(cap->bus_info, sizeof(cap->bus_info),
2651 "PCI:%s", pci_name(btv->c.pci));
2652 cap->version = BTTV_VERSION_CODE;
2654 V4L2_CAP_VIDEO_CAPTURE |
2655 V4L2_CAP_VBI_CAPTURE |
2656 V4L2_CAP_READWRITE |
2658 if (no_overlay <= 0)
2659 cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
2661 if (bttv_tvcards[btv->c.type].tuner != UNSET &&
2662 bttv_tvcards[btv->c.type].tuner != TUNER_ABSENT)
2663 cap->capabilities |= V4L2_CAP_TUNER;
2667 static int bttv_enum_fmt_vbi_cap(struct file *file, void *priv,
2668 struct v4l2_fmtdesc *f)
2673 f->pixelformat = V4L2_PIX_FMT_GREY;
2674 strcpy(f->description, "vbi data");
2679 static int bttv_enum_fmt_cap_ovr(struct v4l2_fmtdesc *f)
2683 for (i = 0; i < FORMATS; i++) {
2684 if (formats[i].fourcc != -1)
2686 if ((unsigned int)index == f->index)
2692 f->pixelformat = formats[i].fourcc;
2693 strlcpy(f->description, formats[i].name, sizeof(f->description));
2698 static int bttv_enum_fmt_vid_cap(struct file *file, void *priv,
2699 struct v4l2_fmtdesc *f)
2701 int rc = bttv_enum_fmt_cap_ovr(f);
2709 static int bttv_enum_fmt_vid_overlay(struct file *file, void *priv,
2710 struct v4l2_fmtdesc *f)
2714 if (no_overlay > 0) {
2715 printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2719 rc = bttv_enum_fmt_cap_ovr(f);
2724 if (!(formats[rc].flags & FORMAT_FLAGS_PACKED))
2730 static int bttv_g_fbuf(struct file *file, void *f,
2731 struct v4l2_framebuffer *fb)
2733 struct bttv_fh *fh = f;
2734 struct bttv *btv = fh->btv;
2737 fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
2739 fb->fmt.pixelformat = fh->ovfmt->fourcc;
2743 static int bttv_overlay(struct file *file, void *f, unsigned int on)
2745 struct bttv_fh *fh = f;
2746 struct bttv *btv = fh->btv;
2747 struct bttv_buffer *new;
2752 if (NULL == btv->fbuf.base)
2754 if (!fh->ov.setup_ok) {
2755 dprintk("bttv%d: overlay: !setup_ok\n", btv->c.nr);
2760 if (!check_alloc_btres(btv, fh, RESOURCE_OVERLAY))
2763 mutex_lock(&fh->cap.vb_lock);
2765 fh->ov.tvnorm = btv->tvnorm;
2766 new = videobuf_sg_alloc(sizeof(*new));
2767 new->crop = btv->crop[!!fh->do_crop].rect;
2768 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2774 retval = bttv_switch_overlay(btv, fh, new);
2775 mutex_unlock(&fh->cap.vb_lock);
2779 static int bttv_s_fbuf(struct file *file, void *f,
2780 struct v4l2_framebuffer *fb)
2782 struct bttv_fh *fh = f;
2783 struct bttv *btv = fh->btv;
2784 const struct bttv_format *fmt;
2787 if (!capable(CAP_SYS_ADMIN) &&
2788 !capable(CAP_SYS_RAWIO))
2792 fmt = format_by_fourcc(fb->fmt.pixelformat);
2795 if (0 == (fmt->flags & FORMAT_FLAGS_PACKED))
2799 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2800 __s32 width = fb->fmt.width;
2801 __s32 height = fb->fmt.height;
2803 retval = limit_scaled_size(fh, &width, &height,
2804 V4L2_FIELD_INTERLACED,
2805 /* width_mask */ ~3,
2807 /* adjust_size */ 0,
2808 /* adjust_crop */ 0);
2814 mutex_lock(&fh->cap.vb_lock);
2815 btv->fbuf.base = fb->base;
2816 btv->fbuf.fmt.width = fb->fmt.width;
2817 btv->fbuf.fmt.height = fb->fmt.height;
2818 if (0 != fb->fmt.bytesperline)
2819 btv->fbuf.fmt.bytesperline = fb->fmt.bytesperline;
2821 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fmt->depth/8;
2825 btv->init.ovfmt = fmt;
2826 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2829 fh->ov.w.width = fb->fmt.width;
2830 fh->ov.w.height = fb->fmt.height;
2831 btv->init.ov.w.width = fb->fmt.width;
2832 btv->init.ov.w.height = fb->fmt.height;
2833 kfree(fh->ov.clips);
2834 fh->ov.clips = NULL;
2837 if (check_btres(fh, RESOURCE_OVERLAY)) {
2838 struct bttv_buffer *new;
2840 new = videobuf_sg_alloc(sizeof(*new));
2841 new->crop = btv->crop[!!fh->do_crop].rect;
2842 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2843 retval = bttv_switch_overlay(btv, fh, new);
2846 mutex_unlock(&fh->cap.vb_lock);
2850 static int bttv_reqbufs(struct file *file, void *priv,
2851 struct v4l2_requestbuffers *p)
2853 struct bttv_fh *fh = priv;
2854 return videobuf_reqbufs(bttv_queue(fh), p);
2857 static int bttv_querybuf(struct file *file, void *priv,
2858 struct v4l2_buffer *b)
2860 struct bttv_fh *fh = priv;
2861 return videobuf_querybuf(bttv_queue(fh), b);
2864 static int bttv_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2866 struct bttv_fh *fh = priv;
2867 struct bttv *btv = fh->btv;
2868 int res = bttv_resource(fh);
2870 if (!check_alloc_btres(btv, fh, res))
2873 return videobuf_qbuf(bttv_queue(fh), b);
2876 static int bttv_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2878 struct bttv_fh *fh = priv;
2879 return videobuf_dqbuf(bttv_queue(fh), b,
2880 file->f_flags & O_NONBLOCK);
2883 static int bttv_streamon(struct file *file, void *priv,
2884 enum v4l2_buf_type type)
2886 struct bttv_fh *fh = priv;
2887 struct bttv *btv = fh->btv;
2888 int res = bttv_resource(fh);
2890 if (!check_alloc_btres(btv, fh, res))
2892 return videobuf_streamon(bttv_queue(fh));
2896 static int bttv_streamoff(struct file *file, void *priv,
2897 enum v4l2_buf_type type)
2899 struct bttv_fh *fh = priv;
2900 struct bttv *btv = fh->btv;
2902 int res = bttv_resource(fh);
2905 retval = videobuf_streamoff(bttv_queue(fh));
2908 free_btres(btv, fh, res);
2912 static int bttv_queryctrl(struct file *file, void *priv,
2913 struct v4l2_queryctrl *c)
2915 struct bttv_fh *fh = priv;
2916 struct bttv *btv = fh->btv;
2917 const struct v4l2_queryctrl *ctrl;
2919 if ((c->id < V4L2_CID_BASE ||
2920 c->id >= V4L2_CID_LASTP1) &&
2921 (c->id < V4L2_CID_PRIVATE_BASE ||
2922 c->id >= V4L2_CID_PRIVATE_LASTP1))
2925 if (!btv->volume_gpio && (c->id == V4L2_CID_AUDIO_VOLUME))
2928 ctrl = ctrl_by_id(c->id);
2930 *c = (NULL != ctrl) ? *ctrl : no_ctl;
2936 static int bttv_g_parm(struct file *file, void *f,
2937 struct v4l2_streamparm *parm)
2939 struct bttv_fh *fh = f;
2940 struct bttv *btv = fh->btv;
2941 struct v4l2_standard s;
2943 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2945 v4l2_video_std_construct(&s, bttv_tvnorms[btv->tvnorm].v4l2_id,
2946 bttv_tvnorms[btv->tvnorm].name);
2947 parm->parm.capture.timeperframe = s.frameperiod;
2951 static int bttv_g_tuner(struct file *file, void *priv,
2952 struct v4l2_tuner *t)
2954 struct bttv_fh *fh = priv;
2955 struct bttv *btv = fh->btv;
2957 if (UNSET == bttv_tvcards[btv->c.type].tuner)
2962 mutex_lock(&btv->lock);
2963 memset(t, 0, sizeof(*t));
2964 t->rxsubchans = V4L2_TUNER_SUB_MONO;
2965 bttv_call_i2c_clients(btv, VIDIOC_G_TUNER, t);
2966 strcpy(t->name, "Television");
2967 t->capability = V4L2_TUNER_CAP_NORM;
2968 t->type = V4L2_TUNER_ANALOG_TV;
2969 if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
2972 if (btv->audio_mode_gpio)
2973 btv->audio_mode_gpio(btv, t, 0);
2975 mutex_unlock(&btv->lock);
2979 static int bttv_g_priority(struct file *file, void *f, enum v4l2_priority *p)
2981 struct bttv_fh *fh = f;
2982 struct bttv *btv = fh->btv;
2984 *p = v4l2_prio_max(&btv->prio);
2989 static int bttv_s_priority(struct file *file, void *f,
2990 enum v4l2_priority prio)
2992 struct bttv_fh *fh = f;
2993 struct bttv *btv = fh->btv;
2995 return v4l2_prio_change(&btv->prio, &fh->prio, prio);
2998 static int bttv_cropcap(struct file *file, void *priv,
2999 struct v4l2_cropcap *cap)
3001 struct bttv_fh *fh = priv;
3002 struct bttv *btv = fh->btv;
3004 if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3005 cap->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3008 *cap = bttv_tvnorms[btv->tvnorm].cropcap;
3013 static int bttv_g_crop(struct file *file, void *f, struct v4l2_crop *crop)
3015 struct bttv_fh *fh = f;
3016 struct bttv *btv = fh->btv;
3018 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3019 crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3022 /* No fh->do_crop = 1; because btv->crop[1] may be
3023 inconsistent with fh->width or fh->height and apps
3024 do not expect a change here. */
3026 crop->c = btv->crop[!!fh->do_crop].rect;
3031 static int bttv_s_crop(struct file *file, void *f, struct v4l2_crop *crop)
3033 struct bttv_fh *fh = f;
3034 struct bttv *btv = fh->btv;
3035 const struct v4l2_rect *b;
3043 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3044 crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3047 retval = v4l2_prio_check(&btv->prio, &fh->prio);
3051 /* Make sure tvnorm, vbi_end and the current cropping
3052 parameters remain consistent until we're done. Note
3053 read() may change vbi_end in check_alloc_btres(). */
3054 mutex_lock(&btv->lock);
3058 if (locked_btres(fh->btv, VIDEO_RESOURCES)) {
3059 mutex_unlock(&btv->lock);
3063 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
3066 b_right = b_left + b->width;
3067 b_bottom = b->top + b->height;
3069 b_top = max(b->top, btv->vbi_end);
3070 if (b_top + 32 >= b_bottom) {
3071 mutex_unlock(&btv->lock);
3075 /* Min. scaled size 48 x 32. */
3076 c.rect.left = clamp(crop->c.left, b_left, b_right - 48);
3077 c.rect.left = min(c.rect.left, (__s32) MAX_HDELAY);
3079 c.rect.width = clamp(crop->c.width,
3080 48, b_right - c.rect.left);
3082 c.rect.top = clamp(crop->c.top, b_top, b_bottom - 32);
3083 /* Top and height must be a multiple of two. */
3084 c.rect.top = (c.rect.top + 1) & ~1;
3086 c.rect.height = clamp(crop->c.height,
3087 32, b_bottom - c.rect.top);
3088 c.rect.height = (c.rect.height + 1) & ~1;
3090 bttv_crop_calc_limits(&c);
3094 mutex_unlock(&btv->lock);
3098 mutex_lock(&fh->cap.vb_lock);
3100 if (fh->width < c.min_scaled_width) {
3101 fh->width = c.min_scaled_width;
3102 btv->init.width = c.min_scaled_width;
3103 } else if (fh->width > c.max_scaled_width) {
3104 fh->width = c.max_scaled_width;
3105 btv->init.width = c.max_scaled_width;
3108 if (fh->height < c.min_scaled_height) {
3109 fh->height = c.min_scaled_height;
3110 btv->init.height = c.min_scaled_height;
3111 } else if (fh->height > c.max_scaled_height) {
3112 fh->height = c.max_scaled_height;
3113 btv->init.height = c.max_scaled_height;
3116 mutex_unlock(&fh->cap.vb_lock);
3121 static int bttv_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
3123 if (unlikely(a->index))
3126 strcpy(a->name, "audio");
3130 static int bttv_s_audio(struct file *file, void *priv, struct v4l2_audio *a)
3132 if (unlikely(a->index))
3138 static ssize_t bttv_read(struct file *file, char __user *data,
3139 size_t count, loff_t *ppos)
3141 struct bttv_fh *fh = file->private_data;
3144 if (fh->btv->errors)
3145 bttv_reinit_bt848(fh->btv);
3146 dprintk("bttv%d: read count=%d type=%s\n",
3147 fh->btv->c.nr,(int)count,v4l2_type_names[fh->type]);
3150 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
3151 if (!check_alloc_btres(fh->btv, fh, RESOURCE_VIDEO_READ)) {
3152 /* VIDEO_READ in use by another fh,
3153 or VIDEO_STREAM by any fh. */
3156 retval = videobuf_read_one(&fh->cap, data, count, ppos,
3157 file->f_flags & O_NONBLOCK);
3158 free_btres(fh->btv, fh, RESOURCE_VIDEO_READ);
3160 case V4L2_BUF_TYPE_VBI_CAPTURE:
3161 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
3163 retval = videobuf_read_stream(&fh->vbi, data, count, ppos, 1,
3164 file->f_flags & O_NONBLOCK);
3172 static unsigned int bttv_poll(struct file *file, poll_table *wait)
3174 struct bttv_fh *fh = file->private_data;
3175 struct bttv_buffer *buf;
3176 enum v4l2_field field;
3178 if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
3179 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
3181 return videobuf_poll_stream(file, &fh->vbi, wait);
3184 if (check_btres(fh,RESOURCE_VIDEO_STREAM)) {
3185 /* streaming capture */
3186 if (list_empty(&fh->cap.stream))
3188 buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
3190 /* read() capture */
3191 mutex_lock(&fh->cap.vb_lock);
3192 if (NULL == fh->cap.read_buf) {
3193 /* need to capture a new frame */
3194 if (locked_btres(fh->btv,RESOURCE_VIDEO_STREAM))
3196 fh->cap.read_buf = videobuf_sg_alloc(fh->cap.msize);
3197 if (NULL == fh->cap.read_buf)
3199 fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
3200 field = videobuf_next_field(&fh->cap);
3201 if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) {
3202 kfree (fh->cap.read_buf);
3203 fh->cap.read_buf = NULL;
3206 fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
3207 fh->cap.read_off = 0;
3209 mutex_unlock(&fh->cap.vb_lock);
3210 buf = (struct bttv_buffer*)fh->cap.read_buf;
3213 poll_wait(file, &buf->vb.done, wait);
3214 if (buf->vb.state == VIDEOBUF_DONE ||
3215 buf->vb.state == VIDEOBUF_ERROR)
3216 return POLLIN|POLLRDNORM;
3219 mutex_unlock(&fh->cap.vb_lock);
3223 static int bttv_open(struct inode *inode, struct file *file)
3225 int minor = iminor(inode);
3226 struct bttv *btv = NULL;
3228 enum v4l2_buf_type type = 0;
3231 dprintk(KERN_DEBUG "bttv: open minor=%d\n",minor);
3234 for (i = 0; i < bttv_num; i++) {
3235 if (bttvs[i].video_dev &&
3236 bttvs[i].video_dev->minor == minor) {
3238 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
3241 if (bttvs[i].vbi_dev &&
3242 bttvs[i].vbi_dev->minor == minor) {
3244 type = V4L2_BUF_TYPE_VBI_CAPTURE;
3253 dprintk(KERN_DEBUG "bttv%d: open called (type=%s)\n",
3254 btv->c.nr,v4l2_type_names[type]);
3256 /* allocate per filehandle data */
3257 fh = kmalloc(sizeof(*fh),GFP_KERNEL);
3262 file->private_data = fh;
3265 fh->ov.setup_ok = 0;
3266 v4l2_prio_open(&btv->prio,&fh->prio);
3268 videobuf_queue_sg_init(&fh->cap, &bttv_video_qops,
3269 &btv->c.pci->dev, &btv->s_lock,
3270 V4L2_BUF_TYPE_VIDEO_CAPTURE,
3271 V4L2_FIELD_INTERLACED,
3272 sizeof(struct bttv_buffer),
3274 videobuf_queue_sg_init(&fh->vbi, &bttv_vbi_qops,
3275 &btv->c.pci->dev, &btv->s_lock,
3276 V4L2_BUF_TYPE_VBI_CAPTURE,
3278 sizeof(struct bttv_buffer),
3280 set_tvnorm(btv,btv->tvnorm);
3281 set_input(btv, btv->input, btv->tvnorm);
3285 /* The V4L2 spec requires one global set of cropping parameters
3286 which only change on request. These are stored in btv->crop[1].
3287 However for compatibility with V4L apps and cropping unaware
3288 V4L2 apps we now reset the cropping parameters as seen through
3289 this fh, which is to say VIDIOC_G_CROP and scaling limit checks
3290 will use btv->crop[0], the default cropping parameters for the
3291 current video standard, and VIDIOC_S_FMT will not implicitely
3292 change the cropping parameters until VIDIOC_S_CROP has been
3294 fh->do_crop = !reset_crop; /* module parameter */
3296 /* Likewise there should be one global set of VBI capture
3297 parameters, but for compatibility with V4L apps and earlier
3298 driver versions each fh has its own parameters. */
3299 bttv_vbi_fmt_reset(&fh->vbi_fmt, btv->tvnorm);
3301 bttv_field_count(btv);
3306 static int bttv_release(struct inode *inode, struct file *file)
3308 struct bttv_fh *fh = file->private_data;
3309 struct bttv *btv = fh->btv;
3311 /* turn off overlay */
3312 if (check_btres(fh, RESOURCE_OVERLAY))
3313 bttv_switch_overlay(btv,fh,NULL);
3315 /* stop video capture */
3316 if (check_btres(fh, RESOURCE_VIDEO_STREAM)) {
3317 videobuf_streamoff(&fh->cap);
3318 free_btres(btv,fh,RESOURCE_VIDEO_STREAM);
3320 if (fh->cap.read_buf) {
3321 buffer_release(&fh->cap,fh->cap.read_buf);
3322 kfree(fh->cap.read_buf);
3324 if (check_btres(fh, RESOURCE_VIDEO_READ)) {
3325 free_btres(btv, fh, RESOURCE_VIDEO_READ);
3328 /* stop vbi capture */
3329 if (check_btres(fh, RESOURCE_VBI)) {
3330 videobuf_stop(&fh->vbi);
3331 free_btres(btv,fh,RESOURCE_VBI);
3335 videobuf_mmap_free(&fh->cap);
3336 videobuf_mmap_free(&fh->vbi);
3337 v4l2_prio_close(&btv->prio,&fh->prio);
3338 file->private_data = NULL;
3342 bttv_field_count(btv);
3351 bttv_mmap(struct file *file, struct vm_area_struct *vma)
3353 struct bttv_fh *fh = file->private_data;
3355 dprintk("bttv%d: mmap type=%s 0x%lx+%ld\n",
3356 fh->btv->c.nr, v4l2_type_names[fh->type],
3357 vma->vm_start, vma->vm_end - vma->vm_start);
3358 return videobuf_mmap_mapper(bttv_queue(fh),vma);
3361 static const struct file_operations bttv_fops =
3363 .owner = THIS_MODULE,
3365 .release = bttv_release,
3366 .ioctl = video_ioctl2,
3367 .compat_ioctl = v4l_compat_ioctl32,
3368 .llseek = no_llseek,
3374 static const struct v4l2_ioctl_ops bttv_ioctl_ops = {
3375 .vidioc_querycap = bttv_querycap,
3376 .vidioc_enum_fmt_vid_cap = bttv_enum_fmt_vid_cap,
3377 .vidioc_g_fmt_vid_cap = bttv_g_fmt_vid_cap,
3378 .vidioc_try_fmt_vid_cap = bttv_try_fmt_vid_cap,
3379 .vidioc_s_fmt_vid_cap = bttv_s_fmt_vid_cap,
3380 .vidioc_enum_fmt_vid_overlay = bttv_enum_fmt_vid_overlay,
3381 .vidioc_g_fmt_vid_overlay = bttv_g_fmt_vid_overlay,
3382 .vidioc_try_fmt_vid_overlay = bttv_try_fmt_vid_overlay,
3383 .vidioc_s_fmt_vid_overlay = bttv_s_fmt_vid_overlay,
3384 .vidioc_enum_fmt_vbi_cap = bttv_enum_fmt_vbi_cap,
3385 .vidioc_g_fmt_vbi_cap = bttv_g_fmt_vbi_cap,
3386 .vidioc_try_fmt_vbi_cap = bttv_try_fmt_vbi_cap,
3387 .vidioc_s_fmt_vbi_cap = bttv_s_fmt_vbi_cap,
3388 .vidioc_g_audio = bttv_g_audio,
3389 .vidioc_s_audio = bttv_s_audio,
3390 .vidioc_cropcap = bttv_cropcap,
3391 .vidioc_reqbufs = bttv_reqbufs,
3392 .vidioc_querybuf = bttv_querybuf,
3393 .vidioc_qbuf = bttv_qbuf,
3394 .vidioc_dqbuf = bttv_dqbuf,
3395 .vidioc_s_std = bttv_s_std,
3396 .vidioc_enum_input = bttv_enum_input,
3397 .vidioc_g_input = bttv_g_input,
3398 .vidioc_s_input = bttv_s_input,
3399 .vidioc_queryctrl = bttv_queryctrl,
3400 .vidioc_g_ctrl = bttv_g_ctrl,
3401 .vidioc_s_ctrl = bttv_s_ctrl,
3402 .vidioc_streamon = bttv_streamon,
3403 .vidioc_streamoff = bttv_streamoff,
3404 .vidioc_g_tuner = bttv_g_tuner,
3405 .vidioc_s_tuner = bttv_s_tuner,
3406 #ifdef CONFIG_VIDEO_V4L1_COMPAT
3407 .vidiocgmbuf = vidiocgmbuf,
3409 .vidioc_g_crop = bttv_g_crop,
3410 .vidioc_s_crop = bttv_s_crop,
3411 .vidioc_g_fbuf = bttv_g_fbuf,
3412 .vidioc_s_fbuf = bttv_s_fbuf,
3413 .vidioc_overlay = bttv_overlay,
3414 .vidioc_g_priority = bttv_g_priority,
3415 .vidioc_s_priority = bttv_s_priority,
3416 .vidioc_g_parm = bttv_g_parm,
3417 .vidioc_g_frequency = bttv_g_frequency,
3418 .vidioc_s_frequency = bttv_s_frequency,
3419 .vidioc_log_status = bttv_log_status,
3420 .vidioc_querystd = bttv_querystd,
3421 #ifdef CONFIG_VIDEO_ADV_DEBUG
3422 .vidioc_g_register = bttv_g_register,
3423 .vidioc_s_register = bttv_s_register,
3427 static struct video_device bttv_video_template = {
3430 .ioctl_ops = &bttv_ioctl_ops,
3431 .tvnorms = BTTV_NORMS,
3432 .current_norm = V4L2_STD_PAL,
3435 /* ----------------------------------------------------------------------- */
3436 /* radio interface */
3438 static int radio_open(struct inode *inode, struct file *file)
3440 int minor = iminor(inode);
3441 struct bttv *btv = NULL;
3445 dprintk("bttv: open minor=%d\n",minor);
3448 for (i = 0; i < bttv_num; i++) {
3449 if (bttvs[i].radio_dev && bttvs[i].radio_dev->minor == minor) {
3459 dprintk("bttv%d: open called (radio)\n",btv->c.nr);
3461 /* allocate per filehandle data */
3462 fh = kmalloc(sizeof(*fh), GFP_KERNEL);
3467 file->private_data = fh;
3469 v4l2_prio_open(&btv->prio, &fh->prio);
3471 mutex_lock(&btv->lock);
3475 bttv_call_i2c_clients(btv,AUDC_SET_RADIO,NULL);
3476 audio_input(btv,TVAUDIO_INPUT_RADIO);
3478 mutex_unlock(&btv->lock);
3483 static int radio_release(struct inode *inode, struct file *file)
3485 struct bttv_fh *fh = file->private_data;
3486 struct bttv *btv = fh->btv;
3487 struct rds_command cmd;
3489 file->private_data = NULL;
3494 bttv_call_i2c_clients(btv, RDS_CMD_CLOSE, &cmd);
3499 static int radio_querycap(struct file *file, void *priv,
3500 struct v4l2_capability *cap)
3502 struct bttv_fh *fh = priv;
3503 struct bttv *btv = fh->btv;
3505 strcpy(cap->driver, "bttv");
3506 strlcpy(cap->card, btv->radio_dev->name, sizeof(cap->card));
3507 sprintf(cap->bus_info, "PCI:%s", pci_name(btv->c.pci));
3508 cap->version = BTTV_VERSION_CODE;
3509 cap->capabilities = V4L2_CAP_TUNER;
3514 static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
3516 struct bttv_fh *fh = priv;
3517 struct bttv *btv = fh->btv;
3519 if (UNSET == bttv_tvcards[btv->c.type].tuner)
3523 mutex_lock(&btv->lock);
3524 memset(t, 0, sizeof(*t));
3525 strcpy(t->name, "Radio");
3526 t->type = V4L2_TUNER_RADIO;
3528 bttv_call_i2c_clients(btv, VIDIOC_G_TUNER, t);
3530 if (btv->audio_mode_gpio)
3531 btv->audio_mode_gpio(btv, t, 0);
3533 mutex_unlock(&btv->lock);
3538 static int radio_enum_input(struct file *file, void *priv,
3539 struct v4l2_input *i)
3544 strcpy(i->name, "Radio");
3545 i->type = V4L2_INPUT_TYPE_TUNER;
3550 static int radio_g_audio(struct file *file, void *priv,
3551 struct v4l2_audio *a)
3553 if (unlikely(a->index))
3556 strcpy(a->name, "Radio");
3561 static int radio_s_tuner(struct file *file, void *priv,
3562 struct v4l2_tuner *t)
3564 struct bttv_fh *fh = priv;
3565 struct bttv *btv = fh->btv;
3570 bttv_call_i2c_clients(btv, VIDIOC_G_TUNER, t);
3574 static int radio_s_audio(struct file *file, void *priv,
3575 struct v4l2_audio *a)
3577 if (unlikely(a->index))
3583 static int radio_s_input(struct file *filp, void *priv, unsigned int i)
3591 static int radio_s_std(struct file *file, void *fh, v4l2_std_id *norm)
3596 static int radio_queryctrl(struct file *file, void *priv,
3597 struct v4l2_queryctrl *c)
3599 const struct v4l2_queryctrl *ctrl;
3601 if (c->id < V4L2_CID_BASE ||
3602 c->id >= V4L2_CID_LASTP1)
3605 if (c->id == V4L2_CID_AUDIO_MUTE) {
3606 ctrl = ctrl_by_id(c->id);
3614 static int radio_g_input(struct file *filp, void *priv, unsigned int *i)
3620 static ssize_t radio_read(struct file *file, char __user *data,
3621 size_t count, loff_t *ppos)
3623 struct bttv_fh *fh = file->private_data;
3624 struct bttv *btv = fh->btv;
3625 struct rds_command cmd;
3626 cmd.block_count = count/3;
3628 cmd.instance = file;
3629 cmd.result = -ENODEV;
3631 bttv_call_i2c_clients(btv, RDS_CMD_READ, &cmd);
3636 static unsigned int radio_poll(struct file *file, poll_table *wait)
3638 struct bttv_fh *fh = file->private_data;
3639 struct bttv *btv = fh->btv;
3640 struct rds_command cmd;
3641 cmd.instance = file;
3642 cmd.event_list = wait;
3643 cmd.result = -ENODEV;
3644 bttv_call_i2c_clients(btv, RDS_CMD_POLL, &cmd);
3649 static const struct file_operations radio_fops =
3651 .owner = THIS_MODULE,
3654 .release = radio_release,
3655 .compat_ioctl = v4l_compat_ioctl32,
3656 .ioctl = video_ioctl2,
3657 .llseek = no_llseek,
3661 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
3662 .vidioc_querycap = radio_querycap,
3663 .vidioc_g_tuner = radio_g_tuner,
3664 .vidioc_enum_input = radio_enum_input,
3665 .vidioc_g_audio = radio_g_audio,
3666 .vidioc_s_tuner = radio_s_tuner,
3667 .vidioc_s_audio = radio_s_audio,
3668 .vidioc_s_input = radio_s_input,
3669 .vidioc_s_std = radio_s_std,
3670 .vidioc_queryctrl = radio_queryctrl,
3671 .vidioc_g_input = radio_g_input,
3672 .vidioc_g_ctrl = bttv_g_ctrl,
3673 .vidioc_s_ctrl = bttv_s_ctrl,
3674 .vidioc_g_frequency = bttv_g_frequency,
3675 .vidioc_s_frequency = bttv_s_frequency,
3678 static struct video_device radio_template = {
3679 .fops = &radio_fops,
3681 .ioctl_ops = &radio_ioctl_ops,
3684 /* ----------------------------------------------------------------------- */
3685 /* some debug code */
3687 static int bttv_risc_decode(u32 risc)
3689 static char *instr[16] = {
3690 [ BT848_RISC_WRITE >> 28 ] = "write",
3691 [ BT848_RISC_SKIP >> 28 ] = "skip",
3692 [ BT848_RISC_WRITEC >> 28 ] = "writec",
3693 [ BT848_RISC_JUMP >> 28 ] = "jump",
3694 [ BT848_RISC_SYNC >> 28 ] = "sync",
3695 [ BT848_RISC_WRITE123 >> 28 ] = "write123",
3696 [ BT848_RISC_SKIP123 >> 28 ] = "skip123",
3697 [ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
3699 static int incr[16] = {
3700 [ BT848_RISC_WRITE >> 28 ] = 2,
3701 [ BT848_RISC_JUMP >> 28 ] = 2,
3702 [ BT848_RISC_SYNC >> 28 ] = 2,
3703 [ BT848_RISC_WRITE123 >> 28 ] = 5,
3704 [ BT848_RISC_SKIP123 >> 28 ] = 2,
3705 [ BT848_RISC_WRITE1S23 >> 28 ] = 3,
3707 static char *bits[] = {
3708 "be0", "be1", "be2", "be3/resync",
3709 "set0", "set1", "set2", "set3",
3710 "clr0", "clr1", "clr2", "clr3",
3711 "irq", "res", "eol", "sol",
3715 printk("0x%08x [ %s", risc,
3716 instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
3717 for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
3718 if (risc & (1 << (i + 12)))
3719 printk(" %s",bits[i]);
3720 printk(" count=%d ]\n", risc & 0xfff);
3721 return incr[risc >> 28] ? incr[risc >> 28] : 1;
3724 static void bttv_risc_disasm(struct bttv *btv,
3725 struct btcx_riscmem *risc)
3729 printk("%s: risc disasm: %p [dma=0x%08lx]\n",
3730 btv->c.name, risc->cpu, (unsigned long)risc->dma);
3731 for (i = 0; i < (risc->size >> 2); i += n) {
3732 printk("%s: 0x%lx: ", btv->c.name,
3733 (unsigned long)(risc->dma + (i<<2)));
3734 n = bttv_risc_decode(le32_to_cpu(risc->cpu[i]));
3735 for (j = 1; j < n; j++)
3736 printk("%s: 0x%lx: 0x%08x [ arg #%d ]\n",
3737 btv->c.name, (unsigned long)(risc->dma + ((i+j)<<2)),
3739 if (0 == risc->cpu[i])
3744 static void bttv_print_riscaddr(struct bttv *btv)
3746 printk(" main: %08Lx\n",
3747 (unsigned long long)btv->main.dma);
3748 printk(" vbi : o=%08Lx e=%08Lx\n",
3749 btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
3750 btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
3751 printk(" cap : o=%08Lx e=%08Lx\n",
3752 btv->curr.top ? (unsigned long long)btv->curr.top->top.dma : 0,
3753 btv->curr.bottom ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
3754 printk(" scr : o=%08Lx e=%08Lx\n",
3755 btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
3756 btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
3757 bttv_risc_disasm(btv, &btv->main);
3760 /* ----------------------------------------------------------------------- */
3763 static char *irq_name[] = {
3764 "FMTCHG", // format change detected (525 vs. 625)
3765 "VSYNC", // vertical sync (new field)
3766 "HSYNC", // horizontal sync
3767 "OFLOW", // chroma/luma AGC overflow
3768 "HLOCK", // horizontal lock changed
3769 "VPRES", // video presence changed
3771 "I2CDONE", // hw irc operation finished
3772 "GPINT", // gpio port triggered irq
3774 "RISCI", // risc instruction triggered irq
3775 "FBUS", // pixel data fifo dropped data (high pci bus latencies)
3776 "FTRGT", // pixel data fifo overrun
3777 "FDSR", // fifo data stream resyncronisation
3778 "PPERR", // parity error (data transfer)
3779 "RIPERR", // parity error (read risc instructions)
3780 "PABORT", // pci abort
3781 "OCERR", // risc instruction error
3782 "SCERR", // syncronisation error
3785 static void bttv_print_irqbits(u32 print, u32 mark)
3790 for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
3791 if (print & (1 << i))
3792 printk(" %s",irq_name[i]);
3793 if (mark & (1 << i))
3798 static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
3800 printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
3802 (unsigned long)btv->main.dma,
3803 (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_VBI+1]),
3804 (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_FIELD+1]),
3807 if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) {
3808 printk("bttv%d: Oh, there (temporarely?) is no input signal. "
3809 "Ok, then this is harmless, don't worry ;)\n",
3813 printk("bttv%d: Uhm. Looks like we have unusual high IRQ latencies.\n",
3815 printk("bttv%d: Lets try to catch the culpit red-handed ...\n",
3821 bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set)
3823 struct bttv_buffer *item;
3825 memset(set,0,sizeof(*set));
3827 /* capture request ? */
3828 if (!list_empty(&btv->capture)) {
3830 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3831 if (V4L2_FIELD_HAS_TOP(item->vb.field))
3833 if (V4L2_FIELD_HAS_BOTTOM(item->vb.field))
3836 /* capture request for other field ? */
3837 if (!V4L2_FIELD_HAS_BOTH(item->vb.field) &&
3838 (item->vb.queue.next != &btv->capture)) {
3839 item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue);
3840 if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) {
3841 if (NULL == set->top &&
3842 V4L2_FIELD_TOP == item->vb.field) {
3845 if (NULL == set->bottom &&
3846 V4L2_FIELD_BOTTOM == item->vb.field) {
3849 if (NULL != set->top && NULL != set->bottom)
3855 /* screen overlay ? */
3856 if (NULL != btv->screen) {
3857 if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) {
3858 if (NULL == set->top && NULL == set->bottom) {
3859 set->top = btv->screen;
3860 set->bottom = btv->screen;
3863 if (V4L2_FIELD_TOP == btv->screen->vb.field &&
3865 set->top = btv->screen;
3867 if (V4L2_FIELD_BOTTOM == btv->screen->vb.field &&
3868 NULL == set->bottom) {
3869 set->bottom = btv->screen;
3874 dprintk("bttv%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
3875 btv->c.nr,set->top, set->bottom,
3876 btv->screen,set->frame_irq,set->top_irq);
3881 bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
3882 struct bttv_buffer_set *curr, unsigned int state)
3886 do_gettimeofday(&ts);
3888 if (wakeup->top == wakeup->bottom) {
3889 if (NULL != wakeup->top && curr->top != wakeup->top) {
3891 printk("bttv%d: wakeup: both=%p\n",btv->c.nr,wakeup->top);
3892 wakeup->top->vb.ts = ts;
3893 wakeup->top->vb.field_count = btv->field_count;
3894 wakeup->top->vb.state = state;
3895 wake_up(&wakeup->top->vb.done);
3898 if (NULL != wakeup->top && curr->top != wakeup->top) {
3900 printk("bttv%d: wakeup: top=%p\n",btv->c.nr,wakeup->top);
3901 wakeup->top->vb.ts = ts;
3902 wakeup->top->vb.field_count = btv->field_count;
3903 wakeup->top->vb.state = state;
3904 wake_up(&wakeup->top->vb.done);
3906 if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
3908 printk("bttv%d: wakeup: bottom=%p\n",btv->c.nr,wakeup->bottom);
3909 wakeup->bottom->vb.ts = ts;
3910 wakeup->bottom->vb.field_count = btv->field_count;
3911 wakeup->bottom->vb.state = state;
3912 wake_up(&wakeup->bottom->vb.done);
3918 bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
3926 do_gettimeofday(&ts);
3928 wakeup->vb.field_count = btv->field_count;
3929 wakeup->vb.state = state;
3930 wake_up(&wakeup->vb.done);
3933 static void bttv_irq_timeout(unsigned long data)
3935 struct bttv *btv = (struct bttv *)data;
3936 struct bttv_buffer_set old,new;
3937 struct bttv_buffer *ovbi;
3938 struct bttv_buffer *item;
3939 unsigned long flags;
3942 printk(KERN_INFO "bttv%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
3943 btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
3944 btread(BT848_RISC_COUNT));
3945 bttv_print_irqbits(btread(BT848_INT_STAT),0);
3949 spin_lock_irqsave(&btv->s_lock,flags);
3951 /* deactivate stuff */
3952 memset(&new,0,sizeof(new));
3958 bttv_buffer_activate_video(btv, &new);
3959 bttv_buffer_activate_vbi(btv, NULL);
3960 bttv_set_dma(btv, 0);
3963 bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_ERROR);
3964 bttv_irq_wakeup_vbi(btv, ovbi, VIDEOBUF_ERROR);
3966 /* cancel all outstanding capture / vbi requests */
3967 while (!list_empty(&btv->capture)) {
3968 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3969 list_del(&item->vb.queue);
3970 item->vb.state = VIDEOBUF_ERROR;
3971 wake_up(&item->vb.done);
3973 while (!list_empty(&btv->vcapture)) {
3974 item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3975 list_del(&item->vb.queue);
3976 item->vb.state = VIDEOBUF_ERROR;
3977 wake_up(&item->vb.done);
3981 spin_unlock_irqrestore(&btv->s_lock,flags);
3985 bttv_irq_wakeup_top(struct bttv *btv)
3987 struct bttv_buffer *wakeup = btv->curr.top;
3992 spin_lock(&btv->s_lock);
3993 btv->curr.top_irq = 0;
3994 btv->curr.top = NULL;
3995 bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
3997 do_gettimeofday(&wakeup->vb.ts);
3998 wakeup->vb.field_count = btv->field_count;
3999 wakeup->vb.state = VIDEOBUF_DONE;
4000 wake_up(&wakeup->vb.done);
4001 spin_unlock(&btv->s_lock);
4004 static inline int is_active(struct btcx_riscmem *risc, u32 rc)
4008 if (rc > risc->dma + risc->size)
4014 bttv_irq_switch_video(struct bttv *btv)
4016 struct bttv_buffer_set new;
4017 struct bttv_buffer_set old;
4020 spin_lock(&btv->s_lock);
4022 /* new buffer set */
4023 bttv_irq_next_video(btv, &new);
4024 rc = btread(BT848_RISC_COUNT);
4025 if ((btv->curr.top && is_active(&btv->curr.top->top, rc)) ||
4026 (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) {
4029 bttv_irq_debug_low_latency(btv, rc);
4030 spin_unlock(&btv->s_lock);
4037 btv->loop_irq &= ~1;
4038 bttv_buffer_activate_video(btv, &new);
4039 bttv_set_dma(btv, 0);
4042 if (UNSET != btv->new_input) {
4043 video_mux(btv,btv->new_input);
4044 btv->new_input = UNSET;
4047 /* wake up finished buffers */
4048 bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_DONE);
4049 spin_unlock(&btv->s_lock);
4053 bttv_irq_switch_vbi(struct bttv *btv)
4055 struct bttv_buffer *new = NULL;
4056 struct bttv_buffer *old;
4059 spin_lock(&btv->s_lock);
4061 if (!list_empty(&btv->vcapture))
4062 new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
4065 rc = btread(BT848_RISC_COUNT);
4066 if (NULL != old && (is_active(&old->top, rc) ||
4067 is_active(&old->bottom, rc))) {
4070 bttv_irq_debug_low_latency(btv, rc);
4071 spin_unlock(&btv->s_lock);
4077 btv->loop_irq &= ~4;
4078 bttv_buffer_activate_vbi(btv, new);
4079 bttv_set_dma(btv, 0);
4081 bttv_irq_wakeup_vbi(btv, old, VIDEOBUF_DONE);
4082 spin_unlock(&btv->s_lock);
4085 static irqreturn_t bttv_irq(int irq, void *dev_id)
4093 btv=(struct bttv *)dev_id;
4095 if (btv->custom_irq)
4096 handled = btv->custom_irq(btv);
4100 /* get/clear interrupt status bits */
4101 stat=btread(BT848_INT_STAT);
4102 astat=stat&btread(BT848_INT_MASK);
4106 btwrite(stat,BT848_INT_STAT);
4108 /* get device status bits */
4109 dstat=btread(BT848_DSTATUS);
4112 printk(KERN_DEBUG "bttv%d: irq loop=%d fc=%d "
4113 "riscs=%x, riscc=%08x, ",
4114 btv->c.nr, count, btv->field_count,
4115 stat>>28, btread(BT848_RISC_COUNT));
4116 bttv_print_irqbits(stat,astat);
4117 if (stat & BT848_INT_HLOCK)
4118 printk(" HLOC => %s", (dstat & BT848_DSTATUS_HLOC)
4120 if (stat & BT848_INT_VPRES)
4121 printk(" PRES => %s", (dstat & BT848_DSTATUS_PRES)
4123 if (stat & BT848_INT_FMTCHG)
4124 printk(" NUML => %s", (dstat & BT848_DSTATUS_NUML)
4129 if (astat&BT848_INT_VSYNC)
4132 if ((astat & BT848_INT_GPINT) && btv->remote) {
4133 wake_up(&btv->gpioq);
4134 bttv_input_irq(btv);
4137 if (astat & BT848_INT_I2CDONE) {
4138 btv->i2c_done = stat;
4139 wake_up(&btv->i2c_queue);
4142 if ((astat & BT848_INT_RISCI) && (stat & (4<<28)))
4143 bttv_irq_switch_vbi(btv);
4145 if ((astat & BT848_INT_RISCI) && (stat & (2<<28)))
4146 bttv_irq_wakeup_top(btv);
4148 if ((astat & BT848_INT_RISCI) && (stat & (1<<28)))
4149 bttv_irq_switch_video(btv);
4151 if ((astat & BT848_INT_HLOCK) && btv->opt_automute)
4152 audio_mute(btv, btv->mute); /* trigger automute */
4154 if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
4155 printk(KERN_INFO "bttv%d: %s%s @ %08x,",btv->c.nr,
4156 (astat & BT848_INT_SCERR) ? "SCERR" : "",
4157 (astat & BT848_INT_OCERR) ? "OCERR" : "",
4158 btread(BT848_RISC_COUNT));
4159 bttv_print_irqbits(stat,astat);
4162 bttv_print_riscaddr(btv);
4164 if (fdsr && astat & BT848_INT_FDSR) {
4165 printk(KERN_INFO "bttv%d: FDSR @ %08x\n",
4166 btv->c.nr,btread(BT848_RISC_COUNT));
4168 bttv_print_riscaddr(btv);
4174 if (count > 8 || !(astat & BT848_INT_GPINT)) {
4175 btwrite(0, BT848_INT_MASK);
4178 "bttv%d: IRQ lockup, cleared int mask [", btv->c.nr);
4181 "bttv%d: IRQ lockup, clearing GPINT from int mask [", btv->c.nr);
4183 btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT),
4187 bttv_print_irqbits(stat,astat);
4195 return IRQ_RETVAL(handled);
4199 /* ----------------------------------------------------------------------- */
4200 /* initialitation */
4202 static struct video_device *vdev_init(struct bttv *btv,
4203 const struct video_device *template,
4204 const char *type_name)
4206 struct video_device *vfd;
4208 vfd = video_device_alloc();
4213 vfd->parent = &btv->c.pci->dev;
4214 vfd->release = video_device_release;
4215 vfd->debug = bttv_debug;
4216 snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
4217 btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
4218 type_name, bttv_tvcards[btv->c.type].name);
4222 static void bttv_unregister_video(struct bttv *btv)
4224 if (btv->video_dev) {
4225 if (-1 != btv->video_dev->minor)
4226 video_unregister_device(btv->video_dev);
4228 video_device_release(btv->video_dev);
4229 btv->video_dev = NULL;
4232 if (-1 != btv->vbi_dev->minor)
4233 video_unregister_device(btv->vbi_dev);
4235 video_device_release(btv->vbi_dev);
4236 btv->vbi_dev = NULL;
4238 if (btv->radio_dev) {
4239 if (-1 != btv->radio_dev->minor)
4240 video_unregister_device(btv->radio_dev);
4242 video_device_release(btv->radio_dev);
4243 btv->radio_dev = NULL;
4247 /* register video4linux devices */
4248 static int __devinit bttv_register_video(struct bttv *btv)
4251 printk("bttv: Overlay support disabled.\n");
4254 btv->video_dev = vdev_init(btv, &bttv_video_template, "video");
4256 if (NULL == btv->video_dev)
4258 if (video_register_device(btv->video_dev, VFL_TYPE_GRABBER,
4259 video_nr[btv->c.nr]) < 0)
4261 printk(KERN_INFO "bttv%d: registered device video%d\n",
4262 btv->c.nr,btv->video_dev->minor & 0x1f);
4263 if (device_create_file(&btv->video_dev->dev,
4264 &dev_attr_card)<0) {
4265 printk(KERN_ERR "bttv%d: device_create_file 'card' "
4266 "failed\n", btv->c.nr);
4271 btv->vbi_dev = vdev_init(btv, &bttv_video_template, "vbi");
4273 if (NULL == btv->vbi_dev)
4275 if (video_register_device(btv->vbi_dev, VFL_TYPE_VBI,
4276 vbi_nr[btv->c.nr]) < 0)
4278 printk(KERN_INFO "bttv%d: registered device vbi%d\n",
4279 btv->c.nr,btv->vbi_dev->minor & 0x1f);
4281 if (!btv->has_radio)
4284 btv->radio_dev = vdev_init(btv, &radio_template, "radio");
4285 if (NULL == btv->radio_dev)
4287 if (video_register_device(btv->radio_dev, VFL_TYPE_RADIO,
4288 radio_nr[btv->c.nr]) < 0)
4290 printk(KERN_INFO "bttv%d: registered device radio%d\n",
4291 btv->c.nr,btv->radio_dev->minor & 0x1f);
4297 bttv_unregister_video(btv);
4302 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
4303 /* response on cards with no firmware is not enabled by OF */
4304 static void pci_set_command(struct pci_dev *dev)
4306 #if defined(__powerpc__)
4309 pci_read_config_dword(dev, PCI_COMMAND, &cmd);
4310 cmd = (cmd | PCI_COMMAND_MEMORY );
4311 pci_write_config_dword(dev, PCI_COMMAND, cmd);
4315 static int __devinit bttv_probe(struct pci_dev *dev,
4316 const struct pci_device_id *pci_id)
4322 if (bttv_num == BTTV_MAX)
4324 printk(KERN_INFO "bttv: Bt8xx card found (%d).\n", bttv_num);
4325 btv=&bttvs[bttv_num];
4326 memset(btv,0,sizeof(*btv));
4327 btv->c.nr = bttv_num;
4328 sprintf(btv->c.name,"bttv%d",btv->c.nr);
4330 /* initialize structs / fill in defaults */
4331 mutex_init(&btv->lock);
4332 spin_lock_init(&btv->s_lock);
4333 spin_lock_init(&btv->gpio_lock);
4334 init_waitqueue_head(&btv->gpioq);
4335 init_waitqueue_head(&btv->i2c_queue);
4336 INIT_LIST_HEAD(&btv->c.subs);
4337 INIT_LIST_HEAD(&btv->capture);
4338 INIT_LIST_HEAD(&btv->vcapture);
4339 v4l2_prio_init(&btv->prio);
4341 init_timer(&btv->timeout);
4342 btv->timeout.function = bttv_irq_timeout;
4343 btv->timeout.data = (unsigned long)btv;
4346 btv->tuner_type = UNSET;
4347 btv->new_input = UNSET;
4348 btv->has_radio=radio[btv->c.nr];
4350 /* pci stuff (init, get irq/mmio, ... */
4352 btv->id = dev->device;
4353 if (pci_enable_device(dev)) {
4354 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4358 if (pci_set_dma_mask(dev, DMA_32BIT_MASK)) {
4359 printk(KERN_WARNING "bttv%d: No suitable DMA available.\n",
4363 if (!request_mem_region(pci_resource_start(dev,0),
4364 pci_resource_len(dev,0),
4366 printk(KERN_WARNING "bttv%d: can't request iomem (0x%llx).\n",
4368 (unsigned long long)pci_resource_start(dev,0));
4371 pci_set_master(dev);
4372 pci_set_command(dev);
4373 pci_set_drvdata(dev,btv);
4375 pci_read_config_byte(dev, PCI_CLASS_REVISION, &btv->revision);
4376 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
4377 printk(KERN_INFO "bttv%d: Bt%d (rev %d) at %s, ",
4378 bttv_num,btv->id, btv->revision, pci_name(dev));
4379 printk("irq: %d, latency: %d, mmio: 0x%llx\n",
4380 btv->c.pci->irq, lat,
4381 (unsigned long long)pci_resource_start(dev,0));
4384 btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), 0x1000);
4385 if (NULL == btv->bt848_mmio) {
4386 printk("bttv%d: ioremap() failed\n", btv->c.nr);
4394 /* disable irqs, register irq handler */
4395 btwrite(0, BT848_INT_MASK);
4396 result = request_irq(btv->c.pci->irq, bttv_irq,
4397 IRQF_SHARED | IRQF_DISABLED,btv->c.name,(void *)btv);
4399 printk(KERN_ERR "bttv%d: can't get IRQ %d\n",
4400 bttv_num,btv->c.pci->irq);
4404 if (0 != bttv_handle_chipset(btv)) {
4409 /* init options from insmod args */
4410 btv->opt_combfilter = combfilter;
4411 btv->opt_lumafilter = lumafilter;
4412 btv->opt_automute = automute;
4413 btv->opt_chroma_agc = chroma_agc;
4414 btv->opt_adc_crush = adc_crush;
4415 btv->opt_vcr_hack = vcr_hack;
4416 btv->opt_whitecrush_upper = whitecrush_upper;
4417 btv->opt_whitecrush_lower = whitecrush_lower;
4418 btv->opt_uv_ratio = uv_ratio;
4419 btv->opt_full_luma_range = full_luma_range;
4420 btv->opt_coring = coring;
4422 /* fill struct bttv with some useful defaults */
4423 btv->init.btv = btv;
4424 btv->init.ov.w.width = 320;
4425 btv->init.ov.w.height = 240;
4426 btv->init.fmt = format_by_fourcc(V4L2_PIX_FMT_BGR24);
4427 btv->init.width = 320;
4428 btv->init.height = 240;
4431 /* initialize hardware */
4433 bttv_gpio_tracking(btv,"pre-init");
4435 bttv_risc_init_main(btv);
4439 btwrite(0x00, BT848_GPIO_REG_INP);
4440 btwrite(0x00, BT848_GPIO_OUT_EN);
4442 bttv_gpio_tracking(btv,"init");
4444 /* needs to be done before i2c is registered */
4445 bttv_init_card1(btv);
4447 /* register i2c + gpio */
4450 /* some card-specific stuff (needs working i2c) */
4451 bttv_init_card2(btv);
4454 /* register video4linux + input */
4455 if (!bttv_tvcards[btv->c.type].no_video) {
4456 bttv_register_video(btv);
4457 bt848_bright(btv,32768);
4458 bt848_contrast(btv,32768);
4459 bt848_hue(btv,32768);
4460 bt848_sat(btv,32768);
4462 set_input(btv, 0, btv->tvnorm);
4463 bttv_crop_reset(&btv->crop[0], btv->tvnorm);
4464 btv->crop[1] = btv->crop[0]; /* current = default */
4465 disclaim_vbi_lines(btv);
4466 disclaim_video_lines(btv);
4469 /* add subdevices and autoload dvb-bt8xx if needed */
4470 if (bttv_tvcards[btv->c.type].has_dvb) {
4471 bttv_sub_add_device(&btv->c, "dvb");
4472 request_modules(btv);
4475 bttv_input_init(btv);
4477 /* everything is fine */
4482 free_irq(btv->c.pci->irq,btv);
4485 if (btv->bt848_mmio)
4486 iounmap(btv->bt848_mmio);
4487 release_mem_region(pci_resource_start(btv->c.pci,0),
4488 pci_resource_len(btv->c.pci,0));
4489 pci_set_drvdata(dev,NULL);
4493 static void __devexit bttv_remove(struct pci_dev *pci_dev)
4495 struct bttv *btv = pci_get_drvdata(pci_dev);
4498 printk("bttv%d: unloading\n",btv->c.nr);
4500 /* shutdown everything (DMA+IRQs) */
4501 btand(~15, BT848_GPIO_DMA_CTL);
4502 btwrite(0, BT848_INT_MASK);
4503 btwrite(~0x0, BT848_INT_STAT);
4504 btwrite(0x0, BT848_GPIO_OUT_EN);
4506 bttv_gpio_tracking(btv,"cleanup");
4508 /* tell gpio modules we are leaving ... */
4510 wake_up(&btv->gpioq);
4511 bttv_input_fini(btv);
4512 bttv_sub_del_devices(&btv->c);
4514 /* unregister i2c_bus + input */
4517 /* unregister video4linux */
4518 bttv_unregister_video(btv);
4520 /* free allocated memory */
4521 btcx_riscmem_free(btv->c.pci,&btv->main);
4523 /* free ressources */
4524 free_irq(btv->c.pci->irq,btv);
4525 iounmap(btv->bt848_mmio);
4526 release_mem_region(pci_resource_start(btv->c.pci,0),
4527 pci_resource_len(btv->c.pci,0));
4529 pci_set_drvdata(pci_dev, NULL);
4534 static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state)
4536 struct bttv *btv = pci_get_drvdata(pci_dev);
4537 struct bttv_buffer_set idle;
4538 unsigned long flags;
4540 dprintk("bttv%d: suspend %d\n", btv->c.nr, state.event);
4542 /* stop dma + irqs */
4543 spin_lock_irqsave(&btv->s_lock,flags);
4544 memset(&idle, 0, sizeof(idle));
4545 btv->state.video = btv->curr;
4546 btv->state.vbi = btv->cvbi;
4547 btv->state.loop_irq = btv->loop_irq;
4550 bttv_buffer_activate_video(btv, &idle);
4551 bttv_buffer_activate_vbi(btv, NULL);
4552 bttv_set_dma(btv, 0);
4553 btwrite(0, BT848_INT_MASK);
4554 spin_unlock_irqrestore(&btv->s_lock,flags);
4556 /* save bt878 state */
4557 btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
4558 btv->state.gpio_data = gpio_read();
4560 /* save pci state */
4561 pci_save_state(pci_dev);
4562 if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
4563 pci_disable_device(pci_dev);
4564 btv->state.disabled = 1;
4569 static int bttv_resume(struct pci_dev *pci_dev)
4571 struct bttv *btv = pci_get_drvdata(pci_dev);
4572 unsigned long flags;
4575 dprintk("bttv%d: resume\n", btv->c.nr);
4577 /* restore pci state */
4578 if (btv->state.disabled) {
4579 err=pci_enable_device(pci_dev);
4581 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4585 btv->state.disabled = 0;
4587 err=pci_set_power_state(pci_dev, PCI_D0);
4589 pci_disable_device(pci_dev);
4590 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4592 btv->state.disabled = 1;
4596 pci_restore_state(pci_dev);
4598 /* restore bt878 state */
4599 bttv_reinit_bt848(btv);
4600 gpio_inout(0xffffff, btv->state.gpio_enable);
4601 gpio_write(btv->state.gpio_data);
4604 spin_lock_irqsave(&btv->s_lock,flags);
4605 btv->curr = btv->state.video;
4606 btv->cvbi = btv->state.vbi;
4607 btv->loop_irq = btv->state.loop_irq;
4608 bttv_buffer_activate_video(btv, &btv->curr);
4609 bttv_buffer_activate_vbi(btv, btv->cvbi);
4610 bttv_set_dma(btv, 0);
4611 spin_unlock_irqrestore(&btv->s_lock,flags);
4616 static struct pci_device_id bttv_pci_tbl[] = {
4617 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848,
4618 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4619 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849,
4620 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4621 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878,
4622 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4623 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879,
4624 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4628 MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
4630 static struct pci_driver bttv_pci_driver = {
4632 .id_table = bttv_pci_tbl,
4633 .probe = bttv_probe,
4634 .remove = __devexit_p(bttv_remove),
4636 .suspend = bttv_suspend,
4637 .resume = bttv_resume,
4641 static int __init bttv_init_module(void)
4647 printk(KERN_INFO "bttv: driver version %d.%d.%d loaded\n",
4648 (BTTV_VERSION_CODE >> 16) & 0xff,
4649 (BTTV_VERSION_CODE >> 8) & 0xff,
4650 BTTV_VERSION_CODE & 0xff);
4652 printk(KERN_INFO "bttv: snapshot date %04d-%02d-%02d\n",
4653 SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
4655 if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
4657 if (gbufsize < 0 || gbufsize > BTTV_MAX_FBUF)
4658 gbufsize = BTTV_MAX_FBUF;
4659 gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
4661 printk(KERN_INFO "bttv: using %d buffers with %dk (%d pages) each for capture\n",
4662 gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
4664 bttv_check_chipset();
4666 ret = bus_register(&bttv_sub_bus_type);
4668 printk(KERN_WARNING "bttv: bus_register error: %d\n", ret);
4671 ret = pci_register_driver(&bttv_pci_driver);
4673 bus_unregister(&bttv_sub_bus_type);
4678 static void __exit bttv_cleanup_module(void)
4680 pci_unregister_driver(&bttv_pci_driver);
4681 bus_unregister(&bttv_sub_bus_type);
4684 module_init(bttv_init_module);
4685 module_exit(bttv_cleanup_module);