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