3 bttv - Bt848 frame grabber driver
5 Copyright (C) 1996,97,98 Ralph Metzler <rjkm@thp.uni-koeln.de>
6 & Marcus Metzler <mocm@thp.uni-koeln.de>
7 (c) 1999-2002 Gerd Knorr <kraxel@bytesex.org>
9 some v4l2 code lines are taken from Justin's bttv2 driver which is
10 (c) 2000 Justin Schoeman <justin@suntiger.ee.up.ac.za>
12 This program is free software; you can redistribute it and/or modify
13 it under the terms of the GNU General Public License as published by
14 the Free Software Foundation; either version 2 of the License, or
15 (at your option) any later version.
17 This program is distributed in the hope that it will be useful,
18 but WITHOUT ANY WARRANTY; without even the implied warranty of
19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 GNU General Public License for more details.
22 You should have received a copy of the GNU General Public License
23 along with this program; if not, write to the Free Software
24 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 #include <linux/init.h>
28 #include <linux/module.h>
29 #include <linux/moduleparam.h>
30 #include <linux/delay.h>
31 #include <linux/errno.h>
33 #include <linux/kernel.h>
34 #include <linux/sched.h>
35 #include <linux/interrupt.h>
36 #include <linux/kdev_t.h>
38 #include <media/v4l2-common.h>
39 #include <media/tvaudio.h>
40 #include <media/msp3400.h>
42 #include <linux/dma-mapping.h>
45 #include <asm/byteorder.h>
47 #include <media/rds.h>
50 unsigned int bttv_num
; /* number of Bt848s in use */
51 struct bttv bttvs
[BTTV_MAX
];
53 unsigned int bttv_debug
;
54 unsigned int bttv_verbose
= 1;
55 unsigned int bttv_gpio
;
57 /* config variables */
59 static unsigned int bigendian
=1;
61 static unsigned int bigendian
;
63 static unsigned int radio
[BTTV_MAX
];
64 static unsigned int irq_debug
;
65 static unsigned int gbuffers
= 8;
66 static unsigned int gbufsize
= 0x208000;
68 static int video_nr
= -1;
69 static int radio_nr
= -1;
70 static int vbi_nr
= -1;
71 static int debug_latency
;
73 static unsigned int fdsr
;
76 static unsigned int combfilter
;
77 static unsigned int lumafilter
;
78 static unsigned int automute
= 1;
79 static unsigned int chroma_agc
;
80 static unsigned int adc_crush
= 1;
81 static unsigned int whitecrush_upper
= 0xCF;
82 static unsigned int whitecrush_lower
= 0x7F;
83 static unsigned int vcr_hack
;
84 static unsigned int irq_iswitch
;
85 static unsigned int uv_ratio
= 50;
86 static unsigned int full_luma_range
;
87 static unsigned int coring
;
88 extern int no_overlay
;
90 /* API features (turn on/off stuff for testing) */
91 static unsigned int v4l2
= 1;
94 module_param(bttv_verbose
, int, 0644);
95 module_param(bttv_gpio
, int, 0644);
96 module_param(bttv_debug
, int, 0644);
97 module_param(irq_debug
, int, 0644);
98 module_param(debug_latency
, int, 0644);
100 module_param(fdsr
, int, 0444);
101 module_param(video_nr
, int, 0444);
102 module_param(radio_nr
, int, 0444);
103 module_param(vbi_nr
, int, 0444);
104 module_param(gbuffers
, int, 0444);
105 module_param(gbufsize
, int, 0444);
107 module_param(v4l2
, int, 0644);
108 module_param(bigendian
, int, 0644);
109 module_param(irq_iswitch
, int, 0644);
110 module_param(combfilter
, int, 0444);
111 module_param(lumafilter
, int, 0444);
112 module_param(automute
, int, 0444);
113 module_param(chroma_agc
, int, 0444);
114 module_param(adc_crush
, int, 0444);
115 module_param(whitecrush_upper
, int, 0444);
116 module_param(whitecrush_lower
, int, 0444);
117 module_param(vcr_hack
, int, 0444);
118 module_param(uv_ratio
, int, 0444);
119 module_param(full_luma_range
, int, 0444);
120 module_param(coring
, int, 0444);
122 module_param_array(radio
, int, NULL
, 0444);
124 MODULE_PARM_DESC(radio
,"The TV card supports radio, default is 0 (no)");
125 MODULE_PARM_DESC(bigendian
,"byte order of the framebuffer, default is native endian");
126 MODULE_PARM_DESC(bttv_verbose
,"verbose startup messages, default is 1 (yes)");
127 MODULE_PARM_DESC(bttv_gpio
,"log gpio changes, default is 0 (no)");
128 MODULE_PARM_DESC(bttv_debug
,"debug messages, default is 0 (no)");
129 MODULE_PARM_DESC(irq_debug
,"irq handler debug messages, default is 0 (no)");
130 MODULE_PARM_DESC(gbuffers
,"number of capture buffers. range 2-32, default 8");
131 MODULE_PARM_DESC(gbufsize
,"size of the capture buffers, default is 0x208000");
132 MODULE_PARM_DESC(automute
,"mute audio on bad/missing video signal, default is 1 (yes)");
133 MODULE_PARM_DESC(chroma_agc
,"enables the AGC of chroma signal, default is 0 (no)");
134 MODULE_PARM_DESC(adc_crush
,"enables the luminance ADC crush, default is 1 (yes)");
135 MODULE_PARM_DESC(whitecrush_upper
,"sets the white crush upper value, default is 207");
136 MODULE_PARM_DESC(whitecrush_lower
,"sets the white crush lower value, default is 127");
137 MODULE_PARM_DESC(vcr_hack
,"enables the VCR hack (improves synch on poor VCR tapes), default is 0 (no)");
138 MODULE_PARM_DESC(irq_iswitch
,"switch inputs in irq handler");
139 MODULE_PARM_DESC(uv_ratio
,"ratio between u and v gains, default is 50");
140 MODULE_PARM_DESC(full_luma_range
,"use the full luma range, default is 0 (no)");
141 MODULE_PARM_DESC(coring
,"set the luma coring level, default is 0 (no)");
143 MODULE_DESCRIPTION("bttv - v4l/v4l2 driver module for bt848/878 based cards");
144 MODULE_AUTHOR("Ralph Metzler & Marcus Metzler & Gerd Knorr");
145 MODULE_LICENSE("GPL");
147 /* ----------------------------------------------------------------------- */
150 static ssize_t
show_card(struct class_device
*cd
, char *buf
)
152 struct video_device
*vfd
= to_video_device(cd
);
153 struct bttv
*btv
= dev_get_drvdata(vfd
->dev
);
154 return sprintf(buf
, "%d\n", btv
? btv
->c
.type
: UNSET
);
156 static CLASS_DEVICE_ATTR(card
, S_IRUGO
, show_card
, NULL
);
158 /* ----------------------------------------------------------------------- */
161 /* special timing tables from conexant... */
162 static u8 SRAM_Table
[][60] =
164 /* PAL digital input over GPIO[7:0] */
166 45, // 45 bytes following
167 0x36,0x11,0x01,0x00,0x90,0x02,0x05,0x10,0x04,0x16,
168 0x12,0x05,0x11,0x00,0x04,0x12,0xC0,0x00,0x31,0x00,
169 0x06,0x51,0x08,0x03,0x89,0x08,0x07,0xC0,0x44,0x00,
170 0x81,0x01,0x01,0xA9,0x0D,0x02,0x02,0x50,0x03,0x37,
171 0x37,0x00,0xAF,0x21,0x00
173 /* NTSC digital input over GPIO[7:0] */
175 51, // 51 bytes following
176 0x0C,0xC0,0x00,0x00,0x90,0x02,0x03,0x10,0x03,0x06,
177 0x10,0x04,0x12,0x12,0x05,0x02,0x13,0x04,0x19,0x00,
178 0x04,0x39,0x00,0x06,0x59,0x08,0x03,0x83,0x08,0x07,
179 0x03,0x50,0x00,0xC0,0x40,0x00,0x86,0x01,0x01,0xA6,
180 0x0D,0x02,0x03,0x11,0x01,0x05,0x37,0x00,0xAC,0x21,
183 // TGB_NTSC392 // quartzsight
184 // This table has been modified to be used for Fusion Rev D
186 0x2A, // size of table = 42
187 0x06, 0x08, 0x04, 0x0a, 0xc0, 0x00, 0x18, 0x08, 0x03, 0x24,
188 0x08, 0x07, 0x02, 0x90, 0x02, 0x08, 0x10, 0x04, 0x0c, 0x10,
189 0x05, 0x2c, 0x11, 0x04, 0x55, 0x48, 0x00, 0x05, 0x50, 0x00,
190 0xbf, 0x0c, 0x02, 0x2f, 0x3d, 0x00, 0x2f, 0x3f, 0x00, 0xc3,
195 const struct bttv_tvnorm bttv_tvnorms
[] = {
197 /* max. active video is actually 922, but 924 is divisible by 4 and 3! */
198 /* actually, max active PAL with HSCALE=0 is 948, NTSC is 768 - nil */
200 .v4l2_id
= V4L2_STD_PAL
,
208 .iform
= (BT848_IFORM_PAL_BDGHI
|BT848_IFORM_XT1
),
209 .scaledtwidth
= 1135,
215 /* ITU-R frame line number of the first VBI line
216 we can capture, of the first and second field. */
217 .vbistart
= { 7,320 },
219 .v4l2_id
= V4L2_STD_NTSC_M
| V4L2_STD_NTSC_M_KR
,
227 .iform
= (BT848_IFORM_NTSC
|BT848_IFORM_XT0
),
234 .vbistart
= { 10, 273 },
236 .v4l2_id
= V4L2_STD_SECAM
,
244 .iform
= (BT848_IFORM_SECAM
|BT848_IFORM_XT1
),
245 .scaledtwidth
= 1135,
250 .sram
= 0, /* like PAL, correct? */
251 .vbistart
= { 7, 320 },
253 .v4l2_id
= V4L2_STD_PAL_Nc
,
261 .iform
= (BT848_IFORM_PAL_NC
|BT848_IFORM_XT0
),
268 .vbistart
= { 7, 320 },
270 .v4l2_id
= V4L2_STD_PAL_M
,
278 .iform
= (BT848_IFORM_PAL_M
|BT848_IFORM_XT0
),
285 .vbistart
= { 10, 273 },
287 .v4l2_id
= V4L2_STD_PAL_N
,
295 .iform
= (BT848_IFORM_PAL_N
|BT848_IFORM_XT1
),
302 .vbistart
= { 7, 320},
304 .v4l2_id
= V4L2_STD_NTSC_M_JP
,
312 .iform
= (BT848_IFORM_NTSC_J
|BT848_IFORM_XT0
),
319 .vbistart
= {10, 273},
321 /* that one hopefully works with the strange timing
322 * which video recorders produce when playing a NTSC
323 * tape on a PAL TV ... */
324 .v4l2_id
= V4L2_STD_PAL_60
,
332 .iform
= (BT848_IFORM_PAL_BDGHI
|BT848_IFORM_XT1
),
333 .scaledtwidth
= 1135,
340 .vbistart
= { 10, 273 },
343 static const unsigned int BTTV_TVNORMS
= ARRAY_SIZE(bttv_tvnorms
);
345 /* ----------------------------------------------------------------------- */
347 packed pixel formats must come first */
348 static const struct bttv_format bttv_formats
[] = {
350 .name
= "8 bpp, gray",
351 .palette
= VIDEO_PALETTE_GREY
,
352 .fourcc
= V4L2_PIX_FMT_GREY
,
353 .btformat
= BT848_COLOR_FMT_Y8
,
355 .flags
= FORMAT_FLAGS_PACKED
,
357 .name
= "8 bpp, dithered color",
358 .palette
= VIDEO_PALETTE_HI240
,
359 .fourcc
= V4L2_PIX_FMT_HI240
,
360 .btformat
= BT848_COLOR_FMT_RGB8
,
362 .flags
= FORMAT_FLAGS_PACKED
| FORMAT_FLAGS_DITHER
,
364 .name
= "15 bpp RGB, le",
365 .palette
= VIDEO_PALETTE_RGB555
,
366 .fourcc
= V4L2_PIX_FMT_RGB555
,
367 .btformat
= BT848_COLOR_FMT_RGB15
,
369 .flags
= FORMAT_FLAGS_PACKED
,
371 .name
= "15 bpp RGB, be",
373 .fourcc
= V4L2_PIX_FMT_RGB555X
,
374 .btformat
= BT848_COLOR_FMT_RGB15
,
375 .btswap
= 0x03, /* byteswap */
377 .flags
= FORMAT_FLAGS_PACKED
,
379 .name
= "16 bpp RGB, le",
380 .palette
= VIDEO_PALETTE_RGB565
,
381 .fourcc
= V4L2_PIX_FMT_RGB565
,
382 .btformat
= BT848_COLOR_FMT_RGB16
,
384 .flags
= FORMAT_FLAGS_PACKED
,
386 .name
= "16 bpp RGB, be",
388 .fourcc
= V4L2_PIX_FMT_RGB565X
,
389 .btformat
= BT848_COLOR_FMT_RGB16
,
390 .btswap
= 0x03, /* byteswap */
392 .flags
= FORMAT_FLAGS_PACKED
,
394 .name
= "24 bpp RGB, le",
395 .palette
= VIDEO_PALETTE_RGB24
,
396 .fourcc
= V4L2_PIX_FMT_BGR24
,
397 .btformat
= BT848_COLOR_FMT_RGB24
,
399 .flags
= FORMAT_FLAGS_PACKED
,
401 .name
= "32 bpp RGB, le",
402 .palette
= VIDEO_PALETTE_RGB32
,
403 .fourcc
= V4L2_PIX_FMT_BGR32
,
404 .btformat
= BT848_COLOR_FMT_RGB32
,
406 .flags
= FORMAT_FLAGS_PACKED
,
408 .name
= "32 bpp RGB, be",
410 .fourcc
= V4L2_PIX_FMT_RGB32
,
411 .btformat
= BT848_COLOR_FMT_RGB32
,
412 .btswap
= 0x0f, /* byte+word swap */
414 .flags
= FORMAT_FLAGS_PACKED
,
416 .name
= "4:2:2, packed, YUYV",
417 .palette
= VIDEO_PALETTE_YUV422
,
418 .fourcc
= V4L2_PIX_FMT_YUYV
,
419 .btformat
= BT848_COLOR_FMT_YUY2
,
421 .flags
= FORMAT_FLAGS_PACKED
,
423 .name
= "4:2:2, packed, YUYV",
424 .palette
= VIDEO_PALETTE_YUYV
,
425 .fourcc
= V4L2_PIX_FMT_YUYV
,
426 .btformat
= BT848_COLOR_FMT_YUY2
,
428 .flags
= FORMAT_FLAGS_PACKED
,
430 .name
= "4:2:2, packed, UYVY",
431 .palette
= VIDEO_PALETTE_UYVY
,
432 .fourcc
= V4L2_PIX_FMT_UYVY
,
433 .btformat
= BT848_COLOR_FMT_YUY2
,
434 .btswap
= 0x03, /* byteswap */
436 .flags
= FORMAT_FLAGS_PACKED
,
438 .name
= "4:2:2, planar, Y-Cb-Cr",
439 .palette
= VIDEO_PALETTE_YUV422P
,
440 .fourcc
= V4L2_PIX_FMT_YUV422P
,
441 .btformat
= BT848_COLOR_FMT_YCrCb422
,
443 .flags
= FORMAT_FLAGS_PLANAR
,
447 .name
= "4:2:0, planar, Y-Cb-Cr",
448 .palette
= VIDEO_PALETTE_YUV420P
,
449 .fourcc
= V4L2_PIX_FMT_YUV420
,
450 .btformat
= BT848_COLOR_FMT_YCrCb422
,
452 .flags
= FORMAT_FLAGS_PLANAR
,
456 .name
= "4:2:0, planar, Y-Cr-Cb",
458 .fourcc
= V4L2_PIX_FMT_YVU420
,
459 .btformat
= BT848_COLOR_FMT_YCrCb422
,
461 .flags
= FORMAT_FLAGS_PLANAR
| FORMAT_FLAGS_CrCb
,
465 .name
= "4:1:1, planar, Y-Cb-Cr",
466 .palette
= VIDEO_PALETTE_YUV411P
,
467 .fourcc
= V4L2_PIX_FMT_YUV411P
,
468 .btformat
= BT848_COLOR_FMT_YCrCb411
,
470 .flags
= FORMAT_FLAGS_PLANAR
,
474 .name
= "4:1:0, planar, Y-Cb-Cr",
475 .palette
= VIDEO_PALETTE_YUV410P
,
476 .fourcc
= V4L2_PIX_FMT_YUV410
,
477 .btformat
= BT848_COLOR_FMT_YCrCb411
,
479 .flags
= FORMAT_FLAGS_PLANAR
,
483 .name
= "4:1:0, planar, Y-Cr-Cb",
485 .fourcc
= V4L2_PIX_FMT_YVU410
,
486 .btformat
= BT848_COLOR_FMT_YCrCb411
,
488 .flags
= FORMAT_FLAGS_PLANAR
| FORMAT_FLAGS_CrCb
,
492 .name
= "raw scanlines",
493 .palette
= VIDEO_PALETTE_RAW
,
495 .btformat
= BT848_COLOR_FMT_RAW
,
497 .flags
= FORMAT_FLAGS_RAW
,
500 static const unsigned int BTTV_FORMATS
= ARRAY_SIZE(bttv_formats
);
502 /* ----------------------------------------------------------------------- */
504 #define V4L2_CID_PRIVATE_CHROMA_AGC (V4L2_CID_PRIVATE_BASE + 0)
505 #define V4L2_CID_PRIVATE_COMBFILTER (V4L2_CID_PRIVATE_BASE + 1)
506 #define V4L2_CID_PRIVATE_AUTOMUTE (V4L2_CID_PRIVATE_BASE + 2)
507 #define V4L2_CID_PRIVATE_LUMAFILTER (V4L2_CID_PRIVATE_BASE + 3)
508 #define V4L2_CID_PRIVATE_AGC_CRUSH (V4L2_CID_PRIVATE_BASE + 4)
509 #define V4L2_CID_PRIVATE_VCR_HACK (V4L2_CID_PRIVATE_BASE + 5)
510 #define V4L2_CID_PRIVATE_WHITECRUSH_UPPER (V4L2_CID_PRIVATE_BASE + 6)
511 #define V4L2_CID_PRIVATE_WHITECRUSH_LOWER (V4L2_CID_PRIVATE_BASE + 7)
512 #define V4L2_CID_PRIVATE_UV_RATIO (V4L2_CID_PRIVATE_BASE + 8)
513 #define V4L2_CID_PRIVATE_FULL_LUMA_RANGE (V4L2_CID_PRIVATE_BASE + 9)
514 #define V4L2_CID_PRIVATE_CORING (V4L2_CID_PRIVATE_BASE + 10)
515 #define V4L2_CID_PRIVATE_LASTP1 (V4L2_CID_PRIVATE_BASE + 11)
517 static const struct v4l2_queryctrl no_ctl
= {
519 .flags
= V4L2_CTRL_FLAG_DISABLED
,
521 static const struct v4l2_queryctrl bttv_ctls
[] = {
524 .id
= V4L2_CID_BRIGHTNESS
,
525 .name
= "Brightness",
529 .default_value
= 32768,
530 .type
= V4L2_CTRL_TYPE_INTEGER
,
532 .id
= V4L2_CID_CONTRAST
,
537 .default_value
= 32768,
538 .type
= V4L2_CTRL_TYPE_INTEGER
,
540 .id
= V4L2_CID_SATURATION
,
541 .name
= "Saturation",
545 .default_value
= 32768,
546 .type
= V4L2_CTRL_TYPE_INTEGER
,
553 .default_value
= 32768,
554 .type
= V4L2_CTRL_TYPE_INTEGER
,
558 .id
= V4L2_CID_AUDIO_MUTE
,
562 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
564 .id
= V4L2_CID_AUDIO_VOLUME
,
569 .default_value
= 65535,
570 .type
= V4L2_CTRL_TYPE_INTEGER
,
572 .id
= V4L2_CID_AUDIO_BALANCE
,
577 .default_value
= 32768,
578 .type
= V4L2_CTRL_TYPE_INTEGER
,
580 .id
= V4L2_CID_AUDIO_BASS
,
585 .default_value
= 32768,
586 .type
= V4L2_CTRL_TYPE_INTEGER
,
588 .id
= V4L2_CID_AUDIO_TREBLE
,
593 .default_value
= 32768,
594 .type
= V4L2_CTRL_TYPE_INTEGER
,
596 /* --- private --- */
598 .id
= V4L2_CID_PRIVATE_CHROMA_AGC
,
599 .name
= "chroma agc",
602 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
604 .id
= V4L2_CID_PRIVATE_COMBFILTER
,
605 .name
= "combfilter",
608 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
610 .id
= V4L2_CID_PRIVATE_AUTOMUTE
,
614 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
616 .id
= V4L2_CID_PRIVATE_LUMAFILTER
,
617 .name
= "luma decimation filter",
620 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
622 .id
= V4L2_CID_PRIVATE_AGC_CRUSH
,
626 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
628 .id
= V4L2_CID_PRIVATE_VCR_HACK
,
632 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
634 .id
= V4L2_CID_PRIVATE_WHITECRUSH_UPPER
,
635 .name
= "whitecrush upper",
639 .default_value
= 0xCF,
640 .type
= V4L2_CTRL_TYPE_INTEGER
,
642 .id
= V4L2_CID_PRIVATE_WHITECRUSH_LOWER
,
643 .name
= "whitecrush lower",
647 .default_value
= 0x7F,
648 .type
= V4L2_CTRL_TYPE_INTEGER
,
650 .id
= V4L2_CID_PRIVATE_UV_RATIO
,
656 .type
= V4L2_CTRL_TYPE_INTEGER
,
658 .id
= V4L2_CID_PRIVATE_FULL_LUMA_RANGE
,
659 .name
= "full luma range",
662 .type
= V4L2_CTRL_TYPE_BOOLEAN
,
664 .id
= V4L2_CID_PRIVATE_CORING
,
670 .type
= V4L2_CTRL_TYPE_INTEGER
,
676 static const int BTTV_CTLS
= ARRAY_SIZE(bttv_ctls
);
678 /* ----------------------------------------------------------------------- */
679 /* resource management */
682 int check_alloc_btres(struct bttv
*btv
, struct bttv_fh
*fh
, int bit
)
684 if (fh
->resources
& bit
)
685 /* have it already allocated */
689 mutex_lock(&btv
->reslock
);
690 if (btv
->resources
& bit
) {
691 /* no, someone else uses it */
692 mutex_unlock(&btv
->reslock
);
695 /* it's free, grab it */
696 fh
->resources
|= bit
;
697 btv
->resources
|= bit
;
698 mutex_unlock(&btv
->reslock
);
703 int check_btres(struct bttv_fh
*fh
, int bit
)
705 return (fh
->resources
& bit
);
709 int locked_btres(struct bttv
*btv
, int bit
)
711 return (btv
->resources
& bit
);
715 void free_btres(struct bttv
*btv
, struct bttv_fh
*fh
, int bits
)
717 if ((fh
->resources
& bits
) != bits
) {
718 /* trying to free ressources not allocated by us ... */
719 printk("bttv: BUG! (btres)\n");
721 mutex_lock(&btv
->reslock
);
722 fh
->resources
&= ~bits
;
723 btv
->resources
&= ~bits
;
724 mutex_unlock(&btv
->reslock
);
727 /* ----------------------------------------------------------------------- */
728 /* If Bt848a or Bt849, use PLL for PAL/SECAM and crystal for NTSC */
730 /* Frequency = (F_input / PLL_X) * PLL_I.PLL_F/PLL_C
731 PLL_X = Reference pre-divider (0=1, 1=2)
732 PLL_C = Post divider (0=6, 1=4)
733 PLL_I = Integer input
734 PLL_F = Fractional input
736 F_input = 28.636363 MHz:
737 PAL (CLKx2 = 35.46895 MHz): PLL_X = 1, PLL_I = 0x0E, PLL_F = 0xDCF9, PLL_C = 0
740 static void set_pll_freq(struct bttv
*btv
, unsigned int fin
, unsigned int fout
)
742 unsigned char fl
, fh
, fi
;
744 /* prevent overflows */
757 btwrite(fl
, BT848_PLL_F_LO
);
758 btwrite(fh
, BT848_PLL_F_HI
);
759 btwrite(fi
|BT848_PLL_X
, BT848_PLL_XCI
);
762 static void set_pll(struct bttv
*btv
)
766 if (!btv
->pll
.pll_crystal
)
769 if (btv
->pll
.pll_ofreq
== btv
->pll
.pll_current
) {
770 dprintk("bttv%d: PLL: no change required\n",btv
->c
.nr
);
774 if (btv
->pll
.pll_ifreq
== btv
->pll
.pll_ofreq
) {
776 if (btv
->pll
.pll_current
== 0)
778 bttv_printk(KERN_INFO
"bttv%d: PLL can sleep, using XTAL (%d).\n",
779 btv
->c
.nr
,btv
->pll
.pll_ifreq
);
780 btwrite(0x00,BT848_TGCTRL
);
781 btwrite(0x00,BT848_PLL_XCI
);
782 btv
->pll
.pll_current
= 0;
786 bttv_printk(KERN_INFO
"bttv%d: PLL: %d => %d ",btv
->c
.nr
,
787 btv
->pll
.pll_ifreq
, btv
->pll
.pll_ofreq
);
788 set_pll_freq(btv
, btv
->pll
.pll_ifreq
, btv
->pll
.pll_ofreq
);
790 for (i
=0; i
<10; i
++) {
791 /* Let other people run while the PLL stabilizes */
795 if (btread(BT848_DSTATUS
) & BT848_DSTATUS_PLOCK
) {
796 btwrite(0,BT848_DSTATUS
);
798 btwrite(0x08,BT848_TGCTRL
);
799 btv
->pll
.pll_current
= btv
->pll
.pll_ofreq
;
800 bttv_printk(" ok\n");
804 btv
->pll
.pll_current
= -1;
805 bttv_printk("failed\n");
809 /* used to switch between the bt848's analog/digital video capture modes */
810 static void bt848A_set_timing(struct bttv
*btv
)
813 int table_idx
= bttv_tvnorms
[btv
->tvnorm
].sram
;
814 int fsc
= bttv_tvnorms
[btv
->tvnorm
].Fsc
;
816 if (UNSET
== bttv_tvcards
[btv
->c
.type
].muxsel
[btv
->input
]) {
817 dprintk("bttv%d: load digital timing table (table_idx=%d)\n",
818 btv
->c
.nr
,table_idx
);
820 /* timing change...reset timing generator address */
821 btwrite(0x00, BT848_TGCTRL
);
822 btwrite(0x02, BT848_TGCTRL
);
823 btwrite(0x00, BT848_TGCTRL
);
825 len
=SRAM_Table
[table_idx
][0];
826 for(i
= 1; i
<= len
; i
++)
827 btwrite(SRAM_Table
[table_idx
][i
],BT848_TGLB
);
828 btv
->pll
.pll_ofreq
= 27000000;
831 btwrite(0x11, BT848_TGCTRL
);
832 btwrite(0x41, BT848_DVSIF
);
834 btv
->pll
.pll_ofreq
= fsc
;
836 btwrite(0x0, BT848_DVSIF
);
840 /* ----------------------------------------------------------------------- */
842 static void bt848_bright(struct bttv
*btv
, int bright
)
846 // printk("bttv: set bright: %d\n",bright); // DEBUG
847 btv
->bright
= bright
;
849 /* We want -128 to 127 we get 0-65535 */
850 value
= (bright
>> 8) - 128;
851 btwrite(value
& 0xff, BT848_BRIGHT
);
854 static void bt848_hue(struct bttv
*btv
, int hue
)
861 value
= (hue
>> 8) - 128;
862 btwrite(value
& 0xff, BT848_HUE
);
865 static void bt848_contrast(struct bttv
*btv
, int cont
)
869 btv
->contrast
= cont
;
873 hibit
= (value
>> 6) & 4;
874 btwrite(value
& 0xff, BT848_CONTRAST_LO
);
875 btaor(hibit
, ~4, BT848_E_CONTROL
);
876 btaor(hibit
, ~4, BT848_O_CONTROL
);
879 static void bt848_sat(struct bttv
*btv
, int color
)
881 int val_u
,val_v
,hibits
;
883 btv
->saturation
= color
;
885 /* 0-511 for the color */
886 val_u
= ((color
* btv
->opt_uv_ratio
) / 50) >> 7;
887 val_v
= (((color
* (100 - btv
->opt_uv_ratio
) / 50) >>7)*180L)/254;
888 hibits
= (val_u
>> 7) & 2;
889 hibits
|= (val_v
>> 8) & 1;
890 btwrite(val_u
& 0xff, BT848_SAT_U_LO
);
891 btwrite(val_v
& 0xff, BT848_SAT_V_LO
);
892 btaor(hibits
, ~3, BT848_E_CONTROL
);
893 btaor(hibits
, ~3, BT848_O_CONTROL
);
896 /* ----------------------------------------------------------------------- */
899 video_mux(struct bttv
*btv
, unsigned int input
)
903 if (input
>= bttv_tvcards
[btv
->c
.type
].video_inputs
)
906 /* needed by RemoteVideo MX */
907 mask2
= bttv_tvcards
[btv
->c
.type
].gpiomask2
;
909 gpio_inout(mask2
,mask2
);
911 if (input
== btv
->svhs
) {
912 btor(BT848_CONTROL_COMP
, BT848_E_CONTROL
);
913 btor(BT848_CONTROL_COMP
, BT848_O_CONTROL
);
915 btand(~BT848_CONTROL_COMP
, BT848_E_CONTROL
);
916 btand(~BT848_CONTROL_COMP
, BT848_O_CONTROL
);
918 mux
= bttv_tvcards
[btv
->c
.type
].muxsel
[input
] & 3;
919 btaor(mux
<<5, ~(3<<5), BT848_IFORM
);
920 dprintk(KERN_DEBUG
"bttv%d: video mux: input=%d mux=%d\n",
921 btv
->c
.nr
,input
,mux
);
923 /* card specific hook */
924 if(bttv_tvcards
[btv
->c
.type
].muxsel_hook
)
925 bttv_tvcards
[btv
->c
.type
].muxsel_hook (btv
, input
);
929 static char *audio_modes
[] = {
930 "audio: tuner", "audio: radio", "audio: extern",
931 "audio: intern", "audio: mute"
935 audio_mux(struct bttv
*btv
, int input
, int mute
)
937 int gpio_val
, signal
;
938 struct v4l2_control ctrl
;
939 struct i2c_client
*c
;
941 gpio_inout(bttv_tvcards
[btv
->c
.type
].gpiomask
,
942 bttv_tvcards
[btv
->c
.type
].gpiomask
);
943 signal
= btread(BT848_DSTATUS
) & BT848_DSTATUS_HLOC
;
949 mute
= mute
|| (btv
->opt_automute
&& !signal
&& !btv
->radio_user
);
952 gpio_val
= bttv_tvcards
[btv
->c
.type
].gpiomute
;
954 gpio_val
= bttv_tvcards
[btv
->c
.type
].gpiomux
[input
];
956 gpio_bits(bttv_tvcards
[btv
->c
.type
].gpiomask
, gpio_val
);
958 bttv_gpio_tracking(btv
, audio_modes
[mute
? 4 : input
]);
962 ctrl
.id
= V4L2_CID_AUDIO_MUTE
;
963 ctrl
.value
= btv
->mute
;
964 bttv_call_i2c_clients(btv
, VIDIOC_S_CTRL
, &ctrl
);
965 c
= btv
->i2c_msp34xx_client
;
967 struct v4l2_routing route
;
969 /* Note: the inputs tuner/radio/extern/intern are translated
970 to msp routings. This assumes common behavior for all msp3400
971 based TV cards. When this assumption fails, then the
972 specific MSP routing must be added to the card table.
973 For now this is sufficient. */
975 case TVAUDIO_INPUT_RADIO
:
976 route
.input
= MSP_INPUT(MSP_IN_SCART2
, MSP_IN_TUNER1
,
977 MSP_DSP_IN_SCART
, MSP_DSP_IN_SCART
);
979 case TVAUDIO_INPUT_EXTERN
:
980 route
.input
= MSP_INPUT(MSP_IN_SCART1
, MSP_IN_TUNER1
,
981 MSP_DSP_IN_SCART
, MSP_DSP_IN_SCART
);
983 case TVAUDIO_INPUT_INTERN
:
984 /* Yes, this is the same input as for RADIO. I doubt
985 if this is ever used. The only board with an INTERN
986 input is the BTTV_BOARD_AVERMEDIA98. I wonder how
987 that was tested. My guess is that the whole INTERN
988 input does not work. */
989 route
.input
= MSP_INPUT(MSP_IN_SCART2
, MSP_IN_TUNER1
,
990 MSP_DSP_IN_SCART
, MSP_DSP_IN_SCART
);
992 case TVAUDIO_INPUT_TUNER
:
994 route
.input
= MSP_INPUT_DEFAULT
;
997 route
.output
= MSP_OUTPUT_DEFAULT
;
998 c
->driver
->command(c
, VIDIOC_INT_S_AUDIO_ROUTING
, &route
);
1000 c
= btv
->i2c_tvaudio_client
;
1002 struct v4l2_routing route
;
1004 route
.input
= input
;
1006 c
->driver
->command(c
, VIDIOC_INT_S_AUDIO_ROUTING
, &route
);
1012 audio_mute(struct bttv
*btv
, int mute
)
1014 return audio_mux(btv
, btv
->audio
, mute
);
1018 audio_input(struct bttv
*btv
, int input
)
1020 return audio_mux(btv
, input
, btv
->mute
);
1024 i2c_vidiocschan(struct bttv
*btv
)
1026 v4l2_std_id std
= bttv_tvnorms
[btv
->tvnorm
].v4l2_id
;
1028 bttv_call_i2c_clients(btv
, VIDIOC_S_STD
, &std
);
1029 if (btv
->c
.type
== BTTV_BOARD_VOODOOTV_FM
)
1030 bttv_tda9880_setnorm(btv
,btv
->tvnorm
);
1034 set_tvnorm(struct bttv
*btv
, unsigned int norm
)
1036 const struct bttv_tvnorm
*tvnorm
;
1038 if (norm
< 0 || norm
>= BTTV_TVNORMS
)
1042 tvnorm
= &bttv_tvnorms
[norm
];
1044 btwrite(tvnorm
->adelay
, BT848_ADELAY
);
1045 btwrite(tvnorm
->bdelay
, BT848_BDELAY
);
1046 btaor(tvnorm
->iform
,~(BT848_IFORM_NORM
|BT848_IFORM_XTBOTH
),
1048 btwrite(tvnorm
->vbipack
, BT848_VBI_PACK_SIZE
);
1049 btwrite(1, BT848_VBI_PACK_DEL
);
1050 bt848A_set_timing(btv
);
1052 switch (btv
->c
.type
) {
1053 case BTTV_BOARD_VOODOOTV_FM
:
1054 bttv_tda9880_setnorm(btv
,norm
);
1061 set_input(struct bttv
*btv
, unsigned int input
)
1063 unsigned long flags
;
1067 spin_lock_irqsave(&btv
->s_lock
,flags
);
1068 if (btv
->curr
.frame_irq
) {
1069 /* active capture -> delayed input switch */
1070 btv
->new_input
= input
;
1072 video_mux(btv
,input
);
1074 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
1076 video_mux(btv
,input
);
1078 audio_input(btv
,(input
== bttv_tvcards
[btv
->c
.type
].tuner
?
1079 TVAUDIO_INPUT_TUNER
: TVAUDIO_INPUT_EXTERN
));
1080 set_tvnorm(btv
,btv
->tvnorm
);
1081 i2c_vidiocschan(btv
);
1084 static void init_irqreg(struct bttv
*btv
)
1087 btwrite(0xfffffUL
, BT848_INT_STAT
);
1089 if (bttv_tvcards
[btv
->c
.type
].no_video
) {
1091 btwrite(BT848_INT_I2CDONE
,
1095 btwrite((btv
->triton1
) |
1096 (btv
->gpioirq
? BT848_INT_GPINT
: 0) |
1098 (fdsr
? BT848_INT_FDSR
: 0) |
1099 BT848_INT_RISCI
|BT848_INT_OCERR
|BT848_INT_VPRES
|
1100 BT848_INT_FMTCHG
|BT848_INT_HLOCK
|
1106 static void init_bt848(struct bttv
*btv
)
1110 if (bttv_tvcards
[btv
->c
.type
].no_video
) {
1111 /* very basic init only */
1116 btwrite(0x00, BT848_CAP_CTL
);
1117 btwrite(BT848_COLOR_CTL_GAMMA
, BT848_COLOR_CTL
);
1118 btwrite(BT848_IFORM_XTAUTO
| BT848_IFORM_AUTO
, BT848_IFORM
);
1120 /* set planar and packed mode trigger points and */
1121 /* set rising edge of inverted GPINTR pin as irq trigger */
1122 btwrite(BT848_GPIO_DMA_CTL_PKTP_32
|
1123 BT848_GPIO_DMA_CTL_PLTP1_16
|
1124 BT848_GPIO_DMA_CTL_PLTP23_16
|
1125 BT848_GPIO_DMA_CTL_GPINTC
|
1126 BT848_GPIO_DMA_CTL_GPINTI
,
1127 BT848_GPIO_DMA_CTL
);
1129 val
= btv
->opt_chroma_agc
? BT848_SCLOOP_CAGC
: 0;
1130 btwrite(val
, BT848_E_SCLOOP
);
1131 btwrite(val
, BT848_O_SCLOOP
);
1133 btwrite(0x20, BT848_E_VSCALE_HI
);
1134 btwrite(0x20, BT848_O_VSCALE_HI
);
1135 btwrite(BT848_ADC_RESERVED
| (btv
->opt_adc_crush
? BT848_ADC_CRUSH
: 0),
1138 btwrite(whitecrush_upper
, BT848_WC_UP
);
1139 btwrite(whitecrush_lower
, BT848_WC_DOWN
);
1141 if (btv
->opt_lumafilter
) {
1142 btwrite(0, BT848_E_CONTROL
);
1143 btwrite(0, BT848_O_CONTROL
);
1145 btwrite(BT848_CONTROL_LDEC
, BT848_E_CONTROL
);
1146 btwrite(BT848_CONTROL_LDEC
, BT848_O_CONTROL
);
1149 bt848_bright(btv
, btv
->bright
);
1150 bt848_hue(btv
, btv
->hue
);
1151 bt848_contrast(btv
, btv
->contrast
);
1152 bt848_sat(btv
, btv
->saturation
);
1158 static void bttv_reinit_bt848(struct bttv
*btv
)
1160 unsigned long flags
;
1163 printk(KERN_INFO
"bttv%d: reset, reinitialize\n",btv
->c
.nr
);
1164 spin_lock_irqsave(&btv
->s_lock
,flags
);
1166 bttv_set_dma(btv
,0);
1167 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
1170 btv
->pll
.pll_current
= -1;
1171 set_input(btv
,btv
->input
);
1174 static int get_control(struct bttv
*btv
, struct v4l2_control
*c
)
1176 struct video_audio va
;
1179 for (i
= 0; i
< BTTV_CTLS
; i
++)
1180 if (bttv_ctls
[i
].id
== c
->id
)
1184 if (btv
->audio_hook
&& i
>= 4 && i
<= 8) {
1185 memset(&va
,0,sizeof(va
));
1186 btv
->audio_hook(btv
,&va
,0);
1188 case V4L2_CID_AUDIO_MUTE
:
1189 c
->value
= (VIDEO_AUDIO_MUTE
& va
.flags
) ? 1 : 0;
1191 case V4L2_CID_AUDIO_VOLUME
:
1192 c
->value
= va
.volume
;
1194 case V4L2_CID_AUDIO_BALANCE
:
1195 c
->value
= va
.balance
;
1197 case V4L2_CID_AUDIO_BASS
:
1200 case V4L2_CID_AUDIO_TREBLE
:
1201 c
->value
= va
.treble
;
1207 case V4L2_CID_BRIGHTNESS
:
1208 c
->value
= btv
->bright
;
1211 c
->value
= btv
->hue
;
1213 case V4L2_CID_CONTRAST
:
1214 c
->value
= btv
->contrast
;
1216 case V4L2_CID_SATURATION
:
1217 c
->value
= btv
->saturation
;
1220 case V4L2_CID_AUDIO_MUTE
:
1221 case V4L2_CID_AUDIO_VOLUME
:
1222 case V4L2_CID_AUDIO_BALANCE
:
1223 case V4L2_CID_AUDIO_BASS
:
1224 case V4L2_CID_AUDIO_TREBLE
:
1225 bttv_call_i2c_clients(btv
,VIDIOC_G_CTRL
,c
);
1228 case V4L2_CID_PRIVATE_CHROMA_AGC
:
1229 c
->value
= btv
->opt_chroma_agc
;
1231 case V4L2_CID_PRIVATE_COMBFILTER
:
1232 c
->value
= btv
->opt_combfilter
;
1234 case V4L2_CID_PRIVATE_LUMAFILTER
:
1235 c
->value
= btv
->opt_lumafilter
;
1237 case V4L2_CID_PRIVATE_AUTOMUTE
:
1238 c
->value
= btv
->opt_automute
;
1240 case V4L2_CID_PRIVATE_AGC_CRUSH
:
1241 c
->value
= btv
->opt_adc_crush
;
1243 case V4L2_CID_PRIVATE_VCR_HACK
:
1244 c
->value
= btv
->opt_vcr_hack
;
1246 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER
:
1247 c
->value
= btv
->opt_whitecrush_upper
;
1249 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER
:
1250 c
->value
= btv
->opt_whitecrush_lower
;
1252 case V4L2_CID_PRIVATE_UV_RATIO
:
1253 c
->value
= btv
->opt_uv_ratio
;
1255 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE
:
1256 c
->value
= btv
->opt_full_luma_range
;
1258 case V4L2_CID_PRIVATE_CORING
:
1259 c
->value
= btv
->opt_coring
;
1267 static int set_control(struct bttv
*btv
, struct v4l2_control
*c
)
1269 struct video_audio va
;
1272 for (i
= 0; i
< BTTV_CTLS
; i
++)
1273 if (bttv_ctls
[i
].id
== c
->id
)
1277 if (btv
->audio_hook
&& i
>= 4 && i
<= 8) {
1278 memset(&va
,0,sizeof(va
));
1279 btv
->audio_hook(btv
,&va
,0);
1281 case V4L2_CID_AUDIO_MUTE
:
1283 va
.flags
|= VIDEO_AUDIO_MUTE
;
1286 va
.flags
&= ~VIDEO_AUDIO_MUTE
;
1291 case V4L2_CID_AUDIO_VOLUME
:
1292 va
.volume
= c
->value
;
1294 case V4L2_CID_AUDIO_BALANCE
:
1295 va
.balance
= c
->value
;
1297 case V4L2_CID_AUDIO_BASS
:
1300 case V4L2_CID_AUDIO_TREBLE
:
1301 va
.treble
= c
->value
;
1304 btv
->audio_hook(btv
,&va
,1);
1308 case V4L2_CID_BRIGHTNESS
:
1309 bt848_bright(btv
,c
->value
);
1312 bt848_hue(btv
,c
->value
);
1314 case V4L2_CID_CONTRAST
:
1315 bt848_contrast(btv
,c
->value
);
1317 case V4L2_CID_SATURATION
:
1318 bt848_sat(btv
,c
->value
);
1320 case V4L2_CID_AUDIO_MUTE
:
1321 audio_mute(btv
, c
->value
);
1323 case V4L2_CID_AUDIO_VOLUME
:
1324 case V4L2_CID_AUDIO_BALANCE
:
1325 case V4L2_CID_AUDIO_BASS
:
1326 case V4L2_CID_AUDIO_TREBLE
:
1327 bttv_call_i2c_clients(btv
,VIDIOC_S_CTRL
,c
);
1330 case V4L2_CID_PRIVATE_CHROMA_AGC
:
1331 btv
->opt_chroma_agc
= c
->value
;
1332 val
= btv
->opt_chroma_agc
? BT848_SCLOOP_CAGC
: 0;
1333 btwrite(val
, BT848_E_SCLOOP
);
1334 btwrite(val
, BT848_O_SCLOOP
);
1336 case V4L2_CID_PRIVATE_COMBFILTER
:
1337 btv
->opt_combfilter
= c
->value
;
1339 case V4L2_CID_PRIVATE_LUMAFILTER
:
1340 btv
->opt_lumafilter
= c
->value
;
1341 if (btv
->opt_lumafilter
) {
1342 btand(~BT848_CONTROL_LDEC
, BT848_E_CONTROL
);
1343 btand(~BT848_CONTROL_LDEC
, BT848_O_CONTROL
);
1345 btor(BT848_CONTROL_LDEC
, BT848_E_CONTROL
);
1346 btor(BT848_CONTROL_LDEC
, BT848_O_CONTROL
);
1349 case V4L2_CID_PRIVATE_AUTOMUTE
:
1350 btv
->opt_automute
= c
->value
;
1352 case V4L2_CID_PRIVATE_AGC_CRUSH
:
1353 btv
->opt_adc_crush
= c
->value
;
1354 btwrite(BT848_ADC_RESERVED
| (btv
->opt_adc_crush
? BT848_ADC_CRUSH
: 0),
1357 case V4L2_CID_PRIVATE_VCR_HACK
:
1358 btv
->opt_vcr_hack
= c
->value
;
1360 case V4L2_CID_PRIVATE_WHITECRUSH_UPPER
:
1361 btv
->opt_whitecrush_upper
= c
->value
;
1362 btwrite(c
->value
, BT848_WC_UP
);
1364 case V4L2_CID_PRIVATE_WHITECRUSH_LOWER
:
1365 btv
->opt_whitecrush_lower
= c
->value
;
1366 btwrite(c
->value
, BT848_WC_DOWN
);
1368 case V4L2_CID_PRIVATE_UV_RATIO
:
1369 btv
->opt_uv_ratio
= c
->value
;
1370 bt848_sat(btv
, btv
->saturation
);
1372 case V4L2_CID_PRIVATE_FULL_LUMA_RANGE
:
1373 btv
->opt_full_luma_range
= c
->value
;
1374 btaor((c
->value
<<7), ~BT848_OFORM_RANGE
, BT848_OFORM
);
1376 case V4L2_CID_PRIVATE_CORING
:
1377 btv
->opt_coring
= c
->value
;
1378 btaor((c
->value
<<5), ~BT848_OFORM_CORE32
, BT848_OFORM
);
1386 /* ----------------------------------------------------------------------- */
1388 void bttv_gpio_tracking(struct bttv
*btv
, char *comment
)
1390 unsigned int outbits
, data
;
1391 outbits
= btread(BT848_GPIO_OUT_EN
);
1392 data
= btread(BT848_GPIO_DATA
);
1393 printk(KERN_DEBUG
"bttv%d: gpio: en=%08x, out=%08x in=%08x [%s]\n",
1394 btv
->c
.nr
,outbits
,data
& outbits
, data
& ~outbits
, comment
);
1397 static void bttv_field_count(struct bttv
*btv
)
1405 /* start field counter */
1406 btor(BT848_INT_VSYNC
,BT848_INT_MASK
);
1408 /* stop field counter */
1409 btand(~BT848_INT_VSYNC
,BT848_INT_MASK
);
1410 btv
->field_count
= 0;
1414 static const struct bttv_format
*
1415 format_by_palette(int palette
)
1419 for (i
= 0; i
< BTTV_FORMATS
; i
++) {
1420 if (-1 == bttv_formats
[i
].palette
)
1422 if (bttv_formats
[i
].palette
== palette
)
1423 return bttv_formats
+i
;
1428 static const struct bttv_format
*
1429 format_by_fourcc(int fourcc
)
1433 for (i
= 0; i
< BTTV_FORMATS
; i
++) {
1434 if (-1 == bttv_formats
[i
].fourcc
)
1436 if (bttv_formats
[i
].fourcc
== fourcc
)
1437 return bttv_formats
+i
;
1442 /* ----------------------------------------------------------------------- */
1446 bttv_switch_overlay(struct bttv
*btv
, struct bttv_fh
*fh
,
1447 struct bttv_buffer
*new)
1449 struct bttv_buffer
*old
;
1450 unsigned long flags
;
1453 dprintk("switch_overlay: enter [new=%p]\n",new);
1455 new->vb
.state
= STATE_DONE
;
1456 spin_lock_irqsave(&btv
->s_lock
,flags
);
1460 bttv_set_dma(btv
, 0x03);
1461 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
1463 free_btres(btv
,fh
,RESOURCE_OVERLAY
);
1465 dprintk("switch_overlay: old=%p state is %d\n",old
,old
->vb
.state
);
1466 bttv_dma_free(&fh
->cap
,btv
, old
);
1469 dprintk("switch_overlay: done\n");
1473 /* ----------------------------------------------------------------------- */
1474 /* video4linux (1) interface */
1476 static int bttv_prepare_buffer(struct videobuf_queue
*q
,struct bttv
*btv
,
1477 struct bttv_buffer
*buf
,
1478 const struct bttv_format
*fmt
,
1479 unsigned int width
, unsigned int height
,
1480 enum v4l2_field field
)
1482 int redo_dma_risc
= 0;
1485 /* check settings */
1488 if (fmt
->btformat
== BT848_COLOR_FMT_RAW
) {
1490 height
= RAW_LINES
*2;
1491 if (width
*height
> buf
->vb
.bsize
)
1493 buf
->vb
.size
= buf
->vb
.bsize
;
1497 width
> bttv_tvnorms
[btv
->tvnorm
].swidth
||
1498 height
> bttv_tvnorms
[btv
->tvnorm
].sheight
)
1500 buf
->vb
.size
= (width
* height
* fmt
->depth
) >> 3;
1501 if (0 != buf
->vb
.baddr
&& buf
->vb
.bsize
< buf
->vb
.size
)
1505 /* alloc + fill struct bttv_buffer (if changed) */
1506 if (buf
->vb
.width
!= width
|| buf
->vb
.height
!= height
||
1507 buf
->vb
.field
!= field
||
1508 buf
->tvnorm
!= btv
->tvnorm
|| buf
->fmt
!= fmt
) {
1509 buf
->vb
.width
= width
;
1510 buf
->vb
.height
= height
;
1511 buf
->vb
.field
= field
;
1512 buf
->tvnorm
= btv
->tvnorm
;
1517 /* alloc risc memory */
1518 if (STATE_NEEDS_INIT
== buf
->vb
.state
) {
1520 if (0 != (rc
= videobuf_iolock(q
,&buf
->vb
,&btv
->fbuf
)))
1525 if (0 != (rc
= bttv_buffer_risc(btv
,buf
)))
1528 buf
->vb
.state
= STATE_PREPARED
;
1532 bttv_dma_free(q
,btv
,buf
);
1537 buffer_setup(struct videobuf_queue
*q
, unsigned int *count
, unsigned int *size
)
1539 struct bttv_fh
*fh
= q
->priv_data
;
1541 *size
= fh
->fmt
->depth
*fh
->width
*fh
->height
>> 3;
1544 while (*size
* *count
> gbuffers
* gbufsize
)
1550 buffer_prepare(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
,
1551 enum v4l2_field field
)
1553 struct bttv_buffer
*buf
= container_of(vb
,struct bttv_buffer
,vb
);
1554 struct bttv_fh
*fh
= q
->priv_data
;
1556 return bttv_prepare_buffer(q
,fh
->btv
, buf
, fh
->fmt
,
1557 fh
->width
, fh
->height
, field
);
1561 buffer_queue(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
)
1563 struct bttv_buffer
*buf
= container_of(vb
,struct bttv_buffer
,vb
);
1564 struct bttv_fh
*fh
= q
->priv_data
;
1565 struct bttv
*btv
= fh
->btv
;
1567 buf
->vb
.state
= STATE_QUEUED
;
1568 list_add_tail(&buf
->vb
.queue
,&btv
->capture
);
1569 if (!btv
->curr
.frame_irq
) {
1571 bttv_set_dma(btv
, 0x03);
1575 static void buffer_release(struct videobuf_queue
*q
, struct videobuf_buffer
*vb
)
1577 struct bttv_buffer
*buf
= container_of(vb
,struct bttv_buffer
,vb
);
1578 struct bttv_fh
*fh
= q
->priv_data
;
1580 bttv_dma_free(&fh
->cap
,fh
->btv
,buf
);
1583 static struct videobuf_queue_ops bttv_video_qops
= {
1584 .buf_setup
= buffer_setup
,
1585 .buf_prepare
= buffer_prepare
,
1586 .buf_queue
= buffer_queue
,
1587 .buf_release
= buffer_release
,
1590 static int bttv_common_ioctls(struct bttv
*btv
, unsigned int cmd
, void *arg
)
1594 return BTTV_VERSION_CODE
;
1596 /* *** v4l1 *** ************************************************ */
1599 unsigned long *freq
= arg
;
1605 struct v4l2_frequency freq
;
1607 memset(&freq
, 0, sizeof(freq
));
1608 freq
.frequency
= *(unsigned long *)arg
;
1609 mutex_lock(&btv
->lock
);
1610 freq
.type
= btv
->radio_user
? V4L2_TUNER_RADIO
: V4L2_TUNER_ANALOG_TV
;
1611 btv
->freq
= *(unsigned long *)arg
;
1612 bttv_call_i2c_clients(btv
,VIDIOC_S_FREQUENCY
,&freq
);
1613 if (btv
->has_matchbox
&& btv
->radio_user
)
1614 tea5757_set_freq(btv
,*(unsigned long *)arg
);
1615 mutex_unlock(&btv
->lock
);
1621 struct video_tuner
*v
= arg
;
1623 if (UNSET
== bttv_tvcards
[btv
->c
.type
].tuner
)
1625 if (v
->tuner
) /* Only tuner 0 */
1627 strcpy(v
->name
, "Television");
1629 v
->rangehigh
= 0x7FFFFFFF;
1630 v
->flags
= VIDEO_TUNER_PAL
|VIDEO_TUNER_NTSC
|VIDEO_TUNER_SECAM
;
1631 v
->mode
= btv
->tvnorm
;
1632 v
->signal
= (btread(BT848_DSTATUS
)&BT848_DSTATUS_HLOC
) ? 0xFFFF : 0;
1633 bttv_call_i2c_clients(btv
,cmd
,v
);
1638 struct video_tuner
*v
= arg
;
1640 if (v
->tuner
) /* Only tuner 0 */
1642 if (v
->mode
>= BTTV_TVNORMS
)
1645 mutex_lock(&btv
->lock
);
1646 set_tvnorm(btv
,v
->mode
);
1647 bttv_call_i2c_clients(btv
,cmd
,v
);
1648 mutex_unlock(&btv
->lock
);
1654 struct video_channel
*v
= arg
;
1655 unsigned int channel
= v
->channel
;
1657 if (channel
>= bttv_tvcards
[btv
->c
.type
].video_inputs
)
1660 v
->flags
= VIDEO_VC_AUDIO
;
1661 v
->type
= VIDEO_TYPE_CAMERA
;
1662 v
->norm
= btv
->tvnorm
;
1663 if (channel
== bttv_tvcards
[btv
->c
.type
].tuner
) {
1664 strcpy(v
->name
,"Television");
1665 v
->flags
|=VIDEO_VC_TUNER
;
1666 v
->type
=VIDEO_TYPE_TV
;
1668 } else if (channel
== btv
->svhs
) {
1669 strcpy(v
->name
,"S-Video");
1671 sprintf(v
->name
,"Composite%d",channel
);
1677 struct video_channel
*v
= arg
;
1678 unsigned int channel
= v
->channel
;
1680 if (channel
>= bttv_tvcards
[btv
->c
.type
].video_inputs
)
1682 if (v
->norm
>= BTTV_TVNORMS
)
1685 mutex_lock(&btv
->lock
);
1686 if (channel
== btv
->input
&&
1687 v
->norm
== btv
->tvnorm
) {
1689 mutex_unlock(&btv
->lock
);
1693 btv
->tvnorm
= v
->norm
;
1694 set_input(btv
,v
->channel
);
1695 mutex_unlock(&btv
->lock
);
1701 struct video_audio
*v
= arg
;
1703 memset(v
,0,sizeof(*v
));
1704 strcpy(v
->name
,"Television");
1705 v
->flags
|= VIDEO_AUDIO_MUTABLE
;
1706 v
->mode
= VIDEO_SOUND_MONO
;
1708 mutex_lock(&btv
->lock
);
1709 bttv_call_i2c_clients(btv
,cmd
,v
);
1711 /* card specific hooks */
1712 if (btv
->audio_hook
)
1713 btv
->audio_hook(btv
,v
,0);
1715 mutex_unlock(&btv
->lock
);
1720 struct video_audio
*v
= arg
;
1721 unsigned int audio
= v
->audio
;
1723 if (audio
>= bttv_tvcards
[btv
->c
.type
].audio_inputs
)
1726 mutex_lock(&btv
->lock
);
1727 audio_mute(btv
, (v
->flags
&VIDEO_AUDIO_MUTE
) ? 1 : 0);
1728 bttv_call_i2c_clients(btv
,cmd
,v
);
1730 /* card specific hooks */
1731 if (btv
->audio_hook
)
1732 btv
->audio_hook(btv
,v
,1);
1734 mutex_unlock(&btv
->lock
);
1738 /* *** v4l2 *** ************************************************ */
1739 case VIDIOC_ENUMSTD
:
1741 struct v4l2_standard
*e
= arg
;
1742 unsigned int index
= e
->index
;
1744 if (index
>= BTTV_TVNORMS
)
1746 v4l2_video_std_construct(e
, bttv_tvnorms
[e
->index
].v4l2_id
,
1747 bttv_tvnorms
[e
->index
].name
);
1753 v4l2_std_id
*id
= arg
;
1754 *id
= bttv_tvnorms
[btv
->tvnorm
].v4l2_id
;
1759 v4l2_std_id
*id
= arg
;
1762 for (i
= 0; i
< BTTV_TVNORMS
; i
++)
1763 if (*id
& bttv_tvnorms
[i
].v4l2_id
)
1765 if (i
== BTTV_TVNORMS
)
1768 mutex_lock(&btv
->lock
);
1770 i2c_vidiocschan(btv
);
1771 mutex_unlock(&btv
->lock
);
1774 case VIDIOC_QUERYSTD
:
1776 v4l2_std_id
*id
= arg
;
1778 if (btread(BT848_DSTATUS
) & BT848_DSTATUS_NUML
)
1779 *id
= V4L2_STD_625_50
;
1781 *id
= V4L2_STD_525_60
;
1785 case VIDIOC_ENUMINPUT
:
1787 struct v4l2_input
*i
= arg
;
1791 if (n
>= bttv_tvcards
[btv
->c
.type
].video_inputs
)
1793 memset(i
,0,sizeof(*i
));
1795 i
->type
= V4L2_INPUT_TYPE_CAMERA
;
1797 if (i
->index
== bttv_tvcards
[btv
->c
.type
].tuner
) {
1798 sprintf(i
->name
, "Television");
1799 i
->type
= V4L2_INPUT_TYPE_TUNER
;
1801 } else if (i
->index
== btv
->svhs
) {
1802 sprintf(i
->name
, "S-Video");
1804 sprintf(i
->name
,"Composite%d",i
->index
);
1806 if (i
->index
== btv
->input
) {
1807 __u32 dstatus
= btread(BT848_DSTATUS
);
1808 if (0 == (dstatus
& BT848_DSTATUS_PRES
))
1809 i
->status
|= V4L2_IN_ST_NO_SIGNAL
;
1810 if (0 == (dstatus
& BT848_DSTATUS_HLOC
))
1811 i
->status
|= V4L2_IN_ST_NO_H_LOCK
;
1813 for (n
= 0; n
< BTTV_TVNORMS
; n
++)
1814 i
->std
|= bttv_tvnorms
[n
].v4l2_id
;
1817 case VIDIOC_G_INPUT
:
1823 case VIDIOC_S_INPUT
:
1825 unsigned int *i
= arg
;
1827 if (*i
> bttv_tvcards
[btv
->c
.type
].video_inputs
)
1829 mutex_lock(&btv
->lock
);
1831 mutex_unlock(&btv
->lock
);
1835 case VIDIOC_G_TUNER
:
1837 struct v4l2_tuner
*t
= arg
;
1839 if (UNSET
== bttv_tvcards
[btv
->c
.type
].tuner
)
1843 mutex_lock(&btv
->lock
);
1844 memset(t
,0,sizeof(*t
));
1845 t
->rxsubchans
= V4L2_TUNER_SUB_MONO
;
1846 bttv_call_i2c_clients(btv
, VIDIOC_G_TUNER
, t
);
1847 strcpy(t
->name
, "Television");
1848 t
->capability
= V4L2_TUNER_CAP_NORM
;
1849 t
->type
= V4L2_TUNER_ANALOG_TV
;
1850 if (btread(BT848_DSTATUS
)&BT848_DSTATUS_HLOC
)
1853 if (btv
->audio_hook
) {
1855 struct video_audio va
;
1856 memset(&va
, 0, sizeof(struct video_audio
));
1857 btv
->audio_hook(btv
,&va
,0);
1858 t
->audmode
= V4L2_TUNER_MODE_MONO
;
1859 t
->rxsubchans
= V4L2_TUNER_SUB_MONO
;
1860 if(va
.mode
& VIDEO_SOUND_STEREO
) {
1861 t
->audmode
= V4L2_TUNER_MODE_STEREO
;
1862 t
->rxsubchans
= V4L2_TUNER_SUB_STEREO
;
1864 if(va
.mode
& VIDEO_SOUND_LANG2
) {
1865 t
->audmode
= V4L2_TUNER_MODE_LANG1
;
1866 t
->rxsubchans
= V4L2_TUNER_SUB_LANG1
1867 | V4L2_TUNER_SUB_LANG2
;
1870 /* FIXME: fill capability+audmode */
1871 mutex_unlock(&btv
->lock
);
1874 case VIDIOC_S_TUNER
:
1876 struct v4l2_tuner
*t
= arg
;
1878 if (UNSET
== bttv_tvcards
[btv
->c
.type
].tuner
)
1882 mutex_lock(&btv
->lock
);
1883 bttv_call_i2c_clients(btv
, VIDIOC_S_TUNER
, t
);
1884 if (btv
->audio_hook
) {
1885 struct video_audio va
;
1886 memset(&va
, 0, sizeof(struct video_audio
));
1887 if (t
->audmode
== V4L2_TUNER_MODE_MONO
)
1888 va
.mode
= VIDEO_SOUND_MONO
;
1889 else if (t
->audmode
== V4L2_TUNER_MODE_STEREO
||
1890 t
->audmode
== V4L2_TUNER_MODE_LANG1_LANG2
)
1891 va
.mode
= VIDEO_SOUND_STEREO
;
1892 else if (t
->audmode
== V4L2_TUNER_MODE_LANG1
)
1893 va
.mode
= VIDEO_SOUND_LANG1
;
1894 else if (t
->audmode
== V4L2_TUNER_MODE_LANG2
)
1895 va
.mode
= VIDEO_SOUND_LANG2
;
1896 btv
->audio_hook(btv
,&va
,1);
1898 mutex_unlock(&btv
->lock
);
1902 case VIDIOC_G_FREQUENCY
:
1904 struct v4l2_frequency
*f
= arg
;
1906 memset(f
,0,sizeof(*f
));
1907 f
->type
= V4L2_TUNER_ANALOG_TV
;
1908 f
->frequency
= btv
->freq
;
1911 case VIDIOC_S_FREQUENCY
:
1913 struct v4l2_frequency
*f
= arg
;
1915 if (unlikely(f
->tuner
!= 0))
1917 if (unlikely (f
->type
!= V4L2_TUNER_ANALOG_TV
))
1919 mutex_lock(&btv
->lock
);
1920 btv
->freq
= f
->frequency
;
1921 bttv_call_i2c_clients(btv
,VIDIOC_S_FREQUENCY
,f
);
1922 if (btv
->has_matchbox
&& btv
->radio_user
)
1923 tea5757_set_freq(btv
,btv
->freq
);
1924 mutex_unlock(&btv
->lock
);
1927 case VIDIOC_LOG_STATUS
:
1929 printk(KERN_INFO
"bttv%d: ================= START STATUS CARD #%d =================\n", btv
->c
.nr
, btv
->c
.nr
);
1930 bttv_call_i2c_clients(btv
, VIDIOC_LOG_STATUS
, NULL
);
1931 printk(KERN_INFO
"bttv%d: ================== END STATUS CARD #%d ==================\n", btv
->c
.nr
, btv
->c
.nr
);
1936 return -ENOIOCTLCMD
;
1942 static int verify_window(const struct bttv_tvnorm
*tvn
,
1943 struct v4l2_window
*win
, int fixup
)
1945 enum v4l2_field field
;
1948 if (win
->w
.width
< 48 || win
->w
.height
< 32)
1950 if (win
->clipcount
> 2048)
1955 maxh
= tvn
->sheight
;
1957 if (V4L2_FIELD_ANY
== field
) {
1958 field
= (win
->w
.height
> maxh
/2)
1959 ? V4L2_FIELD_INTERLACED
1963 case V4L2_FIELD_TOP
:
1964 case V4L2_FIELD_BOTTOM
:
1967 case V4L2_FIELD_INTERLACED
:
1973 if (!fixup
&& (win
->w
.width
> maxw
|| win
->w
.height
> maxh
))
1976 if (win
->w
.width
> maxw
)
1977 win
->w
.width
= maxw
;
1978 if (win
->w
.height
> maxh
)
1979 win
->w
.height
= maxh
;
1984 static int setup_window(struct bttv_fh
*fh
, struct bttv
*btv
,
1985 struct v4l2_window
*win
, int fixup
)
1987 struct v4l2_clip
*clips
= NULL
;
1988 int n
,size
,retval
= 0;
1990 if (NULL
== fh
->ovfmt
)
1992 if (!(fh
->ovfmt
->flags
& FORMAT_FLAGS_PACKED
))
1994 retval
= verify_window(&bttv_tvnorms
[btv
->tvnorm
],win
,fixup
);
1998 /* copy clips -- luckily v4l1 + v4l2 are binary
1999 compatible here ...*/
2001 size
= sizeof(*clips
)*(n
+4);
2002 clips
= kmalloc(size
,GFP_KERNEL
);
2006 if (copy_from_user(clips
,win
->clips
,sizeof(struct v4l2_clip
)*n
)) {
2011 /* clip against screen */
2012 if (NULL
!= btv
->fbuf
.base
)
2013 n
= btcx_screen_clips(btv
->fbuf
.fmt
.width
, btv
->fbuf
.fmt
.height
,
2015 btcx_sort_clips(clips
,n
);
2017 /* 4-byte alignments */
2018 switch (fh
->ovfmt
->depth
) {
2021 btcx_align(&win
->w
, clips
, n
, 3);
2024 btcx_align(&win
->w
, clips
, n
, 1);
2027 /* no alignment fixups needed */
2033 mutex_lock(&fh
->cap
.lock
);
2034 kfree(fh
->ov
.clips
);
2035 fh
->ov
.clips
= clips
;
2039 fh
->ov
.field
= win
->field
;
2040 fh
->ov
.setup_ok
= 1;
2041 btv
->init
.ov
.w
.width
= win
->w
.width
;
2042 btv
->init
.ov
.w
.height
= win
->w
.height
;
2043 btv
->init
.ov
.field
= win
->field
;
2045 /* update overlay if needed */
2047 if (check_btres(fh
, RESOURCE_OVERLAY
)) {
2048 struct bttv_buffer
*new;
2050 new = videobuf_alloc(sizeof(*new));
2051 bttv_overlay_risc(btv
, &fh
->ov
, fh
->ovfmt
, new);
2052 retval
= bttv_switch_overlay(btv
,fh
,new);
2054 mutex_unlock(&fh
->cap
.lock
);
2058 /* ----------------------------------------------------------------------- */
2060 static struct videobuf_queue
* bttv_queue(struct bttv_fh
*fh
)
2062 struct videobuf_queue
* q
= NULL
;
2065 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2068 case V4L2_BUF_TYPE_VBI_CAPTURE
:
2077 static int bttv_resource(struct bttv_fh
*fh
)
2082 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2083 res
= RESOURCE_VIDEO
;
2085 case V4L2_BUF_TYPE_VBI_CAPTURE
:
2094 static int bttv_switch_type(struct bttv_fh
*fh
, enum v4l2_buf_type type
)
2096 struct videobuf_queue
*q
= bttv_queue(fh
);
2097 int res
= bttv_resource(fh
);
2099 if (check_btres(fh
,res
))
2101 if (videobuf_queue_is_busy(q
))
2108 pix_format_set_size (struct v4l2_pix_format
* f
,
2109 const struct bttv_format
* fmt
,
2111 unsigned int height
)
2116 if (fmt
->flags
& FORMAT_FLAGS_PLANAR
) {
2117 f
->bytesperline
= width
; /* Y plane */
2118 f
->sizeimage
= (width
* height
* fmt
->depth
) >> 3;
2120 f
->bytesperline
= (width
* fmt
->depth
) >> 3;
2121 f
->sizeimage
= height
* f
->bytesperline
;
2125 static int bttv_g_fmt(struct bttv_fh
*fh
, struct v4l2_format
*f
)
2128 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2129 memset(&f
->fmt
.pix
,0,sizeof(struct v4l2_pix_format
));
2130 pix_format_set_size (&f
->fmt
.pix
, fh
->fmt
,
2131 fh
->width
, fh
->height
);
2132 f
->fmt
.pix
.field
= fh
->cap
.field
;
2133 f
->fmt
.pix
.pixelformat
= fh
->fmt
->fourcc
;
2135 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
2136 memset(&f
->fmt
.win
,0,sizeof(struct v4l2_window
));
2137 f
->fmt
.win
.w
= fh
->ov
.w
;
2138 f
->fmt
.win
.field
= fh
->ov
.field
;
2140 case V4L2_BUF_TYPE_VBI_CAPTURE
:
2141 bttv_vbi_get_fmt(fh
,f
);
2148 static int bttv_try_fmt(struct bttv_fh
*fh
, struct bttv
*btv
,
2149 struct v4l2_format
*f
)
2152 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2154 const struct bttv_format
*fmt
;
2155 enum v4l2_field field
;
2156 unsigned int maxw
,maxh
;
2158 fmt
= format_by_fourcc(f
->fmt
.pix
.pixelformat
);
2163 maxw
= bttv_tvnorms
[btv
->tvnorm
].swidth
;
2164 maxh
= bttv_tvnorms
[btv
->tvnorm
].sheight
;
2165 field
= f
->fmt
.pix
.field
;
2166 if (V4L2_FIELD_ANY
== field
)
2167 field
= (f
->fmt
.pix
.height
> maxh
/2)
2168 ? V4L2_FIELD_INTERLACED
2169 : V4L2_FIELD_BOTTOM
;
2170 if (V4L2_FIELD_SEQ_BT
== field
)
2171 field
= V4L2_FIELD_SEQ_TB
;
2173 case V4L2_FIELD_TOP
:
2174 case V4L2_FIELD_BOTTOM
:
2175 case V4L2_FIELD_ALTERNATE
:
2178 case V4L2_FIELD_INTERLACED
:
2180 case V4L2_FIELD_SEQ_TB
:
2181 if (fmt
->flags
& FORMAT_FLAGS_PLANAR
)
2188 /* update data for the application */
2189 f
->fmt
.pix
.field
= field
;
2190 if (f
->fmt
.pix
.width
< 48)
2191 f
->fmt
.pix
.width
= 48;
2192 if (f
->fmt
.pix
.height
< 32)
2193 f
->fmt
.pix
.height
= 32;
2194 if (f
->fmt
.pix
.width
> maxw
)
2195 f
->fmt
.pix
.width
= maxw
;
2196 if (f
->fmt
.pix
.height
> maxh
)
2197 f
->fmt
.pix
.height
= maxh
;
2198 pix_format_set_size (&f
->fmt
.pix
, fmt
,
2199 f
->fmt
.pix
.width
& ~3,
2204 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
2205 return verify_window(&bttv_tvnorms
[btv
->tvnorm
],
2207 case V4L2_BUF_TYPE_VBI_CAPTURE
:
2208 bttv_vbi_try_fmt(fh
,f
);
2215 static int bttv_s_fmt(struct bttv_fh
*fh
, struct bttv
*btv
,
2216 struct v4l2_format
*f
)
2221 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2223 const struct bttv_format
*fmt
;
2225 retval
= bttv_switch_type(fh
,f
->type
);
2228 retval
= bttv_try_fmt(fh
,btv
,f
);
2231 fmt
= format_by_fourcc(f
->fmt
.pix
.pixelformat
);
2233 /* update our state informations */
2234 mutex_lock(&fh
->cap
.lock
);
2236 fh
->cap
.field
= f
->fmt
.pix
.field
;
2237 fh
->cap
.last
= V4L2_FIELD_NONE
;
2238 fh
->width
= f
->fmt
.pix
.width
;
2239 fh
->height
= f
->fmt
.pix
.height
;
2240 btv
->init
.fmt
= fmt
;
2241 btv
->init
.width
= f
->fmt
.pix
.width
;
2242 btv
->init
.height
= f
->fmt
.pix
.height
;
2243 mutex_unlock(&fh
->cap
.lock
);
2247 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
2248 if (no_overlay
> 0) {
2249 printk ("V4L2_BUF_TYPE_VIDEO_OVERLAY: no_overlay\n");
2252 return setup_window(fh
, btv
, &f
->fmt
.win
, 1);
2253 case V4L2_BUF_TYPE_VBI_CAPTURE
:
2254 retval
= bttv_switch_type(fh
,f
->type
);
2257 if (locked_btres(fh
->btv
, RESOURCE_VBI
))
2259 bttv_vbi_try_fmt(fh
,f
);
2260 bttv_vbi_setlines(fh
,btv
,f
->fmt
.vbi
.count
[0]);
2261 bttv_vbi_get_fmt(fh
,f
);
2268 static int bttv_do_ioctl(struct inode
*inode
, struct file
*file
,
2269 unsigned int cmd
, void *arg
)
2271 struct bttv_fh
*fh
= file
->private_data
;
2272 struct bttv
*btv
= fh
->btv
;
2273 unsigned long flags
;
2277 v4l_print_ioctl(btv
->c
.name
, cmd
);
2280 bttv_reinit_bt848(btv
);
2288 case VIDIOC_S_INPUT
:
2289 case VIDIOC_S_TUNER
:
2290 case VIDIOC_S_FREQUENCY
:
2291 retval
= v4l2_prio_check(&btv
->prio
,&fh
->prio
);
2298 /* *** v4l1 *** ************************************************ */
2301 struct video_capability
*cap
= arg
;
2303 memset(cap
,0,sizeof(*cap
));
2304 strcpy(cap
->name
,btv
->video_dev
->name
);
2305 if (V4L2_BUF_TYPE_VBI_CAPTURE
== fh
->type
) {
2307 cap
->type
= VID_TYPE_TUNER
|VID_TYPE_TELETEXT
;
2310 cap
->type
= VID_TYPE_CAPTURE
|
2314 if (no_overlay
<= 0)
2315 cap
->type
|= VID_TYPE_OVERLAY
;
2317 cap
->maxwidth
= bttv_tvnorms
[btv
->tvnorm
].swidth
;
2318 cap
->maxheight
= bttv_tvnorms
[btv
->tvnorm
].sheight
;
2320 cap
->minheight
= 32;
2322 cap
->channels
= bttv_tvcards
[btv
->c
.type
].video_inputs
;
2323 cap
->audios
= bttv_tvcards
[btv
->c
.type
].audio_inputs
;
2329 struct video_picture
*pic
= arg
;
2331 memset(pic
,0,sizeof(*pic
));
2332 pic
->brightness
= btv
->bright
;
2333 pic
->contrast
= btv
->contrast
;
2334 pic
->hue
= btv
->hue
;
2335 pic
->colour
= btv
->saturation
;
2337 pic
->depth
= fh
->fmt
->depth
;
2338 pic
->palette
= fh
->fmt
->palette
;
2344 struct video_picture
*pic
= arg
;
2345 const struct bttv_format
*fmt
;
2347 fmt
= format_by_palette(pic
->palette
);
2350 mutex_lock(&fh
->cap
.lock
);
2351 if (fmt
->depth
!= pic
->depth
) {
2353 goto fh_unlock_and_return
;
2355 if (fmt
->flags
& FORMAT_FLAGS_RAW
) {
2356 /* VIDIOCMCAPTURE uses gbufsize, not RAW_BPL *
2357 RAW_LINES * 2. F1 is stored at offset 0, F2
2358 at buffer size / 2. */
2359 fh
->width
= RAW_BPL
;
2360 fh
->height
= gbufsize
/ RAW_BPL
;
2361 btv
->init
.width
= RAW_BPL
;
2362 btv
->init
.height
= gbufsize
/ RAW_BPL
;
2366 btv
->init
.ovfmt
= fmt
;
2367 btv
->init
.fmt
= fmt
;
2369 /* dirty hack time: swap bytes for overlay if the
2370 display adaptor is big endian (insmod option) */
2371 if (fmt
->palette
== VIDEO_PALETTE_RGB555
||
2372 fmt
->palette
== VIDEO_PALETTE_RGB565
||
2373 fmt
->palette
== VIDEO_PALETTE_RGB32
) {
2377 bt848_bright(btv
,pic
->brightness
);
2378 bt848_contrast(btv
,pic
->contrast
);
2379 bt848_hue(btv
,pic
->hue
);
2380 bt848_sat(btv
,pic
->colour
);
2381 mutex_unlock(&fh
->cap
.lock
);
2387 struct video_window
*win
= arg
;
2389 memset(win
,0,sizeof(*win
));
2390 win
->x
= fh
->ov
.w
.left
;
2391 win
->y
= fh
->ov
.w
.top
;
2392 win
->width
= fh
->ov
.w
.width
;
2393 win
->height
= fh
->ov
.w
.height
;
2398 struct video_window
*win
= arg
;
2399 struct v4l2_window w2
;
2401 if (no_overlay
> 0) {
2402 printk ("VIDIOCSWIN: no_overlay\n");
2406 w2
.field
= V4L2_FIELD_ANY
;
2409 w2
.w
.width
= win
->width
;
2410 w2
.w
.height
= win
->height
;
2411 w2
.clipcount
= win
->clipcount
;
2412 w2
.clips
= (struct v4l2_clip __user
*)win
->clips
;
2413 retval
= setup_window(fh
, btv
, &w2
, 0);
2415 /* on v4l1 this ioctl affects the read() size too */
2416 fh
->width
= fh
->ov
.w
.width
;
2417 fh
->height
= fh
->ov
.w
.height
;
2418 btv
->init
.width
= fh
->ov
.w
.width
;
2419 btv
->init
.height
= fh
->ov
.w
.height
;
2426 struct video_buffer
*fbuf
= arg
;
2428 fbuf
->base
= btv
->fbuf
.base
;
2429 fbuf
->width
= btv
->fbuf
.fmt
.width
;
2430 fbuf
->height
= btv
->fbuf
.fmt
.height
;
2431 fbuf
->bytesperline
= btv
->fbuf
.fmt
.bytesperline
;
2433 fbuf
->depth
= fh
->ovfmt
->depth
;
2436 fbuf
->depth
= ((fbuf
->bytesperline
<<3)
2446 struct video_buffer
*fbuf
= arg
;
2447 const struct bttv_format
*fmt
;
2450 if(!capable(CAP_SYS_ADMIN
) &&
2451 !capable(CAP_SYS_RAWIO
))
2453 end
= (unsigned long)fbuf
->base
+
2454 fbuf
->height
* fbuf
->bytesperline
;
2455 mutex_lock(&fh
->cap
.lock
);
2458 switch (fbuf
->depth
) {
2460 fmt
= format_by_palette(VIDEO_PALETTE_HI240
);
2463 fmt
= format_by_palette(VIDEO_PALETTE_RGB565
);
2466 fmt
= format_by_palette(VIDEO_PALETTE_RGB24
);
2469 fmt
= format_by_palette(VIDEO_PALETTE_RGB32
);
2473 fmt
= format_by_palette(VIDEO_PALETTE_RGB555
);
2480 goto fh_unlock_and_return
;
2484 btv
->init
.ovfmt
= fmt
;
2485 btv
->init
.fmt
= fmt
;
2486 btv
->fbuf
.base
= fbuf
->base
;
2487 btv
->fbuf
.fmt
.width
= fbuf
->width
;
2488 btv
->fbuf
.fmt
.height
= fbuf
->height
;
2489 if (fbuf
->bytesperline
)
2490 btv
->fbuf
.fmt
.bytesperline
= fbuf
->bytesperline
;
2492 btv
->fbuf
.fmt
.bytesperline
= btv
->fbuf
.fmt
.width
*fbuf
->depth
/8;
2493 mutex_unlock(&fh
->cap
.lock
);
2498 case VIDIOC_OVERLAY
:
2500 struct bttv_buffer
*new;
2505 if (NULL
== btv
->fbuf
.base
)
2507 if (!fh
->ov
.setup_ok
) {
2508 dprintk("bttv%d: overlay: !setup_ok\n",btv
->c
.nr
);
2513 if (!check_alloc_btres(btv
,fh
,RESOURCE_OVERLAY
))
2516 mutex_lock(&fh
->cap
.lock
);
2518 fh
->ov
.tvnorm
= btv
->tvnorm
;
2519 new = videobuf_alloc(sizeof(*new));
2520 bttv_overlay_risc(btv
, &fh
->ov
, fh
->ovfmt
, new);
2526 retval
= bttv_switch_overlay(btv
,fh
,new);
2527 mutex_unlock(&fh
->cap
.lock
);
2533 struct video_mbuf
*mbuf
= arg
;
2536 mutex_lock(&fh
->cap
.lock
);
2537 retval
= videobuf_mmap_setup(&fh
->cap
,gbuffers
,gbufsize
,
2540 goto fh_unlock_and_return
;
2541 memset(mbuf
,0,sizeof(*mbuf
));
2542 mbuf
->frames
= gbuffers
;
2543 mbuf
->size
= gbuffers
* gbufsize
;
2544 for (i
= 0; i
< gbuffers
; i
++)
2545 mbuf
->offsets
[i
] = i
* gbufsize
;
2546 mutex_unlock(&fh
->cap
.lock
);
2549 case VIDIOCMCAPTURE
:
2551 struct video_mmap
*vm
= arg
;
2552 struct bttv_buffer
*buf
;
2553 enum v4l2_field field
;
2555 if (vm
->frame
>= VIDEO_MAX_FRAME
)
2558 mutex_lock(&fh
->cap
.lock
);
2560 buf
= (struct bttv_buffer
*)fh
->cap
.bufs
[vm
->frame
];
2562 goto fh_unlock_and_return
;
2563 if (0 == buf
->vb
.baddr
)
2564 goto fh_unlock_and_return
;
2565 if (buf
->vb
.state
== STATE_QUEUED
||
2566 buf
->vb
.state
== STATE_ACTIVE
)
2567 goto fh_unlock_and_return
;
2569 field
= (vm
->height
> bttv_tvnorms
[btv
->tvnorm
].sheight
/2)
2570 ? V4L2_FIELD_INTERLACED
2571 : V4L2_FIELD_BOTTOM
;
2572 retval
= bttv_prepare_buffer(&fh
->cap
,btv
,buf
,
2573 format_by_palette(vm
->format
),
2574 vm
->width
,vm
->height
,field
);
2576 goto fh_unlock_and_return
;
2577 spin_lock_irqsave(&btv
->s_lock
,flags
);
2578 buffer_queue(&fh
->cap
,&buf
->vb
);
2579 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
2580 mutex_unlock(&fh
->cap
.lock
);
2586 struct bttv_buffer
*buf
;
2588 if (*frame
>= VIDEO_MAX_FRAME
)
2591 mutex_lock(&fh
->cap
.lock
);
2593 buf
= (struct bttv_buffer
*)fh
->cap
.bufs
[*frame
];
2595 goto fh_unlock_and_return
;
2596 retval
= videobuf_waiton(&buf
->vb
,0,1);
2598 goto fh_unlock_and_return
;
2599 switch (buf
->vb
.state
) {
2604 videobuf_dma_sync(&fh
->cap
,&buf
->vb
.dma
);
2605 bttv_dma_free(&fh
->cap
,btv
,buf
);
2611 mutex_unlock(&fh
->cap
.lock
);
2617 struct vbi_format
*fmt
= (void *) arg
;
2618 struct v4l2_format fmt2
;
2620 if (fh
->type
!= V4L2_BUF_TYPE_VBI_CAPTURE
) {
2621 retval
= bttv_switch_type(fh
,V4L2_BUF_TYPE_VBI_CAPTURE
);
2625 bttv_vbi_get_fmt(fh
, &fmt2
);
2627 memset(fmt
,0,sizeof(*fmt
));
2628 fmt
->sampling_rate
= fmt2
.fmt
.vbi
.sampling_rate
;
2629 fmt
->samples_per_line
= fmt2
.fmt
.vbi
.samples_per_line
;
2630 fmt
->sample_format
= VIDEO_PALETTE_RAW
;
2631 fmt
->start
[0] = fmt2
.fmt
.vbi
.start
[0];
2632 fmt
->count
[0] = fmt2
.fmt
.vbi
.count
[0];
2633 fmt
->start
[1] = fmt2
.fmt
.vbi
.start
[1];
2634 fmt
->count
[1] = fmt2
.fmt
.vbi
.count
[1];
2635 if (fmt2
.fmt
.vbi
.flags
& V4L2_VBI_UNSYNC
)
2636 fmt
->flags
|= VBI_UNSYNC
;
2637 if (fmt2
.fmt
.vbi
.flags
& V4L2_VBI_INTERLACED
)
2638 fmt
->flags
|= VBI_INTERLACED
;
2643 struct vbi_format
*fmt
= (void *) arg
;
2644 struct v4l2_format fmt2
;
2646 retval
= bttv_switch_type(fh
,V4L2_BUF_TYPE_VBI_CAPTURE
);
2649 bttv_vbi_get_fmt(fh
, &fmt2
);
2651 if (fmt
->sampling_rate
!= fmt2
.fmt
.vbi
.sampling_rate
||
2652 fmt
->samples_per_line
!= fmt2
.fmt
.vbi
.samples_per_line
||
2653 fmt
->sample_format
!= VIDEO_PALETTE_RAW
||
2654 fmt
->start
[0] != fmt2
.fmt
.vbi
.start
[0] ||
2655 fmt
->start
[1] != fmt2
.fmt
.vbi
.start
[1] ||
2656 fmt
->count
[0] != fmt
->count
[1] ||
2657 fmt
->count
[0] < 1 ||
2658 fmt
->count
[0] > 32 /* VBI_MAXLINES */)
2661 bttv_vbi_setlines(fh
,btv
,fmt
->count
[0]);
2674 return bttv_common_ioctls(btv
,cmd
,arg
);
2676 /* *** v4l2 *** ************************************************ */
2677 case VIDIOC_QUERYCAP
:
2679 struct v4l2_capability
*cap
= arg
;
2683 memset(cap
, 0, sizeof (*cap
));
2684 strlcpy(cap
->driver
, "bttv", sizeof (cap
->driver
));
2685 strlcpy(cap
->card
, btv
->video_dev
->name
, sizeof (cap
->card
));
2686 snprintf(cap
->bus_info
, sizeof (cap
->bus_info
),
2687 "PCI:%s", pci_name(btv
->c
.pci
));
2688 cap
->version
= BTTV_VERSION_CODE
;
2690 V4L2_CAP_VIDEO_CAPTURE
|
2691 V4L2_CAP_VBI_CAPTURE
|
2692 V4L2_CAP_READWRITE
|
2694 if (no_overlay
<= 0)
2695 cap
->capabilities
|= V4L2_CAP_VIDEO_OVERLAY
;
2697 if (bttv_tvcards
[btv
->c
.type
].tuner
!= UNSET
&&
2698 bttv_tvcards
[btv
->c
.type
].tuner
!= TUNER_ABSENT
)
2699 cap
->capabilities
|= V4L2_CAP_TUNER
;
2703 case VIDIOC_ENUM_FMT
:
2705 struct v4l2_fmtdesc
*f
= arg
;
2706 enum v4l2_buf_type type
;
2711 if (V4L2_BUF_TYPE_VBI_CAPTURE
== type
) {
2716 memset(f
,0,sizeof(*f
));
2719 f
->pixelformat
= V4L2_PIX_FMT_GREY
;
2720 strcpy(f
->description
,"vbi data");
2724 /* video capture + overlay */
2726 for (i
= 0; i
< BTTV_FORMATS
; i
++) {
2727 if (bttv_formats
[i
].fourcc
!= -1)
2729 if ((unsigned int)index
== f
->index
)
2732 if (BTTV_FORMATS
== i
)
2736 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2738 case V4L2_BUF_TYPE_VIDEO_OVERLAY
:
2739 if (!(bttv_formats
[i
].flags
& FORMAT_FLAGS_PACKED
))
2745 memset(f
,0,sizeof(*f
));
2748 f
->pixelformat
= bttv_formats
[i
].fourcc
;
2749 strlcpy(f
->description
,bttv_formats
[i
].name
,sizeof(f
->description
));
2753 case VIDIOC_TRY_FMT
:
2755 struct v4l2_format
*f
= arg
;
2756 return bttv_try_fmt(fh
,btv
,f
);
2760 struct v4l2_format
*f
= arg
;
2761 return bttv_g_fmt(fh
,f
);
2765 struct v4l2_format
*f
= arg
;
2766 return bttv_s_fmt(fh
,btv
,f
);
2771 struct v4l2_framebuffer
*fb
= arg
;
2774 fb
->capability
= V4L2_FBUF_CAP_LIST_CLIPPING
;
2776 fb
->fmt
.pixelformat
= fh
->ovfmt
->fourcc
;
2781 struct v4l2_framebuffer
*fb
= arg
;
2782 const struct bttv_format
*fmt
;
2784 if(!capable(CAP_SYS_ADMIN
) &&
2785 !capable(CAP_SYS_RAWIO
))
2789 fmt
= format_by_fourcc(fb
->fmt
.pixelformat
);
2792 if (0 == (fmt
->flags
& FORMAT_FLAGS_PACKED
))
2795 mutex_lock(&fh
->cap
.lock
);
2797 if (fb
->flags
& V4L2_FBUF_FLAG_OVERLAY
) {
2798 if (fb
->fmt
.width
> bttv_tvnorms
[btv
->tvnorm
].swidth
)
2799 goto fh_unlock_and_return
;
2800 if (fb
->fmt
.height
> bttv_tvnorms
[btv
->tvnorm
].sheight
)
2801 goto fh_unlock_and_return
;
2805 btv
->fbuf
.base
= fb
->base
;
2806 btv
->fbuf
.fmt
.width
= fb
->fmt
.width
;
2807 btv
->fbuf
.fmt
.height
= fb
->fmt
.height
;
2808 if (0 != fb
->fmt
.bytesperline
)
2809 btv
->fbuf
.fmt
.bytesperline
= fb
->fmt
.bytesperline
;
2811 btv
->fbuf
.fmt
.bytesperline
= btv
->fbuf
.fmt
.width
*fmt
->depth
/8;
2815 btv
->init
.ovfmt
= fmt
;
2816 if (fb
->flags
& V4L2_FBUF_FLAG_OVERLAY
) {
2819 fh
->ov
.w
.width
= fb
->fmt
.width
;
2820 fh
->ov
.w
.height
= fb
->fmt
.height
;
2821 btv
->init
.ov
.w
.width
= fb
->fmt
.width
;
2822 btv
->init
.ov
.w
.height
= fb
->fmt
.height
;
2823 kfree(fh
->ov
.clips
);
2824 fh
->ov
.clips
= NULL
;
2827 if (check_btres(fh
, RESOURCE_OVERLAY
)) {
2828 struct bttv_buffer
*new;
2830 new = videobuf_alloc(sizeof(*new));
2831 bttv_overlay_risc(btv
,&fh
->ov
,fh
->ovfmt
,new);
2832 retval
= bttv_switch_overlay(btv
,fh
,new);
2835 mutex_unlock(&fh
->cap
.lock
);
2839 case VIDIOC_REQBUFS
:
2840 return videobuf_reqbufs(bttv_queue(fh
),arg
);
2842 case VIDIOC_QUERYBUF
:
2843 return videobuf_querybuf(bttv_queue(fh
),arg
);
2846 return videobuf_qbuf(bttv_queue(fh
),arg
);
2849 return videobuf_dqbuf(bttv_queue(fh
),arg
,
2850 file
->f_flags
& O_NONBLOCK
);
2852 case VIDIOC_STREAMON
:
2854 int res
= bttv_resource(fh
);
2856 if (!check_alloc_btres(btv
,fh
,res
))
2858 return videobuf_streamon(bttv_queue(fh
));
2860 case VIDIOC_STREAMOFF
:
2862 int res
= bttv_resource(fh
);
2864 retval
= videobuf_streamoff(bttv_queue(fh
));
2867 free_btres(btv
,fh
,res
);
2871 case VIDIOC_QUERYCTRL
:
2873 struct v4l2_queryctrl
*c
= arg
;
2876 if ((c
->id
< V4L2_CID_BASE
||
2877 c
->id
>= V4L2_CID_LASTP1
) &&
2878 (c
->id
< V4L2_CID_PRIVATE_BASE
||
2879 c
->id
>= V4L2_CID_PRIVATE_LASTP1
))
2881 for (i
= 0; i
< BTTV_CTLS
; i
++)
2882 if (bttv_ctls
[i
].id
== c
->id
)
2884 if (i
== BTTV_CTLS
) {
2889 if (btv
->audio_hook
&& i
>= 4 && i
<= 8) {
2890 struct video_audio va
;
2891 memset(&va
,0,sizeof(va
));
2892 btv
->audio_hook(btv
,&va
,0);
2893 switch (bttv_ctls
[i
].id
) {
2894 case V4L2_CID_AUDIO_VOLUME
:
2895 if (!(va
.flags
& VIDEO_AUDIO_VOLUME
))
2898 case V4L2_CID_AUDIO_BALANCE
:
2899 if (!(va
.flags
& VIDEO_AUDIO_BALANCE
))
2902 case V4L2_CID_AUDIO_BASS
:
2903 if (!(va
.flags
& VIDEO_AUDIO_BASS
))
2906 case V4L2_CID_AUDIO_TREBLE
:
2907 if (!(va
.flags
& VIDEO_AUDIO_TREBLE
))
2915 return get_control(btv
,arg
);
2917 return set_control(btv
,arg
);
2920 struct v4l2_streamparm
*parm
= arg
;
2921 struct v4l2_standard s
;
2922 if (parm
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
2924 memset(parm
,0,sizeof(*parm
));
2925 v4l2_video_std_construct(&s
, bttv_tvnorms
[btv
->tvnorm
].v4l2_id
,
2926 bttv_tvnorms
[btv
->tvnorm
].name
);
2927 parm
->parm
.capture
.timeperframe
= s
.frameperiod
;
2931 case VIDIOC_G_PRIORITY
:
2933 enum v4l2_priority
*p
= arg
;
2935 *p
= v4l2_prio_max(&btv
->prio
);
2938 case VIDIOC_S_PRIORITY
:
2940 enum v4l2_priority
*prio
= arg
;
2942 return v4l2_prio_change(&btv
->prio
, &fh
->prio
, *prio
);
2945 case VIDIOC_ENUMSTD
:
2948 case VIDIOC_ENUMINPUT
:
2949 case VIDIOC_G_INPUT
:
2950 case VIDIOC_S_INPUT
:
2951 case VIDIOC_G_TUNER
:
2952 case VIDIOC_S_TUNER
:
2953 case VIDIOC_G_FREQUENCY
:
2954 case VIDIOC_S_FREQUENCY
:
2955 case VIDIOC_LOG_STATUS
:
2956 return bttv_common_ioctls(btv
,cmd
,arg
);
2959 return -ENOIOCTLCMD
;
2963 fh_unlock_and_return
:
2964 mutex_unlock(&fh
->cap
.lock
);
2968 static int bttv_ioctl(struct inode
*inode
, struct file
*file
,
2969 unsigned int cmd
, unsigned long arg
)
2971 struct bttv_fh
*fh
= file
->private_data
;
2975 bttv_switch_type(fh
,V4L2_BUF_TYPE_VBI_CAPTURE
);
2976 return fh
->lines
* 2 * 2048;
2978 return video_usercopy(inode
, file
, cmd
, arg
, bttv_do_ioctl
);
2982 static ssize_t
bttv_read(struct file
*file
, char __user
*data
,
2983 size_t count
, loff_t
*ppos
)
2985 struct bttv_fh
*fh
= file
->private_data
;
2988 if (fh
->btv
->errors
)
2989 bttv_reinit_bt848(fh
->btv
);
2990 dprintk("bttv%d: read count=%d type=%s\n",
2991 fh
->btv
->c
.nr
,(int)count
,v4l2_type_names
[fh
->type
]);
2994 case V4L2_BUF_TYPE_VIDEO_CAPTURE
:
2995 if (locked_btres(fh
->btv
,RESOURCE_VIDEO
))
2997 retval
= videobuf_read_one(&fh
->cap
, data
, count
, ppos
,
2998 file
->f_flags
& O_NONBLOCK
);
3000 case V4L2_BUF_TYPE_VBI_CAPTURE
:
3001 if (!check_alloc_btres(fh
->btv
,fh
,RESOURCE_VBI
))
3003 retval
= videobuf_read_stream(&fh
->vbi
, data
, count
, ppos
, 1,
3004 file
->f_flags
& O_NONBLOCK
);
3012 static unsigned int bttv_poll(struct file
*file
, poll_table
*wait
)
3014 struct bttv_fh
*fh
= file
->private_data
;
3015 struct bttv_buffer
*buf
;
3016 enum v4l2_field field
;
3018 if (V4L2_BUF_TYPE_VBI_CAPTURE
== fh
->type
) {
3019 if (!check_alloc_btres(fh
->btv
,fh
,RESOURCE_VBI
))
3021 return videobuf_poll_stream(file
, &fh
->vbi
, wait
);
3024 if (check_btres(fh
,RESOURCE_VIDEO
)) {
3025 /* streaming capture */
3026 if (list_empty(&fh
->cap
.stream
))
3028 buf
= list_entry(fh
->cap
.stream
.next
,struct bttv_buffer
,vb
.stream
);
3030 /* read() capture */
3031 mutex_lock(&fh
->cap
.lock
);
3032 if (NULL
== fh
->cap
.read_buf
) {
3033 /* need to capture a new frame */
3034 if (locked_btres(fh
->btv
,RESOURCE_VIDEO
)) {
3035 mutex_unlock(&fh
->cap
.lock
);
3038 fh
->cap
.read_buf
= videobuf_alloc(fh
->cap
.msize
);
3039 if (NULL
== fh
->cap
.read_buf
) {
3040 mutex_unlock(&fh
->cap
.lock
);
3043 fh
->cap
.read_buf
->memory
= V4L2_MEMORY_USERPTR
;
3044 field
= videobuf_next_field(&fh
->cap
);
3045 if (0 != fh
->cap
.ops
->buf_prepare(&fh
->cap
,fh
->cap
.read_buf
,field
)) {
3046 kfree (fh
->cap
.read_buf
);
3047 fh
->cap
.read_buf
= NULL
;
3048 mutex_unlock(&fh
->cap
.lock
);
3051 fh
->cap
.ops
->buf_queue(&fh
->cap
,fh
->cap
.read_buf
);
3052 fh
->cap
.read_off
= 0;
3054 mutex_unlock(&fh
->cap
.lock
);
3055 buf
= (struct bttv_buffer
*)fh
->cap
.read_buf
;
3058 poll_wait(file
, &buf
->vb
.done
, wait
);
3059 if (buf
->vb
.state
== STATE_DONE
||
3060 buf
->vb
.state
== STATE_ERROR
)
3061 return POLLIN
|POLLRDNORM
;
3065 static int bttv_open(struct inode
*inode
, struct file
*file
)
3067 int minor
= iminor(inode
);
3068 struct bttv
*btv
= NULL
;
3070 enum v4l2_buf_type type
= 0;
3073 dprintk(KERN_DEBUG
"bttv: open minor=%d\n",minor
);
3075 for (i
= 0; i
< bttv_num
; i
++) {
3076 if (bttvs
[i
].video_dev
&&
3077 bttvs
[i
].video_dev
->minor
== minor
) {
3079 type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
3082 if (bttvs
[i
].vbi_dev
&&
3083 bttvs
[i
].vbi_dev
->minor
== minor
) {
3085 type
= V4L2_BUF_TYPE_VBI_CAPTURE
;
3092 dprintk(KERN_DEBUG
"bttv%d: open called (type=%s)\n",
3093 btv
->c
.nr
,v4l2_type_names
[type
]);
3095 /* allocate per filehandle data */
3096 fh
= kmalloc(sizeof(*fh
),GFP_KERNEL
);
3099 file
->private_data
= fh
;
3102 fh
->ov
.setup_ok
= 0;
3103 v4l2_prio_open(&btv
->prio
,&fh
->prio
);
3105 videobuf_queue_init(&fh
->cap
, &bttv_video_qops
,
3106 btv
->c
.pci
, &btv
->s_lock
,
3107 V4L2_BUF_TYPE_VIDEO_CAPTURE
,
3108 V4L2_FIELD_INTERLACED
,
3109 sizeof(struct bttv_buffer
),
3111 videobuf_queue_init(&fh
->vbi
, &bttv_vbi_qops
,
3112 btv
->c
.pci
, &btv
->s_lock
,
3113 V4L2_BUF_TYPE_VBI_CAPTURE
,
3115 sizeof(struct bttv_buffer
),
3117 i2c_vidiocschan(btv
);
3120 if (V4L2_BUF_TYPE_VBI_CAPTURE
== fh
->type
)
3121 bttv_vbi_setlines(fh
,btv
,16);
3122 bttv_field_count(btv
);
3126 static int bttv_release(struct inode
*inode
, struct file
*file
)
3128 struct bttv_fh
*fh
= file
->private_data
;
3129 struct bttv
*btv
= fh
->btv
;
3131 /* turn off overlay */
3132 if (check_btres(fh
, RESOURCE_OVERLAY
))
3133 bttv_switch_overlay(btv
,fh
,NULL
);
3135 /* stop video capture */
3136 if (check_btres(fh
, RESOURCE_VIDEO
)) {
3137 videobuf_streamoff(&fh
->cap
);
3138 free_btres(btv
,fh
,RESOURCE_VIDEO
);
3140 if (fh
->cap
.read_buf
) {
3141 buffer_release(&fh
->cap
,fh
->cap
.read_buf
);
3142 kfree(fh
->cap
.read_buf
);
3145 /* stop vbi capture */
3146 if (check_btres(fh
, RESOURCE_VBI
)) {
3147 if (fh
->vbi
.streaming
)
3148 videobuf_streamoff(&fh
->vbi
);
3149 if (fh
->vbi
.reading
)
3150 videobuf_read_stop(&fh
->vbi
);
3151 free_btres(btv
,fh
,RESOURCE_VBI
);
3155 videobuf_mmap_free(&fh
->cap
);
3156 videobuf_mmap_free(&fh
->vbi
);
3157 v4l2_prio_close(&btv
->prio
,&fh
->prio
);
3158 file
->private_data
= NULL
;
3162 bttv_field_count(btv
);
3167 bttv_mmap(struct file
*file
, struct vm_area_struct
*vma
)
3169 struct bttv_fh
*fh
= file
->private_data
;
3171 dprintk("bttv%d: mmap type=%s 0x%lx+%ld\n",
3172 fh
->btv
->c
.nr
, v4l2_type_names
[fh
->type
],
3173 vma
->vm_start
, vma
->vm_end
- vma
->vm_start
);
3174 return videobuf_mmap_mapper(bttv_queue(fh
),vma
);
3177 static struct file_operations bttv_fops
=
3179 .owner
= THIS_MODULE
,
3181 .release
= bttv_release
,
3182 .ioctl
= bttv_ioctl
,
3183 .compat_ioctl
= v4l_compat_ioctl32
,
3184 .llseek
= no_llseek
,
3190 static struct video_device bttv_video_template
=
3193 .type
= VID_TYPE_CAPTURE
|VID_TYPE_TUNER
|
3194 VID_TYPE_CLIPPING
|VID_TYPE_SCALES
,
3195 .hardware
= VID_HARDWARE_BT848
,
3200 static struct video_device bttv_vbi_template
=
3202 .name
= "bt848/878 vbi",
3203 .type
= VID_TYPE_TUNER
|VID_TYPE_TELETEXT
,
3204 .hardware
= VID_HARDWARE_BT848
,
3209 /* ----------------------------------------------------------------------- */
3210 /* radio interface */
3212 static int radio_open(struct inode
*inode
, struct file
*file
)
3214 int minor
= iminor(inode
);
3215 struct bttv
*btv
= NULL
;
3218 dprintk("bttv: open minor=%d\n",minor
);
3220 for (i
= 0; i
< bttv_num
; i
++) {
3221 if (bttvs
[i
].radio_dev
->minor
== minor
) {
3229 dprintk("bttv%d: open called (radio)\n",btv
->c
.nr
);
3230 mutex_lock(&btv
->lock
);
3234 file
->private_data
= btv
;
3236 bttv_call_i2c_clients(btv
,AUDC_SET_RADIO
,NULL
);
3237 audio_input(btv
,TVAUDIO_INPUT_RADIO
);
3239 mutex_unlock(&btv
->lock
);
3243 static int radio_release(struct inode
*inode
, struct file
*file
)
3245 struct bttv
*btv
= file
->private_data
;
3246 struct rds_command cmd
;
3250 bttv_call_i2c_clients(btv
, RDS_CMD_CLOSE
, &cmd
);
3255 static int radio_do_ioctl(struct inode
*inode
, struct file
*file
,
3256 unsigned int cmd
, void *arg
)
3258 struct bttv
*btv
= file
->private_data
;
3263 struct video_capability
*cap
= arg
;
3265 memset(cap
,0,sizeof(*cap
));
3266 strcpy(cap
->name
,btv
->radio_dev
->name
);
3267 cap
->type
= VID_TYPE_TUNER
;
3275 struct video_tuner
*v
= arg
;
3279 memset(v
,0,sizeof(*v
));
3280 strcpy(v
->name
, "Radio");
3281 bttv_call_i2c_clients(btv
,cmd
,v
);
3293 case VIDIOC_LOG_STATUS
:
3294 return bttv_common_ioctls(btv
,cmd
,arg
);
3297 return -ENOIOCTLCMD
;
3302 static int radio_ioctl(struct inode
*inode
, struct file
*file
,
3303 unsigned int cmd
, unsigned long arg
)
3305 return video_usercopy(inode
, file
, cmd
, arg
, radio_do_ioctl
);
3308 static ssize_t
radio_read(struct file
*file
, char __user
*data
,
3309 size_t count
, loff_t
*ppos
)
3311 struct bttv
*btv
= file
->private_data
;
3312 struct rds_command cmd
;
3313 cmd
.block_count
= count
/3;
3315 cmd
.instance
= file
;
3316 cmd
.result
= -ENODEV
;
3318 bttv_call_i2c_clients(btv
, RDS_CMD_READ
, &cmd
);
3323 static unsigned int radio_poll(struct file
*file
, poll_table
*wait
)
3325 struct bttv
*btv
= file
->private_data
;
3326 struct rds_command cmd
;
3327 cmd
.instance
= file
;
3328 cmd
.event_list
= wait
;
3329 cmd
.result
= -ENODEV
;
3330 bttv_call_i2c_clients(btv
, RDS_CMD_POLL
, &cmd
);
3335 static struct file_operations radio_fops
=
3337 .owner
= THIS_MODULE
,
3340 .release
= radio_release
,
3341 .ioctl
= radio_ioctl
,
3342 .llseek
= no_llseek
,
3346 static struct video_device radio_template
=
3348 .name
= "bt848/878 radio",
3349 .type
= VID_TYPE_TUNER
,
3350 .hardware
= VID_HARDWARE_BT848
,
3351 .fops
= &radio_fops
,
3355 /* ----------------------------------------------------------------------- */
3356 /* some debug code */
3358 static int bttv_risc_decode(u32 risc
)
3360 static char *instr
[16] = {
3361 [ BT848_RISC_WRITE
>> 28 ] = "write",
3362 [ BT848_RISC_SKIP
>> 28 ] = "skip",
3363 [ BT848_RISC_WRITEC
>> 28 ] = "writec",
3364 [ BT848_RISC_JUMP
>> 28 ] = "jump",
3365 [ BT848_RISC_SYNC
>> 28 ] = "sync",
3366 [ BT848_RISC_WRITE123
>> 28 ] = "write123",
3367 [ BT848_RISC_SKIP123
>> 28 ] = "skip123",
3368 [ BT848_RISC_WRITE1S23
>> 28 ] = "write1s23",
3370 static int incr
[16] = {
3371 [ BT848_RISC_WRITE
>> 28 ] = 2,
3372 [ BT848_RISC_JUMP
>> 28 ] = 2,
3373 [ BT848_RISC_SYNC
>> 28 ] = 2,
3374 [ BT848_RISC_WRITE123
>> 28 ] = 5,
3375 [ BT848_RISC_SKIP123
>> 28 ] = 2,
3376 [ BT848_RISC_WRITE1S23
>> 28 ] = 3,
3378 static char *bits
[] = {
3379 "be0", "be1", "be2", "be3/resync",
3380 "set0", "set1", "set2", "set3",
3381 "clr0", "clr1", "clr2", "clr3",
3382 "irq", "res", "eol", "sol",
3386 printk("0x%08x [ %s", risc
,
3387 instr
[risc
>> 28] ? instr
[risc
>> 28] : "INVALID");
3388 for (i
= ARRAY_SIZE(bits
)-1; i
>= 0; i
--)
3389 if (risc
& (1 << (i
+ 12)))
3390 printk(" %s",bits
[i
]);
3391 printk(" count=%d ]\n", risc
& 0xfff);
3392 return incr
[risc
>> 28] ? incr
[risc
>> 28] : 1;
3395 static void bttv_risc_disasm(struct bttv
*btv
,
3396 struct btcx_riscmem
*risc
)
3400 printk("%s: risc disasm: %p [dma=0x%08lx]\n",
3401 btv
->c
.name
, risc
->cpu
, (unsigned long)risc
->dma
);
3402 for (i
= 0; i
< (risc
->size
>> 2); i
+= n
) {
3403 printk("%s: 0x%lx: ", btv
->c
.name
,
3404 (unsigned long)(risc
->dma
+ (i
<<2)));
3405 n
= bttv_risc_decode(risc
->cpu
[i
]);
3406 for (j
= 1; j
< n
; j
++)
3407 printk("%s: 0x%lx: 0x%08x [ arg #%d ]\n",
3408 btv
->c
.name
, (unsigned long)(risc
->dma
+ ((i
+j
)<<2)),
3410 if (0 == risc
->cpu
[i
])
3415 static void bttv_print_riscaddr(struct bttv
*btv
)
3417 printk(" main: %08Lx\n",
3418 (unsigned long long)btv
->main
.dma
);
3419 printk(" vbi : o=%08Lx e=%08Lx\n",
3420 btv
->cvbi
? (unsigned long long)btv
->cvbi
->top
.dma
: 0,
3421 btv
->cvbi
? (unsigned long long)btv
->cvbi
->bottom
.dma
: 0);
3422 printk(" cap : o=%08Lx e=%08Lx\n",
3423 btv
->curr
.top
? (unsigned long long)btv
->curr
.top
->top
.dma
: 0,
3424 btv
->curr
.bottom
? (unsigned long long)btv
->curr
.bottom
->bottom
.dma
: 0);
3425 printk(" scr : o=%08Lx e=%08Lx\n",
3426 btv
->screen
? (unsigned long long)btv
->screen
->top
.dma
: 0,
3427 btv
->screen
? (unsigned long long)btv
->screen
->bottom
.dma
: 0);
3428 bttv_risc_disasm(btv
, &btv
->main
);
3431 /* ----------------------------------------------------------------------- */
3434 static char *irq_name
[] = {
3435 "FMTCHG", // format change detected (525 vs. 625)
3436 "VSYNC", // vertical sync (new field)
3437 "HSYNC", // horizontal sync
3438 "OFLOW", // chroma/luma AGC overflow
3439 "HLOCK", // horizontal lock changed
3440 "VPRES", // video presence changed
3442 "I2CDONE", // hw irc operation finished
3443 "GPINT", // gpio port triggered irq
3445 "RISCI", // risc instruction triggered irq
3446 "FBUS", // pixel data fifo dropped data (high pci bus latencies)
3447 "FTRGT", // pixel data fifo overrun
3448 "FDSR", // fifo data stream resyncronisation
3449 "PPERR", // parity error (data transfer)
3450 "RIPERR", // parity error (read risc instructions)
3451 "PABORT", // pci abort
3452 "OCERR", // risc instruction error
3453 "SCERR", // syncronisation error
3456 static void bttv_print_irqbits(u32 print
, u32 mark
)
3461 for (i
= 0; i
< ARRAY_SIZE(irq_name
); i
++) {
3462 if (print
& (1 << i
))
3463 printk(" %s",irq_name
[i
]);
3464 if (mark
& (1 << i
))
3469 static void bttv_irq_debug_low_latency(struct bttv
*btv
, u32 rc
)
3471 printk("bttv%d: irq: skipped frame [main=%lx,o_vbi=%lx,o_field=%lx,rc=%lx]\n",
3473 (unsigned long)btv
->main
.dma
,
3474 (unsigned long)btv
->main
.cpu
[RISC_SLOT_O_VBI
+1],
3475 (unsigned long)btv
->main
.cpu
[RISC_SLOT_O_FIELD
+1],
3478 if (0 == (btread(BT848_DSTATUS
) & BT848_DSTATUS_HLOC
)) {
3479 printk("bttv%d: Oh, there (temporarely?) is no input signal. "
3480 "Ok, then this is harmless, don't worry ;)\n",
3484 printk("bttv%d: Uhm. Looks like we have unusual high IRQ latencies.\n",
3486 printk("bttv%d: Lets try to catch the culpit red-handed ...\n",
3492 bttv_irq_next_video(struct bttv
*btv
, struct bttv_buffer_set
*set
)
3494 struct bttv_buffer
*item
;
3496 memset(set
,0,sizeof(*set
));
3498 /* capture request ? */
3499 if (!list_empty(&btv
->capture
)) {
3501 item
= list_entry(btv
->capture
.next
, struct bttv_buffer
, vb
.queue
);
3502 if (V4L2_FIELD_HAS_TOP(item
->vb
.field
))
3504 if (V4L2_FIELD_HAS_BOTTOM(item
->vb
.field
))
3507 /* capture request for other field ? */
3508 if (!V4L2_FIELD_HAS_BOTH(item
->vb
.field
) &&
3509 (item
->vb
.queue
.next
!= &btv
->capture
)) {
3510 item
= list_entry(item
->vb
.queue
.next
, struct bttv_buffer
, vb
.queue
);
3511 if (!V4L2_FIELD_HAS_BOTH(item
->vb
.field
)) {
3512 if (NULL
== set
->top
&&
3513 V4L2_FIELD_TOP
== item
->vb
.field
) {
3516 if (NULL
== set
->bottom
&&
3517 V4L2_FIELD_BOTTOM
== item
->vb
.field
) {
3520 if (NULL
!= set
->top
&& NULL
!= set
->bottom
)
3526 /* screen overlay ? */
3527 if (NULL
!= btv
->screen
) {
3528 if (V4L2_FIELD_HAS_BOTH(btv
->screen
->vb
.field
)) {
3529 if (NULL
== set
->top
&& NULL
== set
->bottom
) {
3530 set
->top
= btv
->screen
;
3531 set
->bottom
= btv
->screen
;
3534 if (V4L2_FIELD_TOP
== btv
->screen
->vb
.field
&&
3536 set
->top
= btv
->screen
;
3538 if (V4L2_FIELD_BOTTOM
== btv
->screen
->vb
.field
&&
3539 NULL
== set
->bottom
) {
3540 set
->bottom
= btv
->screen
;
3545 dprintk("bttv%d: next set: top=%p bottom=%p [screen=%p,irq=%d,%d]\n",
3546 btv
->c
.nr
,set
->top
, set
->bottom
,
3547 btv
->screen
,set
->frame_irq
,set
->top_irq
);
3552 bttv_irq_wakeup_video(struct bttv
*btv
, struct bttv_buffer_set
*wakeup
,
3553 struct bttv_buffer_set
*curr
, unsigned int state
)
3557 do_gettimeofday(&ts
);
3559 if (wakeup
->top
== wakeup
->bottom
) {
3560 if (NULL
!= wakeup
->top
&& curr
->top
!= wakeup
->top
) {
3562 printk("bttv%d: wakeup: both=%p\n",btv
->c
.nr
,wakeup
->top
);
3563 wakeup
->top
->vb
.ts
= ts
;
3564 wakeup
->top
->vb
.field_count
= btv
->field_count
;
3565 wakeup
->top
->vb
.state
= state
;
3566 wake_up(&wakeup
->top
->vb
.done
);
3569 if (NULL
!= wakeup
->top
&& curr
->top
!= wakeup
->top
) {
3571 printk("bttv%d: wakeup: top=%p\n",btv
->c
.nr
,wakeup
->top
);
3572 wakeup
->top
->vb
.ts
= ts
;
3573 wakeup
->top
->vb
.field_count
= btv
->field_count
;
3574 wakeup
->top
->vb
.state
= state
;
3575 wake_up(&wakeup
->top
->vb
.done
);
3577 if (NULL
!= wakeup
->bottom
&& curr
->bottom
!= wakeup
->bottom
) {
3579 printk("bttv%d: wakeup: bottom=%p\n",btv
->c
.nr
,wakeup
->bottom
);
3580 wakeup
->bottom
->vb
.ts
= ts
;
3581 wakeup
->bottom
->vb
.field_count
= btv
->field_count
;
3582 wakeup
->bottom
->vb
.state
= state
;
3583 wake_up(&wakeup
->bottom
->vb
.done
);
3589 bttv_irq_wakeup_vbi(struct bttv
*btv
, struct bttv_buffer
*wakeup
,
3597 do_gettimeofday(&ts
);
3599 wakeup
->vb
.field_count
= btv
->field_count
;
3600 wakeup
->vb
.state
= state
;
3601 wake_up(&wakeup
->vb
.done
);
3604 static void bttv_irq_timeout(unsigned long data
)
3606 struct bttv
*btv
= (struct bttv
*)data
;
3607 struct bttv_buffer_set old
,new;
3608 struct bttv_buffer
*ovbi
;
3609 struct bttv_buffer
*item
;
3610 unsigned long flags
;
3613 printk(KERN_INFO
"bttv%d: timeout: drop=%d irq=%d/%d, risc=%08x, ",
3614 btv
->c
.nr
, btv
->framedrop
, btv
->irq_me
, btv
->irq_total
,
3615 btread(BT848_RISC_COUNT
));
3616 bttv_print_irqbits(btread(BT848_INT_STAT
),0);
3620 spin_lock_irqsave(&btv
->s_lock
,flags
);
3622 /* deactivate stuff */
3623 memset(&new,0,sizeof(new));
3629 bttv_buffer_activate_video(btv
, &new);
3630 bttv_buffer_activate_vbi(btv
, NULL
);
3631 bttv_set_dma(btv
, 0);
3634 bttv_irq_wakeup_video(btv
, &old
, &new, STATE_ERROR
);
3635 bttv_irq_wakeup_vbi(btv
, ovbi
, STATE_ERROR
);
3637 /* cancel all outstanding capture / vbi requests */
3638 while (!list_empty(&btv
->capture
)) {
3639 item
= list_entry(btv
->capture
.next
, struct bttv_buffer
, vb
.queue
);
3640 list_del(&item
->vb
.queue
);
3641 item
->vb
.state
= STATE_ERROR
;
3642 wake_up(&item
->vb
.done
);
3644 while (!list_empty(&btv
->vcapture
)) {
3645 item
= list_entry(btv
->vcapture
.next
, struct bttv_buffer
, vb
.queue
);
3646 list_del(&item
->vb
.queue
);
3647 item
->vb
.state
= STATE_ERROR
;
3648 wake_up(&item
->vb
.done
);
3652 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
3656 bttv_irq_wakeup_top(struct bttv
*btv
)
3658 struct bttv_buffer
*wakeup
= btv
->curr
.top
;
3663 spin_lock(&btv
->s_lock
);
3664 btv
->curr
.top_irq
= 0;
3665 btv
->curr
.top
= NULL
;
3666 bttv_risc_hook(btv
, RISC_SLOT_O_FIELD
, NULL
, 0);
3668 do_gettimeofday(&wakeup
->vb
.ts
);
3669 wakeup
->vb
.field_count
= btv
->field_count
;
3670 wakeup
->vb
.state
= STATE_DONE
;
3671 wake_up(&wakeup
->vb
.done
);
3672 spin_unlock(&btv
->s_lock
);
3675 static inline int is_active(struct btcx_riscmem
*risc
, u32 rc
)
3679 if (rc
> risc
->dma
+ risc
->size
)
3685 bttv_irq_switch_video(struct bttv
*btv
)
3687 struct bttv_buffer_set
new;
3688 struct bttv_buffer_set old
;
3691 spin_lock(&btv
->s_lock
);
3693 /* new buffer set */
3694 bttv_irq_next_video(btv
, &new);
3695 rc
= btread(BT848_RISC_COUNT
);
3696 if ((btv
->curr
.top
&& is_active(&btv
->curr
.top
->top
, rc
)) ||
3697 (btv
->curr
.bottom
&& is_active(&btv
->curr
.bottom
->bottom
, rc
))) {
3700 bttv_irq_debug_low_latency(btv
, rc
);
3701 spin_unlock(&btv
->s_lock
);
3708 btv
->loop_irq
&= ~1;
3709 bttv_buffer_activate_video(btv
, &new);
3710 bttv_set_dma(btv
, 0);
3713 if (UNSET
!= btv
->new_input
) {
3714 video_mux(btv
,btv
->new_input
);
3715 btv
->new_input
= UNSET
;
3718 /* wake up finished buffers */
3719 bttv_irq_wakeup_video(btv
, &old
, &new, STATE_DONE
);
3720 spin_unlock(&btv
->s_lock
);
3724 bttv_irq_switch_vbi(struct bttv
*btv
)
3726 struct bttv_buffer
*new = NULL
;
3727 struct bttv_buffer
*old
;
3730 spin_lock(&btv
->s_lock
);
3732 if (!list_empty(&btv
->vcapture
))
3733 new = list_entry(btv
->vcapture
.next
, struct bttv_buffer
, vb
.queue
);
3736 rc
= btread(BT848_RISC_COUNT
);
3737 if (NULL
!= old
&& (is_active(&old
->top
, rc
) ||
3738 is_active(&old
->bottom
, rc
))) {
3741 bttv_irq_debug_low_latency(btv
, rc
);
3742 spin_unlock(&btv
->s_lock
);
3748 btv
->loop_irq
&= ~4;
3749 bttv_buffer_activate_vbi(btv
, new);
3750 bttv_set_dma(btv
, 0);
3752 bttv_irq_wakeup_vbi(btv
, old
, STATE_DONE
);
3753 spin_unlock(&btv
->s_lock
);
3756 static irqreturn_t
bttv_irq(int irq
, void *dev_id
)
3764 btv
=(struct bttv
*)dev_id
;
3766 if (btv
->custom_irq
)
3767 handled
= btv
->custom_irq(btv
);
3771 /* get/clear interrupt status bits */
3772 stat
=btread(BT848_INT_STAT
);
3773 astat
=stat
&btread(BT848_INT_MASK
);
3777 btwrite(stat
,BT848_INT_STAT
);
3779 /* get device status bits */
3780 dstat
=btread(BT848_DSTATUS
);
3783 printk(KERN_DEBUG
"bttv%d: irq loop=%d fc=%d "
3784 "riscs=%x, riscc=%08x, ",
3785 btv
->c
.nr
, count
, btv
->field_count
,
3786 stat
>>28, btread(BT848_RISC_COUNT
));
3787 bttv_print_irqbits(stat
,astat
);
3788 if (stat
& BT848_INT_HLOCK
)
3789 printk(" HLOC => %s", (dstat
& BT848_DSTATUS_HLOC
)
3791 if (stat
& BT848_INT_VPRES
)
3792 printk(" PRES => %s", (dstat
& BT848_DSTATUS_PRES
)
3794 if (stat
& BT848_INT_FMTCHG
)
3795 printk(" NUML => %s", (dstat
& BT848_DSTATUS_NUML
)
3800 if (astat
&BT848_INT_VSYNC
)
3803 if ((astat
& BT848_INT_GPINT
) && btv
->remote
) {
3804 wake_up(&btv
->gpioq
);
3805 bttv_input_irq(btv
);
3808 if (astat
& BT848_INT_I2CDONE
) {
3809 btv
->i2c_done
= stat
;
3810 wake_up(&btv
->i2c_queue
);
3813 if ((astat
& BT848_INT_RISCI
) && (stat
& (4<<28)))
3814 bttv_irq_switch_vbi(btv
);
3816 if ((astat
& BT848_INT_RISCI
) && (stat
& (2<<28)))
3817 bttv_irq_wakeup_top(btv
);
3819 if ((astat
& BT848_INT_RISCI
) && (stat
& (1<<28)))
3820 bttv_irq_switch_video(btv
);
3822 if ((astat
& BT848_INT_HLOCK
) && btv
->opt_automute
)
3823 audio_mute(btv
, btv
->mute
); /* trigger automute */
3825 if (astat
& (BT848_INT_SCERR
|BT848_INT_OCERR
)) {
3826 printk(KERN_INFO
"bttv%d: %s%s @ %08x,",btv
->c
.nr
,
3827 (astat
& BT848_INT_SCERR
) ? "SCERR" : "",
3828 (astat
& BT848_INT_OCERR
) ? "OCERR" : "",
3829 btread(BT848_RISC_COUNT
));
3830 bttv_print_irqbits(stat
,astat
);
3833 bttv_print_riscaddr(btv
);
3835 if (fdsr
&& astat
& BT848_INT_FDSR
) {
3836 printk(KERN_INFO
"bttv%d: FDSR @ %08x\n",
3837 btv
->c
.nr
,btread(BT848_RISC_COUNT
));
3839 bttv_print_riscaddr(btv
);
3845 if (count
> 8 || !(astat
& BT848_INT_GPINT
)) {
3846 btwrite(0, BT848_INT_MASK
);
3849 "bttv%d: IRQ lockup, cleared int mask [", btv
->c
.nr
);
3852 "bttv%d: IRQ lockup, clearing GPINT from int mask [", btv
->c
.nr
);
3854 btwrite(btread(BT848_INT_MASK
) & (-1 ^ BT848_INT_GPINT
),
3858 bttv_print_irqbits(stat
,astat
);
3866 return IRQ_RETVAL(handled
);
3870 /* ----------------------------------------------------------------------- */
3871 /* initialitation */
3873 static struct video_device
*vdev_init(struct bttv
*btv
,
3874 struct video_device
*template,
3877 struct video_device
*vfd
;
3879 vfd
= video_device_alloc();
3884 vfd
->dev
= &btv
->c
.pci
->dev
;
3885 vfd
->release
= video_device_release
;
3886 snprintf(vfd
->name
, sizeof(vfd
->name
), "BT%d%s %s (%s)",
3887 btv
->id
, (btv
->id
==848 && btv
->revision
==0x12) ? "A" : "",
3888 type
, bttv_tvcards
[btv
->c
.type
].name
);
3892 static void bttv_unregister_video(struct bttv
*btv
)
3894 if (btv
->video_dev
) {
3895 if (-1 != btv
->video_dev
->minor
)
3896 video_unregister_device(btv
->video_dev
);
3898 video_device_release(btv
->video_dev
);
3899 btv
->video_dev
= NULL
;
3902 if (-1 != btv
->vbi_dev
->minor
)
3903 video_unregister_device(btv
->vbi_dev
);
3905 video_device_release(btv
->vbi_dev
);
3906 btv
->vbi_dev
= NULL
;
3908 if (btv
->radio_dev
) {
3909 if (-1 != btv
->radio_dev
->minor
)
3910 video_unregister_device(btv
->radio_dev
);
3912 video_device_release(btv
->radio_dev
);
3913 btv
->radio_dev
= NULL
;
3917 /* register video4linux devices */
3918 static int __devinit
bttv_register_video(struct bttv
*btv
)
3920 if (no_overlay
<= 0) {
3921 bttv_video_template
.type
|= VID_TYPE_OVERLAY
;
3923 printk("bttv: Overlay support disabled.\n");
3927 btv
->video_dev
= vdev_init(btv
, &bttv_video_template
, "video");
3928 if (NULL
== btv
->video_dev
)
3930 if (video_register_device(btv
->video_dev
,VFL_TYPE_GRABBER
,video_nr
)<0)
3932 printk(KERN_INFO
"bttv%d: registered device video%d\n",
3933 btv
->c
.nr
,btv
->video_dev
->minor
& 0x1f);
3934 if (class_device_create_file(&btv
->video_dev
->class_dev
,
3935 &class_device_attr_card
)<0) {
3936 printk(KERN_ERR
"bttv%d: class_device_create_file 'card' "
3937 "failed\n", btv
->c
.nr
);
3942 btv
->vbi_dev
= vdev_init(btv
, &bttv_vbi_template
, "vbi");
3943 if (NULL
== btv
->vbi_dev
)
3945 if (video_register_device(btv
->vbi_dev
,VFL_TYPE_VBI
,vbi_nr
)<0)
3947 printk(KERN_INFO
"bttv%d: registered device vbi%d\n",
3948 btv
->c
.nr
,btv
->vbi_dev
->minor
& 0x1f);
3950 if (!btv
->has_radio
)
3953 btv
->radio_dev
= vdev_init(btv
, &radio_template
, "radio");
3954 if (NULL
== btv
->radio_dev
)
3956 if (video_register_device(btv
->radio_dev
, VFL_TYPE_RADIO
,radio_nr
)<0)
3958 printk(KERN_INFO
"bttv%d: registered device radio%d\n",
3959 btv
->c
.nr
,btv
->radio_dev
->minor
& 0x1f);
3965 bttv_unregister_video(btv
);
3970 /* on OpenFirmware machines (PowerMac at least), PCI memory cycle */
3971 /* response on cards with no firmware is not enabled by OF */
3972 static void pci_set_command(struct pci_dev
*dev
)
3974 #if defined(__powerpc__)
3977 pci_read_config_dword(dev
, PCI_COMMAND
, &cmd
);
3978 cmd
= (cmd
| PCI_COMMAND_MEMORY
);
3979 pci_write_config_dword(dev
, PCI_COMMAND
, cmd
);
3983 static int __devinit
bttv_probe(struct pci_dev
*dev
,
3984 const struct pci_device_id
*pci_id
)
3990 if (bttv_num
== BTTV_MAX
)
3992 printk(KERN_INFO
"bttv: Bt8xx card found (%d).\n", bttv_num
);
3993 btv
=&bttvs
[bttv_num
];
3994 memset(btv
,0,sizeof(*btv
));
3995 btv
->c
.nr
= bttv_num
;
3996 sprintf(btv
->c
.name
,"bttv%d",btv
->c
.nr
);
3998 /* initialize structs / fill in defaults */
3999 mutex_init(&btv
->lock
);
4000 mutex_init(&btv
->reslock
);
4001 spin_lock_init(&btv
->s_lock
);
4002 spin_lock_init(&btv
->gpio_lock
);
4003 init_waitqueue_head(&btv
->gpioq
);
4004 init_waitqueue_head(&btv
->i2c_queue
);
4005 INIT_LIST_HEAD(&btv
->c
.subs
);
4006 INIT_LIST_HEAD(&btv
->capture
);
4007 INIT_LIST_HEAD(&btv
->vcapture
);
4008 v4l2_prio_init(&btv
->prio
);
4010 init_timer(&btv
->timeout
);
4011 btv
->timeout
.function
= bttv_irq_timeout
;
4012 btv
->timeout
.data
= (unsigned long)btv
;
4015 btv
->tuner_type
= UNSET
;
4016 btv
->new_input
= UNSET
;
4017 btv
->has_radio
=radio
[btv
->c
.nr
];
4019 /* pci stuff (init, get irq/mmio, ... */
4021 btv
->id
= dev
->device
;
4022 if (pci_enable_device(dev
)) {
4023 printk(KERN_WARNING
"bttv%d: Can't enable device.\n",
4027 if (pci_set_dma_mask(dev
, DMA_32BIT_MASK
)) {
4028 printk(KERN_WARNING
"bttv%d: No suitable DMA available.\n",
4032 if (!request_mem_region(pci_resource_start(dev
,0),
4033 pci_resource_len(dev
,0),
4035 printk(KERN_WARNING
"bttv%d: can't request iomem (0x%llx).\n",
4037 (unsigned long long)pci_resource_start(dev
,0));
4040 pci_set_master(dev
);
4041 pci_set_command(dev
);
4042 pci_set_drvdata(dev
,btv
);
4044 pci_read_config_byte(dev
, PCI_CLASS_REVISION
, &btv
->revision
);
4045 pci_read_config_byte(dev
, PCI_LATENCY_TIMER
, &lat
);
4046 printk(KERN_INFO
"bttv%d: Bt%d (rev %d) at %s, ",
4047 bttv_num
,btv
->id
, btv
->revision
, pci_name(dev
));
4048 printk("irq: %d, latency: %d, mmio: 0x%llx\n",
4049 btv
->c
.pci
->irq
, lat
,
4050 (unsigned long long)pci_resource_start(dev
,0));
4053 btv
->bt848_mmio
=ioremap(pci_resource_start(dev
,0), 0x1000);
4054 if (NULL
== ioremap(pci_resource_start(dev
,0), 0x1000)) {
4055 printk("bttv%d: ioremap() failed\n", btv
->c
.nr
);
4063 /* disable irqs, register irq handler */
4064 btwrite(0, BT848_INT_MASK
);
4065 result
= request_irq(btv
->c
.pci
->irq
, bttv_irq
,
4066 IRQF_SHARED
| IRQF_DISABLED
,btv
->c
.name
,(void *)btv
);
4068 printk(KERN_ERR
"bttv%d: can't get IRQ %d\n",
4069 bttv_num
,btv
->c
.pci
->irq
);
4073 if (0 != bttv_handle_chipset(btv
)) {
4078 /* init options from insmod args */
4079 btv
->opt_combfilter
= combfilter
;
4080 btv
->opt_lumafilter
= lumafilter
;
4081 btv
->opt_automute
= automute
;
4082 btv
->opt_chroma_agc
= chroma_agc
;
4083 btv
->opt_adc_crush
= adc_crush
;
4084 btv
->opt_vcr_hack
= vcr_hack
;
4085 btv
->opt_whitecrush_upper
= whitecrush_upper
;
4086 btv
->opt_whitecrush_lower
= whitecrush_lower
;
4087 btv
->opt_uv_ratio
= uv_ratio
;
4088 btv
->opt_full_luma_range
= full_luma_range
;
4089 btv
->opt_coring
= coring
;
4091 /* fill struct bttv with some useful defaults */
4092 btv
->init
.btv
= btv
;
4093 btv
->init
.ov
.w
.width
= 320;
4094 btv
->init
.ov
.w
.height
= 240;
4095 btv
->init
.fmt
= format_by_palette(VIDEO_PALETTE_RGB24
);
4096 btv
->init
.width
= 320;
4097 btv
->init
.height
= 240;
4098 btv
->init
.lines
= 16;
4101 /* initialize hardware */
4103 bttv_gpio_tracking(btv
,"pre-init");
4105 bttv_risc_init_main(btv
);
4109 btwrite(0x00, BT848_GPIO_REG_INP
);
4110 btwrite(0x00, BT848_GPIO_OUT_EN
);
4112 bttv_gpio_tracking(btv
,"init");
4114 /* needs to be done before i2c is registered */
4115 bttv_init_card1(btv
);
4117 /* register i2c + gpio */
4120 /* some card-specific stuff (needs working i2c) */
4121 bttv_init_card2(btv
);
4124 /* register video4linux + input */
4125 if (!bttv_tvcards
[btv
->c
.type
].no_video
) {
4126 bttv_register_video(btv
);
4127 bt848_bright(btv
,32768);
4128 bt848_contrast(btv
,32768);
4129 bt848_hue(btv
,32768);
4130 bt848_sat(btv
,32768);
4135 /* add subdevices */
4136 if (bttv_tvcards
[btv
->c
.type
].has_dvb
)
4137 bttv_sub_add_device(&btv
->c
, "dvb");
4139 bttv_input_init(btv
);
4141 /* everything is fine */
4146 free_irq(btv
->c
.pci
->irq
,btv
);
4149 if (btv
->bt848_mmio
)
4150 iounmap(btv
->bt848_mmio
);
4151 release_mem_region(pci_resource_start(btv
->c
.pci
,0),
4152 pci_resource_len(btv
->c
.pci
,0));
4153 pci_set_drvdata(dev
,NULL
);
4157 static void __devexit
bttv_remove(struct pci_dev
*pci_dev
)
4159 struct bttv
*btv
= pci_get_drvdata(pci_dev
);
4162 printk("bttv%d: unloading\n",btv
->c
.nr
);
4164 /* shutdown everything (DMA+IRQs) */
4165 btand(~15, BT848_GPIO_DMA_CTL
);
4166 btwrite(0, BT848_INT_MASK
);
4167 btwrite(~0x0, BT848_INT_STAT
);
4168 btwrite(0x0, BT848_GPIO_OUT_EN
);
4170 bttv_gpio_tracking(btv
,"cleanup");
4172 /* tell gpio modules we are leaving ... */
4174 wake_up(&btv
->gpioq
);
4175 bttv_input_fini(btv
);
4176 bttv_sub_del_devices(&btv
->c
);
4178 /* unregister i2c_bus + input */
4181 /* unregister video4linux */
4182 bttv_unregister_video(btv
);
4184 /* free allocated memory */
4185 btcx_riscmem_free(btv
->c
.pci
,&btv
->main
);
4187 /* free ressources */
4188 free_irq(btv
->c
.pci
->irq
,btv
);
4189 iounmap(btv
->bt848_mmio
);
4190 release_mem_region(pci_resource_start(btv
->c
.pci
,0),
4191 pci_resource_len(btv
->c
.pci
,0));
4193 pci_set_drvdata(pci_dev
, NULL
);
4198 static int bttv_suspend(struct pci_dev
*pci_dev
, pm_message_t state
)
4200 struct bttv
*btv
= pci_get_drvdata(pci_dev
);
4201 struct bttv_buffer_set idle
;
4202 unsigned long flags
;
4204 dprintk("bttv%d: suspend %d\n", btv
->c
.nr
, state
.event
);
4206 /* stop dma + irqs */
4207 spin_lock_irqsave(&btv
->s_lock
,flags
);
4208 memset(&idle
, 0, sizeof(idle
));
4209 btv
->state
.video
= btv
->curr
;
4210 btv
->state
.vbi
= btv
->cvbi
;
4211 btv
->state
.loop_irq
= btv
->loop_irq
;
4214 bttv_buffer_activate_video(btv
, &idle
);
4215 bttv_buffer_activate_vbi(btv
, NULL
);
4216 bttv_set_dma(btv
, 0);
4217 btwrite(0, BT848_INT_MASK
);
4218 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
4220 /* save bt878 state */
4221 btv
->state
.gpio_enable
= btread(BT848_GPIO_OUT_EN
);
4222 btv
->state
.gpio_data
= gpio_read();
4224 /* save pci state */
4225 pci_save_state(pci_dev
);
4226 if (0 != pci_set_power_state(pci_dev
, pci_choose_state(pci_dev
, state
))) {
4227 pci_disable_device(pci_dev
);
4228 btv
->state
.disabled
= 1;
4233 static int bttv_resume(struct pci_dev
*pci_dev
)
4235 struct bttv
*btv
= pci_get_drvdata(pci_dev
);
4236 unsigned long flags
;
4239 dprintk("bttv%d: resume\n", btv
->c
.nr
);
4241 /* restore pci state */
4242 if (btv
->state
.disabled
) {
4243 err
=pci_enable_device(pci_dev
);
4245 printk(KERN_WARNING
"bttv%d: Can't enable device.\n",
4249 btv
->state
.disabled
= 0;
4251 err
=pci_set_power_state(pci_dev
, PCI_D0
);
4253 pci_disable_device(pci_dev
);
4254 printk(KERN_WARNING
"bttv%d: Can't enable device.\n",
4256 btv
->state
.disabled
= 1;
4260 pci_restore_state(pci_dev
);
4262 /* restore bt878 state */
4263 bttv_reinit_bt848(btv
);
4264 gpio_inout(0xffffff, btv
->state
.gpio_enable
);
4265 gpio_write(btv
->state
.gpio_data
);
4268 spin_lock_irqsave(&btv
->s_lock
,flags
);
4269 btv
->curr
= btv
->state
.video
;
4270 btv
->cvbi
= btv
->state
.vbi
;
4271 btv
->loop_irq
= btv
->state
.loop_irq
;
4272 bttv_buffer_activate_video(btv
, &btv
->curr
);
4273 bttv_buffer_activate_vbi(btv
, btv
->cvbi
);
4274 bttv_set_dma(btv
, 0);
4275 spin_unlock_irqrestore(&btv
->s_lock
,flags
);
4280 static struct pci_device_id bttv_pci_tbl
[] = {
4281 {PCI_VENDOR_ID_BROOKTREE
, PCI_DEVICE_ID_BT848
,
4282 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
4283 {PCI_VENDOR_ID_BROOKTREE
, PCI_DEVICE_ID_BT849
,
4284 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
4285 {PCI_VENDOR_ID_BROOKTREE
, PCI_DEVICE_ID_BT878
,
4286 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
4287 {PCI_VENDOR_ID_BROOKTREE
, PCI_DEVICE_ID_BT879
,
4288 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
4292 MODULE_DEVICE_TABLE(pci
, bttv_pci_tbl
);
4294 static struct pci_driver bttv_pci_driver
= {
4296 .id_table
= bttv_pci_tbl
,
4297 .probe
= bttv_probe
,
4298 .remove
= __devexit_p(bttv_remove
),
4300 .suspend
= bttv_suspend
,
4301 .resume
= bttv_resume
,
4305 static int bttv_init_module(void)
4311 printk(KERN_INFO
"bttv: driver version %d.%d.%d loaded\n",
4312 (BTTV_VERSION_CODE
>> 16) & 0xff,
4313 (BTTV_VERSION_CODE
>> 8) & 0xff,
4314 BTTV_VERSION_CODE
& 0xff);
4316 printk(KERN_INFO
"bttv: snapshot date %04d-%02d-%02d\n",
4317 SNAPSHOT
/10000, (SNAPSHOT
/100)%100, SNAPSHOT
%100);
4319 if (gbuffers
< 2 || gbuffers
> VIDEO_MAX_FRAME
)
4321 if (gbufsize
< 0 || gbufsize
> BTTV_MAX_FBUF
)
4322 gbufsize
= BTTV_MAX_FBUF
;
4323 gbufsize
= (gbufsize
+ PAGE_SIZE
- 1) & PAGE_MASK
;
4325 printk(KERN_INFO
"bttv: using %d buffers with %dk (%d pages) each for capture\n",
4326 gbuffers
, gbufsize
>> 10, gbufsize
>> PAGE_SHIFT
);
4328 bttv_check_chipset();
4330 ret
= bus_register(&bttv_sub_bus_type
);
4332 printk(KERN_WARNING
"bttv: bus_register error: %d\n", ret
);
4335 return pci_register_driver(&bttv_pci_driver
);
4338 static void bttv_cleanup_module(void)
4340 pci_unregister_driver(&bttv_pci_driver
);
4341 bus_unregister(&bttv_sub_bus_type
);
4345 module_init(bttv_init_module
);
4346 module_exit(bttv_cleanup_module
);