em28xx-dvb.c 56.6 KB
Newer Older
1 2 3
/*
 DVB device driver for em28xx

4
 (c) 2008-2011 Mauro Carvalho Chehab <mchehab@infradead.org>
5

6 7
 (c) 2008 Devin Heitmueller <devin.heitmueller@gmail.com>
	- 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 12
 (c) 2008 Aidan Thornton <makosoft@googlemail.com>

13 14
 (c) 2012 Frank Schäfer <fschaefer.oss@googlemail.com>

15
 Based on cx88-dvb, saa7134-dvb and videobuf-dvb originally written by:
16 17 18 19 20 21 22 23
	(c) 2004, 2005 Chris Pascoe <c.pascoe@itee.uq.edu.au>
	(c) 2004 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]

 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License.
 */

24 25
#include "em28xx.h"

26
#include <linux/kernel.h>
27
#include <linux/slab.h>
28 29 30
#include <linux/usb.h>

#include <media/v4l2-common.h>
31 32 33
#include <dvb_demux.h>
#include <dvb_net.h>
#include <dmxdev.h>
34 35
#include <media/tuner.h>
#include "tuner-simple.h"
36
#include <linux/gpio.h>
37 38

#include "lgdt330x.h"
39
#include "lgdt3305.h"
40
#include "zl10353.h"
41
#include "s5h1409.h"
42
#include "mt2060.h"
43 44
#include "mt352.h"
#include "mt352_priv.h" /* FIXME */
45
#include "tda1002x.h"
46
#include "drx39xyj/drx39xxj.h"
47
#include "tda18271.h"
48
#include "s921.h"
49
#include "drxd.h"
50
#include "cxd2820r.h"
51 52
#include "tda18271c2dd.h"
#include "drxk.h"
53
#include "tda10071.h"
54
#include "tda18212.h"
55
#include "a8293.h"
A
Aivar Päkk 已提交
56
#include "qt1010.h"
57
#include "mb86a20s.h"
58
#include "m88ds3103.h"
59
#include "ts2020.h"
60 61
#include "si2168.h"
#include "si2157.h"
62 63
#include "tc90522.h"
#include "qm1d1c0042.h"
64 65 66

MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
MODULE_LICENSE("GPL");
67 68 69
MODULE_DESCRIPTION(DRIVER_DESC " - digital TV interface");
MODULE_VERSION(EM28XX_VERSION);

70 71 72 73 74 75
static unsigned int debug;
module_param(debug, int, 0644);
MODULE_PARM_DESC(debug, "enable debug messages [dvb]");

DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);

76 77 78 79
#define dprintk(level, fmt, arg...) do {				\
	if (debug >= level)						\
		dev_printk(KERN_DEBUG, &dev->udev->dev,			\
			   "dvb: " fmt, ## arg);			\
80 81
} while (0)

82
struct em28xx_dvb {
83
	struct dvb_frontend        *fe[2];
84 85 86 87 88 89 90 91 92 93 94 95

	/* feed count management */
	struct mutex               lock;
	int                        nfeeds;

	/* general boilerplate stuff */
	struct dvb_adapter         adapter;
	struct dvb_demux           demux;
	struct dmxdev              dmxdev;
	struct dmx_frontend        fe_hw;
	struct dmx_frontend        fe_mem;
	struct dvb_net             net;
96

97
	/* Due to DRX-K - probably need changes */
98 99
	int (*gate_ctrl)(struct dvb_frontend *, int);
	struct semaphore      pll_mutex;
100
	bool			dont_attach_fe1;
101
	int			lna_gpio;
102
	struct i2c_client	*i2c_client_demod;
103
	struct i2c_client	*i2c_client_tuner;
104
	struct i2c_client	*i2c_client_sec;
105 106 107
};

static inline void print_err_status(struct em28xx *dev,
108
				    int packet, int status)
109
{
110
	char *errmsg = "Unknown";
111

112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
	switch (status) {
	case -ENOENT:
		errmsg = "unlinked synchronuously";
		break;
	case -ECONNRESET:
		errmsg = "unlinked asynchronuously";
		break;
	case -ENOSR:
		errmsg = "Buffer error (overrun)";
		break;
	case -EPIPE:
		errmsg = "Stalled (device not responding)";
		break;
	case -EOVERFLOW:
		errmsg = "Babble (bad cable?)";
		break;
	case -EPROTO:
		errmsg = "Bit-stuff error (bad cable?)";
		break;
	case -EILSEQ:
		errmsg = "CRC/Timeout (could be anything)";
		break;
	case -ETIME:
		errmsg = "Device does not respond";
		break;
	}
	if (packet < 0) {
		dprintk(1, "URB status %d [%s].\n", status, errmsg);
	} else {
141 142
		dprintk(1, "URB packet %d, status %d [%s].\n",
			packet, status, errmsg);
143 144
	}
}
145

146
static inline int em28xx_dvb_urb_data_copy(struct em28xx *dev, struct urb *urb)
147
{
148
	int xfer_bulk, num_packets, i;
149

150 151
	if (!dev)
		return 0;
152

153
	if (dev->disconnected)
154 155
		return 0;

156
	if (urb->status < 0)
157 158
		print_err_status(dev, -1, urb->status);

159 160 161 162 163 164 165 166 167 168 169 170 171 172
	xfer_bulk = usb_pipebulk(urb->pipe);

	if (xfer_bulk) /* bulk */
		num_packets = 1;
	else /* isoc */
		num_packets = urb->number_of_packets;

	for (i = 0; i < num_packets; i++) {
		if (xfer_bulk) {
			if (urb->status < 0) {
				print_err_status(dev, i, urb->status);
				if (urb->status != -EPROTO)
					continue;
			}
173 174
			if (!urb->actual_length)
				continue;
175
			dvb_dmx_swfilter(&dev->dvb->demux, urb->transfer_buffer,
176
					 urb->actual_length);
177 178 179 180 181 182 183
		} else {
			if (urb->iso_frame_desc[i].status < 0) {
				print_err_status(dev, i,
						 urb->iso_frame_desc[i].status);
				if (urb->iso_frame_desc[i].status != -EPROTO)
					continue;
			}
184 185
			if (!urb->iso_frame_desc[i].actual_length)
				continue;
186 187 188 189
			dvb_dmx_swfilter(&dev->dvb->demux,
					 urb->transfer_buffer +
					 urb->iso_frame_desc[i].offset,
					 urb->iso_frame_desc[i].actual_length);
190 191 192 193 194 195
		}
	}

	return 0;
}

196
static int em28xx_start_streaming(struct em28xx_dvb *dvb)
197
{
198
	int rc;
199 200
	struct em28xx_i2c_bus *i2c_bus = dvb->adapter.priv;
	struct em28xx *dev = i2c_bus->dev;
201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
	int dvb_max_packet_size, packet_multiplier, dvb_alt;

	if (dev->dvb_xfer_bulk) {
		if (!dev->dvb_ep_bulk)
			return -ENODEV;
		dvb_max_packet_size = 512; /* USB 2.0 spec */
		packet_multiplier = EM28XX_DVB_BULK_PACKET_MULTIPLIER;
		dvb_alt = 0;
	} else { /* isoc */
		if (!dev->dvb_ep_isoc)
			return -ENODEV;
		dvb_max_packet_size = dev->dvb_max_pkt_size_isoc;
		if (dvb_max_packet_size < 0)
			return dvb_max_packet_size;
		packet_multiplier = EM28XX_DVB_NUM_ISOC_PACKETS;
		dvb_alt = dev->dvb_alt_isoc;
	}
218

219
	usb_set_interface(dev->udev, dev->ifnum, dvb_alt);
220 221 222
	rc = em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
	if (rc < 0)
		return rc;
223

224
	dprintk(1, "Using %d buffers each with %d x %d bytes, alternate %d\n",
225
		EM28XX_DVB_NUM_BUFS,
226
		packet_multiplier,
227
		dvb_max_packet_size, dvb_alt);
228

229 230
	return em28xx_init_usb_xfer(dev, EM28XX_DIGITAL_MODE,
				    dev->dvb_xfer_bulk,
231
				    EM28XX_DVB_NUM_BUFS,
232 233
				    dvb_max_packet_size,
				    packet_multiplier,
234
				    em28xx_dvb_urb_data_copy);
235 236
}

237
static int em28xx_stop_streaming(struct em28xx_dvb *dvb)
238
{
239 240
	struct em28xx_i2c_bus *i2c_bus = dvb->adapter.priv;
	struct em28xx *dev = i2c_bus->dev;
241

242
	em28xx_stop_urbs(dev);
243

244 245 246
	return 0;
}

247
static int em28xx_start_feed(struct dvb_demux_feed *feed)
248 249 250 251 252 253 254 255 256 257 258 259 260
{
	struct dvb_demux *demux  = feed->demux;
	struct em28xx_dvb *dvb = demux->priv;
	int rc, ret;

	if (!demux->dmx.frontend)
		return -EINVAL;

	mutex_lock(&dvb->lock);
	dvb->nfeeds++;
	rc = dvb->nfeeds;

	if (dvb->nfeeds == 1) {
261
		ret = em28xx_start_streaming(dvb);
262 263
		if (ret < 0)
			rc = ret;
264 265 266 267 268 269
	}

	mutex_unlock(&dvb->lock);
	return rc;
}

270
static int em28xx_stop_feed(struct dvb_demux_feed *feed)
271 272 273 274 275 276 277
{
	struct dvb_demux *demux  = feed->demux;
	struct em28xx_dvb *dvb = demux->priv;
	int err = 0;

	mutex_lock(&dvb->lock);
	dvb->nfeeds--;
278 279

	if (0 == dvb->nfeeds)
280
		err = em28xx_stop_streaming(dvb);
281

282 283 284 285 286
	mutex_unlock(&dvb->lock);
	return err;
}


287 288 289
/* ------------------------------------------------------------------ */
static int em28xx_dvb_bus_ctrl(struct dvb_frontend *fe, int acquire)
{
290
	struct em28xx_i2c_bus *i2c_bus = fe->dvb->priv;
291
	struct em28xx *dev = i2c_bus->dev;
292 293 294 295

	if (acquire)
		return em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
	else
296
		return em28xx_set_mode(dev, EM28XX_SUSPEND);
297 298
}

299 300
/* ------------------------------------------------------------------ */

301 302 303 304
static struct lgdt330x_config em2880_lgdt3303_dev = {
	.demod_address = 0x0e,
	.demod_chip = LGDT3303,
};
305

306 307 308 309 310 311 312 313 314 315 316 317
static struct lgdt3305_config em2870_lgdt3304_dev = {
	.i2c_addr           = 0x0e,
	.demod_chip         = LGDT3304,
	.spectral_inversion = 1,
	.deny_i2c_rptr      = 1,
	.mpeg_mode          = LGDT3305_MPEG_PARALLEL,
	.tpclk_edge         = LGDT3305_TPCLK_FALLING_EDGE,
	.tpvalid_polarity   = LGDT3305_TP_VALID_HIGH,
	.vsb_if_khz         = 3250,
	.qam_if_khz         = 4000,
};

