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