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