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 = -1;
80 static int radio_nr = -1;
81 static int vbi_nr = -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(video_nr, int, 0444);
112 module_param(radio_nr, int, 0444);
113 module_param(vbi_nr, int, 0444);
114 module_param(gbuffers, int, 0444);
115 module_param(gbufsize, int, 0444);
116 module_param(reset_crop, int, 0444);
118 module_param(v4l2, int, 0644);
119 module_param(bigendian, int, 0644);
120 module_param(irq_iswitch, int, 0644);
121 module_param(combfilter, int, 0444);
122 module_param(lumafilter, int, 0444);
123 module_param(automute, int, 0444);
124 module_param(chroma_agc, int, 0444);
125 module_param(adc_crush, int, 0444);
126 module_param(whitecrush_upper, int, 0444);
127 module_param(whitecrush_lower, int, 0444);
128 module_param(vcr_hack, int, 0444);
129 module_param(uv_ratio, int, 0444);
130 module_param(full_luma_range, int, 0444);
131 module_param(coring, int, 0444);
133 module_param_array(radio, 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)");
156 MODULE_DESCRIPTION("bttv - v4l/v4l2 driver module for bt848/878 based cards");
157 MODULE_AUTHOR("Ralph Metzler & Marcus Metzler & Gerd Knorr");
158 MODULE_LICENSE("GPL");
160 /* ----------------------------------------------------------------------- */
163 static ssize_t show_card(struct device *cd,
164 struct device_attribute *attr, char *buf)
166 struct video_device *vfd = container_of(cd, struct video_device, dev);
167 struct bttv *btv = dev_get_drvdata(vfd->parent);
168 return sprintf(buf, "%d\n", btv ? btv->c.type : UNSET);
170 static DEVICE_ATTR(card, S_IRUGO, show_card, NULL);
172 /* ----------------------------------------------------------------------- */
173 /* dvb auto-load setup */
174 #if defined(CONFIG_MODULES) && defined(MODULE)
175 static void request_module_async(struct work_struct *work)
177 request_module("dvb-bt8xx");
180 static void request_modules(struct bttv *dev)
182 INIT_WORK(&dev->request_module_wk, request_module_async);
183 schedule_work(&dev->request_module_wk);
186 #define request_modules(dev)
187 #endif /* CONFIG_MODULES */
190 /* ----------------------------------------------------------------------- */
193 /* special timing tables from conexant... */
194 static u8 SRAM_Table[][60] =
196 /* PAL digital input over GPIO[7:0] */
198 45, // 45 bytes following
199 0x36,0x11,0x01,0x00,0x90,0x02,0x05,0x10,0x04,0x16,
200 0x12,0x05,0x11,0x00,0x04,0x12,0xC0,0x00,0x31,0x00,
201 0x06,0x51,0x08,0x03,0x89,0x08,0x07,0xC0,0x44,0x00,
202 0x81,0x01,0x01,0xA9,0x0D,0x02,0x02,0x50,0x03,0x37,
203 0x37,0x00,0xAF,0x21,0x00
205 /* NTSC digital input over GPIO[7:0] */
207 51, // 51 bytes following
208 0x0C,0xC0,0x00,0x00,0x90,0x02,0x03,0x10,0x03,0x06,
209 0x10,0x04,0x12,0x12,0x05,0x02,0x13,0x04,0x19,0x00,
210 0x04,0x39,0x00,0x06,0x59,0x08,0x03,0x83,0x08,0x07,
211 0x03,0x50,0x00,0xC0,0x40,0x00,0x86,0x01,0x01,0xA6,
212 0x0D,0x02,0x03,0x11,0x01,0x05,0x37,0x00,0xAC,0x21,
215 // TGB_NTSC392 // quartzsight
216 // This table has been modified to be used for Fusion Rev D
218 0x2A, // size of table = 42
219 0x06, 0x08, 0x04, 0x0a, 0xc0, 0x00, 0x18, 0x08, 0x03, 0x24,
220 0x08, 0x07, 0x02, 0x90, 0x02, 0x08, 0x10, 0x04, 0x0c, 0x10,
221 0x05, 0x2c, 0x11, 0x04, 0x55, 0x48, 0x00, 0x05, 0x50, 0x00,
222 0xbf, 0x0c, 0x02, 0x2f, 0x3d, 0x00, 0x2f, 0x3f, 0x00, 0xc3,
227 /* minhdelayx1 first video pixel we can capture on a line and
228 hdelayx1 start of active video, both relative to rising edge of
229 /HRESET pulse (0H) in 1 / fCLKx1.
230 swidth width of active video and
231 totalwidth total line width, both in 1 / fCLKx1.
232 sqwidth total line width in square pixels.
233 vdelay start of active video in 2 * field lines relative to
234 trailing edge of /VRESET pulse (VDELAY register).
235 sheight height of active video in 2 * field lines.
236 videostart0 ITU-R frame line number of the line corresponding
237 to vdelay in the first field. */
238 #define CROPCAP(minhdelayx1, hdelayx1, swidth, totalwidth, sqwidth, \
239 vdelay, sheight, videostart0) \
240 .cropcap.bounds.left = minhdelayx1, \
241 /* * 2 because vertically we count field lines times two, */ \
242 /* e.g. 23 * 2 to 23 * 2 + 576 in PAL-BGHI defrect. */ \
243 .cropcap.bounds.top = (videostart0) * 2 - (vdelay) + MIN_VDELAY, \
244 /* 4 is a safety margin at the end of the line. */ \
245 .cropcap.bounds.width = (totalwidth) - (minhdelayx1) - 4, \
246 .cropcap.bounds.height = (sheight) + (vdelay) - MIN_VDELAY, \
247 .cropcap.defrect.left = hdelayx1, \
248 .cropcap.defrect.top = (videostart0) * 2, \
249 .cropcap.defrect.width = swidth, \
250 .cropcap.defrect.height = sheight, \
251 .cropcap.pixelaspect.numerator = totalwidth, \
252 .cropcap.pixelaspect.denominator = sqwidth,
254 const struct bttv_tvnorm bttv_tvnorms[] = {
256 /* max. active video is actually 922, but 924 is divisible by 4 and 3! */
257 /* actually, max active PAL with HSCALE=0 is 948, NTSC is 768 - nil */
259 .v4l2_id = V4L2_STD_PAL,
267 .iform = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
268 .scaledtwidth = 1135,
272 .vbipack = 255, /* min (2048 / 4, 0x1ff) & 0xff */
274 /* ITU-R frame line number of the first VBI line
275 we can capture, of the first and second field.
276 The last line is determined by cropcap.bounds. */
277 .vbistart = { 7, 320 },
278 CROPCAP(/* minhdelayx1 */ 68,
280 /* Should be (768 * 1135 + 944 / 2) / 944.
281 cropcap.defrect is used for image width
282 checks, so we keep the old value 924. */
284 /* totalwidth */ 1135,
288 /* videostart0 */ 23)
289 /* bt878 (and bt848?) can capture another
290 line below active video. */
291 .cropcap.bounds.height = (576 + 2) + 0x20 - 2,
293 .v4l2_id = V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR,
301 .iform = (BT848_IFORM_NTSC|BT848_IFORM_XT0),
306 .vbipack = 144, /* min (1600 / 4, 0x1ff) & 0xff */
308 .vbistart = { 10, 273 },
309 CROPCAP(/* minhdelayx1 */ 68,
311 /* Should be (640 * 910 + 780 / 2) / 780? */
313 /* totalwidth */ 910,
317 /* videostart0 */ 23)
319 .v4l2_id = V4L2_STD_SECAM,
327 .iform = (BT848_IFORM_SECAM|BT848_IFORM_XT1),
328 .scaledtwidth = 1135,
333 .sram = 0, /* like PAL, correct? */
334 .vbistart = { 7, 320 },
335 CROPCAP(/* minhdelayx1 */ 68,
338 /* totalwidth */ 1135,
342 /* videostart0 */ 23)
344 .v4l2_id = V4L2_STD_PAL_Nc,
352 .iform = (BT848_IFORM_PAL_NC|BT848_IFORM_XT0),
359 .vbistart = { 7, 320 },
360 CROPCAP(/* minhdelayx1 */ 68,
362 /* swidth */ (640 * 910 + 780 / 2) / 780,
363 /* totalwidth */ 910,
367 /* videostart0 */ 23)
369 .v4l2_id = V4L2_STD_PAL_M,
377 .iform = (BT848_IFORM_PAL_M|BT848_IFORM_XT0),
384 .vbistart = { 10, 273 },
385 CROPCAP(/* minhdelayx1 */ 68,
387 /* swidth */ (640 * 910 + 780 / 2) / 780,
388 /* totalwidth */ 910,
392 /* videostart0 */ 23)
394 .v4l2_id = V4L2_STD_PAL_N,
402 .iform = (BT848_IFORM_PAL_N|BT848_IFORM_XT1),
409 .vbistart = { 7, 320 },
410 CROPCAP(/* minhdelayx1 */ 68,
412 /* swidth */ (768 * 1135 + 944 / 2) / 944,
413 /* totalwidth */ 1135,
417 /* videostart0 */ 23)
419 .v4l2_id = V4L2_STD_NTSC_M_JP,
427 .iform = (BT848_IFORM_NTSC_J|BT848_IFORM_XT0),
434 .vbistart = { 10, 273 },
435 CROPCAP(/* minhdelayx1 */ 68,
437 /* swidth */ (640 * 910 + 780 / 2) / 780,
438 /* totalwidth */ 910,
442 /* videostart0 */ 23)
444 /* that one hopefully works with the strange timing
445 * which video recorders produce when playing a NTSC
446 * tape on a PAL TV ... */
447 .v4l2_id = V4L2_STD_PAL_60,
455 .iform = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
456 .scaledtwidth = 1135,
463 .vbistart = { 10, 273 },
464 CROPCAP(/* minhdelayx1 */ 68,
467 /* totalwidth */ 1135,
471 /* videostart0 */ 23)
474 static const unsigned int BTTV_TVNORMS = ARRAY_SIZE(bttv_tvnorms);
476 /* ----------------------------------------------------------------------- */
478 packed pixel formats must come first */
479 static const struct bttv_format formats[] = {
481 .name = "8 bpp, gray",
482 .fourcc = V4L2_PIX_FMT_GREY,
483 .btformat = BT848_COLOR_FMT_Y8,
485 .flags = FORMAT_FLAGS_PACKED,
487 .name = "8 bpp, dithered color",
488 .fourcc = V4L2_PIX_FMT_HI240,
489 .btformat = BT848_COLOR_FMT_RGB8,
491 .flags = FORMAT_FLAGS_PACKED | FORMAT_FLAGS_DITHER,
493 .name = "15 bpp RGB, le",
494 .fourcc = V4L2_PIX_FMT_RGB555,
495 .btformat = BT848_COLOR_FMT_RGB15,
497 .flags = FORMAT_FLAGS_PACKED,
499 .name = "15 bpp RGB, be",
500 .fourcc = V4L2_PIX_FMT_RGB555X,
501 .btformat = BT848_COLOR_FMT_RGB15,
502 .btswap = 0x03, /* byteswap */
504 .flags = FORMAT_FLAGS_PACKED,
506 .name = "16 bpp RGB, le",
507 .fourcc = V4L2_PIX_FMT_RGB565,
508 .btformat = BT848_COLOR_FMT_RGB16,
510 .flags = FORMAT_FLAGS_PACKED,
512 .name = "16 bpp RGB, be",
513 .fourcc = V4L2_PIX_FMT_RGB565X,
514 .btformat = BT848_COLOR_FMT_RGB16,
515 .btswap = 0x03, /* byteswap */
517 .flags = FORMAT_FLAGS_PACKED,
519 .name = "24 bpp RGB, le",
520 .fourcc = V4L2_PIX_FMT_BGR24,
521 .btformat = BT848_COLOR_FMT_RGB24,
523 .flags = FORMAT_FLAGS_PACKED,
525 .name = "32 bpp RGB, le",
526 .fourcc = V4L2_PIX_FMT_BGR32,
527 .btformat = BT848_COLOR_FMT_RGB32,
529 .flags = FORMAT_FLAGS_PACKED,
531 .name = "32 bpp RGB, be",
532 .fourcc = V4L2_PIX_FMT_RGB32,
533 .btformat = BT848_COLOR_FMT_RGB32,
534 .btswap = 0x0f, /* byte+word swap */
536 .flags = FORMAT_FLAGS_PACKED,
538 .name = "4:2:2, packed, YUYV",
539 .fourcc = V4L2_PIX_FMT_YUYV,
540 .btformat = BT848_COLOR_FMT_YUY2,
542 .flags = FORMAT_FLAGS_PACKED,
544 .name = "4:2:2, packed, YUYV",
545 .fourcc = V4L2_PIX_FMT_YUYV,
546 .btformat = BT848_COLOR_FMT_YUY2,
548 .flags = FORMAT_FLAGS_PACKED,
550 .name = "4:2:2, packed, UYVY",
551 .fourcc = V4L2_PIX_FMT_UYVY,
552 .btformat = BT848_COLOR_FMT_YUY2,
553 .btswap = 0x03, /* byteswap */
555 .flags = FORMAT_FLAGS_PACKED,
557 .name = "4:2:2, planar, Y-Cb-Cr",
558 .fourcc = V4L2_PIX_FMT_YUV422P,
559 .btformat = BT848_COLOR_FMT_YCrCb422,
561 .flags = FORMAT_FLAGS_PLANAR,
565 .name = "4:2:0, planar, Y-Cb-Cr",
566 .fourcc = V4L2_PIX_FMT_YUV420,
567 .btformat = BT848_COLOR_FMT_YCrCb422,
569 .flags = FORMAT_FLAGS_PLANAR,
573 .name = "4:2:0, planar, Y-Cr-Cb",
574 .fourcc = V4L2_PIX_FMT_YVU420,
575 .btformat = BT848_COLOR_FMT_YCrCb422,
577 .flags = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
581 .name = "4:1:1, planar, Y-Cb-Cr",
582 .fourcc = V4L2_PIX_FMT_YUV411P,
583 .btformat = BT848_COLOR_FMT_YCrCb411,
585 .flags = FORMAT_FLAGS_PLANAR,
589 .name = "4:1:0, planar, Y-Cb-Cr",
590 .fourcc = V4L2_PIX_FMT_YUV410,
591 .btformat = BT848_COLOR_FMT_YCrCb411,
593 .flags = FORMAT_FLAGS_PLANAR,
597 .name = "4:1:0, planar, Y-Cr-Cb",
598 .fourcc = V4L2_PIX_FMT_YVU410,
599 .btformat = BT848_COLOR_FMT_YCrCb411,
601 .flags = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
605 .name = "raw scanlines",
607 .btformat = BT848_COLOR_FMT_RAW,
609 .flags = FORMAT_FLAGS_RAW,
612 static const unsigned int FORMATS = ARRAY_SIZE(formats);
614 /* ----------------------------------------------------------------------- */
616 #define V4L2_CID_PRIVATE_CHROMA_AGC (V4L2_CID_PRIVATE_BASE + 0)
617 #define V4L2_CID_PRIVATE_COMBFILTER (V4L2_CID_PRIVATE_BASE + 1)
618 #define V4L2_CID_PRIVATE_AUTOMUTE (V4L2_CID_PRIVATE_BASE + 2)
619 #define V4L2_CID_PRIVATE_LUMAFILTER (V4L2_CID_PRIVATE_BASE + 3)
620 #define V4L2_CID_PRIVATE_AGC_CRUSH (V4L2_CID_PRIVATE_BASE + 4)
621 #define V4L2_CID_PRIVATE_VCR_HACK (V4L2_CID_PRIVATE_BASE + 5)
622 #define V4L2_CID_PRIVATE_WHITECRUSH_UPPER (V4L2_CID_PRIVATE_BASE + 6)
623 #define V4L2_CID_PRIVATE_WHITECRUSH_LOWER (V4L2_CID_PRIVATE_BASE + 7)
624 #define V4L2_CID_PRIVATE_UV_RATIO (V4L2_CID_PRIVATE_BASE + 8)
625 #define V4L2_CID_PRIVATE_FULL_LUMA_RANGE (V4L2_CID_PRIVATE_BASE + 9)
626 #define V4L2_CID_PRIVATE_CORING (V4L2_CID_PRIVATE_BASE + 10)
627 #define V4L2_CID_PRIVATE_LASTP1 (V4L2_CID_PRIVATE_BASE + 11)
629 static const struct v4l2_queryctrl no_ctl = {
631 .flags = V4L2_CTRL_FLAG_DISABLED,
633 static const struct v4l2_queryctrl bttv_ctls[] = {
636 .id = V4L2_CID_BRIGHTNESS,
637 .name = "Brightness",
641 .default_value = 32768,
642 .type = V4L2_CTRL_TYPE_INTEGER,
644 .id = V4L2_CID_CONTRAST,
649 .default_value = 32768,
650 .type = V4L2_CTRL_TYPE_INTEGER,
652 .id = V4L2_CID_SATURATION,
653 .name = "Saturation",
657 .default_value = 32768,
658 .type = V4L2_CTRL_TYPE_INTEGER,
665 .default_value = 32768,
666 .type = V4L2_CTRL_TYPE_INTEGER,
670 .id = V4L2_CID_AUDIO_MUTE,
674 .type = V4L2_CTRL_TYPE_BOOLEAN,
676 .id = V4L2_CID_AUDIO_VOLUME,
681 .default_value = 65535,
682 .type = V4L2_CTRL_TYPE_INTEGER,
684 .id = V4L2_CID_AUDIO_BALANCE,
689 .default_value = 32768,
690 .type = V4L2_CTRL_TYPE_INTEGER,
692 .id = V4L2_CID_AUDIO_BASS,
697 .default_value = 32768,
698 .type = V4L2_CTRL_TYPE_INTEGER,
700 .id = V4L2_CID_AUDIO_TREBLE,
705 .default_value = 32768,
706 .type = V4L2_CTRL_TYPE_INTEGER,
708 /* --- private --- */
710 .id = V4L2_CID_PRIVATE_CHROMA_AGC,
711 .name = "chroma agc",
714 .type = V4L2_CTRL_TYPE_BOOLEAN,
716 .id = V4L2_CID_PRIVATE_COMBFILTER,
717 .name = "combfilter",
720 .type = V4L2_CTRL_TYPE_BOOLEAN,
722 .id = V4L2_CID_PRIVATE_AUTOMUTE,
726 .type = V4L2_CTRL_TYPE_BOOLEAN,
728 .id = V4L2_CID_PRIVATE_LUMAFILTER,
729 .name = "luma decimation filter",
732 .type = V4L2_CTRL_TYPE_BOOLEAN,
734 .id = V4L2_CID_PRIVATE_AGC_CRUSH,
738 .type = V4L2_CTRL_TYPE_BOOLEAN,
740 .id = V4L2_CID_PRIVATE_VCR_HACK,
744 .type = V4L2_CTRL_TYPE_BOOLEAN,
746 .id = V4L2_CID_PRIVATE_WHITECRUSH_UPPER,
747 .name = "whitecrush upper",
751 .default_value = 0xCF,
752 .type = V4L2_CTRL_TYPE_INTEGER,
754 .id = V4L2_CID_PRIVATE_WHITECRUSH_LOWER,
755 .name = "whitecrush lower",
759 .default_value = 0x7F,
760 .type = V4L2_CTRL_TYPE_INTEGER,
762 .id = V4L2_CID_PRIVATE_UV_RATIO,
768 .type = V4L2_CTRL_TYPE_INTEGER,
770 .id = V4L2_CID_PRIVATE_FULL_LUMA_RANGE,
771 .name = "full luma range",
774 .type = V4L2_CTRL_TYPE_BOOLEAN,
776 .id = V4L2_CID_PRIVATE_CORING,
782 .type = V4L2_CTRL_TYPE_INTEGER,
789 static const struct v4l2_queryctrl *ctrl_by_id(int id)
793 for (i = 0; i < ARRAY_SIZE(bttv_ctls); i++)
794 if (bttv_ctls[i].id == id)
800 /* ----------------------------------------------------------------------- */
801 /* resource management */
804 RESOURCE_ allocated by freed by
806 VIDEO_READ bttv_read 1) bttv_read 2)
808 VIDEO_STREAM VIDIOC_STREAMON VIDIOC_STREAMOFF
809 VIDIOC_QBUF 1) bttv_release
812 OVERLAY VIDIOCCAPTURE on VIDIOCCAPTURE off
813 VIDIOC_OVERLAY on VIDIOC_OVERLAY off
816 VBI VIDIOC_STREAMON VIDIOC_STREAMOFF
817 VIDIOC_QBUF 1) bttv_release
818 bttv_read, bttv_poll 1) 4)
820 1) The resource must be allocated when we enter buffer prepare functions
821 and remain allocated while buffers are in the DMA queue.
822 2) This is a single frame read.
823 3) VIDIOC_S_FBUF and VIDIOC_S_FMT (OVERLAY) still work when
824 RESOURCE_OVERLAY is allocated.
825 4) This is a continuous read, implies VIDIOC_STREAMON.
827 Note this driver permits video input and standard changes regardless if
828 resources are allocated.
831 #define VBI_RESOURCES (RESOURCE_VBI)
832 #define VIDEO_RESOURCES (RESOURCE_VIDEO_READ | \
833 RESOURCE_VIDEO_STREAM | \
837 int check_alloc_btres(struct bttv *btv, struct bttv_fh *fh, int bit)
839 int xbits; /* mutual exclusive resources */
841 if (fh->resources & bit)
842 /* have it already allocated */
846 if (bit & (RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM))
847 xbits |= RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM;
850 mutex_lock(&btv->lock);
851 if (btv->resources & xbits) {
852 /* no, someone else uses it */
856 if ((bit & VIDEO_RESOURCES)
857 && 0 == (btv->resources & VIDEO_RESOURCES)) {
858 /* Do crop - use current, don't - use default parameters. */
859 __s32 top = btv->crop[!!fh->do_crop].rect.top;
861 if (btv->vbi_end > top)
864 /* We cannot capture the same line as video and VBI data.
865 Claim scan lines crop[].rect.top to bottom. */
866 btv->crop_start = top;
867 } else if (bit & VBI_RESOURCES) {
868 __s32 end = fh->vbi_fmt.end;
870 if (end > btv->crop_start)
873 /* Claim scan lines above fh->vbi_fmt.end. */
877 /* it's free, grab it */
878 fh->resources |= bit;
879 btv->resources |= bit;
880 mutex_unlock(&btv->lock);
884 mutex_unlock(&btv->lock);
889 int check_btres(struct bttv_fh *fh, int bit)
891 return (fh->resources & bit);
895 int locked_btres(struct bttv *btv, int bit)
897 return (btv->resources & bit);
900 /* Call with btv->lock down. */
902 disclaim_vbi_lines(struct bttv *btv)
907 /* Call with btv->lock down. */
909 disclaim_video_lines(struct bttv *btv)
911 const struct bttv_tvnorm *tvnorm;
914 tvnorm = &bttv_tvnorms[btv->tvnorm];
915 btv->crop_start = tvnorm->cropcap.bounds.top
916 + tvnorm->cropcap.bounds.height;
918 /* VBI capturing ends at VDELAY, start of video capturing, no
919 matter how many lines the VBI RISC program expects. When video
920 capturing is off, it shall no longer "preempt" VBI capturing,
921 so we set VDELAY to maximum. */
922 crop = btread(BT848_E_CROP) | 0xc0;
923 btwrite(crop, BT848_E_CROP);
924 btwrite(0xfe, BT848_E_VDELAY_LO);
925 btwrite(crop, BT848_O_CROP);
926 btwrite(0xfe, BT848_O_VDELAY_LO);
930 void free_btres(struct bttv *btv, struct bttv_fh *fh, int bits)
932 if ((fh->resources & bits) != bits) {
933 /* trying to free ressources not allocated by us ... */
934 printk("bttv: BUG! (btres)\n");
936 mutex_lock(&btv->lock);
937 fh->resources &= ~bits;
938 btv->resources &= ~bits;
940 bits = btv->resources;
942 if (0 == (bits & VIDEO_RESOURCES))
943 disclaim_video_lines(btv);
945 if (0 == (bits & VBI_RESOURCES))
946 disclaim_vbi_lines(btv);
948 mutex_unlock(&btv->lock);
951 /* ----------------------------------------------------------------------- */
952 /* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC */
954 /* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C
955 PLL_X = Reference pre-divider (0=1, 1=2)
956 PLL_C = Post divider (0=6, 1=4)
957 PLL_I = Integer input
958 PLL_F = Fractional input
960 F_input = 28.636363 MHz:
961 PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0
964 static void set_pll_freq(struct bttv *btv, unsigned int fin, unsigned int fout)
966 unsigned char fl, fh, fi;
968 /* prevent overflows */
981 btwrite(fl, BT848_PLL_F_LO);
982 btwrite(fh, BT848_PLL_F_HI);
983 btwrite(fi|BT848_PLL_X, BT848_PLL_XCI);
986 static void set_pll(struct bttv *btv)
990 if (!btv->pll.pll_crystal)
993 if (btv->pll.pll_ofreq == btv->pll.pll_current) {
994 dprintk("bttv%d: PLL: no change required\n",btv->c.nr);
998 if (btv->pll.pll_ifreq == btv->pll.pll_ofreq) {
1000 if (btv->pll.pll_current == 0)
1002 bttv_printk(KERN_INFO "bttv%d: PLL can sleep, using XTAL (%d).\n",
1003 btv->c.nr,btv->pll.pll_ifreq);
1004 btwrite(0x00,BT848_TGCTRL);
1005 btwrite(0x00,BT848_PLL_XCI);
1006 btv->pll.pll_current = 0;
1010 bttv_printk(KERN_INFO "bttv%d: PLL: %d => %d ",btv->c.nr,
1011 btv->pll.pll_ifreq, btv->pll.pll_ofreq);
1012 set_pll_freq(btv, btv->pll.pll_ifreq, btv->pll.pll_ofreq);
1014 for (i=0; i<10; i++) {
1015 /* Let other people run while the PLL stabilizes */
1019 if (btread(BT848_DSTATUS) & BT848_DSTATUS_PLOCK) {
1020 btwrite(0,BT848_DSTATUS);
1022 btwrite(0x08,BT848_TGCTRL);
1023 btv->pll.pll_current = btv->pll.pll_ofreq;
1024 bttv_printk(" ok\n");
1028 btv->pll.pll_current = -1;
1029 bttv_printk("failed\n");
1033 /* used to switch between the bt848's analog/digital video capture modes */
1034 static void bt848A_set_timing(struct bttv *btv)
1037 int table_idx = bttv_tvnorms[btv->tvnorm].sram;
1038 int fsc = bttv_tvnorms[btv->tvnorm].Fsc;
1040 if (UNSET == bttv_tvcards[btv->c.type].muxsel[btv->input]) {
1041 dprintk("bttv%d: load digital timing table (table_idx=%d)\n",
1042 btv->c.nr,table_idx);
1044 /* timing change...reset timing generator address */
1045 btwrite(0x00, BT848_TGCTRL);
1046 btwrite(0x02, BT848_TGCTRL);
1047 btwrite(0x00, BT848_TGCTRL);
1049 len=SRAM_Table[table_idx][0];
1050 for(i = 1; i <= len; i++)
1051 btwrite(SRAM_Table[table_idx][i],BT848_TGLB);
1052 btv->pll.pll_ofreq = 27000000;
1055 btwrite(0x11, BT848_TGCTRL);
1056 btwrite(0x41, BT848_DVSIF);
1058 btv->pll.pll_ofreq = fsc;
1060 btwrite(0x0, BT848_DVSIF);
1064 /* ----------------------------------------------------------------------- */
1066 static void bt848_bright(struct bttv *btv, int bright)
1070 // printk("bttv: set bright: %d\n",bright); // DEBUG
1071 btv->bright = bright;
1073 /* We want -128 to 127 we get 0-65535 */
1074 value = (bright >> 8) - 128;
1075 btwrite(value & 0xff, BT848_BRIGHT);
1078 static void bt848_hue(struct bttv *btv, int hue)
1085 value = (hue >> 8) - 128;
1086 btwrite(value & 0xff, BT848_HUE);
1089 static void bt848_contrast(struct bttv *btv, int cont)
1093 btv->contrast = cont;
1096 value = (cont >> 7);
1097 hibit = (value >> 6) & 4;
1098 btwrite(value & 0xff, BT848_CONTRAST_LO);
1099 btaor(hibit, ~4, BT848_E_CONTROL);
1100 btaor(hibit, ~4, BT848_O_CONTROL);
1103 static void bt848_sat(struct bttv *btv, int color)
1105 int val_u,val_v,hibits;
1107 btv->saturation = color;
1109 /* 0-511 for the color */
1110 val_u = ((color * btv->opt_uv_ratio) / 50) >> 7;
1111 val_v = (((color * (100 - btv->opt_uv_ratio) / 50) >>7)*180L)/254;
1112 hibits = (val_u >> 7) & 2;
1113 hibits |= (val_v >> 8) & 1;
1114 btwrite(val_u & 0xff, BT848_SAT_U_LO);
1115 btwrite(val_v & 0xff, BT848_SAT_V_LO);
1116 btaor(hibits, ~3, BT848_E_CONTROL);
1117 btaor(hibits, ~3, BT848_O_CONTROL);
1120 /* ----------------------------------------------------------------------- */
1123 video_mux(struct bttv *btv, unsigned int input)
1127 if (input >= bttv_tvcards[btv->c.type].video_inputs)
1130 /* needed by RemoteVideo MX */
1131 mask2 = bttv_tvcards[btv->c.type].gpiomask2;
1133 gpio_inout(mask2,mask2);
1135 if (input == btv->svhs) {
1136 btor(BT848_CONTROL_COMP, BT848_E_CONTROL);
1137 btor(BT848_CONTROL_COMP, BT848_O_CONTROL);
1139 btand(~BT848_CONTROL_COMP, BT848_E_CONTROL);
1140 btand(~BT848_CONTROL_COMP, BT848_O_CONTROL);
1142 mux = bttv_tvcards[btv->c.type].muxsel[input] & 3;
1143 btaor(mux<<5, ~(3<<5), BT848_IFORM);
1144 dprintk(KERN_DEBUG "bttv%d: video mux: input=%d mux=%d\n",
1145 btv->c.nr,input,mux);
1147 /* card specific hook */
1148 if(bttv_tvcards[btv->c.type].muxsel_hook)
1149 bttv_tvcards[btv->c.type].muxsel_hook (btv, input);
1153 static char *audio_modes[] = {
1154 "audio: tuner", "audio: radio", "audio: extern",
1155 "audio: intern", "audio: mute"
1159 audio_mux(struct bttv *btv, int input, int mute)
1161 int gpio_val, signal;
1162 struct v4l2_control ctrl;
1163 struct i2c_client *c;
1165 gpio_inout(bttv_tvcards[btv->c.type].gpiomask,
1166 bttv_tvcards[btv->c.type].gpiomask);
1167 signal = btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC;
1173 mute = mute || (btv->opt_automute && !signal && !btv->radio_user);
1176 gpio_val = bttv_tvcards[btv->c.type].gpiomute;
1178 gpio_val = bttv_tvcards[btv->c.type].gpiomux[input];
1180 gpio_bits(bttv_tvcards[btv->c.type].gpiomask, gpio_val);
1182 bttv_gpio_tracking(btv, audio_modes[mute ? 4 : input]);
1186 ctrl.id = V4L2_CID_AUDIO_MUTE;
1187 ctrl.value = btv->mute;
1188 bttv_call_i2c_clients(btv, VIDIOC_S_CTRL, &ctrl);
1189 c = btv->i2c_msp34xx_client;
1191 struct v4l2_routing route;
1193 /* Note: the inputs tuner/radio/extern/intern are translated
1194 to msp routings. This assumes common behavior for all msp3400
1195 based TV cards. When this assumption fails, then the
1196 specific MSP routing must be added to the card table.
1197 For now this is sufficient. */
1199 case TVAUDIO_INPUT_RADIO:
1200 route.input = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1201 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1203 case TVAUDIO_INPUT_EXTERN:
1204 route.input = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER1,
1205 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1207 case TVAUDIO_INPUT_INTERN:
1208 /* Yes, this is the same input as for RADIO. I doubt
1209 if this is ever used. The only board with an INTERN
1210 input is the BTTV_BOARD_AVERMEDIA98. I wonder how
1211 that was tested. My guess is that the whole INTERN
1212 input does not work. */
1213 route.input = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1214 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1216 case TVAUDIO_INPUT_TUNER:
1218 /* This is the only card that uses TUNER2, and afaik,
1219 is the only difference between the VOODOOTV_FM
1221 if (btv->c.type == BTTV_BOARD_VOODOOTV_200)
1222 route.input = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER2, \
1223 MSP_DSP_IN_TUNER, MSP_DSP_IN_TUNER);
1225 route.input = MSP_INPUT_DEFAULT;
1228 route.output = MSP_OUTPUT_DEFAULT;
1229 c->driver->command(c, VIDIOC_INT_S_AUDIO_ROUTING, &route);
1231 c = btv->i2c_tvaudio_client;
1233 struct v4l2_routing route;
1235 route.input = input;
1237 c->driver->command(c, VIDIOC_INT_S_AUDIO_ROUTING, &route);
1243 audio_mute(struct bttv *btv, int mute)
1245 return audio_mux(btv, btv->audio, mute);
1249 audio_input(struct bttv *btv, int input)
1251 return audio_mux(btv, input, btv->mute);
1255 bttv_crop_calc_limits(struct bttv_crop *c)
1257 /* Scale factor min. 1:1, max. 16:1. Min. image size
1258 48 x 32. Scaled width must be a multiple of 4. */
1261 /* For bug compatibility with VIDIOCGCAP and image
1262 size checks in earlier driver versions. */
1263 c->min_scaled_width = 48;
1264 c->min_scaled_height = 32;
1266 c->min_scaled_width =
1267 (max(48, c->rect.width >> 4) + 3) & ~3;
1268 c->min_scaled_height =
1269 max(32, c->rect.height >> 4);
1272 c->max_scaled_width = c->rect.width & ~3;
1273 c->max_scaled_height = c->rect.height;
1277 bttv_crop_reset(struct bttv_crop *c, int norm)
1279 c->rect = bttv_tvnorms[norm].cropcap.defrect;
1280 bttv_crop_calc_limits(c);
1283 /* Call with btv->lock down. */
1285 set_tvnorm(struct bttv *btv, unsigned int norm)
1287 const struct bttv_tvnorm *tvnorm;
1290 if (norm < 0 || norm >= BTTV_TVNORMS)
1293 tvnorm = &bttv_tvnorms[norm];
1295 if (btv->tvnorm < 0 ||
1296 btv->tvnorm >= BTTV_TVNORMS ||
1297 0 != memcmp(&bttv_tvnorms[btv->tvnorm].cropcap,
1299 sizeof (tvnorm->cropcap))) {
1300 bttv_crop_reset(&btv->crop[0], norm);
1301 btv->crop[1] = btv->crop[0]; /* current = default */
1303 if (0 == (btv->resources & VIDEO_RESOURCES)) {
1304 btv->crop_start = tvnorm->cropcap.bounds.top
1305 + tvnorm->cropcap.bounds.height;
1311 btwrite(tvnorm->adelay, BT848_ADELAY);
1312 btwrite(tvnorm->bdelay, BT848_BDELAY);
1313 btaor(tvnorm->iform,~(BT848_IFORM_NORM|BT848_IFORM_XTBOTH),
1315 btwrite(tvnorm->vbipack, BT848_VBI_PACK_SIZE);
1316 btwrite(1, BT848_VBI_PACK_DEL);
1317 bt848A_set_timing(btv);
1319 switch (btv->c.type) {
1320 case BTTV_BOARD_VOODOOTV_FM:
1321 case BTTV_BOARD_VOODOOTV_200:
1322 bttv_tda9880_setnorm(btv,norm);
1325 id = tvnorm->v4l2_id;
1326 bttv_call_i2c_clients(btv, VIDIOC_S_STD, &id);
1331 /* Call with btv->lock down. */
1333 set_input(struct bttv *btv, unsigned int input, unsigned int norm)
1335 unsigned long flags;
1339 spin_lock_irqsave(&btv->s_lock,flags);
1340 if (btv->curr.frame_irq) {
1341 /* active capture -> delayed input switch */
1342 btv->new_input = input;
1344 video_mux(btv,input);
1346 spin_unlock_irqrestore(&btv->s_lock,flags);
1348 video_mux(btv,input);
1350 audio_input(btv,(input == bttv_tvcards[btv->c.type].tuner ?
1351 TVAUDIO_INPUT_TUNER : TVAUDIO_INPUT_EXTERN));
1352 set_tvnorm(btv, norm);
1355 static void init_irqreg(struct bttv *btv)
1358 btwrite(0xfffffUL, BT848_INT_STAT);
1360 if (bttv_tvcards[btv->c.type].no_video) {
1362 btwrite(BT848_INT_I2CDONE,
1366 btwrite((btv->triton1) |
1367 (btv->gpioirq ? BT848_INT_GPINT : 0) |
1369 (fdsr ? BT848_INT_FDSR : 0) |
1370 BT848_INT_RISCI|BT848_INT_OCERR|BT848_INT_VPRES|
1371 BT848_INT_FMTCHG|BT848_INT_HLOCK|
1377 static void init_bt848(struct bttv *btv)
1381 if (bttv_tvcards[btv->c.type].no_video) {
1382 /* very basic init only */
1387 btwrite(0x00, BT848_CAP_CTL);
1388 btwrite(BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL);
1389 btwrite(BT848_IFORM_XTAUTO | BT848_IFORM_AUTO, BT848_IFORM);
1391 /* set planar and packed mode trigger points and */
1392 /* set rising edge of inverted GPINTR pin as irq trigger */
1393 btwrite(BT848_GPIO_DMA_CTL_PKTP_32|
1394 BT848_GPIO_DMA_CTL_PLTP1_16|
1395 BT848_GPIO_DMA_CTL_PLTP23_16|
1396 BT848_GPIO_DMA_CTL_GPINTC|
1397 BT848_GPIO_DMA_CTL_GPINTI,
1398 BT848_GPIO_DMA_CTL);
1400 val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1401 btwrite(val, BT848_E_SCLOOP);
1402 btwrite(val, BT848_O_SCLOOP);
1404 btwrite(0x20, BT848_E_VSCALE_HI);
1405 btwrite(0x20, BT848_O_VSCALE_HI);
1406 btwrite(BT848_ADC_RESERVED | (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1409 btwrite(whitecrush_upper, BT848_WC_UP);
1410 btwrite(whitecrush_lower, BT848_WC_DOWN);
1412 if (btv->opt_lumafilter) {
1413 btwrite(0, BT848_E_CONTROL);
1414 btwrite(0, BT848_O_CONTROL);
1416 btwrite(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1417 btwrite(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1420 bt848_bright(btv, btv->bright);
1421 bt848_hue(btv, btv->hue);
1422 bt848_contrast(btv, btv->contrast);
1423 bt848_sat(btv, btv->saturation);
1429 static void bttv_reinit_bt848(struct bttv *btv)
1431 unsigned long flags;
1434 printk(KERN_INFO "bttv%d: reset, reinitialize\n",btv->c.nr);
1435 spin_lock_irqsave(&btv->s_lock,flags);
1437 bttv_set_dma(btv,0);
1438 spin_unlock_irqrestore(&btv->s_lock,flags);
1441 btv->pll.pll_current = -1;
1442 set_input(btv, btv->input, btv->tvnorm);
1445 static int bttv_g_ctrl(struct file *file, void *priv,
1446 struct v4l2_control *c)
1448 struct bttv_fh *fh = priv;
1449 struct bttv *btv = fh->btv;
1452 case V4L2_CID_BRIGHTNESS:
1453 c->value = btv->bright;
1456 c->value = btv->hue;
1458 case V4L2_CID_CONTRAST:
1459 c->value = btv->contrast;
1461 case V4L2_CID_SATURATION:
1462 c->value = btv->saturation;
1465 case V4L2_CID_AUDIO_MUTE:
1466 case V4L2_CID_AUDIO_VOLUME:
1467 case V4L2_CID_AUDIO_BALANCE:
1468 case V4L2_CID_AUDIO_BASS:
1469 case V4L2_CID_AUDIO_TREBLE:
1470 bttv_call_i2c_clients(btv, VIDIOC_G_CTRL, c);
1473 case V4L2_CID_PRIVATE_CHROMA_AGC:
1474 c->value = btv->opt_chroma_agc;
1476 case V4L2_CID_PRIVATE_COMBFILTER:
1477 c->value = btv->opt_combfilter;
1479 case V4L2_CID_PRIVATE_LUMAFILTER:
1480 c->value = btv->opt_lumafilter;
1482 case V4L2_CID_PRIVATE_AUTOMUTE:
1483 c->value = btv->opt_automute;
1485 case V4L2_CID_PRIVATE_AGC_CRUSH:
1486 c->value = btv->opt_adc_crush;
1488 case V4L2_CID_PRIVATE_VCR_HACK:
1489 c->value = btv->opt_vcr_hack;
1491 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1492 c->value = btv->opt_whitecrush_upper;
1494 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1495 c->value = btv->opt_whitecrush_lower;
1497 case V4L2_CID_PRIVATE_UV_RATIO:
1498 c->value = btv->opt_uv_ratio;
1500 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1501 c->value = btv->opt_full_luma_range;
1503 case V4L2_CID_PRIVATE_CORING:
1504 c->value = btv->opt_coring;
1512 static int bttv_s_ctrl(struct file *file, void *f,
1513 struct v4l2_control *c)
1517 struct bttv_fh *fh = f;
1518 struct bttv *btv = fh->btv;
1520 err = v4l2_prio_check(&btv->prio, &fh->prio);
1525 case V4L2_CID_BRIGHTNESS:
1526 bt848_bright(btv, c->value);
1529 bt848_hue(btv, c->value);
1531 case V4L2_CID_CONTRAST:
1532 bt848_contrast(btv, c->value);
1534 case V4L2_CID_SATURATION:
1535 bt848_sat(btv, c->value);
1537 case V4L2_CID_AUDIO_MUTE:
1538 audio_mute(btv, c->value);
1540 case V4L2_CID_AUDIO_VOLUME:
1541 if (btv->volume_gpio)
1542 btv->volume_gpio(btv, c->value);
1544 bttv_call_i2c_clients(btv, VIDIOC_S_CTRL, c);
1546 case V4L2_CID_AUDIO_BALANCE:
1547 case V4L2_CID_AUDIO_BASS:
1548 case V4L2_CID_AUDIO_TREBLE:
1549 bttv_call_i2c_clients(btv, VIDIOC_S_CTRL, c);
1552 case V4L2_CID_PRIVATE_CHROMA_AGC:
1553 btv->opt_chroma_agc = c->value;
1554 val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1555 btwrite(val, BT848_E_SCLOOP);
1556 btwrite(val, BT848_O_SCLOOP);
1558 case V4L2_CID_PRIVATE_COMBFILTER:
1559 btv->opt_combfilter = c->value;
1561 case V4L2_CID_PRIVATE_LUMAFILTER:
1562 btv->opt_lumafilter = c->value;
1563 if (btv->opt_lumafilter) {
1564 btand(~BT848_CONTROL_LDEC, BT848_E_CONTROL);
1565 btand(~BT848_CONTROL_LDEC, BT848_O_CONTROL);
1567 btor(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1568 btor(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1571 case V4L2_CID_PRIVATE_AUTOMUTE:
1572 btv->opt_automute = c->value;
1574 case V4L2_CID_PRIVATE_AGC_CRUSH:
1575 btv->opt_adc_crush = c->value;
1576 btwrite(BT848_ADC_RESERVED |
1577 (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1580 case V4L2_CID_PRIVATE_VCR_HACK:
1581 btv->opt_vcr_hack = c->value;
1583 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1584 btv->opt_whitecrush_upper = c->value;
1585 btwrite(c->value, BT848_WC_UP);
1587 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1588 btv->opt_whitecrush_lower = c->value;
1589 btwrite(c->value, BT848_WC_DOWN);
1591 case V4L2_CID_PRIVATE_UV_RATIO:
1592 btv->opt_uv_ratio = c->value;
1593 bt848_sat(btv, btv->saturation);
1595 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1596 btv->opt_full_luma_range = c->value;
1597 btaor((c->value<<7), ~BT848_OFORM_RANGE, BT848_OFORM);
1599 case V4L2_CID_PRIVATE_CORING:
1600 btv->opt_coring = c->value;
1601 btaor((c->value<<5), ~BT848_OFORM_CORE32, BT848_OFORM);
1609 /* ----------------------------------------------------------------------- */
1611 void bttv_gpio_tracking(struct bttv *btv, char *comment)
1613 unsigned int outbits, data;
1614 outbits = btread(BT848_GPIO_OUT_EN);
1615 data = btread(BT848_GPIO_DATA);
1616 printk(KERN_DEBUG "bttv%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
1617 btv->c.nr,outbits,data & outbits, data & ~outbits, comment);
1620 static void bttv_field_count(struct bttv *btv)
1628 /* start field counter */
1629 btor(BT848_INT_VSYNC,BT848_INT_MASK);
1631 /* stop field counter */
1632 btand(~BT848_INT_VSYNC,BT848_INT_MASK);
1633 btv->field_count = 0;
1637 static const struct bttv_format*
1638 format_by_fourcc(int fourcc)
1642 for (i = 0; i < FORMATS; i++) {
1643 if (-1 == formats[i].fourcc)
1645 if (formats[i].fourcc == fourcc)
1651 /* ----------------------------------------------------------------------- */
1655 bttv_switch_overlay(struct bttv *btv, struct bttv_fh *fh,
1656 struct bttv_buffer *new)
1658 struct bttv_buffer *old;
1659 unsigned long flags;
1662 dprintk("switch_overlay: enter [new=%p]\n",new);
1664 new->vb.state = VIDEOBUF_DONE;
1665 spin_lock_irqsave(&btv->s_lock,flags);
1669 bttv_set_dma(btv, 0x03);
1670 spin_unlock_irqrestore(&btv->s_lock,flags);
1672 dprintk("switch_overlay: old=%p state is %d\n",old,old->vb.state);
1673 bttv_dma_free(&fh->cap,btv, old);
1677 free_btres(btv,fh,RESOURCE_OVERLAY);
1678 dprintk("switch_overlay: done\n");
1682 /* ----------------------------------------------------------------------- */
1683 /* video4linux (1) interface */
1685 static int bttv_prepare_buffer(struct videobuf_queue *q,struct bttv *btv,
1686 struct bttv_buffer *buf,
1687 const struct bttv_format *fmt,
1688 unsigned int width, unsigned int height,
1689 enum v4l2_field field)
1691 struct bttv_fh *fh = q->priv_data;
1692 int redo_dma_risc = 0;
1697 /* check settings */
1700 if (fmt->btformat == BT848_COLOR_FMT_RAW) {
1702 height = RAW_LINES*2;
1703 if (width*height > buf->vb.bsize)
1705 buf->vb.size = buf->vb.bsize;
1707 /* Make sure tvnorm and vbi_end remain consistent
1708 until we're done. */
1709 mutex_lock(&btv->lock);
1713 /* In this mode capturing always starts at defrect.top
1714 (default VDELAY), ignoring cropping parameters. */
1715 if (btv->vbi_end > bttv_tvnorms[norm].cropcap.defrect.top) {
1716 mutex_unlock(&btv->lock);
1720 mutex_unlock(&btv->lock);
1722 c.rect = bttv_tvnorms[norm].cropcap.defrect;
1724 mutex_lock(&btv->lock);
1727 c = btv->crop[!!fh->do_crop];
1729 mutex_unlock(&btv->lock);
1731 if (width < c.min_scaled_width ||
1732 width > c.max_scaled_width ||
1733 height < c.min_scaled_height)
1737 case V4L2_FIELD_TOP:
1738 case V4L2_FIELD_BOTTOM:
1739 case V4L2_FIELD_ALTERNATE:
1740 /* btv->crop counts frame lines. Max. scale
1741 factor is 16:1 for frames, 8:1 for fields. */
1742 if (height * 2 > c.max_scaled_height)
1747 if (height > c.max_scaled_height)
1752 buf->vb.size = (width * height * fmt->depth) >> 3;
1753 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
1757 /* alloc + fill struct bttv_buffer (if changed) */
1758 if (buf->vb.width != width || buf->vb.height != height ||
1759 buf->vb.field != field ||
1760 buf->tvnorm != norm || buf->fmt != fmt ||
1761 buf->crop.top != c.rect.top ||
1762 buf->crop.left != c.rect.left ||
1763 buf->crop.width != c.rect.width ||
1764 buf->crop.height != c.rect.height) {
1765 buf->vb.width = width;
1766 buf->vb.height = height;
1767 buf->vb.field = field;
1774 /* alloc risc memory */
1775 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
1777 if (0 != (rc = videobuf_iolock(q,&buf->vb,&btv->fbuf)))
1782 if (0 != (rc = bttv_buffer_risc(btv,buf)))
1785 buf->vb.state = VIDEOBUF_PREPARED;
1789 bttv_dma_free(q,btv,buf);
1794 buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
1796 struct bttv_fh *fh = q->priv_data;
1798 *size = fh->fmt->depth*fh->width*fh->height >> 3;
1801 while (*size * *count > gbuffers * gbufsize)
1807 buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
1808 enum v4l2_field field)
1810 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1811 struct bttv_fh *fh = q->priv_data;
1813 return bttv_prepare_buffer(q,fh->btv, buf, fh->fmt,
1814 fh->width, fh->height, field);
1818 buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
1820 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1821 struct bttv_fh *fh = q->priv_data;
1822 struct bttv *btv = fh->btv;
1824 buf->vb.state = VIDEOBUF_QUEUED;
1825 list_add_tail(&buf->vb.queue,&btv->capture);
1826 if (!btv->curr.frame_irq) {
1828 bttv_set_dma(btv, 0x03);
1832 static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
1834 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1835 struct bttv_fh *fh = q->priv_data;
1837 bttv_dma_free(q,fh->btv,buf);
1840 static struct videobuf_queue_ops bttv_video_qops = {
1841 .buf_setup = buffer_setup,
1842 .buf_prepare = buffer_prepare,
1843 .buf_queue = buffer_queue,
1844 .buf_release = buffer_release,
1847 static int bttv_s_std(struct file *file, void *priv, v4l2_std_id *id)
1849 struct bttv_fh *fh = priv;
1850 struct bttv *btv = fh->btv;
1854 err = v4l2_prio_check(&btv->prio, &fh->prio);
1858 for (i = 0; i < BTTV_TVNORMS; i++)
1859 if (*id & bttv_tvnorms[i].v4l2_id)
1861 if (i == BTTV_TVNORMS)
1864 mutex_lock(&btv->lock);
1866 mutex_unlock(&btv->lock);
1871 static int bttv_querystd(struct file *file, void *f, v4l2_std_id *id)
1873 struct bttv_fh *fh = f;
1874 struct bttv *btv = fh->btv;
1876 if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML)
1877 *id = V4L2_STD_625_50;
1879 *id = V4L2_STD_525_60;
1883 static int bttv_enum_input(struct file *file, void *priv,
1884 struct v4l2_input *i)
1886 struct bttv_fh *fh = priv;
1887 struct bttv *btv = fh->btv;
1892 if (n >= bttv_tvcards[btv->c.type].video_inputs)
1895 memset(i, 0, sizeof(*i));
1898 i->type = V4L2_INPUT_TYPE_CAMERA;
1901 if (i->index == bttv_tvcards[btv->c.type].tuner) {
1902 sprintf(i->name, "Television");
1903 i->type = V4L2_INPUT_TYPE_TUNER;
1905 } else if (i->index == btv->svhs) {
1906 sprintf(i->name, "S-Video");
1908 sprintf(i->name, "Composite%d", i->index);
1911 if (i->index == btv->input) {
1912 __u32 dstatus = btread(BT848_DSTATUS);
1913 if (0 == (dstatus & BT848_DSTATUS_PRES))
1914 i->status |= V4L2_IN_ST_NO_SIGNAL;
1915 if (0 == (dstatus & BT848_DSTATUS_HLOC))
1916 i->status |= V4L2_IN_ST_NO_H_LOCK;
1919 for (n = 0; n < BTTV_TVNORMS; n++)
1920 i->std |= bttv_tvnorms[n].v4l2_id;
1925 static int bttv_g_input(struct file *file, void *priv, unsigned int *i)
1927 struct bttv_fh *fh = priv;
1928 struct bttv *btv = fh->btv;
1934 static int bttv_s_input(struct file *file, void *priv, unsigned int i)
1936 struct bttv_fh *fh = priv;
1937 struct bttv *btv = fh->btv;
1941 err = v4l2_prio_check(&btv->prio, &fh->prio);
1945 if (i > bttv_tvcards[btv->c.type].video_inputs)
1948 mutex_lock(&btv->lock);
1949 set_input(btv, i, btv->tvnorm);
1950 mutex_unlock(&btv->lock);
1954 static int bttv_s_tuner(struct file *file, void *priv,
1955 struct v4l2_tuner *t)
1957 struct bttv_fh *fh = priv;
1958 struct bttv *btv = fh->btv;
1961 err = v4l2_prio_check(&btv->prio, &fh->prio);
1965 if (UNSET == bttv_tvcards[btv->c.type].tuner)
1971 mutex_lock(&btv->lock);
1972 bttv_call_i2c_clients(btv, VIDIOC_S_TUNER, t);
1974 if (btv->audio_mode_gpio)
1975 btv->audio_mode_gpio(btv, t, 1);
1977 mutex_unlock(&btv->lock);
1982 static int bttv_g_frequency(struct file *file, void *priv,
1983 struct v4l2_frequency *f)
1985 struct bttv_fh *fh = priv;
1986 struct bttv *btv = fh->btv;
1989 err = v4l2_prio_check(&btv->prio, &fh->prio);
1993 f->type = btv->radio_user ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
1994 f->frequency = btv->freq;
1999 static int bttv_s_frequency(struct file *file, void *priv,
2000 struct v4l2_frequency *f)
2002 struct bttv_fh *fh = priv;
2003 struct bttv *btv = fh->btv;
2006 err = v4l2_prio_check(&btv->prio, &fh->prio);
2010 if (unlikely(f->tuner != 0))
2012 if (unlikely(f->type != (btv->radio_user
2013 ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV)))
2015 mutex_lock(&btv->lock);
2016 btv->freq = f->frequency;
2017 bttv_call_i2c_clients(btv, VIDIOC_S_FREQUENCY, f);
2018 if (btv->has_matchbox && btv->radio_user)
2019 tea5757_set_freq(btv, btv->freq);
2020 mutex_unlock(&btv->lock);
2024 static int bttv_log_status(struct file *file, void *f)
2026 struct bttv_fh *fh = f;
2027 struct bttv *btv = fh->btv;
2029 printk(KERN_INFO "bttv%d: ======== START STATUS CARD #%d ========\n",
2030 btv->c.nr, btv->c.nr);
2031 bttv_call_i2c_clients(btv, VIDIOC_LOG_STATUS, NULL);
2032 printk(KERN_INFO "bttv%d: ======== END STATUS CARD #%d ========\n",
2033 btv->c.nr, btv->c.nr);
2037 #ifdef CONFIG_VIDEO_ADV_DEBUG
2038 static int bttv_g_register(struct file *file, void *f,
2039 struct v4l2_register *reg)
2041 struct bttv_fh *fh = f;
2042 struct bttv *btv = fh->btv;
2044 if (!capable(CAP_SYS_ADMIN))
2047 if (!v4l2_chip_match_host(reg->match_type, reg->match_chip))
2050 /* bt848 has a 12-bit register space */
2052 reg->val = btread(reg->reg);
2057 static int bttv_s_register(struct file *file, void *f,
2058 struct v4l2_register *reg)
2060 struct bttv_fh *fh = f;
2061 struct bttv *btv = fh->btv;
2063 if (!capable(CAP_SYS_ADMIN))
2066 if (!v4l2_chip_match_host(reg->match_type, reg->match_chip))
2069 /* bt848 has a 12-bit register space */
2071 btwrite(reg->val, reg->reg);
2077 /* Given cropping boundaries b and the scaled width and height of a
2078 single field or frame, which must not exceed hardware limits, this
2079 function adjusts the cropping parameters c. */
2081 bttv_crop_adjust (struct bttv_crop * c,
2082 const struct v4l2_rect * b,
2085 enum v4l2_field field)
2087 __s32 frame_height = height << !V4L2_FIELD_HAS_BOTH(field);
2091 if (width < c->min_scaled_width) {
2092 /* Max. hor. scale factor 16:1. */
2093 c->rect.width = width * 16;
2094 } else if (width > c->max_scaled_width) {
2095 /* Min. hor. scale factor 1:1. */
2096 c->rect.width = width;
2098 max_left = b->left + b->width - width;
2099 max_left = min(max_left, (__s32) MAX_HDELAY);
2100 if (c->rect.left > max_left)
2101 c->rect.left = max_left;
2104 if (height < c->min_scaled_height) {
2105 /* Max. vert. scale factor 16:1, single fields 8:1. */
2106 c->rect.height = height * 16;
2107 } else if (frame_height > c->max_scaled_height) {
2108 /* Min. vert. scale factor 1:1.
2109 Top and height count field lines times two. */
2110 c->rect.height = (frame_height + 1) & ~1;
2112 max_top = b->top + b->height - c->rect.height;
2113 if (c->rect.top > max_top)
2114 c->rect.top = max_top;
2117 bttv_crop_calc_limits(c);
2120 /* Returns an error if scaling to a frame or single field with the given
2121 width and height is not possible with the current cropping parameters
2122 and width aligned according to width_mask. If adjust_size is TRUE the
2123 function may adjust the width and/or height instead, rounding width
2124 to (width + width_bias) & width_mask. If adjust_crop is TRUE it may
2125 also adjust the current cropping parameters to get closer to the
2126 desired image size. */
2128 limit_scaled_size (struct bttv_fh * fh,
2131 enum v4l2_field field,
2132 unsigned int width_mask,
2133 unsigned int width_bias,
2137 struct bttv *btv = fh->btv;
2138 const struct v4l2_rect *b;
2139 struct bttv_crop *c;
2146 BUG_ON((int) width_mask >= 0 ||
2147 width_bias >= (unsigned int) -width_mask);
2149 /* Make sure tvnorm, vbi_end and the current cropping parameters
2150 remain consistent until we're done. */
2151 mutex_lock(&btv->lock);
2153 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2155 /* Do crop - use current, don't - use default parameters. */
2156 c = &btv->crop[!!fh->do_crop];
2161 && !locked_btres(btv, VIDEO_RESOURCES)) {
2165 /* We cannot scale up. When the scaled image is larger
2166 than crop.rect we adjust the crop.rect as required
2167 by the V4L2 spec, hence cropcap.bounds are our limit. */
2168 max_width = min(b->width, (__s32) MAX_HACTIVE);
2169 max_height = b->height;
2171 /* We cannot capture the same line as video and VBI data.
2172 Note btv->vbi_end is really a minimum, see
2173 bttv_vbi_try_fmt(). */
2174 if (btv->vbi_end > b->top) {
2175 max_height -= btv->vbi_end - b->top;
2177 if (min_height > max_height)
2182 if (btv->vbi_end > c->rect.top)
2185 min_width = c->min_scaled_width;
2186 min_height = c->min_scaled_height;
2187 max_width = c->max_scaled_width;
2188 max_height = c->max_scaled_height;
2193 min_width = (min_width - width_mask - 1) & width_mask;
2194 max_width = max_width & width_mask;
2196 /* Max. scale factor is 16:1 for frames, 8:1 for fields. */
2197 min_height = min_height;
2198 /* Min. scale factor is 1:1. */
2199 max_height >>= !V4L2_FIELD_HAS_BOTH(field);
2202 *width = clamp(*width, min_width, max_width);
2203 *height = clamp(*height, min_height, max_height);
2205 /* Round after clamping to avoid overflow. */
2206 *width = (*width + width_bias) & width_mask;
2209 bttv_crop_adjust(c, b, *width, *height, field);
2211 if (btv->vbi_end > c->rect.top) {
2212 /* Move the crop window out of the way. */
2213 c->rect.top = btv->vbi_end;
2218 if (*width < min_width ||
2219 *height < min_height ||
2220 *width > max_width ||
2221 *height > max_height ||
2222 0 != (*width & ~width_mask))
2226 rc = 0; /* success */
2229 mutex_unlock(&btv->lock);
2234 /* Returns an error if the given overlay window dimensions are not
2235 possible with the current cropping parameters. If adjust_size is
2236 TRUE the function may adjust the window width and/or height
2237 instead, however it always rounds the horizontal position and
2238 width as btcx_align() does. If adjust_crop is TRUE the function
2239 may also adjust the current cropping parameters to get closer
2240 to the desired window size. */
2242 verify_window (struct bttv_fh * fh,
2243 struct v4l2_window * win,
2247 enum v4l2_field field;
2248 unsigned int width_mask;
2251 if (win->w.width < 48 || win->w.height < 32)
2253 if (win->clipcount > 2048)
2258 if (V4L2_FIELD_ANY == field) {
2261 height2 = fh->btv->crop[!!fh->do_crop].rect.height >> 1;
2262 field = (win->w.height > height2)
2263 ? V4L2_FIELD_INTERLACED
2267 case V4L2_FIELD_TOP:
2268 case V4L2_FIELD_BOTTOM:
2269 case V4L2_FIELD_INTERLACED:
2275 /* 4-byte alignment. */
2276 if (NULL == fh->ovfmt)
2279 switch (fh->ovfmt->depth) {
2293 win->w.width -= win->w.left & ~width_mask;
2294 win->w.left = (win->w.left - width_mask - 1) & width_mask;
2296 rc = limit_scaled_size(fh, &win->w.width, &win->w.height,
2298 /* width_bias: round down */ 0,
2299 adjust_size, adjust_crop);
2307 static int setup_window(struct bttv_fh *fh, struct bttv *btv,
2308 struct v4l2_window *win, int fixup)
2310 struct v4l2_clip *clips = NULL;
2311 int n,size,retval = 0;
2313 if (NULL == fh->ovfmt)
2315 if (!(fh->ovfmt->flags & FORMAT_FLAGS_PACKED))
2317 retval = verify_window(fh, win,
2318 /* adjust_size */ fixup,
2319 /* adjust_crop */ fixup);
2323 /* copy clips -- luckily v4l1 + v4l2 are binary
2324 compatible here ...*/
2326 size = sizeof(*clips)*(n+4);
2327 clips = kmalloc(size,GFP_KERNEL);
2331 if (copy_from_user(clips,win->clips,sizeof(struct v4l2_clip)*n)) {
2336 /* clip against screen */
2337 if (NULL != btv->fbuf.base)
2338 n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height,
2340 btcx_sort_clips(clips,n);
2342 /* 4-byte alignments */
2343 switch (fh->ovfmt->depth) {
2346 btcx_align(&win->w, clips, n, 3);
2349 btcx_align(&win->w, clips, n, 1);
2352 /* no alignment fixups needed */
2358 mutex_lock(&fh->cap.vb_lock);
2359 kfree(fh->ov.clips);
2360 fh->ov.clips = clips;
2364 fh->ov.field = win->field;
2365 fh->ov.setup_ok = 1;
2366 btv->init.ov.w.width = win->w.width;
2367 btv->init.ov.w.height = win->w.height;
2368 btv->init.ov.field = win->field;
2370 /* update overlay if needed */
2372 if (check_btres(fh, RESOURCE_OVERLAY)) {
2373 struct bttv_buffer *new;
2375 new = videobuf_sg_alloc(sizeof(*new));
2376 new->crop = btv->crop[!!fh->do_crop].rect;
2377 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2378 retval = bttv_switch_overlay(btv,fh,new);
2380 mutex_unlock(&fh->cap.vb_lock);
2384 /* ----------------------------------------------------------------------- */
2386 static struct videobuf_queue* bttv_queue(struct bttv_fh *fh)
2388 struct videobuf_queue* q = NULL;
2391 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2394 case V4L2_BUF_TYPE_VBI_CAPTURE:
2403 static int bttv_resource(struct bttv_fh *fh)
2408 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2409 res = RESOURCE_VIDEO_STREAM;
2411 case V4L2_BUF_TYPE_VBI_CAPTURE:
2420 static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type)
2422 struct videobuf_queue *q = bttv_queue(fh);
2423 int res = bttv_resource(fh);
2425 if (check_btres(fh,res))
2427 if (videobuf_queue_is_busy(q))
2434 pix_format_set_size (struct v4l2_pix_format * f,
2435 const struct bttv_format * fmt,
2437 unsigned int height)
2442 if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2443 f->bytesperline = width; /* Y plane */
2444 f->sizeimage = (width * height * fmt->depth) >> 3;
2446 f->bytesperline = (width * fmt->depth) >> 3;
2447 f->sizeimage = height * f->bytesperline;
2451 static int bttv_g_fmt_vid_cap(struct file *file, void *priv,
2452 struct v4l2_format *f)
2454 struct bttv_fh *fh = priv;
2456 pix_format_set_size(&f->fmt.pix, fh->fmt,
2457 fh->width, fh->height);
2458 f->fmt.pix.field = fh->cap.field;
2459 f->fmt.pix.pixelformat = fh->fmt->fourcc;
2464 static int bttv_g_fmt_vid_overlay(struct file *file, void *priv,
2465 struct v4l2_format *f)
2467 struct bttv_fh *fh = priv;
2469 f->fmt.win.w = fh->ov.w;
2470 f->fmt.win.field = fh->ov.field;
2475 static int bttv_try_fmt_vid_cap(struct file *file, void *priv,
2476 struct v4l2_format *f)
2478 const struct bttv_format *fmt;
2479 struct bttv_fh *fh = priv;
2480 struct bttv *btv = fh->btv;
2481 enum v4l2_field field;
2482 __s32 width, height;
2485 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2489 field = f->fmt.pix.field;
2491 if (V4L2_FIELD_ANY == field) {
2494 height2 = btv->crop[!!fh->do_crop].rect.height >> 1;
2495 field = (f->fmt.pix.height > height2)
2496 ? V4L2_FIELD_INTERLACED
2497 : V4L2_FIELD_BOTTOM;
2500 if (V4L2_FIELD_SEQ_BT == field)
2501 field = V4L2_FIELD_SEQ_TB;
2504 case V4L2_FIELD_TOP:
2505 case V4L2_FIELD_BOTTOM:
2506 case V4L2_FIELD_ALTERNATE:
2507 case V4L2_FIELD_INTERLACED:
2509 case V4L2_FIELD_SEQ_TB:
2510 if (fmt->flags & FORMAT_FLAGS_PLANAR)
2517 width = f->fmt.pix.width;
2518 height = f->fmt.pix.height;
2520 rc = limit_scaled_size(fh, &width, &height, field,
2521 /* width_mask: 4 pixels */ ~3,
2522 /* width_bias: nearest */ 2,
2523 /* adjust_size */ 1,
2524 /* adjust_crop */ 0);
2528 /* update data for the application */
2529 f->fmt.pix.field = field;
2530 pix_format_set_size(&f->fmt.pix, fmt, width, height);
2535 static int bttv_try_fmt_vid_overlay(struct file *file, void *priv,
2536 struct v4l2_format *f)
2538 struct bttv_fh *fh = priv;
2540 return verify_window(fh, &f->fmt.win,
2541 /* adjust_size */ 1,
2542 /* adjust_crop */ 0);
2545 static int bttv_s_fmt_vid_cap(struct file *file, void *priv,
2546 struct v4l2_format *f)
2549 const struct bttv_format *fmt;
2550 struct bttv_fh *fh = priv;
2551 struct bttv *btv = fh->btv;
2552 __s32 width, height;
2553 enum v4l2_field field;
2555 retval = bttv_switch_type(fh, f->type);
2559 retval = bttv_try_fmt_vid_cap(file, priv, f);
2563 width = f->fmt.pix.width;
2564 height = f->fmt.pix.height;
2565 field = f->fmt.pix.field;
2567 retval = limit_scaled_size(fh, &width, &height, f->fmt.pix.field,
2568 /* width_mask: 4 pixels */ ~3,
2569 /* width_bias: nearest */ 2,
2570 /* adjust_size */ 1,
2571 /* adjust_crop */ 1);
2575 f->fmt.pix.field = field;
2577 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2579 /* update our state informations */
2580 mutex_lock(&fh->cap.vb_lock);
2582 fh->cap.field = f->fmt.pix.field;
2583 fh->cap.last = V4L2_FIELD_NONE;
2584 fh->width = f->fmt.pix.width;
2585 fh->height = f->fmt.pix.height;
2586 btv->init.fmt = fmt;
2587 btv->init.width = f->fmt.pix.width;
2588 btv->init.height = f->fmt.pix.height;
2589 mutex_unlock(&fh->cap.vb_lock);
2594 static int bttv_s_fmt_vid_overlay(struct file *file, void *priv,
2595 struct v4l2_format *f)
2597 struct bttv_fh *fh = priv;
2598 struct bttv *btv = fh->btv;
2600 if (no_overlay > 0) {
2601 printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2605 return setup_window(fh, btv, &f->fmt.win, 1);
2608 #ifdef CONFIG_VIDEO_V4L1_COMPAT
2609 static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
2613 struct bttv_fh *fh = priv;
2615 mutex_lock(&fh->cap.vb_lock);
2616 retval = __videobuf_mmap_setup(&fh->cap, gbuffers, gbufsize,
2619 mutex_unlock(&fh->cap.vb_lock);
2624 memset(mbuf, 0, sizeof(*mbuf));
2625 mbuf->frames = gbuffers;
2626 mbuf->size = gbuffers * gbufsize;
2628 for (i = 0; i < gbuffers; i++)
2629 mbuf->offsets[i] = i * gbufsize;
2631 mutex_unlock(&fh->cap.vb_lock);
2636 static int bttv_querycap(struct file *file, void *priv,
2637 struct v4l2_capability *cap)
2639 struct bttv_fh *fh = priv;
2640 struct bttv *btv = fh->btv;
2645 strlcpy(cap->driver, "bttv", sizeof(cap->driver));
2646 strlcpy(cap->card, btv->video_dev->name, sizeof(cap->card));
2647 snprintf(cap->bus_info, sizeof(cap->bus_info),
2648 "PCI:%s", pci_name(btv->c.pci));
2649 cap->version = BTTV_VERSION_CODE;
2651 V4L2_CAP_VIDEO_CAPTURE |
2652 V4L2_CAP_VBI_CAPTURE |
2653 V4L2_CAP_READWRITE |
2655 if (no_overlay <= 0)
2656 cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
2658 if (bttv_tvcards[btv->c.type].tuner != UNSET &&
2659 bttv_tvcards[btv->c.type].tuner != TUNER_ABSENT)
2660 cap->capabilities |= V4L2_CAP_TUNER;
2664 static int bttv_enum_fmt_vbi_cap(struct file *file, void *priv,
2665 struct v4l2_fmtdesc *f)
2670 f->pixelformat = V4L2_PIX_FMT_GREY;
2671 strcpy(f->description, "vbi data");
2676 static int bttv_enum_fmt_cap_ovr(struct v4l2_fmtdesc *f)
2680 for (i = 0; i < FORMATS; i++) {
2681 if (formats[i].fourcc != -1)
2683 if ((unsigned int)index == f->index)
2689 f->pixelformat = formats[i].fourcc;
2690 strlcpy(f->description, formats[i].name, sizeof(f->description));
2695 static int bttv_enum_fmt_vid_cap(struct file *file, void *priv,
2696 struct v4l2_fmtdesc *f)
2698 int rc = bttv_enum_fmt_cap_ovr(f);
2706 static int bttv_enum_fmt_vid_overlay(struct file *file, void *priv,
2707 struct v4l2_fmtdesc *f)
2711 if (no_overlay > 0) {
2712 printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2716 rc = bttv_enum_fmt_cap_ovr(f);
2721 if (!(formats[rc].flags & FORMAT_FLAGS_PACKED))
2727 static int bttv_g_fbuf(struct file *file, void *f,
2728 struct v4l2_framebuffer *fb)
2730 struct bttv_fh *fh = f;
2731 struct bttv *btv = fh->btv;
2734 fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
2736 fb->fmt.pixelformat = fh->ovfmt->fourcc;
2740 static int bttv_overlay(struct file *file, void *f, unsigned int on)
2742 struct bttv_fh *fh = f;
2743 struct bttv *btv = fh->btv;
2744 struct bttv_buffer *new;
2749 if (NULL == btv->fbuf.base)
2751 if (!fh->ov.setup_ok) {
2752 dprintk("bttv%d: overlay: !setup_ok\n", btv->c.nr);
2757 if (!check_alloc_btres(btv, fh, RESOURCE_OVERLAY))
2760 mutex_lock(&fh->cap.vb_lock);
2762 fh->ov.tvnorm = btv->tvnorm;
2763 new = videobuf_sg_alloc(sizeof(*new));
2764 new->crop = btv->crop[!!fh->do_crop].rect;
2765 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2771 retval = bttv_switch_overlay(btv, fh, new);
2772 mutex_unlock(&fh->cap.vb_lock);
2776 static int bttv_s_fbuf(struct file *file, void *f,
2777 struct v4l2_framebuffer *fb)
2779 struct bttv_fh *fh = f;
2780 struct bttv *btv = fh->btv;
2781 const struct bttv_format *fmt;
2784 if (!capable(CAP_SYS_ADMIN) &&
2785 !capable(CAP_SYS_RAWIO))
2789 fmt = format_by_fourcc(fb->fmt.pixelformat);
2792 if (0 == (fmt->flags & FORMAT_FLAGS_PACKED))
2796 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2797 __s32 width = fb->fmt.width;
2798 __s32 height = fb->fmt.height;
2800 retval = limit_scaled_size(fh, &width, &height,
2801 V4L2_FIELD_INTERLACED,
2802 /* width_mask */ ~3,
2804 /* adjust_size */ 0,
2805 /* adjust_crop */ 0);
2811 mutex_lock(&fh->cap.vb_lock);
2812 btv->fbuf.base = fb->base;
2813 btv->fbuf.fmt.width = fb->fmt.width;
2814 btv->fbuf.fmt.height = fb->fmt.height;
2815 if (0 != fb->fmt.bytesperline)
2816 btv->fbuf.fmt.bytesperline = fb->fmt.bytesperline;
2818 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fmt->depth/8;
2822 btv->init.ovfmt = fmt;
2823 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2826 fh->ov.w.width = fb->fmt.width;
2827 fh->ov.w.height = fb->fmt.height;
2828 btv->init.ov.w.width = fb->fmt.width;
2829 btv->init.ov.w.height = fb->fmt.height;
2830 kfree(fh->ov.clips);
2831 fh->ov.clips = NULL;
2834 if (check_btres(fh, RESOURCE_OVERLAY)) {
2835 struct bttv_buffer *new;
2837 new = videobuf_sg_alloc(sizeof(*new));
2838 new->crop = btv->crop[!!fh->do_crop].rect;
2839 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2840 retval = bttv_switch_overlay(btv, fh, new);
2843 mutex_unlock(&fh->cap.vb_lock);
2847 static int bttv_reqbufs(struct file *file, void *priv,
2848 struct v4l2_requestbuffers *p)
2850 struct bttv_fh *fh = priv;
2851 return videobuf_reqbufs(bttv_queue(fh), p);
2854 static int bttv_querybuf(struct file *file, void *priv,
2855 struct v4l2_buffer *b)
2857 struct bttv_fh *fh = priv;
2858 return videobuf_querybuf(bttv_queue(fh), b);
2861 static int bttv_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2863 struct bttv_fh *fh = priv;
2864 struct bttv *btv = fh->btv;
2865 int res = bttv_resource(fh);
2867 if (!check_alloc_btres(btv, fh, res))
2870 return videobuf_qbuf(bttv_queue(fh), b);
2873 static int bttv_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2875 struct bttv_fh *fh = priv;
2876 return videobuf_dqbuf(bttv_queue(fh), b,
2877 file->f_flags & O_NONBLOCK);
2880 static int bttv_streamon(struct file *file, void *priv,
2881 enum v4l2_buf_type type)
2883 struct bttv_fh *fh = priv;
2884 struct bttv *btv = fh->btv;
2885 int res = bttv_resource(fh);
2887 if (!check_alloc_btres(btv, fh, res))
2889 return videobuf_streamon(bttv_queue(fh));
2893 static int bttv_streamoff(struct file *file, void *priv,
2894 enum v4l2_buf_type type)
2896 struct bttv_fh *fh = priv;
2897 struct bttv *btv = fh->btv;
2899 int res = bttv_resource(fh);
2902 retval = videobuf_streamoff(bttv_queue(fh));
2905 free_btres(btv, fh, res);
2909 static int bttv_queryctrl(struct file *file, void *priv,
2910 struct v4l2_queryctrl *c)
2912 struct bttv_fh *fh = priv;
2913 struct bttv *btv = fh->btv;
2914 const struct v4l2_queryctrl *ctrl;
2916 if ((c->id < V4L2_CID_BASE ||
2917 c->id >= V4L2_CID_LASTP1) &&
2918 (c->id < V4L2_CID_PRIVATE_BASE ||
2919 c->id >= V4L2_CID_PRIVATE_LASTP1))
2922 if (!btv->volume_gpio && (c->id == V4L2_CID_AUDIO_VOLUME))
2925 ctrl = ctrl_by_id(c->id);
2927 *c = (NULL != ctrl) ? *ctrl : no_ctl;
2933 static int bttv_g_parm(struct file *file, void *f,
2934 struct v4l2_streamparm *parm)
2936 struct bttv_fh *fh = f;
2937 struct bttv *btv = fh->btv;
2938 struct v4l2_standard s;
2940 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2942 v4l2_video_std_construct(&s, bttv_tvnorms[btv->tvnorm].v4l2_id,
2943 bttv_tvnorms[btv->tvnorm].name);
2944 parm->parm.capture.timeperframe = s.frameperiod;
2948 static int bttv_g_tuner(struct file *file, void *priv,
2949 struct v4l2_tuner *t)
2951 struct bttv_fh *fh = priv;
2952 struct bttv *btv = fh->btv;
2954 if (UNSET == bttv_tvcards[btv->c.type].tuner)
2959 mutex_lock(&btv->lock);
2960 memset(t, 0, sizeof(*t));
2961 t->rxsubchans = V4L2_TUNER_SUB_MONO;
2962 bttv_call_i2c_clients(btv, VIDIOC_G_TUNER, t);
2963 strcpy(t->name, "Television");
2964 t->capability = V4L2_TUNER_CAP_NORM;
2965 t->type = V4L2_TUNER_ANALOG_TV;
2966 if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
2969 if (btv->audio_mode_gpio)
2970 btv->audio_mode_gpio(btv, t, 0);
2972 mutex_unlock(&btv->lock);
2976 static int bttv_g_priority(struct file *file, void *f, enum v4l2_priority *p)
2978 struct bttv_fh *fh = f;
2979 struct bttv *btv = fh->btv;
2981 *p = v4l2_prio_max(&btv->prio);
2986 static int bttv_s_priority(struct file *file, void *f,
2987 enum v4l2_priority prio)
2989 struct bttv_fh *fh = f;
2990 struct bttv *btv = fh->btv;
2992 return v4l2_prio_change(&btv->prio, &fh->prio, prio);
2995 static int bttv_cropcap(struct file *file, void *priv,
2996 struct v4l2_cropcap *cap)
2998 struct bttv_fh *fh = priv;
2999 struct bttv *btv = fh->btv;
3001 if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3002 cap->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3005 *cap = bttv_tvnorms[btv->tvnorm].cropcap;
3010 static int bttv_g_crop(struct file *file, void *f, struct v4l2_crop *crop)
3012 struct bttv_fh *fh = f;
3013 struct bttv *btv = fh->btv;
3015 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3016 crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3019 /* No fh->do_crop = 1; because btv->crop[1] may be
3020 inconsistent with fh->width or fh->height and apps
3021 do not expect a change here. */
3023 crop->c = btv->crop[!!fh->do_crop].rect;
3028 static int bttv_s_crop(struct file *file, void *f, struct v4l2_crop *crop)
3030 struct bttv_fh *fh = f;
3031 struct bttv *btv = fh->btv;
3032 const struct v4l2_rect *b;
3040 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3041 crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3044 retval = v4l2_prio_check(&btv->prio, &fh->prio);
3048 /* Make sure tvnorm, vbi_end and the current cropping
3049 parameters remain consistent until we're done. Note
3050 read() may change vbi_end in check_alloc_btres(). */
3051 mutex_lock(&btv->lock);
3055 if (locked_btres(fh->btv, VIDEO_RESOURCES)) {
3056 mutex_unlock(&btv->lock);
3060 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
3063 b_right = b_left + b->width;
3064 b_bottom = b->top + b->height;
3066 b_top = max(b->top, btv->vbi_end);
3067 if (b_top + 32 >= b_bottom) {
3068 mutex_unlock(&btv->lock);
3072 /* Min. scaled size 48 x 32. */
3073 c.rect.left = clamp(crop->c.left, b_left, b_right - 48);
3074 c.rect.left = min(c.rect.left, (__s32) MAX_HDELAY);
3076 c.rect.width = clamp(crop->c.width,
3077 48, b_right - c.rect.left);
3079 c.rect.top = clamp(crop->c.top, b_top, b_bottom - 32);
3080 /* Top and height must be a multiple of two. */
3081 c.rect.top = (c.rect.top + 1) & ~1;
3083 c.rect.height = clamp(crop->c.height,
3084 32, b_bottom - c.rect.top);
3085 c.rect.height = (c.rect.height + 1) & ~1;
3087 bttv_crop_calc_limits(&c);
3091 mutex_unlock(&btv->lock);
3095 mutex_lock(&fh->cap.vb_lock);
3097 if (fh->width < c.min_scaled_width) {
3098 fh->width = c.min_scaled_width;
3099 btv->init.width = c.min_scaled_width;
3100 } else if (fh->width > c.max_scaled_width) {
3101 fh->width = c.max_scaled_width;
3102 btv->init.width = c.max_scaled_width;
3105 if (fh->height < c.min_scaled_height) {
3106 fh->height = c.min_scaled_height;
3107 btv->init.height = c.min_scaled_height;
3108 } else if (fh->height > c.max_scaled_height) {
3109 fh->height = c.max_scaled_height;
3110 btv->init.height = c.max_scaled_height;
3113 mutex_unlock(&fh->cap.vb_lock);
3118 static int bttv_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
3120 if (unlikely(a->index))
3123 strcpy(a->name, "audio");
3127 static int bttv_s_audio(struct file *file, void *priv, struct v4l2_audio *a)
3129 if (unlikely(a->index))
3135 static ssize_t bttv_read(struct file *file, char __user *data,
3136 size_t count, loff_t *ppos)
3138 struct bttv_fh *fh = file->private_data;
3141 if (fh->btv->errors)
3142 bttv_reinit_bt848(fh->btv);
3143 dprintk("bttv%d: read count=%d type=%s\n",
3144 fh->btv->c.nr,(int)count,v4l2_type_names[fh->type]);
3147 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
3148 if (!check_alloc_btres(fh->btv, fh, RESOURCE_VIDEO_READ)) {
3149 /* VIDEO_READ in use by another fh,
3150 or VIDEO_STREAM by any fh. */
3153 retval = videobuf_read_one(&fh->cap, data, count, ppos,
3154 file->f_flags & O_NONBLOCK);
3155 free_btres(fh->btv, fh, RESOURCE_VIDEO_READ);
3157 case V4L2_BUF_TYPE_VBI_CAPTURE:
3158 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
3160 retval = videobuf_read_stream(&fh->vbi, data, count, ppos, 1,
3161 file->f_flags & O_NONBLOCK);
3169 static unsigned int bttv_poll(struct file *file, poll_table *wait)
3171 struct bttv_fh *fh = file->private_data;
3172 struct bttv_buffer *buf;
3173 enum v4l2_field field;
3175 if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
3176 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
3178 return videobuf_poll_stream(file, &fh->vbi, wait);
3181 if (check_btres(fh,RESOURCE_VIDEO_STREAM)) {
3182 /* streaming capture */
3183 if (list_empty(&fh->cap.stream))
3185 buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
3187 /* read() capture */
3188 mutex_lock(&fh->cap.vb_lock);
3189 if (NULL == fh->cap.read_buf) {
3190 /* need to capture a new frame */
3191 if (locked_btres(fh->btv,RESOURCE_VIDEO_STREAM))
3193 fh->cap.read_buf = videobuf_sg_alloc(fh->cap.msize);
3194 if (NULL == fh->cap.read_buf)
3196 fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
3197 field = videobuf_next_field(&fh->cap);
3198 if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) {
3199 kfree (fh->cap.read_buf);
3200 fh->cap.read_buf = NULL;
3203 fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
3204 fh->cap.read_off = 0;
3206 mutex_unlock(&fh->cap.vb_lock);
3207 buf = (struct bttv_buffer*)fh->cap.read_buf;
3210 poll_wait(file, &buf->vb.done, wait);
3211 if (buf->vb.state == VIDEOBUF_DONE ||
3212 buf->vb.state == VIDEOBUF_ERROR)
3213 return POLLIN|POLLRDNORM;
3216 mutex_unlock(&fh->cap.vb_lock);
3220 static int bttv_open(struct inode *inode, struct file *file)
3222 int minor = iminor(inode);
3223 struct bttv *btv = NULL;
3225 enum v4l2_buf_type type = 0;
3228 dprintk(KERN_DEBUG "bttv: open minor=%d\n",minor);
3231 for (i = 0; i < bttv_num; i++) {
3232 if (bttvs[i].video_dev &&
3233 bttvs[i].video_dev->minor == minor) {
3235 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
3238 if (bttvs[i].vbi_dev &&
3239 bttvs[i].vbi_dev->minor == minor) {
3241 type = V4L2_BUF_TYPE_VBI_CAPTURE;
3250 dprintk(KERN_DEBUG "bttv%d: open called (type=%s)\n",
3251 btv->c.nr,v4l2_type_names[type]);
3253 /* allocate per filehandle data */
3254 fh = kmalloc(sizeof(*fh),GFP_KERNEL);
3259 file->private_data = fh;
3262 fh->ov.setup_ok = 0;
3263 v4l2_prio_open(&btv->prio,&fh->prio);
3265 videobuf_queue_sg_init(&fh->cap, &bttv_video_qops,
3266 &btv->c.pci->dev, &btv->s_lock,
3267 V4L2_BUF_TYPE_VIDEO_CAPTURE,
3268 V4L2_FIELD_INTERLACED,
3269 sizeof(struct bttv_buffer),
3271 videobuf_queue_sg_init(&fh->vbi, &bttv_vbi_qops,
3272 &btv->c.pci->dev, &btv->s_lock,
3273 V4L2_BUF_TYPE_VBI_CAPTURE,
3275 sizeof(struct bttv_buffer),
3277 set_tvnorm(btv,btv->tvnorm);
3278 set_input(btv, btv->input, btv->tvnorm);
3282 /* The V4L2 spec requires one global set of cropping parameters
3283 which only change on request. These are stored in btv->crop[1].
3284 However for compatibility with V4L apps and cropping unaware
3285 V4L2 apps we now reset the cropping parameters as seen through
3286 this fh, which is to say VIDIOC_G_CROP and scaling limit checks
3287 will use btv->crop[0], the default cropping parameters for the
3288 current video standard, and VIDIOC_S_FMT will not implicitely
3289 change the cropping parameters until VIDIOC_S_CROP has been
3291 fh->do_crop = !reset_crop; /* module parameter */
3293 /* Likewise there should be one global set of VBI capture
3294 parameters, but for compatibility with V4L apps and earlier
3295 driver versions each fh has its own parameters. */
3296 bttv_vbi_fmt_reset(&fh->vbi_fmt, btv->tvnorm);
3298 bttv_field_count(btv);
3303 static int bttv_release(struct inode *inode, struct file *file)
3305 struct bttv_fh *fh = file->private_data;
3306 struct bttv *btv = fh->btv;
3308 /* turn off overlay */
3309 if (check_btres(fh, RESOURCE_OVERLAY))
3310 bttv_switch_overlay(btv,fh,NULL);
3312 /* stop video capture */
3313 if (check_btres(fh, RESOURCE_VIDEO_STREAM)) {
3314 videobuf_streamoff(&fh->cap);
3315 free_btres(btv,fh,RESOURCE_VIDEO_STREAM);
3317 if (fh->cap.read_buf) {
3318 buffer_release(&fh->cap,fh->cap.read_buf);
3319 kfree(fh->cap.read_buf);
3321 if (check_btres(fh, RESOURCE_VIDEO_READ)) {
3322 free_btres(btv, fh, RESOURCE_VIDEO_READ);
3325 /* stop vbi capture */
3326 if (check_btres(fh, RESOURCE_VBI)) {
3327 videobuf_stop(&fh->vbi);
3328 free_btres(btv,fh,RESOURCE_VBI);
3332 videobuf_mmap_free(&fh->cap);
3333 videobuf_mmap_free(&fh->vbi);
3334 v4l2_prio_close(&btv->prio,&fh->prio);
3335 file->private_data = NULL;
3339 bttv_field_count(btv);
3348 bttv_mmap(struct file *file, struct vm_area_struct *vma)
3350 struct bttv_fh *fh = file->private_data;
3352 dprintk("bttv%d: mmap type=%s 0x%lx+%ld\n",
3353 fh->btv->c.nr, v4l2_type_names[fh->type],
3354 vma->vm_start, vma->vm_end - vma->vm_start);
3355 return videobuf_mmap_mapper(bttv_queue(fh),vma);
3358 static const struct file_operations bttv_fops =
3360 .owner = THIS_MODULE,
3362 .release = bttv_release,
3363 .ioctl = video_ioctl2,
3364 .compat_ioctl = v4l_compat_ioctl32,
3365 .llseek = no_llseek,
3371 static const struct v4l2_ioctl_ops bttv_ioctl_ops = {
3372 .vidioc_querycap = bttv_querycap,
3373 .vidioc_enum_fmt_vid_cap = bttv_enum_fmt_vid_cap,
3374 .vidioc_g_fmt_vid_cap = bttv_g_fmt_vid_cap,
3375 .vidioc_try_fmt_vid_cap = bttv_try_fmt_vid_cap,
3376 .vidioc_s_fmt_vid_cap = bttv_s_fmt_vid_cap,
3377 .vidioc_enum_fmt_vid_overlay = bttv_enum_fmt_vid_overlay,
3378 .vidioc_g_fmt_vid_overlay = bttv_g_fmt_vid_overlay,
3379 .vidioc_try_fmt_vid_overlay = bttv_try_fmt_vid_overlay,
3380 .vidioc_s_fmt_vid_overlay = bttv_s_fmt_vid_overlay,
3381 .vidioc_enum_fmt_vbi_cap = bttv_enum_fmt_vbi_cap,
3382 .vidioc_g_fmt_vbi_cap = bttv_g_fmt_vbi_cap,
3383 .vidioc_try_fmt_vbi_cap = bttv_try_fmt_vbi_cap,
3384 .vidioc_s_fmt_vbi_cap = bttv_s_fmt_vbi_cap,
3385 .vidioc_g_audio = bttv_g_audio,
3386 .vidioc_s_audio = bttv_s_audio,
3387 .vidioc_cropcap = bttv_cropcap,
3388 .vidioc_reqbufs = bttv_reqbufs,
3389 .vidioc_querybuf = bttv_querybuf,
3390 .vidioc_qbuf = bttv_qbuf,
3391 .vidioc_dqbuf = bttv_dqbuf,
3392 .vidioc_s_std = bttv_s_std,
3393 .vidioc_enum_input = bttv_enum_input,
3394 .vidioc_g_input = bttv_g_input,
3395 .vidioc_s_input = bttv_s_input,
3396 .vidioc_queryctrl = bttv_queryctrl,
3397 .vidioc_g_ctrl = bttv_g_ctrl,
3398 .vidioc_s_ctrl = bttv_s_ctrl,
3399 .vidioc_streamon = bttv_streamon,
3400 .vidioc_streamoff = bttv_streamoff,
3401 .vidioc_g_tuner = bttv_g_tuner,
3402 .vidioc_s_tuner = bttv_s_tuner,
3403 #ifdef CONFIG_VIDEO_V4L1_COMPAT
3404 .vidiocgmbuf = vidiocgmbuf,
3406 .vidioc_g_crop = bttv_g_crop,
3407 .vidioc_s_crop = bttv_s_crop,
3408 .vidioc_g_fbuf = bttv_g_fbuf,
3409 .vidioc_s_fbuf = bttv_s_fbuf,
3410 .vidioc_overlay = bttv_overlay,
3411 .vidioc_g_priority = bttv_g_priority,
3412 .vidioc_s_priority = bttv_s_priority,
3413 .vidioc_g_parm = bttv_g_parm,
3414 .vidioc_g_frequency = bttv_g_frequency,
3415 .vidioc_s_frequency = bttv_s_frequency,
3416 .vidioc_log_status = bttv_log_status,
3417 .vidioc_querystd = bttv_querystd,
3418 #ifdef CONFIG_VIDEO_ADV_DEBUG
3419 .vidioc_g_register = bttv_g_register,
3420 .vidioc_s_register = bttv_s_register,
3424 static struct video_device bttv_video_template = {
3427 .ioctl_ops = &bttv_ioctl_ops,
3428 .tvnorms = BTTV_NORMS,
3429 .current_norm = V4L2_STD_PAL,
3432 /* ----------------------------------------------------------------------- */
3433 /* radio interface */
3435 static int radio_open(struct inode *inode, struct file *file)
3437 int minor = iminor(inode);
3438 struct bttv *btv = NULL;
3442 dprintk("bttv: open minor=%d\n",minor);
3445 for (i = 0; i < bttv_num; i++) {
3446 if (bttvs[i].radio_dev && bttvs[i].radio_dev->minor == minor) {
3456 dprintk("bttv%d: open called (radio)\n",btv->c.nr);
3458 /* allocate per filehandle data */
3459 fh = kmalloc(sizeof(*fh), GFP_KERNEL);
3464 file->private_data = fh;
3466 v4l2_prio_open(&btv->prio, &fh->prio);
3468 mutex_lock(&btv->lock);
3472 bttv_call_i2c_clients(btv,AUDC_SET_RADIO,NULL);
3473 audio_input(btv,TVAUDIO_INPUT_RADIO);
3475 mutex_unlock(&btv->lock);
3480 static int radio_release(struct inode *inode, struct file *file)
3482 struct bttv_fh *fh = file->private_data;
3483 struct bttv *btv = fh->btv;
3484 struct rds_command cmd;
3486 file->private_data = NULL;
3491 bttv_call_i2c_clients(btv, RDS_CMD_CLOSE, &cmd);
3496 static int radio_querycap(struct file *file, void *priv,
3497 struct v4l2_capability *cap)
3499 struct bttv_fh *fh = priv;
3500 struct bttv *btv = fh->btv;
3502 strcpy(cap->driver, "bttv");
3503 strlcpy(cap->card, btv->radio_dev->name, sizeof(cap->card));
3504 sprintf(cap->bus_info, "PCI:%s", pci_name(btv->c.pci));
3505 cap->version = BTTV_VERSION_CODE;
3506 cap->capabilities = V4L2_CAP_TUNER;
3511 static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
3513 struct bttv_fh *fh = priv;
3514 struct bttv *btv = fh->btv;
3516 if (UNSET == bttv_tvcards[btv->c.type].tuner)
3520 mutex_lock(&btv->lock);
3521 memset(t, 0, sizeof(*t));
3522 strcpy(t->name, "Radio");
3523 t->type = V4L2_TUNER_RADIO;
3525 bttv_call_i2c_clients(btv, VIDIOC_G_TUNER, t);
3527 if (btv->audio_mode_gpio)
3528 btv->audio_mode_gpio(btv, t, 0);
3530 mutex_unlock(&btv->lock);
3535 static int radio_enum_input(struct file *file, void *priv,
3536 struct v4l2_input *i)
3541 strcpy(i->name, "Radio");
3542 i->type = V4L2_INPUT_TYPE_TUNER;
3547 static int radio_g_audio(struct file *file, void *priv,
3548 struct v4l2_audio *a)
3550 if (unlikely(a->index))
3553 strcpy(a->name, "Radio");
3558 static int radio_s_tuner(struct file *file, void *priv,
3559 struct v4l2_tuner *t)
3561 struct bttv_fh *fh = priv;
3562 struct bttv *btv = fh->btv;
3567 bttv_call_i2c_clients(btv, VIDIOC_G_TUNER, t);
3571 static int radio_s_audio(struct file *file, void *priv,
3572 struct v4l2_audio *a)
3574 if (unlikely(a->index))
3580 static int radio_s_input(struct file *filp, void *priv, unsigned int i)
3588 static int radio_s_std(struct file *file, void *fh, v4l2_std_id *norm)
3593 static int radio_queryctrl(struct file *file, void *priv,
3594 struct v4l2_queryctrl *c)
3596 const struct v4l2_queryctrl *ctrl;
3598 if (c->id < V4L2_CID_BASE ||
3599 c->id >= V4L2_CID_LASTP1)
3602 if (c->id == V4L2_CID_AUDIO_MUTE) {
3603 ctrl = ctrl_by_id(c->id);
3611 static int radio_g_input(struct file *filp, void *priv, unsigned int *i)
3617 static ssize_t radio_read(struct file *file, char __user *data,
3618 size_t count, loff_t *ppos)
3620 struct bttv_fh *fh = file->private_data;
3621 struct bttv *btv = fh->btv;
3622 struct rds_command cmd;
3623 cmd.block_count = count/3;
3625 cmd.instance = file;
3626 cmd.result = -ENODEV;
3628 bttv_call_i2c_clients(btv, RDS_CMD_READ, &cmd);
3633 static unsigned int radio_poll(struct file *file, poll_table *wait)
3635 struct bttv_fh *fh = file->private_data;
3636 struct bttv *btv = fh->btv;
3637 struct rds_command cmd;
3638 cmd.instance = file;
3639 cmd.event_list = wait;
3640 cmd.result = -ENODEV;
3641 bttv_call_i2c_clients(btv, RDS_CMD_POLL, &cmd);
3646 static const struct file_operations radio_fops =
3648 .owner = THIS_MODULE,
3651 .release = radio_release,
3652 .compat_ioctl = v4l_compat_ioctl32,
3653 .ioctl = video_ioctl2,
3654 .llseek = no_llseek,
3658 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
3659 .vidioc_querycap = radio_querycap,
3660 .vidioc_g_tuner = radio_g_tuner,
3661 .vidioc_enum_input = radio_enum_input,
3662 .vidioc_g_audio = radio_g_audio,
3663 .vidioc_s_tuner = radio_s_tuner,
3664 .vidioc_s_audio = radio_s_audio,
3665 .vidioc_s_input = radio_s_input,
3666 .vidioc_s_std = radio_s_std,
3667 .vidioc_queryctrl = radio_queryctrl,
3668 .vidioc_g_input = radio_g_input,
3669 .vidioc_g_ctrl = bttv_g_ctrl,
3670 .vidioc_s_ctrl = bttv_s_ctrl,
3671 .vidioc_g_frequency = bttv_g_frequency,
3672 .vidioc_s_frequency = bttv_s_frequency,
3675 static struct video_device radio_template = {
3676 .fops = &radio_fops,
3678 .ioctl_ops = &radio_ioctl_ops,
3681 /* ----------------------------------------------------------------------- */
3682 /* some debug code */
3684 static int bttv_risc_decode(u32 risc)
3686 static char *instr[16] = {
3687 [ BT848_RISC_WRITE >> 28 ] = "write",
3688 [ BT848_RISC_SKIP >> 28 ] = "skip",
3689 [ BT848_RISC_WRITEC >> 28 ] = "writec",
3690 [ BT848_RISC_JUMP >> 28 ] = "jump",
3691 [ BT848_RISC_SYNC >> 28 ] = "sync",
3692 [ BT848_RISC_WRITE123 >> 28 ] = "write123",
3693 [ BT848_RISC_SKIP123 >> 28 ] = "skip123",
3694 [ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
3696 static int incr[16] = {
3697 [ BT848_RISC_WRITE >> 28 ] = 2,
3698 [ BT848_RISC_JUMP >> 28 ] = 2,
3699 [ BT848_RISC_SYNC >> 28 ] = 2,
3700 [ BT848_RISC_WRITE123 >> 28 ] = 5,
3701 [ BT848_RISC_SKIP123 >> 28 ] = 2,
3702 [ BT848_RISC_WRITE1S23 >> 28 ] = 3,
3704 static char *bits[] = {
3705 "be0", "be1", "be2", "be3/resync",
3706 "set0", "set1", "set2", "set3",
3707 "clr0", "clr1", "clr2", "clr3",
3708 "irq", "res", "eol", "sol",
3712 printk("0x%08x [ %s", risc,
3713 instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
3714 for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
3715 if (risc & (1 << (i + 12)))
3716 printk(" %s",bits[i]);
3717 printk(" count=%d ]\n", risc & 0xfff);
3718 return incr[risc >> 28] ? incr[risc >> 28] : 1;
3721 static void bttv_risc_disasm(struct bttv *btv,
3722 struct btcx_riscmem *risc)
3726 printk("%s: risc disasm: %p [dma=0x%08lx]\n",
3727 btv->c.name, risc->cpu, (unsigned long)risc->dma);
3728 for (i = 0; i < (risc->size >> 2); i += n) {
3729 printk("%s: 0x%lx: ", btv->c.name,
3730 (unsigned long)(risc->dma + (i<<2)));
3731 n = bttv_risc_decode(le32_to_cpu(risc->cpu[i]));
3732 for (j = 1; j < n; j++)
3733 printk("%s: 0x%lx: 0x%08x [ arg #%d ]\n",
3734 btv->c.name, (unsigned long)(risc->dma + ((i+j)<<2)),
3736 if (0 == risc->cpu[i])
3741 static void bttv_print_riscaddr(struct bttv *btv)
3743 printk(" main: %08Lx\n",
3744 (unsigned long long)btv->main.dma);
3745 printk(" vbi : o=%08Lx e=%08Lx\n",
3746 btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
3747 btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
3748 printk(" cap : o=%08Lx e=%08Lx\n",
3749 btv->curr.top ? (unsigned long long)btv->curr.top->top.dma : 0,
3750 btv->curr.bottom ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
3751 printk(" scr : o=%08Lx e=%08Lx\n",
3752 btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
3753 btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
3754 bttv_risc_disasm(btv, &btv->main);
3757 /* ----------------------------------------------------------------------- */
3760 static char *irq_name[] = {
3761 "FMTCHG", // format change detected (525 vs. 625)
3762 "VSYNC", // vertical sync (new field)
3763 "HSYNC", // horizontal sync
3764 "OFLOW", // chroma/luma AGC overflow
3765 "HLOCK", // horizontal lock changed
3766 "VPRES", // video presence changed
3768 "I2CDONE", // hw irc operation finished
3769 "GPINT", // gpio port triggered irq
3771 "RISCI", // risc instruction triggered irq
3772 "FBUS", // pixel data fifo dropped data (high pci bus latencies)
3773 "FTRGT", // pixel data fifo overrun
3774 "FDSR", // fifo data stream resyncronisation
3775 "PPERR", // parity error (data transfer)
3776 "RIPERR", // parity error (read risc instructions)
3777 "PABORT", // pci abort
3778 "OCERR", // risc instruction error
3779 "SCERR", // syncronisation error
3782 static void bttv_print_irqbits(u32 print, u32 mark)
3787 for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
3788 if (print & (1 << i))
3789 printk(" %s",irq_name[i]);
3790 if (mark & (1 << i))
3795 static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
3797 printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
3799 (unsigned long)btv->main.dma,
3800 (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_VBI+1]),
3801 (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_FIELD+1]),
3804 if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) {
3805 printk("bttv%d: Oh, there (temporarely?) is no input signal. "
3806 "Ok, then this is harmless, don't worry ;)\n",
3810 printk("bttv%d: Uhm. Looks like we have unusual high IRQ latencies.\n",
3812 printk("bttv%d: Lets try to catch the culpit red-handed ...\n",
3818 bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set)
3820 struct bttv_buffer *item;
3822 memset(set,0,sizeof(*set));
3824 /* capture request ? */
3825 if (!list_empty(&btv->capture)) {
3827 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3828 if (V4L2_FIELD_HAS_TOP(item->vb.field))
3830 if (V4L2_FIELD_HAS_BOTTOM(item->vb.field))
3833 /* capture request for other field ? */
3834 if (!V4L2_FIELD_HAS_BOTH(item->vb.field) &&
3835 (item->vb.queue.next != &btv->capture)) {
3836 item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue);
3837 if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) {
3838 if (NULL == set->top &&
3839 V4L2_FIELD_TOP == item->vb.field) {
3842 if (NULL == set->bottom &&
3843 V4L2_FIELD_BOTTOM == item->vb.field) {
3846 if (NULL != set->top && NULL != set->bottom)
3852 /* screen overlay ? */
3853 if (NULL != btv->screen) {
3854 if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) {
3855 if (NULL == set->top && NULL == set->bottom) {
3856 set->top = btv->screen;
3857 set->bottom = btv->screen;
3860 if (V4L2_FIELD_TOP == btv->screen->vb.field &&
3862 set->top = btv->screen;
3864 if (V4L2_FIELD_BOTTOM == btv->screen->vb.field &&
3865 NULL == set->bottom) {
3866 set->bottom = btv->screen;
3871 dprintk("bttv%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
3872 btv->c.nr,set->top, set->bottom,
3873 btv->screen,set->frame_irq,set->top_irq);
3878 bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
3879 struct bttv_buffer_set *curr, unsigned int state)
3883 do_gettimeofday(&ts);
3885 if (wakeup->top == wakeup->bottom) {
3886 if (NULL != wakeup->top && curr->top != wakeup->top) {
3888 printk("bttv%d: wakeup: both=%p\n",btv->c.nr,wakeup->top);
3889 wakeup->top->vb.ts = ts;
3890 wakeup->top->vb.field_count = btv->field_count;
3891 wakeup->top->vb.state = state;
3892 wake_up(&wakeup->top->vb.done);
3895 if (NULL != wakeup->top && curr->top != wakeup->top) {
3897 printk("bttv%d: wakeup: top=%p\n",btv->c.nr,wakeup->top);
3898 wakeup->top->vb.ts = ts;
3899 wakeup->top->vb.field_count = btv->field_count;
3900 wakeup->top->vb.state = state;
3901 wake_up(&wakeup->top->vb.done);
3903 if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
3905 printk("bttv%d: wakeup: bottom=%p\n",btv->c.nr,wakeup->bottom);
3906 wakeup->bottom->vb.ts = ts;
3907 wakeup->bottom->vb.field_count = btv->field_count;
3908 wakeup->bottom->vb.state = state;
3909 wake_up(&wakeup->bottom->vb.done);
3915 bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
3923 do_gettimeofday(&ts);
3925 wakeup->vb.field_count = btv->field_count;
3926 wakeup->vb.state = state;
3927 wake_up(&wakeup->vb.done);
3930 static void bttv_irq_timeout(unsigned long data)
3932 struct bttv *btv = (struct bttv *)data;
3933 struct bttv_buffer_set old,new;
3934 struct bttv_buffer *ovbi;
3935 struct bttv_buffer *item;
3936 unsigned long flags;
3939 printk(KERN_INFO "bttv%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
3940 btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
3941 btread(BT848_RISC_COUNT));
3942 bttv_print_irqbits(btread(BT848_INT_STAT),0);
3946 spin_lock_irqsave(&btv->s_lock,flags);
3948 /* deactivate stuff */
3949 memset(&new,0,sizeof(new));
3955 bttv_buffer_activate_video(btv, &new);
3956 bttv_buffer_activate_vbi(btv, NULL);
3957 bttv_set_dma(btv, 0);
3960 bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_ERROR);
3961 bttv_irq_wakeup_vbi(btv, ovbi, VIDEOBUF_ERROR);
3963 /* cancel all outstanding capture / vbi requests */
3964 while (!list_empty(&btv->capture)) {
3965 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3966 list_del(&item->vb.queue);
3967 item->vb.state = VIDEOBUF_ERROR;
3968 wake_up(&item->vb.done);
3970 while (!list_empty(&btv->vcapture)) {
3971 item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3972 list_del(&item->vb.queue);
3973 item->vb.state = VIDEOBUF_ERROR;
3974 wake_up(&item->vb.done);
3978 spin_unlock_irqrestore(&btv->s_lock,flags);
3982 bttv_irq_wakeup_top(struct bttv *btv)
3984 struct bttv_buffer *wakeup = btv->curr.top;
3989 spin_lock(&btv->s_lock);
3990 btv->curr.top_irq = 0;
3991 btv->curr.top = NULL;
3992 bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
3994 do_gettimeofday(&wakeup->vb.ts);
3995 wakeup->vb.field_count = btv->field_count;
3996 wakeup->vb.state = VIDEOBUF_DONE;
3997 wake_up(&wakeup->vb.done);
3998 spin_unlock(&btv->s_lock);
4001 static inline int is_active(struct btcx_riscmem *risc, u32 rc)
4005 if (rc > risc->dma + risc->size)
4011 bttv_irq_switch_video(struct bttv *btv)
4013 struct bttv_buffer_set new;
4014 struct bttv_buffer_set old;
4017 spin_lock(&btv->s_lock);
4019 /* new buffer set */
4020 bttv_irq_next_video(btv, &new);
4021 rc = btread(BT848_RISC_COUNT);
4022 if ((btv->curr.top && is_active(&btv->curr.top->top, rc)) ||
4023 (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) {
4026 bttv_irq_debug_low_latency(btv, rc);
4027 spin_unlock(&btv->s_lock);
4034 btv->loop_irq &= ~1;
4035 bttv_buffer_activate_video(btv, &new);
4036 bttv_set_dma(btv, 0);
4039 if (UNSET != btv->new_input) {
4040 video_mux(btv,btv->new_input);
4041 btv->new_input = UNSET;
4044 /* wake up finished buffers */
4045 bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_DONE);
4046 spin_unlock(&btv->s_lock);
4050 bttv_irq_switch_vbi(struct bttv *btv)
4052 struct bttv_buffer *new = NULL;
4053 struct bttv_buffer *old;
4056 spin_lock(&btv->s_lock);
4058 if (!list_empty(&btv->vcapture))
4059 new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
4062 rc = btread(BT848_RISC_COUNT);
4063 if (NULL != old && (is_active(&old->top, rc) ||
4064 is_active(&old->bottom, rc))) {
4067 bttv_irq_debug_low_latency(btv, rc);
4068 spin_unlock(&btv->s_lock);
4074 btv->loop_irq &= ~4;
4075 bttv_buffer_activate_vbi(btv, new);
4076 bttv_set_dma(btv, 0);
4078 bttv_irq_wakeup_vbi(btv, old, VIDEOBUF_DONE);
4079 spin_unlock(&btv->s_lock);
4082 static irqreturn_t bttv_irq(int irq, void *dev_id)
4090 btv=(struct bttv *)dev_id;
4092 if (btv->custom_irq)
4093 handled = btv->custom_irq(btv);
4097 /* get/clear interrupt status bits */
4098 stat=btread(BT848_INT_STAT);
4099 astat=stat&btread(BT848_INT_MASK);
4103 btwrite(stat,BT848_INT_STAT);
4105 /* get device status bits */
4106 dstat=btread(BT848_DSTATUS);
4109 printk(KERN_DEBUG "bttv%d: irq loop=%d fc=%d "
4110 "riscs=%x, riscc=%08x, ",
4111 btv->c.nr, count, btv->field_count,
4112 stat>>28, btread(BT848_RISC_COUNT));
4113 bttv_print_irqbits(stat,astat);
4114 if (stat & BT848_INT_HLOCK)
4115 printk(" HLOC => %s", (dstat & BT848_DSTATUS_HLOC)
4117 if (stat & BT848_INT_VPRES)
4118 printk(" PRES => %s", (dstat & BT848_DSTATUS_PRES)
4120 if (stat & BT848_INT_FMTCHG)
4121 printk(" NUML => %s", (dstat & BT848_DSTATUS_NUML)
4126 if (astat&BT848_INT_VSYNC)
4129 if ((astat & BT848_INT_GPINT) && btv->remote) {
4130 wake_up(&btv->gpioq);
4131 bttv_input_irq(btv);
4134 if (astat & BT848_INT_I2CDONE) {
4135 btv->i2c_done = stat;
4136 wake_up(&btv->i2c_queue);
4139 if ((astat & BT848_INT_RISCI) && (stat & (4<<28)))
4140 bttv_irq_switch_vbi(btv);
4142 if ((astat & BT848_INT_RISCI) && (stat & (2<<28)))
4143 bttv_irq_wakeup_top(btv);
4145 if ((astat & BT848_INT_RISCI) && (stat & (1<<28)))
4146 bttv_irq_switch_video(btv);
4148 if ((astat & BT848_INT_HLOCK) && btv->opt_automute)
4149 audio_mute(btv, btv->mute); /* trigger automute */
4151 if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
4152 printk(KERN_INFO "bttv%d: %s%s @ %08x,",btv->c.nr,
4153 (astat & BT848_INT_SCERR) ? "SCERR" : "",
4154 (astat & BT848_INT_OCERR) ? "OCERR" : "",
4155 btread(BT848_RISC_COUNT));
4156 bttv_print_irqbits(stat,astat);
4159 bttv_print_riscaddr(btv);
4161 if (fdsr && astat & BT848_INT_FDSR) {
4162 printk(KERN_INFO "bttv%d: FDSR @ %08x\n",
4163 btv->c.nr,btread(BT848_RISC_COUNT));
4165 bttv_print_riscaddr(btv);
4171 if (count > 8 || !(astat & BT848_INT_GPINT)) {
4172 btwrite(0, BT848_INT_MASK);
4175 "bttv%d: IRQ lockup, cleared int mask [", btv->c.nr);
4178 "bttv%d: IRQ lockup, clearing GPINT from int mask [", btv->c.nr);
4180 btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT),
4184 bttv_print_irqbits(stat,astat);
4192 return IRQ_RETVAL(handled);
4196 /* ----------------------------------------------------------------------- */
4197 /* initialitation */
4199 static struct video_device *vdev_init(struct bttv *btv,
4200 const struct video_device *template,
4201 const char *type_name)
4203 struct video_device *vfd;
4205 vfd = video_device_alloc();
4210 vfd->parent = &btv->c.pci->dev;
4211 vfd->release = video_device_release;
4212 vfd->debug = bttv_debug;
4213 snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
4214 btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
4215 type_name, bttv_tvcards[btv->c.type].name);
4219 static void bttv_unregister_video(struct bttv *btv)
4221 if (btv->video_dev) {
4222 if (-1 != btv->video_dev->minor)
4223 video_unregister_device(btv->video_dev);
4225 video_device_release(btv->video_dev);
4226 btv->video_dev = NULL;
4229 if (-1 != btv->vbi_dev->minor)
4230 video_unregister_device(btv->vbi_dev);
4232 video_device_release(btv->vbi_dev);
4233 btv->vbi_dev = NULL;
4235 if (btv->radio_dev) {
4236 if (-1 != btv->radio_dev->minor)
4237 video_unregister_device(btv->radio_dev);
4239 video_device_release(btv->radio_dev);
4240 btv->radio_dev = NULL;
4244 /* register video4linux devices */
4245 static int __devinit bttv_register_video(struct bttv *btv)
4248 printk("bttv: Overlay support disabled.\n");
4251 btv->video_dev = vdev_init(btv, &bttv_video_template, "video");
4253 if (NULL == btv->video_dev)
4255 if (video_register_device(btv->video_dev,VFL_TYPE_GRABBER,video_nr)<0)
4257 printk(KERN_INFO "bttv%d: registered device video%d\n",
4258 btv->c.nr,btv->video_dev->minor & 0x1f);
4259 if (device_create_file(&btv->video_dev->dev,
4260 &dev_attr_card)<0) {
4261 printk(KERN_ERR "bttv%d: device_create_file 'card' "
4262 "failed\n", btv->c.nr);
4267 btv->vbi_dev = vdev_init(btv, &bttv_video_template, "vbi");
4269 if (NULL == btv->vbi_dev)
4271 if (video_register_device(btv->vbi_dev,VFL_TYPE_VBI,vbi_nr)<0)
4273 printk(KERN_INFO "bttv%d: registered device vbi%d\n",
4274 btv->c.nr,btv->vbi_dev->minor & 0x1f);
4276 if (!btv->has_radio)
4279 btv->radio_dev = vdev_init(btv, &radio_template, "radio");
4280 if (NULL == btv->radio_dev)
4282 if (video_register_device(btv->radio_dev, VFL_TYPE_RADIO,radio_nr)<0)
4284 printk(KERN_INFO "bttv%d: registered device radio%d\n",
4285 btv->c.nr,btv->radio_dev->minor & 0x1f);
4291 bttv_unregister_video(btv);
4296 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
4297 /* response on cards with no firmware is not enabled by OF */
4298 static void pci_set_command(struct pci_dev *dev)
4300 #if defined(__powerpc__)
4303 pci_read_config_dword(dev, PCI_COMMAND, &cmd);
4304 cmd = (cmd | PCI_COMMAND_MEMORY );
4305 pci_write_config_dword(dev, PCI_COMMAND, cmd);
4309 static int __devinit bttv_probe(struct pci_dev *dev,
4310 const struct pci_device_id *pci_id)
4316 if (bttv_num == BTTV_MAX)
4318 printk(KERN_INFO "bttv: Bt8xx card found (%d).\n", bttv_num);
4319 btv=&bttvs[bttv_num];
4320 memset(btv,0,sizeof(*btv));
4321 btv->c.nr = bttv_num;
4322 sprintf(btv->c.name,"bttv%d",btv->c.nr);
4324 /* initialize structs / fill in defaults */
4325 mutex_init(&btv->lock);
4326 spin_lock_init(&btv->s_lock);
4327 spin_lock_init(&btv->gpio_lock);
4328 init_waitqueue_head(&btv->gpioq);
4329 init_waitqueue_head(&btv->i2c_queue);
4330 INIT_LIST_HEAD(&btv->c.subs);
4331 INIT_LIST_HEAD(&btv->capture);
4332 INIT_LIST_HEAD(&btv->vcapture);
4333 v4l2_prio_init(&btv->prio);
4335 init_timer(&btv->timeout);
4336 btv->timeout.function = bttv_irq_timeout;
4337 btv->timeout.data = (unsigned long)btv;
4340 btv->tuner_type = UNSET;
4341 btv->new_input = UNSET;
4342 btv->has_radio=radio[btv->c.nr];
4344 /* pci stuff (init, get irq/mmio, ... */
4346 btv->id = dev->device;
4347 if (pci_enable_device(dev)) {
4348 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4352 if (pci_set_dma_mask(dev, DMA_32BIT_MASK)) {
4353 printk(KERN_WARNING "bttv%d: No suitable DMA available.\n",
4357 if (!request_mem_region(pci_resource_start(dev,0),
4358 pci_resource_len(dev,0),
4360 printk(KERN_WARNING "bttv%d: can't request iomem (0x%llx).\n",
4362 (unsigned long long)pci_resource_start(dev,0));
4365 pci_set_master(dev);
4366 pci_set_command(dev);
4367 pci_set_drvdata(dev,btv);
4369 pci_read_config_byte(dev, PCI_CLASS_REVISION, &btv->revision);
4370 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
4371 printk(KERN_INFO "bttv%d: Bt%d (rev %d) at %s, ",
4372 bttv_num,btv->id, btv->revision, pci_name(dev));
4373 printk("irq: %d, latency: %d, mmio: 0x%llx\n",
4374 btv->c.pci->irq, lat,
4375 (unsigned long long)pci_resource_start(dev,0));
4378 btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), 0x1000);
4379 if (NULL == btv->bt848_mmio) {
4380 printk("bttv%d: ioremap() failed\n", btv->c.nr);
4388 /* disable irqs, register irq handler */
4389 btwrite(0, BT848_INT_MASK);
4390 result = request_irq(btv->c.pci->irq, bttv_irq,
4391 IRQF_SHARED | IRQF_DISABLED,btv->c.name,(void *)btv);
4393 printk(KERN_ERR "bttv%d: can't get IRQ %d\n",
4394 bttv_num,btv->c.pci->irq);
4398 if (0 != bttv_handle_chipset(btv)) {
4403 /* init options from insmod args */
4404 btv->opt_combfilter = combfilter;
4405 btv->opt_lumafilter = lumafilter;
4406 btv->opt_automute = automute;
4407 btv->opt_chroma_agc = chroma_agc;
4408 btv->opt_adc_crush = adc_crush;
4409 btv->opt_vcr_hack = vcr_hack;
4410 btv->opt_whitecrush_upper = whitecrush_upper;
4411 btv->opt_whitecrush_lower = whitecrush_lower;
4412 btv->opt_uv_ratio = uv_ratio;
4413 btv->opt_full_luma_range = full_luma_range;
4414 btv->opt_coring = coring;
4416 /* fill struct bttv with some useful defaults */
4417 btv->init.btv = btv;
4418 btv->init.ov.w.width = 320;
4419 btv->init.ov.w.height = 240;
4420 btv->init.fmt = format_by_fourcc(V4L2_PIX_FMT_BGR24);
4421 btv->init.width = 320;
4422 btv->init.height = 240;
4425 /* initialize hardware */
4427 bttv_gpio_tracking(btv,"pre-init");
4429 bttv_risc_init_main(btv);
4433 btwrite(0x00, BT848_GPIO_REG_INP);
4434 btwrite(0x00, BT848_GPIO_OUT_EN);
4436 bttv_gpio_tracking(btv,"init");
4438 /* needs to be done before i2c is registered */
4439 bttv_init_card1(btv);
4441 /* register i2c + gpio */
4444 /* some card-specific stuff (needs working i2c) */
4445 bttv_init_card2(btv);
4448 /* register video4linux + input */
4449 if (!bttv_tvcards[btv->c.type].no_video) {
4450 bttv_register_video(btv);
4451 bt848_bright(btv,32768);
4452 bt848_contrast(btv,32768);
4453 bt848_hue(btv,32768);
4454 bt848_sat(btv,32768);
4456 set_input(btv, 0, btv->tvnorm);
4457 bttv_crop_reset(&btv->crop[0], btv->tvnorm);
4458 btv->crop[1] = btv->crop[0]; /* current = default */
4459 disclaim_vbi_lines(btv);
4460 disclaim_video_lines(btv);
4463 /* add subdevices and autoload dvb-bt8xx if needed */
4464 if (bttv_tvcards[btv->c.type].has_dvb) {
4465 bttv_sub_add_device(&btv->c, "dvb");
4466 request_modules(btv);
4469 bttv_input_init(btv);
4471 /* everything is fine */
4476 free_irq(btv->c.pci->irq,btv);
4479 if (btv->bt848_mmio)
4480 iounmap(btv->bt848_mmio);
4481 release_mem_region(pci_resource_start(btv->c.pci,0),
4482 pci_resource_len(btv->c.pci,0));
4483 pci_set_drvdata(dev,NULL);
4487 static void __devexit bttv_remove(struct pci_dev *pci_dev)
4489 struct bttv *btv = pci_get_drvdata(pci_dev);
4492 printk("bttv%d: unloading\n",btv->c.nr);
4494 /* shutdown everything (DMA+IRQs) */
4495 btand(~15, BT848_GPIO_DMA_CTL);
4496 btwrite(0, BT848_INT_MASK);
4497 btwrite(~0x0, BT848_INT_STAT);
4498 btwrite(0x0, BT848_GPIO_OUT_EN);
4500 bttv_gpio_tracking(btv,"cleanup");
4502 /* tell gpio modules we are leaving ... */
4504 wake_up(&btv->gpioq);
4505 bttv_input_fini(btv);
4506 bttv_sub_del_devices(&btv->c);
4508 /* unregister i2c_bus + input */
4511 /* unregister video4linux */
4512 bttv_unregister_video(btv);
4514 /* free allocated memory */
4515 btcx_riscmem_free(btv->c.pci,&btv->main);
4517 /* free ressources */
4518 free_irq(btv->c.pci->irq,btv);
4519 iounmap(btv->bt848_mmio);
4520 release_mem_region(pci_resource_start(btv->c.pci,0),
4521 pci_resource_len(btv->c.pci,0));
4523 pci_set_drvdata(pci_dev, NULL);
4528 static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state)
4530 struct bttv *btv = pci_get_drvdata(pci_dev);
4531 struct bttv_buffer_set idle;
4532 unsigned long flags;
4534 dprintk("bttv%d: suspend %d\n", btv->c.nr, state.event);
4536 /* stop dma + irqs */
4537 spin_lock_irqsave(&btv->s_lock,flags);
4538 memset(&idle, 0, sizeof(idle));
4539 btv->state.video = btv->curr;
4540 btv->state.vbi = btv->cvbi;
4541 btv->state.loop_irq = btv->loop_irq;
4544 bttv_buffer_activate_video(btv, &idle);
4545 bttv_buffer_activate_vbi(btv, NULL);
4546 bttv_set_dma(btv, 0);
4547 btwrite(0, BT848_INT_MASK);
4548 spin_unlock_irqrestore(&btv->s_lock,flags);
4550 /* save bt878 state */
4551 btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
4552 btv->state.gpio_data = gpio_read();
4554 /* save pci state */
4555 pci_save_state(pci_dev);
4556 if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
4557 pci_disable_device(pci_dev);
4558 btv->state.disabled = 1;
4563 static int bttv_resume(struct pci_dev *pci_dev)
4565 struct bttv *btv = pci_get_drvdata(pci_dev);
4566 unsigned long flags;
4569 dprintk("bttv%d: resume\n", btv->c.nr);
4571 /* restore pci state */
4572 if (btv->state.disabled) {
4573 err=pci_enable_device(pci_dev);
4575 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4579 btv->state.disabled = 0;
4581 err=pci_set_power_state(pci_dev, PCI_D0);
4583 pci_disable_device(pci_dev);
4584 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4586 btv->state.disabled = 1;
4590 pci_restore_state(pci_dev);
4592 /* restore bt878 state */
4593 bttv_reinit_bt848(btv);
4594 gpio_inout(0xffffff, btv->state.gpio_enable);
4595 gpio_write(btv->state.gpio_data);
4598 spin_lock_irqsave(&btv->s_lock,flags);
4599 btv->curr = btv->state.video;
4600 btv->cvbi = btv->state.vbi;
4601 btv->loop_irq = btv->state.loop_irq;
4602 bttv_buffer_activate_video(btv, &btv->curr);
4603 bttv_buffer_activate_vbi(btv, btv->cvbi);
4604 bttv_set_dma(btv, 0);
4605 spin_unlock_irqrestore(&btv->s_lock,flags);
4610 static struct pci_device_id bttv_pci_tbl[] = {
4611 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848,
4612 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4613 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849,
4614 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4615 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878,
4616 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4617 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879,
4618 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4622 MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
4624 static struct pci_driver bttv_pci_driver = {
4626 .id_table = bttv_pci_tbl,
4627 .probe = bttv_probe,
4628 .remove = __devexit_p(bttv_remove),
4630 .suspend = bttv_suspend,
4631 .resume = bttv_resume,
4635 static int __init bttv_init_module(void)
4641 printk(KERN_INFO "bttv: driver version %d.%d.%d loaded\n",
4642 (BTTV_VERSION_CODE >> 16) & 0xff,
4643 (BTTV_VERSION_CODE >> 8) & 0xff,
4644 BTTV_VERSION_CODE & 0xff);
4646 printk(KERN_INFO "bttv: snapshot date %04d-%02d-%02d\n",
4647 SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
4649 if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
4651 if (gbufsize < 0 || gbufsize > BTTV_MAX_FBUF)
4652 gbufsize = BTTV_MAX_FBUF;
4653 gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
4655 printk(KERN_INFO "bttv: using %d buffers with %dk (%d pages) each for capture\n",
4656 gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
4658 bttv_check_chipset();
4660 ret = bus_register(&bttv_sub_bus_type);
4662 printk(KERN_WARNING "bttv: bus_register error: %d\n", ret);
4665 ret = pci_register_driver(&bttv_pci_driver);
4667 bus_unregister(&bttv_sub_bus_type);
4672 static void __exit bttv_cleanup_module(void)
4674 pci_unregister_driver(&bttv_pci_driver);
4675 bus_unregister(&bttv_sub_bus_type);
4678 module_init(bttv_init_module);
4679 module_exit(bttv_cleanup_module);