Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Bt8xx based DVB adapter driver
0004  *
0005  * Copyright (C) 2002,2003 Florian Schirmer <jolt@tuxbox.org>
0006  */
0007 
0008 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0009 
0010 #include <linux/bitops.h>
0011 #include <linux/module.h>
0012 #include <linux/init.h>
0013 #include <linux/kernel.h>
0014 #include <linux/device.h>
0015 #include <linux/delay.h>
0016 #include <linux/slab.h>
0017 #include <linux/i2c.h>
0018 
0019 #include <media/dmxdev.h>
0020 #include <media/dvbdev.h>
0021 #include <media/dvb_demux.h>
0022 #include <media/dvb_frontend.h>
0023 #include "dvb-bt8xx.h"
0024 #include "bt878.h"
0025 
0026 static int debug;
0027 
0028 module_param(debug, int, 0644);
0029 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
0030 
0031 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
0032 
0033 #define dprintk(fmt, arg...) do {               \
0034     if (debug)                      \
0035         printk(KERN_DEBUG pr_fmt("%s: " fmt),       \
0036                __func__, ##arg);            \
0037 } while (0)
0038 
0039 
0040 #define IF_FREQUENCYx6 217    /* 6 * 36.16666666667MHz */
0041 
0042 static void dvb_bt8xx_task(struct tasklet_struct *t)
0043 {
0044     struct bt878 *bt = from_tasklet(bt, t, tasklet);
0045     struct dvb_bt8xx_card *card = dev_get_drvdata(&bt->adapter->dev);
0046 
0047     dprintk("%d\n", card->bt->finished_block);
0048 
0049     while (card->bt->last_block != card->bt->finished_block) {
0050         (card->bt->TS_Size ? dvb_dmx_swfilter_204 : dvb_dmx_swfilter)
0051             (&card->demux,
0052              &card->bt->buf_cpu[card->bt->last_block *
0053                         card->bt->block_bytes],
0054              card->bt->block_bytes);
0055         card->bt->last_block = (card->bt->last_block + 1) %
0056                     card->bt->block_count;
0057     }
0058 }
0059 
0060 static int dvb_bt8xx_start_feed(struct dvb_demux_feed *dvbdmxfeed)
0061 {
0062     struct dvb_demux*dvbdmx = dvbdmxfeed->demux;
0063     struct dvb_bt8xx_card *card = dvbdmx->priv;
0064     int rc;
0065 
0066     dprintk("dvb_bt8xx: start_feed\n");
0067 
0068     if (!dvbdmx->dmx.frontend)
0069         return -EINVAL;
0070 
0071     mutex_lock(&card->lock);
0072     card->nfeeds++;
0073     rc = card->nfeeds;
0074     if (card->nfeeds == 1)
0075         bt878_start(card->bt, card->gpio_mode,
0076                 card->op_sync_orin, card->irq_err_ignore);
0077     mutex_unlock(&card->lock);
0078     return rc;
0079 }
0080 
0081 static int dvb_bt8xx_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
0082 {
0083     struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
0084     struct dvb_bt8xx_card *card = dvbdmx->priv;
0085 
0086     dprintk("dvb_bt8xx: stop_feed\n");
0087 
0088     if (!dvbdmx->dmx.frontend)
0089         return -EINVAL;
0090 
0091     mutex_lock(&card->lock);
0092     card->nfeeds--;
0093     if (card->nfeeds == 0)
0094         bt878_stop(card->bt);
0095     mutex_unlock(&card->lock);
0096 
0097     return 0;
0098 }
0099 
0100 static int is_pci_slot_eq(struct pci_dev* adev, struct pci_dev* bdev)
0101 {
0102     if ((adev->subsystem_vendor == bdev->subsystem_vendor) &&
0103         (adev->subsystem_device == bdev->subsystem_device) &&
0104         (adev->bus->number == bdev->bus->number) &&
0105         (PCI_SLOT(adev->devfn) == PCI_SLOT(bdev->devfn)))
0106         return 1;
0107     return 0;
0108 }
0109 
0110 static struct bt878 *dvb_bt8xx_878_match(unsigned int bttv_nr,
0111                      struct pci_dev* bttv_pci_dev)
0112 {
0113     unsigned int card_nr;
0114 
0115     /* Hmm, n squared. Hope n is small */
0116     for (card_nr = 0; card_nr < bt878_num; card_nr++)
0117         if (is_pci_slot_eq(bt878[card_nr].dev, bttv_pci_dev))
0118             return &bt878[card_nr];
0119     return NULL;
0120 }
0121 
0122 static int thomson_dtt7579_demod_init(struct dvb_frontend* fe)
0123 {
0124     static u8 mt352_clock_config [] = { 0x89, 0x38, 0x38 };
0125     static u8 mt352_reset [] = { 0x50, 0x80 };
0126     static u8 mt352_adc_ctl_1_cfg [] = { 0x8E, 0x40 };
0127     static u8 mt352_agc_cfg [] = { 0x67, 0x28, 0x20 };
0128     static u8 mt352_gpp_ctl_cfg [] = { 0x8C, 0x33 };
0129     static u8 mt352_capt_range_cfg[] = { 0x75, 0x32 };
0130 
0131     mt352_write(fe, mt352_clock_config, sizeof(mt352_clock_config));
0132     udelay(2000);
0133     mt352_write(fe, mt352_reset, sizeof(mt352_reset));
0134     mt352_write(fe, mt352_adc_ctl_1_cfg, sizeof(mt352_adc_ctl_1_cfg));
0135 
0136     mt352_write(fe, mt352_agc_cfg, sizeof(mt352_agc_cfg));
0137     mt352_write(fe, mt352_gpp_ctl_cfg, sizeof(mt352_gpp_ctl_cfg));
0138     mt352_write(fe, mt352_capt_range_cfg, sizeof(mt352_capt_range_cfg));
0139 
0140     return 0;
0141 }
0142 
0143 static int thomson_dtt7579_tuner_calc_regs(struct dvb_frontend *fe, u8* pllbuf, int buf_len)
0144 {
0145     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0146     u32 div;
0147     unsigned char bs = 0;
0148     unsigned char cp = 0;
0149 
0150     if (buf_len < 5)
0151         return -EINVAL;
0152 
0153     div = (((c->frequency + 83333) * 3) / 500000) + IF_FREQUENCYx6;
0154 
0155     if (c->frequency < 542000000)
0156         cp = 0xb4;
0157     else if (c->frequency < 771000000)
0158         cp = 0xbc;
0159     else
0160         cp = 0xf4;
0161 
0162     if (c->frequency == 0)
0163         bs = 0x03;
0164     else if (c->frequency < 443250000)
0165         bs = 0x02;
0166     else
0167         bs = 0x08;
0168 
0169     pllbuf[0] = 0x60;
0170     pllbuf[1] = div >> 8;
0171     pllbuf[2] = div & 0xff;
0172     pllbuf[3] = cp;
0173     pllbuf[4] = bs;
0174 
0175     return 5;
0176 }
0177 
0178 static struct mt352_config thomson_dtt7579_config = {
0179     .demod_address = 0x0f,
0180     .demod_init = thomson_dtt7579_demod_init,
0181 };
0182 
0183 static struct zl10353_config thomson_dtt7579_zl10353_config = {
0184     .demod_address = 0x0f,
0185 };
0186 
0187 static int cx24108_tuner_set_params(struct dvb_frontend *fe)
0188 {
0189     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0190     u32 freq = c->frequency;
0191     int i, a, n, pump;
0192     u32 band, pll;
0193     u32 osci[]={950000,1019000,1075000,1178000,1296000,1432000,
0194         1576000,1718000,1856000,2036000,2150000};
0195     u32 bandsel[]={0,0x00020000,0x00040000,0x00100800,0x00101000,
0196         0x00102000,0x00104000,0x00108000,0x00110000,
0197         0x00120000,0x00140000};
0198 
0199     #define XTAL 1011100 /* Hz, really 1.0111 MHz and a /10 prescaler */
0200     dprintk("cx24108 debug: entering SetTunerFreq, freq=%d\n", freq);
0201 
0202     /* This is really the bit driving the tuner chip cx24108 */
0203 
0204     if (freq<950000)
0205         freq = 950000; /* kHz */
0206     else if (freq>2150000)
0207         freq = 2150000; /* satellite IF is 950..2150MHz */
0208 
0209     /* decide which VCO to use for the input frequency */
0210     for(i = 1; (i < ARRAY_SIZE(osci) - 1) && (osci[i] < freq); i++);
0211     dprintk("cx24108 debug: select vco #%d (f=%d)\n", i, freq);
0212     band=bandsel[i];
0213     /* the gain values must be set by SetSymbolrate */
0214     /* compute the pll divider needed, from Conexant data sheet,
0215        resolved for (n*32+a), remember f(vco) is f(receive) *2 or *4,
0216        depending on the divider bit. It is set to /4 on the 2 lowest
0217        bands  */
0218     n=((i<=2?2:1)*freq*10L)/(XTAL/100);
0219     a=n%32; n/=32; if(a==0) n--;
0220     pump=(freq<(osci[i-1]+osci[i])/2);
0221     pll=0xf8000000|
0222         ((pump?1:2)<<(14+11))|
0223         ((n&0x1ff)<<(5+11))|
0224         ((a&0x1f)<<11);
0225     /* everything is shifted left 11 bits to left-align the bits in the
0226        32bit word. Output to the tuner goes MSB-aligned, after all */
0227     dprintk("cx24108 debug: pump=%d, n=%d, a=%d\n", pump, n, a);
0228     cx24110_pll_write(fe,band);
0229     /* set vga and vca to their widest-band settings, as a precaution.
0230        SetSymbolrate might not be called to set this up */
0231     cx24110_pll_write(fe,0x500c0000);
0232     cx24110_pll_write(fe,0x83f1f800);
0233     cx24110_pll_write(fe,pll);
0234     //writereg(client,0x56,0x7f);
0235 
0236     return 0;
0237 }
0238 
0239 static int pinnsat_tuner_init(struct dvb_frontend* fe)
0240 {
0241     struct dvb_bt8xx_card *card = fe->dvb->priv;
0242 
0243     bttv_gpio_enable(card->bttv_nr, 1, 1);  /* output */
0244     bttv_write_gpio(card->bttv_nr, 1, 1);   /* relay on */
0245 
0246     return 0;
0247 }
0248 
0249 static int pinnsat_tuner_sleep(struct dvb_frontend* fe)
0250 {
0251     struct dvb_bt8xx_card *card = fe->dvb->priv;
0252 
0253     bttv_write_gpio(card->bttv_nr, 1, 0);   /* relay off */
0254 
0255     return 0;
0256 }
0257 
0258 static struct cx24110_config pctvsat_config = {
0259     .demod_address = 0x55,
0260 };
0261 
0262 static int microtune_mt7202dtf_tuner_set_params(struct dvb_frontend *fe)
0263 {
0264     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0265     struct dvb_bt8xx_card *card = (struct dvb_bt8xx_card *) fe->dvb->priv;
0266     u8 cfg, cpump, band_select;
0267     u8 data[4];
0268     u32 div;
0269     struct i2c_msg msg = { .addr = 0x60, .flags = 0, .buf = data, .len = sizeof(data) };
0270 
0271     div = (36000000 + c->frequency + 83333) / 166666;
0272     cfg = 0x88;
0273 
0274     if (c->frequency < 175000000)
0275         cpump = 2;
0276     else if (c->frequency < 390000000)
0277         cpump = 1;
0278     else if (c->frequency < 470000000)
0279         cpump = 2;
0280     else if (c->frequency < 750000000)
0281         cpump = 2;
0282     else
0283         cpump = 3;
0284 
0285     if (c->frequency < 175000000)
0286         band_select = 0x0e;
0287     else if (c->frequency < 470000000)
0288         band_select = 0x05;
0289     else
0290         band_select = 0x03;
0291 
0292     data[0] = (div >> 8) & 0x7f;
0293     data[1] = div & 0xff;
0294     data[2] = ((div >> 10) & 0x60) | cfg;
0295     data[3] = (cpump << 6) | band_select;
0296 
0297     if (fe->ops.i2c_gate_ctrl)
0298         fe->ops.i2c_gate_ctrl(fe, 1);
0299     i2c_transfer(card->i2c_adapter, &msg, 1);
0300     return (div * 166666 - 36000000);
0301 }
0302 
0303 static int microtune_mt7202dtf_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
0304 {
0305     struct dvb_bt8xx_card* bt = (struct dvb_bt8xx_card*) fe->dvb->priv;
0306 
0307     return request_firmware(fw, name, &bt->bt->dev->dev);
0308 }
0309 
0310 static const struct sp887x_config microtune_mt7202dtf_config = {
0311     .demod_address = 0x70,
0312     .request_firmware = microtune_mt7202dtf_request_firmware,
0313 };
0314 
0315 static int advbt771_samsung_tdtc9251dh0_demod_init(struct dvb_frontend* fe)
0316 {
0317     static u8 mt352_clock_config [] = { 0x89, 0x38, 0x2d };
0318     static u8 mt352_reset [] = { 0x50, 0x80 };
0319     static u8 mt352_adc_ctl_1_cfg [] = { 0x8E, 0x40 };
0320     static u8 mt352_agc_cfg [] = { 0x67, 0x10, 0x23, 0x00, 0xFF, 0xFF,
0321                        0x00, 0xFF, 0x00, 0x40, 0x40 };
0322     static u8 mt352_av771_extra[] = { 0xB5, 0x7A };
0323     static u8 mt352_capt_range_cfg[] = { 0x75, 0x32 };
0324 
0325     mt352_write(fe, mt352_clock_config, sizeof(mt352_clock_config));
0326     udelay(2000);
0327     mt352_write(fe, mt352_reset, sizeof(mt352_reset));
0328     mt352_write(fe, mt352_adc_ctl_1_cfg, sizeof(mt352_adc_ctl_1_cfg));
0329 
0330     mt352_write(fe, mt352_agc_cfg,sizeof(mt352_agc_cfg));
0331     udelay(2000);
0332     mt352_write(fe, mt352_av771_extra,sizeof(mt352_av771_extra));
0333     mt352_write(fe, mt352_capt_range_cfg, sizeof(mt352_capt_range_cfg));
0334 
0335     return 0;
0336 }
0337 
0338 static int advbt771_samsung_tdtc9251dh0_tuner_calc_regs(struct dvb_frontend *fe, u8 *pllbuf, int buf_len)
0339 {
0340     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0341     u32 div;
0342     unsigned char bs = 0;
0343     unsigned char cp = 0;
0344 
0345     if (buf_len < 5) return -EINVAL;
0346 
0347     div = (((c->frequency + 83333) * 3) / 500000) + IF_FREQUENCYx6;
0348 
0349     if (c->frequency < 150000000)
0350         cp = 0xB4;
0351     else if (c->frequency < 173000000)
0352         cp = 0xBC;
0353     else if (c->frequency < 250000000)
0354         cp = 0xB4;
0355     else if (c->frequency < 400000000)
0356         cp = 0xBC;
0357     else if (c->frequency < 420000000)
0358         cp = 0xF4;
0359     else if (c->frequency < 470000000)
0360         cp = 0xFC;
0361     else if (c->frequency < 600000000)
0362         cp = 0xBC;
0363     else if (c->frequency < 730000000)
0364         cp = 0xF4;
0365     else
0366         cp = 0xFC;
0367 
0368     if (c->frequency < 150000000)
0369         bs = 0x01;
0370     else if (c->frequency < 173000000)
0371         bs = 0x01;
0372     else if (c->frequency < 250000000)
0373         bs = 0x02;
0374     else if (c->frequency < 400000000)
0375         bs = 0x02;
0376     else if (c->frequency < 420000000)
0377         bs = 0x02;
0378     else if (c->frequency < 470000000)
0379         bs = 0x02;
0380     else
0381         bs = 0x08;
0382 
0383     pllbuf[0] = 0x61;
0384     pllbuf[1] = div >> 8;
0385     pllbuf[2] = div & 0xff;
0386     pllbuf[3] = cp;
0387     pllbuf[4] = bs;
0388 
0389     return 5;
0390 }
0391 
0392 static struct mt352_config advbt771_samsung_tdtc9251dh0_config = {
0393     .demod_address = 0x0f,
0394     .demod_init = advbt771_samsung_tdtc9251dh0_demod_init,
0395 };
0396 
0397 static const struct dst_config dst_config = {
0398     .demod_address = 0x55,
0399 };
0400 
0401 static int or51211_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
0402 {
0403     struct dvb_bt8xx_card* bt = (struct dvb_bt8xx_card*) fe->dvb->priv;
0404 
0405     return request_firmware(fw, name, &bt->bt->dev->dev);
0406 }
0407 
0408 static void or51211_setmode(struct dvb_frontend * fe, int mode)
0409 {
0410     struct dvb_bt8xx_card *bt = fe->dvb->priv;
0411     bttv_write_gpio(bt->bttv_nr, 0x0002, mode);   /* Reset */
0412     msleep(20);
0413 }
0414 
0415 static void or51211_reset(struct dvb_frontend * fe)
0416 {
0417     struct dvb_bt8xx_card *bt = fe->dvb->priv;
0418 
0419     /* RESET DEVICE
0420      * reset is controlled by GPIO-0
0421      * when set to 0 causes reset and when to 1 for normal op
0422      * must remain reset for 128 clock cycles on a 50Mhz clock
0423      * also PRM1 PRM2 & PRM4 are controlled by GPIO-1,GPIO-2 & GPIO-4
0424      * We assume that the reset has be held low long enough or we
0425      * have been reset by a power on.  When the driver is unloaded
0426      * reset set to 0 so if reloaded we have been reset.
0427      */
0428     /* reset & PRM1,2&4 are outputs */
0429     int ret = bttv_gpio_enable(bt->bttv_nr, 0x001F, 0x001F);
0430     if (ret != 0)
0431         pr_warn("or51211: Init Error - Can't Reset DVR (%i)\n", ret);
0432     bttv_write_gpio(bt->bttv_nr, 0x001F, 0x0000);   /* Reset */
0433     msleep(20);
0434     /* Now set for normal operation */
0435     bttv_write_gpio(bt->bttv_nr, 0x0001F, 0x0001);
0436     /* wait for operation to begin */
0437     msleep(500);
0438 }
0439 
0440 static void or51211_sleep(struct dvb_frontend * fe)
0441 {
0442     struct dvb_bt8xx_card *bt = fe->dvb->priv;
0443     bttv_write_gpio(bt->bttv_nr, 0x0001, 0x0000);
0444 }
0445 
0446 static const struct or51211_config or51211_config = {
0447     .demod_address = 0x15,
0448     .request_firmware = or51211_request_firmware,
0449     .setmode = or51211_setmode,
0450     .reset = or51211_reset,
0451     .sleep = or51211_sleep,
0452 };
0453 
0454 static int vp3021_alps_tded4_tuner_set_params(struct dvb_frontend *fe)
0455 {
0456     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0457     struct dvb_bt8xx_card *card = (struct dvb_bt8xx_card *) fe->dvb->priv;
0458     u8 buf[4];
0459     u32 div;
0460     struct i2c_msg msg = { .addr = 0x60, .flags = 0, .buf = buf, .len = sizeof(buf) };
0461 
0462     div = (c->frequency + 36166667) / 166667;
0463 
0464     buf[0] = (div >> 8) & 0x7F;
0465     buf[1] = div & 0xFF;
0466     buf[2] = 0x85;
0467     if ((c->frequency >= 47000000) && (c->frequency < 153000000))
0468         buf[3] = 0x01;
0469     else if ((c->frequency >= 153000000) && (c->frequency < 430000000))
0470         buf[3] = 0x02;
0471     else if ((c->frequency >= 430000000) && (c->frequency < 824000000))
0472         buf[3] = 0x0C;
0473     else if ((c->frequency >= 824000000) && (c->frequency < 863000000))
0474         buf[3] = 0x8C;
0475     else
0476         return -EINVAL;
0477 
0478     if (fe->ops.i2c_gate_ctrl)
0479         fe->ops.i2c_gate_ctrl(fe, 1);
0480     i2c_transfer(card->i2c_adapter, &msg, 1);
0481     return 0;
0482 }
0483 
0484 static struct nxt6000_config vp3021_alps_tded4_config = {
0485     .demod_address = 0x0a,
0486     .clock_inversion = 1,
0487 };
0488 
0489 static int digitv_alps_tded4_demod_init(struct dvb_frontend* fe)
0490 {
0491     static u8 mt352_clock_config [] = { 0x89, 0x38, 0x2d };
0492     static u8 mt352_reset [] = { 0x50, 0x80 };
0493     static u8 mt352_adc_ctl_1_cfg [] = { 0x8E, 0x40 };
0494     static u8 mt352_agc_cfg [] = { 0x67, 0x20, 0xa0 };
0495     static u8 mt352_capt_range_cfg[] = { 0x75, 0x32 };
0496 
0497     mt352_write(fe, mt352_clock_config, sizeof(mt352_clock_config));
0498     udelay(2000);
0499     mt352_write(fe, mt352_reset, sizeof(mt352_reset));
0500     mt352_write(fe, mt352_adc_ctl_1_cfg, sizeof(mt352_adc_ctl_1_cfg));
0501     mt352_write(fe, mt352_agc_cfg,sizeof(mt352_agc_cfg));
0502     mt352_write(fe, mt352_capt_range_cfg, sizeof(mt352_capt_range_cfg));
0503 
0504     return 0;
0505 }
0506 
0507 static int digitv_alps_tded4_tuner_calc_regs(struct dvb_frontend *fe,  u8 *pllbuf, int buf_len)
0508 {
0509     u32 div;
0510     struct dtv_frontend_properties *c = &fe->dtv_property_cache;
0511 
0512     if (buf_len < 5)
0513         return -EINVAL;
0514 
0515     div = (((c->frequency + 83333) * 3) / 500000) + IF_FREQUENCYx6;
0516 
0517     pllbuf[0] = 0x61;
0518     pllbuf[1] = (div >> 8) & 0x7F;
0519     pllbuf[2] = div & 0xFF;
0520     pllbuf[3] = 0x85;
0521 
0522     dprintk("frequency %u, div %u\n", c->frequency, div);
0523 
0524     if (c->frequency < 470000000)
0525         pllbuf[4] = 0x02;
0526     else if (c->frequency > 823000000)
0527         pllbuf[4] = 0x88;
0528     else
0529         pllbuf[4] = 0x08;
0530 
0531     if (c->bandwidth_hz == 8000000)
0532         pllbuf[4] |= 0x04;
0533 
0534     return 5;
0535 }
0536 
0537 static void digitv_alps_tded4_reset(struct dvb_bt8xx_card *bt)
0538 {
0539     /*
0540      * Reset the frontend, must be called before trying
0541      * to initialise the MT352 or mt352_attach
0542      * will fail. Same goes for the nxt6000 frontend.
0543      *
0544      */
0545 
0546     int ret = bttv_gpio_enable(bt->bttv_nr, 0x08, 0x08);
0547     if (ret != 0)
0548         pr_warn("digitv_alps_tded4: Init Error - Can't Reset DVR (%i)\n",
0549             ret);
0550 
0551     /* Pulse the reset line */
0552     bttv_write_gpio(bt->bttv_nr, 0x08, 0x08); /* High */
0553     bttv_write_gpio(bt->bttv_nr, 0x08, 0x00); /* Low  */
0554     msleep(100);
0555 
0556     bttv_write_gpio(bt->bttv_nr, 0x08, 0x08); /* High */
0557 }
0558 
0559 static struct mt352_config digitv_alps_tded4_config = {
0560     .demod_address = 0x0a,
0561     .demod_init = digitv_alps_tded4_demod_init,
0562 };
0563 
0564 static struct lgdt330x_config tdvs_tua6034_config = {
0565     .demod_chip       = LGDT3303,
0566     .serial_mpeg      = 0x40, /* TPSERIAL for 3303 in TOP_CONTROL */
0567 };
0568 
0569 static void lgdt330x_reset(struct dvb_bt8xx_card *bt)
0570 {
0571     /* Set pin 27 of the lgdt3303 chip high to reset the frontend */
0572 
0573     /* Pulse the reset line */
0574     bttv_write_gpio(bt->bttv_nr, 0x00e00007, 0x00000001); /* High */
0575     bttv_write_gpio(bt->bttv_nr, 0x00e00007, 0x00000000); /* Low  */
0576     msleep(100);
0577 
0578     bttv_write_gpio(bt->bttv_nr, 0x00e00007, 0x00000001); /* High */
0579     msleep(100);
0580 }
0581 
0582 static void frontend_init(struct dvb_bt8xx_card *card, u32 type)
0583 {
0584     struct dst_state* state = NULL;
0585 
0586     switch(type) {
0587     case BTTV_BOARD_DVICO_DVBT_LITE:
0588         card->fe = dvb_attach(mt352_attach, &thomson_dtt7579_config, card->i2c_adapter);
0589 
0590         if (card->fe == NULL)
0591             card->fe = dvb_attach(zl10353_attach, &thomson_dtt7579_zl10353_config,
0592                           card->i2c_adapter);
0593 
0594         if (card->fe != NULL) {
0595             card->fe->ops.tuner_ops.calc_regs = thomson_dtt7579_tuner_calc_regs;
0596             card->fe->ops.info.frequency_min_hz = 174 * MHz;
0597             card->fe->ops.info.frequency_max_hz = 862 * MHz;
0598         }
0599         break;
0600 
0601     case BTTV_BOARD_DVICO_FUSIONHDTV_5_LITE:
0602         lgdt330x_reset(card);
0603         card->fe = dvb_attach(lgdt330x_attach, &tdvs_tua6034_config,
0604                       0x0e, card->i2c_adapter);
0605         if (card->fe != NULL) {
0606             dvb_attach(simple_tuner_attach, card->fe,
0607                    card->i2c_adapter, 0x61,
0608                    TUNER_LG_TDVS_H06XF);
0609             dprintk("dvb_bt8xx: lgdt330x detected\n");
0610         }
0611         break;
0612 
0613     case BTTV_BOARD_NEBULA_DIGITV:
0614         /*
0615          * It is possible to determine the correct frontend using the I2C bus (see the Nebula SDK);
0616          * this would be a cleaner solution than trying each frontend in turn.
0617          */
0618 
0619         /* Old Nebula (marked (c)2003 on high profile pci card) has nxt6000 demod */
0620         digitv_alps_tded4_reset(card);
0621         card->fe = dvb_attach(nxt6000_attach, &vp3021_alps_tded4_config, card->i2c_adapter);
0622         if (card->fe != NULL) {
0623             card->fe->ops.tuner_ops.set_params = vp3021_alps_tded4_tuner_set_params;
0624             dprintk("dvb_bt8xx: an nxt6000 was detected on your digitv card\n");
0625             break;
0626         }
0627 
0628         /* New Nebula (marked (c)2005 on low profile pci card) has mt352 demod */
0629         digitv_alps_tded4_reset(card);
0630         card->fe = dvb_attach(mt352_attach, &digitv_alps_tded4_config, card->i2c_adapter);
0631 
0632         if (card->fe != NULL) {
0633             card->fe->ops.tuner_ops.calc_regs = digitv_alps_tded4_tuner_calc_regs;
0634             dprintk("dvb_bt8xx: an mt352 was detected on your digitv card\n");
0635         }
0636         break;
0637 
0638     case BTTV_BOARD_AVDVBT_761:
0639         card->fe = dvb_attach(sp887x_attach, &microtune_mt7202dtf_config, card->i2c_adapter);
0640         if (card->fe) {
0641             card->fe->ops.tuner_ops.set_params = microtune_mt7202dtf_tuner_set_params;
0642         }
0643         break;
0644 
0645     case BTTV_BOARD_AVDVBT_771:
0646         card->fe = dvb_attach(mt352_attach, &advbt771_samsung_tdtc9251dh0_config, card->i2c_adapter);
0647         if (card->fe != NULL) {
0648             card->fe->ops.tuner_ops.calc_regs = advbt771_samsung_tdtc9251dh0_tuner_calc_regs;
0649             card->fe->ops.info.frequency_min_hz = 174 * MHz;
0650             card->fe->ops.info.frequency_max_hz = 862 * MHz;
0651         }
0652         break;
0653 
0654     case BTTV_BOARD_TWINHAN_DST:
0655         /*  DST is not a frontend driver !!!        */
0656         state = kmalloc(sizeof (struct dst_state), GFP_KERNEL);
0657         if (!state) {
0658             pr_err("No memory\n");
0659             break;
0660         }
0661         /*  Setup the Card                  */
0662         state->config = &dst_config;
0663         state->i2c = card->i2c_adapter;
0664         state->bt = card->bt;
0665         state->dst_ca = NULL;
0666         /*  DST is not a frontend, attaching the ASIC   */
0667         if (dvb_attach(dst_attach, state, &card->dvb_adapter) == NULL) {
0668             pr_err("%s: Could not find a Twinhan DST\n", __func__);
0669             kfree(state);
0670             break;
0671         }
0672         /*  Attach other DST peripherals if any     */
0673         /*  Conditional Access device           */
0674         card->fe = &state->frontend;
0675         if (state->dst_hw_cap & DST_TYPE_HAS_CA)
0676             dvb_attach(dst_ca_attach, state, &card->dvb_adapter);
0677         break;
0678 
0679     case BTTV_BOARD_PINNACLESAT:
0680         card->fe = dvb_attach(cx24110_attach, &pctvsat_config, card->i2c_adapter);
0681         if (card->fe) {
0682             card->fe->ops.tuner_ops.init = pinnsat_tuner_init;
0683             card->fe->ops.tuner_ops.sleep = pinnsat_tuner_sleep;
0684             card->fe->ops.tuner_ops.set_params = cx24108_tuner_set_params;
0685         }
0686         break;
0687 
0688     case BTTV_BOARD_PC_HDTV:
0689         card->fe = dvb_attach(or51211_attach, &or51211_config, card->i2c_adapter);
0690         if (card->fe != NULL)
0691             dvb_attach(simple_tuner_attach, card->fe,
0692                    card->i2c_adapter, 0x61,
0693                    TUNER_PHILIPS_FCV1236D);
0694         break;
0695     }
0696 
0697     if (card->fe == NULL)
0698         pr_err("A frontend driver was not found for device [%04x:%04x] subsystem [%04x:%04x]\n",
0699                card->bt->dev->vendor,
0700                card->bt->dev->device,
0701                card->bt->dev->subsystem_vendor,
0702                card->bt->dev->subsystem_device);
0703     else
0704         if (dvb_register_frontend(&card->dvb_adapter, card->fe)) {
0705             pr_err("Frontend registration failed!\n");
0706             dvb_frontend_detach(card->fe);
0707             card->fe = NULL;
0708         }
0709 }
0710 
0711 static int dvb_bt8xx_load_card(struct dvb_bt8xx_card *card, u32 type)
0712 {
0713     int result;
0714 
0715     result = dvb_register_adapter(&card->dvb_adapter, card->card_name,
0716                       THIS_MODULE, &card->bt->dev->dev,
0717                       adapter_nr);
0718     if (result < 0) {
0719         pr_err("dvb_register_adapter failed (errno = %d)\n", result);
0720         return result;
0721     }
0722     card->dvb_adapter.priv = card;
0723 
0724     card->bt->adapter = card->i2c_adapter;
0725 
0726     memset(&card->demux, 0, sizeof(struct dvb_demux));
0727 
0728     card->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING | DMX_MEMORY_BASED_FILTERING;
0729 
0730     card->demux.priv = card;
0731     card->demux.filternum = 256;
0732     card->demux.feednum = 256;
0733     card->demux.start_feed = dvb_bt8xx_start_feed;
0734     card->demux.stop_feed = dvb_bt8xx_stop_feed;
0735     card->demux.write_to_decoder = NULL;
0736 
0737     result = dvb_dmx_init(&card->demux);
0738     if (result < 0) {
0739         pr_err("dvb_dmx_init failed (errno = %d)\n", result);
0740         goto err_unregister_adaptor;
0741     }
0742 
0743     card->dmxdev.filternum = 256;
0744     card->dmxdev.demux = &card->demux.dmx;
0745     card->dmxdev.capabilities = 0;
0746 
0747     result = dvb_dmxdev_init(&card->dmxdev, &card->dvb_adapter);
0748     if (result < 0) {
0749         pr_err("dvb_dmxdev_init failed (errno = %d)\n", result);
0750         goto err_dmx_release;
0751     }
0752 
0753     card->fe_hw.source = DMX_FRONTEND_0;
0754 
0755     result = card->demux.dmx.add_frontend(&card->demux.dmx, &card->fe_hw);
0756     if (result < 0) {
0757         pr_err("dvb_dmx_init failed (errno = %d)\n", result);
0758         goto err_dmxdev_release;
0759     }
0760 
0761     card->fe_mem.source = DMX_MEMORY_FE;
0762 
0763     result = card->demux.dmx.add_frontend(&card->demux.dmx, &card->fe_mem);
0764     if (result < 0) {
0765         pr_err("dvb_dmx_init failed (errno = %d)\n", result);
0766         goto err_remove_hw_frontend;
0767     }
0768 
0769     result = card->demux.dmx.connect_frontend(&card->demux.dmx, &card->fe_hw);
0770     if (result < 0) {
0771         pr_err("dvb_dmx_init failed (errno = %d)\n", result);
0772         goto err_remove_mem_frontend;
0773     }
0774 
0775     result = dvb_net_init(&card->dvb_adapter, &card->dvbnet, &card->demux.dmx);
0776     if (result < 0) {
0777         pr_err("dvb_net_init failed (errno = %d)\n", result);
0778         goto err_disconnect_frontend;
0779     }
0780 
0781     tasklet_setup(&card->bt->tasklet, dvb_bt8xx_task);
0782 
0783     frontend_init(card, type);
0784 
0785     return 0;
0786 
0787 err_disconnect_frontend:
0788     card->demux.dmx.disconnect_frontend(&card->demux.dmx);
0789 err_remove_mem_frontend:
0790     card->demux.dmx.remove_frontend(&card->demux.dmx, &card->fe_mem);
0791 err_remove_hw_frontend:
0792     card->demux.dmx.remove_frontend(&card->demux.dmx, &card->fe_hw);
0793 err_dmxdev_release:
0794     dvb_dmxdev_release(&card->dmxdev);
0795 err_dmx_release:
0796     dvb_dmx_release(&card->demux);
0797 err_unregister_adaptor:
0798     dvb_unregister_adapter(&card->dvb_adapter);
0799     return result;
0800 }
0801 
0802 static int dvb_bt8xx_probe(struct bttv_sub_device *sub)
0803 {
0804     struct dvb_bt8xx_card *card;
0805     struct pci_dev* bttv_pci_dev;
0806     int ret;
0807 
0808     if (!(card = kzalloc(sizeof(struct dvb_bt8xx_card), GFP_KERNEL)))
0809         return -ENOMEM;
0810 
0811     mutex_init(&card->lock);
0812     card->bttv_nr = sub->core->nr;
0813     strscpy(card->card_name, sub->core->v4l2_dev.name,
0814         sizeof(card->card_name));
0815     card->i2c_adapter = &sub->core->i2c_adap;
0816 
0817     switch(sub->core->type) {
0818     case BTTV_BOARD_PINNACLESAT:
0819         card->gpio_mode = 0x0400c060;
0820         /* should be: BT878_A_GAIN=0,BT878_A_PWRDN,BT878_DA_DPM,BT878_DA_SBR,
0821                   BT878_DA_IOM=1,BT878_DA_APP to enable serial highspeed mode. */
0822         card->op_sync_orin = BT878_RISC_SYNC_MASK;
0823         card->irq_err_ignore = BT878_AFBUS | BT878_AFDSR;
0824         break;
0825 
0826     case BTTV_BOARD_DVICO_DVBT_LITE:
0827         card->gpio_mode = 0x0400C060;
0828         card->op_sync_orin = BT878_RISC_SYNC_MASK;
0829         card->irq_err_ignore = BT878_AFBUS | BT878_AFDSR;
0830         /* 26, 15, 14, 6, 5
0831          * A_PWRDN  DA_DPM DA_SBR DA_IOM_DA
0832          * DA_APP(parallel) */
0833         break;
0834 
0835     case BTTV_BOARD_DVICO_FUSIONHDTV_5_LITE:
0836         card->gpio_mode = 0x0400c060;
0837         card->op_sync_orin = BT878_RISC_SYNC_MASK;
0838         card->irq_err_ignore = BT878_AFBUS | BT878_AFDSR;
0839         break;
0840 
0841     case BTTV_BOARD_NEBULA_DIGITV:
0842     case BTTV_BOARD_AVDVBT_761:
0843         card->gpio_mode = (1 << 26) | (1 << 14) | (1 << 5);
0844         card->op_sync_orin = BT878_RISC_SYNC_MASK;
0845         card->irq_err_ignore = BT878_AFBUS | BT878_AFDSR;
0846         /* A_PWRDN DA_SBR DA_APP (high speed serial) */
0847         break;
0848 
0849     case BTTV_BOARD_AVDVBT_771: //case 0x07711461:
0850         card->gpio_mode = 0x0400402B;
0851         card->op_sync_orin = BT878_RISC_SYNC_MASK;
0852         card->irq_err_ignore = BT878_AFBUS | BT878_AFDSR;
0853         /* A_PWRDN DA_SBR  DA_APP[0] PKTP=10 RISC_ENABLE FIFO_ENABLE*/
0854         break;
0855 
0856     case BTTV_BOARD_TWINHAN_DST:
0857         card->gpio_mode = 0x2204f2c;
0858         card->op_sync_orin = BT878_RISC_SYNC_MASK;
0859         card->irq_err_ignore = BT878_APABORT | BT878_ARIPERR |
0860                        BT878_APPERR | BT878_AFBUS;
0861         /* 25,21,14,11,10,9,8,3,2 then
0862          * 0x33 = 5,4,1,0
0863          * A_SEL=SML, DA_MLB, DA_SBR,
0864          * DA_SDR=f, fifo trigger = 32 DWORDS
0865          * IOM = 0 == audio A/D
0866          * DPM = 0 == digital audio mode
0867          * == async data parallel port
0868          * then 0x33 (13 is set by start_capture)
0869          * DA_APP = async data parallel port,
0870          * ACAP_EN = 1,
0871          * RISC+FIFO ENABLE */
0872         break;
0873 
0874     case BTTV_BOARD_PC_HDTV:
0875         card->gpio_mode = 0x0100EC7B;
0876         card->op_sync_orin = BT878_RISC_SYNC_MASK;
0877         card->irq_err_ignore = BT878_AFBUS | BT878_AFDSR;
0878         break;
0879 
0880     default:
0881         pr_err("Unknown bttv card type: %d\n", sub->core->type);
0882         kfree(card);
0883         return -ENODEV;
0884     }
0885 
0886     dprintk("dvb_bt8xx: identified card%d as %s\n", card->bttv_nr, card->card_name);
0887 
0888     if (!(bttv_pci_dev = bttv_get_pcidev(card->bttv_nr))) {
0889         pr_err("no pci device for card %d\n", card->bttv_nr);
0890         kfree(card);
0891         return -ENODEV;
0892     }
0893 
0894     if (!(card->bt = dvb_bt8xx_878_match(card->bttv_nr, bttv_pci_dev))) {
0895         pr_err("unable to determine DMA core of card %d,\n", card->bttv_nr);
0896         pr_err("if you have the ALSA bt87x audio driver installed, try removing it.\n");
0897 
0898         kfree(card);
0899         return -ENODEV;
0900     }
0901 
0902     mutex_init(&card->bt->gpio_lock);
0903     card->bt->bttv_nr = sub->core->nr;
0904 
0905     if ( (ret = dvb_bt8xx_load_card(card, sub->core->type)) ) {
0906         kfree(card);
0907         return ret;
0908     }
0909 
0910     dev_set_drvdata(&sub->dev, card);
0911     return 0;
0912 }
0913 
0914 static void dvb_bt8xx_remove(struct bttv_sub_device *sub)
0915 {
0916     struct dvb_bt8xx_card *card = dev_get_drvdata(&sub->dev);
0917 
0918     dprintk("dvb_bt8xx: unloading card%d\n", card->bttv_nr);
0919 
0920     bt878_stop(card->bt);
0921     tasklet_kill(&card->bt->tasklet);
0922     dvb_net_release(&card->dvbnet);
0923     card->demux.dmx.remove_frontend(&card->demux.dmx, &card->fe_mem);
0924     card->demux.dmx.remove_frontend(&card->demux.dmx, &card->fe_hw);
0925     dvb_dmxdev_release(&card->dmxdev);
0926     dvb_dmx_release(&card->demux);
0927     if (card->fe) {
0928         dvb_unregister_frontend(card->fe);
0929         dvb_frontend_detach(card->fe);
0930     }
0931     dvb_unregister_adapter(&card->dvb_adapter);
0932 
0933     kfree(card);
0934 }
0935 
0936 static struct bttv_sub_driver driver = {
0937     .drv = {
0938         .name       = "dvb-bt8xx",
0939     },
0940     .probe      = dvb_bt8xx_probe,
0941     .remove     = dvb_bt8xx_remove,
0942     /* FIXME:
0943      * .shutdown    = dvb_bt8xx_shutdown,
0944      * .suspend = dvb_bt8xx_suspend,
0945      * .resume  = dvb_bt8xx_resume,
0946      */
0947 };
0948 
0949 static int __init dvb_bt8xx_init(void)
0950 {
0951     return bttv_sub_register(&driver, "dvb");
0952 }
0953 
0954 static void __exit dvb_bt8xx_exit(void)
0955 {
0956     bttv_sub_unregister(&driver);
0957 }
0958 
0959 module_init(dvb_bt8xx_init);
0960 module_exit(dvb_bt8xx_exit);
0961 
0962 MODULE_DESCRIPTION("Bt8xx based DVB adapter driver");
0963 MODULE_AUTHOR("Florian Schirmer <jolt@tuxbox.org>");
0964 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!