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/slab.h>
41 #include <linux/errno.h>
43 #include <linux/kernel.h>
44 #include <linux/sched.h>
45 #include <linux/smp_lock.h>
46 #include <linux/interrupt.h>
47 #include <linux/kdev_t.h>
49 #include <media/v4l2-common.h>
50 #include <media/v4l2-ioctl.h>
51 #include <media/tvaudio.h>
52 #include <media/msp3400.h>
54 #include <linux/dma-mapping.h>
57 #include <asm/byteorder.h>
59 #include <media/rds.h>
62 unsigned int bttv_num; /* number of Bt848s in use */
63 struct bttv *bttvs[BTTV_MAX];
65 unsigned int bttv_debug;
66 unsigned int bttv_verbose = 1;
67 unsigned int bttv_gpio;
69 /* config variables */
71 static unsigned int bigendian=1;
73 static unsigned int bigendian;
75 static unsigned int radio[BTTV_MAX];
76 static unsigned int irq_debug;
77 static unsigned int gbuffers = 8;
78 static unsigned int gbufsize = 0x208000;
79 static unsigned int reset_crop = 1;
81 static int video_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
82 static int radio_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
83 static int vbi_nr[BTTV_MAX] = { [0 ... (BTTV_MAX-1)] = -1 };
84 static int debug_latency;
85 static int disable_ir;
87 static unsigned int fdsr;
90 static unsigned int combfilter;
91 static unsigned int lumafilter;
92 static unsigned int automute = 1;
93 static unsigned int chroma_agc;
94 static unsigned int adc_crush = 1;
95 static unsigned int whitecrush_upper = 0xCF;
96 static unsigned int whitecrush_lower = 0x7F;
97 static unsigned int vcr_hack;
98 static unsigned int irq_iswitch;
99 static unsigned int uv_ratio = 50;
100 static unsigned int full_luma_range;
101 static unsigned int coring;
103 /* API features (turn on/off stuff for testing) */
104 static unsigned int v4l2 = 1;
107 module_param(bttv_verbose, int, 0644);
108 module_param(bttv_gpio, int, 0644);
109 module_param(bttv_debug, int, 0644);
110 module_param(irq_debug, int, 0644);
111 module_param(debug_latency, int, 0644);
112 module_param(disable_ir, int, 0444);
114 module_param(fdsr, int, 0444);
115 module_param(gbuffers, int, 0444);
116 module_param(gbufsize, int, 0444);
117 module_param(reset_crop, int, 0444);
119 module_param(v4l2, int, 0644);
120 module_param(bigendian, int, 0644);
121 module_param(irq_iswitch, int, 0644);
122 module_param(combfilter, int, 0444);
123 module_param(lumafilter, int, 0444);
124 module_param(automute, int, 0444);
125 module_param(chroma_agc, int, 0444);
126 module_param(adc_crush, int, 0444);
127 module_param(whitecrush_upper, int, 0444);
128 module_param(whitecrush_lower, int, 0444);
129 module_param(vcr_hack, int, 0444);
130 module_param(uv_ratio, int, 0444);
131 module_param(full_luma_range, int, 0444);
132 module_param(coring, int, 0444);
134 module_param_array(radio, int, NULL, 0444);
135 module_param_array(video_nr, int, NULL, 0444);
136 module_param_array(radio_nr, int, NULL, 0444);
137 module_param_array(vbi_nr, int, NULL, 0444);
139 MODULE_PARM_DESC(radio,"The TV card supports radio, default is 0 (no)");
140 MODULE_PARM_DESC(bigendian,"byte order of the framebuffer, default is native endian");
141 MODULE_PARM_DESC(bttv_verbose,"verbose startup messages, default is 1 (yes)");
142 MODULE_PARM_DESC(bttv_gpio,"log gpio changes, default is 0 (no)");
143 MODULE_PARM_DESC(bttv_debug,"debug messages, default is 0 (no)");
144 MODULE_PARM_DESC(irq_debug,"irq handler debug messages, default is 0 (no)");
145 MODULE_PARM_DESC(disable_ir, "disable infrared remote support");
146 MODULE_PARM_DESC(gbuffers,"number of capture buffers. range 2-32, default 8");
147 MODULE_PARM_DESC(gbufsize,"size of the capture buffers, default is 0x208000");
148 MODULE_PARM_DESC(reset_crop,"reset cropping parameters at open(), default "
149 "is 1 (yes) for compatibility with older applications");
150 MODULE_PARM_DESC(automute,"mute audio on bad/missing video signal, default is 1 (yes)");
151 MODULE_PARM_DESC(chroma_agc,"enables the AGC of chroma signal, default is 0 (no)");
152 MODULE_PARM_DESC(adc_crush,"enables the luminance ADC crush, default is 1 (yes)");
153 MODULE_PARM_DESC(whitecrush_upper,"sets the white crush upper value, default is 207");
154 MODULE_PARM_DESC(whitecrush_lower,"sets the white crush lower value, default is 127");
155 MODULE_PARM_DESC(vcr_hack,"enables the VCR hack (improves synch on poor VCR tapes), default is 0 (no)");
156 MODULE_PARM_DESC(irq_iswitch,"switch inputs in irq handler");
157 MODULE_PARM_DESC(uv_ratio,"ratio between u and v gains, default is 50");
158 MODULE_PARM_DESC(full_luma_range,"use the full luma range, default is 0 (no)");
159 MODULE_PARM_DESC(coring,"set the luma coring level, default is 0 (no)");
160 MODULE_PARM_DESC(video_nr, "video device numbers");
161 MODULE_PARM_DESC(vbi_nr, "vbi device numbers");
162 MODULE_PARM_DESC(radio_nr, "radio device numbers");
164 MODULE_DESCRIPTION("bttv - v4l/v4l2 driver module for bt848/878 based cards");
165 MODULE_AUTHOR("Ralph Metzler & Marcus Metzler & Gerd Knorr");
166 MODULE_LICENSE("GPL");
168 /* ----------------------------------------------------------------------- */
171 static ssize_t show_card(struct device *cd,
172 struct device_attribute *attr, char *buf)
174 struct video_device *vfd = container_of(cd, struct video_device, dev);
175 struct bttv *btv = video_get_drvdata(vfd);
176 return sprintf(buf, "%d\n", btv ? btv->c.type : UNSET);
178 static DEVICE_ATTR(card, S_IRUGO, show_card, NULL);
180 /* ----------------------------------------------------------------------- */
181 /* dvb auto-load setup */
182 #if defined(CONFIG_MODULES) && defined(MODULE)
183 static void request_module_async(struct work_struct *work)
185 request_module("dvb-bt8xx");
188 static void request_modules(struct bttv *dev)
190 INIT_WORK(&dev->request_module_wk, request_module_async);
191 schedule_work(&dev->request_module_wk);
194 #define request_modules(dev)
195 #endif /* CONFIG_MODULES */
198 /* ----------------------------------------------------------------------- */
201 /* special timing tables from conexant... */
202 static u8 SRAM_Table[][60] =
204 /* PAL digital input over GPIO[7:0] */
206 45, // 45 bytes following
207 0x36,0x11,0x01,0x00,0x90,0x02,0x05,0x10,0x04,0x16,
208 0x12,0x05,0x11,0x00,0x04,0x12,0xC0,0x00,0x31,0x00,
209 0x06,0x51,0x08,0x03,0x89,0x08,0x07,0xC0,0x44,0x00,
210 0x81,0x01,0x01,0xA9,0x0D,0x02,0x02,0x50,0x03,0x37,
211 0x37,0x00,0xAF,0x21,0x00
213 /* NTSC digital input over GPIO[7:0] */
215 51, // 51 bytes following
216 0x0C,0xC0,0x00,0x00,0x90,0x02,0x03,0x10,0x03,0x06,
217 0x10,0x04,0x12,0x12,0x05,0x02,0x13,0x04,0x19,0x00,
218 0x04,0x39,0x00,0x06,0x59,0x08,0x03,0x83,0x08,0x07,
219 0x03,0x50,0x00,0xC0,0x40,0x00,0x86,0x01,0x01,0xA6,
220 0x0D,0x02,0x03,0x11,0x01,0x05,0x37,0x00,0xAC,0x21,
223 // TGB_NTSC392 // quartzsight
224 // This table has been modified to be used for Fusion Rev D
226 0x2A, // size of table = 42
227 0x06, 0x08, 0x04, 0x0a, 0xc0, 0x00, 0x18, 0x08, 0x03, 0x24,
228 0x08, 0x07, 0x02, 0x90, 0x02, 0x08, 0x10, 0x04, 0x0c, 0x10,
229 0x05, 0x2c, 0x11, 0x04, 0x55, 0x48, 0x00, 0x05, 0x50, 0x00,
230 0xbf, 0x0c, 0x02, 0x2f, 0x3d, 0x00, 0x2f, 0x3f, 0x00, 0xc3,
235 /* minhdelayx1 first video pixel we can capture on a line and
236 hdelayx1 start of active video, both relative to rising edge of
237 /HRESET pulse (0H) in 1 / fCLKx1.
238 swidth width of active video and
239 totalwidth total line width, both in 1 / fCLKx1.
240 sqwidth total line width in square pixels.
241 vdelay start of active video in 2 * field lines relative to
242 trailing edge of /VRESET pulse (VDELAY register).
243 sheight height of active video in 2 * field lines.
244 videostart0 ITU-R frame line number of the line corresponding
245 to vdelay in the first field. */
246 #define CROPCAP(minhdelayx1, hdelayx1, swidth, totalwidth, sqwidth, \
247 vdelay, sheight, videostart0) \
248 .cropcap.bounds.left = minhdelayx1, \
249 /* * 2 because vertically we count field lines times two, */ \
250 /* e.g. 23 * 2 to 23 * 2 + 576 in PAL-BGHI defrect. */ \
251 .cropcap.bounds.top = (videostart0) * 2 - (vdelay) + MIN_VDELAY, \
252 /* 4 is a safety margin at the end of the line. */ \
253 .cropcap.bounds.width = (totalwidth) - (minhdelayx1) - 4, \
254 .cropcap.bounds.height = (sheight) + (vdelay) - MIN_VDELAY, \
255 .cropcap.defrect.left = hdelayx1, \
256 .cropcap.defrect.top = (videostart0) * 2, \
257 .cropcap.defrect.width = swidth, \
258 .cropcap.defrect.height = sheight, \
259 .cropcap.pixelaspect.numerator = totalwidth, \
260 .cropcap.pixelaspect.denominator = sqwidth,
262 const struct bttv_tvnorm bttv_tvnorms[] = {
264 /* max. active video is actually 922, but 924 is divisible by 4 and 3! */
265 /* actually, max active PAL with HSCALE=0 is 948, NTSC is 768 - nil */
267 .v4l2_id = V4L2_STD_PAL,
275 .iform = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
276 .scaledtwidth = 1135,
280 .vbipack = 255, /* min (2048 / 4, 0x1ff) & 0xff */
282 /* ITU-R frame line number of the first VBI line
283 we can capture, of the first and second field.
284 The last line is determined by cropcap.bounds. */
285 .vbistart = { 7, 320 },
286 CROPCAP(/* minhdelayx1 */ 68,
288 /* Should be (768 * 1135 + 944 / 2) / 944.
289 cropcap.defrect is used for image width
290 checks, so we keep the old value 924. */
292 /* totalwidth */ 1135,
296 /* videostart0 */ 23)
297 /* bt878 (and bt848?) can capture another
298 line below active video. */
299 .cropcap.bounds.height = (576 + 2) + 0x20 - 2,
301 .v4l2_id = V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR,
309 .iform = (BT848_IFORM_NTSC|BT848_IFORM_XT0),
314 .vbipack = 144, /* min (1600 / 4, 0x1ff) & 0xff */
316 .vbistart = { 10, 273 },
317 CROPCAP(/* minhdelayx1 */ 68,
319 /* Should be (640 * 910 + 780 / 2) / 780? */
321 /* totalwidth */ 910,
325 /* videostart0 */ 23)
327 .v4l2_id = V4L2_STD_SECAM,
335 .iform = (BT848_IFORM_SECAM|BT848_IFORM_XT1),
336 .scaledtwidth = 1135,
341 .sram = 0, /* like PAL, correct? */
342 .vbistart = { 7, 320 },
343 CROPCAP(/* minhdelayx1 */ 68,
346 /* totalwidth */ 1135,
350 /* videostart0 */ 23)
352 .v4l2_id = V4L2_STD_PAL_Nc,
360 .iform = (BT848_IFORM_PAL_NC|BT848_IFORM_XT0),
367 .vbistart = { 7, 320 },
368 CROPCAP(/* minhdelayx1 */ 68,
370 /* swidth */ (640 * 910 + 780 / 2) / 780,
371 /* totalwidth */ 910,
375 /* videostart0 */ 23)
377 .v4l2_id = V4L2_STD_PAL_M,
385 .iform = (BT848_IFORM_PAL_M|BT848_IFORM_XT0),
392 .vbistart = { 10, 273 },
393 CROPCAP(/* minhdelayx1 */ 68,
395 /* swidth */ (640 * 910 + 780 / 2) / 780,
396 /* totalwidth */ 910,
400 /* videostart0 */ 23)
402 .v4l2_id = V4L2_STD_PAL_N,
410 .iform = (BT848_IFORM_PAL_N|BT848_IFORM_XT1),
417 .vbistart = { 7, 320 },
418 CROPCAP(/* minhdelayx1 */ 68,
420 /* swidth */ (768 * 1135 + 944 / 2) / 944,
421 /* totalwidth */ 1135,
425 /* videostart0 */ 23)
427 .v4l2_id = V4L2_STD_NTSC_M_JP,
435 .iform = (BT848_IFORM_NTSC_J|BT848_IFORM_XT0),
442 .vbistart = { 10, 273 },
443 CROPCAP(/* minhdelayx1 */ 68,
445 /* swidth */ (640 * 910 + 780 / 2) / 780,
446 /* totalwidth */ 910,
450 /* videostart0 */ 23)
452 /* that one hopefully works with the strange timing
453 * which video recorders produce when playing a NTSC
454 * tape on a PAL TV ... */
455 .v4l2_id = V4L2_STD_PAL_60,
463 .iform = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
464 .scaledtwidth = 1135,
471 .vbistart = { 10, 273 },
472 CROPCAP(/* minhdelayx1 */ 68,
475 /* totalwidth */ 1135,
479 /* videostart0 */ 23)
482 static const unsigned int BTTV_TVNORMS = ARRAY_SIZE(bttv_tvnorms);
484 /* ----------------------------------------------------------------------- */
486 packed pixel formats must come first */
487 static const struct bttv_format formats[] = {
489 .name = "8 bpp, gray",
490 .fourcc = V4L2_PIX_FMT_GREY,
491 .btformat = BT848_COLOR_FMT_Y8,
493 .flags = FORMAT_FLAGS_PACKED,
495 .name = "8 bpp, dithered color",
496 .fourcc = V4L2_PIX_FMT_HI240,
497 .btformat = BT848_COLOR_FMT_RGB8,
499 .flags = FORMAT_FLAGS_PACKED | FORMAT_FLAGS_DITHER,
501 .name = "15 bpp RGB, le",
502 .fourcc = V4L2_PIX_FMT_RGB555,
503 .btformat = BT848_COLOR_FMT_RGB15,
505 .flags = FORMAT_FLAGS_PACKED,
507 .name = "15 bpp RGB, be",
508 .fourcc = V4L2_PIX_FMT_RGB555X,
509 .btformat = BT848_COLOR_FMT_RGB15,
510 .btswap = 0x03, /* byteswap */
512 .flags = FORMAT_FLAGS_PACKED,
514 .name = "16 bpp RGB, le",
515 .fourcc = V4L2_PIX_FMT_RGB565,
516 .btformat = BT848_COLOR_FMT_RGB16,
518 .flags = FORMAT_FLAGS_PACKED,
520 .name = "16 bpp RGB, be",
521 .fourcc = V4L2_PIX_FMT_RGB565X,
522 .btformat = BT848_COLOR_FMT_RGB16,
523 .btswap = 0x03, /* byteswap */
525 .flags = FORMAT_FLAGS_PACKED,
527 .name = "24 bpp RGB, le",
528 .fourcc = V4L2_PIX_FMT_BGR24,
529 .btformat = BT848_COLOR_FMT_RGB24,
531 .flags = FORMAT_FLAGS_PACKED,
533 .name = "32 bpp RGB, le",
534 .fourcc = V4L2_PIX_FMT_BGR32,
535 .btformat = BT848_COLOR_FMT_RGB32,
537 .flags = FORMAT_FLAGS_PACKED,
539 .name = "32 bpp RGB, be",
540 .fourcc = V4L2_PIX_FMT_RGB32,
541 .btformat = BT848_COLOR_FMT_RGB32,
542 .btswap = 0x0f, /* byte+word swap */
544 .flags = FORMAT_FLAGS_PACKED,
546 .name = "4:2:2, packed, YUYV",
547 .fourcc = V4L2_PIX_FMT_YUYV,
548 .btformat = BT848_COLOR_FMT_YUY2,
550 .flags = FORMAT_FLAGS_PACKED,
552 .name = "4:2:2, packed, YUYV",
553 .fourcc = V4L2_PIX_FMT_YUYV,
554 .btformat = BT848_COLOR_FMT_YUY2,
556 .flags = FORMAT_FLAGS_PACKED,
558 .name = "4:2:2, packed, UYVY",
559 .fourcc = V4L2_PIX_FMT_UYVY,
560 .btformat = BT848_COLOR_FMT_YUY2,
561 .btswap = 0x03, /* byteswap */
563 .flags = FORMAT_FLAGS_PACKED,
565 .name = "4:2:2, planar, Y-Cb-Cr",
566 .fourcc = V4L2_PIX_FMT_YUV422P,
567 .btformat = BT848_COLOR_FMT_YCrCb422,
569 .flags = FORMAT_FLAGS_PLANAR,
573 .name = "4:2:0, planar, Y-Cb-Cr",
574 .fourcc = V4L2_PIX_FMT_YUV420,
575 .btformat = BT848_COLOR_FMT_YCrCb422,
577 .flags = FORMAT_FLAGS_PLANAR,
581 .name = "4:2:0, planar, Y-Cr-Cb",
582 .fourcc = V4L2_PIX_FMT_YVU420,
583 .btformat = BT848_COLOR_FMT_YCrCb422,
585 .flags = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
589 .name = "4:1:1, planar, Y-Cb-Cr",
590 .fourcc = V4L2_PIX_FMT_YUV411P,
591 .btformat = BT848_COLOR_FMT_YCrCb411,
593 .flags = FORMAT_FLAGS_PLANAR,
597 .name = "4:1:0, planar, Y-Cb-Cr",
598 .fourcc = V4L2_PIX_FMT_YUV410,
599 .btformat = BT848_COLOR_FMT_YCrCb411,
601 .flags = FORMAT_FLAGS_PLANAR,
605 .name = "4:1:0, planar, Y-Cr-Cb",
606 .fourcc = V4L2_PIX_FMT_YVU410,
607 .btformat = BT848_COLOR_FMT_YCrCb411,
609 .flags = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
613 .name = "raw scanlines",
615 .btformat = BT848_COLOR_FMT_RAW,
617 .flags = FORMAT_FLAGS_RAW,
620 static const unsigned int FORMATS = ARRAY_SIZE(formats);
622 /* ----------------------------------------------------------------------- */
624 #define V4L2_CID_PRIVATE_CHROMA_AGC (V4L2_CID_PRIVATE_BASE + 0)
625 #define V4L2_CID_PRIVATE_COMBFILTER (V4L2_CID_PRIVATE_BASE + 1)
626 #define V4L2_CID_PRIVATE_AUTOMUTE (V4L2_CID_PRIVATE_BASE + 2)
627 #define V4L2_CID_PRIVATE_LUMAFILTER (V4L2_CID_PRIVATE_BASE + 3)
628 #define V4L2_CID_PRIVATE_AGC_CRUSH (V4L2_CID_PRIVATE_BASE + 4)
629 #define V4L2_CID_PRIVATE_VCR_HACK (V4L2_CID_PRIVATE_BASE + 5)
630 #define V4L2_CID_PRIVATE_WHITECRUSH_UPPER (V4L2_CID_PRIVATE_BASE + 6)
631 #define V4L2_CID_PRIVATE_WHITECRUSH_LOWER (V4L2_CID_PRIVATE_BASE + 7)
632 #define V4L2_CID_PRIVATE_UV_RATIO (V4L2_CID_PRIVATE_BASE + 8)
633 #define V4L2_CID_PRIVATE_FULL_LUMA_RANGE (V4L2_CID_PRIVATE_BASE + 9)
634 #define V4L2_CID_PRIVATE_CORING (V4L2_CID_PRIVATE_BASE + 10)
635 #define V4L2_CID_PRIVATE_LASTP1 (V4L2_CID_PRIVATE_BASE + 11)
637 static const struct v4l2_queryctrl no_ctl = {
639 .flags = V4L2_CTRL_FLAG_DISABLED,
641 static const struct v4l2_queryctrl bttv_ctls[] = {
644 .id = V4L2_CID_BRIGHTNESS,
645 .name = "Brightness",
649 .default_value = 32768,
650 .type = V4L2_CTRL_TYPE_INTEGER,
652 .id = V4L2_CID_CONTRAST,
657 .default_value = 32768,
658 .type = V4L2_CTRL_TYPE_INTEGER,
660 .id = V4L2_CID_SATURATION,
661 .name = "Saturation",
665 .default_value = 32768,
666 .type = V4L2_CTRL_TYPE_INTEGER,
673 .default_value = 32768,
674 .type = V4L2_CTRL_TYPE_INTEGER,
678 .id = V4L2_CID_AUDIO_MUTE,
682 .type = V4L2_CTRL_TYPE_BOOLEAN,
684 .id = V4L2_CID_AUDIO_VOLUME,
689 .default_value = 65535,
690 .type = V4L2_CTRL_TYPE_INTEGER,
692 .id = V4L2_CID_AUDIO_BALANCE,
697 .default_value = 32768,
698 .type = V4L2_CTRL_TYPE_INTEGER,
700 .id = V4L2_CID_AUDIO_BASS,
705 .default_value = 32768,
706 .type = V4L2_CTRL_TYPE_INTEGER,
708 .id = V4L2_CID_AUDIO_TREBLE,
713 .default_value = 32768,
714 .type = V4L2_CTRL_TYPE_INTEGER,
716 /* --- private --- */
718 .id = V4L2_CID_PRIVATE_CHROMA_AGC,
719 .name = "chroma agc",
722 .type = V4L2_CTRL_TYPE_BOOLEAN,
724 .id = V4L2_CID_PRIVATE_COMBFILTER,
725 .name = "combfilter",
728 .type = V4L2_CTRL_TYPE_BOOLEAN,
730 .id = V4L2_CID_PRIVATE_AUTOMUTE,
734 .type = V4L2_CTRL_TYPE_BOOLEAN,
736 .id = V4L2_CID_PRIVATE_LUMAFILTER,
737 .name = "luma decimation filter",
740 .type = V4L2_CTRL_TYPE_BOOLEAN,
742 .id = V4L2_CID_PRIVATE_AGC_CRUSH,
746 .type = V4L2_CTRL_TYPE_BOOLEAN,
748 .id = V4L2_CID_PRIVATE_VCR_HACK,
752 .type = V4L2_CTRL_TYPE_BOOLEAN,
754 .id = V4L2_CID_PRIVATE_WHITECRUSH_UPPER,
755 .name = "whitecrush upper",
759 .default_value = 0xCF,
760 .type = V4L2_CTRL_TYPE_INTEGER,
762 .id = V4L2_CID_PRIVATE_WHITECRUSH_LOWER,
763 .name = "whitecrush lower",
767 .default_value = 0x7F,
768 .type = V4L2_CTRL_TYPE_INTEGER,
770 .id = V4L2_CID_PRIVATE_UV_RATIO,
776 .type = V4L2_CTRL_TYPE_INTEGER,
778 .id = V4L2_CID_PRIVATE_FULL_LUMA_RANGE,
779 .name = "full luma range",
782 .type = V4L2_CTRL_TYPE_BOOLEAN,
784 .id = V4L2_CID_PRIVATE_CORING,
790 .type = V4L2_CTRL_TYPE_INTEGER,
797 static const struct v4l2_queryctrl *ctrl_by_id(int id)
801 for (i = 0; i < ARRAY_SIZE(bttv_ctls); i++)
802 if (bttv_ctls[i].id == id)
808 /* ----------------------------------------------------------------------- */
809 /* resource management */
812 RESOURCE_ allocated by freed by
814 VIDEO_READ bttv_read 1) bttv_read 2)
816 VIDEO_STREAM VIDIOC_STREAMON VIDIOC_STREAMOFF
817 VIDIOC_QBUF 1) bttv_release
820 OVERLAY VIDIOCCAPTURE on VIDIOCCAPTURE off
821 VIDIOC_OVERLAY on VIDIOC_OVERLAY off
824 VBI VIDIOC_STREAMON VIDIOC_STREAMOFF
825 VIDIOC_QBUF 1) bttv_release
826 bttv_read, bttv_poll 1) 4)
828 1) The resource must be allocated when we enter buffer prepare functions
829 and remain allocated while buffers are in the DMA queue.
830 2) This is a single frame read.
831 3) VIDIOC_S_FBUF and VIDIOC_S_FMT (OVERLAY) still work when
832 RESOURCE_OVERLAY is allocated.
833 4) This is a continuous read, implies VIDIOC_STREAMON.
835 Note this driver permits video input and standard changes regardless if
836 resources are allocated.
839 #define VBI_RESOURCES (RESOURCE_VBI)
840 #define VIDEO_RESOURCES (RESOURCE_VIDEO_READ | \
841 RESOURCE_VIDEO_STREAM | \
845 int check_alloc_btres_lock(struct bttv *btv, struct bttv_fh *fh, int bit)
847 int xbits; /* mutual exclusive resources */
849 if (fh->resources & bit)
850 /* have it already allocated */
854 if (bit & (RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM))
855 xbits |= RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM;
858 mutex_lock(&btv->lock);
859 if (btv->resources & xbits) {
860 /* no, someone else uses it */
864 if ((bit & VIDEO_RESOURCES)
865 && 0 == (btv->resources & VIDEO_RESOURCES)) {
866 /* Do crop - use current, don't - use default parameters. */
867 __s32 top = btv->crop[!!fh->do_crop].rect.top;
869 if (btv->vbi_end > top)
872 /* We cannot capture the same line as video and VBI data.
873 Claim scan lines crop[].rect.top to bottom. */
874 btv->crop_start = top;
875 } else if (bit & VBI_RESOURCES) {
876 __s32 end = fh->vbi_fmt.end;
878 if (end > btv->crop_start)
881 /* Claim scan lines above fh->vbi_fmt.end. */
885 /* it's free, grab it */
886 fh->resources |= bit;
887 btv->resources |= bit;
888 mutex_unlock(&btv->lock);
892 mutex_unlock(&btv->lock);
897 int check_btres(struct bttv_fh *fh, int bit)
899 return (fh->resources & bit);
903 int locked_btres(struct bttv *btv, int bit)
905 return (btv->resources & bit);
908 /* Call with btv->lock down. */
910 disclaim_vbi_lines(struct bttv *btv)
915 /* Call with btv->lock down. */
917 disclaim_video_lines(struct bttv *btv)
919 const struct bttv_tvnorm *tvnorm;
922 tvnorm = &bttv_tvnorms[btv->tvnorm];
923 btv->crop_start = tvnorm->cropcap.bounds.top
924 + tvnorm->cropcap.bounds.height;
926 /* VBI capturing ends at VDELAY, start of video capturing, no
927 matter how many lines the VBI RISC program expects. When video
928 capturing is off, it shall no longer "preempt" VBI capturing,
929 so we set VDELAY to maximum. */
930 crop = btread(BT848_E_CROP) | 0xc0;
931 btwrite(crop, BT848_E_CROP);
932 btwrite(0xfe, BT848_E_VDELAY_LO);
933 btwrite(crop, BT848_O_CROP);
934 btwrite(0xfe, BT848_O_VDELAY_LO);
938 void free_btres_lock(struct bttv *btv, struct bttv_fh *fh, int bits)
940 if ((fh->resources & bits) != bits) {
941 /* trying to free ressources not allocated by us ... */
942 printk("bttv: BUG! (btres)\n");
944 mutex_lock(&btv->lock);
945 fh->resources &= ~bits;
946 btv->resources &= ~bits;
948 bits = btv->resources;
950 if (0 == (bits & VIDEO_RESOURCES))
951 disclaim_video_lines(btv);
953 if (0 == (bits & VBI_RESOURCES))
954 disclaim_vbi_lines(btv);
956 mutex_unlock(&btv->lock);
959 /* ----------------------------------------------------------------------- */
960 /* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC */
962 /* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C
963 PLL_X = Reference pre-divider (0=1, 1=2)
964 PLL_C = Post divider (0=6, 1=4)
965 PLL_I = Integer input
966 PLL_F = Fractional input
968 F_input = 28.636363 MHz:
969 PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0
972 static void set_pll_freq(struct bttv *btv, unsigned int fin, unsigned int fout)
974 unsigned char fl, fh, fi;
976 /* prevent overflows */
989 btwrite(fl, BT848_PLL_F_LO);
990 btwrite(fh, BT848_PLL_F_HI);
991 btwrite(fi|BT848_PLL_X, BT848_PLL_XCI);
994 static void set_pll(struct bttv *btv)
998 if (!btv->pll.pll_crystal)
1001 if (btv->pll.pll_ofreq == btv->pll.pll_current) {
1002 dprintk("bttv%d: PLL: no change required\n",btv->c.nr);
1006 if (btv->pll.pll_ifreq == btv->pll.pll_ofreq) {
1008 if (btv->pll.pll_current == 0)
1010 bttv_printk(KERN_INFO "bttv%d: PLL can sleep, using XTAL (%d).\n",
1011 btv->c.nr,btv->pll.pll_ifreq);
1012 btwrite(0x00,BT848_TGCTRL);
1013 btwrite(0x00,BT848_PLL_XCI);
1014 btv->pll.pll_current = 0;
1018 bttv_printk(KERN_INFO "bttv%d: PLL: %d => %d ",btv->c.nr,
1019 btv->pll.pll_ifreq, btv->pll.pll_ofreq);
1020 set_pll_freq(btv, btv->pll.pll_ifreq, btv->pll.pll_ofreq);
1022 for (i=0; i<10; i++) {
1023 /* Let other people run while the PLL stabilizes */
1027 if (btread(BT848_DSTATUS) & BT848_DSTATUS_PLOCK) {
1028 btwrite(0,BT848_DSTATUS);
1030 btwrite(0x08,BT848_TGCTRL);
1031 btv->pll.pll_current = btv->pll.pll_ofreq;
1032 bttv_printk(" ok\n");
1036 btv->pll.pll_current = -1;
1037 bttv_printk("failed\n");
1041 /* used to switch between the bt848's analog/digital video capture modes */
1042 static void bt848A_set_timing(struct bttv *btv)
1045 int table_idx = bttv_tvnorms[btv->tvnorm].sram;
1046 int fsc = bttv_tvnorms[btv->tvnorm].Fsc;
1048 if (btv->input == btv->dig) {
1049 dprintk("bttv%d: load digital timing table (table_idx=%d)\n",
1050 btv->c.nr,table_idx);
1052 /* timing change...reset timing generator address */
1053 btwrite(0x00, BT848_TGCTRL);
1054 btwrite(0x02, BT848_TGCTRL);
1055 btwrite(0x00, BT848_TGCTRL);
1057 len=SRAM_Table[table_idx][0];
1058 for(i = 1; i <= len; i++)
1059 btwrite(SRAM_Table[table_idx][i],BT848_TGLB);
1060 btv->pll.pll_ofreq = 27000000;
1063 btwrite(0x11, BT848_TGCTRL);
1064 btwrite(0x41, BT848_DVSIF);
1066 btv->pll.pll_ofreq = fsc;
1068 btwrite(0x0, BT848_DVSIF);
1072 /* ----------------------------------------------------------------------- */
1074 static void bt848_bright(struct bttv *btv, int bright)
1078 // printk("bttv: set bright: %d\n",bright); // DEBUG
1079 btv->bright = bright;
1081 /* We want -128 to 127 we get 0-65535 */
1082 value = (bright >> 8) - 128;
1083 btwrite(value & 0xff, BT848_BRIGHT);
1086 static void bt848_hue(struct bttv *btv, int hue)
1093 value = (hue >> 8) - 128;
1094 btwrite(value & 0xff, BT848_HUE);
1097 static void bt848_contrast(struct bttv *btv, int cont)
1101 btv->contrast = cont;
1104 value = (cont >> 7);
1105 hibit = (value >> 6) & 4;
1106 btwrite(value & 0xff, BT848_CONTRAST_LO);
1107 btaor(hibit, ~4, BT848_E_CONTROL);
1108 btaor(hibit, ~4, BT848_O_CONTROL);
1111 static void bt848_sat(struct bttv *btv, int color)
1113 int val_u,val_v,hibits;
1115 btv->saturation = color;
1117 /* 0-511 for the color */
1118 val_u = ((color * btv->opt_uv_ratio) / 50) >> 7;
1119 val_v = (((color * (100 - btv->opt_uv_ratio) / 50) >>7)*180L)/254;
1120 hibits = (val_u >> 7) & 2;
1121 hibits |= (val_v >> 8) & 1;
1122 btwrite(val_u & 0xff, BT848_SAT_U_LO);
1123 btwrite(val_v & 0xff, BT848_SAT_V_LO);
1124 btaor(hibits, ~3, BT848_E_CONTROL);
1125 btaor(hibits, ~3, BT848_O_CONTROL);
1128 /* ----------------------------------------------------------------------- */
1131 video_mux(struct bttv *btv, unsigned int input)
1135 if (input >= bttv_tvcards[btv->c.type].video_inputs)
1138 /* needed by RemoteVideo MX */
1139 mask2 = bttv_tvcards[btv->c.type].gpiomask2;
1141 gpio_inout(mask2,mask2);
1143 if (input == btv->svhs) {
1144 btor(BT848_CONTROL_COMP, BT848_E_CONTROL);
1145 btor(BT848_CONTROL_COMP, BT848_O_CONTROL);
1147 btand(~BT848_CONTROL_COMP, BT848_E_CONTROL);
1148 btand(~BT848_CONTROL_COMP, BT848_O_CONTROL);
1150 mux = bttv_muxsel(btv, input);
1151 btaor(mux<<5, ~(3<<5), BT848_IFORM);
1152 dprintk(KERN_DEBUG "bttv%d: video mux: input=%d mux=%d\n",
1153 btv->c.nr,input,mux);
1155 /* card specific hook */
1156 if(bttv_tvcards[btv->c.type].muxsel_hook)
1157 bttv_tvcards[btv->c.type].muxsel_hook (btv, input);
1161 static char *audio_modes[] = {
1162 "audio: tuner", "audio: radio", "audio: extern",
1163 "audio: intern", "audio: mute"
1167 audio_mux(struct bttv *btv, int input, int mute)
1169 int gpio_val, signal;
1170 struct v4l2_control ctrl;
1172 gpio_inout(bttv_tvcards[btv->c.type].gpiomask,
1173 bttv_tvcards[btv->c.type].gpiomask);
1174 signal = btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC;
1180 mute = mute || (btv->opt_automute && !signal && !btv->radio_user);
1183 gpio_val = bttv_tvcards[btv->c.type].gpiomute;
1185 gpio_val = bttv_tvcards[btv->c.type].gpiomux[input];
1187 switch (btv->c.type) {
1188 case BTTV_BOARD_VOODOOTV_FM:
1189 case BTTV_BOARD_VOODOOTV_200:
1190 gpio_val = bttv_tda9880_setnorm(btv, gpio_val);
1194 gpio_bits(bttv_tvcards[btv->c.type].gpiomask, gpio_val);
1198 bttv_gpio_tracking(btv, audio_modes[mute ? 4 : input]);
1202 ctrl.id = V4L2_CID_AUDIO_MUTE;
1203 ctrl.value = btv->mute;
1204 bttv_call_all(btv, core, s_ctrl, &ctrl);
1205 if (btv->sd_msp34xx) {
1208 /* Note: the inputs tuner/radio/extern/intern are translated
1209 to msp routings. This assumes common behavior for all msp3400
1210 based TV cards. When this assumption fails, then the
1211 specific MSP routing must be added to the card table.
1212 For now this is sufficient. */
1214 case TVAUDIO_INPUT_RADIO:
1215 in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1216 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1218 case TVAUDIO_INPUT_EXTERN:
1219 in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER1,
1220 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1222 case TVAUDIO_INPUT_INTERN:
1223 /* Yes, this is the same input as for RADIO. I doubt
1224 if this is ever used. The only board with an INTERN
1225 input is the BTTV_BOARD_AVERMEDIA98. I wonder how
1226 that was tested. My guess is that the whole INTERN
1227 input does not work. */
1228 in = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1229 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1231 case TVAUDIO_INPUT_TUNER:
1233 /* This is the only card that uses TUNER2, and afaik,
1234 is the only difference between the VOODOOTV_FM
1236 if (btv->c.type == BTTV_BOARD_VOODOOTV_200)
1237 in = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER2, \
1238 MSP_DSP_IN_TUNER, MSP_DSP_IN_TUNER);
1240 in = MSP_INPUT_DEFAULT;
1243 v4l2_subdev_call(btv->sd_msp34xx, audio, s_routing,
1244 in, MSP_OUTPUT_DEFAULT, 0);
1246 if (btv->sd_tvaudio) {
1247 v4l2_subdev_call(btv->sd_tvaudio, audio, s_routing,
1254 audio_mute(struct bttv *btv, int mute)
1256 return audio_mux(btv, btv->audio, mute);
1260 audio_input(struct bttv *btv, int input)
1262 return audio_mux(btv, input, btv->mute);
1266 bttv_crop_calc_limits(struct bttv_crop *c)
1268 /* Scale factor min. 1:1, max. 16:1. Min. image size
1269 48 x 32. Scaled width must be a multiple of 4. */
1272 /* For bug compatibility with VIDIOCGCAP and image
1273 size checks in earlier driver versions. */
1274 c->min_scaled_width = 48;
1275 c->min_scaled_height = 32;
1277 c->min_scaled_width =
1278 (max(48, c->rect.width >> 4) + 3) & ~3;
1279 c->min_scaled_height =
1280 max(32, c->rect.height >> 4);
1283 c->max_scaled_width = c->rect.width & ~3;
1284 c->max_scaled_height = c->rect.height;
1288 bttv_crop_reset(struct bttv_crop *c, unsigned int norm)
1290 c->rect = bttv_tvnorms[norm].cropcap.defrect;
1291 bttv_crop_calc_limits(c);
1294 /* Call with btv->lock down. */
1296 set_tvnorm(struct bttv *btv, unsigned int norm)
1298 const struct bttv_tvnorm *tvnorm;
1301 BUG_ON(norm >= BTTV_TVNORMS);
1302 BUG_ON(btv->tvnorm >= BTTV_TVNORMS);
1304 tvnorm = &bttv_tvnorms[norm];
1306 if (memcmp(&bttv_tvnorms[btv->tvnorm].cropcap, &tvnorm->cropcap,
1307 sizeof (tvnorm->cropcap))) {
1308 bttv_crop_reset(&btv->crop[0], norm);
1309 btv->crop[1] = btv->crop[0]; /* current = default */
1311 if (0 == (btv->resources & VIDEO_RESOURCES)) {
1312 btv->crop_start = tvnorm->cropcap.bounds.top
1313 + tvnorm->cropcap.bounds.height;
1319 btwrite(tvnorm->adelay, BT848_ADELAY);
1320 btwrite(tvnorm->bdelay, BT848_BDELAY);
1321 btaor(tvnorm->iform,~(BT848_IFORM_NORM|BT848_IFORM_XTBOTH),
1323 btwrite(tvnorm->vbipack, BT848_VBI_PACK_SIZE);
1324 btwrite(1, BT848_VBI_PACK_DEL);
1325 bt848A_set_timing(btv);
1327 switch (btv->c.type) {
1328 case BTTV_BOARD_VOODOOTV_FM:
1329 case BTTV_BOARD_VOODOOTV_200:
1330 bttv_tda9880_setnorm(btv, gpio_read());
1333 id = tvnorm->v4l2_id;
1334 bttv_call_all(btv, core, s_std, id);
1339 /* Call with btv->lock down. */
1341 set_input(struct bttv *btv, unsigned int input, unsigned int norm)
1343 unsigned long flags;
1347 spin_lock_irqsave(&btv->s_lock,flags);
1348 if (btv->curr.frame_irq) {
1349 /* active capture -> delayed input switch */
1350 btv->new_input = input;
1352 video_mux(btv,input);
1354 spin_unlock_irqrestore(&btv->s_lock,flags);
1356 video_mux(btv,input);
1358 audio_input(btv, (btv->tuner_type != TUNER_ABSENT && input == 0) ?
1359 TVAUDIO_INPUT_TUNER : TVAUDIO_INPUT_EXTERN);
1360 set_tvnorm(btv, norm);
1363 static void init_irqreg(struct bttv *btv)
1366 btwrite(0xfffffUL, BT848_INT_STAT);
1368 if (bttv_tvcards[btv->c.type].no_video) {
1370 btwrite(BT848_INT_I2CDONE,
1374 btwrite((btv->triton1) |
1375 (btv->gpioirq ? BT848_INT_GPINT : 0) |
1377 (fdsr ? BT848_INT_FDSR : 0) |
1378 BT848_INT_RISCI | BT848_INT_OCERR |
1379 BT848_INT_FMTCHG|BT848_INT_HLOCK|
1385 static void init_bt848(struct bttv *btv)
1389 if (bttv_tvcards[btv->c.type].no_video) {
1390 /* very basic init only */
1395 btwrite(0x00, BT848_CAP_CTL);
1396 btwrite(BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL);
1397 btwrite(BT848_IFORM_XTAUTO | BT848_IFORM_AUTO, BT848_IFORM);
1399 /* set planar and packed mode trigger points and */
1400 /* set rising edge of inverted GPINTR pin as irq trigger */
1401 btwrite(BT848_GPIO_DMA_CTL_PKTP_32|
1402 BT848_GPIO_DMA_CTL_PLTP1_16|
1403 BT848_GPIO_DMA_CTL_PLTP23_16|
1404 BT848_GPIO_DMA_CTL_GPINTC|
1405 BT848_GPIO_DMA_CTL_GPINTI,
1406 BT848_GPIO_DMA_CTL);
1408 val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1409 btwrite(val, BT848_E_SCLOOP);
1410 btwrite(val, BT848_O_SCLOOP);
1412 btwrite(0x20, BT848_E_VSCALE_HI);
1413 btwrite(0x20, BT848_O_VSCALE_HI);
1414 btwrite(BT848_ADC_RESERVED | (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1417 btwrite(whitecrush_upper, BT848_WC_UP);
1418 btwrite(whitecrush_lower, BT848_WC_DOWN);
1420 if (btv->opt_lumafilter) {
1421 btwrite(0, BT848_E_CONTROL);
1422 btwrite(0, BT848_O_CONTROL);
1424 btwrite(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1425 btwrite(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1428 bt848_bright(btv, btv->bright);
1429 bt848_hue(btv, btv->hue);
1430 bt848_contrast(btv, btv->contrast);
1431 bt848_sat(btv, btv->saturation);
1437 static void bttv_reinit_bt848(struct bttv *btv)
1439 unsigned long flags;
1442 printk(KERN_INFO "bttv%d: reset, reinitialize\n",btv->c.nr);
1443 spin_lock_irqsave(&btv->s_lock,flags);
1445 bttv_set_dma(btv,0);
1446 spin_unlock_irqrestore(&btv->s_lock,flags);
1449 btv->pll.pll_current = -1;
1450 set_input(btv, btv->input, btv->tvnorm);
1453 static int bttv_g_ctrl(struct file *file, void *priv,
1454 struct v4l2_control *c)
1456 struct bttv_fh *fh = priv;
1457 struct bttv *btv = fh->btv;
1460 case V4L2_CID_BRIGHTNESS:
1461 c->value = btv->bright;
1464 c->value = btv->hue;
1466 case V4L2_CID_CONTRAST:
1467 c->value = btv->contrast;
1469 case V4L2_CID_SATURATION:
1470 c->value = btv->saturation;
1473 case V4L2_CID_AUDIO_MUTE:
1474 case V4L2_CID_AUDIO_VOLUME:
1475 case V4L2_CID_AUDIO_BALANCE:
1476 case V4L2_CID_AUDIO_BASS:
1477 case V4L2_CID_AUDIO_TREBLE:
1478 bttv_call_all(btv, core, g_ctrl, c);
1481 case V4L2_CID_PRIVATE_CHROMA_AGC:
1482 c->value = btv->opt_chroma_agc;
1484 case V4L2_CID_PRIVATE_COMBFILTER:
1485 c->value = btv->opt_combfilter;
1487 case V4L2_CID_PRIVATE_LUMAFILTER:
1488 c->value = btv->opt_lumafilter;
1490 case V4L2_CID_PRIVATE_AUTOMUTE:
1491 c->value = btv->opt_automute;
1493 case V4L2_CID_PRIVATE_AGC_CRUSH:
1494 c->value = btv->opt_adc_crush;
1496 case V4L2_CID_PRIVATE_VCR_HACK:
1497 c->value = btv->opt_vcr_hack;
1499 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1500 c->value = btv->opt_whitecrush_upper;
1502 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1503 c->value = btv->opt_whitecrush_lower;
1505 case V4L2_CID_PRIVATE_UV_RATIO:
1506 c->value = btv->opt_uv_ratio;
1508 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1509 c->value = btv->opt_full_luma_range;
1511 case V4L2_CID_PRIVATE_CORING:
1512 c->value = btv->opt_coring;
1520 static int bttv_s_ctrl(struct file *file, void *f,
1521 struct v4l2_control *c)
1525 struct bttv_fh *fh = f;
1526 struct bttv *btv = fh->btv;
1528 err = v4l2_prio_check(&btv->prio, fh->prio);
1533 case V4L2_CID_BRIGHTNESS:
1534 bt848_bright(btv, c->value);
1537 bt848_hue(btv, c->value);
1539 case V4L2_CID_CONTRAST:
1540 bt848_contrast(btv, c->value);
1542 case V4L2_CID_SATURATION:
1543 bt848_sat(btv, c->value);
1545 case V4L2_CID_AUDIO_MUTE:
1546 audio_mute(btv, c->value);
1548 case V4L2_CID_AUDIO_VOLUME:
1549 if (btv->volume_gpio)
1550 btv->volume_gpio(btv, c->value);
1552 bttv_call_all(btv, core, s_ctrl, c);
1554 case V4L2_CID_AUDIO_BALANCE:
1555 case V4L2_CID_AUDIO_BASS:
1556 case V4L2_CID_AUDIO_TREBLE:
1557 bttv_call_all(btv, core, s_ctrl, c);
1560 case V4L2_CID_PRIVATE_CHROMA_AGC:
1561 btv->opt_chroma_agc = c->value;
1562 val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1563 btwrite(val, BT848_E_SCLOOP);
1564 btwrite(val, BT848_O_SCLOOP);
1566 case V4L2_CID_PRIVATE_COMBFILTER:
1567 btv->opt_combfilter = c->value;
1569 case V4L2_CID_PRIVATE_LUMAFILTER:
1570 btv->opt_lumafilter = c->value;
1571 if (btv->opt_lumafilter) {
1572 btand(~BT848_CONTROL_LDEC, BT848_E_CONTROL);
1573 btand(~BT848_CONTROL_LDEC, BT848_O_CONTROL);
1575 btor(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1576 btor(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1579 case V4L2_CID_PRIVATE_AUTOMUTE:
1580 btv->opt_automute = c->value;
1582 case V4L2_CID_PRIVATE_AGC_CRUSH:
1583 btv->opt_adc_crush = c->value;
1584 btwrite(BT848_ADC_RESERVED |
1585 (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1588 case V4L2_CID_PRIVATE_VCR_HACK:
1589 btv->opt_vcr_hack = c->value;
1591 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1592 btv->opt_whitecrush_upper = c->value;
1593 btwrite(c->value, BT848_WC_UP);
1595 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1596 btv->opt_whitecrush_lower = c->value;
1597 btwrite(c->value, BT848_WC_DOWN);
1599 case V4L2_CID_PRIVATE_UV_RATIO:
1600 btv->opt_uv_ratio = c->value;
1601 bt848_sat(btv, btv->saturation);
1603 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1604 btv->opt_full_luma_range = c->value;
1605 btaor((c->value<<7), ~BT848_OFORM_RANGE, BT848_OFORM);
1607 case V4L2_CID_PRIVATE_CORING:
1608 btv->opt_coring = c->value;
1609 btaor((c->value<<5), ~BT848_OFORM_CORE32, BT848_OFORM);
1617 /* ----------------------------------------------------------------------- */
1619 void bttv_gpio_tracking(struct bttv *btv, char *comment)
1621 unsigned int outbits, data;
1622 outbits = btread(BT848_GPIO_OUT_EN);
1623 data = btread(BT848_GPIO_DATA);
1624 printk(KERN_DEBUG "bttv%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
1625 btv->c.nr,outbits,data & outbits, data & ~outbits, comment);
1628 static void bttv_field_count(struct bttv *btv)
1636 /* start field counter */
1637 btor(BT848_INT_VSYNC,BT848_INT_MASK);
1639 /* stop field counter */
1640 btand(~BT848_INT_VSYNC,BT848_INT_MASK);
1641 btv->field_count = 0;
1645 static const struct bttv_format*
1646 format_by_fourcc(int fourcc)
1650 for (i = 0; i < FORMATS; i++) {
1651 if (-1 == formats[i].fourcc)
1653 if (formats[i].fourcc == fourcc)
1659 /* ----------------------------------------------------------------------- */
1663 bttv_switch_overlay(struct bttv *btv, struct bttv_fh *fh,
1664 struct bttv_buffer *new)
1666 struct bttv_buffer *old;
1667 unsigned long flags;
1670 dprintk("switch_overlay: enter [new=%p]\n",new);
1672 new->vb.state = VIDEOBUF_DONE;
1673 spin_lock_irqsave(&btv->s_lock,flags);
1677 bttv_set_dma(btv, 0x03);
1678 spin_unlock_irqrestore(&btv->s_lock,flags);
1680 dprintk("switch_overlay: old=%p state is %d\n",old,old->vb.state);
1681 bttv_dma_free(&fh->cap,btv, old);
1685 free_btres_lock(btv,fh,RESOURCE_OVERLAY);
1686 dprintk("switch_overlay: done\n");
1690 /* ----------------------------------------------------------------------- */
1691 /* video4linux (1) interface */
1693 static int bttv_prepare_buffer(struct videobuf_queue *q,struct bttv *btv,
1694 struct bttv_buffer *buf,
1695 const struct bttv_format *fmt,
1696 unsigned int width, unsigned int height,
1697 enum v4l2_field field)
1699 struct bttv_fh *fh = q->priv_data;
1700 int redo_dma_risc = 0;
1705 /* check settings */
1708 if (fmt->btformat == BT848_COLOR_FMT_RAW) {
1710 height = RAW_LINES*2;
1711 if (width*height > buf->vb.bsize)
1713 buf->vb.size = buf->vb.bsize;
1715 /* Make sure tvnorm and vbi_end remain consistent
1716 until we're done. */
1717 mutex_lock(&btv->lock);
1721 /* In this mode capturing always starts at defrect.top
1722 (default VDELAY), ignoring cropping parameters. */
1723 if (btv->vbi_end > bttv_tvnorms[norm].cropcap.defrect.top) {
1724 mutex_unlock(&btv->lock);
1728 mutex_unlock(&btv->lock);
1730 c.rect = bttv_tvnorms[norm].cropcap.defrect;
1732 mutex_lock(&btv->lock);
1735 c = btv->crop[!!fh->do_crop];
1737 mutex_unlock(&btv->lock);
1739 if (width < c.min_scaled_width ||
1740 width > c.max_scaled_width ||
1741 height < c.min_scaled_height)
1745 case V4L2_FIELD_TOP:
1746 case V4L2_FIELD_BOTTOM:
1747 case V4L2_FIELD_ALTERNATE:
1748 /* btv->crop counts frame lines. Max. scale
1749 factor is 16:1 for frames, 8:1 for fields. */
1750 if (height * 2 > c.max_scaled_height)
1755 if (height > c.max_scaled_height)
1760 buf->vb.size = (width * height * fmt->depth) >> 3;
1761 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
1765 /* alloc + fill struct bttv_buffer (if changed) */
1766 if (buf->vb.width != width || buf->vb.height != height ||
1767 buf->vb.field != field ||
1768 buf->tvnorm != norm || buf->fmt != fmt ||
1769 buf->crop.top != c.rect.top ||
1770 buf->crop.left != c.rect.left ||
1771 buf->crop.width != c.rect.width ||
1772 buf->crop.height != c.rect.height) {
1773 buf->vb.width = width;
1774 buf->vb.height = height;
1775 buf->vb.field = field;
1782 /* alloc risc memory */
1783 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
1785 if (0 != (rc = videobuf_iolock(q,&buf->vb,&btv->fbuf)))
1790 if (0 != (rc = bttv_buffer_risc(btv,buf)))
1793 buf->vb.state = VIDEOBUF_PREPARED;
1797 bttv_dma_free(q,btv,buf);
1802 buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
1804 struct bttv_fh *fh = q->priv_data;
1806 *size = fh->fmt->depth*fh->width*fh->height >> 3;
1809 if (*size * *count > gbuffers * gbufsize)
1810 *count = (gbuffers * gbufsize) / *size;
1815 buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
1816 enum v4l2_field field)
1818 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1819 struct bttv_fh *fh = q->priv_data;
1821 return bttv_prepare_buffer(q,fh->btv, buf, fh->fmt,
1822 fh->width, fh->height, field);
1826 buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
1828 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1829 struct bttv_fh *fh = q->priv_data;
1830 struct bttv *btv = fh->btv;
1832 buf->vb.state = VIDEOBUF_QUEUED;
1833 list_add_tail(&buf->vb.queue,&btv->capture);
1834 if (!btv->curr.frame_irq) {
1836 bttv_set_dma(btv, 0x03);
1840 static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
1842 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1843 struct bttv_fh *fh = q->priv_data;
1845 bttv_dma_free(q,fh->btv,buf);
1848 static struct videobuf_queue_ops bttv_video_qops = {
1849 .buf_setup = buffer_setup,
1850 .buf_prepare = buffer_prepare,
1851 .buf_queue = buffer_queue,
1852 .buf_release = buffer_release,
1855 static int bttv_s_std(struct file *file, void *priv, v4l2_std_id *id)
1857 struct bttv_fh *fh = priv;
1858 struct bttv *btv = fh->btv;
1862 mutex_lock(&btv->lock);
1863 err = v4l2_prio_check(&btv->prio, fh->prio);
1867 for (i = 0; i < BTTV_TVNORMS; i++)
1868 if (*id & bttv_tvnorms[i].v4l2_id)
1870 if (i == BTTV_TVNORMS) {
1878 mutex_unlock(&btv->lock);
1883 static int bttv_querystd(struct file *file, void *f, v4l2_std_id *id)
1885 struct bttv_fh *fh = f;
1886 struct bttv *btv = fh->btv;
1888 if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML)
1889 *id = V4L2_STD_625_50;
1891 *id = V4L2_STD_525_60;
1895 static int bttv_enum_input(struct file *file, void *priv,
1896 struct v4l2_input *i)
1898 struct bttv_fh *fh = priv;
1899 struct bttv *btv = fh->btv;
1902 mutex_lock(&btv->lock);
1903 if (i->index >= bttv_tvcards[btv->c.type].video_inputs) {
1908 i->type = V4L2_INPUT_TYPE_CAMERA;
1911 if (btv->tuner_type != TUNER_ABSENT && i->index == 0) {
1912 sprintf(i->name, "Television");
1913 i->type = V4L2_INPUT_TYPE_TUNER;
1915 } else if (i->index == btv->svhs) {
1916 sprintf(i->name, "S-Video");
1918 sprintf(i->name, "Composite%d", i->index);
1921 if (i->index == btv->input) {
1922 __u32 dstatus = btread(BT848_DSTATUS);
1923 if (0 == (dstatus & BT848_DSTATUS_PRES))
1924 i->status |= V4L2_IN_ST_NO_SIGNAL;
1925 if (0 == (dstatus & BT848_DSTATUS_HLOC))
1926 i->status |= V4L2_IN_ST_NO_H_LOCK;
1929 i->std = BTTV_NORMS;
1932 mutex_unlock(&btv->lock);
1937 static int bttv_g_input(struct file *file, void *priv, unsigned int *i)
1939 struct bttv_fh *fh = priv;
1940 struct bttv *btv = fh->btv;
1942 mutex_lock(&btv->lock);
1944 mutex_unlock(&btv->lock);
1949 static int bttv_s_input(struct file *file, void *priv, unsigned int i)
1951 struct bttv_fh *fh = priv;
1952 struct bttv *btv = fh->btv;
1956 mutex_lock(&btv->lock);
1957 err = v4l2_prio_check(&btv->prio, fh->prio);
1961 if (i > bttv_tvcards[btv->c.type].video_inputs) {
1966 set_input(btv, i, btv->tvnorm);
1969 mutex_unlock(&btv->lock);
1973 static int bttv_s_tuner(struct file *file, void *priv,
1974 struct v4l2_tuner *t)
1976 struct bttv_fh *fh = priv;
1977 struct bttv *btv = fh->btv;
1980 if (unlikely(0 != t->index))
1983 mutex_lock(&btv->lock);
1984 if (unlikely(btv->tuner_type == TUNER_ABSENT)) {
1989 err = v4l2_prio_check(&btv->prio, fh->prio);
1993 bttv_call_all(btv, tuner, s_tuner, t);
1995 if (btv->audio_mode_gpio)
1996 btv->audio_mode_gpio(btv, t, 1);
1999 mutex_unlock(&btv->lock);
2004 static int bttv_g_frequency(struct file *file, void *priv,
2005 struct v4l2_frequency *f)
2007 struct bttv_fh *fh = priv;
2008 struct bttv *btv = fh->btv;
2010 mutex_lock(&btv->lock);
2011 f->type = btv->radio_user ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
2012 f->frequency = btv->freq;
2013 mutex_unlock(&btv->lock);
2018 static int bttv_s_frequency(struct file *file, void *priv,
2019 struct v4l2_frequency *f)
2021 struct bttv_fh *fh = priv;
2022 struct bttv *btv = fh->btv;
2025 if (unlikely(f->tuner != 0))
2028 mutex_lock(&btv->lock);
2029 err = v4l2_prio_check(&btv->prio, fh->prio);
2033 if (unlikely(f->type != (btv->radio_user
2034 ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV))) {
2038 btv->freq = f->frequency;
2039 bttv_call_all(btv, tuner, s_frequency, f);
2040 if (btv->has_matchbox && btv->radio_user)
2041 tea5757_set_freq(btv, btv->freq);
2043 mutex_unlock(&btv->lock);
2048 static int bttv_log_status(struct file *file, void *f)
2050 struct bttv_fh *fh = f;
2051 struct bttv *btv = fh->btv;
2053 printk(KERN_INFO "bttv%d: ======== START STATUS CARD #%d ========\n",
2054 btv->c.nr, btv->c.nr);
2055 bttv_call_all(btv, core, log_status);
2056 printk(KERN_INFO "bttv%d: ======== END STATUS CARD #%d ========\n",
2057 btv->c.nr, btv->c.nr);
2061 #ifdef CONFIG_VIDEO_ADV_DEBUG
2062 static int bttv_g_register(struct file *file, void *f,
2063 struct v4l2_dbg_register *reg)
2065 struct bttv_fh *fh = f;
2066 struct bttv *btv = fh->btv;
2068 if (!capable(CAP_SYS_ADMIN))
2071 if (!v4l2_chip_match_host(®->match))
2074 /* bt848 has a 12-bit register space */
2076 reg->val = btread(reg->reg);
2082 static int bttv_s_register(struct file *file, void *f,
2083 struct v4l2_dbg_register *reg)
2085 struct bttv_fh *fh = f;
2086 struct bttv *btv = fh->btv;
2088 if (!capable(CAP_SYS_ADMIN))
2091 if (!v4l2_chip_match_host(®->match))
2094 /* bt848 has a 12-bit register space */
2096 btwrite(reg->val, reg->reg);
2102 /* Given cropping boundaries b and the scaled width and height of a
2103 single field or frame, which must not exceed hardware limits, this
2104 function adjusts the cropping parameters c. */
2106 bttv_crop_adjust (struct bttv_crop * c,
2107 const struct v4l2_rect * b,
2110 enum v4l2_field field)
2112 __s32 frame_height = height << !V4L2_FIELD_HAS_BOTH(field);
2116 if (width < c->min_scaled_width) {
2117 /* Max. hor. scale factor 16:1. */
2118 c->rect.width = width * 16;
2119 } else if (width > c->max_scaled_width) {
2120 /* Min. hor. scale factor 1:1. */
2121 c->rect.width = width;
2123 max_left = b->left + b->width - width;
2124 max_left = min(max_left, (__s32) MAX_HDELAY);
2125 if (c->rect.left > max_left)
2126 c->rect.left = max_left;
2129 if (height < c->min_scaled_height) {
2130 /* Max. vert. scale factor 16:1, single fields 8:1. */
2131 c->rect.height = height * 16;
2132 } else if (frame_height > c->max_scaled_height) {
2133 /* Min. vert. scale factor 1:1.
2134 Top and height count field lines times two. */
2135 c->rect.height = (frame_height + 1) & ~1;
2137 max_top = b->top + b->height - c->rect.height;
2138 if (c->rect.top > max_top)
2139 c->rect.top = max_top;
2142 bttv_crop_calc_limits(c);
2145 /* Returns an error if scaling to a frame or single field with the given
2146 width and height is not possible with the current cropping parameters
2147 and width aligned according to width_mask. If adjust_size is TRUE the
2148 function may adjust the width and/or height instead, rounding width
2149 to (width + width_bias) & width_mask. If adjust_crop is TRUE it may
2150 also adjust the current cropping parameters to get closer to the
2151 desired image size. */
2153 limit_scaled_size_lock (struct bttv_fh * fh,
2156 enum v4l2_field field,
2157 unsigned int width_mask,
2158 unsigned int width_bias,
2162 struct bttv *btv = fh->btv;
2163 const struct v4l2_rect *b;
2164 struct bttv_crop *c;
2171 BUG_ON((int) width_mask >= 0 ||
2172 width_bias >= (unsigned int) -width_mask);
2174 /* Make sure tvnorm, vbi_end and the current cropping parameters
2175 remain consistent until we're done. */
2176 mutex_lock(&btv->lock);
2178 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2180 /* Do crop - use current, don't - use default parameters. */
2181 c = &btv->crop[!!fh->do_crop];
2186 && !locked_btres(btv, VIDEO_RESOURCES)) {
2190 /* We cannot scale up. When the scaled image is larger
2191 than crop.rect we adjust the crop.rect as required
2192 by the V4L2 spec, hence cropcap.bounds are our limit. */
2193 max_width = min(b->width, (__s32) MAX_HACTIVE);
2194 max_height = b->height;
2196 /* We cannot capture the same line as video and VBI data.
2197 Note btv->vbi_end is really a minimum, see
2198 bttv_vbi_try_fmt(). */
2199 if (btv->vbi_end > b->top) {
2200 max_height -= btv->vbi_end - b->top;
2202 if (min_height > max_height)
2207 if (btv->vbi_end > c->rect.top)
2210 min_width = c->min_scaled_width;
2211 min_height = c->min_scaled_height;
2212 max_width = c->max_scaled_width;
2213 max_height = c->max_scaled_height;
2218 min_width = (min_width - width_mask - 1) & width_mask;
2219 max_width = max_width & width_mask;
2221 /* Max. scale factor is 16:1 for frames, 8:1 for fields. */
2222 min_height = min_height;
2223 /* Min. scale factor is 1:1. */
2224 max_height >>= !V4L2_FIELD_HAS_BOTH(field);
2227 *width = clamp(*width, min_width, max_width);
2228 *height = clamp(*height, min_height, max_height);
2230 /* Round after clamping to avoid overflow. */
2231 *width = (*width + width_bias) & width_mask;
2234 bttv_crop_adjust(c, b, *width, *height, field);
2236 if (btv->vbi_end > c->rect.top) {
2237 /* Move the crop window out of the way. */
2238 c->rect.top = btv->vbi_end;
2243 if (*width < min_width ||
2244 *height < min_height ||
2245 *width > max_width ||
2246 *height > max_height ||
2247 0 != (*width & ~width_mask))
2251 rc = 0; /* success */
2254 mutex_unlock(&btv->lock);
2259 /* Returns an error if the given overlay window dimensions are not
2260 possible with the current cropping parameters. If adjust_size is
2261 TRUE the function may adjust the window width and/or height
2262 instead, however it always rounds the horizontal position and
2263 width as btcx_align() does. If adjust_crop is TRUE the function
2264 may also adjust the current cropping parameters to get closer
2265 to the desired window size. */
2267 verify_window_lock (struct bttv_fh * fh,
2268 struct v4l2_window * win,
2272 enum v4l2_field field;
2273 unsigned int width_mask;
2276 if (win->w.width < 48 || win->w.height < 32)
2278 if (win->clipcount > 2048)
2283 if (V4L2_FIELD_ANY == field) {
2286 mutex_lock(&fh->btv->lock);
2287 height2 = fh->btv->crop[!!fh->do_crop].rect.height >> 1;
2288 mutex_unlock(&fh->btv->lock);
2289 field = (win->w.height > height2)
2290 ? V4L2_FIELD_INTERLACED
2294 case V4L2_FIELD_TOP:
2295 case V4L2_FIELD_BOTTOM:
2296 case V4L2_FIELD_INTERLACED:
2302 /* 4-byte alignment. */
2303 if (NULL == fh->ovfmt)
2306 switch (fh->ovfmt->depth) {
2320 win->w.width -= win->w.left & ~width_mask;
2321 win->w.left = (win->w.left - width_mask - 1) & width_mask;
2323 rc = limit_scaled_size_lock(fh, &win->w.width, &win->w.height,
2325 /* width_bias: round down */ 0,
2326 adjust_size, adjust_crop);
2334 static int setup_window_lock(struct bttv_fh *fh, struct bttv *btv,
2335 struct v4l2_window *win, int fixup)
2337 struct v4l2_clip *clips = NULL;
2338 int n,size,retval = 0;
2340 if (NULL == fh->ovfmt)
2342 if (!(fh->ovfmt->flags & FORMAT_FLAGS_PACKED))
2344 retval = verify_window_lock(fh, win,
2345 /* adjust_size */ fixup,
2346 /* adjust_crop */ fixup);
2350 /* copy clips -- luckily v4l1 + v4l2 are binary
2351 compatible here ...*/
2353 size = sizeof(*clips)*(n+4);
2354 clips = kmalloc(size,GFP_KERNEL);
2358 if (copy_from_user(clips,win->clips,sizeof(struct v4l2_clip)*n)) {
2364 mutex_lock(&fh->cap.vb_lock);
2365 /* clip against screen */
2366 if (NULL != btv->fbuf.base)
2367 n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height,
2369 btcx_sort_clips(clips,n);
2371 /* 4-byte alignments */
2372 switch (fh->ovfmt->depth) {
2375 btcx_align(&win->w, clips, n, 3);
2378 btcx_align(&win->w, clips, n, 1);
2381 /* no alignment fixups needed */
2387 kfree(fh->ov.clips);
2388 fh->ov.clips = clips;
2392 fh->ov.field = win->field;
2393 fh->ov.setup_ok = 1;
2396 * FIXME: btv is protected by btv->lock mutex, while btv->init
2397 * is protected by fh->cap.vb_lock. This seems to open the
2398 * possibility for some race situations. Maybe the better would
2399 * be to unify those locks or to use another way to store the
2400 * init values that will be consumed by videobuf callbacks
2402 btv->init.ov.w.width = win->w.width;
2403 btv->init.ov.w.height = win->w.height;
2404 btv->init.ov.field = win->field;
2406 /* update overlay if needed */
2408 if (check_btres(fh, RESOURCE_OVERLAY)) {
2409 struct bttv_buffer *new;
2411 new = videobuf_sg_alloc(sizeof(*new));
2412 new->crop = btv->crop[!!fh->do_crop].rect;
2413 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2414 retval = bttv_switch_overlay(btv,fh,new);
2416 mutex_unlock(&fh->cap.vb_lock);
2420 /* ----------------------------------------------------------------------- */
2422 static struct videobuf_queue* bttv_queue(struct bttv_fh *fh)
2424 struct videobuf_queue* q = NULL;
2427 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2430 case V4L2_BUF_TYPE_VBI_CAPTURE:
2439 static int bttv_resource(struct bttv_fh *fh)
2444 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2445 res = RESOURCE_VIDEO_STREAM;
2447 case V4L2_BUF_TYPE_VBI_CAPTURE:
2456 static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type)
2458 struct videobuf_queue *q = bttv_queue(fh);
2459 int res = bttv_resource(fh);
2461 if (check_btres(fh,res))
2463 if (videobuf_queue_is_busy(q))
2470 pix_format_set_size (struct v4l2_pix_format * f,
2471 const struct bttv_format * fmt,
2473 unsigned int height)
2478 if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2479 f->bytesperline = width; /* Y plane */
2480 f->sizeimage = (width * height * fmt->depth) >> 3;
2482 f->bytesperline = (width * fmt->depth) >> 3;
2483 f->sizeimage = height * f->bytesperline;
2487 static int bttv_g_fmt_vid_cap(struct file *file, void *priv,
2488 struct v4l2_format *f)
2490 struct bttv_fh *fh = priv;
2492 pix_format_set_size(&f->fmt.pix, fh->fmt,
2493 fh->width, fh->height);
2494 f->fmt.pix.field = fh->cap.field;
2495 f->fmt.pix.pixelformat = fh->fmt->fourcc;
2500 static int bttv_g_fmt_vid_overlay(struct file *file, void *priv,
2501 struct v4l2_format *f)
2503 struct bttv_fh *fh = priv;
2505 f->fmt.win.w = fh->ov.w;
2506 f->fmt.win.field = fh->ov.field;
2511 static int bttv_try_fmt_vid_cap(struct file *file, void *priv,
2512 struct v4l2_format *f)
2514 const struct bttv_format *fmt;
2515 struct bttv_fh *fh = priv;
2516 struct bttv *btv = fh->btv;
2517 enum v4l2_field field;
2518 __s32 width, height;
2521 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2525 field = f->fmt.pix.field;
2527 if (V4L2_FIELD_ANY == field) {
2530 mutex_lock(&btv->lock);
2531 height2 = btv->crop[!!fh->do_crop].rect.height >> 1;
2532 mutex_unlock(&btv->lock);
2533 field = (f->fmt.pix.height > height2)
2534 ? V4L2_FIELD_INTERLACED
2535 : V4L2_FIELD_BOTTOM;
2538 if (V4L2_FIELD_SEQ_BT == field)
2539 field = V4L2_FIELD_SEQ_TB;
2542 case V4L2_FIELD_TOP:
2543 case V4L2_FIELD_BOTTOM:
2544 case V4L2_FIELD_ALTERNATE:
2545 case V4L2_FIELD_INTERLACED:
2547 case V4L2_FIELD_SEQ_TB:
2548 if (fmt->flags & FORMAT_FLAGS_PLANAR)
2555 width = f->fmt.pix.width;
2556 height = f->fmt.pix.height;
2558 rc = limit_scaled_size_lock(fh, &width, &height, field,
2559 /* width_mask: 4 pixels */ ~3,
2560 /* width_bias: nearest */ 2,
2561 /* adjust_size */ 1,
2562 /* adjust_crop */ 0);
2566 /* update data for the application */
2567 f->fmt.pix.field = field;
2568 pix_format_set_size(&f->fmt.pix, fmt, width, height);
2573 static int bttv_try_fmt_vid_overlay(struct file *file, void *priv,
2574 struct v4l2_format *f)
2576 struct bttv_fh *fh = priv;
2578 return verify_window_lock(fh, &f->fmt.win,
2579 /* adjust_size */ 1,
2580 /* adjust_crop */ 0);
2583 static int bttv_s_fmt_vid_cap(struct file *file, void *priv,
2584 struct v4l2_format *f)
2587 const struct bttv_format *fmt;
2588 struct bttv_fh *fh = priv;
2589 struct bttv *btv = fh->btv;
2590 __s32 width, height;
2591 enum v4l2_field field;
2593 retval = bttv_switch_type(fh, f->type);
2597 retval = bttv_try_fmt_vid_cap(file, priv, f);
2601 width = f->fmt.pix.width;
2602 height = f->fmt.pix.height;
2603 field = f->fmt.pix.field;
2605 retval = limit_scaled_size_lock(fh, &width, &height, f->fmt.pix.field,
2606 /* width_mask: 4 pixels */ ~3,
2607 /* width_bias: nearest */ 2,
2608 /* adjust_size */ 1,
2609 /* adjust_crop */ 1);
2613 f->fmt.pix.field = field;
2615 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2617 /* update our state informations */
2618 mutex_lock(&fh->cap.vb_lock);
2620 fh->cap.field = f->fmt.pix.field;
2621 fh->cap.last = V4L2_FIELD_NONE;
2622 fh->width = f->fmt.pix.width;
2623 fh->height = f->fmt.pix.height;
2624 btv->init.fmt = fmt;
2625 btv->init.width = f->fmt.pix.width;
2626 btv->init.height = f->fmt.pix.height;
2627 mutex_unlock(&fh->cap.vb_lock);
2632 static int bttv_s_fmt_vid_overlay(struct file *file, void *priv,
2633 struct v4l2_format *f)
2635 struct bttv_fh *fh = priv;
2636 struct bttv *btv = fh->btv;
2638 if (no_overlay > 0) {
2639 printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2643 return setup_window_lock(fh, btv, &f->fmt.win, 1);
2646 #ifdef CONFIG_VIDEO_V4L1_COMPAT
2647 static int vidiocgmbuf(struct file *file, void *priv, struct video_mbuf *mbuf)
2651 struct bttv_fh *fh = priv;
2653 mutex_lock(&fh->cap.vb_lock);
2654 retval = __videobuf_mmap_setup(&fh->cap, gbuffers, gbufsize,
2657 mutex_unlock(&fh->cap.vb_lock);
2662 memset(mbuf, 0, sizeof(*mbuf));
2663 mbuf->frames = gbuffers;
2664 mbuf->size = gbuffers * gbufsize;
2666 for (i = 0; i < gbuffers; i++)
2667 mbuf->offsets[i] = i * gbufsize;
2669 mutex_unlock(&fh->cap.vb_lock);
2674 static int bttv_querycap(struct file *file, void *priv,
2675 struct v4l2_capability *cap)
2677 struct bttv_fh *fh = priv;
2678 struct bttv *btv = fh->btv;
2683 strlcpy(cap->driver, "bttv", sizeof(cap->driver));
2684 strlcpy(cap->card, btv->video_dev->name, sizeof(cap->card));
2685 snprintf(cap->bus_info, sizeof(cap->bus_info),
2686 "PCI:%s", pci_name(btv->c.pci));
2687 cap->version = BTTV_VERSION_CODE;
2689 V4L2_CAP_VIDEO_CAPTURE |
2690 V4L2_CAP_VBI_CAPTURE |
2691 V4L2_CAP_READWRITE |
2693 if (no_overlay <= 0)
2694 cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
2697 * No need to lock here: those vars are initialized during board
2698 * probe and remains untouched during the rest of the driver lifecycle
2700 if (btv->has_saa6588)
2701 cap->capabilities |= V4L2_CAP_RDS_CAPTURE;
2702 if (btv->tuner_type != TUNER_ABSENT)
2703 cap->capabilities |= V4L2_CAP_TUNER;
2707 static int bttv_enum_fmt_cap_ovr(struct v4l2_fmtdesc *f)
2711 for (i = 0; i < FORMATS; i++) {
2712 if (formats[i].fourcc != -1)
2714 if ((unsigned int)index == f->index)
2720 f->pixelformat = formats[i].fourcc;
2721 strlcpy(f->description, formats[i].name, sizeof(f->description));
2726 static int bttv_enum_fmt_vid_cap(struct file *file, void *priv,
2727 struct v4l2_fmtdesc *f)
2729 int rc = bttv_enum_fmt_cap_ovr(f);
2737 static int bttv_enum_fmt_vid_overlay(struct file *file, void *priv,
2738 struct v4l2_fmtdesc *f)
2742 if (no_overlay > 0) {
2743 printk(KERN_ERR "V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2747 rc = bttv_enum_fmt_cap_ovr(f);
2752 if (!(formats[rc].flags & FORMAT_FLAGS_PACKED))
2758 static int bttv_g_fbuf(struct file *file, void *f,
2759 struct v4l2_framebuffer *fb)
2761 struct bttv_fh *fh = f;
2762 struct bttv *btv = fh->btv;
2765 fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
2767 fb->fmt.pixelformat = fh->ovfmt->fourcc;
2771 static int bttv_overlay(struct file *file, void *f, unsigned int on)
2773 struct bttv_fh *fh = f;
2774 struct bttv *btv = fh->btv;
2775 struct bttv_buffer *new;
2779 mutex_lock(&fh->cap.vb_lock);
2781 if (unlikely(!btv->fbuf.base)) {
2782 mutex_unlock(&fh->cap.vb_lock);
2785 if (unlikely(!fh->ov.setup_ok)) {
2786 dprintk("bttv%d: overlay: !setup_ok\n", btv->c.nr);
2791 mutex_unlock(&fh->cap.vb_lock);
2794 if (!check_alloc_btres_lock(btv, fh, RESOURCE_OVERLAY))
2797 mutex_lock(&fh->cap.vb_lock);
2799 fh->ov.tvnorm = btv->tvnorm;
2800 new = videobuf_sg_alloc(sizeof(*new));
2801 new->crop = btv->crop[!!fh->do_crop].rect;
2802 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2808 retval = bttv_switch_overlay(btv, fh, new);
2809 mutex_unlock(&fh->cap.vb_lock);
2813 static int bttv_s_fbuf(struct file *file, void *f,
2814 struct v4l2_framebuffer *fb)
2816 struct bttv_fh *fh = f;
2817 struct bttv *btv = fh->btv;
2818 const struct bttv_format *fmt;
2821 if (!capable(CAP_SYS_ADMIN) &&
2822 !capable(CAP_SYS_RAWIO))
2826 fmt = format_by_fourcc(fb->fmt.pixelformat);
2829 if (0 == (fmt->flags & FORMAT_FLAGS_PACKED))
2833 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2834 __s32 width = fb->fmt.width;
2835 __s32 height = fb->fmt.height;
2837 retval = limit_scaled_size_lock(fh, &width, &height,
2838 V4L2_FIELD_INTERLACED,
2839 /* width_mask */ ~3,
2841 /* adjust_size */ 0,
2842 /* adjust_crop */ 0);
2848 mutex_lock(&fh->cap.vb_lock);
2849 btv->fbuf.base = fb->base;
2850 btv->fbuf.fmt.width = fb->fmt.width;
2851 btv->fbuf.fmt.height = fb->fmt.height;
2852 if (0 != fb->fmt.bytesperline)
2853 btv->fbuf.fmt.bytesperline = fb->fmt.bytesperline;
2855 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fmt->depth/8;
2859 btv->init.ovfmt = fmt;
2860 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2863 fh->ov.w.width = fb->fmt.width;
2864 fh->ov.w.height = fb->fmt.height;
2865 btv->init.ov.w.width = fb->fmt.width;
2866 btv->init.ov.w.height = fb->fmt.height;
2867 kfree(fh->ov.clips);
2868 fh->ov.clips = NULL;
2871 if (check_btres(fh, RESOURCE_OVERLAY)) {
2872 struct bttv_buffer *new;
2874 new = videobuf_sg_alloc(sizeof(*new));
2875 new->crop = btv->crop[!!fh->do_crop].rect;
2876 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2877 retval = bttv_switch_overlay(btv, fh, new);
2880 mutex_unlock(&fh->cap.vb_lock);
2884 static int bttv_reqbufs(struct file *file, void *priv,
2885 struct v4l2_requestbuffers *p)
2887 struct bttv_fh *fh = priv;
2888 return videobuf_reqbufs(bttv_queue(fh), p);
2891 static int bttv_querybuf(struct file *file, void *priv,
2892 struct v4l2_buffer *b)
2894 struct bttv_fh *fh = priv;
2895 return videobuf_querybuf(bttv_queue(fh), b);
2898 static int bttv_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2900 struct bttv_fh *fh = priv;
2901 struct bttv *btv = fh->btv;
2902 int res = bttv_resource(fh);
2904 if (!check_alloc_btres_lock(btv, fh, res))
2907 return videobuf_qbuf(bttv_queue(fh), b);
2910 static int bttv_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
2912 struct bttv_fh *fh = priv;
2913 return videobuf_dqbuf(bttv_queue(fh), b,
2914 file->f_flags & O_NONBLOCK);
2917 static int bttv_streamon(struct file *file, void *priv,
2918 enum v4l2_buf_type type)
2920 struct bttv_fh *fh = priv;
2921 struct bttv *btv = fh->btv;
2922 int res = bttv_resource(fh);
2924 if (!check_alloc_btres_lock(btv, fh, res))
2926 return videobuf_streamon(bttv_queue(fh));
2930 static int bttv_streamoff(struct file *file, void *priv,
2931 enum v4l2_buf_type type)
2933 struct bttv_fh *fh = priv;
2934 struct bttv *btv = fh->btv;
2936 int res = bttv_resource(fh);
2939 retval = videobuf_streamoff(bttv_queue(fh));
2942 free_btres_lock(btv, fh, res);
2946 static int bttv_queryctrl(struct file *file, void *priv,
2947 struct v4l2_queryctrl *c)
2949 struct bttv_fh *fh = priv;
2950 struct bttv *btv = fh->btv;
2951 const struct v4l2_queryctrl *ctrl;
2953 if ((c->id < V4L2_CID_BASE ||
2954 c->id >= V4L2_CID_LASTP1) &&
2955 (c->id < V4L2_CID_PRIVATE_BASE ||
2956 c->id >= V4L2_CID_PRIVATE_LASTP1))
2959 mutex_lock(&btv->lock);
2960 if (!btv->volume_gpio && (c->id == V4L2_CID_AUDIO_VOLUME))
2963 ctrl = ctrl_by_id(c->id);
2965 *c = (NULL != ctrl) ? *ctrl : no_ctl;
2967 mutex_unlock(&btv->lock);
2972 static int bttv_g_parm(struct file *file, void *f,
2973 struct v4l2_streamparm *parm)
2975 struct bttv_fh *fh = f;
2976 struct bttv *btv = fh->btv;
2978 mutex_lock(&btv->lock);
2979 v4l2_video_std_frame_period(bttv_tvnorms[btv->tvnorm].v4l2_id,
2980 &parm->parm.capture.timeperframe);
2981 mutex_unlock(&btv->lock);
2986 static int bttv_g_tuner(struct file *file, void *priv,
2987 struct v4l2_tuner *t)
2989 struct bttv_fh *fh = priv;
2990 struct bttv *btv = fh->btv;
2992 if (btv->tuner_type == TUNER_ABSENT)
2997 mutex_lock(&btv->lock);
2998 t->rxsubchans = V4L2_TUNER_SUB_MONO;
2999 bttv_call_all(btv, tuner, g_tuner, t);
3000 strcpy(t->name, "Television");
3001 t->capability = V4L2_TUNER_CAP_NORM;
3002 t->type = V4L2_TUNER_ANALOG_TV;
3003 if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
3006 if (btv->audio_mode_gpio)
3007 btv->audio_mode_gpio(btv, t, 0);
3009 mutex_unlock(&btv->lock);
3013 static int bttv_g_priority(struct file *file, void *f, enum v4l2_priority *p)
3015 struct bttv_fh *fh = f;
3016 struct bttv *btv = fh->btv;
3018 mutex_lock(&btv->lock);
3019 *p = v4l2_prio_max(&btv->prio);
3020 mutex_unlock(&btv->lock);
3025 static int bttv_s_priority(struct file *file, void *f,
3026 enum v4l2_priority prio)
3028 struct bttv_fh *fh = f;
3029 struct bttv *btv = fh->btv;
3032 mutex_lock(&btv->lock);
3033 rc = v4l2_prio_change(&btv->prio, &fh->prio, prio);
3034 mutex_unlock(&btv->lock);
3039 static int bttv_cropcap(struct file *file, void *priv,
3040 struct v4l2_cropcap *cap)
3042 struct bttv_fh *fh = priv;
3043 struct bttv *btv = fh->btv;
3045 if (cap->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3046 cap->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3049 mutex_lock(&btv->lock);
3050 *cap = bttv_tvnorms[btv->tvnorm].cropcap;
3051 mutex_unlock(&btv->lock);
3056 static int bttv_g_crop(struct file *file, void *f, struct v4l2_crop *crop)
3058 struct bttv_fh *fh = f;
3059 struct bttv *btv = fh->btv;
3061 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3062 crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3065 /* No fh->do_crop = 1; because btv->crop[1] may be
3066 inconsistent with fh->width or fh->height and apps
3067 do not expect a change here. */
3069 mutex_lock(&btv->lock);
3070 crop->c = btv->crop[!!fh->do_crop].rect;
3071 mutex_unlock(&btv->lock);
3076 static int bttv_s_crop(struct file *file, void *f, struct v4l2_crop *crop)
3078 struct bttv_fh *fh = f;
3079 struct bttv *btv = fh->btv;
3080 const struct v4l2_rect *b;
3088 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3089 crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3092 /* Make sure tvnorm, vbi_end and the current cropping
3093 parameters remain consistent until we're done. Note
3094 read() may change vbi_end in check_alloc_btres_lock(). */
3095 mutex_lock(&btv->lock);
3096 retval = v4l2_prio_check(&btv->prio, fh->prio);
3098 mutex_unlock(&btv->lock);
3104 if (locked_btres(fh->btv, VIDEO_RESOURCES)) {
3105 mutex_unlock(&btv->lock);
3109 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
3112 b_right = b_left + b->width;
3113 b_bottom = b->top + b->height;
3115 b_top = max(b->top, btv->vbi_end);
3116 if (b_top + 32 >= b_bottom) {
3117 mutex_unlock(&btv->lock);
3121 /* Min. scaled size 48 x 32. */
3122 c.rect.left = clamp(crop->c.left, b_left, b_right - 48);
3123 c.rect.left = min(c.rect.left, (__s32) MAX_HDELAY);
3125 c.rect.width = clamp(crop->c.width,
3126 48, b_right - c.rect.left);
3128 c.rect.top = clamp(crop->c.top, b_top, b_bottom - 32);
3129 /* Top and height must be a multiple of two. */
3130 c.rect.top = (c.rect.top + 1) & ~1;
3132 c.rect.height = clamp(crop->c.height,
3133 32, b_bottom - c.rect.top);
3134 c.rect.height = (c.rect.height + 1) & ~1;
3136 bttv_crop_calc_limits(&c);
3140 mutex_unlock(&btv->lock);
3144 mutex_lock(&fh->cap.vb_lock);
3146 if (fh->width < c.min_scaled_width) {
3147 fh->width = c.min_scaled_width;
3148 btv->init.width = c.min_scaled_width;
3149 } else if (fh->width > c.max_scaled_width) {
3150 fh->width = c.max_scaled_width;
3151 btv->init.width = c.max_scaled_width;
3154 if (fh->height < c.min_scaled_height) {
3155 fh->height = c.min_scaled_height;
3156 btv->init.height = c.min_scaled_height;
3157 } else if (fh->height > c.max_scaled_height) {
3158 fh->height = c.max_scaled_height;
3159 btv->init.height = c.max_scaled_height;
3162 mutex_unlock(&fh->cap.vb_lock);
3167 static int bttv_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
3169 if (unlikely(a->index))
3172 strcpy(a->name, "audio");
3176 static int bttv_s_audio(struct file *file, void *priv, struct v4l2_audio *a)
3178 if (unlikely(a->index))
3184 static ssize_t bttv_read(struct file *file, char __user *data,
3185 size_t count, loff_t *ppos)
3187 struct bttv_fh *fh = file->private_data;
3190 if (fh->btv->errors)
3191 bttv_reinit_bt848(fh->btv);
3192 dprintk("bttv%d: read count=%d type=%s\n",
3193 fh->btv->c.nr,(int)count,v4l2_type_names[fh->type]);
3196 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
3197 if (!check_alloc_btres_lock(fh->btv, fh, RESOURCE_VIDEO_READ)) {
3198 /* VIDEO_READ in use by another fh,
3199 or VIDEO_STREAM by any fh. */
3202 retval = videobuf_read_one(&fh->cap, data, count, ppos,
3203 file->f_flags & O_NONBLOCK);
3204 free_btres_lock(fh->btv, fh, RESOURCE_VIDEO_READ);
3206 case V4L2_BUF_TYPE_VBI_CAPTURE:
3207 if (!check_alloc_btres_lock(fh->btv,fh,RESOURCE_VBI))
3209 retval = videobuf_read_stream(&fh->vbi, data, count, ppos, 1,
3210 file->f_flags & O_NONBLOCK);
3218 static unsigned int bttv_poll(struct file *file, poll_table *wait)
3220 struct bttv_fh *fh = file->private_data;
3221 struct bttv_buffer *buf;
3222 enum v4l2_field field;
3223 unsigned int rc = POLLERR;
3225 if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
3226 if (!check_alloc_btres_lock(fh->btv,fh,RESOURCE_VBI))
3228 return videobuf_poll_stream(file, &fh->vbi, wait);
3231 mutex_lock(&fh->cap.vb_lock);
3232 if (check_btres(fh,RESOURCE_VIDEO_STREAM)) {
3233 /* streaming capture */
3234 if (list_empty(&fh->cap.stream))
3236 buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
3238 /* read() capture */
3239 if (NULL == fh->cap.read_buf) {
3240 /* need to capture a new frame */
3241 if (locked_btres(fh->btv,RESOURCE_VIDEO_STREAM))
3243 fh->cap.read_buf = videobuf_sg_alloc(fh->cap.msize);
3244 if (NULL == fh->cap.read_buf)
3246 fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
3247 field = videobuf_next_field(&fh->cap);
3248 if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) {
3249 kfree (fh->cap.read_buf);
3250 fh->cap.read_buf = NULL;
3253 fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
3254 fh->cap.read_off = 0;
3256 buf = (struct bttv_buffer*)fh->cap.read_buf;
3259 poll_wait(file, &buf->vb.done, wait);
3260 if (buf->vb.state == VIDEOBUF_DONE ||
3261 buf->vb.state == VIDEOBUF_ERROR)
3262 rc = POLLIN|POLLRDNORM;
3266 mutex_unlock(&fh->cap.vb_lock);
3270 static int bttv_open(struct file *file)
3272 struct video_device *vdev = video_devdata(file);
3273 struct bttv *btv = video_drvdata(file);
3275 enum v4l2_buf_type type = 0;
3277 dprintk(KERN_DEBUG "bttv: open dev=%s\n", video_device_node_name(vdev));
3279 if (vdev->vfl_type == VFL_TYPE_GRABBER) {
3280 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
3281 } else if (vdev->vfl_type == VFL_TYPE_VBI) {
3282 type = V4L2_BUF_TYPE_VBI_CAPTURE;
3288 dprintk(KERN_DEBUG "bttv%d: open called (type=%s)\n",
3289 btv->c.nr,v4l2_type_names[type]);
3291 /* allocate per filehandle data */
3292 fh = kmalloc(sizeof(*fh), GFP_KERNEL);
3295 file->private_data = fh;
3298 * btv is protected by btv->lock mutex, while btv->init and other
3299 * streaming vars are protected by fh->cap.vb_lock. We need to take
3300 * care of both locks to avoid troubles. However, vb_lock is used also
3301 * inside videobuf, without calling buf->lock. So, it is a very bad
3302 * idea to hold both locks at the same time.
3303 * Let's first copy btv->init at fh, holding cap.vb_lock, and then work
3304 * with the rest of init, holding btv->lock.
3306 mutex_lock(&fh->cap.vb_lock);
3308 mutex_unlock(&fh->cap.vb_lock);
3311 fh->ov.setup_ok = 0;
3313 mutex_lock(&btv->lock);
3314 v4l2_prio_open(&btv->prio, &fh->prio);
3316 videobuf_queue_sg_init(&fh->cap, &bttv_video_qops,
3317 &btv->c.pci->dev, &btv->s_lock,
3318 V4L2_BUF_TYPE_VIDEO_CAPTURE,
3319 V4L2_FIELD_INTERLACED,
3320 sizeof(struct bttv_buffer),
3322 videobuf_queue_sg_init(&fh->vbi, &bttv_vbi_qops,
3323 &btv->c.pci->dev, &btv->s_lock,
3324 V4L2_BUF_TYPE_VBI_CAPTURE,
3326 sizeof(struct bttv_buffer),
3328 set_tvnorm(btv,btv->tvnorm);
3329 set_input(btv, btv->input, btv->tvnorm);
3333 /* The V4L2 spec requires one global set of cropping parameters
3334 which only change on request. These are stored in btv->crop[1].
3335 However for compatibility with V4L apps and cropping unaware
3336 V4L2 apps we now reset the cropping parameters as seen through
3337 this fh, which is to say VIDIOC_G_CROP and scaling limit checks
3338 will use btv->crop[0], the default cropping parameters for the
3339 current video standard, and VIDIOC_S_FMT will not implicitely
3340 change the cropping parameters until VIDIOC_S_CROP has been
3342 fh->do_crop = !reset_crop; /* module parameter */
3344 /* Likewise there should be one global set of VBI capture
3345 parameters, but for compatibility with V4L apps and earlier
3346 driver versions each fh has its own parameters. */
3347 bttv_vbi_fmt_reset(&fh->vbi_fmt, btv->tvnorm);
3349 bttv_field_count(btv);
3350 mutex_unlock(&btv->lock);
3354 static int bttv_release(struct file *file)
3356 struct bttv_fh *fh = file->private_data;
3357 struct bttv *btv = fh->btv;
3359 mutex_lock(&btv->lock);
3360 /* turn off overlay */
3361 if (check_btres(fh, RESOURCE_OVERLAY))
3362 bttv_switch_overlay(btv,fh,NULL);
3364 /* stop video capture */
3365 if (check_btres(fh, RESOURCE_VIDEO_STREAM)) {
3366 videobuf_streamoff(&fh->cap);
3367 free_btres_lock(btv,fh,RESOURCE_VIDEO_STREAM);
3369 if (fh->cap.read_buf) {
3370 buffer_release(&fh->cap,fh->cap.read_buf);
3371 kfree(fh->cap.read_buf);
3373 if (check_btres(fh, RESOURCE_VIDEO_READ)) {
3374 free_btres_lock(btv, fh, RESOURCE_VIDEO_READ);
3377 /* stop vbi capture */
3378 if (check_btres(fh, RESOURCE_VBI)) {
3379 videobuf_stop(&fh->vbi);
3380 free_btres_lock(btv,fh,RESOURCE_VBI);
3386 * videobuf uses cap.vb_lock - we should avoid holding btv->lock,
3387 * otherwise we may have dead lock conditions
3389 mutex_unlock(&btv->lock);
3390 videobuf_mmap_free(&fh->cap);
3391 videobuf_mmap_free(&fh->vbi);
3392 mutex_lock(&btv->lock);
3393 v4l2_prio_close(&btv->prio, fh->prio);
3394 file->private_data = NULL;
3398 bttv_field_count(btv);
3402 mutex_unlock(&btv->lock);
3408 bttv_mmap(struct file *file, struct vm_area_struct *vma)
3410 struct bttv_fh *fh = file->private_data;
3412 dprintk("bttv%d: mmap type=%s 0x%lx+%ld\n",
3413 fh->btv->c.nr, v4l2_type_names[fh->type],
3414 vma->vm_start, vma->vm_end - vma->vm_start);
3415 return videobuf_mmap_mapper(bttv_queue(fh),vma);
3418 static const struct v4l2_file_operations bttv_fops =
3420 .owner = THIS_MODULE,
3422 .release = bttv_release,
3423 .unlocked_ioctl = video_ioctl2,
3429 static const struct v4l2_ioctl_ops bttv_ioctl_ops = {
3430 .vidioc_querycap = bttv_querycap,
3431 .vidioc_enum_fmt_vid_cap = bttv_enum_fmt_vid_cap,
3432 .vidioc_g_fmt_vid_cap = bttv_g_fmt_vid_cap,
3433 .vidioc_try_fmt_vid_cap = bttv_try_fmt_vid_cap,
3434 .vidioc_s_fmt_vid_cap = bttv_s_fmt_vid_cap,
3435 .vidioc_enum_fmt_vid_overlay = bttv_enum_fmt_vid_overlay,
3436 .vidioc_g_fmt_vid_overlay = bttv_g_fmt_vid_overlay,
3437 .vidioc_try_fmt_vid_overlay = bttv_try_fmt_vid_overlay,
3438 .vidioc_s_fmt_vid_overlay = bttv_s_fmt_vid_overlay,
3439 .vidioc_g_fmt_vbi_cap = bttv_g_fmt_vbi_cap,
3440 .vidioc_try_fmt_vbi_cap = bttv_try_fmt_vbi_cap,
3441 .vidioc_s_fmt_vbi_cap = bttv_s_fmt_vbi_cap,
3442 .vidioc_g_audio = bttv_g_audio,
3443 .vidioc_s_audio = bttv_s_audio,
3444 .vidioc_cropcap = bttv_cropcap,
3445 .vidioc_reqbufs = bttv_reqbufs,
3446 .vidioc_querybuf = bttv_querybuf,
3447 .vidioc_qbuf = bttv_qbuf,
3448 .vidioc_dqbuf = bttv_dqbuf,
3449 .vidioc_s_std = bttv_s_std,
3450 .vidioc_enum_input = bttv_enum_input,
3451 .vidioc_g_input = bttv_g_input,
3452 .vidioc_s_input = bttv_s_input,
3453 .vidioc_queryctrl = bttv_queryctrl,
3454 .vidioc_g_ctrl = bttv_g_ctrl,
3455 .vidioc_s_ctrl = bttv_s_ctrl,
3456 .vidioc_streamon = bttv_streamon,
3457 .vidioc_streamoff = bttv_streamoff,
3458 .vidioc_g_tuner = bttv_g_tuner,
3459 .vidioc_s_tuner = bttv_s_tuner,
3460 #ifdef CONFIG_VIDEO_V4L1_COMPAT
3461 .vidiocgmbuf = vidiocgmbuf,
3463 .vidioc_g_crop = bttv_g_crop,
3464 .vidioc_s_crop = bttv_s_crop,
3465 .vidioc_g_fbuf = bttv_g_fbuf,
3466 .vidioc_s_fbuf = bttv_s_fbuf,
3467 .vidioc_overlay = bttv_overlay,
3468 .vidioc_g_priority = bttv_g_priority,
3469 .vidioc_s_priority = bttv_s_priority,
3470 .vidioc_g_parm = bttv_g_parm,
3471 .vidioc_g_frequency = bttv_g_frequency,
3472 .vidioc_s_frequency = bttv_s_frequency,
3473 .vidioc_log_status = bttv_log_status,
3474 .vidioc_querystd = bttv_querystd,
3475 #ifdef CONFIG_VIDEO_ADV_DEBUG
3476 .vidioc_g_register = bttv_g_register,
3477 .vidioc_s_register = bttv_s_register,
3481 static struct video_device bttv_video_template = {
3483 .ioctl_ops = &bttv_ioctl_ops,
3484 .tvnorms = BTTV_NORMS,
3485 .current_norm = V4L2_STD_PAL,
3488 /* ----------------------------------------------------------------------- */
3489 /* radio interface */
3491 static int radio_open(struct file *file)
3493 struct video_device *vdev = video_devdata(file);
3494 struct bttv *btv = video_drvdata(file);
3497 dprintk("bttv: open dev=%s\n", video_device_node_name(vdev));
3499 dprintk("bttv%d: open called (radio)\n",btv->c.nr);
3501 /* allocate per filehandle data */
3502 fh = kmalloc(sizeof(*fh), GFP_KERNEL);
3505 file->private_data = fh;
3506 mutex_lock(&fh->cap.vb_lock);
3508 mutex_unlock(&fh->cap.vb_lock);
3510 mutex_lock(&btv->lock);
3511 v4l2_prio_open(&btv->prio, &fh->prio);
3515 bttv_call_all(btv, tuner, s_radio);
3516 audio_input(btv,TVAUDIO_INPUT_RADIO);
3518 mutex_unlock(&btv->lock);
3522 static int radio_release(struct file *file)
3524 struct bttv_fh *fh = file->private_data;
3525 struct bttv *btv = fh->btv;
3526 struct rds_command cmd;
3528 mutex_lock(&btv->lock);
3529 v4l2_prio_close(&btv->prio, fh->prio);
3530 file->private_data = NULL;
3535 bttv_call_all(btv, core, ioctl, RDS_CMD_CLOSE, &cmd);
3536 mutex_unlock(&btv->lock);
3541 static int radio_querycap(struct file *file, void *priv,
3542 struct v4l2_capability *cap)
3544 struct bttv_fh *fh = priv;
3545 struct bttv *btv = fh->btv;
3547 strcpy(cap->driver, "bttv");
3548 strlcpy(cap->card, btv->radio_dev->name, sizeof(cap->card));
3549 sprintf(cap->bus_info, "PCI:%s", pci_name(btv->c.pci));
3550 cap->version = BTTV_VERSION_CODE;
3551 cap->capabilities = V4L2_CAP_TUNER;
3556 static int radio_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
3558 struct bttv_fh *fh = priv;
3559 struct bttv *btv = fh->btv;
3561 if (btv->tuner_type == TUNER_ABSENT)
3565 mutex_lock(&btv->lock);
3566 strcpy(t->name, "Radio");
3567 t->type = V4L2_TUNER_RADIO;
3569 bttv_call_all(btv, tuner, g_tuner, t);
3571 if (btv->audio_mode_gpio)
3572 btv->audio_mode_gpio(btv, t, 0);
3574 mutex_unlock(&btv->lock);
3579 static int radio_enum_input(struct file *file, void *priv,
3580 struct v4l2_input *i)
3585 strcpy(i->name, "Radio");
3586 i->type = V4L2_INPUT_TYPE_TUNER;
3591 static int radio_g_audio(struct file *file, void *priv,
3592 struct v4l2_audio *a)
3594 if (unlikely(a->index))
3597 strcpy(a->name, "Radio");
3602 static int radio_s_tuner(struct file *file, void *priv,
3603 struct v4l2_tuner *t)
3605 struct bttv_fh *fh = priv;
3606 struct bttv *btv = fh->btv;
3611 bttv_call_all(btv, tuner, g_tuner, t);
3615 static int radio_s_audio(struct file *file, void *priv,
3616 struct v4l2_audio *a)
3618 if (unlikely(a->index))
3624 static int radio_s_input(struct file *filp, void *priv, unsigned int i)
3632 static int radio_s_std(struct file *file, void *fh, v4l2_std_id *norm)
3637 static int radio_queryctrl(struct file *file, void *priv,
3638 struct v4l2_queryctrl *c)
3640 const struct v4l2_queryctrl *ctrl;
3642 if (c->id < V4L2_CID_BASE ||
3643 c->id >= V4L2_CID_LASTP1)
3646 if (c->id == V4L2_CID_AUDIO_MUTE) {
3647 ctrl = ctrl_by_id(c->id);
3655 static int radio_g_input(struct file *filp, void *priv, unsigned int *i)
3661 static ssize_t radio_read(struct file *file, char __user *data,
3662 size_t count, loff_t *ppos)
3664 struct bttv_fh *fh = file->private_data;
3665 struct bttv *btv = fh->btv;
3666 struct rds_command cmd;
3667 cmd.block_count = count/3;
3669 cmd.instance = file;
3670 cmd.result = -ENODEV;
3672 bttv_call_all(btv, core, ioctl, RDS_CMD_READ, &cmd);
3677 static unsigned int radio_poll(struct file *file, poll_table *wait)
3679 struct bttv_fh *fh = file->private_data;
3680 struct bttv *btv = fh->btv;
3681 struct rds_command cmd;
3682 cmd.instance = file;
3683 cmd.event_list = wait;
3684 cmd.result = -ENODEV;
3685 bttv_call_all(btv, core, ioctl, RDS_CMD_POLL, &cmd);
3690 static const struct v4l2_file_operations radio_fops =
3692 .owner = THIS_MODULE,
3695 .release = radio_release,
3696 .ioctl = video_ioctl2,
3700 static const struct v4l2_ioctl_ops radio_ioctl_ops = {
3701 .vidioc_querycap = radio_querycap,
3702 .vidioc_g_tuner = radio_g_tuner,
3703 .vidioc_enum_input = radio_enum_input,
3704 .vidioc_g_audio = radio_g_audio,
3705 .vidioc_s_tuner = radio_s_tuner,
3706 .vidioc_s_audio = radio_s_audio,
3707 .vidioc_s_input = radio_s_input,
3708 .vidioc_s_std = radio_s_std,
3709 .vidioc_queryctrl = radio_queryctrl,
3710 .vidioc_g_input = radio_g_input,
3711 .vidioc_g_ctrl = bttv_g_ctrl,
3712 .vidioc_s_ctrl = bttv_s_ctrl,
3713 .vidioc_g_frequency = bttv_g_frequency,
3714 .vidioc_s_frequency = bttv_s_frequency,
3717 static struct video_device radio_template = {
3718 .fops = &radio_fops,
3719 .ioctl_ops = &radio_ioctl_ops,
3722 /* ----------------------------------------------------------------------- */
3723 /* some debug code */
3725 static int bttv_risc_decode(u32 risc)
3727 static char *instr[16] = {
3728 [ BT848_RISC_WRITE >> 28 ] = "write",
3729 [ BT848_RISC_SKIP >> 28 ] = "skip",
3730 [ BT848_RISC_WRITEC >> 28 ] = "writec",
3731 [ BT848_RISC_JUMP >> 28 ] = "jump",
3732 [ BT848_RISC_SYNC >> 28 ] = "sync",
3733 [ BT848_RISC_WRITE123 >> 28 ] = "write123",
3734 [ BT848_RISC_SKIP123 >> 28 ] = "skip123",
3735 [ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
3737 static int incr[16] = {
3738 [ BT848_RISC_WRITE >> 28 ] = 2,
3739 [ BT848_RISC_JUMP >> 28 ] = 2,
3740 [ BT848_RISC_SYNC >> 28 ] = 2,
3741 [ BT848_RISC_WRITE123 >> 28 ] = 5,
3742 [ BT848_RISC_SKIP123 >> 28 ] = 2,
3743 [ BT848_RISC_WRITE1S23 >> 28 ] = 3,
3745 static char *bits[] = {
3746 "be0", "be1", "be2", "be3/resync",
3747 "set0", "set1", "set2", "set3",
3748 "clr0", "clr1", "clr2", "clr3",
3749 "irq", "res", "eol", "sol",
3753 printk("0x%08x [ %s", risc,
3754 instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
3755 for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
3756 if (risc & (1 << (i + 12)))
3757 printk(" %s",bits[i]);
3758 printk(" count=%d ]\n", risc & 0xfff);
3759 return incr[risc >> 28] ? incr[risc >> 28] : 1;
3762 static void bttv_risc_disasm(struct bttv *btv,
3763 struct btcx_riscmem *risc)
3767 printk("%s: risc disasm: %p [dma=0x%08lx]\n",
3768 btv->c.v4l2_dev.name, risc->cpu, (unsigned long)risc->dma);
3769 for (i = 0; i < (risc->size >> 2); i += n) {
3770 printk("%s: 0x%lx: ", btv->c.v4l2_dev.name,
3771 (unsigned long)(risc->dma + (i<<2)));
3772 n = bttv_risc_decode(le32_to_cpu(risc->cpu[i]));
3773 for (j = 1; j < n; j++)
3774 printk("%s: 0x%lx: 0x%08x [ arg #%d ]\n",
3775 btv->c.v4l2_dev.name, (unsigned long)(risc->dma + ((i+j)<<2)),
3777 if (0 == risc->cpu[i])
3782 static void bttv_print_riscaddr(struct bttv *btv)
3784 printk(" main: %08Lx\n",
3785 (unsigned long long)btv->main.dma);
3786 printk(" vbi : o=%08Lx e=%08Lx\n",
3787 btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
3788 btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
3789 printk(" cap : o=%08Lx e=%08Lx\n",
3790 btv->curr.top ? (unsigned long long)btv->curr.top->top.dma : 0,
3791 btv->curr.bottom ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
3792 printk(" scr : o=%08Lx e=%08Lx\n",
3793 btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
3794 btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
3795 bttv_risc_disasm(btv, &btv->main);
3798 /* ----------------------------------------------------------------------- */
3801 static char *irq_name[] = {
3802 "FMTCHG", // format change detected (525 vs. 625)
3803 "VSYNC", // vertical sync (new field)
3804 "HSYNC", // horizontal sync
3805 "OFLOW", // chroma/luma AGC overflow
3806 "HLOCK", // horizontal lock changed
3807 "VPRES", // video presence changed
3809 "I2CDONE", // hw irc operation finished
3810 "GPINT", // gpio port triggered irq
3812 "RISCI", // risc instruction triggered irq
3813 "FBUS", // pixel data fifo dropped data (high pci bus latencies)
3814 "FTRGT", // pixel data fifo overrun
3815 "FDSR", // fifo data stream resyncronisation
3816 "PPERR", // parity error (data transfer)
3817 "RIPERR", // parity error (read risc instructions)
3818 "PABORT", // pci abort
3819 "OCERR", // risc instruction error
3820 "SCERR", // syncronisation error
3823 static void bttv_print_irqbits(u32 print, u32 mark)
3828 for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
3829 if (print & (1 << i))
3830 printk(" %s",irq_name[i]);
3831 if (mark & (1 << i))
3836 static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
3838 printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
3840 (unsigned long)btv->main.dma,
3841 (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_VBI+1]),
3842 (unsigned long)le32_to_cpu(btv->main.cpu[RISC_SLOT_O_FIELD+1]),
3845 if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) {
3846 printk("bttv%d: Oh, there (temporarely?) is no input signal. "
3847 "Ok, then this is harmless, don't worry ;)\n",
3851 printk("bttv%d: Uhm. Looks like we have unusual high IRQ latencies.\n",
3853 printk("bttv%d: Lets try to catch the culpit red-handed ...\n",
3859 bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set)
3861 struct bttv_buffer *item;
3863 memset(set,0,sizeof(*set));
3865 /* capture request ? */
3866 if (!list_empty(&btv->capture)) {
3868 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3869 if (V4L2_FIELD_HAS_TOP(item->vb.field))
3871 if (V4L2_FIELD_HAS_BOTTOM(item->vb.field))
3874 /* capture request for other field ? */
3875 if (!V4L2_FIELD_HAS_BOTH(item->vb.field) &&
3876 (item->vb.queue.next != &btv->capture)) {
3877 item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue);
3878 /* Mike Isely <isely@pobox.com> - Only check
3879 * and set up the bottom field in the logic
3880 * below. Don't ever do the top field. This
3881 * of course means that if we set up the
3882 * bottom field in the above code that we'll
3883 * actually skip a field. But that's OK.
3884 * Having processed only a single buffer this
3885 * time, then the next time around the first
3886 * available buffer should be for a top field.
3887 * That will then cause us here to set up a
3888 * top then a bottom field in the normal way.
3889 * The alternative to this understanding is
3890 * that we set up the second available buffer
3891 * as a top field, but that's out of order
3892 * since this driver always processes the top
3893 * field first - the effect will be the two
3894 * buffers being returned in the wrong order,
3895 * with the second buffer also being delayed
3896 * by one field time (owing to the fifo nature
3897 * of videobuf). Worse still, we'll be stuck
3898 * doing fields out of order now every time
3899 * until something else causes a field to be
3900 * dropped. By effectively forcing a field to
3901 * drop this way then we always get back into
3902 * sync within a single frame time. (Out of
3903 * order fields can screw up deinterlacing
3905 if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) {
3906 if (NULL == set->bottom &&
3907 V4L2_FIELD_BOTTOM == item->vb.field) {
3910 if (NULL != set->top && NULL != set->bottom)
3916 /* screen overlay ? */
3917 if (NULL != btv->screen) {
3918 if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) {
3919 if (NULL == set->top && NULL == set->bottom) {
3920 set->top = btv->screen;
3921 set->bottom = btv->screen;
3924 if (V4L2_FIELD_TOP == btv->screen->vb.field &&
3926 set->top = btv->screen;
3928 if (V4L2_FIELD_BOTTOM == btv->screen->vb.field &&
3929 NULL == set->bottom) {
3930 set->bottom = btv->screen;
3935 dprintk("bttv%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
3936 btv->c.nr,set->top, set->bottom,
3937 btv->screen,set->frame_irq,set->top_irq);
3942 bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
3943 struct bttv_buffer_set *curr, unsigned int state)
3947 do_gettimeofday(&ts);
3949 if (wakeup->top == wakeup->bottom) {
3950 if (NULL != wakeup->top && curr->top != wakeup->top) {
3952 printk("bttv%d: wakeup: both=%p\n",btv->c.nr,wakeup->top);
3953 wakeup->top->vb.ts = ts;
3954 wakeup->top->vb.field_count = btv->field_count;
3955 wakeup->top->vb.state = state;
3956 wake_up(&wakeup->top->vb.done);
3959 if (NULL != wakeup->top && curr->top != wakeup->top) {
3961 printk("bttv%d: wakeup: top=%p\n",btv->c.nr,wakeup->top);
3962 wakeup->top->vb.ts = ts;
3963 wakeup->top->vb.field_count = btv->field_count;
3964 wakeup->top->vb.state = state;
3965 wake_up(&wakeup->top->vb.done);
3967 if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
3969 printk("bttv%d: wakeup: bottom=%p\n",btv->c.nr,wakeup->bottom);
3970 wakeup->bottom->vb.ts = ts;
3971 wakeup->bottom->vb.field_count = btv->field_count;
3972 wakeup->bottom->vb.state = state;
3973 wake_up(&wakeup->bottom->vb.done);
3979 bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
3987 do_gettimeofday(&ts);
3989 wakeup->vb.field_count = btv->field_count;
3990 wakeup->vb.state = state;
3991 wake_up(&wakeup->vb.done);
3994 static void bttv_irq_timeout(unsigned long data)
3996 struct bttv *btv = (struct bttv *)data;
3997 struct bttv_buffer_set old,new;
3998 struct bttv_buffer *ovbi;
3999 struct bttv_buffer *item;
4000 unsigned long flags;
4003 printk(KERN_INFO "bttv%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
4004 btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
4005 btread(BT848_RISC_COUNT));
4006 bttv_print_irqbits(btread(BT848_INT_STAT),0);
4010 spin_lock_irqsave(&btv->s_lock,flags);
4012 /* deactivate stuff */
4013 memset(&new,0,sizeof(new));
4019 bttv_buffer_activate_video(btv, &new);
4020 bttv_buffer_activate_vbi(btv, NULL);
4021 bttv_set_dma(btv, 0);
4024 bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_ERROR);
4025 bttv_irq_wakeup_vbi(btv, ovbi, VIDEOBUF_ERROR);
4027 /* cancel all outstanding capture / vbi requests */
4028 while (!list_empty(&btv->capture)) {
4029 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
4030 list_del(&item->vb.queue);
4031 item->vb.state = VIDEOBUF_ERROR;
4032 wake_up(&item->vb.done);
4034 while (!list_empty(&btv->vcapture)) {
4035 item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
4036 list_del(&item->vb.queue);
4037 item->vb.state = VIDEOBUF_ERROR;
4038 wake_up(&item->vb.done);
4042 spin_unlock_irqrestore(&btv->s_lock,flags);
4046 bttv_irq_wakeup_top(struct bttv *btv)
4048 struct bttv_buffer *wakeup = btv->curr.top;
4053 spin_lock(&btv->s_lock);
4054 btv->curr.top_irq = 0;
4055 btv->curr.top = NULL;
4056 bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
4058 do_gettimeofday(&wakeup->vb.ts);
4059 wakeup->vb.field_count = btv->field_count;
4060 wakeup->vb.state = VIDEOBUF_DONE;
4061 wake_up(&wakeup->vb.done);
4062 spin_unlock(&btv->s_lock);
4065 static inline int is_active(struct btcx_riscmem *risc, u32 rc)
4069 if (rc > risc->dma + risc->size)
4075 bttv_irq_switch_video(struct bttv *btv)
4077 struct bttv_buffer_set new;
4078 struct bttv_buffer_set old;
4081 spin_lock(&btv->s_lock);
4083 /* new buffer set */
4084 bttv_irq_next_video(btv, &new);
4085 rc = btread(BT848_RISC_COUNT);
4086 if ((btv->curr.top && is_active(&btv->curr.top->top, rc)) ||
4087 (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) {
4090 bttv_irq_debug_low_latency(btv, rc);
4091 spin_unlock(&btv->s_lock);
4098 btv->loop_irq &= ~1;
4099 bttv_buffer_activate_video(btv, &new);
4100 bttv_set_dma(btv, 0);
4103 if (UNSET != btv->new_input) {
4104 video_mux(btv,btv->new_input);
4105 btv->new_input = UNSET;
4108 /* wake up finished buffers */
4109 bttv_irq_wakeup_video(btv, &old, &new, VIDEOBUF_DONE);
4110 spin_unlock(&btv->s_lock);
4114 bttv_irq_switch_vbi(struct bttv *btv)
4116 struct bttv_buffer *new = NULL;
4117 struct bttv_buffer *old;
4120 spin_lock(&btv->s_lock);
4122 if (!list_empty(&btv->vcapture))
4123 new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
4126 rc = btread(BT848_RISC_COUNT);
4127 if (NULL != old && (is_active(&old->top, rc) ||
4128 is_active(&old->bottom, rc))) {
4131 bttv_irq_debug_low_latency(btv, rc);
4132 spin_unlock(&btv->s_lock);
4138 btv->loop_irq &= ~4;
4139 bttv_buffer_activate_vbi(btv, new);
4140 bttv_set_dma(btv, 0);
4142 bttv_irq_wakeup_vbi(btv, old, VIDEOBUF_DONE);
4143 spin_unlock(&btv->s_lock);
4146 static irqreturn_t bttv_irq(int irq, void *dev_id)
4154 btv=(struct bttv *)dev_id;
4156 if (btv->custom_irq)
4157 handled = btv->custom_irq(btv);
4161 /* get/clear interrupt status bits */
4162 stat=btread(BT848_INT_STAT);
4163 astat=stat&btread(BT848_INT_MASK);
4167 btwrite(stat,BT848_INT_STAT);
4169 /* get device status bits */
4170 dstat=btread(BT848_DSTATUS);
4173 printk(KERN_DEBUG "bttv%d: irq loop=%d fc=%d "
4174 "riscs=%x, riscc=%08x, ",
4175 btv->c.nr, count, btv->field_count,
4176 stat>>28, btread(BT848_RISC_COUNT));
4177 bttv_print_irqbits(stat,astat);
4178 if (stat & BT848_INT_HLOCK)
4179 printk(" HLOC => %s", (dstat & BT848_DSTATUS_HLOC)
4181 if (stat & BT848_INT_VPRES)
4182 printk(" PRES => %s", (dstat & BT848_DSTATUS_PRES)
4184 if (stat & BT848_INT_FMTCHG)
4185 printk(" NUML => %s", (dstat & BT848_DSTATUS_NUML)
4190 if (astat&BT848_INT_VSYNC)
4193 if ((astat & BT848_INT_GPINT) && btv->remote) {
4194 wake_up(&btv->gpioq);
4195 bttv_input_irq(btv);
4198 if (astat & BT848_INT_I2CDONE) {
4199 btv->i2c_done = stat;
4200 wake_up(&btv->i2c_queue);
4203 if ((astat & BT848_INT_RISCI) && (stat & (4<<28)))
4204 bttv_irq_switch_vbi(btv);
4206 if ((astat & BT848_INT_RISCI) && (stat & (2<<28)))
4207 bttv_irq_wakeup_top(btv);
4209 if ((astat & BT848_INT_RISCI) && (stat & (1<<28)))
4210 bttv_irq_switch_video(btv);
4212 if ((astat & BT848_INT_HLOCK) && btv->opt_automute)
4213 audio_mute(btv, btv->mute); /* trigger automute */
4215 if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
4216 printk(KERN_INFO "bttv%d: %s%s @ %08x,",btv->c.nr,
4217 (astat & BT848_INT_SCERR) ? "SCERR" : "",
4218 (astat & BT848_INT_OCERR) ? "OCERR" : "",
4219 btread(BT848_RISC_COUNT));
4220 bttv_print_irqbits(stat,astat);
4223 bttv_print_riscaddr(btv);
4225 if (fdsr && astat & BT848_INT_FDSR) {
4226 printk(KERN_INFO "bttv%d: FDSR @ %08x\n",
4227 btv->c.nr,btread(BT848_RISC_COUNT));
4229 bttv_print_riscaddr(btv);
4235 if (count > 8 || !(astat & BT848_INT_GPINT)) {
4236 btwrite(0, BT848_INT_MASK);
4239 "bttv%d: IRQ lockup, cleared int mask [", btv->c.nr);
4242 "bttv%d: IRQ lockup, clearing GPINT from int mask [", btv->c.nr);
4244 btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT),
4248 bttv_print_irqbits(stat,astat);
4256 return IRQ_RETVAL(handled);
4260 /* ----------------------------------------------------------------------- */
4261 /* initialitation */
4263 static struct video_device *vdev_init(struct bttv *btv,
4264 const struct video_device *template,
4265 const char *type_name)
4267 struct video_device *vfd;
4269 vfd = video_device_alloc();
4273 vfd->v4l2_dev = &btv->c.v4l2_dev;
4274 vfd->release = video_device_release;
4275 vfd->debug = bttv_debug;
4276 video_set_drvdata(vfd, btv);
4277 snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
4278 btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
4279 type_name, bttv_tvcards[btv->c.type].name);
4283 static void bttv_unregister_video(struct bttv *btv)
4285 if (btv->video_dev) {
4286 if (video_is_registered(btv->video_dev))
4287 video_unregister_device(btv->video_dev);
4289 video_device_release(btv->video_dev);
4290 btv->video_dev = NULL;
4293 if (video_is_registered(btv->vbi_dev))
4294 video_unregister_device(btv->vbi_dev);
4296 video_device_release(btv->vbi_dev);
4297 btv->vbi_dev = NULL;
4299 if (btv->radio_dev) {
4300 if (video_is_registered(btv->radio_dev))
4301 video_unregister_device(btv->radio_dev);
4303 video_device_release(btv->radio_dev);
4304 btv->radio_dev = NULL;
4308 /* register video4linux devices */
4309 static int __devinit bttv_register_video(struct bttv *btv)
4312 printk("bttv: Overlay support disabled.\n");
4315 btv->video_dev = vdev_init(btv, &bttv_video_template, "video");
4317 if (NULL == btv->video_dev)
4319 if (video_register_device(btv->video_dev, VFL_TYPE_GRABBER,
4320 video_nr[btv->c.nr]) < 0)
4322 printk(KERN_INFO "bttv%d: registered device %s\n",
4323 btv->c.nr, video_device_node_name(btv->video_dev));
4324 if (device_create_file(&btv->video_dev->dev,
4325 &dev_attr_card)<0) {
4326 printk(KERN_ERR "bttv%d: device_create_file 'card' "
4327 "failed\n", btv->c.nr);
4332 btv->vbi_dev = vdev_init(btv, &bttv_video_template, "vbi");
4334 if (NULL == btv->vbi_dev)
4336 if (video_register_device(btv->vbi_dev, VFL_TYPE_VBI,
4337 vbi_nr[btv->c.nr]) < 0)
4339 printk(KERN_INFO "bttv%d: registered device %s\n",
4340 btv->c.nr, video_device_node_name(btv->vbi_dev));
4342 if (!btv->has_radio)
4345 btv->radio_dev = vdev_init(btv, &radio_template, "radio");
4346 if (NULL == btv->radio_dev)
4348 if (video_register_device(btv->radio_dev, VFL_TYPE_RADIO,
4349 radio_nr[btv->c.nr]) < 0)
4351 printk(KERN_INFO "bttv%d: registered device %s\n",
4352 btv->c.nr, video_device_node_name(btv->radio_dev));
4358 bttv_unregister_video(btv);
4363 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
4364 /* response on cards with no firmware is not enabled by OF */
4365 static void pci_set_command(struct pci_dev *dev)
4367 #if defined(__powerpc__)
4370 pci_read_config_dword(dev, PCI_COMMAND, &cmd);
4371 cmd = (cmd | PCI_COMMAND_MEMORY );
4372 pci_write_config_dword(dev, PCI_COMMAND, cmd);
4376 static int __devinit bttv_probe(struct pci_dev *dev,
4377 const struct pci_device_id *pci_id)
4383 if (bttv_num == BTTV_MAX)
4385 printk(KERN_INFO "bttv: Bt8xx card found (%d).\n", bttv_num);
4386 bttvs[bttv_num] = btv = kzalloc(sizeof(*btv), GFP_KERNEL);
4388 printk(KERN_ERR "bttv: out of memory.\n");
4391 btv->c.nr = bttv_num;
4392 snprintf(btv->c.v4l2_dev.name, sizeof(btv->c.v4l2_dev.name),
4393 "bttv%d", btv->c.nr);
4395 /* initialize structs / fill in defaults */
4396 mutex_init(&btv->lock);
4397 spin_lock_init(&btv->s_lock);
4398 spin_lock_init(&btv->gpio_lock);
4399 init_waitqueue_head(&btv->gpioq);
4400 init_waitqueue_head(&btv->i2c_queue);
4401 INIT_LIST_HEAD(&btv->c.subs);
4402 INIT_LIST_HEAD(&btv->capture);
4403 INIT_LIST_HEAD(&btv->vcapture);
4404 v4l2_prio_init(&btv->prio);
4406 init_timer(&btv->timeout);
4407 btv->timeout.function = bttv_irq_timeout;
4408 btv->timeout.data = (unsigned long)btv;
4411 btv->tuner_type = UNSET;
4412 btv->new_input = UNSET;
4413 btv->has_radio=radio[btv->c.nr];
4415 /* pci stuff (init, get irq/mmio, ... */
4417 btv->id = dev->device;
4418 if (pci_enable_device(dev)) {
4419 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4423 if (pci_set_dma_mask(dev, DMA_BIT_MASK(32))) {
4424 printk(KERN_WARNING "bttv%d: No suitable DMA available.\n",
4428 if (!request_mem_region(pci_resource_start(dev,0),
4429 pci_resource_len(dev,0),
4430 btv->c.v4l2_dev.name)) {
4431 printk(KERN_WARNING "bttv%d: can't request iomem (0x%llx).\n",
4433 (unsigned long long)pci_resource_start(dev,0));
4436 pci_set_master(dev);
4437 pci_set_command(dev);
4439 result = v4l2_device_register(&dev->dev, &btv->c.v4l2_dev);
4441 printk(KERN_WARNING "bttv%d: v4l2_device_register() failed\n", btv->c.nr);
4445 pci_read_config_byte(dev, PCI_CLASS_REVISION, &btv->revision);
4446 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
4447 printk(KERN_INFO "bttv%d: Bt%d (rev %d) at %s, ",
4448 bttv_num,btv->id, btv->revision, pci_name(dev));
4449 printk("irq: %d, latency: %d, mmio: 0x%llx\n",
4450 btv->c.pci->irq, lat,
4451 (unsigned long long)pci_resource_start(dev,0));
4454 btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), 0x1000);
4455 if (NULL == btv->bt848_mmio) {
4456 printk("bttv%d: ioremap() failed\n", btv->c.nr);
4464 /* disable irqs, register irq handler */
4465 btwrite(0, BT848_INT_MASK);
4466 result = request_irq(btv->c.pci->irq, bttv_irq,
4467 IRQF_SHARED | IRQF_DISABLED, btv->c.v4l2_dev.name, (void *)btv);
4469 printk(KERN_ERR "bttv%d: can't get IRQ %d\n",
4470 bttv_num,btv->c.pci->irq);
4474 if (0 != bttv_handle_chipset(btv)) {
4479 /* init options from insmod args */
4480 btv->opt_combfilter = combfilter;
4481 btv->opt_lumafilter = lumafilter;
4482 btv->opt_automute = automute;
4483 btv->opt_chroma_agc = chroma_agc;
4484 btv->opt_adc_crush = adc_crush;
4485 btv->opt_vcr_hack = vcr_hack;
4486 btv->opt_whitecrush_upper = whitecrush_upper;
4487 btv->opt_whitecrush_lower = whitecrush_lower;
4488 btv->opt_uv_ratio = uv_ratio;
4489 btv->opt_full_luma_range = full_luma_range;
4490 btv->opt_coring = coring;
4492 /* fill struct bttv with some useful defaults */
4493 btv->init.btv = btv;
4494 btv->init.ov.w.width = 320;
4495 btv->init.ov.w.height = 240;
4496 btv->init.fmt = format_by_fourcc(V4L2_PIX_FMT_BGR24);
4497 btv->init.width = 320;
4498 btv->init.height = 240;
4501 /* initialize hardware */
4503 bttv_gpio_tracking(btv,"pre-init");
4505 bttv_risc_init_main(btv);
4509 btwrite(0x00, BT848_GPIO_REG_INP);
4510 btwrite(0x00, BT848_GPIO_OUT_EN);
4512 bttv_gpio_tracking(btv,"init");
4514 /* needs to be done before i2c is registered */
4515 bttv_init_card1(btv);
4517 /* register i2c + gpio */
4520 /* some card-specific stuff (needs working i2c) */
4521 bttv_init_card2(btv);
4522 bttv_init_tuner(btv);
4525 /* register video4linux + input */
4526 if (!bttv_tvcards[btv->c.type].no_video) {
4527 bttv_register_video(btv);
4528 bt848_bright(btv,32768);
4529 bt848_contrast(btv,32768);
4530 bt848_hue(btv,32768);
4531 bt848_sat(btv,32768);
4533 set_input(btv, 0, btv->tvnorm);
4534 bttv_crop_reset(&btv->crop[0], btv->tvnorm);
4535 btv->crop[1] = btv->crop[0]; /* current = default */
4536 disclaim_vbi_lines(btv);
4537 disclaim_video_lines(btv);
4540 /* add subdevices and autoload dvb-bt8xx if needed */
4541 if (bttv_tvcards[btv->c.type].has_dvb) {
4542 bttv_sub_add_device(&btv->c, "dvb");
4543 request_modules(btv);
4547 init_bttv_i2c_ir(btv);
4548 bttv_input_init(btv);
4551 /* everything is fine */
4556 free_irq(btv->c.pci->irq,btv);
4559 v4l2_device_unregister(&btv->c.v4l2_dev);
4562 if (btv->bt848_mmio)
4563 iounmap(btv->bt848_mmio);
4564 release_mem_region(pci_resource_start(btv->c.pci,0),
4565 pci_resource_len(btv->c.pci,0));
4569 static void __devexit bttv_remove(struct pci_dev *pci_dev)
4571 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4572 struct bttv *btv = to_bttv(v4l2_dev);
4575 printk("bttv%d: unloading\n",btv->c.nr);
4577 /* shutdown everything (DMA+IRQs) */
4578 btand(~15, BT848_GPIO_DMA_CTL);
4579 btwrite(0, BT848_INT_MASK);
4580 btwrite(~0x0, BT848_INT_STAT);
4581 btwrite(0x0, BT848_GPIO_OUT_EN);
4583 bttv_gpio_tracking(btv,"cleanup");
4585 /* tell gpio modules we are leaving ... */
4587 wake_up(&btv->gpioq);
4588 bttv_input_fini(btv);
4589 bttv_sub_del_devices(&btv->c);
4591 /* unregister i2c_bus + input */
4594 /* unregister video4linux */
4595 bttv_unregister_video(btv);
4597 /* free allocated memory */
4598 btcx_riscmem_free(btv->c.pci,&btv->main);
4600 /* free ressources */
4601 free_irq(btv->c.pci->irq,btv);
4602 iounmap(btv->bt848_mmio);
4603 release_mem_region(pci_resource_start(btv->c.pci,0),
4604 pci_resource_len(btv->c.pci,0));
4606 v4l2_device_unregister(&btv->c.v4l2_dev);
4607 bttvs[btv->c.nr] = NULL;
4614 static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state)
4616 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4617 struct bttv *btv = to_bttv(v4l2_dev);
4618 struct bttv_buffer_set idle;
4619 unsigned long flags;
4621 dprintk("bttv%d: suspend %d\n", btv->c.nr, state.event);
4623 /* stop dma + irqs */
4624 spin_lock_irqsave(&btv->s_lock,flags);
4625 memset(&idle, 0, sizeof(idle));
4626 btv->state.video = btv->curr;
4627 btv->state.vbi = btv->cvbi;
4628 btv->state.loop_irq = btv->loop_irq;
4631 bttv_buffer_activate_video(btv, &idle);
4632 bttv_buffer_activate_vbi(btv, NULL);
4633 bttv_set_dma(btv, 0);
4634 btwrite(0, BT848_INT_MASK);
4635 spin_unlock_irqrestore(&btv->s_lock,flags);
4637 /* save bt878 state */
4638 btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
4639 btv->state.gpio_data = gpio_read();
4641 /* save pci state */
4642 pci_save_state(pci_dev);
4643 if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
4644 pci_disable_device(pci_dev);
4645 btv->state.disabled = 1;
4650 static int bttv_resume(struct pci_dev *pci_dev)
4652 struct v4l2_device *v4l2_dev = pci_get_drvdata(pci_dev);
4653 struct bttv *btv = to_bttv(v4l2_dev);
4654 unsigned long flags;
4657 dprintk("bttv%d: resume\n", btv->c.nr);
4659 /* restore pci state */
4660 if (btv->state.disabled) {
4661 err=pci_enable_device(pci_dev);
4663 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4667 btv->state.disabled = 0;
4669 err=pci_set_power_state(pci_dev, PCI_D0);
4671 pci_disable_device(pci_dev);
4672 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4674 btv->state.disabled = 1;
4678 pci_restore_state(pci_dev);
4680 /* restore bt878 state */
4681 bttv_reinit_bt848(btv);
4682 gpio_inout(0xffffff, btv->state.gpio_enable);
4683 gpio_write(btv->state.gpio_data);
4686 spin_lock_irqsave(&btv->s_lock,flags);
4687 btv->curr = btv->state.video;
4688 btv->cvbi = btv->state.vbi;
4689 btv->loop_irq = btv->state.loop_irq;
4690 bttv_buffer_activate_video(btv, &btv->curr);
4691 bttv_buffer_activate_vbi(btv, btv->cvbi);
4692 bttv_set_dma(btv, 0);
4693 spin_unlock_irqrestore(&btv->s_lock,flags);
4698 static struct pci_device_id bttv_pci_tbl[] = {
4699 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT848), 0},
4700 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT849), 0},
4701 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT878), 0},
4702 {PCI_VDEVICE(BROOKTREE, PCI_DEVICE_ID_BT879), 0},
4706 MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
4708 static struct pci_driver bttv_pci_driver = {
4710 .id_table = bttv_pci_tbl,
4711 .probe = bttv_probe,
4712 .remove = __devexit_p(bttv_remove),
4714 .suspend = bttv_suspend,
4715 .resume = bttv_resume,
4719 static int __init bttv_init_module(void)
4725 printk(KERN_INFO "bttv: driver version %d.%d.%d loaded\n",
4726 (BTTV_VERSION_CODE >> 16) & 0xff,
4727 (BTTV_VERSION_CODE >> 8) & 0xff,
4728 BTTV_VERSION_CODE & 0xff);
4730 printk(KERN_INFO "bttv: snapshot date %04d-%02d-%02d\n",
4731 SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
4733 if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
4735 if (gbufsize > BTTV_MAX_FBUF)
4736 gbufsize = BTTV_MAX_FBUF;
4737 gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
4739 printk(KERN_INFO "bttv: using %d buffers with %dk (%d pages) each for capture\n",
4740 gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
4742 bttv_check_chipset();
4744 ret = bus_register(&bttv_sub_bus_type);
4746 printk(KERN_WARNING "bttv: bus_register error: %d\n", ret);
4749 ret = pci_register_driver(&bttv_pci_driver);
4751 bus_unregister(&bttv_sub_bus_type);
4756 static void __exit bttv_cleanup_module(void)
4758 pci_unregister_driver(&bttv_pci_driver);
4759 bus_unregister(&bttv_sub_bus_type);
4762 module_init(bttv_init_module);
4763 module_exit(bttv_cleanup_module);