318 319 320 321 322 323 324 325 326 327 328 329
static struct lgdt3305_config em2874_lgdt3305_dev = {
	.i2c_addr           = 0x0e,
	.demod_chip         = LGDT3305,
	.spectral_inversion = 1,
	.deny_i2c_rptr      = 0,
	.mpeg_mode          = LGDT3305_MPEG_SERIAL,
	.tpclk_edge         = LGDT3305_TPCLK_FALLING_EDGE,
	.tpvalid_polarity   = LGDT3305_TP_VALID_HIGH,
	.vsb_if_khz         = 3250,
	.qam_if_khz         = 4000,
};

330 331 332 333 334 335 336 337 338 339 340 341
static struct lgdt3305_config em2874_lgdt3305_nogate_dev = {
	.i2c_addr           = 0x0e,
	.demod_chip         = LGDT3305,
	.spectral_inversion = 1,
	.deny_i2c_rptr      = 1,
	.mpeg_mode          = LGDT3305_MPEG_SERIAL,
	.tpclk_edge         = LGDT3305_TPCLK_FALLING_EDGE,
	.tpvalid_polarity   = LGDT3305_TP_VALID_HIGH,
	.vsb_if_khz         = 3600,
	.qam_if_khz         = 3600,
};

342 343 344 345
static struct s921_config sharp_isdbt = {
	.demod_address = 0x30 >> 1
};

346 347 348 349 350 351 352
static struct zl10353_config em28xx_zl10353_with_xc3028 = {
	.demod_address = (0x1e >> 1),
	.no_tuner = 1,
	.parallel_ts = 1,
	.if2 = 45600,
};

353 354 355 356 357 358 359 360 361
static struct s5h1409_config em28xx_s5h1409_with_xc3028 = {
	.demod_address = 0x32 >> 1,
	.output_mode   = S5H1409_PARALLEL_OUTPUT,
	.gpio          = S5H1409_GPIO_OFF,
	.inversion     = S5H1409_INVERSION_OFF,
	.status_mode   = S5H1409_DEMODLOCKING,
	.mpeg_timing   = S5H1409_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK
};

362 363 364 365 366 367 368 369 370 371 372
static struct tda18271_std_map kworld_a340_std_map = {
	.atsc_6   = { .if_freq = 3250, .agc_mode = 3, .std = 0,
		      .if_lvl = 1, .rfagc_top = 0x37, },
	.qam_6    = { .if_freq = 4000, .agc_mode = 3, .std = 1,
		      .if_lvl = 1, .rfagc_top = 0x37, },
};

static struct tda18271_config kworld_a340_config = {
	.std_map           = &kworld_a340_std_map,
};

373 374 375 376 377
static struct tda18271_config kworld_ub435q_v2_config = {
	.std_map	= &kworld_a340_std_map,
	.gate		= TDA18271_GATE_DIGITAL,
};

378 379 380 381 382
static struct tda18212_config kworld_ub435q_v3_config = {
	.if_atsc_vsb	= 3600,
	.if_atsc_qam	= 3600,
};

383
static struct zl10353_config em28xx_zl10353_xc3028_no_i2c_gate = {
384 385 386 387 388 389 390
	.demod_address = (0x1e >> 1),
	.no_tuner = 1,
	.disable_i2c_gate_ctrl = 1,
	.parallel_ts = 1,
	.if2 = 45600,
};

391
static struct drxd_config em28xx_drxd = {
392 393 394 395 396 397
	.demod_address = 0x70,
	.demod_revision = 0xa2,
	.pll_type = DRXD_PLL_NONE,
	.clock = 12000,
	.insert_rs_byte = 1,
	.IF = 42800000,
398
	.disable_i2c_gate_ctrl = 1,
399 400
};

401
static struct drxk_config terratec_h5_drxk = {
402
	.adr = 0x29,
403
	.single_master = 1,
404
	.no_i2c_bridge = 1,
405
	.microcode_name = "dvb-usb-terratec-h5-drxk.fw",
406
	.qam_demod_parameter_count = 2,
407 408
};

409
static struct drxk_config hauppauge_930c_drxk = {
410 411 412 413 414
	.adr = 0x29,
	.single_master = 1,
	.no_i2c_bridge = 1,
	.microcode_name = "dvb-usb-hauppauge-hvr930c-drxk.fw",
	.chunk_size = 56,
415
	.qam_demod_parameter_count = 2,
416 417
};

418
static struct drxk_config terratec_htc_stick_drxk = {
419 420 421 422 423
	.adr = 0x29,
	.single_master = 1,
	.no_i2c_bridge = 1,
	.microcode_name = "dvb-usb-terratec-htc-stick-drxk.fw",
	.chunk_size = 54,
424
	.qam_demod_parameter_count = 2,
425 426 427 428 429 430
	/* Required for the antenna_gpio to disable LNA. */
	.antenna_dvbt = true,
	/* The windows driver uses the same. This will disable LNA. */
	.antenna_gpio = 0x6,
};

431
static struct drxk_config maxmedia_ub425_tc_drxk = {
432 433 434
	.adr = 0x29,
	.single_master = 1,
	.no_i2c_bridge = 1,
435 436
	.microcode_name = "dvb-demod-drxk-01.fw",
	.chunk_size = 62,
437
	.qam_demod_parameter_count = 2,
438 439
};

440
static struct drxk_config pctv_520e_drxk = {
441 442 443
	.adr = 0x29,
	.single_master = 1,
	.microcode_name = "dvb-demod-drxk-pctv.fw",
444
	.qam_demod_parameter_count = 2,
445
	.chunk_size = 58,
446 447
	.antenna_dvbt = true, /* disable LNA */
	.antenna_gpio = (1 << 2), /* disable LNA */
448 449
};

450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
static int drxk_gate_ctrl(struct dvb_frontend *fe, int enable)
{
	struct em28xx_dvb *dvb = fe->sec_priv;
	int status;

	if (!dvb)
		return -EINVAL;

	if (enable) {
		down(&dvb->pll_mutex);
		status = dvb->gate_ctrl(fe, 1);
	} else {
		status = dvb->gate_ctrl(fe, 0);
		up(&dvb->pll_mutex);
	}
	return status;
}

468 469 470 471 472
static void hauppauge_hvr930c_init(struct em28xx *dev)
{
	int i;

	struct em28xx_reg_seq hauppauge_hvr930c_init[] = {
473 474 475
		{EM2874_R80_GPIO_P0_CTRL,	0xff,	0xff,	0x65},
		{EM2874_R80_GPIO_P0_CTRL,	0xfb,	0xff,	0x32},
		{EM2874_R80_GPIO_P0_CTRL,	0xff,	0xff,	0xb8},
476
		{	-1,			-1,	-1,	-1},
477 478
	};
	struct em28xx_reg_seq hauppauge_hvr930c_end[] = {
479 480 481 482 483 484 485 486 487 488 489
		{EM2874_R80_GPIO_P0_CTRL,	0xef,	0xff,	0x01},
		{EM2874_R80_GPIO_P0_CTRL,	0xaf,	0xff,	0x65},
		{EM2874_R80_GPIO_P0_CTRL,	0xef,	0xff,	0x76},
		{EM2874_R80_GPIO_P0_CTRL,	0xef,	0xff,	0x01},
		{EM2874_R80_GPIO_P0_CTRL,	0xcf,	0xff,	0x0b},
		{EM2874_R80_GPIO_P0_CTRL,	0xef,	0xff,	0x40},

		{EM2874_R80_GPIO_P0_CTRL,	0xcf,	0xff,	0x65},
		{EM2874_R80_GPIO_P0_CTRL,	0xef,	0xff,	0x65},
		{EM2874_R80_GPIO_P0_CTRL,	0xcf,	0xff,	0x0b},
		{EM2874_R80_GPIO_P0_CTRL,	0xef,	0xff,	0x65},
490

491
		{	-1,			-1,	-1,	-1},
492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518
	};

	struct {
		unsigned char r[4];
		int len;
	} regs[] = {
		{{ 0x06, 0x02, 0x00, 0x31 }, 4},
		{{ 0x01, 0x02 }, 2},
		{{ 0x01, 0x02, 0x00, 0xc6 }, 4},
		{{ 0x01, 0x00 }, 2},
		{{ 0x01, 0x00, 0xff, 0xaf }, 4},
		{{ 0x01, 0x00, 0x03, 0xa0 }, 4},
		{{ 0x01, 0x00 }, 2},
		{{ 0x01, 0x00, 0x73, 0xaf }, 4},
		{{ 0x04, 0x00 }, 2},
		{{ 0x00, 0x04 }, 2},
		{{ 0x00, 0x04, 0x00, 0x0a }, 4},
		{{ 0x04, 0x14 }, 2},
		{{ 0x04, 0x14, 0x00, 0x00 }, 4},
	};

	em28xx_gpio_set(dev, hauppauge_hvr930c_init);
	em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
	msleep(10);
	em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44);
	msleep(10);

519
	dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1;
520 521

	for (i = 0; i < ARRAY_SIZE(regs); i++)
522
		i2c_master_send(&dev->i2c_client[dev->def_i2c_bus], regs[i].r, regs[i].len);
523 524 525 526 527 528 529 530 531 532 533 534
	em28xx_gpio_set(dev, hauppauge_hvr930c_end);

	msleep(100);

	em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44);
	msleep(30);

	em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x45);
	msleep(10);

}

535 536 537 538
static void terratec_h5_init(struct em28xx *dev)
{
	int i;
	struct em28xx_reg_seq terratec_h5_init[] = {
539
		{EM2820_R08_GPIO_CTRL,		0xff,	0xff,	10},
540 541 542
		{EM2874_R80_GPIO_P0_CTRL,	0xf6,	0xff,	100},
		{EM2874_R80_GPIO_P0_CTRL,	0xf2,	0xff,	50},
		{EM2874_R80_GPIO_P0_CTRL,	0xf6,	0xff,	100},
543
		{	-1,			-1,	-1,	-1},
544 545
	};
	struct em28xx_reg_seq terratec_h5_end[] = {
546 547 548
		{EM2874_R80_GPIO_P0_CTRL,	0xe6,	0xff,	100},
		{EM2874_R80_GPIO_P0_CTRL,	0xa6,	0xff,	50},
		{EM2874_R80_GPIO_P0_CTRL,	0xe6,	0xff,	100},
549
		{	-1,			-1,	-1,	-1},
550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575
	};
	struct {
		unsigned char r[4];
		int len;
	} regs[] = {
		{{ 0x06, 0x02, 0x00, 0x31 }, 4},
		{{ 0x01, 0x02 }, 2},
		{{ 0x01, 0x02, 0x00, 0xc6 }, 4},
		{{ 0x01, 0x00 }, 2},
		{{ 0x01, 0x00, 0xff, 0xaf }, 4},
		{{ 0x01, 0x00, 0x03, 0xa0 }, 4},
		{{ 0x01, 0x00 }, 2},
		{{ 0x01, 0x00, 0x73, 0xaf }, 4},
		{{ 0x04, 0x00 }, 2},
		{{ 0x00, 0x04 }, 2},
		{{ 0x00, 0x04, 0x00, 0x0a }, 4},
		{{ 0x04, 0x14 }, 2},
		{{ 0x04, 0x14, 0x00, 0x00 }, 4},
	};

	em28xx_gpio_set(dev, terratec_h5_init);
	em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
	msleep(10);
	em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x45);
	msleep(10);

