1 // SPDX-License-Identifier: GPL-2.0
2 //
3 // DVB device driver for em28xx
4 //
5 // (c) 2008-2011 Mauro Carvalho Chehab <mchehab@kernel.org>
6 //
7 // (c) 2008 Devin Heitmueller <devin.heitmueller@gmail.com>
8 // - Fixes for the driver to properly work with HVR-950
9 // - Fixes for the driver to properly work with Pinnacle PCTV HD Pro Stick
10 // - Fixes for the driver to properly work with AMD ATI TV Wonder HD 600
11 //
12 // (c) 2008 Aidan Thornton <makosoft@googlemail.com>
13 //
14 // (c) 2012 Frank Schäfer <fschaefer.oss@googlemail.com>
15 //
16 // Based on cx88-dvb, saa7134-dvb and videobuf-dvb originally written by:
17 // (c) 2004, 2005 Chris Pascoe <c.pascoe@itee.uq.edu.au>
18 // (c) 2004 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
19 //
20 // This program is free software; you can redistribute it and/or modify
21 // it under the terms of the GNU General Public License as published by
22 // the Free Software Foundation version 2 of the License.
23
24 #include "em28xx.h"
25
26 #include <linux/kernel.h>
27 #include <linux/slab.h>
28 #include <linux/usb.h>
29
30 #include <media/v4l2-common.h>
31 #include <media/dvb_demux.h>
32 #include <media/dvb_net.h>
33 #include <media/dmxdev.h>
34 #include <media/tuner.h>
35 #include "tuner-simple.h"
36 #include <linux/gpio.h>
37
38 #include "lgdt330x.h"
39 #include "lgdt3305.h"
40 #include "lgdt3306a.h"
41 #include "zl10353.h"
42 #include "s5h1409.h"
43 #include "mt2060.h"
44 #include "mt352.h"
45 #include "mt352_priv.h" /* FIXME */
46 #include "tda1002x.h"
47 #include "drx39xyj/drx39xxj.h"
48 #include "tda18271.h"
49 #include "s921.h"
50 #include "drxd.h"
51 #include "cxd2820r.h"
52 #include "tda18271c2dd.h"
53 #include "drxk.h"
54 #include "tda10071.h"
55 #include "tda18212.h"
56 #include "a8293.h"
57 #include "qt1010.h"
58 #include "mb86a20s.h"
59 #include "m88ds3103.h"
60 #include "ts2020.h"
61 #include "si2168.h"
62 #include "si2157.h"
63 #include "tc90522.h"
64 #include "qm1d1c0042.h"
65 #include "mxl692.h"
66
67 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@kernel.org>");
68 MODULE_LICENSE("GPL v2");
69 MODULE_DESCRIPTION(DRIVER_DESC " - digital TV interface");
70 MODULE_VERSION(EM28XX_VERSION);
71
72 static unsigned int debug;
73 module_param(debug, int, 0644);
74 MODULE_PARM_DESC(debug, "enable debug messages [dvb]");
75
76 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
77
78 #define dprintk(level, fmt, arg...) do { \
79 if (debug >= level) \
80 dev_printk(KERN_DEBUG, &dev->intf->dev, \
81 "dvb: " fmt, ## arg); \
82 } while (0)
83
84 struct em28xx_dvb {
85 struct dvb_frontend *fe[2];
86
87 /* feed count management */
88 struct mutex lock;
89 int nfeeds;
90
91 /* general boilerplate stuff */
92 struct dvb_adapter adapter;
93 struct dvb_demux demux;
94 struct dmxdev dmxdev;
95 struct dmx_frontend fe_hw;
96 struct dmx_frontend fe_mem;
97 struct dvb_net net;
98
99 /* Due to DRX-K - probably need changes */
100 int (*gate_ctrl)(struct dvb_frontend *fe, int gate);
101 struct semaphore pll_mutex;
102 bool dont_attach_fe1;
103 int lna_gpio;
104 struct i2c_client *i2c_client_demod;
105 struct i2c_client *i2c_client_tuner;
106 struct i2c_client *i2c_client_sec;
107 };
108
print_err_status(struct em28xx * dev,int packet,int status)109 static inline void print_err_status(struct em28xx *dev,
110 int packet, int status)
111 {
112 char *errmsg = "Unknown";
113
114 switch (status) {
115 case -ENOENT:
116 errmsg = "unlinked synchronously";
117 break;
118 case -ECONNRESET:
119 errmsg = "unlinked asynchronously";
120 break;
121 case -ENOSR:
122 errmsg = "Buffer error (overrun)";
123 break;
124 case -EPIPE:
125 errmsg = "Stalled (device not responding)";
126 break;
127 case -EOVERFLOW:
128 errmsg = "Babble (bad cable?)";
129 break;
130 case -EPROTO:
131 errmsg = "Bit-stuff error (bad cable?)";
132 break;
133 case -EILSEQ:
134 errmsg = "CRC/Timeout (could be anything)";
135 break;
136 case -ETIME:
137 errmsg = "Device does not respond";
138 break;
139 }
140 if (packet < 0) {
141 dprintk(1, "URB status %d [%s].\n", status, errmsg);
142 } else {
143 dprintk(1, "URB packet %d, status %d [%s].\n",
144 packet, status, errmsg);
145 }
146 }
147
em28xx_dvb_urb_data_copy(struct em28xx * dev,struct urb * urb)148 static inline int em28xx_dvb_urb_data_copy(struct em28xx *dev, struct urb *urb)
149 {
150 int xfer_bulk, num_packets, i;
151
152 if (!dev)
153 return 0;
154
155 if (dev->disconnected)
156 return 0;
157
158 if (urb->status < 0)
159 print_err_status(dev, -1, urb->status);
160
161 xfer_bulk = usb_pipebulk(urb->pipe);
162
163 if (xfer_bulk) /* bulk */
164 num_packets = 1;
165 else /* isoc */
166 num_packets = urb->number_of_packets;
167
168 for (i = 0; i < num_packets; i++) {
169 if (xfer_bulk) {
170 if (urb->status < 0) {
171 print_err_status(dev, i, urb->status);
172 if (urb->status != -EPROTO)
173 continue;
174 }
175 if (!urb->actual_length)
176 continue;
177 dvb_dmx_swfilter(&dev->dvb->demux, urb->transfer_buffer,
178 urb->actual_length);
179 } else {
180 if (urb->iso_frame_desc[i].status < 0) {
181 print_err_status(dev, i,
182 urb->iso_frame_desc[i].status);
183 if (urb->iso_frame_desc[i].status != -EPROTO)
184 continue;
185 }
186 if (!urb->iso_frame_desc[i].actual_length)
187 continue;
188 dvb_dmx_swfilter(&dev->dvb->demux,
189 urb->transfer_buffer +
190 urb->iso_frame_desc[i].offset,
191 urb->iso_frame_desc[i].actual_length);
192 }
193 }
194
195 return 0;
196 }
197
em28xx_start_streaming(struct em28xx_dvb * dvb)198 static int em28xx_start_streaming(struct em28xx_dvb *dvb)
199 {
200 int rc;
201 struct em28xx_i2c_bus *i2c_bus = dvb->adapter.priv;
202 struct em28xx *dev = i2c_bus->dev;
203 struct usb_device *udev = interface_to_usbdev(dev->intf);
204 int dvb_max_packet_size, packet_multiplier, dvb_alt;
205
206 if (dev->dvb_xfer_bulk) {
207 if (!dev->dvb_ep_bulk)
208 return -ENODEV;
209 dvb_max_packet_size = 512; /* USB 2.0 spec */
210 packet_multiplier = EM28XX_DVB_BULK_PACKET_MULTIPLIER;
211 dvb_alt = 0;
212 } else { /* isoc */
213 if (!dev->dvb_ep_isoc)
214 return -ENODEV;
215 dvb_max_packet_size = dev->dvb_max_pkt_size_isoc;
216 if (dvb_max_packet_size < 0)
217 return dvb_max_packet_size;
218 packet_multiplier = EM28XX_DVB_NUM_ISOC_PACKETS;
219 dvb_alt = dev->dvb_alt_isoc;
220 }
221
222 if (!dev->board.has_dual_ts)
223 usb_set_interface(udev, dev->ifnum, dvb_alt);
224
225 rc = em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
226 if (rc < 0)
227 return rc;
228
229 dprintk(1, "Using %d buffers each with %d x %d bytes, alternate %d\n",
230 EM28XX_DVB_NUM_BUFS,
231 packet_multiplier,
232 dvb_max_packet_size, dvb_alt);
233
234 return em28xx_init_usb_xfer(dev, EM28XX_DIGITAL_MODE,
235 dev->dvb_xfer_bulk,
236 EM28XX_DVB_NUM_BUFS,
237 dvb_max_packet_size,
238 packet_multiplier,
239 em28xx_dvb_urb_data_copy);
240 }
241
em28xx_stop_streaming(struct em28xx_dvb * dvb)242 static int em28xx_stop_streaming(struct em28xx_dvb *dvb)
243 {
244 struct em28xx_i2c_bus *i2c_bus = dvb->adapter.priv;
245 struct em28xx *dev = i2c_bus->dev;
246
247 em28xx_stop_urbs(dev);
248
249 return 0;
250 }
251
em28xx_start_feed(struct dvb_demux_feed * feed)252 static int em28xx_start_feed(struct dvb_demux_feed *feed)
253 {
254 struct dvb_demux *demux = feed->demux;
255 struct em28xx_dvb *dvb = demux->priv;
256 int rc, ret;
257
258 if (!demux->dmx.frontend)
259 return -EINVAL;
260
261 mutex_lock(&dvb->lock);
262 dvb->nfeeds++;
263 rc = dvb->nfeeds;
264
265 if (dvb->nfeeds == 1) {
266 ret = em28xx_start_streaming(dvb);
267 if (ret < 0)
268 rc = ret;
269 }
270
271 mutex_unlock(&dvb->lock);
272 return rc;
273 }
274
em28xx_stop_feed(struct dvb_demux_feed * feed)275 static int em28xx_stop_feed(struct dvb_demux_feed *feed)
276 {
277 struct dvb_demux *demux = feed->demux;
278 struct em28xx_dvb *dvb = demux->priv;
279 int err = 0;
280
281 mutex_lock(&dvb->lock);
282 dvb->nfeeds--;
283
284 if (!dvb->nfeeds)
285 err = em28xx_stop_streaming(dvb);
286
287 mutex_unlock(&dvb->lock);
288 return err;
289 }
290
291 /* ------------------------------------------------------------------ */
em28xx_dvb_bus_ctrl(struct dvb_frontend * fe,int acquire)292 static int em28xx_dvb_bus_ctrl(struct dvb_frontend *fe, int acquire)
293 {
294 struct em28xx_i2c_bus *i2c_bus = fe->dvb->priv;
295 struct em28xx *dev = i2c_bus->dev;
296
297 if (acquire)
298 return em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
299 else
300 return em28xx_set_mode(dev, EM28XX_SUSPEND);
301 }
302
303 /* ------------------------------------------------------------------ */
304
305 static struct lgdt330x_config em2880_lgdt3303_dev = {
306 .demod_chip = LGDT3303,
307 };
308
309 static struct lgdt3305_config em2870_lgdt3304_dev = {
310 .i2c_addr = 0x0e,
311 .demod_chip = LGDT3304,
312 .spectral_inversion = 1,
313 .deny_i2c_rptr = 1,
314 .mpeg_mode = LGDT3305_MPEG_PARALLEL,
315 .tpclk_edge = LGDT3305_TPCLK_FALLING_EDGE,
316 .tpvalid_polarity = LGDT3305_TP_VALID_HIGH,
317 .vsb_if_khz = 3250,
318 .qam_if_khz = 4000,
319 };
320
321 static struct lgdt3305_config em2874_lgdt3305_dev = {
322 .i2c_addr = 0x0e,
323 .demod_chip = LGDT3305,
324 .spectral_inversion = 1,
325 .deny_i2c_rptr = 0,
326 .mpeg_mode = LGDT3305_MPEG_SERIAL,
327 .tpclk_edge = LGDT3305_TPCLK_FALLING_EDGE,
328 .tpvalid_polarity = LGDT3305_TP_VALID_HIGH,
329 .vsb_if_khz = 3250,
330 .qam_if_khz = 4000,
331 };
332
333 static struct lgdt3305_config em2874_lgdt3305_nogate_dev = {
334 .i2c_addr = 0x0e,
335 .demod_chip = LGDT3305,
336 .spectral_inversion = 1,
337 .deny_i2c_rptr = 1,
338 .mpeg_mode = LGDT3305_MPEG_SERIAL,
339 .tpclk_edge = LGDT3305_TPCLK_FALLING_EDGE,
340 .tpvalid_polarity = LGDT3305_TP_VALID_HIGH,
341 .vsb_if_khz = 3600,
342 .qam_if_khz = 3600,
343 };
344
345 static struct s921_config sharp_isdbt = {
346 .demod_address = 0x30 >> 1
347 };
348
349 static struct zl10353_config em28xx_zl10353_with_xc3028 = {
350 .demod_address = (0x1e >> 1),
351 .no_tuner = 1,
352 .parallel_ts = 1,
353 .if2 = 45600,
354 };
355
356 static struct s5h1409_config em28xx_s5h1409_with_xc3028 = {
357 .demod_address = 0x32 >> 1,
358 .output_mode = S5H1409_PARALLEL_OUTPUT,
359 .gpio = S5H1409_GPIO_OFF,
360 .inversion = S5H1409_INVERSION_OFF,
361 .status_mode = S5H1409_DEMODLOCKING,
362 .mpeg_timing = S5H1409_MPEGTIMING_CONTINUOUS_NONINVERTING_CLOCK
363 };
364
365 static struct tda18271_std_map kworld_a340_std_map = {
366 .atsc_6 = { .if_freq = 3250, .agc_mode = 3, .std = 0,
367 .if_lvl = 1, .rfagc_top = 0x37, },
368 .qam_6 = { .if_freq = 4000, .agc_mode = 3, .std = 1,
369 .if_lvl = 1, .rfagc_top = 0x37, },
370 };
371
372 static struct tda18271_config kworld_a340_config = {
373 .std_map = &kworld_a340_std_map,
374 };
375
376 static struct tda18271_config kworld_ub435q_v2_config = {
377 .std_map = &kworld_a340_std_map,
378 .gate = TDA18271_GATE_DIGITAL,
379 };
380
381 static struct tda18212_config kworld_ub435q_v3_config = {
382 .if_atsc_vsb = 3600,
383 .if_atsc_qam = 3600,
384 };
385
386 static struct zl10353_config em28xx_zl10353_xc3028_no_i2c_gate = {
387 .demod_address = (0x1e >> 1),
388 .no_tuner = 1,
389 .disable_i2c_gate_ctrl = 1,
390 .parallel_ts = 1,
391 .if2 = 45600,
392 };
393
394 static struct drxd_config em28xx_drxd = {
395 .demod_address = 0x70,
396 .demod_revision = 0xa2,
397 .pll_type = DRXD_PLL_NONE,
398 .clock = 12000,
399 .insert_rs_byte = 1,
400 .IF = 42800000,
401 .disable_i2c_gate_ctrl = 1,
402 };
403
404 static struct drxk_config terratec_h5_drxk = {
405 .adr = 0x29,
406 .single_master = 1,
407 .no_i2c_bridge = 1,
408 .microcode_name = "dvb-usb-terratec-h5-drxk.fw",
409 .qam_demod_parameter_count = 2,
410 };
411
412 static struct drxk_config hauppauge_930c_drxk = {
413 .adr = 0x29,
414 .single_master = 1,
415 .no_i2c_bridge = 1,
416 .microcode_name = "dvb-usb-hauppauge-hvr930c-drxk.fw",
417 .chunk_size = 56,
418 .qam_demod_parameter_count = 2,
419 };
420
421 static struct drxk_config terratec_htc_stick_drxk = {
422 .adr = 0x29,
423 .single_master = 1,
424 .no_i2c_bridge = 1,
425 .microcode_name = "dvb-usb-terratec-htc-stick-drxk.fw",
426 .chunk_size = 54,
427 .qam_demod_parameter_count = 2,
428 /* Required for the antenna_gpio to disable LNA. */
429 .antenna_dvbt = true,
430 /* The windows driver uses the same. This will disable LNA. */
431 .antenna_gpio = 0x6,
432 };
433
434 static struct drxk_config maxmedia_ub425_tc_drxk = {
435 .adr = 0x29,
436 .single_master = 1,
437 .no_i2c_bridge = 1,
438 .microcode_name = "dvb-demod-drxk-01.fw",
439 .chunk_size = 62,
440 .qam_demod_parameter_count = 2,
441 };
442
443 static struct drxk_config pctv_520e_drxk = {
444 .adr = 0x29,
445 .single_master = 1,
446 .microcode_name = "dvb-demod-drxk-pctv.fw",
447 .qam_demod_parameter_count = 2,
448 .chunk_size = 58,
449 .antenna_dvbt = true, /* disable LNA */
450 .antenna_gpio = (1 << 2), /* disable LNA */
451 };
452
drxk_gate_ctrl(struct dvb_frontend * fe,int enable)453 static int drxk_gate_ctrl(struct dvb_frontend *fe, int enable)
454 {
455 struct em28xx_dvb *dvb = fe->sec_priv;
456 int status;
457
458 if (!dvb)
459 return -EINVAL;
460
461 if (enable) {
462 down(&dvb->pll_mutex);
463 status = dvb->gate_ctrl(fe, 1);
464 } else {
465 status = dvb->gate_ctrl(fe, 0);
466 up(&dvb->pll_mutex);
467 }
468 return status;
469 }
470
hauppauge_hvr930c_init(struct em28xx * dev)471 static void hauppauge_hvr930c_init(struct em28xx *dev)
472 {
473 int i;
474
475 static const struct em28xx_reg_seq hauppauge_hvr930c_init[] = {
476 {EM2874_R80_GPIO_P0_CTRL, 0xff, 0xff, 0x65},
477 {EM2874_R80_GPIO_P0_CTRL, 0xfb, 0xff, 0x32},
478 {EM2874_R80_GPIO_P0_CTRL, 0xff, 0xff, 0xb8},
479 { -1, -1, -1, -1},
480 };
481 static const struct em28xx_reg_seq hauppauge_hvr930c_end[] = {
482 {EM2874_R80_GPIO_P0_CTRL, 0xef, 0xff, 0x01},
483 {EM2874_R80_GPIO_P0_CTRL, 0xaf, 0xff, 0x65},
484 {EM2874_R80_GPIO_P0_CTRL, 0xef, 0xff, 0x76},
485 {EM2874_R80_GPIO_P0_CTRL, 0xef, 0xff, 0x01},
486 {EM2874_R80_GPIO_P0_CTRL, 0xcf, 0xff, 0x0b},
487 {EM2874_R80_GPIO_P0_CTRL, 0xef, 0xff, 0x40},
488
489 {EM2874_R80_GPIO_P0_CTRL, 0xcf, 0xff, 0x65},
490 {EM2874_R80_GPIO_P0_CTRL, 0xef, 0xff, 0x65},
491 {EM2874_R80_GPIO_P0_CTRL, 0xcf, 0xff, 0x0b},
492 {EM2874_R80_GPIO_P0_CTRL, 0xef, 0xff, 0x65},
493
494 { -1, -1, -1, -1},
495 };
496
497 static const struct {
498 unsigned char r[4];
499 int len;
500 } regs[] = {
501 {{ 0x06, 0x02, 0x00, 0x31 }, 4},
502 {{ 0x01, 0x02 }, 2},
503 {{ 0x01, 0x02, 0x00, 0xc6 }, 4},
504 {{ 0x01, 0x00 }, 2},
505 {{ 0x01, 0x00, 0xff, 0xaf }, 4},
506 {{ 0x01, 0x00, 0x03, 0xa0 }, 4},
507 {{ 0x01, 0x00 }, 2},
508 {{ 0x01, 0x00, 0x73, 0xaf }, 4},
509 {{ 0x04, 0x00 }, 2},
510 {{ 0x00, 0x04 }, 2},
511 {{ 0x00, 0x04, 0x00, 0x0a }, 4},
512 {{ 0x04, 0x14 }, 2},
513 {{ 0x04, 0x14, 0x00, 0x00 }, 4},
514 };
515
516 em28xx_gpio_set(dev, hauppauge_hvr930c_init);
517 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
518 usleep_range(10000, 11000);
519 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44);
520 usleep_range(10000, 11000);
521
522 dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1;
523
524 for (i = 0; i < ARRAY_SIZE(regs); i++)
525 i2c_master_send(&dev->i2c_client[dev->def_i2c_bus],
526 regs[i].r, regs[i].len);
527 em28xx_gpio_set(dev, hauppauge_hvr930c_end);
528
529 msleep(100);
530
531 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44);
532 msleep(30);
533
534 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x45);
535 usleep_range(10000, 11000);
536 }
537
terratec_h5_init(struct em28xx * dev)538 static void terratec_h5_init(struct em28xx *dev)
539 {
540 int i;
541 static const struct em28xx_reg_seq terratec_h5_init[] = {
542 {EM2820_R08_GPIO_CTRL, 0xff, 0xff, 10},
543 {EM2874_R80_GPIO_P0_CTRL, 0xf6, 0xff, 100},
544 {EM2874_R80_GPIO_P0_CTRL, 0xf2, 0xff, 50},
545 {EM2874_R80_GPIO_P0_CTRL, 0xf6, 0xff, 100},
546 { -1, -1, -1, -1},
547 };
548 static const struct em28xx_reg_seq terratec_h5_end[] = {
549 {EM2874_R80_GPIO_P0_CTRL, 0xe6, 0xff, 100},
550 {EM2874_R80_GPIO_P0_CTRL, 0xa6, 0xff, 50},
551 {EM2874_R80_GPIO_P0_CTRL, 0xe6, 0xff, 100},
552 { -1, -1, -1, -1},
553 };
554 static const struct {
555 unsigned char r[4];
556 int len;
557 } regs[] = {
558 {{ 0x06, 0x02, 0x00, 0x31 }, 4},
559 {{ 0x01, 0x02 }, 2},
560 {{ 0x01, 0x02, 0x00, 0xc6 }, 4},
561 {{ 0x01, 0x00 }, 2},
562 {{ 0x01, 0x00, 0xff, 0xaf }, 4},
563 {{ 0x01, 0x00, 0x03, 0xa0 }, 4},
564 {{ 0x01, 0x00 }, 2},
565 {{ 0x01, 0x00, 0x73, 0xaf }, 4},
566 {{ 0x04, 0x00 }, 2},
567 {{ 0x00, 0x04 }, 2},
568 {{ 0x00, 0x04, 0x00, 0x0a }, 4},
569 {{ 0x04, 0x14 }, 2},
570 {{ 0x04, 0x14, 0x00, 0x00 }, 4},
571 };
572
573 em28xx_gpio_set(dev, terratec_h5_init);
574 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
575 usleep_range(10000, 11000);
576 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x45);
577 usleep_range(10000, 11000);
578
579 dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1;
580
581 for (i = 0; i < ARRAY_SIZE(regs); i++)
582 i2c_master_send(&dev->i2c_client[dev->def_i2c_bus],
583 regs[i].r, regs[i].len);
584 em28xx_gpio_set(dev, terratec_h5_end);
585 };
586
terratec_htc_stick_init(struct em28xx * dev)587 static void terratec_htc_stick_init(struct em28xx *dev)
588 {
589 int i;
590
591 /*
592 * GPIO configuration:
593 * 0xff: unknown (does not affect DVB-T).
594 * 0xf6: DRX-K (demodulator).
595 * 0xe6: unknown (does not affect DVB-T).
596 * 0xb6: unknown (does not affect DVB-T).
597 */
598 static const struct em28xx_reg_seq terratec_htc_stick_init[] = {
599 {EM2820_R08_GPIO_CTRL, 0xff, 0xff, 10},
600 {EM2874_R80_GPIO_P0_CTRL, 0xf6, 0xff, 100},
601 {EM2874_R80_GPIO_P0_CTRL, 0xe6, 0xff, 50},
602 {EM2874_R80_GPIO_P0_CTRL, 0xf6, 0xff, 100},
603 { -1, -1, -1, -1},
604 };
605 static const struct em28xx_reg_seq terratec_htc_stick_end[] = {
606 {EM2874_R80_GPIO_P0_CTRL, 0xb6, 0xff, 100},
607 {EM2874_R80_GPIO_P0_CTRL, 0xf6, 0xff, 50},
608 { -1, -1, -1, -1},
609 };
610
611 /*
612 * Init the analog decoder (not yet supported), but
613 * it's probably still a good idea.
614 */
615 static const struct {
616 unsigned char r[4];
617 int len;
618 } regs[] = {
619 {{ 0x06, 0x02, 0x00, 0x31 }, 4},
620 {{ 0x01, 0x02 }, 2},
621 {{ 0x01, 0x02, 0x00, 0xc6 }, 4},
622 {{ 0x01, 0x00 }, 2},
623 {{ 0x01, 0x00, 0xff, 0xaf }, 4},
624 };
625
626 em28xx_gpio_set(dev, terratec_htc_stick_init);
627
628 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
629 usleep_range(10000, 11000);
630 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44);
631 usleep_range(10000, 11000);
632
633 dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1;
634
635 for (i = 0; i < ARRAY_SIZE(regs); i++)
636 i2c_master_send(&dev->i2c_client[dev->def_i2c_bus],
637 regs[i].r, regs[i].len);
638
639 em28xx_gpio_set(dev, terratec_htc_stick_end);
640 };
641
terratec_htc_usb_xs_init(struct em28xx * dev)642 static void terratec_htc_usb_xs_init(struct em28xx *dev)
643 {
644 int i;
645
646 static const struct em28xx_reg_seq terratec_htc_usb_xs_init[] = {
647 {EM2820_R08_GPIO_CTRL, 0xff, 0xff, 10},
648 {EM2874_R80_GPIO_P0_CTRL, 0xb2, 0xff, 100},
649 {EM2874_R80_GPIO_P0_CTRL, 0xb2, 0xff, 50},
650 {EM2874_R80_GPIO_P0_CTRL, 0xb6, 0xff, 100},
651 { -1, -1, -1, -1},
652 };
653 static const struct em28xx_reg_seq terratec_htc_usb_xs_end[] = {
654 {EM2874_R80_GPIO_P0_CTRL, 0xa6, 0xff, 100},
655 {EM2874_R80_GPIO_P0_CTRL, 0xa6, 0xff, 50},
656 {EM2874_R80_GPIO_P0_CTRL, 0xe6, 0xff, 100},
657 { -1, -1, -1, -1},
658 };
659
660 /*
661 * Init the analog decoder (not yet supported), but
662 * it's probably still a good idea.
663 */
664 static const struct {
665 unsigned char r[4];
666 int len;
667 } regs[] = {
668 {{ 0x06, 0x02, 0x00, 0x31 }, 4},
669 {{ 0x01, 0x02 }, 2},
670 {{ 0x01, 0x02, 0x00, 0xc6 }, 4},
671 {{ 0x01, 0x00 }, 2},
672 {{ 0x01, 0x00, 0xff, 0xaf }, 4},
673 {{ 0x01, 0x00, 0x03, 0xa0 }, 4},
674 {{ 0x01, 0x00 }, 2},
675 {{ 0x01, 0x00, 0x73, 0xaf }, 4},
676 {{ 0x04, 0x00 }, 2},
677 {{ 0x00, 0x04 }, 2},
678 {{ 0x00, 0x04, 0x00, 0x0a }, 4},
679 {{ 0x04, 0x14 }, 2},
680 {{ 0x04, 0x14, 0x00, 0x00 }, 4},
681 };
682
683 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
684
685 em28xx_gpio_set(dev, terratec_htc_usb_xs_init);
686
687 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
688 usleep_range(10000, 11000);
689 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44);
690 usleep_range(10000, 11000);
691
692 dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1;
693
694 for (i = 0; i < ARRAY_SIZE(regs); i++)
695 i2c_master_send(&dev->i2c_client[dev->def_i2c_bus],
696 regs[i].r, regs[i].len);
697
698 em28xx_gpio_set(dev, terratec_htc_usb_xs_end);
699 };
700
pctv_520e_init(struct em28xx * dev)701 static void pctv_520e_init(struct em28xx *dev)
702 {
703 /*
704 * Init AVF4910B analog decoder. Looks like I2C traffic to
705 * digital demodulator and tuner are routed via AVF4910B.
706 */
707 int i;
708 static const struct {
709 unsigned char r[4];
710 int len;
711 } regs[] = {
712 {{ 0x06, 0x02, 0x00, 0x31 }, 4},
713 {{ 0x01, 0x02 }, 2},
714 {{ 0x01, 0x02, 0x00, 0xc6 }, 4},
715 {{ 0x01, 0x00 }, 2},
716 {{ 0x01, 0x00, 0xff, 0xaf }, 4},
717 {{ 0x01, 0x00, 0x03, 0xa0 }, 4},
718 {{ 0x01, 0x00 }, 2},
719 {{ 0x01, 0x00, 0x73, 0xaf }, 4},
720 };
721
722 dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1; /* 0x41 */
723
724 for (i = 0; i < ARRAY_SIZE(regs); i++)
725 i2c_master_send(&dev->i2c_client[dev->def_i2c_bus],
726 regs[i].r, regs[i].len);
727 };
728
em28xx_pctv_290e_set_lna(struct dvb_frontend * fe)729 static int em28xx_pctv_290e_set_lna(struct dvb_frontend *fe)
730 {
731 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
732 struct em28xx_i2c_bus *i2c_bus = fe->dvb->priv;
733 struct em28xx *dev = i2c_bus->dev;
734 #ifdef CONFIG_GPIOLIB
735 struct em28xx_dvb *dvb = dev->dvb;
736 int ret;
737 unsigned long flags;
738
739 if (c->lna == 1)
740 flags = GPIOF_OUT_INIT_HIGH; /* enable LNA */
741 else
742 flags = GPIOF_OUT_INIT_LOW; /* disable LNA */
743
744 ret = gpio_request_one(dvb->lna_gpio, flags, NULL);
745 if (ret)
746 dev_err(&dev->intf->dev, "gpio request failed %d\n", ret);
747 else
748 gpio_free(dvb->lna_gpio);
749
750 return ret;
751 #else
752 dev_warn(&dev->intf->dev, "%s: LNA control is disabled (lna=%u)\n",
753 KBUILD_MODNAME, c->lna);
754 return 0;
755 #endif
756 }
757
em28xx_pctv_292e_set_lna(struct dvb_frontend * fe)758 static int em28xx_pctv_292e_set_lna(struct dvb_frontend *fe)
759 {
760 struct dtv_frontend_properties *c = &fe->dtv_property_cache;
761 struct em28xx_i2c_bus *i2c_bus = fe->dvb->priv;
762 struct em28xx *dev = i2c_bus->dev;
763 u8 lna;
764
765 if (c->lna == 1)
766 lna = 0x01;
767 else
768 lna = 0x00;
769
770 return em28xx_write_reg_bits(dev, EM2874_R80_GPIO_P0_CTRL, lna, 0x01);
771 }
772
em28xx_mt352_terratec_xs_init(struct dvb_frontend * fe)773 static int em28xx_mt352_terratec_xs_init(struct dvb_frontend *fe)
774 {
775 /* Values extracted from a USB trace of the Terratec Windows driver */
776 static u8 clock_config[] = { CLOCK_CTL, 0x38, 0x2c };
777 static u8 reset[] = { RESET, 0x80 };
778 static u8 adc_ctl_1_cfg[] = { ADC_CTL_1, 0x40 };
779 static u8 agc_cfg[] = { AGC_TARGET, 0x28, 0xa0 };
780 static u8 input_freq_cfg[] = { INPUT_FREQ_1, 0x31, 0xb8 };
781 static u8 rs_err_cfg[] = { RS_ERR_PER_1, 0x00, 0x4d };
782 static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
783 static u8 trl_nom_cfg[] = { TRL_NOMINAL_RATE_1, 0x64, 0x00 };
784 static u8 tps_given_cfg[] = { TPS_GIVEN_1, 0x40, 0x80, 0x50 };
785 static u8 tuner_go[] = { TUNER_GO, 0x01};
786
787 mt352_write(fe, clock_config, sizeof(clock_config));
788 usleep_range(200, 250);
789 mt352_write(fe, reset, sizeof(reset));
790 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
791 mt352_write(fe, agc_cfg, sizeof(agc_cfg));
792 mt352_write(fe, input_freq_cfg, sizeof(input_freq_cfg));
793 mt352_write(fe, rs_err_cfg, sizeof(rs_err_cfg));
794 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
795 mt352_write(fe, trl_nom_cfg, sizeof(trl_nom_cfg));
796 mt352_write(fe, tps_given_cfg, sizeof(tps_given_cfg));
797 mt352_write(fe, tuner_go, sizeof(tuner_go));
798 return 0;
799 }
800
px_bcud_init(struct em28xx * dev)801 static void px_bcud_init(struct em28xx *dev)
802 {
803 int i;
804 static const struct {
805 unsigned char r[4];
806 int len;
807 } regs1[] = {
808 {{ 0x0e, 0x77 }, 2},
809 {{ 0x0f, 0x77 }, 2},
810 {{ 0x03, 0x90 }, 2},
811 }, regs2[] = {
812 {{ 0x07, 0x01 }, 2},
813 {{ 0x08, 0x10 }, 2},
814 {{ 0x13, 0x00 }, 2},
815 {{ 0x17, 0x00 }, 2},
816 {{ 0x03, 0x01 }, 2},
817 {{ 0x10, 0xb1 }, 2},
818 {{ 0x11, 0x40 }, 2},
819 {{ 0x85, 0x7a }, 2},
820 {{ 0x87, 0x04 }, 2},
821 };
822 static const struct em28xx_reg_seq gpio[] = {
823 {EM28XX_R06_I2C_CLK, 0x40, 0xff, 300},
824 {EM2874_R80_GPIO_P0_CTRL, 0xfd, 0xff, 60},
825 {EM28XX_R15_RGAIN, 0x20, 0xff, 0},
826 {EM28XX_R16_GGAIN, 0x20, 0xff, 0},
827 {EM28XX_R17_BGAIN, 0x20, 0xff, 0},
828 {EM28XX_R18_ROFFSET, 0x00, 0xff, 0},
829 {EM28XX_R19_GOFFSET, 0x00, 0xff, 0},
830 {EM28XX_R1A_BOFFSET, 0x00, 0xff, 0},
831 {EM28XX_R23_UOFFSET, 0x00, 0xff, 0},
832 {EM28XX_R24_VOFFSET, 0x00, 0xff, 0},
833 {EM28XX_R26_COMPR, 0x00, 0xff, 0},
834 {0x13, 0x08, 0xff, 0},
835 {EM28XX_R12_VINENABLE, 0x27, 0xff, 0},
836 {EM28XX_R0C_USBSUSP, 0x10, 0xff, 0},
837 {EM28XX_R27_OUTFMT, 0x00, 0xff, 0},
838 {EM28XX_R10_VINMODE, 0x00, 0xff, 0},
839 {EM28XX_R11_VINCTRL, 0x11, 0xff, 0},
840 {EM2874_R50_IR_CONFIG, 0x01, 0xff, 0},
841 {EM2874_R5F_TS_ENABLE, 0x80, 0xff, 0},
842 {EM28XX_R06_I2C_CLK, 0x46, 0xff, 0},
843 };
844 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x46);
845 /* sleeping ISDB-T */
846 dev->dvb->i2c_client_demod->addr = 0x14;
847 for (i = 0; i < ARRAY_SIZE(regs1); i++)
848 i2c_master_send(dev->dvb->i2c_client_demod,
849 regs1[i].r, regs1[i].len);
850 /* sleeping ISDB-S */
851 dev->dvb->i2c_client_demod->addr = 0x15;
852 for (i = 0; i < ARRAY_SIZE(regs2); i++)
853 i2c_master_send(dev->dvb->i2c_client_demod, regs2[i].r,
854 regs2[i].len);
855 for (i = 0; i < ARRAY_SIZE(gpio); i++) {
856 em28xx_write_reg_bits(dev, gpio[i].reg, gpio[i].val,
857 gpio[i].mask);
858 if (gpio[i].sleep > 0)
859 msleep(gpio[i].sleep);
860 }
861 };
862
863 static struct mt352_config terratec_xs_mt352_cfg = {
864 .demod_address = (0x1e >> 1),
865 .no_tuner = 1,
866 .if2 = 45600,
867 .demod_init = em28xx_mt352_terratec_xs_init,
868 };
869
870 static struct tda10023_config em28xx_tda10023_config = {
871 .demod_address = 0x0c,
872 .invert = 1,
873 };
874
875 static struct cxd2820r_config em28xx_cxd2820r_config = {
876 .i2c_address = (0xd8 >> 1),
877 .ts_mode = CXD2820R_TS_SERIAL,
878 };
879
880 static struct tda18271_config em28xx_cxd2820r_tda18271_config = {
881 .output_opt = TDA18271_OUTPUT_LT_OFF,
882 .gate = TDA18271_GATE_DIGITAL,
883 };
884
885 static struct zl10353_config em28xx_zl10353_no_i2c_gate_dev = {
886 .demod_address = (0x1e >> 1),
887 .disable_i2c_gate_ctrl = 1,
888 .no_tuner = 1,
889 .parallel_ts = 1,
890 };
891
892 static struct mt2060_config em28xx_mt2060_config = {
893 .i2c_address = 0x60,
894 };
895
896 static struct qt1010_config em28xx_qt1010_config = {
897 .i2c_address = 0x62
898 };
899
900 static const struct mb86a20s_config c3tech_duo_mb86a20s_config = {
901 .demod_address = 0x10,
902 .is_serial = true,
903 };
904
905 static struct tda18271_std_map mb86a20s_tda18271_config = {
906 .dvbt_6 = { .if_freq = 4000, .agc_mode = 3, .std = 4,
907 .if_lvl = 1, .rfagc_top = 0x37, },
908 };
909
910 static struct tda18271_config c3tech_duo_tda18271_config = {
911 .std_map = &mb86a20s_tda18271_config,
912 .gate = TDA18271_GATE_DIGITAL,
913 .small_i2c = TDA18271_03_BYTE_CHUNK_INIT,
914 };
915
916 static struct tda18271_std_map drx_j_std_map = {
917 .atsc_6 = { .if_freq = 5000, .agc_mode = 3, .std = 0, .if_lvl = 1,
918 .rfagc_top = 0x37, },
919 .qam_6 = { .if_freq = 5380, .agc_mode = 3, .std = 3, .if_lvl = 1,
920 .rfagc_top = 0x37, },
921 };
922
923 static struct tda18271_config pinnacle_80e_dvb_config = {
924 .std_map = &drx_j_std_map,
925 .gate = TDA18271_GATE_DIGITAL,
926 .role = TDA18271_MASTER,
927 };
928
929 static struct lgdt3306a_config hauppauge_01595_lgdt3306a_config = {
930 .qam_if_khz = 4000,
931 .vsb_if_khz = 3250,
932 .spectral_inversion = 0,
933 .deny_i2c_rptr = 0,
934 .mpeg_mode = LGDT3306A_MPEG_SERIAL,
935 .tpclk_edge = LGDT3306A_TPCLK_RISING_EDGE,
936 .tpvalid_polarity = LGDT3306A_TP_VALID_HIGH,
937 .xtalMHz = 25,
938 };
939
940 /* ------------------------------------------------------------------ */
941
em28xx_attach_xc3028(u8 addr,struct em28xx * dev)942 static noinline_for_stack int em28xx_attach_xc3028(u8 addr, struct em28xx *dev)
943 {
944 struct dvb_frontend *fe;
945 struct xc2028_config cfg;
946 struct xc2028_ctrl ctl;
947
948 memset(&cfg, 0, sizeof(cfg));
949 cfg.i2c_adap = &dev->i2c_adap[dev->def_i2c_bus];
950 cfg.i2c_addr = addr;
951
952 memset(&ctl, 0, sizeof(ctl));
953 em28xx_setup_xc3028(dev, &ctl);
954 cfg.ctrl = &ctl;
955
956 if (!dev->dvb->fe[0]) {
957 dev_err(&dev->intf->dev,
958 "dvb frontend not attached. Can't attach xc3028\n");
959 return -EINVAL;
960 }
961
962 fe = dvb_attach(xc2028_attach, dev->dvb->fe[0], &cfg);
963 if (!fe) {
964 dev_err(&dev->intf->dev, "xc3028 attach failed\n");
965 dvb_frontend_detach(dev->dvb->fe[0]);
966 dev->dvb->fe[0] = NULL;
967 return -EINVAL;
968 }
969
970 dev_info(&dev->intf->dev, "xc3028 attached\n");
971
972 return 0;
973 }
974
975 /* ------------------------------------------------------------------ */
976
em28xx_register_dvb(struct em28xx_dvb * dvb,struct module * module,struct em28xx * dev,struct device * device)977 static int em28xx_register_dvb(struct em28xx_dvb *dvb, struct module *module,
978 struct em28xx *dev, struct device *device)
979 {
980 int result;
981 bool create_rf_connector = false;
982
983 mutex_init(&dvb->lock);
984
985 /* register adapter */
986 result = dvb_register_adapter(&dvb->adapter,
987 dev_name(&dev->intf->dev), module,
988 device, adapter_nr);
989 if (result < 0) {
990 dev_warn(&dev->intf->dev,
991 "dvb_register_adapter failed (errno = %d)\n",
992 result);
993 goto fail_adapter;
994 }
995 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
996 dvb->adapter.mdev = dev->media_dev;
997 #endif
998
999 /* Ensure all frontends negotiate bus access */
1000 dvb->fe[0]->ops.ts_bus_ctrl = em28xx_dvb_bus_ctrl;
1001 if (dvb->fe[1])
1002 dvb->fe[1]->ops.ts_bus_ctrl = em28xx_dvb_bus_ctrl;
1003
1004 dvb->adapter.priv = &dev->i2c_bus[dev->def_i2c_bus];
1005
1006 /* register frontend */
1007 result = dvb_register_frontend(&dvb->adapter, dvb->fe[0]);
1008 if (result < 0) {
1009 dev_warn(&dev->intf->dev,
1010 "dvb_register_frontend failed (errno = %d)\n",
1011 result);
1012 goto fail_frontend0;
1013 }
1014
1015 /* register 2nd frontend */
1016 if (dvb->fe[1]) {
1017 result = dvb_register_frontend(&dvb->adapter, dvb->fe[1]);
1018 if (result < 0) {
1019 dev_warn(&dev->intf->dev,
1020 "2nd dvb_register_frontend failed (errno = %d)\n",
1021 result);
1022 goto fail_frontend1;
1023 }
1024 }
1025
1026 /* register demux stuff */
1027 dvb->demux.dmx.capabilities =
1028 DMX_TS_FILTERING | DMX_SECTION_FILTERING |
1029 DMX_MEMORY_BASED_FILTERING;
1030 dvb->demux.priv = dvb;
1031 dvb->demux.filternum = 256;
1032 dvb->demux.feednum = 256;
1033 dvb->demux.start_feed = em28xx_start_feed;
1034 dvb->demux.stop_feed = em28xx_stop_feed;
1035
1036 result = dvb_dmx_init(&dvb->demux);
1037 if (result < 0) {
1038 dev_warn(&dev->intf->dev,
1039 "dvb_dmx_init failed (errno = %d)\n",
1040 result);
1041 goto fail_dmx;
1042 }
1043
1044 dvb->dmxdev.filternum = 256;
1045 dvb->dmxdev.demux = &dvb->demux.dmx;
1046 dvb->dmxdev.capabilities = 0;
1047 result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
1048 if (result < 0) {
1049 dev_warn(&dev->intf->dev,
1050 "dvb_dmxdev_init failed (errno = %d)\n",
1051 result);
1052 goto fail_dmxdev;
1053 }
1054
1055 dvb->fe_hw.source = DMX_FRONTEND_0;
1056 result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw);
1057 if (result < 0) {
1058 dev_warn(&dev->intf->dev,
1059 "add_frontend failed (DMX_FRONTEND_0, errno = %d)\n",
1060 result);
1061 goto fail_fe_hw;
1062 }
1063
1064 dvb->fe_mem.source = DMX_MEMORY_FE;
1065 result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem);
1066 if (result < 0) {
1067 dev_warn(&dev->intf->dev,
1068 "add_frontend failed (DMX_MEMORY_FE, errno = %d)\n",
1069 result);
1070 goto fail_fe_mem;
1071 }
1072
1073 result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw);
1074 if (result < 0) {
1075 dev_warn(&dev->intf->dev,
1076 "connect_frontend failed (errno = %d)\n",
1077 result);
1078 goto fail_fe_conn;
1079 }
1080
1081 /* register network adapter */
1082 dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx);
1083
1084 /* If the analog part won't create RF connectors, DVB will do it */
1085 if (!dev->has_video || dev->tuner_type == TUNER_ABSENT)
1086 create_rf_connector = true;
1087
1088 result = dvb_create_media_graph(&dvb->adapter, create_rf_connector);
1089 if (result < 0)
1090 goto fail_create_graph;
1091
1092 return 0;
1093
1094 fail_create_graph:
1095 dvb_net_release(&dvb->net);
1096 fail_fe_conn:
1097 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
1098 fail_fe_mem:
1099 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
1100 fail_fe_hw:
1101 dvb_dmxdev_release(&dvb->dmxdev);
1102 fail_dmxdev:
1103 dvb_dmx_release(&dvb->demux);
1104 fail_dmx:
1105 if (dvb->fe[1])
1106 dvb_unregister_frontend(dvb->fe[1]);
1107 dvb_unregister_frontend(dvb->fe[0]);
1108 fail_frontend1:
1109 if (dvb->fe[1])
1110 dvb_frontend_detach(dvb->fe[1]);
1111 fail_frontend0:
1112 dvb_frontend_detach(dvb->fe[0]);
1113 dvb_unregister_adapter(&dvb->adapter);
1114 fail_adapter:
1115 return result;
1116 }
1117
em28xx_unregister_dvb(struct em28xx_dvb * dvb)1118 static void em28xx_unregister_dvb(struct em28xx_dvb *dvb)
1119 {
1120 dvb_net_release(&dvb->net);
1121 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
1122 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
1123 dvb_dmxdev_release(&dvb->dmxdev);
1124 dvb_dmx_release(&dvb->demux);
1125 if (dvb->fe[1])
1126 dvb_unregister_frontend(dvb->fe[1]);
1127 dvb_unregister_frontend(dvb->fe[0]);
1128 if (dvb->fe[1] && !dvb->dont_attach_fe1)
1129 dvb_frontend_detach(dvb->fe[1]);
1130 dvb_frontend_detach(dvb->fe[0]);
1131 dvb_unregister_adapter(&dvb->adapter);
1132 }
1133
em28174_dvb_init_pctv_460e(struct em28xx * dev)1134 static int em28174_dvb_init_pctv_460e(struct em28xx *dev)
1135 {
1136 struct em28xx_dvb *dvb = dev->dvb;
1137 struct tda10071_platform_data tda10071_pdata = {};
1138 struct a8293_platform_data a8293_pdata = {};
1139
1140 /* attach demod + tuner combo */
1141 tda10071_pdata.clk = 40444000; /* 40.444 MHz */
1142 tda10071_pdata.i2c_wr_max = 64;
1143 tda10071_pdata.ts_mode = TDA10071_TS_SERIAL;
1144 tda10071_pdata.pll_multiplier = 20;
1145 tda10071_pdata.tuner_i2c_addr = 0x14;
1146
1147 dvb->i2c_client_demod = dvb_module_probe("tda10071", "tda10071_cx24118",
1148 &dev->i2c_adap[dev->def_i2c_bus],
1149 0x55, &tda10071_pdata);
1150 if (!dvb->i2c_client_demod)
1151 return -ENODEV;
1152
1153 dvb->fe[0] = tda10071_pdata.get_dvb_frontend(dvb->i2c_client_demod);
1154
1155 /* attach SEC */
1156 a8293_pdata.dvb_frontend = dvb->fe[0];
1157
1158 dvb->i2c_client_sec = dvb_module_probe("a8293", NULL,
1159 &dev->i2c_adap[dev->def_i2c_bus],
1160 0x08, &a8293_pdata);
1161 if (!dvb->i2c_client_sec) {
1162 dvb_module_release(dvb->i2c_client_demod);
1163 return -ENODEV;
1164 }
1165
1166 return 0;
1167 }
1168
em28178_dvb_init_pctv_461e(struct em28xx * dev)1169 static int em28178_dvb_init_pctv_461e(struct em28xx *dev)
1170 {
1171 struct em28xx_dvb *dvb = dev->dvb;
1172 struct i2c_adapter *i2c_adapter;
1173 struct m88ds3103_platform_data m88ds3103_pdata = {};
1174 struct ts2020_config ts2020_config = {};
1175 struct a8293_platform_data a8293_pdata = {};
1176
1177 /* attach demod */
1178 m88ds3103_pdata.clk = 27000000;
1179 m88ds3103_pdata.i2c_wr_max = 33;
1180 m88ds3103_pdata.ts_mode = M88DS3103_TS_PARALLEL;
1181 m88ds3103_pdata.ts_clk = 16000;
1182 m88ds3103_pdata.ts_clk_pol = 1;
1183 m88ds3103_pdata.agc = 0x99;
1184
1185 dvb->i2c_client_demod = dvb_module_probe("m88ds3103", NULL,
1186 &dev->i2c_adap[dev->def_i2c_bus],
1187 0x68, &m88ds3103_pdata);
1188 if (!dvb->i2c_client_demod)
1189 return -ENODEV;
1190
1191 dvb->fe[0] = m88ds3103_pdata.get_dvb_frontend(dvb->i2c_client_demod);
1192 i2c_adapter = m88ds3103_pdata.get_i2c_adapter(dvb->i2c_client_demod);
1193
1194 /* attach tuner */
1195 ts2020_config.fe = dvb->fe[0];
1196
1197 dvb->i2c_client_tuner = dvb_module_probe("ts2020", "ts2022",
1198 i2c_adapter,
1199 0x60, &ts2020_config);
1200 if (!dvb->i2c_client_tuner) {
1201 dvb_module_release(dvb->i2c_client_demod);
1202 return -ENODEV;
1203 }
1204
1205 /* delegate signal strength measurement to tuner */
1206 dvb->fe[0]->ops.read_signal_strength =
1207 dvb->fe[0]->ops.tuner_ops.get_rf_strength;
1208
1209 /* attach SEC */
1210 a8293_pdata.dvb_frontend = dvb->fe[0];
1211 dvb->i2c_client_sec = dvb_module_probe("a8293", NULL,
1212 &dev->i2c_adap[dev->def_i2c_bus],
1213 0x08, &a8293_pdata);
1214 if (!dvb->i2c_client_sec) {
1215 dvb_module_release(dvb->i2c_client_tuner);
1216 dvb_module_release(dvb->i2c_client_demod);
1217 return -ENODEV;
1218 }
1219
1220 return 0;
1221 }
1222
em28178_dvb_init_pctv_461e_v2(struct em28xx * dev)1223 static int em28178_dvb_init_pctv_461e_v2(struct em28xx *dev)
1224 {
1225 struct em28xx_dvb *dvb = dev->dvb;
1226 struct i2c_adapter *i2c_adapter;
1227 struct m88ds3103_platform_data m88ds3103_pdata = {};
1228 struct ts2020_config ts2020_config = {};
1229 struct a8293_platform_data a8293_pdata = {};
1230
1231 /* attach demod */
1232 m88ds3103_pdata.clk = 27000000;
1233 m88ds3103_pdata.i2c_wr_max = 33;
1234 m88ds3103_pdata.ts_mode = M88DS3103_TS_PARALLEL;
1235 m88ds3103_pdata.ts_clk = 16000;
1236 m88ds3103_pdata.ts_clk_pol = 0;
1237 m88ds3103_pdata.agc = 0x99;
1238 m88ds3103_pdata.agc_inv = 0;
1239 m88ds3103_pdata.spec_inv = 0;
1240 dvb->i2c_client_demod = dvb_module_probe("m88ds3103", "m88ds3103b",
1241 &dev->i2c_adap[dev->def_i2c_bus],
1242 0x6a, &m88ds3103_pdata);
1243
1244 if (!dvb->i2c_client_demod)
1245 return -ENODEV;
1246
1247 dvb->fe[0] = m88ds3103_pdata.get_dvb_frontend(dvb->i2c_client_demod);
1248 i2c_adapter = m88ds3103_pdata.get_i2c_adapter(dvb->i2c_client_demod);
1249
1250 /* attach tuner */
1251 ts2020_config.fe = dvb->fe[0];
1252 dvb->i2c_client_tuner = dvb_module_probe("ts2020", "ts2022",
1253 i2c_adapter,
1254 0x60, &ts2020_config);
1255 if (!dvb->i2c_client_tuner) {
1256 dvb_module_release(dvb->i2c_client_demod);
1257 return -ENODEV;
1258 }
1259
1260 /* delegate signal strength measurement to tuner */
1261 dvb->fe[0]->ops.read_signal_strength =
1262 dvb->fe[0]->ops.tuner_ops.get_rf_strength;
1263
1264 /* attach SEC */
1265 a8293_pdata.dvb_frontend = dvb->fe[0];
1266 dvb->i2c_client_sec = dvb_module_probe("a8293", NULL,
1267 &dev->i2c_adap[dev->def_i2c_bus],
1268 0x08, &a8293_pdata);
1269 if (!dvb->i2c_client_sec) {
1270 dvb_module_release(dvb->i2c_client_tuner);
1271 dvb_module_release(dvb->i2c_client_demod);
1272 return -ENODEV;
1273 }
1274
1275 return 0;
1276 }
1277
em28178_dvb_init_pctv_292e(struct em28xx * dev)1278 static int em28178_dvb_init_pctv_292e(struct em28xx *dev)
1279 {
1280 struct em28xx_dvb *dvb = dev->dvb;
1281 struct i2c_adapter *adapter;
1282 struct si2168_config si2168_config = {};
1283 struct si2157_config si2157_config = {};
1284
1285 /* attach demod */
1286 si2168_config.i2c_adapter = &adapter;
1287 si2168_config.fe = &dvb->fe[0];
1288 si2168_config.ts_mode = SI2168_TS_PARALLEL;
1289 si2168_config.spectral_inversion = true;
1290
1291 dvb->i2c_client_demod = dvb_module_probe("si2168", NULL,
1292 &dev->i2c_adap[dev->def_i2c_bus],
1293 0x64, &si2168_config);
1294 if (!dvb->i2c_client_demod)
1295 return -ENODEV;
1296
1297 /* attach tuner */
1298 si2157_config.fe = dvb->fe[0];
1299 si2157_config.if_port = 1;
1300 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
1301 si2157_config.mdev = dev->media_dev;
1302 #endif
1303 dvb->i2c_client_tuner = dvb_module_probe("si2157", NULL,
1304 adapter,
1305 0x60, &si2157_config);
1306 if (!dvb->i2c_client_tuner) {
1307 dvb_module_release(dvb->i2c_client_demod);
1308 return -ENODEV;
1309 }
1310 dvb->fe[0]->ops.set_lna = em28xx_pctv_292e_set_lna;
1311
1312 return 0;
1313 }
1314
em28178_dvb_init_terratec_t2_stick_hd(struct em28xx * dev)1315 static int em28178_dvb_init_terratec_t2_stick_hd(struct em28xx *dev)
1316 {
1317 struct em28xx_dvb *dvb = dev->dvb;
1318 struct i2c_adapter *adapter;
1319 struct si2168_config si2168_config = {};
1320 struct si2157_config si2157_config = {};
1321
1322 /* attach demod */
1323 si2168_config.i2c_adapter = &adapter;
1324 si2168_config.fe = &dvb->fe[0];
1325 si2168_config.ts_mode = SI2168_TS_PARALLEL;
1326
1327 dvb->i2c_client_demod = dvb_module_probe("si2168", NULL,
1328 &dev->i2c_adap[dev->def_i2c_bus],
1329 0x64, &si2168_config);
1330 if (!dvb->i2c_client_demod)
1331 return -ENODEV;
1332
1333 /* attach tuner */
1334 memset(&si2157_config, 0, sizeof(si2157_config));
1335 si2157_config.fe = dvb->fe[0];
1336 si2157_config.if_port = 0;
1337 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
1338 si2157_config.mdev = dev->media_dev;
1339 #endif
1340 dvb->i2c_client_tuner = dvb_module_probe("si2157", "si2146",
1341 adapter,
1342 0x60, &si2157_config);
1343 if (!dvb->i2c_client_tuner) {
1344 dvb_module_release(dvb->i2c_client_demod);
1345 return -ENODEV;
1346 }
1347
1348 return 0;
1349 }
1350
em28178_dvb_init_plex_px_bcud(struct em28xx * dev)1351 static int em28178_dvb_init_plex_px_bcud(struct em28xx *dev)
1352 {
1353 struct em28xx_dvb *dvb = dev->dvb;
1354 struct tc90522_config tc90522_config = {};
1355 struct qm1d1c0042_config qm1d1c0042_config = {};
1356
1357 /* attach demod */
1358 dvb->i2c_client_demod = dvb_module_probe("tc90522", "tc90522sat",
1359 &dev->i2c_adap[dev->def_i2c_bus],
1360 0x15, &tc90522_config);
1361 if (!dvb->i2c_client_demod)
1362 return -ENODEV;
1363
1364 /* attach tuner */
1365 qm1d1c0042_config.fe = tc90522_config.fe;
1366 qm1d1c0042_config.lpf = 1;
1367
1368 dvb->i2c_client_tuner = dvb_module_probe("qm1d1c0042", NULL,
1369 tc90522_config.tuner_i2c,
1370 0x61, &qm1d1c0042_config);
1371 if (!dvb->i2c_client_tuner) {
1372 dvb_module_release(dvb->i2c_client_demod);
1373 return -ENODEV;
1374 }
1375
1376 dvb->fe[0] = tc90522_config.fe;
1377 px_bcud_init(dev);
1378
1379 return 0;
1380 }
1381
em28174_dvb_init_hauppauge_wintv_dualhd_dvb(struct em28xx * dev)1382 static int em28174_dvb_init_hauppauge_wintv_dualhd_dvb(struct em28xx *dev)
1383 {
1384 struct em28xx_dvb *dvb = dev->dvb;
1385 struct i2c_adapter *adapter;
1386 struct si2168_config si2168_config = {};
1387 struct si2157_config si2157_config = {};
1388 unsigned char addr;
1389
1390 /* attach demod */
1391 si2168_config.i2c_adapter = &adapter;
1392 si2168_config.fe = &dvb->fe[0];
1393 si2168_config.ts_mode = SI2168_TS_SERIAL;
1394 si2168_config.spectral_inversion = true;
1395 addr = (dev->ts == PRIMARY_TS) ? 0x64 : 0x67;
1396
1397 dvb->i2c_client_demod = dvb_module_probe("si2168", NULL,
1398 &dev->i2c_adap[dev->def_i2c_bus],
1399 addr, &si2168_config);
1400 if (!dvb->i2c_client_demod)
1401 return -ENODEV;
1402
1403 /* attach tuner */
1404 memset(&si2157_config, 0, sizeof(si2157_config));
1405 si2157_config.fe = dvb->fe[0];
1406 si2157_config.if_port = 1;
1407 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
1408 si2157_config.mdev = dev->media_dev;
1409 #endif
1410 addr = (dev->ts == PRIMARY_TS) ? 0x60 : 0x63;
1411
1412 dvb->i2c_client_tuner = dvb_module_probe("si2157", NULL,
1413 adapter,
1414 addr, &si2157_config);
1415 if (!dvb->i2c_client_tuner) {
1416 dvb_module_release(dvb->i2c_client_demod);
1417 return -ENODEV;
1418 }
1419
1420 return 0;
1421 }
1422
em28174_dvb_init_hauppauge_wintv_dualhd_01595(struct em28xx * dev)1423 static int em28174_dvb_init_hauppauge_wintv_dualhd_01595(struct em28xx *dev)
1424 {
1425 struct em28xx_dvb *dvb = dev->dvb;
1426 struct i2c_adapter *adapter;
1427 struct lgdt3306a_config lgdt3306a_config = {};
1428 struct si2157_config si2157_config = {};
1429 unsigned char addr;
1430
1431 /* attach demod */
1432 lgdt3306a_config = hauppauge_01595_lgdt3306a_config;
1433 lgdt3306a_config.fe = &dvb->fe[0];
1434 lgdt3306a_config.i2c_adapter = &adapter;
1435 addr = (dev->ts == PRIMARY_TS) ? 0x59 : 0x0e;
1436
1437 dvb->i2c_client_demod = dvb_module_probe("lgdt3306a", NULL,
1438 &dev->i2c_adap[dev->def_i2c_bus],
1439 addr, &lgdt3306a_config);
1440 if (!dvb->i2c_client_demod)
1441 return -ENODEV;
1442
1443 /* attach tuner */
1444 si2157_config.fe = dvb->fe[0];
1445 si2157_config.if_port = 1;
1446 si2157_config.inversion = 1;
1447 #ifdef CONFIG_MEDIA_CONTROLLER_DVB
1448 si2157_config.mdev = dev->media_dev;
1449 #endif
1450 addr = (dev->ts == PRIMARY_TS) ? 0x60 : 0x62;
1451
1452 dvb->i2c_client_tuner = dvb_module_probe("si2157", NULL,
1453 adapter,
1454 addr, &si2157_config);
1455 if (!dvb->i2c_client_tuner) {
1456 dvb_module_release(dvb->i2c_client_demod);
1457 return -ENODEV;
1458 }
1459
1460 return 0;
1461 }
1462
em2874_dvb_init_hauppauge_usb_quadhd(struct em28xx * dev)1463 static int em2874_dvb_init_hauppauge_usb_quadhd(struct em28xx *dev)
1464 {
1465 struct em28xx_dvb *dvb = dev->dvb;
1466 struct mxl692_config mxl692_config = {};
1467 unsigned char addr;
1468
1469 /* attach demod/tuner combo */
1470 mxl692_config.id = (dev->ts == PRIMARY_TS) ? 0 : 1;
1471 mxl692_config.fe = &dvb->fe[0];
1472 addr = (dev->ts == PRIMARY_TS) ? 0x60 : 0x63;
1473
1474 dvb->i2c_client_demod = dvb_module_probe("mxl692", NULL,
1475 &dev->i2c_adap[dev->def_i2c_bus],
1476 addr, &mxl692_config);
1477 if (!dvb->i2c_client_demod)
1478 return -ENODEV;
1479
1480 return 0;
1481 }
1482
em28xx_dvb_init(struct em28xx * dev)1483 static int em28xx_dvb_init(struct em28xx *dev)
1484 {
1485 int result = 0, dvb_alt = 0;
1486 struct em28xx_dvb *dvb;
1487 struct usb_device *udev;
1488
1489 if (dev->is_audio_only) {
1490 /* Shouldn't initialize IR for this interface */
1491 return 0;
1492 }
1493
1494 if (!dev->board.has_dvb) {
1495 /* This device does not support the extension */
1496 return 0;
1497 }
1498
1499 dev_info(&dev->intf->dev, "Binding DVB extension\n");
1500
1501 dvb = kzalloc(sizeof(*dvb), GFP_KERNEL);
1502 if (!dvb)
1503 return -ENOMEM;
1504
1505 dev->dvb = dvb;
1506 dvb->fe[0] = NULL;
1507 dvb->fe[1] = NULL;
1508
1509 /* pre-allocate DVB usb transfer buffers */
1510 if (dev->dvb_xfer_bulk) {
1511 result = em28xx_alloc_urbs(dev, EM28XX_DIGITAL_MODE,
1512 dev->dvb_xfer_bulk,
1513 EM28XX_DVB_NUM_BUFS,
1514 512,
1515 EM28XX_DVB_BULK_PACKET_MULTIPLIER);
1516 } else {
1517 result = em28xx_alloc_urbs(dev, EM28XX_DIGITAL_MODE,
1518 dev->dvb_xfer_bulk,
1519 EM28XX_DVB_NUM_BUFS,
1520 dev->dvb_max_pkt_size_isoc,
1521 EM28XX_DVB_NUM_ISOC_PACKETS);
1522 }
1523 if (result) {
1524 dev_err(&dev->intf->dev,
1525 "failed to pre-allocate USB transfer buffers for DVB.\n");
1526 kfree(dvb);
1527 dev->dvb = NULL;
1528 return result;
1529 }
1530
1531 mutex_lock(&dev->lock);
1532 em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
1533 /* init frontend */
1534 switch (dev->model) {
1535 case EM2874_BOARD_LEADERSHIP_ISDBT:
1536 dvb->fe[0] = dvb_attach(s921_attach,
1537 &sharp_isdbt,
1538 &dev->i2c_adap[dev->def_i2c_bus]);
1539
1540 if (!dvb->fe[0]) {
1541 result = -EINVAL;
1542 goto out_free;
1543 }
1544
1545 break;
1546 case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_850:
1547 case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950:
1548 case EM2880_BOARD_PINNACLE_PCTV_HD_PRO:
1549 case EM2880_BOARD_AMD_ATI_TV_WONDER_HD_600:
1550 dvb->fe[0] = dvb_attach(lgdt330x_attach,
1551 &em2880_lgdt3303_dev,
1552 0x0e,
1553 &dev->i2c_adap[dev->def_i2c_bus]);
1554 if (em28xx_attach_xc3028(0x61, dev) < 0) {
1555 result = -EINVAL;
1556 goto out_free;
1557 }
1558 break;
1559 case EM2880_BOARD_KWORLD_DVB_310U:
1560 dvb->fe[0] = dvb_attach(zl10353_attach,
1561 &em28xx_zl10353_with_xc3028,
1562 &dev->i2c_adap[dev->def_i2c_bus]);
1563 if (em28xx_attach_xc3028(0x61, dev) < 0) {
1564 result = -EINVAL;
1565 goto out_free;
1566 }
1567 break;
1568 case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900:
1569 case EM2882_BOARD_TERRATEC_HYBRID_XS:
1570 case EM2880_BOARD_EMPIRE_DUAL_TV:
1571 case EM2882_BOARD_ZOLID_HYBRID_TV_STICK:
1572 dvb->fe[0] = dvb_attach(zl10353_attach,
1573 &em28xx_zl10353_xc3028_no_i2c_gate,
1574 &dev->i2c_adap[dev->def_i2c_bus]);
1575 if (em28xx_attach_xc3028(0x61, dev) < 0) {
1576 result = -EINVAL;
1577 goto out_free;
1578 }
1579 break;
1580 case EM2880_BOARD_TERRATEC_HYBRID_XS:
1581 case EM2880_BOARD_TERRATEC_HYBRID_XS_FR:
1582 case EM2881_BOARD_PINNACLE_HYBRID_PRO:
1583 case EM2882_BOARD_DIKOM_DK300:
1584 case EM2882_BOARD_KWORLD_VS_DVBT:
1585 /*
1586 * Those boards could have either a zl10353 or a mt352.
1587 * If the chip id isn't for zl10353, try mt352.
1588 */
1589 dvb->fe[0] = dvb_attach(zl10353_attach,
1590 &em28xx_zl10353_xc3028_no_i2c_gate,
1591 &dev->i2c_adap[dev->def_i2c_bus]);
1592 if (!dvb->fe[0])
1593 dvb->fe[0] = dvb_attach(mt352_attach,
1594 &terratec_xs_mt352_cfg,
1595 &dev->i2c_adap[dev->def_i2c_bus]);
1596
1597 if (em28xx_attach_xc3028(0x61, dev) < 0) {
1598 result = -EINVAL;
1599 goto out_free;
1600 }
1601 break;
1602 case EM2870_BOARD_TERRATEC_XS_MT2060:
1603 dvb->fe[0] = dvb_attach(zl10353_attach,
1604 &em28xx_zl10353_no_i2c_gate_dev,
1605 &dev->i2c_adap[dev->def_i2c_bus]);
1606 if (dvb->fe[0]) {
1607 dvb_attach(mt2060_attach, dvb->fe[0],
1608 &dev->i2c_adap[dev->def_i2c_bus],
1609 &em28xx_mt2060_config, 1220);
1610 }
1611 break;
1612 case EM2870_BOARD_KWORLD_355U:
1613 dvb->fe[0] = dvb_attach(zl10353_attach,
1614 &em28xx_zl10353_no_i2c_gate_dev,
1615 &dev->i2c_adap[dev->def_i2c_bus]);
1616 if (dvb->fe[0])
1617 dvb_attach(qt1010_attach, dvb->fe[0],
1618 &dev->i2c_adap[dev->def_i2c_bus],
1619 &em28xx_qt1010_config);
1620 break;
1621 case EM2883_BOARD_KWORLD_HYBRID_330U:
1622 case EM2882_BOARD_EVGA_INDTUBE:
1623 dvb->fe[0] = dvb_attach(s5h1409_attach,
1624 &em28xx_s5h1409_with_xc3028,
1625 &dev->i2c_adap[dev->def_i2c_bus]);
1626 if (em28xx_attach_xc3028(0x61, dev) < 0) {
1627 result = -EINVAL;
1628 goto out_free;
1629 }
1630 break;
1631 case EM2882_BOARD_KWORLD_ATSC_315U:
1632 dvb->fe[0] = dvb_attach(lgdt330x_attach,
1633 &em2880_lgdt3303_dev,
1634 0x0e,
1635 &dev->i2c_adap[dev->def_i2c_bus]);
1636 if (dvb->fe[0]) {
1637 if (!dvb_attach(simple_tuner_attach, dvb->fe[0],
1638 &dev->i2c_adap[dev->def_i2c_bus],
1639 0x61, TUNER_THOMSON_DTT761X)) {
1640 result = -EINVAL;
1641 goto out_free;
1642 }
1643 }
1644 break;
1645 case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900_R2:
1646 case EM2882_BOARD_PINNACLE_HYBRID_PRO_330E:
1647 dvb->fe[0] = dvb_attach(drxd_attach, &em28xx_drxd, NULL,
1648 &dev->i2c_adap[dev->def_i2c_bus],
1649 &dev->intf->dev);
1650 if (em28xx_attach_xc3028(0x61, dev) < 0) {
1651 result = -EINVAL;
1652 goto out_free;
1653 }
1654 break;
1655 case EM2870_BOARD_REDDO_DVB_C_USB_BOX:
1656 /* Philips CU1216L NIM (Philips TDA10023 + Infineon TUA6034) */
1657 dvb->fe[0] = dvb_attach(tda10023_attach,
1658 &em28xx_tda10023_config,
1659 &dev->i2c_adap[dev->def_i2c_bus],
1660 0x48);
1661 if (dvb->fe[0]) {
1662 if (!dvb_attach(simple_tuner_attach, dvb->fe[0],
1663 &dev->i2c_adap[dev->def_i2c_bus],
1664 0x60, TUNER_PHILIPS_CU1216L)) {
1665 result = -EINVAL;
1666 goto out_free;
1667 }
1668 }
1669 break;
1670 case EM2870_BOARD_KWORLD_A340:
1671 dvb->fe[0] = dvb_attach(lgdt3305_attach,
1672 &em2870_lgdt3304_dev,
1673 &dev->i2c_adap[dev->def_i2c_bus]);
1674 if (!dvb->fe[0]) {
1675 result = -EINVAL;
1676 goto out_free;
1677 }
1678 if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1679 &dev->i2c_adap[dev->def_i2c_bus],
1680 &kworld_a340_config)) {
1681 dvb_frontend_detach(dvb->fe[0]);
1682 result = -EINVAL;
1683 goto out_free;
1684 }
1685 break;
1686 case EM28174_BOARD_PCTV_290E:
1687 /* set default GPIO0 for LNA, used if GPIOLIB is undefined */
1688 dvb->lna_gpio = CXD2820R_GPIO_E | CXD2820R_GPIO_O |
1689 CXD2820R_GPIO_L;
1690 dvb->fe[0] = dvb_attach(cxd2820r_attach,
1691 &em28xx_cxd2820r_config,
1692 &dev->i2c_adap[dev->def_i2c_bus],
1693 &dvb->lna_gpio);
1694 if (dvb->fe[0]) {
1695 /* FE 0 attach tuner */
1696 if (!dvb_attach(tda18271_attach,
1697 dvb->fe[0],
1698 0x60,
1699 &dev->i2c_adap[dev->def_i2c_bus],
1700 &em28xx_cxd2820r_tda18271_config)) {
1701 dvb_frontend_detach(dvb->fe[0]);
1702 result = -EINVAL;
1703 goto out_free;
1704 }
1705
1706 #ifdef CONFIG_GPIOLIB
1707 /* enable LNA for DVB-T, DVB-T2 and DVB-C */
1708 result = gpio_request_one(dvb->lna_gpio,
1709 GPIOF_OUT_INIT_LOW, NULL);
1710 if (result)
1711 dev_err(&dev->intf->dev,
1712 "gpio request failed %d\n",
1713 result);
1714 else
1715 gpio_free(dvb->lna_gpio);
1716
1717 result = 0; /* continue even set LNA fails */
1718 #endif
1719 dvb->fe[0]->ops.set_lna = em28xx_pctv_290e_set_lna;
1720 }
1721
1722 break;
1723 case EM2884_BOARD_HAUPPAUGE_WINTV_HVR_930C:
1724 {
1725 struct xc5000_config cfg = {};
1726
1727 hauppauge_hvr930c_init(dev);
1728
1729 dvb->fe[0] = dvb_attach(drxk_attach,
1730 &hauppauge_930c_drxk,
1731 &dev->i2c_adap[dev->def_i2c_bus]);
1732 if (!dvb->fe[0]) {
1733 result = -EINVAL;
1734 goto out_free;
1735 }
1736 /* FIXME: do we need a pll semaphore? */
1737 dvb->fe[0]->sec_priv = dvb;
1738 sema_init(&dvb->pll_mutex, 1);
1739 dvb->gate_ctrl = dvb->fe[0]->ops.i2c_gate_ctrl;
1740 dvb->fe[0]->ops.i2c_gate_ctrl = drxk_gate_ctrl;
1741
1742 /* Attach xc5000 */
1743 cfg.i2c_address = 0x61;
1744 cfg.if_khz = 4000;
1745
1746 if (dvb->fe[0]->ops.i2c_gate_ctrl)
1747 dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 1);
1748 if (!dvb_attach(xc5000_attach, dvb->fe[0],
1749 &dev->i2c_adap[dev->def_i2c_bus], &cfg)) {
1750 result = -EINVAL;
1751 goto out_free;
1752 }
1753 if (dvb->fe[0]->ops.i2c_gate_ctrl)
1754 dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 0);
1755
1756 break;
1757 }
1758 case EM2884_BOARD_TERRATEC_H5:
1759 terratec_h5_init(dev);
1760
1761 dvb->fe[0] = dvb_attach(drxk_attach, &terratec_h5_drxk,
1762 &dev->i2c_adap[dev->def_i2c_bus]);
1763 if (!dvb->fe[0]) {
1764 result = -EINVAL;
1765 goto out_free;
1766 }
1767 /* FIXME: do we need a pll semaphore? */
1768 dvb->fe[0]->sec_priv = dvb;
1769 sema_init(&dvb->pll_mutex, 1);
1770 dvb->gate_ctrl = dvb->fe[0]->ops.i2c_gate_ctrl;
1771 dvb->fe[0]->ops.i2c_gate_ctrl = drxk_gate_ctrl;
1772
1773 /* Attach tda18271 to DVB-C frontend */
1774 if (dvb->fe[0]->ops.i2c_gate_ctrl)
1775 dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 1);
1776 if (!dvb_attach(tda18271c2dd_attach, dvb->fe[0],
1777 &dev->i2c_adap[dev->def_i2c_bus], 0x60)) {
1778 result = -EINVAL;
1779 goto out_free;
1780 }
1781 if (dvb->fe[0]->ops.i2c_gate_ctrl)
1782 dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 0);
1783
1784 break;
1785 case EM2884_BOARD_C3TECH_DIGITAL_DUO:
1786 dvb->fe[0] = dvb_attach(mb86a20s_attach,
1787 &c3tech_duo_mb86a20s_config,
1788 &dev->i2c_adap[dev->def_i2c_bus]);
1789 if (dvb->fe[0])
1790 dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1791 &dev->i2c_adap[dev->def_i2c_bus],
1792 &c3tech_duo_tda18271_config);
1793 break;
1794 case EM28174_BOARD_PCTV_460E:
1795 result = em28174_dvb_init_pctv_460e(dev);
1796 if (result)
1797 goto out_free;
1798 break;
1799 case EM2874_BOARD_DELOCK_61959:
1800 case EM2874_BOARD_MAXMEDIA_UB425_TC:
1801 /* attach demodulator */
1802 dvb->fe[0] = dvb_attach(drxk_attach, &maxmedia_ub425_tc_drxk,
1803 &dev->i2c_adap[dev->def_i2c_bus]);
1804
1805 if (dvb->fe[0]) {
1806 /* disable I2C-gate */
1807 dvb->fe[0]->ops.i2c_gate_ctrl = NULL;
1808
1809 /* attach tuner */
1810 if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1811 &dev->i2c_adap[dev->def_i2c_bus],
1812 &em28xx_cxd2820r_tda18271_config)) {
1813 dvb_frontend_detach(dvb->fe[0]);
1814 result = -EINVAL;
1815 goto out_free;
1816 }
1817 }
1818 break;
1819 case EM2884_BOARD_PCTV_510E:
1820 case EM2884_BOARD_PCTV_520E:
1821 pctv_520e_init(dev);
1822
1823 /* attach demodulator */
1824 dvb->fe[0] = dvb_attach(drxk_attach, &pctv_520e_drxk,
1825 &dev->i2c_adap[dev->def_i2c_bus]);
1826
1827 if (dvb->fe[0]) {
1828 /* attach tuner */
1829 if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1830 &dev->i2c_adap[dev->def_i2c_bus],
1831 &em28xx_cxd2820r_tda18271_config)) {
1832 dvb_frontend_detach(dvb->fe[0]);
1833 result = -EINVAL;
1834 goto out_free;
1835 }
1836 }
1837 break;
1838 case EM2884_BOARD_ELGATO_EYETV_HYBRID_2008:
1839 case EM2884_BOARD_CINERGY_HTC_STICK:
1840 case EM2884_BOARD_TERRATEC_H6:
1841 terratec_htc_stick_init(dev);
1842
1843 /* attach demodulator */
1844 dvb->fe[0] = dvb_attach(drxk_attach, &terratec_htc_stick_drxk,
1845 &dev->i2c_adap[dev->def_i2c_bus]);
1846 if (!dvb->fe[0]) {
1847 result = -EINVAL;
1848 goto out_free;
1849 }
1850
1851 /* Attach the demodulator. */
1852 if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1853 &dev->i2c_adap[dev->def_i2c_bus],
1854 &em28xx_cxd2820r_tda18271_config)) {
1855 result = -EINVAL;
1856 goto out_free;
1857 }
1858 break;
1859 case EM2884_BOARD_TERRATEC_HTC_USB_XS:
1860 terratec_htc_usb_xs_init(dev);
1861
1862 /* attach demodulator */
1863 dvb->fe[0] = dvb_attach(drxk_attach, &terratec_htc_stick_drxk,
1864 &dev->i2c_adap[dev->def_i2c_bus]);
1865 if (!dvb->fe[0]) {
1866 result = -EINVAL;
1867 goto out_free;
1868 }
1869
1870 /* Attach the demodulator. */
1871 if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1872 &dev->i2c_adap[dev->def_i2c_bus],
1873 &em28xx_cxd2820r_tda18271_config)) {
1874 result = -EINVAL;
1875 goto out_free;
1876 }
1877 break;
1878 case EM2874_BOARD_KWORLD_UB435Q_V2:
1879 dvb->fe[0] = dvb_attach(lgdt3305_attach,
1880 &em2874_lgdt3305_dev,
1881 &dev->i2c_adap[dev->def_i2c_bus]);
1882 if (!dvb->fe[0]) {
1883 result = -EINVAL;
1884 goto out_free;
1885 }
1886
1887 /* Attach the demodulator. */
1888 if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1889 &dev->i2c_adap[dev->def_i2c_bus],
1890 &kworld_ub435q_v2_config)) {
1891 result = -EINVAL;
1892 goto out_free;
1893 }
1894 break;
1895 case EM2874_BOARD_KWORLD_UB435Q_V3:
1896 {
1897 struct i2c_adapter *adapter = &dev->i2c_adap[dev->def_i2c_bus];
1898
1899 dvb->fe[0] = dvb_attach(lgdt3305_attach,
1900 &em2874_lgdt3305_nogate_dev,
1901 &dev->i2c_adap[dev->def_i2c_bus]);
1902 if (!dvb->fe[0]) {
1903 result = -EINVAL;
1904 goto out_free;
1905 }
1906
1907 /* attach tuner */
1908 kworld_ub435q_v3_config.fe = dvb->fe[0];
1909
1910 dvb->i2c_client_tuner = dvb_module_probe("tda18212", NULL,
1911 adapter, 0x60,
1912 &kworld_ub435q_v3_config);
1913 if (!dvb->i2c_client_tuner) {
1914 dvb_frontend_detach(dvb->fe[0]);
1915 result = -ENODEV;
1916 goto out_free;
1917 }
1918 break;
1919 }
1920 case EM2874_BOARD_PCTV_HD_MINI_80E:
1921 dvb->fe[0] = dvb_attach(drx39xxj_attach,
1922 &dev->i2c_adap[dev->def_i2c_bus]);
1923 if (dvb->fe[0]) {
1924 dvb->fe[0] = dvb_attach(tda18271_attach, dvb->fe[0],
1925 0x60,
1926 &dev->i2c_adap[dev->def_i2c_bus],
1927 &pinnacle_80e_dvb_config);
1928 if (!dvb->fe[0]) {
1929 result = -EINVAL;
1930 goto out_free;
1931 }
1932 }
1933 break;
1934 case EM28178_BOARD_PCTV_461E:
1935 result = em28178_dvb_init_pctv_461e(dev);
1936 if (result)
1937 goto out_free;
1938 break;
1939 case EM28178_BOARD_PCTV_461E_V2:
1940 result = em28178_dvb_init_pctv_461e_v2(dev);
1941 if (result)
1942 goto out_free;
1943 break;
1944 case EM28178_BOARD_PCTV_292E:
1945 result = em28178_dvb_init_pctv_292e(dev);
1946 if (result)
1947 goto out_free;
1948 break;
1949 case EM28178_BOARD_TERRATEC_T2_STICK_HD:
1950 result = em28178_dvb_init_terratec_t2_stick_hd(dev);
1951 if (result)
1952 goto out_free;
1953 break;
1954 case EM28178_BOARD_PLEX_PX_BCUD:
1955 result = em28178_dvb_init_plex_px_bcud(dev);
1956 if (result)
1957 goto out_free;
1958 break;
1959 case EM28174_BOARD_HAUPPAUGE_WINTV_DUALHD_DVB:
1960 result = em28174_dvb_init_hauppauge_wintv_dualhd_dvb(dev);
1961 if (result)
1962 goto out_free;
1963 break;
1964 case EM28174_BOARD_HAUPPAUGE_WINTV_DUALHD_01595:
1965 result = em28174_dvb_init_hauppauge_wintv_dualhd_01595(dev);
1966 if (result)
1967 goto out_free;
1968 break;
1969 case EM2874_BOARD_HAUPPAUGE_USB_QUADHD:
1970 result = em2874_dvb_init_hauppauge_usb_quadhd(dev);
1971 if (result)
1972 goto out_free;
1973 break;
1974 default:
1975 dev_err(&dev->intf->dev,
1976 "The frontend of your DVB/ATSC card isn't supported yet\n");
1977 break;
1978 }
1979 if (!dvb->fe[0]) {
1980 dev_err(&dev->intf->dev, "frontend initialization failed\n");
1981 result = -EINVAL;
1982 goto out_free;
1983 }
1984 /* define general-purpose callback pointer */
1985 dvb->fe[0]->callback = em28xx_tuner_callback;
1986 if (dvb->fe[1])
1987 dvb->fe[1]->callback = em28xx_tuner_callback;
1988
1989 /* register everything */
1990 result = em28xx_register_dvb(dvb, THIS_MODULE, dev, &dev->intf->dev);
1991
1992 if (result < 0)
1993 goto out_free;
1994
1995 if (dev->dvb_xfer_bulk) {
1996 dvb_alt = 0;
1997 } else { /* isoc */
1998 dvb_alt = dev->dvb_alt_isoc;
1999 }
2000
2001 udev = interface_to_usbdev(dev->intf);
2002 usb_set_interface(udev, dev->ifnum, dvb_alt);
2003 dev_info(&dev->intf->dev, "DVB extension successfully initialized\n");
2004
2005 kref_get(&dev->ref);
2006
2007 ret:
2008 em28xx_set_mode(dev, EM28XX_SUSPEND);
2009 mutex_unlock(&dev->lock);
2010 return result;
2011
2012 out_free:
2013 em28xx_uninit_usb_xfer(dev, EM28XX_DIGITAL_MODE);
2014 kfree(dvb);
2015 dev->dvb = NULL;
2016 goto ret;
2017 }
2018
prevent_sleep(struct dvb_frontend_ops * ops)2019 static inline void prevent_sleep(struct dvb_frontend_ops *ops)
2020 {
2021 ops->set_voltage = NULL;
2022 ops->sleep = NULL;
2023 ops->tuner_ops.sleep = NULL;
2024 }
2025
em28xx_dvb_fini(struct em28xx * dev)2026 static int em28xx_dvb_fini(struct em28xx *dev)
2027 {
2028 struct em28xx_dvb *dvb;
2029
2030 if (dev->is_audio_only) {
2031 /* Shouldn't initialize IR for this interface */
2032 return 0;
2033 }
2034
2035 if (!dev->board.has_dvb) {
2036 /* This device does not support the extension */
2037 return 0;
2038 }
2039
2040 if (!dev->dvb)
2041 return 0;
2042
2043 dev_info(&dev->intf->dev, "Closing DVB extension\n");
2044
2045 dvb = dev->dvb;
2046
2047 em28xx_uninit_usb_xfer(dev, EM28XX_DIGITAL_MODE);
2048
2049 if (dev->disconnected) {
2050 /*
2051 * We cannot tell the device to sleep
2052 * once it has been unplugged.
2053 */
2054 if (dvb->fe[0]) {
2055 prevent_sleep(&dvb->fe[0]->ops);
2056 dvb->fe[0]->exit = DVB_FE_DEVICE_REMOVED;
2057 }
2058 if (dvb->fe[1]) {
2059 prevent_sleep(&dvb->fe[1]->ops);
2060 dvb->fe[1]->exit = DVB_FE_DEVICE_REMOVED;
2061 }
2062 }
2063
2064 em28xx_unregister_dvb(dvb);
2065
2066 /* release I2C module bindings */
2067 dvb_module_release(dvb->i2c_client_sec);
2068 dvb_module_release(dvb->i2c_client_tuner);
2069 dvb_module_release(dvb->i2c_client_demod);
2070
2071 kfree(dvb);
2072 dev->dvb = NULL;
2073 kref_put(&dev->ref, em28xx_free_device);
2074
2075 return 0;
2076 }
2077
em28xx_dvb_suspend(struct em28xx * dev)2078 static int em28xx_dvb_suspend(struct em28xx *dev)
2079 {
2080 int ret = 0;
2081
2082 if (dev->is_audio_only)
2083 return 0;
2084
2085 if (!dev->board.has_dvb)
2086 return 0;
2087
2088 dev_info(&dev->intf->dev, "Suspending DVB extension\n");
2089 if (dev->dvb) {
2090 struct em28xx_dvb *dvb = dev->dvb;
2091
2092 if (dvb->fe[0]) {
2093 ret = dvb_frontend_suspend(dvb->fe[0]);
2094 dev_info(&dev->intf->dev, "fe0 suspend %d\n", ret);
2095 }
2096 if (dvb->fe[1]) {
2097 dvb_frontend_suspend(dvb->fe[1]);
2098 dev_info(&dev->intf->dev, "fe1 suspend %d\n", ret);
2099 }
2100 }
2101
2102 return 0;
2103 }
2104
em28xx_dvb_resume(struct em28xx * dev)2105 static int em28xx_dvb_resume(struct em28xx *dev)
2106 {
2107 int ret = 0;
2108
2109 if (dev->is_audio_only)
2110 return 0;
2111
2112 if (!dev->board.has_dvb)
2113 return 0;
2114
2115 dev_info(&dev->intf->dev, "Resuming DVB extension\n");
2116 if (dev->dvb) {
2117 struct em28xx_dvb *dvb = dev->dvb;
2118
2119 if (dvb->fe[0]) {
2120 ret = dvb_frontend_resume(dvb->fe[0]);
2121 dev_info(&dev->intf->dev, "fe0 resume %d\n", ret);
2122 }
2123
2124 if (dvb->fe[1]) {
2125 ret = dvb_frontend_resume(dvb->fe[1]);
2126 dev_info(&dev->intf->dev, "fe1 resume %d\n", ret);
2127 }
2128 }
2129
2130 return 0;
2131 }
2132
2133 static struct em28xx_ops dvb_ops = {
2134 .id = EM28XX_DVB,
2135 .name = "Em28xx dvb Extension",
2136 .init = em28xx_dvb_init,
2137 .fini = em28xx_dvb_fini,
2138 .suspend = em28xx_dvb_suspend,
2139 .resume = em28xx_dvb_resume,
2140 };
2141
em28xx_dvb_register(void)2142 static int __init em28xx_dvb_register(void)
2143 {
2144 return em28xx_register_extension(&dvb_ops);
2145 }
2146
em28xx_dvb_unregister(void)2147 static void __exit em28xx_dvb_unregister(void)
2148 {
2149 em28xx_unregister_extension(&dvb_ops);
2150 }
2151
2152 module_init(em28xx_dvb_register);
2153 module_exit(em28xx_dvb_unregister);
2154