treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 157
[sfrench/cifs-2.6.git] / drivers / media / pci / bt8xx / dvb-bt8xx.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Bt8xx based DVB adapter driver
4  *
5  * Copyright (C) 2002,2003 Florian Schirmer <jolt@tuxbox.org>
6  */
7
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9
10 #include <linux/bitops.h>
11 #include <linux/module.h>
12 #include <linux/init.h>
13 #include <linux/kernel.h>
14 #include <linux/device.h>
15 #include <linux/delay.h>
16 #include <linux/slab.h>
17 #include <linux/i2c.h>
18
19 #include <media/dmxdev.h>
20 #include <media/dvbdev.h>
21 #include <media/dvb_demux.h>
22 #include <media/dvb_frontend.h>
23 #include "dvb-bt8xx.h"
24 #include "bt878.h"
25
26 static int debug;
27
28 module_param(debug, int, 0644);
29 MODULE_PARM_DESC(debug, "Turn on/off debugging (default:off).");
30
31 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
32
33 #define dprintk(fmt, arg...) do {                               \
34         if (debug)                                              \
35                 printk(KERN_DEBUG pr_fmt("%s: " fmt),           \
36                        __func__, ##arg);                        \
37 } while (0)
38
39
40 #define IF_FREQUENCYx6 217    /* 6 * 36.16666666667MHz */
41
42 static void dvb_bt8xx_task(unsigned long data)
43 {
44         struct dvb_bt8xx_card *card = (struct dvb_bt8xx_card *)data;
45
46         dprintk("%d\n", card->bt->finished_block);
47
48         while (card->bt->last_block != card->bt->finished_block) {
49                 (card->bt->TS_Size ? dvb_dmx_swfilter_204 : dvb_dmx_swfilter)
50                         (&card->demux,
51                          &card->bt->buf_cpu[card->bt->last_block *
52                                             card->bt->block_bytes],
53                          card->bt->block_bytes);
54                 card->bt->last_block = (card->bt->last_block + 1) %
55                                         card->bt->block_count;
56         }
57 }
58
59 static int dvb_bt8xx_start_feed(struct dvb_demux_feed *dvbdmxfeed)
60 {
61         struct dvb_demux*dvbdmx = dvbdmxfeed->demux;
62         struct dvb_bt8xx_card *card = dvbdmx->priv;
63         int rc;
64
65         dprintk("dvb_bt8xx: start_feed\n");
66
67         if (!dvbdmx->dmx.frontend)
68                 return -EINVAL;
69
70         mutex_lock(&card->lock);
71         card->nfeeds++;
72         rc = card->nfeeds;
73         if (card->nfeeds == 1)
74                 bt878_start(card->bt, card->gpio_mode,
75                             card->op_sync_orin, card->irq_err_ignore);
76         mutex_unlock(&card->lock);
77         return rc;
78 }
79
80 static int dvb_bt8xx_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
81 {
82         struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
83         struct dvb_bt8xx_card *card = dvbdmx->priv;
84
85         dprintk("dvb_bt8xx: stop_feed\n");
86
87         if (!dvbdmx->dmx.frontend)
88                 return -EINVAL;
89
90         mutex_lock(&card->lock);
91         card->nfeeds--;
92         if (card->nfeeds == 0)
93                 bt878_stop(card->bt);
94         mutex_unlock(&card->lock);
95
96         return 0;
97 }
98
99 static int is_pci_slot_eq(struct pci_dev* adev, struct pci_dev* bdev)
100 {
101         if ((adev->subsystem_vendor == bdev->subsystem_vendor) &&
102                 (adev->subsystem_device == bdev->subsystem_device) &&
103                 (adev->bus->number == bdev->bus->number) &&
104                 (PCI_SLOT(adev->devfn) == PCI_SLOT(bdev->devfn)))
105                 return 1;
106         return 0;
107 }
108
109 static struct bt878 *dvb_bt8xx_878_match(unsigned int bttv_nr,
110                                          struct pci_dev* bttv_pci_dev)
111 {
112         unsigned int card_nr;
113
114         /* Hmm, n squared. Hope n is small */
115         for (card_nr = 0; card_nr < bt878_num; card_nr++)
116                 if (is_pci_slot_eq(bt878[card_nr].dev, bttv_pci_dev))
117                         return &bt878[card_nr];
118         return NULL;
119 }
120
121 static int thomson_dtt7579_demod_init(struct dvb_frontend* fe)
122 {
123         static u8 mt352_clock_config [] = { 0x89, 0x38, 0x38 };
124         static u8 mt352_reset [] = { 0x50, 0x80 };
125         static u8 mt352_adc_ctl_1_cfg [] = { 0x8E, 0x40 };
126         static u8 mt352_agc_cfg [] = { 0x67, 0x28, 0x20 };
127         static u8 mt352_gpp_ctl_cfg [] = { 0x8C, 0x33 };
128         static u8 mt352_capt_range_cfg[] = { 0x75, 0x32 };
129
130         mt352_write(fe, mt352_clock_config, sizeof(mt352_clock_config));
131         udelay(2000);
132         mt352_write(fe, mt352_reset, sizeof(mt352_reset));
133         mt352_write(fe, mt352_adc_ctl_1_cfg, sizeof(mt352_adc_ctl_1_cfg));
134
135         mt352_write(fe, mt352_agc_cfg, sizeof(mt352_agc_cfg));
136         mt352_write(fe, mt352_gpp_ctl_cfg, sizeof(mt352_gpp_ctl_cfg));
137         mt352_write(fe, mt352_capt_range_cfg, sizeof(mt352_capt_range_cfg));
138
139         return 0;
140 }
141
142 static int thomson_dtt7579_tuner_calc_regs(struct dvb_frontend *fe, u8* pllbuf, int buf_len)
143 {
144         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
145         u32 div;
146         unsigned char bs = 0;
147         unsigned char cp = 0;
148
149         if (buf_len < 5)
150                 return -EINVAL;
151
152         div = (((c->frequency + 83333) * 3) / 500000) + IF_FREQUENCYx6;
153
154         if (c->frequency < 542000000)
155                 cp = 0xb4;
156         else if (c->frequency < 771000000)
157                 cp = 0xbc;
158         else
159                 cp = 0xf4;
160
161         if (c->frequency == 0)
162                 bs = 0x03;
163         else if (c->frequency < 443250000)
164                 bs = 0x02;
165         else
166                 bs = 0x08;
167
168         pllbuf[0] = 0x60;
169         pllbuf[1] = div >> 8;
170         pllbuf[2] = div & 0xff;
171         pllbuf[3] = cp;
172         pllbuf[4] = bs;
173
174         return 5;
175 }
176
177 static struct mt352_config thomson_dtt7579_config = {
178         .demod_address = 0x0f,
179         .demod_init = thomson_dtt7579_demod_init,
180 };
181
182 static struct zl10353_config thomson_dtt7579_zl10353_config = {
183         .demod_address = 0x0f,
184 };
185
186 static int cx24108_tuner_set_params(struct dvb_frontend *fe)
187 {
188         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
189         u32 freq = c->frequency;
190         int i, a, n, pump;
191         u32 band, pll;
192         u32 osci[]={950000,1019000,1075000,1178000,1296000,1432000,
193                 1576000,1718000,1856000,2036000,2150000};
194         u32 bandsel[]={0,0x00020000,0x00040000,0x00100800,0x00101000,
195                 0x00102000,0x00104000,0x00108000,0x00110000,
196                 0x00120000,0x00140000};
197
198         #define XTAL 1011100 /* Hz, really 1.0111 MHz and a /10 prescaler */
199         dprintk("cx24108 debug: entering SetTunerFreq, freq=%d\n", freq);
200
201         /* This is really the bit driving the tuner chip cx24108 */
202
203         if (freq<950000)
204                 freq = 950000; /* kHz */
205         else if (freq>2150000)
206                 freq = 2150000; /* satellite IF is 950..2150MHz */
207
208         /* decide which VCO to use for the input frequency */
209         for(i = 1; (i < ARRAY_SIZE(osci) - 1) && (osci[i] < freq); i++);
210         dprintk("cx24108 debug: select vco #%d (f=%d)\n", i, freq);
211         band=bandsel[i];
212         /* the gain values must be set by SetSymbolrate */
213         /* compute the pll divider needed, from Conexant data sheet,
214            resolved for (n*32+a), remember f(vco) is f(receive) *2 or *4,
215            depending on the divider bit. It is set to /4 on the 2 lowest
216            bands  */
217         n=((i<=2?2:1)*freq*10L)/(XTAL/100);
218         a=n%32; n/=32; if(a==0) n--;
219         pump=(freq<(osci[i-1]+osci[i])/2);
220         pll=0xf8000000|
221             ((pump?1:2)<<(14+11))|
222             ((n&0x1ff)<<(5+11))|
223             ((a&0x1f)<<11);
224         /* everything is shifted left 11 bits to left-align the bits in the
225            32bit word. Output to the tuner goes MSB-aligned, after all */
226         dprintk("cx24108 debug: pump=%d, n=%d, a=%d\n", pump, n, a);
227         cx24110_pll_write(fe,band);
228         /* set vga and vca to their widest-band settings, as a precaution.
229            SetSymbolrate might not be called to set this up */
230         cx24110_pll_write(fe,0x500c0000);
231         cx24110_pll_write(fe,0x83f1f800);
232         cx24110_pll_write(fe,pll);
233         //writereg(client,0x56,0x7f);
234
235         return 0;
236 }
237
238 static int pinnsat_tuner_init(struct dvb_frontend* fe)
239 {
240         struct dvb_bt8xx_card *card = fe->dvb->priv;
241
242         bttv_gpio_enable(card->bttv_nr, 1, 1);  /* output */
243         bttv_write_gpio(card->bttv_nr, 1, 1);   /* relay on */
244
245         return 0;
246 }
247
248 static int pinnsat_tuner_sleep(struct dvb_frontend* fe)
249 {
250         struct dvb_bt8xx_card *card = fe->dvb->priv;
251
252         bttv_write_gpio(card->bttv_nr, 1, 0);   /* relay off */
253
254         return 0;
255 }
256
257 static struct cx24110_config pctvsat_config = {
258         .demod_address = 0x55,
259 };
260
261 static int microtune_mt7202dtf_tuner_set_params(struct dvb_frontend *fe)
262 {
263         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
264         struct dvb_bt8xx_card *card = (struct dvb_bt8xx_card *) fe->dvb->priv;
265         u8 cfg, cpump, band_select;
266         u8 data[4];
267         u32 div;
268         struct i2c_msg msg = { .addr = 0x60, .flags = 0, .buf = data, .len = sizeof(data) };
269
270         div = (36000000 + c->frequency + 83333) / 166666;
271         cfg = 0x88;
272
273         if (c->frequency < 175000000)
274                 cpump = 2;
275         else if (c->frequency < 390000000)
276                 cpump = 1;
277         else if (c->frequency < 470000000)
278                 cpump = 2;
279         else if (c->frequency < 750000000)
280                 cpump = 2;
281         else
282                 cpump = 3;
283
284         if (c->frequency < 175000000)
285                 band_select = 0x0e;
286         else if (c->frequency < 470000000)
287                 band_select = 0x05;
288         else
289                 band_select = 0x03;
290
291         data[0] = (div >> 8) & 0x7f;
292         data[1] = div & 0xff;
293         data[2] = ((div >> 10) & 0x60) | cfg;
294         data[3] = (cpump << 6) | band_select;
295
296         if (fe->ops.i2c_gate_ctrl)
297                 fe->ops.i2c_gate_ctrl(fe, 1);
298         i2c_transfer(card->i2c_adapter, &msg, 1);
299         return (div * 166666 - 36000000);
300 }
301
302 static int microtune_mt7202dtf_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
303 {
304         struct dvb_bt8xx_card* bt = (struct dvb_bt8xx_card*) fe->dvb->priv;
305
306         return request_firmware(fw, name, &bt->bt->dev->dev);
307 }
308
309 static const struct sp887x_config microtune_mt7202dtf_config = {
310         .demod_address = 0x70,
311         .request_firmware = microtune_mt7202dtf_request_firmware,
312 };
313
314 static int advbt771_samsung_tdtc9251dh0_demod_init(struct dvb_frontend* fe)
315 {
316         static u8 mt352_clock_config [] = { 0x89, 0x38, 0x2d };
317         static u8 mt352_reset [] = { 0x50, 0x80 };
318         static u8 mt352_adc_ctl_1_cfg [] = { 0x8E, 0x40 };
319         static u8 mt352_agc_cfg [] = { 0x67, 0x10, 0x23, 0x00, 0xFF, 0xFF,
320                                        0x00, 0xFF, 0x00, 0x40, 0x40 };
321         static u8 mt352_av771_extra[] = { 0xB5, 0x7A };
322         static u8 mt352_capt_range_cfg[] = { 0x75, 0x32 };
323
324         mt352_write(fe, mt352_clock_config, sizeof(mt352_clock_config));
325         udelay(2000);
326         mt352_write(fe, mt352_reset, sizeof(mt352_reset));
327         mt352_write(fe, mt352_adc_ctl_1_cfg, sizeof(mt352_adc_ctl_1_cfg));
328
329         mt352_write(fe, mt352_agc_cfg,sizeof(mt352_agc_cfg));
330         udelay(2000);
331         mt352_write(fe, mt352_av771_extra,sizeof(mt352_av771_extra));
332         mt352_write(fe, mt352_capt_range_cfg, sizeof(mt352_capt_range_cfg));
333
334         return 0;
335 }
336
337 static int advbt771_samsung_tdtc9251dh0_tuner_calc_regs(struct dvb_frontend *fe, u8 *pllbuf, int buf_len)
338 {
339         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
340         u32 div;
341         unsigned char bs = 0;
342         unsigned char cp = 0;
343
344         if (buf_len < 5) return -EINVAL;
345
346         div = (((c->frequency + 83333) * 3) / 500000) + IF_FREQUENCYx6;
347
348         if (c->frequency < 150000000)
349                 cp = 0xB4;
350         else if (c->frequency < 173000000)
351                 cp = 0xBC;
352         else if (c->frequency < 250000000)
353                 cp = 0xB4;
354         else if (c->frequency < 400000000)
355                 cp = 0xBC;
356         else if (c->frequency < 420000000)
357                 cp = 0xF4;
358         else if (c->frequency < 470000000)
359                 cp = 0xFC;
360         else if (c->frequency < 600000000)
361                 cp = 0xBC;
362         else if (c->frequency < 730000000)
363                 cp = 0xF4;
364         else
365                 cp = 0xFC;
366
367         if (c->frequency < 150000000)
368                 bs = 0x01;
369         else if (c->frequency < 173000000)
370                 bs = 0x01;
371         else if (c->frequency < 250000000)
372                 bs = 0x02;
373         else if (c->frequency < 400000000)
374                 bs = 0x02;
375         else if (c->frequency < 420000000)
376                 bs = 0x02;
377         else if (c->frequency < 470000000)
378                 bs = 0x02;
379         else
380                 bs = 0x08;
381
382         pllbuf[0] = 0x61;
383         pllbuf[1] = div >> 8;
384         pllbuf[2] = div & 0xff;
385         pllbuf[3] = cp;
386         pllbuf[4] = bs;
387
388         return 5;
389 }
390
391 static struct mt352_config advbt771_samsung_tdtc9251dh0_config = {
392         .demod_address = 0x0f,
393         .demod_init = advbt771_samsung_tdtc9251dh0_demod_init,
394 };
395
396 static struct dst_config dst_config = {
397         .demod_address = 0x55,
398 };
399
400 static int or51211_request_firmware(struct dvb_frontend* fe, const struct firmware **fw, char* name)
401 {
402         struct dvb_bt8xx_card* bt = (struct dvb_bt8xx_card*) fe->dvb->priv;
403
404         return request_firmware(fw, name, &bt->bt->dev->dev);
405 }
406
407 static void or51211_setmode(struct dvb_frontend * fe, int mode)
408 {
409         struct dvb_bt8xx_card *bt = fe->dvb->priv;
410         bttv_write_gpio(bt->bttv_nr, 0x0002, mode);   /* Reset */
411         msleep(20);
412 }
413
414 static void or51211_reset(struct dvb_frontend * fe)
415 {
416         struct dvb_bt8xx_card *bt = fe->dvb->priv;
417
418         /* RESET DEVICE
419          * reset is controlled by GPIO-0
420          * when set to 0 causes reset and when to 1 for normal op
421          * must remain reset for 128 clock cycles on a 50Mhz clock
422          * also PRM1 PRM2 & PRM4 are controlled by GPIO-1,GPIO-2 & GPIO-4
423          * We assume that the reset has be held low long enough or we
424          * have been reset by a power on.  When the driver is unloaded
425          * reset set to 0 so if reloaded we have been reset.
426          */
427         /* reset & PRM1,2&4 are outputs */
428         int ret = bttv_gpio_enable(bt->bttv_nr, 0x001F, 0x001F);
429         if (ret != 0)
430                 pr_warn("or51211: Init Error - Can't Reset DVR (%i)\n", ret);
431         bttv_write_gpio(bt->bttv_nr, 0x001F, 0x0000);   /* Reset */
432         msleep(20);
433         /* Now set for normal operation */
434         bttv_write_gpio(bt->bttv_nr, 0x0001F, 0x0001);
435         /* wait for operation to begin */
436         msleep(500);
437 }
438
439 static void or51211_sleep(struct dvb_frontend * fe)
440 {
441         struct dvb_bt8xx_card *bt = fe->dvb->priv;
442         bttv_write_gpio(bt->bttv_nr, 0x0001, 0x0000);
443 }
444
445 static const struct or51211_config or51211_config = {
446         .demod_address = 0x15,
447         .request_firmware = or51211_request_firmware,
448         .setmode = or51211_setmode,
449         .reset = or51211_reset,
450         .sleep = or51211_sleep,
451 };
452
453 static int vp3021_alps_tded4_tuner_set_params(struct dvb_frontend *fe)
454 {
455         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
456         struct dvb_bt8xx_card *card = (struct dvb_bt8xx_card *) fe->dvb->priv;
457         u8 buf[4];
458         u32 div;
459         struct i2c_msg msg = { .addr = 0x60, .flags = 0, .buf = buf, .len = sizeof(buf) };
460
461         div = (c->frequency + 36166667) / 166667;
462
463         buf[0] = (div >> 8) & 0x7F;
464         buf[1] = div & 0xFF;
465         buf[2] = 0x85;
466         if ((c->frequency >= 47000000) && (c->frequency < 153000000))
467                 buf[3] = 0x01;
468         else if ((c->frequency >= 153000000) && (c->frequency < 430000000))
469                 buf[3] = 0x02;
470         else if ((c->frequency >= 430000000) && (c->frequency < 824000000))
471                 buf[3] = 0x0C;
472         else if ((c->frequency >= 824000000) && (c->frequency < 863000000))
473                 buf[3] = 0x8C;
474         else
475                 return -EINVAL;
476
477         if (fe->ops.i2c_gate_ctrl)
478                 fe->ops.i2c_gate_ctrl(fe, 1);
479         i2c_transfer(card->i2c_adapter, &msg, 1);
480         return 0;
481 }
482
483 static struct nxt6000_config vp3021_alps_tded4_config = {
484         .demod_address = 0x0a,
485         .clock_inversion = 1,
486 };
487
488 static int digitv_alps_tded4_demod_init(struct dvb_frontend* fe)
489 {
490         static u8 mt352_clock_config [] = { 0x89, 0x38, 0x2d };
491         static u8 mt352_reset [] = { 0x50, 0x80 };
492         static u8 mt352_adc_ctl_1_cfg [] = { 0x8E, 0x40 };
493         static u8 mt352_agc_cfg [] = { 0x67, 0x20, 0xa0 };
494         static u8 mt352_capt_range_cfg[] = { 0x75, 0x32 };
495
496         mt352_write(fe, mt352_clock_config, sizeof(mt352_clock_config));
497         udelay(2000);
498         mt352_write(fe, mt352_reset, sizeof(mt352_reset));
499         mt352_write(fe, mt352_adc_ctl_1_cfg, sizeof(mt352_adc_ctl_1_cfg));
500         mt352_write(fe, mt352_agc_cfg,sizeof(mt352_agc_cfg));
501         mt352_write(fe, mt352_capt_range_cfg, sizeof(mt352_capt_range_cfg));
502
503         return 0;
504 }
505
506 static int digitv_alps_tded4_tuner_calc_regs(struct dvb_frontend *fe,  u8 *pllbuf, int buf_len)
507 {
508         u32 div;
509         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
510
511         if (buf_len < 5)
512                 return -EINVAL;
513
514         div = (((c->frequency + 83333) * 3) / 500000) + IF_FREQUENCYx6;
515
516         pllbuf[0] = 0x61;
517         pllbuf[1] = (div >> 8) & 0x7F;
518         pllbuf[2] = div & 0xFF;
519         pllbuf[3] = 0x85;
520
521         dprintk("frequency %u, div %u\n", c->frequency, div);
522
523         if (c->frequency < 470000000)
524                 pllbuf[4] = 0x02;
525         else if (c->frequency > 823000000)
526                 pllbuf[4] = 0x88;
527         else
528                 pllbuf[4] = 0x08;
529
530         if (c->bandwidth_hz == 8000000)
531                 pllbuf[4] |= 0x04;
532
533         return 5;
534 }
535
536 static void digitv_alps_tded4_reset(struct dvb_bt8xx_card *bt)
537 {
538         /*
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.
542          *
543          */
544
545         int ret = bttv_gpio_enable(bt->bttv_nr, 0x08, 0x08);
546         if (ret != 0)
547                 pr_warn("digitv_alps_tded4: Init Error - Can't Reset DVR (%i)\n",
548                         ret);
549
550         /* Pulse the reset line */
551         bttv_write_gpio(bt->bttv_nr, 0x08, 0x08); /* High */
552         bttv_write_gpio(bt->bttv_nr, 0x08, 0x00); /* Low  */
553         msleep(100);
554
555         bttv_write_gpio(bt->bttv_nr, 0x08, 0x08); /* High */
556 }
557
558 static struct mt352_config digitv_alps_tded4_config = {
559         .demod_address = 0x0a,
560         .demod_init = digitv_alps_tded4_demod_init,
561 };
562
563 static struct lgdt330x_config tdvs_tua6034_config = {
564         .demod_chip       = LGDT3303,
565         .serial_mpeg      = 0x40, /* TPSERIAL for 3303 in TOP_CONTROL */
566 };
567
568 static void lgdt330x_reset(struct dvb_bt8xx_card *bt)
569 {
570         /* Set pin 27 of the lgdt3303 chip high to reset the frontend */
571
572         /* Pulse the reset line */
573         bttv_write_gpio(bt->bttv_nr, 0x00e00007, 0x00000001); /* High */
574         bttv_write_gpio(bt->bttv_nr, 0x00e00007, 0x00000000); /* Low  */
575         msleep(100);
576
577         bttv_write_gpio(bt->bttv_nr, 0x00e00007, 0x00000001); /* High */
578         msleep(100);
579 }
580
581 static void frontend_init(struct dvb_bt8xx_card *card, u32 type)
582 {
583         struct dst_state* state = NULL;
584
585         switch(type) {
586         case BTTV_BOARD_DVICO_DVBT_LITE:
587                 card->fe = dvb_attach(mt352_attach, &thomson_dtt7579_config, card->i2c_adapter);
588
589                 if (card->fe == NULL)
590                         card->fe = dvb_attach(zl10353_attach, &thomson_dtt7579_zl10353_config,
591                                                   card->i2c_adapter);
592
593                 if (card->fe != NULL) {
594                         card->fe->ops.tuner_ops.calc_regs = thomson_dtt7579_tuner_calc_regs;
595                         card->fe->ops.info.frequency_min_hz = 174 * MHz;
596                         card->fe->ops.info.frequency_max_hz = 862 * MHz;
597                 }
598                 break;
599
600         case BTTV_BOARD_DVICO_FUSIONHDTV_5_LITE:
601                 lgdt330x_reset(card);
602                 card->fe = dvb_attach(lgdt330x_attach, &tdvs_tua6034_config,
603                                       0x0e, card->i2c_adapter);
604                 if (card->fe != NULL) {
605                         dvb_attach(simple_tuner_attach, card->fe,
606                                    card->i2c_adapter, 0x61,
607                                    TUNER_LG_TDVS_H06XF);
608                         dprintk("dvb_bt8xx: lgdt330x detected\n");
609                 }
610                 break;
611
612         case BTTV_BOARD_NEBULA_DIGITV:
613                 /*
614                  * It is possible to determine the correct frontend using the I2C bus (see the Nebula SDK);
615                  * this would be a cleaner solution than trying each frontend in turn.
616                  */
617
618                 /* Old Nebula (marked (c)2003 on high profile pci card) has nxt6000 demod */
619                 digitv_alps_tded4_reset(card);
620                 card->fe = dvb_attach(nxt6000_attach, &vp3021_alps_tded4_config, card->i2c_adapter);
621                 if (card->fe != NULL) {
622                         card->fe->ops.tuner_ops.set_params = vp3021_alps_tded4_tuner_set_params;
623                         dprintk("dvb_bt8xx: an nxt6000 was detected on your digitv card\n");
624                         break;
625                 }
626
627                 /* New Nebula (marked (c)2005 on low profile pci card) has mt352 demod */
628                 digitv_alps_tded4_reset(card);
629                 card->fe = dvb_attach(mt352_attach, &digitv_alps_tded4_config, card->i2c_adapter);
630
631                 if (card->fe != NULL) {
632                         card->fe->ops.tuner_ops.calc_regs = digitv_alps_tded4_tuner_calc_regs;
633                         dprintk("dvb_bt8xx: an mt352 was detected on your digitv card\n");
634                 }
635                 break;
636
637         case BTTV_BOARD_AVDVBT_761:
638                 card->fe = dvb_attach(sp887x_attach, &microtune_mt7202dtf_config, card->i2c_adapter);
639                 if (card->fe) {
640                         card->fe->ops.tuner_ops.set_params = microtune_mt7202dtf_tuner_set_params;
641                 }
642                 break;
643
644         case BTTV_BOARD_AVDVBT_771:
645                 card->fe = dvb_attach(mt352_attach, &advbt771_samsung_tdtc9251dh0_config, card->i2c_adapter);
646                 if (card->fe != NULL) {
647                         card->fe->ops.tuner_ops.calc_regs = advbt771_samsung_tdtc9251dh0_tuner_calc_regs;
648                         card->fe->ops.info.frequency_min_hz = 174 * MHz;
649                         card->fe->ops.info.frequency_max_hz = 862 * MHz;
650                 }
651                 break;
652
653         case BTTV_BOARD_TWINHAN_DST:
654                 /*      DST is not a frontend driver !!!                */
655                 state = kmalloc(sizeof (struct dst_state), GFP_KERNEL);
656                 if (!state) {
657                         pr_err("No memory\n");
658                         break;
659                 }
660                 /*      Setup the Card                                  */
661                 state->config = &dst_config;
662                 state->i2c = card->i2c_adapter;
663                 state->bt = card->bt;
664                 state->dst_ca = NULL;
665                 /*      DST is not a frontend, attaching the ASIC       */
666                 if (dvb_attach(dst_attach, state, &card->dvb_adapter) == NULL) {
667                         pr_err("%s: Could not find a Twinhan DST\n", __func__);
668                         kfree(state);
669                         break;
670                 }
671                 /*      Attach other DST peripherals if any             */
672                 /*      Conditional Access device                       */
673                 card->fe = &state->frontend;
674                 if (state->dst_hw_cap & DST_TYPE_HAS_CA)
675                         dvb_attach(dst_ca_attach, state, &card->dvb_adapter);
676                 break;
677
678         case BTTV_BOARD_PINNACLESAT:
679                 card->fe = dvb_attach(cx24110_attach, &pctvsat_config, card->i2c_adapter);
680                 if (card->fe) {
681                         card->fe->ops.tuner_ops.init = pinnsat_tuner_init;
682                         card->fe->ops.tuner_ops.sleep = pinnsat_tuner_sleep;
683                         card->fe->ops.tuner_ops.set_params = cx24108_tuner_set_params;
684                 }
685                 break;
686
687         case BTTV_BOARD_PC_HDTV:
688                 card->fe = dvb_attach(or51211_attach, &or51211_config, card->i2c_adapter);
689                 if (card->fe != NULL)
690                         dvb_attach(simple_tuner_attach, card->fe,
691                                    card->i2c_adapter, 0x61,
692                                    TUNER_PHILIPS_FCV1236D);
693                 break;
694         }
695
696         if (card->fe == NULL)
697                 pr_err("A frontend driver was not found for device [%04x:%04x] subsystem [%04x:%04x]\n",
698                        card->bt->dev->vendor,
699                        card->bt->dev->device,
700                        card->bt->dev->subsystem_vendor,
701                        card->bt->dev->subsystem_device);
702         else
703                 if (dvb_register_frontend(&card->dvb_adapter, card->fe)) {
704                         pr_err("Frontend registration failed!\n");
705                         dvb_frontend_detach(card->fe);
706                         card->fe = NULL;
707                 }
708 }
709
710 static int dvb_bt8xx_load_card(struct dvb_bt8xx_card *card, u32 type)
711 {
712         int result;
713
714         result = dvb_register_adapter(&card->dvb_adapter, card->card_name,
715                                       THIS_MODULE, &card->bt->dev->dev,
716                                       adapter_nr);
717         if (result < 0) {
718                 pr_err("dvb_register_adapter failed (errno = %d)\n", result);
719                 return result;
720         }
721         card->dvb_adapter.priv = card;
722
723         card->bt->adapter = card->i2c_adapter;
724
725         memset(&card->demux, 0, sizeof(struct dvb_demux));
726
727         card->demux.dmx.capabilities = DMX_TS_FILTERING | DMX_SECTION_FILTERING | DMX_MEMORY_BASED_FILTERING;
728
729         card->demux.priv = card;
730         card->demux.filternum = 256;
731         card->demux.feednum = 256;
732         card->demux.start_feed = dvb_bt8xx_start_feed;
733         card->demux.stop_feed = dvb_bt8xx_stop_feed;
734         card->demux.write_to_decoder = NULL;
735
736         result = dvb_dmx_init(&card->demux);
737         if (result < 0) {
738                 pr_err("dvb_dmx_init failed (errno = %d)\n", result);
739                 goto err_unregister_adaptor;
740         }
741
742         card->dmxdev.filternum = 256;
743         card->dmxdev.demux = &card->demux.dmx;
744         card->dmxdev.capabilities = 0;
745
746         result = dvb_dmxdev_init(&card->dmxdev, &card->dvb_adapter);
747         if (result < 0) {
748                 pr_err("dvb_dmxdev_init failed (errno = %d)\n", result);
749                 goto err_dmx_release;
750         }
751
752         card->fe_hw.source = DMX_FRONTEND_0;
753
754         result = card->demux.dmx.add_frontend(&card->demux.dmx, &card->fe_hw);
755         if (result < 0) {
756                 pr_err("dvb_dmx_init failed (errno = %d)\n", result);
757                 goto err_dmxdev_release;
758         }
759
760         card->fe_mem.source = DMX_MEMORY_FE;
761
762         result = card->demux.dmx.add_frontend(&card->demux.dmx, &card->fe_mem);
763         if (result < 0) {
764                 pr_err("dvb_dmx_init failed (errno = %d)\n", result);
765                 goto err_remove_hw_frontend;
766         }
767
768         result = card->demux.dmx.connect_frontend(&card->demux.dmx, &card->fe_hw);
769         if (result < 0) {
770                 pr_err("dvb_dmx_init failed (errno = %d)\n", result);
771                 goto err_remove_mem_frontend;
772         }
773
774         result = dvb_net_init(&card->dvb_adapter, &card->dvbnet, &card->demux.dmx);
775         if (result < 0) {
776                 pr_err("dvb_net_init failed (errno = %d)\n", result);
777                 goto err_disconnect_frontend;
778         }
779
780         tasklet_init(&card->bt->tasklet, dvb_bt8xx_task, (unsigned long) card);
781
782         frontend_init(card, type);
783
784         return 0;
785
786 err_disconnect_frontend:
787         card->demux.dmx.disconnect_frontend(&card->demux.dmx);
788 err_remove_mem_frontend:
789         card->demux.dmx.remove_frontend(&card->demux.dmx, &card->fe_mem);
790 err_remove_hw_frontend:
791         card->demux.dmx.remove_frontend(&card->demux.dmx, &card->fe_hw);
792 err_dmxdev_release:
793         dvb_dmxdev_release(&card->dmxdev);
794 err_dmx_release:
795         dvb_dmx_release(&card->demux);
796 err_unregister_adaptor:
797         dvb_unregister_adapter(&card->dvb_adapter);
798         return result;
799 }
800
801 static int dvb_bt8xx_probe(struct bttv_sub_device *sub)
802 {
803         struct dvb_bt8xx_card *card;
804         struct pci_dev* bttv_pci_dev;
805         int ret;
806
807         if (!(card = kzalloc(sizeof(struct dvb_bt8xx_card), GFP_KERNEL)))
808                 return -ENOMEM;
809
810         mutex_init(&card->lock);
811         card->bttv_nr = sub->core->nr;
812         strscpy(card->card_name, sub->core->v4l2_dev.name,
813                 sizeof(card->card_name));
814         card->i2c_adapter = &sub->core->i2c_adap;
815
816         switch(sub->core->type) {
817         case BTTV_BOARD_PINNACLESAT:
818                 card->gpio_mode = 0x0400c060;
819                 /* should be: BT878_A_GAIN=0,BT878_A_PWRDN,BT878_DA_DPM,BT878_DA_SBR,
820                               BT878_DA_IOM=1,BT878_DA_APP to enable serial highspeed mode. */
821                 card->op_sync_orin = BT878_RISC_SYNC_MASK;
822                 card->irq_err_ignore = BT878_AFBUS | BT878_AFDSR;
823                 break;
824
825         case BTTV_BOARD_DVICO_DVBT_LITE:
826                 card->gpio_mode = 0x0400C060;
827                 card->op_sync_orin = BT878_RISC_SYNC_MASK;
828                 card->irq_err_ignore = BT878_AFBUS | BT878_AFDSR;
829                 /* 26, 15, 14, 6, 5
830                  * A_PWRDN  DA_DPM DA_SBR DA_IOM_DA
831                  * DA_APP(parallel) */
832                 break;
833
834         case BTTV_BOARD_DVICO_FUSIONHDTV_5_LITE:
835                 card->gpio_mode = 0x0400c060;
836                 card->op_sync_orin = BT878_RISC_SYNC_MASK;
837                 card->irq_err_ignore = BT878_AFBUS | BT878_AFDSR;
838                 break;
839
840         case BTTV_BOARD_NEBULA_DIGITV:
841         case BTTV_BOARD_AVDVBT_761:
842                 card->gpio_mode = (1 << 26) | (1 << 14) | (1 << 5);
843                 card->op_sync_orin = BT878_RISC_SYNC_MASK;
844                 card->irq_err_ignore = BT878_AFBUS | BT878_AFDSR;
845                 /* A_PWRDN DA_SBR DA_APP (high speed serial) */
846                 break;
847
848         case BTTV_BOARD_AVDVBT_771: //case 0x07711461:
849                 card->gpio_mode = 0x0400402B;
850                 card->op_sync_orin = BT878_RISC_SYNC_MASK;
851                 card->irq_err_ignore = BT878_AFBUS | BT878_AFDSR;
852                 /* A_PWRDN DA_SBR  DA_APP[0] PKTP=10 RISC_ENABLE FIFO_ENABLE*/
853                 break;
854
855         case BTTV_BOARD_TWINHAN_DST:
856                 card->gpio_mode = 0x2204f2c;
857                 card->op_sync_orin = BT878_RISC_SYNC_MASK;
858                 card->irq_err_ignore = BT878_APABORT | BT878_ARIPERR |
859                                        BT878_APPERR | BT878_AFBUS;
860                 /* 25,21,14,11,10,9,8,3,2 then
861                  * 0x33 = 5,4,1,0
862                  * A_SEL=SML, DA_MLB, DA_SBR,
863                  * DA_SDR=f, fifo trigger = 32 DWORDS
864                  * IOM = 0 == audio A/D
865                  * DPM = 0 == digital audio mode
866                  * == async data parallel port
867                  * then 0x33 (13 is set by start_capture)
868                  * DA_APP = async data parallel port,
869                  * ACAP_EN = 1,
870                  * RISC+FIFO ENABLE */
871                 break;
872
873         case BTTV_BOARD_PC_HDTV:
874                 card->gpio_mode = 0x0100EC7B;
875                 card->op_sync_orin = BT878_RISC_SYNC_MASK;
876                 card->irq_err_ignore = BT878_AFBUS | BT878_AFDSR;
877                 break;
878
879         default:
880                 pr_err("Unknown bttv card type: %d\n", sub->core->type);
881                 kfree(card);
882                 return -ENODEV;
883         }
884
885         dprintk("dvb_bt8xx: identified card%d as %s\n", card->bttv_nr, card->card_name);
886
887         if (!(bttv_pci_dev = bttv_get_pcidev(card->bttv_nr))) {
888                 pr_err("no pci device for card %d\n", card->bttv_nr);
889                 kfree(card);
890                 return -ENODEV;
891         }
892
893         if (!(card->bt = dvb_bt8xx_878_match(card->bttv_nr, bttv_pci_dev))) {
894                 pr_err("unable to determine DMA core of card %d,\n", card->bttv_nr);
895                 pr_err("if you have the ALSA bt87x audio driver installed, try removing it.\n");
896
897                 kfree(card);
898                 return -ENODEV;
899         }
900
901         mutex_init(&card->bt->gpio_lock);
902         card->bt->bttv_nr = sub->core->nr;
903
904         if ( (ret = dvb_bt8xx_load_card(card, sub->core->type)) ) {
905                 kfree(card);
906                 return ret;
907         }
908
909         dev_set_drvdata(&sub->dev, card);
910         return 0;
911 }
912
913 static void dvb_bt8xx_remove(struct bttv_sub_device *sub)
914 {
915         struct dvb_bt8xx_card *card = dev_get_drvdata(&sub->dev);
916
917         dprintk("dvb_bt8xx: unloading card%d\n", card->bttv_nr);
918
919         bt878_stop(card->bt);
920         tasklet_kill(&card->bt->tasklet);
921         dvb_net_release(&card->dvbnet);
922         card->demux.dmx.remove_frontend(&card->demux.dmx, &card->fe_mem);
923         card->demux.dmx.remove_frontend(&card->demux.dmx, &card->fe_hw);
924         dvb_dmxdev_release(&card->dmxdev);
925         dvb_dmx_release(&card->demux);
926         if (card->fe) {
927                 dvb_unregister_frontend(card->fe);
928                 dvb_frontend_detach(card->fe);
929         }
930         dvb_unregister_adapter(&card->dvb_adapter);
931
932         kfree(card);
933 }
934
935 static struct bttv_sub_driver driver = {
936         .drv = {
937                 .name           = "dvb-bt8xx",
938         },
939         .probe          = dvb_bt8xx_probe,
940         .remove         = dvb_bt8xx_remove,
941         /* FIXME:
942          * .shutdown    = dvb_bt8xx_shutdown,
943          * .suspend     = dvb_bt8xx_suspend,
944          * .resume      = dvb_bt8xx_resume,
945          */
946 };
947
948 static int __init dvb_bt8xx_init(void)
949 {
950         return bttv_sub_register(&driver, "dvb");
951 }
952
953 static void __exit dvb_bt8xx_exit(void)
954 {
955         bttv_sub_unregister(&driver);
956 }
957
958 module_init(dvb_bt8xx_init);
959 module_exit(dvb_bt8xx_exit);
960
961 MODULE_DESCRIPTION("Bt8xx based DVB adapter driver");
962 MODULE_AUTHOR("Florian Schirmer <jolt@tuxbox.org>");
963 MODULE_LICENSE("GPL");