576
	dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1;
577 578

	for (i = 0; i < ARRAY_SIZE(regs); i++)
579
		i2c_master_send(&dev->i2c_client[dev->def_i2c_bus], regs[i].r, regs[i].len);
580 581 582
	em28xx_gpio_set(dev, terratec_h5_end);
};

583 584 585 586 587 588 589 590 591 592 593 594
static void terratec_htc_stick_init(struct em28xx *dev)
{
	int i;

	/*
	 * GPIO configuration:
	 * 0xff: unknown (does not affect DVB-T).
	 * 0xf6: DRX-K (demodulator).
	 * 0xe6: unknown (does not affect DVB-T).
	 * 0xb6: unknown (does not affect DVB-T).
	 */
	struct em28xx_reg_seq terratec_htc_stick_init[] = {
595
		{EM2820_R08_GPIO_CTRL,		0xff,	0xff,	10},
596 597 598
		{EM2874_R80_GPIO_P0_CTRL,	0xf6,	0xff,	100},
		{EM2874_R80_GPIO_P0_CTRL,	0xe6,	0xff,	50},
		{EM2874_R80_GPIO_P0_CTRL,	0xf6,	0xff,	100},
599
		{	-1,			-1,	-1,	-1},
600 601
	};
	struct em28xx_reg_seq terratec_htc_stick_end[] = {
602 603
		{EM2874_R80_GPIO_P0_CTRL,	0xb6,	0xff,	100},
		{EM2874_R80_GPIO_P0_CTRL,	0xf6,	0xff,	50},
604
		{	-1,			-1,	-1,	-1},
605 606
	};

607 608 609 610
	/*
	 * Init the analog decoder (not yet supported), but
	 * it's probably still a good idea.
	 */
611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628
	struct {
		unsigned char r[4];
		int len;
	} regs[] = {
		{{ 0x06, 0x02, 0x00, 0x31 }, 4},
		{{ 0x01, 0x02 }, 2},
		{{ 0x01, 0x02, 0x00, 0xc6 }, 4},
		{{ 0x01, 0x00 }, 2},
		{{ 0x01, 0x00, 0xff, 0xaf }, 4},
	};

	em28xx_gpio_set(dev, terratec_htc_stick_init);

	em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
	msleep(10);
	em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44);
	msleep(10);

629
	dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1;
630 631

	for (i = 0; i < ARRAY_SIZE(regs); i++)
632
		i2c_master_send(&dev->i2c_client[dev->def_i2c_bus], regs[i].r, regs[i].len);
633 634 635 636

	em28xx_gpio_set(dev, terratec_htc_stick_end);
};

637 638 639 640 641
static void terratec_htc_usb_xs_init(struct em28xx *dev)
{
	int i;

	struct em28xx_reg_seq terratec_htc_usb_xs_init[] = {
642
		{EM2820_R08_GPIO_CTRL,		0xff,	0xff,	10},
643 644 645
		{EM2874_R80_GPIO_P0_CTRL,	0xb2,	0xff,	100},
		{EM2874_R80_GPIO_P0_CTRL,	0xb2,	0xff,	50},
		{EM2874_R80_GPIO_P0_CTRL,	0xb6,	0xff,	100},
646
		{	-1,			-1,	-1,	-1},
647 648
	};
	struct em28xx_reg_seq terratec_htc_usb_xs_end[] = {
649 650 651
		{EM2874_R80_GPIO_P0_CTRL,	0xa6,	0xff,	100},
		{EM2874_R80_GPIO_P0_CTRL,	0xa6,	0xff,	50},
		{EM2874_R80_GPIO_P0_CTRL,	0xe6,	0xff,	100},
652
		{	-1,			-1,	-1,	-1},
653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686
	};

	/*
	 * Init the analog decoder (not yet supported), but
	 * it's probably still a good idea.
	 */
	struct {
		unsigned char r[4];
		int len;
	} regs[] = {
		{{ 0x06, 0x02, 0x00, 0x31 }, 4},
		{{ 0x01, 0x02 }, 2},
		{{ 0x01, 0x02, 0x00, 0xc6 }, 4},
		{{ 0x01, 0x00 }, 2},
		{{ 0x01, 0x00, 0xff, 0xaf }, 4},
		{{ 0x01, 0x00, 0x03, 0xa0 }, 4},
		{{ 0x01, 0x00 }, 2},
		{{ 0x01, 0x00, 0x73, 0xaf }, 4},
		{{ 0x04, 0x00 }, 2},
		{{ 0x00, 0x04 }, 2},
		{{ 0x00, 0x04, 0x00, 0x0a }, 4},
		{{ 0x04, 0x14 }, 2},
		{{ 0x04, 0x14, 0x00, 0x00 }, 4},
	};

	em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);

	em28xx_gpio_set(dev, terratec_htc_usb_xs_init);

	em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
	msleep(10);
	em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44);
	msleep(10);

687
	dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1;
688 689

	for (i = 0; i < ARRAY_SIZE(regs); i++)
690
		i2c_master_send(&dev->i2c_client[dev->def_i2c_bus], regs[i].r, regs[i].len);
691 692 693 694

	em28xx_gpio_set(dev, terratec_htc_usb_xs_end);
};

695 696 697
static void pctv_520e_init(struct em28xx *dev)
{
	/*
698 699
	 * Init AVF4910B analog decoder. Looks like I2C traffic to
	 * digital demodulator and tuner are routed via AVF4910B.
700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715
	 */
	int i;
	struct {
		unsigned char r[4];
		int len;
	} regs[] = {
		{{ 0x06, 0x02, 0x00, 0x31 }, 4},
		{{ 0x01, 0x02 }, 2},
		{{ 0x01, 0x02, 0x00, 0xc6 }, 4},
		{{ 0x01, 0x00 }, 2},
		{{ 0x01, 0x00, 0xff, 0xaf }, 4},
		{{ 0x01, 0x00, 0x03, 0xa0 }, 4},
		{{ 0x01, 0x00 }, 2},
		{{ 0x01, 0x00, 0x73, 0xaf }, 4},
	};

716
	dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1; /* 0x41 */
717 718

	for (i = 0; i < ARRAY_SIZE(regs); i++)
719
		i2c_master_send(&dev->i2c_client[dev->def_i2c_bus], regs[i].r, regs[i].len);
720 721
};

722
static int em28xx_pctv_290e_set_lna(struct dvb_frontend *fe)
723
{
724
	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
725 726
	struct em28xx_i2c_bus *i2c_bus = fe->dvb->priv;
	struct em28xx *dev = i2c_bus->dev;
727 728 729 730 731
#ifdef CONFIG_GPIOLIB
	struct em28xx_dvb *dvb = dev->dvb;
	int ret;
	unsigned long flags;

732 733
	if (c->lna == 1)
		flags = GPIOF_OUT_INIT_HIGH; /* enable LNA */
734
	else
735
		flags = GPIOF_OUT_INIT_LOW; /* disable LNA */
736 737 738

	ret = gpio_request_one(dvb->lna_gpio, flags, NULL);
	if (ret)
739
		dev_err(&dev->udev->dev, "gpio request failed %d\n", ret);
740 741 742 743 744
	else
		gpio_free(dvb->lna_gpio);

	return ret;
#else
745
	dev_warn(&dev->udev->dev, "%s: LNA control is disabled (lna=%u)\n",
746
		 KBUILD_MODNAME, c->lna);
747 748 749 750
	return 0;
#endif
}

751 752 753 754 755 756 757 758 759 760 761 762 763 764 765
static int em28xx_pctv_292e_set_lna(struct dvb_frontend *fe)
{
	struct dtv_frontend_properties *c = &fe->dtv_property_cache;
	struct em28xx_i2c_bus *i2c_bus = fe->dvb->priv;
	struct em28xx *dev = i2c_bus->dev;
	u8 lna;

	if (c->lna == 1)
		lna = 0x01;
	else
		lna = 0x00;

	return em28xx_write_reg_bits(dev, EM2874_R80_GPIO_P0_CTRL, lna, 0x01);
}

766
static int em28xx_mt352_terratec_xs_init(struct dvb_frontend *fe)
767 768 769 770 771 772 773 774 775 776 777
{
	/* Values extracted from a USB trace of the Terratec Windows driver */
	static u8 clock_config[]   = { CLOCK_CTL,  0x38, 0x2c };
	static u8 reset[]          = { RESET,      0x80 };
	static u8 adc_ctl_1_cfg[]  = { ADC_CTL_1,  0x40 };
	static u8 agc_cfg[]        = { AGC_TARGET, 0x28, 0xa0 };
	static u8 input_freq_cfg[] = { INPUT_FREQ_1, 0x31, 0xb8 };
	static u8 rs_err_cfg[]     = { RS_ERR_PER_1, 0x00, 0x4d };
	static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
	static u8 trl_nom_cfg[]    = { TRL_NOMINAL_RATE_1, 0x64, 0x00 };
	static u8 tps_given_cfg[]  = { TPS_GIVEN_1, 0x40, 0x80, 0x50 };
778
	static u8 tuner_go[]       = { TUNER_GO, 0x01};
779 780 781 782 783 784 785 786 787 788 789 790 791 792 793

	mt352_write(fe, clock_config,   sizeof(clock_config));
	udelay(200);
	mt352_write(fe, reset,          sizeof(reset));
	mt352_write(fe, adc_ctl_1_cfg,  sizeof(adc_ctl_1_cfg));
	mt352_write(fe, agc_cfg,        sizeof(agc_cfg));
	mt352_write(fe, input_freq_cfg, sizeof(input_freq_cfg));
	mt352_write(fe, rs_err_cfg,     sizeof(rs_err_cfg));
	mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
	mt352_write(fe, trl_nom_cfg,    sizeof(trl_nom_cfg));
	mt352_write(fe, tps_given_cfg,  sizeof(tps_given_cfg));
	mt352_write(fe, tuner_go,       sizeof(tuner_go));
	return 0;
}

