?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rt2800: initialize BBP_R104 on proper subroutines
[linux/fpc-iii.git] / drivers / media / pci / cx88 / cx88-dvb.c
blob053ed1ba1d85f34810b37dd78681d2cd5b9541e4
1 /*
2 *
3 * device driver for Conexant 2388x based TV cards
4 * MPEG Transport Stream (DVB) routines
5 *
6 * (c) 2004, 2005 Chris Pascoe <c.pascoe@itee.uq.edu.au>
7 * (c) 2004 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #include <linux/module.h>
25 #include <linux/init.h>
26 #include <linux/device.h>
27 #include <linux/fs.h>
28 #include <linux/kthread.h>
29 #include <linux/file.h>
30 #include <linux/suspend.h>
31
32 #include "cx88.h"
33 #include "dvb-pll.h"
34 #include <media/v4l2-common.h>
35
36 #include "mt352.h"
37 #include "mt352_priv.h"
38 #include "cx88-vp3054-i2c.h"
39 #include "zl10353.h"
40 #include "cx22702.h"
41 #include "or51132.h"
42 #include "lgdt330x.h"
43 #include "s5h1409.h"
44 #include "xc4000.h"
45 #include "xc5000.h"
46 #include "nxt200x.h"
47 #include "cx24123.h"
48 #include "isl6421.h"
49 #include "tuner-simple.h"
50 #include "tda9887.h"
51 #include "s5h1411.h"
52 #include "stv0299.h"
53 #include "z0194a.h"
54 #include "stv0288.h"
55 #include "stb6000.h"
56 #include "cx24116.h"
57 #include "stv0900.h"
58 #include "stb6100.h"
59 #include "stb6100_proc.h"
60 #include "mb86a16.h"
61 #include "ts2020.h"
62 #include "ds3000.h"
63
64 MODULE_DESCRIPTION("driver for cx2388x based DVB cards");
65 MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>");
66 MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]");
67 MODULE_LICENSE("GPL");
68 MODULE_VERSION(CX88_VERSION);
69
70 static unsigned int debug;
71 module_param(debug, int, 0644);
72 MODULE_PARM_DESC(debug,"enable debug messages [dvb]");
73
74 static unsigned int dvb_buf_tscnt = 32;
75 module_param(dvb_buf_tscnt, int, 0644);
76 MODULE_PARM_DESC(dvb_buf_tscnt, "DVB Buffer TS count [dvb]");
77
78 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
79
80 #define dprintk(level,fmt, arg...) if (debug >= level) \
81 printk(KERN_DEBUG "%s/2-dvb: " fmt, core->name, ## arg)
82
83 /* ------------------------------------------------------------------ */
84
85 static int dvb_buf_setup(struct videobuf_queue *q,
86 unsigned int *count, unsigned int *size)
87 {
88 struct cx8802_dev *dev = q->priv_data;
89
90 dev->ts_packet_size = 188 * 4;
91 dev->ts_packet_count = dvb_buf_tscnt;
92
93 *size = dev->ts_packet_size * dev->ts_packet_count;
94 *count = dvb_buf_tscnt;
95 return 0;
96 }
97
98 static int dvb_buf_prepare(struct videobuf_queue *q,
99 struct videobuf_buffer *vb, enum v4l2_field field)
100 {
101 struct cx8802_dev *dev = q->priv_data;
102 return cx8802_buf_prepare(q, dev, (struct cx88_buffer*)vb,field);
103 }
104
105 static void dvb_buf_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
106 {
107 struct cx8802_dev *dev = q->priv_data;
108 cx8802_buf_queue(dev, (struct cx88_buffer*)vb);
109 }
110
111 static void dvb_buf_release(struct videobuf_queue *q,
112 struct videobuf_buffer *vb)
113 {
114 cx88_free_buffer(q, (struct cx88_buffer*)vb);
115 }
116
117 static const struct videobuf_queue_ops dvb_qops = {
118 .buf_setup = dvb_buf_setup,
119 .buf_prepare = dvb_buf_prepare,
120 .buf_queue = dvb_buf_queue,
121 .buf_release = dvb_buf_release,
122 };
123
124 /* ------------------------------------------------------------------ */
125
126 static int cx88_dvb_bus_ctrl(struct dvb_frontend* fe, int acquire)
127 {
128 struct cx8802_dev *dev= fe->dvb->priv;
129 struct cx8802_driver *drv = NULL;
130 int ret = 0;
131 int fe_id;
132
133 fe_id = videobuf_dvb_find_frontend(&dev->frontends, fe);
134 if (!fe_id) {
135 printk(KERN_ERR "%s() No frontend found\n", __func__);
136 return -EINVAL;
137 }
138
139 mutex_lock(&dev->core->lock);
140 drv = cx8802_get_driver(dev, CX88_MPEG_DVB);
141 if (drv) {
142 if (acquire){
143 dev->frontends.active_fe_id = fe_id;
144 ret = drv->request_acquire(drv);
145 } else {
146 ret = drv->request_release(drv);
147 dev->frontends.active_fe_id = 0;
148 }
149 }
150 mutex_unlock(&dev->core->lock);
151
152 return ret;
153 }
154
155 static void cx88_dvb_gate_ctrl(struct cx88_core *core, int open)
156 {
157 struct videobuf_dvb_frontends *f;
158 struct videobuf_dvb_frontend *fe;
159
160 if (!core->dvbdev)
161 return;
162
163 f = &core->dvbdev->frontends;
164
165 if (!f)
166 return;
167
168 if (f->gate <= 1) /* undefined or fe0 */
169 fe = videobuf_dvb_get_frontend(f, 1);
170 else
171 fe = videobuf_dvb_get_frontend(f, f->gate);
172
173 if (fe && fe->dvb.frontend && fe->dvb.frontend->ops.i2c_gate_ctrl)
174 fe->dvb.frontend->ops.i2c_gate_ctrl(fe->dvb.frontend, open);
175 }
176
177 /* ------------------------------------------------------------------ */
178
179 static int dvico_fusionhdtv_demod_init(struct dvb_frontend* fe)
180 {
181 static const u8 clock_config [] = { CLOCK_CTL, 0x38, 0x39 };
182 static const u8 reset [] = { RESET, 0x80 };
183 static const u8 adc_ctl_1_cfg [] = { ADC_CTL_1, 0x40 };
184 static const u8 agc_cfg [] = { AGC_TARGET, 0x24, 0x20 };
185 static const u8 gpp_ctl_cfg [] = { GPP_CTL, 0x33 };
186 static const u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
187
188 mt352_write(fe, clock_config, sizeof(clock_config));
189 udelay(200);
190 mt352_write(fe, reset, sizeof(reset));
191 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
192
193 mt352_write(fe, agc_cfg, sizeof(agc_cfg));
194 mt352_write(fe, gpp_ctl_cfg, sizeof(gpp_ctl_cfg));
195 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
196 return 0;
197 }
198
199 static int dvico_dual_demod_init(struct dvb_frontend *fe)
200 {
201 static const u8 clock_config [] = { CLOCK_CTL, 0x38, 0x38 };
202 static const u8 reset [] = { RESET, 0x80 };
203 static const u8 adc_ctl_1_cfg [] = { ADC_CTL_1, 0x40 };
204 static const u8 agc_cfg [] = { AGC_TARGET, 0x28, 0x20 };
205 static const u8 gpp_ctl_cfg [] = { GPP_CTL, 0x33 };
206 static const u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
207
208 mt352_write(fe, clock_config, sizeof(clock_config));
209 udelay(200);
210 mt352_write(fe, reset, sizeof(reset));
211 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
212
213 mt352_write(fe, agc_cfg, sizeof(agc_cfg));
214 mt352_write(fe, gpp_ctl_cfg, sizeof(gpp_ctl_cfg));
215 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
216
217 return 0;
218 }
219
220 static int dntv_live_dvbt_demod_init(struct dvb_frontend* fe)
221 {
222 static const u8 clock_config [] = { 0x89, 0x38, 0x39 };
223 static const u8 reset [] = { 0x50, 0x80 };
224 static const u8 adc_ctl_1_cfg [] = { 0x8E, 0x40 };
225 static const u8 agc_cfg [] = { 0x67, 0x10, 0x23, 0x00, 0xFF, 0xFF,
226 0x00, 0xFF, 0x00, 0x40, 0x40 };
227 static const u8 dntv_extra[] = { 0xB5, 0x7A };
228 static const u8 capt_range_cfg[] = { 0x75, 0x32 };
229
230 mt352_write(fe, clock_config, sizeof(clock_config));
231 udelay(2000);
232 mt352_write(fe, reset, sizeof(reset));
233 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
234
235 mt352_write(fe, agc_cfg, sizeof(agc_cfg));
236 udelay(2000);
237 mt352_write(fe, dntv_extra, sizeof(dntv_extra));
238 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
239
240 return 0;
241 }
242
243 static const struct mt352_config dvico_fusionhdtv = {
244 .demod_address = 0x0f,
245 .demod_init = dvico_fusionhdtv_demod_init,
246 };
247
248 static const struct mt352_config dntv_live_dvbt_config = {
249 .demod_address = 0x0f,
250 .demod_init = dntv_live_dvbt_demod_init,
251 };
252
253 static const struct mt352_config dvico_fusionhdtv_dual = {
254 .demod_address = 0x0f,
255 .demod_init = dvico_dual_demod_init,
256 };
257
258 static const struct zl10353_config cx88_terratec_cinergy_ht_pci_mkii_config = {
259 .demod_address = (0x1e >> 1),
260 .no_tuner = 1,
261 .if2 = 45600,
262 };
263
264 static struct mb86a16_config twinhan_vp1027 = {
265 .demod_address = 0x08,
266 };
267
268 #if IS_ENABLED(CONFIG_VIDEO_CX88_VP3054)
269 static int dntv_live_dvbt_pro_demod_init(struct dvb_frontend* fe)
270 {
271 static const u8 clock_config [] = { 0x89, 0x38, 0x38 };
272 static const u8 reset [] = { 0x50, 0x80 };
273 static const u8 adc_ctl_1_cfg [] = { 0x8E, 0x40 };
274 static const u8 agc_cfg [] = { 0x67, 0x10, 0x20, 0x00, 0xFF, 0xFF,
275 0x00, 0xFF, 0x00, 0x40, 0x40 };
276 static const u8 dntv_extra[] = { 0xB5, 0x7A };
277 static const u8 capt_range_cfg[] = { 0x75, 0x32 };
278
279 mt352_write(fe, clock_config, sizeof(clock_config));
280 udelay(2000);
281 mt352_write(fe, reset, sizeof(reset));
282 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
283
284 mt352_write(fe, agc_cfg, sizeof(agc_cfg));
285 udelay(2000);
286 mt352_write(fe, dntv_extra, sizeof(dntv_extra));
287 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
288
289 return 0;
290 }
291
292 static const struct mt352_config dntv_live_dvbt_pro_config = {
293 .demod_address = 0x0f,
294 .no_tuner = 1,
295 .demod_init = dntv_live_dvbt_pro_demod_init,
296 };
297 #endif
298
299 static const struct zl10353_config dvico_fusionhdtv_hybrid = {
300 .demod_address = 0x0f,
301 .no_tuner = 1,
302 };
303
304 static const struct zl10353_config dvico_fusionhdtv_xc3028 = {
305 .demod_address = 0x0f,
306 .if2 = 45600,
307 .no_tuner = 1,
308 };
309
310 static const struct mt352_config dvico_fusionhdtv_mt352_xc3028 = {
311 .demod_address = 0x0f,
312 .if2 = 4560,
313 .no_tuner = 1,
314 .demod_init = dvico_fusionhdtv_demod_init,
315 };
316
317 static const struct zl10353_config dvico_fusionhdtv_plus_v1_1 = {
318 .demod_address = 0x0f,
319 };
320
321 static const struct cx22702_config connexant_refboard_config = {
322 .demod_address = 0x43,
323 .output_mode = CX22702_SERIAL_OUTPUT,
324 };
325
326 static const struct cx22702_config hauppauge_hvr_config = {
327 .demod_address = 0x63,
328 .output_mode = CX22702_SERIAL_OUTPUT,
329 };
330
331 static int or51132_set_ts_param(struct dvb_frontend* fe, int is_punctured)
332 {
333 struct cx8802_dev *dev= fe->dvb->priv;
334 dev->ts_gen_cntrl = is_punctured ? 0x04 : 0x00;
335 return 0;
336 }
337
338 static const struct or51132_config pchdtv_hd3000 = {
339 .demod_address = 0x15,
340 .set_ts_params = or51132_set_ts_param,
341 };
342
343 static int lgdt330x_pll_rf_set(struct dvb_frontend* fe, int index)
344 {
345 struct cx8802_dev *dev= fe->dvb->priv;
346 struct cx88_core *core = dev->core;
347
348 dprintk(1, "%s: index = %d\n", __func__, index);
349 if (index == 0)
350 cx_clear(MO_GP0_IO, 8);
351 else
352 cx_set(MO_GP0_IO, 8);
353 return 0;
354 }
355
356 static int lgdt330x_set_ts_param(struct dvb_frontend* fe, int is_punctured)
357 {
358 struct cx8802_dev *dev= fe->dvb->priv;
359 if (is_punctured)
360 dev->ts_gen_cntrl |= 0x04;
361 else
362 dev->ts_gen_cntrl &= ~0x04;
363 return 0;
364 }
365
366 static struct lgdt330x_config fusionhdtv_3_gold = {
367 .demod_address = 0x0e,
368 .demod_chip = LGDT3302,
369 .serial_mpeg = 0x04, /* TPSERIAL for 3302 in TOP_CONTROL */
370 .set_ts_params = lgdt330x_set_ts_param,
371 };
372
373 static const struct lgdt330x_config fusionhdtv_5_gold = {
374 .demod_address = 0x0e,
375 .demod_chip = LGDT3303,
376 .serial_mpeg = 0x40, /* TPSERIAL for 3303 in TOP_CONTROL */
377 .set_ts_params = lgdt330x_set_ts_param,
378 };
379
380 static const struct lgdt330x_config pchdtv_hd5500 = {
381 .demod_address = 0x59,
382 .demod_chip = LGDT3303,
383 .serial_mpeg = 0x40, /* TPSERIAL for 3303 in TOP_CONTROL */
384 .set_ts_params = lgdt330x_set_ts_param,
385 };
386
387 static int nxt200x_set_ts_param(struct dvb_frontend* fe, int is_punctured)
388 {
389 struct cx8802_dev *dev= fe->dvb->priv;
390 dev->ts_gen_cntrl = is_punctured ? 0x04 : 0x00;
391 return 0;
392 }
393
394 static const struct nxt200x_config ati_hdtvwonder = {
395 .demod_address = 0x0a,
396 .set_ts_params = nxt200x_set_ts_param,
397 };
398
399 static int cx24123_set_ts_param(struct dvb_frontend* fe,
400 int is_punctured)
401 {
402 struct cx8802_dev *dev= fe->dvb->priv;
403 dev->ts_gen_cntrl = 0x02;
404 return 0;
405 }
406
407 static int kworld_dvbs_100_set_voltage(struct dvb_frontend* fe,
408 fe_sec_voltage_t voltage)
409 {
410 struct cx8802_dev *dev= fe->dvb->priv;
411 struct cx88_core *core = dev->core;
412
413 if (voltage == SEC_VOLTAGE_OFF)
414 cx_write(MO_GP0_IO, 0x000006fb);
415 else
416 cx_write(MO_GP0_IO, 0x000006f9);
417
418 if (core->prev_set_voltage)
419 return core->prev_set_voltage(fe, voltage);
420 return 0;
421 }
422
423 static int geniatech_dvbs_set_voltage(struct dvb_frontend *fe,
424 fe_sec_voltage_t voltage)
425 {
426 struct cx8802_dev *dev= fe->dvb->priv;
427 struct cx88_core *core = dev->core;
428
429 if (voltage == SEC_VOLTAGE_OFF) {
430 dprintk(1,"LNB Voltage OFF\n");
431 cx_write(MO_GP0_IO, 0x0000efff);
432 }
433
434 if (core->prev_set_voltage)
435 return core->prev_set_voltage(fe, voltage);
436 return 0;
437 }
438
439 static int tevii_dvbs_set_voltage(struct dvb_frontend *fe,
440 fe_sec_voltage_t voltage)
441 {
442 struct cx8802_dev *dev= fe->dvb->priv;
443 struct cx88_core *core = dev->core;
444
445 cx_set(MO_GP0_IO, 0x6040);
446 switch (voltage) {
447 case SEC_VOLTAGE_13:
448 cx_clear(MO_GP0_IO, 0x20);
449 break;
450 case SEC_VOLTAGE_18:
451 cx_set(MO_GP0_IO, 0x20);
452 break;
453 case SEC_VOLTAGE_OFF:
454 cx_clear(MO_GP0_IO, 0x20);
455 break;
456 }
457
458 if (core->prev_set_voltage)
459 return core->prev_set_voltage(fe, voltage);
460 return 0;
461 }
462
463 static int vp1027_set_voltage(struct dvb_frontend *fe,
464 fe_sec_voltage_t voltage)
465 {
466 struct cx8802_dev *dev = fe->dvb->priv;
467 struct cx88_core *core = dev->core;
468
469 switch (voltage) {
470 case SEC_VOLTAGE_13:
471 dprintk(1, "LNB SEC Voltage=13\n");
472 cx_write(MO_GP0_IO, 0x00001220);
473 break;
474 case SEC_VOLTAGE_18:
475 dprintk(1, "LNB SEC Voltage=18\n");
476 cx_write(MO_GP0_IO, 0x00001222);
477 break;
478 case SEC_VOLTAGE_OFF:
479 dprintk(1, "LNB Voltage OFF\n");
480 cx_write(MO_GP0_IO, 0x00001230);
481 break;
482 }
483
484 if (core->prev_set_voltage)
485 return core->prev_set_voltage(fe, voltage);
486 return 0;
487 }
488
489 static const struct cx24123_config geniatech_dvbs_config = {
490 .demod_address = 0x55,
491 .set_ts_params = cx24123_set_ts_param,
492 };
493
494 static const struct cx24123_config hauppauge_novas_config = {
495 .demod_address = 0x55,
496 .set_ts_params = cx24123_set_ts_param,
497 };
498
499 static const struct cx24123_config kworld_dvbs_100_config = {
500 .demod_address = 0x15,
501 .set_ts_params = cx24123_set_ts_param,
502 .lnb_polarity = 1,
503 };
504
505 static const struct s5h1409_config pinnacle_pctv_hd_800i_config = {
506 .demod_address = 0x32 >> 1,
507 .output_mode = S5H1409_PARALLEL_OUTPUT,
508 .gpio = S5H1409_GPIO_ON,
509 .qam_if = 44000,
510 .inversion = S5H1409_INVERSION_OFF,
511 .status_mode = S5H1409_DEMODLOCKING,
512 .mpeg_timing = S5H1409_MPEGTIMING_NONCONTINOUS_NONINVERTING_CLOCK,
513 };
514
515 static const struct s5h1409_config dvico_hdtv5_pci_nano_config = {
516 .demod_address = 0x32 >> 1,
517 .output_mode = S5H1409_SERIAL_OUTPUT,
518 .gpio = S5H1409_GPIO_OFF,
519 .inversion = S5H1409_INVERSION_OFF,
520 .status_mode = S5H1409_DEMODLOCKING,
521 .mpeg_timing = S5H1409_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK,
522 };
523
524 static const struct s5h1409_config kworld_atsc_120_config = {
525 .demod_address = 0x32 >> 1,
526 .output_mode = S5H1409_SERIAL_OUTPUT,
527 .gpio = S5H1409_GPIO_OFF,
528 .inversion = S5H1409_INVERSION_OFF,
529 .status_mode = S5H1409_DEMODLOCKING,
530 .mpeg_timing = S5H1409_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK,
531 };
532
533 static const struct xc5000_config pinnacle_pctv_hd_800i_tuner_config = {
534 .i2c_address = 0x64,
535 .if_khz = 5380,
536 };
537
538 static const struct zl10353_config cx88_pinnacle_hybrid_pctv = {
539 .demod_address = (0x1e >> 1),
540 .no_tuner = 1,
541 .if2 = 45600,
542 };
543
544 static const struct zl10353_config cx88_geniatech_x8000_mt = {
545 .demod_address = (0x1e >> 1),
546 .no_tuner = 1,
547 .disable_i2c_gate_ctrl = 1,
548 };
549
550 static const struct s5h1411_config dvico_fusionhdtv7_config = {
551 .output_mode = S5H1411_SERIAL_OUTPUT,
552 .gpio = S5H1411_GPIO_ON,
553 .mpeg_timing = S5H1411_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK,
554 .qam_if = S5H1411_IF_44000,
555 .vsb_if = S5H1411_IF_44000,
556 .inversion = S5H1411_INVERSION_OFF,
557 .status_mode = S5H1411_DEMODLOCKING
558 };
559
560 static const struct xc5000_config dvico_fusionhdtv7_tuner_config = {
561 .i2c_address = 0xc2 >> 1,
562 .if_khz = 5380,
563 };
564
565 static int attach_xc3028(u8 addr, struct cx8802_dev *dev)
566 {
567 struct dvb_frontend *fe;
568 struct videobuf_dvb_frontend *fe0 = NULL;
569 struct xc2028_ctrl ctl;
570 struct xc2028_config cfg = {
571 .i2c_adap = &dev->core->i2c_adap,
572 .i2c_addr = addr,
573 .ctrl = &ctl,
574 };
575
576 /* Get the first frontend */
577 fe0 = videobuf_dvb_get_frontend(&dev->frontends, 1);
578 if (!fe0)
579 return -EINVAL;
580
581 if (!fe0->dvb.frontend) {
582 printk(KERN_ERR "%s/2: dvb frontend not attached. "
583 "Can't attach xc3028\n",
584 dev->core->name);
585 return -EINVAL;
586 }
587
588 /*
589 * Some xc3028 devices may be hidden by an I2C gate. This is known
590 * to happen with some s5h1409-based devices.
591 * Now that I2C gate is open, sets up xc3028 configuration
592 */
593 cx88_setup_xc3028(dev->core, &ctl);
594
595 fe = dvb_attach(xc2028_attach, fe0->dvb.frontend, &cfg);
596 if (!fe) {
597 printk(KERN_ERR "%s/2: xc3028 attach failed\n",
598 dev->core->name);
599 dvb_frontend_detach(fe0->dvb.frontend);
600 dvb_unregister_frontend(fe0->dvb.frontend);
601 fe0->dvb.frontend = NULL;
602 return -EINVAL;
603 }
604
605 printk(KERN_INFO "%s/2: xc3028 attached\n",
606 dev->core->name);
607
608 return 0;
609 }
610
611 static int attach_xc4000(struct cx8802_dev *dev, struct xc4000_config *cfg)
612 {
613 struct dvb_frontend *fe;
614 struct videobuf_dvb_frontend *fe0 = NULL;
615
616 /* Get the first frontend */
617 fe0 = videobuf_dvb_get_frontend(&dev->frontends, 1);
618 if (!fe0)
619 return -EINVAL;
620
621 if (!fe0->dvb.frontend) {
622 printk(KERN_ERR "%s/2: dvb frontend not attached. "
623 "Can't attach xc4000\n",
624 dev->core->name);
625 return -EINVAL;
626 }
627
628 fe = dvb_attach(xc4000_attach, fe0->dvb.frontend, &dev->core->i2c_adap,
629 cfg);
630 if (!fe) {
631 printk(KERN_ERR "%s/2: xc4000 attach failed\n",
632 dev->core->name);
633 dvb_frontend_detach(fe0->dvb.frontend);
634 dvb_unregister_frontend(fe0->dvb.frontend);
635 fe0->dvb.frontend = NULL;
636 return -EINVAL;
637 }
638
639 printk(KERN_INFO "%s/2: xc4000 attached\n", dev->core->name);
640
641 return 0;
642 }
643
644 static int cx24116_set_ts_param(struct dvb_frontend *fe,
645 int is_punctured)
646 {
647 struct cx8802_dev *dev = fe->dvb->priv;
648 dev->ts_gen_cntrl = 0x2;
649
650 return 0;
651 }
652
653 static int stv0900_set_ts_param(struct dvb_frontend *fe,
654 int is_punctured)
655 {
656 struct cx8802_dev *dev = fe->dvb->priv;
657 dev->ts_gen_cntrl = 0;
658
659 return 0;
660 }
661
662 static int cx24116_reset_device(struct dvb_frontend *fe)
663 {
664 struct cx8802_dev *dev = fe->dvb->priv;
665 struct cx88_core *core = dev->core;
666
667 /* Reset the part */
668 /* Put the cx24116 into reset */
669 cx_write(MO_SRST_IO, 0);
670 msleep(10);
671 /* Take the cx24116 out of reset */
672 cx_write(MO_SRST_IO, 1);
673 msleep(10);
674
675 return 0;
676 }
677
678 static const struct cx24116_config hauppauge_hvr4000_config = {
679 .demod_address = 0x05,
680 .set_ts_params = cx24116_set_ts_param,
681 .reset_device = cx24116_reset_device,
682 };
683
684 static const struct cx24116_config tevii_s460_config = {
685 .demod_address = 0x55,
686 .set_ts_params = cx24116_set_ts_param,
687 .reset_device = cx24116_reset_device,
688 };
689
690 static int ds3000_set_ts_param(struct dvb_frontend *fe,
691 int is_punctured)
692 {
693 struct cx8802_dev *dev = fe->dvb->priv;
694 dev->ts_gen_cntrl = 4;
695
696 return 0;
697 }
698
699 static struct ds3000_config tevii_ds3000_config = {
700 .demod_address = 0x68,
701 .set_ts_params = ds3000_set_ts_param,
702 };
703
704 static struct ts2020_config tevii_ts2020_config = {
705 .tuner_address = 0x60,
706 .clk_out_div = 1,
707 };
708
709 static const struct stv0900_config prof_7301_stv0900_config = {
710 .demod_address = 0x6a,
711 /* demod_mode = 0,*/
712 .xtal = 27000000,
713 .clkmode = 3,/* 0-CLKI, 2-XTALI, else AUTO */
714 .diseqc_mode = 2,/* 2/3 PWM */
715 .tun1_maddress = 0,/* 0x60 */
716 .tun1_adc = 0,/* 2 Vpp */
717 .path1_mode = 3,
718 .set_ts_params = stv0900_set_ts_param,
719 };
720
721 static const struct stb6100_config prof_7301_stb6100_config = {
722 .tuner_address = 0x60,
723 .refclock = 27000000,
724 };
725
726 static const struct stv0299_config tevii_tuner_sharp_config = {
727 .demod_address = 0x68,
728 .inittab = sharp_z0194a_inittab,
729 .mclk = 88000000UL,
730 .invert = 1,
731 .skip_reinit = 0,
732 .lock_output = 1,
733 .volt13_op0_op1 = STV0299_VOLT13_OP1,
734 .min_delay_ms = 100,
735 .set_symbol_rate = sharp_z0194a_set_symbol_rate,
736 .set_ts_params = cx24116_set_ts_param,
737 };
738
739 static const struct stv0288_config tevii_tuner_earda_config = {
740 .demod_address = 0x68,
741 .min_delay_ms = 100,
742 .set_ts_params = cx24116_set_ts_param,
743 };
744
745 static int cx8802_alloc_frontends(struct cx8802_dev *dev)
746 {
747 struct cx88_core *core = dev->core;
748 struct videobuf_dvb_frontend *fe = NULL;
749 int i;
750
751 mutex_init(&dev->frontends.lock);
752 INIT_LIST_HEAD(&dev->frontends.felist);
753
754 if (!core->board.num_frontends)
755 return -ENODEV;
756
757 printk(KERN_INFO "%s() allocating %d frontend(s)\n", __func__,
758 core->board.num_frontends);
759 for (i = 1; i <= core->board.num_frontends; i++) {
760 fe = videobuf_dvb_alloc_frontend(&dev->frontends, i);
761 if (!fe) {
762 printk(KERN_ERR "%s() failed to alloc\n", __func__);
763 videobuf_dvb_dealloc_frontends(&dev->frontends);
764 return -ENOMEM;
765 }
766 }
767 return 0;
768 }
769
770
771
772 static const u8 samsung_smt_7020_inittab[] = {
773 0x01, 0x15,
774 0x02, 0x00,
775 0x03, 0x00,
776 0x04, 0x7D,
777 0x05, 0x0F,
778 0x06, 0x02,
779 0x07, 0x00,
780 0x08, 0x60,
781
782 0x0A, 0xC2,
783 0x0B, 0x00,
784 0x0C, 0x01,
785 0x0D, 0x81,
786 0x0E, 0x44,
787 0x0F, 0x09,
788 0x10, 0x3C,
789 0x11, 0x84,
790 0x12, 0xDA,
791 0x13, 0x99,
792 0x14, 0x8D,
793 0x15, 0xCE,
794 0x16, 0xE8,
795 0x17, 0x43,
796 0x18, 0x1C,
797 0x19, 0x1B,
798 0x1A, 0x1D,
799
800 0x1C, 0x12,
801 0x1D, 0x00,
802 0x1E, 0x00,
803 0x1F, 0x00,
804 0x20, 0x00,
805 0x21, 0x00,
806 0x22, 0x00,
807 0x23, 0x00,
808
809 0x28, 0x02,
810 0x29, 0x28,
811 0x2A, 0x14,
812 0x2B, 0x0F,
813 0x2C, 0x09,
814 0x2D, 0x05,
815
816 0x31, 0x1F,
817 0x32, 0x19,
818 0x33, 0xFC,
819 0x34, 0x13,
820 0xff, 0xff,
821 };
822
823
824 static int samsung_smt_7020_tuner_set_params(struct dvb_frontend *fe)
825 {
826 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
827 struct cx8802_dev *dev = fe->dvb->priv;
828 u8 buf[4];
829 u32 div;
830 struct i2c_msg msg = {
831 .addr = 0x61,
832 .flags = 0,
833 .buf = buf,
834 .len = sizeof(buf) };
835
836 div = c->frequency / 125;
837
838 buf[0] = (div >> 8) & 0x7f;
839 buf[1] = div & 0xff;
840 buf[2] = 0x84; /* 0xC4 */
841 buf[3] = 0x00;
842
843 if (c->frequency < 1500000)
844 buf[3] |= 0x10;
845
846 if (fe->ops.i2c_gate_ctrl)
847 fe->ops.i2c_gate_ctrl(fe, 1);
848
849 if (i2c_transfer(&dev->core->i2c_adap, &msg, 1) != 1)
850 return -EIO;
851
852 return 0;
853 }
854
855 static int samsung_smt_7020_set_tone(struct dvb_frontend *fe,
856 fe_sec_tone_mode_t tone)
857 {
858 struct cx8802_dev *dev = fe->dvb->priv;
859 struct cx88_core *core = dev->core;
860
861 cx_set(MO_GP0_IO, 0x0800);
862
863 switch (tone) {
864 case SEC_TONE_ON:
865 cx_set(MO_GP0_IO, 0x08);
866 break;
867 case SEC_TONE_OFF:
868 cx_clear(MO_GP0_IO, 0x08);
869 break;
870 default:
871 return -EINVAL;
872 }
873
874 return 0;
875 }
876
877 static int samsung_smt_7020_set_voltage(struct dvb_frontend *fe,
878 fe_sec_voltage_t voltage)
879 {
880 struct cx8802_dev *dev = fe->dvb->priv;
881 struct cx88_core *core = dev->core;
882
883 u8 data;
884 struct i2c_msg msg = {
885 .addr = 8,
886 .flags = 0,
887 .buf = &data,
888 .len = sizeof(data) };
889
890 cx_set(MO_GP0_IO, 0x8000);
891
892 switch (voltage) {
893 case SEC_VOLTAGE_OFF:
894 break;
895 case SEC_VOLTAGE_13:
896 data = ISL6421_EN1 | ISL6421_LLC1;
897 cx_clear(MO_GP0_IO, 0x80);
898 break;
899 case SEC_VOLTAGE_18:
900 data = ISL6421_EN1 | ISL6421_LLC1 | ISL6421_VSEL1;
901 cx_clear(MO_GP0_IO, 0x80);
902 break;
903 default:
904 return -EINVAL;
905 }
906
907 return (i2c_transfer(&dev->core->i2c_adap, &msg, 1) == 1) ? 0 : -EIO;
908 }
909
910 static int samsung_smt_7020_stv0299_set_symbol_rate(struct dvb_frontend *fe,
911 u32 srate, u32 ratio)
912 {
913 u8 aclk = 0;
914 u8 bclk = 0;
915
916 if (srate < 1500000) {
917 aclk = 0xb7;
918 bclk = 0x47;
919 } else if (srate < 3000000) {
920 aclk = 0xb7;
921 bclk = 0x4b;
922 } else if (srate < 7000000) {
923 aclk = 0xb7;
924 bclk = 0x4f;
925 } else if (srate < 14000000) {
926 aclk = 0xb7;
927 bclk = 0x53;
928 } else if (srate < 30000000) {
929 aclk = 0xb6;
930 bclk = 0x53;
931 } else if (srate < 45000000) {
932 aclk = 0xb4;
933 bclk = 0x51;
934 }
935
936 stv0299_writereg(fe, 0x13, aclk);
937 stv0299_writereg(fe, 0x14, bclk);
938 stv0299_writereg(fe, 0x1f, (ratio >> 16) & 0xff);
939 stv0299_writereg(fe, 0x20, (ratio >> 8) & 0xff);
940 stv0299_writereg(fe, 0x21, ratio & 0xf0);
941
942 return 0;
943 }
944
945
946 static const struct stv0299_config samsung_stv0299_config = {
947 .demod_address = 0x68,
948 .inittab = samsung_smt_7020_inittab,
949 .mclk = 88000000UL,
950 .invert = 0,
951 .skip_reinit = 0,
952 .lock_output = STV0299_LOCKOUTPUT_LK,
953 .volt13_op0_op1 = STV0299_VOLT13_OP1,
954 .min_delay_ms = 100,
955 .set_symbol_rate = samsung_smt_7020_stv0299_set_symbol_rate,
956 };
957
958 static int dvb_register(struct cx8802_dev *dev)
959 {
960 struct cx88_core *core = dev->core;
961 struct videobuf_dvb_frontend *fe0, *fe1 = NULL;
962 int mfe_shared = 0; /* bus not shared by default */
963 int res = -EINVAL;
964
965 if (0 != core->i2c_rc) {
966 printk(KERN_ERR "%s/2: no i2c-bus available, cannot attach dvb drivers\n", core->name);
967 goto frontend_detach;
968 }
969
970 /* Get the first frontend */
971 fe0 = videobuf_dvb_get_frontend(&dev->frontends, 1);
972 if (!fe0)
973 goto frontend_detach;
974
975 /* multi-frontend gate control is undefined or defaults to fe0 */
976 dev->frontends.gate = 0;
977
978 /* Sets the gate control callback to be used by i2c command calls */
979 core->gate_ctrl = cx88_dvb_gate_ctrl;
980
981 /* init frontend(s) */
982 switch (core->boardnr) {
983 case CX88_BOARD_HAUPPAUGE_DVB_T1:
984 fe0->dvb.frontend = dvb_attach(cx22702_attach,
985 &connexant_refboard_config,
986 &core->i2c_adap);
987 if (fe0->dvb.frontend != NULL) {
988 if (!dvb_attach(dvb_pll_attach, fe0->dvb.frontend,
989 0x61, &core->i2c_adap,
990 DVB_PLL_THOMSON_DTT759X))
991 goto frontend_detach;
992 }
993 break;
994 case CX88_BOARD_TERRATEC_CINERGY_1400_DVB_T1:
995 case CX88_BOARD_CONEXANT_DVB_T1:
996 case CX88_BOARD_KWORLD_DVB_T_CX22702:
997 case CX88_BOARD_WINFAST_DTV1000:
998 fe0->dvb.frontend = dvb_attach(cx22702_attach,
999 &connexant_refboard_config,
1000 &core->i2c_adap);
1001 if (fe0->dvb.frontend != NULL) {
1002 if (!dvb_attach(dvb_pll_attach, fe0->dvb.frontend,
1003 0x60, &core->i2c_adap,
1004 DVB_PLL_THOMSON_DTT7579))
1005 goto frontend_detach;
1006 }
1007 break;
1008 case CX88_BOARD_WINFAST_DTV2000H:
1009 case CX88_BOARD_HAUPPAUGE_HVR1100:
1010 case CX88_BOARD_HAUPPAUGE_HVR1100LP:
1011 case CX88_BOARD_HAUPPAUGE_HVR1300:
1012 fe0->dvb.frontend = dvb_attach(cx22702_attach,
1013 &hauppauge_hvr_config,
1014 &core->i2c_adap);
1015 if (fe0->dvb.frontend != NULL) {
1016 if (!dvb_attach(simple_tuner_attach, fe0->dvb.frontend,
1017 &core->i2c_adap, 0x61,
1018 TUNER_PHILIPS_FMD1216ME_MK3))
1019 goto frontend_detach;
1020 }
1021 break;
1022 case CX88_BOARD_WINFAST_DTV2000H_J:
1023 fe0->dvb.frontend = dvb_attach(cx22702_attach,
1024 &hauppauge_hvr_config,
1025 &core->i2c_adap);
1026 if (fe0->dvb.frontend != NULL) {
1027 if (!dvb_attach(simple_tuner_attach, fe0->dvb.frontend,
1028 &core->i2c_adap, 0x61,
1029 TUNER_PHILIPS_FMD1216MEX_MK3))
1030 goto frontend_detach;
1031 }
1032 break;
1033 case CX88_BOARD_HAUPPAUGE_HVR3000:
1034 /* MFE frontend 1 */
1035 mfe_shared = 1;
1036 dev->frontends.gate = 2;
1037 /* DVB-S init */
1038 fe0->dvb.frontend = dvb_attach(cx24123_attach,
1039 &hauppauge_novas_config,
1040 &dev->core->i2c_adap);
1041 if (fe0->dvb.frontend) {
1042 if (!dvb_attach(isl6421_attach,
1043 fe0->dvb.frontend,
1044 &dev->core->i2c_adap,
1045 0x08, ISL6421_DCL, 0x00, false))
1046 goto frontend_detach;
1047 }
1048 /* MFE frontend 2 */
1049 fe1 = videobuf_dvb_get_frontend(&dev->frontends, 2);
1050 if (!fe1)
1051 goto frontend_detach;
1052 /* DVB-T init */
1053 fe1->dvb.frontend = dvb_attach(cx22702_attach,
1054 &hauppauge_hvr_config,
1055 &dev->core->i2c_adap);
1056 if (fe1->dvb.frontend) {
1057 fe1->dvb.frontend->id = 1;
1058 if (!dvb_attach(simple_tuner_attach,
1059 fe1->dvb.frontend,
1060 &dev->core->i2c_adap,
1061 0x61, TUNER_PHILIPS_FMD1216ME_MK3))
1062 goto frontend_detach;
1063 }
1064 break;
1065 case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PLUS:
1066 fe0->dvb.frontend = dvb_attach(mt352_attach,
1067 &dvico_fusionhdtv,
1068 &core->i2c_adap);
1069 if (fe0->dvb.frontend != NULL) {
1070 if (!dvb_attach(dvb_pll_attach, fe0->dvb.frontend,
1071 0x60, NULL, DVB_PLL_THOMSON_DTT7579))
1072 goto frontend_detach;
1073 break;
1074 }
1075 /* ZL10353 replaces MT352 on later cards */
1076 fe0->dvb.frontend = dvb_attach(zl10353_attach,
1077 &dvico_fusionhdtv_plus_v1_1,
1078 &core->i2c_adap);
1079 if (fe0->dvb.frontend != NULL) {
1080 if (!dvb_attach(dvb_pll_attach, fe0->dvb.frontend,
1081 0x60, NULL, DVB_PLL_THOMSON_DTT7579))
1082 goto frontend_detach;
1083 }
1084 break;
1085 case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_DUAL:
1086 /* The tin box says DEE1601, but it seems to be DTT7579
1087 * compatible, with a slightly different MT352 AGC gain. */
1088 fe0->dvb.frontend = dvb_attach(mt352_attach,
1089 &dvico_fusionhdtv_dual,
1090 &core->i2c_adap);
1091 if (fe0->dvb.frontend != NULL) {
1092 if (!dvb_attach(dvb_pll_attach, fe0->dvb.frontend,
1093 0x61, NULL, DVB_PLL_THOMSON_DTT7579))
1094 goto frontend_detach;
1095 break;
1096 }
1097 /* ZL10353 replaces MT352 on later cards */
1098 fe0->dvb.frontend = dvb_attach(zl10353_attach,
1099 &dvico_fusionhdtv_plus_v1_1,
1100 &core->i2c_adap);
1101 if (fe0->dvb.frontend != NULL) {
1102 if (!dvb_attach(dvb_pll_attach, fe0->dvb.frontend,
1103 0x61, NULL, DVB_PLL_THOMSON_DTT7579))
1104 goto frontend_detach;
1105 }
1106 break;
1107 case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T1:
1108 fe0->dvb.frontend = dvb_attach(mt352_attach,
1109 &dvico_fusionhdtv,
1110 &core->i2c_adap);
1111 if (fe0->dvb.frontend != NULL) {
1112 if (!dvb_attach(dvb_pll_attach, fe0->dvb.frontend,
1113 0x61, NULL, DVB_PLL_LG_Z201))
1114 goto frontend_detach;
1115 }
1116 break;
1117 case CX88_BOARD_KWORLD_DVB_T:
1118 case CX88_BOARD_DNTV_LIVE_DVB_T:
1119 case CX88_BOARD_ADSTECH_DVB_T_PCI:
1120 fe0->dvb.frontend = dvb_attach(mt352_attach,
1121 &dntv_live_dvbt_config,
1122 &core->i2c_adap);
1123 if (fe0->dvb.frontend != NULL) {
1124 if (!dvb_attach(dvb_pll_attach, fe0->dvb.frontend,
1125 0x61, NULL, DVB_PLL_UNKNOWN_1))
1126 goto frontend_detach;
1127 }
1128 break;
1129 case CX88_BOARD_DNTV_LIVE_DVB_T_PRO:
1130 #if IS_ENABLED(CONFIG_VIDEO_CX88_VP3054)
1131 /* MT352 is on a secondary I2C bus made from some GPIO lines */
1132 fe0->dvb.frontend = dvb_attach(mt352_attach, &dntv_live_dvbt_pro_config,
1133 &dev->vp3054->adap);
1134 if (fe0->dvb.frontend != NULL) {
1135 if (!dvb_attach(simple_tuner_attach, fe0->dvb.frontend,
1136 &core->i2c_adap, 0x61,
1137 TUNER_PHILIPS_FMD1216ME_MK3))
1138 goto frontend_detach;
1139 }
1140 #else
1141 printk(KERN_ERR "%s/2: built without vp3054 support\n",
1142 core->name);
1143 #endif
1144 break;
1145 case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_HYBRID:
1146 fe0->dvb.frontend = dvb_attach(zl10353_attach,
1147 &dvico_fusionhdtv_hybrid,
1148 &core->i2c_adap);
1149 if (fe0->dvb.frontend != NULL) {
1150 if (!dvb_attach(simple_tuner_attach, fe0->dvb.frontend,
1151 &core->i2c_adap, 0x61,
1152 TUNER_THOMSON_FE6600))
1153 goto frontend_detach;
1154 }
1155 break;
1156 case CX88_BOARD_DVICO_FUSIONHDTV_DVB_T_PRO:
1157 fe0->dvb.frontend = dvb_attach(zl10353_attach,
1158 &dvico_fusionhdtv_xc3028,
1159 &core->i2c_adap);
1160 if (fe0->dvb.frontend == NULL)
1161 fe0->dvb.frontend = dvb_attach(mt352_attach,
1162 &dvico_fusionhdtv_mt352_xc3028,
1163 &core->i2c_adap);
1164 /*
1165 * On this board, the demod provides the I2C bus pullup.
1166 * We must not permit gate_ctrl to be performed, or
1167 * the xc3028 cannot communicate on the bus.
1168 */
1169 if (fe0->dvb.frontend)
1170 fe0->dvb.frontend->ops.i2c_gate_ctrl = NULL;
1171 if (attach_xc3028(0x61, dev) < 0)
1172 goto frontend_detach;
1173 break;
1174 case CX88_BOARD_PCHDTV_HD3000:
1175 fe0->dvb.frontend = dvb_attach(or51132_attach, &pchdtv_hd3000,
1176 &core->i2c_adap);
1177 if (fe0->dvb.frontend != NULL) {
1178 if (!dvb_attach(simple_tuner_attach, fe0->dvb.frontend,
1179 &core->i2c_adap, 0x61,
1180 TUNER_THOMSON_DTT761X))
1181 goto frontend_detach;
1182 }
1183 break;
1184 case CX88_BOARD_DVICO_FUSIONHDTV_3_GOLD_Q:
1185 dev->ts_gen_cntrl = 0x08;
1186
1187 /* Do a hardware reset of chip before using it. */
1188 cx_clear(MO_GP0_IO, 1);
1189 mdelay(100);
1190 cx_set(MO_GP0_IO, 1);
1191 mdelay(200);
1192
1193 /* Select RF connector callback */
1194 fusionhdtv_3_gold.pll_rf_set = lgdt330x_pll_rf_set;
1195 fe0->dvb.frontend = dvb_attach(lgdt330x_attach,
1196 &fusionhdtv_3_gold,
1197 &core->i2c_adap);
1198 if (fe0->dvb.frontend != NULL) {
1199 if (!dvb_attach(simple_tuner_attach, fe0->dvb.frontend,
1200 &core->i2c_adap, 0x61,
1201 TUNER_MICROTUNE_4042FI5))
1202 goto frontend_detach;
1203 }
1204 break;
1205 case CX88_BOARD_DVICO_FUSIONHDTV_3_GOLD_T:
1206 dev->ts_gen_cntrl = 0x08;
1207
1208 /* Do a hardware reset of chip before using it. */
1209 cx_clear(MO_GP0_IO, 1);
1210 mdelay(100);
1211 cx_set(MO_GP0_IO, 9);
1212 mdelay(200);
1213 fe0->dvb.frontend = dvb_attach(lgdt330x_attach,
1214 &fusionhdtv_3_gold,
1215 &core->i2c_adap);
1216 if (fe0->dvb.frontend != NULL) {
1217 if (!dvb_attach(simple_tuner_attach, fe0->dvb.frontend,
1218 &core->i2c_adap, 0x61,
1219 TUNER_THOMSON_DTT761X))
1220 goto frontend_detach;
1221 }
1222 break;
1223 case CX88_BOARD_DVICO_FUSIONHDTV_5_GOLD:
1224 dev->ts_gen_cntrl = 0x08;
1225
1226 /* Do a hardware reset of chip before using it. */
1227 cx_clear(MO_GP0_IO, 1);
1228 mdelay(100);
1229 cx_set(MO_GP0_IO, 1);
1230 mdelay(200);
1231 fe0->dvb.frontend = dvb_attach(lgdt330x_attach,
1232 &fusionhdtv_5_gold,
1233 &core->i2c_adap);
1234 if (fe0->dvb.frontend != NULL) {
1235 if (!dvb_attach(simple_tuner_attach, fe0->dvb.frontend,
1236 &core->i2c_adap, 0x61,
1237 TUNER_LG_TDVS_H06XF))
1238 goto frontend_detach;
1239 if (!dvb_attach(tda9887_attach, fe0->dvb.frontend,
1240 &core->i2c_adap, 0x43))
1241 goto frontend_detach;
1242 }
1243 break;
1244 case CX88_BOARD_PCHDTV_HD5500:
1245 dev->ts_gen_cntrl = 0x08;
1246
1247 /* Do a hardware reset of chip before using it. */
1248 cx_clear(MO_GP0_IO, 1);
1249 mdelay(100);
1250 cx_set(MO_GP0_IO, 1);
1251 mdelay(200);
1252 fe0->dvb.frontend = dvb_attach(lgdt330x_attach,
1253 &pchdtv_hd5500,
1254 &core->i2c_adap);
1255 if (fe0->dvb.frontend != NULL) {
1256 if (!dvb_attach(simple_tuner_attach, fe0->dvb.frontend,
1257 &core->i2c_adap, 0x61,
1258 TUNER_LG_TDVS_H06XF))
1259 goto frontend_detach;
1260 if (!dvb_attach(tda9887_attach, fe0->dvb.frontend,
1261 &core->i2c_adap, 0x43))
1262 goto frontend_detach;
1263 }
1264 break;
1265 case CX88_BOARD_ATI_HDTVWONDER:
1266 fe0->dvb.frontend = dvb_attach(nxt200x_attach,
1267 &ati_hdtvwonder,
1268 &core->i2c_adap);
1269 if (fe0->dvb.frontend != NULL) {
1270 if (!dvb_attach(simple_tuner_attach, fe0->dvb.frontend,
1271 &core->i2c_adap, 0x61,
1272 TUNER_PHILIPS_TUV1236D))
1273 goto frontend_detach;
1274 }
1275 break;
1276 case CX88_BOARD_HAUPPAUGE_NOVASPLUS_S1:
1277 case CX88_BOARD_HAUPPAUGE_NOVASE2_S1:
1278 fe0->dvb.frontend = dvb_attach(cx24123_attach,
1279 &hauppauge_novas_config,
1280 &core->i2c_adap);
1281 if (fe0->dvb.frontend) {
1282 bool override_tone;
1283
1284 if (core->model == 92001)
1285 override_tone = true;
1286 else
1287 override_tone = false;
1288
1289 if (!dvb_attach(isl6421_attach, fe0->dvb.frontend,
1290 &core->i2c_adap, 0x08, ISL6421_DCL, 0x00,
1291 override_tone))
1292 goto frontend_detach;
1293 }
1294 break;
1295 case CX88_BOARD_KWORLD_DVBS_100:
1296 fe0->dvb.frontend = dvb_attach(cx24123_attach,
1297 &kworld_dvbs_100_config,
1298 &core->i2c_adap);
1299 if (fe0->dvb.frontend) {
1300 core->prev_set_voltage = fe0->dvb.frontend->ops.set_voltage;
1301 fe0->dvb.frontend->ops.set_voltage = kworld_dvbs_100_set_voltage;
1302 }
1303 break;
1304 case CX88_BOARD_GENIATECH_DVBS:
1305 fe0->dvb.frontend = dvb_attach(cx24123_attach,
1306 &geniatech_dvbs_config,
1307 &core->i2c_adap);
1308 if (fe0->dvb.frontend) {
1309 core->prev_set_voltage = fe0->dvb.frontend->ops.set_voltage;
1310 fe0->dvb.frontend->ops.set_voltage = geniatech_dvbs_set_voltage;
1311 }
1312 break;
1313 case CX88_BOARD_PINNACLE_PCTV_HD_800i:
1314 fe0->dvb.frontend = dvb_attach(s5h1409_attach,
1315 &pinnacle_pctv_hd_800i_config,
1316 &core->i2c_adap);
1317 if (fe0->dvb.frontend != NULL) {
1318 if (!dvb_attach(xc5000_attach, fe0->dvb.frontend,
1319 &core->i2c_adap,
1320 &pinnacle_pctv_hd_800i_tuner_config))
1321 goto frontend_detach;
1322 }
1323 break;
1324 case CX88_BOARD_DVICO_FUSIONHDTV_5_PCI_NANO:
1325 fe0->dvb.frontend = dvb_attach(s5h1409_attach,
1326 &dvico_hdtv5_pci_nano_config,
1327 &core->i2c_adap);
1328 if (fe0->dvb.frontend != NULL) {
1329 struct dvb_frontend *fe;
1330 struct xc2028_config cfg = {
1331 .i2c_adap = &core->i2c_adap,
1332 .i2c_addr = 0x61,
1333 };
1334 static struct xc2028_ctrl ctl = {
1335 .fname = XC2028_DEFAULT_FIRMWARE,
1336 .max_len = 64,
1337 .scode_table = XC3028_FE_OREN538,
1338 };
1339
1340 fe = dvb_attach(xc2028_attach,
1341 fe0->dvb.frontend, &cfg);
1342 if (fe != NULL && fe->ops.tuner_ops.set_config != NULL)
1343 fe->ops.tuner_ops.set_config(fe, &ctl);
1344 }
1345 break;
1346 case CX88_BOARD_PINNACLE_HYBRID_PCTV:
1347 case CX88_BOARD_WINFAST_DTV1800H:
1348 fe0->dvb.frontend = dvb_attach(zl10353_attach,
1349 &cx88_pinnacle_hybrid_pctv,
1350 &core->i2c_adap);
1351 if (fe0->dvb.frontend) {
1352 fe0->dvb.frontend->ops.i2c_gate_ctrl = NULL;
1353 if (attach_xc3028(0x61, dev) < 0)
1354 goto frontend_detach;
1355 }
1356 break;
1357 case CX88_BOARD_WINFAST_DTV1800H_XC4000:
1358 case CX88_BOARD_WINFAST_DTV2000H_PLUS:
1359 fe0->dvb.frontend = dvb_attach(zl10353_attach,
1360 &cx88_pinnacle_hybrid_pctv,
1361 &core->i2c_adap);
1362 if (fe0->dvb.frontend) {
1363 struct xc4000_config cfg = {
1364 .i2c_address = 0x61,
1365 .default_pm = 0,
1366 .dvb_amplitude = 134,
1367 .set_smoothedcvbs = 1,
1368 .if_khz = 4560
1369 };
1370 fe0->dvb.frontend->ops.i2c_gate_ctrl = NULL;
1371 if (attach_xc4000(dev, &cfg) < 0)
1372 goto frontend_detach;
1373 }
1374 break;
1375 case CX88_BOARD_GENIATECH_X8000_MT:
1376 dev->ts_gen_cntrl = 0x00;
1377
1378 fe0->dvb.frontend = dvb_attach(zl10353_attach,
1379 &cx88_geniatech_x8000_mt,
1380 &core->i2c_adap);
1381 if (attach_xc3028(0x61, dev) < 0)
1382 goto frontend_detach;
1383 break;
1384 case CX88_BOARD_KWORLD_ATSC_120:
1385 fe0->dvb.frontend = dvb_attach(s5h1409_attach,
1386 &kworld_atsc_120_config,
1387 &core->i2c_adap);
1388 if (attach_xc3028(0x61, dev) < 0)
1389 goto frontend_detach;
1390 break;
1391 case CX88_BOARD_DVICO_FUSIONHDTV_7_GOLD:
1392 fe0->dvb.frontend = dvb_attach(s5h1411_attach,
1393 &dvico_fusionhdtv7_config,
1394 &core->i2c_adap);
1395 if (fe0->dvb.frontend != NULL) {
1396 if (!dvb_attach(xc5000_attach, fe0->dvb.frontend,
1397 &core->i2c_adap,
1398 &dvico_fusionhdtv7_tuner_config))
1399 goto frontend_detach;
1400 }
1401 break;
1402 case CX88_BOARD_HAUPPAUGE_HVR4000:
1403 /* MFE frontend 1 */
1404 mfe_shared = 1;
1405 dev->frontends.gate = 2;
1406 /* DVB-S/S2 Init */
1407 fe0->dvb.frontend = dvb_attach(cx24116_attach,
1408 &hauppauge_hvr4000_config,
1409 &dev->core->i2c_adap);
1410 if (fe0->dvb.frontend) {
1411 if (!dvb_attach(isl6421_attach,
1412 fe0->dvb.frontend,
1413 &dev->core->i2c_adap,
1414 0x08, ISL6421_DCL, 0x00, false))
1415 goto frontend_detach;
1416 }
1417 /* MFE frontend 2 */
1418 fe1 = videobuf_dvb_get_frontend(&dev->frontends, 2);
1419 if (!fe1)
1420 goto frontend_detach;
1421 /* DVB-T Init */
1422 fe1->dvb.frontend = dvb_attach(cx22702_attach,
1423 &hauppauge_hvr_config,
1424 &dev->core->i2c_adap);
1425 if (fe1->dvb.frontend) {
1426 fe1->dvb.frontend->id = 1;
1427 if (!dvb_attach(simple_tuner_attach,
1428 fe1->dvb.frontend,
1429 &dev->core->i2c_adap,
1430 0x61, TUNER_PHILIPS_FMD1216ME_MK3))
1431 goto frontend_detach;
1432 }
1433 break;
1434 case CX88_BOARD_HAUPPAUGE_HVR4000LITE:
1435 fe0->dvb.frontend = dvb_attach(cx24116_attach,
1436 &hauppauge_hvr4000_config,
1437 &dev->core->i2c_adap);
1438 if (fe0->dvb.frontend) {
1439 if (!dvb_attach(isl6421_attach,
1440 fe0->dvb.frontend,
1441 &dev->core->i2c_adap,
1442 0x08, ISL6421_DCL, 0x00, false))
1443 goto frontend_detach;
1444 }
1445 break;
1446 case CX88_BOARD_PROF_6200:
1447 case CX88_BOARD_TBS_8910:
1448 case CX88_BOARD_TEVII_S420:
1449 fe0->dvb.frontend = dvb_attach(stv0299_attach,
1450 &tevii_tuner_sharp_config,
1451 &core->i2c_adap);
1452 if (fe0->dvb.frontend != NULL) {
1453 if (!dvb_attach(dvb_pll_attach, fe0->dvb.frontend, 0x60,
1454 &core->i2c_adap, DVB_PLL_OPERA1))
1455 goto frontend_detach;
1456 core->prev_set_voltage = fe0->dvb.frontend->ops.set_voltage;
1457 fe0->dvb.frontend->ops.set_voltage = tevii_dvbs_set_voltage;
1458
1459 } else {
1460 fe0->dvb.frontend = dvb_attach(stv0288_attach,
1461 &tevii_tuner_earda_config,
1462 &core->i2c_adap);
1463 if (fe0->dvb.frontend != NULL) {
1464 if (!dvb_attach(stb6000_attach, fe0->dvb.frontend, 0x61,
1465 &core->i2c_adap))
1466 goto frontend_detach;
1467 core->prev_set_voltage = fe0->dvb.frontend->ops.set_voltage;
1468 fe0->dvb.frontend->ops.set_voltage = tevii_dvbs_set_voltage;
1469 }
1470 }
1471 break;
1472 case CX88_BOARD_TEVII_S460:
1473 fe0->dvb.frontend = dvb_attach(cx24116_attach,
1474 &tevii_s460_config,
1475 &core->i2c_adap);
1476 if (fe0->dvb.frontend != NULL)
1477 fe0->dvb.frontend->ops.set_voltage = tevii_dvbs_set_voltage;
1478 break;
1479 case CX88_BOARD_TEVII_S464:
1480 fe0->dvb.frontend = dvb_attach(ds3000_attach,
1481 &tevii_ds3000_config,
1482 &core->i2c_adap);
1483 if (fe0->dvb.frontend != NULL) {
1484 dvb_attach(ts2020_attach, fe0->dvb.frontend,
1485 &tevii_ts2020_config, &core->i2c_adap);
1486 fe0->dvb.frontend->ops.set_voltage =
1487 tevii_dvbs_set_voltage;
1488 }
1489 break;
1490 case CX88_BOARD_OMICOM_SS4_PCI:
1491 case CX88_BOARD_TBS_8920:
1492 case CX88_BOARD_PROF_7300:
1493 case CX88_BOARD_SATTRADE_ST4200:
1494 fe0->dvb.frontend = dvb_attach(cx24116_attach,
1495 &hauppauge_hvr4000_config,
1496 &core->i2c_adap);
1497 if (fe0->dvb.frontend != NULL)
1498 fe0->dvb.frontend->ops.set_voltage = tevii_dvbs_set_voltage;
1499 break;
1500 case CX88_BOARD_TERRATEC_CINERGY_HT_PCI_MKII:
1501 fe0->dvb.frontend = dvb_attach(zl10353_attach,
1502 &cx88_terratec_cinergy_ht_pci_mkii_config,
1503 &core->i2c_adap);
1504 if (fe0->dvb.frontend) {
1505 fe0->dvb.frontend->ops.i2c_gate_ctrl = NULL;
1506 if (attach_xc3028(0x61, dev) < 0)
1507 goto frontend_detach;
1508 }
1509 break;
1510 case CX88_BOARD_PROF_7301:{
1511 struct dvb_tuner_ops *tuner_ops = NULL;
1512
1513 fe0->dvb.frontend = dvb_attach(stv0900_attach,
1514 &prof_7301_stv0900_config,
1515 &core->i2c_adap, 0);
1516 if (fe0->dvb.frontend != NULL) {
1517 if (!dvb_attach(stb6100_attach, fe0->dvb.frontend,
1518 &prof_7301_stb6100_config,
1519 &core->i2c_adap))
1520 goto frontend_detach;
1521
1522 tuner_ops = &fe0->dvb.frontend->ops.tuner_ops;
1523 tuner_ops->set_frequency = stb6100_set_freq;
1524 tuner_ops->get_frequency = stb6100_get_freq;
1525 tuner_ops->set_bandwidth = stb6100_set_bandw;
1526 tuner_ops->get_bandwidth = stb6100_get_bandw;
1527
1528 core->prev_set_voltage =
1529 fe0->dvb.frontend->ops.set_voltage;
1530 fe0->dvb.frontend->ops.set_voltage =
1531 tevii_dvbs_set_voltage;
1532 }
1533 break;
1534 }
1535 case CX88_BOARD_SAMSUNG_SMT_7020:
1536 dev->ts_gen_cntrl = 0x08;
1537
1538 cx_set(MO_GP0_IO, 0x0101);
1539
1540 cx_clear(MO_GP0_IO, 0x01);
1541 mdelay(100);
1542 cx_set(MO_GP0_IO, 0x01);
1543 mdelay(200);
1544
1545 fe0->dvb.frontend = dvb_attach(stv0299_attach,
1546 &samsung_stv0299_config,
1547 &dev->core->i2c_adap);
1548 if (fe0->dvb.frontend) {
1549 fe0->dvb.frontend->ops.tuner_ops.set_params =
1550 samsung_smt_7020_tuner_set_params;
1551 fe0->dvb.frontend->tuner_priv =
1552 &dev->core->i2c_adap;
1553 fe0->dvb.frontend->ops.set_voltage =
1554 samsung_smt_7020_set_voltage;
1555 fe0->dvb.frontend->ops.set_tone =
1556 samsung_smt_7020_set_tone;
1557 }
1558
1559 break;
1560 case CX88_BOARD_TWINHAN_VP1027_DVBS:
1561 dev->ts_gen_cntrl = 0x00;
1562 fe0->dvb.frontend = dvb_attach(mb86a16_attach,
1563 &twinhan_vp1027,
1564 &core->i2c_adap);
1565 if (fe0->dvb.frontend) {
1566 core->prev_set_voltage =
1567 fe0->dvb.frontend->ops.set_voltage;
1568 fe0->dvb.frontend->ops.set_voltage =
1569 vp1027_set_voltage;
1570 }
1571 break;
1572
1573 default:
1574 printk(KERN_ERR "%s/2: The frontend of your DVB/ATSC card isn't supported yet\n",
1575 core->name);
1576 break;
1577 }
1578
1579 if ( (NULL == fe0->dvb.frontend) || (fe1 && NULL == fe1->dvb.frontend) ) {
1580 printk(KERN_ERR
1581 "%s/2: frontend initialization failed\n",
1582 core->name);
1583 goto frontend_detach;
1584 }
1585 /* define general-purpose callback pointer */
1586 fe0->dvb.frontend->callback = cx88_tuner_callback;
1587
1588 /* Ensure all frontends negotiate bus access */
1589 fe0->dvb.frontend->ops.ts_bus_ctrl = cx88_dvb_bus_ctrl;
1590 if (fe1)
1591 fe1->dvb.frontend->ops.ts_bus_ctrl = cx88_dvb_bus_ctrl;
1592
1593 /* Put the analog decoder in standby to keep it quiet */
1594 call_all(core, core, s_power, 0);
1595
1596 /* register everything */
1597 res = videobuf_dvb_register_bus(&dev->frontends, THIS_MODULE, dev,
1598 &dev->pci->dev, adapter_nr, mfe_shared);
1599 if (res)
1600 goto frontend_detach;
1601 return res;
1602
1603 frontend_detach:
1604 core->gate_ctrl = NULL;
1605 videobuf_dvb_dealloc_frontends(&dev->frontends);
1606 return res;
1607 }
1608
1609 /* ----------------------------------------------------------- */
1610
1611 /* CX8802 MPEG -> mini driver - We have been given the hardware */
1612 static int cx8802_dvb_advise_acquire(struct cx8802_driver *drv)
1613 {
1614 struct cx88_core *core = drv->core;
1615 int err = 0;
1616 dprintk( 1, "%s\n", __func__);
1617
1618 switch (core->boardnr) {
1619 case CX88_BOARD_HAUPPAUGE_HVR1300:
1620 /* We arrive here with either the cx23416 or the cx22702
1621 * on the bus. Take the bus from the cx23416 and enable the
1622 * cx22702 demod
1623 */
1624 /* Toggle reset on cx22702 leaving i2c active */
1625 cx_set(MO_GP0_IO, 0x00000080);
1626 udelay(1000);
1627 cx_clear(MO_GP0_IO, 0x00000080);
1628 udelay(50);
1629 cx_set(MO_GP0_IO, 0x00000080);
1630 udelay(1000);
1631 /* enable the cx22702 pins */
1632 cx_clear(MO_GP0_IO, 0x00000004);
1633 udelay(1000);
1634 break;
1635
1636 case CX88_BOARD_HAUPPAUGE_HVR3000:
1637 case CX88_BOARD_HAUPPAUGE_HVR4000:
1638 /* Toggle reset on cx22702 leaving i2c active */
1639 cx_set(MO_GP0_IO, 0x00000080);
1640 udelay(1000);
1641 cx_clear(MO_GP0_IO, 0x00000080);
1642 udelay(50);
1643 cx_set(MO_GP0_IO, 0x00000080);
1644 udelay(1000);
1645 switch (core->dvbdev->frontends.active_fe_id) {
1646 case 1: /* DVB-S/S2 Enabled */
1647 /* tri-state the cx22702 pins */
1648 cx_set(MO_GP0_IO, 0x00000004);
1649 /* Take the cx24116/cx24123 out of reset */
1650 cx_write(MO_SRST_IO, 1);
1651 core->dvbdev->ts_gen_cntrl = 0x02; /* Parallel IO */
1652 break;
1653 case 2: /* DVB-T Enabled */
1654 /* Put the cx24116/cx24123 into reset */
1655 cx_write(MO_SRST_IO, 0);
1656 /* enable the cx22702 pins */
1657 cx_clear(MO_GP0_IO, 0x00000004);
1658 core->dvbdev->ts_gen_cntrl = 0x0c; /* Serial IO */
1659 break;
1660 }
1661 udelay(1000);
1662 break;
1663
1664 case CX88_BOARD_WINFAST_DTV2000H_PLUS:
1665 /* set RF input to AIR for DVB-T (GPIO 16) */
1666 cx_write(MO_GP2_IO, 0x0101);
1667 break;
1668
1669 default:
1670 err = -ENODEV;
1671 }
1672 return err;
1673 }
1674
1675 /* CX8802 MPEG -> mini driver - We no longer have the hardware */
1676 static int cx8802_dvb_advise_release(struct cx8802_driver *drv)
1677 {
1678 struct cx88_core *core = drv->core;
1679 int err = 0;
1680 dprintk( 1, "%s\n", __func__);
1681
1682 switch (core->boardnr) {
1683 case CX88_BOARD_HAUPPAUGE_HVR1300:
1684 /* Do Nothing, leave the cx22702 on the bus. */
1685 break;
1686 case CX88_BOARD_HAUPPAUGE_HVR3000:
1687 case CX88_BOARD_HAUPPAUGE_HVR4000:
1688 break;
1689 default:
1690 err = -ENODEV;
1691 }
1692 return err;
1693 }
1694
1695 static int cx8802_dvb_probe(struct cx8802_driver *drv)
1696 {
1697 struct cx88_core *core = drv->core;
1698 struct cx8802_dev *dev = drv->core->dvbdev;
1699 int err;
1700 struct videobuf_dvb_frontend *fe;
1701 int i;
1702
1703 dprintk( 1, "%s\n", __func__);
1704 dprintk( 1, " ->being probed by Card=%d Name=%s, PCI %02x:%02x\n",
1705 core->boardnr,
1706 core->name,
1707 core->pci_bus,
1708 core->pci_slot);
1709
1710 err = -ENODEV;
1711 if (!(core->board.mpeg & CX88_MPEG_DVB))
1712 goto fail_core;
1713
1714 /* If vp3054 isn't enabled, a stub will just return 0 */
1715 err = vp3054_i2c_probe(dev);
1716 if (0 != err)
1717 goto fail_core;
1718
1719 /* dvb stuff */
1720 printk(KERN_INFO "%s/2: cx2388x based DVB/ATSC card\n", core->name);
1721 dev->ts_gen_cntrl = 0x0c;
1722
1723 err = cx8802_alloc_frontends(dev);
1724 if (err)
1725 goto fail_core;
1726
1727 err = -ENODEV;
1728 for (i = 1; i <= core->board.num_frontends; i++) {
1729 fe = videobuf_dvb_get_frontend(&core->dvbdev->frontends, i);
1730 if (fe == NULL) {
1731 printk(KERN_ERR "%s() failed to get frontend(%d)\n",
1732 __func__, i);
1733 goto fail_probe;
1734 }
1735 videobuf_queue_sg_init(&fe->dvb.dvbq, &dvb_qops,
1736 &dev->pci->dev, &dev->slock,
1737 V4L2_BUF_TYPE_VIDEO_CAPTURE,
1738 V4L2_FIELD_TOP,
1739 sizeof(struct cx88_buffer),
1740 dev, NULL);
1741 /* init struct videobuf_dvb */
1742 fe->dvb.name = dev->core->name;
1743 }
1744
1745 err = dvb_register(dev);
1746 if (err)
1747 /* frontends/adapter de-allocated in dvb_register */
1748 printk(KERN_ERR "%s/2: dvb_register failed (err = %d)\n",
1749 core->name, err);
1750 return err;
1751 fail_probe:
1752 videobuf_dvb_dealloc_frontends(&core->dvbdev->frontends);
1753 fail_core:
1754 return err;
1755 }
1756
1757 static int cx8802_dvb_remove(struct cx8802_driver *drv)
1758 {
1759 struct cx88_core *core = drv->core;
1760 struct cx8802_dev *dev = drv->core->dvbdev;
1761
1762 dprintk( 1, "%s\n", __func__);
1763
1764 videobuf_dvb_unregister_bus(&dev->frontends);
1765
1766 vp3054_i2c_remove(dev);
1767
1768 core->gate_ctrl = NULL;
1769
1770 return 0;
1771 }
1772
1773 static struct cx8802_driver cx8802_dvb_driver = {
1774 .type_id = CX88_MPEG_DVB,
1775 .hw_access = CX8802_DRVCTL_SHARED,
1776 .probe = cx8802_dvb_probe,
1777 .remove = cx8802_dvb_remove,
1778 .advise_acquire = cx8802_dvb_advise_acquire,
1779 .advise_release = cx8802_dvb_advise_release,
1780 };
1781
1782 static int __init dvb_init(void)
1783 {
1784 printk(KERN_INFO "cx88/2: cx2388x dvb driver version %s loaded\n",
1785 CX88_VERSION);
1786 return cx8802_register_driver(&cx8802_dvb_driver);
1787 }
1788
1789 static void __exit dvb_fini(void)
1790 {
1791 cx8802_unregister_driver(&cx8802_dvb_driver);
1792 }
1793
1794 module_init(dvb_init);
1795 module_exit(dvb_fini);
Linux with added FPC-III support