3 bttv - Bt848 frame grabber driver
5 Copyright (C) 1996,97,98 Ralph Metzler <rjkm@thp.uni-koeln.de>
6 & Marcus Metzler <mocm@thp.uni-koeln.de>
7 (c) 1999-2002 Gerd Knorr <kraxel@bytesex.org>
9 some v4l2 code lines are taken from Justin's bttv2 driver which is
10 (c) 2000 Justin Schoeman <justin@suntiger.ee.up.ac.za>
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 #include <linux/init.h>
28 #include <linux/module.h>
29 #include <linux/moduleparam.h>
30 #include <linux/delay.h>
31 #include <linux/errno.h>
33 #include <linux/kernel.h>
34 #include <linux/sched.h>
35 #include <linux/interrupt.h>
36 #include <linux/kdev_t.h>
38 #include <media/v4l2-common.h>
40 #include <linux/dma-mapping.h>
43 #include <asm/byteorder.h>
45 #include <media/rds.h>
48 unsigned int bttv_num
; /* number of Bt848s in use */
49 struct bttv bttvs
[BTTV_MAX
];
51 unsigned int bttv_debug
;
52 unsigned int bttv_verbose
= 1;
53 unsigned int bttv_gpio
;
55 /* config variables */
57 static unsigned int bigendian
=1;
59 static unsigned int bigendian
;
61 static unsigned int radio
[BTTV_MAX
];
62 static unsigned int irq_debug
;
63 static unsigned int gbuffers
= 8;
64 static unsigned int gbufsize
= 0x208000;
66 static int video_nr
= -1;
67 static int radio_nr
= -1;
68 static int vbi_nr
= -1;
69 static int debug_latency
;
71 static unsigned int fdsr
;
74 static unsigned int combfilter
;
75 static unsigned int lumafilter
;
76 static unsigned int automute
= 1;
77 static unsigned int chroma_agc
;
78 static unsigned int adc_crush
= 1;
79 static unsigned int whitecrush_upper
= 0xCF;
80 static unsigned int whitecrush_lower
= 0x7F;
81 static unsigned int vcr_hack
;
82 static unsigned int irq_iswitch
;
83 static unsigned int uv_ratio
= 50;
84 static unsigned int full_luma_range
;
85 static unsigned int coring
;
86 extern int no_overlay
;
88 /* API features (turn on/off stuff for testing) */
89 static unsigned int v4l2
= 1;
92 module_param(bttv_verbose
, int, 0644);
93 module_param(bttv_gpio
, int, 0644);
94 module_param(bttv_debug
, int, 0644);
95 module_param(irq_debug
, int, 0644);
96 module_param(debug_latency
, int, 0644);
98 module_param(fdsr
, int, 0444);
99 module_param(video_nr
, int, 0444);
100 module_param(radio_nr
, int, 0444);
101 module_param(vbi_nr
, int, 0444);
102 module_param(gbuffers
, int, 0444);
103 module_param(gbufsize
, int, 0444);
105 module_param(v4l2
, int, 0644);
106 module_param(bigendian
, int, 0644);
107 module_param(irq_iswitch
, int, 0644);
108 module_param(combfilter
, int, 0444);
109 module_param(lumafilter
, int, 0444);
110 module_param(automute
, int, 0444);
111 module_param(chroma_agc
, int, 0444);
112 module_param(adc_crush
, int, 0444);
113 module_param(whitecrush_upper
, int, 0444);
114 module_param(whitecrush_lower
, int, 0444);
115 module_param(vcr_hack
, int, 0444);
116 module_param(uv_ratio
, int, 0444);
117 module_param(full_luma_range
, int, 0444);
118 module_param(coring
, int, 0444);
120 module_param_array(radio
, int, NULL
, 0444);
122 MODULE_PARM_DESC(radio
,"The TV card supports radio, default is 0 (no)");
123 MODULE_PARM_DESC(bigendian
,"byte order of the framebuffer, default is native endian");
124 MODULE_PARM_DESC(bttv_verbose
,"verbose startup messages, default is 1 (yes)");
125 MODULE_PARM_DESC(bttv_gpio
,"log gpio changes, default is 0 (no)");
126 MODULE_PARM_DESC(bttv_debug
,"debug messages, default is 0 (no)");
127 MODULE_PARM_DESC(irq_debug
,"irq handler debug messages, default is 0 (no)");
128 MODULE_PARM_DESC(gbuffers
,"number of capture buffers. range 2-32, default 8");
129 MODULE_PARM_DESC(gbufsize
,"size of the capture buffers, default is 0x208000");
130 MODULE_PARM_DESC(automute
,"mute audio on bad/missing video signal, default is 1 (yes)");
131 MODULE_PARM_DESC(chroma_agc
,"enables the AGC of chroma signal, default is 0 (no)");
132 MODULE_PARM_DESC(adc_crush
,"enables the luminance ADC crush, default is 1 (yes)");
133 MODULE_PARM_DESC(whitecrush_upper
,"sets the white crush upper value, default is 207");
134 MODULE_PARM_DESC(whitecrush_lower
,"sets the white crush lower value, default is 127");
135 MODULE_PARM_DESC(vcr_hack
,"enables the VCR hack (improves synch on poor VCR tapes), default is 0 (no)");
136 MODULE_PARM_DESC(irq_iswitch
,"switch inputs in irq handler");
137 MODULE_PARM_DESC(uv_ratio
,"ratio between u and v gains, default is 50");
138 MODULE_PARM_DESC(full_luma_range
,"use the full luma range, default is 0 (no)");
139 MODULE_PARM_DESC(coring
,"set the luma coring level, default is 0 (no)");
141 MODULE_DESCRIPTION("bttv - v4l/v4l2 driver module for bt848/878 based cards");
142 MODULE_AUTHOR("Ralph Metzler & Marcus Metzler & Gerd Knorr");
143 MODULE_LICENSE("GPL");
145 /* ----------------------------------------------------------------------- */
148 static ssize_t
show_card(struct class_device
*cd
, char *buf
)
150 struct video_device
*vfd
= to_video_device(cd
);
151 struct bttv
*btv
= dev_get_drvdata(vfd
->dev
);
152 return sprintf(buf
, "%d\n", btv
? btv
->c
.type
: UNSET
);
154 static CLASS_DEVICE_ATTR(card
, S_IRUGO
, show_card
, NULL
);
156 /* ----------------------------------------------------------------------- */
159 /* special timing tables from conexant... */
160 static u8 SRAM_Table
[][60] =
162 /* PAL digital input over GPIO[7:0] */
164 45, // 45 bytes following
165 0x36,0x11,0x01,0x00,0x90,0x02,0x05,0x10,0x04,0x16,
166 0x12,0x05,0x11,0x00,0x04,0x12,0xC0,0x00,0x31,0x00,
167 0x06,0x51,0x08,0x03,0x89,0x08,0x07,0xC0,0x44,0x00,
168 0x81,0x01,0x01,0xA9,0x0D,0x02,0x02,0x50,0x03,0x37,
169 0x37,0x00,0xAF,0x21,0x00
171 /* NTSC digital input over GPIO[7:0] */
173 51, // 51 bytes following
174 0x0C,0xC0,0x00,0x00,0x90,0x02,0x03,0x10,0x03,0x06,
175 0x10,0x04,0x12,0x12,0x05,0x02,0x13,0x04,0x19,0x00,
176 0x04,0x39,0x00,0x06,0x59,0x08,0x03,0x83,0x08,0x07,
177 0x03,0x50,0x00,0xC0,0x40,0x00,0x86,0x01,0x01,0xA6,
178 0x0D,0x02,0x03,0x11,0x01,0x05,0x37,0x00,0xAC,0x21,
181 // TGB_NTSC392 // quartzsight
182 // This table has been modified to be used for Fusion Rev D
184 0x2A, // size of table = 42
185 0x06, 0x08, 0x04, 0x0a, 0xc0, 0x00, 0x18, 0x08, 0x03, 0x24,
186 0x08, 0x07, 0x02, 0x90, 0x02, 0x08, 0x10, 0x04, 0x0c, 0x10,
187 0x05, 0x2c, 0x11, 0x04, 0x55, 0x48, 0x00, 0x05, 0x50, 0x00,
188 0xbf, 0x0c, 0x02, 0x2f, 0x3d, 0x00, 0x2f, 0x3f, 0x00, 0xc3,
193 const struct bttv_tvnorm bttv_tvnorms
[] = {
195 /* max. active video is actually 922, but 924 is divisible by 4 and 3! */
196 /* actually, max active PAL with HSCALE=0 is 948, NTSC is 768 - nil */
198 .v4l2_id
= V4L2_STD_PAL
,
206 .iform
= (BT848_IFORM_PAL_BDGHI
|BT848_IFORM_XT1
),
207 .scaledtwidth
= 1135,
213 /* ITU-R frame line number of the first VBI line
214 we can capture, of the first and second field. */
215 .vbistart
= { 7,320 },
217 .v4l2_id
= V4L2_STD_NTSC_M
| V4L2_STD_NTSC_M_KR
,
225 .iform
= (BT848_IFORM_NTSC
|BT848_IFORM_XT0
),
232 .vbistart
= { 10, 273 },
234 .v4l2_id
= V4L2_STD_SECAM
,
242 .iform
= (BT848_IFORM_SECAM
|BT848_IFORM_XT1
),
243 .scaledtwidth
= 1135,
248 .sram
= 0, /* like PAL, correct? */
249 .vbistart
= { 7, 320 },
251 .v4l2_id
= V4L2_STD_PAL_Nc
,
259 .iform
= (BT848_IFORM_PAL_NC
|BT848_IFORM_XT0
),
266 .vbistart
= { 7, 320 },
268 .v4l2_id
= V4L2_STD_PAL_M
,
276 .iform
= (BT848_IFORM_PAL_M
|BT848_IFORM_XT0
),
283 .vbistart
= { 10, 273 },
285 .v4l2_id
= V4L2_STD_PAL_N
,
293 .iform
= (BT848_IFORM_PAL_N
|BT848_IFORM_XT1
),
300 .vbistart
= { 7, 320},
302 .v4l2_id
= V4L2_STD_NTSC_M_JP
,
310 .iform
= (BT848_IFORM_NTSC_J
|BT848_IFORM_XT0
),
317 .vbistart
= {10, 273},
319 /* that one hopefully works with the strange timing
320 * which video recorders produce when playing a NTSC
321 * tape on a PAL TV ... */
322 .v4l2_id
= V4L2_STD_PAL_60
,
330 .iform
= (BT848_IFORM_PAL_BDGHI
|BT848_IFORM_XT1
),
331 .scaledtwidth
= 1135,
338 .vbistart
= { 10, 273 },
341 static const unsigned int BTTV_TVNORMS
= ARRAY_SIZE(bttv_tvnorms
);
343 /* ----------------------------------------------------------------------- */
345 packed pixel formats must come first */
346 static const struct bttv_format bttv_formats
[] = {
348 .name
= "8 bpp, gray",
349 .palette
= VIDEO_PALETTE_GREY
,
350 .fourcc
= V4L2_PIX_FMT_GREY
,
351 .btformat
= BT848_COLOR_FMT_Y8
,
353 .flags
= FORMAT_FLAGS_PACKED
,
355 .name
= "8 bpp, dithered color",
356 .palette
= VIDEO_PALETTE_HI240
,
357 .fourcc
= V4L2_PIX_FMT_HI240
,
358 .btformat
= BT848_COLOR_FMT_RGB8
,
360 .flags
= FORMAT_FLAGS_PACKED
| FORMAT_FLAGS_DITHER
,
362 .name
= "15 bpp RGB, le",
363 .palette
= VIDEO_PALETTE_RGB555
,
364 .fourcc
= V4L2_PIX_FMT_RGB555
,
365 .btformat
= BT848_COLOR_FMT_RGB15
,
367 .flags
= FORMAT_FLAGS_PACKED
,
369 .name
= "15 bpp RGB, be",
371 .fourcc
= V4L2_PIX_FMT_RGB555X
,
372 .btformat
= BT848_COLOR_FMT_RGB15
,
373 .btswap
= 0x03, /* byteswap */
375 .flags
= FORMAT_FLAGS_PACKED
,
377 .name
= "16 bpp RGB, le",
378 .palette
= VIDEO_PALETTE_RGB565
,
379 .fourcc
= V4L2_PIX_FMT_RGB565
,
380 .btformat
= BT848_COLOR_FMT_RGB16
,
382 .flags
= FORMAT_FLAGS_PACKED
,
384 .name
= "16 bpp RGB, be",
386 .fourcc
= V4L2_PIX_FMT_RGB565X
,
387 .btformat
= BT848_COLOR_FMT_RGB16
,
388 .btswap
= 0x03, /* byteswap */
390 .flags
= FORMAT_FLAGS_PACKED
,
392 .name
= "24 bpp RGB, le",
393 .palette
= VIDEO_PALETTE_RGB24
,
394 .fourcc
= V4L2_PIX_FMT_BGR24
,
395 .btformat
= BT848_COLOR_FMT_RGB24
,
397 .flags
= FORMAT_FLAGS_PACKED
,
399 .name
= "32 bpp RGB, le",
400 .palette
= VIDEO_PALETTE_RGB32
,
401 .fourcc
= V4L2_PIX_FMT_BGR32
,
402 .btformat
= BT848_COLOR_FMT_RGB32
,
404 .flags
= FORMAT_FLAGS_PACKED
,
406 .name
= "32 bpp RGB, be",
408 .fourcc
= V4L2_PIX_FMT_RGB32
,
409 .btformat
= BT848_COLOR_FMT_RGB32
,
410 .btswap
= 0x0f, /* byte+word swap */
412 .flags
= FORMAT_FLAGS_PACKED
,
414 .name
= "4:2:2, packed, YUYV",
415 .palette
= VIDEO_PALETTE_YUV422
,
416 .fourcc
= V4L2_PIX_FMT_YUYV
,
417 .btformat
= BT848_COLOR_FMT_YUY2
,
419 .flags
= FORMAT_FLAGS_PACKED
,
421 .name
= "4:2:2, packed, YUYV",
422 .palette
= VIDEO_PALETTE_YUYV
,
423 .fourcc
= V4L2_PIX_FMT_YUYV
,
424 .btformat
= BT848_COLOR_FMT_YUY2
,
426 .flags
= FORMAT_FLAGS_PACKED
,
428 .name
= "4:2:2, packed, UYVY",
429 .palette
= VIDEO_PALETTE_UYVY
,
430 .fourcc
= V4L2_PIX_FMT_UYVY
,
431 .btformat
= BT848_COLOR_FMT_YUY2
,
432 .btswap
= 0x03, /* byteswap */
434 .flags
= FORMAT_FLAGS_PACKED
,
436 .name
= "4:2:2, planar, Y-Cb-Cr",
437 .palette
= VIDEO_PALETTE_YUV422P
,
438 .fourcc
= V4L2_PIX_FMT_YUV422P
,
439 .btformat
= BT848_COLOR_FMT_YCrCb422
,
441 .flags
= FORMAT_FLAGS_PLANAR
,
445 .name
= "4:2:0, planar, Y-Cb-Cr",
446 .palette
= VIDEO_PALETTE_YUV420P
,
447 .fourcc
= V4L2_PIX_FMT_YUV420
,
448 .btformat
= BT848_COLOR_FMT_YCrCb422
,
450 .flags
= FORMAT_FLAGS_PLANAR
,
454 .name
= "4:2:0, planar, Y-Cr-Cb",
456 .fourcc
= V4L2_PIX_FMT_YVU420
,
457 .btformat
= BT848_COLOR_FMT_YCrCb422
,
459 .flags
= FORMAT_FLAGS_PLANAR
| FORMAT_FLAGS_CrCb
,
463 .name
= "4:1:1, planar, Y-Cb-Cr",
464 .palette
= VIDEO_PALETTE_YUV411P
,
465 .fourcc
= V4L2_PIX_FMT_YUV411P
,
466 .btformat
= BT848_COLOR_FMT_YCrCb411
,
468 .flags
= FORMAT_FLAGS_PLANAR
,
472 .name
= "4:1:0, planar, Y-Cb-Cr",
473 .palette
= VIDEO_PALETTE_YUV410P
,
474 .fourcc
= V4L2_PIX_FMT_YUV410
,
475 .btformat
= BT848_COLOR_FMT_YCrCb411
,
477 .flags
= FORMAT_FLAGS_PLANAR
,
481 .name
= "4:1:0, planar, Y-Cr-Cb",
483 .fourcc
= V4L2_PIX_FMT_YVU410
,
484 .btformat
= BT848_COLOR_FMT_YCrCb411
,
486 .flags
= FORMAT_FLAGS_PLANAR
| FORMAT_FLAGS_CrCb
,
490 .name
= "raw scanlines",
491 .palette
= VIDEO_PALETTE_RAW
,
493 .btformat
= BT848_COLOR_FMT_RAW
,
495 .flags
= FORMAT_FLAGS_RAW
,
498 static const unsigned int BTTV_FORMATS
= ARRAY_SIZE(bttv_formats
);
500 /* ----------------------------------------------------------------------- */
502 #define V4L2_CID_PRIVATE_CHROMA_AGC (V4L2_CID_PRIVATE_BASE + 0)
503 #define V4L2_CID_PRIVATE_COMBFILTER (V4L2_CID_PRIVATE_BASE + 1)
504 #define V4L2_CID_PRIVATE_AUTOMUTE (V4L2_CID_PRIVATE_BASE + 2)
505 #define V4L2_CID_PRIVATE_LUMAFILTER (V4L2_CID_PRIVATE_BASE + 3)
506 #define V4L2_CID_PRIVATE_AGC_CRUSH (V4L2_CID_PRIVATE_BASE + 4)
507 #define V4L2_CID_PRIVATE_VCR_HACK (V4L2_CID_PRIVATE_BASE + 5)
508 #define V4L2_CID_PRIVATE_WHITECRUSH_UPPER (V4L2_CID_PRIVATE_BASE + 6)
509 #define V4L2_CID_PRIVATE_WHITECRUSH_LOWER (V4L2_CID_PRIVATE_BASE + 7)
510 #define V4L2_CID_PRIVATE_UV_RATIO (V4L2_CID_PRIVATE_BASE + 8)
511 #define V4L2_CID_PRIVATE_FULL_LUMA_RANGE (V4L2_CID_PRIVATE_BASE + 9)
512 #define V4L2_CID_PRIVATE_CORING (V4L2_CID_PRIVATE_BASE + 10)
513 #define V4L2_CID_PRIVATE_LASTP1 (V4L2_CID_PRIVATE_BASE + 11)
515 static const struct v4l2_queryctrl no_ctl
= {
517 .flags
= V4L2_CTRL_FLAG_DISABLED
,
519 static const struct v4l2_queryctrl bttv_ctls
[] = {
522 .id
= V4L2_CID_BRIGHTNESS
,
523 .name
= "Brightness",
527 .default_value
= 32768,
528 .type
= V4L2_CTRL_TYPE_INTEGER
,
530 .id
= V4L2_CID_CONTRAST
,
535 .default_value
= 32768,
536 .type
= V4L2_CTRL_TYPE_INTEGER
,
538 .id
= V4L2_CID_SATURATION
,
539 .name
= "Saturation",
543 .default_value
= 32768,
544 .type
= V4L2_CTRL_TYPE_INTEGER
,
551 .default_value
= 32768,
552 .type
= V4L2_CTRL_TYPE_INTEGER
,
556 .id
= V4L2_CID_AUDIO_MUTE
,
560 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
562 .id
= V4L2_CID_AUDIO_VOLUME
,
567 .default_value
= 65535,
568 .type
= V4L2_CTRL_TYPE_INTEGER
,
570 .id
= V4L2_CID_AUDIO_BALANCE
,
575 .default_value
= 32768,
576 .type
= V4L2_CTRL_TYPE_INTEGER
,
578 .id
= V4L2_CID_AUDIO_BASS
,
583 .default_value
= 32768,
584 .type
= V4L2_CTRL_TYPE_INTEGER
,
586 .id
= V4L2_CID_AUDIO_TREBLE
,
591 .default_value
= 32768,
592 .type
= V4L2_CTRL_TYPE_INTEGER
,
594 /* --- private --- */
596 .id
= V4L2_CID_PRIVATE_CHROMA_AGC
,
597 .name
= "chroma agc",
600 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
602 .id
= V4L2_CID_PRIVATE_COMBFILTER
,
603 .name
= "combfilter",
606 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
608 .id
= V4L2_CID_PRIVATE_AUTOMUTE
,
612 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
614 .id
= V4L2_CID_PRIVATE_LUMAFILTER
,
615 .name
= "luma decimation filter",
618 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
620 .id
= V4L2_CID_PRIVATE_AGC_CRUSH
,
624 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
626 .id
= V4L2_CID_PRIVATE_VCR_HACK
,
630 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
632 .id
= V4L2_CID_PRIVATE_WHITECRUSH_UPPER
,
633 .name
= "whitecrush upper",
637 .default_value
= 0xCF,
638 .type
= V4L2_CTRL_TYPE_INTEGER
,
640 .id
= V4L2_CID_PRIVATE_WHITECRUSH_LOWER
,
641 .name
= "whitecrush lower",
645 .default_value
= 0x7F,
646 .type
= V4L2_CTRL_TYPE_INTEGER
,
648 .id
= V4L2_CID_PRIVATE_UV_RATIO
,
654 .type
= V4L2_CTRL_TYPE_INTEGER
,
656 .id
= V4L2_CID_PRIVATE_FULL_LUMA_RANGE
,
657 .name
= "full luma range",
660 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
662 .id
= V4L2_CID_PRIVATE_CORING
,
668 .type
= V4L2_CTRL_TYPE_INTEGER
,
674 static const int BTTV_CTLS
= ARRAY_SIZE(bttv_ctls
);
676 /* ----------------------------------------------------------------------- */
677 /* resource management */
680 int check_alloc_btres(struct bttv
*btv
, struct bttv_fh
*fh
, int bit
)
682 if (fh
->resources
& bit
)
683 /* have it already allocated */
687 mutex_lock(&btv
->reslock
);
688 if (btv
->resources
& bit
) {
689 /* no, someone else uses it */
690 mutex_unlock(&btv
->reslock
);
693 /* it's free, grab it */
694 fh
->resources
|= bit
;
695 btv
->resources
|= bit
;
696 mutex_unlock(&btv
->reslock
);
701 int check_btres(struct bttv_fh
*fh
, int bit
)
703 return (fh
->resources
& bit
);
707 int locked_btres(struct bttv
*btv
, int bit
)
709 return (btv
->resources
& bit
);
713 void free_btres(struct bttv
*btv
, struct bttv_fh
*fh
, int bits
)
715 if ((fh
->resources
& bits
) != bits
) {
716 /* trying to free ressources not allocated by us ... */
717 printk("bttv: BUG! (btres)\n");
719 mutex_lock(&btv
->reslock
);
720 fh
->resources
&= ~bits
;
721 btv
->resources
&= ~bits
;
722 mutex_unlock(&btv
->reslock
);
725 /* ----------------------------------------------------------------------- */
726 /* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC */
728 /* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C
729 PLL_X = Reference pre-divider (0=1, 1=2)
730 PLL_C = Post divider (0=6, 1=4)
731 PLL_I = Integer input
732 PLL_F = Fractional input
734 F_input = 28.636363 MHz:
735 PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0
738 static void set_pll_freq(struct bttv
*btv
, unsigned int fin
, unsigned int fout
)
740 unsigned char fl
, fh
, fi
;
742 /* prevent overflows */
755 btwrite(fl
, BT848_PLL_F_LO
);
756 btwrite(fh
, BT848_PLL_F_HI
);
757 btwrite(fi
|BT848_PLL_X
, BT848_PLL_XCI
);
760 static void set_pll(struct bttv
*btv
)
764 if (!btv
->pll
.pll_crystal
)
767 if (btv
->pll
.pll_ofreq
== btv
->pll
.pll_current
) {
768 dprintk("bttv%d: PLL: no change required\n",btv
->c
.nr
);
772 if (btv
->pll
.pll_ifreq
== btv
->pll
.pll_ofreq
) {
774 if (btv
->pll
.pll_current
== 0)
776 bttv_printk(KERN_INFO
"bttv%d: PLL can sleep, using XTAL (%d).\n",
777 btv
->c
.nr
,btv
->pll
.pll_ifreq
);
778 btwrite(0x00,BT848_TGCTRL
);
779 btwrite(0x00,BT848_PLL_XCI
);
780 btv
->pll
.pll_current
= 0;
784 bttv_printk(KERN_INFO
"bttv%d: PLL: %d => %d ",btv
->c
.nr
,
785 btv
->pll
.pll_ifreq
, btv
->pll
.pll_ofreq
);
786 set_pll_freq(btv
, btv
->pll
.pll_ifreq
, btv
->pll
.pll_ofreq
);
788 for (i
=0; i
<10; i
++) {
789 /* Let other people run while the PLL stabilizes */
793 if (btread(BT848_DSTATUS
) & BT848_DSTATUS_PLOCK
) {
794 btwrite(0,BT848_DSTATUS
);
796 btwrite(0x08,BT848_TGCTRL
);
797 btv
->pll
.pll_current
= btv
->pll
.pll_ofreq
;
798 bttv_printk(" ok\n");
802 btv
->pll
.pll_current
= -1;
803 bttv_printk("failed\n");
807 /* used to switch between the bt848's analog/digital video capture modes */
808 static void bt848A_set_timing(struct bttv
*btv
)
811 int table_idx
= bttv_tvnorms
[btv
->tvnorm
].sram
;
812 int fsc
= bttv_tvnorms
[btv
->tvnorm
].Fsc
;
814 if (UNSET
== bttv_tvcards
[btv
->c
.type
].muxsel
[btv
->input
]) {
815 dprintk("bttv%d: load digital timing table (table_idx=%d)\n",
816 btv
->c
.nr
,table_idx
);
818 /* timing change...reset timing generator address */
819 btwrite(0x00, BT848_TGCTRL
);
820 btwrite(0x02, BT848_TGCTRL
);
821 btwrite(0x00, BT848_TGCTRL
);
823 len
=SRAM_Table
[table_idx
][0];
824 for(i
= 1; i
<= len
; i
++)
825 btwrite(SRAM_Table
[table_idx
][i
],BT848_TGLB
);
826 btv
->pll
.pll_ofreq
= 27000000;
829 btwrite(0x11, BT848_TGCTRL
);
830 btwrite(0x41, BT848_DVSIF
);
832 btv
->pll
.pll_ofreq
= fsc
;
834 btwrite(0x0, BT848_DVSIF
);
838 /* ----------------------------------------------------------------------- */
840 static void bt848_bright(struct bttv
*btv
, int bright
)
844 // printk("bttv: set bright: %d\n",bright); // DEBUG
845 btv
->bright
= bright
;
847 /* We want -128 to 127 we get 0-65535 */
848 value
= (bright
>> 8) - 128;
849 btwrite(value
& 0xff, BT848_BRIGHT
);
852 static void bt848_hue(struct bttv
*btv
, int hue
)
859 value
= (hue
>> 8) - 128;
860 btwrite(value
& 0xff, BT848_HUE
);
863 static void bt848_contrast(struct bttv
*btv
, int cont
)
867 btv
->contrast
= cont
;
871 hibit
= (value
>> 6) & 4;
872 btwrite(value
& 0xff, BT848_CONTRAST_LO
);
873 btaor(hibit
, ~4, BT848_E_CONTROL
);
874 btaor(hibit
, ~4, BT848_O_CONTROL
);
877 static void bt848_sat(struct bttv
*btv
, int color
)
879 int val_u
,val_v
,hibits
;
881 btv
->saturation
= color
;
883 /* 0-511 for the color */
884 val_u
= ((color
* btv
->opt_uv_ratio
) / 50) >> 7;
885 val_v
= (((color
* (100 - btv
->opt_uv_ratio
) / 50) >>7)*180L)/254;
886 hibits
= (val_u
>> 7) & 2;
887 hibits
|= (val_v
>> 8) & 1;
888 btwrite(val_u
& 0xff, BT848_SAT_U_LO
);
889 btwrite(val_v
& 0xff, BT848_SAT_V_LO
);
890 btaor(hibits
, ~3, BT848_E_CONTROL
);
891 btaor(hibits
, ~3, BT848_O_CONTROL
);
894 /* ----------------------------------------------------------------------- */
897 video_mux(struct bttv
*btv
, unsigned int input
)
901 if (input
>= bttv_tvcards
[btv
->c
.type
].video_inputs
)
904 /* needed by RemoteVideo MX */
905 mask2
= bttv_tvcards
[btv
->c
.type
].gpiomask2
;
907 gpio_inout(mask2
,mask2
);
909 if (input
== btv
->svhs
) {
910 btor(BT848_CONTROL_COMP
, BT848_E_CONTROL
);
911 btor(BT848_CONTROL_COMP
, BT848_O_CONTROL
);
913 btand(~BT848_CONTROL_COMP
, BT848_E_CONTROL
);
914 btand(~BT848_CONTROL_COMP
, BT848_O_CONTROL
);
916 mux
= bttv_tvcards
[btv
->c
.type
].muxsel
[input
] & 3;
917 btaor(mux
<<5, ~(3<<5), BT848_IFORM
);
918 dprintk(KERN_DEBUG
"bttv%d: video mux: input=%d mux=%d\n",
919 btv
->c
.nr
,input
,mux
);
921 /* card specific hook */
922 if(bttv_tvcards
[btv
->c
.type
].muxsel_hook
)
923 bttv_tvcards
[btv
->c
.type
].muxsel_hook (btv
, input
);
927 static char *audio_modes
[] = {
928 "audio: tuner", "audio: radio", "audio: extern",
929 "audio: intern", "audio: off"
933 audio_mux(struct bttv
*btv
, int mode
)
935 int val
,mux
,i2c_mux
,signal
;
937 gpio_inout(bttv_tvcards
[btv
->c
.type
].gpiomask
,
938 bttv_tvcards
[btv
->c
.type
].gpiomask
);
939 signal
= btread(BT848_DSTATUS
) & BT848_DSTATUS_HLOC
;
943 btv
->audio
|= AUDIO_MUTE
;
946 btv
->audio
&= ~AUDIO_MUTE
;
952 btv
->audio
&= AUDIO_MUTE
;
955 i2c_mux
= mux
= (btv
->audio
& AUDIO_MUTE
) ? AUDIO_OFF
: btv
->audio
;
956 if (btv
->opt_automute
&& !signal
&& !btv
->radio_user
)
959 val
= bttv_tvcards
[btv
->c
.type
].audiomux
[mux
];
960 gpio_bits(bttv_tvcards
[btv
->c
.type
].gpiomask
,val
);
962 bttv_gpio_tracking(btv
,audio_modes
[mux
]);
964 bttv_call_i2c_clients(btv
,AUDC_SET_INPUT
,&(i2c_mux
));
969 i2c_vidiocschan(struct bttv
*btv
)
971 struct video_channel c
;
973 memset(&c
,0,sizeof(c
));
974 c
.norm
= btv
->tvnorm
;
975 c
.channel
= btv
->input
;
976 bttv_call_i2c_clients(btv
,VIDIOCSCHAN
,&c
);
977 if (btv
->c
.type
== BTTV_BOARD_VOODOOTV_FM
)
978 bttv_tda9880_setnorm(btv
,c
.norm
);
982 set_tvnorm(struct bttv
*btv
, unsigned int norm
)
984 const struct bttv_tvnorm
*tvnorm
;
986 if (norm
< 0 || norm
>= BTTV_TVNORMS
)
990 tvnorm
= &bttv_tvnorms
[norm
];
992 btwrite(tvnorm
->adelay
, BT848_ADELAY
);
993 btwrite(tvnorm
->bdelay
, BT848_BDELAY
);
994 btaor(tvnorm
->iform
,~(BT848_IFORM_NORM
|BT848_IFORM_XTBOTH
),
996 btwrite(tvnorm
->vbipack
, BT848_VBI_PACK_SIZE
);
997 btwrite(1, BT848_VBI_PACK_DEL
);
998 bt848A_set_timing(btv
);
1000 switch (btv
->c
.type
) {
1001 case BTTV_BOARD_VOODOOTV_FM
:
1002 bttv_tda9880_setnorm(btv
,norm
);
1009 set_input(struct bttv
*btv
, unsigned int input
)
1011 unsigned long flags
;
1015 spin_lock_irqsave(&btv
->s_lock
,flags
);
1016 if (btv
->curr
.frame_irq
) {
1017 /* active capture -> delayed input switch */
1018 btv
->new_input
= input
;
1020 video_mux(btv
,input
);
1022 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
1024 video_mux(btv
,input
);
1026 audio_mux(btv
,(input
== bttv_tvcards
[btv
->c
.type
].tuner
?
1027 AUDIO_TUNER
: AUDIO_EXTERN
));
1028 set_tvnorm(btv
,btv
->tvnorm
);
1029 i2c_vidiocschan(btv
);
1032 static void init_irqreg(struct bttv
*btv
)
1035 btwrite(0xfffffUL
, BT848_INT_STAT
);
1037 if (bttv_tvcards
[btv
->c
.type
].no_video
) {
1039 btwrite(BT848_INT_I2CDONE
,
1043 btwrite((btv
->triton1
) |
1044 (btv
->gpioirq
? BT848_INT_GPINT
: 0) |
1046 (fdsr
? BT848_INT_FDSR
: 0) |
1047 BT848_INT_RISCI
|BT848_INT_OCERR
|BT848_INT_VPRES
|
1048 BT848_INT_FMTCHG
|BT848_INT_HLOCK
|
1054 static void init_bt848(struct bttv
*btv
)
1058 if (bttv_tvcards
[btv
->c
.type
].no_video
) {
1059 /* very basic init only */
1064 btwrite(0x00, BT848_CAP_CTL
);
1065 btwrite(BT848_COLOR_CTL_GAMMA
, BT848_COLOR_CTL
);
1066 btwrite(BT848_IFORM_XTAUTO
| BT848_IFORM_AUTO
, BT848_IFORM
);
1068 /* set planar and packed mode trigger points and */
1069 /* set rising edge of inverted GPINTR pin as irq trigger */
1070 btwrite(BT848_GPIO_DMA_CTL_PKTP_32
|
1071 BT848_GPIO_DMA_CTL_PLTP1_16
|
1072 BT848_GPIO_DMA_CTL_PLTP23_16
|
1073 BT848_GPIO_DMA_CTL_GPINTC
|
1074 BT848_GPIO_DMA_CTL_GPINTI
,
1075 BT848_GPIO_DMA_CTL
);
1077 val
= btv
->opt_chroma_agc
? BT848_SCLOOP_CAGC
: 0;
1078 btwrite(val
, BT848_E_SCLOOP
);
1079 btwrite(val
, BT848_O_SCLOOP
);
1081 btwrite(0x20, BT848_E_VSCALE_HI
);
1082 btwrite(0x20, BT848_O_VSCALE_HI
);
1083 btwrite(BT848_ADC_RESERVED
| (btv
->opt_adc_crush
? BT848_ADC_CRUSH
: 0),
1086 btwrite(whitecrush_upper
, BT848_WC_UP
);
1087 btwrite(whitecrush_lower
, BT848_WC_DOWN
);
1089 if (btv
->opt_lumafilter
) {
1090 btwrite(0, BT848_E_CONTROL
);
1091 btwrite(0, BT848_O_CONTROL
);
1093 btwrite(BT848_CONTROL_LDEC
, BT848_E_CONTROL
);
1094 btwrite(BT848_CONTROL_LDEC
, BT848_O_CONTROL
);
1097 bt848_bright(btv
, btv
->bright
);
1098 bt848_hue(btv
, btv
->hue
);
1099 bt848_contrast(btv
, btv
->contrast
);
1100 bt848_sat(btv
, btv
->saturation
);
1106 static void bttv_reinit_bt848(struct bttv
*btv
)
1108 unsigned long flags
;
1111 printk(KERN_INFO
"bttv%d: reset, reinitialize\n",btv
->c
.nr
);
1112 spin_lock_irqsave(&btv
->s_lock
,flags
);
1114 bttv_set_dma(btv
,0);
1115 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
1118 btv
->pll
.pll_current
= -1;
1119 set_input(btv
,btv
->input
);
1122 static int get_control(struct bttv
*btv
, struct v4l2_control
*c
)
1124 struct video_audio va
;
1127 for (i
= 0; i
< BTTV_CTLS
; i
++)
1128 if (bttv_ctls
[i
].id
== c
->id
)
1132 if (i
>= 4 && i
<= 8) {
1133 memset(&va
,0,sizeof(va
));
1134 bttv_call_i2c_clients(btv
, VIDIOCGAUDIO
, &va
);
1135 if (btv
->audio_hook
)
1136 btv
->audio_hook(btv
,&va
,0);
1139 case V4L2_CID_BRIGHTNESS
:
1140 c
->value
= btv
->bright
;
1143 c
->value
= btv
->hue
;
1145 case V4L2_CID_CONTRAST
:
1146 c
->value
= btv
->contrast
;
1148 case V4L2_CID_SATURATION
:
1149 c
->value
= btv
->saturation
;
1152 case V4L2_CID_AUDIO_MUTE
:
1153 c
->value
= (VIDEO_AUDIO_MUTE
& va
.flags
) ? 1 : 0;
1155 case V4L2_CID_AUDIO_VOLUME
:
1156 c
->value
= va
.volume
;
1158 case V4L2_CID_AUDIO_BALANCE
:
1159 c
->value
= va
.balance
;
1161 case V4L2_CID_AUDIO_BASS
:
1164 case V4L2_CID_AUDIO_TREBLE
:
1165 c
->value
= va
.treble
;
1168 case V4L2_CID_PRIVATE_CHROMA_AGC
:
1169 c
->value
= btv
->opt_chroma_agc
;
1171 case V4L2_CID_PRIVATE_COMBFILTER
:
1172 c
->value
= btv
->opt_combfilter
;
1174 case V4L2_CID_PRIVATE_LUMAFILTER
:
1175 c
->value
= btv
->opt_lumafilter
;
1177 case V4L2_CID_PRIVATE_AUTOMUTE
:
1178 c
->value
= btv
->opt_automute
;
1180 case V4L2_CID_PRIVATE_AGC_CRUSH
:
1181 c
->value
= btv
->opt_adc_crush
;
1183 case V4L2_CID_PRIVATE_VCR_HACK
:
1184 c
->value
= btv
->opt_vcr_hack
;
1186 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER
:
1187 c
->value
= btv
->opt_whitecrush_upper
;
1189 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER
:
1190 c
->value
= btv
->opt_whitecrush_lower
;
1192 case V4L2_CID_PRIVATE_UV_RATIO
:
1193 c
->value
= btv
->opt_uv_ratio
;
1195 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE
:
1196 c
->value
= btv
->opt_full_luma_range
;
1198 case V4L2_CID_PRIVATE_CORING
:
1199 c
->value
= btv
->opt_coring
;
1207 static int set_control(struct bttv
*btv
, struct v4l2_control
*c
)
1209 struct video_audio va
;
1212 for (i
= 0; i
< BTTV_CTLS
; i
++)
1213 if (bttv_ctls
[i
].id
== c
->id
)
1217 if (i
>= 4 && i
<= 8) {
1218 memset(&va
,0,sizeof(va
));
1219 bttv_call_i2c_clients(btv
, VIDIOCGAUDIO
, &va
);
1220 if (btv
->audio_hook
)
1221 btv
->audio_hook(btv
,&va
,0);
1224 case V4L2_CID_BRIGHTNESS
:
1225 bt848_bright(btv
,c
->value
);
1228 bt848_hue(btv
,c
->value
);
1230 case V4L2_CID_CONTRAST
:
1231 bt848_contrast(btv
,c
->value
);
1233 case V4L2_CID_SATURATION
:
1234 bt848_sat(btv
,c
->value
);
1236 case V4L2_CID_AUDIO_MUTE
:
1238 va
.flags
|= VIDEO_AUDIO_MUTE
;
1239 audio_mux(btv
, AUDIO_MUTE
);
1241 va
.flags
&= ~VIDEO_AUDIO_MUTE
;
1242 audio_mux(btv
, AUDIO_UNMUTE
);
1246 case V4L2_CID_AUDIO_VOLUME
:
1247 va
.volume
= c
->value
;
1249 case V4L2_CID_AUDIO_BALANCE
:
1250 va
.balance
= c
->value
;
1252 case V4L2_CID_AUDIO_BASS
:
1255 case V4L2_CID_AUDIO_TREBLE
:
1256 va
.treble
= c
->value
;
1259 case V4L2_CID_PRIVATE_CHROMA_AGC
:
1260 btv
->opt_chroma_agc
= c
->value
;
1261 val
= btv
->opt_chroma_agc
? BT848_SCLOOP_CAGC
: 0;
1262 btwrite(val
, BT848_E_SCLOOP
);
1263 btwrite(val
, BT848_O_SCLOOP
);
1265 case V4L2_CID_PRIVATE_COMBFILTER
:
1266 btv
->opt_combfilter
= c
->value
;
1268 case V4L2_CID_PRIVATE_LUMAFILTER
:
1269 btv
->opt_lumafilter
= c
->value
;
1270 if (btv
->opt_lumafilter
) {
1271 btand(~BT848_CONTROL_LDEC
, BT848_E_CONTROL
);
1272 btand(~BT848_CONTROL_LDEC
, BT848_O_CONTROL
);
1274 btor(BT848_CONTROL_LDEC
, BT848_E_CONTROL
);
1275 btor(BT848_CONTROL_LDEC
, BT848_O_CONTROL
);
1278 case V4L2_CID_PRIVATE_AUTOMUTE
:
1279 btv
->opt_automute
= c
->value
;
1281 case V4L2_CID_PRIVATE_AGC_CRUSH
:
1282 btv
->opt_adc_crush
= c
->value
;
1283 btwrite(BT848_ADC_RESERVED
| (btv
->opt_adc_crush
? BT848_ADC_CRUSH
: 0),
1286 case V4L2_CID_PRIVATE_VCR_HACK
:
1287 btv
->opt_vcr_hack
= c
->value
;
1289 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER
:
1290 btv
->opt_whitecrush_upper
= c
->value
;
1291 btwrite(c
->value
, BT848_WC_UP
);
1293 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER
:
1294 btv
->opt_whitecrush_lower
= c
->value
;
1295 btwrite(c
->value
, BT848_WC_DOWN
);
1297 case V4L2_CID_PRIVATE_UV_RATIO
:
1298 btv
->opt_uv_ratio
= c
->value
;
1299 bt848_sat(btv
, btv
->saturation
);
1301 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE
:
1302 btv
->opt_full_luma_range
= c
->value
;
1303 btaor((c
->value
<<7), ~BT848_OFORM_RANGE
, BT848_OFORM
);
1305 case V4L2_CID_PRIVATE_CORING
:
1306 btv
->opt_coring
= c
->value
;
1307 btaor((c
->value
<<5), ~BT848_OFORM_CORE32
, BT848_OFORM
);
1312 if (i
>= 4 && i
<= 8) {
1313 bttv_call_i2c_clients(btv
, VIDIOCSAUDIO
, &va
);
1314 if (btv
->audio_hook
)
1315 btv
->audio_hook(btv
,&va
,1);
1320 /* ----------------------------------------------------------------------- */
1322 void bttv_gpio_tracking(struct bttv
*btv
, char *comment
)
1324 unsigned int outbits
, data
;
1325 outbits
= btread(BT848_GPIO_OUT_EN
);
1326 data
= btread(BT848_GPIO_DATA
);
1327 printk(KERN_DEBUG
"bttv%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
1328 btv
->c
.nr
,outbits
,data
& outbits
, data
& ~outbits
, comment
);
1331 static void bttv_field_count(struct bttv
*btv
)
1339 /* start field counter */
1340 btor(BT848_INT_VSYNC
,BT848_INT_MASK
);
1342 /* stop field counter */
1343 btand(~BT848_INT_VSYNC
,BT848_INT_MASK
);
1344 btv
->field_count
= 0;
1348 static const struct bttv_format
*
1349 format_by_palette(int palette
)
1353 for (i
= 0; i
< BTTV_FORMATS
; i
++) {
1354 if (-1 == bttv_formats
[i
].palette
)
1356 if (bttv_formats
[i
].palette
== palette
)
1357 return bttv_formats
+i
;
1362 static const struct bttv_format
*
1363 format_by_fourcc(int fourcc
)
1367 for (i
= 0; i
< BTTV_FORMATS
; i
++) {
1368 if (-1 == bttv_formats
[i
].fourcc
)
1370 if (bttv_formats
[i
].fourcc
== fourcc
)
1371 return bttv_formats
+i
;
1376 /* ----------------------------------------------------------------------- */
1380 bttv_switch_overlay(struct bttv
*btv
, struct bttv_fh
*fh
,
1381 struct bttv_buffer
*new)
1383 struct bttv_buffer
*old
;
1384 unsigned long flags
;
1387 dprintk("switch_overlay: enter [new=%p]\n",new);
1389 new->vb
.state
= STATE_DONE
;
1390 spin_lock_irqsave(&btv
->s_lock
,flags
);
1394 bttv_set_dma(btv
, 0x03);
1395 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
1397 free_btres(btv
,fh
,RESOURCE_OVERLAY
);
1399 dprintk("switch_overlay: old=%p state is %d\n",old
,old
->vb
.state
);
1400 bttv_dma_free(&fh
->cap
,btv
, old
);
1403 dprintk("switch_overlay: done\n");
1407 /* ----------------------------------------------------------------------- */
1408 /* video4linux (1) interface */
1410 static int bttv_prepare_buffer(struct videobuf_queue
*q
,struct bttv
*btv
,
1411 struct bttv_buffer
*buf
,
1412 const struct bttv_format
*fmt
,
1413 unsigned int width
, unsigned int height
,
1414 enum v4l2_field field
)
1416 int redo_dma_risc
= 0;
1419 /* check settings */
1422 if (fmt
->btformat
== BT848_COLOR_FMT_RAW
) {
1424 height
= RAW_LINES
*2;
1425 if (width
*height
> buf
->vb
.bsize
)
1427 buf
->vb
.size
= buf
->vb
.bsize
;
1431 width
> bttv_tvnorms
[btv
->tvnorm
].swidth
||
1432 height
> bttv_tvnorms
[btv
->tvnorm
].sheight
)
1434 buf
->vb
.size
= (width
* height
* fmt
->depth
) >> 3;
1435 if (0 != buf
->vb
.baddr
&& buf
->vb
.bsize
< buf
->vb
.size
)
1439 /* alloc + fill struct bttv_buffer (if changed) */
1440 if (buf
->vb
.width
!= width
|| buf
->vb
.height
!= height
||
1441 buf
->vb
.field
!= field
||
1442 buf
->tvnorm
!= btv
->tvnorm
|| buf
->fmt
!= fmt
) {
1443 buf
->vb
.width
= width
;
1444 buf
->vb
.height
= height
;
1445 buf
->vb
.field
= field
;
1446 buf
->tvnorm
= btv
->tvnorm
;
1451 /* alloc risc memory */
1452 if (STATE_NEEDS_INIT
== buf
->vb
.state
) {
1454 if (0 != (rc
= videobuf_iolock(q
,&buf
->vb
,&btv
->fbuf
)))
1459 if (0 != (rc
= bttv_buffer_risc(btv
,buf
)))
1462 buf
->vb
.state
= STATE_PREPARED
;
1466 bttv_dma_free(q
,btv
,buf
);
1471 buffer_setup(struct videobuf_queue
*q
, unsigned int *count
, unsigned int *size
)
1473 struct bttv_fh
*fh
= q
->priv_data
;
1475 *size
= fh
->fmt
->depth
*fh
->width
*fh
->height
>> 3;
1478 while (*size
* *count
> gbuffers
* gbufsize
)
1484 buffer_prepare(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
,
1485 enum v4l2_field field
)
1487 struct bttv_buffer
*buf
= container_of(vb
,struct bttv_buffer
,vb
);
1488 struct bttv_fh
*fh
= q
->priv_data
;
1490 return bttv_prepare_buffer(q
,fh
->btv
, buf
, fh
->fmt
,
1491 fh
->width
, fh
->height
, field
);
1495 buffer_queue(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
)
1497 struct bttv_buffer
*buf
= container_of(vb
,struct bttv_buffer
,vb
);
1498 struct bttv_fh
*fh
= q
->priv_data
;
1499 struct bttv
*btv
= fh
->btv
;
1501 buf
->vb
.state
= STATE_QUEUED
;
1502 list_add_tail(&buf
->vb
.queue
,&btv
->capture
);
1503 if (!btv
->curr
.frame_irq
) {
1505 bttv_set_dma(btv
, 0x03);
1509 static void buffer_release(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
)
1511 struct bttv_buffer
*buf
= container_of(vb
,struct bttv_buffer
,vb
);
1512 struct bttv_fh
*fh
= q
->priv_data
;
1514 bttv_dma_free(&fh
->cap
,fh
->btv
,buf
);
1517 static struct videobuf_queue_ops bttv_video_qops
= {
1518 .buf_setup
= buffer_setup
,
1519 .buf_prepare
= buffer_prepare
,
1520 .buf_queue
= buffer_queue
,
1521 .buf_release
= buffer_release
,
1524 static int bttv_common_ioctls(struct bttv
*btv
, unsigned int cmd
, void *arg
)
1528 return BTTV_VERSION_CODE
;
1530 /* *** v4l1 *** ************************************************ */
1533 unsigned long *freq
= arg
;
1539 unsigned long *freq
= arg
;
1540 mutex_lock(&btv
->lock
);
1542 bttv_call_i2c_clients(btv
,VIDIOCSFREQ
,freq
);
1543 if (btv
->has_matchbox
&& btv
->radio_user
)
1544 tea5757_set_freq(btv
,*freq
);
1545 mutex_unlock(&btv
->lock
);
1551 struct video_tuner
*v
= arg
;
1553 if (UNSET
== bttv_tvcards
[btv
->c
.type
].tuner
)
1555 if (v
->tuner
) /* Only tuner 0 */
1557 strcpy(v
->name
, "Television");
1559 v
->rangehigh
= 0x7FFFFFFF;
1560 v
->flags
= VIDEO_TUNER_PAL
|VIDEO_TUNER_NTSC
|VIDEO_TUNER_SECAM
;
1561 v
->mode
= btv
->tvnorm
;
1562 v
->signal
= (btread(BT848_DSTATUS
)&BT848_DSTATUS_HLOC
) ? 0xFFFF : 0;
1563 bttv_call_i2c_clients(btv
,cmd
,v
);
1568 struct video_tuner
*v
= arg
;
1570 if (v
->tuner
) /* Only tuner 0 */
1572 if (v
->mode
>= BTTV_TVNORMS
)
1575 mutex_lock(&btv
->lock
);
1576 set_tvnorm(btv
,v
->mode
);
1577 bttv_call_i2c_clients(btv
,cmd
,v
);
1578 mutex_unlock(&btv
->lock
);
1584 struct video_channel
*v
= arg
;
1585 unsigned int channel
= v
->channel
;
1587 if (channel
>= bttv_tvcards
[btv
->c
.type
].video_inputs
)
1590 v
->flags
= VIDEO_VC_AUDIO
;
1591 v
->type
= VIDEO_TYPE_CAMERA
;
1592 v
->norm
= btv
->tvnorm
;
1593 if (channel
== bttv_tvcards
[btv
->c
.type
].tuner
) {
1594 strcpy(v
->name
,"Television");
1595 v
->flags
|=VIDEO_VC_TUNER
;
1596 v
->type
=VIDEO_TYPE_TV
;
1598 } else if (channel
== btv
->svhs
) {
1599 strcpy(v
->name
,"S-Video");
1601 sprintf(v
->name
,"Composite%d",channel
);
1607 struct video_channel
*v
= arg
;
1608 unsigned int channel
= v
->channel
;
1610 if (channel
>= bttv_tvcards
[btv
->c
.type
].video_inputs
)
1612 if (v
->norm
>= BTTV_TVNORMS
)
1615 mutex_lock(&btv
->lock
);
1616 if (channel
== btv
->input
&&
1617 v
->norm
== btv
->tvnorm
) {
1619 mutex_unlock(&btv
->lock
);
1623 btv
->tvnorm
= v
->norm
;
1624 set_input(btv
,v
->channel
);
1625 mutex_unlock(&btv
->lock
);
1631 struct video_audio
*v
= arg
;
1633 memset(v
,0,sizeof(*v
));
1634 strcpy(v
->name
,"Television");
1635 v
->flags
|= VIDEO_AUDIO_MUTABLE
;
1636 v
->mode
= VIDEO_SOUND_MONO
;
1638 mutex_lock(&btv
->lock
);
1639 bttv_call_i2c_clients(btv
,cmd
,v
);
1641 /* card specific hooks */
1642 if (btv
->audio_hook
)
1643 btv
->audio_hook(btv
,v
,0);
1645 mutex_unlock(&btv
->lock
);
1650 struct video_audio
*v
= arg
;
1651 unsigned int audio
= v
->audio
;
1653 if (audio
>= bttv_tvcards
[btv
->c
.type
].audio_inputs
)
1656 mutex_lock(&btv
->lock
);
1657 audio_mux(btv
, (v
->flags
&VIDEO_AUDIO_MUTE
) ? AUDIO_MUTE
: AUDIO_UNMUTE
);
1658 bttv_call_i2c_clients(btv
,cmd
,v
);
1660 /* card specific hooks */
1661 if (btv
->audio_hook
)
1662 btv
->audio_hook(btv
,v
,1);
1664 mutex_unlock(&btv
->lock
);
1668 /* *** v4l2 *** ************************************************ */
1669 case VIDIOC_ENUMSTD
:
1671 struct v4l2_standard
*e
= arg
;
1672 unsigned int index
= e
->index
;
1674 if (index
>= BTTV_TVNORMS
)
1676 v4l2_video_std_construct(e
, bttv_tvnorms
[e
->index
].v4l2_id
,
1677 bttv_tvnorms
[e
->index
].name
);
1683 v4l2_std_id
*id
= arg
;
1684 *id
= bttv_tvnorms
[btv
->tvnorm
].v4l2_id
;
1689 v4l2_std_id
*id
= arg
;
1692 for (i
= 0; i
< BTTV_TVNORMS
; i
++)
1693 if (*id
& bttv_tvnorms
[i
].v4l2_id
)
1695 if (i
== BTTV_TVNORMS
)
1698 mutex_lock(&btv
->lock
);
1700 i2c_vidiocschan(btv
);
1701 mutex_unlock(&btv
->lock
);
1704 case VIDIOC_QUERYSTD
:
1706 v4l2_std_id
*id
= arg
;
1708 if (btread(BT848_DSTATUS
) & BT848_DSTATUS_NUML
)
1709 *id
= V4L2_STD_625_50
;
1711 *id
= V4L2_STD_525_60
;
1715 case VIDIOC_ENUMINPUT
:
1717 struct v4l2_input
*i
= arg
;
1721 if (n
>= bttv_tvcards
[btv
->c
.type
].video_inputs
)
1723 memset(i
,0,sizeof(*i
));
1725 i
->type
= V4L2_INPUT_TYPE_CAMERA
;
1727 if (i
->index
== bttv_tvcards
[btv
->c
.type
].tuner
) {
1728 sprintf(i
->name
, "Television");
1729 i
->type
= V4L2_INPUT_TYPE_TUNER
;
1731 } else if (i
->index
== btv
->svhs
) {
1732 sprintf(i
->name
, "S-Video");
1734 sprintf(i
->name
,"Composite%d",i
->index
);
1736 if (i
->index
== btv
->input
) {
1737 __u32 dstatus
= btread(BT848_DSTATUS
);
1738 if (0 == (dstatus
& BT848_DSTATUS_PRES
))
1739 i
->status
|= V4L2_IN_ST_NO_SIGNAL
;
1740 if (0 == (dstatus
& BT848_DSTATUS_HLOC
))
1741 i
->status
|= V4L2_IN_ST_NO_H_LOCK
;
1743 for (n
= 0; n
< BTTV_TVNORMS
; n
++)
1744 i
->std
|= bttv_tvnorms
[n
].v4l2_id
;
1747 case VIDIOC_G_INPUT
:
1753 case VIDIOC_S_INPUT
:
1755 unsigned int *i
= arg
;
1757 if (*i
> bttv_tvcards
[btv
->c
.type
].video_inputs
)
1759 mutex_lock(&btv
->lock
);
1761 mutex_unlock(&btv
->lock
);
1765 case VIDIOC_G_TUNER
:
1767 struct v4l2_tuner
*t
= arg
;
1769 if (UNSET
== bttv_tvcards
[btv
->c
.type
].tuner
)
1773 mutex_lock(&btv
->lock
);
1774 memset(t
,0,sizeof(*t
));
1775 strcpy(t
->name
, "Television");
1776 t
->type
= V4L2_TUNER_ANALOG_TV
;
1777 t
->capability
= V4L2_TUNER_CAP_NORM
;
1778 t
->rxsubchans
= V4L2_TUNER_SUB_MONO
;
1779 if (btread(BT848_DSTATUS
)&BT848_DSTATUS_HLOC
)
1782 struct video_tuner tuner
;
1784 memset(&tuner
, 0, sizeof (tuner
));
1785 tuner
.rangehigh
= 0xffffffffUL
;
1786 bttv_call_i2c_clients(btv
, VIDIOCGTUNER
, &tuner
);
1787 t
->rangelow
= tuner
.rangelow
;
1788 t
->rangehigh
= tuner
.rangehigh
;
1792 struct video_audio va
;
1793 memset(&va
, 0, sizeof(struct video_audio
));
1794 bttv_call_i2c_clients(btv
, VIDIOCGAUDIO
, &va
);
1795 if (btv
->audio_hook
)
1796 btv
->audio_hook(btv
,&va
,0);
1797 if(va
.mode
& VIDEO_SOUND_STEREO
) {
1798 t
->audmode
= V4L2_TUNER_MODE_STEREO
;
1799 t
->rxsubchans
|= V4L2_TUNER_SUB_STEREO
;
1801 if(va
.mode
& VIDEO_SOUND_LANG1
) {
1802 t
->audmode
= V4L2_TUNER_MODE_LANG1
;
1803 t
->rxsubchans
= V4L2_TUNER_SUB_LANG1
1804 | V4L2_TUNER_SUB_LANG2
;
1807 /* FIXME: fill capability+audmode */
1808 mutex_unlock(&btv
->lock
);
1811 case VIDIOC_S_TUNER
:
1813 struct v4l2_tuner
*t
= arg
;
1815 if (UNSET
== bttv_tvcards
[btv
->c
.type
].tuner
)
1819 mutex_lock(&btv
->lock
);
1821 struct video_audio va
;
1822 memset(&va
, 0, sizeof(struct video_audio
));
1823 bttv_call_i2c_clients(btv
, VIDIOCGAUDIO
, &va
);
1824 if (t
->audmode
== V4L2_TUNER_MODE_MONO
)
1825 va
.mode
= VIDEO_SOUND_MONO
;
1826 else if (t
->audmode
== V4L2_TUNER_MODE_STEREO
)
1827 va
.mode
= VIDEO_SOUND_STEREO
;
1828 else if (t
->audmode
== V4L2_TUNER_MODE_LANG1
)
1829 va
.mode
= VIDEO_SOUND_LANG1
;
1830 else if (t
->audmode
== V4L2_TUNER_MODE_LANG2
)
1831 va
.mode
= VIDEO_SOUND_LANG2
;
1832 bttv_call_i2c_clients(btv
, VIDIOCSAUDIO
, &va
);
1833 if (btv
->audio_hook
)
1834 btv
->audio_hook(btv
,&va
,1);
1836 mutex_unlock(&btv
->lock
);
1840 case VIDIOC_G_FREQUENCY
:
1842 struct v4l2_frequency
*f
= arg
;
1844 memset(f
,0,sizeof(*f
));
1845 f
->type
= V4L2_TUNER_ANALOG_TV
;
1846 f
->frequency
= btv
->freq
;
1849 case VIDIOC_S_FREQUENCY
:
1851 struct v4l2_frequency
*f
= arg
;
1853 if (unlikely(f
->tuner
!= 0))
1855 if (unlikely (f
->type
!= V4L2_TUNER_ANALOG_TV
))
1857 mutex_lock(&btv
->lock
);
1858 btv
->freq
= f
->frequency
;
1859 bttv_call_i2c_clients(btv
,VIDIOCSFREQ
,&btv
->freq
);
1860 if (btv
->has_matchbox
&& btv
->radio_user
)
1861 tea5757_set_freq(btv
,btv
->freq
);
1862 mutex_unlock(&btv
->lock
);
1865 case VIDIOC_LOG_STATUS
:
1867 bttv_call_i2c_clients(btv
, VIDIOC_LOG_STATUS
, NULL
);
1872 return -ENOIOCTLCMD
;
1878 static int verify_window(const struct bttv_tvnorm
*tvn
,
1879 struct v4l2_window
*win
, int fixup
)
1881 enum v4l2_field field
;
1884 if (win
->w
.width
< 48 || win
->w
.height
< 32)
1886 if (win
->clipcount
> 2048)
1891 maxh
= tvn
->sheight
;
1893 if (V4L2_FIELD_ANY
== field
) {
1894 field
= (win
->w
.height
> maxh
/2)
1895 ? V4L2_FIELD_INTERLACED
1899 case V4L2_FIELD_TOP
:
1900 case V4L2_FIELD_BOTTOM
:
1903 case V4L2_FIELD_INTERLACED
:
1909 if (!fixup
&& (win
->w
.width
> maxw
|| win
->w
.height
> maxh
))
1912 if (win
->w
.width
> maxw
)
1913 win
->w
.width
= maxw
;
1914 if (win
->w
.height
> maxh
)
1915 win
->w
.height
= maxh
;
1920 static int setup_window(struct bttv_fh
*fh
, struct bttv
*btv
,
1921 struct v4l2_window
*win
, int fixup
)
1923 struct v4l2_clip
*clips
= NULL
;
1924 int n
,size
,retval
= 0;
1926 if (NULL
== fh
->ovfmt
)
1928 if (!(fh
->ovfmt
->flags
& FORMAT_FLAGS_PACKED
))
1930 retval
= verify_window(&bttv_tvnorms
[btv
->tvnorm
],win
,fixup
);
1934 /* copy clips -- luckily v4l1 + v4l2 are binary
1935 compatible here ...*/
1937 size
= sizeof(*clips
)*(n
+4);
1938 clips
= kmalloc(size
,GFP_KERNEL
);
1942 if (copy_from_user(clips
,win
->clips
,sizeof(struct v4l2_clip
)*n
)) {
1947 /* clip against screen */
1948 if (NULL
!= btv
->fbuf
.base
)
1949 n
= btcx_screen_clips(btv
->fbuf
.fmt
.width
, btv
->fbuf
.fmt
.height
,
1951 btcx_sort_clips(clips
,n
);
1953 /* 4-byte alignments */
1954 switch (fh
->ovfmt
->depth
) {
1957 btcx_align(&win
->w
, clips
, n
, 3);
1960 btcx_align(&win
->w
, clips
, n
, 1);
1963 /* no alignment fixups needed */
1969 mutex_lock(&fh
->cap
.lock
);
1970 kfree(fh
->ov
.clips
);
1971 fh
->ov
.clips
= clips
;
1975 fh
->ov
.field
= win
->field
;
1976 fh
->ov
.setup_ok
= 1;
1977 btv
->init
.ov
.w
.width
= win
->w
.width
;
1978 btv
->init
.ov
.w
.height
= win
->w
.height
;
1979 btv
->init
.ov
.field
= win
->field
;
1981 /* update overlay if needed */
1983 if (check_btres(fh
, RESOURCE_OVERLAY
)) {
1984 struct bttv_buffer
*new;
1986 new = videobuf_alloc(sizeof(*new));
1987 bttv_overlay_risc(btv
, &fh
->ov
, fh
->ovfmt
, new);
1988 retval
= bttv_switch_overlay(btv
,fh
,new);
1990 mutex_unlock(&fh
->cap
.lock
);
1994 /* ----------------------------------------------------------------------- */
1996 static struct videobuf_queue
* bttv_queue(struct bttv_fh
*fh
)
1998 struct videobuf_queue
* q
= NULL
;
2001 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2004 case V4L2_BUF_TYPE_VBI_CAPTURE
:
2013 static int bttv_resource(struct bttv_fh
*fh
)
2018 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2019 res
= RESOURCE_VIDEO
;
2021 case V4L2_BUF_TYPE_VBI_CAPTURE
:
2030 static int bttv_switch_type(struct bttv_fh
*fh
, enum v4l2_buf_type type
)
2032 struct videobuf_queue
*q
= bttv_queue(fh
);
2033 int res
= bttv_resource(fh
);
2035 if (check_btres(fh
,res
))
2037 if (videobuf_queue_is_busy(q
))
2044 pix_format_set_size (struct v4l2_pix_format
* f
,
2045 const struct bttv_format
* fmt
,
2047 unsigned int height
)
2052 if (fmt
->flags
& FORMAT_FLAGS_PLANAR
) {
2053 f
->bytesperline
= width
; /* Y plane */
2054 f
->sizeimage
= (width
* height
* fmt
->depth
) >> 3;
2056 f
->bytesperline
= (width
* fmt
->depth
) >> 3;
2057 f
->sizeimage
= height
* f
->bytesperline
;
2061 static int bttv_g_fmt(struct bttv_fh
*fh
, struct v4l2_format
*f
)
2064 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2065 memset(&f
->fmt
.pix
,0,sizeof(struct v4l2_pix_format
));
2066 pix_format_set_size (&f
->fmt
.pix
, fh
->fmt
,
2067 fh
->width
, fh
->height
);
2068 f
->fmt
.pix
.field
= fh
->cap
.field
;
2069 f
->fmt
.pix
.pixelformat
= fh
->fmt
->fourcc
;
2071 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
2072 memset(&f
->fmt
.win
,0,sizeof(struct v4l2_window
));
2073 f
->fmt
.win
.w
= fh
->ov
.w
;
2074 f
->fmt
.win
.field
= fh
->ov
.field
;
2076 case V4L2_BUF_TYPE_VBI_CAPTURE
:
2077 bttv_vbi_get_fmt(fh
,f
);
2084 static int bttv_try_fmt(struct bttv_fh
*fh
, struct bttv
*btv
,
2085 struct v4l2_format
*f
)
2088 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2090 const struct bttv_format
*fmt
;
2091 enum v4l2_field field
;
2092 unsigned int maxw
,maxh
;
2094 fmt
= format_by_fourcc(f
->fmt
.pix
.pixelformat
);
2099 maxw
= bttv_tvnorms
[btv
->tvnorm
].swidth
;
2100 maxh
= bttv_tvnorms
[btv
->tvnorm
].sheight
;
2101 field
= f
->fmt
.pix
.field
;
2102 if (V4L2_FIELD_ANY
== field
)
2103 field
= (f
->fmt
.pix
.height
> maxh
/2)
2104 ? V4L2_FIELD_INTERLACED
2105 : V4L2_FIELD_BOTTOM
;
2106 if (V4L2_FIELD_SEQ_BT
== field
)
2107 field
= V4L2_FIELD_SEQ_TB
;
2109 case V4L2_FIELD_TOP
:
2110 case V4L2_FIELD_BOTTOM
:
2111 case V4L2_FIELD_ALTERNATE
:
2114 case V4L2_FIELD_INTERLACED
:
2116 case V4L2_FIELD_SEQ_TB
:
2117 if (fmt
->flags
& FORMAT_FLAGS_PLANAR
)
2124 /* update data for the application */
2125 f
->fmt
.pix
.field
= field
;
2126 if (f
->fmt
.pix
.width
< 48)
2127 f
->fmt
.pix
.width
= 48;
2128 if (f
->fmt
.pix
.height
< 32)
2129 f
->fmt
.pix
.height
= 32;
2130 if (f
->fmt
.pix
.width
> maxw
)
2131 f
->fmt
.pix
.width
= maxw
;
2132 if (f
->fmt
.pix
.height
> maxh
)
2133 f
->fmt
.pix
.height
= maxh
;
2134 pix_format_set_size (&f
->fmt
.pix
, fmt
,
2135 f
->fmt
.pix
.width
& ~3,
2140 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
2141 return verify_window(&bttv_tvnorms
[btv
->tvnorm
],
2143 case V4L2_BUF_TYPE_VBI_CAPTURE
:
2144 bttv_vbi_try_fmt(fh
,f
);
2151 static int bttv_s_fmt(struct bttv_fh
*fh
, struct bttv
*btv
,
2152 struct v4l2_format
*f
)
2157 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2159 const struct bttv_format
*fmt
;
2161 retval
= bttv_switch_type(fh
,f
->type
);
2164 retval
= bttv_try_fmt(fh
,btv
,f
);
2167 fmt
= format_by_fourcc(f
->fmt
.pix
.pixelformat
);
2169 /* update our state informations */
2170 mutex_lock(&fh
->cap
.lock
);
2172 fh
->cap
.field
= f
->fmt
.pix
.field
;
2173 fh
->cap
.last
= V4L2_FIELD_NONE
;
2174 fh
->width
= f
->fmt
.pix
.width
;
2175 fh
->height
= f
->fmt
.pix
.height
;
2176 btv
->init
.fmt
= fmt
;
2177 btv
->init
.width
= f
->fmt
.pix
.width
;
2178 btv
->init
.height
= f
->fmt
.pix
.height
;
2179 mutex_unlock(&fh
->cap
.lock
);
2183 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
2184 if (no_overlay
> 0) {
2185 printk ("V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2188 return setup_window(fh
, btv
, &f
->fmt
.win
, 1);
2189 case V4L2_BUF_TYPE_VBI_CAPTURE
:
2190 retval
= bttv_switch_type(fh
,f
->type
);
2193 if (locked_btres(fh
->btv
, RESOURCE_VBI
))
2195 bttv_vbi_try_fmt(fh
,f
);
2196 bttv_vbi_setlines(fh
,btv
,f
->fmt
.vbi
.count
[0]);
2197 bttv_vbi_get_fmt(fh
,f
);
2204 static int bttv_do_ioctl(struct inode
*inode
, struct file
*file
,
2205 unsigned int cmd
, void *arg
)
2207 struct bttv_fh
*fh
= file
->private_data
;
2208 struct bttv
*btv
= fh
->btv
;
2209 unsigned long flags
;
2213 v4l_print_ioctl(btv
->c
.name
, cmd
);
2216 bttv_reinit_bt848(btv
);
2224 case VIDIOC_S_INPUT
:
2225 case VIDIOC_S_TUNER
:
2226 case VIDIOC_S_FREQUENCY
:
2227 retval
= v4l2_prio_check(&btv
->prio
,&fh
->prio
);
2234 /* *** v4l1 *** ************************************************ */
2237 struct video_capability
*cap
= arg
;
2239 memset(cap
,0,sizeof(*cap
));
2240 strcpy(cap
->name
,btv
->video_dev
->name
);
2241 if (V4L2_BUF_TYPE_VBI_CAPTURE
== fh
->type
) {
2243 cap
->type
= VID_TYPE_TUNER
|VID_TYPE_TELETEXT
;
2246 cap
->type
= VID_TYPE_CAPTURE
|
2250 if (no_overlay
<= 0)
2251 cap
->type
|= VID_TYPE_OVERLAY
;
2253 cap
->maxwidth
= bttv_tvnorms
[btv
->tvnorm
].swidth
;
2254 cap
->maxheight
= bttv_tvnorms
[btv
->tvnorm
].sheight
;
2256 cap
->minheight
= 32;
2258 cap
->channels
= bttv_tvcards
[btv
->c
.type
].video_inputs
;
2259 cap
->audios
= bttv_tvcards
[btv
->c
.type
].audio_inputs
;
2265 struct video_picture
*pic
= arg
;
2267 memset(pic
,0,sizeof(*pic
));
2268 pic
->brightness
= btv
->bright
;
2269 pic
->contrast
= btv
->contrast
;
2270 pic
->hue
= btv
->hue
;
2271 pic
->colour
= btv
->saturation
;
2273 pic
->depth
= fh
->fmt
->depth
;
2274 pic
->palette
= fh
->fmt
->palette
;
2280 struct video_picture
*pic
= arg
;
2281 const struct bttv_format
*fmt
;
2283 fmt
= format_by_palette(pic
->palette
);
2286 mutex_lock(&fh
->cap
.lock
);
2287 if (fmt
->depth
!= pic
->depth
) {
2289 goto fh_unlock_and_return
;
2291 if (fmt
->flags
& FORMAT_FLAGS_RAW
) {
2292 /* VIDIOCMCAPTURE uses gbufsize, not RAW_BPL *
2293 RAW_LINES * 2. F1 is stored at offset 0, F2
2294 at buffer size / 2. */
2295 fh
->width
= RAW_BPL
;
2296 fh
->height
= gbufsize
/ RAW_BPL
;
2297 btv
->init
.width
= RAW_BPL
;
2298 btv
->init
.height
= gbufsize
/ RAW_BPL
;
2302 btv
->init
.ovfmt
= fmt
;
2303 btv
->init
.fmt
= fmt
;
2305 /* dirty hack time: swap bytes for overlay if the
2306 display adaptor is big endian (insmod option) */
2307 if (fmt
->palette
== VIDEO_PALETTE_RGB555
||
2308 fmt
->palette
== VIDEO_PALETTE_RGB565
||
2309 fmt
->palette
== VIDEO_PALETTE_RGB32
) {
2313 bt848_bright(btv
,pic
->brightness
);
2314 bt848_contrast(btv
,pic
->contrast
);
2315 bt848_hue(btv
,pic
->hue
);
2316 bt848_sat(btv
,pic
->colour
);
2317 mutex_unlock(&fh
->cap
.lock
);
2323 struct video_window
*win
= arg
;
2325 memset(win
,0,sizeof(*win
));
2326 win
->x
= fh
->ov
.w
.left
;
2327 win
->y
= fh
->ov
.w
.top
;
2328 win
->width
= fh
->ov
.w
.width
;
2329 win
->height
= fh
->ov
.w
.height
;
2334 struct video_window
*win
= arg
;
2335 struct v4l2_window w2
;
2337 if (no_overlay
> 0) {
2338 printk ("VIDIOCSWIN: no_overlay\n");
2342 w2
.field
= V4L2_FIELD_ANY
;
2345 w2
.w
.width
= win
->width
;
2346 w2
.w
.height
= win
->height
;
2347 w2
.clipcount
= win
->clipcount
;
2348 w2
.clips
= (struct v4l2_clip __user
*)win
->clips
;
2349 retval
= setup_window(fh
, btv
, &w2
, 0);
2351 /* on v4l1 this ioctl affects the read() size too */
2352 fh
->width
= fh
->ov
.w
.width
;
2353 fh
->height
= fh
->ov
.w
.height
;
2354 btv
->init
.width
= fh
->ov
.w
.width
;
2355 btv
->init
.height
= fh
->ov
.w
.height
;
2362 struct video_buffer
*fbuf
= arg
;
2364 fbuf
->base
= btv
->fbuf
.base
;
2365 fbuf
->width
= btv
->fbuf
.fmt
.width
;
2366 fbuf
->height
= btv
->fbuf
.fmt
.height
;
2367 fbuf
->bytesperline
= btv
->fbuf
.fmt
.bytesperline
;
2369 fbuf
->depth
= fh
->ovfmt
->depth
;
2374 struct video_buffer
*fbuf
= arg
;
2375 const struct bttv_format
*fmt
;
2378 if(!capable(CAP_SYS_ADMIN
) &&
2379 !capable(CAP_SYS_RAWIO
))
2381 end
= (unsigned long)fbuf
->base
+
2382 fbuf
->height
* fbuf
->bytesperline
;
2383 mutex_lock(&fh
->cap
.lock
);
2386 switch (fbuf
->depth
) {
2388 fmt
= format_by_palette(VIDEO_PALETTE_HI240
);
2391 fmt
= format_by_palette(VIDEO_PALETTE_RGB565
);
2394 fmt
= format_by_palette(VIDEO_PALETTE_RGB24
);
2397 fmt
= format_by_palette(VIDEO_PALETTE_RGB32
);
2401 fmt
= format_by_palette(VIDEO_PALETTE_RGB555
);
2408 goto fh_unlock_and_return
;
2412 btv
->init
.ovfmt
= fmt
;
2413 btv
->init
.fmt
= fmt
;
2414 btv
->fbuf
.base
= fbuf
->base
;
2415 btv
->fbuf
.fmt
.width
= fbuf
->width
;
2416 btv
->fbuf
.fmt
.height
= fbuf
->height
;
2417 if (fbuf
->bytesperline
)
2418 btv
->fbuf
.fmt
.bytesperline
= fbuf
->bytesperline
;
2420 btv
->fbuf
.fmt
.bytesperline
= btv
->fbuf
.fmt
.width
*fbuf
->depth
/8;
2421 mutex_unlock(&fh
->cap
.lock
);
2426 case VIDIOC_OVERLAY
:
2428 struct bttv_buffer
*new;
2433 if (NULL
== btv
->fbuf
.base
)
2435 if (!fh
->ov
.setup_ok
) {
2436 dprintk("bttv%d: overlay: !setup_ok\n",btv
->c
.nr
);
2441 if (!check_alloc_btres(btv
,fh
,RESOURCE_OVERLAY
))
2444 mutex_lock(&fh
->cap
.lock
);
2446 fh
->ov
.tvnorm
= btv
->tvnorm
;
2447 new = videobuf_alloc(sizeof(*new));
2448 bttv_overlay_risc(btv
, &fh
->ov
, fh
->ovfmt
, new);
2454 retval
= bttv_switch_overlay(btv
,fh
,new);
2455 mutex_unlock(&fh
->cap
.lock
);
2461 struct video_mbuf
*mbuf
= arg
;
2464 mutex_lock(&fh
->cap
.lock
);
2465 retval
= videobuf_mmap_setup(&fh
->cap
,gbuffers
,gbufsize
,
2468 goto fh_unlock_and_return
;
2469 memset(mbuf
,0,sizeof(*mbuf
));
2470 mbuf
->frames
= gbuffers
;
2471 mbuf
->size
= gbuffers
* gbufsize
;
2472 for (i
= 0; i
< gbuffers
; i
++)
2473 mbuf
->offsets
[i
] = i
* gbufsize
;
2474 mutex_unlock(&fh
->cap
.lock
);
2477 case VIDIOCMCAPTURE
:
2479 struct video_mmap
*vm
= arg
;
2480 struct bttv_buffer
*buf
;
2481 enum v4l2_field field
;
2483 if (vm
->frame
>= VIDEO_MAX_FRAME
)
2486 mutex_lock(&fh
->cap
.lock
);
2488 buf
= (struct bttv_buffer
*)fh
->cap
.bufs
[vm
->frame
];
2490 goto fh_unlock_and_return
;
2491 if (0 == buf
->vb
.baddr
)
2492 goto fh_unlock_and_return
;
2493 if (buf
->vb
.state
== STATE_QUEUED
||
2494 buf
->vb
.state
== STATE_ACTIVE
)
2495 goto fh_unlock_and_return
;
2497 field
= (vm
->height
> bttv_tvnorms
[btv
->tvnorm
].sheight
/2)
2498 ? V4L2_FIELD_INTERLACED
2499 : V4L2_FIELD_BOTTOM
;
2500 retval
= bttv_prepare_buffer(&fh
->cap
,btv
,buf
,
2501 format_by_palette(vm
->format
),
2502 vm
->width
,vm
->height
,field
);
2504 goto fh_unlock_and_return
;
2505 spin_lock_irqsave(&btv
->s_lock
,flags
);
2506 buffer_queue(&fh
->cap
,&buf
->vb
);
2507 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
2508 mutex_unlock(&fh
->cap
.lock
);
2514 struct bttv_buffer
*buf
;
2516 if (*frame
>= VIDEO_MAX_FRAME
)
2519 mutex_lock(&fh
->cap
.lock
);
2521 buf
= (struct bttv_buffer
*)fh
->cap
.bufs
[*frame
];
2523 goto fh_unlock_and_return
;
2524 retval
= videobuf_waiton(&buf
->vb
,0,1);
2526 goto fh_unlock_and_return
;
2527 switch (buf
->vb
.state
) {
2532 videobuf_dma_sync(&fh
->cap
,&buf
->vb
.dma
);
2533 bttv_dma_free(&fh
->cap
,btv
,buf
);
2539 mutex_unlock(&fh
->cap
.lock
);
2545 struct vbi_format
*fmt
= (void *) arg
;
2546 struct v4l2_format fmt2
;
2548 if (fh
->type
!= V4L2_BUF_TYPE_VBI_CAPTURE
) {
2549 retval
= bttv_switch_type(fh
,V4L2_BUF_TYPE_VBI_CAPTURE
);
2553 bttv_vbi_get_fmt(fh
, &fmt2
);
2555 memset(fmt
,0,sizeof(*fmt
));
2556 fmt
->sampling_rate
= fmt2
.fmt
.vbi
.sampling_rate
;
2557 fmt
->samples_per_line
= fmt2
.fmt
.vbi
.samples_per_line
;
2558 fmt
->sample_format
= VIDEO_PALETTE_RAW
;
2559 fmt
->start
[0] = fmt2
.fmt
.vbi
.start
[0];
2560 fmt
->count
[0] = fmt2
.fmt
.vbi
.count
[0];
2561 fmt
->start
[1] = fmt2
.fmt
.vbi
.start
[1];
2562 fmt
->count
[1] = fmt2
.fmt
.vbi
.count
[1];
2563 if (fmt2
.fmt
.vbi
.flags
& V4L2_VBI_UNSYNC
)
2564 fmt
->flags
|= VBI_UNSYNC
;
2565 if (fmt2
.fmt
.vbi
.flags
& V4L2_VBI_INTERLACED
)
2566 fmt
->flags
|= VBI_INTERLACED
;
2571 struct vbi_format
*fmt
= (void *) arg
;
2572 struct v4l2_format fmt2
;
2574 retval
= bttv_switch_type(fh
,V4L2_BUF_TYPE_VBI_CAPTURE
);
2577 bttv_vbi_get_fmt(fh
, &fmt2
);
2579 if (fmt
->sampling_rate
!= fmt2
.fmt
.vbi
.sampling_rate
||
2580 fmt
->samples_per_line
!= fmt2
.fmt
.vbi
.samples_per_line
||
2581 fmt
->sample_format
!= VIDEO_PALETTE_RAW
||
2582 fmt
->start
[0] != fmt2
.fmt
.vbi
.start
[0] ||
2583 fmt
->start
[1] != fmt2
.fmt
.vbi
.start
[1] ||
2584 fmt
->count
[0] != fmt
->count
[1] ||
2585 fmt
->count
[0] < 1 ||
2586 fmt
->count
[0] > 32 /* VBI_MAXLINES */)
2589 bttv_vbi_setlines(fh
,btv
,fmt
->count
[0]);
2602 return bttv_common_ioctls(btv
,cmd
,arg
);
2604 /* *** v4l2 *** ************************************************ */
2605 case VIDIOC_QUERYCAP
:
2607 struct v4l2_capability
*cap
= arg
;
2611 memset(cap
, 0, sizeof (*cap
));
2612 strlcpy(cap
->driver
, "bttv", sizeof (cap
->driver
));
2613 strlcpy(cap
->card
, btv
->video_dev
->name
, sizeof (cap
->card
));
2614 snprintf(cap
->bus_info
, sizeof (cap
->bus_info
),
2615 "PCI:%s", pci_name(btv
->c
.pci
));
2616 cap
->version
= BTTV_VERSION_CODE
;
2618 V4L2_CAP_VIDEO_CAPTURE
|
2619 V4L2_CAP_VBI_CAPTURE
|
2620 V4L2_CAP_READWRITE
|
2622 if (no_overlay
<= 0)
2623 cap
->capabilities
|= V4L2_CAP_VIDEO_OVERLAY
;
2625 if (bttv_tvcards
[btv
->c
.type
].tuner
!= UNSET
&&
2626 bttv_tvcards
[btv
->c
.type
].tuner
!= TUNER_ABSENT
)
2627 cap
->capabilities
|= V4L2_CAP_TUNER
;
2631 case VIDIOC_ENUM_FMT
:
2633 struct v4l2_fmtdesc
*f
= arg
;
2634 enum v4l2_buf_type type
;
2639 if (V4L2_BUF_TYPE_VBI_CAPTURE
== type
) {
2644 memset(f
,0,sizeof(*f
));
2647 f
->pixelformat
= V4L2_PIX_FMT_GREY
;
2648 strcpy(f
->description
,"vbi data");
2652 /* video capture + overlay */
2654 for (i
= 0; i
< BTTV_FORMATS
; i
++) {
2655 if (bttv_formats
[i
].fourcc
!= -1)
2657 if ((unsigned int)index
== f
->index
)
2660 if (BTTV_FORMATS
== i
)
2664 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2666 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
2667 if (!(bttv_formats
[i
].flags
& FORMAT_FLAGS_PACKED
))
2673 memset(f
,0,sizeof(*f
));
2676 f
->pixelformat
= bttv_formats
[i
].fourcc
;
2677 strlcpy(f
->description
,bttv_formats
[i
].name
,sizeof(f
->description
));
2681 case VIDIOC_TRY_FMT
:
2683 struct v4l2_format
*f
= arg
;
2684 return bttv_try_fmt(fh
,btv
,f
);
2688 struct v4l2_format
*f
= arg
;
2689 return bttv_g_fmt(fh
,f
);
2693 struct v4l2_format
*f
= arg
;
2694 return bttv_s_fmt(fh
,btv
,f
);
2699 struct v4l2_framebuffer
*fb
= arg
;
2702 fb
->capability
= V4L2_FBUF_CAP_LIST_CLIPPING
;
2704 fb
->fmt
.pixelformat
= fh
->ovfmt
->fourcc
;
2709 struct v4l2_framebuffer
*fb
= arg
;
2710 const struct bttv_format
*fmt
;
2712 if(!capable(CAP_SYS_ADMIN
) &&
2713 !capable(CAP_SYS_RAWIO
))
2717 fmt
= format_by_fourcc(fb
->fmt
.pixelformat
);
2720 if (0 == (fmt
->flags
& FORMAT_FLAGS_PACKED
))
2723 mutex_lock(&fh
->cap
.lock
);
2725 if (fb
->flags
& V4L2_FBUF_FLAG_OVERLAY
) {
2726 if (fb
->fmt
.width
> bttv_tvnorms
[btv
->tvnorm
].swidth
)
2727 goto fh_unlock_and_return
;
2728 if (fb
->fmt
.height
> bttv_tvnorms
[btv
->tvnorm
].sheight
)
2729 goto fh_unlock_and_return
;
2733 btv
->fbuf
.base
= fb
->base
;
2734 btv
->fbuf
.fmt
.width
= fb
->fmt
.width
;
2735 btv
->fbuf
.fmt
.height
= fb
->fmt
.height
;
2736 if (0 != fb
->fmt
.bytesperline
)
2737 btv
->fbuf
.fmt
.bytesperline
= fb
->fmt
.bytesperline
;
2739 btv
->fbuf
.fmt
.bytesperline
= btv
->fbuf
.fmt
.width
*fmt
->depth
/8;
2743 btv
->init
.ovfmt
= fmt
;
2744 if (fb
->flags
& V4L2_FBUF_FLAG_OVERLAY
) {
2747 fh
->ov
.w
.width
= fb
->fmt
.width
;
2748 fh
->ov
.w
.height
= fb
->fmt
.height
;
2749 btv
->init
.ov
.w
.width
= fb
->fmt
.width
;
2750 btv
->init
.ov
.w
.height
= fb
->fmt
.height
;
2751 kfree(fh
->ov
.clips
);
2752 fh
->ov
.clips
= NULL
;
2755 if (check_btres(fh
, RESOURCE_OVERLAY
)) {
2756 struct bttv_buffer
*new;
2758 new = videobuf_alloc(sizeof(*new));
2759 bttv_overlay_risc(btv
,&fh
->ov
,fh
->ovfmt
,new);
2760 retval
= bttv_switch_overlay(btv
,fh
,new);
2763 mutex_unlock(&fh
->cap
.lock
);
2767 case VIDIOC_REQBUFS
:
2768 return videobuf_reqbufs(bttv_queue(fh
),arg
);
2770 case VIDIOC_QUERYBUF
:
2771 return videobuf_querybuf(bttv_queue(fh
),arg
);
2774 return videobuf_qbuf(bttv_queue(fh
),arg
);
2777 return videobuf_dqbuf(bttv_queue(fh
),arg
,
2778 file
->f_flags
& O_NONBLOCK
);
2780 case VIDIOC_STREAMON
:
2782 int res
= bttv_resource(fh
);
2784 if (!check_alloc_btres(btv
,fh
,res
))
2786 return videobuf_streamon(bttv_queue(fh
));
2788 case VIDIOC_STREAMOFF
:
2790 int res
= bttv_resource(fh
);
2792 retval
= videobuf_streamoff(bttv_queue(fh
));
2795 free_btres(btv
,fh
,res
);
2799 case VIDIOC_QUERYCTRL
:
2801 struct v4l2_queryctrl
*c
= arg
;
2804 if ((c
->id
< V4L2_CID_BASE
||
2805 c
->id
>= V4L2_CID_LASTP1
) &&
2806 (c
->id
< V4L2_CID_PRIVATE_BASE
||
2807 c
->id
>= V4L2_CID_PRIVATE_LASTP1
))
2809 for (i
= 0; i
< BTTV_CTLS
; i
++)
2810 if (bttv_ctls
[i
].id
== c
->id
)
2812 if (i
== BTTV_CTLS
) {
2817 if (i
>= 4 && i
<= 8) {
2818 struct video_audio va
;
2819 memset(&va
,0,sizeof(va
));
2820 bttv_call_i2c_clients(btv
, VIDIOCGAUDIO
, &va
);
2821 if (btv
->audio_hook
)
2822 btv
->audio_hook(btv
,&va
,0);
2823 switch (bttv_ctls
[i
].id
) {
2824 case V4L2_CID_AUDIO_VOLUME
:
2825 if (!(va
.flags
& VIDEO_AUDIO_VOLUME
))
2828 case V4L2_CID_AUDIO_BALANCE
:
2829 if (!(va
.flags
& VIDEO_AUDIO_BALANCE
))
2832 case V4L2_CID_AUDIO_BASS
:
2833 if (!(va
.flags
& VIDEO_AUDIO_BASS
))
2836 case V4L2_CID_AUDIO_TREBLE
:
2837 if (!(va
.flags
& VIDEO_AUDIO_TREBLE
))
2845 return get_control(btv
,arg
);
2847 return set_control(btv
,arg
);
2850 struct v4l2_streamparm
*parm
= arg
;
2851 struct v4l2_standard s
;
2852 if (parm
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
2854 memset(parm
,0,sizeof(*parm
));
2855 v4l2_video_std_construct(&s
, bttv_tvnorms
[btv
->tvnorm
].v4l2_id
,
2856 bttv_tvnorms
[btv
->tvnorm
].name
);
2857 parm
->parm
.capture
.timeperframe
= s
.frameperiod
;
2861 case VIDIOC_G_PRIORITY
:
2863 enum v4l2_priority
*p
= arg
;
2865 *p
= v4l2_prio_max(&btv
->prio
);
2868 case VIDIOC_S_PRIORITY
:
2870 enum v4l2_priority
*prio
= arg
;
2872 return v4l2_prio_change(&btv
->prio
, &fh
->prio
, *prio
);
2875 case VIDIOC_ENUMSTD
:
2878 case VIDIOC_ENUMINPUT
:
2879 case VIDIOC_G_INPUT
:
2880 case VIDIOC_S_INPUT
:
2881 case VIDIOC_G_TUNER
:
2882 case VIDIOC_S_TUNER
:
2883 case VIDIOC_G_FREQUENCY
:
2884 case VIDIOC_S_FREQUENCY
:
2885 case VIDIOC_LOG_STATUS
:
2886 return bttv_common_ioctls(btv
,cmd
,arg
);
2889 return -ENOIOCTLCMD
;
2893 fh_unlock_and_return
:
2894 mutex_unlock(&fh
->cap
.lock
);
2898 static int bttv_ioctl(struct inode
*inode
, struct file
*file
,
2899 unsigned int cmd
, unsigned long arg
)
2901 struct bttv_fh
*fh
= file
->private_data
;
2905 bttv_switch_type(fh
,V4L2_BUF_TYPE_VBI_CAPTURE
);
2906 return fh
->lines
* 2 * 2048;
2908 return video_usercopy(inode
, file
, cmd
, arg
, bttv_do_ioctl
);
2912 static ssize_t
bttv_read(struct file
*file
, char __user
*data
,
2913 size_t count
, loff_t
*ppos
)
2915 struct bttv_fh
*fh
= file
->private_data
;
2918 if (fh
->btv
->errors
)
2919 bttv_reinit_bt848(fh
->btv
);
2920 dprintk("bttv%d: read count=%d type=%s\n",
2921 fh
->btv
->c
.nr
,(int)count
,v4l2_type_names
[fh
->type
]);
2924 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2925 if (locked_btres(fh
->btv
,RESOURCE_VIDEO
))
2927 retval
= videobuf_read_one(&fh
->cap
, data
, count
, ppos
,
2928 file
->f_flags
& O_NONBLOCK
);
2930 case V4L2_BUF_TYPE_VBI_CAPTURE
:
2931 if (!check_alloc_btres(fh
->btv
,fh
,RESOURCE_VBI
))
2933 retval
= videobuf_read_stream(&fh
->vbi
, data
, count
, ppos
, 1,
2934 file
->f_flags
& O_NONBLOCK
);
2942 static unsigned int bttv_poll(struct file
*file
, poll_table
*wait
)
2944 struct bttv_fh
*fh
= file
->private_data
;
2945 struct bttv_buffer
*buf
;
2946 enum v4l2_field field
;
2948 if (V4L2_BUF_TYPE_VBI_CAPTURE
== fh
->type
) {
2949 if (!check_alloc_btres(fh
->btv
,fh
,RESOURCE_VBI
))
2951 return videobuf_poll_stream(file
, &fh
->vbi
, wait
);
2954 if (check_btres(fh
,RESOURCE_VIDEO
)) {
2955 /* streaming capture */
2956 if (list_empty(&fh
->cap
.stream
))
2958 buf
= list_entry(fh
->cap
.stream
.next
,struct bttv_buffer
,vb
.stream
);
2960 /* read() capture */
2961 mutex_lock(&fh
->cap
.lock
);
2962 if (NULL
== fh
->cap
.read_buf
) {
2963 /* need to capture a new frame */
2964 if (locked_btres(fh
->btv
,RESOURCE_VIDEO
)) {
2965 mutex_unlock(&fh
->cap
.lock
);
2968 fh
->cap
.read_buf
= videobuf_alloc(fh
->cap
.msize
);
2969 if (NULL
== fh
->cap
.read_buf
) {
2970 mutex_unlock(&fh
->cap
.lock
);
2973 fh
->cap
.read_buf
->memory
= V4L2_MEMORY_USERPTR
;
2974 field
= videobuf_next_field(&fh
->cap
);
2975 if (0 != fh
->cap
.ops
->buf_prepare(&fh
->cap
,fh
->cap
.read_buf
,field
)) {
2976 kfree (fh
->cap
.read_buf
);
2977 fh
->cap
.read_buf
= NULL
;
2978 mutex_unlock(&fh
->cap
.lock
);
2981 fh
->cap
.ops
->buf_queue(&fh
->cap
,fh
->cap
.read_buf
);
2982 fh
->cap
.read_off
= 0;
2984 mutex_unlock(&fh
->cap
.lock
);
2985 buf
= (struct bttv_buffer
*)fh
->cap
.read_buf
;
2988 poll_wait(file
, &buf
->vb
.done
, wait
);
2989 if (buf
->vb
.state
== STATE_DONE
||
2990 buf
->vb
.state
== STATE_ERROR
)
2991 return POLLIN
|POLLRDNORM
;
2995 static int bttv_open(struct inode
*inode
, struct file
*file
)
2997 int minor
= iminor(inode
);
2998 struct bttv
*btv
= NULL
;
3000 enum v4l2_buf_type type
= 0;
3003 dprintk(KERN_DEBUG
"bttv: open minor=%d\n",minor
);
3005 for (i
= 0; i
< bttv_num
; i
++) {
3006 if (bttvs
[i
].video_dev
&&
3007 bttvs
[i
].video_dev
->minor
== minor
) {
3009 type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
3012 if (bttvs
[i
].vbi_dev
&&
3013 bttvs
[i
].vbi_dev
->minor
== minor
) {
3015 type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
3022 dprintk(KERN_DEBUG
"bttv%d: open called (type=%s)\n",
3023 btv
->c
.nr
,v4l2_type_names
[type
]);
3025 /* allocate per filehandle data */
3026 fh
= kmalloc(sizeof(*fh
),GFP_KERNEL
);
3029 file
->private_data
= fh
;
3032 fh
->ov
.setup_ok
= 0;
3033 v4l2_prio_open(&btv
->prio
,&fh
->prio
);
3035 videobuf_queue_init(&fh
->cap
, &bttv_video_qops
,
3036 btv
->c
.pci
, &btv
->s_lock
,
3037 V4L2_BUF_TYPE_VIDEO_CAPTURE
,
3038 V4L2_FIELD_INTERLACED
,
3039 sizeof(struct bttv_buffer
),
3041 videobuf_queue_init(&fh
->vbi
, &bttv_vbi_qops
,
3042 btv
->c
.pci
, &btv
->s_lock
,
3043 V4L2_BUF_TYPE_VBI_CAPTURE
,
3045 sizeof(struct bttv_buffer
),
3047 i2c_vidiocschan(btv
);
3050 if (V4L2_BUF_TYPE_VBI_CAPTURE
== fh
->type
)
3051 bttv_vbi_setlines(fh
,btv
,16);
3052 bttv_field_count(btv
);
3056 static int bttv_release(struct inode
*inode
, struct file
*file
)
3058 struct bttv_fh
*fh
= file
->private_data
;
3059 struct bttv
*btv
= fh
->btv
;
3061 /* turn off overlay */
3062 if (check_btres(fh
, RESOURCE_OVERLAY
))
3063 bttv_switch_overlay(btv
,fh
,NULL
);
3065 /* stop video capture */
3066 if (check_btres(fh
, RESOURCE_VIDEO
)) {
3067 videobuf_streamoff(&fh
->cap
);
3068 free_btres(btv
,fh
,RESOURCE_VIDEO
);
3070 if (fh
->cap
.read_buf
) {
3071 buffer_release(&fh
->cap
,fh
->cap
.read_buf
);
3072 kfree(fh
->cap
.read_buf
);
3075 /* stop vbi capture */
3076 if (check_btres(fh
, RESOURCE_VBI
)) {
3077 if (fh
->vbi
.streaming
)
3078 videobuf_streamoff(&fh
->vbi
);
3079 if (fh
->vbi
.reading
)
3080 videobuf_read_stop(&fh
->vbi
);
3081 free_btres(btv
,fh
,RESOURCE_VBI
);
3085 videobuf_mmap_free(&fh
->cap
);
3086 videobuf_mmap_free(&fh
->vbi
);
3087 v4l2_prio_close(&btv
->prio
,&fh
->prio
);
3088 file
->private_data
= NULL
;
3092 bttv_field_count(btv
);
3097 bttv_mmap(struct file
*file
, struct vm_area_struct
*vma
)
3099 struct bttv_fh
*fh
= file
->private_data
;
3101 dprintk("bttv%d: mmap type=%s 0x%lx+%ld\n",
3102 fh
->btv
->c
.nr
, v4l2_type_names
[fh
->type
],
3103 vma
->vm_start
, vma
->vm_end
- vma
->vm_start
);
3104 return videobuf_mmap_mapper(bttv_queue(fh
),vma
);
3107 static struct file_operations bttv_fops
=
3109 .owner
= THIS_MODULE
,
3111 .release
= bttv_release
,
3112 .ioctl
= bttv_ioctl
,
3113 .compat_ioctl
= v4l_compat_ioctl32
,
3114 .llseek
= no_llseek
,
3120 static struct video_device bttv_video_template
=
3123 .type
= VID_TYPE_CAPTURE
|VID_TYPE_TUNER
|
3124 VID_TYPE_CLIPPING
|VID_TYPE_SCALES
,
3125 .hardware
= VID_HARDWARE_BT848
,
3130 static struct video_device bttv_vbi_template
=
3132 .name
= "bt848/878 vbi",
3133 .type
= VID_TYPE_TUNER
|VID_TYPE_TELETEXT
,
3134 .hardware
= VID_HARDWARE_BT848
,
3139 /* ----------------------------------------------------------------------- */
3140 /* radio interface */
3142 static int radio_open(struct inode
*inode
, struct file
*file
)
3144 int minor
= iminor(inode
);
3145 struct bttv
*btv
= NULL
;
3148 dprintk("bttv: open minor=%d\n",minor
);
3150 for (i
= 0; i
< bttv_num
; i
++) {
3151 if (bttvs
[i
].radio_dev
->minor
== minor
) {
3159 dprintk("bttv%d: open called (radio)\n",btv
->c
.nr
);
3160 mutex_lock(&btv
->lock
);
3164 file
->private_data
= btv
;
3166 bttv_call_i2c_clients(btv
,AUDC_SET_RADIO
,&btv
->tuner_type
);
3167 audio_mux(btv
,AUDIO_RADIO
);
3169 mutex_unlock(&btv
->lock
);
3173 static int radio_release(struct inode
*inode
, struct file
*file
)
3175 struct bttv
*btv
= file
->private_data
;
3176 struct rds_command cmd
;
3180 bttv_call_i2c_clients(btv
, RDS_CMD_CLOSE
, &cmd
);
3185 static int radio_do_ioctl(struct inode
*inode
, struct file
*file
,
3186 unsigned int cmd
, void *arg
)
3188 struct bttv
*btv
= file
->private_data
;
3193 struct video_capability
*cap
= arg
;
3195 memset(cap
,0,sizeof(*cap
));
3196 strcpy(cap
->name
,btv
->radio_dev
->name
);
3197 cap
->type
= VID_TYPE_TUNER
;
3205 struct video_tuner
*v
= arg
;
3209 memset(v
,0,sizeof(*v
));
3210 strcpy(v
->name
, "Radio");
3211 bttv_call_i2c_clients(btv
,cmd
,v
);
3223 case VIDIOC_LOG_STATUS
:
3224 return bttv_common_ioctls(btv
,cmd
,arg
);
3227 return -ENOIOCTLCMD
;
3232 static int radio_ioctl(struct inode
*inode
, struct file
*file
,
3233 unsigned int cmd
, unsigned long arg
)
3235 return video_usercopy(inode
, file
, cmd
, arg
, radio_do_ioctl
);
3238 static ssize_t
radio_read(struct file
*file
, char __user
*data
,
3239 size_t count
, loff_t
*ppos
)
3241 struct bttv
*btv
= file
->private_data
;
3242 struct rds_command cmd
;
3243 cmd
.block_count
= count
/3;
3245 cmd
.instance
= file
;
3246 cmd
.result
= -ENODEV
;
3248 bttv_call_i2c_clients(btv
, RDS_CMD_READ
, &cmd
);
3253 static unsigned int radio_poll(struct file
*file
, poll_table
*wait
)
3255 struct bttv
*btv
= file
->private_data
;
3256 struct rds_command cmd
;
3257 cmd
.instance
= file
;
3258 cmd
.event_list
= wait
;
3259 cmd
.result
= -ENODEV
;
3260 bttv_call_i2c_clients(btv
, RDS_CMD_POLL
, &cmd
);
3265 static struct file_operations radio_fops
=
3267 .owner
= THIS_MODULE
,
3270 .release
= radio_release
,
3271 .ioctl
= radio_ioctl
,
3272 .llseek
= no_llseek
,
3276 static struct video_device radio_template
=
3278 .name
= "bt848/878 radio",
3279 .type
= VID_TYPE_TUNER
,
3280 .hardware
= VID_HARDWARE_BT848
,
3281 .fops
= &radio_fops
,
3285 /* ----------------------------------------------------------------------- */
3286 /* some debug code */
3288 static int bttv_risc_decode(u32 risc
)
3290 static char *instr
[16] = {
3291 [ BT848_RISC_WRITE
>> 28 ] = "write",
3292 [ BT848_RISC_SKIP
>> 28 ] = "skip",
3293 [ BT848_RISC_WRITEC
>> 28 ] = "writec",
3294 [ BT848_RISC_JUMP
>> 28 ] = "jump",
3295 [ BT848_RISC_SYNC
>> 28 ] = "sync",
3296 [ BT848_RISC_WRITE123
>> 28 ] = "write123",
3297 [ BT848_RISC_SKIP123
>> 28 ] = "skip123",
3298 [ BT848_RISC_WRITE1S23
>> 28 ] = "write1s23",
3300 static int incr
[16] = {
3301 [ BT848_RISC_WRITE
>> 28 ] = 2,
3302 [ BT848_RISC_JUMP
>> 28 ] = 2,
3303 [ BT848_RISC_SYNC
>> 28 ] = 2,
3304 [ BT848_RISC_WRITE123
>> 28 ] = 5,
3305 [ BT848_RISC_SKIP123
>> 28 ] = 2,
3306 [ BT848_RISC_WRITE1S23
>> 28 ] = 3,
3308 static char *bits
[] = {
3309 "be0", "be1", "be2", "be3/resync",
3310 "set0", "set1", "set2", "set3",
3311 "clr0", "clr1", "clr2", "clr3",
3312 "irq", "res", "eol", "sol",
3316 printk("0x%08x [ %s", risc
,
3317 instr
[risc
>> 28] ? instr
[risc
>> 28] : "INVALID");
3318 for (i
= ARRAY_SIZE(bits
)-1; i
>= 0; i
--)
3319 if (risc
& (1 << (i
+ 12)))
3320 printk(" %s",bits
[i
]);
3321 printk(" count=%d ]\n", risc
& 0xfff);
3322 return incr
[risc
>> 28] ? incr
[risc
>> 28] : 1;
3325 static void bttv_risc_disasm(struct bttv
*btv
,
3326 struct btcx_riscmem
*risc
)
3330 printk("%s: risc disasm: %p [dma=0x%08lx]\n",
3331 btv
->c
.name
, risc
->cpu
, (unsigned long)risc
->dma
);
3332 for (i
= 0; i
< (risc
->size
>> 2); i
+= n
) {
3333 printk("%s: 0x%lx: ", btv
->c
.name
,
3334 (unsigned long)(risc
->dma
+ (i
<<2)));
3335 n
= bttv_risc_decode(risc
->cpu
[i
]);
3336 for (j
= 1; j
< n
; j
++)
3337 printk("%s: 0x%lx: 0x%08x [ arg #%d ]\n",
3338 btv
->c
.name
, (unsigned long)(risc
->dma
+ ((i
+j
)<<2)),
3340 if (0 == risc
->cpu
[i
])
3345 static void bttv_print_riscaddr(struct bttv
*btv
)
3347 printk(" main: %08Lx\n",
3348 (unsigned long long)btv
->main
.dma
);
3349 printk(" vbi : o=%08Lx e=%08Lx\n",
3350 btv
->cvbi
? (unsigned long long)btv
->cvbi
->top
.dma
: 0,
3351 btv
->cvbi
? (unsigned long long)btv
->cvbi
->bottom
.dma
: 0);
3352 printk(" cap : o=%08Lx e=%08Lx\n",
3353 btv
->curr
.top
? (unsigned long long)btv
->curr
.top
->top
.dma
: 0,
3354 btv
->curr
.bottom
? (unsigned long long)btv
->curr
.bottom
->bottom
.dma
: 0);
3355 printk(" scr : o=%08Lx e=%08Lx\n",
3356 btv
->screen
? (unsigned long long)btv
->screen
->top
.dma
: 0,
3357 btv
->screen
? (unsigned long long)btv
->screen
->bottom
.dma
: 0);
3358 bttv_risc_disasm(btv
, &btv
->main
);
3361 /* ----------------------------------------------------------------------- */
3364 static char *irq_name
[] = {
3365 "FMTCHG", // format change detected (525 vs. 625)
3366 "VSYNC", // vertical sync (new field)
3367 "HSYNC", // horizontal sync
3368 "OFLOW", // chroma/luma AGC overflow
3369 "HLOCK", // horizontal lock changed
3370 "VPRES", // video presence changed
3372 "I2CDONE", // hw irc operation finished
3373 "GPINT", // gpio port triggered irq
3375 "RISCI", // risc instruction triggered irq
3376 "FBUS", // pixel data fifo dropped data (high pci bus latencies)
3377 "FTRGT", // pixel data fifo overrun
3378 "FDSR", // fifo data stream resyncronisation
3379 "PPERR", // parity error (data transfer)
3380 "RIPERR", // parity error (read risc instructions)
3381 "PABORT", // pci abort
3382 "OCERR", // risc instruction error
3383 "SCERR", // syncronisation error
3386 static void bttv_print_irqbits(u32 print
, u32 mark
)
3391 for (i
= 0; i
< ARRAY_SIZE(irq_name
); i
++) {
3392 if (print
& (1 << i
))
3393 printk(" %s",irq_name
[i
]);
3394 if (mark
& (1 << i
))
3399 static void bttv_irq_debug_low_latency(struct bttv
*btv
, u32 rc
)
3401 printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
3403 (unsigned long)btv
->main
.dma
,
3404 (unsigned long)btv
->main
.cpu
[RISC_SLOT_O_VBI
+1],
3405 (unsigned long)btv
->main
.cpu
[RISC_SLOT_O_FIELD
+1],
3408 if (0 == (btread(BT848_DSTATUS
) & BT848_DSTATUS_HLOC
)) {
3409 printk("bttv%d: Oh, there (temporarely?) is no input signal. "
3410 "Ok, then this is harmless, don't worry ;)\n",
3414 printk("bttv%d: Uhm. Looks like we have unusual high IRQ latencies.\n",
3416 printk("bttv%d: Lets try to catch the culpit red-handed ...\n",
3422 bttv_irq_next_video(struct bttv
*btv
, struct bttv_buffer_set
*set
)
3424 struct bttv_buffer
*item
;
3426 memset(set
,0,sizeof(*set
));
3428 /* capture request ? */
3429 if (!list_empty(&btv
->capture
)) {
3431 item
= list_entry(btv
->capture
.next
, struct bttv_buffer
, vb
.queue
);
3432 if (V4L2_FIELD_HAS_TOP(item
->vb
.field
))
3434 if (V4L2_FIELD_HAS_BOTTOM(item
->vb
.field
))
3437 /* capture request for other field ? */
3438 if (!V4L2_FIELD_HAS_BOTH(item
->vb
.field
) &&
3439 (item
->vb
.queue
.next
!= &btv
->capture
)) {
3440 item
= list_entry(item
->vb
.queue
.next
, struct bttv_buffer
, vb
.queue
);
3441 if (!V4L2_FIELD_HAS_BOTH(item
->vb
.field
)) {
3442 if (NULL
== set
->top
&&
3443 V4L2_FIELD_TOP
== item
->vb
.field
) {
3446 if (NULL
== set
->bottom
&&
3447 V4L2_FIELD_BOTTOM
== item
->vb
.field
) {
3450 if (NULL
!= set
->top
&& NULL
!= set
->bottom
)
3456 /* screen overlay ? */
3457 if (NULL
!= btv
->screen
) {
3458 if (V4L2_FIELD_HAS_BOTH(btv
->screen
->vb
.field
)) {
3459 if (NULL
== set
->top
&& NULL
== set
->bottom
) {
3460 set
->top
= btv
->screen
;
3461 set
->bottom
= btv
->screen
;
3464 if (V4L2_FIELD_TOP
== btv
->screen
->vb
.field
&&
3466 set
->top
= btv
->screen
;
3468 if (V4L2_FIELD_BOTTOM
== btv
->screen
->vb
.field
&&
3469 NULL
== set
->bottom
) {
3470 set
->bottom
= btv
->screen
;
3475 dprintk("bttv%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
3476 btv
->c
.nr
,set
->top
, set
->bottom
,
3477 btv
->screen
,set
->frame_irq
,set
->top_irq
);
3482 bttv_irq_wakeup_video(struct bttv
*btv
, struct bttv_buffer_set
*wakeup
,
3483 struct bttv_buffer_set
*curr
, unsigned int state
)
3487 do_gettimeofday(&ts
);
3489 if (wakeup
->top
== wakeup
->bottom
) {
3490 if (NULL
!= wakeup
->top
&& curr
->top
!= wakeup
->top
) {
3492 printk("bttv%d: wakeup: both=%p\n",btv
->c
.nr
,wakeup
->top
);
3493 wakeup
->top
->vb
.ts
= ts
;
3494 wakeup
->top
->vb
.field_count
= btv
->field_count
;
3495 wakeup
->top
->vb
.state
= state
;
3496 wake_up(&wakeup
->top
->vb
.done
);
3499 if (NULL
!= wakeup
->top
&& curr
->top
!= wakeup
->top
) {
3501 printk("bttv%d: wakeup: top=%p\n",btv
->c
.nr
,wakeup
->top
);
3502 wakeup
->top
->vb
.ts
= ts
;
3503 wakeup
->top
->vb
.field_count
= btv
->field_count
;
3504 wakeup
->top
->vb
.state
= state
;
3505 wake_up(&wakeup
->top
->vb
.done
);
3507 if (NULL
!= wakeup
->bottom
&& curr
->bottom
!= wakeup
->bottom
) {
3509 printk("bttv%d: wakeup: bottom=%p\n",btv
->c
.nr
,wakeup
->bottom
);
3510 wakeup
->bottom
->vb
.ts
= ts
;
3511 wakeup
->bottom
->vb
.field_count
= btv
->field_count
;
3512 wakeup
->bottom
->vb
.state
= state
;
3513 wake_up(&wakeup
->bottom
->vb
.done
);
3519 bttv_irq_wakeup_vbi(struct bttv
*btv
, struct bttv_buffer
*wakeup
,
3527 do_gettimeofday(&ts
);
3529 wakeup
->vb
.field_count
= btv
->field_count
;
3530 wakeup
->vb
.state
= state
;
3531 wake_up(&wakeup
->vb
.done
);
3534 static void bttv_irq_timeout(unsigned long data
)
3536 struct bttv
*btv
= (struct bttv
*)data
;
3537 struct bttv_buffer_set old
,new;
3538 struct bttv_buffer
*ovbi
;
3539 struct bttv_buffer
*item
;
3540 unsigned long flags
;
3543 printk(KERN_INFO
"bttv%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
3544 btv
->c
.nr
, btv
->framedrop
, btv
->irq_me
, btv
->irq_total
,
3545 btread(BT848_RISC_COUNT
));
3546 bttv_print_irqbits(btread(BT848_INT_STAT
),0);
3550 spin_lock_irqsave(&btv
->s_lock
,flags
);
3552 /* deactivate stuff */
3553 memset(&new,0,sizeof(new));
3559 bttv_buffer_activate_video(btv
, &new);
3560 bttv_buffer_activate_vbi(btv
, NULL
);
3561 bttv_set_dma(btv
, 0);
3564 bttv_irq_wakeup_video(btv
, &old
, &new, STATE_ERROR
);
3565 bttv_irq_wakeup_vbi(btv
, ovbi
, STATE_ERROR
);
3567 /* cancel all outstanding capture / vbi requests */
3568 while (!list_empty(&btv
->capture
)) {
3569 item
= list_entry(btv
->capture
.next
, struct bttv_buffer
, vb
.queue
);
3570 list_del(&item
->vb
.queue
);
3571 item
->vb
.state
= STATE_ERROR
;
3572 wake_up(&item
->vb
.done
);
3574 while (!list_empty(&btv
->vcapture
)) {
3575 item
= list_entry(btv
->vcapture
.next
, struct bttv_buffer
, vb
.queue
);
3576 list_del(&item
->vb
.queue
);
3577 item
->vb
.state
= STATE_ERROR
;
3578 wake_up(&item
->vb
.done
);
3582 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
3586 bttv_irq_wakeup_top(struct bttv
*btv
)
3588 struct bttv_buffer
*wakeup
= btv
->curr
.top
;
3593 spin_lock(&btv
->s_lock
);
3594 btv
->curr
.top_irq
= 0;
3595 btv
->curr
.top
= NULL
;
3596 bttv_risc_hook(btv
, RISC_SLOT_O_FIELD
, NULL
, 0);
3598 do_gettimeofday(&wakeup
->vb
.ts
);
3599 wakeup
->vb
.field_count
= btv
->field_count
;
3600 wakeup
->vb
.state
= STATE_DONE
;
3601 wake_up(&wakeup
->vb
.done
);
3602 spin_unlock(&btv
->s_lock
);
3605 static inline int is_active(struct btcx_riscmem
*risc
, u32 rc
)
3609 if (rc
> risc
->dma
+ risc
->size
)
3615 bttv_irq_switch_video(struct bttv
*btv
)
3617 struct bttv_buffer_set
new;
3618 struct bttv_buffer_set old
;
3621 spin_lock(&btv
->s_lock
);
3623 /* new buffer set */
3624 bttv_irq_next_video(btv
, &new);
3625 rc
= btread(BT848_RISC_COUNT
);
3626 if ((btv
->curr
.top
&& is_active(&btv
->curr
.top
->top
, rc
)) ||
3627 (btv
->curr
.bottom
&& is_active(&btv
->curr
.bottom
->bottom
, rc
))) {
3630 bttv_irq_debug_low_latency(btv
, rc
);
3631 spin_unlock(&btv
->s_lock
);
3638 btv
->loop_irq
&= ~1;
3639 bttv_buffer_activate_video(btv
, &new);
3640 bttv_set_dma(btv
, 0);
3643 if (UNSET
!= btv
->new_input
) {
3644 video_mux(btv
,btv
->new_input
);
3645 btv
->new_input
= UNSET
;
3648 /* wake up finished buffers */
3649 bttv_irq_wakeup_video(btv
, &old
, &new, STATE_DONE
);
3650 spin_unlock(&btv
->s_lock
);
3654 bttv_irq_switch_vbi(struct bttv
*btv
)
3656 struct bttv_buffer
*new = NULL
;
3657 struct bttv_buffer
*old
;
3660 spin_lock(&btv
->s_lock
);
3662 if (!list_empty(&btv
->vcapture
))
3663 new = list_entry(btv
->vcapture
.next
, struct bttv_buffer
, vb
.queue
);
3666 rc
= btread(BT848_RISC_COUNT
);
3667 if (NULL
!= old
&& (is_active(&old
->top
, rc
) ||
3668 is_active(&old
->bottom
, rc
))) {
3671 bttv_irq_debug_low_latency(btv
, rc
);
3672 spin_unlock(&btv
->s_lock
);
3678 btv
->loop_irq
&= ~4;
3679 bttv_buffer_activate_vbi(btv
, new);
3680 bttv_set_dma(btv
, 0);
3682 bttv_irq_wakeup_vbi(btv
, old
, STATE_DONE
);
3683 spin_unlock(&btv
->s_lock
);
3686 static irqreturn_t
bttv_irq(int irq
, void *dev_id
, struct pt_regs
* regs
)
3694 btv
=(struct bttv
*)dev_id
;
3696 if (btv
->custom_irq
)
3697 handled
= btv
->custom_irq(btv
);
3701 /* get/clear interrupt status bits */
3702 stat
=btread(BT848_INT_STAT
);
3703 astat
=stat
&btread(BT848_INT_MASK
);
3707 btwrite(stat
,BT848_INT_STAT
);
3709 /* get device status bits */
3710 dstat
=btread(BT848_DSTATUS
);
3713 printk(KERN_DEBUG
"bttv%d: irq loop=%d fc=%d "
3714 "riscs=%x, riscc=%08x, ",
3715 btv
->c
.nr
, count
, btv
->field_count
,
3716 stat
>>28, btread(BT848_RISC_COUNT
));
3717 bttv_print_irqbits(stat
,astat
);
3718 if (stat
& BT848_INT_HLOCK
)
3719 printk(" HLOC => %s", (dstat
& BT848_DSTATUS_HLOC
)
3721 if (stat
& BT848_INT_VPRES
)
3722 printk(" PRES => %s", (dstat
& BT848_DSTATUS_PRES
)
3724 if (stat
& BT848_INT_FMTCHG
)
3725 printk(" NUML => %s", (dstat
& BT848_DSTATUS_NUML
)
3730 if (astat
&BT848_INT_VSYNC
)
3733 if ((astat
& BT848_INT_GPINT
) && btv
->remote
) {
3734 wake_up(&btv
->gpioq
);
3735 bttv_input_irq(btv
);
3738 if (astat
& BT848_INT_I2CDONE
) {
3739 btv
->i2c_done
= stat
;
3740 wake_up(&btv
->i2c_queue
);
3743 if ((astat
& BT848_INT_RISCI
) && (stat
& (4<<28)))
3744 bttv_irq_switch_vbi(btv
);
3746 if ((astat
& BT848_INT_RISCI
) && (stat
& (2<<28)))
3747 bttv_irq_wakeup_top(btv
);
3749 if ((astat
& BT848_INT_RISCI
) && (stat
& (1<<28)))
3750 bttv_irq_switch_video(btv
);
3752 if ((astat
& BT848_INT_HLOCK
) && btv
->opt_automute
)
3755 if (astat
& (BT848_INT_SCERR
|BT848_INT_OCERR
)) {
3756 printk(KERN_INFO
"bttv%d: %s%s @ %08x,",btv
->c
.nr
,
3757 (astat
& BT848_INT_SCERR
) ? "SCERR" : "",
3758 (astat
& BT848_INT_OCERR
) ? "OCERR" : "",
3759 btread(BT848_RISC_COUNT
));
3760 bttv_print_irqbits(stat
,astat
);
3763 bttv_print_riscaddr(btv
);
3765 if (fdsr
&& astat
& BT848_INT_FDSR
) {
3766 printk(KERN_INFO
"bttv%d: FDSR @ %08x\n",
3767 btv
->c
.nr
,btread(BT848_RISC_COUNT
));
3769 bttv_print_riscaddr(btv
);
3775 if (count
> 8 || !(astat
& BT848_INT_GPINT
)) {
3776 btwrite(0, BT848_INT_MASK
);
3779 "bttv%d: IRQ lockup, cleared int mask [", btv
->c
.nr
);
3782 "bttv%d: IRQ lockup, clearing GPINT from int mask [", btv
->c
.nr
);
3784 btwrite(btread(BT848_INT_MASK
) & (-1 ^ BT848_INT_GPINT
),
3788 bttv_print_irqbits(stat
,astat
);
3796 return IRQ_RETVAL(handled
);
3800 /* ----------------------------------------------------------------------- */
3801 /* initialitation */
3803 static struct video_device
*vdev_init(struct bttv
*btv
,
3804 struct video_device
*template,
3807 struct video_device
*vfd
;
3809 vfd
= video_device_alloc();
3814 vfd
->dev
= &btv
->c
.pci
->dev
;
3815 vfd
->release
= video_device_release
;
3816 snprintf(vfd
->name
, sizeof(vfd
->name
), "BT%d%s %s (%s)",
3817 btv
->id
, (btv
->id
==848 && btv
->revision
==0x12) ? "A" : "",
3818 type
, bttv_tvcards
[btv
->c
.type
].name
);
3822 static void bttv_unregister_video(struct bttv
*btv
)
3824 if (btv
->video_dev
) {
3825 if (-1 != btv
->video_dev
->minor
)
3826 video_unregister_device(btv
->video_dev
);
3828 video_device_release(btv
->video_dev
);
3829 btv
->video_dev
= NULL
;
3832 if (-1 != btv
->vbi_dev
->minor
)
3833 video_unregister_device(btv
->vbi_dev
);
3835 video_device_release(btv
->vbi_dev
);
3836 btv
->vbi_dev
= NULL
;
3838 if (btv
->radio_dev
) {
3839 if (-1 != btv
->radio_dev
->minor
)
3840 video_unregister_device(btv
->radio_dev
);
3842 video_device_release(btv
->radio_dev
);
3843 btv
->radio_dev
= NULL
;
3847 /* register video4linux devices */
3848 static int __devinit
bttv_register_video(struct bttv
*btv
)
3850 if (no_overlay
<= 0) {
3851 bttv_video_template
.type
|= VID_TYPE_OVERLAY
;
3853 printk("bttv: Overlay support disabled.\n");
3857 btv
->video_dev
= vdev_init(btv
, &bttv_video_template
, "video");
3858 if (NULL
== btv
->video_dev
)
3860 if (video_register_device(btv
->video_dev
,VFL_TYPE_GRABBER
,video_nr
)<0)
3862 printk(KERN_INFO
"bttv%d: registered device video%d\n",
3863 btv
->c
.nr
,btv
->video_dev
->minor
& 0x1f);
3864 video_device_create_file(btv
->video_dev
, &class_device_attr_card
);
3867 btv
->vbi_dev
= vdev_init(btv
, &bttv_vbi_template
, "vbi");
3868 if (NULL
== btv
->vbi_dev
)
3870 if (video_register_device(btv
->vbi_dev
,VFL_TYPE_VBI
,vbi_nr
)<0)
3872 printk(KERN_INFO
"bttv%d: registered device vbi%d\n",
3873 btv
->c
.nr
,btv
->vbi_dev
->minor
& 0x1f);
3875 if (!btv
->has_radio
)
3878 btv
->radio_dev
= vdev_init(btv
, &radio_template
, "radio");
3879 if (NULL
== btv
->radio_dev
)
3881 if (video_register_device(btv
->radio_dev
, VFL_TYPE_RADIO
,radio_nr
)<0)
3883 printk(KERN_INFO
"bttv%d: registered device radio%d\n",
3884 btv
->c
.nr
,btv
->radio_dev
->minor
& 0x1f);
3890 bttv_unregister_video(btv
);
3895 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
3896 /* response on cards with no firmware is not enabled by OF */
3897 static void pci_set_command(struct pci_dev
*dev
)
3899 #if defined(__powerpc__)
3902 pci_read_config_dword(dev
, PCI_COMMAND
, &cmd
);
3903 cmd
= (cmd
| PCI_COMMAND_MEMORY
);
3904 pci_write_config_dword(dev
, PCI_COMMAND
, cmd
);
3908 static int __devinit
bttv_probe(struct pci_dev
*dev
,
3909 const struct pci_device_id
*pci_id
)
3915 if (bttv_num
== BTTV_MAX
)
3917 printk(KERN_INFO
"bttv: Bt8xx card found (%d).\n", bttv_num
);
3918 btv
=&bttvs
[bttv_num
];
3919 memset(btv
,0,sizeof(*btv
));
3920 btv
->c
.nr
= bttv_num
;
3921 sprintf(btv
->c
.name
,"bttv%d",btv
->c
.nr
);
3923 /* initialize structs / fill in defaults */
3924 mutex_init(&btv
->lock
);
3925 mutex_init(&btv
->reslock
);
3926 spin_lock_init(&btv
->s_lock
);
3927 spin_lock_init(&btv
->gpio_lock
);
3928 init_waitqueue_head(&btv
->gpioq
);
3929 init_waitqueue_head(&btv
->i2c_queue
);
3930 INIT_LIST_HEAD(&btv
->c
.subs
);
3931 INIT_LIST_HEAD(&btv
->capture
);
3932 INIT_LIST_HEAD(&btv
->vcapture
);
3933 v4l2_prio_init(&btv
->prio
);
3935 init_timer(&btv
->timeout
);
3936 btv
->timeout
.function
= bttv_irq_timeout
;
3937 btv
->timeout
.data
= (unsigned long)btv
;
3940 btv
->tuner_type
= UNSET
;
3941 btv
->new_input
= UNSET
;
3942 btv
->has_radio
=radio
[btv
->c
.nr
];
3944 /* pci stuff (init, get irq/mmio, ... */
3946 btv
->id
= dev
->device
;
3947 if (pci_enable_device(dev
)) {
3948 printk(KERN_WARNING
"bttv%d: Can't enable device.\n",
3952 if (pci_set_dma_mask(dev
, DMA_32BIT_MASK
)) {
3953 printk(KERN_WARNING
"bttv%d: No suitable DMA available.\n",
3957 if (!request_mem_region(pci_resource_start(dev
,0),
3958 pci_resource_len(dev
,0),
3960 printk(KERN_WARNING
"bttv%d: can't request iomem (0x%lx).\n",
3961 btv
->c
.nr
, pci_resource_start(dev
,0));
3964 pci_set_master(dev
);
3965 pci_set_command(dev
);
3966 pci_set_drvdata(dev
,btv
);
3968 pci_read_config_byte(dev
, PCI_CLASS_REVISION
, &btv
->revision
);
3969 pci_read_config_byte(dev
, PCI_LATENCY_TIMER
, &lat
);
3970 printk(KERN_INFO
"bttv%d: Bt%d (rev %d) at %s, ",
3971 bttv_num
,btv
->id
, btv
->revision
, pci_name(dev
));
3972 printk("irq: %d, latency: %d, mmio: 0x%lx\n",
3973 btv
->c
.pci
->irq
, lat
, pci_resource_start(dev
,0));
3976 btv
->bt848_mmio
=ioremap(pci_resource_start(dev
,0), 0x1000);
3977 if (NULL
== ioremap(pci_resource_start(dev
,0), 0x1000)) {
3978 printk("bttv%d: ioremap() failed\n", btv
->c
.nr
);
3986 /* disable irqs, register irq handler */
3987 btwrite(0, BT848_INT_MASK
);
3988 result
= request_irq(btv
->c
.pci
->irq
, bttv_irq
,
3989 SA_SHIRQ
| SA_INTERRUPT
,btv
->c
.name
,(void *)btv
);
3991 printk(KERN_ERR
"bttv%d: can't get IRQ %d\n",
3992 bttv_num
,btv
->c
.pci
->irq
);
3996 if (0 != bttv_handle_chipset(btv
)) {
4001 /* init options from insmod args */
4002 btv
->opt_combfilter
= combfilter
;
4003 btv
->opt_lumafilter
= lumafilter
;
4004 btv
->opt_automute
= automute
;
4005 btv
->opt_chroma_agc
= chroma_agc
;
4006 btv
->opt_adc_crush
= adc_crush
;
4007 btv
->opt_vcr_hack
= vcr_hack
;
4008 btv
->opt_whitecrush_upper
= whitecrush_upper
;
4009 btv
->opt_whitecrush_lower
= whitecrush_lower
;
4010 btv
->opt_uv_ratio
= uv_ratio
;
4011 btv
->opt_full_luma_range
= full_luma_range
;
4012 btv
->opt_coring
= coring
;
4014 /* fill struct bttv with some useful defaults */
4015 btv
->init
.btv
= btv
;
4016 btv
->init
.ov
.w
.width
= 320;
4017 btv
->init
.ov
.w
.height
= 240;
4018 btv
->init
.fmt
= format_by_palette(VIDEO_PALETTE_RGB24
);
4019 btv
->init
.width
= 320;
4020 btv
->init
.height
= 240;
4021 btv
->init
.lines
= 16;
4024 /* initialize hardware */
4026 bttv_gpio_tracking(btv
,"pre-init");
4028 bttv_risc_init_main(btv
);
4032 btwrite(0x00, BT848_GPIO_REG_INP
);
4033 btwrite(0x00, BT848_GPIO_OUT_EN
);
4035 bttv_gpio_tracking(btv
,"init");
4037 /* needs to be done before i2c is registered */
4038 bttv_init_card1(btv
);
4040 /* register i2c + gpio */
4043 /* some card-specific stuff (needs working i2c) */
4044 bttv_init_card2(btv
);
4047 /* register video4linux + input */
4048 if (!bttv_tvcards
[btv
->c
.type
].no_video
) {
4049 bttv_register_video(btv
);
4050 bt848_bright(btv
,32768);
4051 bt848_contrast(btv
,32768);
4052 bt848_hue(btv
,32768);
4053 bt848_sat(btv
,32768);
4054 audio_mux(btv
,AUDIO_MUTE
);
4058 /* add subdevices */
4059 if (bttv_tvcards
[btv
->c
.type
].has_dvb
)
4060 bttv_sub_add_device(&btv
->c
, "dvb");
4062 bttv_input_init(btv
);
4064 /* everything is fine */
4069 free_irq(btv
->c
.pci
->irq
,btv
);
4072 if (btv
->bt848_mmio
)
4073 iounmap(btv
->bt848_mmio
);
4074 release_mem_region(pci_resource_start(btv
->c
.pci
,0),
4075 pci_resource_len(btv
->c
.pci
,0));
4076 pci_set_drvdata(dev
,NULL
);
4080 static void __devexit
bttv_remove(struct pci_dev
*pci_dev
)
4082 struct bttv
*btv
= pci_get_drvdata(pci_dev
);
4085 printk("bttv%d: unloading\n",btv
->c
.nr
);
4087 /* shutdown everything (DMA+IRQs) */
4088 btand(~15, BT848_GPIO_DMA_CTL
);
4089 btwrite(0, BT848_INT_MASK
);
4090 btwrite(~0x0, BT848_INT_STAT
);
4091 btwrite(0x0, BT848_GPIO_OUT_EN
);
4093 bttv_gpio_tracking(btv
,"cleanup");
4095 /* tell gpio modules we are leaving ... */
4097 wake_up(&btv
->gpioq
);
4098 bttv_input_fini(btv
);
4099 bttv_sub_del_devices(&btv
->c
);
4101 /* unregister i2c_bus + input */
4104 /* unregister video4linux */
4105 bttv_unregister_video(btv
);
4107 /* free allocated memory */
4108 btcx_riscmem_free(btv
->c
.pci
,&btv
->main
);
4110 /* free ressources */
4111 free_irq(btv
->c
.pci
->irq
,btv
);
4112 iounmap(btv
->bt848_mmio
);
4113 release_mem_region(pci_resource_start(btv
->c
.pci
,0),
4114 pci_resource_len(btv
->c
.pci
,0));
4116 pci_set_drvdata(pci_dev
, NULL
);
4120 static int bttv_suspend(struct pci_dev
*pci_dev
, pm_message_t state
)
4122 struct bttv
*btv
= pci_get_drvdata(pci_dev
);
4123 struct bttv_buffer_set idle
;
4124 unsigned long flags
;
4126 dprintk("bttv%d: suspend %d\n", btv
->c
.nr
, state
.event
);
4128 /* stop dma + irqs */
4129 spin_lock_irqsave(&btv
->s_lock
,flags
);
4130 memset(&idle
, 0, sizeof(idle
));
4131 btv
->state
.video
= btv
->curr
;
4132 btv
->state
.vbi
= btv
->cvbi
;
4133 btv
->state
.loop_irq
= btv
->loop_irq
;
4136 bttv_buffer_activate_video(btv
, &idle
);
4137 bttv_buffer_activate_vbi(btv
, NULL
);
4138 bttv_set_dma(btv
, 0);
4139 btwrite(0, BT848_INT_MASK
);
4140 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
4142 /* save bt878 state */
4143 btv
->state
.gpio_enable
= btread(BT848_GPIO_OUT_EN
);
4144 btv
->state
.gpio_data
= gpio_read();
4146 /* save pci state */
4147 pci_save_state(pci_dev
);
4148 if (0 != pci_set_power_state(pci_dev
, pci_choose_state(pci_dev
, state
))) {
4149 pci_disable_device(pci_dev
);
4150 btv
->state
.disabled
= 1;
4155 static int bttv_resume(struct pci_dev
*pci_dev
)
4157 struct bttv
*btv
= pci_get_drvdata(pci_dev
);
4158 unsigned long flags
;
4161 dprintk("bttv%d: resume\n", btv
->c
.nr
);
4163 /* restore pci state */
4164 if (btv
->state
.disabled
) {
4165 err
=pci_enable_device(pci_dev
);
4167 printk(KERN_WARNING
"bttv%d: Can't enable device.\n",
4171 btv
->state
.disabled
= 0;
4173 err
=pci_set_power_state(pci_dev
, PCI_D0
);
4175 pci_disable_device(pci_dev
);
4176 printk(KERN_WARNING
"bttv%d: Can't enable device.\n",
4178 btv
->state
.disabled
= 1;
4182 pci_restore_state(pci_dev
);
4184 /* restore bt878 state */
4185 bttv_reinit_bt848(btv
);
4186 gpio_inout(0xffffff, btv
->state
.gpio_enable
);
4187 gpio_write(btv
->state
.gpio_data
);
4190 spin_lock_irqsave(&btv
->s_lock
,flags
);
4191 btv
->curr
= btv
->state
.video
;
4192 btv
->cvbi
= btv
->state
.vbi
;
4193 btv
->loop_irq
= btv
->state
.loop_irq
;
4194 bttv_buffer_activate_video(btv
, &btv
->curr
);
4195 bttv_buffer_activate_vbi(btv
, btv
->cvbi
);
4196 bttv_set_dma(btv
, 0);
4197 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
4201 static struct pci_device_id bttv_pci_tbl
[] = {
4202 {PCI_VENDOR_ID_BROOKTREE
, PCI_DEVICE_ID_BT848
,
4203 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
4204 {PCI_VENDOR_ID_BROOKTREE
, PCI_DEVICE_ID_BT849
,
4205 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
4206 {PCI_VENDOR_ID_BROOKTREE
, PCI_DEVICE_ID_BT878
,
4207 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
4208 {PCI_VENDOR_ID_BROOKTREE
, PCI_DEVICE_ID_BT879
,
4209 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
4213 MODULE_DEVICE_TABLE(pci
, bttv_pci_tbl
);
4215 static struct pci_driver bttv_pci_driver
= {
4217 .id_table
= bttv_pci_tbl
,
4218 .probe
= bttv_probe
,
4219 .remove
= __devexit_p(bttv_remove
),
4220 .suspend
= bttv_suspend
,
4221 .resume
= bttv_resume
,
4224 static int bttv_init_module(void)
4228 printk(KERN_INFO
"bttv: driver version %d.%d.%d loaded\n",
4229 (BTTV_VERSION_CODE
>> 16) & 0xff,
4230 (BTTV_VERSION_CODE
>> 8) & 0xff,
4231 BTTV_VERSION_CODE
& 0xff);
4233 printk(KERN_INFO
"bttv: snapshot date %04d-%02d-%02d\n",
4234 SNAPSHOT
/10000, (SNAPSHOT
/100)%100, SNAPSHOT
%100);
4236 if (gbuffers
< 2 || gbuffers
> VIDEO_MAX_FRAME
)
4238 if (gbufsize
< 0 || gbufsize
> BTTV_MAX_FBUF
)
4239 gbufsize
= BTTV_MAX_FBUF
;
4240 gbufsize
= (gbufsize
+ PAGE_SIZE
- 1) & PAGE_MASK
;
4242 printk(KERN_INFO
"bttv: using %d buffers with %dk (%d pages) each for capture\n",
4243 gbuffers
, gbufsize
>> 10, gbufsize
>> PAGE_SHIFT
);
4245 bttv_check_chipset();
4247 bus_register(&bttv_sub_bus_type
);
4248 return pci_register_driver(&bttv_pci_driver
);
4251 static void bttv_cleanup_module(void)
4253 pci_unregister_driver(&bttv_pci_driver
);
4254 bus_unregister(&bttv_sub_bus_type
);
4258 module_init(bttv_init_module
);
4259 module_exit(bttv_cleanup_module
);