794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855
static void px_bcud_init(struct em28xx *dev)
{
	int i;
	struct {
		unsigned char r[4];
		int len;
	} regs1[] = {
		{{ 0x0e, 0x77 }, 2},
		{{ 0x0f, 0x77 }, 2},
		{{ 0x03, 0x90 }, 2},
	}, regs2[] = {
		{{ 0x07, 0x01 }, 2},
		{{ 0x08, 0x10 }, 2},
		{{ 0x13, 0x00 }, 2},
		{{ 0x17, 0x00 }, 2},
		{{ 0x03, 0x01 }, 2},
		{{ 0x10, 0xb1 }, 2},
		{{ 0x11, 0x40 }, 2},
		{{ 0x85, 0x7a }, 2},
		{{ 0x87, 0x04 }, 2},
	};
	static struct em28xx_reg_seq gpio[] = {
		{EM28XX_R06_I2C_CLK,		0x40,	0xff,	300},
		{EM2874_R80_GPIO_P0_CTRL,	0xfd,	0xff,	60},
		{EM28XX_R15_RGAIN,		0x20,	0xff,	0},
		{EM28XX_R16_GGAIN,		0x20,	0xff,	0},
		{EM28XX_R17_BGAIN,		0x20,	0xff,	0},
		{EM28XX_R18_ROFFSET,		0x00,	0xff,	0},
		{EM28XX_R19_GOFFSET,		0x00,	0xff,	0},
		{EM28XX_R1A_BOFFSET,		0x00,	0xff,	0},
		{EM28XX_R23_UOFFSET,		0x00,	0xff,	0},
		{EM28XX_R24_VOFFSET,		0x00,	0xff,	0},
		{EM28XX_R26_COMPR,		0x00,	0xff,	0},
		{0x13,				0x08,	0xff,	0},
		{EM28XX_R12_VINENABLE,		0x27,	0xff,	0},
		{EM28XX_R0C_USBSUSP,		0x10,	0xff,	0},
		{EM28XX_R27_OUTFMT,		0x00,	0xff,	0},
		{EM28XX_R10_VINMODE,		0x00,	0xff,	0},
		{EM28XX_R11_VINCTRL,		0x11,	0xff,	0},
		{EM2874_R50_IR_CONFIG,		0x01,	0xff,	0},
		{EM2874_R5F_TS_ENABLE,		0x80,	0xff,	0},
		{EM28XX_R06_I2C_CLK,		0x46,	0xff,	0},
	};
	em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x46);
	/* sleeping ISDB-T */
	dev->dvb->i2c_client_demod->addr = 0x14;
	for (i = 0; i < ARRAY_SIZE(regs1); i++)
		i2c_master_send(dev->dvb->i2c_client_demod, regs1[i].r,
				regs1[i].len);
	/* sleeping ISDB-S */
	dev->dvb->i2c_client_demod->addr = 0x15;
	for (i = 0; i < ARRAY_SIZE(regs2); i++)
		i2c_master_send(dev->dvb->i2c_client_demod, regs2[i].r,
				regs2[i].len);
	for (i = 0; i < ARRAY_SIZE(gpio); i++) {
		em28xx_write_reg_bits(dev, gpio[i].reg, gpio[i].val,
				      gpio[i].mask);
		if (gpio[i].sleep > 0)
			msleep(gpio[i].sleep);
	}
};

856 857 858 859
static struct mt352_config terratec_xs_mt352_cfg = {
	.demod_address = (0x1e >> 1),
	.no_tuner = 1,
	.if2 = 45600,
860
	.demod_init = em28xx_mt352_terratec_xs_init,
861 862
};

863 864 865 866 867
static struct tda10023_config em28xx_tda10023_config = {
	.demod_address = 0x0c,
	.invert = 1,
};

868 869 870 871 872 873 874
static struct cxd2820r_config em28xx_cxd2820r_config = {
	.i2c_address = (0xd8 >> 1),
	.ts_mode = CXD2820R_TS_SERIAL,
};

static struct tda18271_config em28xx_cxd2820r_tda18271_config = {
	.output_opt = TDA18271_OUTPUT_LT_OFF,
875
	.gate = TDA18271_GATE_DIGITAL,
876 877
};

A
Aivar Päkk 已提交
878 879 880 881 882 883
static struct zl10353_config em28xx_zl10353_no_i2c_gate_dev = {
	.demod_address = (0x1e >> 1),
	.disable_i2c_gate_ctrl = 1,
	.no_tuner = 1,
	.parallel_ts = 1,
};
884

885 886 887 888
static struct mt2060_config em28xx_mt2060_config = {
	.i2c_address = 0x60,
};

A
Aivar Päkk 已提交
889 890
static struct qt1010_config em28xx_qt1010_config = {
	.i2c_address = 0x62
891 892 893 894 895 896 897 898 899 900 901
};

static const struct mb86a20s_config c3tech_duo_mb86a20s_config = {
	.demod_address = 0x10,
	.is_serial = true,
};

static struct tda18271_std_map mb86a20s_tda18271_config = {
	.dvbt_6   = { .if_freq = 4000, .agc_mode = 3, .std = 4,
		      .if_lvl = 1, .rfagc_top = 0x37, },
};
A
Aivar Päkk 已提交
902

903 904 905 906
static struct tda18271_config c3tech_duo_tda18271_config = {
	.std_map = &mb86a20s_tda18271_config,
	.gate    = TDA18271_GATE_DIGITAL,
	.small_i2c = TDA18271_03_BYTE_CHUNK_INIT,
A
Aivar Päkk 已提交
907 908
};

909 910 911 912 913 914 915 916 917 918 919 920 921
static struct tda18271_std_map drx_j_std_map = {
	.atsc_6   = { .if_freq = 5000, .agc_mode = 3, .std = 0, .if_lvl = 1,
		      .rfagc_top = 0x37, },
	.qam_6    = { .if_freq = 5380, .agc_mode = 3, .std = 3, .if_lvl = 1,
		      .rfagc_top = 0x37, },
};

static struct tda18271_config pinnacle_80e_dvb_config = {
	.std_map = &drx_j_std_map,
	.gate    = TDA18271_GATE_DIGITAL,
	.role    = TDA18271_MASTER,
};

922 923
/* ------------------------------------------------------------------ */

924
static int em28xx_attach_xc3028(u8 addr, struct em28xx *dev)
925 926
{
	struct dvb_frontend *fe;
927
	struct xc2028_config cfg;
928
	struct xc2028_ctrl ctl;
929

930
	memset(&cfg, 0, sizeof(cfg));
931
	cfg.i2c_adap  = &dev->i2c_adap[dev->def_i2c_bus];
932 933
	cfg.i2c_addr  = addr;

934 935 936 937
	memset(&ctl, 0, sizeof(ctl));
	em28xx_setup_xc3028(dev, &ctl);
	cfg.ctrl  = &ctl;

938
	if (!dev->dvb->fe[0]) {
939 940
		dev_err(&dev->udev->dev,
			"dvb frontend not attached. Can't attach xc3028\n");
941 942 943
		return -EINVAL;
	}

944
	fe = dvb_attach(xc2028_attach, dev->dvb->fe[0], &cfg);
945
	if (!fe) {
946
		dev_err(&dev->udev->dev, "xc3028 attach failed\n");
947 948
		dvb_frontend_detach(dev->dvb->fe[0]);
		dev->dvb->fe[0] = NULL;
949 950 951
		return -EINVAL;
	}

952
	dev_info(&dev->udev->dev, "xc3028 attached\n");
953 954 955 956

	return 0;
}

957 958
/* ------------------------------------------------------------------ */

959 960
static int em28xx_register_dvb(struct em28xx_dvb *dvb, struct module *module,
			       struct em28xx *dev, struct device *device)
961
{
962
	int result;
963
	bool create_rf_connector = false;
964

965
	mutex_init(&dvb->lock);
966

967
	/* register adapter */
968 969 970
	result = dvb_register_adapter(&dvb->adapter,
				      dev_name(&dev->udev->dev), module,
				      device, adapter_nr);
971
	if (result < 0) {
972 973 974
		dev_warn(&dev->udev->dev,
			 "dvb_register_adapter failed (errno = %d)\n",
			 result);
975 976
		goto fail_adapter;
	}
977 978 979
#ifdef CONFIG_MEDIA_CONTROLLER_DVB
	dvb->adapter.mdev = dev->media_dev;
#endif
980 981

	/* Ensure all frontends negotiate bus access */
982 983 984
	dvb->fe[0]->ops.ts_bus_ctrl = em28xx_dvb_bus_ctrl;
	if (dvb->fe[1])
		dvb->fe[1]->ops.ts_bus_ctrl = em28xx_dvb_bus_ctrl;
985

986
	dvb->adapter.priv = &dev->i2c_bus[dev->def_i2c_bus];
987 988

	/* register frontend */
989
	result = dvb_register_frontend(&dvb->adapter, dvb->fe[0]);
990
	if (result < 0) {
991 992 993
		dev_warn(&dev->udev->dev,
			 "dvb_register_frontend failed (errno = %d)\n",
			 result);
994 995 996 997 998 999 1000
		goto fail_frontend0;
	}

	/* register 2nd frontend */
	if (dvb->fe[1]) {
		result = dvb_register_frontend(&dvb->adapter, dvb->fe[1]);
		if (result < 0) {
1001 1002 1003
			dev_warn(&dev->udev->dev,
				 "2nd dvb_register_frontend failed (errno = %d)\n",
				 result);
1004 1005
			goto fail_frontend1;
		}
1006 1007 1008 1009 1010 1011 1012 1013 1014
	}

	/* register demux stuff */
	dvb->demux.dmx.capabilities =
		DMX_TS_FILTERING | DMX_SECTION_FILTERING |
		DMX_MEMORY_BASED_FILTERING;
	dvb->demux.priv       = dvb;
	dvb->demux.filternum  = 256;
	dvb->demux.feednum    = 256;
1015 1016
	dvb->demux.start_feed = em28xx_start_feed;
	dvb->demux.stop_feed  = em28xx_stop_feed;
1017

1018 1019
	result = dvb_dmx_init(&dvb->demux);
	if (result < 0) {
1020 1021 1022
		dev_warn(&dev->udev->dev,
			 "dvb_dmx_init failed (errno = %d)\n",
			 result);
1023 1024 1025 1026 1027 1028 1029 1030
		goto fail_dmx;
	}

	dvb->dmxdev.filternum    = 256;
	dvb->dmxdev.demux        = &dvb->demux.dmx;
	dvb->dmxdev.capabilities = 0;
	result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
	if (result < 0) {
1031 1032 1033
		dev_warn(&dev->udev->dev,
			 "dvb_dmxdev_init failed (errno = %d)\n",
			 result);
1034 1035
		goto fail_dmxdev;
	}
1036

1037 1038 1039
	dvb->fe_hw.source = DMX_FRONTEND_0;
	result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw);
	if (result < 0) {
1040 1041 1042
		dev_warn(&dev->udev->dev,
			 "add_frontend failed (DMX_FRONTEND_0, errno = %d)\n",
			 result);
1043 1044 1045 1046 1047 1048
		goto fail_fe_hw;
	}

	dvb->fe_mem.source = DMX_MEMORY_FE;
	result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem);
	if (result < 0) {
1049 1050 1051
		dev_warn(&dev->udev->dev,
			 "add_frontend failed (DMX_MEMORY_FE, errno = %d)\n",
			 result);
1052 1053 1054 1055 1056
		goto fail_fe_mem;
	}

	result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw);
	if (result < 0) {
1057 1058 1059
		dev_warn(&dev->udev->dev,
			 "connect_frontend failed (errno = %d)\n",
			 result);
1060 1061 1062 1063 1064
		goto fail_fe_conn;
	}

	/* register network adapter */
	dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx);
1065

