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