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