1066 1067 1068 1069 1070
	/* If the analog part won't create RF connectors, DVB will do it */
	if (!dev->has_video || (dev->tuner_type == TUNER_ABSENT))
		create_rf_connector = true;

	result = dvb_create_media_graph(&dvb->adapter, create_rf_connector);
1071 1072 1073
	if (result < 0)
		goto fail_create_graph;

1074 1075
	return 0;

1076 1077
fail_create_graph:
	dvb_net_release(&dvb->net);
1078 1079 1080 1081 1082 1083 1084 1085 1086
fail_fe_conn:
	dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
fail_fe_mem:
	dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
fail_fe_hw:
	dvb_dmxdev_release(&dvb->dmxdev);
fail_dmxdev:
	dvb_dmx_release(&dvb->demux);
fail_dmx:
1087 1088 1089 1090 1091 1092 1093 1094
	if (dvb->fe[1])
		dvb_unregister_frontend(dvb->fe[1]);
	dvb_unregister_frontend(dvb->fe[0]);
fail_frontend1:
	if (dvb->fe[1])
		dvb_frontend_detach(dvb->fe[1]);
fail_frontend0:
	dvb_frontend_detach(dvb->fe[0]);
1095 1096 1097 1098 1099
	dvb_unregister_adapter(&dvb->adapter);
fail_adapter:
	return result;
}

1100
static void em28xx_unregister_dvb(struct em28xx_dvb *dvb)
1101 1102 1103 1104 1105 1106
{
	dvb_net_release(&dvb->net);
	dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
	dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
	dvb_dmxdev_release(&dvb->dmxdev);
	dvb_dmx_release(&dvb->demux);
1107 1108 1109
	if (dvb->fe[1])
		dvb_unregister_frontend(dvb->fe[1]);
	dvb_unregister_frontend(dvb->fe[0]);
1110
	if (dvb->fe[1] && !dvb->dont_attach_fe1)
1111 1112
		dvb_frontend_detach(dvb->fe[1]);
	dvb_frontend_detach(dvb->fe[0]);
1113 1114 1115
	dvb_unregister_adapter(&dvb->adapter);
}

1116
static int em28xx_dvb_init(struct em28xx *dev)
1117
{
1118
	int result = 0;
1119 1120
	struct em28xx_dvb *dvb;

1121 1122 1123 1124 1125
	if (dev->is_audio_only) {
		/* Shouldn't initialize IR for this interface */
		return 0;
	}

1126
	if (!dev->board.has_dvb) {
1127 1128 1129 1130
		/* This device does not support the extension */
		return 0;
	}

1131
	dev_info(&dev->udev->dev, "Binding DVB extension\n");
1132

1133
	dvb = kzalloc(sizeof(struct em28xx_dvb), GFP_KERNEL);
1134
	if (!dvb)
1135
		return -ENOMEM;
1136

1137
	dev->dvb = dvb;
1138
	dvb->fe[0] = dvb->fe[1] = NULL;
1139

1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154
	/* pre-allocate DVB usb transfer buffers */
	if (dev->dvb_xfer_bulk) {
		result = em28xx_alloc_urbs(dev, EM28XX_DIGITAL_MODE,
					   dev->dvb_xfer_bulk,
					   EM28XX_DVB_NUM_BUFS,
					   512,
					   EM28XX_DVB_BULK_PACKET_MULTIPLIER);
	} else {
		result = em28xx_alloc_urbs(dev, EM28XX_DIGITAL_MODE,
					   dev->dvb_xfer_bulk,
					   EM28XX_DVB_NUM_BUFS,
					   dev->dvb_max_pkt_size_isoc,
					   EM28XX_DVB_NUM_ISOC_PACKETS);
	}
	if (result) {
1155 1156
		dev_err(&dev->udev->dev,
			"failed to pre-allocate USB transfer buffers for DVB.\n");
1157 1158 1159 1160 1161
		kfree(dvb);
		dev->dvb = NULL;
		return result;
	}

1162
	mutex_lock(&dev->lock);
1163
	em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
1164 1165
	/* init frontend */
	switch (dev->model) {
1166
	case EM2874_BOARD_LEADERSHIP_ISDBT:
1167
		dvb->fe[0] = dvb_attach(s921_attach,
1168
				&sharp_isdbt, &dev->i2c_adap[dev->def_i2c_bus]);
1169

1170
		if (!dvb->fe[0]) {
1171 1172 1173 1174 1175
			result = -EINVAL;
			goto out_free;
		}

		break;
1176
	case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_850:
1177
	case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950:
1178
	case EM2880_BOARD_PINNACLE_PCTV_HD_PRO:
1179
	case EM2880_BOARD_AMD_ATI_TV_WONDER_HD_600:
1180
		dvb->fe[0] = dvb_attach(lgdt330x_attach,
1181
					   &em2880_lgdt3303_dev,
1182
					   &dev->i2c_adap[dev->def_i2c_bus]);
1183
		if (em28xx_attach_xc3028(0x61, dev) < 0) {
1184 1185 1186
			result = -EINVAL;
			goto out_free;
		}
1187
		break;
1188
	case EM2880_BOARD_KWORLD_DVB_310U:
1189
		dvb->fe[0] = dvb_attach(zl10353_attach,
1190
					   &em28xx_zl10353_with_xc3028,
1191
					   &dev->i2c_adap[dev->def_i2c_bus]);
1192
		if (em28xx_attach_xc3028(0x61, dev) < 0) {
1193 1194 1195
			result = -EINVAL;
			goto out_free;
		}
1196
		break;
1197
	case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900:
1198
	case EM2882_BOARD_TERRATEC_HYBRID_XS:
1199
	case EM2880_BOARD_EMPIRE_DUAL_TV:
1200
		dvb->fe[0] = dvb_attach(zl10353_attach,
1201
					   &em28xx_zl10353_xc3028_no_i2c_gate,
1202
					   &dev->i2c_adap[dev->def_i2c_bus]);
1203
		if (em28xx_attach_xc3028(0x61, dev) < 0) {
1204 1205 1206 1207
			result = -EINVAL;
			goto out_free;
		}
		break;
1208
	case EM2880_BOARD_TERRATEC_HYBRID_XS:
1209
	case EM2880_BOARD_TERRATEC_HYBRID_XS_FR:
1210
	case EM2881_BOARD_PINNACLE_HYBRID_PRO:
1211
	case EM2882_BOARD_DIKOM_DK300:
1212
	case EM2882_BOARD_KWORLD_VS_DVBT:
1213
		dvb->fe[0] = dvb_attach(zl10353_attach,
1214
					   &em28xx_zl10353_xc3028_no_i2c_gate,
1215
					   &dev->i2c_adap[dev->def_i2c_bus]);
1216
		if (dvb->fe[0] == NULL) {
1217 1218
			/* This board could have either a zl10353 or a mt352.
			   If the chip id isn't for zl10353, try mt352 */
1219
			dvb->fe[0] = dvb_attach(mt352_attach,
1220
						   &terratec_xs_mt352_cfg,
1221
						   &dev->i2c_adap[dev->def_i2c_bus]);
1222
		}
1223

1224
		if (em28xx_attach_xc3028(0x61, dev) < 0) {
1225 1226 1227 1228
			result = -EINVAL;
			goto out_free;
		}
		break;
1229 1230 1231 1232 1233 1234 1235 1236 1237 1238
	case EM2870_BOARD_TERRATEC_XS_MT2060:
		dvb->fe[0] = dvb_attach(zl10353_attach,
						&em28xx_zl10353_no_i2c_gate_dev,
						&dev->i2c_adap[dev->def_i2c_bus]);
		if (dvb->fe[0] != NULL) {
			dvb_attach(mt2060_attach, dvb->fe[0],
					&dev->i2c_adap[dev->def_i2c_bus],
					&em28xx_mt2060_config, 1220);
		}
		break;
A
Aivar Päkk 已提交
1239 1240 1241
	case EM2870_BOARD_KWORLD_355U:
		dvb->fe[0] = dvb_attach(zl10353_attach,
					   &em28xx_zl10353_no_i2c_gate_dev,
1242
					   &dev->i2c_adap[dev->def_i2c_bus]);
A
Aivar Päkk 已提交
1243 1244
		if (dvb->fe[0] != NULL)
			dvb_attach(qt1010_attach, dvb->fe[0],
1245
				   &dev->i2c_adap[dev->def_i2c_bus], &em28xx_qt1010_config);
A
Aivar Päkk 已提交
1246
		break;
1247
	case EM2883_BOARD_KWORLD_HYBRID_330U:
1248
	case EM2882_BOARD_EVGA_INDTUBE:
1249
		dvb->fe[0] = dvb_attach(s5h1409_attach,
1250
					   &em28xx_s5h1409_with_xc3028,
1251
					   &dev->i2c_adap[dev->def_i2c_bus]);
1252
		if (em28xx_attach_xc3028(0x61, dev) < 0) {
1253 1254 1255 1256
			result = -EINVAL;
			goto out_free;
		}
		break;
1257
	case EM2882_BOARD_KWORLD_ATSC_315U:
1258
		dvb->fe[0] = dvb_attach(lgdt330x_attach,
1259
					   &em2880_lgdt3303_dev,
1260
					   &dev->i2c_adap[dev->def_i2c_bus]);
1261 1262
		if (dvb->fe[0] != NULL) {
			if (!dvb_attach(simple_tuner_attach, dvb->fe[0],
1263 1264
					&dev->i2c_adap[dev->def_i2c_bus],
					0x61, TUNER_THOMSON_DTT761X)) {
1265 1266 1267 1268 1269
				result = -EINVAL;
				goto out_free;
			}
		}
		break;
1270
	case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900_R2:
1271
	case EM2882_BOARD_PINNACLE_HYBRID_PRO_330E:
1272
		dvb->fe[0] = dvb_attach(drxd_attach, &em28xx_drxd, NULL,
1273
					   &dev->i2c_adap[dev->def_i2c_bus], &dev->udev->dev);
1274
		if (em28xx_attach_xc3028(0x61, dev) < 0) {
1275 1276 1277 1278
			result = -EINVAL;
			goto out_free;
		}
		break;
1279 1280
	case EM2870_BOARD_REDDO_DVB_C_USB_BOX:
		/* Philips CU1216L NIM (Philips TDA10023 + Infineon TUA6034) */
1281
		dvb->fe[0] = dvb_attach(tda10023_attach,
1282
			&em28xx_tda10023_config,
1283
			&dev->i2c_adap[dev->def_i2c_bus], 0x48);
1284 1285
		if (dvb->fe[0]) {
			if (!dvb_attach(simple_tuner_attach, dvb->fe[0],
1286 1287
					&dev->i2c_adap[dev->def_i2c_bus],
					0x60, TUNER_PHILIPS_CU1216L)) {
1288 1289 1290 1291 1292
				result = -EINVAL;
				goto out_free;
			}
		}
		break;
1293
	case EM2870_BOARD_KWORLD_A340:
1294
		dvb->fe[0] = dvb_attach(lgdt3305_attach,
1295
					   &em2870_lgdt3304_dev,
1296
					   &dev->i2c_adap[dev->def_i2c_bus]);
1297 1298 1299 1300 1301
		if (!dvb->fe[0]) {
			result = -EINVAL;
			goto out_free;
		}
		if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1302
				&dev->i2c_adap[dev->def_i2c_bus],
1303 1304 1305 1306 1307
			&kworld_a340_config)) {
				dvb_frontend_detach(dvb->fe[0]);
				result = -EINVAL;
				goto out_free;
		}
