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 "tda18271.h" 45 #include "s921.h" 46 #include "drxd.h" 47 #include "cxd2820r.h" 48 #include "tda18271c2dd.h" 49 #include "drxk.h" 50 #include "tda10071.h" 51 #include "a8293.h" 52 #include "qt1010.h" 53 #include "mb86a20s.h" 54 55 MODULE_DESCRIPTION("driver for em28xx based DVB cards"); 56 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>"); 57 MODULE_LICENSE("GPL"); 58 59 static unsigned int debug; 60 module_param(debug, int, 0644); 61 MODULE_PARM_DESC(debug, "enable debug messages [dvb]"); 62 63 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); 64 65 #define dprintk(level, fmt, arg...) do { \ 66 if (debug >= level) \ 67 printk(KERN_DEBUG "%s/2-dvb: " fmt, dev->name, ## arg); \ 68 } while (0) 69 70 struct em28xx_dvb { 71 struct dvb_frontend *fe[2]; 72 73 /* feed count management */ 74 struct mutex lock; 75 int nfeeds; 76 77 /* general boilerplate stuff */ 78 struct dvb_adapter adapter; 79 struct dvb_demux demux; 80 struct dmxdev dmxdev; 81 struct dmx_frontend fe_hw; 82 struct dmx_frontend fe_mem; 83 struct dvb_net net; 84 85 /* Due to DRX-K - probably need changes */ 86 int (*gate_ctrl)(struct dvb_frontend *, int); 87 struct semaphore pll_mutex; 88 bool dont_attach_fe1; 89 int lna_gpio; 90 }; 91 92 93 static inline void print_err_status(struct em28xx *dev, 94 int packet, int status) 95 { 96 char *errmsg = "Unknown"; 97 98 switch (status) { 99 case -ENOENT: 100 errmsg = "unlinked synchronuously"; 101 break; 102 case -ECONNRESET: 103 errmsg = "unlinked asynchronuously"; 104 break; 105 case -ENOSR: 106 errmsg = "Buffer error (overrun)"; 107 break; 108 case -EPIPE: 109 errmsg = "Stalled (device not responding)"; 110 break; 111 case -EOVERFLOW: 112 errmsg = "Babble (bad cable?)"; 113 break; 114 case -EPROTO: 115 errmsg = "Bit-stuff error (bad cable?)"; 116 break; 117 case -EILSEQ: 118 errmsg = "CRC/Timeout (could be anything)"; 119 break; 120 case -ETIME: 121 errmsg = "Device does not respond"; 122 break; 123 } 124 if (packet < 0) { 125 dprintk(1, "URB status %d [%s].\n", status, errmsg); 126 } else { 127 dprintk(1, "URB packet %d, status %d [%s].\n", 128 packet, status, errmsg); 129 } 130 } 131 132 static inline int em28xx_dvb_urb_data_copy(struct em28xx *dev, struct urb *urb) 133 { 134 int xfer_bulk, num_packets, i; 135 136 if (!dev) 137 return 0; 138 139 if (dev->disconnected) 140 return 0; 141 142 if (urb->status < 0) 143 print_err_status(dev, -1, urb->status); 144 145 xfer_bulk = usb_pipebulk(urb->pipe); 146 147 if (xfer_bulk) /* bulk */ 148 num_packets = 1; 149 else /* isoc */ 150 num_packets = urb->number_of_packets; 151 152 for (i = 0; i < num_packets; i++) { 153 if (xfer_bulk) { 154 if (urb->status < 0) { 155 print_err_status(dev, i, urb->status); 156 if (urb->status != -EPROTO) 157 continue; 158 } 159 dvb_dmx_swfilter(&dev->dvb->demux, urb->transfer_buffer, 160 urb->actual_length); 161 } else { 162 if (urb->iso_frame_desc[i].status < 0) { 163 print_err_status(dev, i, 164 urb->iso_frame_desc[i].status); 165 if (urb->iso_frame_desc[i].status != -EPROTO) 166 continue; 167 } 168 dvb_dmx_swfilter(&dev->dvb->demux, 169 urb->transfer_buffer + 170 urb->iso_frame_desc[i].offset, 171 urb->iso_frame_desc[i].actual_length); 172 } 173 } 174 175 return 0; 176 } 177 178 static int em28xx_start_streaming(struct em28xx_dvb *dvb) 179 { 180 int rc; 181 struct em28xx_i2c_bus *i2c_bus = dvb->adapter.priv; 182 struct em28xx *dev = i2c_bus->dev; 183 int dvb_max_packet_size, packet_multiplier, dvb_alt; 184 185 if (dev->dvb_xfer_bulk) { 186 if (!dev->dvb_ep_bulk) 187 return -ENODEV; 188 dvb_max_packet_size = 512; /* USB 2.0 spec */ 189 packet_multiplier = EM28XX_DVB_BULK_PACKET_MULTIPLIER; 190 dvb_alt = 0; 191 } else { /* isoc */ 192 if (!dev->dvb_ep_isoc) 193 return -ENODEV; 194 dvb_max_packet_size = dev->dvb_max_pkt_size_isoc; 195 if (dvb_max_packet_size < 0) 196 return dvb_max_packet_size; 197 packet_multiplier = EM28XX_DVB_NUM_ISOC_PACKETS; 198 dvb_alt = dev->dvb_alt_isoc; 199 } 200 201 usb_set_interface(dev->udev, 0, dvb_alt); 202 rc = em28xx_set_mode(dev, EM28XX_DIGITAL_MODE); 203 if (rc < 0) 204 return rc; 205 206 dprintk(1, "Using %d buffers each with %d x %d bytes\n", 207 EM28XX_DVB_NUM_BUFS, 208 packet_multiplier, 209 dvb_max_packet_size); 210 211 return em28xx_init_usb_xfer(dev, EM28XX_DIGITAL_MODE, 212 dev->dvb_xfer_bulk, 213 EM28XX_DVB_NUM_BUFS, 214 dvb_max_packet_size, 215 packet_multiplier, 216 em28xx_dvb_urb_data_copy); 217 } 218 219 static int em28xx_stop_streaming(struct em28xx_dvb *dvb) 220 { 221 struct em28xx_i2c_bus *i2c_bus = dvb->adapter.priv; 222 struct em28xx *dev = i2c_bus->dev; 223 224 em28xx_stop_urbs(dev); 225 226 return 0; 227 } 228 229 static int em28xx_start_feed(struct dvb_demux_feed *feed) 230 { 231 struct dvb_demux *demux = feed->demux; 232 struct em28xx_dvb *dvb = demux->priv; 233 int rc, ret; 234 235 if (!demux->dmx.frontend) 236 return -EINVAL; 237 238 mutex_lock(&dvb->lock); 239 dvb->nfeeds++; 240 rc = dvb->nfeeds; 241 242 if (dvb->nfeeds == 1) { 243 ret = em28xx_start_streaming(dvb); 244 if (ret < 0) 245 rc = ret; 246 } 247 248 mutex_unlock(&dvb->lock); 249 return rc; 250 } 251 252 static int em28xx_stop_feed(struct dvb_demux_feed *feed) 253 { 254 struct dvb_demux *demux = feed->demux; 255 struct em28xx_dvb *dvb = demux->priv; 256 int err = 0; 257 258 mutex_lock(&dvb->lock); 259 dvb->nfeeds--; 260 261 if (0 == dvb->nfeeds) 262 err = em28xx_stop_streaming(dvb); 263 264 mutex_unlock(&dvb->lock); 265 return err; 266 } 267 268 269 270 /* ------------------------------------------------------------------ */ 271 static int em28xx_dvb_bus_ctrl(struct dvb_frontend *fe, int acquire) 272 { 273 struct em28xx_i2c_bus *i2c_bus = fe->dvb->priv; 274 struct em28xx *dev = i2c_bus->dev; 275 276 if (acquire) 277 return em28xx_set_mode(dev, EM28XX_DIGITAL_MODE); 278 else 279 return em28xx_set_mode(dev, EM28XX_SUSPEND); 280 } 281 282 /* ------------------------------------------------------------------ */ 283 284 static struct lgdt330x_config em2880_lgdt3303_dev = { 285 .demod_address = 0x0e, 286 .demod_chip = LGDT3303, 287 }; 288 289 static struct lgdt3305_config em2870_lgdt3304_dev = { 290 .i2c_addr = 0x0e, 291 .demod_chip = LGDT3304, 292 .spectral_inversion = 1, 293 .deny_i2c_rptr = 1, 294 .mpeg_mode = LGDT3305_MPEG_PARALLEL, 295 .tpclk_edge = LGDT3305_TPCLK_FALLING_EDGE, 296 .tpvalid_polarity = LGDT3305_TP_VALID_HIGH, 297 .vsb_if_khz = 3250, 298 .qam_if_khz = 4000, 299 }; 300 301 static struct s921_config sharp_isdbt = { 302 .demod_address = 0x30 >> 1 303 }; 304 305 static struct zl10353_config em28xx_zl10353_with_xc3028 = { 306 .demod_address = (0x1e >> 1), 307 .no_tuner = 1, 308 .parallel_ts = 1, 309 .if2 = 45600, 310 }; 311 312 static struct s5h1409_config em28xx_s5h1409_with_xc3028 = { 313 .demod_address = 0x32 >> 1, 314 .output_mode = S5H1409_PARALLEL_OUTPUT, 315 .gpio = S5H1409_GPIO_OFF, 316 .inversion = S5H1409_INVERSION_OFF, 317 .status_mode = S5H1409_DEMODLOCKING, 318 .mpeg_timing = S5H1409_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK 319 }; 320 321 static struct tda18271_std_map kworld_a340_std_map = { 322 .atsc_6 = { .if_freq = 3250, .agc_mode = 3, .std = 0, 323 .if_lvl = 1, .rfagc_top = 0x37, }, 324 .qam_6 = { .if_freq = 4000, .agc_mode = 3, .std = 1, 325 .if_lvl = 1, .rfagc_top = 0x37, }, 326 }; 327 328 static struct tda18271_config kworld_a340_config = { 329 .std_map = &kworld_a340_std_map, 330 }; 331 332 static struct zl10353_config em28xx_zl10353_xc3028_no_i2c_gate = { 333 .demod_address = (0x1e >> 1), 334 .no_tuner = 1, 335 .disable_i2c_gate_ctrl = 1, 336 .parallel_ts = 1, 337 .if2 = 45600, 338 }; 339 340 static struct drxd_config em28xx_drxd = { 341 .demod_address = 0x70, 342 .demod_revision = 0xa2, 343 .pll_type = DRXD_PLL_NONE, 344 .clock = 12000, 345 .insert_rs_byte = 1, 346 .IF = 42800000, 347 .disable_i2c_gate_ctrl = 1, 348 }; 349 350 static struct drxk_config terratec_h5_drxk = { 351 .adr = 0x29, 352 .single_master = 1, 353 .no_i2c_bridge = 1, 354 .microcode_name = "dvb-usb-terratec-h5-drxk.fw", 355 .qam_demod_parameter_count = 2, 356 .load_firmware_sync = true, 357 }; 358 359 static struct drxk_config hauppauge_930c_drxk = { 360 .adr = 0x29, 361 .single_master = 1, 362 .no_i2c_bridge = 1, 363 .microcode_name = "dvb-usb-hauppauge-hvr930c-drxk.fw", 364 .chunk_size = 56, 365 .qam_demod_parameter_count = 2, 366 .load_firmware_sync = true, 367 }; 368 369 static struct drxk_config terratec_htc_stick_drxk = { 370 .adr = 0x29, 371 .single_master = 1, 372 .no_i2c_bridge = 1, 373 .microcode_name = "dvb-usb-terratec-htc-stick-drxk.fw", 374 .chunk_size = 54, 375 .qam_demod_parameter_count = 2, 376 /* Required for the antenna_gpio to disable LNA. */ 377 .antenna_dvbt = true, 378 /* The windows driver uses the same. This will disable LNA. */ 379 .antenna_gpio = 0x6, 380 .load_firmware_sync = true, 381 }; 382 383 static struct drxk_config maxmedia_ub425_tc_drxk = { 384 .adr = 0x29, 385 .single_master = 1, 386 .no_i2c_bridge = 1, 387 .load_firmware_sync = true, 388 }; 389 390 static struct drxk_config pctv_520e_drxk = { 391 .adr = 0x29, 392 .single_master = 1, 393 .microcode_name = "dvb-demod-drxk-pctv.fw", 394 .qam_demod_parameter_count = 2, 395 .chunk_size = 58, 396 .antenna_dvbt = true, /* disable LNA */ 397 .antenna_gpio = (1 << 2), /* disable LNA */ 398 .load_firmware_sync = true, 399 }; 400 401 static int drxk_gate_ctrl(struct dvb_frontend *fe, int enable) 402 { 403 struct em28xx_dvb *dvb = fe->sec_priv; 404 int status; 405 406 if (!dvb) 407 return -EINVAL; 408 409 if (enable) { 410 down(&dvb->pll_mutex); 411 status = dvb->gate_ctrl(fe, 1); 412 } else { 413 status = dvb->gate_ctrl(fe, 0); 414 up(&dvb->pll_mutex); 415 } 416 return status; 417 } 418 419 static void hauppauge_hvr930c_init(struct em28xx *dev) 420 { 421 int i; 422 423 struct em28xx_reg_seq hauppauge_hvr930c_init[] = { 424 {EM2874_R80_GPIO_P0_CTRL, 0xff, 0xff, 0x65}, 425 {EM2874_R80_GPIO_P0_CTRL, 0xfb, 0xff, 0x32}, 426 {EM2874_R80_GPIO_P0_CTRL, 0xff, 0xff, 0xb8}, 427 { -1, -1, -1, -1}, 428 }; 429 struct em28xx_reg_seq hauppauge_hvr930c_end[] = { 430 {EM2874_R80_GPIO_P0_CTRL, 0xef, 0xff, 0x01}, 431 {EM2874_R80_GPIO_P0_CTRL, 0xaf, 0xff, 0x65}, 432 {EM2874_R80_GPIO_P0_CTRL, 0xef, 0xff, 0x76}, 433 {EM2874_R80_GPIO_P0_CTRL, 0xef, 0xff, 0x01}, 434 {EM2874_R80_GPIO_P0_CTRL, 0xcf, 0xff, 0x0b}, 435 {EM2874_R80_GPIO_P0_CTRL, 0xef, 0xff, 0x40}, 436 437 {EM2874_R80_GPIO_P0_CTRL, 0xcf, 0xff, 0x65}, 438 {EM2874_R80_GPIO_P0_CTRL, 0xef, 0xff, 0x65}, 439 {EM2874_R80_GPIO_P0_CTRL, 0xcf, 0xff, 0x0b}, 440 {EM2874_R80_GPIO_P0_CTRL, 0xef, 0xff, 0x65}, 441 442 { -1, -1, -1, -1}, 443 }; 444 445 struct { 446 unsigned char r[4]; 447 int len; 448 } regs[] = { 449 {{ 0x06, 0x02, 0x00, 0x31 }, 4}, 450 {{ 0x01, 0x02 }, 2}, 451 {{ 0x01, 0x02, 0x00, 0xc6 }, 4}, 452 {{ 0x01, 0x00 }, 2}, 453 {{ 0x01, 0x00, 0xff, 0xaf }, 4}, 454 {{ 0x01, 0x00, 0x03, 0xa0 }, 4}, 455 {{ 0x01, 0x00 }, 2}, 456 {{ 0x01, 0x00, 0x73, 0xaf }, 4}, 457 {{ 0x04, 0x00 }, 2}, 458 {{ 0x00, 0x04 }, 2}, 459 {{ 0x00, 0x04, 0x00, 0x0a }, 4}, 460 {{ 0x04, 0x14 }, 2}, 461 {{ 0x04, 0x14, 0x00, 0x00 }, 4}, 462 }; 463 464 em28xx_gpio_set(dev, hauppauge_hvr930c_init); 465 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40); 466 msleep(10); 467 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44); 468 msleep(10); 469 470 dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1; 471 472 for (i = 0; i < ARRAY_SIZE(regs); i++) 473 i2c_master_send(&dev->i2c_client[dev->def_i2c_bus], regs[i].r, regs[i].len); 474 em28xx_gpio_set(dev, hauppauge_hvr930c_end); 475 476 msleep(100); 477 478 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44); 479 msleep(30); 480 481 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x45); 482 msleep(10); 483 484 } 485 486 static void terratec_h5_init(struct em28xx *dev) 487 { 488 int i; 489 struct em28xx_reg_seq terratec_h5_init[] = { 490 {EM2820_R08_GPIO_CTRL, 0xff, 0xff, 10}, 491 {EM2874_R80_GPIO_P0_CTRL, 0xf6, 0xff, 100}, 492 {EM2874_R80_GPIO_P0_CTRL, 0xf2, 0xff, 50}, 493 {EM2874_R80_GPIO_P0_CTRL, 0xf6, 0xff, 100}, 494 { -1, -1, -1, -1}, 495 }; 496 struct em28xx_reg_seq terratec_h5_end[] = { 497 {EM2874_R80_GPIO_P0_CTRL, 0xe6, 0xff, 100}, 498 {EM2874_R80_GPIO_P0_CTRL, 0xa6, 0xff, 50}, 499 {EM2874_R80_GPIO_P0_CTRL, 0xe6, 0xff, 100}, 500 { -1, -1, -1, -1}, 501 }; 502 struct { 503 unsigned char r[4]; 504 int len; 505 } regs[] = { 506 {{ 0x06, 0x02, 0x00, 0x31 }, 4}, 507 {{ 0x01, 0x02 }, 2}, 508 {{ 0x01, 0x02, 0x00, 0xc6 }, 4}, 509 {{ 0x01, 0x00 }, 2}, 510 {{ 0x01, 0x00, 0xff, 0xaf }, 4}, 511 {{ 0x01, 0x00, 0x03, 0xa0 }, 4}, 512 {{ 0x01, 0x00 }, 2}, 513 {{ 0x01, 0x00, 0x73, 0xaf }, 4}, 514 {{ 0x04, 0x00 }, 2}, 515 {{ 0x00, 0x04 }, 2}, 516 {{ 0x00, 0x04, 0x00, 0x0a }, 4}, 517 {{ 0x04, 0x14 }, 2}, 518 {{ 0x04, 0x14, 0x00, 0x00 }, 4}, 519 }; 520 521 em28xx_gpio_set(dev, terratec_h5_init); 522 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40); 523 msleep(10); 524 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x45); 525 msleep(10); 526 527 dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1; 528 529 for (i = 0; i < ARRAY_SIZE(regs); i++) 530 i2c_master_send(&dev->i2c_client[dev->def_i2c_bus], regs[i].r, regs[i].len); 531 em28xx_gpio_set(dev, terratec_h5_end); 532 }; 533 534 static void terratec_htc_stick_init(struct em28xx *dev) 535 { 536 int i; 537 538 /* 539 * GPIO configuration: 540 * 0xff: unknown (does not affect DVB-T). 541 * 0xf6: DRX-K (demodulator). 542 * 0xe6: unknown (does not affect DVB-T). 543 * 0xb6: unknown (does not affect DVB-T). 544 */ 545 struct em28xx_reg_seq terratec_htc_stick_init[] = { 546 {EM2820_R08_GPIO_CTRL, 0xff, 0xff, 10}, 547 {EM2874_R80_GPIO_P0_CTRL, 0xf6, 0xff, 100}, 548 {EM2874_R80_GPIO_P0_CTRL, 0xe6, 0xff, 50}, 549 {EM2874_R80_GPIO_P0_CTRL, 0xf6, 0xff, 100}, 550 { -1, -1, -1, -1}, 551 }; 552 struct em28xx_reg_seq terratec_htc_stick_end[] = { 553 {EM2874_R80_GPIO_P0_CTRL, 0xb6, 0xff, 100}, 554 {EM2874_R80_GPIO_P0_CTRL, 0xf6, 0xff, 50}, 555 { -1, -1, -1, -1}, 556 }; 557 558 /* 559 * Init the analog decoder (not yet supported), but 560 * it's probably still a good idea. 561 */ 562 struct { 563 unsigned char r[4]; 564 int len; 565 } regs[] = { 566 {{ 0x06, 0x02, 0x00, 0x31 }, 4}, 567 {{ 0x01, 0x02 }, 2}, 568 {{ 0x01, 0x02, 0x00, 0xc6 }, 4}, 569 {{ 0x01, 0x00 }, 2}, 570 {{ 0x01, 0x00, 0xff, 0xaf }, 4}, 571 }; 572 573 em28xx_gpio_set(dev, terratec_htc_stick_init); 574 575 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40); 576 msleep(10); 577 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44); 578 msleep(10); 579 580 dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1; 581 582 for (i = 0; i < ARRAY_SIZE(regs); i++) 583 i2c_master_send(&dev->i2c_client[dev->def_i2c_bus], regs[i].r, regs[i].len); 584 585 em28xx_gpio_set(dev, terratec_htc_stick_end); 586 }; 587 588 static void terratec_htc_usb_xs_init(struct em28xx *dev) 589 { 590 int i; 591 592 struct em28xx_reg_seq terratec_htc_usb_xs_init[] = { 593 {EM2820_R08_GPIO_CTRL, 0xff, 0xff, 10}, 594 {EM2874_R80_GPIO_P0_CTRL, 0xb2, 0xff, 100}, 595 {EM2874_R80_GPIO_P0_CTRL, 0xb2, 0xff, 50}, 596 {EM2874_R80_GPIO_P0_CTRL, 0xb6, 0xff, 100}, 597 { -1, -1, -1, -1}, 598 }; 599 struct em28xx_reg_seq terratec_htc_usb_xs_end[] = { 600 {EM2874_R80_GPIO_P0_CTRL, 0xa6, 0xff, 100}, 601 {EM2874_R80_GPIO_P0_CTRL, 0xa6, 0xff, 50}, 602 {EM2874_R80_GPIO_P0_CTRL, 0xe6, 0xff, 100}, 603 { -1, -1, -1, -1}, 604 }; 605 606 /* 607 * Init the analog decoder (not yet supported), but 608 * it's probably still a good idea. 609 */ 610 struct { 611 unsigned char r[4]; 612 int len; 613 } regs[] = { 614 {{ 0x06, 0x02, 0x00, 0x31 }, 4}, 615 {{ 0x01, 0x02 }, 2}, 616 {{ 0x01, 0x02, 0x00, 0xc6 }, 4}, 617 {{ 0x01, 0x00 }, 2}, 618 {{ 0x01, 0x00, 0xff, 0xaf }, 4}, 619 {{ 0x01, 0x00, 0x03, 0xa0 }, 4}, 620 {{ 0x01, 0x00 }, 2}, 621 {{ 0x01, 0x00, 0x73, 0xaf }, 4}, 622 {{ 0x04, 0x00 }, 2}, 623 {{ 0x00, 0x04 }, 2}, 624 {{ 0x00, 0x04, 0x00, 0x0a }, 4}, 625 {{ 0x04, 0x14 }, 2}, 626 {{ 0x04, 0x14, 0x00, 0x00 }, 4}, 627 }; 628 629 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40); 630 631 em28xx_gpio_set(dev, terratec_htc_usb_xs_init); 632 633 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40); 634 msleep(10); 635 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x44); 636 msleep(10); 637 638 dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1; 639 640 for (i = 0; i < ARRAY_SIZE(regs); i++) 641 i2c_master_send(&dev->i2c_client[dev->def_i2c_bus], regs[i].r, regs[i].len); 642 643 em28xx_gpio_set(dev, terratec_htc_usb_xs_end); 644 }; 645 646 static void pctv_520e_init(struct em28xx *dev) 647 { 648 /* 649 * Init AVF4910B analog decoder. Looks like I2C traffic to 650 * digital demodulator and tuner are routed via AVF4910B. 651 */ 652 int i; 653 struct { 654 unsigned char r[4]; 655 int len; 656 } regs[] = { 657 {{ 0x06, 0x02, 0x00, 0x31 }, 4}, 658 {{ 0x01, 0x02 }, 2}, 659 {{ 0x01, 0x02, 0x00, 0xc6 }, 4}, 660 {{ 0x01, 0x00 }, 2}, 661 {{ 0x01, 0x00, 0xff, 0xaf }, 4}, 662 {{ 0x01, 0x00, 0x03, 0xa0 }, 4}, 663 {{ 0x01, 0x00 }, 2}, 664 {{ 0x01, 0x00, 0x73, 0xaf }, 4}, 665 }; 666 667 dev->i2c_client[dev->def_i2c_bus].addr = 0x82 >> 1; /* 0x41 */ 668 669 for (i = 0; i < ARRAY_SIZE(regs); i++) 670 i2c_master_send(&dev->i2c_client[dev->def_i2c_bus], regs[i].r, regs[i].len); 671 }; 672 673 static int em28xx_pctv_290e_set_lna(struct dvb_frontend *fe) 674 { 675 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 676 struct em28xx *dev = fe->dvb->priv; 677 #ifdef CONFIG_GPIOLIB 678 struct em28xx_dvb *dvb = dev->dvb; 679 int ret; 680 unsigned long flags; 681 682 if (c->lna == 1) 683 flags = GPIOF_OUT_INIT_HIGH; /* enable LNA */ 684 else 685 flags = GPIOF_OUT_INIT_LOW; /* disable LNA */ 686 687 ret = gpio_request_one(dvb->lna_gpio, flags, NULL); 688 if (ret) 689 em28xx_errdev("gpio request failed %d\n", ret); 690 else 691 gpio_free(dvb->lna_gpio); 692 693 return ret; 694 #else 695 dev_warn(&dev->udev->dev, "%s: LNA control is disabled (lna=%u)\n", 696 KBUILD_MODNAME, c->lna); 697 return 0; 698 #endif 699 } 700 701 static int em28xx_mt352_terratec_xs_init(struct dvb_frontend *fe) 702 { 703 /* Values extracted from a USB trace of the Terratec Windows driver */ 704 static u8 clock_config[] = { CLOCK_CTL, 0x38, 0x2c }; 705 static u8 reset[] = { RESET, 0x80 }; 706 static u8 adc_ctl_1_cfg[] = { ADC_CTL_1, 0x40 }; 707 static u8 agc_cfg[] = { AGC_TARGET, 0x28, 0xa0 }; 708 static u8 input_freq_cfg[] = { INPUT_FREQ_1, 0x31, 0xb8 }; 709 static u8 rs_err_cfg[] = { RS_ERR_PER_1, 0x00, 0x4d }; 710 static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 }; 711 static u8 trl_nom_cfg[] = { TRL_NOMINAL_RATE_1, 0x64, 0x00 }; 712 static u8 tps_given_cfg[] = { TPS_GIVEN_1, 0x40, 0x80, 0x50 }; 713 static u8 tuner_go[] = { TUNER_GO, 0x01}; 714 715 mt352_write(fe, clock_config, sizeof(clock_config)); 716 udelay(200); 717 mt352_write(fe, reset, sizeof(reset)); 718 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg)); 719 mt352_write(fe, agc_cfg, sizeof(agc_cfg)); 720 mt352_write(fe, input_freq_cfg, sizeof(input_freq_cfg)); 721 mt352_write(fe, rs_err_cfg, sizeof(rs_err_cfg)); 722 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg)); 723 mt352_write(fe, trl_nom_cfg, sizeof(trl_nom_cfg)); 724 mt352_write(fe, tps_given_cfg, sizeof(tps_given_cfg)); 725 mt352_write(fe, tuner_go, sizeof(tuner_go)); 726 return 0; 727 } 728 729 static struct mt352_config terratec_xs_mt352_cfg = { 730 .demod_address = (0x1e >> 1), 731 .no_tuner = 1, 732 .if2 = 45600, 733 .demod_init = em28xx_mt352_terratec_xs_init, 734 }; 735 736 static struct tda10023_config em28xx_tda10023_config = { 737 .demod_address = 0x0c, 738 .invert = 1, 739 }; 740 741 static struct cxd2820r_config em28xx_cxd2820r_config = { 742 .i2c_address = (0xd8 >> 1), 743 .ts_mode = CXD2820R_TS_SERIAL, 744 }; 745 746 static struct tda18271_config em28xx_cxd2820r_tda18271_config = { 747 .output_opt = TDA18271_OUTPUT_LT_OFF, 748 .gate = TDA18271_GATE_DIGITAL, 749 }; 750 751 static const struct tda10071_config em28xx_tda10071_config = { 752 .demod_i2c_addr = 0x55, /* (0xaa >> 1) */ 753 .tuner_i2c_addr = 0x14, 754 .i2c_wr_max = 64, 755 .ts_mode = TDA10071_TS_SERIAL, 756 .spec_inv = 0, 757 .xtal = 40444000, /* 40.444 MHz */ 758 .pll_multiplier = 20, 759 }; 760 761 static const struct a8293_config em28xx_a8293_config = { 762 .i2c_addr = 0x08, /* (0x10 >> 1) */ 763 }; 764 765 static struct zl10353_config em28xx_zl10353_no_i2c_gate_dev = { 766 .demod_address = (0x1e >> 1), 767 .disable_i2c_gate_ctrl = 1, 768 .no_tuner = 1, 769 .parallel_ts = 1, 770 }; 771 static struct qt1010_config em28xx_qt1010_config = { 772 .i2c_address = 0x62 773 }; 774 775 static const struct mb86a20s_config c3tech_duo_mb86a20s_config = { 776 .demod_address = 0x10, 777 .is_serial = true, 778 }; 779 780 static struct tda18271_std_map mb86a20s_tda18271_config = { 781 .dvbt_6 = { .if_freq = 4000, .agc_mode = 3, .std = 4, 782 .if_lvl = 1, .rfagc_top = 0x37, }, 783 }; 784 785 static struct tda18271_config c3tech_duo_tda18271_config = { 786 .std_map = &mb86a20s_tda18271_config, 787 .gate = TDA18271_GATE_DIGITAL, 788 .small_i2c = TDA18271_03_BYTE_CHUNK_INIT, 789 }; 790 791 792 /* ------------------------------------------------------------------ */ 793 794 static int em28xx_attach_xc3028(u8 addr, struct em28xx *dev) 795 { 796 struct dvb_frontend *fe; 797 struct xc2028_config cfg; 798 799 memset(&cfg, 0, sizeof(cfg)); 800 cfg.i2c_adap = &dev->i2c_adap[dev->def_i2c_bus]; 801 cfg.i2c_addr = addr; 802 803 if (!dev->dvb->fe[0]) { 804 em28xx_errdev("/2: dvb frontend not attached. " 805 "Can't attach xc3028\n"); 806 return -EINVAL; 807 } 808 809 fe = dvb_attach(xc2028_attach, dev->dvb->fe[0], &cfg); 810 if (!fe) { 811 em28xx_errdev("/2: xc3028 attach failed\n"); 812 dvb_frontend_detach(dev->dvb->fe[0]); 813 dev->dvb->fe[0] = NULL; 814 return -EINVAL; 815 } 816 817 em28xx_info("%s/2: xc3028 attached\n", dev->name); 818 819 return 0; 820 } 821 822 /* ------------------------------------------------------------------ */ 823 824 static int em28xx_register_dvb(struct em28xx_dvb *dvb, struct module *module, 825 struct em28xx *dev, struct device *device) 826 { 827 int result; 828 829 mutex_init(&dvb->lock); 830 831 /* register adapter */ 832 result = dvb_register_adapter(&dvb->adapter, dev->name, module, device, 833 adapter_nr); 834 if (result < 0) { 835 printk(KERN_WARNING "%s: dvb_register_adapter failed (errno = %d)\n", 836 dev->name, result); 837 goto fail_adapter; 838 } 839 840 /* Ensure all frontends negotiate bus access */ 841 dvb->fe[0]->ops.ts_bus_ctrl = em28xx_dvb_bus_ctrl; 842 if (dvb->fe[1]) 843 dvb->fe[1]->ops.ts_bus_ctrl = em28xx_dvb_bus_ctrl; 844 845 dvb->adapter.priv = &dev->i2c_bus[dev->def_i2c_bus]; 846 847 /* register frontend */ 848 result = dvb_register_frontend(&dvb->adapter, dvb->fe[0]); 849 if (result < 0) { 850 printk(KERN_WARNING "%s: dvb_register_frontend failed (errno = %d)\n", 851 dev->name, result); 852 goto fail_frontend0; 853 } 854 855 /* register 2nd frontend */ 856 if (dvb->fe[1]) { 857 result = dvb_register_frontend(&dvb->adapter, dvb->fe[1]); 858 if (result < 0) { 859 printk(KERN_WARNING "%s: 2nd dvb_register_frontend failed (errno = %d)\n", 860 dev->name, result); 861 goto fail_frontend1; 862 } 863 } 864 865 /* register demux stuff */ 866 dvb->demux.dmx.capabilities = 867 DMX_TS_FILTERING | DMX_SECTION_FILTERING | 868 DMX_MEMORY_BASED_FILTERING; 869 dvb->demux.priv = dvb; 870 dvb->demux.filternum = 256; 871 dvb->demux.feednum = 256; 872 dvb->demux.start_feed = em28xx_start_feed; 873 dvb->demux.stop_feed = em28xx_stop_feed; 874 875 result = dvb_dmx_init(&dvb->demux); 876 if (result < 0) { 877 printk(KERN_WARNING "%s: dvb_dmx_init failed (errno = %d)\n", 878 dev->name, result); 879 goto fail_dmx; 880 } 881 882 dvb->dmxdev.filternum = 256; 883 dvb->dmxdev.demux = &dvb->demux.dmx; 884 dvb->dmxdev.capabilities = 0; 885 result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter); 886 if (result < 0) { 887 printk(KERN_WARNING "%s: dvb_dmxdev_init failed (errno = %d)\n", 888 dev->name, result); 889 goto fail_dmxdev; 890 } 891 892 dvb->fe_hw.source = DMX_FRONTEND_0; 893 result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw); 894 if (result < 0) { 895 printk(KERN_WARNING "%s: add_frontend failed (DMX_FRONTEND_0, errno = %d)\n", 896 dev->name, result); 897 goto fail_fe_hw; 898 } 899 900 dvb->fe_mem.source = DMX_MEMORY_FE; 901 result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem); 902 if (result < 0) { 903 printk(KERN_WARNING "%s: add_frontend failed (DMX_MEMORY_FE, errno = %d)\n", 904 dev->name, result); 905 goto fail_fe_mem; 906 } 907 908 result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw); 909 if (result < 0) { 910 printk(KERN_WARNING "%s: connect_frontend failed (errno = %d)\n", 911 dev->name, result); 912 goto fail_fe_conn; 913 } 914 915 /* register network adapter */ 916 dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx); 917 return 0; 918 919 fail_fe_conn: 920 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem); 921 fail_fe_mem: 922 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw); 923 fail_fe_hw: 924 dvb_dmxdev_release(&dvb->dmxdev); 925 fail_dmxdev: 926 dvb_dmx_release(&dvb->demux); 927 fail_dmx: 928 if (dvb->fe[1]) 929 dvb_unregister_frontend(dvb->fe[1]); 930 dvb_unregister_frontend(dvb->fe[0]); 931 fail_frontend1: 932 if (dvb->fe[1]) 933 dvb_frontend_detach(dvb->fe[1]); 934 fail_frontend0: 935 dvb_frontend_detach(dvb->fe[0]); 936 dvb_unregister_adapter(&dvb->adapter); 937 fail_adapter: 938 return result; 939 } 940 941 static void em28xx_unregister_dvb(struct em28xx_dvb *dvb) 942 { 943 dvb_net_release(&dvb->net); 944 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem); 945 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw); 946 dvb_dmxdev_release(&dvb->dmxdev); 947 dvb_dmx_release(&dvb->demux); 948 if (dvb->fe[1]) 949 dvb_unregister_frontend(dvb->fe[1]); 950 dvb_unregister_frontend(dvb->fe[0]); 951 if (dvb->fe[1] && !dvb->dont_attach_fe1) 952 dvb_frontend_detach(dvb->fe[1]); 953 dvb_frontend_detach(dvb->fe[0]); 954 dvb_unregister_adapter(&dvb->adapter); 955 } 956 957 static int em28xx_dvb_init(struct em28xx *dev) 958 { 959 int result = 0, mfe_shared = 0; 960 struct em28xx_dvb *dvb; 961 962 if (!dev->board.has_dvb) { 963 /* This device does not support the extension */ 964 printk(KERN_INFO "em28xx_dvb: This device does not support the extension\n"); 965 return 0; 966 } 967 968 dvb = kzalloc(sizeof(struct em28xx_dvb), GFP_KERNEL); 969 970 if (dvb == NULL) { 971 em28xx_info("em28xx_dvb: memory allocation failed\n"); 972 return -ENOMEM; 973 } 974 dev->dvb = dvb; 975 dvb->fe[0] = dvb->fe[1] = NULL; 976 977 mutex_lock(&dev->lock); 978 em28xx_set_mode(dev, EM28XX_DIGITAL_MODE); 979 /* init frontend */ 980 switch (dev->model) { 981 case EM2874_BOARD_LEADERSHIP_ISDBT: 982 dvb->fe[0] = dvb_attach(s921_attach, 983 &sharp_isdbt, &dev->i2c_adap[dev->def_i2c_bus]); 984 985 if (!dvb->fe[0]) { 986 result = -EINVAL; 987 goto out_free; 988 } 989 990 break; 991 case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_850: 992 case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950: 993 case EM2880_BOARD_PINNACLE_PCTV_HD_PRO: 994 case EM2880_BOARD_AMD_ATI_TV_WONDER_HD_600: 995 dvb->fe[0] = dvb_attach(lgdt330x_attach, 996 &em2880_lgdt3303_dev, 997 &dev->i2c_adap[dev->def_i2c_bus]); 998 if (em28xx_attach_xc3028(0x61, dev) < 0) { 999 result = -EINVAL; 1000 goto out_free; 1001 } 1002 break; 1003 case EM2880_BOARD_KWORLD_DVB_310U: 1004 dvb->fe[0] = dvb_attach(zl10353_attach, 1005 &em28xx_zl10353_with_xc3028, 1006 &dev->i2c_adap[dev->def_i2c_bus]); 1007 if (em28xx_attach_xc3028(0x61, dev) < 0) { 1008 result = -EINVAL; 1009 goto out_free; 1010 } 1011 break; 1012 case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900: 1013 case EM2882_BOARD_TERRATEC_HYBRID_XS: 1014 case EM2880_BOARD_EMPIRE_DUAL_TV: 1015 dvb->fe[0] = dvb_attach(zl10353_attach, 1016 &em28xx_zl10353_xc3028_no_i2c_gate, 1017 &dev->i2c_adap[dev->def_i2c_bus]); 1018 if (em28xx_attach_xc3028(0x61, dev) < 0) { 1019 result = -EINVAL; 1020 goto out_free; 1021 } 1022 break; 1023 case EM2880_BOARD_TERRATEC_HYBRID_XS: 1024 case EM2880_BOARD_TERRATEC_HYBRID_XS_FR: 1025 case EM2881_BOARD_PINNACLE_HYBRID_PRO: 1026 case EM2882_BOARD_DIKOM_DK300: 1027 case EM2882_BOARD_KWORLD_VS_DVBT: 1028 dvb->fe[0] = dvb_attach(zl10353_attach, 1029 &em28xx_zl10353_xc3028_no_i2c_gate, 1030 &dev->i2c_adap[dev->def_i2c_bus]); 1031 if (dvb->fe[0] == NULL) { 1032 /* This board could have either a zl10353 or a mt352. 1033 If the chip id isn't for zl10353, try mt352 */ 1034 dvb->fe[0] = dvb_attach(mt352_attach, 1035 &terratec_xs_mt352_cfg, 1036 &dev->i2c_adap[dev->def_i2c_bus]); 1037 } 1038 1039 if (em28xx_attach_xc3028(0x61, dev) < 0) { 1040 result = -EINVAL; 1041 goto out_free; 1042 } 1043 break; 1044 case EM2870_BOARD_KWORLD_355U: 1045 dvb->fe[0] = dvb_attach(zl10353_attach, 1046 &em28xx_zl10353_no_i2c_gate_dev, 1047 &dev->i2c_adap[dev->def_i2c_bus]); 1048 if (dvb->fe[0] != NULL) 1049 dvb_attach(qt1010_attach, dvb->fe[0], 1050 &dev->i2c_adap[dev->def_i2c_bus], &em28xx_qt1010_config); 1051 break; 1052 case EM2883_BOARD_KWORLD_HYBRID_330U: 1053 case EM2882_BOARD_EVGA_INDTUBE: 1054 dvb->fe[0] = dvb_attach(s5h1409_attach, 1055 &em28xx_s5h1409_with_xc3028, 1056 &dev->i2c_adap[dev->def_i2c_bus]); 1057 if (em28xx_attach_xc3028(0x61, dev) < 0) { 1058 result = -EINVAL; 1059 goto out_free; 1060 } 1061 break; 1062 case EM2882_BOARD_KWORLD_ATSC_315U: 1063 dvb->fe[0] = dvb_attach(lgdt330x_attach, 1064 &em2880_lgdt3303_dev, 1065 &dev->i2c_adap[dev->def_i2c_bus]); 1066 if (dvb->fe[0] != NULL) { 1067 if (!dvb_attach(simple_tuner_attach, dvb->fe[0], 1068 &dev->i2c_adap[dev->def_i2c_bus], 0x61, TUNER_THOMSON_DTT761X)) { 1069 result = -EINVAL; 1070 goto out_free; 1071 } 1072 } 1073 break; 1074 case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900_R2: 1075 case EM2882_BOARD_PINNACLE_HYBRID_PRO_330E: 1076 dvb->fe[0] = dvb_attach(drxd_attach, &em28xx_drxd, NULL, 1077 &dev->i2c_adap[dev->def_i2c_bus], &dev->udev->dev); 1078 if (em28xx_attach_xc3028(0x61, dev) < 0) { 1079 result = -EINVAL; 1080 goto out_free; 1081 } 1082 break; 1083 case EM2870_BOARD_REDDO_DVB_C_USB_BOX: 1084 /* Philips CU1216L NIM (Philips TDA10023 + Infineon TUA6034) */ 1085 dvb->fe[0] = dvb_attach(tda10023_attach, 1086 &em28xx_tda10023_config, 1087 &dev->i2c_adap[dev->def_i2c_bus], 0x48); 1088 if (dvb->fe[0]) { 1089 if (!dvb_attach(simple_tuner_attach, dvb->fe[0], 1090 &dev->i2c_adap[dev->def_i2c_bus], 0x60, TUNER_PHILIPS_CU1216L)) { 1091 result = -EINVAL; 1092 goto out_free; 1093 } 1094 } 1095 break; 1096 case EM2870_BOARD_KWORLD_A340: 1097 dvb->fe[0] = dvb_attach(lgdt3305_attach, 1098 &em2870_lgdt3304_dev, 1099 &dev->i2c_adap[dev->def_i2c_bus]); 1100 if (dvb->fe[0] != NULL) 1101 dvb_attach(tda18271_attach, dvb->fe[0], 0x60, 1102 &dev->i2c_adap[dev->def_i2c_bus], &kworld_a340_config); 1103 break; 1104 case EM28174_BOARD_PCTV_290E: 1105 /* set default GPIO0 for LNA, used if GPIOLIB is undefined */ 1106 dvb->lna_gpio = CXD2820R_GPIO_E | CXD2820R_GPIO_O | 1107 CXD2820R_GPIO_L; 1108 dvb->fe[0] = dvb_attach(cxd2820r_attach, 1109 &em28xx_cxd2820r_config, 1110 &dev->i2c_adap[dev->def_i2c_bus], 1111 &dvb->lna_gpio); 1112 if (dvb->fe[0]) { 1113 /* FE 0 attach tuner */ 1114 if (!dvb_attach(tda18271_attach, 1115 dvb->fe[0], 1116 0x60, 1117 &dev->i2c_adap[dev->def_i2c_bus], 1118 &em28xx_cxd2820r_tda18271_config)) { 1119 1120 dvb_frontend_detach(dvb->fe[0]); 1121 result = -EINVAL; 1122 goto out_free; 1123 } 1124 1125 #ifdef CONFIG_GPIOLIB 1126 /* enable LNA for DVB-T, DVB-T2 and DVB-C */ 1127 result = gpio_request_one(dvb->lna_gpio, 1128 GPIOF_OUT_INIT_LOW, NULL); 1129 if (result) 1130 em28xx_errdev("gpio request failed %d\n", 1131 result); 1132 else 1133 gpio_free(dvb->lna_gpio); 1134 1135 result = 0; /* continue even set LNA fails */ 1136 #endif 1137 dvb->fe[0]->ops.set_lna = em28xx_pctv_290e_set_lna; 1138 } 1139 1140 break; 1141 case EM2884_BOARD_HAUPPAUGE_WINTV_HVR_930C: 1142 { 1143 struct xc5000_config cfg; 1144 hauppauge_hvr930c_init(dev); 1145 1146 dvb->fe[0] = dvb_attach(drxk_attach, 1147 &hauppauge_930c_drxk, &dev->i2c_adap[dev->def_i2c_bus]); 1148 if (!dvb->fe[0]) { 1149 result = -EINVAL; 1150 goto out_free; 1151 } 1152 /* FIXME: do we need a pll semaphore? */ 1153 dvb->fe[0]->sec_priv = dvb; 1154 sema_init(&dvb->pll_mutex, 1); 1155 dvb->gate_ctrl = dvb->fe[0]->ops.i2c_gate_ctrl; 1156 dvb->fe[0]->ops.i2c_gate_ctrl = drxk_gate_ctrl; 1157 1158 /* Attach xc5000 */ 1159 memset(&cfg, 0, sizeof(cfg)); 1160 cfg.i2c_address = 0x61; 1161 cfg.if_khz = 4000; 1162 1163 if (dvb->fe[0]->ops.i2c_gate_ctrl) 1164 dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 1); 1165 if (!dvb_attach(xc5000_attach, dvb->fe[0], &dev->i2c_adap[dev->def_i2c_bus], 1166 &cfg)) { 1167 result = -EINVAL; 1168 goto out_free; 1169 } 1170 if (dvb->fe[0]->ops.i2c_gate_ctrl) 1171 dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 0); 1172 1173 break; 1174 } 1175 case EM2884_BOARD_TERRATEC_H5: 1176 terratec_h5_init(dev); 1177 1178 dvb->fe[0] = dvb_attach(drxk_attach, &terratec_h5_drxk, &dev->i2c_adap[dev->def_i2c_bus]); 1179 if (!dvb->fe[0]) { 1180 result = -EINVAL; 1181 goto out_free; 1182 } 1183 /* FIXME: do we need a pll semaphore? */ 1184 dvb->fe[0]->sec_priv = dvb; 1185 sema_init(&dvb->pll_mutex, 1); 1186 dvb->gate_ctrl = dvb->fe[0]->ops.i2c_gate_ctrl; 1187 dvb->fe[0]->ops.i2c_gate_ctrl = drxk_gate_ctrl; 1188 1189 /* Attach tda18271 to DVB-C frontend */ 1190 if (dvb->fe[0]->ops.i2c_gate_ctrl) 1191 dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 1); 1192 if (!dvb_attach(tda18271c2dd_attach, dvb->fe[0], &dev->i2c_adap[dev->def_i2c_bus], 0x60)) { 1193 result = -EINVAL; 1194 goto out_free; 1195 } 1196 if (dvb->fe[0]->ops.i2c_gate_ctrl) 1197 dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 0); 1198 1199 break; 1200 case EM2884_BOARD_C3TECH_DIGITAL_DUO: 1201 dvb->fe[0] = dvb_attach(mb86a20s_attach, 1202 &c3tech_duo_mb86a20s_config, 1203 &dev->i2c_adap[dev->def_i2c_bus]); 1204 if (dvb->fe[0] != NULL) 1205 dvb_attach(tda18271_attach, dvb->fe[0], 0x60, 1206 &dev->i2c_adap[dev->def_i2c_bus], 1207 &c3tech_duo_tda18271_config); 1208 break; 1209 case EM28174_BOARD_PCTV_460E: 1210 /* attach demod */ 1211 dvb->fe[0] = dvb_attach(tda10071_attach, 1212 &em28xx_tda10071_config, &dev->i2c_adap[dev->def_i2c_bus]); 1213 1214 /* attach SEC */ 1215 if (dvb->fe[0]) 1216 dvb_attach(a8293_attach, dvb->fe[0], &dev->i2c_adap[dev->def_i2c_bus], 1217 &em28xx_a8293_config); 1218 break; 1219 case EM2874_BOARD_DELOCK_61959: 1220 case EM2874_BOARD_MAXMEDIA_UB425_TC: 1221 /* attach demodulator */ 1222 dvb->fe[0] = dvb_attach(drxk_attach, &maxmedia_ub425_tc_drxk, 1223 &dev->i2c_adap[dev->def_i2c_bus]); 1224 1225 if (dvb->fe[0]) { 1226 /* disable I2C-gate */ 1227 dvb->fe[0]->ops.i2c_gate_ctrl = NULL; 1228 1229 /* attach tuner */ 1230 if (!dvb_attach(tda18271c2dd_attach, dvb->fe[0], 1231 &dev->i2c_adap[dev->def_i2c_bus], 0x60)) { 1232 dvb_frontend_detach(dvb->fe[0]); 1233 result = -EINVAL; 1234 goto out_free; 1235 } 1236 } 1237 1238 /* TODO: we need drx-3913k firmware in order to support DVB-T */ 1239 em28xx_info("MaxMedia UB425-TC/Delock 61959: only DVB-C " \ 1240 "supported by that driver version\n"); 1241 1242 break; 1243 case EM2884_BOARD_PCTV_510E: 1244 case EM2884_BOARD_PCTV_520E: 1245 pctv_520e_init(dev); 1246 1247 /* attach demodulator */ 1248 dvb->fe[0] = dvb_attach(drxk_attach, &pctv_520e_drxk, 1249 &dev->i2c_adap[dev->def_i2c_bus]); 1250 1251 if (dvb->fe[0]) { 1252 /* attach tuner */ 1253 if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60, 1254 &dev->i2c_adap[dev->def_i2c_bus], 1255 &em28xx_cxd2820r_tda18271_config)) { 1256 dvb_frontend_detach(dvb->fe[0]); 1257 result = -EINVAL; 1258 goto out_free; 1259 } 1260 } 1261 break; 1262 case EM2884_BOARD_CINERGY_HTC_STICK: 1263 terratec_htc_stick_init(dev); 1264 1265 /* attach demodulator */ 1266 dvb->fe[0] = dvb_attach(drxk_attach, &terratec_htc_stick_drxk, 1267 &dev->i2c_adap[dev->def_i2c_bus]); 1268 if (!dvb->fe[0]) { 1269 result = -EINVAL; 1270 goto out_free; 1271 } 1272 1273 /* Attach the demodulator. */ 1274 if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60, 1275 &dev->i2c_adap[dev->def_i2c_bus], 1276 &em28xx_cxd2820r_tda18271_config)) { 1277 result = -EINVAL; 1278 goto out_free; 1279 } 1280 break; 1281 case EM2884_BOARD_TERRATEC_HTC_USB_XS: 1282 terratec_htc_usb_xs_init(dev); 1283 1284 /* attach demodulator */ 1285 dvb->fe[0] = dvb_attach(drxk_attach, &terratec_htc_stick_drxk, 1286 &dev->i2c_adap[dev->def_i2c_bus]); 1287 if (!dvb->fe[0]) { 1288 result = -EINVAL; 1289 goto out_free; 1290 } 1291 1292 /* Attach the demodulator. */ 1293 if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60, 1294 &dev->i2c_adap[dev->def_i2c_bus], 1295 &em28xx_cxd2820r_tda18271_config)) { 1296 result = -EINVAL; 1297 goto out_free; 1298 } 1299 break; 1300 default: 1301 em28xx_errdev("/2: The frontend of your DVB/ATSC card" 1302 " isn't supported yet\n"); 1303 break; 1304 } 1305 if (NULL == dvb->fe[0]) { 1306 em28xx_errdev("/2: frontend initialization failed\n"); 1307 result = -EINVAL; 1308 goto out_free; 1309 } 1310 /* define general-purpose callback pointer */ 1311 dvb->fe[0]->callback = em28xx_tuner_callback; 1312 if (dvb->fe[1]) 1313 dvb->fe[1]->callback = em28xx_tuner_callback; 1314 1315 /* register everything */ 1316 result = em28xx_register_dvb(dvb, THIS_MODULE, dev, &dev->udev->dev); 1317 1318 if (result < 0) 1319 goto out_free; 1320 1321 /* MFE lock */ 1322 dvb->adapter.mfe_shared = mfe_shared; 1323 1324 em28xx_info("Successfully loaded em28xx-dvb\n"); 1325 ret: 1326 em28xx_set_mode(dev, EM28XX_SUSPEND); 1327 mutex_unlock(&dev->lock); 1328 return result; 1329 1330 out_free: 1331 kfree(dvb); 1332 dev->dvb = NULL; 1333 goto ret; 1334 } 1335 1336 static inline void prevent_sleep(struct dvb_frontend_ops *ops) 1337 { 1338 ops->set_voltage = NULL; 1339 ops->sleep = NULL; 1340 ops->tuner_ops.sleep = NULL; 1341 } 1342 1343 static int em28xx_dvb_fini(struct em28xx *dev) 1344 { 1345 if (!dev->board.has_dvb) { 1346 /* This device does not support the extension */ 1347 return 0; 1348 } 1349 1350 if (dev->dvb) { 1351 struct em28xx_dvb *dvb = dev->dvb; 1352 1353 if (dev->disconnected) { 1354 /* We cannot tell the device to sleep 1355 * once it has been unplugged. */ 1356 if (dvb->fe[0]) 1357 prevent_sleep(&dvb->fe[0]->ops); 1358 if (dvb->fe[1]) 1359 prevent_sleep(&dvb->fe[1]->ops); 1360 } 1361 1362 em28xx_unregister_dvb(dvb); 1363 kfree(dvb); 1364 dev->dvb = NULL; 1365 } 1366 1367 return 0; 1368 } 1369 1370 static struct em28xx_ops dvb_ops = { 1371 .id = EM28XX_DVB, 1372 .name = "Em28xx dvb Extension", 1373 .init = em28xx_dvb_init, 1374 .fini = em28xx_dvb_fini, 1375 }; 1376 1377 static int __init em28xx_dvb_register(void) 1378 { 1379 return em28xx_register_extension(&dvb_ops); 1380 } 1381 1382 static void __exit em28xx_dvb_unregister(void) 1383 { 1384 em28xx_unregister_extension(&dvb_ops); 1385 } 1386 1387 module_init(em28xx_dvb_register); 1388 module_exit(em28xx_dvb_unregister); 1389