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>
38 #include <media/v4l2-common.h>
39 #include <media/tvaudio.h>
40 #include <media/msp3400.h>
42 #include <linux/dma-mapping.h>
45 #include <asm/byteorder.h>
47 #include <media/rds.h>
50 unsigned int bttv_num; /* number of Bt848s in use */
51 struct bttv bttvs[BTTV_MAX];
53 unsigned int bttv_debug;
54 unsigned int bttv_verbose = 1;
55 unsigned int bttv_gpio;
57 /* config variables */
59 static unsigned int bigendian=1;
61 static unsigned int bigendian;
63 static unsigned int radio[BTTV_MAX];
64 static unsigned int irq_debug;
65 static unsigned int gbuffers = 8;
66 static unsigned int gbufsize = 0x208000;
68 static int video_nr = -1;
69 static int radio_nr = -1;
70 static int vbi_nr = -1;
71 static int debug_latency;
73 static unsigned int fdsr;
76 static unsigned int combfilter;
77 static unsigned int lumafilter;
78 static unsigned int automute = 1;
79 static unsigned int chroma_agc;
80 static unsigned int adc_crush = 1;
81 static unsigned int whitecrush_upper = 0xCF;
82 static unsigned int whitecrush_lower = 0x7F;
83 static unsigned int vcr_hack;
84 static unsigned int irq_iswitch;
85 static unsigned int uv_ratio = 50;
86 static unsigned int full_luma_range;
87 static unsigned int coring;
88 extern int no_overlay;
90 /* API features (turn on/off stuff for testing) */
91 static unsigned int v4l2 = 1;
94 module_param(bttv_verbose, int, 0644);
95 module_param(bttv_gpio, int, 0644);
96 module_param(bttv_debug, int, 0644);
97 module_param(irq_debug, int, 0644);
98 module_param(debug_latency, int, 0644);
100 module_param(fdsr, int, 0444);
101 module_param(video_nr, int, 0444);
102 module_param(radio_nr, int, 0444);
103 module_param(vbi_nr, int, 0444);
104 module_param(gbuffers, int, 0444);
105 module_param(gbufsize, int, 0444);
107 module_param(v4l2, int, 0644);
108 module_param(bigendian, int, 0644);
109 module_param(irq_iswitch, int, 0644);
110 module_param(combfilter, int, 0444);
111 module_param(lumafilter, int, 0444);
112 module_param(automute, int, 0444);
113 module_param(chroma_agc, int, 0444);
114 module_param(adc_crush, int, 0444);
115 module_param(whitecrush_upper, int, 0444);
116 module_param(whitecrush_lower, int, 0444);
117 module_param(vcr_hack, int, 0444);
118 module_param(uv_ratio, int, 0444);
119 module_param(full_luma_range, int, 0444);
120 module_param(coring, int, 0444);
122 module_param_array(radio, int, NULL, 0444);
124 MODULE_PARM_DESC(radio,"The TV card supports radio, default is 0 (no)");
125 MODULE_PARM_DESC(bigendian,"byte order of the framebuffer, default is native endian");
126 MODULE_PARM_DESC(bttv_verbose,"verbose startup messages, default is 1 (yes)");
127 MODULE_PARM_DESC(bttv_gpio,"log gpio changes, default is 0 (no)");
128 MODULE_PARM_DESC(bttv_debug,"debug messages, default is 0 (no)");
129 MODULE_PARM_DESC(irq_debug,"irq handler debug messages, default is 0 (no)");
130 MODULE_PARM_DESC(gbuffers,"number of capture buffers. range 2-32, default 8");
131 MODULE_PARM_DESC(gbufsize,"size of the capture buffers, default is 0x208000");
132 MODULE_PARM_DESC(automute,"mute audio on bad/missing video signal, default is 1 (yes)");
133 MODULE_PARM_DESC(chroma_agc,"enables the AGC of chroma signal, default is 0 (no)");
134 MODULE_PARM_DESC(adc_crush,"enables the luminance ADC crush, default is 1 (yes)");
135 MODULE_PARM_DESC(whitecrush_upper,"sets the white crush upper value, default is 207");
136 MODULE_PARM_DESC(whitecrush_lower,"sets the white crush lower value, default is 127");
137 MODULE_PARM_DESC(vcr_hack,"enables the VCR hack (improves synch on poor VCR tapes), default is 0 (no)");
138 MODULE_PARM_DESC(irq_iswitch,"switch inputs in irq handler");
139 MODULE_PARM_DESC(uv_ratio,"ratio between u and v gains, default is 50");
140 MODULE_PARM_DESC(full_luma_range,"use the full luma range, default is 0 (no)");
141 MODULE_PARM_DESC(coring,"set the luma coring level, default is 0 (no)");
143 MODULE_DESCRIPTION("bttv - v4l/v4l2 driver module for bt848/878 based cards");
144 MODULE_AUTHOR("Ralph Metzler & Marcus Metzler & Gerd Knorr");
145 MODULE_LICENSE("GPL");
147 /* ----------------------------------------------------------------------- */
150 static ssize_t show_card(struct class_device *cd, char *buf)
152 struct video_device *vfd = to_video_device(cd);
153 struct bttv *btv = dev_get_drvdata(vfd->dev);
154 return sprintf(buf, "%d\n", btv ? btv->c.type : UNSET);
156 static CLASS_DEVICE_ATTR(card, S_IRUGO, show_card, NULL);
158 /* ----------------------------------------------------------------------- */
161 /* special timing tables from conexant... */
162 static u8 SRAM_Table[][60] =
164 /* PAL digital input over GPIO[7:0] */
166 45, // 45 bytes following
167 0x36,0x11,0x01,0x00,0x90,0x02,0x05,0x10,0x04,0x16,
168 0x12,0x05,0x11,0x00,0x04,0x12,0xC0,0x00,0x31,0x00,
169 0x06,0x51,0x08,0x03,0x89,0x08,0x07,0xC0,0x44,0x00,
170 0x81,0x01,0x01,0xA9,0x0D,0x02,0x02,0x50,0x03,0x37,
171 0x37,0x00,0xAF,0x21,0x00
173 /* NTSC digital input over GPIO[7:0] */
175 51, // 51 bytes following
176 0x0C,0xC0,0x00,0x00,0x90,0x02,0x03,0x10,0x03,0x06,
177 0x10,0x04,0x12,0x12,0x05,0x02,0x13,0x04,0x19,0x00,
178 0x04,0x39,0x00,0x06,0x59,0x08,0x03,0x83,0x08,0x07,
179 0x03,0x50,0x00,0xC0,0x40,0x00,0x86,0x01,0x01,0xA6,
180 0x0D,0x02,0x03,0x11,0x01,0x05,0x37,0x00,0xAC,0x21,
183 // TGB_NTSC392 // quartzsight
184 // This table has been modified to be used for Fusion Rev D
186 0x2A, // size of table = 42
187 0x06, 0x08, 0x04, 0x0a, 0xc0, 0x00, 0x18, 0x08, 0x03, 0x24,
188 0x08, 0x07, 0x02, 0x90, 0x02, 0x08, 0x10, 0x04, 0x0c, 0x10,
189 0x05, 0x2c, 0x11, 0x04, 0x55, 0x48, 0x00, 0x05, 0x50, 0x00,
190 0xbf, 0x0c, 0x02, 0x2f, 0x3d, 0x00, 0x2f, 0x3f, 0x00, 0xc3,
195 const struct bttv_tvnorm bttv_tvnorms[] = {
197 /* max. active video is actually 922, but 924 is divisible by 4 and 3! */
198 /* actually, max active PAL with HSCALE=0 is 948, NTSC is 768 - nil */
200 .v4l2_id = V4L2_STD_PAL,
208 .iform = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
209 .scaledtwidth = 1135,
215 /* ITU-R frame line number of the first VBI line
216 we can capture, of the first and second field. */
217 .vbistart = { 7,320 },
219 .v4l2_id = V4L2_STD_NTSC_M | V4L2_STD_NTSC_M_KR,
227 .iform = (BT848_IFORM_NTSC|BT848_IFORM_XT0),
234 .vbistart = { 10, 273 },
236 .v4l2_id = V4L2_STD_SECAM,
244 .iform = (BT848_IFORM_SECAM|BT848_IFORM_XT1),
245 .scaledtwidth = 1135,
250 .sram = 0, /* like PAL, correct? */
251 .vbistart = { 7, 320 },
253 .v4l2_id = V4L2_STD_PAL_Nc,
261 .iform = (BT848_IFORM_PAL_NC|BT848_IFORM_XT0),
268 .vbistart = { 7, 320 },
270 .v4l2_id = V4L2_STD_PAL_M,
278 .iform = (BT848_IFORM_PAL_M|BT848_IFORM_XT0),
285 .vbistart = { 10, 273 },
287 .v4l2_id = V4L2_STD_PAL_N,
295 .iform = (BT848_IFORM_PAL_N|BT848_IFORM_XT1),
302 .vbistart = { 7, 320},
304 .v4l2_id = V4L2_STD_NTSC_M_JP,
312 .iform = (BT848_IFORM_NTSC_J|BT848_IFORM_XT0),
319 .vbistart = {10, 273},
321 /* that one hopefully works with the strange timing
322 * which video recorders produce when playing a NTSC
323 * tape on a PAL TV ... */
324 .v4l2_id = V4L2_STD_PAL_60,
332 .iform = (BT848_IFORM_PAL_BDGHI|BT848_IFORM_XT1),
333 .scaledtwidth = 1135,
340 .vbistart = { 10, 273 },
343 static const unsigned int BTTV_TVNORMS = ARRAY_SIZE(bttv_tvnorms);
345 /* ----------------------------------------------------------------------- */
347 packed pixel formats must come first */
348 static const struct bttv_format bttv_formats[] = {
350 .name = "8 bpp, gray",
351 .palette = VIDEO_PALETTE_GREY,
352 .fourcc = V4L2_PIX_FMT_GREY,
353 .btformat = BT848_COLOR_FMT_Y8,
355 .flags = FORMAT_FLAGS_PACKED,
357 .name = "8 bpp, dithered color",
358 .palette = VIDEO_PALETTE_HI240,
359 .fourcc = V4L2_PIX_FMT_HI240,
360 .btformat = BT848_COLOR_FMT_RGB8,
362 .flags = FORMAT_FLAGS_PACKED | FORMAT_FLAGS_DITHER,
364 .name = "15 bpp RGB, le",
365 .palette = VIDEO_PALETTE_RGB555,
366 .fourcc = V4L2_PIX_FMT_RGB555,
367 .btformat = BT848_COLOR_FMT_RGB15,
369 .flags = FORMAT_FLAGS_PACKED,
371 .name = "15 bpp RGB, be",
373 .fourcc = V4L2_PIX_FMT_RGB555X,
374 .btformat = BT848_COLOR_FMT_RGB15,
375 .btswap = 0x03, /* byteswap */
377 .flags = FORMAT_FLAGS_PACKED,
379 .name = "16 bpp RGB, le",
380 .palette = VIDEO_PALETTE_RGB565,
381 .fourcc = V4L2_PIX_FMT_RGB565,
382 .btformat = BT848_COLOR_FMT_RGB16,
384 .flags = FORMAT_FLAGS_PACKED,
386 .name = "16 bpp RGB, be",
388 .fourcc = V4L2_PIX_FMT_RGB565X,
389 .btformat = BT848_COLOR_FMT_RGB16,
390 .btswap = 0x03, /* byteswap */
392 .flags = FORMAT_FLAGS_PACKED,
394 .name = "24 bpp RGB, le",
395 .palette = VIDEO_PALETTE_RGB24,
396 .fourcc = V4L2_PIX_FMT_BGR24,
397 .btformat = BT848_COLOR_FMT_RGB24,
399 .flags = FORMAT_FLAGS_PACKED,
401 .name = "32 bpp RGB, le",
402 .palette = VIDEO_PALETTE_RGB32,
403 .fourcc = V4L2_PIX_FMT_BGR32,
404 .btformat = BT848_COLOR_FMT_RGB32,
406 .flags = FORMAT_FLAGS_PACKED,
408 .name = "32 bpp RGB, be",
410 .fourcc = V4L2_PIX_FMT_RGB32,
411 .btformat = BT848_COLOR_FMT_RGB32,
412 .btswap = 0x0f, /* byte+word swap */
414 .flags = FORMAT_FLAGS_PACKED,
416 .name = "4:2:2, packed, YUYV",
417 .palette = VIDEO_PALETTE_YUV422,
418 .fourcc = V4L2_PIX_FMT_YUYV,
419 .btformat = BT848_COLOR_FMT_YUY2,
421 .flags = FORMAT_FLAGS_PACKED,
423 .name = "4:2:2, packed, YUYV",
424 .palette = VIDEO_PALETTE_YUYV,
425 .fourcc = V4L2_PIX_FMT_YUYV,
426 .btformat = BT848_COLOR_FMT_YUY2,
428 .flags = FORMAT_FLAGS_PACKED,
430 .name = "4:2:2, packed, UYVY",
431 .palette = VIDEO_PALETTE_UYVY,
432 .fourcc = V4L2_PIX_FMT_UYVY,
433 .btformat = BT848_COLOR_FMT_YUY2,
434 .btswap = 0x03, /* byteswap */
436 .flags = FORMAT_FLAGS_PACKED,
438 .name = "4:2:2, planar, Y-Cb-Cr",
439 .palette = VIDEO_PALETTE_YUV422P,
440 .fourcc = V4L2_PIX_FMT_YUV422P,
441 .btformat = BT848_COLOR_FMT_YCrCb422,
443 .flags = FORMAT_FLAGS_PLANAR,
447 .name = "4:2:0, planar, Y-Cb-Cr",
448 .palette = VIDEO_PALETTE_YUV420P,
449 .fourcc = V4L2_PIX_FMT_YUV420,
450 .btformat = BT848_COLOR_FMT_YCrCb422,
452 .flags = FORMAT_FLAGS_PLANAR,
456 .name = "4:2:0, planar, Y-Cr-Cb",
458 .fourcc = V4L2_PIX_FMT_YVU420,
459 .btformat = BT848_COLOR_FMT_YCrCb422,
461 .flags = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
465 .name = "4:1:1, planar, Y-Cb-Cr",
466 .palette = VIDEO_PALETTE_YUV411P,
467 .fourcc = V4L2_PIX_FMT_YUV411P,
468 .btformat = BT848_COLOR_FMT_YCrCb411,
470 .flags = FORMAT_FLAGS_PLANAR,
474 .name = "4:1:0, planar, Y-Cb-Cr",
475 .palette = VIDEO_PALETTE_YUV410P,
476 .fourcc = V4L2_PIX_FMT_YUV410,
477 .btformat = BT848_COLOR_FMT_YCrCb411,
479 .flags = FORMAT_FLAGS_PLANAR,
483 .name = "4:1:0, planar, Y-Cr-Cb",
485 .fourcc = V4L2_PIX_FMT_YVU410,
486 .btformat = BT848_COLOR_FMT_YCrCb411,
488 .flags = FORMAT_FLAGS_PLANAR | FORMAT_FLAGS_CrCb,
492 .name = "raw scanlines",
493 .palette = VIDEO_PALETTE_RAW,
495 .btformat = BT848_COLOR_FMT_RAW,
497 .flags = FORMAT_FLAGS_RAW,
500 static const unsigned int BTTV_FORMATS = ARRAY_SIZE(bttv_formats);
502 /* ----------------------------------------------------------------------- */
504 #define V4L2_CID_PRIVATE_CHROMA_AGC (V4L2_CID_PRIVATE_BASE + 0)
505 #define V4L2_CID_PRIVATE_COMBFILTER (V4L2_CID_PRIVATE_BASE + 1)
506 #define V4L2_CID_PRIVATE_AUTOMUTE (V4L2_CID_PRIVATE_BASE + 2)
507 #define V4L2_CID_PRIVATE_LUMAFILTER (V4L2_CID_PRIVATE_BASE + 3)
508 #define V4L2_CID_PRIVATE_AGC_CRUSH (V4L2_CID_PRIVATE_BASE + 4)
509 #define V4L2_CID_PRIVATE_VCR_HACK (V4L2_CID_PRIVATE_BASE + 5)
510 #define V4L2_CID_PRIVATE_WHITECRUSH_UPPER (V4L2_CID_PRIVATE_BASE + 6)
511 #define V4L2_CID_PRIVATE_WHITECRUSH_LOWER (V4L2_CID_PRIVATE_BASE + 7)
512 #define V4L2_CID_PRIVATE_UV_RATIO (V4L2_CID_PRIVATE_BASE + 8)
513 #define V4L2_CID_PRIVATE_FULL_LUMA_RANGE (V4L2_CID_PRIVATE_BASE + 9)
514 #define V4L2_CID_PRIVATE_CORING (V4L2_CID_PRIVATE_BASE + 10)
515 #define V4L2_CID_PRIVATE_LASTP1 (V4L2_CID_PRIVATE_BASE + 11)
517 static const struct v4l2_queryctrl no_ctl = {
519 .flags = V4L2_CTRL_FLAG_DISABLED,
521 static const struct v4l2_queryctrl bttv_ctls[] = {
524 .id = V4L2_CID_BRIGHTNESS,
525 .name = "Brightness",
529 .default_value = 32768,
530 .type = V4L2_CTRL_TYPE_INTEGER,
532 .id = V4L2_CID_CONTRAST,
537 .default_value = 32768,
538 .type = V4L2_CTRL_TYPE_INTEGER,
540 .id = V4L2_CID_SATURATION,
541 .name = "Saturation",
545 .default_value = 32768,
546 .type = V4L2_CTRL_TYPE_INTEGER,
553 .default_value = 32768,
554 .type = V4L2_CTRL_TYPE_INTEGER,
558 .id = V4L2_CID_AUDIO_MUTE,
562 .type = V4L2_CTRL_TYPE_BOOLEAN,
564 .id = V4L2_CID_AUDIO_VOLUME,
569 .default_value = 65535,
570 .type = V4L2_CTRL_TYPE_INTEGER,
572 .id = V4L2_CID_AUDIO_BALANCE,
577 .default_value = 32768,
578 .type = V4L2_CTRL_TYPE_INTEGER,
580 .id = V4L2_CID_AUDIO_BASS,
585 .default_value = 32768,
586 .type = V4L2_CTRL_TYPE_INTEGER,
588 .id = V4L2_CID_AUDIO_TREBLE,
593 .default_value = 32768,
594 .type = V4L2_CTRL_TYPE_INTEGER,
596 /* --- private --- */
598 .id = V4L2_CID_PRIVATE_CHROMA_AGC,
599 .name = "chroma agc",
602 .type = V4L2_CTRL_TYPE_BOOLEAN,
604 .id = V4L2_CID_PRIVATE_COMBFILTER,
605 .name = "combfilter",
608 .type = V4L2_CTRL_TYPE_BOOLEAN,
610 .id = V4L2_CID_PRIVATE_AUTOMUTE,
614 .type = V4L2_CTRL_TYPE_BOOLEAN,
616 .id = V4L2_CID_PRIVATE_LUMAFILTER,
617 .name = "luma decimation filter",
620 .type = V4L2_CTRL_TYPE_BOOLEAN,
622 .id = V4L2_CID_PRIVATE_AGC_CRUSH,
626 .type = V4L2_CTRL_TYPE_BOOLEAN,
628 .id = V4L2_CID_PRIVATE_VCR_HACK,
632 .type = V4L2_CTRL_TYPE_BOOLEAN,
634 .id = V4L2_CID_PRIVATE_WHITECRUSH_UPPER,
635 .name = "whitecrush upper",
639 .default_value = 0xCF,
640 .type = V4L2_CTRL_TYPE_INTEGER,
642 .id = V4L2_CID_PRIVATE_WHITECRUSH_LOWER,
643 .name = "whitecrush lower",
647 .default_value = 0x7F,
648 .type = V4L2_CTRL_TYPE_INTEGER,
650 .id = V4L2_CID_PRIVATE_UV_RATIO,
656 .type = V4L2_CTRL_TYPE_INTEGER,
658 .id = V4L2_CID_PRIVATE_FULL_LUMA_RANGE,
659 .name = "full luma range",
662 .type = V4L2_CTRL_TYPE_BOOLEAN,
664 .id = V4L2_CID_PRIVATE_CORING,
670 .type = V4L2_CTRL_TYPE_INTEGER,
676 static const int BTTV_CTLS = ARRAY_SIZE(bttv_ctls);
678 /* ----------------------------------------------------------------------- */
679 /* resource management */
682 int check_alloc_btres(struct bttv *btv, struct bttv_fh *fh, int bit)
684 if (fh->resources & bit)
685 /* have it already allocated */
689 mutex_lock(&btv->reslock);
690 if (btv->resources & bit) {
691 /* no, someone else uses it */
692 mutex_unlock(&btv->reslock);
695 /* it's free, grab it */
696 fh->resources |= bit;
697 btv->resources |= bit;
698 mutex_unlock(&btv->reslock);
703 int check_btres(struct bttv_fh *fh, int bit)
705 return (fh->resources & bit);
709 int locked_btres(struct bttv *btv, int bit)
711 return (btv->resources & bit);
715 void free_btres(struct bttv *btv, struct bttv_fh *fh, int bits)
717 if ((fh->resources & bits) != bits) {
718 /* trying to free ressources not allocated by us ... */
719 printk("bttv: BUG! (btres)\n");
721 mutex_lock(&btv->reslock);
722 fh->resources &= ~bits;
723 btv->resources &= ~bits;
724 mutex_unlock(&btv->reslock);
727 /* ----------------------------------------------------------------------- */
728 /* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC */
730 /* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C
731 PLL_X = Reference pre-divider (0=1, 1=2)
732 PLL_C = Post divider (0=6, 1=4)
733 PLL_I = Integer input
734 PLL_F = Fractional input
736 F_input = 28.636363 MHz:
737 PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0
740 static void set_pll_freq(struct bttv *btv, unsigned int fin, unsigned int fout)
742 unsigned char fl, fh, fi;
744 /* prevent overflows */
757 btwrite(fl, BT848_PLL_F_LO);
758 btwrite(fh, BT848_PLL_F_HI);
759 btwrite(fi|BT848_PLL_X, BT848_PLL_XCI);
762 static void set_pll(struct bttv *btv)
766 if (!btv->pll.pll_crystal)
769 if (btv->pll.pll_ofreq == btv->pll.pll_current) {
770 dprintk("bttv%d: PLL: no change required\n",btv->c.nr);
774 if (btv->pll.pll_ifreq == btv->pll.pll_ofreq) {
776 if (btv->pll.pll_current == 0)
778 bttv_printk(KERN_INFO "bttv%d: PLL can sleep, using XTAL (%d).\n",
779 btv->c.nr,btv->pll.pll_ifreq);
780 btwrite(0x00,BT848_TGCTRL);
781 btwrite(0x00,BT848_PLL_XCI);
782 btv->pll.pll_current = 0;
786 bttv_printk(KERN_INFO "bttv%d: PLL: %d => %d ",btv->c.nr,
787 btv->pll.pll_ifreq, btv->pll.pll_ofreq);
788 set_pll_freq(btv, btv->pll.pll_ifreq, btv->pll.pll_ofreq);
790 for (i=0; i<10; i++) {
791 /* Let other people run while the PLL stabilizes */
795 if (btread(BT848_DSTATUS) & BT848_DSTATUS_PLOCK) {
796 btwrite(0,BT848_DSTATUS);
798 btwrite(0x08,BT848_TGCTRL);
799 btv->pll.pll_current = btv->pll.pll_ofreq;
800 bttv_printk(" ok\n");
804 btv->pll.pll_current = -1;
805 bttv_printk("failed\n");
809 /* used to switch between the bt848's analog/digital video capture modes */
810 static void bt848A_set_timing(struct bttv *btv)
813 int table_idx = bttv_tvnorms[btv->tvnorm].sram;
814 int fsc = bttv_tvnorms[btv->tvnorm].Fsc;
816 if (UNSET == bttv_tvcards[btv->c.type].muxsel[btv->input]) {
817 dprintk("bttv%d: load digital timing table (table_idx=%d)\n",
818 btv->c.nr,table_idx);
820 /* timing change...reset timing generator address */
821 btwrite(0x00, BT848_TGCTRL);
822 btwrite(0x02, BT848_TGCTRL);
823 btwrite(0x00, BT848_TGCTRL);
825 len=SRAM_Table[table_idx][0];
826 for(i = 1; i <= len; i++)
827 btwrite(SRAM_Table[table_idx][i],BT848_TGLB);
828 btv->pll.pll_ofreq = 27000000;
831 btwrite(0x11, BT848_TGCTRL);
832 btwrite(0x41, BT848_DVSIF);
834 btv->pll.pll_ofreq = fsc;
836 btwrite(0x0, BT848_DVSIF);
840 /* ----------------------------------------------------------------------- */
842 static void bt848_bright(struct bttv *btv, int bright)
846 // printk("bttv: set bright: %d\n",bright); // DEBUG
847 btv->bright = bright;
849 /* We want -128 to 127 we get 0-65535 */
850 value = (bright >> 8) - 128;
851 btwrite(value & 0xff, BT848_BRIGHT);
854 static void bt848_hue(struct bttv *btv, int hue)
861 value = (hue >> 8) - 128;
862 btwrite(value & 0xff, BT848_HUE);
865 static void bt848_contrast(struct bttv *btv, int cont)
869 btv->contrast = cont;
873 hibit = (value >> 6) & 4;
874 btwrite(value & 0xff, BT848_CONTRAST_LO);
875 btaor(hibit, ~4, BT848_E_CONTROL);
876 btaor(hibit, ~4, BT848_O_CONTROL);
879 static void bt848_sat(struct bttv *btv, int color)
881 int val_u,val_v,hibits;
883 btv->saturation = color;
885 /* 0-511 for the color */
886 val_u = ((color * btv->opt_uv_ratio) / 50) >> 7;
887 val_v = (((color * (100 - btv->opt_uv_ratio) / 50) >>7)*180L)/254;
888 hibits = (val_u >> 7) & 2;
889 hibits |= (val_v >> 8) & 1;
890 btwrite(val_u & 0xff, BT848_SAT_U_LO);
891 btwrite(val_v & 0xff, BT848_SAT_V_LO);
892 btaor(hibits, ~3, BT848_E_CONTROL);
893 btaor(hibits, ~3, BT848_O_CONTROL);
896 /* ----------------------------------------------------------------------- */
899 video_mux(struct bttv *btv, unsigned int input)
903 if (input >= bttv_tvcards[btv->c.type].video_inputs)
906 /* needed by RemoteVideo MX */
907 mask2 = bttv_tvcards[btv->c.type].gpiomask2;
909 gpio_inout(mask2,mask2);
911 if (input == btv->svhs) {
912 btor(BT848_CONTROL_COMP, BT848_E_CONTROL);
913 btor(BT848_CONTROL_COMP, BT848_O_CONTROL);
915 btand(~BT848_CONTROL_COMP, BT848_E_CONTROL);
916 btand(~BT848_CONTROL_COMP, BT848_O_CONTROL);
918 mux = bttv_tvcards[btv->c.type].muxsel[input] & 3;
919 btaor(mux<<5, ~(3<<5), BT848_IFORM);
920 dprintk(KERN_DEBUG "bttv%d: video mux: input=%d mux=%d\n",
921 btv->c.nr,input,mux);
923 /* card specific hook */
924 if(bttv_tvcards[btv->c.type].muxsel_hook)
925 bttv_tvcards[btv->c.type].muxsel_hook (btv, input);
929 static char *audio_modes[] = {
930 "audio: tuner", "audio: radio", "audio: extern",
931 "audio: intern", "audio: mute"
935 audio_mux(struct bttv *btv, int input, int mute)
937 int gpio_val, signal;
938 struct v4l2_control ctrl;
939 struct i2c_client *c;
941 gpio_inout(bttv_tvcards[btv->c.type].gpiomask,
942 bttv_tvcards[btv->c.type].gpiomask);
943 signal = btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC;
949 mute = mute || (btv->opt_automute && !signal && !btv->radio_user);
952 gpio_val = bttv_tvcards[btv->c.type].gpiomute;
954 gpio_val = bttv_tvcards[btv->c.type].gpiomux[input];
956 gpio_bits(bttv_tvcards[btv->c.type].gpiomask, gpio_val);
958 bttv_gpio_tracking(btv, audio_modes[mute ? 4 : input]);
962 ctrl.id = V4L2_CID_AUDIO_MUTE;
963 ctrl.value = btv->mute;
964 bttv_call_i2c_clients(btv, VIDIOC_S_CTRL, &ctrl);
965 c = btv->i2c_msp34xx_client;
967 struct v4l2_routing route;
969 /* Note: the inputs tuner/radio/extern/intern are translated
970 to msp routings. This assumes common behavior for all msp3400
971 based TV cards. When this assumption fails, then the
972 specific MSP routing must be added to the card table.
973 For now this is sufficient. */
975 case TVAUDIO_INPUT_RADIO:
976 route.input = MSP_INPUT(MSP_IN_SCART_2, MSP_IN_TUNER_1,
977 MSP_DSP_OUT_SCART, MSP_DSP_OUT_SCART);
979 case TVAUDIO_INPUT_EXTERN:
980 route.input = MSP_INPUT(MSP_IN_SCART_1, MSP_IN_TUNER_1,
981 MSP_DSP_OUT_SCART, MSP_DSP_OUT_SCART);
983 case TVAUDIO_INPUT_INTERN:
984 /* Yes, this is the same input as for RADIO. I doubt
985 if this is ever used. The only board with an INTERN
986 input is the BTTV_BOARD_AVERMEDIA98. I wonder how
987 that was tested. My guess is that the whole INTERN
988 input does not work. */
989 route.input = MSP_INPUT(MSP_IN_SCART_2, MSP_IN_TUNER_1,
990 MSP_DSP_OUT_SCART, MSP_DSP_OUT_SCART);
992 case TVAUDIO_INPUT_TUNER:
994 route.input = MSP_INPUT_DEFAULT;
997 route.output = MSP_OUTPUT_DEFAULT;
998 c->driver->command(c, VIDIOC_INT_S_AUDIO_ROUTING, &route);
1000 c = btv->i2c_tvaudio_client;
1002 struct v4l2_routing route;
1004 route.input = input;
1006 c->driver->command(c, VIDIOC_INT_S_AUDIO_ROUTING, &route);
1012 audio_mute(struct bttv *btv, int mute)
1014 return audio_mux(btv, btv->audio, mute);
1018 audio_input(struct bttv *btv, int input)
1020 return audio_mux(btv, input, btv->mute);
1024 i2c_vidiocschan(struct bttv *btv)
1026 struct video_channel c;
1028 memset(&c,0,sizeof(c));
1029 c.norm = btv->tvnorm;
1030 c.channel = btv->input;
1031 bttv_call_i2c_clients(btv,VIDIOCSCHAN,&c);
1032 if (btv->c.type == BTTV_BOARD_VOODOOTV_FM)
1033 bttv_tda9880_setnorm(btv,c.norm);
1037 set_tvnorm(struct bttv *btv, unsigned int norm)
1039 const struct bttv_tvnorm *tvnorm;
1041 if (norm < 0 || norm >= BTTV_TVNORMS)
1045 tvnorm = &bttv_tvnorms[norm];
1047 btwrite(tvnorm->adelay, BT848_ADELAY);
1048 btwrite(tvnorm->bdelay, BT848_BDELAY);
1049 btaor(tvnorm->iform,~(BT848_IFORM_NORM|BT848_IFORM_XTBOTH),
1051 btwrite(tvnorm->vbipack, BT848_VBI_PACK_SIZE);
1052 btwrite(1, BT848_VBI_PACK_DEL);
1053 bt848A_set_timing(btv);
1055 switch (btv->c.type) {
1056 case BTTV_BOARD_VOODOOTV_FM:
1057 bttv_tda9880_setnorm(btv,norm);
1064 set_input(struct bttv *btv, unsigned int input)
1066 unsigned long flags;
1070 spin_lock_irqsave(&btv->s_lock,flags);
1071 if (btv->curr.frame_irq) {
1072 /* active capture -> delayed input switch */
1073 btv->new_input = input;
1075 video_mux(btv,input);
1077 spin_unlock_irqrestore(&btv->s_lock,flags);
1079 video_mux(btv,input);
1081 audio_input(btv,(input == bttv_tvcards[btv->c.type].tuner ?
1082 TVAUDIO_INPUT_TUNER : TVAUDIO_INPUT_EXTERN));
1083 set_tvnorm(btv,btv->tvnorm);
1084 i2c_vidiocschan(btv);
1087 static void init_irqreg(struct bttv *btv)
1090 btwrite(0xfffffUL, BT848_INT_STAT);
1092 if (bttv_tvcards[btv->c.type].no_video) {
1094 btwrite(BT848_INT_I2CDONE,
1098 btwrite((btv->triton1) |
1099 (btv->gpioirq ? BT848_INT_GPINT : 0) |
1101 (fdsr ? BT848_INT_FDSR : 0) |
1102 BT848_INT_RISCI|BT848_INT_OCERR|BT848_INT_VPRES|
1103 BT848_INT_FMTCHG|BT848_INT_HLOCK|
1109 static void init_bt848(struct bttv *btv)
1113 if (bttv_tvcards[btv->c.type].no_video) {
1114 /* very basic init only */
1119 btwrite(0x00, BT848_CAP_CTL);
1120 btwrite(BT848_COLOR_CTL_GAMMA, BT848_COLOR_CTL);
1121 btwrite(BT848_IFORM_XTAUTO | BT848_IFORM_AUTO, BT848_IFORM);
1123 /* set planar and packed mode trigger points and */
1124 /* set rising edge of inverted GPINTR pin as irq trigger */
1125 btwrite(BT848_GPIO_DMA_CTL_PKTP_32|
1126 BT848_GPIO_DMA_CTL_PLTP1_16|
1127 BT848_GPIO_DMA_CTL_PLTP23_16|
1128 BT848_GPIO_DMA_CTL_GPINTC|
1129 BT848_GPIO_DMA_CTL_GPINTI,
1130 BT848_GPIO_DMA_CTL);
1132 val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1133 btwrite(val, BT848_E_SCLOOP);
1134 btwrite(val, BT848_O_SCLOOP);
1136 btwrite(0x20, BT848_E_VSCALE_HI);
1137 btwrite(0x20, BT848_O_VSCALE_HI);
1138 btwrite(BT848_ADC_RESERVED | (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1141 btwrite(whitecrush_upper, BT848_WC_UP);
1142 btwrite(whitecrush_lower, BT848_WC_DOWN);
1144 if (btv->opt_lumafilter) {
1145 btwrite(0, BT848_E_CONTROL);
1146 btwrite(0, BT848_O_CONTROL);
1148 btwrite(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1149 btwrite(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1152 bt848_bright(btv, btv->bright);
1153 bt848_hue(btv, btv->hue);
1154 bt848_contrast(btv, btv->contrast);
1155 bt848_sat(btv, btv->saturation);
1161 static void bttv_reinit_bt848(struct bttv *btv)
1163 unsigned long flags;
1166 printk(KERN_INFO "bttv%d: reset, reinitialize\n",btv->c.nr);
1167 spin_lock_irqsave(&btv->s_lock,flags);
1169 bttv_set_dma(btv,0);
1170 spin_unlock_irqrestore(&btv->s_lock,flags);
1173 btv->pll.pll_current = -1;
1174 set_input(btv,btv->input);
1177 static int get_control(struct bttv *btv, struct v4l2_control *c)
1179 struct video_audio va;
1182 for (i = 0; i < BTTV_CTLS; i++)
1183 if (bttv_ctls[i].id == c->id)
1187 if (i >= 4 && i <= 8) {
1188 memset(&va,0,sizeof(va));
1189 bttv_call_i2c_clients(btv, VIDIOCGAUDIO, &va);
1190 if (btv->audio_hook)
1191 btv->audio_hook(btv,&va,0);
1194 case V4L2_CID_BRIGHTNESS:
1195 c->value = btv->bright;
1198 c->value = btv->hue;
1200 case V4L2_CID_CONTRAST:
1201 c->value = btv->contrast;
1203 case V4L2_CID_SATURATION:
1204 c->value = btv->saturation;
1207 case V4L2_CID_AUDIO_MUTE:
1208 c->value = (VIDEO_AUDIO_MUTE & va.flags) ? 1 : 0;
1210 case V4L2_CID_AUDIO_VOLUME:
1211 c->value = va.volume;
1213 case V4L2_CID_AUDIO_BALANCE:
1214 c->value = va.balance;
1216 case V4L2_CID_AUDIO_BASS:
1219 case V4L2_CID_AUDIO_TREBLE:
1220 c->value = va.treble;
1223 case V4L2_CID_PRIVATE_CHROMA_AGC:
1224 c->value = btv->opt_chroma_agc;
1226 case V4L2_CID_PRIVATE_COMBFILTER:
1227 c->value = btv->opt_combfilter;
1229 case V4L2_CID_PRIVATE_LUMAFILTER:
1230 c->value = btv->opt_lumafilter;
1232 case V4L2_CID_PRIVATE_AUTOMUTE:
1233 c->value = btv->opt_automute;
1235 case V4L2_CID_PRIVATE_AGC_CRUSH:
1236 c->value = btv->opt_adc_crush;
1238 case V4L2_CID_PRIVATE_VCR_HACK:
1239 c->value = btv->opt_vcr_hack;
1241 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1242 c->value = btv->opt_whitecrush_upper;
1244 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1245 c->value = btv->opt_whitecrush_lower;
1247 case V4L2_CID_PRIVATE_UV_RATIO:
1248 c->value = btv->opt_uv_ratio;
1250 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1251 c->value = btv->opt_full_luma_range;
1253 case V4L2_CID_PRIVATE_CORING:
1254 c->value = btv->opt_coring;
1262 static int set_control(struct bttv *btv, struct v4l2_control *c)
1264 struct video_audio va;
1267 for (i = 0; i < BTTV_CTLS; i++)
1268 if (bttv_ctls[i].id == c->id)
1272 if (i >= 4 && i <= 8) {
1273 memset(&va,0,sizeof(va));
1274 bttv_call_i2c_clients(btv, VIDIOCGAUDIO, &va);
1275 if (btv->audio_hook)
1276 btv->audio_hook(btv,&va,0);
1279 case V4L2_CID_BRIGHTNESS:
1280 bt848_bright(btv,c->value);
1283 bt848_hue(btv,c->value);
1285 case V4L2_CID_CONTRAST:
1286 bt848_contrast(btv,c->value);
1288 case V4L2_CID_SATURATION:
1289 bt848_sat(btv,c->value);
1291 case V4L2_CID_AUDIO_MUTE:
1293 va.flags |= VIDEO_AUDIO_MUTE;
1296 va.flags &= ~VIDEO_AUDIO_MUTE;
1301 case V4L2_CID_AUDIO_VOLUME:
1302 va.volume = c->value;
1304 case V4L2_CID_AUDIO_BALANCE:
1305 va.balance = c->value;
1307 case V4L2_CID_AUDIO_BASS:
1310 case V4L2_CID_AUDIO_TREBLE:
1311 va.treble = c->value;
1314 case V4L2_CID_PRIVATE_CHROMA_AGC:
1315 btv->opt_chroma_agc = c->value;
1316 val = btv->opt_chroma_agc ? BT848_SCLOOP_CAGC : 0;
1317 btwrite(val, BT848_E_SCLOOP);
1318 btwrite(val, BT848_O_SCLOOP);
1320 case V4L2_CID_PRIVATE_COMBFILTER:
1321 btv->opt_combfilter = c->value;
1323 case V4L2_CID_PRIVATE_LUMAFILTER:
1324 btv->opt_lumafilter = c->value;
1325 if (btv->opt_lumafilter) {
1326 btand(~BT848_CONTROL_LDEC, BT848_E_CONTROL);
1327 btand(~BT848_CONTROL_LDEC, BT848_O_CONTROL);
1329 btor(BT848_CONTROL_LDEC, BT848_E_CONTROL);
1330 btor(BT848_CONTROL_LDEC, BT848_O_CONTROL);
1333 case V4L2_CID_PRIVATE_AUTOMUTE:
1334 btv->opt_automute = c->value;
1336 case V4L2_CID_PRIVATE_AGC_CRUSH:
1337 btv->opt_adc_crush = c->value;
1338 btwrite(BT848_ADC_RESERVED | (btv->opt_adc_crush ? BT848_ADC_CRUSH : 0),
1341 case V4L2_CID_PRIVATE_VCR_HACK:
1342 btv->opt_vcr_hack = c->value;
1344 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER:
1345 btv->opt_whitecrush_upper = c->value;
1346 btwrite(c->value, BT848_WC_UP);
1348 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER:
1349 btv->opt_whitecrush_lower = c->value;
1350 btwrite(c->value, BT848_WC_DOWN);
1352 case V4L2_CID_PRIVATE_UV_RATIO:
1353 btv->opt_uv_ratio = c->value;
1354 bt848_sat(btv, btv->saturation);
1356 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE:
1357 btv->opt_full_luma_range = c->value;
1358 btaor((c->value<<7), ~BT848_OFORM_RANGE, BT848_OFORM);
1360 case V4L2_CID_PRIVATE_CORING:
1361 btv->opt_coring = c->value;
1362 btaor((c->value<<5), ~BT848_OFORM_CORE32, BT848_OFORM);
1367 if (i >= 4 && i <= 8) {
1368 bttv_call_i2c_clients(btv, VIDIOCSAUDIO, &va);
1369 if (btv->audio_hook)
1370 btv->audio_hook(btv,&va,1);
1375 /* ----------------------------------------------------------------------- */
1377 void bttv_gpio_tracking(struct bttv *btv, char *comment)
1379 unsigned int outbits, data;
1380 outbits = btread(BT848_GPIO_OUT_EN);
1381 data = btread(BT848_GPIO_DATA);
1382 printk(KERN_DEBUG "bttv%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
1383 btv->c.nr,outbits,data & outbits, data & ~outbits, comment);
1386 static void bttv_field_count(struct bttv *btv)
1394 /* start field counter */
1395 btor(BT848_INT_VSYNC,BT848_INT_MASK);
1397 /* stop field counter */
1398 btand(~BT848_INT_VSYNC,BT848_INT_MASK);
1399 btv->field_count = 0;
1403 static const struct bttv_format*
1404 format_by_palette(int palette)
1408 for (i = 0; i < BTTV_FORMATS; i++) {
1409 if (-1 == bttv_formats[i].palette)
1411 if (bttv_formats[i].palette == palette)
1412 return bttv_formats+i;
1417 static const struct bttv_format*
1418 format_by_fourcc(int fourcc)
1422 for (i = 0; i < BTTV_FORMATS; i++) {
1423 if (-1 == bttv_formats[i].fourcc)
1425 if (bttv_formats[i].fourcc == fourcc)
1426 return bttv_formats+i;
1431 /* ----------------------------------------------------------------------- */
1435 bttv_switch_overlay(struct bttv *btv, struct bttv_fh *fh,
1436 struct bttv_buffer *new)
1438 struct bttv_buffer *old;
1439 unsigned long flags;
1442 dprintk("switch_overlay: enter [new=%p]\n",new);
1444 new->vb.state = STATE_DONE;
1445 spin_lock_irqsave(&btv->s_lock,flags);
1449 bttv_set_dma(btv, 0x03);
1450 spin_unlock_irqrestore(&btv->s_lock,flags);
1452 free_btres(btv,fh,RESOURCE_OVERLAY);
1454 dprintk("switch_overlay: old=%p state is %d\n",old,old->vb.state);
1455 bttv_dma_free(&fh->cap,btv, old);
1458 dprintk("switch_overlay: done\n");
1462 /* ----------------------------------------------------------------------- */
1463 /* video4linux (1) interface */
1465 static int bttv_prepare_buffer(struct videobuf_queue *q,struct bttv *btv,
1466 struct bttv_buffer *buf,
1467 const struct bttv_format *fmt,
1468 unsigned int width, unsigned int height,
1469 enum v4l2_field field)
1471 int redo_dma_risc = 0;
1474 /* check settings */
1477 if (fmt->btformat == BT848_COLOR_FMT_RAW) {
1479 height = RAW_LINES*2;
1480 if (width*height > buf->vb.bsize)
1482 buf->vb.size = buf->vb.bsize;
1486 width > bttv_tvnorms[btv->tvnorm].swidth ||
1487 height > bttv_tvnorms[btv->tvnorm].sheight)
1489 buf->vb.size = (width * height * fmt->depth) >> 3;
1490 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
1494 /* alloc + fill struct bttv_buffer (if changed) */
1495 if (buf->vb.width != width || buf->vb.height != height ||
1496 buf->vb.field != field ||
1497 buf->tvnorm != btv->tvnorm || buf->fmt != fmt) {
1498 buf->vb.width = width;
1499 buf->vb.height = height;
1500 buf->vb.field = field;
1501 buf->tvnorm = btv->tvnorm;
1506 /* alloc risc memory */
1507 if (STATE_NEEDS_INIT == buf->vb.state) {
1509 if (0 != (rc = videobuf_iolock(q,&buf->vb,&btv->fbuf)))
1514 if (0 != (rc = bttv_buffer_risc(btv,buf)))
1517 buf->vb.state = STATE_PREPARED;
1521 bttv_dma_free(q,btv,buf);
1526 buffer_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
1528 struct bttv_fh *fh = q->priv_data;
1530 *size = fh->fmt->depth*fh->width*fh->height >> 3;
1533 while (*size * *count > gbuffers * gbufsize)
1539 buffer_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
1540 enum v4l2_field field)
1542 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1543 struct bttv_fh *fh = q->priv_data;
1545 return bttv_prepare_buffer(q,fh->btv, buf, fh->fmt,
1546 fh->width, fh->height, field);
1550 buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
1552 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1553 struct bttv_fh *fh = q->priv_data;
1554 struct bttv *btv = fh->btv;
1556 buf->vb.state = STATE_QUEUED;
1557 list_add_tail(&buf->vb.queue,&btv->capture);
1558 if (!btv->curr.frame_irq) {
1560 bttv_set_dma(btv, 0x03);
1564 static void buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
1566 struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
1567 struct bttv_fh *fh = q->priv_data;
1569 bttv_dma_free(&fh->cap,fh->btv,buf);
1572 static struct videobuf_queue_ops bttv_video_qops = {
1573 .buf_setup = buffer_setup,
1574 .buf_prepare = buffer_prepare,
1575 .buf_queue = buffer_queue,
1576 .buf_release = buffer_release,
1579 static int bttv_common_ioctls(struct bttv *btv, unsigned int cmd, void *arg)
1583 return BTTV_VERSION_CODE;
1585 /* *** v4l1 *** ************************************************ */
1588 unsigned long *freq = arg;
1594 unsigned long *freq = arg;
1595 mutex_lock(&btv->lock);
1597 bttv_call_i2c_clients(btv,VIDIOCSFREQ,freq);
1598 if (btv->has_matchbox && btv->radio_user)
1599 tea5757_set_freq(btv,*freq);
1600 mutex_unlock(&btv->lock);
1606 struct video_tuner *v = arg;
1608 if (UNSET == bttv_tvcards[btv->c.type].tuner)
1610 if (v->tuner) /* Only tuner 0 */
1612 strcpy(v->name, "Television");
1614 v->rangehigh = 0x7FFFFFFF;
1615 v->flags = VIDEO_TUNER_PAL|VIDEO_TUNER_NTSC|VIDEO_TUNER_SECAM;
1616 v->mode = btv->tvnorm;
1617 v->signal = (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC) ? 0xFFFF : 0;
1618 bttv_call_i2c_clients(btv,cmd,v);
1623 struct video_tuner *v = arg;
1625 if (v->tuner) /* Only tuner 0 */
1627 if (v->mode >= BTTV_TVNORMS)
1630 mutex_lock(&btv->lock);
1631 set_tvnorm(btv,v->mode);
1632 bttv_call_i2c_clients(btv,cmd,v);
1633 mutex_unlock(&btv->lock);
1639 struct video_channel *v = arg;
1640 unsigned int channel = v->channel;
1642 if (channel >= bttv_tvcards[btv->c.type].video_inputs)
1645 v->flags = VIDEO_VC_AUDIO;
1646 v->type = VIDEO_TYPE_CAMERA;
1647 v->norm = btv->tvnorm;
1648 if (channel == bttv_tvcards[btv->c.type].tuner) {
1649 strcpy(v->name,"Television");
1650 v->flags|=VIDEO_VC_TUNER;
1651 v->type=VIDEO_TYPE_TV;
1653 } else if (channel == btv->svhs) {
1654 strcpy(v->name,"S-Video");
1656 sprintf(v->name,"Composite%d",channel);
1662 struct video_channel *v = arg;
1663 unsigned int channel = v->channel;
1665 if (channel >= bttv_tvcards[btv->c.type].video_inputs)
1667 if (v->norm >= BTTV_TVNORMS)
1670 mutex_lock(&btv->lock);
1671 if (channel == btv->input &&
1672 v->norm == btv->tvnorm) {
1674 mutex_unlock(&btv->lock);
1678 btv->tvnorm = v->norm;
1679 set_input(btv,v->channel);
1680 mutex_unlock(&btv->lock);
1686 struct video_audio *v = arg;
1688 memset(v,0,sizeof(*v));
1689 strcpy(v->name,"Television");
1690 v->flags |= VIDEO_AUDIO_MUTABLE;
1691 v->mode = VIDEO_SOUND_MONO;
1693 mutex_lock(&btv->lock);
1694 bttv_call_i2c_clients(btv,cmd,v);
1696 /* card specific hooks */
1697 if (btv->audio_hook)
1698 btv->audio_hook(btv,v,0);
1700 mutex_unlock(&btv->lock);
1705 struct video_audio *v = arg;
1706 unsigned int audio = v->audio;
1708 if (audio >= bttv_tvcards[btv->c.type].audio_inputs)
1711 mutex_lock(&btv->lock);
1712 audio_mute(btv, (v->flags&VIDEO_AUDIO_MUTE) ? 1 : 0);
1713 bttv_call_i2c_clients(btv,cmd,v);
1715 /* card specific hooks */
1716 if (btv->audio_hook)
1717 btv->audio_hook(btv,v,1);
1719 mutex_unlock(&btv->lock);
1723 /* *** v4l2 *** ************************************************ */
1724 case VIDIOC_ENUMSTD:
1726 struct v4l2_standard *e = arg;
1727 unsigned int index = e->index;
1729 if (index >= BTTV_TVNORMS)
1731 v4l2_video_std_construct(e, bttv_tvnorms[e->index].v4l2_id,
1732 bttv_tvnorms[e->index].name);
1738 v4l2_std_id *id = arg;
1739 *id = bttv_tvnorms[btv->tvnorm].v4l2_id;
1744 v4l2_std_id *id = arg;
1747 for (i = 0; i < BTTV_TVNORMS; i++)
1748 if (*id & bttv_tvnorms[i].v4l2_id)
1750 if (i == BTTV_TVNORMS)
1753 mutex_lock(&btv->lock);
1755 i2c_vidiocschan(btv);
1756 mutex_unlock(&btv->lock);
1759 case VIDIOC_QUERYSTD:
1761 v4l2_std_id *id = arg;
1763 if (btread(BT848_DSTATUS) & BT848_DSTATUS_NUML)
1764 *id = V4L2_STD_625_50;
1766 *id = V4L2_STD_525_60;
1770 case VIDIOC_ENUMINPUT:
1772 struct v4l2_input *i = arg;
1776 if (n >= bttv_tvcards[btv->c.type].video_inputs)
1778 memset(i,0,sizeof(*i));
1780 i->type = V4L2_INPUT_TYPE_CAMERA;
1782 if (i->index == bttv_tvcards[btv->c.type].tuner) {
1783 sprintf(i->name, "Television");
1784 i->type = V4L2_INPUT_TYPE_TUNER;
1786 } else if (i->index == btv->svhs) {
1787 sprintf(i->name, "S-Video");
1789 sprintf(i->name,"Composite%d",i->index);
1791 if (i->index == btv->input) {
1792 __u32 dstatus = btread(BT848_DSTATUS);
1793 if (0 == (dstatus & BT848_DSTATUS_PRES))
1794 i->status |= V4L2_IN_ST_NO_SIGNAL;
1795 if (0 == (dstatus & BT848_DSTATUS_HLOC))
1796 i->status |= V4L2_IN_ST_NO_H_LOCK;
1798 for (n = 0; n < BTTV_TVNORMS; n++)
1799 i->std |= bttv_tvnorms[n].v4l2_id;
1802 case VIDIOC_G_INPUT:
1808 case VIDIOC_S_INPUT:
1810 unsigned int *i = arg;
1812 if (*i > bttv_tvcards[btv->c.type].video_inputs)
1814 mutex_lock(&btv->lock);
1816 mutex_unlock(&btv->lock);
1820 case VIDIOC_G_TUNER:
1822 struct v4l2_tuner *t = arg;
1824 if (UNSET == bttv_tvcards[btv->c.type].tuner)
1828 mutex_lock(&btv->lock);
1829 memset(t,0,sizeof(*t));
1830 strcpy(t->name, "Television");
1831 t->type = V4L2_TUNER_ANALOG_TV;
1832 t->capability = V4L2_TUNER_CAP_NORM;
1833 t->rxsubchans = V4L2_TUNER_SUB_MONO;
1834 if (btread(BT848_DSTATUS)&BT848_DSTATUS_HLOC)
1837 struct video_tuner tuner;
1839 memset(&tuner, 0, sizeof (tuner));
1840 tuner.rangehigh = 0xffffffffUL;
1841 bttv_call_i2c_clients(btv, VIDIOCGTUNER, &tuner);
1842 t->rangelow = tuner.rangelow;
1843 t->rangehigh = tuner.rangehigh;
1847 struct video_audio va;
1848 memset(&va, 0, sizeof(struct video_audio));
1849 bttv_call_i2c_clients(btv, VIDIOCGAUDIO, &va);
1850 if (btv->audio_hook)
1851 btv->audio_hook(btv,&va,0);
1852 if(va.mode & VIDEO_SOUND_STEREO) {
1853 t->audmode = V4L2_TUNER_MODE_STEREO;
1854 t->rxsubchans |= V4L2_TUNER_SUB_STEREO;
1856 if(va.mode & VIDEO_SOUND_LANG1) {
1857 t->audmode = V4L2_TUNER_MODE_LANG1;
1858 t->rxsubchans = V4L2_TUNER_SUB_LANG1
1859 | V4L2_TUNER_SUB_LANG2;
1862 /* FIXME: fill capability+audmode */
1863 mutex_unlock(&btv->lock);
1866 case VIDIOC_S_TUNER:
1868 struct v4l2_tuner *t = arg;
1870 if (UNSET == bttv_tvcards[btv->c.type].tuner)
1874 mutex_lock(&btv->lock);
1876 struct video_audio va;
1877 memset(&va, 0, sizeof(struct video_audio));
1878 bttv_call_i2c_clients(btv, VIDIOCGAUDIO, &va);
1879 if (t->audmode == V4L2_TUNER_MODE_MONO)
1880 va.mode = VIDEO_SOUND_MONO;
1881 else if (t->audmode == V4L2_TUNER_MODE_STEREO ||
1882 t->audmode == V4L2_TUNER_MODE_LANG1_LANG2)
1883 va.mode = VIDEO_SOUND_STEREO;
1884 else if (t->audmode == V4L2_TUNER_MODE_LANG1)
1885 va.mode = VIDEO_SOUND_LANG1;
1886 else if (t->audmode == V4L2_TUNER_MODE_LANG2)
1887 va.mode = VIDEO_SOUND_LANG2;
1888 bttv_call_i2c_clients(btv, VIDIOCSAUDIO, &va);
1889 if (btv->audio_hook)
1890 btv->audio_hook(btv,&va,1);
1892 mutex_unlock(&btv->lock);
1896 case VIDIOC_G_FREQUENCY:
1898 struct v4l2_frequency *f = arg;
1900 memset(f,0,sizeof(*f));
1901 f->type = V4L2_TUNER_ANALOG_TV;
1902 f->frequency = btv->freq;
1905 case VIDIOC_S_FREQUENCY:
1907 struct v4l2_frequency *f = arg;
1909 if (unlikely(f->tuner != 0))
1911 if (unlikely (f->type != V4L2_TUNER_ANALOG_TV))
1913 mutex_lock(&btv->lock);
1914 btv->freq = f->frequency;
1915 bttv_call_i2c_clients(btv,VIDIOCSFREQ,&btv->freq);
1916 if (btv->has_matchbox && btv->radio_user)
1917 tea5757_set_freq(btv,btv->freq);
1918 mutex_unlock(&btv->lock);
1921 case VIDIOC_LOG_STATUS:
1923 bttv_call_i2c_clients(btv, VIDIOC_LOG_STATUS, NULL);
1928 return -ENOIOCTLCMD;
1934 static int verify_window(const struct bttv_tvnorm *tvn,
1935 struct v4l2_window *win, int fixup)
1937 enum v4l2_field field;
1940 if (win->w.width < 48 || win->w.height < 32)
1942 if (win->clipcount > 2048)
1947 maxh = tvn->sheight;
1949 if (V4L2_FIELD_ANY == field) {
1950 field = (win->w.height > maxh/2)
1951 ? V4L2_FIELD_INTERLACED
1955 case V4L2_FIELD_TOP:
1956 case V4L2_FIELD_BOTTOM:
1959 case V4L2_FIELD_INTERLACED:
1965 if (!fixup && (win->w.width > maxw || win->w.height > maxh))
1968 if (win->w.width > maxw)
1969 win->w.width = maxw;
1970 if (win->w.height > maxh)
1971 win->w.height = maxh;
1976 static int setup_window(struct bttv_fh *fh, struct bttv *btv,
1977 struct v4l2_window *win, int fixup)
1979 struct v4l2_clip *clips = NULL;
1980 int n,size,retval = 0;
1982 if (NULL == fh->ovfmt)
1984 if (!(fh->ovfmt->flags & FORMAT_FLAGS_PACKED))
1986 retval = verify_window(&bttv_tvnorms[btv->tvnorm],win,fixup);
1990 /* copy clips -- luckily v4l1 + v4l2 are binary
1991 compatible here ...*/
1993 size = sizeof(*clips)*(n+4);
1994 clips = kmalloc(size,GFP_KERNEL);
1998 if (copy_from_user(clips,win->clips,sizeof(struct v4l2_clip)*n)) {
2003 /* clip against screen */
2004 if (NULL != btv->fbuf.base)
2005 n = btcx_screen_clips(btv->fbuf.fmt.width, btv->fbuf.fmt.height,
2007 btcx_sort_clips(clips,n);
2009 /* 4-byte alignments */
2010 switch (fh->ovfmt->depth) {
2013 btcx_align(&win->w, clips, n, 3);
2016 btcx_align(&win->w, clips, n, 1);
2019 /* no alignment fixups needed */
2025 mutex_lock(&fh->cap.lock);
2026 kfree(fh->ov.clips);
2027 fh->ov.clips = clips;
2031 fh->ov.field = win->field;
2032 fh->ov.setup_ok = 1;
2033 btv->init.ov.w.width = win->w.width;
2034 btv->init.ov.w.height = win->w.height;
2035 btv->init.ov.field = win->field;
2037 /* update overlay if needed */
2039 if (check_btres(fh, RESOURCE_OVERLAY)) {
2040 struct bttv_buffer *new;
2042 new = videobuf_alloc(sizeof(*new));
2043 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2044 retval = bttv_switch_overlay(btv,fh,new);
2046 mutex_unlock(&fh->cap.lock);
2050 /* ----------------------------------------------------------------------- */
2052 static struct videobuf_queue* bttv_queue(struct bttv_fh *fh)
2054 struct videobuf_queue* q = NULL;
2057 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2060 case V4L2_BUF_TYPE_VBI_CAPTURE:
2069 static int bttv_resource(struct bttv_fh *fh)
2074 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2075 res = RESOURCE_VIDEO;
2077 case V4L2_BUF_TYPE_VBI_CAPTURE:
2086 static int bttv_switch_type(struct bttv_fh *fh, enum v4l2_buf_type type)
2088 struct videobuf_queue *q = bttv_queue(fh);
2089 int res = bttv_resource(fh);
2091 if (check_btres(fh,res))
2093 if (videobuf_queue_is_busy(q))
2100 pix_format_set_size (struct v4l2_pix_format * f,
2101 const struct bttv_format * fmt,
2103 unsigned int height)
2108 if (fmt->flags & FORMAT_FLAGS_PLANAR) {
2109 f->bytesperline = width; /* Y plane */
2110 f->sizeimage = (width * height * fmt->depth) >> 3;
2112 f->bytesperline = (width * fmt->depth) >> 3;
2113 f->sizeimage = height * f->bytesperline;
2117 static int bttv_g_fmt(struct bttv_fh *fh, struct v4l2_format *f)
2120 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2121 memset(&f->fmt.pix,0,sizeof(struct v4l2_pix_format));
2122 pix_format_set_size (&f->fmt.pix, fh->fmt,
2123 fh->width, fh->height);
2124 f->fmt.pix.field = fh->cap.field;
2125 f->fmt.pix.pixelformat = fh->fmt->fourcc;
2127 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2128 memset(&f->fmt.win,0,sizeof(struct v4l2_window));
2129 f->fmt.win.w = fh->ov.w;
2130 f->fmt.win.field = fh->ov.field;
2132 case V4L2_BUF_TYPE_VBI_CAPTURE:
2133 bttv_vbi_get_fmt(fh,f);
2140 static int bttv_try_fmt(struct bttv_fh *fh, struct bttv *btv,
2141 struct v4l2_format *f)
2144 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2146 const struct bttv_format *fmt;
2147 enum v4l2_field field;
2148 unsigned int maxw,maxh;
2150 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2155 maxw = bttv_tvnorms[btv->tvnorm].swidth;
2156 maxh = bttv_tvnorms[btv->tvnorm].sheight;
2157 field = f->fmt.pix.field;
2158 if (V4L2_FIELD_ANY == field)
2159 field = (f->fmt.pix.height > maxh/2)
2160 ? V4L2_FIELD_INTERLACED
2161 : V4L2_FIELD_BOTTOM;
2162 if (V4L2_FIELD_SEQ_BT == field)
2163 field = V4L2_FIELD_SEQ_TB;
2165 case V4L2_FIELD_TOP:
2166 case V4L2_FIELD_BOTTOM:
2167 case V4L2_FIELD_ALTERNATE:
2170 case V4L2_FIELD_INTERLACED:
2172 case V4L2_FIELD_SEQ_TB:
2173 if (fmt->flags & FORMAT_FLAGS_PLANAR)
2180 /* update data for the application */
2181 f->fmt.pix.field = field;
2182 if (f->fmt.pix.width < 48)
2183 f->fmt.pix.width = 48;
2184 if (f->fmt.pix.height < 32)
2185 f->fmt.pix.height = 32;
2186 if (f->fmt.pix.width > maxw)
2187 f->fmt.pix.width = maxw;
2188 if (f->fmt.pix.height > maxh)
2189 f->fmt.pix.height = maxh;
2190 pix_format_set_size (&f->fmt.pix, fmt,
2191 f->fmt.pix.width & ~3,
2196 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2197 return verify_window(&bttv_tvnorms[btv->tvnorm],
2199 case V4L2_BUF_TYPE_VBI_CAPTURE:
2200 bttv_vbi_try_fmt(fh,f);
2207 static int bttv_s_fmt(struct bttv_fh *fh, struct bttv *btv,
2208 struct v4l2_format *f)
2213 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2215 const struct bttv_format *fmt;
2217 retval = bttv_switch_type(fh,f->type);
2220 retval = bttv_try_fmt(fh,btv,f);
2223 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
2225 /* update our state informations */
2226 mutex_lock(&fh->cap.lock);
2228 fh->cap.field = f->fmt.pix.field;
2229 fh->cap.last = V4L2_FIELD_NONE;
2230 fh->width = f->fmt.pix.width;
2231 fh->height = f->fmt.pix.height;
2232 btv->init.fmt = fmt;
2233 btv->init.width = f->fmt.pix.width;
2234 btv->init.height = f->fmt.pix.height;
2235 mutex_unlock(&fh->cap.lock);
2239 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2240 if (no_overlay > 0) {
2241 printk ("V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2244 return setup_window(fh, btv, &f->fmt.win, 1);
2245 case V4L2_BUF_TYPE_VBI_CAPTURE:
2246 retval = bttv_switch_type(fh,f->type);
2249 if (locked_btres(fh->btv, RESOURCE_VBI))
2251 bttv_vbi_try_fmt(fh,f);
2252 bttv_vbi_setlines(fh,btv,f->fmt.vbi.count[0]);
2253 bttv_vbi_get_fmt(fh,f);
2260 static int bttv_do_ioctl(struct inode *inode, struct file *file,
2261 unsigned int cmd, void *arg)
2263 struct bttv_fh *fh = file->private_data;
2264 struct bttv *btv = fh->btv;
2265 unsigned long flags;
2269 v4l_print_ioctl(btv->c.name, cmd);
2272 bttv_reinit_bt848(btv);
2280 case VIDIOC_S_INPUT:
2281 case VIDIOC_S_TUNER:
2282 case VIDIOC_S_FREQUENCY:
2283 retval = v4l2_prio_check(&btv->prio,&fh->prio);
2290 /* *** v4l1 *** ************************************************ */
2293 struct video_capability *cap = arg;
2295 memset(cap,0,sizeof(*cap));
2296 strcpy(cap->name,btv->video_dev->name);
2297 if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
2299 cap->type = VID_TYPE_TUNER|VID_TYPE_TELETEXT;
2302 cap->type = VID_TYPE_CAPTURE|
2306 if (no_overlay <= 0)
2307 cap->type |= VID_TYPE_OVERLAY;
2309 cap->maxwidth = bttv_tvnorms[btv->tvnorm].swidth;
2310 cap->maxheight = bttv_tvnorms[btv->tvnorm].sheight;
2312 cap->minheight = 32;
2314 cap->channels = bttv_tvcards[btv->c.type].video_inputs;
2315 cap->audios = bttv_tvcards[btv->c.type].audio_inputs;
2321 struct video_picture *pic = arg;
2323 memset(pic,0,sizeof(*pic));
2324 pic->brightness = btv->bright;
2325 pic->contrast = btv->contrast;
2326 pic->hue = btv->hue;
2327 pic->colour = btv->saturation;
2329 pic->depth = fh->fmt->depth;
2330 pic->palette = fh->fmt->palette;
2336 struct video_picture *pic = arg;
2337 const struct bttv_format *fmt;
2339 fmt = format_by_palette(pic->palette);
2342 mutex_lock(&fh->cap.lock);
2343 if (fmt->depth != pic->depth) {
2345 goto fh_unlock_and_return;
2347 if (fmt->flags & FORMAT_FLAGS_RAW) {
2348 /* VIDIOCMCAPTURE uses gbufsize, not RAW_BPL *
2349 RAW_LINES * 2. F1 is stored at offset 0, F2
2350 at buffer size / 2. */
2351 fh->width = RAW_BPL;
2352 fh->height = gbufsize / RAW_BPL;
2353 btv->init.width = RAW_BPL;
2354 btv->init.height = gbufsize / RAW_BPL;
2358 btv->init.ovfmt = fmt;
2359 btv->init.fmt = fmt;
2361 /* dirty hack time: swap bytes for overlay if the
2362 display adaptor is big endian (insmod option) */
2363 if (fmt->palette == VIDEO_PALETTE_RGB555 ||
2364 fmt->palette == VIDEO_PALETTE_RGB565 ||
2365 fmt->palette == VIDEO_PALETTE_RGB32) {
2369 bt848_bright(btv,pic->brightness);
2370 bt848_contrast(btv,pic->contrast);
2371 bt848_hue(btv,pic->hue);
2372 bt848_sat(btv,pic->colour);
2373 mutex_unlock(&fh->cap.lock);
2379 struct video_window *win = arg;
2381 memset(win,0,sizeof(*win));
2382 win->x = fh->ov.w.left;
2383 win->y = fh->ov.w.top;
2384 win->width = fh->ov.w.width;
2385 win->height = fh->ov.w.height;
2390 struct video_window *win = arg;
2391 struct v4l2_window w2;
2393 if (no_overlay > 0) {
2394 printk ("VIDIOCSWIN: no_overlay\n");
2398 w2.field = V4L2_FIELD_ANY;
2401 w2.w.width = win->width;
2402 w2.w.height = win->height;
2403 w2.clipcount = win->clipcount;
2404 w2.clips = (struct v4l2_clip __user *)win->clips;
2405 retval = setup_window(fh, btv, &w2, 0);
2407 /* on v4l1 this ioctl affects the read() size too */
2408 fh->width = fh->ov.w.width;
2409 fh->height = fh->ov.w.height;
2410 btv->init.width = fh->ov.w.width;
2411 btv->init.height = fh->ov.w.height;
2418 struct video_buffer *fbuf = arg;
2420 fbuf->base = btv->fbuf.base;
2421 fbuf->width = btv->fbuf.fmt.width;
2422 fbuf->height = btv->fbuf.fmt.height;
2423 fbuf->bytesperline = btv->fbuf.fmt.bytesperline;
2425 fbuf->depth = fh->ovfmt->depth;
2430 struct video_buffer *fbuf = arg;
2431 const struct bttv_format *fmt;
2434 if(!capable(CAP_SYS_ADMIN) &&
2435 !capable(CAP_SYS_RAWIO))
2437 end = (unsigned long)fbuf->base +
2438 fbuf->height * fbuf->bytesperline;
2439 mutex_lock(&fh->cap.lock);
2442 switch (fbuf->depth) {
2444 fmt = format_by_palette(VIDEO_PALETTE_HI240);
2447 fmt = format_by_palette(VIDEO_PALETTE_RGB565);
2450 fmt = format_by_palette(VIDEO_PALETTE_RGB24);
2453 fmt = format_by_palette(VIDEO_PALETTE_RGB32);
2457 fmt = format_by_palette(VIDEO_PALETTE_RGB555);
2464 goto fh_unlock_and_return;
2468 btv->init.ovfmt = fmt;
2469 btv->init.fmt = fmt;
2470 btv->fbuf.base = fbuf->base;
2471 btv->fbuf.fmt.width = fbuf->width;
2472 btv->fbuf.fmt.height = fbuf->height;
2473 if (fbuf->bytesperline)
2474 btv->fbuf.fmt.bytesperline = fbuf->bytesperline;
2476 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fbuf->depth/8;
2477 mutex_unlock(&fh->cap.lock);
2482 case VIDIOC_OVERLAY:
2484 struct bttv_buffer *new;
2489 if (NULL == btv->fbuf.base)
2491 if (!fh->ov.setup_ok) {
2492 dprintk("bttv%d: overlay: !setup_ok\n",btv->c.nr);
2497 if (!check_alloc_btres(btv,fh,RESOURCE_OVERLAY))
2500 mutex_lock(&fh->cap.lock);
2502 fh->ov.tvnorm = btv->tvnorm;
2503 new = videobuf_alloc(sizeof(*new));
2504 bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
2510 retval = bttv_switch_overlay(btv,fh,new);
2511 mutex_unlock(&fh->cap.lock);
2517 struct video_mbuf *mbuf = arg;
2520 mutex_lock(&fh->cap.lock);
2521 retval = videobuf_mmap_setup(&fh->cap,gbuffers,gbufsize,
2524 goto fh_unlock_and_return;
2525 memset(mbuf,0,sizeof(*mbuf));
2526 mbuf->frames = gbuffers;
2527 mbuf->size = gbuffers * gbufsize;
2528 for (i = 0; i < gbuffers; i++)
2529 mbuf->offsets[i] = i * gbufsize;
2530 mutex_unlock(&fh->cap.lock);
2533 case VIDIOCMCAPTURE:
2535 struct video_mmap *vm = arg;
2536 struct bttv_buffer *buf;
2537 enum v4l2_field field;
2539 if (vm->frame >= VIDEO_MAX_FRAME)
2542 mutex_lock(&fh->cap.lock);
2544 buf = (struct bttv_buffer *)fh->cap.bufs[vm->frame];
2546 goto fh_unlock_and_return;
2547 if (0 == buf->vb.baddr)
2548 goto fh_unlock_and_return;
2549 if (buf->vb.state == STATE_QUEUED ||
2550 buf->vb.state == STATE_ACTIVE)
2551 goto fh_unlock_and_return;
2553 field = (vm->height > bttv_tvnorms[btv->tvnorm].sheight/2)
2554 ? V4L2_FIELD_INTERLACED
2555 : V4L2_FIELD_BOTTOM;
2556 retval = bttv_prepare_buffer(&fh->cap,btv,buf,
2557 format_by_palette(vm->format),
2558 vm->width,vm->height,field);
2560 goto fh_unlock_and_return;
2561 spin_lock_irqsave(&btv->s_lock,flags);
2562 buffer_queue(&fh->cap,&buf->vb);
2563 spin_unlock_irqrestore(&btv->s_lock,flags);
2564 mutex_unlock(&fh->cap.lock);
2570 struct bttv_buffer *buf;
2572 if (*frame >= VIDEO_MAX_FRAME)
2575 mutex_lock(&fh->cap.lock);
2577 buf = (struct bttv_buffer *)fh->cap.bufs[*frame];
2579 goto fh_unlock_and_return;
2580 retval = videobuf_waiton(&buf->vb,0,1);
2582 goto fh_unlock_and_return;
2583 switch (buf->vb.state) {
2588 videobuf_dma_sync(&fh->cap,&buf->vb.dma);
2589 bttv_dma_free(&fh->cap,btv,buf);
2595 mutex_unlock(&fh->cap.lock);
2601 struct vbi_format *fmt = (void *) arg;
2602 struct v4l2_format fmt2;
2604 if (fh->type != V4L2_BUF_TYPE_VBI_CAPTURE) {
2605 retval = bttv_switch_type(fh,V4L2_BUF_TYPE_VBI_CAPTURE);
2609 bttv_vbi_get_fmt(fh, &fmt2);
2611 memset(fmt,0,sizeof(*fmt));
2612 fmt->sampling_rate = fmt2.fmt.vbi.sampling_rate;
2613 fmt->samples_per_line = fmt2.fmt.vbi.samples_per_line;
2614 fmt->sample_format = VIDEO_PALETTE_RAW;
2615 fmt->start[0] = fmt2.fmt.vbi.start[0];
2616 fmt->count[0] = fmt2.fmt.vbi.count[0];
2617 fmt->start[1] = fmt2.fmt.vbi.start[1];
2618 fmt->count[1] = fmt2.fmt.vbi.count[1];
2619 if (fmt2.fmt.vbi.flags & V4L2_VBI_UNSYNC)
2620 fmt->flags |= VBI_UNSYNC;
2621 if (fmt2.fmt.vbi.flags & V4L2_VBI_INTERLACED)
2622 fmt->flags |= VBI_INTERLACED;
2627 struct vbi_format *fmt = (void *) arg;
2628 struct v4l2_format fmt2;
2630 retval = bttv_switch_type(fh,V4L2_BUF_TYPE_VBI_CAPTURE);
2633 bttv_vbi_get_fmt(fh, &fmt2);
2635 if (fmt->sampling_rate != fmt2.fmt.vbi.sampling_rate ||
2636 fmt->samples_per_line != fmt2.fmt.vbi.samples_per_line ||
2637 fmt->sample_format != VIDEO_PALETTE_RAW ||
2638 fmt->start[0] != fmt2.fmt.vbi.start[0] ||
2639 fmt->start[1] != fmt2.fmt.vbi.start[1] ||
2640 fmt->count[0] != fmt->count[1] ||
2641 fmt->count[0] < 1 ||
2642 fmt->count[0] > 32 /* VBI_MAXLINES */)
2645 bttv_vbi_setlines(fh,btv,fmt->count[0]);
2658 return bttv_common_ioctls(btv,cmd,arg);
2660 /* *** v4l2 *** ************************************************ */
2661 case VIDIOC_QUERYCAP:
2663 struct v4l2_capability *cap = arg;
2667 memset(cap, 0, sizeof (*cap));
2668 strlcpy(cap->driver, "bttv", sizeof (cap->driver));
2669 strlcpy(cap->card, btv->video_dev->name, sizeof (cap->card));
2670 snprintf(cap->bus_info, sizeof (cap->bus_info),
2671 "PCI:%s", pci_name(btv->c.pci));
2672 cap->version = BTTV_VERSION_CODE;
2674 V4L2_CAP_VIDEO_CAPTURE |
2675 V4L2_CAP_VBI_CAPTURE |
2676 V4L2_CAP_READWRITE |
2678 if (no_overlay <= 0)
2679 cap->capabilities |= V4L2_CAP_VIDEO_OVERLAY;
2681 if (bttv_tvcards[btv->c.type].tuner != UNSET &&
2682 bttv_tvcards[btv->c.type].tuner != TUNER_ABSENT)
2683 cap->capabilities |= V4L2_CAP_TUNER;
2687 case VIDIOC_ENUM_FMT:
2689 struct v4l2_fmtdesc *f = arg;
2690 enum v4l2_buf_type type;
2695 if (V4L2_BUF_TYPE_VBI_CAPTURE == type) {
2700 memset(f,0,sizeof(*f));
2703 f->pixelformat = V4L2_PIX_FMT_GREY;
2704 strcpy(f->description,"vbi data");
2708 /* video capture + overlay */
2710 for (i = 0; i < BTTV_FORMATS; i++) {
2711 if (bttv_formats[i].fourcc != -1)
2713 if ((unsigned int)index == f->index)
2716 if (BTTV_FORMATS == i)
2720 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2722 case V4L2_BUF_TYPE_VIDEO_OVERLAY:
2723 if (!(bttv_formats[i].flags & FORMAT_FLAGS_PACKED))
2729 memset(f,0,sizeof(*f));
2732 f->pixelformat = bttv_formats[i].fourcc;
2733 strlcpy(f->description,bttv_formats[i].name,sizeof(f->description));
2737 case VIDIOC_TRY_FMT:
2739 struct v4l2_format *f = arg;
2740 return bttv_try_fmt(fh,btv,f);
2744 struct v4l2_format *f = arg;
2745 return bttv_g_fmt(fh,f);
2749 struct v4l2_format *f = arg;
2750 return bttv_s_fmt(fh,btv,f);
2755 struct v4l2_framebuffer *fb = arg;
2758 fb->capability = V4L2_FBUF_CAP_LIST_CLIPPING;
2760 fb->fmt.pixelformat = fh->ovfmt->fourcc;
2765 struct v4l2_framebuffer *fb = arg;
2766 const struct bttv_format *fmt;
2768 if(!capable(CAP_SYS_ADMIN) &&
2769 !capable(CAP_SYS_RAWIO))
2773 fmt = format_by_fourcc(fb->fmt.pixelformat);
2776 if (0 == (fmt->flags & FORMAT_FLAGS_PACKED))
2779 mutex_lock(&fh->cap.lock);
2781 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2782 if (fb->fmt.width > bttv_tvnorms[btv->tvnorm].swidth)
2783 goto fh_unlock_and_return;
2784 if (fb->fmt.height > bttv_tvnorms[btv->tvnorm].sheight)
2785 goto fh_unlock_and_return;
2789 btv->fbuf.base = fb->base;
2790 btv->fbuf.fmt.width = fb->fmt.width;
2791 btv->fbuf.fmt.height = fb->fmt.height;
2792 if (0 != fb->fmt.bytesperline)
2793 btv->fbuf.fmt.bytesperline = fb->fmt.bytesperline;
2795 btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fmt->depth/8;
2799 btv->init.ovfmt = fmt;
2800 if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
2803 fh->ov.w.width = fb->fmt.width;
2804 fh->ov.w.height = fb->fmt.height;
2805 btv->init.ov.w.width = fb->fmt.width;
2806 btv->init.ov.w.height = fb->fmt.height;
2807 kfree(fh->ov.clips);
2808 fh->ov.clips = NULL;
2811 if (check_btres(fh, RESOURCE_OVERLAY)) {
2812 struct bttv_buffer *new;
2814 new = videobuf_alloc(sizeof(*new));
2815 bttv_overlay_risc(btv,&fh->ov,fh->ovfmt,new);
2816 retval = bttv_switch_overlay(btv,fh,new);
2819 mutex_unlock(&fh->cap.lock);
2823 case VIDIOC_REQBUFS:
2824 return videobuf_reqbufs(bttv_queue(fh),arg);
2826 case VIDIOC_QUERYBUF:
2827 return videobuf_querybuf(bttv_queue(fh),arg);
2830 return videobuf_qbuf(bttv_queue(fh),arg);
2833 return videobuf_dqbuf(bttv_queue(fh),arg,
2834 file->f_flags & O_NONBLOCK);
2836 case VIDIOC_STREAMON:
2838 int res = bttv_resource(fh);
2840 if (!check_alloc_btres(btv,fh,res))
2842 return videobuf_streamon(bttv_queue(fh));
2844 case VIDIOC_STREAMOFF:
2846 int res = bttv_resource(fh);
2848 retval = videobuf_streamoff(bttv_queue(fh));
2851 free_btres(btv,fh,res);
2855 case VIDIOC_QUERYCTRL:
2857 struct v4l2_queryctrl *c = arg;
2860 if ((c->id < V4L2_CID_BASE ||
2861 c->id >= V4L2_CID_LASTP1) &&
2862 (c->id < V4L2_CID_PRIVATE_BASE ||
2863 c->id >= V4L2_CID_PRIVATE_LASTP1))
2865 for (i = 0; i < BTTV_CTLS; i++)
2866 if (bttv_ctls[i].id == c->id)
2868 if (i == BTTV_CTLS) {
2873 if (i >= 4 && i <= 8) {
2874 struct video_audio va;
2875 memset(&va,0,sizeof(va));
2876 bttv_call_i2c_clients(btv, VIDIOCGAUDIO, &va);
2877 if (btv->audio_hook)
2878 btv->audio_hook(btv,&va,0);
2879 switch (bttv_ctls[i].id) {
2880 case V4L2_CID_AUDIO_VOLUME:
2881 if (!(va.flags & VIDEO_AUDIO_VOLUME))
2884 case V4L2_CID_AUDIO_BALANCE:
2885 if (!(va.flags & VIDEO_AUDIO_BALANCE))
2888 case V4L2_CID_AUDIO_BASS:
2889 if (!(va.flags & VIDEO_AUDIO_BASS))
2892 case V4L2_CID_AUDIO_TREBLE:
2893 if (!(va.flags & VIDEO_AUDIO_TREBLE))
2901 return get_control(btv,arg);
2903 return set_control(btv,arg);
2906 struct v4l2_streamparm *parm = arg;
2907 struct v4l2_standard s;
2908 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
2910 memset(parm,0,sizeof(*parm));
2911 v4l2_video_std_construct(&s, bttv_tvnorms[btv->tvnorm].v4l2_id,
2912 bttv_tvnorms[btv->tvnorm].name);
2913 parm->parm.capture.timeperframe = s.frameperiod;
2917 case VIDIOC_G_PRIORITY:
2919 enum v4l2_priority *p = arg;
2921 *p = v4l2_prio_max(&btv->prio);
2924 case VIDIOC_S_PRIORITY:
2926 enum v4l2_priority *prio = arg;
2928 return v4l2_prio_change(&btv->prio, &fh->prio, *prio);
2931 case VIDIOC_ENUMSTD:
2934 case VIDIOC_ENUMINPUT:
2935 case VIDIOC_G_INPUT:
2936 case VIDIOC_S_INPUT:
2937 case VIDIOC_G_TUNER:
2938 case VIDIOC_S_TUNER:
2939 case VIDIOC_G_FREQUENCY:
2940 case VIDIOC_S_FREQUENCY:
2941 case VIDIOC_LOG_STATUS:
2942 return bttv_common_ioctls(btv,cmd,arg);
2945 return -ENOIOCTLCMD;
2949 fh_unlock_and_return:
2950 mutex_unlock(&fh->cap.lock);
2954 static int bttv_ioctl(struct inode *inode, struct file *file,
2955 unsigned int cmd, unsigned long arg)
2957 struct bttv_fh *fh = file->private_data;
2961 bttv_switch_type(fh,V4L2_BUF_TYPE_VBI_CAPTURE);
2962 return fh->lines * 2 * 2048;
2964 return video_usercopy(inode, file, cmd, arg, bttv_do_ioctl);
2968 static ssize_t bttv_read(struct file *file, char __user *data,
2969 size_t count, loff_t *ppos)
2971 struct bttv_fh *fh = file->private_data;
2974 if (fh->btv->errors)
2975 bttv_reinit_bt848(fh->btv);
2976 dprintk("bttv%d: read count=%d type=%s\n",
2977 fh->btv->c.nr,(int)count,v4l2_type_names[fh->type]);
2980 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
2981 if (locked_btres(fh->btv,RESOURCE_VIDEO))
2983 retval = videobuf_read_one(&fh->cap, data, count, ppos,
2984 file->f_flags & O_NONBLOCK);
2986 case V4L2_BUF_TYPE_VBI_CAPTURE:
2987 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
2989 retval = videobuf_read_stream(&fh->vbi, data, count, ppos, 1,
2990 file->f_flags & O_NONBLOCK);
2998 static unsigned int bttv_poll(struct file *file, poll_table *wait)
3000 struct bttv_fh *fh = file->private_data;
3001 struct bttv_buffer *buf;
3002 enum v4l2_field field;
3004 if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type) {
3005 if (!check_alloc_btres(fh->btv,fh,RESOURCE_VBI))
3007 return videobuf_poll_stream(file, &fh->vbi, wait);
3010 if (check_btres(fh,RESOURCE_VIDEO)) {
3011 /* streaming capture */
3012 if (list_empty(&fh->cap.stream))
3014 buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
3016 /* read() capture */
3017 mutex_lock(&fh->cap.lock);
3018 if (NULL == fh->cap.read_buf) {
3019 /* need to capture a new frame */
3020 if (locked_btres(fh->btv,RESOURCE_VIDEO)) {
3021 mutex_unlock(&fh->cap.lock);
3024 fh->cap.read_buf = videobuf_alloc(fh->cap.msize);
3025 if (NULL == fh->cap.read_buf) {
3026 mutex_unlock(&fh->cap.lock);
3029 fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
3030 field = videobuf_next_field(&fh->cap);
3031 if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) {
3032 kfree (fh->cap.read_buf);
3033 fh->cap.read_buf = NULL;
3034 mutex_unlock(&fh->cap.lock);
3037 fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
3038 fh->cap.read_off = 0;
3040 mutex_unlock(&fh->cap.lock);
3041 buf = (struct bttv_buffer*)fh->cap.read_buf;
3044 poll_wait(file, &buf->vb.done, wait);
3045 if (buf->vb.state == STATE_DONE ||
3046 buf->vb.state == STATE_ERROR)
3047 return POLLIN|POLLRDNORM;
3051 static int bttv_open(struct inode *inode, struct file *file)
3053 int minor = iminor(inode);
3054 struct bttv *btv = NULL;
3056 enum v4l2_buf_type type = 0;
3059 dprintk(KERN_DEBUG "bttv: open minor=%d\n",minor);
3061 for (i = 0; i < bttv_num; i++) {
3062 if (bttvs[i].video_dev &&
3063 bttvs[i].video_dev->minor == minor) {
3065 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
3068 if (bttvs[i].vbi_dev &&
3069 bttvs[i].vbi_dev->minor == minor) {
3071 type = V4L2_BUF_TYPE_VBI_CAPTURE;
3078 dprintk(KERN_DEBUG "bttv%d: open called (type=%s)\n",
3079 btv->c.nr,v4l2_type_names[type]);
3081 /* allocate per filehandle data */
3082 fh = kmalloc(sizeof(*fh),GFP_KERNEL);
3085 file->private_data = fh;
3088 fh->ov.setup_ok = 0;
3089 v4l2_prio_open(&btv->prio,&fh->prio);
3091 videobuf_queue_init(&fh->cap, &bttv_video_qops,
3092 btv->c.pci, &btv->s_lock,
3093 V4L2_BUF_TYPE_VIDEO_CAPTURE,
3094 V4L2_FIELD_INTERLACED,
3095 sizeof(struct bttv_buffer),
3097 videobuf_queue_init(&fh->vbi, &bttv_vbi_qops,
3098 btv->c.pci, &btv->s_lock,
3099 V4L2_BUF_TYPE_VBI_CAPTURE,
3101 sizeof(struct bttv_buffer),
3103 i2c_vidiocschan(btv);
3106 if (V4L2_BUF_TYPE_VBI_CAPTURE == fh->type)
3107 bttv_vbi_setlines(fh,btv,16);
3108 bttv_field_count(btv);
3112 static int bttv_release(struct inode *inode, struct file *file)
3114 struct bttv_fh *fh = file->private_data;
3115 struct bttv *btv = fh->btv;
3117 /* turn off overlay */
3118 if (check_btres(fh, RESOURCE_OVERLAY))
3119 bttv_switch_overlay(btv,fh,NULL);
3121 /* stop video capture */
3122 if (check_btres(fh, RESOURCE_VIDEO)) {
3123 videobuf_streamoff(&fh->cap);
3124 free_btres(btv,fh,RESOURCE_VIDEO);
3126 if (fh->cap.read_buf) {
3127 buffer_release(&fh->cap,fh->cap.read_buf);
3128 kfree(fh->cap.read_buf);
3131 /* stop vbi capture */
3132 if (check_btres(fh, RESOURCE_VBI)) {
3133 if (fh->vbi.streaming)
3134 videobuf_streamoff(&fh->vbi);
3135 if (fh->vbi.reading)
3136 videobuf_read_stop(&fh->vbi);
3137 free_btres(btv,fh,RESOURCE_VBI);
3141 videobuf_mmap_free(&fh->cap);
3142 videobuf_mmap_free(&fh->vbi);
3143 v4l2_prio_close(&btv->prio,&fh->prio);
3144 file->private_data = NULL;
3148 bttv_field_count(btv);
3153 bttv_mmap(struct file *file, struct vm_area_struct *vma)
3155 struct bttv_fh *fh = file->private_data;
3157 dprintk("bttv%d: mmap type=%s 0x%lx+%ld\n",
3158 fh->btv->c.nr, v4l2_type_names[fh->type],
3159 vma->vm_start, vma->vm_end - vma->vm_start);
3160 return videobuf_mmap_mapper(bttv_queue(fh),vma);
3163 static struct file_operations bttv_fops =
3165 .owner = THIS_MODULE,
3167 .release = bttv_release,
3168 .ioctl = bttv_ioctl,
3169 .compat_ioctl = v4l_compat_ioctl32,
3170 .llseek = no_llseek,
3176 static struct video_device bttv_video_template =
3179 .type = VID_TYPE_CAPTURE|VID_TYPE_TUNER|
3180 VID_TYPE_CLIPPING|VID_TYPE_SCALES,
3181 .hardware = VID_HARDWARE_BT848,
3186 static struct video_device bttv_vbi_template =
3188 .name = "bt848/878 vbi",
3189 .type = VID_TYPE_TUNER|VID_TYPE_TELETEXT,
3190 .hardware = VID_HARDWARE_BT848,
3195 /* ----------------------------------------------------------------------- */
3196 /* radio interface */
3198 static int radio_open(struct inode *inode, struct file *file)
3200 int minor = iminor(inode);
3201 struct bttv *btv = NULL;
3204 dprintk("bttv: open minor=%d\n",minor);
3206 for (i = 0; i < bttv_num; i++) {
3207 if (bttvs[i].radio_dev->minor == minor) {
3215 dprintk("bttv%d: open called (radio)\n",btv->c.nr);
3216 mutex_lock(&btv->lock);
3220 file->private_data = btv;
3222 bttv_call_i2c_clients(btv,AUDC_SET_RADIO,NULL);
3223 audio_input(btv,TVAUDIO_INPUT_RADIO);
3225 mutex_unlock(&btv->lock);
3229 static int radio_release(struct inode *inode, struct file *file)
3231 struct bttv *btv = file->private_data;
3232 struct rds_command cmd;
3236 bttv_call_i2c_clients(btv, RDS_CMD_CLOSE, &cmd);
3241 static int radio_do_ioctl(struct inode *inode, struct file *file,
3242 unsigned int cmd, void *arg)
3244 struct bttv *btv = file->private_data;
3249 struct video_capability *cap = arg;
3251 memset(cap,0,sizeof(*cap));
3252 strcpy(cap->name,btv->radio_dev->name);
3253 cap->type = VID_TYPE_TUNER;
3261 struct video_tuner *v = arg;
3265 memset(v,0,sizeof(*v));
3266 strcpy(v->name, "Radio");
3267 bttv_call_i2c_clients(btv,cmd,v);
3279 case VIDIOC_LOG_STATUS:
3280 return bttv_common_ioctls(btv,cmd,arg);
3283 return -ENOIOCTLCMD;
3288 static int radio_ioctl(struct inode *inode, struct file *file,
3289 unsigned int cmd, unsigned long arg)
3291 return video_usercopy(inode, file, cmd, arg, radio_do_ioctl);
3294 static ssize_t radio_read(struct file *file, char __user *data,
3295 size_t count, loff_t *ppos)
3297 struct bttv *btv = file->private_data;
3298 struct rds_command cmd;
3299 cmd.block_count = count/3;
3301 cmd.instance = file;
3302 cmd.result = -ENODEV;
3304 bttv_call_i2c_clients(btv, RDS_CMD_READ, &cmd);
3309 static unsigned int radio_poll(struct file *file, poll_table *wait)
3311 struct bttv *btv = file->private_data;
3312 struct rds_command cmd;
3313 cmd.instance = file;
3314 cmd.event_list = wait;
3315 cmd.result = -ENODEV;
3316 bttv_call_i2c_clients(btv, RDS_CMD_POLL, &cmd);
3321 static struct file_operations radio_fops =
3323 .owner = THIS_MODULE,
3326 .release = radio_release,
3327 .ioctl = radio_ioctl,
3328 .llseek = no_llseek,
3332 static struct video_device radio_template =
3334 .name = "bt848/878 radio",
3335 .type = VID_TYPE_TUNER,
3336 .hardware = VID_HARDWARE_BT848,
3337 .fops = &radio_fops,
3341 /* ----------------------------------------------------------------------- */
3342 /* some debug code */
3344 static int bttv_risc_decode(u32 risc)
3346 static char *instr[16] = {
3347 [ BT848_RISC_WRITE >> 28 ] = "write",
3348 [ BT848_RISC_SKIP >> 28 ] = "skip",
3349 [ BT848_RISC_WRITEC >> 28 ] = "writec",
3350 [ BT848_RISC_JUMP >> 28 ] = "jump",
3351 [ BT848_RISC_SYNC >> 28 ] = "sync",
3352 [ BT848_RISC_WRITE123 >> 28 ] = "write123",
3353 [ BT848_RISC_SKIP123 >> 28 ] = "skip123",
3354 [ BT848_RISC_WRITE1S23 >> 28 ] = "write1s23",
3356 static int incr[16] = {
3357 [ BT848_RISC_WRITE >> 28 ] = 2,
3358 [ BT848_RISC_JUMP >> 28 ] = 2,
3359 [ BT848_RISC_SYNC >> 28 ] = 2,
3360 [ BT848_RISC_WRITE123 >> 28 ] = 5,
3361 [ BT848_RISC_SKIP123 >> 28 ] = 2,
3362 [ BT848_RISC_WRITE1S23 >> 28 ] = 3,
3364 static char *bits[] = {
3365 "be0", "be1", "be2", "be3/resync",
3366 "set0", "set1", "set2", "set3",
3367 "clr0", "clr1", "clr2", "clr3",
3368 "irq", "res", "eol", "sol",
3372 printk("0x%08x [ %s", risc,
3373 instr[risc >> 28] ? instr[risc >> 28] : "INVALID");
3374 for (i = ARRAY_SIZE(bits)-1; i >= 0; i--)
3375 if (risc & (1 << (i + 12)))
3376 printk(" %s",bits[i]);
3377 printk(" count=%d ]\n", risc & 0xfff);
3378 return incr[risc >> 28] ? incr[risc >> 28] : 1;
3381 static void bttv_risc_disasm(struct bttv *btv,
3382 struct btcx_riscmem *risc)
3386 printk("%s: risc disasm: %p [dma=0x%08lx]\n",
3387 btv->c.name, risc->cpu, (unsigned long)risc->dma);
3388 for (i = 0; i < (risc->size >> 2); i += n) {
3389 printk("%s: 0x%lx: ", btv->c.name,
3390 (unsigned long)(risc->dma + (i<<2)));
3391 n = bttv_risc_decode(risc->cpu[i]);
3392 for (j = 1; j < n; j++)
3393 printk("%s: 0x%lx: 0x%08x [ arg #%d ]\n",
3394 btv->c.name, (unsigned long)(risc->dma + ((i+j)<<2)),
3396 if (0 == risc->cpu[i])
3401 static void bttv_print_riscaddr(struct bttv *btv)
3403 printk(" main: %08Lx\n",
3404 (unsigned long long)btv->main.dma);
3405 printk(" vbi : o=%08Lx e=%08Lx\n",
3406 btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0,
3407 btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0);
3408 printk(" cap : o=%08Lx e=%08Lx\n",
3409 btv->curr.top ? (unsigned long long)btv->curr.top->top.dma : 0,
3410 btv->curr.bottom ? (unsigned long long)btv->curr.bottom->bottom.dma : 0);
3411 printk(" scr : o=%08Lx e=%08Lx\n",
3412 btv->screen ? (unsigned long long)btv->screen->top.dma : 0,
3413 btv->screen ? (unsigned long long)btv->screen->bottom.dma : 0);
3414 bttv_risc_disasm(btv, &btv->main);
3417 /* ----------------------------------------------------------------------- */
3420 static char *irq_name[] = {
3421 "FMTCHG", // format change detected (525 vs. 625)
3422 "VSYNC", // vertical sync (new field)
3423 "HSYNC", // horizontal sync
3424 "OFLOW", // chroma/luma AGC overflow
3425 "HLOCK", // horizontal lock changed
3426 "VPRES", // video presence changed
3428 "I2CDONE", // hw irc operation finished
3429 "GPINT", // gpio port triggered irq
3431 "RISCI", // risc instruction triggered irq
3432 "FBUS", // pixel data fifo dropped data (high pci bus latencies)
3433 "FTRGT", // pixel data fifo overrun
3434 "FDSR", // fifo data stream resyncronisation
3435 "PPERR", // parity error (data transfer)
3436 "RIPERR", // parity error (read risc instructions)
3437 "PABORT", // pci abort
3438 "OCERR", // risc instruction error
3439 "SCERR", // syncronisation error
3442 static void bttv_print_irqbits(u32 print, u32 mark)
3447 for (i = 0; i < ARRAY_SIZE(irq_name); i++) {
3448 if (print & (1 << i))
3449 printk(" %s",irq_name[i]);
3450 if (mark & (1 << i))
3455 static void bttv_irq_debug_low_latency(struct bttv *btv, u32 rc)
3457 printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
3459 (unsigned long)btv->main.dma,
3460 (unsigned long)btv->main.cpu[RISC_SLOT_O_VBI+1],
3461 (unsigned long)btv->main.cpu[RISC_SLOT_O_FIELD+1],
3464 if (0 == (btread(BT848_DSTATUS) & BT848_DSTATUS_HLOC)) {
3465 printk("bttv%d: Oh, there (temporarely?) is no input signal. "
3466 "Ok, then this is harmless, don't worry ;)\n",
3470 printk("bttv%d: Uhm. Looks like we have unusual high IRQ latencies.\n",
3472 printk("bttv%d: Lets try to catch the culpit red-handed ...\n",
3478 bttv_irq_next_video(struct bttv *btv, struct bttv_buffer_set *set)
3480 struct bttv_buffer *item;
3482 memset(set,0,sizeof(*set));
3484 /* capture request ? */
3485 if (!list_empty(&btv->capture)) {
3487 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3488 if (V4L2_FIELD_HAS_TOP(item->vb.field))
3490 if (V4L2_FIELD_HAS_BOTTOM(item->vb.field))
3493 /* capture request for other field ? */
3494 if (!V4L2_FIELD_HAS_BOTH(item->vb.field) &&
3495 (item->vb.queue.next != &btv->capture)) {
3496 item = list_entry(item->vb.queue.next, struct bttv_buffer, vb.queue);
3497 if (!V4L2_FIELD_HAS_BOTH(item->vb.field)) {
3498 if (NULL == set->top &&
3499 V4L2_FIELD_TOP == item->vb.field) {
3502 if (NULL == set->bottom &&
3503 V4L2_FIELD_BOTTOM == item->vb.field) {
3506 if (NULL != set->top && NULL != set->bottom)
3512 /* screen overlay ? */
3513 if (NULL != btv->screen) {
3514 if (V4L2_FIELD_HAS_BOTH(btv->screen->vb.field)) {
3515 if (NULL == set->top && NULL == set->bottom) {
3516 set->top = btv->screen;
3517 set->bottom = btv->screen;
3520 if (V4L2_FIELD_TOP == btv->screen->vb.field &&
3522 set->top = btv->screen;
3524 if (V4L2_FIELD_BOTTOM == btv->screen->vb.field &&
3525 NULL == set->bottom) {
3526 set->bottom = btv->screen;
3531 dprintk("bttv%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
3532 btv->c.nr,set->top, set->bottom,
3533 btv->screen,set->frame_irq,set->top_irq);
3538 bttv_irq_wakeup_video(struct bttv *btv, struct bttv_buffer_set *wakeup,
3539 struct bttv_buffer_set *curr, unsigned int state)
3543 do_gettimeofday(&ts);
3545 if (wakeup->top == wakeup->bottom) {
3546 if (NULL != wakeup->top && curr->top != wakeup->top) {
3548 printk("bttv%d: wakeup: both=%p\n",btv->c.nr,wakeup->top);
3549 wakeup->top->vb.ts = ts;
3550 wakeup->top->vb.field_count = btv->field_count;
3551 wakeup->top->vb.state = state;
3552 wake_up(&wakeup->top->vb.done);
3555 if (NULL != wakeup->top && curr->top != wakeup->top) {
3557 printk("bttv%d: wakeup: top=%p\n",btv->c.nr,wakeup->top);
3558 wakeup->top->vb.ts = ts;
3559 wakeup->top->vb.field_count = btv->field_count;
3560 wakeup->top->vb.state = state;
3561 wake_up(&wakeup->top->vb.done);
3563 if (NULL != wakeup->bottom && curr->bottom != wakeup->bottom) {
3565 printk("bttv%d: wakeup: bottom=%p\n",btv->c.nr,wakeup->bottom);
3566 wakeup->bottom->vb.ts = ts;
3567 wakeup->bottom->vb.field_count = btv->field_count;
3568 wakeup->bottom->vb.state = state;
3569 wake_up(&wakeup->bottom->vb.done);
3575 bttv_irq_wakeup_vbi(struct bttv *btv, struct bttv_buffer *wakeup,
3583 do_gettimeofday(&ts);
3585 wakeup->vb.field_count = btv->field_count;
3586 wakeup->vb.state = state;
3587 wake_up(&wakeup->vb.done);
3590 static void bttv_irq_timeout(unsigned long data)
3592 struct bttv *btv = (struct bttv *)data;
3593 struct bttv_buffer_set old,new;
3594 struct bttv_buffer *ovbi;
3595 struct bttv_buffer *item;
3596 unsigned long flags;
3599 printk(KERN_INFO "bttv%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
3600 btv->c.nr, btv->framedrop, btv->irq_me, btv->irq_total,
3601 btread(BT848_RISC_COUNT));
3602 bttv_print_irqbits(btread(BT848_INT_STAT),0);
3606 spin_lock_irqsave(&btv->s_lock,flags);
3608 /* deactivate stuff */
3609 memset(&new,0,sizeof(new));
3615 bttv_buffer_activate_video(btv, &new);
3616 bttv_buffer_activate_vbi(btv, NULL);
3617 bttv_set_dma(btv, 0);
3620 bttv_irq_wakeup_video(btv, &old, &new, STATE_ERROR);
3621 bttv_irq_wakeup_vbi(btv, ovbi, STATE_ERROR);
3623 /* cancel all outstanding capture / vbi requests */
3624 while (!list_empty(&btv->capture)) {
3625 item = list_entry(btv->capture.next, struct bttv_buffer, vb.queue);
3626 list_del(&item->vb.queue);
3627 item->vb.state = STATE_ERROR;
3628 wake_up(&item->vb.done);
3630 while (!list_empty(&btv->vcapture)) {
3631 item = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3632 list_del(&item->vb.queue);
3633 item->vb.state = STATE_ERROR;
3634 wake_up(&item->vb.done);
3638 spin_unlock_irqrestore(&btv->s_lock,flags);
3642 bttv_irq_wakeup_top(struct bttv *btv)
3644 struct bttv_buffer *wakeup = btv->curr.top;
3649 spin_lock(&btv->s_lock);
3650 btv->curr.top_irq = 0;
3651 btv->curr.top = NULL;
3652 bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0);
3654 do_gettimeofday(&wakeup->vb.ts);
3655 wakeup->vb.field_count = btv->field_count;
3656 wakeup->vb.state = STATE_DONE;
3657 wake_up(&wakeup->vb.done);
3658 spin_unlock(&btv->s_lock);
3661 static inline int is_active(struct btcx_riscmem *risc, u32 rc)
3665 if (rc > risc->dma + risc->size)
3671 bttv_irq_switch_video(struct bttv *btv)
3673 struct bttv_buffer_set new;
3674 struct bttv_buffer_set old;
3677 spin_lock(&btv->s_lock);
3679 /* new buffer set */
3680 bttv_irq_next_video(btv, &new);
3681 rc = btread(BT848_RISC_COUNT);
3682 if ((btv->curr.top && is_active(&btv->curr.top->top, rc)) ||
3683 (btv->curr.bottom && is_active(&btv->curr.bottom->bottom, rc))) {
3686 bttv_irq_debug_low_latency(btv, rc);
3687 spin_unlock(&btv->s_lock);
3694 btv->loop_irq &= ~1;
3695 bttv_buffer_activate_video(btv, &new);
3696 bttv_set_dma(btv, 0);
3699 if (UNSET != btv->new_input) {
3700 video_mux(btv,btv->new_input);
3701 btv->new_input = UNSET;
3704 /* wake up finished buffers */
3705 bttv_irq_wakeup_video(btv, &old, &new, STATE_DONE);
3706 spin_unlock(&btv->s_lock);
3710 bttv_irq_switch_vbi(struct bttv *btv)
3712 struct bttv_buffer *new = NULL;
3713 struct bttv_buffer *old;
3716 spin_lock(&btv->s_lock);
3718 if (!list_empty(&btv->vcapture))
3719 new = list_entry(btv->vcapture.next, struct bttv_buffer, vb.queue);
3722 rc = btread(BT848_RISC_COUNT);
3723 if (NULL != old && (is_active(&old->top, rc) ||
3724 is_active(&old->bottom, rc))) {
3727 bttv_irq_debug_low_latency(btv, rc);
3728 spin_unlock(&btv->s_lock);
3734 btv->loop_irq &= ~4;
3735 bttv_buffer_activate_vbi(btv, new);
3736 bttv_set_dma(btv, 0);
3738 bttv_irq_wakeup_vbi(btv, old, STATE_DONE);
3739 spin_unlock(&btv->s_lock);
3742 static irqreturn_t bttv_irq(int irq, void *dev_id, struct pt_regs * regs)
3750 btv=(struct bttv *)dev_id;
3752 if (btv->custom_irq)
3753 handled = btv->custom_irq(btv);
3757 /* get/clear interrupt status bits */
3758 stat=btread(BT848_INT_STAT);
3759 astat=stat&btread(BT848_INT_MASK);
3763 btwrite(stat,BT848_INT_STAT);
3765 /* get device status bits */
3766 dstat=btread(BT848_DSTATUS);
3769 printk(KERN_DEBUG "bttv%d: irq loop=%d fc=%d "
3770 "riscs=%x, riscc=%08x, ",
3771 btv->c.nr, count, btv->field_count,
3772 stat>>28, btread(BT848_RISC_COUNT));
3773 bttv_print_irqbits(stat,astat);
3774 if (stat & BT848_INT_HLOCK)
3775 printk(" HLOC => %s", (dstat & BT848_DSTATUS_HLOC)
3777 if (stat & BT848_INT_VPRES)
3778 printk(" PRES => %s", (dstat & BT848_DSTATUS_PRES)
3780 if (stat & BT848_INT_FMTCHG)
3781 printk(" NUML => %s", (dstat & BT848_DSTATUS_NUML)
3786 if (astat&BT848_INT_VSYNC)
3789 if ((astat & BT848_INT_GPINT) && btv->remote) {
3790 wake_up(&btv->gpioq);
3791 bttv_input_irq(btv);
3794 if (astat & BT848_INT_I2CDONE) {
3795 btv->i2c_done = stat;
3796 wake_up(&btv->i2c_queue);
3799 if ((astat & BT848_INT_RISCI) && (stat & (4<<28)))
3800 bttv_irq_switch_vbi(btv);
3802 if ((astat & BT848_INT_RISCI) && (stat & (2<<28)))
3803 bttv_irq_wakeup_top(btv);
3805 if ((astat & BT848_INT_RISCI) && (stat & (1<<28)))
3806 bttv_irq_switch_video(btv);
3808 if ((astat & BT848_INT_HLOCK) && btv->opt_automute)
3809 audio_mute(btv, btv->mute); /* trigger automute */
3811 if (astat & (BT848_INT_SCERR|BT848_INT_OCERR)) {
3812 printk(KERN_INFO "bttv%d: %s%s @ %08x,",btv->c.nr,
3813 (astat & BT848_INT_SCERR) ? "SCERR" : "",
3814 (astat & BT848_INT_OCERR) ? "OCERR" : "",
3815 btread(BT848_RISC_COUNT));
3816 bttv_print_irqbits(stat,astat);
3819 bttv_print_riscaddr(btv);
3821 if (fdsr && astat & BT848_INT_FDSR) {
3822 printk(KERN_INFO "bttv%d: FDSR @ %08x\n",
3823 btv->c.nr,btread(BT848_RISC_COUNT));
3825 bttv_print_riscaddr(btv);
3831 if (count > 8 || !(astat & BT848_INT_GPINT)) {
3832 btwrite(0, BT848_INT_MASK);
3835 "bttv%d: IRQ lockup, cleared int mask [", btv->c.nr);
3838 "bttv%d: IRQ lockup, clearing GPINT from int mask [", btv->c.nr);
3840 btwrite(btread(BT848_INT_MASK) & (-1 ^ BT848_INT_GPINT),
3844 bttv_print_irqbits(stat,astat);
3852 return IRQ_RETVAL(handled);
3856 /* ----------------------------------------------------------------------- */
3857 /* initialitation */
3859 static struct video_device *vdev_init(struct bttv *btv,
3860 struct video_device *template,
3863 struct video_device *vfd;
3865 vfd = video_device_alloc();
3870 vfd->dev = &btv->c.pci->dev;
3871 vfd->release = video_device_release;
3872 snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)",
3873 btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
3874 type, bttv_tvcards[btv->c.type].name);
3878 static void bttv_unregister_video(struct bttv *btv)
3880 if (btv->video_dev) {
3881 if (-1 != btv->video_dev->minor)
3882 video_unregister_device(btv->video_dev);
3884 video_device_release(btv->video_dev);
3885 btv->video_dev = NULL;
3888 if (-1 != btv->vbi_dev->minor)
3889 video_unregister_device(btv->vbi_dev);
3891 video_device_release(btv->vbi_dev);
3892 btv->vbi_dev = NULL;
3894 if (btv->radio_dev) {
3895 if (-1 != btv->radio_dev->minor)
3896 video_unregister_device(btv->radio_dev);
3898 video_device_release(btv->radio_dev);
3899 btv->radio_dev = NULL;
3903 /* register video4linux devices */
3904 static int __devinit bttv_register_video(struct bttv *btv)
3906 if (no_overlay <= 0) {
3907 bttv_video_template.type |= VID_TYPE_OVERLAY;
3909 printk("bttv: Overlay support disabled.\n");
3913 btv->video_dev = vdev_init(btv, &bttv_video_template, "video");
3914 if (NULL == btv->video_dev)
3916 if (video_register_device(btv->video_dev,VFL_TYPE_GRABBER,video_nr)<0)
3918 printk(KERN_INFO "bttv%d: registered device video%d\n",
3919 btv->c.nr,btv->video_dev->minor & 0x1f);
3920 video_device_create_file(btv->video_dev, &class_device_attr_card);
3923 btv->vbi_dev = vdev_init(btv, &bttv_vbi_template, "vbi");
3924 if (NULL == btv->vbi_dev)
3926 if (video_register_device(btv->vbi_dev,VFL_TYPE_VBI,vbi_nr)<0)
3928 printk(KERN_INFO "bttv%d: registered device vbi%d\n",
3929 btv->c.nr,btv->vbi_dev->minor & 0x1f);
3931 if (!btv->has_radio)
3934 btv->radio_dev = vdev_init(btv, &radio_template, "radio");
3935 if (NULL == btv->radio_dev)
3937 if (video_register_device(btv->radio_dev, VFL_TYPE_RADIO,radio_nr)<0)
3939 printk(KERN_INFO "bttv%d: registered device radio%d\n",
3940 btv->c.nr,btv->radio_dev->minor & 0x1f);
3946 bttv_unregister_video(btv);
3951 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
3952 /* response on cards with no firmware is not enabled by OF */
3953 static void pci_set_command(struct pci_dev *dev)
3955 #if defined(__powerpc__)
3958 pci_read_config_dword(dev, PCI_COMMAND, &cmd);
3959 cmd = (cmd | PCI_COMMAND_MEMORY );
3960 pci_write_config_dword(dev, PCI_COMMAND, cmd);
3964 static int __devinit bttv_probe(struct pci_dev *dev,
3965 const struct pci_device_id *pci_id)
3971 if (bttv_num == BTTV_MAX)
3973 printk(KERN_INFO "bttv: Bt8xx card found (%d).\n", bttv_num);
3974 btv=&bttvs[bttv_num];
3975 memset(btv,0,sizeof(*btv));
3976 btv->c.nr = bttv_num;
3977 sprintf(btv->c.name,"bttv%d",btv->c.nr);
3979 /* initialize structs / fill in defaults */
3980 mutex_init(&btv->lock);
3981 mutex_init(&btv->reslock);
3982 spin_lock_init(&btv->s_lock);
3983 spin_lock_init(&btv->gpio_lock);
3984 init_waitqueue_head(&btv->gpioq);
3985 init_waitqueue_head(&btv->i2c_queue);
3986 INIT_LIST_HEAD(&btv->c.subs);
3987 INIT_LIST_HEAD(&btv->capture);
3988 INIT_LIST_HEAD(&btv->vcapture);
3989 v4l2_prio_init(&btv->prio);
3991 init_timer(&btv->timeout);
3992 btv->timeout.function = bttv_irq_timeout;
3993 btv->timeout.data = (unsigned long)btv;
3996 btv->tuner_type = UNSET;
3997 btv->new_input = UNSET;
3998 btv->has_radio=radio[btv->c.nr];
4000 /* pci stuff (init, get irq/mmio, ... */
4002 btv->id = dev->device;
4003 if (pci_enable_device(dev)) {
4004 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4008 if (pci_set_dma_mask(dev, DMA_32BIT_MASK)) {
4009 printk(KERN_WARNING "bttv%d: No suitable DMA available.\n",
4013 if (!request_mem_region(pci_resource_start(dev,0),
4014 pci_resource_len(dev,0),
4016 printk(KERN_WARNING "bttv%d: can't request iomem (0x%lx).\n",
4017 btv->c.nr, pci_resource_start(dev,0));
4020 pci_set_master(dev);
4021 pci_set_command(dev);
4022 pci_set_drvdata(dev,btv);
4024 pci_read_config_byte(dev, PCI_CLASS_REVISION, &btv->revision);
4025 pci_read_config_byte(dev, PCI_LATENCY_TIMER, &lat);
4026 printk(KERN_INFO "bttv%d: Bt%d (rev %d) at %s, ",
4027 bttv_num,btv->id, btv->revision, pci_name(dev));
4028 printk("irq: %d, latency: %d, mmio: 0x%lx\n",
4029 btv->c.pci->irq, lat, pci_resource_start(dev,0));
4032 btv->bt848_mmio=ioremap(pci_resource_start(dev,0), 0x1000);
4033 if (NULL == ioremap(pci_resource_start(dev,0), 0x1000)) {
4034 printk("bttv%d: ioremap() failed\n", btv->c.nr);
4042 /* disable irqs, register irq handler */
4043 btwrite(0, BT848_INT_MASK);
4044 result = request_irq(btv->c.pci->irq, bttv_irq,
4045 SA_SHIRQ | SA_INTERRUPT,btv->c.name,(void *)btv);
4047 printk(KERN_ERR "bttv%d: can't get IRQ %d\n",
4048 bttv_num,btv->c.pci->irq);
4052 if (0 != bttv_handle_chipset(btv)) {
4057 /* init options from insmod args */
4058 btv->opt_combfilter = combfilter;
4059 btv->opt_lumafilter = lumafilter;
4060 btv->opt_automute = automute;
4061 btv->opt_chroma_agc = chroma_agc;
4062 btv->opt_adc_crush = adc_crush;
4063 btv->opt_vcr_hack = vcr_hack;
4064 btv->opt_whitecrush_upper = whitecrush_upper;
4065 btv->opt_whitecrush_lower = whitecrush_lower;
4066 btv->opt_uv_ratio = uv_ratio;
4067 btv->opt_full_luma_range = full_luma_range;
4068 btv->opt_coring = coring;
4070 /* fill struct bttv with some useful defaults */
4071 btv->init.btv = btv;
4072 btv->init.ov.w.width = 320;
4073 btv->init.ov.w.height = 240;
4074 btv->init.fmt = format_by_palette(VIDEO_PALETTE_RGB24);
4075 btv->init.width = 320;
4076 btv->init.height = 240;
4077 btv->init.lines = 16;
4080 /* initialize hardware */
4082 bttv_gpio_tracking(btv,"pre-init");
4084 bttv_risc_init_main(btv);
4088 btwrite(0x00, BT848_GPIO_REG_INP);
4089 btwrite(0x00, BT848_GPIO_OUT_EN);
4091 bttv_gpio_tracking(btv,"init");
4093 /* needs to be done before i2c is registered */
4094 bttv_init_card1(btv);
4096 /* register i2c + gpio */
4099 /* some card-specific stuff (needs working i2c) */
4100 bttv_init_card2(btv);
4103 /* register video4linux + input */
4104 if (!bttv_tvcards[btv->c.type].no_video) {
4105 bttv_register_video(btv);
4106 bt848_bright(btv,32768);
4107 bt848_contrast(btv,32768);
4108 bt848_hue(btv,32768);
4109 bt848_sat(btv,32768);
4114 /* add subdevices */
4115 if (bttv_tvcards[btv->c.type].has_dvb)
4116 bttv_sub_add_device(&btv->c, "dvb");
4118 bttv_input_init(btv);
4120 /* everything is fine */
4125 free_irq(btv->c.pci->irq,btv);
4128 if (btv->bt848_mmio)
4129 iounmap(btv->bt848_mmio);
4130 release_mem_region(pci_resource_start(btv->c.pci,0),
4131 pci_resource_len(btv->c.pci,0));
4132 pci_set_drvdata(dev,NULL);
4136 static void __devexit bttv_remove(struct pci_dev *pci_dev)
4138 struct bttv *btv = pci_get_drvdata(pci_dev);
4141 printk("bttv%d: unloading\n",btv->c.nr);
4143 /* shutdown everything (DMA+IRQs) */
4144 btand(~15, BT848_GPIO_DMA_CTL);
4145 btwrite(0, BT848_INT_MASK);
4146 btwrite(~0x0, BT848_INT_STAT);
4147 btwrite(0x0, BT848_GPIO_OUT_EN);
4149 bttv_gpio_tracking(btv,"cleanup");
4151 /* tell gpio modules we are leaving ... */
4153 wake_up(&btv->gpioq);
4154 bttv_input_fini(btv);
4155 bttv_sub_del_devices(&btv->c);
4157 /* unregister i2c_bus + input */
4160 /* unregister video4linux */
4161 bttv_unregister_video(btv);
4163 /* free allocated memory */
4164 btcx_riscmem_free(btv->c.pci,&btv->main);
4166 /* free ressources */
4167 free_irq(btv->c.pci->irq,btv);
4168 iounmap(btv->bt848_mmio);
4169 release_mem_region(pci_resource_start(btv->c.pci,0),
4170 pci_resource_len(btv->c.pci,0));
4172 pci_set_drvdata(pci_dev, NULL);
4176 static int bttv_suspend(struct pci_dev *pci_dev, pm_message_t state)
4178 struct bttv *btv = pci_get_drvdata(pci_dev);
4179 struct bttv_buffer_set idle;
4180 unsigned long flags;
4182 dprintk("bttv%d: suspend %d\n", btv->c.nr, state.event);
4184 /* stop dma + irqs */
4185 spin_lock_irqsave(&btv->s_lock,flags);
4186 memset(&idle, 0, sizeof(idle));
4187 btv->state.video = btv->curr;
4188 btv->state.vbi = btv->cvbi;
4189 btv->state.loop_irq = btv->loop_irq;
4192 bttv_buffer_activate_video(btv, &idle);
4193 bttv_buffer_activate_vbi(btv, NULL);
4194 bttv_set_dma(btv, 0);
4195 btwrite(0, BT848_INT_MASK);
4196 spin_unlock_irqrestore(&btv->s_lock,flags);
4198 /* save bt878 state */
4199 btv->state.gpio_enable = btread(BT848_GPIO_OUT_EN);
4200 btv->state.gpio_data = gpio_read();
4202 /* save pci state */
4203 pci_save_state(pci_dev);
4204 if (0 != pci_set_power_state(pci_dev, pci_choose_state(pci_dev, state))) {
4205 pci_disable_device(pci_dev);
4206 btv->state.disabled = 1;
4211 static int bttv_resume(struct pci_dev *pci_dev)
4213 struct bttv *btv = pci_get_drvdata(pci_dev);
4214 unsigned long flags;
4217 dprintk("bttv%d: resume\n", btv->c.nr);
4219 /* restore pci state */
4220 if (btv->state.disabled) {
4221 err=pci_enable_device(pci_dev);
4223 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4227 btv->state.disabled = 0;
4229 err=pci_set_power_state(pci_dev, PCI_D0);
4231 pci_disable_device(pci_dev);
4232 printk(KERN_WARNING "bttv%d: Can't enable device.\n",
4234 btv->state.disabled = 1;
4238 pci_restore_state(pci_dev);
4240 /* restore bt878 state */
4241 bttv_reinit_bt848(btv);
4242 gpio_inout(0xffffff, btv->state.gpio_enable);
4243 gpio_write(btv->state.gpio_data);
4246 spin_lock_irqsave(&btv->s_lock,flags);
4247 btv->curr = btv->state.video;
4248 btv->cvbi = btv->state.vbi;
4249 btv->loop_irq = btv->state.loop_irq;
4250 bttv_buffer_activate_video(btv, &btv->curr);
4251 bttv_buffer_activate_vbi(btv, btv->cvbi);
4252 bttv_set_dma(btv, 0);
4253 spin_unlock_irqrestore(&btv->s_lock,flags);
4257 static struct pci_device_id bttv_pci_tbl[] = {
4258 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT848,
4259 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4260 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT849,
4261 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4262 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT878,
4263 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4264 {PCI_VENDOR_ID_BROOKTREE, PCI_DEVICE_ID_BT879,
4265 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
4269 MODULE_DEVICE_TABLE(pci, bttv_pci_tbl);
4271 static struct pci_driver bttv_pci_driver = {
4273 .id_table = bttv_pci_tbl,
4274 .probe = bttv_probe,
4275 .remove = __devexit_p(bttv_remove),
4276 .suspend = bttv_suspend,
4277 .resume = bttv_resume,
4280 static int bttv_init_module(void)
4284 printk(KERN_INFO "bttv: driver version %d.%d.%d loaded\n",
4285 (BTTV_VERSION_CODE >> 16) & 0xff,
4286 (BTTV_VERSION_CODE >> 8) & 0xff,
4287 BTTV_VERSION_CODE & 0xff);
4289 printk(KERN_INFO "bttv: snapshot date %04d-%02d-%02d\n",
4290 SNAPSHOT/10000, (SNAPSHOT/100)%100, SNAPSHOT%100);
4292 if (gbuffers < 2 || gbuffers > VIDEO_MAX_FRAME)
4294 if (gbufsize < 0 || gbufsize > BTTV_MAX_FBUF)
4295 gbufsize = BTTV_MAX_FBUF;
4296 gbufsize = (gbufsize + PAGE_SIZE - 1) & PAGE_MASK;
4298 printk(KERN_INFO "bttv: using %d buffers with %dk (%d pages) each for capture\n",
4299 gbuffers, gbufsize >> 10, gbufsize >> PAGE_SHIFT);
4301 bttv_check_chipset();
4303 bus_register(&bttv_sub_bus_type);
4304 return pci_register_driver(&bttv_pci_driver);
4307 static void bttv_cleanup_module(void)
4309 pci_unregister_driver(&bttv_pci_driver);
4310 bus_unregister(&bttv_sub_bus_type);
4314 module_init(bttv_init_module);
4315 module_exit(bttv_cleanup_module);