1308
		break;
1309
	case EM28174_BOARD_PCTV_290E:
1310 1311 1312
		/* set default GPIO0 for LNA, used if GPIOLIB is undefined */
		dvb->lna_gpio = CXD2820R_GPIO_E | CXD2820R_GPIO_O |
				CXD2820R_GPIO_L;
1313
		dvb->fe[0] = dvb_attach(cxd2820r_attach,
1314
					&em28xx_cxd2820r_config,
1315
					&dev->i2c_adap[dev->def_i2c_bus],
1316
					&dvb->lna_gpio);
1317 1318
		if (dvb->fe[0]) {
			/* FE 0 attach tuner */
1319 1320 1321
			if (!dvb_attach(tda18271_attach,
					dvb->fe[0],
					0x60,
1322
					&dev->i2c_adap[dev->def_i2c_bus],
1323 1324
					&em28xx_cxd2820r_tda18271_config)) {

1325 1326 1327 1328
				dvb_frontend_detach(dvb->fe[0]);
				result = -EINVAL;
				goto out_free;
			}
1329

1330
#ifdef CONFIG_GPIOLIB
1331 1332
			/* enable LNA for DVB-T, DVB-T2 and DVB-C */
			result = gpio_request_one(dvb->lna_gpio,
1333
						  GPIOF_OUT_INIT_LOW, NULL);
1334
			if (result)
1335 1336 1337
				dev_err(&dev->udev->dev,
					"gpio request failed %d\n",
					result);
1338 1339 1340 1341
			else
				gpio_free(dvb->lna_gpio);

			result = 0; /* continue even set LNA fails */
1342
#endif
1343 1344 1345
			dvb->fe[0]->ops.set_lna = em28xx_pctv_290e_set_lna;
		}

1346 1347
		break;
	case EM2884_BOARD_HAUPPAUGE_WINTV_HVR_930C:
1348 1349
	{
		struct xc5000_config cfg;
1350

1351 1352
		hauppauge_hvr930c_init(dev);

1353
		dvb->fe[0] = dvb_attach(drxk_attach,
1354
					&hauppauge_930c_drxk, &dev->i2c_adap[dev->def_i2c_bus]);
1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367
		if (!dvb->fe[0]) {
			result = -EINVAL;
			goto out_free;
		}
		/* FIXME: do we need a pll semaphore? */
		dvb->fe[0]->sec_priv = dvb;
		sema_init(&dvb->pll_mutex, 1);
		dvb->gate_ctrl = dvb->fe[0]->ops.i2c_gate_ctrl;
		dvb->fe[0]->ops.i2c_gate_ctrl = drxk_gate_ctrl;

		/* Attach xc5000 */
		memset(&cfg, 0, sizeof(cfg));
		cfg.i2c_address  = 0x61;
1368
		cfg.if_khz = 4000;
1369 1370 1371

		if (dvb->fe[0]->ops.i2c_gate_ctrl)
			dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 1);
1372
		if (!dvb_attach(xc5000_attach, dvb->fe[0], &dev->i2c_adap[dev->def_i2c_bus],
1373
				&cfg)) {
1374 1375 1376 1377 1378 1379
			result = -EINVAL;
			goto out_free;
		}
		if (dvb->fe[0]->ops.i2c_gate_ctrl)
			dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 0);

1380
		break;
1381
	}
1382 1383 1384
	case EM2884_BOARD_TERRATEC_H5:
		terratec_h5_init(dev);

1385
		dvb->fe[0] = dvb_attach(drxk_attach, &terratec_h5_drxk, &dev->i2c_adap[dev->def_i2c_bus]);
1386
		if (!dvb->fe[0]) {
1387 1388 1389 1390 1391 1392 1393 1394 1395
			result = -EINVAL;
			goto out_free;
		}
		/* FIXME: do we need a pll semaphore? */
		dvb->fe[0]->sec_priv = dvb;
		sema_init(&dvb->pll_mutex, 1);
		dvb->gate_ctrl = dvb->fe[0]->ops.i2c_gate_ctrl;
		dvb->fe[0]->ops.i2c_gate_ctrl = drxk_gate_ctrl;

1396
		/* Attach tda18271 to DVB-C frontend */
1397 1398
		if (dvb->fe[0]->ops.i2c_gate_ctrl)
			dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 1);
1399
		if (!dvb_attach(tda18271c2dd_attach, dvb->fe[0], &dev->i2c_adap[dev->def_i2c_bus], 0x60)) {
1400 1401 1402 1403 1404
			result = -EINVAL;
			goto out_free;
		}
		if (dvb->fe[0]->ops.i2c_gate_ctrl)
			dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 0);
1405

1406
		break;
1407 1408 1409 1410 1411 1412 1413 1414 1415
	case EM2884_BOARD_C3TECH_DIGITAL_DUO:
		dvb->fe[0] = dvb_attach(mb86a20s_attach,
					   &c3tech_duo_mb86a20s_config,
					   &dev->i2c_adap[dev->def_i2c_bus]);
		if (dvb->fe[0] != NULL)
			dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
				   &dev->i2c_adap[dev->def_i2c_bus],
				   &c3tech_duo_tda18271_config);
		break;
1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444
	case EM28174_BOARD_PCTV_460E: {
		struct i2c_client *client;
		struct i2c_board_info board_info;
		struct tda10071_platform_data tda10071_pdata = {};
		struct a8293_platform_data a8293_pdata = {};

		/* attach demod + tuner combo */
		tda10071_pdata.clk = 40444000, /* 40.444 MHz */
		tda10071_pdata.i2c_wr_max = 64,
		tda10071_pdata.ts_mode = TDA10071_TS_SERIAL,
		tda10071_pdata.pll_multiplier = 20,
		tda10071_pdata.tuner_i2c_addr = 0x14,
		memset(&board_info, 0, sizeof(board_info));
		strlcpy(board_info.type, "tda10071_cx24118", I2C_NAME_SIZE);
		board_info.addr = 0x55;
		board_info.platform_data = &tda10071_pdata;
		request_module("tda10071");
		client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &board_info);
		if (client == NULL || client->dev.driver == NULL) {
			result = -ENODEV;
			goto out_free;
		}
		if (!try_module_get(client->dev.driver->owner)) {
			i2c_unregister_device(client);
			result = -ENODEV;
			goto out_free;
		}
		dvb->fe[0] = tda10071_pdata.get_dvb_frontend(client);
		dvb->i2c_client_demod = client;
1445 1446

		/* attach SEC */
1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467
		a8293_pdata.dvb_frontend = dvb->fe[0];
		memset(&board_info, 0, sizeof(board_info));
		strlcpy(board_info.type, "a8293", I2C_NAME_SIZE);
		board_info.addr = 0x08;
		board_info.platform_data = &a8293_pdata;
		request_module("a8293");
		client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &board_info);
		if (client == NULL || client->dev.driver == NULL) {
			module_put(dvb->i2c_client_demod->dev.driver->owner);
			i2c_unregister_device(dvb->i2c_client_demod);
			result = -ENODEV;
			goto out_free;
		}
		if (!try_module_get(client->dev.driver->owner)) {
			i2c_unregister_device(client);
			module_put(dvb->i2c_client_demod->dev.driver->owner);
			i2c_unregister_device(dvb->i2c_client_demod);
			result = -ENODEV;
			goto out_free;
		}
		dvb->i2c_client_sec = client;
1468
		break;
1469
	}
1470
	case EM2874_BOARD_DELOCK_61959:
1471 1472 1473
	case EM2874_BOARD_MAXMEDIA_UB425_TC:
		/* attach demodulator */
		dvb->fe[0] = dvb_attach(drxk_attach, &maxmedia_ub425_tc_drxk,
1474
				&dev->i2c_adap[dev->def_i2c_bus]);
1475 1476 1477 1478 1479 1480

		if (dvb->fe[0]) {
			/* disable I2C-gate */
			dvb->fe[0]->ops.i2c_gate_ctrl = NULL;

			/* attach tuner */
1481 1482 1483
			if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
					&dev->i2c_adap[dev->def_i2c_bus],
					&em28xx_cxd2820r_tda18271_config)) {
1484 1485 1486 1487 1488
				dvb_frontend_detach(dvb->fe[0]);
				result = -EINVAL;
				goto out_free;
			}
		}
1489
		break;
1490 1491 1492 1493
	case EM2884_BOARD_PCTV_510E:
	case EM2884_BOARD_PCTV_520E:
		pctv_520e_init(dev);

1494 1495
		/* attach demodulator */
		dvb->fe[0] = dvb_attach(drxk_attach, &pctv_520e_drxk,
1496
				&dev->i2c_adap[dev->def_i2c_bus]);
1497 1498 1499 1500

		if (dvb->fe[0]) {
			/* attach tuner */
			if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1501
					&dev->i2c_adap[dev->def_i2c_bus],
1502 1503 1504 1505 1506 1507
					&em28xx_cxd2820r_tda18271_config)) {
				dvb_frontend_detach(dvb->fe[0]);
				result = -EINVAL;
				goto out_free;
			}
		}
1508
		break;
1509
	case EM2884_BOARD_ELGATO_EYETV_HYBRID_2008:
1510 1511 1512
	case EM2884_BOARD_CINERGY_HTC_STICK:
		terratec_htc_stick_init(dev);

1513 1514
		/* attach demodulator */
		dvb->fe[0] = dvb_attach(drxk_attach, &terratec_htc_stick_drxk,
1515
					&dev->i2c_adap[dev->def_i2c_bus]);
1516 1517 1518 1519 1520 1521 1522
		if (!dvb->fe[0]) {
			result = -EINVAL;
			goto out_free;
		}

		/* Attach the demodulator. */
		if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1523
				&dev->i2c_adap[dev->def_i2c_bus],
1524 1525 1526 1527 1528 1529 1530 1531
				&em28xx_cxd2820r_tda18271_config)) {
			result = -EINVAL;
			goto out_free;
		}
		break;
	case EM2884_BOARD_TERRATEC_HTC_USB_XS:
		terratec_htc_usb_xs_init(dev);

1532 1533
		/* attach demodulator */
		dvb->fe[0] = dvb_attach(drxk_attach, &terratec_htc_stick_drxk,
1534
					&dev->i2c_adap[dev->def_i2c_bus]);
1535 1536 1537 1538 1539 1540 1541
		if (!dvb->fe[0]) {
			result = -EINVAL;
			goto out_free;
		}

		/* Attach the demodulator. */
		if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
1542
				&dev->i2c_adap[dev->def_i2c_bus],
1543 1544 1545 1546 1547
				&em28xx_cxd2820r_tda18271_config)) {
			result = -EINVAL;
			goto out_free;
		}
		break;
