3 bttv - Bt848 frame grabber driver
5 Copyright (C) 1996,97,98 Ralph Metzler <rjkm@thp.uni-koeln.de>
6 & Marcus Metzler <mocm@thp.uni-koeln.de>
7 (c) 1999-2002 Gerd Knorr <kraxel@bytesex.org>
9 some v4l2 code lines are taken from Justin's bttv2 driver which is
10 (c) 2000 Justin Schoeman <justin@suntiger.ee.up.ac.za>
13 (c) 2005-2006 Nickolay V. Shmyrev <nshmyrev@yandex.ru>
15 Fixes to be fully V4L2 compliant by
16 (c) 2006 Mauro Carvalho Chehab <mchehab@infradead.org>
18 Cropping and overscan support
19 Copyright (C) 2005, 2006 Michael H. Schimek <mschimek@gmx.at>
20 Sponsored by OPQ Systems AB
22 This program is free software; you can redistribute it and/or modify
23 it under the terms of the GNU General Public License as published by
24 the Free Software Foundation; either version 2 of the License, or
25 (at your option) any later version.
27 This program is distributed in the hope that it will be useful,
28 but WITHOUT ANY WARRANTY; without even the implied warranty of
29 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 GNU General Public License for more details.
32 You should have received a copy of the GNU General Public License
33 along with this program; if not, write to the Free Software
34 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
37 #include <linux/init.h>
38 #include <linux/module.h>
39 #include <linux/delay.h>
40 #include <linux/errno.h>
42 #include <linux/kernel.h>
43 #include <linux/sched.h>
44 #include <linux/smp_lock.h>
45 #include <linux/interrupt.h>
46 #include <linux/kdev_t.h>
48 #include <media/v4l2-common.h>
49 #include <media/v4l2-ioctl.h>
50 #include <media/tvaudio.h>
51 #include <media/msp3400.h>
53 #include <linux/dma-mapping.h>
56 #include <asm/byteorder.h>
58 #include <media/rds.h>
61 unsigned int bttv_num
; /* number of Bt848s in use */
62 struct bttv
*bttvs
[BTTV_MAX
];
64 unsigned int bttv_debug
;
65 unsigned int bttv_verbose
= 1;
66 unsigned int bttv_gpio
;
68 /* config variables */
70 static unsigned int bigendian
=1;
72 static unsigned int bigendian
;
74 static unsigned int radio
[BTTV_MAX
];
75 static unsigned int irq_debug
;
76 static unsigned int gbuffers
= 8;
77 static unsigned int gbufsize
= 0x208000;
78 static unsigned int reset_crop
= 1;
80 static int video_nr
[BTTV_MAX
] = { [0 ... (BTTV_MAX
-1)] = -1 };
81 static int radio_nr
[BTTV_MAX
] = { [0 ... (BTTV_MAX
-1)] = -1 };
82 static int vbi_nr
[BTTV_MAX
] = { [0 ... (BTTV_MAX
-1)] = -1 };
83 static int debug_latency
;
85 static unsigned int fdsr
;
88 static unsigned int combfilter
;
89 static unsigned int lumafilter
;
90 static unsigned int automute
= 1;
91 static unsigned int chroma_agc
;
92 static unsigned int adc_crush
= 1;
93 static unsigned int whitecrush_upper
= 0xCF;
94 static unsigned int whitecrush_lower
= 0x7F;
95 static unsigned int vcr_hack
;
96 static unsigned int irq_iswitch
;
97 static unsigned int uv_ratio
= 50;
98 static unsigned int full_luma_range
;
99 static unsigned int coring
;
101 /* API features (turn on/off stuff for testing) */
102 static unsigned int v4l2
= 1;
105 module_param(bttv_verbose
, int, 0644);
106 module_param(bttv_gpio
, int, 0644);
107 module_param(bttv_debug
, int, 0644);
108 module_param(irq_debug
, int, 0644);
109 module_param(debug_latency
, int, 0644);
111 module_param(fdsr
, int, 0444);
112 module_param(gbuffers
, int, 0444);
113 module_param(gbufsize
, int, 0444);
114 module_param(reset_crop
, int, 0444);
116 module_param(v4l2
, int, 0644);
117 module_param(bigendian
, int, 0644);
118 module_param(irq_iswitch
, int, 0644);
119 module_param(combfilter
, int, 0444);
120 module_param(lumafilter
, int, 0444);
121 module_param(automute
, int, 0444);
122 module_param(chroma_agc
, int, 0444);
123 module_param(adc_crush
, int, 0444);
124 module_param(whitecrush_upper
, int, 0444);
125 module_param(whitecrush_lower
, int, 0444);
126 module_param(vcr_hack
, int, 0444);
127 module_param(uv_ratio
, int, 0444);
128 module_param(full_luma_range
, int, 0444);
129 module_param(coring
, int, 0444);
131 module_param_array(radio
, int, NULL
, 0444);
132 module_param_array(video_nr
, int, NULL
, 0444);
133 module_param_array(radio_nr
, int, NULL
, 0444);
134 module_param_array(vbi_nr
, int, NULL
, 0444);
136 MODULE_PARM_DESC(radio
,"The TV card supports radio, default is 0 (no)");
137 MODULE_PARM_DESC(bigendian
,"byte order of the framebuffer, default is native endian");
138 MODULE_PARM_DESC(bttv_verbose
,"verbose startup messages, default is 1 (yes)");
139 MODULE_PARM_DESC(bttv_gpio
,"log gpio changes, default is 0 (no)");
140 MODULE_PARM_DESC(bttv_debug
,"debug messages, default is 0 (no)");
141 MODULE_PARM_DESC(irq_debug
,"irq handler debug messages, default is 0 (no)");
142 MODULE_PARM_DESC(gbuffers
,"number of capture buffers. range 2-32, default 8");
143 MODULE_PARM_DESC(gbufsize
,"size of the capture buffers, default is 0x208000");
144 MODULE_PARM_DESC(reset_crop
,"reset cropping parameters at open(), default "
145 "is 1 (yes) for compatibility with older applications");
146 MODULE_PARM_DESC(automute
,"mute audio on bad/missing video signal, default is 1 (yes)");
147 MODULE_PARM_DESC(chroma_agc
,"enables the AGC of chroma signal, default is 0 (no)");
148 MODULE_PARM_DESC(adc_crush
,"enables the luminance ADC crush, default is 1 (yes)");
149 MODULE_PARM_DESC(whitecrush_upper
,"sets the white crush upper value, default is 207");
150 MODULE_PARM_DESC(whitecrush_lower
,"sets the white crush lower value, default is 127");
151 MODULE_PARM_DESC(vcr_hack
,"enables the VCR hack (improves synch on poor VCR tapes), default is 0 (no)");
152 MODULE_PARM_DESC(irq_iswitch
,"switch inputs in irq handler");
153 MODULE_PARM_DESC(uv_ratio
,"ratio between u and v gains, default is 50");
154 MODULE_PARM_DESC(full_luma_range
,"use the full luma range, default is 0 (no)");
155 MODULE_PARM_DESC(coring
,"set the luma coring level, default is 0 (no)");
156 MODULE_PARM_DESC(video_nr
, "video device numbers");
157 MODULE_PARM_DESC(vbi_nr
, "vbi device numbers");
158 MODULE_PARM_DESC(radio_nr
, "radio device numbers");
160 MODULE_DESCRIPTION("bttv - v4l/v4l2 driver module for bt848/878 based cards");
161 MODULE_AUTHOR("Ralph Metzler & Marcus Metzler & Gerd Knorr");
162 MODULE_LICENSE("GPL");
164 /* ----------------------------------------------------------------------- */
167 static ssize_t
show_card(struct device
*cd
,
168 struct device_attribute
*attr
, char *buf
)
170 struct video_device
*vfd
= container_of(cd
, struct video_device
, dev
);
171 struct bttv
*btv
= video_get_drvdata(vfd
);
172 return sprintf(buf
, "%d\n", btv
? btv
->c
.type
: UNSET
);
174 static DEVICE_ATTR(card
, S_IRUGO
, show_card
, NULL
);
176 /* ----------------------------------------------------------------------- */
177 /* dvb auto-load setup */
178 #if defined(CONFIG_MODULES) && defined(MODULE)
179 static void request_module_async(struct work_struct
*work
)
181 request_module("dvb-bt8xx");
184 static void request_modules(struct bttv
*dev
)
186 INIT_WORK(&dev
->request_module_wk
, request_module_async
);
187 schedule_work(&dev
->request_module_wk
);
190 #define request_modules(dev)
191 #endif /* CONFIG_MODULES */
194 /* ----------------------------------------------------------------------- */
197 /* special timing tables from conexant... */
198 static u8 SRAM_Table
[][60] =
200 /* PAL digital input over GPIO[7:0] */
202 45, // 45 bytes following
203 0x36,0x11,0x01,0x00,0x90,0x02,0x05,0x10,0x04,0x16,
204 0x12,0x05,0x11,0x00,0x04,0x12,0xC0,0x00,0x31,0x00,
205 0x06,0x51,0x08,0x03,0x89,0x08,0x07,0xC0,0x44,0x00,
206 0x81,0x01,0x01,0xA9,0x0D,0x02,0x02,0x50,0x03,0x37,
207 0x37,0x00,0xAF,0x21,0x00
209 /* NTSC digital input over GPIO[7:0] */
211 51, // 51 bytes following
212 0x0C,0xC0,0x00,0x00,0x90,0x02,0x03,0x10,0x03,0x06,
213 0x10,0x04,0x12,0x12,0x05,0x02,0x13,0x04,0x19,0x00,
214 0x04,0x39,0x00,0x06,0x59,0x08,0x03,0x83,0x08,0x07,
215 0x03,0x50,0x00,0xC0,0x40,0x00,0x86,0x01,0x01,0xA6,
216 0x0D,0x02,0x03,0x11,0x01,0x05,0x37,0x00,0xAC,0x21,
219 // TGB_NTSC392 // quartzsight
220 // This table has been modified to be used for Fusion Rev D
222 0x2A, // size of table = 42
223 0x06, 0x08, 0x04, 0x0a, 0xc0, 0x00, 0x18, 0x08, 0x03, 0x24,
224 0x08, 0x07, 0x02, 0x90, 0x02, 0x08, 0x10, 0x04, 0x0c, 0x10,
225 0x05, 0x2c, 0x11, 0x04, 0x55, 0x48, 0x00, 0x05, 0x50, 0x00,
226 0xbf, 0x0c, 0x02, 0x2f, 0x3d, 0x00, 0x2f, 0x3f, 0x00, 0xc3,
231 /* minhdelayx1 first video pixel we can capture on a line and
232 hdelayx1 start of active video, both relative to rising edge of
233 /HRESET pulse (0H) in 1 / fCLKx1.
234 swidth width of active video and
235 totalwidth total line width, both in 1 / fCLKx1.
236 sqwidth total line width in square pixels.
237 vdelay start of active video in 2 * field lines relative to
238 trailing edge of /VRESET pulse (VDELAY register).
239 sheight height of active video in 2 * field lines.
240 videostart0 ITU-R frame line number of the line corresponding
241 to vdelay in the first field. */
242 #define CROPCAP(minhdelayx1, hdelayx1, swidth, totalwidth, sqwidth, \
243 vdelay, sheight, videostart0) \
244 .cropcap.bounds.left = minhdelayx1, \
245 /* * 2 because vertically we count field lines times two, */ \
246 /* e.g. 23 * 2 to 23 * 2 + 576 in PAL-BGHI defrect. */ \
247 .cropcap.bounds.top = (videostart0) * 2 - (vdelay) + MIN_VDELAY, \
248 /* 4 is a safety margin at the end of the line. */ \
249 .cropcap.bounds.width = (totalwidth) - (minhdelayx1) - 4, \
250 .cropcap.bounds.height = (sheight) + (vdelay) - MIN_VDELAY, \
251 .cropcap.defrect.left = hdelayx1, \
252 .cropcap.defrect.top = (videostart0) * 2, \
253 .cropcap.defrect.width = swidth, \
254 .cropcap.defrect.height = sheight, \
255 .cropcap.pixelaspect.numerator = totalwidth, \
256 .cropcap.pixelaspect.denominator = sqwidth,
258 const struct bttv_tvnorm bttv_tvnorms
[] = {
260 /* max. active video is actually 922, but 924 is divisible by 4 and 3! */
261 /* actually, max active PAL with HSCALE=0 is 948, NTSC is 768 - nil */
263 .v4l2_id
= V4L2_STD_PAL
,
271 .iform
= (BT848_IFORM_PAL_BDGHI
|BT848_IFORM_XT1
),
272 .scaledtwidth
= 1135,
276 .vbipack
= 255, /* min (2048 / 4, 0x1ff) & 0xff */
278 /* ITU-R frame line number of the first VBI line
279 we can capture, of the first and second field.
280 The last line is determined by cropcap.bounds. */
281 .vbistart
= { 7, 320 },
282 CROPCAP(/* minhdelayx1 */ 68,
284 /* Should be (768 * 1135 + 944 / 2) / 944.
285 cropcap.defrect is used for image width
286 checks, so we keep the old value 924. */
288 /* totalwidth */ 1135,
292 /* videostart0 */ 23)
293 /* bt878 (and bt848?) can capture another
294 line below active video. */
295 .cropcap
.bounds
.height
= (576 + 2) + 0x20 - 2,
297 .v4l2_id
= V4L2_STD_NTSC_M
| V4L2_STD_NTSC_M_KR
,
305 .iform
= (BT848_IFORM_NTSC
|BT848_IFORM_XT0
),
310 .vbipack
= 144, /* min (1600 / 4, 0x1ff) & 0xff */
312 .vbistart
= { 10, 273 },
313 CROPCAP(/* minhdelayx1 */ 68,
315 /* Should be (640 * 910 + 780 / 2) / 780? */
317 /* totalwidth */ 910,
321 /* videostart0 */ 23)
323 .v4l2_id
= V4L2_STD_SECAM
,
331 .iform
= (BT848_IFORM_SECAM
|BT848_IFORM_XT1
),
332 .scaledtwidth
= 1135,
337 .sram
= 0, /* like PAL, correct? */
338 .vbistart
= { 7, 320 },
339 CROPCAP(/* minhdelayx1 */ 68,
342 /* totalwidth */ 1135,
346 /* videostart0 */ 23)
348 .v4l2_id
= V4L2_STD_PAL_Nc
,
356 .iform
= (BT848_IFORM_PAL_NC
|BT848_IFORM_XT0
),
363 .vbistart
= { 7, 320 },
364 CROPCAP(/* minhdelayx1 */ 68,
366 /* swidth */ (640 * 910 + 780 / 2) / 780,
367 /* totalwidth */ 910,
371 /* videostart0 */ 23)
373 .v4l2_id
= V4L2_STD_PAL_M
,
381 .iform
= (BT848_IFORM_PAL_M
|BT848_IFORM_XT0
),
388 .vbistart
= { 10, 273 },
389 CROPCAP(/* minhdelayx1 */ 68,
391 /* swidth */ (640 * 910 + 780 / 2) / 780,
392 /* totalwidth */ 910,
396 /* videostart0 */ 23)
398 .v4l2_id
= V4L2_STD_PAL_N
,
406 .iform
= (BT848_IFORM_PAL_N
|BT848_IFORM_XT1
),
413 .vbistart
= { 7, 320 },
414 CROPCAP(/* minhdelayx1 */ 68,
416 /* swidth */ (768 * 1135 + 944 / 2) / 944,
417 /* totalwidth */ 1135,
421 /* videostart0 */ 23)
423 .v4l2_id
= V4L2_STD_NTSC_M_JP
,
431 .iform
= (BT848_IFORM_NTSC_J
|BT848_IFORM_XT0
),
438 .vbistart
= { 10, 273 },
439 CROPCAP(/* minhdelayx1 */ 68,
441 /* swidth */ (640 * 910 + 780 / 2) / 780,
442 /* totalwidth */ 910,
446 /* videostart0 */ 23)
448 /* that one hopefully works with the strange timing
449 * which video recorders produce when playing a NTSC
450 * tape on a PAL TV ... */
451 .v4l2_id
= V4L2_STD_PAL_60
,
459 .iform
= (BT848_IFORM_PAL_BDGHI
|BT848_IFORM_XT1
),
460 .scaledtwidth
= 1135,
467 .vbistart
= { 10, 273 },
468 CROPCAP(/* minhdelayx1 */ 68,
471 /* totalwidth */ 1135,
475 /* videostart0 */ 23)
478 static const unsigned int BTTV_TVNORMS
= ARRAY_SIZE(bttv_tvnorms
);
480 /* ----------------------------------------------------------------------- */
482 packed pixel formats must come first */
483 static const struct bttv_format formats
[] = {
485 .name
= "8 bpp, gray",
486 .fourcc
= V4L2_PIX_FMT_GREY
,
487 .btformat
= BT848_COLOR_FMT_Y8
,
489 .flags
= FORMAT_FLAGS_PACKED
,
491 .name
= "8 bpp, dithered color",
492 .fourcc
= V4L2_PIX_FMT_HI240
,
493 .btformat
= BT848_COLOR_FMT_RGB8
,
495 .flags
= FORMAT_FLAGS_PACKED
| FORMAT_FLAGS_DITHER
,
497 .name
= "15 bpp RGB, le",
498 .fourcc
= V4L2_PIX_FMT_RGB555
,
499 .btformat
= BT848_COLOR_FMT_RGB15
,
501 .flags
= FORMAT_FLAGS_PACKED
,
503 .name
= "15 bpp RGB, be",
504 .fourcc
= V4L2_PIX_FMT_RGB555X
,
505 .btformat
= BT848_COLOR_FMT_RGB15
,
506 .btswap
= 0x03, /* byteswap */
508 .flags
= FORMAT_FLAGS_PACKED
,
510 .name
= "16 bpp RGB, le",
511 .fourcc
= V4L2_PIX_FMT_RGB565
,
512 .btformat
= BT848_COLOR_FMT_RGB16
,
514 .flags
= FORMAT_FLAGS_PACKED
,
516 .name
= "16 bpp RGB, be",
517 .fourcc
= V4L2_PIX_FMT_RGB565X
,
518 .btformat
= BT848_COLOR_FMT_RGB16
,
519 .btswap
= 0x03, /* byteswap */
521 .flags
= FORMAT_FLAGS_PACKED
,
523 .name
= "24 bpp RGB, le",
524 .fourcc
= V4L2_PIX_FMT_BGR24
,
525 .btformat
= BT848_COLOR_FMT_RGB24
,
527 .flags
= FORMAT_FLAGS_PACKED
,
529 .name
= "32 bpp RGB, le",
530 .fourcc
= V4L2_PIX_FMT_BGR32
,
531 .btformat
= BT848_COLOR_FMT_RGB32
,
533 .flags
= FORMAT_FLAGS_PACKED
,
535 .name
= "32 bpp RGB, be",
536 .fourcc
= V4L2_PIX_FMT_RGB32
,
537 .btformat
= BT848_COLOR_FMT_RGB32
,
538 .btswap
= 0x0f, /* byte+word swap */
540 .flags
= FORMAT_FLAGS_PACKED
,
542 .name
= "4:2:2, packed, YUYV",
543 .fourcc
= V4L2_PIX_FMT_YUYV
,
544 .btformat
= BT848_COLOR_FMT_YUY2
,
546 .flags
= FORMAT_FLAGS_PACKED
,
548 .name
= "4:2:2, packed, YUYV",
549 .fourcc
= V4L2_PIX_FMT_YUYV
,
550 .btformat
= BT848_COLOR_FMT_YUY2
,
552 .flags
= FORMAT_FLAGS_PACKED
,
554 .name
= "4:2:2, packed, UYVY",
555 .fourcc
= V4L2_PIX_FMT_UYVY
,
556 .btformat
= BT848_COLOR_FMT_YUY2
,
557 .btswap
= 0x03, /* byteswap */
559 .flags
= FORMAT_FLAGS_PACKED
,
561 .name
= "4:2:2, planar, Y-Cb-Cr",
562 .fourcc
= V4L2_PIX_FMT_YUV422P
,
563 .btformat
= BT848_COLOR_FMT_YCrCb422
,
565 .flags
= FORMAT_FLAGS_PLANAR
,
569 .name
= "4:2:0, planar, Y-Cb-Cr",
570 .fourcc
= V4L2_PIX_FMT_YUV420
,
571 .btformat
= BT848_COLOR_FMT_YCrCb422
,
573 .flags
= FORMAT_FLAGS_PLANAR
,
577 .name
= "4:2:0, planar, Y-Cr-Cb",
578 .fourcc
= V4L2_PIX_FMT_YVU420
,
579 .btformat
= BT848_COLOR_FMT_YCrCb422
,
581 .flags
= FORMAT_FLAGS_PLANAR
| FORMAT_FLAGS_CrCb
,
585 .name
= "4:1:1, planar, Y-Cb-Cr",
586 .fourcc
= V4L2_PIX_FMT_YUV411P
,
587 .btformat
= BT848_COLOR_FMT_YCrCb411
,
589 .flags
= FORMAT_FLAGS_PLANAR
,
593 .name
= "4:1:0, planar, Y-Cb-Cr",
594 .fourcc
= V4L2_PIX_FMT_YUV410
,
595 .btformat
= BT848_COLOR_FMT_YCrCb411
,
597 .flags
= FORMAT_FLAGS_PLANAR
,
601 .name
= "4:1:0, planar, Y-Cr-Cb",
602 .fourcc
= V4L2_PIX_FMT_YVU410
,
603 .btformat
= BT848_COLOR_FMT_YCrCb411
,
605 .flags
= FORMAT_FLAGS_PLANAR
| FORMAT_FLAGS_CrCb
,
609 .name
= "raw scanlines",
611 .btformat
= BT848_COLOR_FMT_RAW
,
613 .flags
= FORMAT_FLAGS_RAW
,
616 static const unsigned int FORMATS
= ARRAY_SIZE(formats
);
618 /* ----------------------------------------------------------------------- */
620 #define V4L2_CID_PRIVATE_CHROMA_AGC (V4L2_CID_PRIVATE_BASE + 0)
621 #define V4L2_CID_PRIVATE_COMBFILTER (V4L2_CID_PRIVATE_BASE + 1)
622 #define V4L2_CID_PRIVATE_AUTOMUTE (V4L2_CID_PRIVATE_BASE + 2)
623 #define V4L2_CID_PRIVATE_LUMAFILTER (V4L2_CID_PRIVATE_BASE + 3)
624 #define V4L2_CID_PRIVATE_AGC_CRUSH (V4L2_CID_PRIVATE_BASE + 4)
625 #define V4L2_CID_PRIVATE_VCR_HACK (V4L2_CID_PRIVATE_BASE + 5)
626 #define V4L2_CID_PRIVATE_WHITECRUSH_UPPER (V4L2_CID_PRIVATE_BASE + 6)
627 #define V4L2_CID_PRIVATE_WHITECRUSH_LOWER (V4L2_CID_PRIVATE_BASE + 7)
628 #define V4L2_CID_PRIVATE_UV_RATIO (V4L2_CID_PRIVATE_BASE + 8)
629 #define V4L2_CID_PRIVATE_FULL_LUMA_RANGE (V4L2_CID_PRIVATE_BASE + 9)
630 #define V4L2_CID_PRIVATE_CORING (V4L2_CID_PRIVATE_BASE + 10)
631 #define V4L2_CID_PRIVATE_LASTP1 (V4L2_CID_PRIVATE_BASE + 11)
633 static const struct v4l2_queryctrl no_ctl
= {
635 .flags
= V4L2_CTRL_FLAG_DISABLED
,
637 static const struct v4l2_queryctrl bttv_ctls
[] = {
640 .id
= V4L2_CID_BRIGHTNESS
,
641 .name
= "Brightness",
645 .default_value
= 32768,
646 .type
= V4L2_CTRL_TYPE_INTEGER
,
648 .id
= V4L2_CID_CONTRAST
,
653 .default_value
= 32768,
654 .type
= V4L2_CTRL_TYPE_INTEGER
,
656 .id
= V4L2_CID_SATURATION
,
657 .name
= "Saturation",
661 .default_value
= 32768,
662 .type
= V4L2_CTRL_TYPE_INTEGER
,
669 .default_value
= 32768,
670 .type
= V4L2_CTRL_TYPE_INTEGER
,
674 .id
= V4L2_CID_AUDIO_MUTE
,
678 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
680 .id
= V4L2_CID_AUDIO_VOLUME
,
685 .default_value
= 65535,
686 .type
= V4L2_CTRL_TYPE_INTEGER
,
688 .id
= V4L2_CID_AUDIO_BALANCE
,
693 .default_value
= 32768,
694 .type
= V4L2_CTRL_TYPE_INTEGER
,
696 .id
= V4L2_CID_AUDIO_BASS
,
701 .default_value
= 32768,
702 .type
= V4L2_CTRL_TYPE_INTEGER
,
704 .id
= V4L2_CID_AUDIO_TREBLE
,
709 .default_value
= 32768,
710 .type
= V4L2_CTRL_TYPE_INTEGER
,
712 /* --- private --- */
714 .id
= V4L2_CID_PRIVATE_CHROMA_AGC
,
715 .name
= "chroma agc",
718 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
720 .id
= V4L2_CID_PRIVATE_COMBFILTER
,
721 .name
= "combfilter",
724 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
726 .id
= V4L2_CID_PRIVATE_AUTOMUTE
,
730 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
732 .id
= V4L2_CID_PRIVATE_LUMAFILTER
,
733 .name
= "luma decimation filter",
736 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
738 .id
= V4L2_CID_PRIVATE_AGC_CRUSH
,
742 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
744 .id
= V4L2_CID_PRIVATE_VCR_HACK
,
748 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
750 .id
= V4L2_CID_PRIVATE_WHITECRUSH_UPPER
,
751 .name
= "whitecrush upper",
755 .default_value
= 0xCF,
756 .type
= V4L2_CTRL_TYPE_INTEGER
,
758 .id
= V4L2_CID_PRIVATE_WHITECRUSH_LOWER
,
759 .name
= "whitecrush lower",
763 .default_value
= 0x7F,
764 .type
= V4L2_CTRL_TYPE_INTEGER
,
766 .id
= V4L2_CID_PRIVATE_UV_RATIO
,
772 .type
= V4L2_CTRL_TYPE_INTEGER
,
774 .id
= V4L2_CID_PRIVATE_FULL_LUMA_RANGE
,
775 .name
= "full luma range",
778 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
780 .id
= V4L2_CID_PRIVATE_CORING
,
786 .type
= V4L2_CTRL_TYPE_INTEGER
,
793 static const struct v4l2_queryctrl
*ctrl_by_id(int id
)
797 for (i
= 0; i
< ARRAY_SIZE(bttv_ctls
); i
++)
798 if (bttv_ctls
[i
].id
== id
)
804 /* ----------------------------------------------------------------------- */
805 /* resource management */
808 RESOURCE_ allocated by freed by
810 VIDEO_READ bttv_read 1) bttv_read 2)
812 VIDEO_STREAM VIDIOC_STREAMON VIDIOC_STREAMOFF
813 VIDIOC_QBUF 1) bttv_release
816 OVERLAY VIDIOCCAPTURE on VIDIOCCAPTURE off
817 VIDIOC_OVERLAY on VIDIOC_OVERLAY off
820 VBI VIDIOC_STREAMON VIDIOC_STREAMOFF
821 VIDIOC_QBUF 1) bttv_release
822 bttv_read, bttv_poll 1) 4)
824 1) The resource must be allocated when we enter buffer prepare functions
825 and remain allocated while buffers are in the DMA queue.
826 2) This is a single frame read.
827 3) VIDIOC_S_FBUF and VIDIOC_S_FMT (OVERLAY) still work when
828 RESOURCE_OVERLAY is allocated.
829 4) This is a continuous read, implies VIDIOC_STREAMON.
831 Note this driver permits video input and standard changes regardless if
832 resources are allocated.
835 #define VBI_RESOURCES (RESOURCE_VBI)
836 #define VIDEO_RESOURCES (RESOURCE_VIDEO_READ | \
837 RESOURCE_VIDEO_STREAM | \
841 int check_alloc_btres(struct bttv
*btv
, struct bttv_fh
*fh
, int bit
)
843 int xbits
; /* mutual exclusive resources */
845 if (fh
->resources
& bit
)
846 /* have it already allocated */
850 if (bit
& (RESOURCE_VIDEO_READ
| RESOURCE_VIDEO_STREAM
))
851 xbits
|= RESOURCE_VIDEO_READ
| RESOURCE_VIDEO_STREAM
;
854 mutex_lock(&btv
->lock
);
855 if (btv
->resources
& xbits
) {
856 /* no, someone else uses it */
860 if ((bit
& VIDEO_RESOURCES
)
861 && 0 == (btv
->resources
& VIDEO_RESOURCES
)) {
862 /* Do crop - use current, don't - use default parameters. */
863 __s32 top
= btv
->crop
[!!fh
->do_crop
].rect
.top
;
865 if (btv
->vbi_end
> top
)
868 /* We cannot capture the same line as video and VBI data.
869 Claim scan lines crop[].rect.top to bottom. */
870 btv
->crop_start
= top
;
871 } else if (bit
& VBI_RESOURCES
) {
872 __s32 end
= fh
->vbi_fmt
.end
;
874 if (end
> btv
->crop_start
)
877 /* Claim scan lines above fh->vbi_fmt.end. */
881 /* it's free, grab it */
882 fh
->resources
|= bit
;
883 btv
->resources
|= bit
;
884 mutex_unlock(&btv
->lock
);
888 mutex_unlock(&btv
->lock
);
893 int check_btres(struct bttv_fh
*fh
, int bit
)
895 return (fh
->resources
& bit
);
899 int locked_btres(struct bttv
*btv
, int bit
)
901 return (btv
->resources
& bit
);
904 /* Call with btv->lock down. */
906 disclaim_vbi_lines(struct bttv
*btv
)
911 /* Call with btv->lock down. */
913 disclaim_video_lines(struct bttv
*btv
)
915 const struct bttv_tvnorm
*tvnorm
;
918 tvnorm
= &bttv_tvnorms
[btv
->tvnorm
];
919 btv
->crop_start
= tvnorm
->cropcap
.bounds
.top
920 + tvnorm
->cropcap
.bounds
.height
;
922 /* VBI capturing ends at VDELAY, start of video capturing, no
923 matter how many lines the VBI RISC program expects. When video
924 capturing is off, it shall no longer "preempt" VBI capturing,
925 so we set VDELAY to maximum. */
926 crop
= btread(BT848_E_CROP
) | 0xc0;
927 btwrite(crop
, BT848_E_CROP
);
928 btwrite(0xfe, BT848_E_VDELAY_LO
);
929 btwrite(crop
, BT848_O_CROP
);
930 btwrite(0xfe, BT848_O_VDELAY_LO
);
934 void free_btres(struct bttv
*btv
, struct bttv_fh
*fh
, int bits
)
936 if ((fh
->resources
& bits
) != bits
) {
937 /* trying to free ressources not allocated by us ... */
938 printk("bttv: BUG! (btres)\n");
940 mutex_lock(&btv
->lock
);
941 fh
->resources
&= ~bits
;
942 btv
->resources
&= ~bits
;
944 bits
= btv
->resources
;
946 if (0 == (bits
& VIDEO_RESOURCES
))
947 disclaim_video_lines(btv
);
949 if (0 == (bits
& VBI_RESOURCES
))
950 disclaim_vbi_lines(btv
);
952 mutex_unlock(&btv
->lock
);
955 /* ----------------------------------------------------------------------- */
956 /* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC */
958 /* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C
959 PLL_X = Reference pre-divider (0=1, 1=2)
960 PLL_C = Post divider (0=6, 1=4)
961 PLL_I = Integer input
962 PLL_F = Fractional input
964 F_input = 28.636363 MHz:
965 PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0
968 static void set_pll_freq(struct bttv
*btv
, unsigned int fin
, unsigned int fout
)
970 unsigned char fl
, fh
, fi
;
972 /* prevent overflows */
985 btwrite(fl
, BT848_PLL_F_LO
);
986 btwrite(fh
, BT848_PLL_F_HI
);
987 btwrite(fi
|BT848_PLL_X
, BT848_PLL_XCI
);
990 static void set_pll(struct bttv
*btv
)
994 if (!btv
->pll
.pll_crystal
)
997 if (btv
->pll
.pll_ofreq
== btv
->pll
.pll_current
) {
998 dprintk("bttv%d: PLL: no change required\n",btv
->c
.nr
);
1002 if (btv
->pll
.pll_ifreq
== btv
->pll
.pll_ofreq
) {
1004 if (btv
->pll
.pll_current
== 0)
1006 bttv_printk(KERN_INFO
"bttv%d: PLL can sleep, using XTAL (%d).\n",
1007 btv
->c
.nr
,btv
->pll
.pll_ifreq
);
1008 btwrite(0x00,BT848_TGCTRL
);
1009 btwrite(0x00,BT848_PLL_XCI
);
1010 btv
->pll
.pll_current
= 0;
1014 bttv_printk(KERN_INFO
"bttv%d: PLL: %d => %d ",btv
->c
.nr
,
1015 btv
->pll
.pll_ifreq
, btv
->pll
.pll_ofreq
);
1016 set_pll_freq(btv
, btv
->pll
.pll_ifreq
, btv
->pll
.pll_ofreq
);
1018 for (i
=0; i
<10; i
++) {
1019 /* Let other people run while the PLL stabilizes */
1023 if (btread(BT848_DSTATUS
) & BT848_DSTATUS_PLOCK
) {
1024 btwrite(0,BT848_DSTATUS
);
1026 btwrite(0x08,BT848_TGCTRL
);
1027 btv
->pll
.pll_current
= btv
->pll
.pll_ofreq
;
1028 bttv_printk(" ok\n");
1032 btv
->pll
.pll_current
= -1;
1033 bttv_printk("failed\n");
1037 /* used to switch between the bt848's analog/digital video capture modes */
1038 static void bt848A_set_timing(struct bttv
*btv
)
1041 int table_idx
= bttv_tvnorms
[btv
->tvnorm
].sram
;
1042 int fsc
= bttv_tvnorms
[btv
->tvnorm
].Fsc
;
1044 if (btv
->input
== btv
->dig
) {
1045 dprintk("bttv%d: load digital timing table (table_idx=%d)\n",
1046 btv
->c
.nr
,table_idx
);
1048 /* timing change...reset timing generator address */
1049 btwrite(0x00, BT848_TGCTRL
);
1050 btwrite(0x02, BT848_TGCTRL
);
1051 btwrite(0x00, BT848_TGCTRL
);
1053 len
=SRAM_Table
[table_idx
][0];
1054 for(i
= 1; i
<= len
; i
++)
1055 btwrite(SRAM_Table
[table_idx
][i
],BT848_TGLB
);
1056 btv
->pll
.pll_ofreq
= 27000000;
1059 btwrite(0x11, BT848_TGCTRL
);
1060 btwrite(0x41, BT848_DVSIF
);
1062 btv
->pll
.pll_ofreq
= fsc
;
1064 btwrite(0x0, BT848_DVSIF
);
1068 /* ----------------------------------------------------------------------- */
1070 static void bt848_bright(struct bttv
*btv
, int bright
)
1074 // printk("bttv: set bright: %d\n",bright); // DEBUG
1075 btv
->bright
= bright
;
1077 /* We want -128 to 127 we get 0-65535 */
1078 value
= (bright
>> 8) - 128;
1079 btwrite(value
& 0xff, BT848_BRIGHT
);
1082 static void bt848_hue(struct bttv
*btv
, int hue
)
1089 value
= (hue
>> 8) - 128;
1090 btwrite(value
& 0xff, BT848_HUE
);
1093 static void bt848_contrast(struct bttv
*btv
, int cont
)
1097 btv
->contrast
= cont
;
1100 value
= (cont
>> 7);
1101 hibit
= (value
>> 6) & 4;
1102 btwrite(value
& 0xff, BT848_CONTRAST_LO
);
1103 btaor(hibit
, ~4, BT848_E_CONTROL
);
1104 btaor(hibit
, ~4, BT848_O_CONTROL
);
1107 static void bt848_sat(struct bttv
*btv
, int color
)
1109 int val_u
,val_v
,hibits
;
1111 btv
->saturation
= color
;
1113 /* 0-511 for the color */
1114 val_u
= ((color
* btv
->opt_uv_ratio
) / 50) >> 7;
1115 val_v
= (((color
* (100 - btv
->opt_uv_ratio
) / 50) >>7)*180L)/254;
1116 hibits
= (val_u
>> 7) & 2;
1117 hibits
|= (val_v
>> 8) & 1;
1118 btwrite(val_u
& 0xff, BT848_SAT_U_LO
);
1119 btwrite(val_v
& 0xff, BT848_SAT_V_LO
);
1120 btaor(hibits
, ~3, BT848_E_CONTROL
);
1121 btaor(hibits
, ~3, BT848_O_CONTROL
);
1124 /* ----------------------------------------------------------------------- */
1127 video_mux(struct bttv
*btv
, unsigned int input
)
1131 if (input
>= bttv_tvcards
[btv
->c
.type
].video_inputs
)
1134 /* needed by RemoteVideo MX */
1135 mask2
= bttv_tvcards
[btv
->c
.type
].gpiomask2
;
1137 gpio_inout(mask2
,mask2
);
1139 if (input
== btv
->svhs
) {
1140 btor(BT848_CONTROL_COMP
, BT848_E_CONTROL
);
1141 btor(BT848_CONTROL_COMP
, BT848_O_CONTROL
);
1143 btand(~BT848_CONTROL_COMP
, BT848_E_CONTROL
);
1144 btand(~BT848_CONTROL_COMP
, BT848_O_CONTROL
);
1146 mux
= bttv_muxsel(btv
, input
);
1147 btaor(mux
<<5, ~(3<<5), BT848_IFORM
);
1148 dprintk(KERN_DEBUG
"bttv%d: video mux: input=%d mux=%d\n",
1149 btv
->c
.nr
,input
,mux
);
1151 /* card specific hook */
1152 if(bttv_tvcards
[btv
->c
.type
].muxsel_hook
)
1153 bttv_tvcards
[btv
->c
.type
].muxsel_hook (btv
, input
);
1157 static char *audio_modes
[] = {
1158 "audio: tuner", "audio: radio", "audio: extern",
1159 "audio: intern", "audio: mute"
1163 audio_mux(struct bttv
*btv
, int input
, int mute
)
1165 int gpio_val
, signal
;
1166 struct v4l2_control ctrl
;
1168 gpio_inout(bttv_tvcards
[btv
->c
.type
].gpiomask
,
1169 bttv_tvcards
[btv
->c
.type
].gpiomask
);
1170 signal
= btread(BT848_DSTATUS
) & BT848_DSTATUS_HLOC
;
1176 mute
= mute
|| (btv
->opt_automute
&& !signal
&& !btv
->radio_user
);
1179 gpio_val
= bttv_tvcards
[btv
->c
.type
].gpiomute
;
1181 gpio_val
= bttv_tvcards
[btv
->c
.type
].gpiomux
[input
];
1183 switch (btv
->c
.type
) {
1184 case BTTV_BOARD_VOODOOTV_FM
:
1185 case BTTV_BOARD_VOODOOTV_200
:
1186 gpio_val
= bttv_tda9880_setnorm(btv
, gpio_val
);
1190 gpio_bits(bttv_tvcards
[btv
->c
.type
].gpiomask
, gpio_val
);
1194 bttv_gpio_tracking(btv
, audio_modes
[mute
? 4 : input
]);
1198 ctrl
.id
= V4L2_CID_AUDIO_MUTE
;
1199 ctrl
.value
= btv
->mute
;
1200 bttv_call_all(btv
, core
, s_ctrl
, &ctrl
);
1201 if (btv
->sd_msp34xx
) {
1204 /* Note: the inputs tuner/radio/extern/intern are translated
1205 to msp routings. This assumes common behavior for all msp3400
1206 based TV cards. When this assumption fails, then the
1207 specific MSP routing must be added to the card table.
1208 For now this is sufficient. */
1210 case TVAUDIO_INPUT_RADIO
:
1211 in
= MSP_INPUT(MSP_IN_SCART2
, MSP_IN_TUNER1
,
1212 MSP_DSP_IN_SCART
, MSP_DSP_IN_SCART
);
1214 case TVAUDIO_INPUT_EXTERN
:
1215 in
= MSP_INPUT(MSP_IN_SCART1
, MSP_IN_TUNER1
,
1216 MSP_DSP_IN_SCART
, MSP_DSP_IN_SCART
);
1218 case TVAUDIO_INPUT_INTERN
:
1219 /* Yes, this is the same input as for RADIO. I doubt
1220 if this is ever used. The only board with an INTERN
1221 input is the BTTV_BOARD_AVERMEDIA98. I wonder how
1222 that was tested. My guess is that the whole INTERN
1223 input does not work. */
1224 in
= MSP_INPUT(MSP_IN_SCART2
, MSP_IN_TUNER1
,
1225 MSP_DSP_IN_SCART
, MSP_DSP_IN_SCART
);
1227 case TVAUDIO_INPUT_TUNER
:
1229 /* This is the only card that uses TUNER2, and afaik,
1230 is the only difference between the VOODOOTV_FM
1232 if (btv
->c
.type
== BTTV_BOARD_VOODOOTV_200
)
1233 in
= MSP_INPUT(MSP_IN_SCART1
, MSP_IN_TUNER2
, \
1234 MSP_DSP_IN_TUNER
, MSP_DSP_IN_TUNER
);
1236 in
= MSP_INPUT_DEFAULT
;
1239 v4l2_subdev_call(btv
->sd_msp34xx
, audio
, s_routing
,
1240 in
, MSP_OUTPUT_DEFAULT
, 0);
1242 if (btv
->sd_tvaudio
) {
1243 v4l2_subdev_call(btv
->sd_tvaudio
, audio
, s_routing
,
1250 audio_mute(struct bttv
*btv
, int mute
)
1252 return audio_mux(btv
, btv
->audio
, mute
);
1256 audio_input(struct bttv
*btv
, int input
)
1258 return audio_mux(btv
, input
, btv
->mute
);
1262 bttv_crop_calc_limits(struct bttv_crop
*c
)
1264 /* Scale factor min. 1:1, max. 16:1. Min. image size
1265 48 x 32. Scaled width must be a multiple of 4. */
1268 /* For bug compatibility with VIDIOCGCAP and image
1269 size checks in earlier driver versions. */
1270 c
->min_scaled_width
= 48;
1271 c
->min_scaled_height
= 32;
1273 c
->min_scaled_width
=
1274 (max(48, c
->rect
.width
>> 4) + 3) & ~3;
1275 c
->min_scaled_height
=
1276 max(32, c
->rect
.height
>> 4);
1279 c
->max_scaled_width
= c
->rect
.width
& ~3;
1280 c
->max_scaled_height
= c
->rect
.height
;
1284 bttv_crop_reset(struct bttv_crop
*c
, unsigned int norm
)
1286 c
->rect
= bttv_tvnorms
[norm
].cropcap
.defrect
;
1287 bttv_crop_calc_limits(c
);
1290 /* Call with btv->lock down. */
1292 set_tvnorm(struct bttv
*btv
, unsigned int norm
)
1294 const struct bttv_tvnorm
*tvnorm
;
1297 BUG_ON(norm
>= BTTV_TVNORMS
);
1298 BUG_ON(btv
->tvnorm
>= BTTV_TVNORMS
);
1300 tvnorm
= &bttv_tvnorms
[norm
];
1302 if (!memcmp(&bttv_tvnorms
[btv
->tvnorm
].cropcap
, &tvnorm
->cropcap
,
1303 sizeof (tvnorm
->cropcap
))) {
1304 bttv_crop_reset(&btv
->crop
[0], norm
);
1305 btv
->crop
[1] = btv
->crop
[0]; /* current = default */
1307 if (0 == (btv
->resources
& VIDEO_RESOURCES
)) {
1308 btv
->crop_start
= tvnorm
->cropcap
.bounds
.top
1309 + tvnorm
->cropcap
.bounds
.height
;
1315 btwrite(tvnorm
->adelay
, BT848_ADELAY
);
1316 btwrite(tvnorm
->bdelay
, BT848_BDELAY
);
1317 btaor(tvnorm
->iform
,~(BT848_IFORM_NORM
|BT848_IFORM_XTBOTH
),
1319 btwrite(tvnorm
->vbipack
, BT848_VBI_PACK_SIZE
);
1320 btwrite(1, BT848_VBI_PACK_DEL
);
1321 bt848A_set_timing(btv
);
1323 switch (btv
->c
.type
) {
1324 case BTTV_BOARD_VOODOOTV_FM
:
1325 case BTTV_BOARD_VOODOOTV_200
:
1326 bttv_tda9880_setnorm(btv
, gpio_read());
1329 id
= tvnorm
->v4l2_id
;
1330 bttv_call_all(btv
, core
, s_std
, id
);
1335 /* Call with btv->lock down. */
1337 set_input(struct bttv
*btv
, unsigned int input
, unsigned int norm
)
1339 unsigned long flags
;
1343 spin_lock_irqsave(&btv
->s_lock
,flags
);
1344 if (btv
->curr
.frame_irq
) {
1345 /* active capture -> delayed input switch */
1346 btv
->new_input
= input
;
1348 video_mux(btv
,input
);
1350 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
1352 video_mux(btv
,input
);
1354 audio_input(btv
, (btv
->tuner_type
!= TUNER_ABSENT
&& input
== 0) ?
1355 TVAUDIO_INPUT_TUNER
: TVAUDIO_INPUT_EXTERN
);
1356 set_tvnorm(btv
, norm
);
1359 static void init_irqreg(struct bttv
*btv
)
1362 btwrite(0xfffffUL
, BT848_INT_STAT
);
1364 if (bttv_tvcards
[btv
->c
.type
].no_video
) {
1366 btwrite(BT848_INT_I2CDONE
,
1370 btwrite((btv
->triton1
) |
1371 (btv
->gpioirq
? BT848_INT_GPINT
: 0) |
1373 (fdsr
? BT848_INT_FDSR
: 0) |
1374 BT848_INT_RISCI
| BT848_INT_OCERR
|
1375 BT848_INT_FMTCHG
|BT848_INT_HLOCK
|
1381 static void init_bt848(struct bttv
*btv
)
1385 if (bttv_tvcards
[btv
->c
.type
].no_video
) {
1386 /* very basic init only */
1391 btwrite(0x00, BT848_CAP_CTL
);
1392 btwrite(BT848_COLOR_CTL_GAMMA
, BT848_COLOR_CTL
);
1393 btwrite(BT848_IFORM_XTAUTO
| BT848_IFORM_AUTO
, BT848_IFORM
);
1395 /* set planar and packed mode trigger points and */
1396 /* set rising edge of inverted GPINTR pin as irq trigger */
1397 btwrite(BT848_GPIO_DMA_CTL_PKTP_32
|
1398 BT848_GPIO_DMA_CTL_PLTP1_16
|
1399 BT848_GPIO_DMA_CTL_PLTP23_16
|
1400 BT848_GPIO_DMA_CTL_GPINTC
|
1401 BT848_GPIO_DMA_CTL_GPINTI
,
1402 BT848_GPIO_DMA_CTL
);
1404 val
= btv
->opt_chroma_agc
? BT848_SCLOOP_CAGC
: 0;
1405 btwrite(val
, BT848_E_SCLOOP
);
1406 btwrite(val
, BT848_O_SCLOOP
);
1408 btwrite(0x20, BT848_E_VSCALE_HI
);
1409 btwrite(0x20, BT848_O_VSCALE_HI
);
1410 btwrite(BT848_ADC_RESERVED
| (btv
->opt_adc_crush
? BT848_ADC_CRUSH
: 0),
1413 btwrite(whitecrush_upper
, BT848_WC_UP
);
1414 btwrite(whitecrush_lower
, BT848_WC_DOWN
);
1416 if (btv
->opt_lumafilter
) {
1417 btwrite(0, BT848_E_CONTROL
);
1418 btwrite(0, BT848_O_CONTROL
);
1420 btwrite(BT848_CONTROL_LDEC
, BT848_E_CONTROL
);
1421 btwrite(BT848_CONTROL_LDEC
, BT848_O_CONTROL
);
1424 bt848_bright(btv
, btv
->bright
);
1425 bt848_hue(btv
, btv
->hue
);
1426 bt848_contrast(btv
, btv
->contrast
);
1427 bt848_sat(btv
, btv
->saturation
);
1433 static void bttv_reinit_bt848(struct bttv
*btv
)
1435 unsigned long flags
;
1438 printk(KERN_INFO
"bttv%d: reset, reinitialize\n",btv
->c
.nr
);
1439 spin_lock_irqsave(&btv
->s_lock
,flags
);
1441 bttv_set_dma(btv
,0);
1442 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
1445 btv
->pll
.pll_current
= -1;
1446 set_input(btv
, btv
->input
, btv
->tvnorm
);
1449 static int bttv_g_ctrl(struct file
*file
, void *priv
,
1450 struct v4l2_control
*c
)
1452 struct bttv_fh
*fh
= priv
;
1453 struct bttv
*btv
= fh
->btv
;
1456 case V4L2_CID_BRIGHTNESS
:
1457 c
->value
= btv
->bright
;
1460 c
->value
= btv
->hue
;
1462 case V4L2_CID_CONTRAST
:
1463 c
->value
= btv
->contrast
;
1465 case V4L2_CID_SATURATION
:
1466 c
->value
= btv
->saturation
;
1469 case V4L2_CID_AUDIO_MUTE
:
1470 case V4L2_CID_AUDIO_VOLUME
:
1471 case V4L2_CID_AUDIO_BALANCE
:
1472 case V4L2_CID_AUDIO_BASS
:
1473 case V4L2_CID_AUDIO_TREBLE
:
1474 bttv_call_all(btv
, core
, g_ctrl
, c
);
1477 case V4L2_CID_PRIVATE_CHROMA_AGC
:
1478 c
->value
= btv
->opt_chroma_agc
;
1480 case V4L2_CID_PRIVATE_COMBFILTER
:
1481 c
->value
= btv
->opt_combfilter
;
1483 case V4L2_CID_PRIVATE_LUMAFILTER
:
1484 c
->value
= btv
->opt_lumafilter
;
1486 case V4L2_CID_PRIVATE_AUTOMUTE
:
1487 c
->value
= btv
->opt_automute
;
1489 case V4L2_CID_PRIVATE_AGC_CRUSH
:
1490 c
->value
= btv
->opt_adc_crush
;
1492 case V4L2_CID_PRIVATE_VCR_HACK
:
1493 c
->value
= btv
->opt_vcr_hack
;
1495 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER
:
1496 c
->value
= btv
->opt_whitecrush_upper
;
1498 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER
:
1499 c
->value
= btv
->opt_whitecrush_lower
;
1501 case V4L2_CID_PRIVATE_UV_RATIO
:
1502 c
->value
= btv
->opt_uv_ratio
;
1504 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE
:
1505 c
->value
= btv
->opt_full_luma_range
;
1507 case V4L2_CID_PRIVATE_CORING
:
1508 c
->value
= btv
->opt_coring
;
1516 static int bttv_s_ctrl(struct file
*file
, void *f
,
1517 struct v4l2_control
*c
)
1521 struct bttv_fh
*fh
= f
;
1522 struct bttv
*btv
= fh
->btv
;
1524 err
= v4l2_prio_check(&btv
->prio
, &fh
->prio
);
1529 case V4L2_CID_BRIGHTNESS
:
1530 bt848_bright(btv
, c
->value
);
1533 bt848_hue(btv
, c
->value
);
1535 case V4L2_CID_CONTRAST
:
1536 bt848_contrast(btv
, c
->value
);
1538 case V4L2_CID_SATURATION
:
1539 bt848_sat(btv
, c
->value
);
1541 case V4L2_CID_AUDIO_MUTE
:
1542 audio_mute(btv
, c
->value
);
1544 case V4L2_CID_AUDIO_VOLUME
:
1545 if (btv
->volume_gpio
)
1546 btv
->volume_gpio(btv
, c
->value
);
1548 bttv_call_all(btv
, core
, s_ctrl
, c
);
1550 case V4L2_CID_AUDIO_BALANCE
:
1551 case V4L2_CID_AUDIO_BASS
:
1552 case V4L2_CID_AUDIO_TREBLE
:
1553 bttv_call_all(btv
, core
, s_ctrl
, c
);
1556 case V4L2_CID_PRIVATE_CHROMA_AGC
:
1557 btv
->opt_chroma_agc
= c
->value
;
1558 val
= btv
->opt_chroma_agc
? BT848_SCLOOP_CAGC
: 0;
1559 btwrite(val
, BT848_E_SCLOOP
);
1560 btwrite(val
, BT848_O_SCLOOP
);
1562 case V4L2_CID_PRIVATE_COMBFILTER
:
1563 btv
->opt_combfilter
= c
->value
;
1565 case V4L2_CID_PRIVATE_LUMAFILTER
:
1566 btv
->opt_lumafilter
= c
->value
;
1567 if (btv
->opt_lumafilter
) {
1568 btand(~BT848_CONTROL_LDEC
, BT848_E_CONTROL
);
1569 btand(~BT848_CONTROL_LDEC
, BT848_O_CONTROL
);
1571 btor(BT848_CONTROL_LDEC
, BT848_E_CONTROL
);
1572 btor(BT848_CONTROL_LDEC
, BT848_O_CONTROL
);
1575 case V4L2_CID_PRIVATE_AUTOMUTE
:
1576 btv
->opt_automute
= c
->value
;
1578 case V4L2_CID_PRIVATE_AGC_CRUSH
:
1579 btv
->opt_adc_crush
= c
->value
;
1580 btwrite(BT848_ADC_RESERVED
|
1581 (btv
->opt_adc_crush
? BT848_ADC_CRUSH
: 0),
1584 case V4L2_CID_PRIVATE_VCR_HACK
:
1585 btv
->opt_vcr_hack
= c
->value
;
1587 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER
:
1588 btv
->opt_whitecrush_upper
= c
->value
;
1589 btwrite(c
->value
, BT848_WC_UP
);
1591 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER
:
1592 btv
->opt_whitecrush_lower
= c
->value
;
1593 btwrite(c
->value
, BT848_WC_DOWN
);
1595 case V4L2_CID_PRIVATE_UV_RATIO
:
1596 btv
->opt_uv_ratio
= c
->value
;
1597 bt848_sat(btv
, btv
->saturation
);
1599 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE
:
1600 btv
->opt_full_luma_range
= c
->value
;
1601 btaor((c
->value
<<7), ~BT848_OFORM_RANGE
, BT848_OFORM
);
1603 case V4L2_CID_PRIVATE_CORING
:
1604 btv
->opt_coring
= c
->value
;
1605 btaor((c
->value
<<5), ~BT848_OFORM_CORE32
, BT848_OFORM
);
1613 /* ----------------------------------------------------------------------- */
1615 void bttv_gpio_tracking(struct bttv
*btv
, char *comment
)
1617 unsigned int outbits
, data
;
1618 outbits
= btread(BT848_GPIO_OUT_EN
);
1619 data
= btread(BT848_GPIO_DATA
);
1620 printk(KERN_DEBUG
"bttv%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
1621 btv
->c
.nr
,outbits
,data
& outbits
, data
& ~outbits
, comment
);
1624 static void bttv_field_count(struct bttv
*btv
)
1632 /* start field counter */
1633 btor(BT848_INT_VSYNC
,BT848_INT_MASK
);
1635 /* stop field counter */
1636 btand(~BT848_INT_VSYNC
,BT848_INT_MASK
);
1637 btv
->field_count
= 0;
1641 static const struct bttv_format
*
1642 format_by_fourcc(int fourcc
)
1646 for (i
= 0; i
< FORMATS
; i
++) {
1647 if (-1 == formats
[i
].fourcc
)
1649 if (formats
[i
].fourcc
== fourcc
)
1655 /* ----------------------------------------------------------------------- */
1659 bttv_switch_overlay(struct bttv
*btv
, struct bttv_fh
*fh
,
1660 struct bttv_buffer
*new)
1662 struct bttv_buffer
*old
;
1663 unsigned long flags
;
1666 dprintk("switch_overlay: enter [new=%p]\n",new);
1668 new->vb
.state
= VIDEOBUF_DONE
;
1669 spin_lock_irqsave(&btv
->s_lock
,flags
);
1673 bttv_set_dma(btv
, 0x03);
1674 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
1676 dprintk("switch_overlay: old=%p state is %d\n",old
,old
->vb
.state
);
1677 bttv_dma_free(&fh
->cap
,btv
, old
);
1681 free_btres(btv
,fh
,RESOURCE_OVERLAY
);
1682 dprintk("switch_overlay: done\n");
1686 /* ----------------------------------------------------------------------- */
1687 /* video4linux (1) interface */
1689 static int bttv_prepare_buffer(struct videobuf_queue
*q
,struct bttv
*btv
,
1690 struct bttv_buffer
*buf
,
1691 const struct bttv_format
*fmt
,
1692 unsigned int width
, unsigned int height
,
1693 enum v4l2_field field
)
1695 struct bttv_fh
*fh
= q
->priv_data
;
1696 int redo_dma_risc
= 0;
1701 /* check settings */
1704 if (fmt
->btformat
== BT848_COLOR_FMT_RAW
) {
1706 height
= RAW_LINES
*2;
1707 if (width
*height
> buf
->vb
.bsize
)
1709 buf
->vb
.size
= buf
->vb
.bsize
;
1711 /* Make sure tvnorm and vbi_end remain consistent
1712 until we're done. */
1713 mutex_lock(&btv
->lock
);
1717 /* In this mode capturing always starts at defrect.top
1718 (default VDELAY), ignoring cropping parameters. */
1719 if (btv
->vbi_end
> bttv_tvnorms
[norm
].cropcap
.defrect
.top
) {
1720 mutex_unlock(&btv
->lock
);
1724 mutex_unlock(&btv
->lock
);
1726 c
.rect
= bttv_tvnorms
[norm
].cropcap
.defrect
;
1728 mutex_lock(&btv
->lock
);
1731 c
= btv
->crop
[!!fh
->do_crop
];
1733 mutex_unlock(&btv
->lock
);
1735 if (width
< c
.min_scaled_width
||
1736 width
> c
.max_scaled_width
||
1737 height
< c
.min_scaled_height
)
1741 case V4L2_FIELD_TOP
:
1742 case V4L2_FIELD_BOTTOM
:
1743 case V4L2_FIELD_ALTERNATE
:
1744 /* btv->crop counts frame lines. Max. scale
1745 factor is 16:1 for frames, 8:1 for fields. */
1746 if (height
* 2 > c
.max_scaled_height
)
1751 if (height
> c
.max_scaled_height
)
1756 buf
->vb
.size
= (width
* height
* fmt
->depth
) >> 3;
1757 if (0 != buf
->vb
.baddr
&& buf
->vb
.bsize
< buf
->vb
.size
)
1761 /* alloc + fill struct bttv_buffer (if changed) */
1762 if (buf
->vb
.width
!= width
|| buf
->vb
.height
!= height
||
1763 buf
->vb
.field
!= field
||
1764 buf
->tvnorm
!= norm
|| buf
->fmt
!= fmt
||
1765 buf
->crop
.top
!= c
.rect
.top
||
1766 buf
->crop
.left
!= c
.rect
.left
||
1767 buf
->crop
.width
!= c
.rect
.width
||
1768 buf
->crop
.height
!= c
.rect
.height
) {
1769 buf
->vb
.width
= width
;
1770 buf
->vb
.height
= height
;
1771 buf
->vb
.field
= field
;
1778 /* alloc risc memory */
1779 if (VIDEOBUF_NEEDS_INIT
== buf
->vb
.state
) {
1781 if (0 != (rc
= videobuf_iolock(q
,&buf
->vb
,&btv
->fbuf
)))
1786 if (0 != (rc
= bttv_buffer_risc(btv
,buf
)))
1789 buf
->vb
.state
= VIDEOBUF_PREPARED
;
1793 bttv_dma_free(q
,btv
,buf
);
1798 buffer_setup(struct videobuf_queue
*q
, unsigned int *count
, unsigned int *size
)
1800 struct bttv_fh
*fh
= q
->priv_data
;
1802 *size
= fh
->fmt
->depth
*fh
->width
*fh
->height
>> 3;
1805 while (*size
* *count
> gbuffers
* gbufsize
)
1811 buffer_prepare(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
,
1812 enum v4l2_field field
)
1814 struct bttv_buffer
*buf
= container_of(vb
,struct bttv_buffer
,vb
);
1815 struct bttv_fh
*fh
= q
->priv_data
;
1817 return bttv_prepare_buffer(q
,fh
->btv
, buf
, fh
->fmt
,
1818 fh
->width
, fh
->height
, field
);
1822 buffer_queue(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
)
1824 struct bttv_buffer
*buf
= container_of(vb
,struct bttv_buffer
,vb
);
1825 struct bttv_fh
*fh
= q
->priv_data
;
1826 struct bttv
*btv
= fh
->btv
;
1828 buf
->vb
.state
= VIDEOBUF_QUEUED
;
1829 list_add_tail(&buf
->vb
.queue
,&btv
->capture
);
1830 if (!btv
->curr
.frame_irq
) {
1832 bttv_set_dma(btv
, 0x03);
1836 static void buffer_release(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
)
1838 struct bttv_buffer
*buf
= container_of(vb
,struct bttv_buffer
,vb
);
1839 struct bttv_fh
*fh
= q
->priv_data
;
1841 bttv_dma_free(q
,fh
->btv
,buf
);
1844 static struct videobuf_queue_ops bttv_video_qops
= {
1845 .buf_setup
= buffer_setup
,
1846 .buf_prepare
= buffer_prepare
,
1847 .buf_queue
= buffer_queue
,
1848 .buf_release
= buffer_release
,
1851 static int bttv_s_std(struct file
*file
, void *priv
, v4l2_std_id
*id
)
1853 struct bttv_fh
*fh
= priv
;
1854 struct bttv
*btv
= fh
->btv
;
1858 err
= v4l2_prio_check(&btv
->prio
, &fh
->prio
);
1862 for (i
= 0; i
< BTTV_TVNORMS
; i
++)
1863 if (*id
& bttv_tvnorms
[i
].v4l2_id
)
1865 if (i
== BTTV_TVNORMS
)
1868 mutex_lock(&btv
->lock
);
1870 mutex_unlock(&btv
->lock
);
1875 static int bttv_querystd(struct file
*file
, void *f
, v4l2_std_id
*id
)
1877 struct bttv_fh
*fh
= f
;
1878 struct bttv
*btv
= fh
->btv
;
1880 if (btread(BT848_DSTATUS
) & BT848_DSTATUS_NUML
)
1881 *id
= V4L2_STD_625_50
;
1883 *id
= V4L2_STD_525_60
;
1887 static int bttv_enum_input(struct file
*file
, void *priv
,
1888 struct v4l2_input
*i
)
1890 struct bttv_fh
*fh
= priv
;
1891 struct bttv
*btv
= fh
->btv
;
1894 if (i
->index
>= bttv_tvcards
[btv
->c
.type
].video_inputs
)
1897 i
->type
= V4L2_INPUT_TYPE_CAMERA
;
1900 if (btv
->tuner_type
!= TUNER_ABSENT
&& i
->index
== 0) {
1901 sprintf(i
->name
, "Television");
1902 i
->type
= V4L2_INPUT_TYPE_TUNER
;
1904 } else if (i
->index
== btv
->svhs
) {
1905 sprintf(i
->name
, "S-Video");
1907 sprintf(i
->name
, "Composite%d", i
->index
);
1910 if (i
->index
== btv
->input
) {
1911 __u32 dstatus
= btread(BT848_DSTATUS
);
1912 if (0 == (dstatus
& BT848_DSTATUS_PRES
))
1913 i
->status
|= V4L2_IN_ST_NO_SIGNAL
;
1914 if (0 == (dstatus
& BT848_DSTATUS_HLOC
))
1915 i
->status
|= V4L2_IN_ST_NO_H_LOCK
;
1918 for (n
= 0; n
< BTTV_TVNORMS
; n
++)
1919 i
->std
|= bttv_tvnorms
[n
].v4l2_id
;
1924 static int bttv_g_input(struct file
*file
, void *priv
, unsigned int *i
)
1926 struct bttv_fh
*fh
= priv
;
1927 struct bttv
*btv
= fh
->btv
;
1933 static int bttv_s_input(struct file
*file
, void *priv
, unsigned int i
)
1935 struct bttv_fh
*fh
= priv
;
1936 struct bttv
*btv
= fh
->btv
;
1940 err
= v4l2_prio_check(&btv
->prio
, &fh
->prio
);
1944 if (i
> bttv_tvcards
[btv
->c
.type
].video_inputs
)
1947 mutex_lock(&btv
->lock
);
1948 set_input(btv
, i
, btv
->tvnorm
);
1949 mutex_unlock(&btv
->lock
);
1953 static int bttv_s_tuner(struct file
*file
, void *priv
,
1954 struct v4l2_tuner
*t
)
1956 struct bttv_fh
*fh
= priv
;
1957 struct bttv
*btv
= fh
->btv
;
1960 err
= v4l2_prio_check(&btv
->prio
, &fh
->prio
);
1964 if (btv
->tuner_type
== TUNER_ABSENT
)
1970 mutex_lock(&btv
->lock
);
1971 bttv_call_all(btv
, tuner
, s_tuner
, t
);
1973 if (btv
->audio_mode_gpio
)
1974 btv
->audio_mode_gpio(btv
, t
, 1);
1976 mutex_unlock(&btv
->lock
);
1981 static int bttv_g_frequency(struct file
*file
, void *priv
,
1982 struct v4l2_frequency
*f
)
1984 struct bttv_fh
*fh
= priv
;
1985 struct bttv
*btv
= fh
->btv
;
1988 err
= v4l2_prio_check(&btv
->prio
, &fh
->prio
);
1992 f
->type
= btv
->radio_user
? V4L2_TUNER_RADIO
: V4L2_TUNER_ANALOG_TV
;
1993 f
->frequency
= btv
->freq
;
1998 static int bttv_s_frequency(struct file
*file
, void *priv
,
1999 struct v4l2_frequency
*f
)
2001 struct bttv_fh
*fh
= priv
;
2002 struct bttv
*btv
= fh
->btv
;
2005 err
= v4l2_prio_check(&btv
->prio
, &fh
->prio
);
2009 if (unlikely(f
->tuner
!= 0))
2011 if (unlikely(f
->type
!= (btv
->radio_user
2012 ? V4L2_TUNER_RADIO
: V4L2_TUNER_ANALOG_TV
)))
2014 mutex_lock(&btv
->lock
);
2015 btv
->freq
= f
->frequency
;
2016 bttv_call_all(btv
, tuner
, s_frequency
, f
);
2017 if (btv
->has_matchbox
&& btv
->radio_user
)
2018 tea5757_set_freq(btv
, btv
->freq
);
2019 mutex_unlock(&btv
->lock
);
2023 static int bttv_log_status(struct file
*file
, void *f
)
2025 struct bttv_fh
*fh
= f
;
2026 struct bttv
*btv
= fh
->btv
;
2028 printk(KERN_INFO
"bttv%d: ======== START STATUS CARD #%d ========\n",
2029 btv
->c
.nr
, btv
->c
.nr
);
2030 bttv_call_all(btv
, core
, log_status
);
2031 printk(KERN_INFO
"bttv%d: ======== END STATUS CARD #%d ========\n",
2032 btv
->c
.nr
, btv
->c
.nr
);
2036 #ifdef CONFIG_VIDEO_ADV_DEBUG
2037 static int bttv_g_register(struct file
*file
, void *f
,
2038 struct v4l2_dbg_register
*reg
)
2040 struct bttv_fh
*fh
= f
;
2041 struct bttv
*btv
= fh
->btv
;
2043 if (!capable(CAP_SYS_ADMIN
))
2046 if (!v4l2_chip_match_host(®
->match
))
2049 /* bt848 has a 12-bit register space */
2051 reg
->val
= btread(reg
->reg
);
2057 static int bttv_s_register(struct file
*file
, void *f
,
2058 struct v4l2_dbg_register
*reg
)
2060 struct bttv_fh
*fh
= f
;
2061 struct bttv
*btv
= fh
->btv
;
2063 if (!capable(CAP_SYS_ADMIN
))
2066 if (!v4l2_chip_match_host(®
->match
))
2069 /* bt848 has a 12-bit register space */
2071 btwrite(reg
->val
, reg
->reg
);
2077 /* Given cropping boundaries b and the scaled width and height of a
2078 single field or frame, which must not exceed hardware limits, this
2079 function adjusts the cropping parameters c. */
2081 bttv_crop_adjust (struct bttv_crop
* c
,
2082 const struct v4l2_rect
* b
,
2085 enum v4l2_field field
)
2087 __s32 frame_height
= height
<< !V4L2_FIELD_HAS_BOTH(field
);
2091 if (width
< c
->min_scaled_width
) {
2092 /* Max. hor. scale factor 16:1. */
2093 c
->rect
.width
= width
* 16;
2094 } else if (width
> c
->max_scaled_width
) {
2095 /* Min. hor. scale factor 1:1. */
2096 c
->rect
.width
= width
;
2098 max_left
= b
->left
+ b
->width
- width
;
2099 max_left
= min(max_left
, (__s32
) MAX_HDELAY
);
2100 if (c
->rect
.left
> max_left
)
2101 c
->rect
.left
= max_left
;
2104 if (height
< c
->min_scaled_height
) {
2105 /* Max. vert. scale factor 16:1, single fields 8:1. */
2106 c
->rect
.height
= height
* 16;
2107 } else if (frame_height
> c
->max_scaled_height
) {
2108 /* Min. vert. scale factor 1:1.
2109 Top and height count field lines times two. */
2110 c
->rect
.height
= (frame_height
+ 1) & ~1;
2112 max_top
= b
->top
+ b
->height
- c
->rect
.height
;
2113 if (c
->rect
.top
> max_top
)
2114 c
->rect
.top
= max_top
;
2117 bttv_crop_calc_limits(c
);
2120 /* Returns an error if scaling to a frame or single field with the given
2121 width and height is not possible with the current cropping parameters
2122 and width aligned according to width_mask. If adjust_size is TRUE the
2123 function may adjust the width and/or height instead, rounding width
2124 to (width + width_bias) & width_mask. If adjust_crop is TRUE it may
2125 also adjust the current cropping parameters to get closer to the
2126 desired image size. */
2128 limit_scaled_size (struct bttv_fh
* fh
,
2131 enum v4l2_field field
,
2132 unsigned int width_mask
,
2133 unsigned int width_bias
,
2137 struct bttv
*btv
= fh
->btv
;
2138 const struct v4l2_rect
*b
;
2139 struct bttv_crop
*c
;
2146 BUG_ON((int) width_mask
>= 0 ||
2147 width_bias
>= (unsigned int) -width_mask
);
2149 /* Make sure tvnorm, vbi_end and the current cropping parameters
2150 remain consistent until we're done. */
2151 mutex_lock(&btv
->lock
);
2153 b
= &bttv_tvnorms
[btv
->tvnorm
].cropcap
.bounds
;
2155 /* Do crop - use current, don't - use default parameters. */
2156 c
= &btv
->crop
[!!fh
->do_crop
];
2161 && !locked_btres(btv
, VIDEO_RESOURCES
)) {
2165 /* We cannot scale up. When the scaled image is larger
2166 than crop.rect we adjust the crop.rect as required
2167 by the V4L2 spec, hence cropcap.bounds are our limit. */
2168 max_width
= min(b
->width
, (__s32
) MAX_HACTIVE
);
2169 max_height
= b
->height
;
2171 /* We cannot capture the same line as video and VBI data.
2172 Note btv->vbi_end is really a minimum, see
2173 bttv_vbi_try_fmt(). */
2174 if (btv
->vbi_end
> b
->top
) {
2175 max_height
-= btv
->vbi_end
- b
->top
;
2177 if (min_height
> max_height
)
2182 if (btv
->vbi_end
> c
->rect
.top
)
2185 min_width
= c
->min_scaled_width
;
2186 min_height
= c
->min_scaled_height
;
2187 max_width
= c
->max_scaled_width
;
2188 max_height
= c
->max_scaled_height
;
2193 min_width
= (min_width
- width_mask
- 1) & width_mask
;
2194 max_width
= max_width
& width_mask
;
2196 /* Max. scale factor is 16:1 for frames, 8:1 for fields. */
2197 min_height
= min_height
;
2198 /* Min. scale factor is 1:1. */
2199 max_height
>>= !V4L2_FIELD_HAS_BOTH(field
);
2202 *width
= clamp(*width
, min_width
, max_width
);
2203 *height
= clamp(*height
, min_height
, max_height
);
2205 /* Round after clamping to avoid overflow. */
2206 *width
= (*width
+ width_bias
) & width_mask
;
2209 bttv_crop_adjust(c
, b
, *width
, *height
, field
);
2211 if (btv
->vbi_end
> c
->rect
.top
) {
2212 /* Move the crop window out of the way. */
2213 c
->rect
.top
= btv
->vbi_end
;
2218 if (*width
< min_width
||
2219 *height
< min_height
||
2220 *width
> max_width
||
2221 *height
> max_height
||
2222 0 != (*width
& ~width_mask
))
2226 rc
= 0; /* success */
2229 mutex_unlock(&btv
->lock
);
2234 /* Returns an error if the given overlay window dimensions are not
2235 possible with the current cropping parameters. If adjust_size is
2236 TRUE the function may adjust the window width and/or height
2237 instead, however it always rounds the horizontal position and
2238 width as btcx_align() does. If adjust_crop is TRUE the function
2239 may also adjust the current cropping parameters to get closer
2240 to the desired window size. */
2242 verify_window (struct bttv_fh
* fh
,
2243 struct v4l2_window
* win
,
2247 enum v4l2_field field
;
2248 unsigned int width_mask
;
2251 if (win
->w
.width
< 48 || win
->w
.height
< 32)
2253 if (win
->clipcount
> 2048)
2258 if (V4L2_FIELD_ANY
== field
) {
2261 height2
= fh
->btv
->crop
[!!fh
->do_crop
].rect
.height
>> 1;
2262 field
= (win
->w
.height
> height2
)
2263 ? V4L2_FIELD_INTERLACED
2267 case V4L2_FIELD_TOP
:
2268 case V4L2_FIELD_BOTTOM
:
2269 case V4L2_FIELD_INTERLACED
:
2275 /* 4-byte alignment. */
2276 if (NULL
== fh
->ovfmt
)
2279 switch (fh
->ovfmt
->depth
) {
2293 win
->w
.width
-= win
->w
.left
& ~width_mask
;
2294 win
->w
.left
= (win
->w
.left
- width_mask
- 1) & width_mask
;
2296 rc
= limit_scaled_size(fh
, &win
->w
.width
, &win
->w
.height
,
2298 /* width_bias: round down */ 0,
2299 adjust_size
, adjust_crop
);
2307 static int setup_window(struct bttv_fh
*fh
, struct bttv
*btv
,
2308 struct v4l2_window
*win
, int fixup
)
2310 struct v4l2_clip
*clips
= NULL
;
2311 int n
,size
,retval
= 0;
2313 if (NULL
== fh
->ovfmt
)
2315 if (!(fh
->ovfmt
->flags
& FORMAT_FLAGS_PACKED
))
2317 retval
= verify_window(fh
, win
,
2318 /* adjust_size */ fixup
,
2319 /* adjust_crop */ fixup
);
2323 /* copy clips -- luckily v4l1 + v4l2 are binary
2324 compatible here ...*/
2326 size
= sizeof(*clips
)*(n
+4);
2327 clips
= kmalloc(size
,GFP_KERNEL
);
2331 if (copy_from_user(clips
,win
->clips
,sizeof(struct v4l2_clip
)*n
)) {
2336 /* clip against screen */
2337 if (NULL
!= btv
->fbuf
.base
)
2338 n
= btcx_screen_clips(btv
->fbuf
.fmt
.width
, btv
->fbuf
.fmt
.height
,
2340 btcx_sort_clips(clips
,n
);
2342 /* 4-byte alignments */
2343 switch (fh
->ovfmt
->depth
) {
2346 btcx_align(&win
->w
, clips
, n
, 3);
2349 btcx_align(&win
->w
, clips
, n
, 1);
2352 /* no alignment fixups needed */
2358 mutex_lock(&fh
->cap
.vb_lock
);
2359 kfree(fh
->ov
.clips
);
2360 fh
->ov
.clips
= clips
;
2364 fh
->ov
.field
= win
->field
;
2365 fh
->ov
.setup_ok
= 1;
2366 btv
->init
.ov
.w
.width
= win
->w
.width
;
2367 btv
->init
.ov
.w
.height
= win
->w
.height
;
2368 btv
->init
.ov
.field
= win
->field
;
2370 /* update overlay if needed */
2372 if (check_btres(fh
, RESOURCE_OVERLAY
)) {
2373 struct bttv_buffer
*new;
2375 new = videobuf_sg_alloc(sizeof(*new));
2376 new->crop
= btv
->crop
[!!fh
->do_crop
].rect
;
2377 bttv_overlay_risc(btv
, &fh
->ov
, fh
->ovfmt
, new);
2378 retval
= bttv_switch_overlay(btv
,fh
,new);
2380 mutex_unlock(&fh
->cap
.vb_lock
);
2384 /* ----------------------------------------------------------------------- */
2386 static struct videobuf_queue
* bttv_queue(struct bttv_fh
*fh
)
2388 struct videobuf_queue
* q
= NULL
;
2391 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2394 case V4L2_BUF_TYPE_VBI_CAPTURE
:
2403 static int bttv_resource(struct bttv_fh
*fh
)
2408 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2409 res
= RESOURCE_VIDEO_STREAM
;
2411 case V4L2_BUF_TYPE_VBI_CAPTURE
:
2420 static int bttv_switch_type(struct bttv_fh
*fh
, enum v4l2_buf_type type
)
2422 struct videobuf_queue
*q
= bttv_queue(fh
);
2423 int res
= bttv_resource(fh
);
2425 if (check_btres(fh
,res
))
2427 if (videobuf_queue_is_busy(q
))
2434 pix_format_set_size (struct v4l2_pix_format
* f
,
2435 const struct bttv_format
* fmt
,
2437 unsigned int height
)
2442 if (fmt
->flags
& FORMAT_FLAGS_PLANAR
) {
2443 f
->bytesperline
= width
; /* Y plane */
2444 f
->sizeimage
= (width
* height
* fmt
->depth
) >> 3;
2446 f
->bytesperline
= (width
* fmt
->depth
) >> 3;
2447 f
->sizeimage
= height
* f
->bytesperline
;
2451 static int bttv_g_fmt_vid_cap(struct file
*file
, void *priv
,
2452 struct v4l2_format
*f
)
2454 struct bttv_fh
*fh
= priv
;
2456 pix_format_set_size(&f
->fmt
.pix
, fh
->fmt
,
2457 fh
->width
, fh
->height
);
2458 f
->fmt
.pix
.field
= fh
->cap
.field
;
2459 f
->fmt
.pix
.pixelformat
= fh
->fmt
->fourcc
;
2464 static int bttv_g_fmt_vid_overlay(struct file
*file
, void *priv
,
2465 struct v4l2_format
*f
)
2467 struct bttv_fh
*fh
= priv
;
2469 f
->fmt
.win
.w
= fh
->ov
.w
;
2470 f
->fmt
.win
.field
= fh
->ov
.field
;
2475 static int bttv_try_fmt_vid_cap(struct file
*file
, void *priv
,
2476 struct v4l2_format
*f
)
2478 const struct bttv_format
*fmt
;
2479 struct bttv_fh
*fh
= priv
;
2480 struct bttv
*btv
= fh
->btv
;
2481 enum v4l2_field field
;
2482 __s32 width
, height
;
2485 fmt
= format_by_fourcc(f
->fmt
.pix
.pixelformat
);
2489 field
= f
->fmt
.pix
.field
;
2491 if (V4L2_FIELD_ANY
== field
) {
2494 height2
= btv
->crop
[!!fh
->do_crop
].rect
.height
>> 1;
2495 field
= (f
->fmt
.pix
.height
> height2
)
2496 ? V4L2_FIELD_INTERLACED
2497 : V4L2_FIELD_BOTTOM
;
2500 if (V4L2_FIELD_SEQ_BT
== field
)
2501 field
= V4L2_FIELD_SEQ_TB
;
2504 case V4L2_FIELD_TOP
:
2505 case V4L2_FIELD_BOTTOM
:
2506 case V4L2_FIELD_ALTERNATE
:
2507 case V4L2_FIELD_INTERLACED
:
2509 case V4L2_FIELD_SEQ_TB
:
2510 if (fmt
->flags
& FORMAT_FLAGS_PLANAR
)
2517 width
= f
->fmt
.pix
.width
;
2518 height
= f
->fmt
.pix
.height
;
2520 rc
= limit_scaled_size(fh
, &width
, &height
, field
,
2521 /* width_mask: 4 pixels */ ~3,
2522 /* width_bias: nearest */ 2,
2523 /* adjust_size */ 1,
2524 /* adjust_crop */ 0);
2528 /* update data for the application */
2529 f
->fmt
.pix
.field
= field
;
2530 pix_format_set_size(&f
->fmt
.pix
, fmt
, width
, height
);
2535 static int bttv_try_fmt_vid_overlay(struct file
*file
, void *priv
,
2536 struct v4l2_format
*f
)
2538 struct bttv_fh
*fh
= priv
;
2540 return verify_window(fh
, &f
->fmt
.win
,
2541 /* adjust_size */ 1,
2542 /* adjust_crop */ 0);
2545 static int bttv_s_fmt_vid_cap(struct file
*file
, void *priv
,
2546 struct v4l2_format
*f
)
2549 const struct bttv_format
*fmt
;
2550 struct bttv_fh
*fh
= priv
;
2551 struct bttv
*btv
= fh
->btv
;
2552 __s32 width
, height
;
2553 enum v4l2_field field
;
2555 retval
= bttv_switch_type(fh
, f
->type
);
2559 retval
= bttv_try_fmt_vid_cap(file
, priv
, f
);
2563 width
= f
->fmt
.pix
.width
;
2564 height
= f
->fmt
.pix
.height
;
2565 field
= f
->fmt
.pix
.field
;
2567 retval
= limit_scaled_size(fh
, &width
, &height
, f
->fmt
.pix
.field
,
2568 /* width_mask: 4 pixels */ ~3,
2569 /* width_bias: nearest */ 2,
2570 /* adjust_size */ 1,
2571 /* adjust_crop */ 1);
2575 f
->fmt
.pix
.field
= field
;
2577 fmt
= format_by_fourcc(f
->fmt
.pix
.pixelformat
);
2579 /* update our state informations */
2580 mutex_lock(&fh
->cap
.vb_lock
);
2582 fh
->cap
.field
= f
->fmt
.pix
.field
;
2583 fh
->cap
.last
= V4L2_FIELD_NONE
;
2584 fh
->width
= f
->fmt
.pix
.width
;
2585 fh
->height
= f
->fmt
.pix
.height
;
2586 btv
->init
.fmt
= fmt
;
2587 btv
->init
.width
= f
->fmt
.pix
.width
;
2588 btv
->init
.height
= f
->fmt
.pix
.height
;
2589 mutex_unlock(&fh
->cap
.vb_lock
);
2594 static int bttv_s_fmt_vid_overlay(struct file
*file
, void *priv
,
2595 struct v4l2_format
*f
)
2597 struct bttv_fh
*fh
= priv
;
2598 struct bttv
*btv
= fh
->btv
;
2600 if (no_overlay
> 0) {
2601 printk(KERN_ERR
"V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2605 return setup_window(fh
, btv
, &f
->fmt
.win
, 1);
2608 #ifdef CONFIG_VIDEO_V4L1_COMPAT
2609 static int vidiocgmbuf(struct file
*file
, void *priv
, struct video_mbuf
*mbuf
)
2613 struct bttv_fh
*fh
= priv
;
2615 mutex_lock(&fh
->cap
.vb_lock
);
2616 retval
= __videobuf_mmap_setup(&fh
->cap
, gbuffers
, gbufsize
,
2619 mutex_unlock(&fh
->cap
.vb_lock
);
2624 memset(mbuf
, 0, sizeof(*mbuf
));
2625 mbuf
->frames
= gbuffers
;
2626 mbuf
->size
= gbuffers
* gbufsize
;
2628 for (i
= 0; i
< gbuffers
; i
++)
2629 mbuf
->offsets
[i
] = i
* gbufsize
;
2631 mutex_unlock(&fh
->cap
.vb_lock
);
2636 static int bttv_querycap(struct file
*file
, void *priv
,
2637 struct v4l2_capability
*cap
)
2639 struct bttv_fh
*fh
= priv
;
2640 struct bttv
*btv
= fh
->btv
;
2645 strlcpy(cap
->driver
, "bttv", sizeof(cap
->driver
));
2646 strlcpy(cap
->card
, btv
->video_dev
->name
, sizeof(cap
->card
));
2647 snprintf(cap
->bus_info
, sizeof(cap
->bus_info
),
2648 "PCI:%s", pci_name(btv
->c
.pci
));
2649 cap
->version
= BTTV_VERSION_CODE
;
2651 V4L2_CAP_VIDEO_CAPTURE
|
2652 V4L2_CAP_VBI_CAPTURE
|
2653 V4L2_CAP_READWRITE
|
2655 if (no_overlay
<= 0)
2656 cap
->capabilities
|= V4L2_CAP_VIDEO_OVERLAY
;
2658 if (btv
->tuner_type
!= TUNER_ABSENT
)
2659 cap
->capabilities
|= V4L2_CAP_TUNER
;
2663 static int bttv_enum_fmt_cap_ovr(struct v4l2_fmtdesc
*f
)
2667 for (i
= 0; i
< FORMATS
; i
++) {
2668 if (formats
[i
].fourcc
!= -1)
2670 if ((unsigned int)index
== f
->index
)
2676 f
->pixelformat
= formats
[i
].fourcc
;
2677 strlcpy(f
->description
, formats
[i
].name
, sizeof(f
->description
));
2682 static int bttv_enum_fmt_vid_cap(struct file
*file
, void *priv
,
2683 struct v4l2_fmtdesc
*f
)
2685 int rc
= bttv_enum_fmt_cap_ovr(f
);
2693 static int bttv_enum_fmt_vid_overlay(struct file
*file
, void *priv
,
2694 struct v4l2_fmtdesc
*f
)
2698 if (no_overlay
> 0) {
2699 printk(KERN_ERR
"V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2703 rc
= bttv_enum_fmt_cap_ovr(f
);
2708 if (!(formats
[rc
].flags
& FORMAT_FLAGS_PACKED
))
2714 static int bttv_g_fbuf(struct file
*file
, void *f
,
2715 struct v4l2_framebuffer
*fb
)
2717 struct bttv_fh
*fh
= f
;
2718 struct bttv
*btv
= fh
->btv
;
2721 fb
->capability
= V4L2_FBUF_CAP_LIST_CLIPPING
;
2723 fb
->fmt
.pixelformat
= fh
->ovfmt
->fourcc
;
2727 static int bttv_overlay(struct file
*file
, void *f
, unsigned int on
)
2729 struct bttv_fh
*fh
= f
;
2730 struct bttv
*btv
= fh
->btv
;
2731 struct bttv_buffer
*new;
2736 if (NULL
== btv
->fbuf
.base
)
2738 if (!fh
->ov
.setup_ok
) {
2739 dprintk("bttv%d: overlay: !setup_ok\n", btv
->c
.nr
);
2744 if (!check_alloc_btres(btv
, fh
, RESOURCE_OVERLAY
))
2747 mutex_lock(&fh
->cap
.vb_lock
);
2749 fh
->ov
.tvnorm
= btv
->tvnorm
;
2750 new = videobuf_sg_alloc(sizeof(*new));
2751 new->crop
= btv
->crop
[!!fh
->do_crop
].rect
;
2752 bttv_overlay_risc(btv
, &fh
->ov
, fh
->ovfmt
, new);
2758 retval
= bttv_switch_overlay(btv
, fh
, new);
2759 mutex_unlock(&fh
->cap
.vb_lock
);
2763 static int bttv_s_fbuf(struct file
*file
, void *f
,
2764 struct v4l2_framebuffer
*fb
)
2766 struct bttv_fh
*fh
= f
;
2767 struct bttv
*btv
= fh
->btv
;
2768 const struct bttv_format
*fmt
;
2771 if (!capable(CAP_SYS_ADMIN
) &&
2772 !capable(CAP_SYS_RAWIO
))
2776 fmt
= format_by_fourcc(fb
->fmt
.pixelformat
);
2779 if (0 == (fmt
->flags
& FORMAT_FLAGS_PACKED
))
2783 if (fb
->flags
& V4L2_FBUF_FLAG_OVERLAY
) {
2784 __s32 width
= fb
->fmt
.width
;
2785 __s32 height
= fb
->fmt
.height
;
2787 retval
= limit_scaled_size(fh
, &width
, &height
,
2788 V4L2_FIELD_INTERLACED
,
2789 /* width_mask */ ~3,
2791 /* adjust_size */ 0,
2792 /* adjust_crop */ 0);
2798 mutex_lock(&fh
->cap
.vb_lock
);
2799 btv
->fbuf
.base
= fb
->base
;
2800 btv
->fbuf
.fmt
.width
= fb
->fmt
.width
;
2801 btv
->fbuf
.fmt
.height
= fb
->fmt
.height
;
2802 if (0 != fb
->fmt
.bytesperline
)
2803 btv
->fbuf
.fmt
.bytesperline
= fb
->fmt
.bytesperline
;
2805 btv
->fbuf
.fmt
.bytesperline
= btv
->fbuf
.fmt
.width
*fmt
->depth
/8;
2809 btv
->init
.ovfmt
= fmt
;
2810 if (fb
->flags
& V4L2_FBUF_FLAG_OVERLAY
) {
2813 fh
->ov
.w
.width
= fb
->fmt
.width
;
2814 fh
->ov
.w
.height
= fb
->fmt
.height
;
2815 btv
->init
.ov
.w
.width
= fb
->fmt
.width
;
2816 btv
->init
.ov
.w
.height
= fb
->fmt
.height
;
2817 kfree(fh
->ov
.clips
);
2818 fh
->ov
.clips
= NULL
;
2821 if (check_btres(fh
, RESOURCE_OVERLAY
)) {
2822 struct bttv_buffer
*new;
2824 new = videobuf_sg_alloc(sizeof(*new));
2825 new->crop
= btv
->crop
[!!fh
->do_crop
].rect
;
2826 bttv_overlay_risc(btv
, &fh
->ov
, fh
->ovfmt
, new);
2827 retval
= bttv_switch_overlay(btv
, fh
, new);
2830 mutex_unlock(&fh
->cap
.vb_lock
);
2834 static int bttv_reqbufs(struct file
*file
, void *priv
,
2835 struct v4l2_requestbuffers
*p
)
2837 struct bttv_fh
*fh
= priv
;
2838 return videobuf_reqbufs(bttv_queue(fh
), p
);
2841 static int bttv_querybuf(struct file
*file
, void *priv
,
2842 struct v4l2_buffer
*b
)
2844 struct bttv_fh
*fh
= priv
;
2845 return videobuf_querybuf(bttv_queue(fh
), b
);
2848 static int bttv_qbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*b
)
2850 struct bttv_fh
*fh
= priv
;
2851 struct bttv
*btv
= fh
->btv
;
2852 int res
= bttv_resource(fh
);
2854 if (!check_alloc_btres(btv
, fh
, res
))
2857 return videobuf_qbuf(bttv_queue(fh
), b
);
2860 static int bttv_dqbuf(struct file
*file
, void *priv
, struct v4l2_buffer
*b
)
2862 struct bttv_fh
*fh
= priv
;
2863 return videobuf_dqbuf(bttv_queue(fh
), b
,
2864 file
->f_flags
& O_NONBLOCK
);
2867 static int bttv_streamon(struct file
*file
, void *priv
,
2868 enum v4l2_buf_type type
)
2870 struct bttv_fh
*fh
= priv
;
2871 struct bttv
*btv
= fh
->btv
;
2872 int res
= bttv_resource(fh
);
2874 if (!check_alloc_btres(btv
, fh
, res
))
2876 return videobuf_streamon(bttv_queue(fh
));
2880 static int bttv_streamoff(struct file
*file
, void *priv
,
2881 enum v4l2_buf_type type
)
2883 struct bttv_fh
*fh
= priv
;
2884 struct bttv
*btv
= fh
->btv
;
2886 int res
= bttv_resource(fh
);
2889 retval
= videobuf_streamoff(bttv_queue(fh
));
2892 free_btres(btv
, fh
, res
);
2896 static int bttv_queryctrl(struct file
*file
, void *priv
,
2897 struct v4l2_queryctrl
*c
)
2899 struct bttv_fh
*fh
= priv
;
2900 struct bttv
*btv
= fh
->btv
;
2901 const struct v4l2_queryctrl
*ctrl
;
2903 if ((c
->id
< V4L2_CID_BASE
||
2904 c
->id
>= V4L2_CID_LASTP1
) &&
2905 (c
->id
< V4L2_CID_PRIVATE_BASE
||
2906 c
->id
>= V4L2_CID_PRIVATE_LASTP1
))
2909 if (!btv
->volume_gpio
&& (c
->id
== V4L2_CID_AUDIO_VOLUME
))
2912 ctrl
= ctrl_by_id(c
->id
);
2914 *c
= (NULL
!= ctrl
) ? *ctrl
: no_ctl
;
2920 static int bttv_g_parm(struct file
*file
, void *f
,
2921 struct v4l2_streamparm
*parm
)
2923 struct bttv_fh
*fh
= f
;
2924 struct bttv
*btv
= fh
->btv
;
2926 v4l2_video_std_frame_period(bttv_tvnorms
[btv
->tvnorm
].v4l2_id
,
2927 &parm
->parm
.capture
.timeperframe
);
2931 static int bttv_g_tuner(struct file
*file
, void *priv
,
2932 struct v4l2_tuner
*t
)
2934 struct bttv_fh
*fh
= priv
;
2935 struct bttv
*btv
= fh
->btv
;
2937 if (btv
->tuner_type
== TUNER_ABSENT
)
2942 mutex_lock(&btv
->lock
);
2943 t
->rxsubchans
= V4L2_TUNER_SUB_MONO
;
2944 bttv_call_all(btv
, tuner
, g_tuner
, t
);
2945 strcpy(t
->name
, "Television");
2946 t
->capability
= V4L2_TUNER_CAP_NORM
;
2947 t
->type
= V4L2_TUNER_ANALOG_TV
;
2948 if (btread(BT848_DSTATUS
)&BT848_DSTATUS_HLOC
)
2951 if (btv
->audio_mode_gpio
)
2952 btv
->audio_mode_gpio(btv
, t
, 0);
2954 mutex_unlock(&btv
->lock
);
2958 static int bttv_g_priority(struct file
*file
, void *f
, enum v4l2_priority
*p
)
2960 struct bttv_fh
*fh
= f
;
2961 struct bttv
*btv
= fh
->btv
;
2963 *p
= v4l2_prio_max(&btv
->prio
);
2968 static int bttv_s_priority(struct file
*file
, void *f
,
2969 enum v4l2_priority prio
)
2971 struct bttv_fh
*fh
= f
;
2972 struct bttv
*btv
= fh
->btv
;
2974 return v4l2_prio_change(&btv
->prio
, &fh
->prio
, prio
);
2977 static int bttv_cropcap(struct file
*file
, void *priv
,
2978 struct v4l2_cropcap
*cap
)
2980 struct bttv_fh
*fh
= priv
;
2981 struct bttv
*btv
= fh
->btv
;
2983 if (cap
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
&&
2984 cap
->type
!= V4L2_BUF_TYPE_VIDEO_OVERLAY
)
2987 *cap
= bttv_tvnorms
[btv
->tvnorm
].cropcap
;
2992 static int bttv_g_crop(struct file
*file
, void *f
, struct v4l2_crop
*crop
)
2994 struct bttv_fh
*fh
= f
;
2995 struct bttv
*btv
= fh
->btv
;
2997 if (crop
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
&&
2998 crop
->type
!= V4L2_BUF_TYPE_VIDEO_OVERLAY
)
3001 /* No fh->do_crop = 1; because btv->crop[1] may be
3002 inconsistent with fh->width or fh->height and apps
3003 do not expect a change here. */
3005 crop
->c
= btv
->crop
[!!fh
->do_crop
].rect
;
3010 static int bttv_s_crop(struct file
*file
, void *f
, struct v4l2_crop
*crop
)
3012 struct bttv_fh
*fh
= f
;
3013 struct bttv
*btv
= fh
->btv
;
3014 const struct v4l2_rect
*b
;
3022 if (crop
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
&&
3023 crop
->type
!= V4L2_BUF_TYPE_VIDEO_OVERLAY
)
3026 retval
= v4l2_prio_check(&btv
->prio
, &fh
->prio
);
3030 /* Make sure tvnorm, vbi_end and the current cropping
3031 parameters remain consistent until we're done. Note
3032 read() may change vbi_end in check_alloc_btres(). */
3033 mutex_lock(&btv
->lock
);
3037 if (locked_btres(fh
->btv
, VIDEO_RESOURCES
)) {
3038 mutex_unlock(&btv
->lock
);
3042 b
= &bttv_tvnorms
[btv
->tvnorm
].cropcap
.bounds
;
3045 b_right
= b_left
+ b
->width
;
3046 b_bottom
= b
->top
+ b
->height
;
3048 b_top
= max(b
->top
, btv
->vbi_end
);
3049 if (b_top
+ 32 >= b_bottom
) {
3050 mutex_unlock(&btv
->lock
);
3054 /* Min. scaled size 48 x 32. */
3055 c
.rect
.left
= clamp(crop
->c
.left
, b_left
, b_right
- 48);
3056 c
.rect
.left
= min(c
.rect
.left
, (__s32
) MAX_HDELAY
);
3058 c
.rect
.width
= clamp(crop
->c
.width
,
3059 48, b_right
- c
.rect
.left
);
3061 c
.rect
.top
= clamp(crop
->c
.top
, b_top
, b_bottom
- 32);
3062 /* Top and height must be a multiple of two. */
3063 c
.rect
.top
= (c
.rect
.top
+ 1) & ~1;
3065 c
.rect
.height
= clamp(crop
->c
.height
,
3066 32, b_bottom
- c
.rect
.top
);
3067 c
.rect
.height
= (c
.rect
.height
+ 1) & ~1;
3069 bttv_crop_calc_limits(&c
);
3073 mutex_unlock(&btv
->lock
);
3077 mutex_lock(&fh
->cap
.vb_lock
);
3079 if (fh
->width
< c
.min_scaled_width
) {
3080 fh
->width
= c
.min_scaled_width
;
3081 btv
->init
.width
= c
.min_scaled_width
;
3082 } else if (fh
->width
> c
.max_scaled_width
) {
3083 fh
->width
= c
.max_scaled_width
;
3084 btv
->init
.width
= c
.max_scaled_width
;
3087 if (fh
->height
< c
.min_scaled_height
) {
3088 fh
->height
= c
.min_scaled_height
;
3089 btv
->init
.height
= c
.min_scaled_height
;
3090 } else if (fh
->height
> c
.max_scaled_height
) {
3091 fh
->height
= c
.max_scaled_height
;
3092 btv
->init
.height
= c
.max_scaled_height
;
3095 mutex_unlock(&fh
->cap
.vb_lock
);
3100 static int bttv_g_audio(struct file
*file
, void *priv
, struct v4l2_audio
*a
)
3102 if (unlikely(a
->index
))
3105 strcpy(a
->name
, "audio");
3109 static int bttv_s_audio(struct file
*file
, void *priv
, struct v4l2_audio
*a
)
3111 if (unlikely(a
->index
))
3117 static ssize_t
bttv_read(struct file
*file
, char __user
*data
,
3118 size_t count
, loff_t
*ppos
)
3120 struct bttv_fh
*fh
= file
->private_data
;
3123 if (fh
->btv
->errors
)
3124 bttv_reinit_bt848(fh
->btv
);
3125 dprintk("bttv%d: read count=%d type=%s\n",
3126 fh
->btv
->c
.nr
,(int)count
,v4l2_type_names
[fh
->type
]);
3129 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
3130 if (!check_alloc_btres(fh
->btv
, fh
, RESOURCE_VIDEO_READ
)) {
3131 /* VIDEO_READ in use by another fh,
3132 or VIDEO_STREAM by any fh. */
3135 retval
= videobuf_read_one(&fh
->cap
, data
, count
, ppos
,
3136 file
->f_flags
& O_NONBLOCK
);
3137 free_btres(fh
->btv
, fh
, RESOURCE_VIDEO_READ
);
3139 case V4L2_BUF_TYPE_VBI_CAPTURE
:
3140 if (!check_alloc_btres(fh
->btv
,fh
,RESOURCE_VBI
))
3142 retval
= videobuf_read_stream(&fh
->vbi
, data
, count
, ppos
, 1,
3143 file
->f_flags
& O_NONBLOCK
);
3151 static unsigned int bttv_poll(struct file
*file
, poll_table
*wait
)
3153 struct bttv_fh
*fh
= file
->private_data
;
3154 struct bttv_buffer
*buf
;
3155 enum v4l2_field field
;
3156 unsigned int rc
= POLLERR
;
3158 if (V4L2_BUF_TYPE_VBI_CAPTURE
== fh
->type
) {
3159 if (!check_alloc_btres(fh
->btv
,fh
,RESOURCE_VBI
))
3161 return videobuf_poll_stream(file
, &fh
->vbi
, wait
);
3164 if (check_btres(fh
,RESOURCE_VIDEO_STREAM
)) {
3165 mutex_lock(&fh
->cap
.vb_lock
);
3166 /* streaming capture */
3167 if (list_empty(&fh
->cap
.stream
))
3169 buf
= list_entry(fh
->cap
.stream
.next
,struct bttv_buffer
,vb
.stream
);
3171 /* read() capture */
3172 mutex_lock(&fh
->cap
.vb_lock
);
3173 if (NULL
== fh
->cap
.read_buf
) {
3174 /* need to capture a new frame */
3175 if (locked_btres(fh
->btv
,RESOURCE_VIDEO_STREAM
))
3177 fh
->cap
.read_buf
= videobuf_sg_alloc(fh
->cap
.msize
);
3178 if (NULL
== fh
->cap
.read_buf
)
3180 fh
->cap
.read_buf
->memory
= V4L2_MEMORY_USERPTR
;
3181 field
= videobuf_next_field(&fh
->cap
);
3182 if (0 != fh
->cap
.ops
->buf_prepare(&fh
->cap
,fh
->cap
.read_buf
,field
)) {
3183 kfree (fh
->cap
.read_buf
);
3184 fh
->cap
.read_buf
= NULL
;
3187 fh
->cap
.ops
->buf_queue(&fh
->cap
,fh
->cap
.read_buf
);
3188 fh
->cap
.read_off
= 0;
3190 mutex_unlock(&fh
->cap
.vb_lock
);
3191 buf
= (struct bttv_buffer
*)fh
->cap
.read_buf
;
3194 poll_wait(file
, &buf
->vb
.done
, wait
);
3195 if (buf
->vb
.state
== VIDEOBUF_DONE
||
3196 buf
->vb
.state
== VIDEOBUF_ERROR
)
3197 rc
= POLLIN
|POLLRDNORM
;
3201 mutex_unlock(&fh
->cap
.vb_lock
);
3205 static int bttv_open(struct file
*file
)
3207 int minor
= video_devdata(file
)->minor
;
3208 struct bttv
*btv
= video_drvdata(file
);
3210 enum v4l2_buf_type type
= 0;
3212 dprintk(KERN_DEBUG
"bttv: open minor=%d\n",minor
);
3215 if (btv
->video_dev
->minor
== minor
) {
3216 type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
3217 } else if (btv
->vbi_dev
->minor
== minor
) {
3218 type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
3225 dprintk(KERN_DEBUG
"bttv%d: open called (type=%s)\n",
3226 btv
->c
.nr
,v4l2_type_names
[type
]);
3228 /* allocate per filehandle data */
3229 fh
= kmalloc(sizeof(*fh
),GFP_KERNEL
);
3234 file
->private_data
= fh
;
3237 fh
->ov
.setup_ok
= 0;
3238 v4l2_prio_open(&btv
->prio
,&fh
->prio
);
3240 videobuf_queue_sg_init(&fh
->cap
, &bttv_video_qops
,
3241 &btv
->c
.pci
->dev
, &btv
->s_lock
,
3242 V4L2_BUF_TYPE_VIDEO_CAPTURE
,
3243 V4L2_FIELD_INTERLACED
,
3244 sizeof(struct bttv_buffer
),
3246 videobuf_queue_sg_init(&fh
->vbi
, &bttv_vbi_qops
,
3247 &btv
->c
.pci
->dev
, &btv
->s_lock
,
3248 V4L2_BUF_TYPE_VBI_CAPTURE
,
3250 sizeof(struct bttv_buffer
),
3252 set_tvnorm(btv
,btv
->tvnorm
);
3253 set_input(btv
, btv
->input
, btv
->tvnorm
);
3257 /* The V4L2 spec requires one global set of cropping parameters
3258 which only change on request. These are stored in btv->crop[1].
3259 However for compatibility with V4L apps and cropping unaware
3260 V4L2 apps we now reset the cropping parameters as seen through
3261 this fh, which is to say VIDIOC_G_CROP and scaling limit checks
3262 will use btv->crop[0], the default cropping parameters for the
3263 current video standard, and VIDIOC_S_FMT will not implicitely
3264 change the cropping parameters until VIDIOC_S_CROP has been
3266 fh
->do_crop
= !reset_crop
; /* module parameter */
3268 /* Likewise there should be one global set of VBI capture
3269 parameters, but for compatibility with V4L apps and earlier
3270 driver versions each fh has its own parameters. */
3271 bttv_vbi_fmt_reset(&fh
->vbi_fmt
, btv
->tvnorm
);
3273 bttv_field_count(btv
);
3278 static int bttv_release(struct file
*file
)
3280 struct bttv_fh
*fh
= file
->private_data
;
3281 struct bttv
*btv
= fh
->btv
;
3283 /* turn off overlay */
3284 if (check_btres(fh
, RESOURCE_OVERLAY
))
3285 bttv_switch_overlay(btv
,fh
,NULL
);
3287 /* stop video capture */
3288 if (check_btres(fh
, RESOURCE_VIDEO_STREAM
)) {
3289 videobuf_streamoff(&fh
->cap
);
3290 free_btres(btv
,fh
,RESOURCE_VIDEO_STREAM
);
3292 if (fh
->cap
.read_buf
) {
3293 buffer_release(&fh
->cap
,fh
->cap
.read_buf
);
3294 kfree(fh
->cap
.read_buf
);
3296 if (check_btres(fh
, RESOURCE_VIDEO_READ
)) {
3297 free_btres(btv
, fh
, RESOURCE_VIDEO_READ
);
3300 /* stop vbi capture */
3301 if (check_btres(fh
, RESOURCE_VBI
)) {
3302 videobuf_stop(&fh
->vbi
);
3303 free_btres(btv
,fh
,RESOURCE_VBI
);
3307 videobuf_mmap_free(&fh
->cap
);
3308 videobuf_mmap_free(&fh
->vbi
);
3309 v4l2_prio_close(&btv
->prio
,&fh
->prio
);
3310 file
->private_data
= NULL
;
3314 bttv_field_count(btv
);
3323 bttv_mmap(struct file
*file
, struct vm_area_struct
*vma
)
3325 struct bttv_fh
*fh
= file
->private_data
;
3327 dprintk("bttv%d: mmap type=%s 0x%lx+%ld\n",
3328 fh
->btv
->c
.nr
, v4l2_type_names
[fh
->type
],
3329 vma
->vm_start
, vma
->vm_end
- vma
->vm_start
);
3330 return videobuf_mmap_mapper(bttv_queue(fh
),vma
);
3333 static const struct v4l2_file_operations bttv_fops
=
3335 .owner
= THIS_MODULE
,
3337 .release
= bttv_release
,
3338 .ioctl
= video_ioctl2
,
3344 static const struct v4l2_ioctl_ops bttv_ioctl_ops
= {
3345 .vidioc_querycap
= bttv_querycap
,
3346 .vidioc_enum_fmt_vid_cap
= bttv_enum_fmt_vid_cap
,
3347 .vidioc_g_fmt_vid_cap
= bttv_g_fmt_vid_cap
,
3348 .vidioc_try_fmt_vid_cap
= bttv_try_fmt_vid_cap
,
3349 .vidioc_s_fmt_vid_cap
= bttv_s_fmt_vid_cap
,
3350 .vidioc_enum_fmt_vid_overlay
= bttv_enum_fmt_vid_overlay
,
3351 .vidioc_g_fmt_vid_overlay
= bttv_g_fmt_vid_overlay
,
3352 .vidioc_try_fmt_vid_overlay
= bttv_try_fmt_vid_overlay
,
3353 .vidioc_s_fmt_vid_overlay
= bttv_s_fmt_vid_overlay
,
3354 .vidioc_g_fmt_vbi_cap
= bttv_g_fmt_vbi_cap
,
3355 .vidioc_try_fmt_vbi_cap
= bttv_try_fmt_vbi_cap
,
3356 .vidioc_s_fmt_vbi_cap
= bttv_s_fmt_vbi_cap
,
3357 .vidioc_g_audio
= bttv_g_audio
,
3358 .vidioc_s_audio
= bttv_s_audio
,
3359 .vidioc_cropcap
= bttv_cropcap
,
3360 .vidioc_reqbufs
= bttv_reqbufs
,
3361 .vidioc_querybuf
= bttv_querybuf
,
3362 .vidioc_qbuf
= bttv_qbuf
,
3363 .vidioc_dqbuf
= bttv_dqbuf
,
3364 .vidioc_s_std
= bttv_s_std
,
3365 .vidioc_enum_input
= bttv_enum_input
,
3366 .vidioc_g_input
= bttv_g_input
,
3367 .vidioc_s_input
= bttv_s_input
,
3368 .vidioc_queryctrl
= bttv_queryctrl
,
3369 .vidioc_g_ctrl
= bttv_g_ctrl
,
3370 .vidioc_s_ctrl
= bttv_s_ctrl
,
3371 .vidioc_streamon
= bttv_streamon
,
3372 .vidioc_streamoff
= bttv_streamoff
,
3373 .vidioc_g_tuner
= bttv_g_tuner
,
3374 .vidioc_s_tuner
= bttv_s_tuner
,
3375 #ifdef CONFIG_VIDEO_V4L1_COMPAT
3376 .vidiocgmbuf
= vidiocgmbuf
,
3378 .vidioc_g_crop
= bttv_g_crop
,
3379 .vidioc_s_crop
= bttv_s_crop
,
3380 .vidioc_g_fbuf
= bttv_g_fbuf
,
3381 .vidioc_s_fbuf
= bttv_s_fbuf
,
3382 .vidioc_overlay
= bttv_overlay
,
3383 .vidioc_g_priority
= bttv_g_priority
,
3384 .vidioc_s_priority
= bttv_s_priority
,
3385 .vidioc_g_parm
= bttv_g_parm
,
3386 .vidioc_g_frequency
= bttv_g_frequency
,
3387 .vidioc_s_frequency
= bttv_s_frequency
,
3388 .vidioc_log_status
= bttv_log_status
,
3389 .vidioc_querystd
= bttv_querystd
,
3390 #ifdef CONFIG_VIDEO_ADV_DEBUG
3391 .vidioc_g_register
= bttv_g_register
,
3392 .vidioc_s_register
= bttv_s_register
,
3396 static struct video_device bttv_video_template
= {
3399 .ioctl_ops
= &bttv_ioctl_ops
,
3400 .tvnorms
= BTTV_NORMS
,
3401 .current_norm
= V4L2_STD_PAL
,
3404 /* ----------------------------------------------------------------------- */
3405 /* radio interface */
3407 static int radio_open(struct file
*file
)
3409 int minor
= video_devdata(file
)->minor
;
3410 struct bttv
*btv
= video_drvdata(file
);
3413 dprintk("bttv: open minor=%d\n",minor
);
3416 WARN_ON(btv
->radio_dev
&& btv
->radio_dev
->minor
!= minor
);
3417 if (!btv
->radio_dev
|| btv
->radio_dev
->minor
!= minor
) {
3422 dprintk("bttv%d: open called (radio)\n",btv
->c
.nr
);
3424 /* allocate per filehandle data */
3425 fh
= kmalloc(sizeof(*fh
), GFP_KERNEL
);
3430 file
->private_data
= fh
;
3432 v4l2_prio_open(&btv
->prio
, &fh
->prio
);
3434 mutex_lock(&btv
->lock
);
3438 bttv_call_all(btv
, tuner
, s_radio
);
3439 audio_input(btv
,TVAUDIO_INPUT_RADIO
);
3441 mutex_unlock(&btv
->lock
);
3446 static int radio_release(struct file
*file
)
3448 struct bttv_fh
*fh
= file
->private_data
;
3449 struct bttv
*btv
= fh
->btv
;
3450 struct rds_command cmd
;
3452 v4l2_prio_close(&btv
->prio
,&fh
->prio
);
3453 file
->private_data
= NULL
;
3458 bttv_call_all(btv
, core
, ioctl
, RDS_CMD_CLOSE
, &cmd
);
3463 static int radio_querycap(struct file
*file
, void *priv
,
3464 struct v4l2_capability
*cap
)
3466 struct bttv_fh
*fh
= priv
;
3467 struct bttv
*btv
= fh
->btv
;
3469 strcpy(cap
->driver
, "bttv");
3470 strlcpy(cap
->card
, btv
->radio_dev
->name
, sizeof(cap
->card
));
3471 sprintf(cap
->bus_info
, "PCI:%s", pci_name(btv
->c
.pci
));
3472 cap
->version
= BTTV_VERSION_CODE
;
3473 cap
->capabilities
= V4L2_CAP_TUNER
;
3478 static int radio_g_tuner(struct file
*file
, void *priv
, struct v4l2_tuner
*t
)
3480 struct bttv_fh
*fh
= priv
;
3481 struct bttv
*btv
= fh
->btv
;
3483 if (btv
->tuner_type
== TUNER_ABSENT
)
3487 mutex_lock(&btv
->lock
);
3488 strcpy(t
->name
, "Radio");
3489 t
->type
= V4L2_TUNER_RADIO
;
3491 bttv_call_all(btv
, tuner
, g_tuner
, t
);
3493 if (btv
->audio_mode_gpio
)
3494 btv
->audio_mode_gpio(btv
, t
, 0);
3496 mutex_unlock(&btv
->lock
);
3501 static int radio_enum_input(struct file
*file
, void *priv
,
3502 struct v4l2_input
*i
)
3507 strcpy(i
->name
, "Radio");
3508 i
->type
= V4L2_INPUT_TYPE_TUNER
;
3513 static int radio_g_audio(struct file
*file
, void *priv
,
3514 struct v4l2_audio
*a
)
3516 if (unlikely(a
->index
))
3519 strcpy(a
->name
, "Radio");
3524 static int radio_s_tuner(struct file
*file
, void *priv
,
3525 struct v4l2_tuner
*t
)
3527 struct bttv_fh
*fh
= priv
;
3528 struct bttv
*btv
= fh
->btv
;
3533 bttv_call_all(btv
, tuner
, g_tuner
, t
);
3537 static int radio_s_audio(struct file
*file
, void *priv
,
3538 struct v4l2_audio
*a
)
3540 if (unlikely(a
->index
))
3546 static int radio_s_input(struct file
*filp
, void *priv
, unsigned int i
)
3554 static int radio_s_std(struct file
*file
, void *fh
, v4l2_std_id
*norm
)
3559 static int radio_queryctrl(struct file
*file
, void *priv
,
3560 struct v4l2_queryctrl
*c
)
3562 const struct v4l2_queryctrl
*ctrl
;
3564 if (c
->id
< V4L2_CID_BASE
||
3565 c
->id
>= V4L2_CID_LASTP1
)
3568 if (c
->id
== V4L2_CID_AUDIO_MUTE
) {
3569 ctrl
= ctrl_by_id(c
->id
);
3577 static int radio_g_input(struct file
*filp
, void *priv
, unsigned int *i
)
3583 static ssize_t
radio_read(struct file
*file
, char __user
*data
,
3584 size_t count
, loff_t
*ppos
)
3586 struct bttv_fh
*fh
= file
->private_data
;
3587 struct bttv
*btv
= fh
->btv
;
3588 struct rds_command cmd
;
3589 cmd
.block_count
= count
/3;
3591 cmd
.instance
= file
;
3592 cmd
.result
= -ENODEV
;
3594 bttv_call_all(btv
, core
, ioctl
, RDS_CMD_READ
, &cmd
);
3599 static unsigned int radio_poll(struct file
*file
, poll_table
*wait
)
3601 struct bttv_fh
*fh
= file
->private_data
;
3602 struct bttv
*btv
= fh
->btv
;
3603 struct rds_command cmd
;
3604 cmd
.instance
= file
;
3605 cmd
.event_list
= wait
;
3606 cmd
.result
= -ENODEV
;
3607 bttv_call_all(btv
, core
, ioctl
, RDS_CMD_POLL
, &cmd
);
3612 static const struct v4l2_file_operations radio_fops
=
3614 .owner
= THIS_MODULE
,
3617 .release
= radio_release
,
3618 .ioctl
= video_ioctl2
,
3622 static const struct v4l2_ioctl_ops radio_ioctl_ops
= {
3623 .vidioc_querycap
= radio_querycap
,
3624 .vidioc_g_tuner
= radio_g_tuner
,
3625 .vidioc_enum_input
= radio_enum_input
,
3626 .vidioc_g_audio
= radio_g_audio
,
3627 .vidioc_s_tuner
= radio_s_tuner
,
3628 .vidioc_s_audio
= radio_s_audio
,
3629 .vidioc_s_input
= radio_s_input
,
3630 .vidioc_s_std
= radio_s_std
,
3631 .vidioc_queryctrl
= radio_queryctrl
,
3632 .vidioc_g_input
= radio_g_input
,
3633 .vidioc_g_ctrl
= bttv_g_ctrl
,
3634 .vidioc_s_ctrl
= bttv_s_ctrl
,
3635 .vidioc_g_frequency
= bttv_g_frequency
,
3636 .vidioc_s_frequency
= bttv_s_frequency
,
3639 static struct video_device radio_template
= {
3640 .fops
= &radio_fops
,
3642 .ioctl_ops
= &radio_ioctl_ops
,
3645 /* ----------------------------------------------------------------------- */
3646 /* some debug code */
3648 static int bttv_risc_decode(u32 risc
)
3650 static char *instr
[16] = {
3651 [ BT848_RISC_WRITE
>> 28 ] = "write",
3652 [ BT848_RISC_SKIP
>> 28 ] = "skip",
3653 [ BT848_RISC_WRITEC
>> 28 ] = "writec",
3654 [ BT848_RISC_JUMP
>> 28 ] = "jump",
3655 [ BT848_RISC_SYNC
>> 28 ] = "sync",
3656 [ BT848_RISC_WRITE123
>> 28 ] = "write123",
3657 [ BT848_RISC_SKIP123
>> 28 ] = "skip123",
3658 [ BT848_RISC_WRITE1S23
>> 28 ] = "write1s23",
3660 static int incr
[16] = {
3661 [ BT848_RISC_WRITE
>> 28 ] = 2,
3662 [ BT848_RISC_JUMP
>> 28 ] = 2,
3663 [ BT848_RISC_SYNC
>> 28 ] = 2,
3664 [ BT848_RISC_WRITE123
>> 28 ] = 5,
3665 [ BT848_RISC_SKIP123
>> 28 ] = 2,
3666 [ BT848_RISC_WRITE1S23
>> 28 ] = 3,
3668 static char *bits
[] = {
3669 "be0", "be1", "be2", "be3/resync",
3670 "set0", "set1", "set2", "set3",
3671 "clr0", "clr1", "clr2", "clr3",
3672 "irq", "res", "eol", "sol",
3676 printk("0x%08x [ %s", risc
,
3677 instr
[risc
>> 28] ? instr
[risc
>> 28] : "INVALID");
3678 for (i
= ARRAY_SIZE(bits
)-1; i
>= 0; i
--)
3679 if (risc
& (1 << (i
+ 12)))
3680 printk(" %s",bits
[i
]);
3681 printk(" count=%d ]\n", risc
& 0xfff);
3682 return incr
[risc
>> 28] ? incr
[risc
>> 28] : 1;
3685 static void bttv_risc_disasm(struct bttv
*btv
,
3686 struct btcx_riscmem
*risc
)
3690 printk("%s: risc disasm: %p [dma=0x%08lx]\n",
3691 btv
->c
.v4l2_dev
.name
, risc
->cpu
, (unsigned long)risc
->dma
);
3692 for (i
= 0; i
< (risc
->size
>> 2); i
+= n
) {
3693 printk("%s: 0x%lx: ", btv
->c
.v4l2_dev
.name
,
3694 (unsigned long)(risc
->dma
+ (i
<<2)));
3695 n
= bttv_risc_decode(le32_to_cpu(risc
->cpu
[i
]));
3696 for (j
= 1; j
< n
; j
++)
3697 printk("%s: 0x%lx: 0x%08x [ arg #%d ]\n",
3698 btv
->c
.v4l2_dev
.name
, (unsigned long)(risc
->dma
+ ((i
+j
)<<2)),
3700 if (0 == risc
->cpu
[i
])
3705 static void bttv_print_riscaddr(struct bttv
*btv
)
3707 printk(" main: %08Lx\n",
3708 (unsigned long long)btv
->main
.dma
);
3709 printk(" vbi : o=%08Lx e=%08Lx\n",
3710 btv
->cvbi
? (unsigned long long)btv
->cvbi
->top
.dma
: 0,
3711 btv
->cvbi
? (unsigned long long)btv
->cvbi
->bottom
.dma
: 0);
3712 printk(" cap : o=%08Lx e=%08Lx\n",
3713 btv
->curr
.top
? (unsigned long long)btv
->curr
.top
->top
.dma
: 0,
3714 btv
->curr
.bottom
? (unsigned long long)btv
->curr
.bottom
->bottom
.dma
: 0);
3715 printk(" scr : o=%08Lx e=%08Lx\n",
3716 btv
->screen
? (unsigned long long)btv
->screen
->top
.dma
: 0,
3717 btv
->screen
? (unsigned long long)btv
->screen
->bottom
.dma
: 0);
3718 bttv_risc_disasm(btv
, &btv
->main
);
3721 /* ----------------------------------------------------------------------- */
3724 static char *irq_name
[] = {
3725 "FMTCHG", // format change detected (525 vs. 625)
3726 "VSYNC", // vertical sync (new field)
3727 "HSYNC", // horizontal sync
3728 "OFLOW", // chroma/luma AGC overflow
3729 "HLOCK", // horizontal lock changed
3730 "VPRES", // video presence changed
3732 "I2CDONE", // hw irc operation finished
3733 "GPINT", // gpio port triggered irq
3735 "RISCI", // risc instruction triggered irq
3736 "FBUS", // pixel data fifo dropped data (high pci bus latencies)
3737 "FTRGT", // pixel data fifo overrun
3738 "FDSR", // fifo data stream resyncronisation
3739 "PPERR", // parity error (data transfer)
3740 "RIPERR", // parity error (read risc instructions)
3741 "PABORT", // pci abort
3742 "OCERR", // risc instruction error
3743 "SCERR", // syncronisation error
3746 static void bttv_print_irqbits(u32 print
, u32 mark
)
3751 for (i
= 0; i
< ARRAY_SIZE(irq_name
); i
++) {
3752 if (print
& (1 << i
))
3753 printk(" %s",irq_name
[i
]);
3754 if (mark
& (1 << i
))
3759 static void bttv_irq_debug_low_latency(struct bttv
*btv
, u32 rc
)
3761 printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
3763 (unsigned long)btv
->main
.dma
,
3764 (unsigned long)le32_to_cpu(btv
->main
.cpu
[RISC_SLOT_O_VBI
+1]),
3765 (unsigned long)le32_to_cpu(btv
->main
.cpu
[RISC_SLOT_O_FIELD
+1]),
3768 if (0 == (btread(BT848_DSTATUS
) & BT848_DSTATUS_HLOC
)) {
3769 printk("bttv%d: Oh, there (temporarely?) is no input signal. "
3770 "Ok, then this is harmless, don't worry ;)\n",
3774 printk("bttv%d: Uhm. Looks like we have unusual high IRQ latencies.\n",
3776 printk("bttv%d: Lets try to catch the culpit red-handed ...\n",
3782 bttv_irq_next_video(struct bttv
*btv
, struct bttv_buffer_set
*set
)
3784 struct bttv_buffer
*item
;
3786 memset(set
,0,sizeof(*set
));
3788 /* capture request ? */
3789 if (!list_empty(&btv
->capture
)) {
3791 item
= list_entry(btv
->capture
.next
, struct bttv_buffer
, vb
.queue
);
3792 if (V4L2_FIELD_HAS_TOP(item
->vb
.field
))
3794 if (V4L2_FIELD_HAS_BOTTOM(item
->vb
.field
))
3797 /* capture request for other field ? */
3798 if (!V4L2_FIELD_HAS_BOTH(item
->vb
.field
) &&
3799 (item
->vb
.queue
.next
!= &btv
->capture
)) {
3800 item
= list_entry(item
->vb
.queue
.next
, struct bttv_buffer
, vb
.queue
);
3801 if (!V4L2_FIELD_HAS_BOTH(item
->vb
.field
)) {
3802 if (NULL
== set
->top
&&
3803 V4L2_FIELD_TOP
== item
->vb
.field
) {
3806 if (NULL
== set
->bottom
&&
3807 V4L2_FIELD_BOTTOM
== item
->vb
.field
) {
3810 if (NULL
!= set
->top
&& NULL
!= set
->bottom
)
3816 /* screen overlay ? */
3817 if (NULL
!= btv
->screen
) {
3818 if (V4L2_FIELD_HAS_BOTH(btv
->screen
->vb
.field
)) {
3819 if (NULL
== set
->top
&& NULL
== set
->bottom
) {
3820 set
->top
= btv
->screen
;
3821 set
->bottom
= btv
->screen
;
3824 if (V4L2_FIELD_TOP
== btv
->screen
->vb
.field
&&
3826 set
->top
= btv
->screen
;
3828 if (V4L2_FIELD_BOTTOM
== btv
->screen
->vb
.field
&&
3829 NULL
== set
->bottom
) {
3830 set
->bottom
= btv
->screen
;
3835 dprintk("bttv%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
3836 btv
->c
.nr
,set
->top
, set
->bottom
,
3837 btv
->screen
,set
->frame_irq
,set
->top_irq
);
3842 bttv_irq_wakeup_video(struct bttv
*btv
, struct bttv_buffer_set
*wakeup
,
3843 struct bttv_buffer_set
*curr
, unsigned int state
)
3847 do_gettimeofday(&ts
);
3849 if (wakeup
->top
== wakeup
->bottom
) {
3850 if (NULL
!= wakeup
->top
&& curr
->top
!= wakeup
->top
) {
3852 printk("bttv%d: wakeup: both=%p\n",btv
->c
.nr
,wakeup
->top
);
3853 wakeup
->top
->vb
.ts
= ts
;
3854 wakeup
->top
->vb
.field_count
= btv
->field_count
;
3855 wakeup
->top
->vb
.state
= state
;
3856 wake_up(&wakeup
->top
->vb
.done
);
3859 if (NULL
!= wakeup
->top
&& curr
->top
!= wakeup
->top
) {
3861 printk("bttv%d: wakeup: top=%p\n",btv
->c
.nr
,wakeup
->top
);
3862 wakeup
->top
->vb
.ts
= ts
;
3863 wakeup
->top
->vb
.field_count
= btv
->field_count
;
3864 wakeup
->top
->vb
.state
= state
;
3865 wake_up(&wakeup
->top
->vb
.done
);
3867 if (NULL
!= wakeup
->bottom
&& curr
->bottom
!= wakeup
->bottom
) {
3869 printk("bttv%d: wakeup: bottom=%p\n",btv
->c
.nr
,wakeup
->bottom
);
3870 wakeup
->bottom
->vb
.ts
= ts
;
3871 wakeup
->bottom
->vb
.field_count
= btv
->field_count
;
3872 wakeup
->bottom
->vb
.state
= state
;
3873 wake_up(&wakeup
->bottom
->vb
.done
);
3879 bttv_irq_wakeup_vbi(struct bttv
*btv
, struct bttv_buffer
*wakeup
,
3887 do_gettimeofday(&ts
);
3889 wakeup
->vb
.field_count
= btv
->field_count
;
3890 wakeup
->vb
.state
= state
;
3891 wake_up(&wakeup
->vb
.done
);
3894 static void bttv_irq_timeout(unsigned long data
)
3896 struct bttv
*btv
= (struct bttv
*)data
;
3897 struct bttv_buffer_set old
,new;
3898 struct bttv_buffer
*ovbi
;
3899 struct bttv_buffer
*item
;
3900 unsigned long flags
;
3903 printk(KERN_INFO
"bttv%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
3904 btv
->c
.nr
, btv
->framedrop
, btv
->irq_me
, btv
->irq_total
,
3905 btread(BT848_RISC_COUNT
));
3906 bttv_print_irqbits(btread(BT848_INT_STAT
),0);
3910 spin_lock_irqsave(&btv
->s_lock
,flags
);
3912 /* deactivate stuff */
3913 memset(&new,0,sizeof(new));
3919 bttv_buffer_activate_video(btv
, &new);
3920 bttv_buffer_activate_vbi(btv
, NULL
);
3921 bttv_set_dma(btv
, 0);
3924 bttv_irq_wakeup_video(btv
, &old
, &new, VIDEOBUF_ERROR
);
3925 bttv_irq_wakeup_vbi(btv
, ovbi
, VIDEOBUF_ERROR
);
3927 /* cancel all outstanding capture / vbi requests */
3928 while (!list_empty(&btv
->capture
)) {
3929 item
= list_entry(btv
->capture
.next
, struct bttv_buffer
, vb
.queue
);
3930 list_del(&item
->vb
.queue
);
3931 item
->vb
.state
= VIDEOBUF_ERROR
;
3932 wake_up(&item
->vb
.done
);
3934 while (!list_empty(&btv
->vcapture
)) {
3935 item
= list_entry(btv
->vcapture
.next
, struct bttv_buffer
, vb
.queue
);
3936 list_del(&item
->vb
.queue
);
3937 item
->vb
.state
= VIDEOBUF_ERROR
;
3938 wake_up(&item
->vb
.done
);
3942 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
3946 bttv_irq_wakeup_top(struct bttv
*btv
)
3948 struct bttv_buffer
*wakeup
= btv
->curr
.top
;
3953 spin_lock(&btv
->s_lock
);
3954 btv
->curr
.top_irq
= 0;
3955 btv
->curr
.top
= NULL
;
3956 bttv_risc_hook(btv
, RISC_SLOT_O_FIELD
, NULL
, 0);
3958 do_gettimeofday(&wakeup
->vb
.ts
);
3959 wakeup
->vb
.field_count
= btv
->field_count
;
3960 wakeup
->vb
.state
= VIDEOBUF_DONE
;
3961 wake_up(&wakeup
->vb
.done
);
3962 spin_unlock(&btv
->s_lock
);
3965 static inline int is_active(struct btcx_riscmem
*risc
, u32 rc
)
3969 if (rc
> risc
->dma
+ risc
->size
)
3975 bttv_irq_switch_video(struct bttv
*btv
)
3977 struct bttv_buffer_set
new;
3978 struct bttv_buffer_set old
;
3981 spin_lock(&btv
->s_lock
);
3983 /* new buffer set */
3984 bttv_irq_next_video(btv
, &new);
3985 rc
= btread(BT848_RISC_COUNT
);
3986 if ((btv
->curr
.top
&& is_active(&btv
->curr
.top
->top
, rc
)) ||
3987 (btv
->curr
.bottom
&& is_active(&btv
->curr
.bottom
->bottom
, rc
))) {
3990 bttv_irq_debug_low_latency(btv
, rc
);
3991 spin_unlock(&btv
->s_lock
);
3998 btv
->loop_irq
&= ~1;
3999 bttv_buffer_activate_video(btv
, &new);
4000 bttv_set_dma(btv
, 0);
4003 if (UNSET
!= btv
->new_input
) {
4004 video_mux(btv
,btv
->new_input
);
4005 btv
->new_input
= UNSET
;
4008 /* wake up finished buffers */
4009 bttv_irq_wakeup_video(btv
, &old
, &new, VIDEOBUF_DONE
);
4010 spin_unlock(&btv
->s_lock
);
4014 bttv_irq_switch_vbi(struct bttv
*btv
)
4016 struct bttv_buffer
*new = NULL
;
4017 struct bttv_buffer
*old
;
4020 spin_lock(&btv
->s_lock
);
4022 if (!list_empty(&btv
->vcapture
))
4023 new = list_entry(btv
->vcapture
.next
, struct bttv_buffer
, vb
.queue
);
4026 rc
= btread(BT848_RISC_COUNT
);
4027 if (NULL
!= old
&& (is_active(&old
->top
, rc
) ||
4028 is_active(&old
->bottom
, rc
))) {
4031 bttv_irq_debug_low_latency(btv
, rc
);
4032 spin_unlock(&btv
->s_lock
);
4038 btv
->loop_irq
&= ~4;
4039 bttv_buffer_activate_vbi(btv
, new);
4040 bttv_set_dma(btv
, 0);
4042 bttv_irq_wakeup_vbi(btv
, old
, VIDEOBUF_DONE
);
4043 spin_unlock(&btv
->s_lock
);
4046 static irqreturn_t
bttv_irq(int irq
, void *dev_id
)
4054 btv
=(struct bttv
*)dev_id
;
4056 if (btv
->custom_irq
)
4057 handled
= btv
->custom_irq(btv
);
4061 /* get/clear interrupt status bits */
4062 stat
=btread(BT848_INT_STAT
);
4063 astat
=stat
&btread(BT848_INT_MASK
);
4067 btwrite(stat
,BT848_INT_STAT
);
4069 /* get device status bits */
4070 dstat
=btread(BT848_DSTATUS
);
4073 printk(KERN_DEBUG
"bttv%d: irq loop=%d fc=%d "
4074 "riscs=%x, riscc=%08x, ",
4075 btv
->c
.nr
, count
, btv
->field_count
,
4076 stat
>>28, btread(BT848_RISC_COUNT
));
4077 bttv_print_irqbits(stat
,astat
);
4078 if (stat
& BT848_INT_HLOCK
)
4079 printk(" HLOC => %s", (dstat
& BT848_DSTATUS_HLOC
)
4081 if (stat
& BT848_INT_VPRES
)
4082 printk(" PRES => %s", (dstat
& BT848_DSTATUS_PRES
)
4084 if (stat
& BT848_INT_FMTCHG
)
4085 printk(" NUML => %s", (dstat
& BT848_DSTATUS_NUML
)
4090 if (astat
&BT848_INT_VSYNC
)
4093 if ((astat
& BT848_INT_GPINT
) && btv
->remote
) {
4094 wake_up(&btv
->gpioq
);
4095 bttv_input_irq(btv
);
4098 if (astat
& BT848_INT_I2CDONE
) {
4099 btv
->i2c_done
= stat
;
4100 wake_up(&btv
->i2c_queue
);
4103 if ((astat
& BT848_INT_RISCI
) && (stat
& (4<<28)))
4104 bttv_irq_switch_vbi(btv
);
4106 if ((astat
& BT848_INT_RISCI
) && (stat
& (2<<28)))
4107 bttv_irq_wakeup_top(btv
);
4109 if ((astat
& BT848_INT_RISCI
) && (stat
& (1<<28)))
4110 bttv_irq_switch_video(btv
);
4112 if ((astat
& BT848_INT_HLOCK
) && btv
->opt_automute
)
4113 audio_mute(btv
, btv
->mute
); /* trigger automute */
4115 if (astat
& (BT848_INT_SCERR
|BT848_INT_OCERR
)) {
4116 printk(KERN_INFO
"bttv%d: %s%s @ %08x,",btv
->c
.nr
,
4117 (astat
& BT848_INT_SCERR
) ? "SCERR" : "",
4118 (astat
& BT848_INT_OCERR
) ? "OCERR" : "",
4119 btread(BT848_RISC_COUNT
));
4120 bttv_print_irqbits(stat
,astat
);
4123 bttv_print_riscaddr(btv
);
4125 if (fdsr
&& astat
& BT848_INT_FDSR
) {
4126 printk(KERN_INFO
"bttv%d: FDSR @ %08x\n",
4127 btv
->c
.nr
,btread(BT848_RISC_COUNT
));
4129 bttv_print_riscaddr(btv
);
4135 if (count
> 8 || !(astat
& BT848_INT_GPINT
)) {
4136 btwrite(0, BT848_INT_MASK
);
4139 "bttv%d: IRQ lockup, cleared int mask [", btv
->c
.nr
);
4142 "bttv%d: IRQ lockup, clearing GPINT from int mask [", btv
->c
.nr
);
4144 btwrite(btread(BT848_INT_MASK
) & (-1 ^ BT848_INT_GPINT
),
4148 bttv_print_irqbits(stat
,astat
);
4156 return IRQ_RETVAL(handled
);
4160 /* ----------------------------------------------------------------------- */
4161 /* initialitation */
4163 static struct video_device
*vdev_init(struct bttv
*btv
,
4164 const struct video_device
*template,
4165 const char *type_name
)
4167 struct video_device
*vfd
;
4169 vfd
= video_device_alloc();
4173 vfd
->v4l2_dev
= &btv
->c
.v4l2_dev
;
4174 vfd
->release
= video_device_release
;
4175 vfd
->debug
= bttv_debug
;
4176 video_set_drvdata(vfd
, btv
);
4177 snprintf(vfd
->name
, sizeof(vfd
->name
), "BT%d%s %s (%s)",
4178 btv
->id
, (btv
->id
==848 && btv
->revision
==0x12) ? "A" : "",
4179 type_name
, bttv_tvcards
[btv
->c
.type
].name
);
4183 static void bttv_unregister_video(struct bttv
*btv
)
4185 if (btv
->video_dev
) {
4186 if (-1 != btv
->video_dev
->minor
)
4187 video_unregister_device(btv
->video_dev
);
4189 video_device_release(btv
->video_dev
);
4190 btv
->video_dev
= NULL
;
4193 if (-1 != btv
->vbi_dev
->minor
)
4194 video_unregister_device(btv
->vbi_dev
);
4196 video_device_release(btv
->vbi_dev
);
4197 btv
->vbi_dev
= NULL
;
4199 if (btv
->radio_dev
) {
4200 if (-1 != btv
->radio_dev
->minor
)
4201 video_unregister_device(btv
->radio_dev
);
4203 video_device_release(btv
->radio_dev
);
4204 btv
->radio_dev
= NULL
;
4208 /* register video4linux devices */
4209 static int __devinit
bttv_register_video(struct bttv
*btv
)
4212 printk("bttv: Overlay support disabled.\n");
4215 btv
->video_dev
= vdev_init(btv
, &bttv_video_template
, "video");
4217 if (NULL
== btv
->video_dev
)
4219 if (video_register_device(btv
->video_dev
, VFL_TYPE_GRABBER
,
4220 video_nr
[btv
->c
.nr
]) < 0)
4222 printk(KERN_INFO
"bttv%d: registered device video%d\n",
4223 btv
->c
.nr
, btv
->video_dev
->num
);
4224 if (device_create_file(&btv
->video_dev
->dev
,
4225 &dev_attr_card
)<0) {
4226 printk(KERN_ERR
"bttv%d: device_create_file 'card' "
4227 "failed\n", btv
->c
.nr
);
4232 btv
->vbi_dev
= vdev_init(btv
, &bttv_video_template
, "vbi");
4234 if (NULL
== btv
->vbi_dev
)
4236 if (video_register_device(btv
->vbi_dev
, VFL_TYPE_VBI
,
4237 vbi_nr
[btv
->c
.nr
]) < 0)
4239 printk(KERN_INFO
"bttv%d: registered device vbi%d\n",
4240 btv
->c
.nr
, btv
->vbi_dev
->num
);
4242 if (!btv
->has_radio
)
4245 btv
->radio_dev
= vdev_init(btv
, &radio_template
, "radio");
4246 if (NULL
== btv
->radio_dev
)
4248 if (video_register_device(btv
->radio_dev
, VFL_TYPE_RADIO
,
4249 radio_nr
[btv
->c
.nr
]) < 0)
4251 printk(KERN_INFO
"bttv%d: registered device radio%d\n",
4252 btv
->c
.nr
, btv
->radio_dev
->num
);
4258 bttv_unregister_video(btv
);
4263 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
4264 /* response on cards with no firmware is not enabled by OF */
4265 static void pci_set_command(struct pci_dev
*dev
)
4267 #if defined(__powerpc__)
4270 pci_read_config_dword(dev
, PCI_COMMAND
, &cmd
);
4271 cmd
= (cmd
| PCI_COMMAND_MEMORY
);
4272 pci_write_config_dword(dev
, PCI_COMMAND
, cmd
);
4276 static int __devinit
bttv_probe(struct pci_dev
*dev
,
4277 const struct pci_device_id
*pci_id
)
4283 if (bttv_num
== BTTV_MAX
)
4285 printk(KERN_INFO
"bttv: Bt8xx card found (%d).\n", bttv_num
);
4286 bttvs
[bttv_num
] = btv
= kzalloc(sizeof(*btv
), GFP_KERNEL
);
4288 printk(KERN_ERR
"bttv: out of memory.\n");
4291 btv
->c
.nr
= bttv_num
;
4292 snprintf(btv
->c
.v4l2_dev
.name
, sizeof(btv
->c
.v4l2_dev
.name
),
4293 "bttv%d", btv
->c
.nr
);
4295 /* initialize structs / fill in defaults */
4296 mutex_init(&btv
->lock
);
4297 spin_lock_init(&btv
->s_lock
);
4298 spin_lock_init(&btv
->gpio_lock
);
4299 init_waitqueue_head(&btv
->gpioq
);
4300 init_waitqueue_head(&btv
->i2c_queue
);
4301 INIT_LIST_HEAD(&btv
->c
.subs
);
4302 INIT_LIST_HEAD(&btv
->capture
);
4303 INIT_LIST_HEAD(&btv
->vcapture
);
4304 v4l2_prio_init(&btv
->prio
);
4306 init_timer(&btv
->timeout
);
4307 btv
->timeout
.function
= bttv_irq_timeout
;
4308 btv
->timeout
.data
= (unsigned long)btv
;
4311 btv
->tuner_type
= UNSET
;
4312 btv
->new_input
= UNSET
;
4313 btv
->has_radio
=radio
[btv
->c
.nr
];
4315 /* pci stuff (init, get irq/mmio, ... */
4317 btv
->id
= dev
->device
;
4318 if (pci_enable_device(dev
)) {
4319 printk(KERN_WARNING
"bttv%d: Can't enable device.\n",
4323 if (pci_set_dma_mask(dev
, DMA_BIT_MASK(32))) {
4324 printk(KERN_WARNING
"bttv%d: No suitable DMA available.\n",
4328 if (!request_mem_region(pci_resource_start(dev
,0),
4329 pci_resource_len(dev
,0),
4330 btv
->c
.v4l2_dev
.name
)) {
4331 printk(KERN_WARNING
"bttv%d: can't request iomem (0x%llx).\n",
4333 (unsigned long long)pci_resource_start(dev
,0));
4336 pci_set_master(dev
);
4337 pci_set_command(dev
);
4339 result
= v4l2_device_register(&dev
->dev
, &btv
->c
.v4l2_dev
);
4341 printk(KERN_WARNING
"bttv%d: v4l2_device_register() failed\n", btv
->c
.nr
);
4345 pci_read_config_byte(dev
, PCI_CLASS_REVISION
, &btv
->revision
);
4346 pci_read_config_byte(dev
, PCI_LATENCY_TIMER
, &lat
);
4347 printk(KERN_INFO
"bttv%d: Bt%d (rev %d) at %s, ",
4348 bttv_num
,btv
->id
, btv
->revision
, pci_name(dev
));
4349 printk("irq: %d, latency: %d, mmio: 0x%llx\n",
4350 btv
->c
.pci
->irq
, lat
,
4351 (unsigned long long)pci_resource_start(dev
,0));
4354 btv
->bt848_mmio
= ioremap(pci_resource_start(dev
, 0), 0x1000);
4355 if (NULL
== btv
->bt848_mmio
) {
4356 printk("bttv%d: ioremap() failed\n", btv
->c
.nr
);
4364 /* disable irqs, register irq handler */
4365 btwrite(0, BT848_INT_MASK
);
4366 result
= request_irq(btv
->c
.pci
->irq
, bttv_irq
,
4367 IRQF_SHARED
| IRQF_DISABLED
, btv
->c
.v4l2_dev
.name
, (void *)btv
);
4369 printk(KERN_ERR
"bttv%d: can't get IRQ %d\n",
4370 bttv_num
,btv
->c
.pci
->irq
);
4374 if (0 != bttv_handle_chipset(btv
)) {
4379 /* init options from insmod args */
4380 btv
->opt_combfilter
= combfilter
;
4381 btv
->opt_lumafilter
= lumafilter
;
4382 btv
->opt_automute
= automute
;
4383 btv
->opt_chroma_agc
= chroma_agc
;
4384 btv
->opt_adc_crush
= adc_crush
;
4385 btv
->opt_vcr_hack
= vcr_hack
;
4386 btv
->opt_whitecrush_upper
= whitecrush_upper
;
4387 btv
->opt_whitecrush_lower
= whitecrush_lower
;
4388 btv
->opt_uv_ratio
= uv_ratio
;
4389 btv
->opt_full_luma_range
= full_luma_range
;
4390 btv
->opt_coring
= coring
;
4392 /* fill struct bttv with some useful defaults */
4393 btv
->init
.btv
= btv
;
4394 btv
->init
.ov
.w
.width
= 320;
4395 btv
->init
.ov
.w
.height
= 240;
4396 btv
->init
.fmt
= format_by_fourcc(V4L2_PIX_FMT_BGR24
);
4397 btv
->init
.width
= 320;
4398 btv
->init
.height
= 240;
4401 /* initialize hardware */
4403 bttv_gpio_tracking(btv
,"pre-init");
4405 bttv_risc_init_main(btv
);
4409 btwrite(0x00, BT848_GPIO_REG_INP
);
4410 btwrite(0x00, BT848_GPIO_OUT_EN
);
4412 bttv_gpio_tracking(btv
,"init");
4414 /* needs to be done before i2c is registered */
4415 bttv_init_card1(btv
);
4417 /* register i2c + gpio */
4420 /* some card-specific stuff (needs working i2c) */
4421 bttv_init_card2(btv
);
4422 bttv_init_tuner(btv
);
4425 /* register video4linux + input */
4426 if (!bttv_tvcards
[btv
->c
.type
].no_video
) {
4427 bttv_register_video(btv
);
4428 bt848_bright(btv
,32768);
4429 bt848_contrast(btv
,32768);
4430 bt848_hue(btv
,32768);
4431 bt848_sat(btv
,32768);
4433 set_input(btv
, 0, btv
->tvnorm
);
4434 bttv_crop_reset(&btv
->crop
[0], btv
->tvnorm
);
4435 btv
->crop
[1] = btv
->crop
[0]; /* current = default */
4436 disclaim_vbi_lines(btv
);
4437 disclaim_video_lines(btv
);
4440 /* add subdevices and autoload dvb-bt8xx if needed */
4441 if (bttv_tvcards
[btv
->c
.type
].has_dvb
) {
4442 bttv_sub_add_device(&btv
->c
, "dvb");
4443 request_modules(btv
);
4446 bttv_input_init(btv
);
4448 /* everything is fine */
4453 free_irq(btv
->c
.pci
->irq
,btv
);
4456 v4l2_device_unregister(&btv
->c
.v4l2_dev
);
4459 if (btv
->bt848_mmio
)
4460 iounmap(btv
->bt848_mmio
);
4461 release_mem_region(pci_resource_start(btv
->c
.pci
,0),
4462 pci_resource_len(btv
->c
.pci
,0));
4466 static void __devexit
bttv_remove(struct pci_dev
*pci_dev
)
4468 struct v4l2_device
*v4l2_dev
= pci_get_drvdata(pci_dev
);
4469 struct bttv
*btv
= to_bttv(v4l2_dev
);
4472 printk("bttv%d: unloading\n",btv
->c
.nr
);
4474 /* shutdown everything (DMA+IRQs) */
4475 btand(~15, BT848_GPIO_DMA_CTL
);
4476 btwrite(0, BT848_INT_MASK
);
4477 btwrite(~0x0, BT848_INT_STAT
);
4478 btwrite(0x0, BT848_GPIO_OUT_EN
);
4480 bttv_gpio_tracking(btv
,"cleanup");
4482 /* tell gpio modules we are leaving ... */
4484 wake_up(&btv
->gpioq
);
4485 bttv_input_fini(btv
);
4486 bttv_sub_del_devices(&btv
->c
);
4488 /* unregister i2c_bus + input */
4491 /* unregister video4linux */
4492 bttv_unregister_video(btv
);
4494 /* free allocated memory */
4495 btcx_riscmem_free(btv
->c
.pci
,&btv
->main
);
4497 /* free ressources */
4498 free_irq(btv
->c
.pci
->irq
,btv
);
4499 iounmap(btv
->bt848_mmio
);
4500 release_mem_region(pci_resource_start(btv
->c
.pci
,0),
4501 pci_resource_len(btv
->c
.pci
,0));
4503 v4l2_device_unregister(&btv
->c
.v4l2_dev
);
4504 bttvs
[btv
->c
.nr
] = NULL
;
4511 static int bttv_suspend(struct pci_dev
*pci_dev
, pm_message_t state
)
4513 struct v4l2_device
*v4l2_dev
= pci_get_drvdata(pci_dev
);
4514 struct bttv
*btv
= to_bttv(v4l2_dev
);
4515 struct bttv_buffer_set idle
;
4516 unsigned long flags
;
4518 dprintk("bttv%d: suspend %d\n", btv
->c
.nr
, state
.event
);
4520 /* stop dma + irqs */
4521 spin_lock_irqsave(&btv
->s_lock
,flags
);
4522 memset(&idle
, 0, sizeof(idle
));
4523 btv
->state
.video
= btv
->curr
;
4524 btv
->state
.vbi
= btv
->cvbi
;
4525 btv
->state
.loop_irq
= btv
->loop_irq
;
4528 bttv_buffer_activate_video(btv
, &idle
);
4529 bttv_buffer_activate_vbi(btv
, NULL
);
4530 bttv_set_dma(btv
, 0);
4531 btwrite(0, BT848_INT_MASK
);
4532 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
4534 /* save bt878 state */
4535 btv
->state
.gpio_enable
= btread(BT848_GPIO_OUT_EN
);
4536 btv
->state
.gpio_data
= gpio_read();
4538 /* save pci state */
4539 pci_save_state(pci_dev
);
4540 if (0 != pci_set_power_state(pci_dev
, pci_choose_state(pci_dev
, state
))) {
4541 pci_disable_device(pci_dev
);
4542 btv
->state
.disabled
= 1;
4547 static int bttv_resume(struct pci_dev
*pci_dev
)
4549 struct v4l2_device
*v4l2_dev
= pci_get_drvdata(pci_dev
);
4550 struct bttv
*btv
= to_bttv(v4l2_dev
);
4551 unsigned long flags
;
4554 dprintk("bttv%d: resume\n", btv
->c
.nr
);
4556 /* restore pci state */
4557 if (btv
->state
.disabled
) {
4558 err
=pci_enable_device(pci_dev
);
4560 printk(KERN_WARNING
"bttv%d: Can't enable device.\n",
4564 btv
->state
.disabled
= 0;
4566 err
=pci_set_power_state(pci_dev
, PCI_D0
);
4568 pci_disable_device(pci_dev
);
4569 printk(KERN_WARNING
"bttv%d: Can't enable device.\n",
4571 btv
->state
.disabled
= 1;
4575 pci_restore_state(pci_dev
);
4577 /* restore bt878 state */
4578 bttv_reinit_bt848(btv
);
4579 gpio_inout(0xffffff, btv
->state
.gpio_enable
);
4580 gpio_write(btv
->state
.gpio_data
);
4583 spin_lock_irqsave(&btv
->s_lock
,flags
);
4584 btv
->curr
= btv
->state
.video
;
4585 btv
->cvbi
= btv
->state
.vbi
;
4586 btv
->loop_irq
= btv
->state
.loop_irq
;
4587 bttv_buffer_activate_video(btv
, &btv
->curr
);
4588 bttv_buffer_activate_vbi(btv
, btv
->cvbi
);
4589 bttv_set_dma(btv
, 0);
4590 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
4595 static struct pci_device_id bttv_pci_tbl
[] = {
4596 {PCI_VENDOR_ID_BROOKTREE
, PCI_DEVICE_ID_BT848
,
4597 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
4598 {PCI_VENDOR_ID_BROOKTREE
, PCI_DEVICE_ID_BT849
,
4599 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
4600 {PCI_VENDOR_ID_BROOKTREE
, PCI_DEVICE_ID_BT878
,
4601 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
4602 {PCI_VENDOR_ID_BROOKTREE
, PCI_DEVICE_ID_BT879
,
4603 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
4607 MODULE_DEVICE_TABLE(pci
, bttv_pci_tbl
);
4609 static struct pci_driver bttv_pci_driver
= {
4611 .id_table
= bttv_pci_tbl
,
4612 .probe
= bttv_probe
,
4613 .remove
= __devexit_p(bttv_remove
),
4615 .suspend
= bttv_suspend
,
4616 .resume
= bttv_resume
,
4620 static int __init
bttv_init_module(void)
4626 printk(KERN_INFO
"bttv: driver version %d.%d.%d loaded\n",
4627 (BTTV_VERSION_CODE
>> 16) & 0xff,
4628 (BTTV_VERSION_CODE
>> 8) & 0xff,
4629 BTTV_VERSION_CODE
& 0xff);
4631 printk(KERN_INFO
"bttv: snapshot date %04d-%02d-%02d\n",
4632 SNAPSHOT
/10000, (SNAPSHOT
/100)%100, SNAPSHOT
%100);
4634 if (gbuffers
< 2 || gbuffers
> VIDEO_MAX_FRAME
)
4636 if (gbufsize
> BTTV_MAX_FBUF
)
4637 gbufsize
= BTTV_MAX_FBUF
;
4638 gbufsize
= (gbufsize
+ PAGE_SIZE
- 1) & PAGE_MASK
;
4640 printk(KERN_INFO
"bttv: using %d buffers with %dk (%d pages) each for capture\n",
4641 gbuffers
, gbufsize
>> 10, gbufsize
>> PAGE_SHIFT
);
4643 bttv_check_chipset();
4645 ret
= bus_register(&bttv_sub_bus_type
);
4647 printk(KERN_WARNING
"bttv: bus_register error: %d\n", ret
);
4650 ret
= pci_register_driver(&bttv_pci_driver
);
4652 bus_unregister(&bttv_sub_bus_type
);
4657 static void __exit
bttv_cleanup_module(void)
4659 pci_unregister_driver(&bttv_pci_driver
);
4660 bus_unregister(&bttv_sub_bus_type
);
4663 module_init(bttv_init_module
);
4664 module_exit(bttv_cleanup_module
);