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