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 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 #include <linux/init.h>
28 #include <linux/module.h>
29 #include <linux/moduleparam.h>
30 #include <linux/delay.h>
31 #include <linux/errno.h>
33 #include <linux/kernel.h>
34 #include <linux/sched.h>
35 #include <linux/interrupt.h>
36 #include <linux/kdev_t.h>
37 #include <linux/dma-mapping.h>
40 #include <asm/byteorder.h>
47 unsigned int bttv_num; /* number of Bt848s in use */
48 struct bttv bttvs[BTTV_MAX];
50 unsigned int bttv_debug = 0;
51 unsigned int bttv_verbose = 1;
52 unsigned int bttv_gpio = 0;
54 /* config variables */
56 static unsigned int bigendian=1;
58 static unsigned int bigendian=0;
60 static unsigned int radio[BTTV_MAX];
61 static unsigned int irq_debug = 0;
62 static unsigned int gbuffers = 8;
63 static unsigned int gbufsize = 0x208000;
65 static int video_nr = -1;
66 static int radio_nr = -1;
67 static int vbi_nr = -1;
68 static int debug_latency = 0;
70 static unsigned int fdsr = 0;
73 static unsigned int combfilter = 0;
74 static unsigned int lumafilter = 0;
75 static unsigned int automute = 1;
76 static unsigned int chroma_agc = 0;
77 static unsigned int adc_crush = 1;
78 static unsigned int whitecrush_upper = 0xCF;
79 static unsigned int whitecrush_lower = 0x7F;
80 static unsigned int vcr_hack = 0;
81 static unsigned int irq_iswitch = 0;
82 static unsigned int uv_ratio = 50;
83 static unsigned int full_luma_range = 0;
84 static unsigned int coring = 0;
85 extern int no_overlay;
87 /* API features (turn on/off stuff for testing) */
88 static unsigned int v4l2 = 1;
92 module_param(bttv_verbose, int, 0644);
93 module_param(bttv_gpio, int, 0644);
94 module_param(bttv_debug, int, 0644);
95 module_param(irq_debug, int, 0644);
96 module_param(debug_latency, int, 0644);
98 module_param(fdsr, int, 0444);
99 module_param(video_nr, int, 0444);
100 module_param(radio_nr, int, 0444);
101 module_param(vbi_nr, int, 0444);
102 module_param(gbuffers, int, 0444);
103 module_param(gbufsize, int, 0444);
105 module_param(v4l2, int, 0644);
106 module_param(bigendian, int, 0644);
107 module_param(irq_iswitch, int, 0644);
108 module_param(combfilter, int, 0444);
109 module_param(lumafilter, int, 0444);
110 module_param(automute, int, 0444);
111 module_param(chroma_agc, int, 0444);
112 module_param(adc_crush, int, 0444);
113 module_param(whitecrush_upper, int, 0444);
114 module_param(whitecrush_lower, int, 0444);
115 module_param(vcr_hack, int, 0444);
116 module_param(uv_ratio, int, 0444);
117 module_param(full_luma_range, int, 0444);
118 module_param(coring, int, 0444);
120 module_param_array(radio, int, NULL, 0444);
122 MODULE_PARM_DESC(radio,"The TV card supports radio, default is 0 (no)");
123 MODULE_PARM_DESC(bigendian,"byte order of the framebuffer, default is native endian");
124 MODULE_PARM_DESC(bttv_verbose,"verbose startup messages, default is 1 (yes)");
125 MODULE_PARM_DESC(bttv_gpio,"log gpio changes, default is 0 (no)");
126 MODULE_PARM_DESC(bttv_debug,"debug messages, default is 0 (no)");
127 MODULE_PARM_DESC(irq_debug,"irq handler debug messages, default is 0 (no)");
128 MODULE_PARM_DESC(gbuffers,"number of capture buffers. range 2-32, default 8");
129 MODULE_PARM_DESC(gbufsize,"size of the capture buffers, default is 0x208000");
130 MODULE_PARM_DESC(automute,"mute audio on bad/missing video signal, default is 1 (yes)");
131 MODULE_PARM_DESC(chroma_agc,"enables the AGC of chroma signal, default is 0 (no)");
132 MODULE_PARM_DESC(adc_crush,"enables the luminance ADC crush, default is 1 (yes)");
133 MODULE_PARM_DESC(whitecrush_upper,"sets the white crush upper value, default is 207");
134 MODULE_PARM_DESC(whitecrush_lower,"sets the white crush lower value, default is 127");
135 MODULE_PARM_DESC(vcr_hack,"enables the VCR hack (improves synch on poor VCR tapes), default is 0 (no)");
136 MODULE_PARM_DESC(irq_iswitch,"switch inputs in irq handler");
137 MODULE_PARM_DESC(uv_ratio,"ratio between u and v gains, default is 50");
138 MODULE_PARM_DESC(full_luma_range,"use the full luma range, default is 0 (no)");
139 MODULE_PARM_DESC(coring,"set the luma coring level, default is 0 (no)");
141 MODULE_DESCRIPTION("bttv - v4l/v4l2 driver module for bt848/878 based cards");
142 MODULE_AUTHOR("Ralph Metzler & Marcus Metzler & Gerd Knorr");
143 MODULE_LICENSE("GPL");
145 /* ----------------------------------------------------------------------- */
148 static ssize_t show_card(struct class_device *cd, char *buf)
150 struct video_device *vfd = to_video_device(cd);
151 struct bttv *btv = dev_get_drvdata(vfd->dev);
152 return sprintf(buf, "%d\n", btv ? btv->c.type : UNSET);
154 static CLASS_DEVICE_ATTR(card, S_IRUGO, show_card, NULL);
156 /* ----------------------------------------------------------------------- */
159 /* special timing tables from conexant... */
160 static u8 SRAM_Table[][60] =
162 /* PAL digital input over GPIO[7:0] */
164 45, // 45 bytes following
165 0x36,0x11,0x01,0x00,0x90,0x02,0x05,0x10,0x04,0x16,
166 0x12,0x05,0x11,0x00,0x04,0x12,0xC0,0x00,0x31,0x00,
167 0x06,0x51,0x08,0x03,0x89,0x08,0x07,0xC0,0x44,0x00,
168 0x81,0x01,0x01,0xA9,0x0D,0x02,0x02,0x50,0x03,0x37,
169 0x37,0x00,0xAF,0x21,0x00
171 /* NTSC digital input over GPIO[7:0] */
173 51, // 51 bytes following
174 0x0C,0xC0,0x00,0x00,0x90,0x02,0x03,0x10,0x03,0x06,
175 0x10,0x04,0x12,0x12,0x05,0x02,0x13,0x04,0x19,0x00,
176 0x04,0x39,0x00,0x06,0x59,0x08,0x03,0x83,0x08,0x07,
177 0x03,0x50,0x00,0xC0,0x40,0x00,0x86,0x01,0x01,0xA6,
178 0x0D,0x02,0x03,0x11,0x01,0x05,0x37,0x00,0xAC,0x21,
181 // TGB_NTSC392 // quartzsight
182 // This table has been modified to be used for Fusion Rev D
184 0x2A, // size of table = 42
185 0x06, 0x08, 0x04, 0x0a, 0xc0, 0x00, 0x18, 0x08, 0x03, 0x24,
186 0x08, 0x07, 0x02, 0x90, 0x02, 0x08, 0x10, 0x04, 0x0c, 0x10,
187 0x05, 0x2c, 0x11, 0x04, 0x55, 0x48, 0x00, 0x05, 0x50, 0x00,
188 0xbf, 0x0c, 0x02, 0x2f, 0x3d, 0x00, 0x2f, 0x3f, 0x00, 0xc3,
193 const struct bttv_tvnorm bttv_tvnorms[] = {
195 /* max. active video is actually 922, but 924 is divisible by 4 and 3! */
196 /* actually, max active PAL with HSCALE=0 is 948, NTSC is 768 - nil */
198 .v4l2_id = V4L2_STD_PAL,
206 .iform = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
207 .scaledtwidth = 1135,
214 .v4l2_id = V4L2_STD_NTSC_M,
222 .iform = (BT848_IFORM_NTSC|BT848_IFORM_XT0),
230 .v4l2_id = V4L2_STD_SECAM,
238 .iform = (BT848_IFORM_SECAM|BT848_IFORM_XT1),
239 .scaledtwidth = 1135,
244 .sram = 0, /* like PAL, correct? */
246 .v4l2_id = V4L2_STD_PAL_Nc,
254 .iform = (BT848_IFORM_PAL_NC|BT848_IFORM_XT0),
262 .v4l2_id = V4L2_STD_PAL_M,
270 .iform = (BT848_IFORM_PAL_M|BT848_IFORM_XT0),
278 .v4l2_id = V4L2_STD_PAL_N,
286 .iform = (BT848_IFORM_PAL_N|BT848_IFORM_XT1),
294 .v4l2_id = V4L2_STD_NTSC_M_JP,
302 .iform = (BT848_IFORM_NTSC_J|BT848_IFORM_XT0),
310 /* that one hopefully works with the strange timing
311 * which video recorders produce when playing a NTSC
312 * tape on a PAL TV ... */
313 .v4l2_id = V4L2_STD_PAL_60,
321 .iform = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
322 .scaledtwidth = 1135,
331 static const unsigned int BTTV_TVNORMS = ARRAY_SIZE(bttv_tvnorms);
333 /* ----------------------------------------------------------------------- */
335 packed pixel formats must come first */
336 static const struct bttv_format bttv_formats[] = {
338 .name = "8 bpp, gray",
339 .palette = VIDEO_PALETTE_GREY,
340 .fourcc = V4L2_PIX_FMT_GREY,
341 .btformat = BT848_COLOR_FMT_Y8,
343 .flags = FORMAT_FLAGS_PACKED,
345 .name = "8 bpp, dithered color",
346 .palette = VIDEO_PALETTE_HI240,
347 .fourcc = V4L2_PIX_FMT_HI240,
348 .btformat = BT848_COLOR_FMT_RGB8,
350 .flags = FORMAT_FLAGS_PACKED | FORMAT_FLAGS_DITHER,
352 .name = "15 bpp RGB, le",
353 .palette = VIDEO_PALETTE_RGB555,
354 .fourcc = V4L2_PIX_FMT_RGB555,
355 .btformat = BT848_COLOR_FMT_RGB15,
357 .flags = FORMAT_FLAGS_PACKED,
359 .name = "15 bpp RGB, be",
361 .fourcc = V4L2_PIX_FMT_RGB555X,
362 .btformat = BT848_COLOR_FMT_RGB15,
363 .btswap = 0x03, /* byteswap */
365 .flags = FORMAT_FLAGS_PACKED,
367 .name = "16 bpp RGB, le",
368 .palette = VIDEO_PALETTE_RGB565,
369 .fourcc = V4L2_PIX_FMT_RGB565,
370 .btformat = BT848_COLOR_FMT_RGB16,
372 .flags = FORMAT_FLAGS_PACKED,
374 .name = "16 bpp RGB, be",
376 .fourcc = V4L2_PIX_FMT_RGB565X,
377 .btformat = BT848_COLOR_FMT_RGB16,
378 .btswap = 0x03, /* byteswap */
380 .flags = FORMAT_FLAGS_PACKED,
382 .name = "24 bpp RGB, le",
383 .palette = VIDEO_PALETTE_RGB24,
384 .fourcc = V4L2_PIX_FMT_BGR24,
385 .btformat = BT848_COLOR_FMT_RGB24,
387 .flags = FORMAT_FLAGS_PACKED,
389 .name = "32 bpp RGB, le",
390 .palette = VIDEO_PALETTE_RGB32,
391 .fourcc = V4L2_PIX_FMT_BGR32,
392 .btformat = BT848_COLOR_FMT_RGB32,
394 .flags = FORMAT_FLAGS_PACKED,
396 .name = "32 bpp RGB, be",
398 .fourcc = V4L2_PIX_FMT_RGB32,
399 .btformat = BT848_COLOR_FMT_RGB32,
400 .btswap = 0x0f, /* byte+word swap */
402 .flags = FORMAT_FLAGS_PACKED,
404 .name = "4:2:2, packed, YUYV",
405 .palette = VIDEO_PALETTE_YUV422,
406 .fourcc = V4L2_PIX_FMT_YUYV,
407 .btformat = BT848_COLOR_FMT_YUY2,
409 .flags = FORMAT_FLAGS_PACKED,
411 .name = "4:2:2, packed, YUYV",
412 .palette = VIDEO_PALETTE_YUYV,
413 .fourcc = V4L2_PIX_FMT_YUYV,
414 .btformat = BT848_COLOR_FMT_YUY2,
416 .flags = FORMAT_FLAGS_PACKED,
418 .name = "4:2:2, packed, UYVY",
419 .palette = VIDEO_PALETTE_UYVY,
420 .fourcc = V4L2_PIX_FMT_UYVY,
421 .btformat = BT848_COLOR_FMT_YUY2,
422 .btswap = 0x03, /* byteswap */
424 .flags = FORMAT_FLAGS_PACKED,
426 .name = "4:2:2, planar, Y-Cb-Cr",
427 .palette = VIDEO_PALETTE_YUV422P,
428 .fourcc = V4L2_PIX_FMT_YUV422P,
429 .btformat = BT848_COLOR_FMT_YCrCb422,
431 .flags = FORMAT_FLAGS_PLANAR,
435 .name = "4:2:0, planar, Y-Cb-Cr",
436 .palette = VIDEO_PALETTE_YUV420P,
437 .fourcc = V4L2_PIX_FMT_YUV420,
438 .btformat = BT848_COLOR_FMT_YCrCb422,
440 .flags = FORMAT_FLAGS_PLANAR,
444 .name = "4:2:0, planar, Y-Cr-Cb",
446 .fourcc = V4L2_PIX_FMT_YVU420,
447 .btformat = BT848_COLOR_FMT_YCrCb422,
449 .flags = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
453 .name = "4:1:1, planar, Y-Cb-Cr",
454 .palette = VIDEO_PALETTE_YUV411P,
455 .fourcc = V4L2_PIX_FMT_YUV411P,
456 .btformat = BT848_COLOR_FMT_YCrCb411,
458 .flags = FORMAT_FLAGS_PLANAR,
462 .name = "4:1:0, planar, Y-Cb-Cr",
463 .palette = VIDEO_PALETTE_YUV410P,
464 .fourcc = V4L2_PIX_FMT_YUV410,
465 .btformat = BT848_COLOR_FMT_YCrCb411,
467 .flags = FORMAT_FLAGS_PLANAR,
471 .name = "4:1:0, planar, Y-Cr-Cb",
473 .fourcc = V4L2_PIX_FMT_YVU410,
474 .btformat = BT848_COLOR_FMT_YCrCb411,
476 .flags = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
480 .name = "raw scanlines",
481 .palette = VIDEO_PALETTE_RAW,
483 .btformat = BT848_COLOR_FMT_RAW,
485 .flags = FORMAT_FLAGS_RAW,
488 static const unsigned int BTTV_FORMATS = ARRAY_SIZE(bttv_formats);
490 /* ----------------------------------------------------------------------- */
492 #define V4L2_CID_PRIVATE_CHROMA_AGC (V4L2_CID_PRIVATE_BASE + 0)
493 #define V4L2_CID_PRIVATE_COMBFILTER (V4L2_CID_PRIVATE_BASE + 1)
494 #define V4L2_CID_PRIVATE_AUTOMUTE (V4L2_CID_PRIVATE_BASE + 2)
495 #define V4L2_CID_PRIVATE_LUMAFILTER (V4L2_CID_PRIVATE_BASE + 3)
496 #define V4L2_CID_PRIVATE_AGC_CRUSH (V4L2_CID_PRIVATE_BASE + 4)
497 #define V4L2_CID_PRIVATE_VCR_HACK (V4L2_CID_PRIVATE_BASE + 5)
498 #define V4L2_CID_PRIVATE_WHITECRUSH_UPPER (V4L2_CID_PRIVATE_BASE + 6)
499 #define V4L2_CID_PRIVATE_WHITECRUSH_LOWER (V4L2_CID_PRIVATE_BASE + 7)
500 #define V4L2_CID_PRIVATE_UV_RATIO (V4L2_CID_PRIVATE_BASE + 8)
501 #define V4L2_CID_PRIVATE_FULL_LUMA_RANGE (V4L2_CID_PRIVATE_BASE + 9)
502 #define V4L2_CID_PRIVATE_CORING (V4L2_CID_PRIVATE_BASE + 10)
503 #define V4L2_CID_PRIVATE_LASTP1 (V4L2_CID_PRIVATE_BASE + 11)
505 static const struct v4l2_queryctrl no_ctl = {
507 .flags = V4L2_CTRL_FLAG_DISABLED,
509 static const struct v4l2_queryctrl bttv_ctls[] = {
512 .id = V4L2_CID_BRIGHTNESS,
513 .name = "Brightness",
517 .default_value = 32768,
518 .type = V4L2_CTRL_TYPE_INTEGER,
520 .id = V4L2_CID_CONTRAST,
525 .default_value = 32768,
526 .type = V4L2_CTRL_TYPE_INTEGER,
528 .id = V4L2_CID_SATURATION,
529 .name = "Saturation",
533 .default_value = 32768,
534 .type = V4L2_CTRL_TYPE_INTEGER,
541 .default_value = 32768,
542 .type = V4L2_CTRL_TYPE_INTEGER,
546 .id = V4L2_CID_AUDIO_MUTE,
550 .type = V4L2_CTRL_TYPE_BOOLEAN,
552 .id = V4L2_CID_AUDIO_VOLUME,
557 .default_value = 65535,
558 .type = V4L2_CTRL_TYPE_INTEGER,
560 .id = V4L2_CID_AUDIO_BALANCE,
565 .default_value = 32768,
566 .type = V4L2_CTRL_TYPE_INTEGER,
568 .id = V4L2_CID_AUDIO_BASS,
573 .default_value = 32768,
574 .type = V4L2_CTRL_TYPE_INTEGER,
576 .id = V4L2_CID_AUDIO_TREBLE,
581 .default_value = 32768,
582 .type = V4L2_CTRL_TYPE_INTEGER,
584 /* --- private --- */
586 .id = V4L2_CID_PRIVATE_CHROMA_AGC,
587 .name = "chroma agc",
590 .type = V4L2_CTRL_TYPE_BOOLEAN,
592 .id = V4L2_CID_PRIVATE_COMBFILTER,
593 .name = "combfilter",
596 .type = V4L2_CTRL_TYPE_BOOLEAN,
598 .id = V4L2_CID_PRIVATE_AUTOMUTE,
602 .type = V4L2_CTRL_TYPE_BOOLEAN,
604 .id = V4L2_CID_PRIVATE_LUMAFILTER,
605 .name = "luma decimation filter",
608 .type = V4L2_CTRL_TYPE_BOOLEAN,
610 .id = V4L2_CID_PRIVATE_AGC_CRUSH,
614 .type = V4L2_CTRL_TYPE_BOOLEAN,
616 .id = V4L2_CID_PRIVATE_VCR_HACK,
620 .type = V4L2_CTRL_TYPE_BOOLEAN,
622 .id = V4L2_CID_PRIVATE_WHITECRUSH_UPPER,
623 .name = "whitecrush upper",
627 .default_value = 0xCF,
628 .type = V4L2_CTRL_TYPE_INTEGER,
630 .id = V4L2_CID_PRIVATE_WHITECRUSH_LOWER,
631 .name = "whitecrush lower",
635 .default_value = 0x7F,
636 .type = V4L2_CTRL_TYPE_INTEGER,
638 .id = V4L2_CID_PRIVATE_UV_RATIO,
644 .type = V4L2_CTRL_TYPE_INTEGER,
646 .id = V4L2_CID_PRIVATE_FULL_LUMA_RANGE,
647 .name = "full luma range",
650 .type = V4L2_CTRL_TYPE_BOOLEAN,
652 .id = V4L2_CID_PRIVATE_CORING,
658 .type = V4L2_CTRL_TYPE_INTEGER,
664 static const int BTTV_CTLS = ARRAY_SIZE(bttv_ctls);
666 /* ----------------------------------------------------------------------- */
667 /* resource management */
670 int check_alloc_btres(struct bttv *btv, struct bttv_fh *fh, int bit)
672 if (fh->resources & bit)
673 /* have it already allocated */
678 if (btv->resources & bit) {
679 /* no, someone else uses it */
683 /* it's free, grab it */
684 fh->resources |= bit;
685 btv->resources |= bit;
691 int check_btres(struct bttv_fh *fh, int bit)
693 return (fh->resources & bit);
697 int locked_btres(struct bttv *btv, int bit)
699 return (btv->resources & bit);
703 void free_btres(struct bttv *btv, struct bttv_fh *fh, int bits)
705 if ((fh->resources & bits) != bits) {
706 /* trying to free ressources not allocated by us ... */
707 printk("bttv: BUG! (btres)\n");
710 fh->resources &= ~bits;
711 btv->resources &= ~bits;
715 /* ----------------------------------------------------------------------- */
716 /* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC */
718 /* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C
719 PLL_X = Reference pre-divider (0=1, 1=2)
720 PLL_C = Post divider (0=6, 1=4)
721 PLL_I = Integer input
722 PLL_F = Fractional input
724 F_input = 28.636363 MHz:
725 PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0
728 static void set_pll_freq(struct bttv *btv, unsigned int fin, unsigned int fout)
730 unsigned char fl, fh, fi;
732 /* prevent overflows */
745 btwrite(fl, BT848_PLL_F_LO);
746 btwrite(fh, BT848_PLL_F_HI);
747 btwrite(fi|BT848_PLL_X, BT848_PLL_XCI);
750 static void set_pll(struct bttv *btv)
754 if (!btv->pll.pll_crystal)
757 if (btv->pll.pll_ofreq == btv->pll.pll_current) {
758 dprintk("bttv%d: PLL: no change required\n",btv->c.nr);
762 if (btv->pll.pll_ifreq == btv->pll.pll_ofreq) {
764 if (btv->pll.pll_current == 0)
766 bttv_printk(KERN_INFO "bttv%d: PLL can sleep, using XTAL (%d).\n",
767 btv->c.nr,btv->pll.pll_ifreq);
768 btwrite(0x00,BT848_TGCTRL);
769 btwrite(0x00,BT848_PLL_XCI);
770 btv->pll.pll_current = 0;
774 bttv_printk(KERN_INFO "bttv%d: PLL: %d => %d ",btv->c.nr,
775 btv->pll.pll_ifreq, btv->pll.pll_ofreq);
776 set_pll_freq(btv, btv->pll.pll_ifreq, btv->pll.pll_ofreq);
778 for (i=0; i<10; i++) {
779 /* Let other people run while the PLL stabilizes */
783 if (btread(BT848_DSTATUS) & BT848_DSTATUS_PLOCK) {
784 btwrite(0,BT848_DSTATUS);
786 btwrite(0x08,BT848_TGCTRL);
787 btv->pll.pll_current = btv->pll.pll_ofreq;
788 bttv_printk(" ok\n");
792 btv->pll.pll_current = -1;
793 bttv_printk("failed\n");
797 /* used to switch between the bt848's analog/digital video capture modes */
798 static void bt848A_set_timing(struct bttv *btv)
801 int table_idx = bttv_tvnorms[btv->tvnorm].sram;
802 int fsc = bttv_tvnorms[btv->tvnorm].Fsc;
804 if (UNSET == bttv_tvcards[btv->c.type].muxsel[btv->input]) {
805 dprintk("bttv%d: load digital timing table (table_idx=%d)\n",
806 btv->c.nr,table_idx);
808 /* timing change...reset timing generator address */
809 btwrite(0x00, BT848_TGCTRL);
810 btwrite(0x02, BT848_TGCTRL);
811 btwrite(0x00, BT848_TGCTRL);
813 len=SRAM_Table[table_idx][0];
814 for(i = 1; i <= len; i++)
815 btwrite(SRAM_Table[table_idx][i],BT848_TGLB);
816 btv->pll.pll_ofreq = 27000000;
819 btwrite(0x11, BT848_TGCTRL);
820 btwrite(0x41, BT848_DVSIF);
822 btv->pll.pll_ofreq = fsc;
824 btwrite(0x0, BT848_DVSIF);
828 /* ----------------------------------------------------------------------- */
830 static void bt848_bright(struct bttv *btv, int bright)
834 // printk("bttv: set bright: %d\n",bright); // DEBUG
835 btv->bright = bright;
837 /* We want -128 to 127 we get 0-65535 */
838 value = (bright >> 8) - 128;
839 btwrite(value & 0xff, BT848_BRIGHT);
842 static void bt848_hue(struct bttv *btv, int hue)
849 value = (hue >> 8) - 128;
850 btwrite(value & 0xff, BT848_HUE);
853 static void bt848_contrast(struct bttv *btv, int cont)
857 btv->contrast = cont;
861 hibit = (value >> 6) & 4;
862 btwrite(value & 0xff, BT848_CONTRAST_LO);
863 btaor(hibit, ~4, BT848_E_CONTROL);
864 btaor(hibit, ~4, BT848_O_CONTROL);
867 static void bt848_sat(struct bttv *btv, int color)
869 int val_u,val_v,hibits;
871 btv->saturation = color;
873 /* 0-511 for the color */
874 val_u = ((color * btv->opt_uv_ratio) / 50) >> 7;
875 val_v = (((color * (100 - btv->opt_uv_ratio) / 50) >>7)*180L)/254;
876 hibits = (val_u >> 7) & 2;
877 hibits |= (val_v >> 8) & 1;
878 btwrite(val_u & 0xff, BT848_SAT_U_LO);
879 btwrite(val_v & 0xff, BT848_SAT_V_LO);
880 btaor(hibits, ~3, BT848_E_CONTROL);
881 btaor(hibits, ~3, BT848_O_CONTROL);
884 /* ----------------------------------------------------------------------- */
887 video_mux(struct bttv *btv, unsigned int input)
891 if (input >= bttv_tvcards[btv->c.type].video_inputs)
894 /* needed by RemoteVideo MX */
895 mask2 = bttv_tvcards[btv->c.type].gpiomask2;
897 gpio_inout(mask2,mask2);
899 if (input == btv->svhs) {
900 btor(BT848_CONTROL_COMP, BT848_E_CONTROL);
901 btor(BT848_CONTROL_COMP, BT848_O_CONTROL);
903 btand(~BT848_CONTROL_COMP, BT848_E_CONTROL);
904 btand(~BT848_CONTROL_COMP, BT848_O_CONTROL);
906 mux = bttv_tvcards[btv->c.type].muxsel[input] & 3;
907 btaor(mux<<5, ~(3<<5), BT848_IFORM);
908 dprintk(KERN_DEBUG "bttv%d: video mux: input=%d mux=%d\n",
909 btv->c.nr,input,mux);
911 /* card specific hook */
912 if(bttv_tvcards[btv->c.type].muxsel_hook)
913 bttv_tvcards[btv->c.type].muxsel_hook (btv, input);
917 static char *audio_modes[] = {
918 "audio: tuner", "audio: radio", "audio: extern",
919 "audio: intern", "audio: off"
923 audio_mux(struct bttv *btv, int mode)
925 int val,mux,i2c_mux,signal;
927 gpio_inout(bttv_tvcards[btv->c.type].gpiomask,
928 bttv_tvcards[btv->c.type].gpiomask);
929 signal = btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC;
933 btv->audio |= AUDIO_MUTE;
936 btv->audio &= ~AUDIO_MUTE;
942 btv->audio &= AUDIO_MUTE;
945 i2c_mux = mux = (btv->audio & AUDIO_MUTE) ? AUDIO_OFF : btv->audio;
946 if (btv->opt_automute && !signal && !btv->radio_user)
949 val = bttv_tvcards[btv->c.type].audiomux[mux];
950 gpio_bits(bttv_tvcards[btv->c.type].gpiomask,val);
952 bttv_gpio_tracking(btv,audio_modes[mux]);
954 bttv_call_i2c_clients(btv,AUDC_SET_INPUT,&(i2c_mux));
959 i2c_vidiocschan(struct bttv *btv)
961 struct video_channel c;
963 memset(&c,0,sizeof(c));
964 c.norm = btv->tvnorm;
965 c.channel = btv->input;
966 bttv_call_i2c_clients(btv,VIDIOCSCHAN,&c);
967 if (btv->c.type == BTTV_BOARD_VOODOOTV_FM)
968 bttv_tda9880_setnorm(btv,c.norm);
972 set_tvnorm(struct bttv *btv, unsigned int norm)
974 const struct bttv_tvnorm *tvnorm;
976 if (norm < 0 || norm >= BTTV_TVNORMS)
980 tvnorm = &bttv_tvnorms[norm];
982 btwrite(tvnorm->adelay, BT848_ADELAY);
983 btwrite(tvnorm->bdelay, BT848_BDELAY);
984 btaor(tvnorm->iform,~(BT848_IFORM_NORM|BT848_IFORM_XTBOTH),
986 btwrite(tvnorm->vbipack, BT848_VBI_PACK_SIZE);
987 btwrite(1, BT848_VBI_PACK_DEL);
988 bt848A_set_timing(btv);
990 switch (btv->c.type) {
991 case BTTV_BOARD_VOODOOTV_FM:
992 bttv_tda9880_setnorm(btv,norm);
999 set_input(struct bttv *btv, unsigned int input)
1001 unsigned long flags;
1005 spin_lock_irqsave(&btv->s_lock,flags);
1006 if (btv->curr.frame_irq) {
1007 /* active capture -> delayed input switch */
1008 btv->new_input = input;
1010 video_mux(btv,input);
1012 spin_unlock_irqrestore(&btv->s_lock,flags);
1014 video_mux(btv,input);
1016 audio_mux(btv,(input == bttv_tvcards[btv->c.type].tuner ?
1017 AUDIO_TUNER : AUDIO_EXTERN));
1018 set_tvnorm(btv,btv->tvnorm);
1019 i2c_vidiocschan(btv);
1022 static void init_irqreg(struct bttv *btv)
1025 btwrite(0xfffffUL, BT848_INT_STAT);
1027 if (bttv_tvcards[btv->c.type].no_video) {
1029 btwrite(BT848_INT_I2CDONE,
1033 btwrite((btv->triton1) |
1034 (btv->gpioirq ? BT848_INT_GPINT : 0) |
1036 (fdsr ? BT848_INT_FDSR : 0) |
1037 BT848_INT_RISCI|BT848_INT_OCERR|BT848_INT_VPRES|
1038 BT848_INT_FMTCHG|BT848_INT_HLOCK|
1044 static void init_bt848(struct bttv *btv)
1048 if (bttv_tvcards[btv->c.type].no_video) {
1049 /* very basic init only */
1054 btwrite(0x00, BT848_CAP_CTL);
1055 btwrite(BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL);
1056 btwrite(BT848_IFORM_XTAUTO | BT848_IFORM_AUTO, BT848_IFORM);
1058 /* set planar and packed mode trigger points and */
1059 /* set rising edge of inverted GPINTR pin as irq trigger */
1060 btwrite(BT848_GPIO_DMA_CTL_PKTP_32|
1061 BT848_GPIO_DMA_CTL_PLTP1_16|
1062 BT848_GPIO_DMA_CTL_PLTP23_16|
1063 BT848_GPIO_DMA_CTL_GPINTC|
1064 BT848_GPIO_DMA_CTL_GPINTI,
1065 BT848_GPIO_DMA_CTL);
1067 val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1068 btwrite(val, BT848_E_SCLOOP);
1069 btwrite(val, BT848_O_SCLOOP);
1071 btwrite(0x20, BT848_E_VSCALE_HI);
1072 btwrite(0x20, BT848_O_VSCALE_HI);
1073 btwrite(BT848_ADC_RESERVED | (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1076 btwrite(whitecrush_upper, BT848_WC_UP);
1077 btwrite(whitecrush_lower, BT848_WC_DOWN);
1079 if (btv->opt_lumafilter) {
1080 btwrite(0, BT848_E_CONTROL);
1081 btwrite(0, BT848_O_CONTROL);
1083 btwrite(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1084 btwrite(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1087 bt848_bright(btv, btv->bright);
1088 bt848_hue(btv, btv->hue);
1089 bt848_contrast(btv, btv->contrast);
1090 bt848_sat(btv, btv->saturation);
1096 static void bttv_reinit_bt848(struct bttv *btv)
1098 unsigned long flags;
1101 printk(KERN_INFO "bttv%d: reset, reinitialize\n",btv->c.nr);
1102 spin_lock_irqsave(&btv->s_lock,flags);
1104 bttv_set_dma(btv,0);
1105 spin_unlock_irqrestore(&btv->s_lock,flags);
1108 btv->pll.pll_current = -1;
1109 set_input(btv,btv->input);
1112 static int get_control(struct bttv *btv, struct v4l2_control *c)
1114 struct video_audio va;
1117 for (i = 0; i < BTTV_CTLS; i++)
1118 if (bttv_ctls[i].id == c->id)
1122 if (i >= 4 && i <= 8) {
1123 memset(&va,0,sizeof(va));
1124 bttv_call_i2c_clients(btv, VIDIOCGAUDIO, &va);
1125 if (btv->audio_hook)
1126 btv->audio_hook(btv,&va,0);
1129 case V4L2_CID_BRIGHTNESS:
1130 c->value = btv->bright;
1133 c->value = btv->hue;
1135 case V4L2_CID_CONTRAST:
1136 c->value = btv->contrast;
1138 case V4L2_CID_SATURATION:
1139 c->value = btv->saturation;
1142 case V4L2_CID_AUDIO_MUTE:
1143 c->value = (VIDEO_AUDIO_MUTE & va.flags) ? 1 : 0;
1145 case V4L2_CID_AUDIO_VOLUME:
1146 c->value = va.volume;
1148 case V4L2_CID_AUDIO_BALANCE:
1149 c->value = va.balance;
1151 case V4L2_CID_AUDIO_BASS:
1154 case V4L2_CID_AUDIO_TREBLE:
1155 c->value = va.treble;
1158 case V4L2_CID_PRIVATE_CHROMA_AGC:
1159 c->value = btv->opt_chroma_agc;
1161 case V4L2_CID_PRIVATE_COMBFILTER:
1162 c->value = btv->opt_combfilter;
1164 case V4L2_CID_PRIVATE_LUMAFILTER:
1165 c->value = btv->opt_lumafilter;
1167 case V4L2_CID_PRIVATE_AUTOMUTE:
1168 c->value = btv->opt_automute;
1170 case V4L2_CID_PRIVATE_AGC_CRUSH:
1171 c->value = btv->opt_adc_crush;
1173 case V4L2_CID_PRIVATE_VCR_HACK:
1174 c->value = btv->opt_vcr_hack;
1176 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1177 c->value = btv->opt_whitecrush_upper;
1179 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1180 c->value = btv->opt_whitecrush_lower;
1182 case V4L2_CID_PRIVATE_UV_RATIO:
1183 c->value = btv->opt_uv_ratio;
1185 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1186 c->value = btv->opt_full_luma_range;
1188 case V4L2_CID_PRIVATE_CORING:
1189 c->value = btv->opt_coring;
1197 static int set_control(struct bttv *btv, struct v4l2_control *c)
1199 struct video_audio va;
1202 for (i = 0; i < BTTV_CTLS; i++)
1203 if (bttv_ctls[i].id == c->id)
1207 if (i >= 4 && i <= 8) {
1208 memset(&va,0,sizeof(va));
1209 bttv_call_i2c_clients(btv, VIDIOCGAUDIO, &va);
1210 if (btv->audio_hook)
1211 btv->audio_hook(btv,&va,0);
1214 case V4L2_CID_BRIGHTNESS:
1215 bt848_bright(btv,c->value);
1218 bt848_hue(btv,c->value);
1220 case V4L2_CID_CONTRAST:
1221 bt848_contrast(btv,c->value);
1223 case V4L2_CID_SATURATION:
1224 bt848_sat(btv,c->value);
1226 case V4L2_CID_AUDIO_MUTE:
1228 va.flags |= VIDEO_AUDIO_MUTE;
1229 audio_mux(btv, AUDIO_MUTE);
1231 va.flags &= ~VIDEO_AUDIO_MUTE;
1232 audio_mux(btv, AUDIO_UNMUTE);
1236 case V4L2_CID_AUDIO_VOLUME:
1237 va.volume = c->value;
1239 case V4L2_CID_AUDIO_BALANCE:
1240 va.balance = c->value;
1242 case V4L2_CID_AUDIO_BASS:
1245 case V4L2_CID_AUDIO_TREBLE:
1246 va.treble = c->value;
1249 case V4L2_CID_PRIVATE_CHROMA_AGC:
1250 btv->opt_chroma_agc = c->value;
1251 val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1252 btwrite(val, BT848_E_SCLOOP);
1253 btwrite(val, BT848_O_SCLOOP);
1255 case V4L2_CID_PRIVATE_COMBFILTER:
1256 btv->opt_combfilter = c->value;
1258 case V4L2_CID_PRIVATE_LUMAFILTER:
1259 btv->opt_lumafilter = c->value;
1260 if (btv->opt_lumafilter) {
1261 btand(~BT848_CONTROL_LDEC, BT848_E_CONTROL);
1262 btand(~BT848_CONTROL_LDEC, BT848_O_CONTROL);
1264 btor(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1265 btor(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1268 case V4L2_CID_PRIVATE_AUTOMUTE:
1269 btv->opt_automute = c->value;
1271 case V4L2_CID_PRIVATE_AGC_CRUSH:
1272 btv->opt_adc_crush = c->value;
1273 btwrite(BT848_ADC_RESERVED | (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1276 case V4L2_CID_PRIVATE_VCR_HACK:
1277 btv->opt_vcr_hack = c->value;
1279 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1280 btv->opt_whitecrush_upper = c->value;
1281 btwrite(c->value, BT848_WC_UP);
1283 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1284 btv->opt_whitecrush_lower = c->value;
1285 btwrite(c->value, BT848_WC_DOWN);
1287 case V4L2_CID_PRIVATE_UV_RATIO:
1288 btv->opt_uv_ratio = c->value;
1289 bt848_sat(btv, btv->saturation);
1291 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1292 btv->opt_full_luma_range = c->value;
1293 btaor((c->value<<7), ~BT848_OFORM_RANGE, BT848_OFORM);
1295 case V4L2_CID_PRIVATE_CORING:
1296 btv->opt_coring = c->value;
1297 btaor((c->value<<5), ~BT848_OFORM_CORE32, BT848_OFORM);
1302 if (i >= 4 && i <= 8) {
1303 bttv_call_i2c_clients(btv, VIDIOCSAUDIO, &va);
1304 if (btv->audio_hook)
1305 btv->audio_hook(btv,&va,1);
1310 /* ----------------------------------------------------------------------- */
1312 void bttv_gpio_tracking(struct bttv *btv, char *comment)
1314 unsigned int outbits, data;
1315 outbits = btread(BT848_GPIO_OUT_EN);
1316 data = btread(BT848_GPIO_DATA);
1317 printk(KERN_DEBUG "bttv%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
1318 btv->c.nr,outbits,data & outbits, data & ~outbits, comment);
1321 static void bttv_field_count(struct bttv *btv)
1329 /* start field counter */
1330 btor(BT848_INT_VSYNC,BT848_INT_MASK);
1332 /* stop field counter */
1333 btand(~BT848_INT_VSYNC,BT848_INT_MASK);
1334 btv->field_count = 0;
1338 static const struct bttv_format*
1339 format_by_palette(int palette)
1343 for (i = 0; i < BTTV_FORMATS; i++) {
1344 if (-1 == bttv_formats[i].palette)
1346 if (bttv_formats[i].palette == palette)
1347 return bttv_formats+i;
1352 static const struct bttv_format*
1353 format_by_fourcc(int fourcc)
1357 for (i = 0; i < BTTV_FORMATS; i++) {
1358 if (-1 == bttv_formats[i].fourcc)
1360 if (bttv_formats[i].fourcc == fourcc)
1361 return bttv_formats+i;
1366 /* ----------------------------------------------------------------------- */
1370 bttv_switch_overlay(struct bttv *btv, struct bttv_fh *fh,
1371 struct bttv_buffer *new)
1373 struct bttv_buffer *old;
1374 unsigned long flags;
1377 dprintk("switch_overlay: enter [new=%p]\n",new);
1379 new->vb.state = STATE_DONE;
1380 spin_lock_irqsave(&btv->s_lock,flags);
1384 bttv_set_dma(btv, 0x03);
1385 spin_unlock_irqrestore(&btv->s_lock,flags);
1387 free_btres(btv,fh,RESOURCE_OVERLAY);
1389 dprintk("switch_overlay: old=%p state is %d\n",old,old->vb.state);
1390 bttv_dma_free(btv, old);
1393 dprintk("switch_overlay: done\n");
1397 /* ----------------------------------------------------------------------- */
1398 /* video4linux (1) interface */
1400 static int bttv_prepare_buffer(struct bttv *btv, struct bttv_buffer *buf,
1401 const struct bttv_format *fmt,
1402 unsigned int width, unsigned int height,
1403 enum v4l2_field field)
1405 int redo_dma_risc = 0;
1408 /* check settings */
1411 if (fmt->btformat == BT848_COLOR_FMT_RAW) {
1413 height = RAW_LINES*2;
1414 if (width*height > buf->vb.bsize)
1416 buf->vb.size = buf->vb.bsize;
1420 width > bttv_tvnorms[btv->tvnorm].swidth ||
1421 height > bttv_tvnorms[btv->tvnorm].sheight)
1423 buf->vb.size = (width * height * fmt->depth) >> 3;
1424 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
1428 /* alloc + fill struct bttv_buffer (if changed) */
1429 if (buf->vb.width != width || buf->vb.height != height ||
1430 buf->vb.field != field ||
1431 buf->tvnorm != btv->tvnorm || buf->fmt != fmt) {
1432 buf->vb.width = width;
1433 buf->vb.height = height;
1434 buf->vb.field = field;
1435 buf->tvnorm = btv->tvnorm;
1440 /* alloc risc memory */
1441 if (STATE_NEEDS_INIT == buf->vb.state) {
1443 if (0 != (rc = videobuf_iolock(btv->c.pci,&buf->vb,&btv->fbuf)))
1448 if (0 != (rc = bttv_buffer_risc(btv,buf)))
1451 buf->vb.state = STATE_PREPARED;
1455 bttv_dma_free(btv,buf);
1460 buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
1462 struct bttv_fh *fh = q->priv_data;
1464 *size = fh->fmt->depth*fh->width*fh->height >> 3;
1467 while (*size * *count > gbuffers * gbufsize)
1473 buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
1474 enum v4l2_field field)
1476 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1477 struct bttv_fh *fh = q->priv_data;
1479 return bttv_prepare_buffer(fh->btv, buf, fh->fmt,
1480 fh->width, fh->height, field);
1484 buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
1486 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1487 struct bttv_fh *fh = q->priv_data;
1488 struct bttv *btv = fh->btv;
1490 buf->vb.state = STATE_QUEUED;
1491 list_add_tail(&buf->vb.queue,&btv->capture);
1492 if (!btv->curr.frame_irq) {
1494 bttv_set_dma(btv, 0x03);
1498 static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
1500 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1501 struct bttv_fh *fh = q->priv_data;
1503 bttv_dma_free(fh->btv,buf);
1506 static struct videobuf_queue_ops bttv_video_qops = {
1507 .buf_setup = buffer_setup,
1508 .buf_prepare = buffer_prepare,
1509 .buf_queue = buffer_queue,
1510 .buf_release = buffer_release,
1513 static const char *v4l1_ioctls[] = {
1514 "?", "CGAP", "GCHAN", "SCHAN", "GTUNER", "STUNER", "GPICT", "SPICT",
1515 "CCAPTURE", "GWIN", "SWIN", "GFBUF", "SFBUF", "KEY", "GFREQ",
1516 "SFREQ", "GAUDIO", "SAUDIO", "SYNC", "MCAPTURE", "GMBUF", "GUNIT",
1517 "GCAPTURE", "SCAPTURE", "SPLAYMODE", "SWRITEMODE", "GPLAYINFO",
1518 "SMICROCODE", "GVBIFMT", "SVBIFMT" };
1519 #define V4L1_IOCTLS ARRAY_SIZE(v4l1_ioctls)
1521 static int bttv_common_ioctls(struct bttv *btv, unsigned int cmd, void *arg)
1525 return BTTV_VERSION_CODE;
1527 /* *** v4l1 *** ************************************************ */
1530 unsigned long *freq = arg;
1536 unsigned long *freq = arg;
1539 bttv_call_i2c_clients(btv,VIDIOCSFREQ,freq);
1540 if (btv->has_matchbox && btv->radio_user)
1541 tea5757_set_freq(btv,*freq);
1548 struct video_tuner *v = arg;
1550 if (UNSET == bttv_tvcards[btv->c.type].tuner)
1552 if (v->tuner) /* Only tuner 0 */
1554 strcpy(v->name, "Television");
1556 v->rangehigh = 0x7FFFFFFF;
1557 v->flags = VIDEO_TUNER_PAL|VIDEO_TUNER_NTSC|VIDEO_TUNER_SECAM;
1558 v->mode = btv->tvnorm;
1559 v->signal = (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC) ? 0xFFFF : 0;
1560 bttv_call_i2c_clients(btv,cmd,v);
1565 struct video_tuner *v = arg;
1567 if (v->tuner) /* Only tuner 0 */
1569 if (v->mode >= BTTV_TVNORMS)
1573 set_tvnorm(btv,v->mode);
1574 bttv_call_i2c_clients(btv,cmd,v);
1581 struct video_channel *v = arg;
1582 unsigned int channel = v->channel;
1584 if (channel >= bttv_tvcards[btv->c.type].video_inputs)
1587 v->flags = VIDEO_VC_AUDIO;
1588 v->type = VIDEO_TYPE_CAMERA;
1589 v->norm = btv->tvnorm;
1590 if (channel == bttv_tvcards[btv->c.type].tuner) {
1591 strcpy(v->name,"Television");
1592 v->flags|=VIDEO_VC_TUNER;
1593 v->type=VIDEO_TYPE_TV;
1595 } else if (channel == btv->svhs) {
1596 strcpy(v->name,"S-Video");
1598 sprintf(v->name,"Composite%d",channel);
1604 struct video_channel *v = arg;
1605 unsigned int channel = v->channel;
1607 if (channel >= bttv_tvcards[btv->c.type].video_inputs)
1609 if (v->norm >= BTTV_TVNORMS)
1613 if (channel == btv->input &&
1614 v->norm == btv->tvnorm) {
1620 btv->tvnorm = v->norm;
1621 set_input(btv,v->channel);
1628 struct video_audio *v = arg;
1630 memset(v,0,sizeof(*v));
1631 strcpy(v->name,"Television");
1632 v->flags |= VIDEO_AUDIO_MUTABLE;
1633 v->mode = VIDEO_SOUND_MONO;
1636 bttv_call_i2c_clients(btv,cmd,v);
1638 /* card specific hooks */
1639 if (btv->audio_hook)
1640 btv->audio_hook(btv,v,0);
1647 struct video_audio *v = arg;
1648 unsigned int audio = v->audio;
1650 if (audio >= bttv_tvcards[btv->c.type].audio_inputs)
1654 audio_mux(btv, (v->flags&VIDEO_AUDIO_MUTE) ? AUDIO_MUTE : AUDIO_UNMUTE);
1655 bttv_call_i2c_clients(btv,cmd,v);
1657 /* card specific hooks */
1658 if (btv->audio_hook)
1659 btv->audio_hook(btv,v,1);
1665 /* *** v4l2 *** ************************************************ */
1666 case VIDIOC_ENUMSTD:
1668 struct v4l2_standard *e = arg;
1669 unsigned int index = e->index;
1671 if (index >= BTTV_TVNORMS)
1673 v4l2_video_std_construct(e, bttv_tvnorms[e->index].v4l2_id,
1674 bttv_tvnorms[e->index].name);
1680 v4l2_std_id *id = arg;
1681 *id = bttv_tvnorms[btv->tvnorm].v4l2_id;
1686 v4l2_std_id *id = arg;
1689 for (i = 0; i < BTTV_TVNORMS; i++)
1690 if (*id & bttv_tvnorms[i].v4l2_id)
1692 if (i == BTTV_TVNORMS)
1697 i2c_vidiocschan(btv);
1701 case VIDIOC_QUERYSTD:
1703 v4l2_std_id *id = arg;
1705 if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML)
1706 *id = V4L2_STD_625_50;
1708 *id = V4L2_STD_525_60;
1712 case VIDIOC_ENUMINPUT:
1714 struct v4l2_input *i = arg;
1718 if (n >= bttv_tvcards[btv->c.type].video_inputs)
1720 memset(i,0,sizeof(*i));
1722 i->type = V4L2_INPUT_TYPE_CAMERA;
1724 if (i->index == bttv_tvcards[btv->c.type].tuner) {
1725 sprintf(i->name, "Television");
1726 i->type = V4L2_INPUT_TYPE_TUNER;
1728 } else if (i->index == btv->svhs) {
1729 sprintf(i->name, "S-Video");
1731 sprintf(i->name,"Composite%d",i->index);
1733 if (i->index == btv->input) {
1734 __u32 dstatus = btread(BT848_DSTATUS);
1735 if (0 == (dstatus & BT848_DSTATUS_PRES))
1736 i->status |= V4L2_IN_ST_NO_SIGNAL;
1737 if (0 == (dstatus & BT848_DSTATUS_HLOC))
1738 i->status |= V4L2_IN_ST_NO_H_LOCK;
1740 for (n = 0; n < BTTV_TVNORMS; n++)
1741 i->std |= bttv_tvnorms[n].v4l2_id;
1744 case VIDIOC_G_INPUT:
1750 case VIDIOC_S_INPUT:
1752 unsigned int *i = arg;
1754 if (*i > bttv_tvcards[btv->c.type].video_inputs)
1762 case VIDIOC_G_TUNER:
1764 struct v4l2_tuner *t = arg;
1766 if (UNSET == bttv_tvcards[btv->c.type].tuner)
1771 memset(t,0,sizeof(*t));
1772 strcpy(t->name, "Television");
1773 t->type = V4L2_TUNER_ANALOG_TV;
1774 t->rangehigh = 0xffffffffUL;
1775 t->capability = V4L2_TUNER_CAP_NORM;
1776 t->rxsubchans = V4L2_TUNER_SUB_MONO;
1777 if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
1781 struct video_audio va;
1782 memset(&va, 0, sizeof(struct video_audio));
1783 bttv_call_i2c_clients(btv, VIDIOCGAUDIO, &va);
1784 if (btv->audio_hook)
1785 btv->audio_hook(btv,&va,0);
1786 if(va.mode & VIDEO_SOUND_STEREO) {
1787 t->audmode = V4L2_TUNER_MODE_STEREO;
1788 t->rxsubchans |= V4L2_TUNER_SUB_STEREO;
1790 if(va.mode & VIDEO_SOUND_LANG1) {
1791 t->audmode = V4L2_TUNER_MODE_LANG1;
1792 t->rxsubchans = V4L2_TUNER_SUB_LANG1
1793 | V4L2_TUNER_SUB_LANG2;
1796 /* FIXME: fill capability+audmode */
1800 case VIDIOC_S_TUNER:
1802 struct v4l2_tuner *t = arg;
1804 if (UNSET == bttv_tvcards[btv->c.type].tuner)
1810 struct video_audio va;
1811 memset(&va, 0, sizeof(struct video_audio));
1812 bttv_call_i2c_clients(btv, VIDIOCGAUDIO, &va);
1813 if (t->audmode == V4L2_TUNER_MODE_MONO)
1814 va.mode = VIDEO_SOUND_MONO;
1815 else if (t->audmode == V4L2_TUNER_MODE_STEREO)
1816 va.mode = VIDEO_SOUND_STEREO;
1817 else if (t->audmode == V4L2_TUNER_MODE_LANG1)
1818 va.mode = VIDEO_SOUND_LANG1;
1819 else if (t->audmode == V4L2_TUNER_MODE_LANG2)
1820 va.mode = VIDEO_SOUND_LANG2;
1821 bttv_call_i2c_clients(btv, VIDIOCSAUDIO, &va);
1822 if (btv->audio_hook)
1823 btv->audio_hook(btv,&va,1);
1829 case VIDIOC_G_FREQUENCY:
1831 struct v4l2_frequency *f = arg;
1833 memset(f,0,sizeof(*f));
1834 f->type = V4L2_TUNER_ANALOG_TV;
1835 f->frequency = btv->freq;
1838 case VIDIOC_S_FREQUENCY:
1840 struct v4l2_frequency *f = arg;
1842 if (unlikely(f->tuner != 0))
1844 if (unlikely (f->type != V4L2_TUNER_ANALOG_TV))
1847 btv->freq = f->frequency;
1848 bttv_call_i2c_clients(btv,VIDIOCSFREQ,&btv->freq);
1849 if (btv->has_matchbox && btv->radio_user)
1850 tea5757_set_freq(btv,btv->freq);
1854 case VIDIOC_LOG_STATUS:
1856 bttv_call_i2c_clients(btv, VIDIOC_LOG_STATUS, NULL);
1861 return -ENOIOCTLCMD;
1867 static int verify_window(const struct bttv_tvnorm *tvn,
1868 struct v4l2_window *win, int fixup)
1870 enum v4l2_field field;
1873 if (win->w.width < 48 || win->w.height < 32)
1875 if (win->clipcount > 2048)
1880 maxh = tvn->sheight;
1882 if (V4L2_FIELD_ANY == field) {
1883 field = (win->w.height > maxh/2)
1884 ? V4L2_FIELD_INTERLACED
1888 case V4L2_FIELD_TOP:
1889 case V4L2_FIELD_BOTTOM:
1892 case V4L2_FIELD_INTERLACED:
1898 if (!fixup && (win->w.width > maxw || win->w.height > maxh))
1901 if (win->w.width > maxw)
1902 win->w.width = maxw;
1903 if (win->w.height > maxh)
1904 win->w.height = maxh;
1909 static int setup_window(struct bttv_fh *fh, struct bttv *btv,
1910 struct v4l2_window *win, int fixup)
1912 struct v4l2_clip *clips = NULL;
1913 int n,size,retval = 0;
1915 if (NULL == fh->ovfmt)
1917 if (!(fh->ovfmt->flags & FORMAT_FLAGS_PACKED))
1919 retval = verify_window(&bttv_tvnorms[btv->tvnorm],win,fixup);
1923 /* copy clips -- luckily v4l1 + v4l2 are binary
1924 compatible here ...*/
1926 size = sizeof(*clips)*(n+4);
1927 clips = kmalloc(size,GFP_KERNEL);
1931 if (copy_from_user(clips,win->clips,sizeof(struct v4l2_clip)*n)) {
1936 /* clip against screen */
1937 if (NULL != btv->fbuf.base)
1938 n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height,
1940 btcx_sort_clips(clips,n);
1942 /* 4-byte alignments */
1943 switch (fh->ovfmt->depth) {
1946 btcx_align(&win->w, clips, n, 3);
1949 btcx_align(&win->w, clips, n, 1);
1952 /* no alignment fixups needed */
1958 down(&fh->cap.lock);
1959 kfree(fh->ov.clips);
1960 fh->ov.clips = clips;
1964 fh->ov.field = win->field;
1965 fh->ov.setup_ok = 1;
1966 btv->init.ov.w.width = win->w.width;
1967 btv->init.ov.w.height = win->w.height;
1968 btv->init.ov.field = win->field;
1970 /* update overlay if needed */
1972 if (check_btres(fh, RESOURCE_OVERLAY)) {
1973 struct bttv_buffer *new;
1975 new = videobuf_alloc(sizeof(*new));
1976 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
1977 retval = bttv_switch_overlay(btv,fh,new);
1983 /* ----------------------------------------------------------------------- */
1985 static struct videobuf_queue* bttv_queue(struct bttv_fh *fh)
1987 struct videobuf_queue* q = NULL;
1990 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
1993 case V4L2_BUF_TYPE_VBI_CAPTURE:
2002 static int bttv_resource(struct bttv_fh *fh)
2007 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2008 res = RESOURCE_VIDEO;
2010 case V4L2_BUF_TYPE_VBI_CAPTURE:
2019 static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type)
2021 struct videobuf_queue *q = bttv_queue(fh);
2022 int res = bttv_resource(fh);
2024 if (check_btres(fh,res))
2026 if (videobuf_queue_is_busy(q))
2033 pix_format_set_size (struct v4l2_pix_format * f,
2034 const struct bttv_format * fmt,
2036 unsigned int height)
2041 if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2042 f->bytesperline = width; /* Y plane */
2043 f->sizeimage = (width * height * fmt->depth) >> 3;
2045 f->bytesperline = (width * fmt->depth) >> 3;
2046 f->sizeimage = height * f->bytesperline;
2050 static int bttv_g_fmt(struct bttv_fh *fh, struct v4l2_format *f)
2053 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2054 memset(&f->fmt.pix,0,sizeof(struct v4l2_pix_format));
2055 pix_format_set_size (&f->fmt.pix, fh->fmt,
2056 fh->width, fh->height);
2057 f->fmt.pix.field = fh->cap.field;
2058 f->fmt.pix.pixelformat = fh->fmt->fourcc;
2060 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2061 memset(&f->fmt.win,0,sizeof(struct v4l2_window));
2062 f->fmt.win.w = fh->ov.w;
2063 f->fmt.win.field = fh->ov.field;
2065 case V4L2_BUF_TYPE_VBI_CAPTURE:
2066 bttv_vbi_get_fmt(fh,f);
2073 static int bttv_try_fmt(struct bttv_fh *fh, struct bttv *btv,
2074 struct v4l2_format *f)
2077 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2079 const struct bttv_format *fmt;
2080 enum v4l2_field field;
2081 unsigned int maxw,maxh;
2083 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2088 maxw = bttv_tvnorms[btv->tvnorm].swidth;
2089 maxh = bttv_tvnorms[btv->tvnorm].sheight;
2090 field = f->fmt.pix.field;
2091 if (V4L2_FIELD_ANY == field)
2092 field = (f->fmt.pix.height > maxh/2)
2093 ? V4L2_FIELD_INTERLACED
2094 : V4L2_FIELD_BOTTOM;
2095 if (V4L2_FIELD_SEQ_BT == field)
2096 field = V4L2_FIELD_SEQ_TB;
2098 case V4L2_FIELD_TOP:
2099 case V4L2_FIELD_BOTTOM:
2100 case V4L2_FIELD_ALTERNATE:
2103 case V4L2_FIELD_INTERLACED:
2105 case V4L2_FIELD_SEQ_TB:
2106 if (fmt->flags & FORMAT_FLAGS_PLANAR)
2113 /* update data for the application */
2114 f->fmt.pix.field = field;
2115 if (f->fmt.pix.width < 48)
2116 f->fmt.pix.width = 48;
2117 if (f->fmt.pix.height < 32)
2118 f->fmt.pix.height = 32;
2119 if (f->fmt.pix.width > maxw)
2120 f->fmt.pix.width = maxw;
2121 if (f->fmt.pix.height > maxh)
2122 f->fmt.pix.height = maxh;
2123 pix_format_set_size (&f->fmt.pix, fmt,
2124 f->fmt.pix.width & ~3,
2129 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2130 return verify_window(&bttv_tvnorms[btv->tvnorm],
2132 case V4L2_BUF_TYPE_VBI_CAPTURE:
2133 bttv_vbi_try_fmt(fh,f);
2140 static int bttv_s_fmt(struct bttv_fh *fh, struct bttv *btv,
2141 struct v4l2_format *f)
2146 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2148 const struct bttv_format *fmt;
2150 retval = bttv_switch_type(fh,f->type);
2153 retval = bttv_try_fmt(fh,btv,f);
2156 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2158 /* update our state informations */
2159 down(&fh->cap.lock);
2161 fh->cap.field = f->fmt.pix.field;
2162 fh->cap.last = V4L2_FIELD_NONE;
2163 fh->width = f->fmt.pix.width;
2164 fh->height = f->fmt.pix.height;
2165 btv->init.fmt = fmt;
2166 btv->init.width = f->fmt.pix.width;
2167 btv->init.height = f->fmt.pix.height;
2172 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2173 if (no_overlay > 0) {
2174 printk ("V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2177 return setup_window(fh, btv, &f->fmt.win, 1);
2178 case V4L2_BUF_TYPE_VBI_CAPTURE:
2179 retval = bttv_switch_type(fh,f->type);
2182 if (locked_btres(fh->btv, RESOURCE_VBI))
2184 bttv_vbi_try_fmt(fh,f);
2185 bttv_vbi_setlines(fh,btv,f->fmt.vbi.count[0]);
2186 bttv_vbi_get_fmt(fh,f);
2193 static int bttv_do_ioctl(struct inode *inode, struct file *file,
2194 unsigned int cmd, void *arg)
2196 struct bttv_fh *fh = file->private_data;
2197 struct bttv *btv = fh->btv;
2198 unsigned long flags;
2201 if (bttv_debug > 1) {
2202 switch (_IOC_TYPE(cmd)) {
2204 printk("bttv%d: ioctl 0x%x (v4l1, VIDIOC%s)\n",
2205 btv->c.nr, cmd, (_IOC_NR(cmd) < V4L1_IOCTLS) ?
2206 v4l1_ioctls[_IOC_NR(cmd)] : "???");
2209 printk("bttv%d: ioctl 0x%x (v4l2, %s)\n",
2210 btv->c.nr, cmd, v4l2_ioctl_names[_IOC_NR(cmd)]);
2213 printk("bttv%d: ioctl 0x%x (???)\n",
2218 bttv_reinit_bt848(btv);
2226 case VIDIOC_S_INPUT:
2227 case VIDIOC_S_TUNER:
2228 case VIDIOC_S_FREQUENCY:
2229 retval = v4l2_prio_check(&btv->prio,&fh->prio);
2236 /* *** v4l1 *** ************************************************ */
2239 struct video_capability *cap = arg;
2241 memset(cap,0,sizeof(*cap));
2242 strcpy(cap->name,btv->video_dev->name);
2243 if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
2245 cap->type = VID_TYPE_TUNER|VID_TYPE_TELETEXT;
2248 cap->type = VID_TYPE_CAPTURE|
2252 if (no_overlay <= 0)
2253 cap->type |= VID_TYPE_OVERLAY;
2255 cap->maxwidth = bttv_tvnorms[btv->tvnorm].swidth;
2256 cap->maxheight = bttv_tvnorms[btv->tvnorm].sheight;
2258 cap->minheight = 32;
2260 cap->channels = bttv_tvcards[btv->c.type].video_inputs;
2261 cap->audios = bttv_tvcards[btv->c.type].audio_inputs;
2267 struct video_picture *pic = arg;
2269 memset(pic,0,sizeof(*pic));
2270 pic->brightness = btv->bright;
2271 pic->contrast = btv->contrast;
2272 pic->hue = btv->hue;
2273 pic->colour = btv->saturation;
2275 pic->depth = fh->fmt->depth;
2276 pic->palette = fh->fmt->palette;
2282 struct video_picture *pic = arg;
2283 const struct bttv_format *fmt;
2285 fmt = format_by_palette(pic->palette);
2288 down(&fh->cap.lock);
2289 if (fmt->depth != pic->depth) {
2291 goto fh_unlock_and_return;
2295 btv->init.ovfmt = fmt;
2296 btv->init.fmt = fmt;
2298 /* dirty hack time: swap bytes for overlay if the
2299 display adaptor is big endian (insmod option) */
2300 if (fmt->palette == VIDEO_PALETTE_RGB555 ||
2301 fmt->palette == VIDEO_PALETTE_RGB565 ||
2302 fmt->palette == VIDEO_PALETTE_RGB32) {
2306 bt848_bright(btv,pic->brightness);
2307 bt848_contrast(btv,pic->contrast);
2308 bt848_hue(btv,pic->hue);
2309 bt848_sat(btv,pic->colour);
2316 struct video_window *win = arg;
2318 memset(win,0,sizeof(*win));
2319 win->x = fh->ov.w.left;
2320 win->y = fh->ov.w.top;
2321 win->width = fh->ov.w.width;
2322 win->height = fh->ov.w.height;
2327 struct video_window *win = arg;
2328 struct v4l2_window w2;
2330 if (no_overlay > 0) {
2331 printk ("VIDIOCSWIN: no_overlay\n");
2335 w2.field = V4L2_FIELD_ANY;
2338 w2.w.width = win->width;
2339 w2.w.height = win->height;
2340 w2.clipcount = win->clipcount;
2341 w2.clips = (struct v4l2_clip __user *)win->clips;
2342 retval = setup_window(fh, btv, &w2, 0);
2344 /* on v4l1 this ioctl affects the read() size too */
2345 fh->width = fh->ov.w.width;
2346 fh->height = fh->ov.w.height;
2347 btv->init.width = fh->ov.w.width;
2348 btv->init.height = fh->ov.w.height;
2355 struct video_buffer *fbuf = arg;
2357 fbuf->base = btv->fbuf.base;
2358 fbuf->width = btv->fbuf.fmt.width;
2359 fbuf->height = btv->fbuf.fmt.height;
2360 fbuf->bytesperline = btv->fbuf.fmt.bytesperline;
2362 fbuf->depth = fh->ovfmt->depth;
2367 struct video_buffer *fbuf = arg;
2368 const struct bttv_format *fmt;
2371 if(!capable(CAP_SYS_ADMIN) &&
2372 !capable(CAP_SYS_RAWIO))
2374 end = (unsigned long)fbuf->base +
2375 fbuf->height * fbuf->bytesperline;
2376 down(&fh->cap.lock);
2379 switch (fbuf->depth) {
2381 fmt = format_by_palette(VIDEO_PALETTE_HI240);
2384 fmt = format_by_palette(VIDEO_PALETTE_RGB565);
2387 fmt = format_by_palette(VIDEO_PALETTE_RGB24);
2390 fmt = format_by_palette(VIDEO_PALETTE_RGB32);
2394 fmt = format_by_palette(VIDEO_PALETTE_RGB555);
2401 goto fh_unlock_and_return;
2405 btv->init.ovfmt = fmt;
2406 btv->init.fmt = fmt;
2407 btv->fbuf.base = fbuf->base;
2408 btv->fbuf.fmt.width = fbuf->width;
2409 btv->fbuf.fmt.height = fbuf->height;
2410 if (fbuf->bytesperline)
2411 btv->fbuf.fmt.bytesperline = fbuf->bytesperline;
2413 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fbuf->depth/8;
2419 case VIDIOC_OVERLAY:
2421 struct bttv_buffer *new;
2426 if (NULL == btv->fbuf.base)
2428 if (!fh->ov.setup_ok) {
2429 dprintk("bttv%d: overlay: !setup_ok\n",btv->c.nr);
2434 if (!check_alloc_btres(btv,fh,RESOURCE_OVERLAY))
2437 down(&fh->cap.lock);
2439 fh->ov.tvnorm = btv->tvnorm;
2440 new = videobuf_alloc(sizeof(*new));
2441 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2447 retval = bttv_switch_overlay(btv,fh,new);
2454 struct video_mbuf *mbuf = arg;
2457 down(&fh->cap.lock);
2458 retval = videobuf_mmap_setup(&fh->cap,gbuffers,gbufsize,
2461 goto fh_unlock_and_return;
2462 memset(mbuf,0,sizeof(*mbuf));
2463 mbuf->frames = gbuffers;
2464 mbuf->size = gbuffers * gbufsize;
2465 for (i = 0; i < gbuffers; i++)
2466 mbuf->offsets[i] = i * gbufsize;
2470 case VIDIOCMCAPTURE:
2472 struct video_mmap *vm = arg;
2473 struct bttv_buffer *buf;
2474 enum v4l2_field field;
2476 if (vm->frame >= VIDEO_MAX_FRAME)
2479 down(&fh->cap.lock);
2481 buf = (struct bttv_buffer *)fh->cap.bufs[vm->frame];
2483 goto fh_unlock_and_return;
2484 if (0 == buf->vb.baddr)
2485 goto fh_unlock_and_return;
2486 if (buf->vb.state == STATE_QUEUED ||
2487 buf->vb.state == STATE_ACTIVE)
2488 goto fh_unlock_and_return;
2490 field = (vm->height > bttv_tvnorms[btv->tvnorm].sheight/2)
2491 ? V4L2_FIELD_INTERLACED
2492 : V4L2_FIELD_BOTTOM;
2493 retval = bttv_prepare_buffer(btv,buf,
2494 format_by_palette(vm->format),
2495 vm->width,vm->height,field);
2497 goto fh_unlock_and_return;
2498 spin_lock_irqsave(&btv->s_lock,flags);
2499 buffer_queue(&fh->cap,&buf->vb);
2500 spin_unlock_irqrestore(&btv->s_lock,flags);
2507 struct bttv_buffer *buf;
2509 if (*frame >= VIDEO_MAX_FRAME)
2512 down(&fh->cap.lock);
2514 buf = (struct bttv_buffer *)fh->cap.bufs[*frame];
2516 goto fh_unlock_and_return;
2517 retval = videobuf_waiton(&buf->vb,0,1);
2519 goto fh_unlock_and_return;
2520 switch (buf->vb.state) {
2525 videobuf_dma_pci_sync(btv->c.pci,&buf->vb.dma);
2526 bttv_dma_free(btv,buf);
2538 struct vbi_format *fmt = (void *) arg;
2539 struct v4l2_format fmt2;
2541 if (fh->type != V4L2_BUF_TYPE_VBI_CAPTURE) {
2542 retval = bttv_switch_type(fh,V4L2_BUF_TYPE_VBI_CAPTURE);
2546 bttv_vbi_get_fmt(fh, &fmt2);
2548 memset(fmt,0,sizeof(*fmt));
2549 fmt->sampling_rate = fmt2.fmt.vbi.sampling_rate;
2550 fmt->samples_per_line = fmt2.fmt.vbi.samples_per_line;
2551 fmt->sample_format = VIDEO_PALETTE_RAW;
2552 fmt->start[0] = fmt2.fmt.vbi.start[0];
2553 fmt->count[0] = fmt2.fmt.vbi.count[0];
2554 fmt->start[1] = fmt2.fmt.vbi.start[1];
2555 fmt->count[1] = fmt2.fmt.vbi.count[1];
2556 if (fmt2.fmt.vbi.flags & VBI_UNSYNC)
2557 fmt->flags |= V4L2_VBI_UNSYNC;
2558 if (fmt2.fmt.vbi.flags & VBI_INTERLACED)
2559 fmt->flags |= V4L2_VBI_INTERLACED;
2564 struct vbi_format *fmt = (void *) arg;
2565 struct v4l2_format fmt2;
2567 retval = bttv_switch_type(fh,V4L2_BUF_TYPE_VBI_CAPTURE);
2570 bttv_vbi_get_fmt(fh, &fmt2);
2572 if (fmt->sampling_rate != fmt2.fmt.vbi.sampling_rate ||
2573 fmt->samples_per_line != fmt2.fmt.vbi.samples_per_line ||
2574 fmt->sample_format != VIDEO_PALETTE_RAW ||
2575 fmt->start[0] != fmt2.fmt.vbi.start[0] ||
2576 fmt->start[1] != fmt2.fmt.vbi.start[1] ||
2577 fmt->count[0] != fmt->count[1] ||
2578 fmt->count[0] < 1 ||
2579 fmt->count[0] > 32 /* VBI_MAXLINES */)
2582 bttv_vbi_setlines(fh,btv,fmt->count[0]);
2595 return bttv_common_ioctls(btv,cmd,arg);
2597 /* *** v4l2 *** ************************************************ */
2598 case VIDIOC_QUERYCAP:
2600 struct v4l2_capability *cap = arg;
2604 strcpy(cap->driver,"bttv");
2605 strlcpy(cap->card,btv->video_dev->name,sizeof(cap->card));
2606 sprintf(cap->bus_info,"PCI:%s",pci_name(btv->c.pci));
2607 cap->version = BTTV_VERSION_CODE;
2609 V4L2_CAP_VIDEO_CAPTURE |
2610 V4L2_CAP_VBI_CAPTURE |
2611 V4L2_CAP_READWRITE |
2613 if (no_overlay <= 0)
2614 cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
2616 if (bttv_tvcards[btv->c.type].tuner != UNSET &&
2617 bttv_tvcards[btv->c.type].tuner != TUNER_ABSENT)
2618 cap->capabilities |= V4L2_CAP_TUNER;
2622 case VIDIOC_ENUM_FMT:
2624 struct v4l2_fmtdesc *f = arg;
2625 enum v4l2_buf_type type;
2630 if (V4L2_BUF_TYPE_VBI_CAPTURE == type) {
2635 memset(f,0,sizeof(*f));
2638 f->pixelformat = V4L2_PIX_FMT_GREY;
2639 strcpy(f->description,"vbi data");
2643 /* video capture + overlay */
2645 for (i = 0; i < BTTV_FORMATS; i++) {
2646 if (bttv_formats[i].fourcc != -1)
2648 if ((unsigned int)index == f->index)
2651 if (BTTV_FORMATS == i)
2655 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2657 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2658 if (!(bttv_formats[i].flags & FORMAT_FLAGS_PACKED))
2664 memset(f,0,sizeof(*f));
2667 f->pixelformat = bttv_formats[i].fourcc;
2668 strlcpy(f->description,bttv_formats[i].name,sizeof(f->description));
2672 case VIDIOC_TRY_FMT:
2674 struct v4l2_format *f = arg;
2675 return bttv_try_fmt(fh,btv,f);
2679 struct v4l2_format *f = arg;
2680 return bttv_g_fmt(fh,f);
2684 struct v4l2_format *f = arg;
2685 return bttv_s_fmt(fh,btv,f);
2690 struct v4l2_framebuffer *fb = arg;
2693 fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
2695 fb->fmt.pixelformat = fh->ovfmt->fourcc;
2700 struct v4l2_framebuffer *fb = arg;
2701 const struct bttv_format *fmt;
2703 if(!capable(CAP_SYS_ADMIN) &&
2704 !capable(CAP_SYS_RAWIO))
2708 fmt = format_by_fourcc(fb->fmt.pixelformat);
2711 if (0 == (fmt->flags & FORMAT_FLAGS_PACKED))
2714 down(&fh->cap.lock);
2716 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2717 if (fb->fmt.width > bttv_tvnorms[btv->tvnorm].swidth)
2718 goto fh_unlock_and_return;
2719 if (fb->fmt.height > bttv_tvnorms[btv->tvnorm].sheight)
2720 goto fh_unlock_and_return;
2724 btv->fbuf.base = fb->base;
2725 btv->fbuf.fmt.width = fb->fmt.width;
2726 btv->fbuf.fmt.height = fb->fmt.height;
2727 if (0 != fb->fmt.bytesperline)
2728 btv->fbuf.fmt.bytesperline = fb->fmt.bytesperline;
2730 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fmt->depth/8;
2734 btv->init.ovfmt = fmt;
2735 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2738 fh->ov.w.width = fb->fmt.width;
2739 fh->ov.w.height = fb->fmt.height;
2740 btv->init.ov.w.width = fb->fmt.width;
2741 btv->init.ov.w.height = fb->fmt.height;
2742 kfree(fh->ov.clips);
2743 fh->ov.clips = NULL;
2746 if (check_btres(fh, RESOURCE_OVERLAY)) {
2747 struct bttv_buffer *new;
2749 new = videobuf_alloc(sizeof(*new));
2750 bttv_overlay_risc(btv,&fh->ov,fh->ovfmt,new);
2751 retval = bttv_switch_overlay(btv,fh,new);
2758 case VIDIOC_REQBUFS:
2759 return videobuf_reqbufs(bttv_queue(fh),arg);
2761 case VIDIOC_QUERYBUF:
2762 return videobuf_querybuf(bttv_queue(fh),arg);
2765 return videobuf_qbuf(bttv_queue(fh),arg);
2768 return videobuf_dqbuf(bttv_queue(fh),arg,
2769 file->f_flags & O_NONBLOCK);
2771 case VIDIOC_STREAMON:
2773 int res = bttv_resource(fh);
2775 if (!check_alloc_btres(btv,fh,res))
2777 return videobuf_streamon(bttv_queue(fh));
2779 case VIDIOC_STREAMOFF:
2781 int res = bttv_resource(fh);
2783 retval = videobuf_streamoff(bttv_queue(fh));
2786 free_btres(btv,fh,res);
2790 case VIDIOC_QUERYCTRL:
2792 struct v4l2_queryctrl *c = arg;
2795 if ((c->id < V4L2_CID_BASE ||
2796 c->id >= V4L2_CID_LASTP1) &&
2797 (c->id < V4L2_CID_PRIVATE_BASE ||
2798 c->id >= V4L2_CID_PRIVATE_LASTP1))
2800 for (i = 0; i < BTTV_CTLS; i++)
2801 if (bttv_ctls[i].id == c->id)
2803 if (i == BTTV_CTLS) {
2808 if (i >= 4 && i <= 8) {
2809 struct video_audio va;
2810 memset(&va,0,sizeof(va));
2811 bttv_call_i2c_clients(btv, VIDIOCGAUDIO, &va);
2812 if (btv->audio_hook)
2813 btv->audio_hook(btv,&va,0);
2814 switch (bttv_ctls[i].id) {
2815 case V4L2_CID_AUDIO_VOLUME:
2816 if (!(va.flags & VIDEO_AUDIO_VOLUME))
2819 case V4L2_CID_AUDIO_BALANCE:
2820 if (!(va.flags & VIDEO_AUDIO_BALANCE))
2823 case V4L2_CID_AUDIO_BASS:
2824 if (!(va.flags & VIDEO_AUDIO_BASS))
2827 case V4L2_CID_AUDIO_TREBLE:
2828 if (!(va.flags & VIDEO_AUDIO_TREBLE))
2836 return get_control(btv,arg);
2838 return set_control(btv,arg);
2841 struct v4l2_streamparm *parm = arg;
2842 struct v4l2_standard s;
2843 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2845 memset(parm,0,sizeof(*parm));
2846 v4l2_video_std_construct(&s, bttv_tvnorms[btv->tvnorm].v4l2_id,
2847 bttv_tvnorms[btv->tvnorm].name);
2848 parm->parm.capture.timeperframe = s.frameperiod;
2852 case VIDIOC_G_PRIORITY:
2854 enum v4l2_priority *p = arg;
2856 *p = v4l2_prio_max(&btv->prio);
2859 case VIDIOC_S_PRIORITY:
2861 enum v4l2_priority *prio = arg;
2863 return v4l2_prio_change(&btv->prio, &fh->prio, *prio);
2866 case VIDIOC_ENUMSTD:
2869 case VIDIOC_ENUMINPUT:
2870 case VIDIOC_G_INPUT:
2871 case VIDIOC_S_INPUT:
2872 case VIDIOC_G_TUNER:
2873 case VIDIOC_S_TUNER:
2874 case VIDIOC_G_FREQUENCY:
2875 case VIDIOC_S_FREQUENCY:
2876 case VIDIOC_LOG_STATUS:
2877 return bttv_common_ioctls(btv,cmd,arg);
2880 return -ENOIOCTLCMD;
2884 fh_unlock_and_return:
2889 static int bttv_ioctl(struct inode *inode, struct file *file,
2890 unsigned int cmd, unsigned long arg)
2892 struct bttv_fh *fh = file->private_data;
2896 bttv_switch_type(fh,V4L2_BUF_TYPE_VBI_CAPTURE);
2897 return fh->lines * 2 * 2048;
2899 return video_usercopy(inode, file, cmd, arg, bttv_do_ioctl);
2903 static ssize_t bttv_read(struct file *file, char __user *data,
2904 size_t count, loff_t *ppos)
2906 struct bttv_fh *fh = file->private_data;
2909 if (fh->btv->errors)
2910 bttv_reinit_bt848(fh->btv);
2911 dprintk("bttv%d: read count=%d type=%s\n",
2912 fh->btv->c.nr,(int)count,v4l2_type_names[fh->type]);
2915 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2916 if (locked_btres(fh->btv,RESOURCE_VIDEO))
2918 retval = videobuf_read_one(&fh->cap, data, count, ppos,
2919 file->f_flags & O_NONBLOCK);
2921 case V4L2_BUF_TYPE_VBI_CAPTURE:
2922 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
2924 retval = videobuf_read_stream(&fh->vbi, data, count, ppos, 1,
2925 file->f_flags & O_NONBLOCK);
2933 static unsigned int bttv_poll(struct file *file, poll_table *wait)
2935 struct bttv_fh *fh = file->private_data;
2936 struct bttv_buffer *buf;
2937 enum v4l2_field field;
2939 if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
2940 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
2942 return videobuf_poll_stream(file, &fh->vbi, wait);
2945 if (check_btres(fh,RESOURCE_VIDEO)) {
2946 /* streaming capture */
2947 if (list_empty(&fh->cap.stream))
2949 buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
2951 /* read() capture */
2952 down(&fh->cap.lock);
2953 if (NULL == fh->cap.read_buf) {
2954 /* need to capture a new frame */
2955 if (locked_btres(fh->btv,RESOURCE_VIDEO)) {
2959 fh->cap.read_buf = videobuf_alloc(fh->cap.msize);
2960 if (NULL == fh->cap.read_buf) {
2964 fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
2965 field = videobuf_next_field(&fh->cap);
2966 if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) {
2967 kfree (fh->cap.read_buf);
2968 fh->cap.read_buf = NULL;
2972 fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
2973 fh->cap.read_off = 0;
2976 buf = (struct bttv_buffer*)fh->cap.read_buf;
2979 poll_wait(file, &buf->vb.done, wait);
2980 if (buf->vb.state == STATE_DONE ||
2981 buf->vb.state == STATE_ERROR)
2982 return POLLIN|POLLRDNORM;
2986 static int bttv_open(struct inode *inode, struct file *file)
2988 int minor = iminor(inode);
2989 struct bttv *btv = NULL;
2991 enum v4l2_buf_type type = 0;
2994 dprintk(KERN_DEBUG "bttv: open minor=%d\n",minor);
2996 for (i = 0; i < bttv_num; i++) {
2997 if (bttvs[i].video_dev &&
2998 bttvs[i].video_dev->minor == minor) {
3000 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
3003 if (bttvs[i].vbi_dev &&
3004 bttvs[i].vbi_dev->minor == minor) {
3006 type = V4L2_BUF_TYPE_VBI_CAPTURE;
3013 dprintk(KERN_DEBUG "bttv%d: open called (type=%s)\n",
3014 btv->c.nr,v4l2_type_names[type]);
3016 /* allocate per filehandle data */
3017 fh = kmalloc(sizeof(*fh),GFP_KERNEL);
3020 file->private_data = fh;
3023 fh->ov.setup_ok = 0;
3024 v4l2_prio_open(&btv->prio,&fh->prio);
3026 videobuf_queue_init(&fh->cap, &bttv_video_qops,
3027 btv->c.pci, &btv->s_lock,
3028 V4L2_BUF_TYPE_VIDEO_CAPTURE,
3029 V4L2_FIELD_INTERLACED,
3030 sizeof(struct bttv_buffer),
3032 videobuf_queue_init(&fh->vbi, &bttv_vbi_qops,
3033 btv->c.pci, &btv->s_lock,
3034 V4L2_BUF_TYPE_VBI_CAPTURE,
3036 sizeof(struct bttv_buffer),
3038 i2c_vidiocschan(btv);
3041 if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type)
3042 bttv_vbi_setlines(fh,btv,16);
3043 bttv_field_count(btv);
3047 static int bttv_release(struct inode *inode, struct file *file)
3049 struct bttv_fh *fh = file->private_data;
3050 struct bttv *btv = fh->btv;
3052 /* turn off overlay */
3053 if (check_btres(fh, RESOURCE_OVERLAY))
3054 bttv_switch_overlay(btv,fh,NULL);
3056 /* stop video capture */
3057 if (check_btres(fh, RESOURCE_VIDEO)) {
3058 videobuf_streamoff(&fh->cap);
3059 free_btres(btv,fh,RESOURCE_VIDEO);
3061 if (fh->cap.read_buf) {
3062 buffer_release(&fh->cap,fh->cap.read_buf);
3063 kfree(fh->cap.read_buf);
3066 /* stop vbi capture */
3067 if (check_btres(fh, RESOURCE_VBI)) {
3068 if (fh->vbi.streaming)
3069 videobuf_streamoff(&fh->vbi);
3070 if (fh->vbi.reading)
3071 videobuf_read_stop(&fh->vbi);
3072 free_btres(btv,fh,RESOURCE_VBI);
3076 videobuf_mmap_free(&fh->cap);
3077 videobuf_mmap_free(&fh->vbi);
3078 v4l2_prio_close(&btv->prio,&fh->prio);
3079 file->private_data = NULL;
3083 bttv_field_count(btv);
3088 bttv_mmap(struct file *file, struct vm_area_struct *vma)
3090 struct bttv_fh *fh = file->private_data;
3092 dprintk("bttv%d: mmap type=%s 0x%lx+%ld\n",
3093 fh->btv->c.nr, v4l2_type_names[fh->type],
3094 vma->vm_start, vma->vm_end - vma->vm_start);
3095 return videobuf_mmap_mapper(bttv_queue(fh),vma);
3098 static struct file_operations bttv_fops =
3100 .owner = THIS_MODULE,
3102 .release = bttv_release,
3103 .ioctl = bttv_ioctl,
3104 .llseek = no_llseek,
3110 static struct video_device bttv_video_template =
3113 .type = VID_TYPE_CAPTURE|VID_TYPE_TUNER|
3114 VID_TYPE_CLIPPING|VID_TYPE_SCALES,
3115 .hardware = VID_HARDWARE_BT848,
3120 static struct video_device bttv_vbi_template =
3122 .name = "bt848/878 vbi",
3123 .type = VID_TYPE_TUNER|VID_TYPE_TELETEXT,
3124 .hardware = VID_HARDWARE_BT848,
3129 /* ----------------------------------------------------------------------- */
3130 /* radio interface */
3132 static int radio_open(struct inode *inode, struct file *file)
3134 int minor = iminor(inode);
3135 struct bttv *btv = NULL;
3138 dprintk("bttv: open minor=%d\n",minor);
3140 for (i = 0; i < bttv_num; i++) {
3141 if (bttvs[i].radio_dev->minor == minor) {
3149 dprintk("bttv%d: open called (radio)\n",btv->c.nr);
3154 file->private_data = btv;
3156 bttv_call_i2c_clients(btv,AUDC_SET_RADIO,&btv->tuner_type);
3157 audio_mux(btv,AUDIO_RADIO);
3163 static int radio_release(struct inode *inode, struct file *file)
3165 struct bttv *btv = file->private_data;
3166 struct rds_command cmd;
3170 bttv_call_i2c_clients(btv, RDS_CMD_CLOSE, &cmd);
3175 static int radio_do_ioctl(struct inode *inode, struct file *file,
3176 unsigned int cmd, void *arg)
3178 struct bttv *btv = file->private_data;
3183 struct video_capability *cap = arg;
3185 memset(cap,0,sizeof(*cap));
3186 strcpy(cap->name,btv->radio_dev->name);
3187 cap->type = VID_TYPE_TUNER;
3195 struct video_tuner *v = arg;
3199 memset(v,0,sizeof(*v));
3200 strcpy(v->name, "Radio");
3201 bttv_call_i2c_clients(btv,cmd,v);
3213 return bttv_common_ioctls(btv,cmd,arg);
3216 return -ENOIOCTLCMD;
3221 static int radio_ioctl(struct inode *inode, struct file *file,
3222 unsigned int cmd, unsigned long arg)
3224 return video_usercopy(inode, file, cmd, arg, radio_do_ioctl);
3227 static ssize_t radio_read(struct file *file, char __user *data,
3228 size_t count, loff_t *ppos)
3230 struct bttv *btv = file->private_data;
3231 struct rds_command cmd;
3232 cmd.block_count = count/3;
3234 cmd.instance = file;
3235 cmd.result = -ENODEV;
3237 bttv_call_i2c_clients(btv, RDS_CMD_READ, &cmd);
3242 static unsigned int radio_poll(struct file *file, poll_table *wait)
3244 struct bttv *btv = file->private_data;
3245 struct rds_command cmd;
3246 cmd.instance = file;
3247 cmd.event_list = wait;
3248 cmd.result = -ENODEV;
3249 bttv_call_i2c_clients(btv, RDS_CMD_POLL, &cmd);
3254 static struct file_operations radio_fops =
3256 .owner = THIS_MODULE,
3259 .release = radio_release,
3260 .ioctl = radio_ioctl,
3261 .llseek = no_llseek,
3265 static struct video_device radio_template =
3267 .name = "bt848/878 radio",
3268 .type = VID_TYPE_TUNER,
3269 .hardware = VID_HARDWARE_BT848,
3270 .fops = &radio_fops,
3274 /* ----------------------------------------------------------------------- */
3275 /* some debug code */
3277 static int bttv_risc_decode(u32 risc)
3279 static char *instr[16] = {
3280 [ BT848_RISC_WRITE >> 28 ] = "write",
3281 [ BT848_RISC_SKIP >> 28 ] = "skip",
3282 [ BT848_RISC_WRITEC >> 28 ] = "writec",
3283 [ BT848_RISC_JUMP >> 28 ] = "jump",
3284 [ BT848_RISC_SYNC >> 28 ] = "sync",
3285 [ BT848_RISC_WRITE123 >> 28 ] = "write123",
3286 [ BT848_RISC_SKIP123 >> 28 ] = "skip123",
3287 [ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
3289 static int incr[16] = {
3290 [ BT848_RISC_WRITE >> 28 ] = 2,
3291 [ BT848_RISC_JUMP >> 28 ] = 2,
3292 [ BT848_RISC_SYNC >> 28 ] = 2,
3293 [ BT848_RISC_WRITE123 >> 28 ] = 5,
3294 [ BT848_RISC_SKIP123 >> 28 ] = 2,
3295 [ BT848_RISC_WRITE1S23 >> 28 ] = 3,
3297 static char *bits[] = {
3298 "be0", "be1", "be2", "be3/resync",
3299 "set0", "set1", "set2", "set3",
3300 "clr0", "clr1", "clr2", "clr3",
3301 "irq", "res", "eol", "sol",
3305 printk("0x%08x [ %s", risc,
3306 instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
3307 for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
3308 if (risc & (1 << (i + 12)))
3309 printk(" %s",bits[i]);
3310 printk(" count=%d ]\n", risc & 0xfff);
3311 return incr[risc >> 28] ? incr[risc >> 28] : 1;
3314 static void bttv_risc_disasm(struct bttv *btv,
3315 struct btcx_riscmem *risc)
3319 printk("%s: risc disasm: %p [dma=0x%08lx]\n",
3320 btv->c.name, risc->cpu, (unsigned long)risc->dma);
3321 for (i = 0; i < (risc->size >> 2); i += n) {
3322 printk("%s: 0x%lx: ", btv->c.name,
3323 (unsigned long)(risc->dma + (i<<2)));
3324 n = bttv_risc_decode(risc->cpu[i]);
3325 for (j = 1; j < n; j++)
3326 printk("%s: 0x%lx: 0x%08x [ arg #%d ]\n",
3327 btv->c.name, (unsigned long)(risc->dma + ((i+j)<<2)),
3329 if (0 == risc->cpu[i])
3334 static void bttv_print_riscaddr(struct bttv *btv)
3336 printk(" main: %08Lx\n",
3337 (unsigned long long)btv->main.dma);
3338 printk(" vbi : o=%08Lx e=%08Lx\n",
3339 btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
3340 btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
3341 printk(" cap : o=%08Lx e=%08Lx\n",
3342 btv->curr.top ? (unsigned long long)btv->curr.top->top.dma : 0,
3343 btv->curr.bottom ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
3344 printk(" scr : o=%08Lx e=%08Lx\n",
3345 btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
3346 btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
3347 bttv_risc_disasm(btv, &btv->main);
3350 /* ----------------------------------------------------------------------- */
3353 static char *irq_name[] = {
3354 "FMTCHG", // format change detected (525 vs. 625)
3355 "VSYNC", // vertical sync (new field)
3356 "HSYNC", // horizontal sync
3357 "OFLOW", // chroma/luma AGC overflow
3358 "HLOCK", // horizontal lock changed
3359 "VPRES", // video presence changed
3361 "I2CDONE", // hw irc operation finished
3362 "GPINT", // gpio port triggered irq
3364 "RISCI", // risc instruction triggered irq
3365 "FBUS", // pixel data fifo dropped data (high pci bus latencies)
3366 "FTRGT", // pixel data fifo overrun
3367 "FDSR", // fifo data stream resyncronisation
3368 "PPERR", // parity error (data transfer)
3369 "RIPERR", // parity error (read risc instructions)
3370 "PABORT", // pci abort
3371 "OCERR", // risc instruction error
3372 "SCERR", // syncronisation error
3375 static void bttv_print_irqbits(u32 print, u32 mark)
3380 for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
3381 if (print & (1 << i))
3382 printk(" %s",irq_name[i]);
3383 if (mark & (1 << i))
3388 static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
3390 printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
3392 (unsigned long)btv->main.dma,
3393 (unsigned long)btv->main.cpu[RISC_SLOT_O_VBI+1],
3394 (unsigned long)btv->main.cpu[RISC_SLOT_O_FIELD+1],
3397 if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) {
3398 printk("bttv%d: Oh, there (temporarely?) is no input signal. "
3399 "Ok, then this is harmless, don't worry ;)\n",
3403 printk("bttv%d: Uhm. Looks like we have unusual high IRQ latencies.\n",
3405 printk("bttv%d: Lets try to catch the culpit red-handed ...\n",
3411 bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set)
3413 struct bttv_buffer *item;
3415 memset(set,0,sizeof(*set));
3417 /* capture request ? */
3418 if (!list_empty(&btv->capture)) {
3420 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3421 if (V4L2_FIELD_HAS_TOP(item->vb.field))
3423 if (V4L2_FIELD_HAS_BOTTOM(item->vb.field))
3426 /* capture request for other field ? */
3427 if (!V4L2_FIELD_HAS_BOTH(item->vb.field) &&
3428 (item->vb.queue.next != &btv->capture)) {
3429 item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue);
3430 if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) {
3431 if (NULL == set->top &&
3432 V4L2_FIELD_TOP == item->vb.field) {
3435 if (NULL == set->bottom &&
3436 V4L2_FIELD_BOTTOM == item->vb.field) {
3439 if (NULL != set->top && NULL != set->bottom)
3445 /* screen overlay ? */
3446 if (NULL != btv->screen) {
3447 if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) {
3448 if (NULL == set->top && NULL == set->bottom) {
3449 set->top = btv->screen;
3450 set->bottom = btv->screen;
3453 if (V4L2_FIELD_TOP == btv->screen->vb.field &&
3455 set->top = btv->screen;
3457 if (V4L2_FIELD_BOTTOM == btv->screen->vb.field &&
3458 NULL == set->bottom) {
3459 set->bottom = btv->screen;
3464 dprintk("bttv%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
3465 btv->c.nr,set->top, set->bottom,
3466 btv->screen,set->frame_irq,set->top_irq);
3471 bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
3472 struct bttv_buffer_set *curr, unsigned int state)
3476 do_gettimeofday(&ts);
3478 if (wakeup->top == wakeup->bottom) {
3479 if (NULL != wakeup->top && curr->top != wakeup->top) {
3481 printk("bttv%d: wakeup: both=%p\n",btv->c.nr,wakeup->top);
3482 wakeup->top->vb.ts = ts;
3483 wakeup->top->vb.field_count = btv->field_count;
3484 wakeup->top->vb.state = state;
3485 wake_up(&wakeup->top->vb.done);
3488 if (NULL != wakeup->top && curr->top != wakeup->top) {
3490 printk("bttv%d: wakeup: top=%p\n",btv->c.nr,wakeup->top);
3491 wakeup->top->vb.ts = ts;
3492 wakeup->top->vb.field_count = btv->field_count;
3493 wakeup->top->vb.state = state;
3494 wake_up(&wakeup->top->vb.done);
3496 if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
3498 printk("bttv%d: wakeup: bottom=%p\n",btv->c.nr,wakeup->bottom);
3499 wakeup->bottom->vb.ts = ts;
3500 wakeup->bottom->vb.field_count = btv->field_count;
3501 wakeup->bottom->vb.state = state;
3502 wake_up(&wakeup->bottom->vb.done);
3508 bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
3516 do_gettimeofday(&ts);
3518 wakeup->vb.field_count = btv->field_count;
3519 wakeup->vb.state = state;
3520 wake_up(&wakeup->vb.done);
3523 static void bttv_irq_timeout(unsigned long data)
3525 struct bttv *btv = (struct bttv *)data;
3526 struct bttv_buffer_set old,new;
3527 struct bttv_buffer *ovbi;
3528 struct bttv_buffer *item;
3529 unsigned long flags;
3532 printk(KERN_INFO "bttv%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
3533 btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
3534 btread(BT848_RISC_COUNT));
3535 bttv_print_irqbits(btread(BT848_INT_STAT),0);
3539 spin_lock_irqsave(&btv->s_lock,flags);
3541 /* deactivate stuff */
3542 memset(&new,0,sizeof(new));
3548 bttv_buffer_activate_video(btv, &new);
3549 bttv_buffer_activate_vbi(btv, NULL);
3550 bttv_set_dma(btv, 0);
3553 bttv_irq_wakeup_video(btv, &old, &new, STATE_ERROR);
3554 bttv_irq_wakeup_vbi(btv, ovbi, STATE_ERROR);
3556 /* cancel all outstanding capture / vbi requests */
3557 while (!list_empty(&btv->capture)) {
3558 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3559 list_del(&item->vb.queue);
3560 item->vb.state = STATE_ERROR;
3561 wake_up(&item->vb.done);
3563 while (!list_empty(&btv->vcapture)) {
3564 item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3565 list_del(&item->vb.queue);
3566 item->vb.state = STATE_ERROR;
3567 wake_up(&item->vb.done);
3571 spin_unlock_irqrestore(&btv->s_lock,flags);
3575 bttv_irq_wakeup_top(struct bttv *btv)
3577 struct bttv_buffer *wakeup = btv->curr.top;
3582 spin_lock(&btv->s_lock);
3583 btv->curr.top_irq = 0;
3584 btv->curr.top = NULL;
3585 bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
3587 do_gettimeofday(&wakeup->vb.ts);
3588 wakeup->vb.field_count = btv->field_count;
3589 wakeup->vb.state = STATE_DONE;
3590 wake_up(&wakeup->vb.done);
3591 spin_unlock(&btv->s_lock);
3594 static inline int is_active(struct btcx_riscmem *risc, u32 rc)
3598 if (rc > risc->dma + risc->size)
3604 bttv_irq_switch_video(struct bttv *btv)
3606 struct bttv_buffer_set new;
3607 struct bttv_buffer_set old;
3610 spin_lock(&btv->s_lock);
3612 /* new buffer set */
3613 bttv_irq_next_video(btv, &new);
3614 rc = btread(BT848_RISC_COUNT);
3615 if ((btv->curr.top && is_active(&btv->curr.top->top, rc)) ||
3616 (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) {
3619 bttv_irq_debug_low_latency(btv, rc);
3620 spin_unlock(&btv->s_lock);
3627 btv->loop_irq &= ~1;
3628 bttv_buffer_activate_video(btv, &new);
3629 bttv_set_dma(btv, 0);
3632 if (UNSET != btv->new_input) {
3633 video_mux(btv,btv->new_input);
3634 btv->new_input = UNSET;
3637 /* wake up finished buffers */
3638 bttv_irq_wakeup_video(btv, &old, &new, STATE_DONE);
3639 spin_unlock(&btv->s_lock);
3643 bttv_irq_switch_vbi(struct bttv *btv)
3645 struct bttv_buffer *new = NULL;
3646 struct bttv_buffer *old;
3649 spin_lock(&btv->s_lock);
3651 if (!list_empty(&btv->vcapture))
3652 new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3655 rc = btread(BT848_RISC_COUNT);
3656 if (NULL != old && (is_active(&old->top, rc) ||
3657 is_active(&old->bottom, rc))) {
3660 bttv_irq_debug_low_latency(btv, rc);
3661 spin_unlock(&btv->s_lock);
3667 btv->loop_irq &= ~4;
3668 bttv_buffer_activate_vbi(btv, new);
3669 bttv_set_dma(btv, 0);
3671 bttv_irq_wakeup_vbi(btv, old, STATE_DONE);
3672 spin_unlock(&btv->s_lock);
3675 static irqreturn_t bttv_irq(int irq, void *dev_id, struct pt_regs * regs)
3683 btv=(struct bttv *)dev_id;
3686 handled = bttv_any_irq(&btv->c);
3690 /* get/clear interrupt status bits */
3691 stat=btread(BT848_INT_STAT);
3692 astat=stat&btread(BT848_INT_MASK);
3696 btwrite(stat,BT848_INT_STAT);
3698 /* get device status bits */
3699 dstat=btread(BT848_DSTATUS);
3702 printk(KERN_DEBUG "bttv%d: irq loop=%d fc=%d "
3703 "riscs=%x, riscc=%08x, ",
3704 btv->c.nr, count, btv->field_count,
3705 stat>>28, btread(BT848_RISC_COUNT));
3706 bttv_print_irqbits(stat,astat);
3707 if (stat & BT848_INT_HLOCK)
3708 printk(" HLOC => %s", (dstat & BT848_DSTATUS_HLOC)
3710 if (stat & BT848_INT_VPRES)
3711 printk(" PRES => %s", (dstat & BT848_DSTATUS_PRES)
3713 if (stat & BT848_INT_FMTCHG)
3714 printk(" NUML => %s", (dstat & BT848_DSTATUS_NUML)
3719 if (astat&BT848_INT_VSYNC)
3722 if (astat & BT848_INT_GPINT) {
3723 wake_up(&btv->gpioq);
3724 bttv_gpio_irq(&btv->c);
3727 if (astat & BT848_INT_I2CDONE) {
3728 btv->i2c_done = stat;
3729 wake_up(&btv->i2c_queue);
3732 if ((astat & BT848_INT_RISCI) && (stat & (4<<28)))
3733 bttv_irq_switch_vbi(btv);
3735 if ((astat & BT848_INT_RISCI) && (stat & (2<<28)))
3736 bttv_irq_wakeup_top(btv);
3738 if ((astat & BT848_INT_RISCI) && (stat & (1<<28)))
3739 bttv_irq_switch_video(btv);
3741 if ((astat & BT848_INT_HLOCK) && btv->opt_automute)
3744 if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
3745 printk(KERN_INFO "bttv%d: %s%s @ %08x,",btv->c.nr,
3746 (astat & BT848_INT_SCERR) ? "SCERR" : "",
3747 (astat & BT848_INT_OCERR) ? "OCERR" : "",
3748 btread(BT848_RISC_COUNT));
3749 bttv_print_irqbits(stat,astat);
3752 bttv_print_riscaddr(btv);
3754 if (fdsr && astat & BT848_INT_FDSR) {
3755 printk(KERN_INFO "bttv%d: FDSR @ %08x\n",
3756 btv->c.nr,btread(BT848_RISC_COUNT));
3758 bttv_print_riscaddr(btv);
3764 if (count > 8 || !(astat & BT848_INT_GPINT)) {
3765 btwrite(0, BT848_INT_MASK);
3768 "bttv%d: IRQ lockup, cleared int mask [", btv->c.nr);
3771 "bttv%d: IRQ lockup, clearing GPINT from int mask [", btv->c.nr);
3773 btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT),
3777 bttv_print_irqbits(stat,astat);
3785 return IRQ_RETVAL(handled);
3789 /* ----------------------------------------------------------------------- */
3790 /* initialitation */
3792 static struct video_device *vdev_init(struct bttv *btv,
3793 struct video_device *template,
3796 struct video_device *vfd;
3798 vfd = video_device_alloc();
3803 vfd->dev = &btv->c.pci->dev;
3804 vfd->release = video_device_release;
3805 snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
3806 btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
3807 type, bttv_tvcards[btv->c.type].name);
3811 static void bttv_unregister_video(struct bttv *btv)
3813 if (btv->video_dev) {
3814 if (-1 != btv->video_dev->minor)
3815 video_unregister_device(btv->video_dev);
3817 video_device_release(btv->video_dev);
3818 btv->video_dev = NULL;
3821 if (-1 != btv->vbi_dev->minor)
3822 video_unregister_device(btv->vbi_dev);
3824 video_device_release(btv->vbi_dev);
3825 btv->vbi_dev = NULL;
3827 if (btv->radio_dev) {
3828 if (-1 != btv->radio_dev->minor)
3829 video_unregister_device(btv->radio_dev);
3831 video_device_release(btv->radio_dev);
3832 btv->radio_dev = NULL;
3836 /* register video4linux devices */
3837 static int __devinit bttv_register_video(struct bttv *btv)
3839 if (no_overlay <= 0) {
3840 bttv_video_template.type |= VID_TYPE_OVERLAY;
3842 printk("bttv: Overlay support disabled.\n");
3846 btv->video_dev = vdev_init(btv, &bttv_video_template, "video");
3847 if (NULL == btv->video_dev)
3849 if (video_register_device(btv->video_dev,VFL_TYPE_GRABBER,video_nr)<0)
3851 printk(KERN_INFO "bttv%d: registered device video%d\n",
3852 btv->c.nr,btv->video_dev->minor & 0x1f);
3853 video_device_create_file(btv->video_dev, &class_device_attr_card);
3856 btv->vbi_dev = vdev_init(btv, &bttv_vbi_template, "vbi");
3857 if (NULL == btv->vbi_dev)
3859 if (video_register_device(btv->vbi_dev,VFL_TYPE_VBI,vbi_nr)<0)
3861 printk(KERN_INFO "bttv%d: registered device vbi%d\n",
3862 btv->c.nr,btv->vbi_dev->minor & 0x1f);
3864 if (!btv->has_radio)
3867 btv->radio_dev = vdev_init(btv, &radio_template, "radio");
3868 if (NULL == btv->radio_dev)
3870 if (video_register_device(btv->radio_dev, VFL_TYPE_RADIO,radio_nr)<0)
3872 printk(KERN_INFO "bttv%d: registered device radio%d\n",
3873 btv->c.nr,btv->radio_dev->minor & 0x1f);
3879 bttv_unregister_video(btv);
3884 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
3885 /* response on cards with no firmware is not enabled by OF */
3886 static void pci_set_command(struct pci_dev *dev)
3888 #if defined(__powerpc__)
3891 pci_read_config_dword(dev, PCI_COMMAND, &cmd);
3892 cmd = (cmd | PCI_COMMAND_MEMORY );
3893 pci_write_config_dword(dev, PCI_COMMAND, cmd);
3897 static int __devinit bttv_probe(struct pci_dev *dev,
3898 const struct pci_device_id *pci_id)
3904 if (bttv_num == BTTV_MAX)
3906 printk(KERN_INFO "bttv: Bt8xx card found (%d).\n", bttv_num);
3907 btv=&bttvs[bttv_num];
3908 memset(btv,0,sizeof(*btv));
3909 btv->c.nr = bttv_num;
3910 sprintf(btv->c.name,"bttv%d",btv->c.nr);
3912 /* initialize structs / fill in defaults */
3913 init_MUTEX(&btv->lock);
3914 init_MUTEX(&btv->reslock);
3915 spin_lock_init(&btv->s_lock);
3916 spin_lock_init(&btv->gpio_lock);
3917 init_waitqueue_head(&btv->gpioq);
3918 init_waitqueue_head(&btv->i2c_queue);
3919 INIT_LIST_HEAD(&btv->c.subs);
3920 INIT_LIST_HEAD(&btv->capture);
3921 INIT_LIST_HEAD(&btv->vcapture);
3922 v4l2_prio_init(&btv->prio);
3924 init_timer(&btv->timeout);
3925 btv->timeout.function = bttv_irq_timeout;
3926 btv->timeout.data = (unsigned long)btv;
3929 btv->tuner_type = UNSET;
3930 btv->pinnacle_id = UNSET;
3931 btv->new_input = UNSET;
3932 btv->has_radio=radio[btv->c.nr];
3934 /* pci stuff (init, get irq/mmio, ... */
3936 btv->id = dev->device;
3937 if (pci_enable_device(dev)) {
3938 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
3942 if (pci_set_dma_mask(dev, DMA_32BIT_MASK)) {
3943 printk(KERN_WARNING "bttv%d: No suitable DMA available.\n",
3947 if (!request_mem_region(pci_resource_start(dev,0),
3948 pci_resource_len(dev,0),
3950 printk(KERN_WARNING "bttv%d: can't request iomem (0x%lx).\n",
3951 btv->c.nr, pci_resource_start(dev,0));
3954 pci_set_master(dev);
3955 pci_set_command(dev);
3956 pci_set_drvdata(dev,btv);
3958 pci_read_config_byte(dev, PCI_CLASS_REVISION, &btv->revision);
3959 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
3960 printk(KERN_INFO "bttv%d: Bt%d (rev %d) at %s, ",
3961 bttv_num,btv->id, btv->revision, pci_name(dev));
3962 printk("irq: %d, latency: %d, mmio: 0x%lx\n",
3963 btv->c.pci->irq, lat, pci_resource_start(dev,0));
3966 btv->bt848_mmio=ioremap(pci_resource_start(dev,0), 0x1000);
3967 if (NULL == ioremap(pci_resource_start(dev,0), 0x1000)) {
3968 printk("bttv%d: ioremap() failed\n", btv->c.nr);
3976 /* disable irqs, register irq handler */
3977 btwrite(0, BT848_INT_MASK);
3978 result = request_irq(btv->c.pci->irq, bttv_irq,
3979 SA_SHIRQ | SA_INTERRUPT,btv->c.name,(void *)btv);
3981 printk(KERN_ERR "bttv%d: can't get IRQ %d\n",
3982 bttv_num,btv->c.pci->irq);
3986 if (0 != bttv_handle_chipset(btv)) {
3991 /* init options from insmod args */
3992 btv->opt_combfilter = combfilter;
3993 btv->opt_lumafilter = lumafilter;
3994 btv->opt_automute = automute;
3995 btv->opt_chroma_agc = chroma_agc;
3996 btv->opt_adc_crush = adc_crush;
3997 btv->opt_vcr_hack = vcr_hack;
3998 btv->opt_whitecrush_upper = whitecrush_upper;
3999 btv->opt_whitecrush_lower = whitecrush_lower;
4000 btv->opt_uv_ratio = uv_ratio;
4001 btv->opt_full_luma_range = full_luma_range;
4002 btv->opt_coring = coring;
4004 /* fill struct bttv with some useful defaults */
4005 btv->init.btv = btv;
4006 btv->init.ov.w.width = 320;
4007 btv->init.ov.w.height = 240;
4008 btv->init.fmt = format_by_palette(VIDEO_PALETTE_RGB24);
4009 btv->init.width = 320;
4010 btv->init.height = 240;
4011 btv->init.lines = 16;
4014 /* initialize hardware */
4016 bttv_gpio_tracking(btv,"pre-init");
4018 bttv_risc_init_main(btv);
4022 btwrite(0x00, BT848_GPIO_REG_INP);
4023 btwrite(0x00, BT848_GPIO_OUT_EN);
4025 bttv_gpio_tracking(btv,"init");
4027 /* needs to be done before i2c is registered */
4028 bttv_init_card1(btv);
4030 /* register i2c + gpio */
4033 /* some card-specific stuff (needs working i2c) */
4034 bttv_init_card2(btv);
4037 /* register video4linux + input */
4038 if (!bttv_tvcards[btv->c.type].no_video) {
4039 bttv_register_video(btv);
4040 bt848_bright(btv,32768);
4041 bt848_contrast(btv,32768);
4042 bt848_hue(btv,32768);
4043 bt848_sat(btv,32768);
4044 audio_mux(btv,AUDIO_MUTE);
4048 /* add subdevices */
4049 if (btv->has_remote)
4050 bttv_sub_add_device(&btv->c, "remote");
4051 if (bttv_tvcards[btv->c.type].has_dvb)
4052 bttv_sub_add_device(&btv->c, "dvb");
4054 /* everything is fine */
4059 free_irq(btv->c.pci->irq,btv);
4062 if (btv->bt848_mmio)
4063 iounmap(btv->bt848_mmio);
4064 release_mem_region(pci_resource_start(btv->c.pci,0),
4065 pci_resource_len(btv->c.pci,0));
4066 pci_set_drvdata(dev,NULL);
4070 static void __devexit bttv_remove(struct pci_dev *pci_dev)
4072 struct bttv *btv = pci_get_drvdata(pci_dev);
4075 printk("bttv%d: unloading\n",btv->c.nr);
4077 /* shutdown everything (DMA+IRQs) */
4078 btand(~15, BT848_GPIO_DMA_CTL);
4079 btwrite(0, BT848_INT_MASK);
4080 btwrite(~0x0, BT848_INT_STAT);
4081 btwrite(0x0, BT848_GPIO_OUT_EN);
4083 bttv_gpio_tracking(btv,"cleanup");
4085 /* tell gpio modules we are leaving ... */
4087 wake_up(&btv->gpioq);
4088 bttv_sub_del_devices(&btv->c);
4090 /* unregister i2c_bus + input */
4093 /* unregister video4linux */
4094 bttv_unregister_video(btv);
4096 /* free allocated memory */
4097 btcx_riscmem_free(btv->c.pci,&btv->main);
4099 /* free ressources */
4100 free_irq(btv->c.pci->irq,btv);
4101 iounmap(btv->bt848_mmio);
4102 release_mem_region(pci_resource_start(btv->c.pci,0),
4103 pci_resource_len(btv->c.pci,0));
4105 pci_set_drvdata(pci_dev, NULL);
4109 static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state)
4111 struct bttv *btv = pci_get_drvdata(pci_dev);
4112 struct bttv_buffer_set idle;
4113 unsigned long flags;
4115 dprintk("bttv%d: suspend %d\n", btv->c.nr, state.event);
4117 /* stop dma + irqs */
4118 spin_lock_irqsave(&btv->s_lock,flags);
4119 memset(&idle, 0, sizeof(idle));
4120 btv->state.video = btv->curr;
4121 btv->state.vbi = btv->cvbi;
4122 btv->state.loop_irq = btv->loop_irq;
4125 bttv_buffer_activate_video(btv, &idle);
4126 bttv_buffer_activate_vbi(btv, NULL);
4127 bttv_set_dma(btv, 0);
4128 btwrite(0, BT848_INT_MASK);
4129 spin_unlock_irqrestore(&btv->s_lock,flags);
4131 /* save bt878 state */
4132 btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
4133 btv->state.gpio_data = gpio_read();
4135 /* save pci state */
4136 pci_save_state(pci_dev);
4137 if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
4138 pci_disable_device(pci_dev);
4139 btv->state.disabled = 1;
4144 static int bttv_resume(struct pci_dev *pci_dev)
4146 struct bttv *btv = pci_get_drvdata(pci_dev);
4147 unsigned long flags;
4150 dprintk("bttv%d: resume\n", btv->c.nr);
4152 /* restore pci state */
4153 if (btv->state.disabled) {
4154 err=pci_enable_device(pci_dev);
4156 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4160 btv->state.disabled = 0;
4162 err=pci_set_power_state(pci_dev, PCI_D0);
4164 pci_disable_device(pci_dev);
4165 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4167 btv->state.disabled = 1;
4171 pci_restore_state(pci_dev);
4173 /* restore bt878 state */
4174 bttv_reinit_bt848(btv);
4175 gpio_inout(0xffffff, btv->state.gpio_enable);
4176 gpio_write(btv->state.gpio_data);
4179 spin_lock_irqsave(&btv->s_lock,flags);
4180 btv->curr = btv->state.video;
4181 btv->cvbi = btv->state.vbi;
4182 btv->loop_irq = btv->state.loop_irq;
4183 bttv_buffer_activate_video(btv, &btv->curr);
4184 bttv_buffer_activate_vbi(btv, btv->cvbi);
4185 bttv_set_dma(btv, 0);
4186 spin_unlock_irqrestore(&btv->s_lock,flags);
4190 static struct pci_device_id bttv_pci_tbl[] = {
4191 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848,
4192 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4193 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849,
4194 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4195 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878,
4196 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4197 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879,
4198 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4202 MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
4204 static struct pci_driver bttv_pci_driver = {
4206 .id_table = bttv_pci_tbl,
4207 .probe = bttv_probe,
4208 .remove = __devexit_p(bttv_remove),
4209 .suspend = bttv_suspend,
4210 .resume = bttv_resume,
4213 static int bttv_init_module(void)
4217 printk(KERN_INFO "bttv: driver version %d.%d.%d loaded\n",
4218 (BTTV_VERSION_CODE >> 16) & 0xff,
4219 (BTTV_VERSION_CODE >> 8) & 0xff,
4220 BTTV_VERSION_CODE & 0xff);
4222 printk(KERN_INFO "bttv: snapshot date %04d-%02d-%02d\n",
4223 SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
4225 if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
4227 if (gbufsize < 0 || gbufsize > BTTV_MAX_FBUF)
4228 gbufsize = BTTV_MAX_FBUF;
4229 gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
4231 printk(KERN_INFO "bttv: using %d buffers with %dk (%d pages) each for capture\n",
4232 gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
4234 bttv_check_chipset();
4236 bus_register(&bttv_sub_bus_type);
4237 return pci_module_init(&bttv_pci_driver);
4240 static void bttv_cleanup_module(void)
4242 pci_unregister_driver(&bttv_pci_driver);
4243 bus_unregister(&bttv_sub_bus_type);
4247 module_init(bttv_init_module);
4248 module_exit(bttv_cleanup_module);