2 * Bt8xx based DVB adapter driver
4 * Copyright (C) 2002,2003 Florian Schirmer <jolt@tuxbox.org>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 #include <linux/bitops.h>
23 #include <linux/module.h>
24 #include <linux/moduleparam.h>
25 #include <linux/init.h>
26 #include <linux/device.h>
27 #include <linux/delay.h>
28 #include <linux/slab.h>
29 #include <linux/i2c.h>
33 #include "dvb_demux.h"
34 #include "dvb_frontend.h"
35 #include "dvb-bt8xx.h"
41 module_param(debug
, int, 0644);
42 MODULE_PARM_DESC(debug
, "Turn on/off debugging (default:off).");
44 #define dprintk( args... ) \
46 if (debug) printk(KERN_DEBUG args); \
49 #define IF_FREQUENCYx6 217 /* 6 * 36.16666666667MHz */
51 static void dvb_bt8xx_task(unsigned long data
)
53 struct dvb_bt8xx_card
*card
= (struct dvb_bt8xx_card
*)data
;
55 //printk("%d ", card->bt->finished_block);
57 while (card
->bt
->last_block
!= card
->bt
->finished_block
) {
58 (card
->bt
->TS_Size
? dvb_dmx_swfilter_204
: dvb_dmx_swfilter
)
60 &card
->bt
->buf_cpu
[card
->bt
->last_block
*
61 card
->bt
->block_bytes
],
62 card
->bt
->block_bytes
);
63 card
->bt
->last_block
= (card
->bt
->last_block
+ 1) %
64 card
->bt
->block_count
;
68 static int dvb_bt8xx_start_feed(struct dvb_demux_feed
*dvbdmxfeed
)
70 struct dvb_demux
*dvbdmx
= dvbdmxfeed
->demux
;
71 struct dvb_bt8xx_card
*card
= dvbdmx
->priv
;
74 dprintk("dvb_bt8xx: start_feed\n");
76 if (!dvbdmx
->dmx
.frontend
)
79 mutex_lock(&card
->lock
);
82 if (card
->nfeeds
== 1)
83 bt878_start(card
->bt
, card
->gpio_mode
,
84 card
->op_sync_orin
, card
->irq_err_ignore
);
85 mutex_unlock(&card
->lock
);
89 static int dvb_bt8xx_stop_feed(struct dvb_demux_feed
*dvbdmxfeed
)
91 struct dvb_demux
*dvbdmx
= dvbdmxfeed
->demux
;
92 struct dvb_bt8xx_card
*card
= dvbdmx
->priv
;
94 dprintk("dvb_bt8xx: stop_feed\n");
96 if (!dvbdmx
->dmx
.frontend
)
99 mutex_lock(&card
->lock
);
101 if (card
->nfeeds
== 0)
102 bt878_stop(card
->bt
);
103 mutex_unlock(&card
->lock
);
108 static int is_pci_slot_eq(struct pci_dev
* adev
, struct pci_dev
* bdev
)
110 if ((adev
->subsystem_vendor
== bdev
->subsystem_vendor
) &&
111 (adev
->subsystem_device
== bdev
->subsystem_device
) &&
112 (adev
->bus
->number
== bdev
->bus
->number
) &&
113 (PCI_SLOT(adev
->devfn
) == PCI_SLOT(bdev
->devfn
)))
118 static struct bt878 __init
*dvb_bt8xx_878_match(unsigned int bttv_nr
, struct pci_dev
* bttv_pci_dev
)
120 unsigned int card_nr
;
122 /* Hmm, n squared. Hope n is small */
123 for (card_nr
= 0; card_nr
< bt878_num
; card_nr
++)
124 if (is_pci_slot_eq(bt878
[card_nr
].dev
, bttv_pci_dev
))
125 return &bt878
[card_nr
];
129 static int thomson_dtt7579_demod_init(struct dvb_frontend
* fe
)
131 static u8 mt352_clock_config
[] = { 0x89, 0x38, 0x38 };
132 static u8 mt352_reset
[] = { 0x50, 0x80 };
133 static u8 mt352_adc_ctl_1_cfg
[] = { 0x8E, 0x40 };
134 static u8 mt352_agc_cfg
[] = { 0x67, 0x28, 0x20 };
135 static u8 mt352_gpp_ctl_cfg
[] = { 0x8C, 0x33 };
136 static u8 mt352_capt_range_cfg
[] = { 0x75, 0x32 };
138 mt352_write(fe
, mt352_clock_config
, sizeof(mt352_clock_config
));
140 mt352_write(fe
, mt352_reset
, sizeof(mt352_reset
));
141 mt352_write(fe
, mt352_adc_ctl_1_cfg
, sizeof(mt352_adc_ctl_1_cfg
));
143 mt352_write(fe
, mt352_agc_cfg
, sizeof(mt352_agc_cfg
));
144 mt352_write(fe
, mt352_gpp_ctl_cfg
, sizeof(mt352_gpp_ctl_cfg
));
145 mt352_write(fe
, mt352_capt_range_cfg
, sizeof(mt352_capt_range_cfg
));
150 static int thomson_dtt7579_pll_set(struct dvb_frontend
* fe
, struct dvb_frontend_parameters
* params
, u8
* pllbuf
)
153 unsigned char bs
= 0;
154 unsigned char cp
= 0;
156 div
= (((params
->frequency
+ 83333) * 3) / 500000) + IF_FREQUENCYx6
;
158 if (params
->frequency
< 542000000)
160 else if (params
->frequency
< 771000000)
165 if (params
->frequency
== 0)
167 else if (params
->frequency
< 443250000)
172 pllbuf
[0] = 0xc0; // Note: non-linux standard PLL i2c address
173 pllbuf
[1] = div
>> 8;
174 pllbuf
[2] = div
& 0xff;
181 static struct mt352_config thomson_dtt7579_config
= {
182 .demod_address
= 0x0f,
183 .demod_init
= thomson_dtt7579_demod_init
,
184 .pll_set
= thomson_dtt7579_pll_set
,
187 static int cx24108_pll_set(struct dvb_frontend
* fe
, struct dvb_frontend_parameters
* params
)
189 u32 freq
= params
->frequency
;
194 u32 osci
[]={950000,1019000,1075000,1178000,1296000,1432000,
195 1576000,1718000,1856000,2036000,2150000};
196 u32 bandsel
[]={0,0x00020000,0x00040000,0x00100800,0x00101000,
197 0x00102000,0x00104000,0x00108000,0x00110000,
198 0x00120000,0x00140000};
200 #define XTAL 1011100 /* Hz, really 1.0111 MHz and a /10 prescaler */
201 printk("cx24108 debug: entering SetTunerFreq, freq=%d\n",freq
);
203 /* This is really the bit driving the tuner chip cx24108 */
206 freq
= 950000; /* kHz */
207 else if (freq
>2150000)
208 freq
= 2150000; /* satellite IF is 950..2150MHz */
210 /* decide which VCO to use for the input frequency */
211 for(i
=1;(i
<sizeof(osci
)/sizeof(osci
[0]))&&(osci
[i
]<freq
);i
++);
212 printk("cx24108 debug: select vco #%d (f=%d)\n",i
,freq
);
214 /* the gain values must be set by SetSymbolrate */
215 /* compute the pll divider needed, from Conexant data sheet,
216 resolved for (n*32+a), remember f(vco) is f(receive) *2 or *4,
217 depending on the divider bit. It is set to /4 on the 2 lowest
219 n
=((i
<=2?2:1)*freq
*10L)/(XTAL
/100);
220 a
=n
%32; n
/=32; if(a
==0) n
--;
221 pump
=(freq
<(osci
[i
-1]+osci
[i
])/2);
223 ((pump
?1:2)<<(14+11))|
226 /* everything is shifted left 11 bits to left-align the bits in the
227 32bit word. Output to the tuner goes MSB-aligned, after all */
228 printk("cx24108 debug: pump=%d, n=%d, a=%d\n",pump
,n
,a
);
229 cx24110_pll_write(fe
,band
);
230 /* set vga and vca to their widest-band settings, as a precaution.
231 SetSymbolrate might not be called to set this up */
232 cx24110_pll_write(fe
,0x500c0000);
233 cx24110_pll_write(fe
,0x83f1f800);
234 cx24110_pll_write(fe
,pll
);
235 //writereg(client,0x56,0x7f);
240 static int pinnsat_pll_init(struct dvb_frontend
* fe
)
242 struct dvb_bt8xx_card
*card
= fe
->dvb
->priv
;
244 bttv_gpio_enable(card
->bttv_nr
, 1, 1); /* output */
245 bttv_write_gpio(card
->bttv_nr
, 1, 1); /* relay on */
250 static int pinnsat_pll_sleep(struct dvb_frontend
* fe
)
252 struct dvb_bt8xx_card
*card
= fe
->dvb
->priv
;
254 bttv_write_gpio(card
->bttv_nr
, 1, 0); /* relay off */
259 static struct cx24110_config pctvsat_config
= {
260 .demod_address
= 0x55,
261 .pll_init
= pinnsat_pll_init
,
262 .pll_set
= cx24108_pll_set
,
263 .pll_sleep
= pinnsat_pll_sleep
,
266 static int microtune_mt7202dtf_pll_set(struct dvb_frontend
* fe
, struct dvb_frontend_parameters
* params
)
268 struct dvb_bt8xx_card
*card
= (struct dvb_bt8xx_card
*) fe
->dvb
->priv
;
269 u8 cfg
, cpump
, band_select
;
272 struct i2c_msg msg
= { .addr
= 0x60, .flags
= 0, .buf
= data
, .len
= sizeof(data
) };
274 div
= (36000000 + params
->frequency
+ 83333) / 166666;
277 if (params
->frequency
< 175000000)
279 else if (params
->frequency
< 390000000)
281 else if (params
->frequency
< 470000000)
283 else if (params
->frequency
< 750000000)
288 if (params
->frequency
< 175000000)
290 else if (params
->frequency
< 470000000)
295 data
[0] = (div
>> 8) & 0x7f;
296 data
[1] = div
& 0xff;
297 data
[2] = ((div
>> 10) & 0x60) | cfg
;
298 data
[3] = (cpump
<< 6) | band_select
;
300 i2c_transfer(card
->i2c_adapter
, &msg
, 1);
301 return (div
* 166666 - 36000000);
304 static int microtune_mt7202dtf_request_firmware(struct dvb_frontend
* fe
, const struct firmware
**fw
, char* name
)
306 struct dvb_bt8xx_card
* bt
= (struct dvb_bt8xx_card
*) fe
->dvb
->priv
;
308 return request_firmware(fw
, name
, &bt
->bt
->dev
->dev
);
311 static struct sp887x_config microtune_mt7202dtf_config
= {
312 .demod_address
= 0x70,
313 .pll_set
= microtune_mt7202dtf_pll_set
,
314 .request_firmware
= microtune_mt7202dtf_request_firmware
,
317 static int advbt771_samsung_tdtc9251dh0_demod_init(struct dvb_frontend
* fe
)
319 static u8 mt352_clock_config
[] = { 0x89, 0x38, 0x2d };
320 static u8 mt352_reset
[] = { 0x50, 0x80 };
321 static u8 mt352_adc_ctl_1_cfg
[] = { 0x8E, 0x40 };
322 static u8 mt352_agc_cfg
[] = { 0x67, 0x10, 0x23, 0x00, 0xFF, 0xFF,
323 0x00, 0xFF, 0x00, 0x40, 0x40 };
324 static u8 mt352_av771_extra
[] = { 0xB5, 0x7A };
325 static u8 mt352_capt_range_cfg
[] = { 0x75, 0x32 };
327 mt352_write(fe
, mt352_clock_config
, sizeof(mt352_clock_config
));
329 mt352_write(fe
, mt352_reset
, sizeof(mt352_reset
));
330 mt352_write(fe
, mt352_adc_ctl_1_cfg
, sizeof(mt352_adc_ctl_1_cfg
));
332 mt352_write(fe
, mt352_agc_cfg
,sizeof(mt352_agc_cfg
));
334 mt352_write(fe
, mt352_av771_extra
,sizeof(mt352_av771_extra
));
335 mt352_write(fe
, mt352_capt_range_cfg
, sizeof(mt352_capt_range_cfg
));
340 static int advbt771_samsung_tdtc9251dh0_pll_set(struct dvb_frontend
* fe
, struct dvb_frontend_parameters
* params
, u8
* pllbuf
)
343 unsigned char bs
= 0;
344 unsigned char cp
= 0;
346 div
= (((params
->frequency
+ 83333) * 3) / 500000) + IF_FREQUENCYx6
;
348 if (params
->frequency
< 150000000)
350 else if (params
->frequency
< 173000000)
352 else if (params
->frequency
< 250000000)
354 else if (params
->frequency
< 400000000)
356 else if (params
->frequency
< 420000000)
358 else if (params
->frequency
< 470000000)
360 else if (params
->frequency
< 600000000)
362 else if (params
->frequency
< 730000000)
367 if (params
->frequency
< 150000000)
369 else if (params
->frequency
< 173000000)
371 else if (params
->frequency
< 250000000)
373 else if (params
->frequency
< 400000000)
375 else if (params
->frequency
< 420000000)
377 else if (params
->frequency
< 470000000)
379 else if (params
->frequency
< 600000000)
381 else if (params
->frequency
< 730000000)
386 pllbuf
[0] = 0xc2; // Note: non-linux standard PLL i2c address
387 pllbuf
[1] = div
>> 8;
388 pllbuf
[2] = div
& 0xff;
395 static struct mt352_config advbt771_samsung_tdtc9251dh0_config
= {
396 .demod_address
= 0x0f,
397 .demod_init
= advbt771_samsung_tdtc9251dh0_demod_init
,
398 .pll_set
= advbt771_samsung_tdtc9251dh0_pll_set
,
401 static struct dst_config dst_config
= {
402 .demod_address
= 0x55,
405 static int or51211_request_firmware(struct dvb_frontend
* fe
, const struct firmware
**fw
, char* name
)
407 struct dvb_bt8xx_card
* bt
= (struct dvb_bt8xx_card
*) fe
->dvb
->priv
;
409 return request_firmware(fw
, name
, &bt
->bt
->dev
->dev
);
412 static void or51211_setmode(struct dvb_frontend
* fe
, int mode
)
414 struct dvb_bt8xx_card
*bt
= fe
->dvb
->priv
;
415 bttv_write_gpio(bt
->bttv_nr
, 0x0002, mode
); /* Reset */
419 static void or51211_reset(struct dvb_frontend
* fe
)
421 struct dvb_bt8xx_card
*bt
= fe
->dvb
->priv
;
424 * reset is controled by GPIO-0
425 * when set to 0 causes reset and when to 1 for normal op
426 * must remain reset for 128 clock cycles on a 50Mhz clock
427 * also PRM1 PRM2 & PRM4 are controled by GPIO-1,GPIO-2 & GPIO-4
428 * We assume that the reset has be held low long enough or we
429 * have been reset by a power on. When the driver is unloaded
430 * reset set to 0 so if reloaded we have been reset.
432 /* reset & PRM1,2&4 are outputs */
433 int ret
= bttv_gpio_enable(bt
->bttv_nr
, 0x001F, 0x001F);
435 printk(KERN_WARNING
"or51211: Init Error - Can't Reset DVR (%i)\n", ret
);
436 bttv_write_gpio(bt
->bttv_nr
, 0x001F, 0x0000); /* Reset */
438 /* Now set for normal operation */
439 bttv_write_gpio(bt
->bttv_nr
, 0x0001F, 0x0001);
440 /* wait for operation to begin */
444 static void or51211_sleep(struct dvb_frontend
* fe
)
446 struct dvb_bt8xx_card
*bt
= fe
->dvb
->priv
;
447 bttv_write_gpio(bt
->bttv_nr
, 0x0001, 0x0000);
450 static struct or51211_config or51211_config
= {
451 .demod_address
= 0x15,
452 .request_firmware
= or51211_request_firmware
,
453 .setmode
= or51211_setmode
,
454 .reset
= or51211_reset
,
455 .sleep
= or51211_sleep
,
458 static int vp3021_alps_tded4_pll_set(struct dvb_frontend
* fe
, struct dvb_frontend_parameters
* params
)
460 struct dvb_bt8xx_card
*card
= (struct dvb_bt8xx_card
*) fe
->dvb
->priv
;
463 struct i2c_msg msg
= { .addr
= 0x60, .flags
= 0, .buf
= buf
, .len
= sizeof(buf
) };
465 div
= (params
->frequency
+ 36166667) / 166667;
467 buf
[0] = (div
>> 8) & 0x7F;
470 if ((params
->frequency
>= 47000000) && (params
->frequency
< 153000000))
472 else if ((params
->frequency
>= 153000000) && (params
->frequency
< 430000000))
474 else if ((params
->frequency
>= 430000000) && (params
->frequency
< 824000000))
476 else if ((params
->frequency
>= 824000000) && (params
->frequency
< 863000000))
481 i2c_transfer(card
->i2c_adapter
, &msg
, 1);
485 static struct nxt6000_config vp3021_alps_tded4_config
= {
486 .demod_address
= 0x0a,
487 .clock_inversion
= 1,
488 .pll_set
= vp3021_alps_tded4_pll_set
,
491 static int digitv_alps_tded4_demod_init(struct dvb_frontend
* fe
)
493 static u8 mt352_clock_config
[] = { 0x89, 0x38, 0x2d };
494 static u8 mt352_reset
[] = { 0x50, 0x80 };
495 static u8 mt352_adc_ctl_1_cfg
[] = { 0x8E, 0x40 };
496 static u8 mt352_agc_cfg
[] = { 0x67, 0x20, 0xa0 };
497 static u8 mt352_capt_range_cfg
[] = { 0x75, 0x32 };
499 mt352_write(fe
, mt352_clock_config
, sizeof(mt352_clock_config
));
501 mt352_write(fe
, mt352_reset
, sizeof(mt352_reset
));
502 mt352_write(fe
, mt352_adc_ctl_1_cfg
, sizeof(mt352_adc_ctl_1_cfg
));
503 mt352_write(fe
, mt352_agc_cfg
,sizeof(mt352_agc_cfg
));
504 mt352_write(fe
, mt352_capt_range_cfg
, sizeof(mt352_capt_range_cfg
));
509 static int digitv_alps_tded4_pll_set(struct dvb_frontend
* fe
, struct dvb_frontend_parameters
* params
, u8
* pllbuf
)
512 struct dvb_ofdm_parameters
*op
= ¶ms
->u
.ofdm
;
514 div
= (((params
->frequency
+ 83333) * 3) / 500000) + IF_FREQUENCYx6
;
517 pllbuf
[1] = (div
>> 8) & 0x7F;
518 pllbuf
[2] = div
& 0xFF;
521 dprintk("frequency %u, div %u\n", params
->frequency
, div
);
523 if (params
->frequency
< 470000000)
525 else if (params
->frequency
> 823000000)
530 if (op
->bandwidth
== 8)
536 static void digitv_alps_tded4_reset(struct dvb_bt8xx_card
*bt
)
539 * Reset the frontend, must be called before trying
540 * to initialise the MT352 or mt352_attach
541 * will fail. Same goes for the nxt6000 frontend.
545 int ret
= bttv_gpio_enable(bt
->bttv_nr
, 0x08, 0x08);
547 printk(KERN_WARNING
"digitv_alps_tded4: Init Error - Can't Reset DVR (%i)\n", ret
);
549 /* Pulse the reset line */
550 bttv_write_gpio(bt
->bttv_nr
, 0x08, 0x08); /* High */
551 bttv_write_gpio(bt
->bttv_nr
, 0x08, 0x00); /* Low */
554 bttv_write_gpio(bt
->bttv_nr
, 0x08, 0x08); /* High */
557 static struct mt352_config digitv_alps_tded4_config
= {
558 .demod_address
= 0x0a,
559 .demod_init
= digitv_alps_tded4_demod_init
,
560 .pll_set
= digitv_alps_tded4_pll_set
,
563 static int tdvs_tua6034_pll_set(struct dvb_frontend
* fe
, struct dvb_frontend_parameters
* params
)
565 struct dvb_bt8xx_card
*card
= (struct dvb_bt8xx_card
*) fe
->dvb
->priv
;
567 struct i2c_msg msg
= { .addr
= 0x61, .flags
= 0, .buf
= buf
, .len
= sizeof(buf
) };
570 dvb_pll_configure(&dvb_pll_tdvs_tua6034
, buf
, params
->frequency
, 0);
571 dprintk("%s: tuner at 0x%02x bytes: 0x%02x 0x%02x 0x%02x 0x%02x\n",
572 __FUNCTION__
, msg
.addr
, buf
[0],buf
[1],buf
[2],buf
[3]);
573 if ((err
= i2c_transfer(card
->i2c_adapter
, &msg
, 1)) != 1) {
574 printk(KERN_WARNING
"dvb-bt8xx: %s error "
575 "(addr %02x <- %02x, err = %i)\n",
576 __FUNCTION__
, buf
[0], buf
[1], err
);
583 /* Set the Auxiliary Byte. */
587 i2c_transfer(card
->i2c_adapter
, &msg
, 1);
592 static struct lgdt330x_config tdvs_tua6034_config
= {
593 .demod_address
= 0x0e,
594 .demod_chip
= LGDT3303
,
595 .serial_mpeg
= 0x40, /* TPSERIAL for 3303 in TOP_CONTROL */
596 .pll_set
= tdvs_tua6034_pll_set
,
599 static void lgdt330x_reset(struct dvb_bt8xx_card
*bt
)
601 /* Set pin 27 of the lgdt3303 chip high to reset the frontend */
603 /* Pulse the reset line */
604 bttv_write_gpio(bt
->bttv_nr
, 0x00e00007, 0x00000001); /* High */
605 bttv_write_gpio(bt
->bttv_nr
, 0x00e00007, 0x00000000); /* Low */
608 bttv_write_gpio(bt
->bttv_nr
, 0x00e00007, 0x00000001); /* High */
612 static void frontend_init(struct dvb_bt8xx_card
*card
, u32 type
)
615 struct dst_state
* state
= NULL
;
618 case BTTV_BOARD_DVICO_DVBT_LITE
:
619 card
->fe
= mt352_attach(&thomson_dtt7579_config
, card
->i2c_adapter
);
620 if (card
->fe
!= NULL
) {
621 card
->fe
->ops
->info
.frequency_min
= 174000000;
622 card
->fe
->ops
->info
.frequency_max
= 862000000;
626 case BTTV_BOARD_DVICO_FUSIONHDTV_5_LITE
:
627 lgdt330x_reset(card
);
628 card
->fe
= lgdt330x_attach(&tdvs_tua6034_config
, card
->i2c_adapter
);
629 if (card
->fe
!= NULL
)
630 dprintk ("dvb_bt8xx: lgdt330x detected\n");
633 case BTTV_BOARD_NEBULA_DIGITV
:
635 * It is possible to determine the correct frontend using the I2C bus (see the Nebula SDK);
636 * this would be a cleaner solution than trying each frontend in turn.
639 /* Old Nebula (marked (c)2003 on high profile pci card) has nxt6000 demod */
640 digitv_alps_tded4_reset(card
);
641 card
->fe
= nxt6000_attach(&vp3021_alps_tded4_config
, card
->i2c_adapter
);
642 if (card
->fe
!= NULL
) {
643 dprintk ("dvb_bt8xx: an nxt6000 was detected on your digitv card\n");
647 /* New Nebula (marked (c)2005 on low profile pci card) has mt352 demod */
648 digitv_alps_tded4_reset(card
);
649 card
->fe
= mt352_attach(&digitv_alps_tded4_config
, card
->i2c_adapter
);
651 if (card
->fe
!= NULL
)
652 dprintk ("dvb_bt8xx: an mt352 was detected on your digitv card\n");
655 case BTTV_BOARD_AVDVBT_761
:
656 card
->fe
= sp887x_attach(µtune_mt7202dtf_config
, card
->i2c_adapter
);
659 case BTTV_BOARD_AVDVBT_771
:
660 card
->fe
= mt352_attach(&advbt771_samsung_tdtc9251dh0_config
, card
->i2c_adapter
);
661 if (card
->fe
!= NULL
) {
662 card
->fe
->ops
->info
.frequency_min
= 174000000;
663 card
->fe
->ops
->info
.frequency_max
= 862000000;
667 case BTTV_BOARD_TWINHAN_DST
:
668 /* DST is not a frontend driver !!! */
669 state
= (struct dst_state
*) kmalloc(sizeof (struct dst_state
), GFP_KERNEL
);
671 state
->config
= &dst_config
;
672 state
->i2c
= card
->i2c_adapter
;
673 state
->bt
= card
->bt
;
675 /* DST is not a frontend, attaching the ASIC */
676 if ((dst_attach(state
, &card
->dvb_adapter
)) == NULL
) {
677 printk("%s: Could not find a Twinhan DST.\n", __FUNCTION__
);
680 card
->fe
= &state
->frontend
;
682 /* Attach other DST peripherals if any */
683 /* Conditional Access device */
684 if (state
->dst_hw_cap
& DST_TYPE_HAS_CA
)
685 ret
= dst_ca_attach(state
, &card
->dvb_adapter
);
688 case BTTV_BOARD_PINNACLESAT
:
689 card
->fe
= cx24110_attach(&pctvsat_config
, card
->i2c_adapter
);
692 case BTTV_BOARD_PC_HDTV
:
693 card
->fe
= or51211_attach(&or51211_config
, card
->i2c_adapter
);
697 if (card
->fe
== NULL
)
698 printk("dvb-bt8xx: A frontend driver was not found for device %04x/%04x subsystem %04x/%04x\n",
699 card
->bt
->dev
->vendor
,
700 card
->bt
->dev
->device
,
701 card
->bt
->dev
->subsystem_vendor
,
702 card
->bt
->dev
->subsystem_device
);
704 if (dvb_register_frontend(&card
->dvb_adapter
, card
->fe
)) {
705 printk("dvb-bt8xx: Frontend registration failed!\n");
706 if (card
->fe
->ops
->release
)
707 card
->fe
->ops
->release(card
->fe
);
712 static int __init
dvb_bt8xx_load_card(struct dvb_bt8xx_card
*card
, u32 type
)
716 if ((result
= dvb_register_adapter(&card
->dvb_adapter
, card
->card_name
, THIS_MODULE
)) < 0) {
717 printk("dvb_bt8xx: dvb_register_adapter failed (errno = %d)\n", result
);
720 card
->dvb_adapter
.priv
= card
;
722 card
->bt
->adapter
= card
->i2c_adapter
;
724 memset(&card
->demux
, 0, sizeof(struct dvb_demux
));
726 card
->demux
.dmx
.capabilities
= DMX_TS_FILTERING
| DMX_SECTION_FILTERING
| DMX_MEMORY_BASED_FILTERING
;
728 card
->demux
.priv
= card
;
729 card
->demux
.filternum
= 256;
730 card
->demux
.feednum
= 256;
731 card
->demux
.start_feed
= dvb_bt8xx_start_feed
;
732 card
->demux
.stop_feed
= dvb_bt8xx_stop_feed
;
733 card
->demux
.write_to_decoder
= NULL
;
735 if ((result
= dvb_dmx_init(&card
->demux
)) < 0) {
736 printk("dvb_bt8xx: dvb_dmx_init failed (errno = %d)\n", result
);
738 dvb_unregister_adapter(&card
->dvb_adapter
);
742 card
->dmxdev
.filternum
= 256;
743 card
->dmxdev
.demux
= &card
->demux
.dmx
;
744 card
->dmxdev
.capabilities
= 0;
746 if ((result
= dvb_dmxdev_init(&card
->dmxdev
, &card
->dvb_adapter
)) < 0) {
747 printk("dvb_bt8xx: dvb_dmxdev_init failed (errno = %d)\n", result
);
749 dvb_dmx_release(&card
->demux
);
750 dvb_unregister_adapter(&card
->dvb_adapter
);
754 card
->fe_hw
.source
= DMX_FRONTEND_0
;
756 if ((result
= card
->demux
.dmx
.add_frontend(&card
->demux
.dmx
, &card
->fe_hw
)) < 0) {
757 printk("dvb_bt8xx: dvb_dmx_init failed (errno = %d)\n", result
);
759 dvb_dmxdev_release(&card
->dmxdev
);
760 dvb_dmx_release(&card
->demux
);
761 dvb_unregister_adapter(&card
->dvb_adapter
);
765 card
->fe_mem
.source
= DMX_MEMORY_FE
;
767 if ((result
= card
->demux
.dmx
.add_frontend(&card
->demux
.dmx
, &card
->fe_mem
)) < 0) {
768 printk("dvb_bt8xx: dvb_dmx_init failed (errno = %d)\n", result
);
770 card
->demux
.dmx
.remove_frontend(&card
->demux
.dmx
, &card
->fe_hw
);
771 dvb_dmxdev_release(&card
->dmxdev
);
772 dvb_dmx_release(&card
->demux
);
773 dvb_unregister_adapter(&card
->dvb_adapter
);
777 if ((result
= card
->demux
.dmx
.connect_frontend(&card
->demux
.dmx
, &card
->fe_hw
)) < 0) {
778 printk("dvb_bt8xx: dvb_dmx_init failed (errno = %d)\n", result
);
780 card
->demux
.dmx
.remove_frontend(&card
->demux
.dmx
, &card
->fe_mem
);
781 card
->demux
.dmx
.remove_frontend(&card
->demux
.dmx
, &card
->fe_hw
);
782 dvb_dmxdev_release(&card
->dmxdev
);
783 dvb_dmx_release(&card
->demux
);
784 dvb_unregister_adapter(&card
->dvb_adapter
);
788 dvb_net_init(&card
->dvb_adapter
, &card
->dvbnet
, &card
->demux
.dmx
);
790 tasklet_init(&card
->bt
->tasklet
, dvb_bt8xx_task
, (unsigned long) card
);
792 frontend_init(card
, type
);
797 static int dvb_bt8xx_probe(struct bttv_sub_device
*sub
)
799 struct dvb_bt8xx_card
*card
;
800 struct pci_dev
* bttv_pci_dev
;
803 if (!(card
= kzalloc(sizeof(struct dvb_bt8xx_card
), GFP_KERNEL
)))
806 mutex_init(&card
->lock
);
807 card
->bttv_nr
= sub
->core
->nr
;
808 strncpy(card
->card_name
, sub
->core
->name
, sizeof(sub
->core
->name
));
809 card
->i2c_adapter
= &sub
->core
->i2c_adap
;
811 switch(sub
->core
->type
) {
812 case BTTV_BOARD_PINNACLESAT
:
813 card
->gpio_mode
= 0x0400c060;
814 /* should be: BT878_A_GAIN=0,BT878_A_PWRDN,BT878_DA_DPM,BT878_DA_SBR,
815 BT878_DA_IOM=1,BT878_DA_APP to enable serial highspeed mode. */
816 card
->op_sync_orin
= BT878_RISC_SYNC_MASK
;
817 card
->irq_err_ignore
= BT878_AFBUS
| BT878_AFDSR
;
820 case BTTV_BOARD_DVICO_DVBT_LITE
:
821 card
->gpio_mode
= 0x0400C060;
822 card
->op_sync_orin
= BT878_RISC_SYNC_MASK
;
823 card
->irq_err_ignore
= BT878_AFBUS
| BT878_AFDSR
;
825 * A_PWRDN DA_DPM DA_SBR DA_IOM_DA
826 * DA_APP(parallel) */
829 case BTTV_BOARD_DVICO_FUSIONHDTV_5_LITE
:
830 card
->gpio_mode
= 0x0400c060;
831 card
->op_sync_orin
= BT878_RISC_SYNC_MASK
;
832 card
->irq_err_ignore
= BT878_AFBUS
| BT878_AFDSR
;
835 case BTTV_BOARD_NEBULA_DIGITV
:
836 case BTTV_BOARD_AVDVBT_761
:
837 card
->gpio_mode
= (1 << 26) | (1 << 14) | (1 << 5);
838 card
->op_sync_orin
= BT878_RISC_SYNC_MASK
;
839 card
->irq_err_ignore
= BT878_AFBUS
| BT878_AFDSR
;
840 /* A_PWRDN DA_SBR DA_APP (high speed serial) */
843 case BTTV_BOARD_AVDVBT_771
: //case 0x07711461:
844 card
->gpio_mode
= 0x0400402B;
845 card
->op_sync_orin
= BT878_RISC_SYNC_MASK
;
846 card
->irq_err_ignore
= BT878_AFBUS
| BT878_AFDSR
;
847 /* A_PWRDN DA_SBR DA_APP[0] PKTP=10 RISC_ENABLE FIFO_ENABLE*/
850 case BTTV_BOARD_TWINHAN_DST
:
851 card
->gpio_mode
= 0x2204f2c;
852 card
->op_sync_orin
= BT878_RISC_SYNC_MASK
;
853 card
->irq_err_ignore
= BT878_APABORT
| BT878_ARIPERR
|
854 BT878_APPERR
| BT878_AFBUS
;
855 /* 25,21,14,11,10,9,8,3,2 then
857 * A_SEL=SML, DA_MLB, DA_SBR,
858 * DA_SDR=f, fifo trigger = 32 DWORDS
859 * IOM = 0 == audio A/D
860 * DPM = 0 == digital audio mode
861 * == async data parallel port
862 * then 0x33 (13 is set by start_capture)
863 * DA_APP = async data parallel port,
865 * RISC+FIFO ENABLE */
868 case BTTV_BOARD_PC_HDTV
:
869 card
->gpio_mode
= 0x0100EC7B;
870 card
->op_sync_orin
= BT878_RISC_SYNC_MASK
;
871 card
->irq_err_ignore
= BT878_AFBUS
| BT878_AFDSR
;
875 printk(KERN_WARNING
"dvb_bt8xx: Unknown bttv card type: %d.\n",
881 dprintk("dvb_bt8xx: identified card%d as %s\n", card
->bttv_nr
, card
->card_name
);
883 if (!(bttv_pci_dev
= bttv_get_pcidev(card
->bttv_nr
))) {
884 printk("dvb_bt8xx: no pci device for card %d\n", card
->bttv_nr
);
889 if (!(card
->bt
= dvb_bt8xx_878_match(card
->bttv_nr
, bttv_pci_dev
))) {
890 printk("dvb_bt8xx: unable to determine DMA core of card %d,\n",
892 printk("dvb_bt8xx: if you have the ALSA bt87x audio driver "
893 "installed, try removing it.\n");
899 mutex_init(&card
->bt
->gpio_lock
);
900 card
->bt
->bttv_nr
= sub
->core
->nr
;
902 if ( (ret
= dvb_bt8xx_load_card(card
, sub
->core
->type
)) ) {
907 dev_set_drvdata(&sub
->dev
, card
);
911 static void dvb_bt8xx_remove(struct bttv_sub_device
*sub
)
913 struct dvb_bt8xx_card
*card
= dev_get_drvdata(&sub
->dev
);
915 dprintk("dvb_bt8xx: unloading card%d\n", card
->bttv_nr
);
917 bt878_stop(card
->bt
);
918 tasklet_kill(&card
->bt
->tasklet
);
919 dvb_net_release(&card
->dvbnet
);
920 card
->demux
.dmx
.remove_frontend(&card
->demux
.dmx
, &card
->fe_mem
);
921 card
->demux
.dmx
.remove_frontend(&card
->demux
.dmx
, &card
->fe_hw
);
922 dvb_dmxdev_release(&card
->dmxdev
);
923 dvb_dmx_release(&card
->demux
);
925 dvb_unregister_frontend(card
->fe
);
926 dvb_unregister_adapter(&card
->dvb_adapter
);
931 static struct bttv_sub_driver driver
= {
935 .probe
= dvb_bt8xx_probe
,
936 .remove
= dvb_bt8xx_remove
,
938 * .shutdown = dvb_bt8xx_shutdown,
939 * .suspend = dvb_bt8xx_suspend,
940 * .resume = dvb_bt8xx_resume,
944 static int __init
dvb_bt8xx_init(void)
946 return bttv_sub_register(&driver
, "dvb");
949 static void __exit
dvb_bt8xx_exit(void)
951 bttv_sub_unregister(&driver
);
954 module_init(dvb_bt8xx_init
);
955 module_exit(dvb_bt8xx_exit
);
957 MODULE_DESCRIPTION("Bt8xx based DVB adapter driver");
958 MODULE_AUTHOR("Florian Schirmer <jolt@tuxbox.org>");
959 MODULE_LICENSE("GPL");