3 bttv - Bt848 frame grabber driver
5 Copyright (C) 1996,97,98 Ralph Metzler <rjkm@thp.uni-koeln.de>
6 & Marcus Metzler <mocm@thp.uni-koeln.de>
7 (c) 1999-2002 Gerd Knorr <kraxel@bytesex.org>
9 some v4l2 code lines are taken from Justin's bttv2 driver which is
10 (c) 2000 Justin Schoeman <justin@suntiger.ee.up.ac.za>
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 #include <linux/init.h>
28 #include <linux/module.h>
29 #include <linux/moduleparam.h>
30 #include <linux/delay.h>
31 #include <linux/errno.h>
33 #include <linux/kernel.h>
34 #include <linux/sched.h>
35 #include <linux/interrupt.h>
36 #include <linux/kdev_t.h>
37 #include <linux/dma-mapping.h>
40 #include <asm/byteorder.h>
47 unsigned int bttv_num
; /* number of Bt848s in use */
48 struct bttv bttvs
[BTTV_MAX
];
50 unsigned int bttv_debug
= 0;
51 unsigned int bttv_verbose
= 1;
52 unsigned int bttv_gpio
= 0;
54 /* config variables */
56 static unsigned int bigendian
=1;
58 static unsigned int bigendian
=0;
60 static unsigned int radio
[BTTV_MAX
];
61 static unsigned int irq_debug
= 0;
62 static unsigned int gbuffers
= 8;
63 static unsigned int gbufsize
= 0x208000;
65 static int video_nr
= -1;
66 static int radio_nr
= -1;
67 static int vbi_nr
= -1;
68 static int debug_latency
= 0;
70 static unsigned int fdsr
= 0;
73 static unsigned int combfilter
= 0;
74 static unsigned int lumafilter
= 0;
75 static unsigned int automute
= 1;
76 static unsigned int chroma_agc
= 0;
77 static unsigned int adc_crush
= 1;
78 static unsigned int whitecrush_upper
= 0xCF;
79 static unsigned int whitecrush_lower
= 0x7F;
80 static unsigned int vcr_hack
= 0;
81 static unsigned int irq_iswitch
= 0;
82 static unsigned int uv_ratio
= 50;
83 static unsigned int full_luma_range
= 0;
84 static unsigned int coring
= 0;
85 extern int no_overlay
;
87 /* API features (turn on/off stuff for testing) */
88 static unsigned int v4l2
= 1;
92 module_param(bttv_verbose
, int, 0644);
93 module_param(bttv_gpio
, int, 0644);
94 module_param(bttv_debug
, int, 0644);
95 module_param(irq_debug
, int, 0644);
96 module_param(debug_latency
, int, 0644);
98 module_param(fdsr
, int, 0444);
99 module_param(video_nr
, int, 0444);
100 module_param(radio_nr
, int, 0444);
101 module_param(vbi_nr
, int, 0444);
102 module_param(gbuffers
, int, 0444);
103 module_param(gbufsize
, int, 0444);
105 module_param(v4l2
, int, 0644);
106 module_param(bigendian
, int, 0644);
107 module_param(irq_iswitch
, int, 0644);
108 module_param(combfilter
, int, 0444);
109 module_param(lumafilter
, int, 0444);
110 module_param(automute
, int, 0444);
111 module_param(chroma_agc
, int, 0444);
112 module_param(adc_crush
, int, 0444);
113 module_param(whitecrush_upper
, int, 0444);
114 module_param(whitecrush_lower
, int, 0444);
115 module_param(vcr_hack
, int, 0444);
116 module_param(uv_ratio
, int, 0444);
117 module_param(full_luma_range
, int, 0444);
118 module_param(coring
, int, 0444);
120 module_param_array(radio
, int, NULL
, 0444);
122 MODULE_PARM_DESC(radio
,"The TV card supports radio, default is 0 (no)");
123 MODULE_PARM_DESC(bigendian
,"byte order of the framebuffer, default is native endian");
124 MODULE_PARM_DESC(bttv_verbose
,"verbose startup messages, default is 1 (yes)");
125 MODULE_PARM_DESC(bttv_gpio
,"log gpio changes, default is 0 (no)");
126 MODULE_PARM_DESC(bttv_debug
,"debug messages, default is 0 (no)");
127 MODULE_PARM_DESC(irq_debug
,"irq handler debug messages, default is 0 (no)");
128 MODULE_PARM_DESC(gbuffers
,"number of capture buffers. range 2-32, default 8");
129 MODULE_PARM_DESC(gbufsize
,"size of the capture buffers, default is 0x208000");
130 MODULE_PARM_DESC(automute
,"mute audio on bad/missing video signal, default is 1 (yes)");
131 MODULE_PARM_DESC(chroma_agc
,"enables the AGC of chroma signal, default is 0 (no)");
132 MODULE_PARM_DESC(adc_crush
,"enables the luminance ADC crush, default is 1 (yes)");
133 MODULE_PARM_DESC(whitecrush_upper
,"sets the white crush upper value, default is 207");
134 MODULE_PARM_DESC(whitecrush_lower
,"sets the white crush lower value, default is 127");
135 MODULE_PARM_DESC(vcr_hack
,"enables the VCR hack (improves synch on poor VCR tapes), default is 0 (no)");
136 MODULE_PARM_DESC(irq_iswitch
,"switch inputs in irq handler");
137 MODULE_PARM_DESC(uv_ratio
,"ratio between u and v gains, default is 50");
138 MODULE_PARM_DESC(full_luma_range
,"use the full luma range, default is 0 (no)");
139 MODULE_PARM_DESC(coring
,"set the luma coring level, default is 0 (no)");
141 MODULE_DESCRIPTION("bttv - v4l/v4l2 driver module for bt848/878 based cards");
142 MODULE_AUTHOR("Ralph Metzler & Marcus Metzler & Gerd Knorr");
143 MODULE_LICENSE("GPL");
145 /* ----------------------------------------------------------------------- */
148 static ssize_t
show_card(struct class_device
*cd
, char *buf
)
150 struct video_device
*vfd
= to_video_device(cd
);
151 struct bttv
*btv
= dev_get_drvdata(vfd
->dev
);
152 return sprintf(buf
, "%d\n", btv
? btv
->c
.type
: UNSET
);
154 static CLASS_DEVICE_ATTR(card
, S_IRUGO
, show_card
, NULL
);
156 /* ----------------------------------------------------------------------- */
159 /* special timing tables from conexant... */
160 static u8 SRAM_Table
[][60] =
162 /* PAL digital input over GPIO[7:0] */
164 45, // 45 bytes following
165 0x36,0x11,0x01,0x00,0x90,0x02,0x05,0x10,0x04,0x16,
166 0x12,0x05,0x11,0x00,0x04,0x12,0xC0,0x00,0x31,0x00,
167 0x06,0x51,0x08,0x03,0x89,0x08,0x07,0xC0,0x44,0x00,
168 0x81,0x01,0x01,0xA9,0x0D,0x02,0x02,0x50,0x03,0x37,
169 0x37,0x00,0xAF,0x21,0x00
171 /* NTSC digital input over GPIO[7:0] */
173 51, // 51 bytes following
174 0x0C,0xC0,0x00,0x00,0x90,0x02,0x03,0x10,0x03,0x06,
175 0x10,0x04,0x12,0x12,0x05,0x02,0x13,0x04,0x19,0x00,
176 0x04,0x39,0x00,0x06,0x59,0x08,0x03,0x83,0x08,0x07,
177 0x03,0x50,0x00,0xC0,0x40,0x00,0x86,0x01,0x01,0xA6,
178 0x0D,0x02,0x03,0x11,0x01,0x05,0x37,0x00,0xAC,0x21,
181 // TGB_NTSC392 // quartzsight
182 // This table has been modified to be used for Fusion Rev D
184 0x2A, // size of table = 42
185 0x06, 0x08, 0x04, 0x0a, 0xc0, 0x00, 0x18, 0x08, 0x03, 0x24,
186 0x08, 0x07, 0x02, 0x90, 0x02, 0x08, 0x10, 0x04, 0x0c, 0x10,
187 0x05, 0x2c, 0x11, 0x04, 0x55, 0x48, 0x00, 0x05, 0x50, 0x00,
188 0xbf, 0x0c, 0x02, 0x2f, 0x3d, 0x00, 0x2f, 0x3f, 0x00, 0xc3,
193 const struct bttv_tvnorm bttv_tvnorms
[] = {
195 /* max. active video is actually 922, but 924 is divisible by 4 and 3! */
196 /* actually, max active PAL with HSCALE=0 is 948, NTSC is 768 - nil */
198 .v4l2_id
= V4L2_STD_PAL
,
206 .iform
= (BT848_IFORM_PAL_BDGHI
|BT848_IFORM_XT1
),
207 .scaledtwidth
= 1135,
214 .v4l2_id
= V4L2_STD_NTSC_M
,
222 .iform
= (BT848_IFORM_NTSC
|BT848_IFORM_XT0
),
230 .v4l2_id
= V4L2_STD_SECAM
,
238 .iform
= (BT848_IFORM_SECAM
|BT848_IFORM_XT1
),
239 .scaledtwidth
= 1135,
244 .sram
= 0, /* like PAL, correct? */
246 .v4l2_id
= V4L2_STD_PAL_Nc
,
254 .iform
= (BT848_IFORM_PAL_NC
|BT848_IFORM_XT0
),
262 .v4l2_id
= V4L2_STD_PAL_M
,
270 .iform
= (BT848_IFORM_PAL_M
|BT848_IFORM_XT0
),
278 .v4l2_id
= V4L2_STD_PAL_N
,
286 .iform
= (BT848_IFORM_PAL_N
|BT848_IFORM_XT1
),
294 .v4l2_id
= V4L2_STD_NTSC_M_JP
,
302 .iform
= (BT848_IFORM_NTSC_J
|BT848_IFORM_XT0
),
310 /* that one hopefully works with the strange timing
311 * which video recorders produce when playing a NTSC
312 * tape on a PAL TV ... */
313 .v4l2_id
= V4L2_STD_PAL_60
,
321 .iform
= (BT848_IFORM_PAL_BDGHI
|BT848_IFORM_XT1
),
322 .scaledtwidth
= 1135,
331 static const unsigned int BTTV_TVNORMS
= ARRAY_SIZE(bttv_tvnorms
);
333 /* ----------------------------------------------------------------------- */
335 packed pixel formats must come first */
336 static const struct bttv_format bttv_formats
[] = {
338 .name
= "8 bpp, gray",
339 .palette
= VIDEO_PALETTE_GREY
,
340 .fourcc
= V4L2_PIX_FMT_GREY
,
341 .btformat
= BT848_COLOR_FMT_Y8
,
343 .flags
= FORMAT_FLAGS_PACKED
,
345 .name
= "8 bpp, dithered color",
346 .palette
= VIDEO_PALETTE_HI240
,
347 .fourcc
= V4L2_PIX_FMT_HI240
,
348 .btformat
= BT848_COLOR_FMT_RGB8
,
350 .flags
= FORMAT_FLAGS_PACKED
| FORMAT_FLAGS_DITHER
,
352 .name
= "15 bpp RGB, le",
353 .palette
= VIDEO_PALETTE_RGB555
,
354 .fourcc
= V4L2_PIX_FMT_RGB555
,
355 .btformat
= BT848_COLOR_FMT_RGB15
,
357 .flags
= FORMAT_FLAGS_PACKED
,
359 .name
= "15 bpp RGB, be",
361 .fourcc
= V4L2_PIX_FMT_RGB555X
,
362 .btformat
= BT848_COLOR_FMT_RGB15
,
363 .btswap
= 0x03, /* byteswap */
365 .flags
= FORMAT_FLAGS_PACKED
,
367 .name
= "16 bpp RGB, le",
368 .palette
= VIDEO_PALETTE_RGB565
,
369 .fourcc
= V4L2_PIX_FMT_RGB565
,
370 .btformat
= BT848_COLOR_FMT_RGB16
,
372 .flags
= FORMAT_FLAGS_PACKED
,
374 .name
= "16 bpp RGB, be",
376 .fourcc
= V4L2_PIX_FMT_RGB565X
,
377 .btformat
= BT848_COLOR_FMT_RGB16
,
378 .btswap
= 0x03, /* byteswap */
380 .flags
= FORMAT_FLAGS_PACKED
,
382 .name
= "24 bpp RGB, le",
383 .palette
= VIDEO_PALETTE_RGB24
,
384 .fourcc
= V4L2_PIX_FMT_BGR24
,
385 .btformat
= BT848_COLOR_FMT_RGB24
,
387 .flags
= FORMAT_FLAGS_PACKED
,
389 .name
= "32 bpp RGB, le",
390 .palette
= VIDEO_PALETTE_RGB32
,
391 .fourcc
= V4L2_PIX_FMT_BGR32
,
392 .btformat
= BT848_COLOR_FMT_RGB32
,
394 .flags
= FORMAT_FLAGS_PACKED
,
396 .name
= "32 bpp RGB, be",
398 .fourcc
= V4L2_PIX_FMT_RGB32
,
399 .btformat
= BT848_COLOR_FMT_RGB32
,
400 .btswap
= 0x0f, /* byte+word swap */
402 .flags
= FORMAT_FLAGS_PACKED
,
404 .name
= "4:2:2, packed, YUYV",
405 .palette
= VIDEO_PALETTE_YUV422
,
406 .fourcc
= V4L2_PIX_FMT_YUYV
,
407 .btformat
= BT848_COLOR_FMT_YUY2
,
409 .flags
= FORMAT_FLAGS_PACKED
,
411 .name
= "4:2:2, packed, YUYV",
412 .palette
= VIDEO_PALETTE_YUYV
,
413 .fourcc
= V4L2_PIX_FMT_YUYV
,
414 .btformat
= BT848_COLOR_FMT_YUY2
,
416 .flags
= FORMAT_FLAGS_PACKED
,
418 .name
= "4:2:2, packed, UYVY",
419 .palette
= VIDEO_PALETTE_UYVY
,
420 .fourcc
= V4L2_PIX_FMT_UYVY
,
421 .btformat
= BT848_COLOR_FMT_YUY2
,
422 .btswap
= 0x03, /* byteswap */
424 .flags
= FORMAT_FLAGS_PACKED
,
426 .name
= "4:2:2, planar, Y-Cb-Cr",
427 .palette
= VIDEO_PALETTE_YUV422P
,
428 .fourcc
= V4L2_PIX_FMT_YUV422P
,
429 .btformat
= BT848_COLOR_FMT_YCrCb422
,
431 .flags
= FORMAT_FLAGS_PLANAR
,
435 .name
= "4:2:0, planar, Y-Cb-Cr",
436 .palette
= VIDEO_PALETTE_YUV420P
,
437 .fourcc
= V4L2_PIX_FMT_YUV420
,
438 .btformat
= BT848_COLOR_FMT_YCrCb422
,
440 .flags
= FORMAT_FLAGS_PLANAR
,
444 .name
= "4:2:0, planar, Y-Cr-Cb",
446 .fourcc
= V4L2_PIX_FMT_YVU420
,
447 .btformat
= BT848_COLOR_FMT_YCrCb422
,
449 .flags
= FORMAT_FLAGS_PLANAR
| FORMAT_FLAGS_CrCb
,
453 .name
= "4:1:1, planar, Y-Cb-Cr",
454 .palette
= VIDEO_PALETTE_YUV411P
,
455 .fourcc
= V4L2_PIX_FMT_YUV411P
,
456 .btformat
= BT848_COLOR_FMT_YCrCb411
,
458 .flags
= FORMAT_FLAGS_PLANAR
,
462 .name
= "4:1:0, planar, Y-Cb-Cr",
463 .palette
= VIDEO_PALETTE_YUV410P
,
464 .fourcc
= V4L2_PIX_FMT_YUV410
,
465 .btformat
= BT848_COLOR_FMT_YCrCb411
,
467 .flags
= FORMAT_FLAGS_PLANAR
,
471 .name
= "4:1:0, planar, Y-Cr-Cb",
473 .fourcc
= V4L2_PIX_FMT_YVU410
,
474 .btformat
= BT848_COLOR_FMT_YCrCb411
,
476 .flags
= FORMAT_FLAGS_PLANAR
| FORMAT_FLAGS_CrCb
,
480 .name
= "raw scanlines",
481 .palette
= VIDEO_PALETTE_RAW
,
483 .btformat
= BT848_COLOR_FMT_RAW
,
485 .flags
= FORMAT_FLAGS_RAW
,
488 static const unsigned int BTTV_FORMATS
= ARRAY_SIZE(bttv_formats
);
490 /* ----------------------------------------------------------------------- */
492 #define V4L2_CID_PRIVATE_CHROMA_AGC (V4L2_CID_PRIVATE_BASE + 0)
493 #define V4L2_CID_PRIVATE_COMBFILTER (V4L2_CID_PRIVATE_BASE + 1)
494 #define V4L2_CID_PRIVATE_AUTOMUTE (V4L2_CID_PRIVATE_BASE + 2)
495 #define V4L2_CID_PRIVATE_LUMAFILTER (V4L2_CID_PRIVATE_BASE + 3)
496 #define V4L2_CID_PRIVATE_AGC_CRUSH (V4L2_CID_PRIVATE_BASE + 4)
497 #define V4L2_CID_PRIVATE_VCR_HACK (V4L2_CID_PRIVATE_BASE + 5)
498 #define V4L2_CID_PRIVATE_WHITECRUSH_UPPER (V4L2_CID_PRIVATE_BASE + 6)
499 #define V4L2_CID_PRIVATE_WHITECRUSH_LOWER (V4L2_CID_PRIVATE_BASE + 7)
500 #define V4L2_CID_PRIVATE_UV_RATIO (V4L2_CID_PRIVATE_BASE + 8)
501 #define V4L2_CID_PRIVATE_FULL_LUMA_RANGE (V4L2_CID_PRIVATE_BASE + 9)
502 #define V4L2_CID_PRIVATE_CORING (V4L2_CID_PRIVATE_BASE + 10)
503 #define V4L2_CID_PRIVATE_LASTP1 (V4L2_CID_PRIVATE_BASE + 11)
505 static const struct v4l2_queryctrl no_ctl
= {
507 .flags
= V4L2_CTRL_FLAG_DISABLED
,
509 static const struct v4l2_queryctrl bttv_ctls
[] = {
512 .id
= V4L2_CID_BRIGHTNESS
,
513 .name
= "Brightness",
517 .default_value
= 32768,
518 .type
= V4L2_CTRL_TYPE_INTEGER
,
520 .id
= V4L2_CID_CONTRAST
,
525 .default_value
= 32768,
526 .type
= V4L2_CTRL_TYPE_INTEGER
,
528 .id
= V4L2_CID_SATURATION
,
529 .name
= "Saturation",
533 .default_value
= 32768,
534 .type
= V4L2_CTRL_TYPE_INTEGER
,
541 .default_value
= 32768,
542 .type
= V4L2_CTRL_TYPE_INTEGER
,
546 .id
= V4L2_CID_AUDIO_MUTE
,
550 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
552 .id
= V4L2_CID_AUDIO_VOLUME
,
557 .default_value
= 65535,
558 .type
= V4L2_CTRL_TYPE_INTEGER
,
560 .id
= V4L2_CID_AUDIO_BALANCE
,
565 .default_value
= 32768,
566 .type
= V4L2_CTRL_TYPE_INTEGER
,
568 .id
= V4L2_CID_AUDIO_BASS
,
573 .default_value
= 32768,
574 .type
= V4L2_CTRL_TYPE_INTEGER
,
576 .id
= V4L2_CID_AUDIO_TREBLE
,
581 .default_value
= 32768,
582 .type
= V4L2_CTRL_TYPE_INTEGER
,
584 /* --- private --- */
586 .id
= V4L2_CID_PRIVATE_CHROMA_AGC
,
587 .name
= "chroma agc",
590 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
592 .id
= V4L2_CID_PRIVATE_COMBFILTER
,
593 .name
= "combfilter",
596 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
598 .id
= V4L2_CID_PRIVATE_AUTOMUTE
,
602 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
604 .id
= V4L2_CID_PRIVATE_LUMAFILTER
,
605 .name
= "luma decimation filter",
608 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
610 .id
= V4L2_CID_PRIVATE_AGC_CRUSH
,
614 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
616 .id
= V4L2_CID_PRIVATE_VCR_HACK
,
620 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
622 .id
= V4L2_CID_PRIVATE_WHITECRUSH_UPPER
,
623 .name
= "whitecrush upper",
627 .default_value
= 0xCF,
628 .type
= V4L2_CTRL_TYPE_INTEGER
,
630 .id
= V4L2_CID_PRIVATE_WHITECRUSH_LOWER
,
631 .name
= "whitecrush lower",
635 .default_value
= 0x7F,
636 .type
= V4L2_CTRL_TYPE_INTEGER
,
638 .id
= V4L2_CID_PRIVATE_UV_RATIO
,
644 .type
= V4L2_CTRL_TYPE_INTEGER
,
646 .id
= V4L2_CID_PRIVATE_FULL_LUMA_RANGE
,
647 .name
= "full luma range",
650 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
652 .id
= V4L2_CID_PRIVATE_CORING
,
658 .type
= V4L2_CTRL_TYPE_INTEGER
,
664 static const int BTTV_CTLS
= ARRAY_SIZE(bttv_ctls
);
666 /* ----------------------------------------------------------------------- */
667 /* resource management */
670 int check_alloc_btres(struct bttv
*btv
, struct bttv_fh
*fh
, int bit
)
672 if (fh
->resources
& bit
)
673 /* have it already allocated */
678 if (btv
->resources
& bit
) {
679 /* no, someone else uses it */
683 /* it's free, grab it */
684 fh
->resources
|= bit
;
685 btv
->resources
|= bit
;
691 int check_btres(struct bttv_fh
*fh
, int bit
)
693 return (fh
->resources
& bit
);
697 int locked_btres(struct bttv
*btv
, int bit
)
699 return (btv
->resources
& bit
);
703 void free_btres(struct bttv
*btv
, struct bttv_fh
*fh
, int bits
)
705 if ((fh
->resources
& bits
) != bits
) {
706 /* trying to free ressources not allocated by us ... */
707 printk("bttv: BUG! (btres)\n");
710 fh
->resources
&= ~bits
;
711 btv
->resources
&= ~bits
;
715 /* ----------------------------------------------------------------------- */
716 /* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC */
718 /* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C
719 PLL_X = Reference pre-divider (0=1, 1=2)
720 PLL_C = Post divider (0=6, 1=4)
721 PLL_I = Integer input
722 PLL_F = Fractional input
724 F_input = 28.636363 MHz:
725 PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0
728 static void set_pll_freq(struct bttv
*btv
, unsigned int fin
, unsigned int fout
)
730 unsigned char fl
, fh
, fi
;
732 /* prevent overflows */
745 btwrite(fl
, BT848_PLL_F_LO
);
746 btwrite(fh
, BT848_PLL_F_HI
);
747 btwrite(fi
|BT848_PLL_X
, BT848_PLL_XCI
);
750 static void set_pll(struct bttv
*btv
)
754 if (!btv
->pll
.pll_crystal
)
757 if (btv
->pll
.pll_ofreq
== btv
->pll
.pll_current
) {
758 dprintk("bttv%d: PLL: no change required\n",btv
->c
.nr
);
762 if (btv
->pll
.pll_ifreq
== btv
->pll
.pll_ofreq
) {
764 if (btv
->pll
.pll_current
== 0)
766 bttv_printk(KERN_INFO
"bttv%d: PLL can sleep, using XTAL (%d).\n",
767 btv
->c
.nr
,btv
->pll
.pll_ifreq
);
768 btwrite(0x00,BT848_TGCTRL
);
769 btwrite(0x00,BT848_PLL_XCI
);
770 btv
->pll
.pll_current
= 0;
774 bttv_printk(KERN_INFO
"bttv%d: PLL: %d => %d ",btv
->c
.nr
,
775 btv
->pll
.pll_ifreq
, btv
->pll
.pll_ofreq
);
776 set_pll_freq(btv
, btv
->pll
.pll_ifreq
, btv
->pll
.pll_ofreq
);
778 for (i
=0; i
<10; i
++) {
779 /* Let other people run while the PLL stabilizes */
783 if (btread(BT848_DSTATUS
) & BT848_DSTATUS_PLOCK
) {
784 btwrite(0,BT848_DSTATUS
);
786 btwrite(0x08,BT848_TGCTRL
);
787 btv
->pll
.pll_current
= btv
->pll
.pll_ofreq
;
788 bttv_printk(" ok\n");
792 btv
->pll
.pll_current
= -1;
793 bttv_printk("failed\n");
797 /* used to switch between the bt848's analog/digital video capture modes */
798 static void bt848A_set_timing(struct bttv
*btv
)
801 int table_idx
= bttv_tvnorms
[btv
->tvnorm
].sram
;
802 int fsc
= bttv_tvnorms
[btv
->tvnorm
].Fsc
;
804 if (UNSET
== bttv_tvcards
[btv
->c
.type
].muxsel
[btv
->input
]) {
805 dprintk("bttv%d: load digital timing table (table_idx=%d)\n",
806 btv
->c
.nr
,table_idx
);
808 /* timing change...reset timing generator address */
809 btwrite(0x00, BT848_TGCTRL
);
810 btwrite(0x02, BT848_TGCTRL
);
811 btwrite(0x00, BT848_TGCTRL
);
813 len
=SRAM_Table
[table_idx
][0];
814 for(i
= 1; i
<= len
; i
++)
815 btwrite(SRAM_Table
[table_idx
][i
],BT848_TGLB
);
816 btv
->pll
.pll_ofreq
= 27000000;
819 btwrite(0x11, BT848_TGCTRL
);
820 btwrite(0x41, BT848_DVSIF
);
822 btv
->pll
.pll_ofreq
= fsc
;
824 btwrite(0x0, BT848_DVSIF
);
828 /* ----------------------------------------------------------------------- */
830 static void bt848_bright(struct bttv
*btv
, int bright
)
834 // printk("bttv: set bright: %d\n",bright); // DEBUG
835 btv
->bright
= bright
;
837 /* We want -128 to 127 we get 0-65535 */
838 value
= (bright
>> 8) - 128;
839 btwrite(value
& 0xff, BT848_BRIGHT
);
842 static void bt848_hue(struct bttv
*btv
, int hue
)
849 value
= (hue
>> 8) - 128;
850 btwrite(value
& 0xff, BT848_HUE
);
853 static void bt848_contrast(struct bttv
*btv
, int cont
)
857 btv
->contrast
= cont
;
861 hibit
= (value
>> 6) & 4;
862 btwrite(value
& 0xff, BT848_CONTRAST_LO
);
863 btaor(hibit
, ~4, BT848_E_CONTROL
);
864 btaor(hibit
, ~4, BT848_O_CONTROL
);
867 static void bt848_sat(struct bttv
*btv
, int color
)
869 int val_u
,val_v
,hibits
;
871 btv
->saturation
= color
;
873 /* 0-511 for the color */
874 val_u
= ((color
* btv
->opt_uv_ratio
) / 50) >> 7;
875 val_v
= (((color
* (100 - btv
->opt_uv_ratio
) / 50) >>7)*180L)/254;
876 hibits
= (val_u
>> 7) & 2;
877 hibits
|= (val_v
>> 8) & 1;
878 btwrite(val_u
& 0xff, BT848_SAT_U_LO
);
879 btwrite(val_v
& 0xff, BT848_SAT_V_LO
);
880 btaor(hibits
, ~3, BT848_E_CONTROL
);
881 btaor(hibits
, ~3, BT848_O_CONTROL
);
884 /* ----------------------------------------------------------------------- */
887 video_mux(struct bttv
*btv
, unsigned int input
)
891 if (input
>= bttv_tvcards
[btv
->c
.type
].video_inputs
)
894 /* needed by RemoteVideo MX */
895 mask2
= bttv_tvcards
[btv
->c
.type
].gpiomask2
;
897 gpio_inout(mask2
,mask2
);
899 if (input
== btv
->svhs
) {
900 btor(BT848_CONTROL_COMP
, BT848_E_CONTROL
);
901 btor(BT848_CONTROL_COMP
, BT848_O_CONTROL
);
903 btand(~BT848_CONTROL_COMP
, BT848_E_CONTROL
);
904 btand(~BT848_CONTROL_COMP
, BT848_O_CONTROL
);
906 mux
= bttv_tvcards
[btv
->c
.type
].muxsel
[input
] & 3;
907 btaor(mux
<<5, ~(3<<5), BT848_IFORM
);
908 dprintk(KERN_DEBUG
"bttv%d: video mux: input=%d mux=%d\n",
909 btv
->c
.nr
,input
,mux
);
911 /* card specific hook */
912 if(bttv_tvcards
[btv
->c
.type
].muxsel_hook
)
913 bttv_tvcards
[btv
->c
.type
].muxsel_hook (btv
, input
);
917 static char *audio_modes
[] = {
918 "audio: tuner", "audio: radio", "audio: extern",
919 "audio: intern", "audio: off"
923 audio_mux(struct bttv
*btv
, int mode
)
925 int val
,mux
,i2c_mux
,signal
;
927 gpio_inout(bttv_tvcards
[btv
->c
.type
].gpiomask
,
928 bttv_tvcards
[btv
->c
.type
].gpiomask
);
929 signal
= btread(BT848_DSTATUS
) & BT848_DSTATUS_HLOC
;
933 btv
->audio
|= AUDIO_MUTE
;
936 btv
->audio
&= ~AUDIO_MUTE
;
942 btv
->audio
&= AUDIO_MUTE
;
945 i2c_mux
= mux
= (btv
->audio
& AUDIO_MUTE
) ? AUDIO_OFF
: btv
->audio
;
946 if (btv
->opt_automute
&& !signal
&& !btv
->radio_user
)
949 val
= bttv_tvcards
[btv
->c
.type
].audiomux
[mux
];
950 gpio_bits(bttv_tvcards
[btv
->c
.type
].gpiomask
,val
);
952 bttv_gpio_tracking(btv
,audio_modes
[mux
]);
954 bttv_call_i2c_clients(btv
,AUDC_SET_INPUT
,&(i2c_mux
));
959 i2c_vidiocschan(struct bttv
*btv
)
961 struct video_channel c
;
963 memset(&c
,0,sizeof(c
));
964 c
.norm
= btv
->tvnorm
;
965 c
.channel
= btv
->input
;
966 bttv_call_i2c_clients(btv
,VIDIOCSCHAN
,&c
);
967 if (btv
->c
.type
== BTTV_VOODOOTV_FM
)
968 bttv_tda9880_setnorm(btv
,c
.norm
);
972 set_tvnorm(struct bttv
*btv
, unsigned int norm
)
974 const struct bttv_tvnorm
*tvnorm
;
976 if (norm
< 0 || norm
>= BTTV_TVNORMS
)
980 tvnorm
= &bttv_tvnorms
[norm
];
982 btwrite(tvnorm
->adelay
, BT848_ADELAY
);
983 btwrite(tvnorm
->bdelay
, BT848_BDELAY
);
984 btaor(tvnorm
->iform
,~(BT848_IFORM_NORM
|BT848_IFORM_XTBOTH
),
986 btwrite(tvnorm
->vbipack
, BT848_VBI_PACK_SIZE
);
987 btwrite(1, BT848_VBI_PACK_DEL
);
988 bt848A_set_timing(btv
);
990 switch (btv
->c
.type
) {
991 case BTTV_VOODOOTV_FM
:
992 bttv_tda9880_setnorm(btv
,norm
);
999 set_input(struct bttv
*btv
, unsigned int input
)
1001 unsigned long flags
;
1005 spin_lock_irqsave(&btv
->s_lock
,flags
);
1006 if (btv
->curr
.frame_irq
) {
1007 /* active capture -> delayed input switch */
1008 btv
->new_input
= input
;
1010 video_mux(btv
,input
);
1012 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
1014 video_mux(btv
,input
);
1016 audio_mux(btv
,(input
== bttv_tvcards
[btv
->c
.type
].tuner
?
1017 AUDIO_TUNER
: AUDIO_EXTERN
));
1018 set_tvnorm(btv
,btv
->tvnorm
);
1019 i2c_vidiocschan(btv
);
1022 static void init_irqreg(struct bttv
*btv
)
1025 btwrite(0xfffffUL
, BT848_INT_STAT
);
1027 if (bttv_tvcards
[btv
->c
.type
].no_video
) {
1029 btwrite(BT848_INT_I2CDONE
,
1033 btwrite((btv
->triton1
) |
1034 (btv
->gpioirq
? BT848_INT_GPINT
: 0) |
1036 (fdsr
? BT848_INT_FDSR
: 0) |
1037 BT848_INT_RISCI
|BT848_INT_OCERR
|BT848_INT_VPRES
|
1038 BT848_INT_FMTCHG
|BT848_INT_HLOCK
|
1044 static void init_bt848(struct bttv
*btv
)
1048 if (bttv_tvcards
[btv
->c
.type
].no_video
) {
1049 /* very basic init only */
1054 btwrite(0x00, BT848_CAP_CTL
);
1055 btwrite(BT848_COLOR_CTL_GAMMA
, BT848_COLOR_CTL
);
1056 btwrite(BT848_IFORM_XTAUTO
| BT848_IFORM_AUTO
, BT848_IFORM
);
1058 /* set planar and packed mode trigger points and */
1059 /* set rising edge of inverted GPINTR pin as irq trigger */
1060 btwrite(BT848_GPIO_DMA_CTL_PKTP_32
|
1061 BT848_GPIO_DMA_CTL_PLTP1_16
|
1062 BT848_GPIO_DMA_CTL_PLTP23_16
|
1063 BT848_GPIO_DMA_CTL_GPINTC
|
1064 BT848_GPIO_DMA_CTL_GPINTI
,
1065 BT848_GPIO_DMA_CTL
);
1067 val
= btv
->opt_chroma_agc
? BT848_SCLOOP_CAGC
: 0;
1068 btwrite(val
, BT848_E_SCLOOP
);
1069 btwrite(val
, BT848_O_SCLOOP
);
1071 btwrite(0x20, BT848_E_VSCALE_HI
);
1072 btwrite(0x20, BT848_O_VSCALE_HI
);
1073 btwrite(BT848_ADC_RESERVED
| (btv
->opt_adc_crush
? BT848_ADC_CRUSH
: 0),
1076 btwrite(whitecrush_upper
, BT848_WC_UP
);
1077 btwrite(whitecrush_lower
, BT848_WC_DOWN
);
1079 if (btv
->opt_lumafilter
) {
1080 btwrite(0, BT848_E_CONTROL
);
1081 btwrite(0, BT848_O_CONTROL
);
1083 btwrite(BT848_CONTROL_LDEC
, BT848_E_CONTROL
);
1084 btwrite(BT848_CONTROL_LDEC
, BT848_O_CONTROL
);
1087 bt848_bright(btv
, btv
->bright
);
1088 bt848_hue(btv
, btv
->hue
);
1089 bt848_contrast(btv
, btv
->contrast
);
1090 bt848_sat(btv
, btv
->saturation
);
1096 static void bttv_reinit_bt848(struct bttv
*btv
)
1098 unsigned long flags
;
1101 printk(KERN_INFO
"bttv%d: reset, reinitialize\n",btv
->c
.nr
);
1102 spin_lock_irqsave(&btv
->s_lock
,flags
);
1104 bttv_set_dma(btv
,0);
1105 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
1108 btv
->pll
.pll_current
= -1;
1109 set_input(btv
,btv
->input
);
1112 static int get_control(struct bttv
*btv
, struct v4l2_control
*c
)
1114 struct video_audio va
;
1117 for (i
= 0; i
< BTTV_CTLS
; i
++)
1118 if (bttv_ctls
[i
].id
== c
->id
)
1122 if (i
>= 4 && i
<= 8) {
1123 memset(&va
,0,sizeof(va
));
1124 bttv_call_i2c_clients(btv
, VIDIOCGAUDIO
, &va
);
1125 if (btv
->audio_hook
)
1126 btv
->audio_hook(btv
,&va
,0);
1129 case V4L2_CID_BRIGHTNESS
:
1130 c
->value
= btv
->bright
;
1133 c
->value
= btv
->hue
;
1135 case V4L2_CID_CONTRAST
:
1136 c
->value
= btv
->contrast
;
1138 case V4L2_CID_SATURATION
:
1139 c
->value
= btv
->saturation
;
1142 case V4L2_CID_AUDIO_MUTE
:
1143 c
->value
= (VIDEO_AUDIO_MUTE
& va
.flags
) ? 1 : 0;
1145 case V4L2_CID_AUDIO_VOLUME
:
1146 c
->value
= va
.volume
;
1148 case V4L2_CID_AUDIO_BALANCE
:
1149 c
->value
= va
.balance
;
1151 case V4L2_CID_AUDIO_BASS
:
1154 case V4L2_CID_AUDIO_TREBLE
:
1155 c
->value
= va
.treble
;
1158 case V4L2_CID_PRIVATE_CHROMA_AGC
:
1159 c
->value
= btv
->opt_chroma_agc
;
1161 case V4L2_CID_PRIVATE_COMBFILTER
:
1162 c
->value
= btv
->opt_combfilter
;
1164 case V4L2_CID_PRIVATE_LUMAFILTER
:
1165 c
->value
= btv
->opt_lumafilter
;
1167 case V4L2_CID_PRIVATE_AUTOMUTE
:
1168 c
->value
= btv
->opt_automute
;
1170 case V4L2_CID_PRIVATE_AGC_CRUSH
:
1171 c
->value
= btv
->opt_adc_crush
;
1173 case V4L2_CID_PRIVATE_VCR_HACK
:
1174 c
->value
= btv
->opt_vcr_hack
;
1176 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER
:
1177 c
->value
= btv
->opt_whitecrush_upper
;
1179 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER
:
1180 c
->value
= btv
->opt_whitecrush_lower
;
1182 case V4L2_CID_PRIVATE_UV_RATIO
:
1183 c
->value
= btv
->opt_uv_ratio
;
1185 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE
:
1186 c
->value
= btv
->opt_full_luma_range
;
1188 case V4L2_CID_PRIVATE_CORING
:
1189 c
->value
= btv
->opt_coring
;
1197 static int set_control(struct bttv
*btv
, struct v4l2_control
*c
)
1199 struct video_audio va
;
1202 for (i
= 0; i
< BTTV_CTLS
; i
++)
1203 if (bttv_ctls
[i
].id
== c
->id
)
1207 if (i
>= 4 && i
<= 8) {
1208 memset(&va
,0,sizeof(va
));
1209 bttv_call_i2c_clients(btv
, VIDIOCGAUDIO
, &va
);
1210 if (btv
->audio_hook
)
1211 btv
->audio_hook(btv
,&va
,0);
1214 case V4L2_CID_BRIGHTNESS
:
1215 bt848_bright(btv
,c
->value
);
1218 bt848_hue(btv
,c
->value
);
1220 case V4L2_CID_CONTRAST
:
1221 bt848_contrast(btv
,c
->value
);
1223 case V4L2_CID_SATURATION
:
1224 bt848_sat(btv
,c
->value
);
1226 case V4L2_CID_AUDIO_MUTE
:
1228 va
.flags
|= VIDEO_AUDIO_MUTE
;
1229 audio_mux(btv
, AUDIO_MUTE
);
1231 va
.flags
&= ~VIDEO_AUDIO_MUTE
;
1232 audio_mux(btv
, AUDIO_UNMUTE
);
1236 case V4L2_CID_AUDIO_VOLUME
:
1237 va
.volume
= c
->value
;
1239 case V4L2_CID_AUDIO_BALANCE
:
1240 va
.balance
= c
->value
;
1242 case V4L2_CID_AUDIO_BASS
:
1245 case V4L2_CID_AUDIO_TREBLE
:
1246 va
.treble
= c
->value
;
1249 case V4L2_CID_PRIVATE_CHROMA_AGC
:
1250 btv
->opt_chroma_agc
= c
->value
;
1251 val
= btv
->opt_chroma_agc
? BT848_SCLOOP_CAGC
: 0;
1252 btwrite(val
, BT848_E_SCLOOP
);
1253 btwrite(val
, BT848_O_SCLOOP
);
1255 case V4L2_CID_PRIVATE_COMBFILTER
:
1256 btv
->opt_combfilter
= c
->value
;
1258 case V4L2_CID_PRIVATE_LUMAFILTER
:
1259 btv
->opt_lumafilter
= c
->value
;
1260 if (btv
->opt_lumafilter
) {
1261 btand(~BT848_CONTROL_LDEC
, BT848_E_CONTROL
);
1262 btand(~BT848_CONTROL_LDEC
, BT848_O_CONTROL
);
1264 btor(BT848_CONTROL_LDEC
, BT848_E_CONTROL
);
1265 btor(BT848_CONTROL_LDEC
, BT848_O_CONTROL
);
1268 case V4L2_CID_PRIVATE_AUTOMUTE
:
1269 btv
->opt_automute
= c
->value
;
1271 case V4L2_CID_PRIVATE_AGC_CRUSH
:
1272 btv
->opt_adc_crush
= c
->value
;
1273 btwrite(BT848_ADC_RESERVED
| (btv
->opt_adc_crush
? BT848_ADC_CRUSH
: 0),
1276 case V4L2_CID_PRIVATE_VCR_HACK
:
1277 btv
->opt_vcr_hack
= c
->value
;
1279 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER
:
1280 btv
->opt_whitecrush_upper
= c
->value
;
1281 btwrite(c
->value
, BT848_WC_UP
);
1283 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER
:
1284 btv
->opt_whitecrush_lower
= c
->value
;
1285 btwrite(c
->value
, BT848_WC_DOWN
);
1287 case V4L2_CID_PRIVATE_UV_RATIO
:
1288 btv
->opt_uv_ratio
= c
->value
;
1289 bt848_sat(btv
, btv
->saturation
);
1291 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE
:
1292 btv
->opt_full_luma_range
= c
->value
;
1293 btaor((c
->value
<<7), ~BT848_OFORM_RANGE
, BT848_OFORM
);
1295 case V4L2_CID_PRIVATE_CORING
:
1296 btv
->opt_coring
= c
->value
;
1297 btaor((c
->value
<<5), ~BT848_OFORM_CORE32
, BT848_OFORM
);
1302 if (i
>= 4 && i
<= 8) {
1303 bttv_call_i2c_clients(btv
, VIDIOCSAUDIO
, &va
);
1304 if (btv
->audio_hook
)
1305 btv
->audio_hook(btv
,&va
,1);
1310 /* ----------------------------------------------------------------------- */
1312 void bttv_gpio_tracking(struct bttv
*btv
, char *comment
)
1314 unsigned int outbits
, data
;
1315 outbits
= btread(BT848_GPIO_OUT_EN
);
1316 data
= btread(BT848_GPIO_DATA
);
1317 printk(KERN_DEBUG
"bttv%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
1318 btv
->c
.nr
,outbits
,data
& outbits
, data
& ~outbits
, comment
);
1321 static void bttv_field_count(struct bttv
*btv
)
1329 /* start field counter */
1330 btor(BT848_INT_VSYNC
,BT848_INT_MASK
);
1332 /* stop field counter */
1333 btand(~BT848_INT_VSYNC
,BT848_INT_MASK
);
1334 btv
->field_count
= 0;
1338 static const struct bttv_format
*
1339 format_by_palette(int palette
)
1343 for (i
= 0; i
< BTTV_FORMATS
; i
++) {
1344 if (-1 == bttv_formats
[i
].palette
)
1346 if (bttv_formats
[i
].palette
== palette
)
1347 return bttv_formats
+i
;
1352 static const struct bttv_format
*
1353 format_by_fourcc(int fourcc
)
1357 for (i
= 0; i
< BTTV_FORMATS
; i
++) {
1358 if (-1 == bttv_formats
[i
].fourcc
)
1360 if (bttv_formats
[i
].fourcc
== fourcc
)
1361 return bttv_formats
+i
;
1366 /* ----------------------------------------------------------------------- */
1370 bttv_switch_overlay(struct bttv
*btv
, struct bttv_fh
*fh
,
1371 struct bttv_buffer
*new)
1373 struct bttv_buffer
*old
;
1374 unsigned long flags
;
1377 dprintk("switch_overlay: enter [new=%p]\n",new);
1379 new->vb
.state
= STATE_DONE
;
1380 spin_lock_irqsave(&btv
->s_lock
,flags
);
1384 bttv_set_dma(btv
, 0x03);
1385 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
1387 free_btres(btv
,fh
,RESOURCE_OVERLAY
);
1389 dprintk("switch_overlay: old=%p state is %d\n",old
,old
->vb
.state
);
1390 bttv_dma_free(btv
, old
);
1393 dprintk("switch_overlay: done\n");
1397 /* ----------------------------------------------------------------------- */
1398 /* video4linux (1) interface */
1400 static int bttv_prepare_buffer(struct bttv
*btv
, struct bttv_buffer
*buf
,
1401 const struct bttv_format
*fmt
,
1402 unsigned int width
, unsigned int height
,
1403 enum v4l2_field field
)
1405 int redo_dma_risc
= 0;
1408 /* check settings */
1411 if (fmt
->btformat
== BT848_COLOR_FMT_RAW
) {
1413 height
= RAW_LINES
*2;
1414 if (width
*height
> buf
->vb
.bsize
)
1416 buf
->vb
.size
= buf
->vb
.bsize
;
1420 width
> bttv_tvnorms
[btv
->tvnorm
].swidth
||
1421 height
> bttv_tvnorms
[btv
->tvnorm
].sheight
)
1423 buf
->vb
.size
= (width
* height
* fmt
->depth
) >> 3;
1424 if (0 != buf
->vb
.baddr
&& buf
->vb
.bsize
< buf
->vb
.size
)
1428 /* alloc + fill struct bttv_buffer (if changed) */
1429 if (buf
->vb
.width
!= width
|| buf
->vb
.height
!= height
||
1430 buf
->vb
.field
!= field
||
1431 buf
->tvnorm
!= btv
->tvnorm
|| buf
->fmt
!= fmt
) {
1432 buf
->vb
.width
= width
;
1433 buf
->vb
.height
= height
;
1434 buf
->vb
.field
= field
;
1435 buf
->tvnorm
= btv
->tvnorm
;
1440 /* alloc risc memory */
1441 if (STATE_NEEDS_INIT
== buf
->vb
.state
) {
1443 if (0 != (rc
= videobuf_iolock(btv
->c
.pci
,&buf
->vb
,&btv
->fbuf
)))
1448 if (0 != (rc
= bttv_buffer_risc(btv
,buf
)))
1451 buf
->vb
.state
= STATE_PREPARED
;
1455 bttv_dma_free(btv
,buf
);
1460 buffer_setup(struct videobuf_queue
*q
, unsigned int *count
, unsigned int *size
)
1462 struct bttv_fh
*fh
= q
->priv_data
;
1464 *size
= fh
->fmt
->depth
*fh
->width
*fh
->height
>> 3;
1467 while (*size
* *count
> gbuffers
* gbufsize
)
1473 buffer_prepare(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
,
1474 enum v4l2_field field
)
1476 struct bttv_buffer
*buf
= container_of(vb
,struct bttv_buffer
,vb
);
1477 struct bttv_fh
*fh
= q
->priv_data
;
1479 return bttv_prepare_buffer(fh
->btv
, buf
, fh
->fmt
,
1480 fh
->width
, fh
->height
, field
);
1484 buffer_queue(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
)
1486 struct bttv_buffer
*buf
= container_of(vb
,struct bttv_buffer
,vb
);
1487 struct bttv_fh
*fh
= q
->priv_data
;
1488 struct bttv
*btv
= fh
->btv
;
1490 buf
->vb
.state
= STATE_QUEUED
;
1491 list_add_tail(&buf
->vb
.queue
,&btv
->capture
);
1492 if (!btv
->curr
.frame_irq
) {
1494 bttv_set_dma(btv
, 0x03);
1498 static void buffer_release(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
)
1500 struct bttv_buffer
*buf
= container_of(vb
,struct bttv_buffer
,vb
);
1501 struct bttv_fh
*fh
= q
->priv_data
;
1503 bttv_dma_free(fh
->btv
,buf
);
1506 static struct videobuf_queue_ops bttv_video_qops
= {
1507 .buf_setup
= buffer_setup
,
1508 .buf_prepare
= buffer_prepare
,
1509 .buf_queue
= buffer_queue
,
1510 .buf_release
= buffer_release
,
1513 static const char *v4l1_ioctls
[] = {
1514 "?", "CGAP", "GCHAN", "SCHAN", "GTUNER", "STUNER", "GPICT", "SPICT",
1515 "CCAPTURE", "GWIN", "SWIN", "GFBUF", "SFBUF", "KEY", "GFREQ",
1516 "SFREQ", "GAUDIO", "SAUDIO", "SYNC", "MCAPTURE", "GMBUF", "GUNIT",
1517 "GCAPTURE", "SCAPTURE", "SPLAYMODE", "SWRITEMODE", "GPLAYINFO",
1518 "SMICROCODE", "GVBIFMT", "SVBIFMT" };
1519 #define V4L1_IOCTLS ARRAY_SIZE(v4l1_ioctls)
1521 static int bttv_common_ioctls(struct bttv
*btv
, unsigned int cmd
, void *arg
)
1525 return BTTV_VERSION_CODE
;
1527 /* *** v4l1 *** ************************************************ */
1530 unsigned long *freq
= arg
;
1536 unsigned long *freq
= arg
;
1539 bttv_call_i2c_clients(btv
,VIDIOCSFREQ
,freq
);
1540 if (btv
->has_matchbox
&& btv
->radio_user
)
1541 tea5757_set_freq(btv
,*freq
);
1548 struct video_tuner
*v
= arg
;
1550 if (UNSET
== bttv_tvcards
[btv
->c
.type
].tuner
)
1552 if (v
->tuner
) /* Only tuner 0 */
1554 strcpy(v
->name
, "Television");
1556 v
->rangehigh
= 0x7FFFFFFF;
1557 v
->flags
= VIDEO_TUNER_PAL
|VIDEO_TUNER_NTSC
|VIDEO_TUNER_SECAM
;
1558 v
->mode
= btv
->tvnorm
;
1559 v
->signal
= (btread(BT848_DSTATUS
)&BT848_DSTATUS_HLOC
) ? 0xFFFF : 0;
1560 bttv_call_i2c_clients(btv
,cmd
,v
);
1565 struct video_tuner
*v
= arg
;
1567 if (v
->tuner
) /* Only tuner 0 */
1569 if (v
->mode
>= BTTV_TVNORMS
)
1573 set_tvnorm(btv
,v
->mode
);
1574 bttv_call_i2c_clients(btv
,cmd
,v
);
1581 struct video_channel
*v
= arg
;
1582 unsigned int channel
= v
->channel
;
1584 if (channel
>= bttv_tvcards
[btv
->c
.type
].video_inputs
)
1587 v
->flags
= VIDEO_VC_AUDIO
;
1588 v
->type
= VIDEO_TYPE_CAMERA
;
1589 v
->norm
= btv
->tvnorm
;
1590 if (channel
== bttv_tvcards
[btv
->c
.type
].tuner
) {
1591 strcpy(v
->name
,"Television");
1592 v
->flags
|=VIDEO_VC_TUNER
;
1593 v
->type
=VIDEO_TYPE_TV
;
1595 } else if (channel
== btv
->svhs
) {
1596 strcpy(v
->name
,"S-Video");
1598 sprintf(v
->name
,"Composite%d",channel
);
1604 struct video_channel
*v
= arg
;
1605 unsigned int channel
= v
->channel
;
1607 if (channel
>= bttv_tvcards
[btv
->c
.type
].video_inputs
)
1609 if (v
->norm
>= BTTV_TVNORMS
)
1613 if (channel
== btv
->input
&&
1614 v
->norm
== btv
->tvnorm
) {
1620 btv
->tvnorm
= v
->norm
;
1621 set_input(btv
,v
->channel
);
1628 struct video_audio
*v
= arg
;
1630 memset(v
,0,sizeof(*v
));
1631 strcpy(v
->name
,"Television");
1632 v
->flags
|= VIDEO_AUDIO_MUTABLE
;
1633 v
->mode
= VIDEO_SOUND_MONO
;
1636 bttv_call_i2c_clients(btv
,cmd
,v
);
1638 /* card specific hooks */
1639 if (btv
->audio_hook
)
1640 btv
->audio_hook(btv
,v
,0);
1647 struct video_audio
*v
= arg
;
1648 unsigned int audio
= v
->audio
;
1650 if (audio
>= bttv_tvcards
[btv
->c
.type
].audio_inputs
)
1654 audio_mux(btv
, (v
->flags
&VIDEO_AUDIO_MUTE
) ? AUDIO_MUTE
: AUDIO_UNMUTE
);
1655 bttv_call_i2c_clients(btv
,cmd
,v
);
1657 /* card specific hooks */
1658 if (btv
->audio_hook
)
1659 btv
->audio_hook(btv
,v
,1);
1665 /* *** v4l2 *** ************************************************ */
1666 case VIDIOC_ENUMSTD
:
1668 struct v4l2_standard
*e
= arg
;
1669 unsigned int index
= e
->index
;
1671 if (index
>= BTTV_TVNORMS
)
1673 v4l2_video_std_construct(e
, bttv_tvnorms
[e
->index
].v4l2_id
,
1674 bttv_tvnorms
[e
->index
].name
);
1680 v4l2_std_id
*id
= arg
;
1681 *id
= bttv_tvnorms
[btv
->tvnorm
].v4l2_id
;
1686 v4l2_std_id
*id
= arg
;
1689 for (i
= 0; i
< BTTV_TVNORMS
; i
++)
1690 if (*id
& bttv_tvnorms
[i
].v4l2_id
)
1692 if (i
== BTTV_TVNORMS
)
1697 i2c_vidiocschan(btv
);
1701 case VIDIOC_QUERYSTD
:
1703 v4l2_std_id
*id
= arg
;
1705 if (btread(BT848_DSTATUS
) & BT848_DSTATUS_NUML
)
1706 *id
= V4L2_STD_625_50
;
1708 *id
= V4L2_STD_525_60
;
1712 case VIDIOC_ENUMINPUT
:
1714 struct v4l2_input
*i
= arg
;
1718 if (n
>= bttv_tvcards
[btv
->c
.type
].video_inputs
)
1720 memset(i
,0,sizeof(*i
));
1722 i
->type
= V4L2_INPUT_TYPE_CAMERA
;
1724 if (i
->index
== bttv_tvcards
[btv
->c
.type
].tuner
) {
1725 sprintf(i
->name
, "Television");
1726 i
->type
= V4L2_INPUT_TYPE_TUNER
;
1728 } else if (i
->index
== btv
->svhs
) {
1729 sprintf(i
->name
, "S-Video");
1731 sprintf(i
->name
,"Composite%d",i
->index
);
1733 if (i
->index
== btv
->input
) {
1734 __u32 dstatus
= btread(BT848_DSTATUS
);
1735 if (0 == (dstatus
& BT848_DSTATUS_PRES
))
1736 i
->status
|= V4L2_IN_ST_NO_SIGNAL
;
1737 if (0 == (dstatus
& BT848_DSTATUS_HLOC
))
1738 i
->status
|= V4L2_IN_ST_NO_H_LOCK
;
1740 for (n
= 0; n
< BTTV_TVNORMS
; n
++)
1741 i
->std
|= bttv_tvnorms
[n
].v4l2_id
;
1744 case VIDIOC_G_INPUT
:
1750 case VIDIOC_S_INPUT
:
1752 unsigned int *i
= arg
;
1754 if (*i
> bttv_tvcards
[btv
->c
.type
].video_inputs
)
1762 case VIDIOC_G_TUNER
:
1764 struct v4l2_tuner
*t
= arg
;
1766 if (UNSET
== bttv_tvcards
[btv
->c
.type
].tuner
)
1771 memset(t
,0,sizeof(*t
));
1772 strcpy(t
->name
, "Television");
1773 t
->type
= V4L2_TUNER_ANALOG_TV
;
1774 t
->rangehigh
= 0xffffffffUL
;
1775 t
->capability
= V4L2_TUNER_CAP_NORM
;
1776 t
->rxsubchans
= V4L2_TUNER_SUB_MONO
;
1777 if (btread(BT848_DSTATUS
)&BT848_DSTATUS_HLOC
)
1781 struct video_audio va
;
1782 memset(&va
, 0, sizeof(struct video_audio
));
1783 bttv_call_i2c_clients(btv
, VIDIOCGAUDIO
, &va
);
1784 if (btv
->audio_hook
)
1785 btv
->audio_hook(btv
,&va
,0);
1786 if(va
.mode
& VIDEO_SOUND_STEREO
) {
1787 t
->audmode
= V4L2_TUNER_MODE_STEREO
;
1788 t
->rxsubchans
|= V4L2_TUNER_SUB_STEREO
;
1790 if(va
.mode
& VIDEO_SOUND_LANG1
) {
1791 t
->audmode
= V4L2_TUNER_MODE_LANG1
;
1792 t
->rxsubchans
= V4L2_TUNER_SUB_LANG1
1793 | V4L2_TUNER_SUB_LANG2
;
1796 /* FIXME: fill capability+audmode */
1800 case VIDIOC_S_TUNER
:
1802 struct v4l2_tuner
*t
= arg
;
1804 if (UNSET
== bttv_tvcards
[btv
->c
.type
].tuner
)
1810 struct video_audio va
;
1811 memset(&va
, 0, sizeof(struct video_audio
));
1812 bttv_call_i2c_clients(btv
, VIDIOCGAUDIO
, &va
);
1813 if (t
->audmode
== V4L2_TUNER_MODE_MONO
)
1814 va
.mode
= VIDEO_SOUND_MONO
;
1815 else if (t
->audmode
== V4L2_TUNER_MODE_STEREO
)
1816 va
.mode
= VIDEO_SOUND_STEREO
;
1817 else if (t
->audmode
== V4L2_TUNER_MODE_LANG1
)
1818 va
.mode
= VIDEO_SOUND_LANG1
;
1819 else if (t
->audmode
== V4L2_TUNER_MODE_LANG2
)
1820 va
.mode
= VIDEO_SOUND_LANG2
;
1821 bttv_call_i2c_clients(btv
, VIDIOCSAUDIO
, &va
);
1822 if (btv
->audio_hook
)
1823 btv
->audio_hook(btv
,&va
,1);
1829 case VIDIOC_G_FREQUENCY
:
1831 struct v4l2_frequency
*f
= arg
;
1833 memset(f
,0,sizeof(*f
));
1834 f
->type
= V4L2_TUNER_ANALOG_TV
;
1835 f
->frequency
= btv
->freq
;
1838 case VIDIOC_S_FREQUENCY
:
1840 struct v4l2_frequency
*f
= arg
;
1842 if (unlikely(f
->tuner
!= 0))
1844 if (unlikely (f
->type
!= V4L2_TUNER_ANALOG_TV
))
1847 btv
->freq
= f
->frequency
;
1848 bttv_call_i2c_clients(btv
,VIDIOCSFREQ
,&btv
->freq
);
1849 if (btv
->has_matchbox
&& btv
->radio_user
)
1850 tea5757_set_freq(btv
,btv
->freq
);
1856 return -ENOIOCTLCMD
;
1862 static int verify_window(const struct bttv_tvnorm
*tvn
,
1863 struct v4l2_window
*win
, int fixup
)
1865 enum v4l2_field field
;
1868 if (win
->w
.width
< 48 || win
->w
.height
< 32)
1870 if (win
->clipcount
> 2048)
1875 maxh
= tvn
->sheight
;
1877 if (V4L2_FIELD_ANY
== field
) {
1878 field
= (win
->w
.height
> maxh
/2)
1879 ? V4L2_FIELD_INTERLACED
1883 case V4L2_FIELD_TOP
:
1884 case V4L2_FIELD_BOTTOM
:
1887 case V4L2_FIELD_INTERLACED
:
1893 if (!fixup
&& (win
->w
.width
> maxw
|| win
->w
.height
> maxh
))
1896 if (win
->w
.width
> maxw
)
1897 win
->w
.width
= maxw
;
1898 if (win
->w
.height
> maxh
)
1899 win
->w
.height
= maxh
;
1904 static int setup_window(struct bttv_fh
*fh
, struct bttv
*btv
,
1905 struct v4l2_window
*win
, int fixup
)
1907 struct v4l2_clip
*clips
= NULL
;
1908 int n
,size
,retval
= 0;
1910 if (NULL
== fh
->ovfmt
)
1912 if (!(fh
->ovfmt
->flags
& FORMAT_FLAGS_PACKED
))
1914 retval
= verify_window(&bttv_tvnorms
[btv
->tvnorm
],win
,fixup
);
1918 /* copy clips -- luckily v4l1 + v4l2 are binary
1919 compatible here ...*/
1921 size
= sizeof(*clips
)*(n
+4);
1922 clips
= kmalloc(size
,GFP_KERNEL
);
1926 if (copy_from_user(clips
,win
->clips
,sizeof(struct v4l2_clip
)*n
)) {
1931 /* clip against screen */
1932 if (NULL
!= btv
->fbuf
.base
)
1933 n
= btcx_screen_clips(btv
->fbuf
.fmt
.width
, btv
->fbuf
.fmt
.height
,
1935 btcx_sort_clips(clips
,n
);
1937 /* 4-byte alignments */
1938 switch (fh
->ovfmt
->depth
) {
1941 btcx_align(&win
->w
, clips
, n
, 3);
1944 btcx_align(&win
->w
, clips
, n
, 1);
1947 /* no alignment fixups needed */
1953 down(&fh
->cap
.lock
);
1954 kfree(fh
->ov
.clips
);
1955 fh
->ov
.clips
= clips
;
1959 fh
->ov
.field
= win
->field
;
1960 fh
->ov
.setup_ok
= 1;
1961 btv
->init
.ov
.w
.width
= win
->w
.width
;
1962 btv
->init
.ov
.w
.height
= win
->w
.height
;
1963 btv
->init
.ov
.field
= win
->field
;
1965 /* update overlay if needed */
1967 if (check_btres(fh
, RESOURCE_OVERLAY
)) {
1968 struct bttv_buffer
*new;
1970 new = videobuf_alloc(sizeof(*new));
1971 bttv_overlay_risc(btv
, &fh
->ov
, fh
->ovfmt
, new);
1972 retval
= bttv_switch_overlay(btv
,fh
,new);
1978 /* ----------------------------------------------------------------------- */
1980 static struct videobuf_queue
* bttv_queue(struct bttv_fh
*fh
)
1982 struct videobuf_queue
* q
= NULL
;
1985 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
1988 case V4L2_BUF_TYPE_VBI_CAPTURE
:
1997 static int bttv_resource(struct bttv_fh
*fh
)
2002 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2003 res
= RESOURCE_VIDEO
;
2005 case V4L2_BUF_TYPE_VBI_CAPTURE
:
2014 static int bttv_switch_type(struct bttv_fh
*fh
, enum v4l2_buf_type type
)
2016 struct videobuf_queue
*q
= bttv_queue(fh
);
2017 int res
= bttv_resource(fh
);
2019 if (check_btres(fh
,res
))
2021 if (videobuf_queue_is_busy(q
))
2027 static int bttv_g_fmt(struct bttv_fh
*fh
, struct v4l2_format
*f
)
2030 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2031 memset(&f
->fmt
.pix
,0,sizeof(struct v4l2_pix_format
));
2032 f
->fmt
.pix
.width
= fh
->width
;
2033 f
->fmt
.pix
.height
= fh
->height
;
2034 f
->fmt
.pix
.field
= fh
->cap
.field
;
2035 f
->fmt
.pix
.pixelformat
= fh
->fmt
->fourcc
;
2036 f
->fmt
.pix
.bytesperline
=
2037 (f
->fmt
.pix
.width
* fh
->fmt
->depth
) >> 3;
2038 f
->fmt
.pix
.sizeimage
=
2039 f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
2041 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
2042 memset(&f
->fmt
.win
,0,sizeof(struct v4l2_window
));
2043 f
->fmt
.win
.w
= fh
->ov
.w
;
2044 f
->fmt
.win
.field
= fh
->ov
.field
;
2046 case V4L2_BUF_TYPE_VBI_CAPTURE
:
2047 bttv_vbi_get_fmt(fh
,f
);
2054 static int bttv_try_fmt(struct bttv_fh
*fh
, struct bttv
*btv
,
2055 struct v4l2_format
*f
)
2058 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2060 const struct bttv_format
*fmt
;
2061 enum v4l2_field field
;
2062 unsigned int maxw
,maxh
;
2064 fmt
= format_by_fourcc(f
->fmt
.pix
.pixelformat
);
2069 maxw
= bttv_tvnorms
[btv
->tvnorm
].swidth
;
2070 maxh
= bttv_tvnorms
[btv
->tvnorm
].sheight
;
2071 field
= f
->fmt
.pix
.field
;
2072 if (V4L2_FIELD_ANY
== field
)
2073 field
= (f
->fmt
.pix
.height
> maxh
/2)
2074 ? V4L2_FIELD_INTERLACED
2075 : V4L2_FIELD_BOTTOM
;
2076 if (V4L2_FIELD_SEQ_BT
== field
)
2077 field
= V4L2_FIELD_SEQ_TB
;
2079 case V4L2_FIELD_TOP
:
2080 case V4L2_FIELD_BOTTOM
:
2081 case V4L2_FIELD_ALTERNATE
:
2084 case V4L2_FIELD_INTERLACED
:
2086 case V4L2_FIELD_SEQ_TB
:
2087 if (fmt
->flags
& FORMAT_FLAGS_PLANAR
)
2094 /* update data for the application */
2095 f
->fmt
.pix
.field
= field
;
2096 if (f
->fmt
.pix
.width
< 48)
2097 f
->fmt
.pix
.width
= 48;
2098 if (f
->fmt
.pix
.height
< 32)
2099 f
->fmt
.pix
.height
= 32;
2100 if (f
->fmt
.pix
.width
> maxw
)
2101 f
->fmt
.pix
.width
= maxw
;
2102 if (f
->fmt
.pix
.height
> maxh
)
2103 f
->fmt
.pix
.height
= maxh
;
2104 f
->fmt
.pix
.width
&= ~0x03;
2105 f
->fmt
.pix
.bytesperline
=
2106 (f
->fmt
.pix
.width
* fmt
->depth
) >> 3;
2107 f
->fmt
.pix
.sizeimage
=
2108 f
->fmt
.pix
.height
* f
->fmt
.pix
.bytesperline
;
2112 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
2113 return verify_window(&bttv_tvnorms
[btv
->tvnorm
],
2115 case V4L2_BUF_TYPE_VBI_CAPTURE
:
2116 bttv_vbi_try_fmt(fh
,f
);
2123 static int bttv_s_fmt(struct bttv_fh
*fh
, struct bttv
*btv
,
2124 struct v4l2_format
*f
)
2129 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2131 const struct bttv_format
*fmt
;
2133 retval
= bttv_switch_type(fh
,f
->type
);
2136 retval
= bttv_try_fmt(fh
,btv
,f
);
2139 fmt
= format_by_fourcc(f
->fmt
.pix
.pixelformat
);
2141 /* update our state informations */
2142 down(&fh
->cap
.lock
);
2144 fh
->cap
.field
= f
->fmt
.pix
.field
;
2145 fh
->cap
.last
= V4L2_FIELD_NONE
;
2146 fh
->width
= f
->fmt
.pix
.width
;
2147 fh
->height
= f
->fmt
.pix
.height
;
2148 btv
->init
.fmt
= fmt
;
2149 btv
->init
.width
= f
->fmt
.pix
.width
;
2150 btv
->init
.height
= f
->fmt
.pix
.height
;
2155 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
2156 if (no_overlay
> 0) {
2157 printk ("V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2160 return setup_window(fh
, btv
, &f
->fmt
.win
, 1);
2161 case V4L2_BUF_TYPE_VBI_CAPTURE
:
2162 retval
= bttv_switch_type(fh
,f
->type
);
2165 if (locked_btres(fh
->btv
, RESOURCE_VBI
))
2167 bttv_vbi_try_fmt(fh
,f
);
2168 bttv_vbi_setlines(fh
,btv
,f
->fmt
.vbi
.count
[0]);
2169 bttv_vbi_get_fmt(fh
,f
);
2176 static int bttv_do_ioctl(struct inode
*inode
, struct file
*file
,
2177 unsigned int cmd
, void *arg
)
2179 struct bttv_fh
*fh
= file
->private_data
;
2180 struct bttv
*btv
= fh
->btv
;
2181 unsigned long flags
;
2184 if (bttv_debug
> 1) {
2185 switch (_IOC_TYPE(cmd
)) {
2187 printk("bttv%d: ioctl 0x%x (v4l1, VIDIOC%s)\n",
2188 btv
->c
.nr
, cmd
, (_IOC_NR(cmd
) < V4L1_IOCTLS
) ?
2189 v4l1_ioctls
[_IOC_NR(cmd
)] : "???");
2192 printk("bttv%d: ioctl 0x%x (v4l2, %s)\n",
2193 btv
->c
.nr
, cmd
, v4l2_ioctl_names
[_IOC_NR(cmd
)]);
2196 printk("bttv%d: ioctl 0x%x (???)\n",
2201 bttv_reinit_bt848(btv
);
2209 case VIDIOC_S_INPUT
:
2210 case VIDIOC_S_TUNER
:
2211 case VIDIOC_S_FREQUENCY
:
2212 retval
= v4l2_prio_check(&btv
->prio
,&fh
->prio
);
2219 /* *** v4l1 *** ************************************************ */
2222 struct video_capability
*cap
= arg
;
2224 memset(cap
,0,sizeof(*cap
));
2225 strcpy(cap
->name
,btv
->video_dev
->name
);
2226 if (V4L2_BUF_TYPE_VBI_CAPTURE
== fh
->type
) {
2228 cap
->type
= VID_TYPE_TUNER
|VID_TYPE_TELETEXT
;
2231 cap
->type
= VID_TYPE_CAPTURE
|
2235 if (no_overlay
<= 0)
2236 cap
->type
|= VID_TYPE_OVERLAY
;
2238 cap
->maxwidth
= bttv_tvnorms
[btv
->tvnorm
].swidth
;
2239 cap
->maxheight
= bttv_tvnorms
[btv
->tvnorm
].sheight
;
2241 cap
->minheight
= 32;
2243 cap
->channels
= bttv_tvcards
[btv
->c
.type
].video_inputs
;
2244 cap
->audios
= bttv_tvcards
[btv
->c
.type
].audio_inputs
;
2250 struct video_picture
*pic
= arg
;
2252 memset(pic
,0,sizeof(*pic
));
2253 pic
->brightness
= btv
->bright
;
2254 pic
->contrast
= btv
->contrast
;
2255 pic
->hue
= btv
->hue
;
2256 pic
->colour
= btv
->saturation
;
2258 pic
->depth
= fh
->fmt
->depth
;
2259 pic
->palette
= fh
->fmt
->palette
;
2265 struct video_picture
*pic
= arg
;
2266 const struct bttv_format
*fmt
;
2268 fmt
= format_by_palette(pic
->palette
);
2271 down(&fh
->cap
.lock
);
2272 if (fmt
->depth
!= pic
->depth
) {
2274 goto fh_unlock_and_return
;
2278 btv
->init
.ovfmt
= fmt
;
2279 btv
->init
.fmt
= fmt
;
2281 /* dirty hack time: swap bytes for overlay if the
2282 display adaptor is big endian (insmod option) */
2283 if (fmt
->palette
== VIDEO_PALETTE_RGB555
||
2284 fmt
->palette
== VIDEO_PALETTE_RGB565
||
2285 fmt
->palette
== VIDEO_PALETTE_RGB32
) {
2289 bt848_bright(btv
,pic
->brightness
);
2290 bt848_contrast(btv
,pic
->contrast
);
2291 bt848_hue(btv
,pic
->hue
);
2292 bt848_sat(btv
,pic
->colour
);
2299 struct video_window
*win
= arg
;
2301 memset(win
,0,sizeof(*win
));
2302 win
->x
= fh
->ov
.w
.left
;
2303 win
->y
= fh
->ov
.w
.top
;
2304 win
->width
= fh
->ov
.w
.width
;
2305 win
->height
= fh
->ov
.w
.height
;
2310 struct video_window
*win
= arg
;
2311 struct v4l2_window w2
;
2313 if (no_overlay
> 0) {
2314 printk ("VIDIOCSWIN: no_overlay\n");
2318 w2
.field
= V4L2_FIELD_ANY
;
2321 w2
.w
.width
= win
->width
;
2322 w2
.w
.height
= win
->height
;
2323 w2
.clipcount
= win
->clipcount
;
2324 w2
.clips
= (struct v4l2_clip __user
*)win
->clips
;
2325 retval
= setup_window(fh
, btv
, &w2
, 0);
2327 /* on v4l1 this ioctl affects the read() size too */
2328 fh
->width
= fh
->ov
.w
.width
;
2329 fh
->height
= fh
->ov
.w
.height
;
2330 btv
->init
.width
= fh
->ov
.w
.width
;
2331 btv
->init
.height
= fh
->ov
.w
.height
;
2338 struct video_buffer
*fbuf
= arg
;
2340 fbuf
->base
= btv
->fbuf
.base
;
2341 fbuf
->width
= btv
->fbuf
.fmt
.width
;
2342 fbuf
->height
= btv
->fbuf
.fmt
.height
;
2343 fbuf
->bytesperline
= btv
->fbuf
.fmt
.bytesperline
;
2345 fbuf
->depth
= fh
->ovfmt
->depth
;
2350 struct video_buffer
*fbuf
= arg
;
2351 const struct bttv_format
*fmt
;
2354 if(!capable(CAP_SYS_ADMIN
) &&
2355 !capable(CAP_SYS_RAWIO
))
2357 end
= (unsigned long)fbuf
->base
+
2358 fbuf
->height
* fbuf
->bytesperline
;
2359 down(&fh
->cap
.lock
);
2362 switch (fbuf
->depth
) {
2364 fmt
= format_by_palette(VIDEO_PALETTE_HI240
);
2367 fmt
= format_by_palette(VIDEO_PALETTE_RGB565
);
2370 fmt
= format_by_palette(VIDEO_PALETTE_RGB24
);
2373 fmt
= format_by_palette(VIDEO_PALETTE_RGB32
);
2377 fmt
= format_by_palette(VIDEO_PALETTE_RGB555
);
2384 goto fh_unlock_and_return
;
2388 btv
->init
.ovfmt
= fmt
;
2389 btv
->init
.fmt
= fmt
;
2390 btv
->fbuf
.base
= fbuf
->base
;
2391 btv
->fbuf
.fmt
.width
= fbuf
->width
;
2392 btv
->fbuf
.fmt
.height
= fbuf
->height
;
2393 if (fbuf
->bytesperline
)
2394 btv
->fbuf
.fmt
.bytesperline
= fbuf
->bytesperline
;
2396 btv
->fbuf
.fmt
.bytesperline
= btv
->fbuf
.fmt
.width
*fbuf
->depth
/8;
2402 case VIDIOC_OVERLAY
:
2404 struct bttv_buffer
*new;
2409 if (NULL
== btv
->fbuf
.base
)
2411 if (!fh
->ov
.setup_ok
) {
2412 dprintk("bttv%d: overlay: !setup_ok\n",btv
->c
.nr
);
2417 if (!check_alloc_btres(btv
,fh
,RESOURCE_OVERLAY
))
2420 down(&fh
->cap
.lock
);
2422 fh
->ov
.tvnorm
= btv
->tvnorm
;
2423 new = videobuf_alloc(sizeof(*new));
2424 bttv_overlay_risc(btv
, &fh
->ov
, fh
->ovfmt
, new);
2430 retval
= bttv_switch_overlay(btv
,fh
,new);
2437 struct video_mbuf
*mbuf
= arg
;
2440 down(&fh
->cap
.lock
);
2441 retval
= videobuf_mmap_setup(&fh
->cap
,gbuffers
,gbufsize
,
2444 goto fh_unlock_and_return
;
2445 memset(mbuf
,0,sizeof(*mbuf
));
2446 mbuf
->frames
= gbuffers
;
2447 mbuf
->size
= gbuffers
* gbufsize
;
2448 for (i
= 0; i
< gbuffers
; i
++)
2449 mbuf
->offsets
[i
] = i
* gbufsize
;
2453 case VIDIOCMCAPTURE
:
2455 struct video_mmap
*vm
= arg
;
2456 struct bttv_buffer
*buf
;
2457 enum v4l2_field field
;
2459 if (vm
->frame
>= VIDEO_MAX_FRAME
)
2462 down(&fh
->cap
.lock
);
2464 buf
= (struct bttv_buffer
*)fh
->cap
.bufs
[vm
->frame
];
2466 goto fh_unlock_and_return
;
2467 if (0 == buf
->vb
.baddr
)
2468 goto fh_unlock_and_return
;
2469 if (buf
->vb
.state
== STATE_QUEUED
||
2470 buf
->vb
.state
== STATE_ACTIVE
)
2471 goto fh_unlock_and_return
;
2473 field
= (vm
->height
> bttv_tvnorms
[btv
->tvnorm
].sheight
/2)
2474 ? V4L2_FIELD_INTERLACED
2475 : V4L2_FIELD_BOTTOM
;
2476 retval
= bttv_prepare_buffer(btv
,buf
,
2477 format_by_palette(vm
->format
),
2478 vm
->width
,vm
->height
,field
);
2480 goto fh_unlock_and_return
;
2481 spin_lock_irqsave(&btv
->s_lock
,flags
);
2482 buffer_queue(&fh
->cap
,&buf
->vb
);
2483 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
2490 struct bttv_buffer
*buf
;
2492 if (*frame
>= VIDEO_MAX_FRAME
)
2495 down(&fh
->cap
.lock
);
2497 buf
= (struct bttv_buffer
*)fh
->cap
.bufs
[*frame
];
2499 goto fh_unlock_and_return
;
2500 retval
= videobuf_waiton(&buf
->vb
,0,1);
2502 goto fh_unlock_and_return
;
2503 switch (buf
->vb
.state
) {
2508 videobuf_dma_pci_sync(btv
->c
.pci
,&buf
->vb
.dma
);
2509 bttv_dma_free(btv
,buf
);
2521 struct vbi_format
*fmt
= (void *) arg
;
2522 struct v4l2_format fmt2
;
2524 if (fh
->type
!= V4L2_BUF_TYPE_VBI_CAPTURE
) {
2525 retval
= bttv_switch_type(fh
,V4L2_BUF_TYPE_VBI_CAPTURE
);
2529 bttv_vbi_get_fmt(fh
, &fmt2
);
2531 memset(fmt
,0,sizeof(*fmt
));
2532 fmt
->sampling_rate
= fmt2
.fmt
.vbi
.sampling_rate
;
2533 fmt
->samples_per_line
= fmt2
.fmt
.vbi
.samples_per_line
;
2534 fmt
->sample_format
= VIDEO_PALETTE_RAW
;
2535 fmt
->start
[0] = fmt2
.fmt
.vbi
.start
[0];
2536 fmt
->count
[0] = fmt2
.fmt
.vbi
.count
[0];
2537 fmt
->start
[1] = fmt2
.fmt
.vbi
.start
[1];
2538 fmt
->count
[1] = fmt2
.fmt
.vbi
.count
[1];
2539 if (fmt2
.fmt
.vbi
.flags
& VBI_UNSYNC
)
2540 fmt
->flags
|= V4L2_VBI_UNSYNC
;
2541 if (fmt2
.fmt
.vbi
.flags
& VBI_INTERLACED
)
2542 fmt
->flags
|= V4L2_VBI_INTERLACED
;
2547 struct vbi_format
*fmt
= (void *) arg
;
2548 struct v4l2_format fmt2
;
2550 retval
= bttv_switch_type(fh
,V4L2_BUF_TYPE_VBI_CAPTURE
);
2553 bttv_vbi_get_fmt(fh
, &fmt2
);
2555 if (fmt
->sampling_rate
!= fmt2
.fmt
.vbi
.sampling_rate
||
2556 fmt
->samples_per_line
!= fmt2
.fmt
.vbi
.samples_per_line
||
2557 fmt
->sample_format
!= VIDEO_PALETTE_RAW
||
2558 fmt
->start
[0] != fmt2
.fmt
.vbi
.start
[0] ||
2559 fmt
->start
[1] != fmt2
.fmt
.vbi
.start
[1] ||
2560 fmt
->count
[0] != fmt
->count
[1] ||
2561 fmt
->count
[0] < 1 ||
2562 fmt
->count
[0] > 32 /* VBI_MAXLINES */)
2565 bttv_vbi_setlines(fh
,btv
,fmt
->count
[0]);
2578 return bttv_common_ioctls(btv
,cmd
,arg
);
2580 /* *** v4l2 *** ************************************************ */
2581 case VIDIOC_QUERYCAP
:
2583 struct v4l2_capability
*cap
= arg
;
2587 strcpy(cap
->driver
,"bttv");
2588 strlcpy(cap
->card
,btv
->video_dev
->name
,sizeof(cap
->card
));
2589 sprintf(cap
->bus_info
,"PCI:%s",pci_name(btv
->c
.pci
));
2590 cap
->version
= BTTV_VERSION_CODE
;
2592 V4L2_CAP_VIDEO_CAPTURE
|
2593 V4L2_CAP_VBI_CAPTURE
|
2594 V4L2_CAP_READWRITE
|
2596 if (no_overlay
<= 0)
2597 cap
->capabilities
|= V4L2_CAP_VIDEO_OVERLAY
;
2599 if (bttv_tvcards
[btv
->c
.type
].tuner
!= UNSET
&&
2600 bttv_tvcards
[btv
->c
.type
].tuner
!= TUNER_ABSENT
)
2601 cap
->capabilities
|= V4L2_CAP_TUNER
;
2605 case VIDIOC_ENUM_FMT
:
2607 struct v4l2_fmtdesc
*f
= arg
;
2608 enum v4l2_buf_type type
;
2613 if (V4L2_BUF_TYPE_VBI_CAPTURE
== type
) {
2618 memset(f
,0,sizeof(*f
));
2621 f
->pixelformat
= V4L2_PIX_FMT_GREY
;
2622 strcpy(f
->description
,"vbi data");
2626 /* video capture + overlay */
2628 for (i
= 0; i
< BTTV_FORMATS
; i
++) {
2629 if (bttv_formats
[i
].fourcc
!= -1)
2631 if ((unsigned int)index
== f
->index
)
2634 if (BTTV_FORMATS
== i
)
2638 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2640 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
2641 if (!(bttv_formats
[i
].flags
& FORMAT_FLAGS_PACKED
))
2647 memset(f
,0,sizeof(*f
));
2650 f
->pixelformat
= bttv_formats
[i
].fourcc
;
2651 strlcpy(f
->description
,bttv_formats
[i
].name
,sizeof(f
->description
));
2655 case VIDIOC_TRY_FMT
:
2657 struct v4l2_format
*f
= arg
;
2658 return bttv_try_fmt(fh
,btv
,f
);
2662 struct v4l2_format
*f
= arg
;
2663 return bttv_g_fmt(fh
,f
);
2667 struct v4l2_format
*f
= arg
;
2668 return bttv_s_fmt(fh
,btv
,f
);
2673 struct v4l2_framebuffer
*fb
= arg
;
2676 fb
->capability
= V4L2_FBUF_CAP_LIST_CLIPPING
;
2678 fb
->fmt
.pixelformat
= fh
->ovfmt
->fourcc
;
2683 struct v4l2_framebuffer
*fb
= arg
;
2684 const struct bttv_format
*fmt
;
2686 if(!capable(CAP_SYS_ADMIN
) &&
2687 !capable(CAP_SYS_RAWIO
))
2691 fmt
= format_by_fourcc(fb
->fmt
.pixelformat
);
2694 if (0 == (fmt
->flags
& FORMAT_FLAGS_PACKED
))
2697 down(&fh
->cap
.lock
);
2699 if (fb
->flags
& V4L2_FBUF_FLAG_OVERLAY
) {
2700 if (fb
->fmt
.width
> bttv_tvnorms
[btv
->tvnorm
].swidth
)
2701 goto fh_unlock_and_return
;
2702 if (fb
->fmt
.height
> bttv_tvnorms
[btv
->tvnorm
].sheight
)
2703 goto fh_unlock_and_return
;
2707 btv
->fbuf
.base
= fb
->base
;
2708 btv
->fbuf
.fmt
.width
= fb
->fmt
.width
;
2709 btv
->fbuf
.fmt
.height
= fb
->fmt
.height
;
2710 if (0 != fb
->fmt
.bytesperline
)
2711 btv
->fbuf
.fmt
.bytesperline
= fb
->fmt
.bytesperline
;
2713 btv
->fbuf
.fmt
.bytesperline
= btv
->fbuf
.fmt
.width
*fmt
->depth
/8;
2717 btv
->init
.ovfmt
= fmt
;
2718 if (fb
->flags
& V4L2_FBUF_FLAG_OVERLAY
) {
2721 fh
->ov
.w
.width
= fb
->fmt
.width
;
2722 fh
->ov
.w
.height
= fb
->fmt
.height
;
2723 btv
->init
.ov
.w
.width
= fb
->fmt
.width
;
2724 btv
->init
.ov
.w
.height
= fb
->fmt
.height
;
2725 kfree(fh
->ov
.clips
);
2726 fh
->ov
.clips
= NULL
;
2729 if (check_btres(fh
, RESOURCE_OVERLAY
)) {
2730 struct bttv_buffer
*new;
2732 new = videobuf_alloc(sizeof(*new));
2733 bttv_overlay_risc(btv
,&fh
->ov
,fh
->ovfmt
,new);
2734 retval
= bttv_switch_overlay(btv
,fh
,new);
2741 case VIDIOC_REQBUFS
:
2742 return videobuf_reqbufs(bttv_queue(fh
),arg
);
2744 case VIDIOC_QUERYBUF
:
2745 return videobuf_querybuf(bttv_queue(fh
),arg
);
2748 return videobuf_qbuf(bttv_queue(fh
),arg
);
2751 return videobuf_dqbuf(bttv_queue(fh
),arg
,
2752 file
->f_flags
& O_NONBLOCK
);
2754 case VIDIOC_STREAMON
:
2756 int res
= bttv_resource(fh
);
2758 if (!check_alloc_btres(btv
,fh
,res
))
2760 return videobuf_streamon(bttv_queue(fh
));
2762 case VIDIOC_STREAMOFF
:
2764 int res
= bttv_resource(fh
);
2766 retval
= videobuf_streamoff(bttv_queue(fh
));
2769 free_btres(btv
,fh
,res
);
2773 case VIDIOC_QUERYCTRL
:
2775 struct v4l2_queryctrl
*c
= arg
;
2778 if ((c
->id
< V4L2_CID_BASE
||
2779 c
->id
>= V4L2_CID_LASTP1
) &&
2780 (c
->id
< V4L2_CID_PRIVATE_BASE
||
2781 c
->id
>= V4L2_CID_PRIVATE_LASTP1
))
2783 for (i
= 0; i
< BTTV_CTLS
; i
++)
2784 if (bttv_ctls
[i
].id
== c
->id
)
2786 if (i
== BTTV_CTLS
) {
2791 if (i
>= 4 && i
<= 8) {
2792 struct video_audio va
;
2793 memset(&va
,0,sizeof(va
));
2794 bttv_call_i2c_clients(btv
, VIDIOCGAUDIO
, &va
);
2795 if (btv
->audio_hook
)
2796 btv
->audio_hook(btv
,&va
,0);
2797 switch (bttv_ctls
[i
].id
) {
2798 case V4L2_CID_AUDIO_VOLUME
:
2799 if (!(va
.flags
& VIDEO_AUDIO_VOLUME
))
2802 case V4L2_CID_AUDIO_BALANCE
:
2803 if (!(va
.flags
& VIDEO_AUDIO_BALANCE
))
2806 case V4L2_CID_AUDIO_BASS
:
2807 if (!(va
.flags
& VIDEO_AUDIO_BASS
))
2810 case V4L2_CID_AUDIO_TREBLE
:
2811 if (!(va
.flags
& VIDEO_AUDIO_TREBLE
))
2819 return get_control(btv
,arg
);
2821 return set_control(btv
,arg
);
2824 struct v4l2_streamparm
*parm
= arg
;
2825 struct v4l2_standard s
;
2826 if (parm
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
2828 memset(parm
,0,sizeof(*parm
));
2829 v4l2_video_std_construct(&s
, bttv_tvnorms
[btv
->tvnorm
].v4l2_id
,
2830 bttv_tvnorms
[btv
->tvnorm
].name
);
2831 parm
->parm
.capture
.timeperframe
= s
.frameperiod
;
2835 case VIDIOC_G_PRIORITY
:
2837 enum v4l2_priority
*p
= arg
;
2839 *p
= v4l2_prio_max(&btv
->prio
);
2842 case VIDIOC_S_PRIORITY
:
2844 enum v4l2_priority
*prio
= arg
;
2846 return v4l2_prio_change(&btv
->prio
, &fh
->prio
, *prio
);
2849 case VIDIOC_ENUMSTD
:
2852 case VIDIOC_ENUMINPUT
:
2853 case VIDIOC_G_INPUT
:
2854 case VIDIOC_S_INPUT
:
2855 case VIDIOC_G_TUNER
:
2856 case VIDIOC_S_TUNER
:
2857 case VIDIOC_G_FREQUENCY
:
2858 case VIDIOC_S_FREQUENCY
:
2859 return bttv_common_ioctls(btv
,cmd
,arg
);
2862 return -ENOIOCTLCMD
;
2866 fh_unlock_and_return
:
2871 static int bttv_ioctl(struct inode
*inode
, struct file
*file
,
2872 unsigned int cmd
, unsigned long arg
)
2874 struct bttv_fh
*fh
= file
->private_data
;
2878 bttv_switch_type(fh
,V4L2_BUF_TYPE_VBI_CAPTURE
);
2879 return fh
->lines
* 2 * 2048;
2881 return video_usercopy(inode
, file
, cmd
, arg
, bttv_do_ioctl
);
2885 static ssize_t
bttv_read(struct file
*file
, char __user
*data
,
2886 size_t count
, loff_t
*ppos
)
2888 struct bttv_fh
*fh
= file
->private_data
;
2891 if (fh
->btv
->errors
)
2892 bttv_reinit_bt848(fh
->btv
);
2893 dprintk("bttv%d: read count=%d type=%s\n",
2894 fh
->btv
->c
.nr
,(int)count
,v4l2_type_names
[fh
->type
]);
2897 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2898 if (locked_btres(fh
->btv
,RESOURCE_VIDEO
))
2900 retval
= videobuf_read_one(&fh
->cap
, data
, count
, ppos
,
2901 file
->f_flags
& O_NONBLOCK
);
2903 case V4L2_BUF_TYPE_VBI_CAPTURE
:
2904 if (!check_alloc_btres(fh
->btv
,fh
,RESOURCE_VBI
))
2906 retval
= videobuf_read_stream(&fh
->vbi
, data
, count
, ppos
, 1,
2907 file
->f_flags
& O_NONBLOCK
);
2915 static unsigned int bttv_poll(struct file
*file
, poll_table
*wait
)
2917 struct bttv_fh
*fh
= file
->private_data
;
2918 struct bttv_buffer
*buf
;
2919 enum v4l2_field field
;
2921 if (V4L2_BUF_TYPE_VBI_CAPTURE
== fh
->type
) {
2922 if (!check_alloc_btres(fh
->btv
,fh
,RESOURCE_VBI
))
2924 return videobuf_poll_stream(file
, &fh
->vbi
, wait
);
2927 if (check_btres(fh
,RESOURCE_VIDEO
)) {
2928 /* streaming capture */
2929 if (list_empty(&fh
->cap
.stream
))
2931 buf
= list_entry(fh
->cap
.stream
.next
,struct bttv_buffer
,vb
.stream
);
2933 /* read() capture */
2934 down(&fh
->cap
.lock
);
2935 if (NULL
== fh
->cap
.read_buf
) {
2936 /* need to capture a new frame */
2937 if (locked_btres(fh
->btv
,RESOURCE_VIDEO
)) {
2941 fh
->cap
.read_buf
= videobuf_alloc(fh
->cap
.msize
);
2942 if (NULL
== fh
->cap
.read_buf
) {
2946 fh
->cap
.read_buf
->memory
= V4L2_MEMORY_USERPTR
;
2947 field
= videobuf_next_field(&fh
->cap
);
2948 if (0 != fh
->cap
.ops
->buf_prepare(&fh
->cap
,fh
->cap
.read_buf
,field
)) {
2952 fh
->cap
.ops
->buf_queue(&fh
->cap
,fh
->cap
.read_buf
);
2953 fh
->cap
.read_off
= 0;
2956 buf
= (struct bttv_buffer
*)fh
->cap
.read_buf
;
2959 poll_wait(file
, &buf
->vb
.done
, wait
);
2960 if (buf
->vb
.state
== STATE_DONE
||
2961 buf
->vb
.state
== STATE_ERROR
)
2962 return POLLIN
|POLLRDNORM
;
2966 static int bttv_open(struct inode
*inode
, struct file
*file
)
2968 int minor
= iminor(inode
);
2969 struct bttv
*btv
= NULL
;
2971 enum v4l2_buf_type type
= 0;
2974 dprintk(KERN_DEBUG
"bttv: open minor=%d\n",minor
);
2976 for (i
= 0; i
< bttv_num
; i
++) {
2977 if (bttvs
[i
].video_dev
&&
2978 bttvs
[i
].video_dev
->minor
== minor
) {
2980 type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
2983 if (bttvs
[i
].vbi_dev
&&
2984 bttvs
[i
].vbi_dev
->minor
== minor
) {
2986 type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
2993 dprintk(KERN_DEBUG
"bttv%d: open called (type=%s)\n",
2994 btv
->c
.nr
,v4l2_type_names
[type
]);
2996 /* allocate per filehandle data */
2997 fh
= kmalloc(sizeof(*fh
),GFP_KERNEL
);
3000 file
->private_data
= fh
;
3003 fh
->ov
.setup_ok
= 0;
3004 v4l2_prio_open(&btv
->prio
,&fh
->prio
);
3006 videobuf_queue_init(&fh
->cap
, &bttv_video_qops
,
3007 btv
->c
.pci
, &btv
->s_lock
,
3008 V4L2_BUF_TYPE_VIDEO_CAPTURE
,
3009 V4L2_FIELD_INTERLACED
,
3010 sizeof(struct bttv_buffer
),
3012 videobuf_queue_init(&fh
->vbi
, &bttv_vbi_qops
,
3013 btv
->c
.pci
, &btv
->s_lock
,
3014 V4L2_BUF_TYPE_VBI_CAPTURE
,
3016 sizeof(struct bttv_buffer
),
3018 i2c_vidiocschan(btv
);
3021 if (V4L2_BUF_TYPE_VBI_CAPTURE
== fh
->type
)
3022 bttv_vbi_setlines(fh
,btv
,16);
3023 bttv_field_count(btv
);
3027 static int bttv_release(struct inode
*inode
, struct file
*file
)
3029 struct bttv_fh
*fh
= file
->private_data
;
3030 struct bttv
*btv
= fh
->btv
;
3032 /* turn off overlay */
3033 if (check_btres(fh
, RESOURCE_OVERLAY
))
3034 bttv_switch_overlay(btv
,fh
,NULL
);
3036 /* stop video capture */
3037 if (check_btres(fh
, RESOURCE_VIDEO
)) {
3038 videobuf_streamoff(&fh
->cap
);
3039 free_btres(btv
,fh
,RESOURCE_VIDEO
);
3041 if (fh
->cap
.read_buf
) {
3042 buffer_release(&fh
->cap
,fh
->cap
.read_buf
);
3043 kfree(fh
->cap
.read_buf
);
3046 /* stop vbi capture */
3047 if (check_btres(fh
, RESOURCE_VBI
)) {
3048 if (fh
->vbi
.streaming
)
3049 videobuf_streamoff(&fh
->vbi
);
3050 if (fh
->vbi
.reading
)
3051 videobuf_read_stop(&fh
->vbi
);
3052 free_btres(btv
,fh
,RESOURCE_VBI
);
3056 videobuf_mmap_free(&fh
->cap
);
3057 videobuf_mmap_free(&fh
->vbi
);
3058 v4l2_prio_close(&btv
->prio
,&fh
->prio
);
3059 file
->private_data
= NULL
;
3063 bttv_field_count(btv
);
3068 bttv_mmap(struct file
*file
, struct vm_area_struct
*vma
)
3070 struct bttv_fh
*fh
= file
->private_data
;
3072 dprintk("bttv%d: mmap type=%s 0x%lx+%ld\n",
3073 fh
->btv
->c
.nr
, v4l2_type_names
[fh
->type
],
3074 vma
->vm_start
, vma
->vm_end
- vma
->vm_start
);
3075 return videobuf_mmap_mapper(bttv_queue(fh
),vma
);
3078 static struct file_operations bttv_fops
=
3080 .owner
= THIS_MODULE
,
3082 .release
= bttv_release
,
3083 .ioctl
= bttv_ioctl
,
3084 .llseek
= no_llseek
,
3090 static struct video_device bttv_video_template
=
3093 .type
= VID_TYPE_CAPTURE
|VID_TYPE_TUNER
|
3094 VID_TYPE_CLIPPING
|VID_TYPE_SCALES
,
3095 .hardware
= VID_HARDWARE_BT848
,
3100 static struct video_device bttv_vbi_template
=
3102 .name
= "bt848/878 vbi",
3103 .type
= VID_TYPE_TUNER
|VID_TYPE_TELETEXT
,
3104 .hardware
= VID_HARDWARE_BT848
,
3109 /* ----------------------------------------------------------------------- */
3110 /* radio interface */
3112 static int radio_open(struct inode
*inode
, struct file
*file
)
3114 int minor
= iminor(inode
);
3115 struct bttv
*btv
= NULL
;
3118 dprintk("bttv: open minor=%d\n",minor
);
3120 for (i
= 0; i
< bttv_num
; i
++) {
3121 if (bttvs
[i
].radio_dev
->minor
== minor
) {
3129 dprintk("bttv%d: open called (radio)\n",btv
->c
.nr
);
3134 file
->private_data
= btv
;
3136 bttv_call_i2c_clients(btv
,AUDC_SET_RADIO
,&btv
->tuner_type
);
3137 audio_mux(btv
,AUDIO_RADIO
);
3143 static int radio_release(struct inode
*inode
, struct file
*file
)
3145 struct bttv
*btv
= file
->private_data
;
3146 struct rds_command cmd
;
3150 bttv_call_i2c_clients(btv
, RDS_CMD_CLOSE
, &cmd
);
3155 static int radio_do_ioctl(struct inode
*inode
, struct file
*file
,
3156 unsigned int cmd
, void *arg
)
3158 struct bttv
*btv
= file
->private_data
;
3163 struct video_capability
*cap
= arg
;
3165 memset(cap
,0,sizeof(*cap
));
3166 strcpy(cap
->name
,btv
->radio_dev
->name
);
3167 cap
->type
= VID_TYPE_TUNER
;
3175 struct video_tuner
*v
= arg
;
3179 memset(v
,0,sizeof(*v
));
3180 strcpy(v
->name
, "Radio");
3181 bttv_call_i2c_clients(btv
,cmd
,v
);
3193 return bttv_common_ioctls(btv
,cmd
,arg
);
3196 return -ENOIOCTLCMD
;
3201 static int radio_ioctl(struct inode
*inode
, struct file
*file
,
3202 unsigned int cmd
, unsigned long arg
)
3204 return video_usercopy(inode
, file
, cmd
, arg
, radio_do_ioctl
);
3207 static ssize_t
radio_read(struct file
*file
, char __user
*data
,
3208 size_t count
, loff_t
*ppos
)
3210 struct bttv
*btv
= file
->private_data
;
3211 struct rds_command cmd
;
3212 cmd
.block_count
= count
/3;
3214 cmd
.instance
= file
;
3215 cmd
.result
= -ENODEV
;
3217 bttv_call_i2c_clients(btv
, RDS_CMD_READ
, &cmd
);
3222 static unsigned int radio_poll(struct file
*file
, poll_table
*wait
)
3224 struct bttv
*btv
= file
->private_data
;
3225 struct rds_command cmd
;
3226 cmd
.instance
= file
;
3227 cmd
.event_list
= wait
;
3228 cmd
.result
= -ENODEV
;
3229 bttv_call_i2c_clients(btv
, RDS_CMD_POLL
, &cmd
);
3234 static struct file_operations radio_fops
=
3236 .owner
= THIS_MODULE
,
3239 .release
= radio_release
,
3240 .ioctl
= radio_ioctl
,
3241 .llseek
= no_llseek
,
3245 static struct video_device radio_template
=
3247 .name
= "bt848/878 radio",
3248 .type
= VID_TYPE_TUNER
,
3249 .hardware
= VID_HARDWARE_BT848
,
3250 .fops
= &radio_fops
,
3254 /* ----------------------------------------------------------------------- */
3255 /* some debug code */
3257 static int bttv_risc_decode(u32 risc
)
3259 static char *instr
[16] = {
3260 [ BT848_RISC_WRITE
>> 28 ] = "write",
3261 [ BT848_RISC_SKIP
>> 28 ] = "skip",
3262 [ BT848_RISC_WRITEC
>> 28 ] = "writec",
3263 [ BT848_RISC_JUMP
>> 28 ] = "jump",
3264 [ BT848_RISC_SYNC
>> 28 ] = "sync",
3265 [ BT848_RISC_WRITE123
>> 28 ] = "write123",
3266 [ BT848_RISC_SKIP123
>> 28 ] = "skip123",
3267 [ BT848_RISC_WRITE1S23
>> 28 ] = "write1s23",
3269 static int incr
[16] = {
3270 [ BT848_RISC_WRITE
>> 28 ] = 2,
3271 [ BT848_RISC_JUMP
>> 28 ] = 2,
3272 [ BT848_RISC_SYNC
>> 28 ] = 2,
3273 [ BT848_RISC_WRITE123
>> 28 ] = 5,
3274 [ BT848_RISC_SKIP123
>> 28 ] = 2,
3275 [ BT848_RISC_WRITE1S23
>> 28 ] = 3,
3277 static char *bits
[] = {
3278 "be0", "be1", "be2", "be3/resync",
3279 "set0", "set1", "set2", "set3",
3280 "clr0", "clr1", "clr2", "clr3",
3281 "irq", "res", "eol", "sol",
3285 printk("0x%08x [ %s", risc
,
3286 instr
[risc
>> 28] ? instr
[risc
>> 28] : "INVALID");
3287 for (i
= ARRAY_SIZE(bits
)-1; i
>= 0; i
--)
3288 if (risc
& (1 << (i
+ 12)))
3289 printk(" %s",bits
[i
]);
3290 printk(" count=%d ]\n", risc
& 0xfff);
3291 return incr
[risc
>> 28] ? incr
[risc
>> 28] : 1;
3294 static void bttv_risc_disasm(struct bttv
*btv
,
3295 struct btcx_riscmem
*risc
)
3299 printk("%s: risc disasm: %p [dma=0x%08lx]\n",
3300 btv
->c
.name
, risc
->cpu
, (unsigned long)risc
->dma
);
3301 for (i
= 0; i
< (risc
->size
>> 2); i
+= n
) {
3302 printk("%s: 0x%lx: ", btv
->c
.name
,
3303 (unsigned long)(risc
->dma
+ (i
<<2)));
3304 n
= bttv_risc_decode(risc
->cpu
[i
]);
3305 for (j
= 1; j
< n
; j
++)
3306 printk("%s: 0x%lx: 0x%08x [ arg #%d ]\n",
3307 btv
->c
.name
, (unsigned long)(risc
->dma
+ ((i
+j
)<<2)),
3309 if (0 == risc
->cpu
[i
])
3314 static void bttv_print_riscaddr(struct bttv
*btv
)
3316 printk(" main: %08Lx\n",
3317 (unsigned long long)btv
->main
.dma
);
3318 printk(" vbi : o=%08Lx e=%08Lx\n",
3319 btv
->cvbi
? (unsigned long long)btv
->cvbi
->top
.dma
: 0,
3320 btv
->cvbi
? (unsigned long long)btv
->cvbi
->bottom
.dma
: 0);
3321 printk(" cap : o=%08Lx e=%08Lx\n",
3322 btv
->curr
.top
? (unsigned long long)btv
->curr
.top
->top
.dma
: 0,
3323 btv
->curr
.bottom
? (unsigned long long)btv
->curr
.bottom
->bottom
.dma
: 0);
3324 printk(" scr : o=%08Lx e=%08Lx\n",
3325 btv
->screen
? (unsigned long long)btv
->screen
->top
.dma
: 0,
3326 btv
->screen
? (unsigned long long)btv
->screen
->bottom
.dma
: 0);
3327 bttv_risc_disasm(btv
, &btv
->main
);
3330 /* ----------------------------------------------------------------------- */
3333 static char *irq_name
[] = {
3334 "FMTCHG", // format change detected (525 vs. 625)
3335 "VSYNC", // vertical sync (new field)
3336 "HSYNC", // horizontal sync
3337 "OFLOW", // chroma/luma AGC overflow
3338 "HLOCK", // horizontal lock changed
3339 "VPRES", // video presence changed
3341 "I2CDONE", // hw irc operation finished
3342 "GPINT", // gpio port triggered irq
3344 "RISCI", // risc instruction triggered irq
3345 "FBUS", // pixel data fifo dropped data (high pci bus latencies)
3346 "FTRGT", // pixel data fifo overrun
3347 "FDSR", // fifo data stream resyncronisation
3348 "PPERR", // parity error (data transfer)
3349 "RIPERR", // parity error (read risc instructions)
3350 "PABORT", // pci abort
3351 "OCERR", // risc instruction error
3352 "SCERR", // syncronisation error
3355 static void bttv_print_irqbits(u32 print
, u32 mark
)
3360 for (i
= 0; i
< ARRAY_SIZE(irq_name
); i
++) {
3361 if (print
& (1 << i
))
3362 printk(" %s",irq_name
[i
]);
3363 if (mark
& (1 << i
))
3368 static void bttv_irq_debug_low_latency(struct bttv
*btv
, u32 rc
)
3370 printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
3372 (unsigned long)btv
->main
.dma
,
3373 (unsigned long)btv
->main
.cpu
[RISC_SLOT_O_VBI
+1],
3374 (unsigned long)btv
->main
.cpu
[RISC_SLOT_O_FIELD
+1],
3377 if (0 == (btread(BT848_DSTATUS
) & BT848_DSTATUS_HLOC
)) {
3378 printk("bttv%d: Oh, there (temporarely?) is no input signal. "
3379 "Ok, then this is harmless, don't worry ;)\n",
3383 printk("bttv%d: Uhm. Looks like we have unusual high IRQ latencies.\n",
3385 printk("bttv%d: Lets try to catch the culpit red-handed ...\n",
3391 bttv_irq_next_video(struct bttv
*btv
, struct bttv_buffer_set
*set
)
3393 struct bttv_buffer
*item
;
3395 memset(set
,0,sizeof(*set
));
3397 /* capture request ? */
3398 if (!list_empty(&btv
->capture
)) {
3400 item
= list_entry(btv
->capture
.next
, struct bttv_buffer
, vb
.queue
);
3401 if (V4L2_FIELD_HAS_TOP(item
->vb
.field
))
3403 if (V4L2_FIELD_HAS_BOTTOM(item
->vb
.field
))
3406 /* capture request for other field ? */
3407 if (!V4L2_FIELD_HAS_BOTH(item
->vb
.field
) &&
3408 (item
->vb
.queue
.next
!= &btv
->capture
)) {
3409 item
= list_entry(item
->vb
.queue
.next
, struct bttv_buffer
, vb
.queue
);
3410 if (!V4L2_FIELD_HAS_BOTH(item
->vb
.field
)) {
3411 if (NULL
== set
->top
&&
3412 V4L2_FIELD_TOP
== item
->vb
.field
) {
3415 if (NULL
== set
->bottom
&&
3416 V4L2_FIELD_BOTTOM
== item
->vb
.field
) {
3419 if (NULL
!= set
->top
&& NULL
!= set
->bottom
)
3425 /* screen overlay ? */
3426 if (NULL
!= btv
->screen
) {
3427 if (V4L2_FIELD_HAS_BOTH(btv
->screen
->vb
.field
)) {
3428 if (NULL
== set
->top
&& NULL
== set
->bottom
) {
3429 set
->top
= btv
->screen
;
3430 set
->bottom
= btv
->screen
;
3433 if (V4L2_FIELD_TOP
== btv
->screen
->vb
.field
&&
3435 set
->top
= btv
->screen
;
3437 if (V4L2_FIELD_BOTTOM
== btv
->screen
->vb
.field
&&
3438 NULL
== set
->bottom
) {
3439 set
->bottom
= btv
->screen
;
3444 dprintk("bttv%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
3445 btv
->c
.nr
,set
->top
, set
->bottom
,
3446 btv
->screen
,set
->frame_irq
,set
->top_irq
);
3451 bttv_irq_wakeup_video(struct bttv
*btv
, struct bttv_buffer_set
*wakeup
,
3452 struct bttv_buffer_set
*curr
, unsigned int state
)
3456 do_gettimeofday(&ts
);
3458 if (wakeup
->top
== wakeup
->bottom
) {
3459 if (NULL
!= wakeup
->top
&& curr
->top
!= wakeup
->top
) {
3461 printk("bttv%d: wakeup: both=%p\n",btv
->c
.nr
,wakeup
->top
);
3462 wakeup
->top
->vb
.ts
= ts
;
3463 wakeup
->top
->vb
.field_count
= btv
->field_count
;
3464 wakeup
->top
->vb
.state
= state
;
3465 wake_up(&wakeup
->top
->vb
.done
);
3468 if (NULL
!= wakeup
->top
&& curr
->top
!= wakeup
->top
) {
3470 printk("bttv%d: wakeup: top=%p\n",btv
->c
.nr
,wakeup
->top
);
3471 wakeup
->top
->vb
.ts
= ts
;
3472 wakeup
->top
->vb
.field_count
= btv
->field_count
;
3473 wakeup
->top
->vb
.state
= state
;
3474 wake_up(&wakeup
->top
->vb
.done
);
3476 if (NULL
!= wakeup
->bottom
&& curr
->bottom
!= wakeup
->bottom
) {
3478 printk("bttv%d: wakeup: bottom=%p\n",btv
->c
.nr
,wakeup
->bottom
);
3479 wakeup
->bottom
->vb
.ts
= ts
;
3480 wakeup
->bottom
->vb
.field_count
= btv
->field_count
;
3481 wakeup
->bottom
->vb
.state
= state
;
3482 wake_up(&wakeup
->bottom
->vb
.done
);
3488 bttv_irq_wakeup_vbi(struct bttv
*btv
, struct bttv_buffer
*wakeup
,
3496 do_gettimeofday(&ts
);
3498 wakeup
->vb
.field_count
= btv
->field_count
;
3499 wakeup
->vb
.state
= state
;
3500 wake_up(&wakeup
->vb
.done
);
3503 static void bttv_irq_timeout(unsigned long data
)
3505 struct bttv
*btv
= (struct bttv
*)data
;
3506 struct bttv_buffer_set old
,new;
3507 struct bttv_buffer
*ovbi
;
3508 struct bttv_buffer
*item
;
3509 unsigned long flags
;
3512 printk(KERN_INFO
"bttv%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
3513 btv
->c
.nr
, btv
->framedrop
, btv
->irq_me
, btv
->irq_total
,
3514 btread(BT848_RISC_COUNT
));
3515 bttv_print_irqbits(btread(BT848_INT_STAT
),0);
3519 spin_lock_irqsave(&btv
->s_lock
,flags
);
3521 /* deactivate stuff */
3522 memset(&new,0,sizeof(new));
3528 bttv_buffer_activate_video(btv
, &new);
3529 bttv_buffer_activate_vbi(btv
, NULL
);
3530 bttv_set_dma(btv
, 0);
3533 bttv_irq_wakeup_video(btv
, &old
, &new, STATE_ERROR
);
3534 bttv_irq_wakeup_vbi(btv
, ovbi
, STATE_ERROR
);
3536 /* cancel all outstanding capture / vbi requests */
3537 while (!list_empty(&btv
->capture
)) {
3538 item
= list_entry(btv
->capture
.next
, struct bttv_buffer
, vb
.queue
);
3539 list_del(&item
->vb
.queue
);
3540 item
->vb
.state
= STATE_ERROR
;
3541 wake_up(&item
->vb
.done
);
3543 while (!list_empty(&btv
->vcapture
)) {
3544 item
= list_entry(btv
->vcapture
.next
, struct bttv_buffer
, vb
.queue
);
3545 list_del(&item
->vb
.queue
);
3546 item
->vb
.state
= STATE_ERROR
;
3547 wake_up(&item
->vb
.done
);
3551 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
3555 bttv_irq_wakeup_top(struct bttv
*btv
)
3557 struct bttv_buffer
*wakeup
= btv
->curr
.top
;
3562 spin_lock(&btv
->s_lock
);
3563 btv
->curr
.top_irq
= 0;
3564 btv
->curr
.top
= NULL
;
3565 bttv_risc_hook(btv
, RISC_SLOT_O_FIELD
, NULL
, 0);
3567 do_gettimeofday(&wakeup
->vb
.ts
);
3568 wakeup
->vb
.field_count
= btv
->field_count
;
3569 wakeup
->vb
.state
= STATE_DONE
;
3570 wake_up(&wakeup
->vb
.done
);
3571 spin_unlock(&btv
->s_lock
);
3574 static inline int is_active(struct btcx_riscmem
*risc
, u32 rc
)
3578 if (rc
> risc
->dma
+ risc
->size
)
3584 bttv_irq_switch_video(struct bttv
*btv
)
3586 struct bttv_buffer_set
new;
3587 struct bttv_buffer_set old
;
3590 spin_lock(&btv
->s_lock
);
3592 /* new buffer set */
3593 bttv_irq_next_video(btv
, &new);
3594 rc
= btread(BT848_RISC_COUNT
);
3595 if ((btv
->curr
.top
&& is_active(&btv
->curr
.top
->top
, rc
)) ||
3596 (btv
->curr
.bottom
&& is_active(&btv
->curr
.bottom
->bottom
, rc
))) {
3599 bttv_irq_debug_low_latency(btv
, rc
);
3600 spin_unlock(&btv
->s_lock
);
3607 btv
->loop_irq
&= ~1;
3608 bttv_buffer_activate_video(btv
, &new);
3609 bttv_set_dma(btv
, 0);
3612 if (UNSET
!= btv
->new_input
) {
3613 video_mux(btv
,btv
->new_input
);
3614 btv
->new_input
= UNSET
;
3617 /* wake up finished buffers */
3618 bttv_irq_wakeup_video(btv
, &old
, &new, STATE_DONE
);
3619 spin_unlock(&btv
->s_lock
);
3623 bttv_irq_switch_vbi(struct bttv
*btv
)
3625 struct bttv_buffer
*new = NULL
;
3626 struct bttv_buffer
*old
;
3629 spin_lock(&btv
->s_lock
);
3631 if (!list_empty(&btv
->vcapture
))
3632 new = list_entry(btv
->vcapture
.next
, struct bttv_buffer
, vb
.queue
);
3635 rc
= btread(BT848_RISC_COUNT
);
3636 if (NULL
!= old
&& (is_active(&old
->top
, rc
) ||
3637 is_active(&old
->bottom
, rc
))) {
3640 bttv_irq_debug_low_latency(btv
, rc
);
3641 spin_unlock(&btv
->s_lock
);
3647 btv
->loop_irq
&= ~4;
3648 bttv_buffer_activate_vbi(btv
, new);
3649 bttv_set_dma(btv
, 0);
3651 bttv_irq_wakeup_vbi(btv
, old
, STATE_DONE
);
3652 spin_unlock(&btv
->s_lock
);
3655 static irqreturn_t
bttv_irq(int irq
, void *dev_id
, struct pt_regs
* regs
)
3663 btv
=(struct bttv
*)dev_id
;
3666 /* get/clear interrupt status bits */
3667 stat
=btread(BT848_INT_STAT
);
3668 astat
=stat
&btread(BT848_INT_MASK
);
3672 btwrite(stat
,BT848_INT_STAT
);
3674 /* get device status bits */
3675 dstat
=btread(BT848_DSTATUS
);
3678 printk(KERN_DEBUG
"bttv%d: irq loop=%d fc=%d "
3679 "riscs=%x, riscc=%08x, ",
3680 btv
->c
.nr
, count
, btv
->field_count
,
3681 stat
>>28, btread(BT848_RISC_COUNT
));
3682 bttv_print_irqbits(stat
,astat
);
3683 if (stat
& BT848_INT_HLOCK
)
3684 printk(" HLOC => %s", (dstat
& BT848_DSTATUS_HLOC
)
3686 if (stat
& BT848_INT_VPRES
)
3687 printk(" PRES => %s", (dstat
& BT848_DSTATUS_PRES
)
3689 if (stat
& BT848_INT_FMTCHG
)
3690 printk(" NUML => %s", (dstat
& BT848_DSTATUS_NUML
)
3695 if (astat
&BT848_INT_VSYNC
)
3698 if (astat
& BT848_INT_GPINT
) {
3699 wake_up(&btv
->gpioq
);
3700 bttv_gpio_irq(&btv
->c
);
3703 if (astat
& BT848_INT_I2CDONE
) {
3704 btv
->i2c_done
= stat
;
3705 wake_up(&btv
->i2c_queue
);
3708 if ((astat
& BT848_INT_RISCI
) && (stat
& (4<<28)))
3709 bttv_irq_switch_vbi(btv
);
3711 if ((astat
& BT848_INT_RISCI
) && (stat
& (2<<28)))
3712 bttv_irq_wakeup_top(btv
);
3714 if ((astat
& BT848_INT_RISCI
) && (stat
& (1<<28)))
3715 bttv_irq_switch_video(btv
);
3717 if ((astat
& BT848_INT_HLOCK
) && btv
->opt_automute
)
3720 if (astat
& (BT848_INT_SCERR
|BT848_INT_OCERR
)) {
3721 printk(KERN_INFO
"bttv%d: %s%s @ %08x,",btv
->c
.nr
,
3722 (astat
& BT848_INT_SCERR
) ? "SCERR" : "",
3723 (astat
& BT848_INT_OCERR
) ? "OCERR" : "",
3724 btread(BT848_RISC_COUNT
));
3725 bttv_print_irqbits(stat
,astat
);
3728 bttv_print_riscaddr(btv
);
3730 if (fdsr
&& astat
& BT848_INT_FDSR
) {
3731 printk(KERN_INFO
"bttv%d: FDSR @ %08x\n",
3732 btv
->c
.nr
,btread(BT848_RISC_COUNT
));
3734 bttv_print_riscaddr(btv
);
3739 btwrite(0, BT848_INT_MASK
);
3741 "bttv%d: IRQ lockup, cleared int mask [", btv
->c
.nr
);
3742 bttv_print_irqbits(stat
,astat
);
3749 return IRQ_RETVAL(handled
);
3753 /* ----------------------------------------------------------------------- */
3754 /* initialitation */
3756 static struct video_device
*vdev_init(struct bttv
*btv
,
3757 struct video_device
*template,
3760 struct video_device
*vfd
;
3762 vfd
= video_device_alloc();
3767 vfd
->dev
= &btv
->c
.pci
->dev
;
3768 vfd
->release
= video_device_release
;
3769 snprintf(vfd
->name
, sizeof(vfd
->name
), "BT%d%s %s (%s)",
3770 btv
->id
, (btv
->id
==848 && btv
->revision
==0x12) ? "A" : "",
3771 type
, bttv_tvcards
[btv
->c
.type
].name
);
3775 static void bttv_unregister_video(struct bttv
*btv
)
3777 if (btv
->video_dev
) {
3778 if (-1 != btv
->video_dev
->minor
)
3779 video_unregister_device(btv
->video_dev
);
3781 video_device_release(btv
->video_dev
);
3782 btv
->video_dev
= NULL
;
3785 if (-1 != btv
->vbi_dev
->minor
)
3786 video_unregister_device(btv
->vbi_dev
);
3788 video_device_release(btv
->vbi_dev
);
3789 btv
->vbi_dev
= NULL
;
3791 if (btv
->radio_dev
) {
3792 if (-1 != btv
->radio_dev
->minor
)
3793 video_unregister_device(btv
->radio_dev
);
3795 video_device_release(btv
->radio_dev
);
3796 btv
->radio_dev
= NULL
;
3800 /* register video4linux devices */
3801 static int __devinit
bttv_register_video(struct bttv
*btv
)
3803 if (no_overlay
<= 0) {
3804 bttv_video_template
.type
|= VID_TYPE_OVERLAY
;
3806 printk("bttv: Overlay support disabled.\n");
3810 btv
->video_dev
= vdev_init(btv
, &bttv_video_template
, "video");
3811 if (NULL
== btv
->video_dev
)
3813 if (video_register_device(btv
->video_dev
,VFL_TYPE_GRABBER
,video_nr
)<0)
3815 printk(KERN_INFO
"bttv%d: registered device video%d\n",
3816 btv
->c
.nr
,btv
->video_dev
->minor
& 0x1f);
3817 video_device_create_file(btv
->video_dev
, &class_device_attr_card
);
3820 btv
->vbi_dev
= vdev_init(btv
, &bttv_vbi_template
, "vbi");
3821 if (NULL
== btv
->vbi_dev
)
3823 if (video_register_device(btv
->vbi_dev
,VFL_TYPE_VBI
,vbi_nr
)<0)
3825 printk(KERN_INFO
"bttv%d: registered device vbi%d\n",
3826 btv
->c
.nr
,btv
->vbi_dev
->minor
& 0x1f);
3828 if (!btv
->has_radio
)
3831 btv
->radio_dev
= vdev_init(btv
, &radio_template
, "radio");
3832 if (NULL
== btv
->radio_dev
)
3834 if (video_register_device(btv
->radio_dev
, VFL_TYPE_RADIO
,radio_nr
)<0)
3836 printk(KERN_INFO
"bttv%d: registered device radio%d\n",
3837 btv
->c
.nr
,btv
->radio_dev
->minor
& 0x1f);
3843 bttv_unregister_video(btv
);
3848 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
3849 /* response on cards with no firmware is not enabled by OF */
3850 static void pci_set_command(struct pci_dev
*dev
)
3852 #if defined(__powerpc__)
3855 pci_read_config_dword(dev
, PCI_COMMAND
, &cmd
);
3856 cmd
= (cmd
| PCI_COMMAND_MEMORY
);
3857 pci_write_config_dword(dev
, PCI_COMMAND
, cmd
);
3861 static int __devinit
bttv_probe(struct pci_dev
*dev
,
3862 const struct pci_device_id
*pci_id
)
3868 if (bttv_num
== BTTV_MAX
)
3870 printk(KERN_INFO
"bttv: Bt8xx card found (%d).\n", bttv_num
);
3871 btv
=&bttvs
[bttv_num
];
3872 memset(btv
,0,sizeof(*btv
));
3873 btv
->c
.nr
= bttv_num
;
3874 sprintf(btv
->c
.name
,"bttv%d",btv
->c
.nr
);
3876 /* initialize structs / fill in defaults */
3877 init_MUTEX(&btv
->lock
);
3878 init_MUTEX(&btv
->reslock
);
3879 spin_lock_init(&btv
->s_lock
);
3880 spin_lock_init(&btv
->gpio_lock
);
3881 init_waitqueue_head(&btv
->gpioq
);
3882 init_waitqueue_head(&btv
->i2c_queue
);
3883 INIT_LIST_HEAD(&btv
->c
.subs
);
3884 INIT_LIST_HEAD(&btv
->capture
);
3885 INIT_LIST_HEAD(&btv
->vcapture
);
3886 v4l2_prio_init(&btv
->prio
);
3888 init_timer(&btv
->timeout
);
3889 btv
->timeout
.function
= bttv_irq_timeout
;
3890 btv
->timeout
.data
= (unsigned long)btv
;
3893 btv
->tuner_type
= UNSET
;
3894 btv
->pinnacle_id
= UNSET
;
3895 btv
->new_input
= UNSET
;
3897 btv
->has_radio
=radio
[btv
->c
.nr
];
3899 /* pci stuff (init, get irq/mmio, ... */
3901 btv
->id
= dev
->device
;
3902 if (pci_enable_device(dev
)) {
3903 printk(KERN_WARNING
"bttv%d: Can't enable device.\n",
3907 if (pci_set_dma_mask(dev
, DMA_32BIT_MASK
)) {
3908 printk(KERN_WARNING
"bttv%d: No suitable DMA available.\n",
3912 if (!request_mem_region(pci_resource_start(dev
,0),
3913 pci_resource_len(dev
,0),
3915 printk(KERN_WARNING
"bttv%d: can't request iomem (0x%lx).\n",
3916 btv
->c
.nr
, pci_resource_start(dev
,0));
3919 pci_set_master(dev
);
3920 pci_set_command(dev
);
3921 pci_set_drvdata(dev
,btv
);
3923 pci_read_config_byte(dev
, PCI_CLASS_REVISION
, &btv
->revision
);
3924 pci_read_config_byte(dev
, PCI_LATENCY_TIMER
, &lat
);
3925 printk(KERN_INFO
"bttv%d: Bt%d (rev %d) at %s, ",
3926 bttv_num
,btv
->id
, btv
->revision
, pci_name(dev
));
3927 printk("irq: %d, latency: %d, mmio: 0x%lx\n",
3928 btv
->c
.pci
->irq
, lat
, pci_resource_start(dev
,0));
3931 btv
->bt848_mmio
=ioremap(pci_resource_start(dev
,0), 0x1000);
3932 if (NULL
== ioremap(pci_resource_start(dev
,0), 0x1000)) {
3933 printk("bttv%d: ioremap() failed\n", btv
->c
.nr
);
3941 /* disable irqs, register irq handler */
3942 btwrite(0, BT848_INT_MASK
);
3943 result
= request_irq(btv
->c
.pci
->irq
, bttv_irq
,
3944 SA_SHIRQ
| SA_INTERRUPT
,btv
->c
.name
,(void *)btv
);
3946 printk(KERN_ERR
"bttv%d: can't get IRQ %d\n",
3947 bttv_num
,btv
->c
.pci
->irq
);
3951 if (0 != bttv_handle_chipset(btv
)) {
3956 /* init options from insmod args */
3957 btv
->opt_combfilter
= combfilter
;
3958 btv
->opt_lumafilter
= lumafilter
;
3959 btv
->opt_automute
= automute
;
3960 btv
->opt_chroma_agc
= chroma_agc
;
3961 btv
->opt_adc_crush
= adc_crush
;
3962 btv
->opt_vcr_hack
= vcr_hack
;
3963 btv
->opt_whitecrush_upper
= whitecrush_upper
;
3964 btv
->opt_whitecrush_lower
= whitecrush_lower
;
3965 btv
->opt_uv_ratio
= uv_ratio
;
3966 btv
->opt_full_luma_range
= full_luma_range
;
3967 btv
->opt_coring
= coring
;
3969 /* fill struct bttv with some useful defaults */
3970 btv
->init
.btv
= btv
;
3971 btv
->init
.ov
.w
.width
= 320;
3972 btv
->init
.ov
.w
.height
= 240;
3973 btv
->init
.fmt
= format_by_palette(VIDEO_PALETTE_RGB24
);
3974 btv
->init
.width
= 320;
3975 btv
->init
.height
= 240;
3976 btv
->init
.lines
= 16;
3979 /* initialize hardware */
3981 bttv_gpio_tracking(btv
,"pre-init");
3983 bttv_risc_init_main(btv
);
3987 btwrite(0x00, BT848_GPIO_REG_INP
);
3988 btwrite(0x00, BT848_GPIO_OUT_EN
);
3990 bttv_gpio_tracking(btv
,"init");
3992 /* needs to be done before i2c is registered */
3993 bttv_init_card1(btv
);
3995 /* register i2c + gpio */
3998 /* some card-specific stuff (needs working i2c) */
3999 bttv_init_card2(btv
);
4002 /* register video4linux + input */
4003 if (!bttv_tvcards
[btv
->c
.type
].no_video
) {
4004 bttv_register_video(btv
);
4005 bt848_bright(btv
,32768);
4006 bt848_contrast(btv
,32768);
4007 bt848_hue(btv
,32768);
4008 bt848_sat(btv
,32768);
4009 audio_mux(btv
,AUDIO_MUTE
);
4013 /* add subdevices */
4014 if (btv
->has_remote
)
4015 bttv_sub_add_device(&btv
->c
, "remote");
4016 if (bttv_tvcards
[btv
->c
.type
].has_dvb
)
4017 bttv_sub_add_device(&btv
->c
, "dvb");
4019 /* everything is fine */
4024 free_irq(btv
->c
.pci
->irq
,btv
);
4027 if (btv
->bt848_mmio
)
4028 iounmap(btv
->bt848_mmio
);
4029 release_mem_region(pci_resource_start(btv
->c
.pci
,0),
4030 pci_resource_len(btv
->c
.pci
,0));
4031 pci_set_drvdata(dev
,NULL
);
4035 static void __devexit
bttv_remove(struct pci_dev
*pci_dev
)
4037 struct bttv
*btv
= pci_get_drvdata(pci_dev
);
4040 printk("bttv%d: unloading\n",btv
->c
.nr
);
4042 /* shutdown everything (DMA+IRQs) */
4043 btand(~15, BT848_GPIO_DMA_CTL
);
4044 btwrite(0, BT848_INT_MASK
);
4045 btwrite(~0x0, BT848_INT_STAT
);
4046 btwrite(0x0, BT848_GPIO_OUT_EN
);
4048 bttv_gpio_tracking(btv
,"cleanup");
4050 /* tell gpio modules we are leaving ... */
4052 wake_up(&btv
->gpioq
);
4053 bttv_sub_del_devices(&btv
->c
);
4055 /* unregister i2c_bus + input */
4058 /* unregister video4linux */
4059 bttv_unregister_video(btv
);
4061 /* free allocated memory */
4062 btcx_riscmem_free(btv
->c
.pci
,&btv
->main
);
4064 /* free ressources */
4065 free_irq(btv
->c
.pci
->irq
,btv
);
4066 iounmap(btv
->bt848_mmio
);
4067 release_mem_region(pci_resource_start(btv
->c
.pci
,0),
4068 pci_resource_len(btv
->c
.pci
,0));
4070 pci_set_drvdata(pci_dev
, NULL
);
4074 static int bttv_suspend(struct pci_dev
*pci_dev
, pm_message_t state
)
4076 struct bttv
*btv
= pci_get_drvdata(pci_dev
);
4077 struct bttv_buffer_set idle
;
4078 unsigned long flags
;
4080 dprintk("bttv%d: suspend %d\n", btv
->c
.nr
, state
.event
);
4082 /* stop dma + irqs */
4083 spin_lock_irqsave(&btv
->s_lock
,flags
);
4084 memset(&idle
, 0, sizeof(idle
));
4085 btv
->state
.video
= btv
->curr
;
4086 btv
->state
.vbi
= btv
->cvbi
;
4087 btv
->state
.loop_irq
= btv
->loop_irq
;
4090 bttv_buffer_activate_video(btv
, &idle
);
4091 bttv_buffer_activate_vbi(btv
, NULL
);
4092 bttv_set_dma(btv
, 0);
4093 btwrite(0, BT848_INT_MASK
);
4094 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
4096 /* save bt878 state */
4097 btv
->state
.gpio_enable
= btread(BT848_GPIO_OUT_EN
);
4098 btv
->state
.gpio_data
= gpio_read();
4100 /* save pci state */
4101 pci_save_state(pci_dev
);
4102 if (0 != pci_set_power_state(pci_dev
, pci_choose_state(pci_dev
, state
))) {
4103 pci_disable_device(pci_dev
);
4104 btv
->state
.disabled
= 1;
4109 static int bttv_resume(struct pci_dev
*pci_dev
)
4111 struct bttv
*btv
= pci_get_drvdata(pci_dev
);
4112 unsigned long flags
;
4115 dprintk("bttv%d: resume\n", btv
->c
.nr
);
4117 /* restore pci state */
4118 if (btv
->state
.disabled
) {
4119 err
=pci_enable_device(pci_dev
);
4121 printk(KERN_WARNING
"bttv%d: Can't enable device.\n",
4125 btv
->state
.disabled
= 0;
4127 err
=pci_set_power_state(pci_dev
, PCI_D0
);
4129 pci_disable_device(pci_dev
);
4130 printk(KERN_WARNING
"bttv%d: Can't enable device.\n",
4132 btv
->state
.disabled
= 1;
4136 pci_restore_state(pci_dev
);
4138 /* restore bt878 state */
4139 bttv_reinit_bt848(btv
);
4140 gpio_inout(0xffffff, btv
->state
.gpio_enable
);
4141 gpio_write(btv
->state
.gpio_data
);
4144 spin_lock_irqsave(&btv
->s_lock
,flags
);
4145 btv
->curr
= btv
->state
.video
;
4146 btv
->cvbi
= btv
->state
.vbi
;
4147 btv
->loop_irq
= btv
->state
.loop_irq
;
4148 bttv_buffer_activate_video(btv
, &btv
->curr
);
4149 bttv_buffer_activate_vbi(btv
, btv
->cvbi
);
4150 bttv_set_dma(btv
, 0);
4151 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
4155 static struct pci_device_id bttv_pci_tbl
[] = {
4156 {PCI_VENDOR_ID_BROOKTREE
, PCI_DEVICE_ID_BT848
,
4157 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
4158 {PCI_VENDOR_ID_BROOKTREE
, PCI_DEVICE_ID_BT849
,
4159 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
4160 {PCI_VENDOR_ID_BROOKTREE
, PCI_DEVICE_ID_BT878
,
4161 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
4162 {PCI_VENDOR_ID_BROOKTREE
, PCI_DEVICE_ID_BT879
,
4163 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
4167 MODULE_DEVICE_TABLE(pci
, bttv_pci_tbl
);
4169 static struct pci_driver bttv_pci_driver
= {
4171 .id_table
= bttv_pci_tbl
,
4172 .probe
= bttv_probe
,
4173 .remove
= __devexit_p(bttv_remove
),
4174 .suspend
= bttv_suspend
,
4175 .resume
= bttv_resume
,
4178 static int bttv_init_module(void)
4182 printk(KERN_INFO
"bttv: driver version %d.%d.%d loaded\n",
4183 (BTTV_VERSION_CODE
>> 16) & 0xff,
4184 (BTTV_VERSION_CODE
>> 8) & 0xff,
4185 BTTV_VERSION_CODE
& 0xff);
4187 printk(KERN_INFO
"bttv: snapshot date %04d-%02d-%02d\n",
4188 SNAPSHOT
/10000, (SNAPSHOT
/100)%100, SNAPSHOT
%100);
4190 if (gbuffers
< 2 || gbuffers
> VIDEO_MAX_FRAME
)
4192 if (gbufsize
< 0 || gbufsize
> BTTV_MAX_FBUF
)
4193 gbufsize
= BTTV_MAX_FBUF
;
4194 gbufsize
= (gbufsize
+ PAGE_SIZE
- 1) & PAGE_MASK
;
4196 printk(KERN_INFO
"bttv: using %d buffers with %dk (%d pages) each for capture\n",
4197 gbuffers
, gbufsize
>> 10, gbufsize
>> PAGE_SHIFT
);
4199 bttv_check_chipset();
4201 bus_register(&bttv_sub_bus_type
);
4202 return pci_module_init(&bttv_pci_driver
);
4205 static void bttv_cleanup_module(void)
4207 pci_unregister_driver(&bttv_pci_driver
);
4208 bus_unregister(&bttv_sub_bus_type
);
4212 module_init(bttv_init_module
);
4213 module_exit(bttv_cleanup_module
);