1 /* DVB USB compliant linux driver for Conexant USB reference design. 2 * 3 * The Conexant reference design I saw on their website was only for analogue 4 * capturing (using the cx25842). The box I took to write this driver (reverse 5 * engineered) is the one labeled Medion MD95700. In addition to the cx25842 6 * for analogue capturing it also has a cx22702 DVB-T demodulator on the main 7 * board. Besides it has a atiremote (X10) and a USB2.0 hub onboard. 8 * 9 * Maybe it is a little bit premature to call this driver cxusb, but I assume 10 * the USB protocol is identical or at least inherited from the reference 11 * design, so it can be reused for the "analogue-only" device (if it will 12 * appear at all). 13 * 14 * TODO: Use the cx25840-driver for the analogue part 15 * 16 * Copyright (C) 2005 Patrick Boettcher (patrick.boettcher@posteo.de) 17 * Copyright (C) 2006 Michael Krufky (mkrufky@linuxtv.org) 18 * Copyright (C) 2006, 2007 Chris Pascoe (c.pascoe@itee.uq.edu.au) 19 * 20 * This program is free software; you can redistribute it and/or modify it 21 * under the terms of the GNU General Public License as published by the Free 22 * Software Foundation, version 2. 23 * 24 * see Documentation/media/dvb-drivers/dvb-usb.rst for more information 25 */ 26 #include <media/tuner.h> 27 #include <linux/vmalloc.h> 28 #include <linux/slab.h> 29 #include <linux/kernel.h> 30 31 #include "cxusb.h" 32 33 #include "cx22702.h" 34 #include "lgdt330x.h" 35 #include "mt352.h" 36 #include "mt352_priv.h" 37 #include "zl10353.h" 38 #include "tuner-xc2028.h" 39 #include "tuner-simple.h" 40 #include "mxl5005s.h" 41 #include "max2165.h" 42 #include "dib7000p.h" 43 #include "dib0070.h" 44 #include "lgs8gxx.h" 45 #include "atbm8830.h" 46 #include "si2168.h" 47 #include "si2157.h" 48 49 /* debug */ 50 static int dvb_usb_cxusb_debug; 51 module_param_named(debug, dvb_usb_cxusb_debug, int, 0644); 52 MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS); 53 54 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); 55 56 #define deb_info(args...) dprintk(dvb_usb_cxusb_debug, 0x03, args) 57 #define deb_i2c(args...) dprintk(dvb_usb_cxusb_debug, 0x02, args) 58 59 static int cxusb_ctrl_msg(struct dvb_usb_device *d, 60 u8 cmd, const u8 *wbuf, int wlen, u8 *rbuf, int rlen) 61 { 62 struct cxusb_state *st = d->priv; 63 int ret; 64 65 if (1 + wlen > MAX_XFER_SIZE) { 66 warn("i2c wr: len=%d is too big!\n", wlen); 67 return -EOPNOTSUPP; 68 } 69 70 if (rlen > MAX_XFER_SIZE) { 71 warn("i2c rd: len=%d is too big!\n", rlen); 72 return -EOPNOTSUPP; 73 } 74 75 mutex_lock(&d->data_mutex); 76 st->data[0] = cmd; 77 memcpy(&st->data[1], wbuf, wlen); 78 ret = dvb_usb_generic_rw(d, st->data, 1 + wlen, st->data, rlen, 0); 79 if (!ret && rbuf && rlen) 80 memcpy(rbuf, st->data, rlen); 81 82 mutex_unlock(&d->data_mutex); 83 return ret; 84 } 85 86 /* GPIO */ 87 static void cxusb_gpio_tuner(struct dvb_usb_device *d, int onoff) 88 { 89 struct cxusb_state *st = d->priv; 90 u8 o[2], i; 91 92 if (st->gpio_write_state[GPIO_TUNER] == onoff) 93 return; 94 95 o[0] = GPIO_TUNER; 96 o[1] = onoff; 97 cxusb_ctrl_msg(d, CMD_GPIO_WRITE, o, 2, &i, 1); 98 99 if (i != 0x01) 100 deb_info("gpio_write failed.\n"); 101 102 st->gpio_write_state[GPIO_TUNER] = onoff; 103 } 104 105 static int cxusb_bluebird_gpio_rw(struct dvb_usb_device *d, u8 changemask, 106 u8 newval) 107 { 108 u8 o[2], gpio_state; 109 int rc; 110 111 o[0] = 0xff & ~changemask; /* mask of bits to keep */ 112 o[1] = newval & changemask; /* new values for bits */ 113 114 rc = cxusb_ctrl_msg(d, CMD_BLUEBIRD_GPIO_RW, o, 2, &gpio_state, 1); 115 if (rc < 0 || (gpio_state & changemask) != (newval & changemask)) 116 deb_info("bluebird_gpio_write failed.\n"); 117 118 return rc < 0 ? rc : gpio_state; 119 } 120 121 static void cxusb_bluebird_gpio_pulse(struct dvb_usb_device *d, u8 pin, int low) 122 { 123 cxusb_bluebird_gpio_rw(d, pin, low ? 0 : pin); 124 msleep(5); 125 cxusb_bluebird_gpio_rw(d, pin, low ? pin : 0); 126 } 127 128 static void cxusb_nano2_led(struct dvb_usb_device *d, int onoff) 129 { 130 cxusb_bluebird_gpio_rw(d, 0x40, onoff ? 0 : 0x40); 131 } 132 133 static int cxusb_d680_dmb_gpio_tuner(struct dvb_usb_device *d, 134 u8 addr, int onoff) 135 { 136 u8 o[2] = {addr, onoff}; 137 u8 i; 138 int rc; 139 140 rc = cxusb_ctrl_msg(d, CMD_GPIO_WRITE, o, 2, &i, 1); 141 142 if (rc < 0) 143 return rc; 144 if (i == 0x01) 145 return 0; 146 else { 147 deb_info("gpio_write failed.\n"); 148 return -EIO; 149 } 150 } 151 152 /* I2C */ 153 static int cxusb_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[], 154 int num) 155 { 156 struct dvb_usb_device *d = i2c_get_adapdata(adap); 157 int ret; 158 int i; 159 160 if (mutex_lock_interruptible(&d->i2c_mutex) < 0) 161 return -EAGAIN; 162 163 for (i = 0; i < num; i++) { 164 165 if (le16_to_cpu(d->udev->descriptor.idVendor) == USB_VID_MEDION) 166 switch (msg[i].addr) { 167 case 0x63: 168 cxusb_gpio_tuner(d, 0); 169 break; 170 default: 171 cxusb_gpio_tuner(d, 1); 172 break; 173 } 174 175 if (msg[i].flags & I2C_M_RD) { 176 /* read only */ 177 u8 obuf[3], ibuf[MAX_XFER_SIZE]; 178 179 if (1 + msg[i].len > sizeof(ibuf)) { 180 warn("i2c rd: len=%d is too big!\n", 181 msg[i].len); 182 ret = -EOPNOTSUPP; 183 goto unlock; 184 } 185 obuf[0] = 0; 186 obuf[1] = msg[i].len; 187 obuf[2] = msg[i].addr; 188 if (cxusb_ctrl_msg(d, CMD_I2C_READ, 189 obuf, 3, 190 ibuf, 1+msg[i].len) < 0) { 191 warn("i2c read failed"); 192 break; 193 } 194 memcpy(msg[i].buf, &ibuf[1], msg[i].len); 195 } else if (i+1 < num && (msg[i+1].flags & I2C_M_RD) && 196 msg[i].addr == msg[i+1].addr) { 197 /* write to then read from same address */ 198 u8 obuf[MAX_XFER_SIZE], ibuf[MAX_XFER_SIZE]; 199 200 if (3 + msg[i].len > sizeof(obuf)) { 201 warn("i2c wr: len=%d is too big!\n", 202 msg[i].len); 203 ret = -EOPNOTSUPP; 204 goto unlock; 205 } 206 if (1 + msg[i + 1].len > sizeof(ibuf)) { 207 warn("i2c rd: len=%d is too big!\n", 208 msg[i + 1].len); 209 ret = -EOPNOTSUPP; 210 goto unlock; 211 } 212 obuf[0] = msg[i].len; 213 obuf[1] = msg[i+1].len; 214 obuf[2] = msg[i].addr; 215 memcpy(&obuf[3], msg[i].buf, msg[i].len); 216 217 if (cxusb_ctrl_msg(d, CMD_I2C_READ, 218 obuf, 3+msg[i].len, 219 ibuf, 1+msg[i+1].len) < 0) 220 break; 221 222 if (ibuf[0] != 0x08) 223 deb_i2c("i2c read may have failed\n"); 224 225 memcpy(msg[i+1].buf, &ibuf[1], msg[i+1].len); 226 227 i++; 228 } else { 229 /* write only */ 230 u8 obuf[MAX_XFER_SIZE], ibuf; 231 232 if (2 + msg[i].len > sizeof(obuf)) { 233 warn("i2c wr: len=%d is too big!\n", 234 msg[i].len); 235 ret = -EOPNOTSUPP; 236 goto unlock; 237 } 238 obuf[0] = msg[i].addr; 239 obuf[1] = msg[i].len; 240 memcpy(&obuf[2], msg[i].buf, msg[i].len); 241 242 if (cxusb_ctrl_msg(d, CMD_I2C_WRITE, obuf, 243 2+msg[i].len, &ibuf,1) < 0) 244 break; 245 if (ibuf != 0x08) 246 deb_i2c("i2c write may have failed\n"); 247 } 248 } 249 250 if (i == num) 251 ret = num; 252 else 253 ret = -EREMOTEIO; 254 255 unlock: 256 mutex_unlock(&d->i2c_mutex); 257 return ret; 258 } 259 260 static u32 cxusb_i2c_func(struct i2c_adapter *adapter) 261 { 262 return I2C_FUNC_I2C; 263 } 264 265 static struct i2c_algorithm cxusb_i2c_algo = { 266 .master_xfer = cxusb_i2c_xfer, 267 .functionality = cxusb_i2c_func, 268 }; 269 270 static int cxusb_power_ctrl(struct dvb_usb_device *d, int onoff) 271 { 272 u8 b = 0; 273 if (onoff) 274 return cxusb_ctrl_msg(d, CMD_POWER_ON, &b, 1, NULL, 0); 275 else 276 return cxusb_ctrl_msg(d, CMD_POWER_OFF, &b, 1, NULL, 0); 277 } 278 279 static int cxusb_aver_power_ctrl(struct dvb_usb_device *d, int onoff) 280 { 281 int ret; 282 if (!onoff) 283 return cxusb_ctrl_msg(d, CMD_POWER_OFF, NULL, 0, NULL, 0); 284 if (d->state == DVB_USB_STATE_INIT && 285 usb_set_interface(d->udev, 0, 0) < 0) 286 err("set interface failed"); 287 do {} while (!(ret = cxusb_ctrl_msg(d, CMD_POWER_ON, NULL, 0, NULL, 0)) && 288 !(ret = cxusb_ctrl_msg(d, 0x15, NULL, 0, NULL, 0)) && 289 !(ret = cxusb_ctrl_msg(d, 0x17, NULL, 0, NULL, 0)) && 0); 290 if (!ret) { 291 /* FIXME: We don't know why, but we need to configure the 292 * lgdt3303 with the register settings below on resume */ 293 int i; 294 u8 buf; 295 static const u8 bufs[] = { 296 0x0e, 0x2, 0x00, 0x7f, 297 0x0e, 0x2, 0x02, 0xfe, 298 0x0e, 0x2, 0x02, 0x01, 299 0x0e, 0x2, 0x00, 0x03, 300 0x0e, 0x2, 0x0d, 0x40, 301 0x0e, 0x2, 0x0e, 0x87, 302 0x0e, 0x2, 0x0f, 0x8e, 303 0x0e, 0x2, 0x10, 0x01, 304 0x0e, 0x2, 0x14, 0xd7, 305 0x0e, 0x2, 0x47, 0x88, 306 }; 307 msleep(20); 308 for (i = 0; i < ARRAY_SIZE(bufs); i += 4 / sizeof(u8)) { 309 ret = cxusb_ctrl_msg(d, CMD_I2C_WRITE, 310 bufs+i, 4, &buf, 1); 311 if (ret) 312 break; 313 if (buf != 0x8) 314 return -EREMOTEIO; 315 } 316 } 317 return ret; 318 } 319 320 static int cxusb_bluebird_power_ctrl(struct dvb_usb_device *d, int onoff) 321 { 322 u8 b = 0; 323 if (onoff) 324 return cxusb_ctrl_msg(d, CMD_POWER_ON, &b, 1, NULL, 0); 325 else 326 return 0; 327 } 328 329 static int cxusb_nano2_power_ctrl(struct dvb_usb_device *d, int onoff) 330 { 331 int rc = 0; 332 333 rc = cxusb_power_ctrl(d, onoff); 334 if (!onoff) 335 cxusb_nano2_led(d, 0); 336 337 return rc; 338 } 339 340 static int cxusb_d680_dmb_power_ctrl(struct dvb_usb_device *d, int onoff) 341 { 342 int ret; 343 u8 b; 344 ret = cxusb_power_ctrl(d, onoff); 345 if (!onoff) 346 return ret; 347 348 msleep(128); 349 cxusb_ctrl_msg(d, CMD_DIGITAL, NULL, 0, &b, 1); 350 msleep(100); 351 return ret; 352 } 353 354 static int cxusb_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff) 355 { 356 u8 buf[2] = { 0x03, 0x00 }; 357 if (onoff) 358 cxusb_ctrl_msg(adap->dev, CMD_STREAMING_ON, buf, 2, NULL, 0); 359 else 360 cxusb_ctrl_msg(adap->dev, CMD_STREAMING_OFF, NULL, 0, NULL, 0); 361 362 return 0; 363 } 364 365 static int cxusb_aver_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff) 366 { 367 if (onoff) 368 cxusb_ctrl_msg(adap->dev, CMD_AVER_STREAM_ON, NULL, 0, NULL, 0); 369 else 370 cxusb_ctrl_msg(adap->dev, CMD_AVER_STREAM_OFF, 371 NULL, 0, NULL, 0); 372 return 0; 373 } 374 375 static int cxusb_read_status(struct dvb_frontend *fe, 376 enum fe_status *status) 377 { 378 struct dvb_usb_adapter *adap = (struct dvb_usb_adapter *)fe->dvb->priv; 379 struct cxusb_state *state = (struct cxusb_state *)adap->dev->priv; 380 int ret; 381 382 ret = state->fe_read_status(fe, status); 383 384 /* it need resync slave fifo when signal change from unlock to lock.*/ 385 if ((*status & FE_HAS_LOCK) && (!state->last_lock)) { 386 mutex_lock(&state->stream_mutex); 387 cxusb_streaming_ctrl(adap, 1); 388 mutex_unlock(&state->stream_mutex); 389 } 390 391 state->last_lock = (*status & FE_HAS_LOCK) ? 1 : 0; 392 return ret; 393 } 394 395 static void cxusb_d680_dmb_drain_message(struct dvb_usb_device *d) 396 { 397 int ep = d->props.generic_bulk_ctrl_endpoint; 398 const int timeout = 100; 399 const int junk_len = 32; 400 u8 *junk; 401 int rd_count; 402 403 /* Discard remaining data in video pipe */ 404 junk = kmalloc(junk_len, GFP_KERNEL); 405 if (!junk) 406 return; 407 while (1) { 408 if (usb_bulk_msg(d->udev, 409 usb_rcvbulkpipe(d->udev, ep), 410 junk, junk_len, &rd_count, timeout) < 0) 411 break; 412 if (!rd_count) 413 break; 414 } 415 kfree(junk); 416 } 417 418 static void cxusb_d680_dmb_drain_video(struct dvb_usb_device *d) 419 { 420 struct usb_data_stream_properties *p = &d->props.adapter[0].fe[0].stream; 421 const int timeout = 100; 422 const int junk_len = p->u.bulk.buffersize; 423 u8 *junk; 424 int rd_count; 425 426 /* Discard remaining data in video pipe */ 427 junk = kmalloc(junk_len, GFP_KERNEL); 428 if (!junk) 429 return; 430 while (1) { 431 if (usb_bulk_msg(d->udev, 432 usb_rcvbulkpipe(d->udev, p->endpoint), 433 junk, junk_len, &rd_count, timeout) < 0) 434 break; 435 if (!rd_count) 436 break; 437 } 438 kfree(junk); 439 } 440 441 static int cxusb_d680_dmb_streaming_ctrl( 442 struct dvb_usb_adapter *adap, int onoff) 443 { 444 if (onoff) { 445 u8 buf[2] = { 0x03, 0x00 }; 446 cxusb_d680_dmb_drain_video(adap->dev); 447 return cxusb_ctrl_msg(adap->dev, CMD_STREAMING_ON, 448 buf, sizeof(buf), NULL, 0); 449 } else { 450 int ret = cxusb_ctrl_msg(adap->dev, 451 CMD_STREAMING_OFF, NULL, 0, NULL, 0); 452 return ret; 453 } 454 } 455 456 static int cxusb_rc_query(struct dvb_usb_device *d) 457 { 458 u8 ircode[4]; 459 460 cxusb_ctrl_msg(d, CMD_GET_IR_CODE, NULL, 0, ircode, 4); 461 462 if (ircode[2] || ircode[3]) 463 rc_keydown(d->rc_dev, RC_PROTO_NEC, 464 RC_SCANCODE_NEC(~ircode[2] & 0xff, ircode[3]), 0); 465 return 0; 466 } 467 468 static int cxusb_bluebird2_rc_query(struct dvb_usb_device *d) 469 { 470 u8 ircode[4]; 471 struct i2c_msg msg = { .addr = 0x6b, .flags = I2C_M_RD, 472 .buf = ircode, .len = 4 }; 473 474 if (cxusb_i2c_xfer(&d->i2c_adap, &msg, 1) != 1) 475 return 0; 476 477 if (ircode[1] || ircode[2]) 478 rc_keydown(d->rc_dev, RC_PROTO_NEC, 479 RC_SCANCODE_NEC(~ircode[1] & 0xff, ircode[2]), 0); 480 return 0; 481 } 482 483 static int cxusb_d680_dmb_rc_query(struct dvb_usb_device *d) 484 { 485 u8 ircode[2]; 486 487 if (cxusb_ctrl_msg(d, 0x10, NULL, 0, ircode, 2) < 0) 488 return 0; 489 490 if (ircode[0] || ircode[1]) 491 rc_keydown(d->rc_dev, RC_PROTO_UNKNOWN, 492 RC_SCANCODE_RC5(ircode[0], ircode[1]), 0); 493 return 0; 494 } 495 496 static int cxusb_dee1601_demod_init(struct dvb_frontend* fe) 497 { 498 static u8 clock_config [] = { CLOCK_CTL, 0x38, 0x28 }; 499 static u8 reset [] = { RESET, 0x80 }; 500 static u8 adc_ctl_1_cfg [] = { ADC_CTL_1, 0x40 }; 501 static u8 agc_cfg [] = { AGC_TARGET, 0x28, 0x20 }; 502 static u8 gpp_ctl_cfg [] = { GPP_CTL, 0x33 }; 503 static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 }; 504 505 mt352_write(fe, clock_config, sizeof(clock_config)); 506 udelay(200); 507 mt352_write(fe, reset, sizeof(reset)); 508 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg)); 509 510 mt352_write(fe, agc_cfg, sizeof(agc_cfg)); 511 mt352_write(fe, gpp_ctl_cfg, sizeof(gpp_ctl_cfg)); 512 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg)); 513 514 return 0; 515 } 516 517 static int cxusb_mt352_demod_init(struct dvb_frontend* fe) 518 { /* used in both lgz201 and th7579 */ 519 static u8 clock_config [] = { CLOCK_CTL, 0x38, 0x29 }; 520 static u8 reset [] = { RESET, 0x80 }; 521 static u8 adc_ctl_1_cfg [] = { ADC_CTL_1, 0x40 }; 522 static u8 agc_cfg [] = { AGC_TARGET, 0x24, 0x20 }; 523 static u8 gpp_ctl_cfg [] = { GPP_CTL, 0x33 }; 524 static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 }; 525 526 mt352_write(fe, clock_config, sizeof(clock_config)); 527 udelay(200); 528 mt352_write(fe, reset, sizeof(reset)); 529 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg)); 530 531 mt352_write(fe, agc_cfg, sizeof(agc_cfg)); 532 mt352_write(fe, gpp_ctl_cfg, sizeof(gpp_ctl_cfg)); 533 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg)); 534 return 0; 535 } 536 537 static struct cx22702_config cxusb_cx22702_config = { 538 .demod_address = 0x63, 539 .output_mode = CX22702_PARALLEL_OUTPUT, 540 }; 541 542 static struct lgdt330x_config cxusb_lgdt3303_config = { 543 .demod_chip = LGDT3303, 544 }; 545 546 static struct lgdt330x_config cxusb_aver_lgdt3303_config = { 547 .demod_chip = LGDT3303, 548 .clock_polarity_flip = 2, 549 }; 550 551 static struct mt352_config cxusb_dee1601_config = { 552 .demod_address = 0x0f, 553 .demod_init = cxusb_dee1601_demod_init, 554 }; 555 556 static struct zl10353_config cxusb_zl10353_dee1601_config = { 557 .demod_address = 0x0f, 558 .parallel_ts = 1, 559 }; 560 561 static struct mt352_config cxusb_mt352_config = { 562 /* used in both lgz201 and th7579 */ 563 .demod_address = 0x0f, 564 .demod_init = cxusb_mt352_demod_init, 565 }; 566 567 static struct zl10353_config cxusb_zl10353_xc3028_config = { 568 .demod_address = 0x0f, 569 .if2 = 45600, 570 .no_tuner = 1, 571 .parallel_ts = 1, 572 }; 573 574 static struct zl10353_config cxusb_zl10353_xc3028_config_no_i2c_gate = { 575 .demod_address = 0x0f, 576 .if2 = 45600, 577 .no_tuner = 1, 578 .parallel_ts = 1, 579 .disable_i2c_gate_ctrl = 1, 580 }; 581 582 static struct mt352_config cxusb_mt352_xc3028_config = { 583 .demod_address = 0x0f, 584 .if2 = 4560, 585 .no_tuner = 1, 586 .demod_init = cxusb_mt352_demod_init, 587 }; 588 589 /* FIXME: needs tweaking */ 590 static struct mxl5005s_config aver_a868r_tuner = { 591 .i2c_address = 0x63, 592 .if_freq = 6000000UL, 593 .xtal_freq = CRYSTAL_FREQ_16000000HZ, 594 .agc_mode = MXL_SINGLE_AGC, 595 .tracking_filter = MXL_TF_C, 596 .rssi_enable = MXL_RSSI_ENABLE, 597 .cap_select = MXL_CAP_SEL_ENABLE, 598 .div_out = MXL_DIV_OUT_4, 599 .clock_out = MXL_CLOCK_OUT_DISABLE, 600 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM, 601 .top = MXL5005S_TOP_25P2, 602 .mod_mode = MXL_DIGITAL_MODE, 603 .if_mode = MXL_ZERO_IF, 604 .AgcMasterByte = 0x00, 605 }; 606 607 /* FIXME: needs tweaking */ 608 static struct mxl5005s_config d680_dmb_tuner = { 609 .i2c_address = 0x63, 610 .if_freq = 36125000UL, 611 .xtal_freq = CRYSTAL_FREQ_16000000HZ, 612 .agc_mode = MXL_SINGLE_AGC, 613 .tracking_filter = MXL_TF_C, 614 .rssi_enable = MXL_RSSI_ENABLE, 615 .cap_select = MXL_CAP_SEL_ENABLE, 616 .div_out = MXL_DIV_OUT_4, 617 .clock_out = MXL_CLOCK_OUT_DISABLE, 618 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM, 619 .top = MXL5005S_TOP_25P2, 620 .mod_mode = MXL_DIGITAL_MODE, 621 .if_mode = MXL_ZERO_IF, 622 .AgcMasterByte = 0x00, 623 }; 624 625 static struct max2165_config mygica_d689_max2165_cfg = { 626 .i2c_address = 0x60, 627 .osc_clk = 20 628 }; 629 630 /* Callbacks for DVB USB */ 631 static int cxusb_fmd1216me_tuner_attach(struct dvb_usb_adapter *adap) 632 { 633 dvb_attach(simple_tuner_attach, adap->fe_adap[0].fe, 634 &adap->dev->i2c_adap, 0x61, 635 TUNER_PHILIPS_FMD1216ME_MK3); 636 return 0; 637 } 638 639 static int cxusb_dee1601_tuner_attach(struct dvb_usb_adapter *adap) 640 { 641 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x61, 642 NULL, DVB_PLL_THOMSON_DTT7579); 643 return 0; 644 } 645 646 static int cxusb_lgz201_tuner_attach(struct dvb_usb_adapter *adap) 647 { 648 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x61, NULL, DVB_PLL_LG_Z201); 649 return 0; 650 } 651 652 static int cxusb_dtt7579_tuner_attach(struct dvb_usb_adapter *adap) 653 { 654 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x60, 655 NULL, DVB_PLL_THOMSON_DTT7579); 656 return 0; 657 } 658 659 static int cxusb_lgh064f_tuner_attach(struct dvb_usb_adapter *adap) 660 { 661 dvb_attach(simple_tuner_attach, adap->fe_adap[0].fe, 662 &adap->dev->i2c_adap, 0x61, TUNER_LG_TDVS_H06XF); 663 return 0; 664 } 665 666 static int dvico_bluebird_xc2028_callback(void *ptr, int component, 667 int command, int arg) 668 { 669 struct dvb_usb_adapter *adap = ptr; 670 struct dvb_usb_device *d = adap->dev; 671 672 switch (command) { 673 case XC2028_TUNER_RESET: 674 deb_info("%s: XC2028_TUNER_RESET %d\n", __func__, arg); 675 cxusb_bluebird_gpio_pulse(d, 0x01, 1); 676 break; 677 case XC2028_RESET_CLK: 678 deb_info("%s: XC2028_RESET_CLK %d\n", __func__, arg); 679 break; 680 case XC2028_I2C_FLUSH: 681 break; 682 default: 683 deb_info("%s: unknown command %d, arg %d\n", __func__, 684 command, arg); 685 return -EINVAL; 686 } 687 688 return 0; 689 } 690 691 static int cxusb_dvico_xc3028_tuner_attach(struct dvb_usb_adapter *adap) 692 { 693 struct dvb_frontend *fe; 694 struct xc2028_config cfg = { 695 .i2c_adap = &adap->dev->i2c_adap, 696 .i2c_addr = 0x61, 697 }; 698 static struct xc2028_ctrl ctl = { 699 .fname = XC2028_DEFAULT_FIRMWARE, 700 .max_len = 64, 701 .demod = XC3028_FE_ZARLINK456, 702 }; 703 704 /* FIXME: generalize & move to common area */ 705 adap->fe_adap[0].fe->callback = dvico_bluebird_xc2028_callback; 706 707 fe = dvb_attach(xc2028_attach, adap->fe_adap[0].fe, &cfg); 708 if (fe == NULL || fe->ops.tuner_ops.set_config == NULL) 709 return -EIO; 710 711 fe->ops.tuner_ops.set_config(fe, &ctl); 712 713 return 0; 714 } 715 716 static int cxusb_mxl5003s_tuner_attach(struct dvb_usb_adapter *adap) 717 { 718 dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe, 719 &adap->dev->i2c_adap, &aver_a868r_tuner); 720 return 0; 721 } 722 723 static int cxusb_d680_dmb_tuner_attach(struct dvb_usb_adapter *adap) 724 { 725 struct dvb_frontend *fe; 726 fe = dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe, 727 &adap->dev->i2c_adap, &d680_dmb_tuner); 728 return (fe == NULL) ? -EIO : 0; 729 } 730 731 static int cxusb_mygica_d689_tuner_attach(struct dvb_usb_adapter *adap) 732 { 733 struct dvb_frontend *fe; 734 fe = dvb_attach(max2165_attach, adap->fe_adap[0].fe, 735 &adap->dev->i2c_adap, &mygica_d689_max2165_cfg); 736 return (fe == NULL) ? -EIO : 0; 737 } 738 739 static int cxusb_cx22702_frontend_attach(struct dvb_usb_adapter *adap) 740 { 741 u8 b; 742 if (usb_set_interface(adap->dev->udev, 0, 6) < 0) 743 err("set interface failed"); 744 745 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, &b, 1); 746 747 adap->fe_adap[0].fe = dvb_attach(cx22702_attach, &cxusb_cx22702_config, 748 &adap->dev->i2c_adap); 749 if ((adap->fe_adap[0].fe) != NULL) 750 return 0; 751 752 return -EIO; 753 } 754 755 static int cxusb_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap) 756 { 757 if (usb_set_interface(adap->dev->udev, 0, 7) < 0) 758 err("set interface failed"); 759 760 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0); 761 762 adap->fe_adap[0].fe = dvb_attach(lgdt330x_attach, 763 &cxusb_lgdt3303_config, 764 0x0e, 765 &adap->dev->i2c_adap); 766 if ((adap->fe_adap[0].fe) != NULL) 767 return 0; 768 769 return -EIO; 770 } 771 772 static int cxusb_aver_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap) 773 { 774 adap->fe_adap[0].fe = dvb_attach(lgdt330x_attach, 775 &cxusb_aver_lgdt3303_config, 776 0x0e, 777 &adap->dev->i2c_adap); 778 if (adap->fe_adap[0].fe != NULL) 779 return 0; 780 781 return -EIO; 782 } 783 784 static int cxusb_mt352_frontend_attach(struct dvb_usb_adapter *adap) 785 { 786 /* used in both lgz201 and th7579 */ 787 if (usb_set_interface(adap->dev->udev, 0, 0) < 0) 788 err("set interface failed"); 789 790 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0); 791 792 adap->fe_adap[0].fe = dvb_attach(mt352_attach, &cxusb_mt352_config, 793 &adap->dev->i2c_adap); 794 if ((adap->fe_adap[0].fe) != NULL) 795 return 0; 796 797 return -EIO; 798 } 799 800 static int cxusb_dee1601_frontend_attach(struct dvb_usb_adapter *adap) 801 { 802 if (usb_set_interface(adap->dev->udev, 0, 0) < 0) 803 err("set interface failed"); 804 805 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0); 806 807 adap->fe_adap[0].fe = dvb_attach(mt352_attach, &cxusb_dee1601_config, 808 &adap->dev->i2c_adap); 809 if ((adap->fe_adap[0].fe) != NULL) 810 return 0; 811 812 adap->fe_adap[0].fe = dvb_attach(zl10353_attach, 813 &cxusb_zl10353_dee1601_config, 814 &adap->dev->i2c_adap); 815 if ((adap->fe_adap[0].fe) != NULL) 816 return 0; 817 818 return -EIO; 819 } 820 821 static int cxusb_dualdig4_frontend_attach(struct dvb_usb_adapter *adap) 822 { 823 u8 ircode[4]; 824 int i; 825 struct i2c_msg msg = { .addr = 0x6b, .flags = I2C_M_RD, 826 .buf = ircode, .len = 4 }; 827 828 if (usb_set_interface(adap->dev->udev, 0, 1) < 0) 829 err("set interface failed"); 830 831 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0); 832 833 /* reset the tuner and demodulator */ 834 cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0); 835 cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1); 836 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1); 837 838 adap->fe_adap[0].fe = 839 dvb_attach(zl10353_attach, 840 &cxusb_zl10353_xc3028_config_no_i2c_gate, 841 &adap->dev->i2c_adap); 842 if ((adap->fe_adap[0].fe) == NULL) 843 return -EIO; 844 845 /* try to determine if there is no IR decoder on the I2C bus */ 846 for (i = 0; adap->dev->props.rc.core.rc_codes && i < 5; i++) { 847 msleep(20); 848 if (cxusb_i2c_xfer(&adap->dev->i2c_adap, &msg, 1) != 1) 849 goto no_IR; 850 if (ircode[0] == 0 && ircode[1] == 0) 851 continue; 852 if (ircode[2] + ircode[3] != 0xff) { 853 no_IR: 854 adap->dev->props.rc.core.rc_codes = NULL; 855 info("No IR receiver detected on this device."); 856 break; 857 } 858 } 859 860 return 0; 861 } 862 863 static struct dibx000_agc_config dib7070_agc_config = { 864 .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND, 865 866 /* 867 * P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5, 868 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0, 869 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 870 */ 871 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | 872 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0), 873 .inv_gain = 600, 874 .time_stabiliz = 10, 875 .alpha_level = 0, 876 .thlock = 118, 877 .wbd_inv = 0, 878 .wbd_ref = 3530, 879 .wbd_sel = 1, 880 .wbd_alpha = 5, 881 .agc1_max = 65535, 882 .agc1_min = 0, 883 .agc2_max = 65535, 884 .agc2_min = 0, 885 .agc1_pt1 = 0, 886 .agc1_pt2 = 40, 887 .agc1_pt3 = 183, 888 .agc1_slope1 = 206, 889 .agc1_slope2 = 255, 890 .agc2_pt1 = 72, 891 .agc2_pt2 = 152, 892 .agc2_slope1 = 88, 893 .agc2_slope2 = 90, 894 .alpha_mant = 17, 895 .alpha_exp = 27, 896 .beta_mant = 23, 897 .beta_exp = 51, 898 .perform_agc_softsplit = 0, 899 }; 900 901 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = { 902 .internal = 60000, 903 .sampling = 15000, 904 .pll_prediv = 1, 905 .pll_ratio = 20, 906 .pll_range = 3, 907 .pll_reset = 1, 908 .pll_bypass = 0, 909 .enable_refdiv = 0, 910 .bypclk_div = 0, 911 .IO_CLK_en_core = 1, 912 .ADClkSrc = 1, 913 .modulo = 2, 914 /* refsel, sel, freq_15k */ 915 .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0), 916 .ifreq = (0 << 25) | 0, 917 .timf = 20452225, 918 .xtal_hz = 12000000, 919 }; 920 921 static struct dib7000p_config cxusb_dualdig4_rev2_config = { 922 .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK, 923 .output_mpeg2_in_188_bytes = 1, 924 925 .agc_config_count = 1, 926 .agc = &dib7070_agc_config, 927 .bw = &dib7070_bw_config_12_mhz, 928 .tuner_is_baseband = 1, 929 .spur_protect = 1, 930 931 .gpio_dir = 0xfcef, 932 .gpio_val = 0x0110, 933 934 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS, 935 936 .hostbus_diversity = 1, 937 }; 938 939 struct dib0700_adapter_state { 940 int (*set_param_save)(struct dvb_frontend *); 941 struct dib7000p_ops dib7000p_ops; 942 }; 943 944 static int cxusb_dualdig4_rev2_frontend_attach(struct dvb_usb_adapter *adap) 945 { 946 struct dib0700_adapter_state *state = adap->priv; 947 948 if (usb_set_interface(adap->dev->udev, 0, 1) < 0) 949 err("set interface failed"); 950 951 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0); 952 953 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1); 954 955 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops)) 956 return -ENODEV; 957 958 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 959 &cxusb_dualdig4_rev2_config) < 0) { 960 printk(KERN_WARNING "Unable to enumerate dib7000p\n"); 961 return -ENODEV; 962 } 963 964 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80, 965 &cxusb_dualdig4_rev2_config); 966 if (adap->fe_adap[0].fe == NULL) 967 return -EIO; 968 969 return 0; 970 } 971 972 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff) 973 { 974 struct dvb_usb_adapter *adap = fe->dvb->priv; 975 struct dib0700_adapter_state *state = adap->priv; 976 977 return state->dib7000p_ops.set_gpio(fe, 8, 0, !onoff); 978 } 979 980 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff) 981 { 982 return 0; 983 } 984 985 static struct dib0070_config dib7070p_dib0070_config = { 986 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS, 987 .reset = dib7070_tuner_reset, 988 .sleep = dib7070_tuner_sleep, 989 .clock_khz = 12000, 990 }; 991 992 static int dib7070_set_param_override(struct dvb_frontend *fe) 993 { 994 struct dtv_frontend_properties *p = &fe->dtv_property_cache; 995 struct dvb_usb_adapter *adap = fe->dvb->priv; 996 struct dib0700_adapter_state *state = adap->priv; 997 998 u16 offset; 999 u8 band = BAND_OF_FREQUENCY(p->frequency/1000); 1000 switch (band) { 1001 case BAND_VHF: offset = 950; break; 1002 default: 1003 case BAND_UHF: offset = 550; break; 1004 } 1005 1006 state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe)); 1007 1008 return state->set_param_save(fe); 1009 } 1010 1011 static int cxusb_dualdig4_rev2_tuner_attach(struct dvb_usb_adapter *adap) 1012 { 1013 struct dib0700_adapter_state *st = adap->priv; 1014 struct i2c_adapter *tun_i2c; 1015 1016 /* 1017 * No need to call dvb7000p_attach here, as it was called 1018 * already, as frontend_attach method is called first, and 1019 * tuner_attach is only called on sucess. 1020 */ 1021 tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe, 1022 DIBX000_I2C_INTERFACE_TUNER, 1); 1023 1024 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, 1025 &dib7070p_dib0070_config) == NULL) 1026 return -ENODEV; 1027 1028 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params; 1029 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7070_set_param_override; 1030 return 0; 1031 } 1032 1033 static int cxusb_nano2_frontend_attach(struct dvb_usb_adapter *adap) 1034 { 1035 if (usb_set_interface(adap->dev->udev, 0, 1) < 0) 1036 err("set interface failed"); 1037 1038 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0); 1039 1040 /* reset the tuner and demodulator */ 1041 cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0); 1042 cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1); 1043 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1); 1044 1045 adap->fe_adap[0].fe = dvb_attach(zl10353_attach, 1046 &cxusb_zl10353_xc3028_config, 1047 &adap->dev->i2c_adap); 1048 if ((adap->fe_adap[0].fe) != NULL) 1049 return 0; 1050 1051 adap->fe_adap[0].fe = dvb_attach(mt352_attach, 1052 &cxusb_mt352_xc3028_config, 1053 &adap->dev->i2c_adap); 1054 if ((adap->fe_adap[0].fe) != NULL) 1055 return 0; 1056 1057 return -EIO; 1058 } 1059 1060 static struct lgs8gxx_config d680_lgs8gl5_cfg = { 1061 .prod = LGS8GXX_PROD_LGS8GL5, 1062 .demod_address = 0x19, 1063 .serial_ts = 0, 1064 .ts_clk_pol = 0, 1065 .ts_clk_gated = 1, 1066 .if_clk_freq = 30400, /* 30.4 MHz */ 1067 .if_freq = 5725, /* 5.725 MHz */ 1068 .if_neg_center = 0, 1069 .ext_adc = 0, 1070 .adc_signed = 0, 1071 .if_neg_edge = 0, 1072 }; 1073 1074 static int cxusb_d680_dmb_frontend_attach(struct dvb_usb_adapter *adap) 1075 { 1076 struct dvb_usb_device *d = adap->dev; 1077 int n; 1078 1079 /* Select required USB configuration */ 1080 if (usb_set_interface(d->udev, 0, 0) < 0) 1081 err("set interface failed"); 1082 1083 /* Unblock all USB pipes */ 1084 usb_clear_halt(d->udev, 1085 usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint)); 1086 usb_clear_halt(d->udev, 1087 usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint)); 1088 usb_clear_halt(d->udev, 1089 usb_rcvbulkpipe(d->udev, d->props.adapter[0].fe[0].stream.endpoint)); 1090 1091 /* Drain USB pipes to avoid hang after reboot */ 1092 for (n = 0; n < 5; n++) { 1093 cxusb_d680_dmb_drain_message(d); 1094 cxusb_d680_dmb_drain_video(d); 1095 msleep(200); 1096 } 1097 1098 /* Reset the tuner */ 1099 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) { 1100 err("clear tuner gpio failed"); 1101 return -EIO; 1102 } 1103 msleep(100); 1104 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) { 1105 err("set tuner gpio failed"); 1106 return -EIO; 1107 } 1108 msleep(100); 1109 1110 /* Attach frontend */ 1111 adap->fe_adap[0].fe = dvb_attach(lgs8gxx_attach, &d680_lgs8gl5_cfg, &d->i2c_adap); 1112 if (adap->fe_adap[0].fe == NULL) 1113 return -EIO; 1114 1115 return 0; 1116 } 1117 1118 static struct atbm8830_config mygica_d689_atbm8830_cfg = { 1119 .prod = ATBM8830_PROD_8830, 1120 .demod_address = 0x40, 1121 .serial_ts = 0, 1122 .ts_sampling_edge = 1, 1123 .ts_clk_gated = 0, 1124 .osc_clk_freq = 30400, /* in kHz */ 1125 .if_freq = 0, /* zero IF */ 1126 .zif_swap_iq = 1, 1127 .agc_min = 0x2E, 1128 .agc_max = 0x90, 1129 .agc_hold_loop = 0, 1130 }; 1131 1132 static int cxusb_mygica_d689_frontend_attach(struct dvb_usb_adapter *adap) 1133 { 1134 struct dvb_usb_device *d = adap->dev; 1135 1136 /* Select required USB configuration */ 1137 if (usb_set_interface(d->udev, 0, 0) < 0) 1138 err("set interface failed"); 1139 1140 /* Unblock all USB pipes */ 1141 usb_clear_halt(d->udev, 1142 usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint)); 1143 usb_clear_halt(d->udev, 1144 usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint)); 1145 usb_clear_halt(d->udev, 1146 usb_rcvbulkpipe(d->udev, d->props.adapter[0].fe[0].stream.endpoint)); 1147 1148 1149 /* Reset the tuner */ 1150 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) { 1151 err("clear tuner gpio failed"); 1152 return -EIO; 1153 } 1154 msleep(100); 1155 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) { 1156 err("set tuner gpio failed"); 1157 return -EIO; 1158 } 1159 msleep(100); 1160 1161 /* Attach frontend */ 1162 adap->fe_adap[0].fe = dvb_attach(atbm8830_attach, &mygica_d689_atbm8830_cfg, 1163 &d->i2c_adap); 1164 if (adap->fe_adap[0].fe == NULL) 1165 return -EIO; 1166 1167 return 0; 1168 } 1169 1170 static int cxusb_mygica_t230_frontend_attach(struct dvb_usb_adapter *adap) 1171 { 1172 struct dvb_usb_device *d = adap->dev; 1173 struct cxusb_state *st = d->priv; 1174 struct i2c_adapter *adapter; 1175 struct i2c_client *client_demod; 1176 struct i2c_client *client_tuner; 1177 struct i2c_board_info info; 1178 struct si2168_config si2168_config; 1179 struct si2157_config si2157_config; 1180 1181 /* Select required USB configuration */ 1182 if (usb_set_interface(d->udev, 0, 0) < 0) 1183 err("set interface failed"); 1184 1185 /* Unblock all USB pipes */ 1186 usb_clear_halt(d->udev, 1187 usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint)); 1188 usb_clear_halt(d->udev, 1189 usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint)); 1190 usb_clear_halt(d->udev, 1191 usb_rcvbulkpipe(d->udev, d->props.adapter[0].fe[0].stream.endpoint)); 1192 1193 /* attach frontend */ 1194 si2168_config.i2c_adapter = &adapter; 1195 si2168_config.fe = &adap->fe_adap[0].fe; 1196 si2168_config.ts_mode = SI2168_TS_PARALLEL; 1197 si2168_config.ts_clock_inv = 1; 1198 memset(&info, 0, sizeof(struct i2c_board_info)); 1199 strlcpy(info.type, "si2168", I2C_NAME_SIZE); 1200 info.addr = 0x64; 1201 info.platform_data = &si2168_config; 1202 request_module(info.type); 1203 client_demod = i2c_new_device(&d->i2c_adap, &info); 1204 if (client_demod == NULL || client_demod->dev.driver == NULL) 1205 return -ENODEV; 1206 1207 if (!try_module_get(client_demod->dev.driver->owner)) { 1208 i2c_unregister_device(client_demod); 1209 return -ENODEV; 1210 } 1211 1212 st->i2c_client_demod = client_demod; 1213 1214 /* attach tuner */ 1215 memset(&si2157_config, 0, sizeof(si2157_config)); 1216 si2157_config.fe = adap->fe_adap[0].fe; 1217 si2157_config.if_port = 1; 1218 memset(&info, 0, sizeof(struct i2c_board_info)); 1219 strlcpy(info.type, "si2157", I2C_NAME_SIZE); 1220 info.addr = 0x60; 1221 info.platform_data = &si2157_config; 1222 request_module(info.type); 1223 client_tuner = i2c_new_device(adapter, &info); 1224 if (client_tuner == NULL || client_tuner->dev.driver == NULL) { 1225 module_put(client_demod->dev.driver->owner); 1226 i2c_unregister_device(client_demod); 1227 return -ENODEV; 1228 } 1229 if (!try_module_get(client_tuner->dev.driver->owner)) { 1230 i2c_unregister_device(client_tuner); 1231 module_put(client_demod->dev.driver->owner); 1232 i2c_unregister_device(client_demod); 1233 return -ENODEV; 1234 } 1235 1236 st->i2c_client_tuner = client_tuner; 1237 1238 /* hook fe: need to resync the slave fifo when signal locks. */ 1239 mutex_init(&st->stream_mutex); 1240 st->last_lock = 0; 1241 st->fe_read_status = adap->fe_adap[0].fe->ops.read_status; 1242 adap->fe_adap[0].fe->ops.read_status = cxusb_read_status; 1243 1244 return 0; 1245 } 1246 1247 /* 1248 * DViCO has shipped two devices with the same USB ID, but only one of them 1249 * needs a firmware download. Check the device class details to see if they 1250 * have non-default values to decide whether the device is actually cold or 1251 * not, and forget a match if it turns out we selected the wrong device. 1252 */ 1253 static int bluebird_fx2_identify_state(struct usb_device *udev, 1254 struct dvb_usb_device_properties *props, 1255 struct dvb_usb_device_description **desc, 1256 int *cold) 1257 { 1258 int wascold = *cold; 1259 1260 *cold = udev->descriptor.bDeviceClass == 0xff && 1261 udev->descriptor.bDeviceSubClass == 0xff && 1262 udev->descriptor.bDeviceProtocol == 0xff; 1263 1264 if (*cold && !wascold) 1265 *desc = NULL; 1266 1267 return 0; 1268 } 1269 1270 /* 1271 * DViCO bluebird firmware needs the "warm" product ID to be patched into the 1272 * firmware file before download. 1273 */ 1274 1275 static const int dvico_firmware_id_offsets[] = { 6638, 3204 }; 1276 static int bluebird_patch_dvico_firmware_download(struct usb_device *udev, 1277 const struct firmware *fw) 1278 { 1279 int pos; 1280 1281 for (pos = 0; pos < ARRAY_SIZE(dvico_firmware_id_offsets); pos++) { 1282 int idoff = dvico_firmware_id_offsets[pos]; 1283 1284 if (fw->size < idoff + 4) 1285 continue; 1286 1287 if (fw->data[idoff] == (USB_VID_DVICO & 0xff) && 1288 fw->data[idoff + 1] == USB_VID_DVICO >> 8) { 1289 struct firmware new_fw; 1290 u8 *new_fw_data = vmalloc(fw->size); 1291 int ret; 1292 1293 if (!new_fw_data) 1294 return -ENOMEM; 1295 1296 memcpy(new_fw_data, fw->data, fw->size); 1297 new_fw.size = fw->size; 1298 new_fw.data = new_fw_data; 1299 1300 new_fw_data[idoff + 2] = 1301 le16_to_cpu(udev->descriptor.idProduct) + 1; 1302 new_fw_data[idoff + 3] = 1303 le16_to_cpu(udev->descriptor.idProduct) >> 8; 1304 1305 ret = usb_cypress_load_firmware(udev, &new_fw, 1306 CYPRESS_FX2); 1307 vfree(new_fw_data); 1308 return ret; 1309 } 1310 } 1311 1312 return -EINVAL; 1313 } 1314 1315 /* DVB USB Driver stuff */ 1316 static struct dvb_usb_device_properties cxusb_medion_properties; 1317 static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties; 1318 static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties; 1319 static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties; 1320 static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties; 1321 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties; 1322 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties; 1323 static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties; 1324 static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties; 1325 static struct dvb_usb_device_properties cxusb_aver_a868r_properties; 1326 static struct dvb_usb_device_properties cxusb_d680_dmb_properties; 1327 static struct dvb_usb_device_properties cxusb_mygica_d689_properties; 1328 static struct dvb_usb_device_properties cxusb_mygica_t230_properties; 1329 1330 static int cxusb_probe(struct usb_interface *intf, 1331 const struct usb_device_id *id) 1332 { 1333 if (0 == dvb_usb_device_init(intf, &cxusb_medion_properties, 1334 THIS_MODULE, NULL, adapter_nr) || 1335 0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgh064f_properties, 1336 THIS_MODULE, NULL, adapter_nr) || 1337 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dee1601_properties, 1338 THIS_MODULE, NULL, adapter_nr) || 1339 0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgz201_properties, 1340 THIS_MODULE, NULL, adapter_nr) || 1341 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dtt7579_properties, 1342 THIS_MODULE, NULL, adapter_nr) || 1343 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dualdig4_properties, 1344 THIS_MODULE, NULL, adapter_nr) || 1345 0 == dvb_usb_device_init(intf, &cxusb_bluebird_nano2_properties, 1346 THIS_MODULE, NULL, adapter_nr) || 1347 0 == dvb_usb_device_init(intf, 1348 &cxusb_bluebird_nano2_needsfirmware_properties, 1349 THIS_MODULE, NULL, adapter_nr) || 1350 0 == dvb_usb_device_init(intf, &cxusb_aver_a868r_properties, 1351 THIS_MODULE, NULL, adapter_nr) || 1352 0 == dvb_usb_device_init(intf, 1353 &cxusb_bluebird_dualdig4_rev2_properties, 1354 THIS_MODULE, NULL, adapter_nr) || 1355 0 == dvb_usb_device_init(intf, &cxusb_d680_dmb_properties, 1356 THIS_MODULE, NULL, adapter_nr) || 1357 0 == dvb_usb_device_init(intf, &cxusb_mygica_d689_properties, 1358 THIS_MODULE, NULL, adapter_nr) || 1359 0 == dvb_usb_device_init(intf, &cxusb_mygica_t230_properties, 1360 THIS_MODULE, NULL, adapter_nr) || 1361 0) 1362 return 0; 1363 1364 return -EINVAL; 1365 } 1366 1367 static void cxusb_disconnect(struct usb_interface *intf) 1368 { 1369 struct dvb_usb_device *d = usb_get_intfdata(intf); 1370 struct cxusb_state *st = d->priv; 1371 struct i2c_client *client; 1372 1373 /* remove I2C client for tuner */ 1374 client = st->i2c_client_tuner; 1375 if (client) { 1376 module_put(client->dev.driver->owner); 1377 i2c_unregister_device(client); 1378 } 1379 1380 /* remove I2C client for demodulator */ 1381 client = st->i2c_client_demod; 1382 if (client) { 1383 module_put(client->dev.driver->owner); 1384 i2c_unregister_device(client); 1385 } 1386 1387 dvb_usb_device_exit(intf); 1388 } 1389 1390 enum cxusb_table_index { 1391 MEDION_MD95700, 1392 DVICO_BLUEBIRD_LG064F_COLD, 1393 DVICO_BLUEBIRD_LG064F_WARM, 1394 DVICO_BLUEBIRD_DUAL_1_COLD, 1395 DVICO_BLUEBIRD_DUAL_1_WARM, 1396 DVICO_BLUEBIRD_LGZ201_COLD, 1397 DVICO_BLUEBIRD_LGZ201_WARM, 1398 DVICO_BLUEBIRD_TH7579_COLD, 1399 DVICO_BLUEBIRD_TH7579_WARM, 1400 DIGITALNOW_BLUEBIRD_DUAL_1_COLD, 1401 DIGITALNOW_BLUEBIRD_DUAL_1_WARM, 1402 DVICO_BLUEBIRD_DUAL_2_COLD, 1403 DVICO_BLUEBIRD_DUAL_2_WARM, 1404 DVICO_BLUEBIRD_DUAL_4, 1405 DVICO_BLUEBIRD_DVB_T_NANO_2, 1406 DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM, 1407 AVERMEDIA_VOLAR_A868R, 1408 DVICO_BLUEBIRD_DUAL_4_REV_2, 1409 CONEXANT_D680_DMB, 1410 MYGICA_D689, 1411 MYGICA_T230, 1412 NR__cxusb_table_index 1413 }; 1414 1415 static struct usb_device_id cxusb_table[NR__cxusb_table_index + 1] = { 1416 [MEDION_MD95700] = { 1417 USB_DEVICE(USB_VID_MEDION, USB_PID_MEDION_MD95700) 1418 }, 1419 [DVICO_BLUEBIRD_LG064F_COLD] = { 1420 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_COLD) 1421 }, 1422 [DVICO_BLUEBIRD_LG064F_WARM] = { 1423 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_WARM) 1424 }, 1425 [DVICO_BLUEBIRD_DUAL_1_COLD] = { 1426 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_COLD) 1427 }, 1428 [DVICO_BLUEBIRD_DUAL_1_WARM] = { 1429 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_WARM) 1430 }, 1431 [DVICO_BLUEBIRD_LGZ201_COLD] = { 1432 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_COLD) 1433 }, 1434 [DVICO_BLUEBIRD_LGZ201_WARM] = { 1435 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_WARM) 1436 }, 1437 [DVICO_BLUEBIRD_TH7579_COLD] = { 1438 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_COLD) 1439 }, 1440 [DVICO_BLUEBIRD_TH7579_WARM] = { 1441 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_WARM) 1442 }, 1443 [DIGITALNOW_BLUEBIRD_DUAL_1_COLD] = { 1444 USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_COLD) 1445 }, 1446 [DIGITALNOW_BLUEBIRD_DUAL_1_WARM] = { 1447 USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_WARM) 1448 }, 1449 [DVICO_BLUEBIRD_DUAL_2_COLD] = { 1450 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_COLD) 1451 }, 1452 [DVICO_BLUEBIRD_DUAL_2_WARM] = { 1453 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_WARM) 1454 }, 1455 [DVICO_BLUEBIRD_DUAL_4] = { 1456 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4) 1457 }, 1458 [DVICO_BLUEBIRD_DVB_T_NANO_2] = { 1459 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2) 1460 }, 1461 [DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM] = { 1462 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM) 1463 }, 1464 [AVERMEDIA_VOLAR_A868R] = { 1465 USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_A868R) 1466 }, 1467 [DVICO_BLUEBIRD_DUAL_4_REV_2] = { 1468 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4_REV_2) 1469 }, 1470 [CONEXANT_D680_DMB] = { 1471 USB_DEVICE(USB_VID_CONEXANT, USB_PID_CONEXANT_D680_DMB) 1472 }, 1473 [MYGICA_D689] = { 1474 USB_DEVICE(USB_VID_CONEXANT, USB_PID_MYGICA_D689) 1475 }, 1476 [MYGICA_T230] = { 1477 USB_DEVICE(USB_VID_CONEXANT, USB_PID_MYGICA_T230) 1478 }, 1479 {} /* Terminating entry */ 1480 }; 1481 MODULE_DEVICE_TABLE (usb, cxusb_table); 1482 1483 static struct dvb_usb_device_properties cxusb_medion_properties = { 1484 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1485 1486 .usb_ctrl = CYPRESS_FX2, 1487 1488 .size_of_priv = sizeof(struct cxusb_state), 1489 1490 .num_adapters = 1, 1491 .adapter = { 1492 { 1493 .num_frontends = 1, 1494 .fe = {{ 1495 .streaming_ctrl = cxusb_streaming_ctrl, 1496 .frontend_attach = cxusb_cx22702_frontend_attach, 1497 .tuner_attach = cxusb_fmd1216me_tuner_attach, 1498 /* parameter for the MPEG2-data transfer */ 1499 .stream = { 1500 .type = USB_BULK, 1501 .count = 5, 1502 .endpoint = 0x02, 1503 .u = { 1504 .bulk = { 1505 .buffersize = 8192, 1506 } 1507 } 1508 }, 1509 }}, 1510 }, 1511 }, 1512 .power_ctrl = cxusb_power_ctrl, 1513 1514 .i2c_algo = &cxusb_i2c_algo, 1515 1516 .generic_bulk_ctrl_endpoint = 0x01, 1517 1518 .num_device_descs = 1, 1519 .devices = { 1520 { "Medion MD95700 (MDUSBTV-HYBRID)", 1521 { NULL }, 1522 { &cxusb_table[MEDION_MD95700], NULL }, 1523 }, 1524 } 1525 }; 1526 1527 static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties = { 1528 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1529 1530 .usb_ctrl = DEVICE_SPECIFIC, 1531 .firmware = "dvb-usb-bluebird-01.fw", 1532 .download_firmware = bluebird_patch_dvico_firmware_download, 1533 /* use usb alt setting 0 for EP4 transfer (dvb-t), 1534 use usb alt setting 7 for EP2 transfer (atsc) */ 1535 1536 .size_of_priv = sizeof(struct cxusb_state), 1537 1538 .num_adapters = 1, 1539 .adapter = { 1540 { 1541 .num_frontends = 1, 1542 .fe = {{ 1543 .streaming_ctrl = cxusb_streaming_ctrl, 1544 .frontend_attach = cxusb_lgdt3303_frontend_attach, 1545 .tuner_attach = cxusb_lgh064f_tuner_attach, 1546 1547 /* parameter for the MPEG2-data transfer */ 1548 .stream = { 1549 .type = USB_BULK, 1550 .count = 5, 1551 .endpoint = 0x02, 1552 .u = { 1553 .bulk = { 1554 .buffersize = 8192, 1555 } 1556 } 1557 }, 1558 }}, 1559 }, 1560 }, 1561 1562 .power_ctrl = cxusb_bluebird_power_ctrl, 1563 1564 .i2c_algo = &cxusb_i2c_algo, 1565 1566 .rc.core = { 1567 .rc_interval = 100, 1568 .rc_codes = RC_MAP_DVICO_PORTABLE, 1569 .module_name = KBUILD_MODNAME, 1570 .rc_query = cxusb_rc_query, 1571 .allowed_protos = RC_PROTO_BIT_NEC, 1572 }, 1573 1574 .generic_bulk_ctrl_endpoint = 0x01, 1575 1576 .num_device_descs = 1, 1577 .devices = { 1578 { "DViCO FusionHDTV5 USB Gold", 1579 { &cxusb_table[DVICO_BLUEBIRD_LG064F_COLD], NULL }, 1580 { &cxusb_table[DVICO_BLUEBIRD_LG064F_WARM], NULL }, 1581 }, 1582 } 1583 }; 1584 1585 static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties = { 1586 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1587 1588 .usb_ctrl = DEVICE_SPECIFIC, 1589 .firmware = "dvb-usb-bluebird-01.fw", 1590 .download_firmware = bluebird_patch_dvico_firmware_download, 1591 /* use usb alt setting 0 for EP4 transfer (dvb-t), 1592 use usb alt setting 7 for EP2 transfer (atsc) */ 1593 1594 .size_of_priv = sizeof(struct cxusb_state), 1595 1596 .num_adapters = 1, 1597 .adapter = { 1598 { 1599 .num_frontends = 1, 1600 .fe = {{ 1601 .streaming_ctrl = cxusb_streaming_ctrl, 1602 .frontend_attach = cxusb_dee1601_frontend_attach, 1603 .tuner_attach = cxusb_dee1601_tuner_attach, 1604 /* parameter for the MPEG2-data transfer */ 1605 .stream = { 1606 .type = USB_BULK, 1607 .count = 5, 1608 .endpoint = 0x04, 1609 .u = { 1610 .bulk = { 1611 .buffersize = 8192, 1612 } 1613 } 1614 }, 1615 }}, 1616 }, 1617 }, 1618 1619 .power_ctrl = cxusb_bluebird_power_ctrl, 1620 1621 .i2c_algo = &cxusb_i2c_algo, 1622 1623 .rc.core = { 1624 .rc_interval = 100, 1625 .rc_codes = RC_MAP_DVICO_MCE, 1626 .module_name = KBUILD_MODNAME, 1627 .rc_query = cxusb_rc_query, 1628 .allowed_protos = RC_PROTO_BIT_NEC, 1629 }, 1630 1631 .generic_bulk_ctrl_endpoint = 0x01, 1632 1633 .num_device_descs = 3, 1634 .devices = { 1635 { "DViCO FusionHDTV DVB-T Dual USB", 1636 { &cxusb_table[DVICO_BLUEBIRD_DUAL_1_COLD], NULL }, 1637 { &cxusb_table[DVICO_BLUEBIRD_DUAL_1_WARM], NULL }, 1638 }, 1639 { "DigitalNow DVB-T Dual USB", 1640 { &cxusb_table[DIGITALNOW_BLUEBIRD_DUAL_1_COLD], NULL }, 1641 { &cxusb_table[DIGITALNOW_BLUEBIRD_DUAL_1_WARM], NULL }, 1642 }, 1643 { "DViCO FusionHDTV DVB-T Dual Digital 2", 1644 { &cxusb_table[DVICO_BLUEBIRD_DUAL_2_COLD], NULL }, 1645 { &cxusb_table[DVICO_BLUEBIRD_DUAL_2_WARM], NULL }, 1646 }, 1647 } 1648 }; 1649 1650 static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties = { 1651 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1652 1653 .usb_ctrl = DEVICE_SPECIFIC, 1654 .firmware = "dvb-usb-bluebird-01.fw", 1655 .download_firmware = bluebird_patch_dvico_firmware_download, 1656 /* use usb alt setting 0 for EP4 transfer (dvb-t), 1657 use usb alt setting 7 for EP2 transfer (atsc) */ 1658 1659 .size_of_priv = sizeof(struct cxusb_state), 1660 1661 .num_adapters = 2, 1662 .adapter = { 1663 { 1664 .num_frontends = 1, 1665 .fe = {{ 1666 .streaming_ctrl = cxusb_streaming_ctrl, 1667 .frontend_attach = cxusb_mt352_frontend_attach, 1668 .tuner_attach = cxusb_lgz201_tuner_attach, 1669 1670 /* parameter for the MPEG2-data transfer */ 1671 .stream = { 1672 .type = USB_BULK, 1673 .count = 5, 1674 .endpoint = 0x04, 1675 .u = { 1676 .bulk = { 1677 .buffersize = 8192, 1678 } 1679 } 1680 }, 1681 }}, 1682 }, 1683 }, 1684 .power_ctrl = cxusb_bluebird_power_ctrl, 1685 1686 .i2c_algo = &cxusb_i2c_algo, 1687 1688 .rc.core = { 1689 .rc_interval = 100, 1690 .rc_codes = RC_MAP_DVICO_PORTABLE, 1691 .module_name = KBUILD_MODNAME, 1692 .rc_query = cxusb_rc_query, 1693 .allowed_protos = RC_PROTO_BIT_NEC, 1694 }, 1695 1696 .generic_bulk_ctrl_endpoint = 0x01, 1697 .num_device_descs = 1, 1698 .devices = { 1699 { "DViCO FusionHDTV DVB-T USB (LGZ201)", 1700 { &cxusb_table[DVICO_BLUEBIRD_LGZ201_COLD], NULL }, 1701 { &cxusb_table[DVICO_BLUEBIRD_LGZ201_WARM], NULL }, 1702 }, 1703 } 1704 }; 1705 1706 static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties = { 1707 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1708 1709 .usb_ctrl = DEVICE_SPECIFIC, 1710 .firmware = "dvb-usb-bluebird-01.fw", 1711 .download_firmware = bluebird_patch_dvico_firmware_download, 1712 /* use usb alt setting 0 for EP4 transfer (dvb-t), 1713 use usb alt setting 7 for EP2 transfer (atsc) */ 1714 1715 .size_of_priv = sizeof(struct cxusb_state), 1716 1717 .num_adapters = 1, 1718 .adapter = { 1719 { 1720 .num_frontends = 1, 1721 .fe = {{ 1722 .streaming_ctrl = cxusb_streaming_ctrl, 1723 .frontend_attach = cxusb_mt352_frontend_attach, 1724 .tuner_attach = cxusb_dtt7579_tuner_attach, 1725 1726 /* parameter for the MPEG2-data transfer */ 1727 .stream = { 1728 .type = USB_BULK, 1729 .count = 5, 1730 .endpoint = 0x04, 1731 .u = { 1732 .bulk = { 1733 .buffersize = 8192, 1734 } 1735 } 1736 }, 1737 }}, 1738 }, 1739 }, 1740 .power_ctrl = cxusb_bluebird_power_ctrl, 1741 1742 .i2c_algo = &cxusb_i2c_algo, 1743 1744 .rc.core = { 1745 .rc_interval = 100, 1746 .rc_codes = RC_MAP_DVICO_PORTABLE, 1747 .module_name = KBUILD_MODNAME, 1748 .rc_query = cxusb_rc_query, 1749 .allowed_protos = RC_PROTO_BIT_NEC, 1750 }, 1751 1752 .generic_bulk_ctrl_endpoint = 0x01, 1753 1754 .num_device_descs = 1, 1755 .devices = { 1756 { "DViCO FusionHDTV DVB-T USB (TH7579)", 1757 { &cxusb_table[DVICO_BLUEBIRD_TH7579_COLD], NULL }, 1758 { &cxusb_table[DVICO_BLUEBIRD_TH7579_WARM], NULL }, 1759 }, 1760 } 1761 }; 1762 1763 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties = { 1764 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1765 1766 .usb_ctrl = CYPRESS_FX2, 1767 1768 .size_of_priv = sizeof(struct cxusb_state), 1769 1770 .num_adapters = 1, 1771 .adapter = { 1772 { 1773 .num_frontends = 1, 1774 .fe = {{ 1775 .streaming_ctrl = cxusb_streaming_ctrl, 1776 .frontend_attach = cxusb_dualdig4_frontend_attach, 1777 .tuner_attach = cxusb_dvico_xc3028_tuner_attach, 1778 /* parameter for the MPEG2-data transfer */ 1779 .stream = { 1780 .type = USB_BULK, 1781 .count = 5, 1782 .endpoint = 0x02, 1783 .u = { 1784 .bulk = { 1785 .buffersize = 8192, 1786 } 1787 } 1788 }, 1789 }}, 1790 }, 1791 }, 1792 1793 .power_ctrl = cxusb_power_ctrl, 1794 1795 .i2c_algo = &cxusb_i2c_algo, 1796 1797 .generic_bulk_ctrl_endpoint = 0x01, 1798 1799 .rc.core = { 1800 .rc_interval = 100, 1801 .rc_codes = RC_MAP_DVICO_MCE, 1802 .module_name = KBUILD_MODNAME, 1803 .rc_query = cxusb_bluebird2_rc_query, 1804 .allowed_protos = RC_PROTO_BIT_NEC, 1805 }, 1806 1807 .num_device_descs = 1, 1808 .devices = { 1809 { "DViCO FusionHDTV DVB-T Dual Digital 4", 1810 { NULL }, 1811 { &cxusb_table[DVICO_BLUEBIRD_DUAL_4], NULL }, 1812 }, 1813 } 1814 }; 1815 1816 static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties = { 1817 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1818 1819 .usb_ctrl = CYPRESS_FX2, 1820 .identify_state = bluebird_fx2_identify_state, 1821 1822 .size_of_priv = sizeof(struct cxusb_state), 1823 1824 .num_adapters = 1, 1825 .adapter = { 1826 { 1827 .num_frontends = 1, 1828 .fe = {{ 1829 .streaming_ctrl = cxusb_streaming_ctrl, 1830 .frontend_attach = cxusb_nano2_frontend_attach, 1831 .tuner_attach = cxusb_dvico_xc3028_tuner_attach, 1832 /* parameter for the MPEG2-data transfer */ 1833 .stream = { 1834 .type = USB_BULK, 1835 .count = 5, 1836 .endpoint = 0x02, 1837 .u = { 1838 .bulk = { 1839 .buffersize = 8192, 1840 } 1841 } 1842 }, 1843 }}, 1844 }, 1845 }, 1846 1847 .power_ctrl = cxusb_nano2_power_ctrl, 1848 1849 .i2c_algo = &cxusb_i2c_algo, 1850 1851 .generic_bulk_ctrl_endpoint = 0x01, 1852 1853 .rc.core = { 1854 .rc_interval = 100, 1855 .rc_codes = RC_MAP_DVICO_PORTABLE, 1856 .module_name = KBUILD_MODNAME, 1857 .rc_query = cxusb_bluebird2_rc_query, 1858 .allowed_protos = RC_PROTO_BIT_NEC, 1859 }, 1860 1861 .num_device_descs = 1, 1862 .devices = { 1863 { "DViCO FusionHDTV DVB-T NANO2", 1864 { NULL }, 1865 { &cxusb_table[DVICO_BLUEBIRD_DVB_T_NANO_2], NULL }, 1866 }, 1867 } 1868 }; 1869 1870 static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties = { 1871 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1872 1873 .usb_ctrl = DEVICE_SPECIFIC, 1874 .firmware = "dvb-usb-bluebird-02.fw", 1875 .download_firmware = bluebird_patch_dvico_firmware_download, 1876 .identify_state = bluebird_fx2_identify_state, 1877 1878 .size_of_priv = sizeof(struct cxusb_state), 1879 1880 .num_adapters = 1, 1881 .adapter = { 1882 { 1883 .num_frontends = 1, 1884 .fe = {{ 1885 .streaming_ctrl = cxusb_streaming_ctrl, 1886 .frontend_attach = cxusb_nano2_frontend_attach, 1887 .tuner_attach = cxusb_dvico_xc3028_tuner_attach, 1888 /* parameter for the MPEG2-data transfer */ 1889 .stream = { 1890 .type = USB_BULK, 1891 .count = 5, 1892 .endpoint = 0x02, 1893 .u = { 1894 .bulk = { 1895 .buffersize = 8192, 1896 } 1897 } 1898 }, 1899 }}, 1900 }, 1901 }, 1902 1903 .power_ctrl = cxusb_nano2_power_ctrl, 1904 1905 .i2c_algo = &cxusb_i2c_algo, 1906 1907 .generic_bulk_ctrl_endpoint = 0x01, 1908 1909 .rc.core = { 1910 .rc_interval = 100, 1911 .rc_codes = RC_MAP_DVICO_PORTABLE, 1912 .module_name = KBUILD_MODNAME, 1913 .rc_query = cxusb_rc_query, 1914 .allowed_protos = RC_PROTO_BIT_NEC, 1915 }, 1916 1917 .num_device_descs = 1, 1918 .devices = { 1919 { "DViCO FusionHDTV DVB-T NANO2 w/o firmware", 1920 { &cxusb_table[DVICO_BLUEBIRD_DVB_T_NANO_2], NULL }, 1921 { &cxusb_table[DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM], NULL }, 1922 }, 1923 } 1924 }; 1925 1926 static struct dvb_usb_device_properties cxusb_aver_a868r_properties = { 1927 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1928 1929 .usb_ctrl = CYPRESS_FX2, 1930 1931 .size_of_priv = sizeof(struct cxusb_state), 1932 1933 .num_adapters = 1, 1934 .adapter = { 1935 { 1936 .num_frontends = 1, 1937 .fe = {{ 1938 .streaming_ctrl = cxusb_aver_streaming_ctrl, 1939 .frontend_attach = cxusb_aver_lgdt3303_frontend_attach, 1940 .tuner_attach = cxusb_mxl5003s_tuner_attach, 1941 /* parameter for the MPEG2-data transfer */ 1942 .stream = { 1943 .type = USB_BULK, 1944 .count = 5, 1945 .endpoint = 0x04, 1946 .u = { 1947 .bulk = { 1948 .buffersize = 8192, 1949 } 1950 } 1951 }, 1952 }}, 1953 }, 1954 }, 1955 .power_ctrl = cxusb_aver_power_ctrl, 1956 1957 .i2c_algo = &cxusb_i2c_algo, 1958 1959 .generic_bulk_ctrl_endpoint = 0x01, 1960 1961 .num_device_descs = 1, 1962 .devices = { 1963 { "AVerMedia AVerTVHD Volar (A868R)", 1964 { NULL }, 1965 { &cxusb_table[AVERMEDIA_VOLAR_A868R], NULL }, 1966 }, 1967 } 1968 }; 1969 1970 static 1971 struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties = { 1972 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1973 1974 .usb_ctrl = CYPRESS_FX2, 1975 1976 .size_of_priv = sizeof(struct cxusb_state), 1977 1978 .num_adapters = 1, 1979 .adapter = { 1980 { 1981 .size_of_priv = sizeof(struct dib0700_adapter_state), 1982 .num_frontends = 1, 1983 .fe = {{ 1984 .streaming_ctrl = cxusb_streaming_ctrl, 1985 .frontend_attach = cxusb_dualdig4_rev2_frontend_attach, 1986 .tuner_attach = cxusb_dualdig4_rev2_tuner_attach, 1987 /* parameter for the MPEG2-data transfer */ 1988 .stream = { 1989 .type = USB_BULK, 1990 .count = 7, 1991 .endpoint = 0x02, 1992 .u = { 1993 .bulk = { 1994 .buffersize = 4096, 1995 } 1996 } 1997 }, 1998 }}, 1999 }, 2000 }, 2001 2002 .power_ctrl = cxusb_bluebird_power_ctrl, 2003 2004 .i2c_algo = &cxusb_i2c_algo, 2005 2006 .generic_bulk_ctrl_endpoint = 0x01, 2007 2008 .rc.core = { 2009 .rc_interval = 100, 2010 .rc_codes = RC_MAP_DVICO_MCE, 2011 .module_name = KBUILD_MODNAME, 2012 .rc_query = cxusb_rc_query, 2013 .allowed_protos = RC_PROTO_BIT_NEC, 2014 }, 2015 2016 .num_device_descs = 1, 2017 .devices = { 2018 { "DViCO FusionHDTV DVB-T Dual Digital 4 (rev 2)", 2019 { NULL }, 2020 { &cxusb_table[DVICO_BLUEBIRD_DUAL_4_REV_2], NULL }, 2021 }, 2022 } 2023 }; 2024 2025 static struct dvb_usb_device_properties cxusb_d680_dmb_properties = { 2026 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 2027 2028 .usb_ctrl = CYPRESS_FX2, 2029 2030 .size_of_priv = sizeof(struct cxusb_state), 2031 2032 .num_adapters = 1, 2033 .adapter = { 2034 { 2035 .num_frontends = 1, 2036 .fe = {{ 2037 .streaming_ctrl = cxusb_d680_dmb_streaming_ctrl, 2038 .frontend_attach = cxusb_d680_dmb_frontend_attach, 2039 .tuner_attach = cxusb_d680_dmb_tuner_attach, 2040 2041 /* parameter for the MPEG2-data transfer */ 2042 .stream = { 2043 .type = USB_BULK, 2044 .count = 5, 2045 .endpoint = 0x02, 2046 .u = { 2047 .bulk = { 2048 .buffersize = 8192, 2049 } 2050 } 2051 }, 2052 }}, 2053 }, 2054 }, 2055 2056 .power_ctrl = cxusb_d680_dmb_power_ctrl, 2057 2058 .i2c_algo = &cxusb_i2c_algo, 2059 2060 .generic_bulk_ctrl_endpoint = 0x01, 2061 2062 .rc.core = { 2063 .rc_interval = 100, 2064 .rc_codes = RC_MAP_TOTAL_MEDIA_IN_HAND_02, 2065 .module_name = KBUILD_MODNAME, 2066 .rc_query = cxusb_d680_dmb_rc_query, 2067 .allowed_protos = RC_PROTO_BIT_UNKNOWN, 2068 }, 2069 2070 .num_device_descs = 1, 2071 .devices = { 2072 { 2073 "Conexant DMB-TH Stick", 2074 { NULL }, 2075 { &cxusb_table[CONEXANT_D680_DMB], NULL }, 2076 }, 2077 } 2078 }; 2079 2080 static struct dvb_usb_device_properties cxusb_mygica_d689_properties = { 2081 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 2082 2083 .usb_ctrl = CYPRESS_FX2, 2084 2085 .size_of_priv = sizeof(struct cxusb_state), 2086 2087 .num_adapters = 1, 2088 .adapter = { 2089 { 2090 .num_frontends = 1, 2091 .fe = {{ 2092 .streaming_ctrl = cxusb_d680_dmb_streaming_ctrl, 2093 .frontend_attach = cxusb_mygica_d689_frontend_attach, 2094 .tuner_attach = cxusb_mygica_d689_tuner_attach, 2095 2096 /* parameter for the MPEG2-data transfer */ 2097 .stream = { 2098 .type = USB_BULK, 2099 .count = 5, 2100 .endpoint = 0x02, 2101 .u = { 2102 .bulk = { 2103 .buffersize = 8192, 2104 } 2105 } 2106 }, 2107 }}, 2108 }, 2109 }, 2110 2111 .power_ctrl = cxusb_d680_dmb_power_ctrl, 2112 2113 .i2c_algo = &cxusb_i2c_algo, 2114 2115 .generic_bulk_ctrl_endpoint = 0x01, 2116 2117 .rc.core = { 2118 .rc_interval = 100, 2119 .rc_codes = RC_MAP_D680_DMB, 2120 .module_name = KBUILD_MODNAME, 2121 .rc_query = cxusb_d680_dmb_rc_query, 2122 .allowed_protos = RC_PROTO_BIT_UNKNOWN, 2123 }, 2124 2125 .num_device_descs = 1, 2126 .devices = { 2127 { 2128 "Mygica D689 DMB-TH", 2129 { NULL }, 2130 { &cxusb_table[MYGICA_D689], NULL }, 2131 }, 2132 } 2133 }; 2134 2135 static struct dvb_usb_device_properties cxusb_mygica_t230_properties = { 2136 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 2137 2138 .usb_ctrl = CYPRESS_FX2, 2139 2140 .size_of_priv = sizeof(struct cxusb_state), 2141 2142 .num_adapters = 1, 2143 .adapter = { 2144 { 2145 .num_frontends = 1, 2146 .fe = {{ 2147 .streaming_ctrl = cxusb_streaming_ctrl, 2148 .frontend_attach = cxusb_mygica_t230_frontend_attach, 2149 2150 /* parameter for the MPEG2-data transfer */ 2151 .stream = { 2152 .type = USB_BULK, 2153 .count = 5, 2154 .endpoint = 0x02, 2155 .u = { 2156 .bulk = { 2157 .buffersize = 8192, 2158 } 2159 } 2160 }, 2161 } }, 2162 }, 2163 }, 2164 2165 .power_ctrl = cxusb_d680_dmb_power_ctrl, 2166 2167 .i2c_algo = &cxusb_i2c_algo, 2168 2169 .generic_bulk_ctrl_endpoint = 0x01, 2170 2171 .rc.core = { 2172 .rc_interval = 100, 2173 .rc_codes = RC_MAP_D680_DMB, 2174 .module_name = KBUILD_MODNAME, 2175 .rc_query = cxusb_d680_dmb_rc_query, 2176 .allowed_protos = RC_PROTO_BIT_UNKNOWN, 2177 }, 2178 2179 .num_device_descs = 1, 2180 .devices = { 2181 { 2182 "Mygica T230 DVB-T/T2/C", 2183 { NULL }, 2184 { &cxusb_table[MYGICA_T230], NULL }, 2185 }, 2186 } 2187 }; 2188 2189 static struct usb_driver cxusb_driver = { 2190 .name = "dvb_usb_cxusb", 2191 .probe = cxusb_probe, 2192 .disconnect = cxusb_disconnect, 2193 .id_table = cxusb_table, 2194 }; 2195 2196 module_usb_driver(cxusb_driver); 2197 2198 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>"); 2199 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>"); 2200 MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>"); 2201 MODULE_DESCRIPTION("Driver for Conexant USB2.0 hybrid reference design"); 2202 MODULE_VERSION("1.0-alpha"); 2203 MODULE_LICENSE("GPL"); 2204