1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564
	case EM2874_BOARD_KWORLD_UB435Q_V2:
		dvb->fe[0] = dvb_attach(lgdt3305_attach,
					&em2874_lgdt3305_dev,
					&dev->i2c_adap[dev->def_i2c_bus]);
		if (!dvb->fe[0]) {
			result = -EINVAL;
			goto out_free;
		}

		/* Attach the demodulator. */
		if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
				&dev->i2c_adap[dev->def_i2c_bus],
				&kworld_ub435q_v2_config)) {
			result = -EINVAL;
			goto out_free;
		}
		break;
1565
	case EM2874_BOARD_KWORLD_UB435Q_V3:
1566 1567 1568 1569 1570 1571 1572 1573 1574
	{
		struct i2c_client *client;
		struct i2c_adapter *adapter = &dev->i2c_adap[dev->def_i2c_bus];
		struct i2c_board_info board_info = {
			.type = "tda18212",
			.addr = 0x60,
			.platform_data = &kworld_ub435q_v3_config,
		};

1575 1576 1577 1578 1579 1580 1581 1582
		dvb->fe[0] = dvb_attach(lgdt3305_attach,
					&em2874_lgdt3305_nogate_dev,
					&dev->i2c_adap[dev->def_i2c_bus]);
		if (!dvb->fe[0]) {
			result = -EINVAL;
			goto out_free;
		}

1583 1584 1585 1586 1587 1588 1589
		/* attach tuner */
		kworld_ub435q_v3_config.fe = dvb->fe[0];
		request_module("tda18212");
		client = i2c_new_device(adapter, &board_info);
		if (client == NULL || client->dev.driver == NULL) {
			dvb_frontend_detach(dvb->fe[0]);
			result = -ENODEV;
1590 1591
			goto out_free;
		}
1592 1593 1594 1595 1596 1597 1598 1599 1600

		if (!try_module_get(client->dev.driver->owner)) {
			i2c_unregister_device(client);
			dvb_frontend_detach(dvb->fe[0]);
			result = -ENODEV;
			goto out_free;
		}

		dvb->i2c_client_tuner = client;
1601
		break;
1602
	}
1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614
	case EM2874_BOARD_PCTV_HD_MINI_80E:
		dvb->fe[0] = dvb_attach(drx39xxj_attach, &dev->i2c_adap[dev->def_i2c_bus]);
		if (dvb->fe[0] != NULL) {
			dvb->fe[0] = dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
						&dev->i2c_adap[dev->def_i2c_bus],
						&pinnacle_80e_dvb_config);
			if (!dvb->fe[0]) {
				result = -EINVAL;
				goto out_free;
			}
		}
		break;
1615 1616 1617 1618 1619 1620 1621
	case EM28178_BOARD_PCTV_461E: {
		struct i2c_client *client;
		struct i2c_adapter *i2c_adapter;
		struct i2c_board_info board_info;
		struct m88ds3103_platform_data m88ds3103_pdata = {};
		struct ts2020_config ts2020_config = {};
		struct a8293_platform_data a8293_pdata = {};
1622

1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647
		/* attach demod */
		m88ds3103_pdata.clk = 27000000;
		m88ds3103_pdata.i2c_wr_max = 33;
		m88ds3103_pdata.ts_mode = M88DS3103_TS_PARALLEL;
		m88ds3103_pdata.ts_clk = 16000;
		m88ds3103_pdata.ts_clk_pol = 1;
		m88ds3103_pdata.agc = 0x99;
		memset(&board_info, 0, sizeof(board_info));
		strlcpy(board_info.type, "m88ds3103", I2C_NAME_SIZE);
		board_info.addr = 0x68;
		board_info.platform_data = &m88ds3103_pdata;
		request_module("m88ds3103");
		client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &board_info);
		if (client == NULL || client->dev.driver == NULL) {
			result = -ENODEV;
			goto out_free;
		}
		if (!try_module_get(client->dev.driver->owner)) {
			i2c_unregister_device(client);
			result = -ENODEV;
			goto out_free;
		}
		dvb->fe[0] = m88ds3103_pdata.get_dvb_frontend(client);
		i2c_adapter = m88ds3103_pdata.get_i2c_adapter(client);
		dvb->i2c_client_demod = client;
1648

1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673
		/* attach tuner */
		ts2020_config.fe = dvb->fe[0];
		memset(&board_info, 0, sizeof(board_info));
		strlcpy(board_info.type, "ts2022", I2C_NAME_SIZE);
		board_info.addr = 0x60;
		board_info.platform_data = &ts2020_config;
		request_module("ts2020");
		client = i2c_new_device(i2c_adapter, &board_info);
		if (client == NULL || client->dev.driver == NULL) {
			module_put(dvb->i2c_client_demod->dev.driver->owner);
			i2c_unregister_device(dvb->i2c_client_demod);
			result = -ENODEV;
			goto out_free;
		}
		if (!try_module_get(client->dev.driver->owner)) {
			i2c_unregister_device(client);
			module_put(dvb->i2c_client_demod->dev.driver->owner);
			i2c_unregister_device(dvb->i2c_client_demod);
			result = -ENODEV;
			goto out_free;
		}
		dvb->i2c_client_tuner = client;
		/* delegate signal strength measurement to tuner */
		dvb->fe[0]->ops.read_signal_strength =
				dvb->fe[0]->ops.tuner_ops.get_rf_strength;
1674

1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689
		/* attach SEC */
		a8293_pdata.dvb_frontend = dvb->fe[0];
		memset(&board_info, 0, sizeof(board_info));
		strlcpy(board_info.type, "a8293", I2C_NAME_SIZE);
		board_info.addr = 0x08;
		board_info.platform_data = &a8293_pdata;
		request_module("a8293");
		client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &board_info);
		if (client == NULL || client->dev.driver == NULL) {
			module_put(dvb->i2c_client_tuner->dev.driver->owner);
			i2c_unregister_device(dvb->i2c_client_tuner);
			module_put(dvb->i2c_client_demod->dev.driver->owner);
			i2c_unregister_device(dvb->i2c_client_demod);
			result = -ENODEV;
			goto out_free;
1690
		}
1691 1692 1693 1694 1695 1696 1697 1698 1699 1700
		if (!try_module_get(client->dev.driver->owner)) {
			i2c_unregister_device(client);
			module_put(dvb->i2c_client_tuner->dev.driver->owner);
			i2c_unregister_device(dvb->i2c_client_tuner);
			module_put(dvb->i2c_client_demod->dev.driver->owner);
			i2c_unregister_device(dvb->i2c_client_demod);
			result = -ENODEV;
			goto out_free;
		}
		dvb->i2c_client_sec = client;
1701
		break;
1702
	}
1703 1704 1705 1706 1707 1708 1709 1710 1711
	case EM28178_BOARD_PCTV_292E:
		{
			struct i2c_adapter *adapter;
			struct i2c_client *client;
			struct i2c_board_info info;
			struct si2168_config si2168_config;
			struct si2157_config si2157_config;

			/* attach demod */
1712
			memset(&si2168_config, 0, sizeof(si2168_config));
1713 1714
			si2168_config.i2c_adapter = &adapter;
			si2168_config.fe = &dvb->fe[0];
1715
			si2168_config.ts_mode = SI2168_TS_PARALLEL;
1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735
			memset(&info, 0, sizeof(struct i2c_board_info));
			strlcpy(info.type, "si2168", I2C_NAME_SIZE);
			info.addr = 0x64;
			info.platform_data = &si2168_config;
			request_module(info.type);
			client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &info);
			if (client == NULL || client->dev.driver == NULL) {
				result = -ENODEV;
				goto out_free;
			}

			if (!try_module_get(client->dev.driver->owner)) {
				i2c_unregister_device(client);
				result = -ENODEV;
				goto out_free;
			}

			dvb->i2c_client_demod = client;

			/* attach tuner */
1736
			memset(&si2157_config, 0, sizeof(si2157_config));
1737
			si2157_config.fe = dvb->fe[0];
1738
			si2157_config.if_port = 1;
1739 1740 1741
#ifdef CONFIG_MEDIA_CONTROLLER_DVB
			si2157_config.mdev = dev->media_dev;
#endif
1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763
			memset(&info, 0, sizeof(struct i2c_board_info));
			strlcpy(info.type, "si2157", I2C_NAME_SIZE);
			info.addr = 0x60;
			info.platform_data = &si2157_config;
			request_module(info.type);
			client = i2c_new_device(adapter, &info);
			if (client == NULL || client->dev.driver == NULL) {
				module_put(dvb->i2c_client_demod->dev.driver->owner);
				i2c_unregister_device(dvb->i2c_client_demod);
				result = -ENODEV;
				goto out_free;
			}

			if (!try_module_get(client->dev.driver->owner)) {
				i2c_unregister_device(client);
				module_put(dvb->i2c_client_demod->dev.driver->owner);
				i2c_unregister_device(dvb->i2c_client_demod);
				result = -ENODEV;
				goto out_free;
			}

			dvb->i2c_client_tuner = client;
1764
			dvb->fe[0]->ops.set_lna = em28xx_pctv_292e_set_lna;
1765 1766
		}
		break;
1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801
	case EM28178_BOARD_TERRATEC_T2_STICK_HD:
		{
			struct i2c_adapter *adapter;
			struct i2c_client *client;
			struct i2c_board_info info;
			struct si2168_config si2168_config;
			struct si2157_config si2157_config;

			/* attach demod */
			memset(&si2168_config, 0, sizeof(si2168_config));
			si2168_config.i2c_adapter = &adapter;
			si2168_config.fe = &dvb->fe[0];
			si2168_config.ts_mode = SI2168_TS_PARALLEL;
			memset(&info, 0, sizeof(struct i2c_board_info));
			strlcpy(info.type, "si2168", I2C_NAME_SIZE);
			info.addr = 0x64;
			info.platform_data = &si2168_config;
			request_module(info.type);
			client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &info);
			if (client == NULL || client->dev.driver == NULL) {
				result = -ENODEV;
				goto out_free;
			}

			if (!try_module_get(client->dev.driver->owner)) {
				i2c_unregister_device(client);
				result = -ENODEV;
				goto out_free;
			}

			dvb->i2c_client_demod = client;

			/* attach tuner */
			memset(&si2157_config, 0, sizeof(si2157_config));
			si2157_config.fe = dvb->fe[0];
1802
			si2157_config.if_port = 0;
1803 1804 1805
#ifdef CONFIG_MEDIA_CONTROLLER_DVB
			si2157_config.mdev = dev->media_dev;
#endif
1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829
			memset(&info, 0, sizeof(struct i2c_board_info));
			strlcpy(info.type, "si2146", I2C_NAME_SIZE);
			info.addr = 0x60;
			info.platform_data = &si2157_config;
			request_module("si2157");
			client = i2c_new_device(adapter, &info);
			if (client == NULL || client->dev.driver == NULL) {
				module_put(dvb->i2c_client_demod->dev.driver->owner);
				i2c_unregister_device(dvb->i2c_client_demod);
				result = -ENODEV;
				goto out_free;
			}

			if (!try_module_get(client->dev.driver->owner)) {
				i2c_unregister_device(client);
				module_put(dvb->i2c_client_demod->dev.driver->owner);
				i2c_unregister_device(dvb->i2c_client_demod);
				result = -ENODEV;
				goto out_free;
			}

			dvb->i2c_client_tuner = client;
		}
		break;
