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