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