1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886

	case EM28178_BOARD_PLEX_PX_BCUD:
		{
			struct i2c_client *client;
			struct i2c_board_info info;
			struct tc90522_config tc90522_config;
			struct qm1d1c0042_config qm1d1c0042_config;

			/* attach demod */
			memset(&tc90522_config, 0, sizeof(tc90522_config));
			memset(&info, 0, sizeof(struct i2c_board_info));
			strlcpy(info.type, "tc90522sat", I2C_NAME_SIZE);
			info.addr = 0x15;
			info.platform_data = &tc90522_config;
			request_module("tc90522");
			client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &info);
			if (client == NULL || client->dev.driver == NULL) {
				result = -ENODEV;
				goto out_free;
			}
			dvb->i2c_client_demod = client;
			if (!try_module_get(client->dev.driver->owner)) {
				i2c_unregister_device(client);
				result = -ENODEV;
				goto out_free;
			}

			/* attach tuner */
			memset(&qm1d1c0042_config, 0,
			       sizeof(qm1d1c0042_config));
			qm1d1c0042_config.fe = tc90522_config.fe;
			qm1d1c0042_config.lpf = 1;
			memset(&info, 0, sizeof(struct i2c_board_info));
			strlcpy(info.type, "qm1d1c0042", I2C_NAME_SIZE);
			info.addr = 0x61;
			info.platform_data = &qm1d1c0042_config;
			request_module(info.type);
			client = i2c_new_device(tc90522_config.tuner_i2c,
						&info);
			if (client == NULL || client->dev.driver == NULL) {
				module_put(dvb->i2c_client_demod->dev.driver->owner);
				i2c_unregister_device(dvb->i2c_client_demod);
				result = -ENODEV;
				goto out_free;
			}
			dvb->i2c_client_tuner = client;
			if (!try_module_get(client->dev.driver->owner)) {
				i2c_unregister_device(client);
				module_put(dvb->i2c_client_demod->dev.driver->owner);
				i2c_unregister_device(dvb->i2c_client_demod);
				result = -ENODEV;
				goto out_free;
			}
			dvb->fe[0] = tc90522_config.fe;
			px_bcud_init(dev);
		}
		break;
1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950
	case EM28174_BOARD_HAUPPAUGE_WINTV_DUALHD_DVB:
		{
			struct i2c_adapter *adapter;
			struct i2c_client *client;
			struct i2c_board_info info;
			struct si2168_config si2168_config;
			struct si2157_config si2157_config;

			/* attach demod */
			memset(&si2168_config, 0, sizeof(si2168_config));
			si2168_config.i2c_adapter = &adapter;
			si2168_config.fe = &dvb->fe[0];
			si2168_config.ts_mode = SI2168_TS_SERIAL;
			memset(&info, 0, sizeof(struct i2c_board_info));
			strlcpy(info.type, "si2168", I2C_NAME_SIZE);
			info.addr = 0x64;
			info.platform_data = &si2168_config;
			request_module(info.type);
			client = i2c_new_device(&dev->i2c_adap[dev->def_i2c_bus], &info);
			if (client == NULL || client->dev.driver == NULL) {
				result = -ENODEV;
				goto out_free;
			}

			if (!try_module_get(client->dev.driver->owner)) {
				i2c_unregister_device(client);
				result = -ENODEV;
				goto out_free;
			}

			dvb->i2c_client_demod = client;

			/* attach tuner */
			memset(&si2157_config, 0, sizeof(si2157_config));
			si2157_config.fe = dvb->fe[0];
			si2157_config.if_port = 1;
#ifdef CONFIG_MEDIA_CONTROLLER_DVB
			si2157_config.mdev = dev->media_dev;
#endif
			memset(&info, 0, sizeof(struct i2c_board_info));
			strlcpy(info.type, "si2157", I2C_NAME_SIZE);
			info.addr = 0x60;
			info.platform_data = &si2157_config;
			request_module(info.type);
			client = i2c_new_device(adapter, &info);
			if (client == NULL || client->dev.driver == NULL) {
				module_put(dvb->i2c_client_demod->dev.driver->owner);
				i2c_unregister_device(dvb->i2c_client_demod);
				result = -ENODEV;
				goto out_free;
			}

			if (!try_module_get(client->dev.driver->owner)) {
				i2c_unregister_device(client);
				module_put(dvb->i2c_client_demod->dev.driver->owner);
				i2c_unregister_device(dvb->i2c_client_demod);
				result = -ENODEV;
				goto out_free;
			}

			dvb->i2c_client_tuner = client;

		}
		break;
1951
	default:
1952 1953
		dev_err(&dev->udev->dev,
			"The frontend of your DVB/ATSC card isn't supported yet\n");
1954 1955
		break;
	}
1956
	if (NULL == dvb->fe[0]) {
1957
		dev_err(&dev->udev->dev, "frontend initialization failed\n");
1958 1959
		result = -EINVAL;
		goto out_free;
1960
	}
1961
	/* define general-purpose callback pointer */
1962
	dvb->fe[0]->callback = em28xx_tuner_callback;
1963
	if (dvb->fe[1])
1964
		dvb->fe[1]->callback = em28xx_tuner_callback;
1965 1966

	/* register everything */
1967
	result = em28xx_register_dvb(dvb, THIS_MODULE, dev, &dev->udev->dev);
1968

1969
	if (result < 0)
1970 1971
		goto out_free;

1972
	dev_info(&dev->udev->dev, "DVB extension successfully initialized\n");
1973 1974 1975

	kref_get(&dev->ref);

1976 1977 1978 1979
ret:
	em28xx_set_mode(dev, EM28XX_SUSPEND);
	mutex_unlock(&dev->lock);
	return result;
1980 1981 1982 1983

out_free:
	kfree(dvb);
	dev->dvb = NULL;
1984
	goto ret;
1985 1986
}

1987 1988 1989 1990 1991 1992 1993
static inline void prevent_sleep(struct dvb_frontend_ops *ops)
{
	ops->set_voltage = NULL;
	ops->sleep = NULL;
	ops->tuner_ops.sleep = NULL;
}

1994
static int em28xx_dvb_fini(struct em28xx *dev)
1995
{
1996 1997 1998
	struct em28xx_dvb *dvb;
	struct i2c_client *client;

1999 2000 2001 2002 2003
	if (dev->is_audio_only) {
		/* Shouldn't initialize IR for this interface */
		return 0;
	}

2004
	if (!dev->board.has_dvb) {
2005 2006 2007 2008
		/* This device does not support the extension */
		return 0;
	}

2009 2010
	if (!dev->dvb)
		return 0;
2011

2012
	dev_info(&dev->udev->dev, "Closing DVB extension\n");
2013

2014
	dvb = dev->dvb;
2015

2016
	em28xx_uninit_usb_xfer(dev, EM28XX_DIGITAL_MODE);
2017

2018 2019 2020
	if (dev->disconnected) {
		/* We cannot tell the device to sleep
		 * once it has been unplugged. */
2021
		if (dvb->fe[0]) {
2022
			prevent_sleep(&dvb->fe[0]->ops);
2023 2024 2025
			dvb->fe[0]->exit = DVB_FE_DEVICE_REMOVED;
		}
		if (dvb->fe[1]) {
2026
			prevent_sleep(&dvb->fe[1]->ops);
2027 2028
			dvb->fe[1]->exit = DVB_FE_DEVICE_REMOVED;
		}
2029
	}
2030

2031 2032 2033 2034 2035 2036 2037
	/* remove I2C SEC */
	client = dvb->i2c_client_sec;
	if (client) {
		module_put(client->dev.driver->owner);
		i2c_unregister_device(client);
	}

2038
	/* remove I2C tuner */
2039
	client = dvb->i2c_client_tuner;
2040 2041 2042
	if (client) {
		module_put(client->dev.driver->owner);
		i2c_unregister_device(client);
2043
	}
2044

2045 2046 2047 2048 2049 2050 2051
	/* remove I2C demod */
	client = dvb->i2c_client_demod;
	if (client) {
		module_put(client->dev.driver->owner);
		i2c_unregister_device(client);
	}

2052 2053 2054 2055 2056
	em28xx_unregister_dvb(dvb);
	kfree(dvb);
	dev->dvb = NULL;
	kref_put(&dev->ref, em28xx_free_device);

2057 2058 2059
	return 0;
}

2060 2061 2062 2063 2064 2065 2066 2067 2068 2069
static int em28xx_dvb_suspend(struct em28xx *dev)
{
	int ret = 0;

	if (dev->is_audio_only)
		return 0;

	if (!dev->board.has_dvb)
		return 0;

2070
	dev_info(&dev->udev->dev, "Suspending DVB extension\n");
2071 2072 2073 2074 2075
	if (dev->dvb) {
		struct em28xx_dvb *dvb = dev->dvb;

		if (dvb->fe[0]) {
			ret = dvb_frontend_suspend(dvb->fe[0]);
2076
			dev_info(&dev->udev->dev, "fe0 suspend %d\n", ret);
2077 2078 2079
		}
		if (dvb->fe[1]) {
			dvb_frontend_suspend(dvb->fe[1]);
2080
			dev_info(&dev->udev->dev, "fe1 suspend %d\n", ret);
2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096
		}
	}

	return 0;
}

static int em28xx_dvb_resume(struct em28xx *dev)
{
	int ret = 0;

	if (dev->is_audio_only)
		return 0;

	if (!dev->board.has_dvb)
		return 0;

2097
	dev_info(&dev->udev->dev, "Resuming DVB extension\n");
2098 2099 2100 2101 2102
	if (dev->dvb) {
		struct em28xx_dvb *dvb = dev->dvb;

		if (dvb->fe[0]) {
			ret = dvb_frontend_resume(dvb->fe[0]);
2103
			dev_info(&dev->udev->dev, "fe0 resume %d\n", ret);
2104 2105 2106 2107
		}

		if (dvb->fe[1]) {
			ret = dvb_frontend_resume(dvb->fe[1]);
2108
			dev_info(&dev->udev->dev, "fe1 resume %d\n", ret);
2109 2110 2111 2112 2113 2114
		}
	}

	return 0;
}

2115 2116 2117
static struct em28xx_ops dvb_ops = {
	.id   = EM28XX_DVB,
	.name = "Em28xx dvb Extension",
2118 2119
	.init = em28xx_dvb_init,
	.fini = em28xx_dvb_fini,
2120 2121
	.suspend = em28xx_dvb_suspend,
	.resume = em28xx_dvb_resume,
2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135
};

static int __init em28xx_dvb_register(void)
{
	return em28xx_register_extension(&dvb_ops);
}

static void __exit em28xx_dvb_unregister(void)
{
	em28xx_unregister_extension(&dvb_ops);
}

module_init(em28xx_dvb_register);
module_exit(em28xx_dvb_unregister);