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>
12 Cropping and overscan support
13 Copyright (C) 2005, 2006 Michael H. Schimek <mschimek@gmx.at>
14 Sponsored by OPQ Systems AB
16 This program is free software; you can redistribute it and/or modify
17 it under the terms of the GNU General Public License as published by
18 the Free Software Foundation; either version 2 of the License, or
19 (at your option) any later version.
21 This program is distributed in the hope that it will be useful,
22 but WITHOUT ANY WARRANTY; without even the implied warranty of
23 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 GNU General Public License for more details.
26 You should have received a copy of the GNU General Public License
27 along with this program; if not, write to the Free Software
28 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
31 #include <linux/init.h>
32 #include <linux/module.h>
33 #include <linux/moduleparam.h>
34 #include <linux/delay.h>
35 #include <linux/errno.h>
37 #include <linux/kernel.h>
38 #include <linux/sched.h>
39 #include <linux/interrupt.h>
40 #include <linux/kdev_t.h>
42 #include <media/v4l2-common.h>
43 #include <media/tvaudio.h>
44 #include <media/msp3400.h>
46 #include <linux/dma-mapping.h>
49 #include <asm/byteorder.h>
51 #include <media/rds.h>
54 unsigned int bttv_num; /* number of Bt848s in use */
55 struct bttv bttvs[BTTV_MAX];
57 unsigned int bttv_debug;
58 unsigned int bttv_verbose = 1;
59 unsigned int bttv_gpio;
61 /* config variables */
63 static unsigned int bigendian=1;
65 static unsigned int bigendian;
67 static unsigned int radio[BTTV_MAX];
68 static unsigned int irq_debug;
69 static unsigned int gbuffers = 8;
70 static unsigned int gbufsize = 0x208000;
71 static unsigned int reset_crop = 1;
73 static int video_nr = -1;
74 static int radio_nr = -1;
75 static int vbi_nr = -1;
76 static int debug_latency;
78 static unsigned int fdsr;
81 static unsigned int combfilter;
82 static unsigned int lumafilter;
83 static unsigned int automute = 1;
84 static unsigned int chroma_agc;
85 static unsigned int adc_crush = 1;
86 static unsigned int whitecrush_upper = 0xCF;
87 static unsigned int whitecrush_lower = 0x7F;
88 static unsigned int vcr_hack;
89 static unsigned int irq_iswitch;
90 static unsigned int uv_ratio = 50;
91 static unsigned int full_luma_range;
92 static unsigned int coring;
93 extern int no_overlay;
95 /* API features (turn on/off stuff for testing) */
96 static unsigned int v4l2 = 1;
99 module_param(bttv_verbose, int, 0644);
100 module_param(bttv_gpio, int, 0644);
101 module_param(bttv_debug, int, 0644);
102 module_param(irq_debug, int, 0644);
103 module_param(debug_latency, int, 0644);
105 module_param(fdsr, int, 0444);
106 module_param(video_nr, int, 0444);
107 module_param(radio_nr, int, 0444);
108 module_param(vbi_nr, int, 0444);
109 module_param(gbuffers, int, 0444);
110 module_param(gbufsize, int, 0444);
111 module_param(reset_crop, int, 0444);
113 module_param(v4l2, int, 0644);
114 module_param(bigendian, int, 0644);
115 module_param(irq_iswitch, int, 0644);
116 module_param(combfilter, int, 0444);
117 module_param(lumafilter, int, 0444);
118 module_param(automute, int, 0444);
119 module_param(chroma_agc, int, 0444);
120 module_param(adc_crush, int, 0444);
121 module_param(whitecrush_upper, int, 0444);
122 module_param(whitecrush_lower, int, 0444);
123 module_param(vcr_hack, int, 0444);
124 module_param(uv_ratio, int, 0444);
125 module_param(full_luma_range, int, 0444);
126 module_param(coring, int, 0444);
128 module_param_array(radio, int, NULL, 0444);
130 MODULE_PARM_DESC(radio,"The TV card supports radio, default is 0 (no)");
131 MODULE_PARM_DESC(bigendian,"byte order of the framebuffer, default is native endian");
132 MODULE_PARM_DESC(bttv_verbose,"verbose startup messages, default is 1 (yes)");
133 MODULE_PARM_DESC(bttv_gpio,"log gpio changes, default is 0 (no)");
134 MODULE_PARM_DESC(bttv_debug,"debug messages, default is 0 (no)");
135 MODULE_PARM_DESC(irq_debug,"irq handler debug messages, default is 0 (no)");
136 MODULE_PARM_DESC(gbuffers,"number of capture buffers. range 2-32, default 8");
137 MODULE_PARM_DESC(gbufsize,"size of the capture buffers, default is 0x208000");
138 MODULE_PARM_DESC(reset_crop,"reset cropping parameters at open(), default "
139 "is 1 (yes) for compatibility with older applications");
140 MODULE_PARM_DESC(automute,"mute audio on bad/missing video signal, default is 1 (yes)");
141 MODULE_PARM_DESC(chroma_agc,"enables the AGC of chroma signal, default is 0 (no)");
142 MODULE_PARM_DESC(adc_crush,"enables the luminance ADC crush, default is 1 (yes)");
143 MODULE_PARM_DESC(whitecrush_upper,"sets the white crush upper value, default is 207");
144 MODULE_PARM_DESC(whitecrush_lower,"sets the white crush lower value, default is 127");
145 MODULE_PARM_DESC(vcr_hack,"enables the VCR hack (improves synch on poor VCR tapes), default is 0 (no)");
146 MODULE_PARM_DESC(irq_iswitch,"switch inputs in irq handler");
147 MODULE_PARM_DESC(uv_ratio,"ratio between u and v gains, default is 50");
148 MODULE_PARM_DESC(full_luma_range,"use the full luma range, default is 0 (no)");
149 MODULE_PARM_DESC(coring,"set the luma coring level, default is 0 (no)");
151 MODULE_DESCRIPTION("bttv - v4l/v4l2 driver module for bt848/878 based cards");
152 MODULE_AUTHOR("Ralph Metzler & Marcus Metzler & Gerd Knorr");
153 MODULE_LICENSE("GPL");
155 /* ----------------------------------------------------------------------- */
158 static ssize_t show_card(struct class_device *cd, char *buf)
160 struct video_device *vfd = to_video_device(cd);
161 struct bttv *btv = dev_get_drvdata(vfd->dev);
162 return sprintf(buf, "%d\n", btv ? btv->c.type : UNSET);
164 static CLASS_DEVICE_ATTR(card, S_IRUGO, show_card, NULL);
166 /* ----------------------------------------------------------------------- */
167 /* dvb auto-load setup */
168 #if defined(CONFIG_MODULES) && defined(MODULE)
169 static void request_module_async(struct work_struct *work)
171 request_module("dvb-bt8xx");
174 static void request_modules(struct bttv *dev)
176 INIT_WORK(&dev->request_module_wk, request_module_async);
177 schedule_work(&dev->request_module_wk);
180 #define request_modules(dev)
181 #endif /* CONFIG_MODULES */
184 /* ----------------------------------------------------------------------- */
187 /* special timing tables from conexant... */
188 static u8 SRAM_Table[][60] =
190 /* PAL digital input over GPIO[7:0] */
192 45, // 45 bytes following
193 0x36,0x11,0x01,0x00,0x90,0x02,0x05,0x10,0x04,0x16,
194 0x12,0x05,0x11,0x00,0x04,0x12,0xC0,0x00,0x31,0x00,
195 0x06,0x51,0x08,0x03,0x89,0x08,0x07,0xC0,0x44,0x00,
196 0x81,0x01,0x01,0xA9,0x0D,0x02,0x02,0x50,0x03,0x37,
197 0x37,0x00,0xAF,0x21,0x00
199 /* NTSC digital input over GPIO[7:0] */
201 51, // 51 bytes following
202 0x0C,0xC0,0x00,0x00,0x90,0x02,0x03,0x10,0x03,0x06,
203 0x10,0x04,0x12,0x12,0x05,0x02,0x13,0x04,0x19,0x00,
204 0x04,0x39,0x00,0x06,0x59,0x08,0x03,0x83,0x08,0x07,
205 0x03,0x50,0x00,0xC0,0x40,0x00,0x86,0x01,0x01,0xA6,
206 0x0D,0x02,0x03,0x11,0x01,0x05,0x37,0x00,0xAC,0x21,
209 // TGB_NTSC392 // quartzsight
210 // This table has been modified to be used for Fusion Rev D
212 0x2A, // size of table = 42
213 0x06, 0x08, 0x04, 0x0a, 0xc0, 0x00, 0x18, 0x08, 0x03, 0x24,
214 0x08, 0x07, 0x02, 0x90, 0x02, 0x08, 0x10, 0x04, 0x0c, 0x10,
215 0x05, 0x2c, 0x11, 0x04, 0x55, 0x48, 0x00, 0x05, 0x50, 0x00,
216 0xbf, 0x0c, 0x02, 0x2f, 0x3d, 0x00, 0x2f, 0x3f, 0x00, 0xc3,
221 /* minhdelayx1 first video pixel we can capture on a line and
222 hdelayx1 start of active video, both relative to rising edge of
223 /HRESET pulse (0H) in 1 / fCLKx1.
224 swidth width of active video and
225 totalwidth total line width, both in 1 / fCLKx1.
226 sqwidth total line width in square pixels.
227 vdelay start of active video in 2 * field lines relative to
228 trailing edge of /VRESET pulse (VDELAY register).
229 sheight height of active video in 2 * field lines.
230 videostart0 ITU-R frame line number of the line corresponding
231 to vdelay in the first field. */
232 #define CROPCAP(minhdelayx1, hdelayx1, swidth, totalwidth, sqwidth, \
233 vdelay, sheight, videostart0) \
234 .cropcap.bounds.left = minhdelayx1, \
235 /* * 2 because vertically we count field lines times two, */ \
236 /* e.g. 23 * 2 to 23 * 2 + 576 in PAL-BGHI defrect. */ \
237 .cropcap.bounds.top = (videostart0) * 2 - (vdelay) + MIN_VDELAY, \
238 /* 4 is a safety margin at the end of the line. */ \
239 .cropcap.bounds.width = (totalwidth) - (minhdelayx1) - 4, \
240 .cropcap.bounds.height = (sheight) + (vdelay) - MIN_VDELAY, \
241 .cropcap.defrect.left = hdelayx1, \
242 .cropcap.defrect.top = (videostart0) * 2, \
243 .cropcap.defrect.width = swidth, \
244 .cropcap.defrect.height = sheight, \
245 .cropcap.pixelaspect.numerator = totalwidth, \
246 .cropcap.pixelaspect.denominator = sqwidth,
248 const struct bttv_tvnorm bttv_tvnorms[] = {
250 /* max. active video is actually 922, but 924 is divisible by 4 and 3! */
251 /* actually, max active PAL with HSCALE=0 is 948, NTSC is 768 - nil */
253 .v4l2_id = V4L2_STD_PAL,
261 .iform = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
262 .scaledtwidth = 1135,
266 .vbipack = 255, /* min (2048 / 4, 0x1ff) & 0xff */
268 /* ITU-R frame line number of the first VBI line
269 we can capture, of the first and second field.
270 The last line is determined by cropcap.bounds. */
271 .vbistart = { 7, 320 },
272 CROPCAP(/* minhdelayx1 */ 68,
274 /* Should be (768 * 1135 + 944 / 2) / 944.
275 cropcap.defrect is used for image width
276 checks, so we keep the old value 924. */
278 /* totalwidth */ 1135,
282 /* videostart0 */ 23)
283 /* bt878 (and bt848?) can capture another
284 line below active video. */
285 .cropcap.bounds.height = (576 + 2) + 0x20 - 2,
287 .v4l2_id = V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR,
295 .iform = (BT848_IFORM_NTSC|BT848_IFORM_XT0),
300 .vbipack = 144, /* min (1600 / 4, 0x1ff) & 0xff */
302 .vbistart = { 10, 273 },
303 CROPCAP(/* minhdelayx1 */ 68,
305 /* Should be (640 * 910 + 780 / 2) / 780? */
307 /* totalwidth */ 910,
311 /* videostart0 */ 23)
313 .v4l2_id = V4L2_STD_SECAM,
321 .iform = (BT848_IFORM_SECAM|BT848_IFORM_XT1),
322 .scaledtwidth = 1135,
327 .sram = 0, /* like PAL, correct? */
328 .vbistart = { 7, 320 },
329 CROPCAP(/* minhdelayx1 */ 68,
332 /* totalwidth */ 1135,
336 /* videostart0 */ 23)
338 .v4l2_id = V4L2_STD_PAL_Nc,
346 .iform = (BT848_IFORM_PAL_NC|BT848_IFORM_XT0),
353 .vbistart = { 7, 320 },
354 CROPCAP(/* minhdelayx1 */ 68,
356 /* swidth */ (640 * 910 + 780 / 2) / 780,
357 /* totalwidth */ 910,
361 /* videostart0 */ 23)
363 .v4l2_id = V4L2_STD_PAL_M,
371 .iform = (BT848_IFORM_PAL_M|BT848_IFORM_XT0),
378 .vbistart = { 10, 273 },
379 CROPCAP(/* minhdelayx1 */ 68,
381 /* swidth */ (640 * 910 + 780 / 2) / 780,
382 /* totalwidth */ 910,
386 /* videostart0 */ 23)
388 .v4l2_id = V4L2_STD_PAL_N,
396 .iform = (BT848_IFORM_PAL_N|BT848_IFORM_XT1),
403 .vbistart = { 7, 320 },
404 CROPCAP(/* minhdelayx1 */ 68,
406 /* swidth */ (768 * 1135 + 944 / 2) / 944,
407 /* totalwidth */ 1135,
411 /* videostart0 */ 23)
413 .v4l2_id = V4L2_STD_NTSC_M_JP,
421 .iform = (BT848_IFORM_NTSC_J|BT848_IFORM_XT0),
428 .vbistart = { 10, 273 },
429 CROPCAP(/* minhdelayx1 */ 68,
431 /* swidth */ (640 * 910 + 780 / 2) / 780,
432 /* totalwidth */ 910,
436 /* videostart0 */ 23)
438 /* that one hopefully works with the strange timing
439 * which video recorders produce when playing a NTSC
440 * tape on a PAL TV ... */
441 .v4l2_id = V4L2_STD_PAL_60,
449 .iform = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
450 .scaledtwidth = 1135,
457 .vbistart = { 10, 273 },
458 CROPCAP(/* minhdelayx1 */ 68,
461 /* totalwidth */ 1135,
465 /* videostart0 */ 23)
468 static const unsigned int BTTV_TVNORMS = ARRAY_SIZE(bttv_tvnorms);
470 /* ----------------------------------------------------------------------- */
472 packed pixel formats must come first */
473 static const struct bttv_format bttv_formats[] = {
475 .name = "8 bpp, gray",
476 .palette = VIDEO_PALETTE_GREY,
477 .fourcc = V4L2_PIX_FMT_GREY,
478 .btformat = BT848_COLOR_FMT_Y8,
480 .flags = FORMAT_FLAGS_PACKED,
482 .name = "8 bpp, dithered color",
483 .palette = VIDEO_PALETTE_HI240,
484 .fourcc = V4L2_PIX_FMT_HI240,
485 .btformat = BT848_COLOR_FMT_RGB8,
487 .flags = FORMAT_FLAGS_PACKED | FORMAT_FLAGS_DITHER,
489 .name = "15 bpp RGB, le",
490 .palette = VIDEO_PALETTE_RGB555,
491 .fourcc = V4L2_PIX_FMT_RGB555,
492 .btformat = BT848_COLOR_FMT_RGB15,
494 .flags = FORMAT_FLAGS_PACKED,
496 .name = "15 bpp RGB, be",
498 .fourcc = V4L2_PIX_FMT_RGB555X,
499 .btformat = BT848_COLOR_FMT_RGB15,
500 .btswap = 0x03, /* byteswap */
502 .flags = FORMAT_FLAGS_PACKED,
504 .name = "16 bpp RGB, le",
505 .palette = VIDEO_PALETTE_RGB565,
506 .fourcc = V4L2_PIX_FMT_RGB565,
507 .btformat = BT848_COLOR_FMT_RGB16,
509 .flags = FORMAT_FLAGS_PACKED,
511 .name = "16 bpp RGB, be",
513 .fourcc = V4L2_PIX_FMT_RGB565X,
514 .btformat = BT848_COLOR_FMT_RGB16,
515 .btswap = 0x03, /* byteswap */
517 .flags = FORMAT_FLAGS_PACKED,
519 .name = "24 bpp RGB, le",
520 .palette = VIDEO_PALETTE_RGB24,
521 .fourcc = V4L2_PIX_FMT_BGR24,
522 .btformat = BT848_COLOR_FMT_RGB24,
524 .flags = FORMAT_FLAGS_PACKED,
526 .name = "32 bpp RGB, le",
527 .palette = VIDEO_PALETTE_RGB32,
528 .fourcc = V4L2_PIX_FMT_BGR32,
529 .btformat = BT848_COLOR_FMT_RGB32,
531 .flags = FORMAT_FLAGS_PACKED,
533 .name = "32 bpp RGB, be",
535 .fourcc = V4L2_PIX_FMT_RGB32,
536 .btformat = BT848_COLOR_FMT_RGB32,
537 .btswap = 0x0f, /* byte+word swap */
539 .flags = FORMAT_FLAGS_PACKED,
541 .name = "4:2:2, packed, YUYV",
542 .palette = VIDEO_PALETTE_YUV422,
543 .fourcc = V4L2_PIX_FMT_YUYV,
544 .btformat = BT848_COLOR_FMT_YUY2,
546 .flags = FORMAT_FLAGS_PACKED,
548 .name = "4:2:2, packed, YUYV",
549 .palette = VIDEO_PALETTE_YUYV,
550 .fourcc = V4L2_PIX_FMT_YUYV,
551 .btformat = BT848_COLOR_FMT_YUY2,
553 .flags = FORMAT_FLAGS_PACKED,
555 .name = "4:2:2, packed, UYVY",
556 .palette = VIDEO_PALETTE_UYVY,
557 .fourcc = V4L2_PIX_FMT_UYVY,
558 .btformat = BT848_COLOR_FMT_YUY2,
559 .btswap = 0x03, /* byteswap */
561 .flags = FORMAT_FLAGS_PACKED,
563 .name = "4:2:2, planar, Y-Cb-Cr",
564 .palette = VIDEO_PALETTE_YUV422P,
565 .fourcc = V4L2_PIX_FMT_YUV422P,
566 .btformat = BT848_COLOR_FMT_YCrCb422,
568 .flags = FORMAT_FLAGS_PLANAR,
572 .name = "4:2:0, planar, Y-Cb-Cr",
573 .palette = VIDEO_PALETTE_YUV420P,
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",
583 .fourcc = V4L2_PIX_FMT_YVU420,
584 .btformat = BT848_COLOR_FMT_YCrCb422,
586 .flags = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
590 .name = "4:1:1, planar, Y-Cb-Cr",
591 .palette = VIDEO_PALETTE_YUV411P,
592 .fourcc = V4L2_PIX_FMT_YUV411P,
593 .btformat = BT848_COLOR_FMT_YCrCb411,
595 .flags = FORMAT_FLAGS_PLANAR,
599 .name = "4:1:0, planar, Y-Cb-Cr",
600 .palette = VIDEO_PALETTE_YUV410P,
601 .fourcc = V4L2_PIX_FMT_YUV410,
602 .btformat = BT848_COLOR_FMT_YCrCb411,
604 .flags = FORMAT_FLAGS_PLANAR,
608 .name = "4:1:0, planar, Y-Cr-Cb",
610 .fourcc = V4L2_PIX_FMT_YVU410,
611 .btformat = BT848_COLOR_FMT_YCrCb411,
613 .flags = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
617 .name = "raw scanlines",
618 .palette = VIDEO_PALETTE_RAW,
620 .btformat = BT848_COLOR_FMT_RAW,
622 .flags = FORMAT_FLAGS_RAW,
625 static const unsigned int BTTV_FORMATS = ARRAY_SIZE(bttv_formats);
627 /* ----------------------------------------------------------------------- */
629 #define V4L2_CID_PRIVATE_CHROMA_AGC (V4L2_CID_PRIVATE_BASE + 0)
630 #define V4L2_CID_PRIVATE_COMBFILTER (V4L2_CID_PRIVATE_BASE + 1)
631 #define V4L2_CID_PRIVATE_AUTOMUTE (V4L2_CID_PRIVATE_BASE + 2)
632 #define V4L2_CID_PRIVATE_LUMAFILTER (V4L2_CID_PRIVATE_BASE + 3)
633 #define V4L2_CID_PRIVATE_AGC_CRUSH (V4L2_CID_PRIVATE_BASE + 4)
634 #define V4L2_CID_PRIVATE_VCR_HACK (V4L2_CID_PRIVATE_BASE + 5)
635 #define V4L2_CID_PRIVATE_WHITECRUSH_UPPER (V4L2_CID_PRIVATE_BASE + 6)
636 #define V4L2_CID_PRIVATE_WHITECRUSH_LOWER (V4L2_CID_PRIVATE_BASE + 7)
637 #define V4L2_CID_PRIVATE_UV_RATIO (V4L2_CID_PRIVATE_BASE + 8)
638 #define V4L2_CID_PRIVATE_FULL_LUMA_RANGE (V4L2_CID_PRIVATE_BASE + 9)
639 #define V4L2_CID_PRIVATE_CORING (V4L2_CID_PRIVATE_BASE + 10)
640 #define V4L2_CID_PRIVATE_LASTP1 (V4L2_CID_PRIVATE_BASE + 11)
642 static const struct v4l2_queryctrl no_ctl = {
644 .flags = V4L2_CTRL_FLAG_DISABLED,
646 static const struct v4l2_queryctrl bttv_ctls[] = {
649 .id = V4L2_CID_BRIGHTNESS,
650 .name = "Brightness",
654 .default_value = 32768,
655 .type = V4L2_CTRL_TYPE_INTEGER,
657 .id = V4L2_CID_CONTRAST,
662 .default_value = 32768,
663 .type = V4L2_CTRL_TYPE_INTEGER,
665 .id = V4L2_CID_SATURATION,
666 .name = "Saturation",
670 .default_value = 32768,
671 .type = V4L2_CTRL_TYPE_INTEGER,
678 .default_value = 32768,
679 .type = V4L2_CTRL_TYPE_INTEGER,
683 .id = V4L2_CID_AUDIO_MUTE,
687 .type = V4L2_CTRL_TYPE_BOOLEAN,
689 .id = V4L2_CID_AUDIO_VOLUME,
694 .default_value = 65535,
695 .type = V4L2_CTRL_TYPE_INTEGER,
697 .id = V4L2_CID_AUDIO_BALANCE,
702 .default_value = 32768,
703 .type = V4L2_CTRL_TYPE_INTEGER,
705 .id = V4L2_CID_AUDIO_BASS,
710 .default_value = 32768,
711 .type = V4L2_CTRL_TYPE_INTEGER,
713 .id = V4L2_CID_AUDIO_TREBLE,
718 .default_value = 32768,
719 .type = V4L2_CTRL_TYPE_INTEGER,
721 /* --- private --- */
723 .id = V4L2_CID_PRIVATE_CHROMA_AGC,
724 .name = "chroma agc",
727 .type = V4L2_CTRL_TYPE_BOOLEAN,
729 .id = V4L2_CID_PRIVATE_COMBFILTER,
730 .name = "combfilter",
733 .type = V4L2_CTRL_TYPE_BOOLEAN,
735 .id = V4L2_CID_PRIVATE_AUTOMUTE,
739 .type = V4L2_CTRL_TYPE_BOOLEAN,
741 .id = V4L2_CID_PRIVATE_LUMAFILTER,
742 .name = "luma decimation filter",
745 .type = V4L2_CTRL_TYPE_BOOLEAN,
747 .id = V4L2_CID_PRIVATE_AGC_CRUSH,
751 .type = V4L2_CTRL_TYPE_BOOLEAN,
753 .id = V4L2_CID_PRIVATE_VCR_HACK,
757 .type = V4L2_CTRL_TYPE_BOOLEAN,
759 .id = V4L2_CID_PRIVATE_WHITECRUSH_UPPER,
760 .name = "whitecrush upper",
764 .default_value = 0xCF,
765 .type = V4L2_CTRL_TYPE_INTEGER,
767 .id = V4L2_CID_PRIVATE_WHITECRUSH_LOWER,
768 .name = "whitecrush lower",
772 .default_value = 0x7F,
773 .type = V4L2_CTRL_TYPE_INTEGER,
775 .id = V4L2_CID_PRIVATE_UV_RATIO,
781 .type = V4L2_CTRL_TYPE_INTEGER,
783 .id = V4L2_CID_PRIVATE_FULL_LUMA_RANGE,
784 .name = "full luma range",
787 .type = V4L2_CTRL_TYPE_BOOLEAN,
789 .id = V4L2_CID_PRIVATE_CORING,
795 .type = V4L2_CTRL_TYPE_INTEGER,
801 static const int BTTV_CTLS = ARRAY_SIZE(bttv_ctls);
803 /* ----------------------------------------------------------------------- */
804 /* resource management */
807 RESOURCE_ allocated by freed by
809 VIDEO_READ bttv_read 1) bttv_read 2)
811 VIDEO_STREAM VIDIOC_STREAMON VIDIOC_STREAMOFF
812 VIDIOC_QBUF 1) bttv_release
815 OVERLAY VIDIOCCAPTURE on VIDIOCCAPTURE off
816 VIDIOC_OVERLAY on VIDIOC_OVERLAY off
819 VBI VIDIOC_STREAMON VIDIOC_STREAMOFF
820 VIDIOC_QBUF 1) bttv_release
821 bttv_read, bttv_poll 1) 4)
823 1) The resource must be allocated when we enter buffer prepare functions
824 and remain allocated while buffers are in the DMA queue.
825 2) This is a single frame read.
826 3) VIDIOC_S_FBUF and VIDIOC_S_FMT (OVERLAY) still work when
827 RESOURCE_OVERLAY is allocated.
828 4) This is a continuous read, implies VIDIOC_STREAMON.
830 Note this driver permits video input and standard changes regardless if
831 resources are allocated.
834 #define VBI_RESOURCES (RESOURCE_VBI)
835 #define VIDEO_RESOURCES (RESOURCE_VIDEO_READ | \
836 RESOURCE_VIDEO_STREAM | \
840 int check_alloc_btres(struct bttv *btv, struct bttv_fh *fh, int bit)
842 int xbits; /* mutual exclusive resources */
844 if (fh->resources & bit)
845 /* have it already allocated */
849 if (bit & (RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM))
850 xbits |= RESOURCE_VIDEO_READ | RESOURCE_VIDEO_STREAM;
853 mutex_lock(&btv->lock);
854 if (btv->resources & xbits) {
855 /* no, someone else uses it */
859 if ((bit & VIDEO_RESOURCES)
860 && 0 == (btv->resources & VIDEO_RESOURCES)) {
861 /* Do crop - use current, don't - use default parameters. */
862 __s32 top = btv->crop[!!fh->do_crop].rect.top;
864 if (btv->vbi_end > top)
867 /* We cannot capture the same line as video and VBI data.
868 Claim scan lines crop[].rect.top to bottom. */
869 btv->crop_start = top;
870 } else if (bit & VBI_RESOURCES) {
871 __s32 end = fh->vbi_fmt.end;
873 if (end > btv->crop_start)
876 /* Claim scan lines above fh->vbi_fmt.end. */
880 /* it's free, grab it */
881 fh->resources |= bit;
882 btv->resources |= bit;
883 mutex_unlock(&btv->lock);
887 mutex_unlock(&btv->lock);
892 int check_btres(struct bttv_fh *fh, int bit)
894 return (fh->resources & bit);
898 int locked_btres(struct bttv *btv, int bit)
900 return (btv->resources & bit);
903 /* Call with btv->lock down. */
905 disclaim_vbi_lines(struct bttv *btv)
910 /* Call with btv->lock down. */
912 disclaim_video_lines(struct bttv *btv)
914 const struct bttv_tvnorm *tvnorm;
917 tvnorm = &bttv_tvnorms[btv->tvnorm];
918 btv->crop_start = tvnorm->cropcap.bounds.top
919 + tvnorm->cropcap.bounds.height;
921 /* VBI capturing ends at VDELAY, start of video capturing, no
922 matter how many lines the VBI RISC program expects. When video
923 capturing is off, it shall no longer "preempt" VBI capturing,
924 so we set VDELAY to maximum. */
925 crop = btread(BT848_E_CROP) | 0xc0;
926 btwrite(crop, BT848_E_CROP);
927 btwrite(0xfe, BT848_E_VDELAY_LO);
928 btwrite(crop, BT848_O_CROP);
929 btwrite(0xfe, BT848_O_VDELAY_LO);
933 void free_btres(struct bttv *btv, struct bttv_fh *fh, int bits)
935 if ((fh->resources & bits) != bits) {
936 /* trying to free ressources not allocated by us ... */
937 printk("bttv: BUG! (btres)\n");
939 mutex_lock(&btv->lock);
940 fh->resources &= ~bits;
941 btv->resources &= ~bits;
943 bits = btv->resources;
945 if (0 == (bits & VIDEO_RESOURCES))
946 disclaim_video_lines(btv);
948 if (0 == (bits & VBI_RESOURCES))
949 disclaim_vbi_lines(btv);
951 mutex_unlock(&btv->lock);
954 /* ----------------------------------------------------------------------- */
955 /* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC */
957 /* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C
958 PLL_X = Reference pre-divider (0=1, 1=2)
959 PLL_C = Post divider (0=6, 1=4)
960 PLL_I = Integer input
961 PLL_F = Fractional input
963 F_input = 28.636363 MHz:
964 PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0
967 static void set_pll_freq(struct bttv *btv, unsigned int fin, unsigned int fout)
969 unsigned char fl, fh, fi;
971 /* prevent overflows */
984 btwrite(fl, BT848_PLL_F_LO);
985 btwrite(fh, BT848_PLL_F_HI);
986 btwrite(fi|BT848_PLL_X, BT848_PLL_XCI);
989 static void set_pll(struct bttv *btv)
993 if (!btv->pll.pll_crystal)
996 if (btv->pll.pll_ofreq == btv->pll.pll_current) {
997 dprintk("bttv%d: PLL: no change required\n",btv->c.nr);
1001 if (btv->pll.pll_ifreq == btv->pll.pll_ofreq) {
1003 if (btv->pll.pll_current == 0)
1005 bttv_printk(KERN_INFO "bttv%d: PLL can sleep, using XTAL (%d).\n",
1006 btv->c.nr,btv->pll.pll_ifreq);
1007 btwrite(0x00,BT848_TGCTRL);
1008 btwrite(0x00,BT848_PLL_XCI);
1009 btv->pll.pll_current = 0;
1013 bttv_printk(KERN_INFO "bttv%d: PLL: %d => %d ",btv->c.nr,
1014 btv->pll.pll_ifreq, btv->pll.pll_ofreq);
1015 set_pll_freq(btv, btv->pll.pll_ifreq, btv->pll.pll_ofreq);
1017 for (i=0; i<10; i++) {
1018 /* Let other people run while the PLL stabilizes */
1022 if (btread(BT848_DSTATUS) & BT848_DSTATUS_PLOCK) {
1023 btwrite(0,BT848_DSTATUS);
1025 btwrite(0x08,BT848_TGCTRL);
1026 btv->pll.pll_current = btv->pll.pll_ofreq;
1027 bttv_printk(" ok\n");
1031 btv->pll.pll_current = -1;
1032 bttv_printk("failed\n");
1036 /* used to switch between the bt848's analog/digital video capture modes */
1037 static void bt848A_set_timing(struct bttv *btv)
1040 int table_idx = bttv_tvnorms[btv->tvnorm].sram;
1041 int fsc = bttv_tvnorms[btv->tvnorm].Fsc;
1043 if (UNSET == bttv_tvcards[btv->c.type].muxsel[btv->input]) {
1044 dprintk("bttv%d: load digital timing table (table_idx=%d)\n",
1045 btv->c.nr,table_idx);
1047 /* timing change...reset timing generator address */
1048 btwrite(0x00, BT848_TGCTRL);
1049 btwrite(0x02, BT848_TGCTRL);
1050 btwrite(0x00, BT848_TGCTRL);
1052 len=SRAM_Table[table_idx][0];
1053 for(i = 1; i <= len; i++)
1054 btwrite(SRAM_Table[table_idx][i],BT848_TGLB);
1055 btv->pll.pll_ofreq = 27000000;
1058 btwrite(0x11, BT848_TGCTRL);
1059 btwrite(0x41, BT848_DVSIF);
1061 btv->pll.pll_ofreq = fsc;
1063 btwrite(0x0, BT848_DVSIF);
1067 /* ----------------------------------------------------------------------- */
1069 static void bt848_bright(struct bttv *btv, int bright)
1073 // printk("bttv: set bright: %d\n",bright); // DEBUG
1074 btv->bright = bright;
1076 /* We want -128 to 127 we get 0-65535 */
1077 value = (bright >> 8) - 128;
1078 btwrite(value & 0xff, BT848_BRIGHT);
1081 static void bt848_hue(struct bttv *btv, int hue)
1088 value = (hue >> 8) - 128;
1089 btwrite(value & 0xff, BT848_HUE);
1092 static void bt848_contrast(struct bttv *btv, int cont)
1096 btv->contrast = cont;
1099 value = (cont >> 7);
1100 hibit = (value >> 6) & 4;
1101 btwrite(value & 0xff, BT848_CONTRAST_LO);
1102 btaor(hibit, ~4, BT848_E_CONTROL);
1103 btaor(hibit, ~4, BT848_O_CONTROL);
1106 static void bt848_sat(struct bttv *btv, int color)
1108 int val_u,val_v,hibits;
1110 btv->saturation = color;
1112 /* 0-511 for the color */
1113 val_u = ((color * btv->opt_uv_ratio) / 50) >> 7;
1114 val_v = (((color * (100 - btv->opt_uv_ratio) / 50) >>7)*180L)/254;
1115 hibits = (val_u >> 7) & 2;
1116 hibits |= (val_v >> 8) & 1;
1117 btwrite(val_u & 0xff, BT848_SAT_U_LO);
1118 btwrite(val_v & 0xff, BT848_SAT_V_LO);
1119 btaor(hibits, ~3, BT848_E_CONTROL);
1120 btaor(hibits, ~3, BT848_O_CONTROL);
1123 /* ----------------------------------------------------------------------- */
1126 video_mux(struct bttv *btv, unsigned int input)
1130 if (input >= bttv_tvcards[btv->c.type].video_inputs)
1133 /* needed by RemoteVideo MX */
1134 mask2 = bttv_tvcards[btv->c.type].gpiomask2;
1136 gpio_inout(mask2,mask2);
1138 if (input == btv->svhs) {
1139 btor(BT848_CONTROL_COMP, BT848_E_CONTROL);
1140 btor(BT848_CONTROL_COMP, BT848_O_CONTROL);
1142 btand(~BT848_CONTROL_COMP, BT848_E_CONTROL);
1143 btand(~BT848_CONTROL_COMP, BT848_O_CONTROL);
1145 mux = bttv_tvcards[btv->c.type].muxsel[input] & 3;
1146 btaor(mux<<5, ~(3<<5), BT848_IFORM);
1147 dprintk(KERN_DEBUG "bttv%d: video mux: input=%d mux=%d\n",
1148 btv->c.nr,input,mux);
1150 /* card specific hook */
1151 if(bttv_tvcards[btv->c.type].muxsel_hook)
1152 bttv_tvcards[btv->c.type].muxsel_hook (btv, input);
1156 static char *audio_modes[] = {
1157 "audio: tuner", "audio: radio", "audio: extern",
1158 "audio: intern", "audio: mute"
1162 audio_mux(struct bttv *btv, int input, int mute)
1164 int gpio_val, signal;
1165 struct v4l2_control ctrl;
1166 struct i2c_client *c;
1168 gpio_inout(bttv_tvcards[btv->c.type].gpiomask,
1169 bttv_tvcards[btv->c.type].gpiomask);
1170 signal = btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC;
1176 mute = mute || (btv->opt_automute && !signal && !btv->radio_user);
1179 gpio_val = bttv_tvcards[btv->c.type].gpiomute;
1181 gpio_val = bttv_tvcards[btv->c.type].gpiomux[input];
1183 gpio_bits(bttv_tvcards[btv->c.type].gpiomask, gpio_val);
1185 bttv_gpio_tracking(btv, audio_modes[mute ? 4 : input]);
1189 ctrl.id = V4L2_CID_AUDIO_MUTE;
1190 ctrl.value = btv->mute;
1191 bttv_call_i2c_clients(btv, VIDIOC_S_CTRL, &ctrl);
1192 c = btv->i2c_msp34xx_client;
1194 struct v4l2_routing route;
1196 /* Note: the inputs tuner/radio/extern/intern are translated
1197 to msp routings. This assumes common behavior for all msp3400
1198 based TV cards. When this assumption fails, then the
1199 specific MSP routing must be added to the card table.
1200 For now this is sufficient. */
1202 case TVAUDIO_INPUT_RADIO:
1203 route.input = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1204 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1206 case TVAUDIO_INPUT_EXTERN:
1207 route.input = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER1,
1208 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1210 case TVAUDIO_INPUT_INTERN:
1211 /* Yes, this is the same input as for RADIO. I doubt
1212 if this is ever used. The only board with an INTERN
1213 input is the BTTV_BOARD_AVERMEDIA98. I wonder how
1214 that was tested. My guess is that the whole INTERN
1215 input does not work. */
1216 route.input = MSP_INPUT(MSP_IN_SCART2, MSP_IN_TUNER1,
1217 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART);
1219 case TVAUDIO_INPUT_TUNER:
1221 /* This is the only card that uses TUNER2, and afaik,
1222 is the only difference between the VOODOOTV_FM
1224 if (btv->c.type == BTTV_BOARD_VOODOOTV_200)
1225 route.input = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER2, \
1226 MSP_DSP_IN_TUNER, MSP_DSP_IN_TUNER);
1228 route.input = MSP_INPUT_DEFAULT;
1231 route.output = MSP_OUTPUT_DEFAULT;
1232 c->driver->command(c, VIDIOC_INT_S_AUDIO_ROUTING, &route);
1234 c = btv->i2c_tvaudio_client;
1236 struct v4l2_routing route;
1238 route.input = input;
1240 c->driver->command(c, VIDIOC_INT_S_AUDIO_ROUTING, &route);
1246 audio_mute(struct bttv *btv, int mute)
1248 return audio_mux(btv, btv->audio, mute);
1252 audio_input(struct bttv *btv, int input)
1254 return audio_mux(btv, input, btv->mute);
1258 i2c_vidiocschan(struct bttv *btv)
1260 v4l2_std_id std = bttv_tvnorms[btv->tvnorm].v4l2_id;
1262 bttv_call_i2c_clients(btv, VIDIOC_S_STD, &std);
1263 if (btv->c.type == BTTV_BOARD_VOODOOTV_FM || btv->c.type == BTTV_BOARD_VOODOOTV_200)
1264 bttv_tda9880_setnorm(btv,btv->tvnorm);
1268 bttv_crop_calc_limits(struct bttv_crop *c)
1270 /* Scale factor min. 1:1, max. 16:1. Min. image size
1271 48 x 32. Scaled width must be a multiple of 4. */
1274 /* For bug compatibility with VIDIOCGCAP and image
1275 size checks in earlier driver versions. */
1276 c->min_scaled_width = 48;
1277 c->min_scaled_height = 32;
1279 c->min_scaled_width =
1280 (max(48, c->rect.width >> 4) + 3) & ~3;
1281 c->min_scaled_height =
1282 max(32, c->rect.height >> 4);
1285 c->max_scaled_width = c->rect.width & ~3;
1286 c->max_scaled_height = c->rect.height;
1290 bttv_crop_reset(struct bttv_crop *c, int norm)
1292 c->rect = bttv_tvnorms[norm].cropcap.defrect;
1293 bttv_crop_calc_limits(c);
1296 /* Call with btv->lock down. */
1298 set_tvnorm(struct bttv *btv, unsigned int norm)
1300 const struct bttv_tvnorm *tvnorm;
1302 if (norm < 0 || norm >= BTTV_TVNORMS)
1305 tvnorm = &bttv_tvnorms[norm];
1307 if (btv->tvnorm < 0 ||
1308 btv->tvnorm >= BTTV_TVNORMS ||
1309 0 != memcmp(&bttv_tvnorms[btv->tvnorm].cropcap,
1311 sizeof (tvnorm->cropcap))) {
1312 bttv_crop_reset(&btv->crop[0], norm);
1313 btv->crop[1] = btv->crop[0]; /* current = default */
1315 if (0 == (btv->resources & VIDEO_RESOURCES)) {
1316 btv->crop_start = tvnorm->cropcap.bounds.top
1317 + tvnorm->cropcap.bounds.height;
1323 btwrite(tvnorm->adelay, BT848_ADELAY);
1324 btwrite(tvnorm->bdelay, BT848_BDELAY);
1325 btaor(tvnorm->iform,~(BT848_IFORM_NORM|BT848_IFORM_XTBOTH),
1327 btwrite(tvnorm->vbipack, BT848_VBI_PACK_SIZE);
1328 btwrite(1, BT848_VBI_PACK_DEL);
1329 bt848A_set_timing(btv);
1331 switch (btv->c.type) {
1332 case BTTV_BOARD_VOODOOTV_FM:
1333 case BTTV_BOARD_VOODOOTV_200:
1334 bttv_tda9880_setnorm(btv,norm);
1340 /* Call with btv->lock down. */
1342 set_input(struct bttv *btv, unsigned int input, unsigned int norm)
1344 unsigned long flags;
1348 spin_lock_irqsave(&btv->s_lock,flags);
1349 if (btv->curr.frame_irq) {
1350 /* active capture -> delayed input switch */
1351 btv->new_input = input;
1353 video_mux(btv,input);
1355 spin_unlock_irqrestore(&btv->s_lock,flags);
1357 video_mux(btv,input);
1359 audio_input(btv,(input == bttv_tvcards[btv->c.type].tuner ?
1360 TVAUDIO_INPUT_TUNER : TVAUDIO_INPUT_EXTERN));
1361 set_tvnorm(btv, norm);
1362 i2c_vidiocschan(btv);
1365 static void init_irqreg(struct bttv *btv)
1368 btwrite(0xfffffUL, BT848_INT_STAT);
1370 if (bttv_tvcards[btv->c.type].no_video) {
1372 btwrite(BT848_INT_I2CDONE,
1376 btwrite((btv->triton1) |
1377 (btv->gpioirq ? BT848_INT_GPINT : 0) |
1379 (fdsr ? BT848_INT_FDSR : 0) |
1380 BT848_INT_RISCI|BT848_INT_OCERR|BT848_INT_VPRES|
1381 BT848_INT_FMTCHG|BT848_INT_HLOCK|
1387 static void init_bt848(struct bttv *btv)
1391 if (bttv_tvcards[btv->c.type].no_video) {
1392 /* very basic init only */
1397 btwrite(0x00, BT848_CAP_CTL);
1398 btwrite(BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL);
1399 btwrite(BT848_IFORM_XTAUTO | BT848_IFORM_AUTO, BT848_IFORM);
1401 /* set planar and packed mode trigger points and */
1402 /* set rising edge of inverted GPINTR pin as irq trigger */
1403 btwrite(BT848_GPIO_DMA_CTL_PKTP_32|
1404 BT848_GPIO_DMA_CTL_PLTP1_16|
1405 BT848_GPIO_DMA_CTL_PLTP23_16|
1406 BT848_GPIO_DMA_CTL_GPINTC|
1407 BT848_GPIO_DMA_CTL_GPINTI,
1408 BT848_GPIO_DMA_CTL);
1410 val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1411 btwrite(val, BT848_E_SCLOOP);
1412 btwrite(val, BT848_O_SCLOOP);
1414 btwrite(0x20, BT848_E_VSCALE_HI);
1415 btwrite(0x20, BT848_O_VSCALE_HI);
1416 btwrite(BT848_ADC_RESERVED | (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1419 btwrite(whitecrush_upper, BT848_WC_UP);
1420 btwrite(whitecrush_lower, BT848_WC_DOWN);
1422 if (btv->opt_lumafilter) {
1423 btwrite(0, BT848_E_CONTROL);
1424 btwrite(0, BT848_O_CONTROL);
1426 btwrite(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1427 btwrite(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1430 bt848_bright(btv, btv->bright);
1431 bt848_hue(btv, btv->hue);
1432 bt848_contrast(btv, btv->contrast);
1433 bt848_sat(btv, btv->saturation);
1439 static void bttv_reinit_bt848(struct bttv *btv)
1441 unsigned long flags;
1444 printk(KERN_INFO "bttv%d: reset, reinitialize\n",btv->c.nr);
1445 spin_lock_irqsave(&btv->s_lock,flags);
1447 bttv_set_dma(btv,0);
1448 spin_unlock_irqrestore(&btv->s_lock,flags);
1451 btv->pll.pll_current = -1;
1452 set_input(btv, btv->input, btv->tvnorm);
1455 static int get_control(struct bttv *btv, struct v4l2_control *c)
1457 struct video_audio va;
1460 for (i = 0; i < BTTV_CTLS; i++)
1461 if (bttv_ctls[i].id == c->id)
1465 if (btv->audio_hook && i >= 4 && i <= 8) {
1466 memset(&va,0,sizeof(va));
1467 btv->audio_hook(btv,&va,0);
1469 case V4L2_CID_AUDIO_MUTE:
1470 c->value = (VIDEO_AUDIO_MUTE & va.flags) ? 1 : 0;
1472 case V4L2_CID_AUDIO_VOLUME:
1473 c->value = va.volume;
1475 case V4L2_CID_AUDIO_BALANCE:
1476 c->value = va.balance;
1478 case V4L2_CID_AUDIO_BASS:
1481 case V4L2_CID_AUDIO_TREBLE:
1482 c->value = va.treble;
1488 case V4L2_CID_BRIGHTNESS:
1489 c->value = btv->bright;
1492 c->value = btv->hue;
1494 case V4L2_CID_CONTRAST:
1495 c->value = btv->contrast;
1497 case V4L2_CID_SATURATION:
1498 c->value = btv->saturation;
1501 case V4L2_CID_AUDIO_MUTE:
1502 case V4L2_CID_AUDIO_VOLUME:
1503 case V4L2_CID_AUDIO_BALANCE:
1504 case V4L2_CID_AUDIO_BASS:
1505 case V4L2_CID_AUDIO_TREBLE:
1506 bttv_call_i2c_clients(btv,VIDIOC_G_CTRL,c);
1509 case V4L2_CID_PRIVATE_CHROMA_AGC:
1510 c->value = btv->opt_chroma_agc;
1512 case V4L2_CID_PRIVATE_COMBFILTER:
1513 c->value = btv->opt_combfilter;
1515 case V4L2_CID_PRIVATE_LUMAFILTER:
1516 c->value = btv->opt_lumafilter;
1518 case V4L2_CID_PRIVATE_AUTOMUTE:
1519 c->value = btv->opt_automute;
1521 case V4L2_CID_PRIVATE_AGC_CRUSH:
1522 c->value = btv->opt_adc_crush;
1524 case V4L2_CID_PRIVATE_VCR_HACK:
1525 c->value = btv->opt_vcr_hack;
1527 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1528 c->value = btv->opt_whitecrush_upper;
1530 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1531 c->value = btv->opt_whitecrush_lower;
1533 case V4L2_CID_PRIVATE_UV_RATIO:
1534 c->value = btv->opt_uv_ratio;
1536 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1537 c->value = btv->opt_full_luma_range;
1539 case V4L2_CID_PRIVATE_CORING:
1540 c->value = btv->opt_coring;
1548 static int set_control(struct bttv *btv, struct v4l2_control *c)
1550 struct video_audio va;
1553 for (i = 0; i < BTTV_CTLS; i++)
1554 if (bttv_ctls[i].id == c->id)
1558 if (btv->audio_hook && i >= 4 && i <= 8) {
1559 memset(&va,0,sizeof(va));
1560 btv->audio_hook(btv,&va,0);
1562 case V4L2_CID_AUDIO_MUTE:
1564 va.flags |= VIDEO_AUDIO_MUTE;
1567 va.flags &= ~VIDEO_AUDIO_MUTE;
1572 case V4L2_CID_AUDIO_VOLUME:
1573 va.volume = c->value;
1575 case V4L2_CID_AUDIO_BALANCE:
1576 va.balance = c->value;
1578 case V4L2_CID_AUDIO_BASS:
1581 case V4L2_CID_AUDIO_TREBLE:
1582 va.treble = c->value;
1585 btv->audio_hook(btv,&va,1);
1589 case V4L2_CID_BRIGHTNESS:
1590 bt848_bright(btv,c->value);
1593 bt848_hue(btv,c->value);
1595 case V4L2_CID_CONTRAST:
1596 bt848_contrast(btv,c->value);
1598 case V4L2_CID_SATURATION:
1599 bt848_sat(btv,c->value);
1601 case V4L2_CID_AUDIO_MUTE:
1602 audio_mute(btv, c->value);
1604 case V4L2_CID_AUDIO_VOLUME:
1605 case V4L2_CID_AUDIO_BALANCE:
1606 case V4L2_CID_AUDIO_BASS:
1607 case V4L2_CID_AUDIO_TREBLE:
1608 bttv_call_i2c_clients(btv,VIDIOC_S_CTRL,c);
1611 case V4L2_CID_PRIVATE_CHROMA_AGC:
1612 btv->opt_chroma_agc = c->value;
1613 val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1614 btwrite(val, BT848_E_SCLOOP);
1615 btwrite(val, BT848_O_SCLOOP);
1617 case V4L2_CID_PRIVATE_COMBFILTER:
1618 btv->opt_combfilter = c->value;
1620 case V4L2_CID_PRIVATE_LUMAFILTER:
1621 btv->opt_lumafilter = c->value;
1622 if (btv->opt_lumafilter) {
1623 btand(~BT848_CONTROL_LDEC, BT848_E_CONTROL);
1624 btand(~BT848_CONTROL_LDEC, BT848_O_CONTROL);
1626 btor(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1627 btor(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1630 case V4L2_CID_PRIVATE_AUTOMUTE:
1631 btv->opt_automute = c->value;
1633 case V4L2_CID_PRIVATE_AGC_CRUSH:
1634 btv->opt_adc_crush = c->value;
1635 btwrite(BT848_ADC_RESERVED | (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1638 case V4L2_CID_PRIVATE_VCR_HACK:
1639 btv->opt_vcr_hack = c->value;
1641 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1642 btv->opt_whitecrush_upper = c->value;
1643 btwrite(c->value, BT848_WC_UP);
1645 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1646 btv->opt_whitecrush_lower = c->value;
1647 btwrite(c->value, BT848_WC_DOWN);
1649 case V4L2_CID_PRIVATE_UV_RATIO:
1650 btv->opt_uv_ratio = c->value;
1651 bt848_sat(btv, btv->saturation);
1653 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1654 btv->opt_full_luma_range = c->value;
1655 btaor((c->value<<7), ~BT848_OFORM_RANGE, BT848_OFORM);
1657 case V4L2_CID_PRIVATE_CORING:
1658 btv->opt_coring = c->value;
1659 btaor((c->value<<5), ~BT848_OFORM_CORE32, BT848_OFORM);
1667 /* ----------------------------------------------------------------------- */
1669 void bttv_gpio_tracking(struct bttv *btv, char *comment)
1671 unsigned int outbits, data;
1672 outbits = btread(BT848_GPIO_OUT_EN);
1673 data = btread(BT848_GPIO_DATA);
1674 printk(KERN_DEBUG "bttv%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
1675 btv->c.nr,outbits,data & outbits, data & ~outbits, comment);
1678 static void bttv_field_count(struct bttv *btv)
1686 /* start field counter */
1687 btor(BT848_INT_VSYNC,BT848_INT_MASK);
1689 /* stop field counter */
1690 btand(~BT848_INT_VSYNC,BT848_INT_MASK);
1691 btv->field_count = 0;
1695 static const struct bttv_format*
1696 format_by_palette(int palette)
1700 for (i = 0; i < BTTV_FORMATS; i++) {
1701 if (-1 == bttv_formats[i].palette)
1703 if (bttv_formats[i].palette == palette)
1704 return bttv_formats+i;
1709 static const struct bttv_format*
1710 format_by_fourcc(int fourcc)
1714 for (i = 0; i < BTTV_FORMATS; i++) {
1715 if (-1 == bttv_formats[i].fourcc)
1717 if (bttv_formats[i].fourcc == fourcc)
1718 return bttv_formats+i;
1723 /* ----------------------------------------------------------------------- */
1727 bttv_switch_overlay(struct bttv *btv, struct bttv_fh *fh,
1728 struct bttv_buffer *new)
1730 struct bttv_buffer *old;
1731 unsigned long flags;
1734 dprintk("switch_overlay: enter [new=%p]\n",new);
1736 new->vb.state = STATE_DONE;
1737 spin_lock_irqsave(&btv->s_lock,flags);
1741 bttv_set_dma(btv, 0x03);
1742 spin_unlock_irqrestore(&btv->s_lock,flags);
1744 dprintk("switch_overlay: old=%p state is %d\n",old,old->vb.state);
1745 bttv_dma_free(&fh->cap,btv, old);
1749 free_btres(btv,fh,RESOURCE_OVERLAY);
1750 dprintk("switch_overlay: done\n");
1754 /* ----------------------------------------------------------------------- */
1755 /* video4linux (1) interface */
1757 static int bttv_prepare_buffer(struct videobuf_queue *q,struct bttv *btv,
1758 struct bttv_buffer *buf,
1759 const struct bttv_format *fmt,
1760 unsigned int width, unsigned int height,
1761 enum v4l2_field field)
1763 struct bttv_fh *fh = q->priv_data;
1764 int redo_dma_risc = 0;
1769 /* check settings */
1772 if (fmt->btformat == BT848_COLOR_FMT_RAW) {
1774 height = RAW_LINES*2;
1775 if (width*height > buf->vb.bsize)
1777 buf->vb.size = buf->vb.bsize;
1779 /* Make sure tvnorm and vbi_end remain consistent
1780 until we're done. */
1781 mutex_lock(&btv->lock);
1785 /* In this mode capturing always starts at defrect.top
1786 (default VDELAY), ignoring cropping parameters. */
1787 if (btv->vbi_end > bttv_tvnorms[norm].cropcap.defrect.top) {
1788 mutex_unlock(&btv->lock);
1792 mutex_unlock(&btv->lock);
1794 c.rect = bttv_tvnorms[norm].cropcap.defrect;
1796 mutex_lock(&btv->lock);
1799 c = btv->crop[!!fh->do_crop];
1801 mutex_unlock(&btv->lock);
1803 if (width < c.min_scaled_width ||
1804 width > c.max_scaled_width ||
1805 height < c.min_scaled_height)
1809 case V4L2_FIELD_TOP:
1810 case V4L2_FIELD_BOTTOM:
1811 case V4L2_FIELD_ALTERNATE:
1812 /* btv->crop counts frame lines. Max. scale
1813 factor is 16:1 for frames, 8:1 for fields. */
1814 if (height * 2 > c.max_scaled_height)
1819 if (height > c.max_scaled_height)
1824 buf->vb.size = (width * height * fmt->depth) >> 3;
1825 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
1829 /* alloc + fill struct bttv_buffer (if changed) */
1830 if (buf->vb.width != width || buf->vb.height != height ||
1831 buf->vb.field != field ||
1832 buf->tvnorm != norm || buf->fmt != fmt ||
1833 buf->crop.top != c.rect.top ||
1834 buf->crop.left != c.rect.left ||
1835 buf->crop.width != c.rect.width ||
1836 buf->crop.height != c.rect.height) {
1837 buf->vb.width = width;
1838 buf->vb.height = height;
1839 buf->vb.field = field;
1846 /* alloc risc memory */
1847 if (STATE_NEEDS_INIT == buf->vb.state) {
1849 if (0 != (rc = videobuf_iolock(q,&buf->vb,&btv->fbuf)))
1854 if (0 != (rc = bttv_buffer_risc(btv,buf)))
1857 buf->vb.state = STATE_PREPARED;
1861 bttv_dma_free(q,btv,buf);
1866 buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
1868 struct bttv_fh *fh = q->priv_data;
1870 *size = fh->fmt->depth*fh->width*fh->height >> 3;
1873 while (*size * *count > gbuffers * gbufsize)
1879 buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
1880 enum v4l2_field field)
1882 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1883 struct bttv_fh *fh = q->priv_data;
1885 return bttv_prepare_buffer(q,fh->btv, buf, fh->fmt,
1886 fh->width, fh->height, field);
1890 buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
1892 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1893 struct bttv_fh *fh = q->priv_data;
1894 struct bttv *btv = fh->btv;
1896 buf->vb.state = STATE_QUEUED;
1897 list_add_tail(&buf->vb.queue,&btv->capture);
1898 if (!btv->curr.frame_irq) {
1900 bttv_set_dma(btv, 0x03);
1904 static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
1906 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1907 struct bttv_fh *fh = q->priv_data;
1909 bttv_dma_free(q,fh->btv,buf);
1912 static struct videobuf_queue_ops bttv_video_qops = {
1913 .buf_setup = buffer_setup,
1914 .buf_prepare = buffer_prepare,
1915 .buf_queue = buffer_queue,
1916 .buf_release = buffer_release,
1919 static int bttv_common_ioctls(struct bttv *btv, unsigned int cmd, void *arg)
1923 return BTTV_VERSION_CODE;
1925 /* *** v4l1 *** ************************************************ */
1928 unsigned long *freq = arg;
1934 struct v4l2_frequency freq;
1936 memset(&freq, 0, sizeof(freq));
1937 freq.frequency = *(unsigned long *)arg;
1938 mutex_lock(&btv->lock);
1939 freq.type = btv->radio_user ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
1940 btv->freq = *(unsigned long *)arg;
1941 bttv_call_i2c_clients(btv,VIDIOC_S_FREQUENCY,&freq);
1942 if (btv->has_matchbox && btv->radio_user)
1943 tea5757_set_freq(btv,*(unsigned long *)arg);
1944 mutex_unlock(&btv->lock);
1950 struct video_tuner *v = arg;
1952 if (UNSET == bttv_tvcards[btv->c.type].tuner)
1954 if (v->tuner) /* Only tuner 0 */
1956 strcpy(v->name, "Television");
1958 v->rangehigh = 0x7FFFFFFF;
1959 v->flags = VIDEO_TUNER_PAL|VIDEO_TUNER_NTSC|VIDEO_TUNER_SECAM;
1960 v->mode = btv->tvnorm;
1961 v->signal = (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC) ? 0xFFFF : 0;
1962 bttv_call_i2c_clients(btv,cmd,v);
1967 struct video_tuner *v = arg;
1969 if (v->tuner) /* Only tuner 0 */
1971 if (v->mode >= BTTV_TVNORMS)
1974 mutex_lock(&btv->lock);
1975 set_tvnorm(btv,v->mode);
1976 bttv_call_i2c_clients(btv,cmd,v);
1977 mutex_unlock(&btv->lock);
1983 struct video_channel *v = arg;
1984 unsigned int channel = v->channel;
1986 if (channel >= bttv_tvcards[btv->c.type].video_inputs)
1989 v->flags = VIDEO_VC_AUDIO;
1990 v->type = VIDEO_TYPE_CAMERA;
1991 v->norm = btv->tvnorm;
1992 if (channel == bttv_tvcards[btv->c.type].tuner) {
1993 strcpy(v->name,"Television");
1994 v->flags|=VIDEO_VC_TUNER;
1995 v->type=VIDEO_TYPE_TV;
1997 } else if (channel == btv->svhs) {
1998 strcpy(v->name,"S-Video");
2000 sprintf(v->name,"Composite%d",channel);
2006 struct video_channel *v = arg;
2007 unsigned int channel = v->channel;
2009 if (channel >= bttv_tvcards[btv->c.type].video_inputs)
2011 if (v->norm >= BTTV_TVNORMS)
2014 mutex_lock(&btv->lock);
2015 if (channel == btv->input &&
2016 v->norm == btv->tvnorm) {
2018 mutex_unlock(&btv->lock);
2022 set_input(btv, v->channel, v->norm);
2023 mutex_unlock(&btv->lock);
2029 struct video_audio *v = arg;
2031 memset(v,0,sizeof(*v));
2032 strcpy(v->name,"Television");
2033 v->flags |= VIDEO_AUDIO_MUTABLE;
2034 v->mode = VIDEO_SOUND_MONO;
2036 mutex_lock(&btv->lock);
2037 bttv_call_i2c_clients(btv,cmd,v);
2039 /* card specific hooks */
2040 if (btv->audio_hook)
2041 btv->audio_hook(btv,v,0);
2043 mutex_unlock(&btv->lock);
2048 struct video_audio *v = arg;
2049 unsigned int audio = v->audio;
2051 if (audio >= bttv_tvcards[btv->c.type].audio_inputs)
2054 mutex_lock(&btv->lock);
2055 audio_mute(btv, (v->flags&VIDEO_AUDIO_MUTE) ? 1 : 0);
2056 bttv_call_i2c_clients(btv,cmd,v);
2058 /* card specific hooks */
2059 if (btv->audio_hook)
2060 btv->audio_hook(btv,v,1);
2062 mutex_unlock(&btv->lock);
2066 /* *** v4l2 *** ************************************************ */
2067 case VIDIOC_ENUMSTD:
2069 struct v4l2_standard *e = arg;
2070 unsigned int index = e->index;
2072 if (index >= BTTV_TVNORMS)
2074 v4l2_video_std_construct(e, bttv_tvnorms[e->index].v4l2_id,
2075 bttv_tvnorms[e->index].name);
2081 v4l2_std_id *id = arg;
2082 *id = bttv_tvnorms[btv->tvnorm].v4l2_id;
2087 v4l2_std_id *id = arg;
2090 for (i = 0; i < BTTV_TVNORMS; i++)
2091 if (*id & bttv_tvnorms[i].v4l2_id)
2093 if (i == BTTV_TVNORMS)
2096 mutex_lock(&btv->lock);
2098 i2c_vidiocschan(btv);
2099 mutex_unlock(&btv->lock);
2102 case VIDIOC_QUERYSTD:
2104 v4l2_std_id *id = arg;
2106 if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML)
2107 *id = V4L2_STD_625_50;
2109 *id = V4L2_STD_525_60;
2113 case VIDIOC_ENUMINPUT:
2115 struct v4l2_input *i = arg;
2119 if (n >= bttv_tvcards[btv->c.type].video_inputs)
2121 memset(i,0,sizeof(*i));
2123 i->type = V4L2_INPUT_TYPE_CAMERA;
2125 if (i->index == bttv_tvcards[btv->c.type].tuner) {
2126 sprintf(i->name, "Television");
2127 i->type = V4L2_INPUT_TYPE_TUNER;
2129 } else if (i->index == btv->svhs) {
2130 sprintf(i->name, "S-Video");
2132 sprintf(i->name,"Composite%d",i->index);
2134 if (i->index == btv->input) {
2135 __u32 dstatus = btread(BT848_DSTATUS);
2136 if (0 == (dstatus & BT848_DSTATUS_PRES))
2137 i->status |= V4L2_IN_ST_NO_SIGNAL;
2138 if (0 == (dstatus & BT848_DSTATUS_HLOC))
2139 i->status |= V4L2_IN_ST_NO_H_LOCK;
2141 for (n = 0; n < BTTV_TVNORMS; n++)
2142 i->std |= bttv_tvnorms[n].v4l2_id;
2145 case VIDIOC_G_INPUT:
2151 case VIDIOC_S_INPUT:
2153 unsigned int *i = arg;
2155 if (*i > bttv_tvcards[btv->c.type].video_inputs)
2157 mutex_lock(&btv->lock);
2158 set_input(btv, *i, btv->tvnorm);
2159 mutex_unlock(&btv->lock);
2163 case VIDIOC_G_TUNER:
2165 struct v4l2_tuner *t = arg;
2167 if (UNSET == bttv_tvcards[btv->c.type].tuner)
2171 mutex_lock(&btv->lock);
2172 memset(t,0,sizeof(*t));
2173 t->rxsubchans = V4L2_TUNER_SUB_MONO;
2174 bttv_call_i2c_clients(btv, VIDIOC_G_TUNER, t);
2175 strcpy(t->name, "Television");
2176 t->capability = V4L2_TUNER_CAP_NORM;
2177 t->type = V4L2_TUNER_ANALOG_TV;
2178 if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
2181 if (btv->audio_hook) {
2183 struct video_audio va;
2184 memset(&va, 0, sizeof(struct video_audio));
2185 btv->audio_hook(btv,&va,0);
2186 t->audmode = V4L2_TUNER_MODE_MONO;
2187 t->rxsubchans = V4L2_TUNER_SUB_MONO;
2188 if(va.mode & VIDEO_SOUND_STEREO) {
2189 t->audmode = V4L2_TUNER_MODE_STEREO;
2190 t->rxsubchans = V4L2_TUNER_SUB_STEREO;
2192 if(va.mode & VIDEO_SOUND_LANG2) {
2193 t->audmode = V4L2_TUNER_MODE_LANG1;
2194 t->rxsubchans = V4L2_TUNER_SUB_LANG1
2195 | V4L2_TUNER_SUB_LANG2;
2198 /* FIXME: fill capability+audmode */
2199 mutex_unlock(&btv->lock);
2202 case VIDIOC_S_TUNER:
2204 struct v4l2_tuner *t = arg;
2206 if (UNSET == bttv_tvcards[btv->c.type].tuner)
2210 mutex_lock(&btv->lock);
2211 bttv_call_i2c_clients(btv, VIDIOC_S_TUNER, t);
2212 if (btv->audio_hook) {
2213 struct video_audio va;
2214 memset(&va, 0, sizeof(struct video_audio));
2215 if (t->audmode == V4L2_TUNER_MODE_MONO)
2216 va.mode = VIDEO_SOUND_MONO;
2217 else if (t->audmode == V4L2_TUNER_MODE_STEREO ||
2218 t->audmode == V4L2_TUNER_MODE_LANG1_LANG2)
2219 va.mode = VIDEO_SOUND_STEREO;
2220 else if (t->audmode == V4L2_TUNER_MODE_LANG1)
2221 va.mode = VIDEO_SOUND_LANG1;
2222 else if (t->audmode == V4L2_TUNER_MODE_LANG2)
2223 va.mode = VIDEO_SOUND_LANG2;
2224 btv->audio_hook(btv,&va,1);
2226 mutex_unlock(&btv->lock);
2230 case VIDIOC_G_FREQUENCY:
2232 struct v4l2_frequency *f = arg;
2234 memset(f,0,sizeof(*f));
2235 f->type = V4L2_TUNER_ANALOG_TV;
2236 f->frequency = btv->freq;
2239 case VIDIOC_S_FREQUENCY:
2241 struct v4l2_frequency *f = arg;
2243 if (unlikely(f->tuner != 0))
2245 if (unlikely (f->type != V4L2_TUNER_ANALOG_TV))
2247 mutex_lock(&btv->lock);
2248 btv->freq = f->frequency;
2249 bttv_call_i2c_clients(btv,VIDIOC_S_FREQUENCY,f);
2250 if (btv->has_matchbox && btv->radio_user)
2251 tea5757_set_freq(btv,btv->freq);
2252 mutex_unlock(&btv->lock);
2255 case VIDIOC_LOG_STATUS:
2257 printk(KERN_INFO "bttv%d: ================= START STATUS CARD #%d =================\n", btv->c.nr, btv->c.nr);
2258 bttv_call_i2c_clients(btv, VIDIOC_LOG_STATUS, NULL);
2259 printk(KERN_INFO "bttv%d: ================== END STATUS CARD #%d ==================\n", btv->c.nr, btv->c.nr);
2264 return -ENOIOCTLCMD;
2270 /* Given cropping boundaries b and the scaled width and height of a
2271 single field or frame, which must not exceed hardware limits, this
2272 function adjusts the cropping parameters c. */
2274 bttv_crop_adjust (struct bttv_crop * c,
2275 const struct v4l2_rect * b,
2278 enum v4l2_field field)
2280 __s32 frame_height = height << !V4L2_FIELD_HAS_BOTH(field);
2284 if (width < c->min_scaled_width) {
2285 /* Max. hor. scale factor 16:1. */
2286 c->rect.width = width * 16;
2287 } else if (width > c->max_scaled_width) {
2288 /* Min. hor. scale factor 1:1. */
2289 c->rect.width = width;
2291 max_left = b->left + b->width - width;
2292 max_left = min(max_left, (__s32) MAX_HDELAY);
2293 if (c->rect.left > max_left)
2294 c->rect.left = max_left;
2297 if (height < c->min_scaled_height) {
2298 /* Max. vert. scale factor 16:1, single fields 8:1. */
2299 c->rect.height = height * 16;
2300 } else if (frame_height > c->max_scaled_height) {
2301 /* Min. vert. scale factor 1:1.
2302 Top and height count field lines times two. */
2303 c->rect.height = (frame_height + 1) & ~1;
2305 max_top = b->top + b->height - c->rect.height;
2306 if (c->rect.top > max_top)
2307 c->rect.top = max_top;
2310 bttv_crop_calc_limits(c);
2313 /* Returns an error if scaling to a frame or single field with the given
2314 width and height is not possible with the current cropping parameters
2315 and width aligned according to width_mask. If adjust_size is TRUE the
2316 function may adjust the width and/or height instead, rounding width
2317 to (width + width_bias) & width_mask. If adjust_crop is TRUE it may
2318 also adjust the current cropping parameters to get closer to the
2319 desired image size. */
2321 limit_scaled_size (struct bttv_fh * fh,
2324 enum v4l2_field field,
2325 unsigned int width_mask,
2326 unsigned int width_bias,
2330 struct bttv *btv = fh->btv;
2331 const struct v4l2_rect *b;
2332 struct bttv_crop *c;
2339 BUG_ON((int) width_mask >= 0 ||
2340 width_bias >= (unsigned int) -width_mask);
2342 /* Make sure tvnorm, vbi_end and the current cropping parameters
2343 remain consistent until we're done. */
2344 mutex_lock(&btv->lock);
2346 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
2348 /* Do crop - use current, don't - use default parameters. */
2349 c = &btv->crop[!!fh->do_crop];
2354 && !locked_btres(btv, VIDEO_RESOURCES)) {
2358 /* We cannot scale up. When the scaled image is larger
2359 than crop.rect we adjust the crop.rect as required
2360 by the V4L2 spec, hence cropcap.bounds are our limit. */
2361 max_width = min(b->width, (__s32) MAX_HACTIVE);
2362 max_height = b->height;
2364 /* We cannot capture the same line as video and VBI data.
2365 Note btv->vbi_end is really a minimum, see
2366 bttv_vbi_try_fmt(). */
2367 if (btv->vbi_end > b->top) {
2368 max_height -= btv->vbi_end - b->top;
2370 if (min_height > max_height)
2375 if (btv->vbi_end > c->rect.top)
2378 min_width = c->min_scaled_width;
2379 min_height = c->min_scaled_height;
2380 max_width = c->max_scaled_width;
2381 max_height = c->max_scaled_height;
2386 min_width = (min_width - width_mask - 1) & width_mask;
2387 max_width = max_width & width_mask;
2389 /* Max. scale factor is 16:1 for frames, 8:1 for fields. */
2390 min_height = min_height;
2391 /* Min. scale factor is 1:1. */
2392 max_height >>= !V4L2_FIELD_HAS_BOTH(field);
2395 *width = clamp(*width, min_width, max_width);
2396 *height = clamp(*height, min_height, max_height);
2398 /* Round after clamping to avoid overflow. */
2399 *width = (*width + width_bias) & width_mask;
2402 bttv_crop_adjust(c, b, *width, *height, field);
2404 if (btv->vbi_end > c->rect.top) {
2405 /* Move the crop window out of the way. */
2406 c->rect.top = btv->vbi_end;
2411 if (*width < min_width ||
2412 *height < min_height ||
2413 *width > max_width ||
2414 *height > max_height ||
2415 0 != (*width & ~width_mask))
2419 rc = 0; /* success */
2422 mutex_unlock(&btv->lock);
2427 /* Returns an error if the given overlay window dimensions are not
2428 possible with the current cropping parameters. If adjust_size is
2429 TRUE the function may adjust the window width and/or height
2430 instead, however it always rounds the horizontal position and
2431 width as btcx_align() does. If adjust_crop is TRUE the function
2432 may also adjust the current cropping parameters to get closer
2433 to the desired window size. */
2435 verify_window (struct bttv_fh * fh,
2436 struct v4l2_window * win,
2440 enum v4l2_field field;
2441 unsigned int width_mask;
2444 if (win->w.width < 48 || win->w.height < 32)
2446 if (win->clipcount > 2048)
2451 if (V4L2_FIELD_ANY == field) {
2454 height2 = fh->btv->crop[!!fh->do_crop].rect.height >> 1;
2455 field = (win->w.height > height2)
2456 ? V4L2_FIELD_INTERLACED
2460 case V4L2_FIELD_TOP:
2461 case V4L2_FIELD_BOTTOM:
2462 case V4L2_FIELD_INTERLACED:
2468 /* 4-byte alignment. */
2469 if (NULL == fh->ovfmt)
2472 switch (fh->ovfmt->depth) {
2486 win->w.width -= win->w.left & ~width_mask;
2487 win->w.left = (win->w.left - width_mask - 1) & width_mask;
2489 rc = limit_scaled_size(fh, &win->w.width, &win->w.height,
2491 /* width_bias: round down */ 0,
2492 adjust_size, adjust_crop);
2500 static int setup_window(struct bttv_fh *fh, struct bttv *btv,
2501 struct v4l2_window *win, int fixup)
2503 struct v4l2_clip *clips = NULL;
2504 int n,size,retval = 0;
2506 if (NULL == fh->ovfmt)
2508 if (!(fh->ovfmt->flags & FORMAT_FLAGS_PACKED))
2510 retval = verify_window(fh, win,
2511 /* adjust_size */ fixup,
2512 /* adjust_crop */ fixup);
2516 /* copy clips -- luckily v4l1 + v4l2 are binary
2517 compatible here ...*/
2519 size = sizeof(*clips)*(n+4);
2520 clips = kmalloc(size,GFP_KERNEL);
2524 if (copy_from_user(clips,win->clips,sizeof(struct v4l2_clip)*n)) {
2529 /* clip against screen */
2530 if (NULL != btv->fbuf.base)
2531 n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height,
2533 btcx_sort_clips(clips,n);
2535 /* 4-byte alignments */
2536 switch (fh->ovfmt->depth) {
2539 btcx_align(&win->w, clips, n, 3);
2542 btcx_align(&win->w, clips, n, 1);
2545 /* no alignment fixups needed */
2551 mutex_lock(&fh->cap.lock);
2552 kfree(fh->ov.clips);
2553 fh->ov.clips = clips;
2557 fh->ov.field = win->field;
2558 fh->ov.setup_ok = 1;
2559 btv->init.ov.w.width = win->w.width;
2560 btv->init.ov.w.height = win->w.height;
2561 btv->init.ov.field = win->field;
2563 /* update overlay if needed */
2565 if (check_btres(fh, RESOURCE_OVERLAY)) {
2566 struct bttv_buffer *new;
2568 new = videobuf_alloc(sizeof(*new));
2569 new->crop = btv->crop[!!fh->do_crop].rect;
2570 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2571 retval = bttv_switch_overlay(btv,fh,new);
2573 mutex_unlock(&fh->cap.lock);
2577 /* ----------------------------------------------------------------------- */
2579 static struct videobuf_queue* bttv_queue(struct bttv_fh *fh)
2581 struct videobuf_queue* q = NULL;
2584 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2587 case V4L2_BUF_TYPE_VBI_CAPTURE:
2596 static int bttv_resource(struct bttv_fh *fh)
2601 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2602 res = RESOURCE_VIDEO_STREAM;
2604 case V4L2_BUF_TYPE_VBI_CAPTURE:
2613 static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type)
2615 struct videobuf_queue *q = bttv_queue(fh);
2616 int res = bttv_resource(fh);
2618 if (check_btres(fh,res))
2620 if (videobuf_queue_is_busy(q))
2627 pix_format_set_size (struct v4l2_pix_format * f,
2628 const struct bttv_format * fmt,
2630 unsigned int height)
2635 if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2636 f->bytesperline = width; /* Y plane */
2637 f->sizeimage = (width * height * fmt->depth) >> 3;
2639 f->bytesperline = (width * fmt->depth) >> 3;
2640 f->sizeimage = height * f->bytesperline;
2644 static int bttv_g_fmt(struct bttv_fh *fh, struct v4l2_format *f)
2647 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2648 memset(&f->fmt.pix,0,sizeof(struct v4l2_pix_format));
2649 pix_format_set_size (&f->fmt.pix, fh->fmt,
2650 fh->width, fh->height);
2651 f->fmt.pix.field = fh->cap.field;
2652 f->fmt.pix.pixelformat = fh->fmt->fourcc;
2654 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2655 memset(&f->fmt.win,0,sizeof(struct v4l2_window));
2656 f->fmt.win.w = fh->ov.w;
2657 f->fmt.win.field = fh->ov.field;
2659 case V4L2_BUF_TYPE_VBI_CAPTURE:
2660 bttv_vbi_get_fmt(fh, &f->fmt.vbi);
2667 static int bttv_try_fmt(struct bttv_fh *fh, struct bttv *btv,
2668 struct v4l2_format *f, int adjust_crop)
2671 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2673 const struct bttv_format *fmt;
2674 enum v4l2_field field;
2675 __s32 width, height;
2678 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2682 field = f->fmt.pix.field;
2683 if (V4L2_FIELD_ANY == field) {
2686 height2 = btv->crop[!!fh->do_crop].rect.height >> 1;
2687 field = (f->fmt.pix.height > height2)
2688 ? V4L2_FIELD_INTERLACED
2689 : V4L2_FIELD_BOTTOM;
2691 if (V4L2_FIELD_SEQ_BT == field)
2692 field = V4L2_FIELD_SEQ_TB;
2694 case V4L2_FIELD_TOP:
2695 case V4L2_FIELD_BOTTOM:
2696 case V4L2_FIELD_ALTERNATE:
2697 case V4L2_FIELD_INTERLACED:
2699 case V4L2_FIELD_SEQ_TB:
2700 if (fmt->flags & FORMAT_FLAGS_PLANAR)
2707 width = f->fmt.pix.width;
2708 height = f->fmt.pix.height;
2710 rc = limit_scaled_size(fh, &width, &height, field,
2711 /* width_mask: 4 pixels */ ~3,
2712 /* width_bias: nearest */ 2,
2713 /* adjust_size */ 1,
2718 /* update data for the application */
2719 f->fmt.pix.field = field;
2720 pix_format_set_size(&f->fmt.pix, fmt, width, height);
2724 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2725 return verify_window(fh, &f->fmt.win,
2726 /* adjust_size */ 1,
2727 /* adjust_crop */ 0);
2728 case V4L2_BUF_TYPE_VBI_CAPTURE:
2729 return bttv_vbi_try_fmt(fh, &f->fmt.vbi);
2735 static int bttv_s_fmt(struct bttv_fh *fh, struct bttv *btv,
2736 struct v4l2_format *f)
2741 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2743 const struct bttv_format *fmt;
2745 retval = bttv_switch_type(fh,f->type);
2748 retval = bttv_try_fmt(fh,btv,f, /* adjust_crop */ 1);
2751 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2753 /* update our state informations */
2754 mutex_lock(&fh->cap.lock);
2756 fh->cap.field = f->fmt.pix.field;
2757 fh->cap.last = V4L2_FIELD_NONE;
2758 fh->width = f->fmt.pix.width;
2759 fh->height = f->fmt.pix.height;
2760 btv->init.fmt = fmt;
2761 btv->init.width = f->fmt.pix.width;
2762 btv->init.height = f->fmt.pix.height;
2763 mutex_unlock(&fh->cap.lock);
2767 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2768 if (no_overlay > 0) {
2769 printk ("V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2772 return setup_window(fh, btv, &f->fmt.win, 1);
2773 case V4L2_BUF_TYPE_VBI_CAPTURE:
2774 retval = bttv_switch_type(fh,f->type);
2777 return bttv_vbi_set_fmt(fh, &f->fmt.vbi);
2783 static int bttv_do_ioctl(struct inode *inode, struct file *file,
2784 unsigned int cmd, void *arg)
2786 struct bttv_fh *fh = file->private_data;
2787 struct bttv *btv = fh->btv;
2788 unsigned long flags;
2792 v4l_print_ioctl(btv->c.name, cmd);
2795 bttv_reinit_bt848(btv);
2803 case VIDIOC_S_INPUT:
2804 case VIDIOC_S_TUNER:
2805 case VIDIOC_S_FREQUENCY:
2806 retval = v4l2_prio_check(&btv->prio,&fh->prio);
2813 /* *** v4l1 *** ************************************************ */
2816 struct video_capability *cap = arg;
2818 memset(cap,0,sizeof(*cap));
2819 strcpy(cap->name,btv->video_dev->name);
2820 if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
2822 cap->type = VID_TYPE_TUNER|VID_TYPE_TELETEXT;
2825 cap->type = VID_TYPE_CAPTURE|
2829 if (no_overlay <= 0)
2830 cap->type |= VID_TYPE_OVERLAY;
2832 cap->maxwidth = bttv_tvnorms[btv->tvnorm].swidth;
2833 cap->maxheight = bttv_tvnorms[btv->tvnorm].sheight;
2835 cap->minheight = 32;
2837 cap->channels = bttv_tvcards[btv->c.type].video_inputs;
2838 cap->audios = bttv_tvcards[btv->c.type].audio_inputs;
2844 struct video_picture *pic = arg;
2846 memset(pic,0,sizeof(*pic));
2847 pic->brightness = btv->bright;
2848 pic->contrast = btv->contrast;
2849 pic->hue = btv->hue;
2850 pic->colour = btv->saturation;
2852 pic->depth = fh->fmt->depth;
2853 pic->palette = fh->fmt->palette;
2859 struct video_picture *pic = arg;
2860 const struct bttv_format *fmt;
2862 fmt = format_by_palette(pic->palette);
2865 mutex_lock(&fh->cap.lock);
2866 if (fmt->depth != pic->depth) {
2868 goto fh_unlock_and_return;
2870 if (fmt->flags & FORMAT_FLAGS_RAW) {
2871 /* VIDIOCMCAPTURE uses gbufsize, not RAW_BPL *
2872 RAW_LINES * 2. F1 is stored at offset 0, F2
2873 at buffer size / 2. */
2874 fh->width = RAW_BPL;
2875 fh->height = gbufsize / RAW_BPL;
2876 btv->init.width = RAW_BPL;
2877 btv->init.height = gbufsize / RAW_BPL;
2881 btv->init.ovfmt = fmt;
2882 btv->init.fmt = fmt;
2884 /* dirty hack time: swap bytes for overlay if the
2885 display adaptor is big endian (insmod option) */
2886 if (fmt->palette == VIDEO_PALETTE_RGB555 ||
2887 fmt->palette == VIDEO_PALETTE_RGB565 ||
2888 fmt->palette == VIDEO_PALETTE_RGB32) {
2892 bt848_bright(btv,pic->brightness);
2893 bt848_contrast(btv,pic->contrast);
2894 bt848_hue(btv,pic->hue);
2895 bt848_sat(btv,pic->colour);
2896 mutex_unlock(&fh->cap.lock);
2902 struct video_window *win = arg;
2904 memset(win,0,sizeof(*win));
2905 win->x = fh->ov.w.left;
2906 win->y = fh->ov.w.top;
2907 win->width = fh->ov.w.width;
2908 win->height = fh->ov.w.height;
2913 struct video_window *win = arg;
2914 struct v4l2_window w2;
2916 if (no_overlay > 0) {
2917 printk ("VIDIOCSWIN: no_overlay\n");
2921 w2.field = V4L2_FIELD_ANY;
2924 w2.w.width = win->width;
2925 w2.w.height = win->height;
2926 w2.clipcount = win->clipcount;
2927 w2.clips = (struct v4l2_clip __user *)win->clips;
2928 retval = setup_window(fh, btv, &w2, 0);
2930 /* on v4l1 this ioctl affects the read() size too */
2931 fh->width = fh->ov.w.width;
2932 fh->height = fh->ov.w.height;
2933 btv->init.width = fh->ov.w.width;
2934 btv->init.height = fh->ov.w.height;
2941 struct video_buffer *fbuf = arg;
2943 fbuf->base = btv->fbuf.base;
2944 fbuf->width = btv->fbuf.fmt.width;
2945 fbuf->height = btv->fbuf.fmt.height;
2946 fbuf->bytesperline = btv->fbuf.fmt.bytesperline;
2948 fbuf->depth = fh->ovfmt->depth;
2951 fbuf->depth = ((fbuf->bytesperline<<3)
2961 struct video_buffer *fbuf = arg;
2962 const struct bttv_format *fmt;
2965 if(!capable(CAP_SYS_ADMIN) &&
2966 !capable(CAP_SYS_RAWIO))
2968 end = (unsigned long)fbuf->base +
2969 fbuf->height * fbuf->bytesperline;
2970 mutex_lock(&fh->cap.lock);
2973 switch (fbuf->depth) {
2975 fmt = format_by_palette(VIDEO_PALETTE_HI240);
2978 fmt = format_by_palette(VIDEO_PALETTE_RGB565);
2981 fmt = format_by_palette(VIDEO_PALETTE_RGB24);
2984 fmt = format_by_palette(VIDEO_PALETTE_RGB32);
2988 fmt = format_by_palette(VIDEO_PALETTE_RGB555);
2995 goto fh_unlock_and_return;
2999 btv->init.ovfmt = fmt;
3000 btv->init.fmt = fmt;
3001 btv->fbuf.base = fbuf->base;
3002 btv->fbuf.fmt.width = fbuf->width;
3003 btv->fbuf.fmt.height = fbuf->height;
3004 if (fbuf->bytesperline)
3005 btv->fbuf.fmt.bytesperline = fbuf->bytesperline;
3007 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fbuf->depth/8;
3008 mutex_unlock(&fh->cap.lock);
3013 case VIDIOC_OVERLAY:
3015 struct bttv_buffer *new;
3020 if (NULL == btv->fbuf.base)
3022 if (!fh->ov.setup_ok) {
3023 dprintk("bttv%d: overlay: !setup_ok\n",btv->c.nr);
3028 if (!check_alloc_btres(btv,fh,RESOURCE_OVERLAY))
3031 mutex_lock(&fh->cap.lock);
3033 fh->ov.tvnorm = btv->tvnorm;
3034 new = videobuf_alloc(sizeof(*new));
3035 new->crop = btv->crop[!!fh->do_crop].rect;
3036 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
3042 retval = bttv_switch_overlay(btv,fh,new);
3043 mutex_unlock(&fh->cap.lock);
3049 struct video_mbuf *mbuf = arg;
3052 mutex_lock(&fh->cap.lock);
3053 retval = videobuf_mmap_setup(&fh->cap,gbuffers,gbufsize,
3056 goto fh_unlock_and_return;
3057 memset(mbuf,0,sizeof(*mbuf));
3058 mbuf->frames = gbuffers;
3059 mbuf->size = gbuffers * gbufsize;
3060 for (i = 0; i < gbuffers; i++)
3061 mbuf->offsets[i] = i * gbufsize;
3062 mutex_unlock(&fh->cap.lock);
3065 case VIDIOCMCAPTURE:
3067 struct video_mmap *vm = arg;
3068 struct bttv_buffer *buf;
3069 enum v4l2_field field;
3073 if (vm->frame >= VIDEO_MAX_FRAME)
3076 res = bttv_resource(fh);
3077 if (!check_alloc_btres(btv, fh, res))
3080 mutex_lock(&fh->cap.lock);
3082 buf = (struct bttv_buffer *)fh->cap.bufs[vm->frame];
3084 goto fh_unlock_and_return;
3085 if (0 == buf->vb.baddr)
3086 goto fh_unlock_and_return;
3087 if (buf->vb.state == STATE_QUEUED ||
3088 buf->vb.state == STATE_ACTIVE)
3089 goto fh_unlock_and_return;
3091 height2 = btv->crop[!!fh->do_crop].rect.height >> 1;
3092 field = (vm->height > height2)
3093 ? V4L2_FIELD_INTERLACED
3094 : V4L2_FIELD_BOTTOM;
3095 retval = bttv_prepare_buffer(&fh->cap,btv,buf,
3096 format_by_palette(vm->format),
3097 vm->width,vm->height,field);
3099 goto fh_unlock_and_return;
3100 spin_lock_irqsave(&btv->s_lock,flags);
3101 buffer_queue(&fh->cap,&buf->vb);
3102 spin_unlock_irqrestore(&btv->s_lock,flags);
3103 mutex_unlock(&fh->cap.lock);
3109 struct bttv_buffer *buf;
3111 if (*frame >= VIDEO_MAX_FRAME)
3114 mutex_lock(&fh->cap.lock);
3116 buf = (struct bttv_buffer *)fh->cap.bufs[*frame];
3118 goto fh_unlock_and_return;
3119 retval = videobuf_waiton(&buf->vb,0,1);
3121 goto fh_unlock_and_return;
3122 switch (buf->vb.state) {
3127 videobuf_dma_sync(&fh->cap,&buf->vb.dma);
3128 bttv_dma_free(&fh->cap,btv,buf);
3134 mutex_unlock(&fh->cap.lock);
3139 if (fh->type != V4L2_BUF_TYPE_VBI_CAPTURE) {
3140 retval = bttv_switch_type(fh,V4L2_BUF_TYPE_VBI_CAPTURE);
3148 return v4l_compat_translate_ioctl(inode, file, cmd,
3149 arg, bttv_do_ioctl);
3160 return bttv_common_ioctls(btv,cmd,arg);
3162 /* *** v4l2 *** ************************************************ */
3163 case VIDIOC_QUERYCAP:
3165 struct v4l2_capability *cap = arg;
3169 memset(cap, 0, sizeof (*cap));
3170 strlcpy(cap->driver, "bttv", sizeof (cap->driver));
3171 strlcpy(cap->card, btv->video_dev->name, sizeof (cap->card));
3172 snprintf(cap->bus_info, sizeof (cap->bus_info),
3173 "PCI:%s", pci_name(btv->c.pci));
3174 cap->version = BTTV_VERSION_CODE;
3176 V4L2_CAP_VIDEO_CAPTURE |
3177 V4L2_CAP_VBI_CAPTURE |
3178 V4L2_CAP_READWRITE |
3180 if (no_overlay <= 0)
3181 cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
3183 if (bttv_tvcards[btv->c.type].tuner != UNSET &&
3184 bttv_tvcards[btv->c.type].tuner != TUNER_ABSENT)
3185 cap->capabilities |= V4L2_CAP_TUNER;
3189 case VIDIOC_ENUM_FMT:
3191 struct v4l2_fmtdesc *f = arg;
3192 enum v4l2_buf_type type;
3197 if (V4L2_BUF_TYPE_VBI_CAPTURE == type) {
3202 memset(f,0,sizeof(*f));
3205 f->pixelformat = V4L2_PIX_FMT_GREY;
3206 strcpy(f->description,"vbi data");
3210 /* video capture + overlay */
3212 for (i = 0; i < BTTV_FORMATS; i++) {
3213 if (bttv_formats[i].fourcc != -1)
3215 if ((unsigned int)index == f->index)
3218 if (BTTV_FORMATS == i)
3222 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
3224 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
3225 if (!(bttv_formats[i].flags & FORMAT_FLAGS_PACKED))
3231 memset(f,0,sizeof(*f));
3234 f->pixelformat = bttv_formats[i].fourcc;
3235 strlcpy(f->description,bttv_formats[i].name,sizeof(f->description));
3239 case VIDIOC_TRY_FMT:
3241 struct v4l2_format *f = arg;
3242 return bttv_try_fmt(fh,btv,f, /* adjust_crop */ 0);
3246 struct v4l2_format *f = arg;
3247 return bttv_g_fmt(fh,f);
3251 struct v4l2_format *f = arg;
3252 return bttv_s_fmt(fh,btv,f);
3257 struct v4l2_framebuffer *fb = arg;
3260 fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
3262 fb->fmt.pixelformat = fh->ovfmt->fourcc;
3267 struct v4l2_framebuffer *fb = arg;
3268 const struct bttv_format *fmt;
3270 if(!capable(CAP_SYS_ADMIN) &&
3271 !capable(CAP_SYS_RAWIO))
3275 fmt = format_by_fourcc(fb->fmt.pixelformat);
3278 if (0 == (fmt->flags & FORMAT_FLAGS_PACKED))
3282 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
3283 __s32 width = fb->fmt.width;
3284 __s32 height = fb->fmt.height;
3286 retval = limit_scaled_size(fh, &width, &height,
3287 V4L2_FIELD_INTERLACED,
3288 /* width_mask */ ~3,
3290 /* adjust_size */ 0,
3291 /* adjust_crop */ 0);
3297 mutex_lock(&fh->cap.lock);
3298 btv->fbuf.base = fb->base;
3299 btv->fbuf.fmt.width = fb->fmt.width;
3300 btv->fbuf.fmt.height = fb->fmt.height;
3301 if (0 != fb->fmt.bytesperline)
3302 btv->fbuf.fmt.bytesperline = fb->fmt.bytesperline;
3304 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fmt->depth/8;
3308 btv->init.ovfmt = fmt;
3309 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
3312 fh->ov.w.width = fb->fmt.width;
3313 fh->ov.w.height = fb->fmt.height;
3314 btv->init.ov.w.width = fb->fmt.width;
3315 btv->init.ov.w.height = fb->fmt.height;
3316 kfree(fh->ov.clips);
3317 fh->ov.clips = NULL;
3320 if (check_btres(fh, RESOURCE_OVERLAY)) {
3321 struct bttv_buffer *new;
3323 new = videobuf_alloc(sizeof(*new));
3324 new->crop = btv->crop[!!fh->do_crop].rect;
3325 bttv_overlay_risc(btv,&fh->ov,fh->ovfmt,new);
3326 retval = bttv_switch_overlay(btv,fh,new);
3329 mutex_unlock(&fh->cap.lock);
3333 case VIDIOC_REQBUFS:
3334 return videobuf_reqbufs(bttv_queue(fh),arg);
3336 case VIDIOC_QUERYBUF:
3337 return videobuf_querybuf(bttv_queue(fh),arg);
3341 int res = bttv_resource(fh);
3343 if (!check_alloc_btres(btv, fh, res))
3345 return videobuf_qbuf(bttv_queue(fh),arg);
3349 return videobuf_dqbuf(bttv_queue(fh),arg,
3350 file->f_flags & O_NONBLOCK);
3352 case VIDIOC_STREAMON:
3354 int res = bttv_resource(fh);
3356 if (!check_alloc_btres(btv,fh,res))
3358 return videobuf_streamon(bttv_queue(fh));
3360 case VIDIOC_STREAMOFF:
3362 int res = bttv_resource(fh);
3364 retval = videobuf_streamoff(bttv_queue(fh));
3367 free_btres(btv,fh,res);
3371 case VIDIOC_QUERYCTRL:
3373 struct v4l2_queryctrl *c = arg;
3376 if ((c->id < V4L2_CID_BASE ||
3377 c->id >= V4L2_CID_LASTP1) &&
3378 (c->id < V4L2_CID_PRIVATE_BASE ||
3379 c->id >= V4L2_CID_PRIVATE_LASTP1))
3381 for (i = 0; i < BTTV_CTLS; i++)
3382 if (bttv_ctls[i].id == c->id)
3384 if (i == BTTV_CTLS) {
3389 if (btv->audio_hook && i >= 4 && i <= 8) {
3390 struct video_audio va;
3391 memset(&va,0,sizeof(va));
3392 btv->audio_hook(btv,&va,0);
3393 switch (bttv_ctls[i].id) {
3394 case V4L2_CID_AUDIO_VOLUME:
3395 if (!(va.flags & VIDEO_AUDIO_VOLUME))
3398 case V4L2_CID_AUDIO_BALANCE:
3399 if (!(va.flags & VIDEO_AUDIO_BALANCE))
3402 case V4L2_CID_AUDIO_BASS:
3403 if (!(va.flags & VIDEO_AUDIO_BASS))
3406 case V4L2_CID_AUDIO_TREBLE:
3407 if (!(va.flags & VIDEO_AUDIO_TREBLE))
3415 return get_control(btv,arg);
3417 return set_control(btv,arg);
3420 struct v4l2_streamparm *parm = arg;
3421 struct v4l2_standard s;
3422 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
3424 memset(parm,0,sizeof(*parm));
3425 v4l2_video_std_construct(&s, bttv_tvnorms[btv->tvnorm].v4l2_id,
3426 bttv_tvnorms[btv->tvnorm].name);
3427 parm->parm.capture.timeperframe = s.frameperiod;
3431 case VIDIOC_G_PRIORITY:
3433 enum v4l2_priority *p = arg;
3435 *p = v4l2_prio_max(&btv->prio);
3438 case VIDIOC_S_PRIORITY:
3440 enum v4l2_priority *prio = arg;
3442 return v4l2_prio_change(&btv->prio, &fh->prio, *prio);
3445 case VIDIOC_CROPCAP:
3447 struct v4l2_cropcap *cap = arg;
3448 enum v4l2_buf_type type;
3452 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3453 type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3456 *cap = bttv_tvnorms[btv->tvnorm].cropcap;
3463 struct v4l2_crop * crop = arg;
3465 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3466 crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3469 /* No fh->do_crop = 1; because btv->crop[1] may be
3470 inconsistent with fh->width or fh->height and apps
3471 do not expect a change here. */
3473 crop->c = btv->crop[!!fh->do_crop].rect;
3479 struct v4l2_crop *crop = arg;
3480 const struct v4l2_rect *b;
3487 if (crop->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
3488 crop->type != V4L2_BUF_TYPE_VIDEO_OVERLAY)
3491 retval = v4l2_prio_check(&btv->prio,&fh->prio);
3495 /* Make sure tvnorm, vbi_end and the current cropping
3496 parameters remain consistent until we're done. Note
3497 read() may change vbi_end in check_alloc_btres(). */
3498 mutex_lock(&btv->lock);
3502 if (locked_btres(fh->btv, VIDEO_RESOURCES))
3503 goto btv_unlock_and_return;
3505 b = &bttv_tvnorms[btv->tvnorm].cropcap.bounds;
3508 b_right = b_left + b->width;
3509 b_bottom = b->top + b->height;
3511 b_top = max(b->top, btv->vbi_end);
3512 if (b_top + 32 >= b_bottom)
3513 goto btv_unlock_and_return;
3515 /* Min. scaled size 48 x 32. */
3516 c.rect.left = clamp(crop->c.left, b_left, b_right - 48);
3517 c.rect.left = min(c.rect.left, (__s32) MAX_HDELAY);
3519 c.rect.width = clamp(crop->c.width,
3520 48, b_right - c.rect.left);
3522 c.rect.top = clamp(crop->c.top, b_top, b_bottom - 32);
3523 /* Top and height must be a multiple of two. */
3524 c.rect.top = (c.rect.top + 1) & ~1;
3526 c.rect.height = clamp(crop->c.height,
3527 32, b_bottom - c.rect.top);
3528 c.rect.height = (c.rect.height + 1) & ~1;
3530 bttv_crop_calc_limits(&c);
3534 mutex_unlock(&btv->lock);
3538 mutex_lock(&fh->cap.lock);
3540 if (fh->width < c.min_scaled_width) {
3541 fh->width = c.min_scaled_width;
3542 btv->init.width = c.min_scaled_width;
3543 } else if (fh->width > c.max_scaled_width) {
3544 fh->width = c.max_scaled_width;
3545 btv->init.width = c.max_scaled_width;
3548 if (fh->height < c.min_scaled_height) {
3549 fh->height = c.min_scaled_height;
3550 btv->init.height = c.min_scaled_height;
3551 } else if (fh->height > c.max_scaled_height) {
3552 fh->height = c.max_scaled_height;
3553 btv->init.height = c.max_scaled_height;
3556 mutex_unlock(&fh->cap.lock);
3561 case VIDIOC_ENUMSTD:
3564 case VIDIOC_ENUMINPUT:
3565 case VIDIOC_G_INPUT:
3566 case VIDIOC_S_INPUT:
3567 case VIDIOC_G_TUNER:
3568 case VIDIOC_S_TUNER:
3569 case VIDIOC_G_FREQUENCY:
3570 case VIDIOC_S_FREQUENCY:
3571 case VIDIOC_LOG_STATUS:
3572 return bttv_common_ioctls(btv,cmd,arg);
3575 return -ENOIOCTLCMD;
3579 fh_unlock_and_return:
3580 mutex_unlock(&fh->cap.lock);
3583 btv_unlock_and_return:
3584 mutex_unlock(&btv->lock);
3588 static int bttv_ioctl(struct inode *inode, struct file *file,
3589 unsigned int cmd, unsigned long arg)
3591 struct bttv_fh *fh = file->private_data;
3596 const struct bttv_tvnorm *tvnorm;
3598 tvnorm = fh->vbi_fmt.tvnorm;
3600 if (fh->vbi_fmt.fmt.start[0] != tvnorm->vbistart[0] ||
3601 fh->vbi_fmt.fmt.start[1] != tvnorm->vbistart[1] ||
3602 fh->vbi_fmt.fmt.count[0] != fh->vbi_fmt.fmt.count[1]) {
3603 /* BTTV_VBISIZE cannot express these parameters,
3604 however open() resets the paramters to defaults
3605 and apps shouldn't call BTTV_VBISIZE after
3610 bttv_switch_type(fh,V4L2_BUF_TYPE_VBI_CAPTURE);
3611 return (fh->vbi_fmt.fmt.count[0] * 2
3612 * fh->vbi_fmt.fmt.samples_per_line);
3616 return video_usercopy(inode, file, cmd, arg, bttv_do_ioctl);
3620 static ssize_t bttv_read(struct file *file, char __user *data,
3621 size_t count, loff_t *ppos)
3623 struct bttv_fh *fh = file->private_data;
3626 if (fh->btv->errors)
3627 bttv_reinit_bt848(fh->btv);
3628 dprintk("bttv%d: read count=%d type=%s\n",
3629 fh->btv->c.nr,(int)count,v4l2_type_names[fh->type]);
3632 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
3633 if (!check_alloc_btres(fh->btv, fh, RESOURCE_VIDEO_READ)) {
3634 /* VIDEO_READ in use by another fh,
3635 or VIDEO_STREAM by any fh. */
3638 retval = videobuf_read_one(&fh->cap, data, count, ppos,
3639 file->f_flags & O_NONBLOCK);
3640 free_btres(fh->btv, fh, RESOURCE_VIDEO_READ);
3642 case V4L2_BUF_TYPE_VBI_CAPTURE:
3643 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
3645 retval = videobuf_read_stream(&fh->vbi, data, count, ppos, 1,
3646 file->f_flags & O_NONBLOCK);
3654 static unsigned int bttv_poll(struct file *file, poll_table *wait)
3656 struct bttv_fh *fh = file->private_data;
3657 struct bttv_buffer *buf;
3658 enum v4l2_field field;
3660 if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
3661 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
3663 return videobuf_poll_stream(file, &fh->vbi, wait);
3666 if (check_btres(fh,RESOURCE_VIDEO_STREAM)) {
3667 /* streaming capture */
3668 if (list_empty(&fh->cap.stream))
3670 buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
3672 /* read() capture */
3673 mutex_lock(&fh->cap.lock);
3674 if (NULL == fh->cap.read_buf) {
3675 /* need to capture a new frame */
3676 if (locked_btres(fh->btv,RESOURCE_VIDEO_STREAM)) {
3677 mutex_unlock(&fh->cap.lock);
3680 fh->cap.read_buf = videobuf_alloc(fh->cap.msize);
3681 if (NULL == fh->cap.read_buf) {
3682 mutex_unlock(&fh->cap.lock);
3685 fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
3686 field = videobuf_next_field(&fh->cap);
3687 if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) {
3688 kfree (fh->cap.read_buf);
3689 fh->cap.read_buf = NULL;
3690 mutex_unlock(&fh->cap.lock);
3693 fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
3694 fh->cap.read_off = 0;
3696 mutex_unlock(&fh->cap.lock);
3697 buf = (struct bttv_buffer*)fh->cap.read_buf;
3700 poll_wait(file, &buf->vb.done, wait);
3701 if (buf->vb.state == STATE_DONE ||
3702 buf->vb.state == STATE_ERROR)
3703 return POLLIN|POLLRDNORM;
3707 static int bttv_open(struct inode *inode, struct file *file)
3709 int minor = iminor(inode);
3710 struct bttv *btv = NULL;
3712 enum v4l2_buf_type type = 0;
3715 dprintk(KERN_DEBUG "bttv: open minor=%d\n",minor);
3717 for (i = 0; i < bttv_num; i++) {
3718 if (bttvs[i].video_dev &&
3719 bttvs[i].video_dev->minor == minor) {
3721 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
3724 if (bttvs[i].vbi_dev &&
3725 bttvs[i].vbi_dev->minor == minor) {
3727 type = V4L2_BUF_TYPE_VBI_CAPTURE;
3734 dprintk(KERN_DEBUG "bttv%d: open called (type=%s)\n",
3735 btv->c.nr,v4l2_type_names[type]);
3737 /* allocate per filehandle data */
3738 fh = kmalloc(sizeof(*fh),GFP_KERNEL);
3741 file->private_data = fh;
3744 fh->ov.setup_ok = 0;
3745 v4l2_prio_open(&btv->prio,&fh->prio);
3747 videobuf_queue_init(&fh->cap, &bttv_video_qops,
3748 btv->c.pci, &btv->s_lock,
3749 V4L2_BUF_TYPE_VIDEO_CAPTURE,
3750 V4L2_FIELD_INTERLACED,
3751 sizeof(struct bttv_buffer),
3753 videobuf_queue_init(&fh->vbi, &bttv_vbi_qops,
3754 btv->c.pci, &btv->s_lock,
3755 V4L2_BUF_TYPE_VBI_CAPTURE,
3757 sizeof(struct bttv_buffer),
3759 i2c_vidiocschan(btv);
3763 /* The V4L2 spec requires one global set of cropping parameters
3764 which only change on request. These are stored in btv->crop[1].
3765 However for compatibility with V4L apps and cropping unaware
3766 V4L2 apps we now reset the cropping parameters as seen through
3767 this fh, which is to say VIDIOC_G_CROP and scaling limit checks
3768 will use btv->crop[0], the default cropping parameters for the
3769 current video standard, and VIDIOC_S_FMT will not implicitely
3770 change the cropping parameters until VIDIOC_S_CROP has been
3772 fh->do_crop = !reset_crop; /* module parameter */
3774 /* Likewise there should be one global set of VBI capture
3775 parameters, but for compatibility with V4L apps and earlier
3776 driver versions each fh has its own parameters. */
3777 bttv_vbi_fmt_reset(&fh->vbi_fmt, btv->tvnorm);
3779 bttv_field_count(btv);
3783 static int bttv_release(struct inode *inode, struct file *file)
3785 struct bttv_fh *fh = file->private_data;
3786 struct bttv *btv = fh->btv;
3788 /* turn off overlay */
3789 if (check_btres(fh, RESOURCE_OVERLAY))
3790 bttv_switch_overlay(btv,fh,NULL);
3792 /* stop video capture */
3793 if (check_btres(fh, RESOURCE_VIDEO_STREAM)) {
3794 videobuf_streamoff(&fh->cap);
3795 free_btres(btv,fh,RESOURCE_VIDEO_STREAM);
3797 if (fh->cap.read_buf) {
3798 buffer_release(&fh->cap,fh->cap.read_buf);
3799 kfree(fh->cap.read_buf);
3801 if (check_btres(fh, RESOURCE_VIDEO_READ)) {
3802 free_btres(btv, fh, RESOURCE_VIDEO_READ);
3805 /* stop vbi capture */
3806 if (check_btres(fh, RESOURCE_VBI)) {
3807 if (fh->vbi.streaming)
3808 videobuf_streamoff(&fh->vbi);
3809 if (fh->vbi.reading)
3810 videobuf_read_stop(&fh->vbi);
3811 free_btres(btv,fh,RESOURCE_VBI);
3815 videobuf_mmap_free(&fh->cap);
3816 videobuf_mmap_free(&fh->vbi);
3817 v4l2_prio_close(&btv->prio,&fh->prio);
3818 file->private_data = NULL;
3822 bttv_field_count(btv);
3827 bttv_mmap(struct file *file, struct vm_area_struct *vma)
3829 struct bttv_fh *fh = file->private_data;
3831 dprintk("bttv%d: mmap type=%s 0x%lx+%ld\n",
3832 fh->btv->c.nr, v4l2_type_names[fh->type],
3833 vma->vm_start, vma->vm_end - vma->vm_start);
3834 return videobuf_mmap_mapper(bttv_queue(fh),vma);
3837 static const struct file_operations bttv_fops =
3839 .owner = THIS_MODULE,
3841 .release = bttv_release,
3842 .ioctl = bttv_ioctl,
3843 .compat_ioctl = v4l_compat_ioctl32,
3844 .llseek = no_llseek,
3850 static struct video_device bttv_video_template =
3853 .type = VID_TYPE_CAPTURE|VID_TYPE_TUNER|
3854 VID_TYPE_CLIPPING|VID_TYPE_SCALES,
3855 .hardware = VID_HARDWARE_BT848,
3860 static struct video_device bttv_vbi_template =
3862 .name = "bt848/878 vbi",
3863 .type = VID_TYPE_TUNER|VID_TYPE_TELETEXT,
3864 .hardware = VID_HARDWARE_BT848,
3869 /* ----------------------------------------------------------------------- */
3870 /* radio interface */
3872 static int radio_open(struct inode *inode, struct file *file)
3874 int minor = iminor(inode);
3875 struct bttv *btv = NULL;
3878 dprintk("bttv: open minor=%d\n",minor);
3880 for (i = 0; i < bttv_num; i++) {
3881 if (bttvs[i].radio_dev->minor == minor) {
3889 dprintk("bttv%d: open called (radio)\n",btv->c.nr);
3890 mutex_lock(&btv->lock);
3894 file->private_data = btv;
3896 bttv_call_i2c_clients(btv,AUDC_SET_RADIO,NULL);
3897 audio_input(btv,TVAUDIO_INPUT_RADIO);
3899 mutex_unlock(&btv->lock);
3903 static int radio_release(struct inode *inode, struct file *file)
3905 struct bttv *btv = file->private_data;
3906 struct rds_command cmd;
3910 bttv_call_i2c_clients(btv, RDS_CMD_CLOSE, &cmd);
3915 static int radio_do_ioctl(struct inode *inode, struct file *file,
3916 unsigned int cmd, void *arg)
3918 struct bttv *btv = file->private_data;
3923 struct video_capability *cap = arg;
3925 memset(cap,0,sizeof(*cap));
3926 strcpy(cap->name,btv->radio_dev->name);
3927 cap->type = VID_TYPE_TUNER;
3935 struct video_tuner *v = arg;
3939 memset(v,0,sizeof(*v));
3940 strcpy(v->name, "Radio");
3941 bttv_call_i2c_clients(btv,cmd,v);
3953 case VIDIOC_LOG_STATUS:
3954 return bttv_common_ioctls(btv,cmd,arg);
3957 return -ENOIOCTLCMD;
3962 static int radio_ioctl(struct inode *inode, struct file *file,
3963 unsigned int cmd, unsigned long arg)
3965 return video_usercopy(inode, file, cmd, arg, radio_do_ioctl);
3968 static ssize_t radio_read(struct file *file, char __user *data,
3969 size_t count, loff_t *ppos)
3971 struct bttv *btv = file->private_data;
3972 struct rds_command cmd;
3973 cmd.block_count = count/3;
3975 cmd.instance = file;
3976 cmd.result = -ENODEV;
3978 bttv_call_i2c_clients(btv, RDS_CMD_READ, &cmd);
3983 static unsigned int radio_poll(struct file *file, poll_table *wait)
3985 struct bttv *btv = file->private_data;
3986 struct rds_command cmd;
3987 cmd.instance = file;
3988 cmd.event_list = wait;
3989 cmd.result = -ENODEV;
3990 bttv_call_i2c_clients(btv, RDS_CMD_POLL, &cmd);
3995 static const struct file_operations radio_fops =
3997 .owner = THIS_MODULE,
4000 .release = radio_release,
4001 .ioctl = radio_ioctl,
4002 .llseek = no_llseek,
4006 static struct video_device radio_template =
4008 .name = "bt848/878 radio",
4009 .type = VID_TYPE_TUNER,
4010 .hardware = VID_HARDWARE_BT848,
4011 .fops = &radio_fops,
4015 /* ----------------------------------------------------------------------- */
4016 /* some debug code */
4018 static int bttv_risc_decode(u32 risc)
4020 static char *instr[16] = {
4021 [ BT848_RISC_WRITE >> 28 ] = "write",
4022 [ BT848_RISC_SKIP >> 28 ] = "skip",
4023 [ BT848_RISC_WRITEC >> 28 ] = "writec",
4024 [ BT848_RISC_JUMP >> 28 ] = "jump",
4025 [ BT848_RISC_SYNC >> 28 ] = "sync",
4026 [ BT848_RISC_WRITE123 >> 28 ] = "write123",
4027 [ BT848_RISC_SKIP123 >> 28 ] = "skip123",
4028 [ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
4030 static int incr[16] = {
4031 [ BT848_RISC_WRITE >> 28 ] = 2,
4032 [ BT848_RISC_JUMP >> 28 ] = 2,
4033 [ BT848_RISC_SYNC >> 28 ] = 2,
4034 [ BT848_RISC_WRITE123 >> 28 ] = 5,
4035 [ BT848_RISC_SKIP123 >> 28 ] = 2,
4036 [ BT848_RISC_WRITE1S23 >> 28 ] = 3,
4038 static char *bits[] = {
4039 "be0", "be1", "be2", "be3/resync",
4040 "set0", "set1", "set2", "set3",
4041 "clr0", "clr1", "clr2", "clr3",
4042 "irq", "res", "eol", "sol",
4046 printk("0x%08x [ %s", risc,
4047 instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
4048 for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
4049 if (risc & (1 << (i + 12)))
4050 printk(" %s",bits[i]);
4051 printk(" count=%d ]\n", risc & 0xfff);
4052 return incr[risc >> 28] ? incr[risc >> 28] : 1;
4055 static void bttv_risc_disasm(struct bttv *btv,
4056 struct btcx_riscmem *risc)
4060 printk("%s: risc disasm: %p [dma=0x%08lx]\n",
4061 btv->c.name, risc->cpu, (unsigned long)risc->dma);
4062 for (i = 0; i < (risc->size >> 2); i += n) {
4063 printk("%s: 0x%lx: ", btv->c.name,
4064 (unsigned long)(risc->dma + (i<<2)));
4065 n = bttv_risc_decode(risc->cpu[i]);
4066 for (j = 1; j < n; j++)
4067 printk("%s: 0x%lx: 0x%08x [ arg #%d ]\n",
4068 btv->c.name, (unsigned long)(risc->dma + ((i+j)<<2)),
4070 if (0 == risc->cpu[i])
4075 static void bttv_print_riscaddr(struct bttv *btv)
4077 printk(" main: %08Lx\n",
4078 (unsigned long long)btv->main.dma);
4079 printk(" vbi : o=%08Lx e=%08Lx\n",
4080 btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
4081 btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
4082 printk(" cap : o=%08Lx e=%08Lx\n",
4083 btv->curr.top ? (unsigned long long)btv->curr.top->top.dma : 0,
4084 btv->curr.bottom ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
4085 printk(" scr : o=%08Lx e=%08Lx\n",
4086 btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
4087 btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
4088 bttv_risc_disasm(btv, &btv->main);
4091 /* ----------------------------------------------------------------------- */
4094 static char *irq_name[] = {
4095 "FMTCHG", // format change detected (525 vs. 625)
4096 "VSYNC", // vertical sync (new field)
4097 "HSYNC", // horizontal sync
4098 "OFLOW", // chroma/luma AGC overflow
4099 "HLOCK", // horizontal lock changed
4100 "VPRES", // video presence changed
4102 "I2CDONE", // hw irc operation finished
4103 "GPINT", // gpio port triggered irq
4105 "RISCI", // risc instruction triggered irq
4106 "FBUS", // pixel data fifo dropped data (high pci bus latencies)
4107 "FTRGT", // pixel data fifo overrun
4108 "FDSR", // fifo data stream resyncronisation
4109 "PPERR", // parity error (data transfer)
4110 "RIPERR", // parity error (read risc instructions)
4111 "PABORT", // pci abort
4112 "OCERR", // risc instruction error
4113 "SCERR", // syncronisation error
4116 static void bttv_print_irqbits(u32 print, u32 mark)
4121 for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
4122 if (print & (1 << i))
4123 printk(" %s",irq_name[i]);
4124 if (mark & (1 << i))
4129 static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
4131 printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
4133 (unsigned long)btv->main.dma,
4134 (unsigned long)btv->main.cpu[RISC_SLOT_O_VBI+1],
4135 (unsigned long)btv->main.cpu[RISC_SLOT_O_FIELD+1],
4138 if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) {
4139 printk("bttv%d: Oh, there (temporarely?) is no input signal. "
4140 "Ok, then this is harmless, don't worry ;)\n",
4144 printk("bttv%d: Uhm. Looks like we have unusual high IRQ latencies.\n",
4146 printk("bttv%d: Lets try to catch the culpit red-handed ...\n",
4152 bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set)
4154 struct bttv_buffer *item;
4156 memset(set,0,sizeof(*set));
4158 /* capture request ? */
4159 if (!list_empty(&btv->capture)) {
4161 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
4162 if (V4L2_FIELD_HAS_TOP(item->vb.field))
4164 if (V4L2_FIELD_HAS_BOTTOM(item->vb.field))
4167 /* capture request for other field ? */
4168 if (!V4L2_FIELD_HAS_BOTH(item->vb.field) &&
4169 (item->vb.queue.next != &btv->capture)) {
4170 item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue);
4171 if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) {
4172 if (NULL == set->top &&
4173 V4L2_FIELD_TOP == item->vb.field) {
4176 if (NULL == set->bottom &&
4177 V4L2_FIELD_BOTTOM == item->vb.field) {
4180 if (NULL != set->top && NULL != set->bottom)
4186 /* screen overlay ? */
4187 if (NULL != btv->screen) {
4188 if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) {
4189 if (NULL == set->top && NULL == set->bottom) {
4190 set->top = btv->screen;
4191 set->bottom = btv->screen;
4194 if (V4L2_FIELD_TOP == btv->screen->vb.field &&
4196 set->top = btv->screen;
4198 if (V4L2_FIELD_BOTTOM == btv->screen->vb.field &&
4199 NULL == set->bottom) {
4200 set->bottom = btv->screen;
4205 dprintk("bttv%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
4206 btv->c.nr,set->top, set->bottom,
4207 btv->screen,set->frame_irq,set->top_irq);
4212 bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
4213 struct bttv_buffer_set *curr, unsigned int state)
4217 do_gettimeofday(&ts);
4219 if (wakeup->top == wakeup->bottom) {
4220 if (NULL != wakeup->top && curr->top != wakeup->top) {
4222 printk("bttv%d: wakeup: both=%p\n",btv->c.nr,wakeup->top);
4223 wakeup->top->vb.ts = ts;
4224 wakeup->top->vb.field_count = btv->field_count;
4225 wakeup->top->vb.state = state;
4226 wake_up(&wakeup->top->vb.done);
4229 if (NULL != wakeup->top && curr->top != wakeup->top) {
4231 printk("bttv%d: wakeup: top=%p\n",btv->c.nr,wakeup->top);
4232 wakeup->top->vb.ts = ts;
4233 wakeup->top->vb.field_count = btv->field_count;
4234 wakeup->top->vb.state = state;
4235 wake_up(&wakeup->top->vb.done);
4237 if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
4239 printk("bttv%d: wakeup: bottom=%p\n",btv->c.nr,wakeup->bottom);
4240 wakeup->bottom->vb.ts = ts;
4241 wakeup->bottom->vb.field_count = btv->field_count;
4242 wakeup->bottom->vb.state = state;
4243 wake_up(&wakeup->bottom->vb.done);
4249 bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
4257 do_gettimeofday(&ts);
4259 wakeup->vb.field_count = btv->field_count;
4260 wakeup->vb.state = state;
4261 wake_up(&wakeup->vb.done);
4264 static void bttv_irq_timeout(unsigned long data)
4266 struct bttv *btv = (struct bttv *)data;
4267 struct bttv_buffer_set old,new;
4268 struct bttv_buffer *ovbi;
4269 struct bttv_buffer *item;
4270 unsigned long flags;
4273 printk(KERN_INFO "bttv%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
4274 btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
4275 btread(BT848_RISC_COUNT));
4276 bttv_print_irqbits(btread(BT848_INT_STAT),0);
4280 spin_lock_irqsave(&btv->s_lock,flags);
4282 /* deactivate stuff */
4283 memset(&new,0,sizeof(new));
4289 bttv_buffer_activate_video(btv, &new);
4290 bttv_buffer_activate_vbi(btv, NULL);
4291 bttv_set_dma(btv, 0);
4294 bttv_irq_wakeup_video(btv, &old, &new, STATE_ERROR);
4295 bttv_irq_wakeup_vbi(btv, ovbi, STATE_ERROR);
4297 /* cancel all outstanding capture / vbi requests */
4298 while (!list_empty(&btv->capture)) {
4299 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
4300 list_del(&item->vb.queue);
4301 item->vb.state = STATE_ERROR;
4302 wake_up(&item->vb.done);
4304 while (!list_empty(&btv->vcapture)) {
4305 item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
4306 list_del(&item->vb.queue);
4307 item->vb.state = STATE_ERROR;
4308 wake_up(&item->vb.done);
4312 spin_unlock_irqrestore(&btv->s_lock,flags);
4316 bttv_irq_wakeup_top(struct bttv *btv)
4318 struct bttv_buffer *wakeup = btv->curr.top;
4323 spin_lock(&btv->s_lock);
4324 btv->curr.top_irq = 0;
4325 btv->curr.top = NULL;
4326 bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
4328 do_gettimeofday(&wakeup->vb.ts);
4329 wakeup->vb.field_count = btv->field_count;
4330 wakeup->vb.state = STATE_DONE;
4331 wake_up(&wakeup->vb.done);
4332 spin_unlock(&btv->s_lock);
4335 static inline int is_active(struct btcx_riscmem *risc, u32 rc)
4339 if (rc > risc->dma + risc->size)
4345 bttv_irq_switch_video(struct bttv *btv)
4347 struct bttv_buffer_set new;
4348 struct bttv_buffer_set old;
4351 spin_lock(&btv->s_lock);
4353 /* new buffer set */
4354 bttv_irq_next_video(btv, &new);
4355 rc = btread(BT848_RISC_COUNT);
4356 if ((btv->curr.top && is_active(&btv->curr.top->top, rc)) ||
4357 (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) {
4360 bttv_irq_debug_low_latency(btv, rc);
4361 spin_unlock(&btv->s_lock);
4368 btv->loop_irq &= ~1;
4369 bttv_buffer_activate_video(btv, &new);
4370 bttv_set_dma(btv, 0);
4373 if (UNSET != btv->new_input) {
4374 video_mux(btv,btv->new_input);
4375 btv->new_input = UNSET;
4378 /* wake up finished buffers */
4379 bttv_irq_wakeup_video(btv, &old, &new, STATE_DONE);
4380 spin_unlock(&btv->s_lock);
4384 bttv_irq_switch_vbi(struct bttv *btv)
4386 struct bttv_buffer *new = NULL;
4387 struct bttv_buffer *old;
4390 spin_lock(&btv->s_lock);
4392 if (!list_empty(&btv->vcapture))
4393 new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
4396 rc = btread(BT848_RISC_COUNT);
4397 if (NULL != old && (is_active(&old->top, rc) ||
4398 is_active(&old->bottom, rc))) {
4401 bttv_irq_debug_low_latency(btv, rc);
4402 spin_unlock(&btv->s_lock);
4408 btv->loop_irq &= ~4;
4409 bttv_buffer_activate_vbi(btv, new);
4410 bttv_set_dma(btv, 0);
4412 bttv_irq_wakeup_vbi(btv, old, STATE_DONE);
4413 spin_unlock(&btv->s_lock);
4416 static irqreturn_t bttv_irq(int irq, void *dev_id)
4424 btv=(struct bttv *)dev_id;
4426 if (btv->custom_irq)
4427 handled = btv->custom_irq(btv);
4431 /* get/clear interrupt status bits */
4432 stat=btread(BT848_INT_STAT);
4433 astat=stat&btread(BT848_INT_MASK);
4437 btwrite(stat,BT848_INT_STAT);
4439 /* get device status bits */
4440 dstat=btread(BT848_DSTATUS);
4443 printk(KERN_DEBUG "bttv%d: irq loop=%d fc=%d "
4444 "riscs=%x, riscc=%08x, ",
4445 btv->c.nr, count, btv->field_count,
4446 stat>>28, btread(BT848_RISC_COUNT));
4447 bttv_print_irqbits(stat,astat);
4448 if (stat & BT848_INT_HLOCK)
4449 printk(" HLOC => %s", (dstat & BT848_DSTATUS_HLOC)
4451 if (stat & BT848_INT_VPRES)
4452 printk(" PRES => %s", (dstat & BT848_DSTATUS_PRES)
4454 if (stat & BT848_INT_FMTCHG)
4455 printk(" NUML => %s", (dstat & BT848_DSTATUS_NUML)
4460 if (astat&BT848_INT_VSYNC)
4463 if ((astat & BT848_INT_GPINT) && btv->remote) {
4464 wake_up(&btv->gpioq);
4465 bttv_input_irq(btv);
4468 if (astat & BT848_INT_I2CDONE) {
4469 btv->i2c_done = stat;
4470 wake_up(&btv->i2c_queue);
4473 if ((astat & BT848_INT_RISCI) && (stat & (4<<28)))
4474 bttv_irq_switch_vbi(btv);
4476 if ((astat & BT848_INT_RISCI) && (stat & (2<<28)))
4477 bttv_irq_wakeup_top(btv);
4479 if ((astat & BT848_INT_RISCI) && (stat & (1<<28)))
4480 bttv_irq_switch_video(btv);
4482 if ((astat & BT848_INT_HLOCK) && btv->opt_automute)
4483 audio_mute(btv, btv->mute); /* trigger automute */
4485 if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
4486 printk(KERN_INFO "bttv%d: %s%s @ %08x,",btv->c.nr,
4487 (astat & BT848_INT_SCERR) ? "SCERR" : "",
4488 (astat & BT848_INT_OCERR) ? "OCERR" : "",
4489 btread(BT848_RISC_COUNT));
4490 bttv_print_irqbits(stat,astat);
4493 bttv_print_riscaddr(btv);
4495 if (fdsr && astat & BT848_INT_FDSR) {
4496 printk(KERN_INFO "bttv%d: FDSR @ %08x\n",
4497 btv->c.nr,btread(BT848_RISC_COUNT));
4499 bttv_print_riscaddr(btv);
4505 if (count > 8 || !(astat & BT848_INT_GPINT)) {
4506 btwrite(0, BT848_INT_MASK);
4509 "bttv%d: IRQ lockup, cleared int mask [", btv->c.nr);
4512 "bttv%d: IRQ lockup, clearing GPINT from int mask [", btv->c.nr);
4514 btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT),
4518 bttv_print_irqbits(stat,astat);
4526 return IRQ_RETVAL(handled);
4530 /* ----------------------------------------------------------------------- */
4531 /* initialitation */
4533 static struct video_device *vdev_init(struct bttv *btv,
4534 struct video_device *template,
4537 struct video_device *vfd;
4539 vfd = video_device_alloc();
4544 vfd->dev = &btv->c.pci->dev;
4545 vfd->release = video_device_release;
4546 snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
4547 btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
4548 type, bttv_tvcards[btv->c.type].name);
4552 static void bttv_unregister_video(struct bttv *btv)
4554 if (btv->video_dev) {
4555 if (-1 != btv->video_dev->minor)
4556 video_unregister_device(btv->video_dev);
4558 video_device_release(btv->video_dev);
4559 btv->video_dev = NULL;
4562 if (-1 != btv->vbi_dev->minor)
4563 video_unregister_device(btv->vbi_dev);
4565 video_device_release(btv->vbi_dev);
4566 btv->vbi_dev = NULL;
4568 if (btv->radio_dev) {
4569 if (-1 != btv->radio_dev->minor)
4570 video_unregister_device(btv->radio_dev);
4572 video_device_release(btv->radio_dev);
4573 btv->radio_dev = NULL;
4577 /* register video4linux devices */
4578 static int __devinit bttv_register_video(struct bttv *btv)
4580 if (no_overlay <= 0) {
4581 bttv_video_template.type |= VID_TYPE_OVERLAY;
4583 printk("bttv: Overlay support disabled.\n");
4587 btv->video_dev = vdev_init(btv, &bttv_video_template, "video");
4588 if (NULL == btv->video_dev)
4590 if (video_register_device(btv->video_dev,VFL_TYPE_GRABBER,video_nr)<0)
4592 printk(KERN_INFO "bttv%d: registered device video%d\n",
4593 btv->c.nr,btv->video_dev->minor & 0x1f);
4594 if (class_device_create_file(&btv->video_dev->class_dev,
4595 &class_device_attr_card)<0) {
4596 printk(KERN_ERR "bttv%d: class_device_create_file 'card' "
4597 "failed\n", btv->c.nr);
4602 btv->vbi_dev = vdev_init(btv, &bttv_vbi_template, "vbi");
4603 if (NULL == btv->vbi_dev)
4605 if (video_register_device(btv->vbi_dev,VFL_TYPE_VBI,vbi_nr)<0)
4607 printk(KERN_INFO "bttv%d: registered device vbi%d\n",
4608 btv->c.nr,btv->vbi_dev->minor & 0x1f);
4610 if (!btv->has_radio)
4613 btv->radio_dev = vdev_init(btv, &radio_template, "radio");
4614 if (NULL == btv->radio_dev)
4616 if (video_register_device(btv->radio_dev, VFL_TYPE_RADIO,radio_nr)<0)
4618 printk(KERN_INFO "bttv%d: registered device radio%d\n",
4619 btv->c.nr,btv->radio_dev->minor & 0x1f);
4625 bttv_unregister_video(btv);
4630 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
4631 /* response on cards with no firmware is not enabled by OF */
4632 static void pci_set_command(struct pci_dev *dev)
4634 #if defined(__powerpc__)
4637 pci_read_config_dword(dev, PCI_COMMAND, &cmd);
4638 cmd = (cmd | PCI_COMMAND_MEMORY );
4639 pci_write_config_dword(dev, PCI_COMMAND, cmd);
4643 static int __devinit bttv_probe(struct pci_dev *dev,
4644 const struct pci_device_id *pci_id)
4650 if (bttv_num == BTTV_MAX)
4652 printk(KERN_INFO "bttv: Bt8xx card found (%d).\n", bttv_num);
4653 btv=&bttvs[bttv_num];
4654 memset(btv,0,sizeof(*btv));
4655 btv->c.nr = bttv_num;
4656 sprintf(btv->c.name,"bttv%d",btv->c.nr);
4658 /* initialize structs / fill in defaults */
4659 mutex_init(&btv->lock);
4660 spin_lock_init(&btv->s_lock);
4661 spin_lock_init(&btv->gpio_lock);
4662 init_waitqueue_head(&btv->gpioq);
4663 init_waitqueue_head(&btv->i2c_queue);
4664 INIT_LIST_HEAD(&btv->c.subs);
4665 INIT_LIST_HEAD(&btv->capture);
4666 INIT_LIST_HEAD(&btv->vcapture);
4667 v4l2_prio_init(&btv->prio);
4669 init_timer(&btv->timeout);
4670 btv->timeout.function = bttv_irq_timeout;
4671 btv->timeout.data = (unsigned long)btv;
4674 btv->tuner_type = UNSET;
4675 btv->new_input = UNSET;
4676 btv->has_radio=radio[btv->c.nr];
4678 /* pci stuff (init, get irq/mmio, ... */
4680 btv->id = dev->device;
4681 if (pci_enable_device(dev)) {
4682 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4686 if (pci_set_dma_mask(dev, DMA_32BIT_MASK)) {
4687 printk(KERN_WARNING "bttv%d: No suitable DMA available.\n",
4691 if (!request_mem_region(pci_resource_start(dev,0),
4692 pci_resource_len(dev,0),
4694 printk(KERN_WARNING "bttv%d: can't request iomem (0x%llx).\n",
4696 (unsigned long long)pci_resource_start(dev,0));
4699 pci_set_master(dev);
4700 pci_set_command(dev);
4701 pci_set_drvdata(dev,btv);
4703 pci_read_config_byte(dev, PCI_CLASS_REVISION, &btv->revision);
4704 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
4705 printk(KERN_INFO "bttv%d: Bt%d (rev %d) at %s, ",
4706 bttv_num,btv->id, btv->revision, pci_name(dev));
4707 printk("irq: %d, latency: %d, mmio: 0x%llx\n",
4708 btv->c.pci->irq, lat,
4709 (unsigned long long)pci_resource_start(dev,0));
4712 btv->bt848_mmio = ioremap(pci_resource_start(dev, 0), 0x1000);
4713 if (NULL == btv->bt848_mmio) {
4714 printk("bttv%d: ioremap() failed\n", btv->c.nr);
4722 /* disable irqs, register irq handler */
4723 btwrite(0, BT848_INT_MASK);
4724 result = request_irq(btv->c.pci->irq, bttv_irq,
4725 IRQF_SHARED | IRQF_DISABLED,btv->c.name,(void *)btv);
4727 printk(KERN_ERR "bttv%d: can't get IRQ %d\n",
4728 bttv_num,btv->c.pci->irq);
4732 if (0 != bttv_handle_chipset(btv)) {
4737 /* init options from insmod args */
4738 btv->opt_combfilter = combfilter;
4739 btv->opt_lumafilter = lumafilter;
4740 btv->opt_automute = automute;
4741 btv->opt_chroma_agc = chroma_agc;
4742 btv->opt_adc_crush = adc_crush;
4743 btv->opt_vcr_hack = vcr_hack;
4744 btv->opt_whitecrush_upper = whitecrush_upper;
4745 btv->opt_whitecrush_lower = whitecrush_lower;
4746 btv->opt_uv_ratio = uv_ratio;
4747 btv->opt_full_luma_range = full_luma_range;
4748 btv->opt_coring = coring;
4750 /* fill struct bttv with some useful defaults */
4751 btv->init.btv = btv;
4752 btv->init.ov.w.width = 320;
4753 btv->init.ov.w.height = 240;
4754 btv->init.fmt = format_by_palette(VIDEO_PALETTE_RGB24);
4755 btv->init.width = 320;
4756 btv->init.height = 240;
4759 /* initialize hardware */
4761 bttv_gpio_tracking(btv,"pre-init");
4763 bttv_risc_init_main(btv);
4767 btwrite(0x00, BT848_GPIO_REG_INP);
4768 btwrite(0x00, BT848_GPIO_OUT_EN);
4770 bttv_gpio_tracking(btv,"init");
4772 /* needs to be done before i2c is registered */
4773 bttv_init_card1(btv);
4775 /* register i2c + gpio */
4778 /* some card-specific stuff (needs working i2c) */
4779 bttv_init_card2(btv);
4782 /* register video4linux + input */
4783 if (!bttv_tvcards[btv->c.type].no_video) {
4784 bttv_register_video(btv);
4785 bt848_bright(btv,32768);
4786 bt848_contrast(btv,32768);
4787 bt848_hue(btv,32768);
4788 bt848_sat(btv,32768);
4790 set_input(btv, 0, btv->tvnorm);
4791 bttv_crop_reset(&btv->crop[0], btv->tvnorm);
4792 btv->crop[1] = btv->crop[0]; /* current = default */
4793 disclaim_vbi_lines(btv);
4794 disclaim_video_lines(btv);
4797 /* add subdevices and autoload dvb-bt8xx if needed */
4798 if (bttv_tvcards[btv->c.type].has_dvb) {
4799 bttv_sub_add_device(&btv->c, "dvb");
4800 request_modules(btv);
4803 bttv_input_init(btv);
4805 /* everything is fine */
4810 free_irq(btv->c.pci->irq,btv);
4813 if (btv->bt848_mmio)
4814 iounmap(btv->bt848_mmio);
4815 release_mem_region(pci_resource_start(btv->c.pci,0),
4816 pci_resource_len(btv->c.pci,0));
4817 pci_set_drvdata(dev,NULL);
4821 static void __devexit bttv_remove(struct pci_dev *pci_dev)
4823 struct bttv *btv = pci_get_drvdata(pci_dev);
4826 printk("bttv%d: unloading\n",btv->c.nr);
4828 /* shutdown everything (DMA+IRQs) */
4829 btand(~15, BT848_GPIO_DMA_CTL);
4830 btwrite(0, BT848_INT_MASK);
4831 btwrite(~0x0, BT848_INT_STAT);
4832 btwrite(0x0, BT848_GPIO_OUT_EN);
4834 bttv_gpio_tracking(btv,"cleanup");
4836 /* tell gpio modules we are leaving ... */
4838 wake_up(&btv->gpioq);
4839 bttv_input_fini(btv);
4840 bttv_sub_del_devices(&btv->c);
4842 /* unregister i2c_bus + input */
4845 /* unregister video4linux */
4846 bttv_unregister_video(btv);
4848 /* free allocated memory */
4849 btcx_riscmem_free(btv->c.pci,&btv->main);
4851 /* free ressources */
4852 free_irq(btv->c.pci->irq,btv);
4853 iounmap(btv->bt848_mmio);
4854 release_mem_region(pci_resource_start(btv->c.pci,0),
4855 pci_resource_len(btv->c.pci,0));
4857 pci_set_drvdata(pci_dev, NULL);
4862 static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state)
4864 struct bttv *btv = pci_get_drvdata(pci_dev);
4865 struct bttv_buffer_set idle;
4866 unsigned long flags;
4868 dprintk("bttv%d: suspend %d\n", btv->c.nr, state.event);
4870 /* stop dma + irqs */
4871 spin_lock_irqsave(&btv->s_lock,flags);
4872 memset(&idle, 0, sizeof(idle));
4873 btv->state.video = btv->curr;
4874 btv->state.vbi = btv->cvbi;
4875 btv->state.loop_irq = btv->loop_irq;
4878 bttv_buffer_activate_video(btv, &idle);
4879 bttv_buffer_activate_vbi(btv, NULL);
4880 bttv_set_dma(btv, 0);
4881 btwrite(0, BT848_INT_MASK);
4882 spin_unlock_irqrestore(&btv->s_lock,flags);
4884 /* save bt878 state */
4885 btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
4886 btv->state.gpio_data = gpio_read();
4888 /* save pci state */
4889 pci_save_state(pci_dev);
4890 if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
4891 pci_disable_device(pci_dev);
4892 btv->state.disabled = 1;
4897 static int bttv_resume(struct pci_dev *pci_dev)
4899 struct bttv *btv = pci_get_drvdata(pci_dev);
4900 unsigned long flags;
4903 dprintk("bttv%d: resume\n", btv->c.nr);
4905 /* restore pci state */
4906 if (btv->state.disabled) {
4907 err=pci_enable_device(pci_dev);
4909 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4913 btv->state.disabled = 0;
4915 err=pci_set_power_state(pci_dev, PCI_D0);
4917 pci_disable_device(pci_dev);
4918 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4920 btv->state.disabled = 1;
4924 pci_restore_state(pci_dev);
4926 /* restore bt878 state */
4927 bttv_reinit_bt848(btv);
4928 gpio_inout(0xffffff, btv->state.gpio_enable);
4929 gpio_write(btv->state.gpio_data);
4932 spin_lock_irqsave(&btv->s_lock,flags);
4933 btv->curr = btv->state.video;
4934 btv->cvbi = btv->state.vbi;
4935 btv->loop_irq = btv->state.loop_irq;
4936 bttv_buffer_activate_video(btv, &btv->curr);
4937 bttv_buffer_activate_vbi(btv, btv->cvbi);
4938 bttv_set_dma(btv, 0);
4939 spin_unlock_irqrestore(&btv->s_lock,flags);
4944 static struct pci_device_id bttv_pci_tbl[] = {
4945 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848,
4946 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4947 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849,
4948 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4949 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878,
4950 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4951 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879,
4952 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4956 MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
4958 static struct pci_driver bttv_pci_driver = {
4960 .id_table = bttv_pci_tbl,
4961 .probe = bttv_probe,
4962 .remove = __devexit_p(bttv_remove),
4964 .suspend = bttv_suspend,
4965 .resume = bttv_resume,
4969 static int bttv_init_module(void)
4975 printk(KERN_INFO "bttv: driver version %d.%d.%d loaded\n",
4976 (BTTV_VERSION_CODE >> 16) & 0xff,
4977 (BTTV_VERSION_CODE >> 8) & 0xff,
4978 BTTV_VERSION_CODE & 0xff);
4980 printk(KERN_INFO "bttv: snapshot date %04d-%02d-%02d\n",
4981 SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
4983 if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
4985 if (gbufsize < 0 || gbufsize > BTTV_MAX_FBUF)
4986 gbufsize = BTTV_MAX_FBUF;
4987 gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
4989 printk(KERN_INFO "bttv: using %d buffers with %dk (%d pages) each for capture\n",
4990 gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
4992 bttv_check_chipset();
4994 ret = bus_register(&bttv_sub_bus_type);
4996 printk(KERN_WARNING "bttv: bus_register error: %d\n", ret);
4999 return pci_register_driver(&bttv_pci_driver);
5002 static void bttv_cleanup_module(void)
5004 pci_unregister_driver(&bttv_pci_driver);
5005 bus_unregister(&bttv_sub_bus_type);
5009 module_init(bttv_init_module);
5010 module_exit(bttv_cleanup_module);