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/dvb/README.dvb-usb 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_address = 0x0e, 544 .demod_chip = LGDT3303, 545 }; 546 547 static struct lgdt330x_config cxusb_aver_lgdt3303_config = { 548 .demod_address = 0x0e, 549 .demod_chip = LGDT3303, 550 .clock_polarity_flip = 2, 551 }; 552 553 static struct mt352_config cxusb_dee1601_config = { 554 .demod_address = 0x0f, 555 .demod_init = cxusb_dee1601_demod_init, 556 }; 557 558 static struct zl10353_config cxusb_zl10353_dee1601_config = { 559 .demod_address = 0x0f, 560 .parallel_ts = 1, 561 }; 562 563 static struct mt352_config cxusb_mt352_config = { 564 /* used in both lgz201 and th7579 */ 565 .demod_address = 0x0f, 566 .demod_init = cxusb_mt352_demod_init, 567 }; 568 569 static struct zl10353_config cxusb_zl10353_xc3028_config = { 570 .demod_address = 0x0f, 571 .if2 = 45600, 572 .no_tuner = 1, 573 .parallel_ts = 1, 574 }; 575 576 static struct zl10353_config cxusb_zl10353_xc3028_config_no_i2c_gate = { 577 .demod_address = 0x0f, 578 .if2 = 45600, 579 .no_tuner = 1, 580 .parallel_ts = 1, 581 .disable_i2c_gate_ctrl = 1, 582 }; 583 584 static struct mt352_config cxusb_mt352_xc3028_config = { 585 .demod_address = 0x0f, 586 .if2 = 4560, 587 .no_tuner = 1, 588 .demod_init = cxusb_mt352_demod_init, 589 }; 590 591 /* FIXME: needs tweaking */ 592 static struct mxl5005s_config aver_a868r_tuner = { 593 .i2c_address = 0x63, 594 .if_freq = 6000000UL, 595 .xtal_freq = CRYSTAL_FREQ_16000000HZ, 596 .agc_mode = MXL_SINGLE_AGC, 597 .tracking_filter = MXL_TF_C, 598 .rssi_enable = MXL_RSSI_ENABLE, 599 .cap_select = MXL_CAP_SEL_ENABLE, 600 .div_out = MXL_DIV_OUT_4, 601 .clock_out = MXL_CLOCK_OUT_DISABLE, 602 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM, 603 .top = MXL5005S_TOP_25P2, 604 .mod_mode = MXL_DIGITAL_MODE, 605 .if_mode = MXL_ZERO_IF, 606 .AgcMasterByte = 0x00, 607 }; 608 609 /* FIXME: needs tweaking */ 610 static struct mxl5005s_config d680_dmb_tuner = { 611 .i2c_address = 0x63, 612 .if_freq = 36125000UL, 613 .xtal_freq = CRYSTAL_FREQ_16000000HZ, 614 .agc_mode = MXL_SINGLE_AGC, 615 .tracking_filter = MXL_TF_C, 616 .rssi_enable = MXL_RSSI_ENABLE, 617 .cap_select = MXL_CAP_SEL_ENABLE, 618 .div_out = MXL_DIV_OUT_4, 619 .clock_out = MXL_CLOCK_OUT_DISABLE, 620 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM, 621 .top = MXL5005S_TOP_25P2, 622 .mod_mode = MXL_DIGITAL_MODE, 623 .if_mode = MXL_ZERO_IF, 624 .AgcMasterByte = 0x00, 625 }; 626 627 static struct max2165_config mygica_d689_max2165_cfg = { 628 .i2c_address = 0x60, 629 .osc_clk = 20 630 }; 631 632 /* Callbacks for DVB USB */ 633 static int cxusb_fmd1216me_tuner_attach(struct dvb_usb_adapter *adap) 634 { 635 dvb_attach(simple_tuner_attach, adap->fe_adap[0].fe, 636 &adap->dev->i2c_adap, 0x61, 637 TUNER_PHILIPS_FMD1216ME_MK3); 638 return 0; 639 } 640 641 static int cxusb_dee1601_tuner_attach(struct dvb_usb_adapter *adap) 642 { 643 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x61, 644 NULL, DVB_PLL_THOMSON_DTT7579); 645 return 0; 646 } 647 648 static int cxusb_lgz201_tuner_attach(struct dvb_usb_adapter *adap) 649 { 650 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x61, NULL, DVB_PLL_LG_Z201); 651 return 0; 652 } 653 654 static int cxusb_dtt7579_tuner_attach(struct dvb_usb_adapter *adap) 655 { 656 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x60, 657 NULL, DVB_PLL_THOMSON_DTT7579); 658 return 0; 659 } 660 661 static int cxusb_lgh064f_tuner_attach(struct dvb_usb_adapter *adap) 662 { 663 dvb_attach(simple_tuner_attach, adap->fe_adap[0].fe, 664 &adap->dev->i2c_adap, 0x61, TUNER_LG_TDVS_H06XF); 665 return 0; 666 } 667 668 static int dvico_bluebird_xc2028_callback(void *ptr, int component, 669 int command, int arg) 670 { 671 struct dvb_usb_adapter *adap = ptr; 672 struct dvb_usb_device *d = adap->dev; 673 674 switch (command) { 675 case XC2028_TUNER_RESET: 676 deb_info("%s: XC2028_TUNER_RESET %d\n", __func__, arg); 677 cxusb_bluebird_gpio_pulse(d, 0x01, 1); 678 break; 679 case XC2028_RESET_CLK: 680 deb_info("%s: XC2028_RESET_CLK %d\n", __func__, arg); 681 break; 682 case XC2028_I2C_FLUSH: 683 break; 684 default: 685 deb_info("%s: unknown command %d, arg %d\n", __func__, 686 command, arg); 687 return -EINVAL; 688 } 689 690 return 0; 691 } 692 693 static int cxusb_dvico_xc3028_tuner_attach(struct dvb_usb_adapter *adap) 694 { 695 struct dvb_frontend *fe; 696 struct xc2028_config cfg = { 697 .i2c_adap = &adap->dev->i2c_adap, 698 .i2c_addr = 0x61, 699 }; 700 static struct xc2028_ctrl ctl = { 701 .fname = XC2028_DEFAULT_FIRMWARE, 702 .max_len = 64, 703 .demod = XC3028_FE_ZARLINK456, 704 }; 705 706 /* FIXME: generalize & move to common area */ 707 adap->fe_adap[0].fe->callback = dvico_bluebird_xc2028_callback; 708 709 fe = dvb_attach(xc2028_attach, adap->fe_adap[0].fe, &cfg); 710 if (fe == NULL || fe->ops.tuner_ops.set_config == NULL) 711 return -EIO; 712 713 fe->ops.tuner_ops.set_config(fe, &ctl); 714 715 return 0; 716 } 717 718 static int cxusb_mxl5003s_tuner_attach(struct dvb_usb_adapter *adap) 719 { 720 dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe, 721 &adap->dev->i2c_adap, &aver_a868r_tuner); 722 return 0; 723 } 724 725 static int cxusb_d680_dmb_tuner_attach(struct dvb_usb_adapter *adap) 726 { 727 struct dvb_frontend *fe; 728 fe = dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe, 729 &adap->dev->i2c_adap, &d680_dmb_tuner); 730 return (fe == NULL) ? -EIO : 0; 731 } 732 733 static int cxusb_mygica_d689_tuner_attach(struct dvb_usb_adapter *adap) 734 { 735 struct dvb_frontend *fe; 736 fe = dvb_attach(max2165_attach, adap->fe_adap[0].fe, 737 &adap->dev->i2c_adap, &mygica_d689_max2165_cfg); 738 return (fe == NULL) ? -EIO : 0; 739 } 740 741 static int cxusb_cx22702_frontend_attach(struct dvb_usb_adapter *adap) 742 { 743 u8 b; 744 if (usb_set_interface(adap->dev->udev, 0, 6) < 0) 745 err("set interface failed"); 746 747 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, &b, 1); 748 749 adap->fe_adap[0].fe = dvb_attach(cx22702_attach, &cxusb_cx22702_config, 750 &adap->dev->i2c_adap); 751 if ((adap->fe_adap[0].fe) != NULL) 752 return 0; 753 754 return -EIO; 755 } 756 757 static int cxusb_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap) 758 { 759 if (usb_set_interface(adap->dev->udev, 0, 7) < 0) 760 err("set interface failed"); 761 762 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0); 763 764 adap->fe_adap[0].fe = dvb_attach(lgdt330x_attach, 765 &cxusb_lgdt3303_config, 766 &adap->dev->i2c_adap); 767 if ((adap->fe_adap[0].fe) != NULL) 768 return 0; 769 770 return -EIO; 771 } 772 773 static int cxusb_aver_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap) 774 { 775 adap->fe_adap[0].fe = dvb_attach(lgdt330x_attach, &cxusb_aver_lgdt3303_config, 776 &adap->dev->i2c_adap); 777 if (adap->fe_adap[0].fe != NULL) 778 return 0; 779 780 return -EIO; 781 } 782 783 static int cxusb_mt352_frontend_attach(struct dvb_usb_adapter *adap) 784 { 785 /* used in both lgz201 and th7579 */ 786 if (usb_set_interface(adap->dev->udev, 0, 0) < 0) 787 err("set interface failed"); 788 789 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0); 790 791 adap->fe_adap[0].fe = dvb_attach(mt352_attach, &cxusb_mt352_config, 792 &adap->dev->i2c_adap); 793 if ((adap->fe_adap[0].fe) != NULL) 794 return 0; 795 796 return -EIO; 797 } 798 799 static int cxusb_dee1601_frontend_attach(struct dvb_usb_adapter *adap) 800 { 801 if (usb_set_interface(adap->dev->udev, 0, 0) < 0) 802 err("set interface failed"); 803 804 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0); 805 806 adap->fe_adap[0].fe = dvb_attach(mt352_attach, &cxusb_dee1601_config, 807 &adap->dev->i2c_adap); 808 if ((adap->fe_adap[0].fe) != NULL) 809 return 0; 810 811 adap->fe_adap[0].fe = dvb_attach(zl10353_attach, 812 &cxusb_zl10353_dee1601_config, 813 &adap->dev->i2c_adap); 814 if ((adap->fe_adap[0].fe) != NULL) 815 return 0; 816 817 return -EIO; 818 } 819 820 static int cxusb_dualdig4_frontend_attach(struct dvb_usb_adapter *adap) 821 { 822 u8 ircode[4]; 823 int i; 824 struct i2c_msg msg = { .addr = 0x6b, .flags = I2C_M_RD, 825 .buf = ircode, .len = 4 }; 826 827 if (usb_set_interface(adap->dev->udev, 0, 1) < 0) 828 err("set interface failed"); 829 830 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0); 831 832 /* reset the tuner and demodulator */ 833 cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0); 834 cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1); 835 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1); 836 837 adap->fe_adap[0].fe = 838 dvb_attach(zl10353_attach, 839 &cxusb_zl10353_xc3028_config_no_i2c_gate, 840 &adap->dev->i2c_adap); 841 if ((adap->fe_adap[0].fe) == NULL) 842 return -EIO; 843 844 /* try to determine if there is no IR decoder on the I2C bus */ 845 for (i = 0; adap->dev->props.rc.core.rc_codes && i < 5; i++) { 846 msleep(20); 847 if (cxusb_i2c_xfer(&adap->dev->i2c_adap, &msg, 1) != 1) 848 goto no_IR; 849 if (ircode[0] == 0 && ircode[1] == 0) 850 continue; 851 if (ircode[2] + ircode[3] != 0xff) { 852 no_IR: 853 adap->dev->props.rc.core.rc_codes = NULL; 854 info("No IR receiver detected on this device."); 855 break; 856 } 857 } 858 859 return 0; 860 } 861 862 static struct dibx000_agc_config dib7070_agc_config = { 863 .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND, 864 865 /* 866 * P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5, 867 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0, 868 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0 869 */ 870 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) | 871 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0), 872 .inv_gain = 600, 873 .time_stabiliz = 10, 874 .alpha_level = 0, 875 .thlock = 118, 876 .wbd_inv = 0, 877 .wbd_ref = 3530, 878 .wbd_sel = 1, 879 .wbd_alpha = 5, 880 .agc1_max = 65535, 881 .agc1_min = 0, 882 .agc2_max = 65535, 883 .agc2_min = 0, 884 .agc1_pt1 = 0, 885 .agc1_pt2 = 40, 886 .agc1_pt3 = 183, 887 .agc1_slope1 = 206, 888 .agc1_slope2 = 255, 889 .agc2_pt1 = 72, 890 .agc2_pt2 = 152, 891 .agc2_slope1 = 88, 892 .agc2_slope2 = 90, 893 .alpha_mant = 17, 894 .alpha_exp = 27, 895 .beta_mant = 23, 896 .beta_exp = 51, 897 .perform_agc_softsplit = 0, 898 }; 899 900 static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = { 901 .internal = 60000, 902 .sampling = 15000, 903 .pll_prediv = 1, 904 .pll_ratio = 20, 905 .pll_range = 3, 906 .pll_reset = 1, 907 .pll_bypass = 0, 908 .enable_refdiv = 0, 909 .bypclk_div = 0, 910 .IO_CLK_en_core = 1, 911 .ADClkSrc = 1, 912 .modulo = 2, 913 /* refsel, sel, freq_15k */ 914 .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0), 915 .ifreq = (0 << 25) | 0, 916 .timf = 20452225, 917 .xtal_hz = 12000000, 918 }; 919 920 static struct dib7000p_config cxusb_dualdig4_rev2_config = { 921 .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK, 922 .output_mpeg2_in_188_bytes = 1, 923 924 .agc_config_count = 1, 925 .agc = &dib7070_agc_config, 926 .bw = &dib7070_bw_config_12_mhz, 927 .tuner_is_baseband = 1, 928 .spur_protect = 1, 929 930 .gpio_dir = 0xfcef, 931 .gpio_val = 0x0110, 932 933 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS, 934 935 .hostbus_diversity = 1, 936 }; 937 938 struct dib0700_adapter_state { 939 int (*set_param_save)(struct dvb_frontend *); 940 struct dib7000p_ops dib7000p_ops; 941 }; 942 943 static int cxusb_dualdig4_rev2_frontend_attach(struct dvb_usb_adapter *adap) 944 { 945 struct dib0700_adapter_state *state = adap->priv; 946 947 if (usb_set_interface(adap->dev->udev, 0, 1) < 0) 948 err("set interface failed"); 949 950 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0); 951 952 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1); 953 954 if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops)) 955 return -ENODEV; 956 957 if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18, 958 &cxusb_dualdig4_rev2_config) < 0) { 959 printk(KERN_WARNING "Unable to enumerate dib7000p\n"); 960 return -ENODEV; 961 } 962 963 adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80, 964 &cxusb_dualdig4_rev2_config); 965 if (adap->fe_adap[0].fe == NULL) 966 return -EIO; 967 968 return 0; 969 } 970 971 static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff) 972 { 973 struct dvb_usb_adapter *adap = fe->dvb->priv; 974 struct dib0700_adapter_state *state = adap->priv; 975 976 return state->dib7000p_ops.set_gpio(fe, 8, 0, !onoff); 977 } 978 979 static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff) 980 { 981 return 0; 982 } 983 984 static struct dib0070_config dib7070p_dib0070_config = { 985 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS, 986 .reset = dib7070_tuner_reset, 987 .sleep = dib7070_tuner_sleep, 988 .clock_khz = 12000, 989 }; 990 991 static int dib7070_set_param_override(struct dvb_frontend *fe) 992 { 993 struct dtv_frontend_properties *p = &fe->dtv_property_cache; 994 struct dvb_usb_adapter *adap = fe->dvb->priv; 995 struct dib0700_adapter_state *state = adap->priv; 996 997 u16 offset; 998 u8 band = BAND_OF_FREQUENCY(p->frequency/1000); 999 switch (band) { 1000 case BAND_VHF: offset = 950; break; 1001 default: 1002 case BAND_UHF: offset = 550; break; 1003 } 1004 1005 state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe)); 1006 1007 return state->set_param_save(fe); 1008 } 1009 1010 static int cxusb_dualdig4_rev2_tuner_attach(struct dvb_usb_adapter *adap) 1011 { 1012 struct dib0700_adapter_state *st = adap->priv; 1013 struct i2c_adapter *tun_i2c; 1014 1015 /* 1016 * No need to call dvb7000p_attach here, as it was called 1017 * already, as frontend_attach method is called first, and 1018 * tuner_attach is only called on sucess. 1019 */ 1020 tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe, 1021 DIBX000_I2C_INTERFACE_TUNER, 1); 1022 1023 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c, 1024 &dib7070p_dib0070_config) == NULL) 1025 return -ENODEV; 1026 1027 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params; 1028 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7070_set_param_override; 1029 return 0; 1030 } 1031 1032 static int cxusb_nano2_frontend_attach(struct dvb_usb_adapter *adap) 1033 { 1034 if (usb_set_interface(adap->dev->udev, 0, 1) < 0) 1035 err("set interface failed"); 1036 1037 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0); 1038 1039 /* reset the tuner and demodulator */ 1040 cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0); 1041 cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1); 1042 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1); 1043 1044 adap->fe_adap[0].fe = dvb_attach(zl10353_attach, 1045 &cxusb_zl10353_xc3028_config, 1046 &adap->dev->i2c_adap); 1047 if ((adap->fe_adap[0].fe) != NULL) 1048 return 0; 1049 1050 adap->fe_adap[0].fe = dvb_attach(mt352_attach, 1051 &cxusb_mt352_xc3028_config, 1052 &adap->dev->i2c_adap); 1053 if ((adap->fe_adap[0].fe) != NULL) 1054 return 0; 1055 1056 return -EIO; 1057 } 1058 1059 static struct lgs8gxx_config d680_lgs8gl5_cfg = { 1060 .prod = LGS8GXX_PROD_LGS8GL5, 1061 .demod_address = 0x19, 1062 .serial_ts = 0, 1063 .ts_clk_pol = 0, 1064 .ts_clk_gated = 1, 1065 .if_clk_freq = 30400, /* 30.4 MHz */ 1066 .if_freq = 5725, /* 5.725 MHz */ 1067 .if_neg_center = 0, 1068 .ext_adc = 0, 1069 .adc_signed = 0, 1070 .if_neg_edge = 0, 1071 }; 1072 1073 static int cxusb_d680_dmb_frontend_attach(struct dvb_usb_adapter *adap) 1074 { 1075 struct dvb_usb_device *d = adap->dev; 1076 int n; 1077 1078 /* Select required USB configuration */ 1079 if (usb_set_interface(d->udev, 0, 0) < 0) 1080 err("set interface failed"); 1081 1082 /* Unblock all USB pipes */ 1083 usb_clear_halt(d->udev, 1084 usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint)); 1085 usb_clear_halt(d->udev, 1086 usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint)); 1087 usb_clear_halt(d->udev, 1088 usb_rcvbulkpipe(d->udev, d->props.adapter[0].fe[0].stream.endpoint)); 1089 1090 /* Drain USB pipes to avoid hang after reboot */ 1091 for (n = 0; n < 5; n++) { 1092 cxusb_d680_dmb_drain_message(d); 1093 cxusb_d680_dmb_drain_video(d); 1094 msleep(200); 1095 } 1096 1097 /* Reset the tuner */ 1098 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) { 1099 err("clear tuner gpio failed"); 1100 return -EIO; 1101 } 1102 msleep(100); 1103 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) { 1104 err("set tuner gpio failed"); 1105 return -EIO; 1106 } 1107 msleep(100); 1108 1109 /* Attach frontend */ 1110 adap->fe_adap[0].fe = dvb_attach(lgs8gxx_attach, &d680_lgs8gl5_cfg, &d->i2c_adap); 1111 if (adap->fe_adap[0].fe == NULL) 1112 return -EIO; 1113 1114 return 0; 1115 } 1116 1117 static struct atbm8830_config mygica_d689_atbm8830_cfg = { 1118 .prod = ATBM8830_PROD_8830, 1119 .demod_address = 0x40, 1120 .serial_ts = 0, 1121 .ts_sampling_edge = 1, 1122 .ts_clk_gated = 0, 1123 .osc_clk_freq = 30400, /* in kHz */ 1124 .if_freq = 0, /* zero IF */ 1125 .zif_swap_iq = 1, 1126 .agc_min = 0x2E, 1127 .agc_max = 0x90, 1128 .agc_hold_loop = 0, 1129 }; 1130 1131 static int cxusb_mygica_d689_frontend_attach(struct dvb_usb_adapter *adap) 1132 { 1133 struct dvb_usb_device *d = adap->dev; 1134 1135 /* Select required USB configuration */ 1136 if (usb_set_interface(d->udev, 0, 0) < 0) 1137 err("set interface failed"); 1138 1139 /* Unblock all USB pipes */ 1140 usb_clear_halt(d->udev, 1141 usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint)); 1142 usb_clear_halt(d->udev, 1143 usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint)); 1144 usb_clear_halt(d->udev, 1145 usb_rcvbulkpipe(d->udev, d->props.adapter[0].fe[0].stream.endpoint)); 1146 1147 1148 /* Reset the tuner */ 1149 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) { 1150 err("clear tuner gpio failed"); 1151 return -EIO; 1152 } 1153 msleep(100); 1154 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) { 1155 err("set tuner gpio failed"); 1156 return -EIO; 1157 } 1158 msleep(100); 1159 1160 /* Attach frontend */ 1161 adap->fe_adap[0].fe = dvb_attach(atbm8830_attach, &mygica_d689_atbm8830_cfg, 1162 &d->i2c_adap); 1163 if (adap->fe_adap[0].fe == NULL) 1164 return -EIO; 1165 1166 return 0; 1167 } 1168 1169 static int cxusb_mygica_t230_frontend_attach(struct dvb_usb_adapter *adap) 1170 { 1171 struct dvb_usb_device *d = adap->dev; 1172 struct cxusb_state *st = d->priv; 1173 struct i2c_adapter *adapter; 1174 struct i2c_client *client_demod; 1175 struct i2c_client *client_tuner; 1176 struct i2c_board_info info; 1177 struct si2168_config si2168_config; 1178 struct si2157_config si2157_config; 1179 1180 /* Select required USB configuration */ 1181 if (usb_set_interface(d->udev, 0, 0) < 0) 1182 err("set interface failed"); 1183 1184 /* Unblock all USB pipes */ 1185 usb_clear_halt(d->udev, 1186 usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint)); 1187 usb_clear_halt(d->udev, 1188 usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint)); 1189 usb_clear_halt(d->udev, 1190 usb_rcvbulkpipe(d->udev, d->props.adapter[0].fe[0].stream.endpoint)); 1191 1192 /* attach frontend */ 1193 si2168_config.i2c_adapter = &adapter; 1194 si2168_config.fe = &adap->fe_adap[0].fe; 1195 si2168_config.ts_mode = SI2168_TS_PARALLEL; 1196 si2168_config.ts_clock_inv = 1; 1197 memset(&info, 0, sizeof(struct i2c_board_info)); 1198 strlcpy(info.type, "si2168", I2C_NAME_SIZE); 1199 info.addr = 0x64; 1200 info.platform_data = &si2168_config; 1201 request_module(info.type); 1202 client_demod = i2c_new_device(&d->i2c_adap, &info); 1203 if (client_demod == NULL || client_demod->dev.driver == NULL) 1204 return -ENODEV; 1205 1206 if (!try_module_get(client_demod->dev.driver->owner)) { 1207 i2c_unregister_device(client_demod); 1208 return -ENODEV; 1209 } 1210 1211 st->i2c_client_demod = client_demod; 1212 1213 /* attach tuner */ 1214 memset(&si2157_config, 0, sizeof(si2157_config)); 1215 si2157_config.fe = adap->fe_adap[0].fe; 1216 si2157_config.if_port = 1; 1217 memset(&info, 0, sizeof(struct i2c_board_info)); 1218 strlcpy(info.type, "si2157", I2C_NAME_SIZE); 1219 info.addr = 0x60; 1220 info.platform_data = &si2157_config; 1221 request_module(info.type); 1222 client_tuner = i2c_new_device(adapter, &info); 1223 if (client_tuner == NULL || client_tuner->dev.driver == NULL) { 1224 module_put(client_demod->dev.driver->owner); 1225 i2c_unregister_device(client_demod); 1226 return -ENODEV; 1227 } 1228 if (!try_module_get(client_tuner->dev.driver->owner)) { 1229 i2c_unregister_device(client_tuner); 1230 module_put(client_demod->dev.driver->owner); 1231 i2c_unregister_device(client_demod); 1232 return -ENODEV; 1233 } 1234 1235 st->i2c_client_tuner = client_tuner; 1236 1237 /* hook fe: need to resync the slave fifo when signal locks. */ 1238 mutex_init(&st->stream_mutex); 1239 st->last_lock = 0; 1240 st->fe_read_status = adap->fe_adap[0].fe->ops.read_status; 1241 adap->fe_adap[0].fe->ops.read_status = cxusb_read_status; 1242 1243 return 0; 1244 } 1245 1246 static int cxusb_mygica_t230c_frontend_attach(struct dvb_usb_adapter *adap) 1247 { 1248 struct dvb_usb_device *d = adap->dev; 1249 struct cxusb_state *st = d->priv; 1250 struct i2c_adapter *adapter; 1251 struct i2c_client *client_demod; 1252 struct i2c_client *client_tuner; 1253 struct i2c_board_info info; 1254 struct si2168_config si2168_config; 1255 struct si2157_config si2157_config; 1256 1257 /* Select required USB configuration */ 1258 if (usb_set_interface(d->udev, 0, 0) < 0) 1259 err("set interface failed"); 1260 1261 /* Unblock all USB pipes */ 1262 usb_clear_halt(d->udev, 1263 usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint)); 1264 usb_clear_halt(d->udev, 1265 usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint)); 1266 usb_clear_halt(d->udev, 1267 usb_rcvbulkpipe(d->udev, d->props.adapter[0].fe[0].stream.endpoint)); 1268 1269 /* attach frontend */ 1270 memset(&si2168_config, 0, sizeof(si2168_config)); 1271 si2168_config.i2c_adapter = &adapter; 1272 si2168_config.fe = &adap->fe_adap[0].fe; 1273 si2168_config.ts_mode = SI2168_TS_PARALLEL; 1274 si2168_config.ts_clock_inv = 1; 1275 memset(&info, 0, sizeof(struct i2c_board_info)); 1276 strlcpy(info.type, "si2168", I2C_NAME_SIZE); 1277 info.addr = 0x64; 1278 info.platform_data = &si2168_config; 1279 request_module(info.type); 1280 client_demod = i2c_new_device(&d->i2c_adap, &info); 1281 if (client_demod == NULL || client_demod->dev.driver == NULL) 1282 return -ENODEV; 1283 1284 if (!try_module_get(client_demod->dev.driver->owner)) { 1285 i2c_unregister_device(client_demod); 1286 return -ENODEV; 1287 } 1288 1289 /* attach tuner */ 1290 memset(&si2157_config, 0, sizeof(si2157_config)); 1291 si2157_config.fe = adap->fe_adap[0].fe; 1292 memset(&info, 0, sizeof(struct i2c_board_info)); 1293 strlcpy(info.type, "si2141", I2C_NAME_SIZE); 1294 info.addr = 0x60; 1295 info.platform_data = &si2157_config; 1296 request_module("si2157"); 1297 client_tuner = i2c_new_device(adapter, &info); 1298 if (client_tuner == NULL || client_tuner->dev.driver == NULL) { 1299 module_put(client_demod->dev.driver->owner); 1300 i2c_unregister_device(client_demod); 1301 return -ENODEV; 1302 } 1303 if (!try_module_get(client_tuner->dev.driver->owner)) { 1304 i2c_unregister_device(client_tuner); 1305 module_put(client_demod->dev.driver->owner); 1306 i2c_unregister_device(client_demod); 1307 return -ENODEV; 1308 } 1309 1310 st->i2c_client_demod = client_demod; 1311 st->i2c_client_tuner = client_tuner; 1312 1313 /* hook fe: need to resync the slave fifo when signal locks. */ 1314 mutex_init(&st->stream_mutex); 1315 st->last_lock = 0; 1316 st->fe_read_status = adap->fe_adap[0].fe->ops.read_status; 1317 adap->fe_adap[0].fe->ops.read_status = cxusb_read_status; 1318 1319 return 0; 1320 } 1321 1322 /* 1323 * DViCO has shipped two devices with the same USB ID, but only one of them 1324 * needs a firmware download. Check the device class details to see if they 1325 * have non-default values to decide whether the device is actually cold or 1326 * not, and forget a match if it turns out we selected the wrong device. 1327 */ 1328 static int bluebird_fx2_identify_state(struct usb_device *udev, 1329 struct dvb_usb_device_properties *props, 1330 struct dvb_usb_device_description **desc, 1331 int *cold) 1332 { 1333 int wascold = *cold; 1334 1335 *cold = udev->descriptor.bDeviceClass == 0xff && 1336 udev->descriptor.bDeviceSubClass == 0xff && 1337 udev->descriptor.bDeviceProtocol == 0xff; 1338 1339 if (*cold && !wascold) 1340 *desc = NULL; 1341 1342 return 0; 1343 } 1344 1345 /* 1346 * DViCO bluebird firmware needs the "warm" product ID to be patched into the 1347 * firmware file before download. 1348 */ 1349 1350 static const int dvico_firmware_id_offsets[] = { 6638, 3204 }; 1351 static int bluebird_patch_dvico_firmware_download(struct usb_device *udev, 1352 const struct firmware *fw) 1353 { 1354 int pos; 1355 1356 for (pos = 0; pos < ARRAY_SIZE(dvico_firmware_id_offsets); pos++) { 1357 int idoff = dvico_firmware_id_offsets[pos]; 1358 1359 if (fw->size < idoff + 4) 1360 continue; 1361 1362 if (fw->data[idoff] == (USB_VID_DVICO & 0xff) && 1363 fw->data[idoff + 1] == USB_VID_DVICO >> 8) { 1364 struct firmware new_fw; 1365 u8 *new_fw_data = vmalloc(fw->size); 1366 int ret; 1367 1368 if (!new_fw_data) 1369 return -ENOMEM; 1370 1371 memcpy(new_fw_data, fw->data, fw->size); 1372 new_fw.size = fw->size; 1373 new_fw.data = new_fw_data; 1374 1375 new_fw_data[idoff + 2] = 1376 le16_to_cpu(udev->descriptor.idProduct) + 1; 1377 new_fw_data[idoff + 3] = 1378 le16_to_cpu(udev->descriptor.idProduct) >> 8; 1379 1380 ret = usb_cypress_load_firmware(udev, &new_fw, 1381 CYPRESS_FX2); 1382 vfree(new_fw_data); 1383 return ret; 1384 } 1385 } 1386 1387 return -EINVAL; 1388 } 1389 1390 /* DVB USB Driver stuff */ 1391 static struct dvb_usb_device_properties cxusb_medion_properties; 1392 static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties; 1393 static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties; 1394 static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties; 1395 static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties; 1396 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties; 1397 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties; 1398 static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties; 1399 static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties; 1400 static struct dvb_usb_device_properties cxusb_aver_a868r_properties; 1401 static struct dvb_usb_device_properties cxusb_d680_dmb_properties; 1402 static struct dvb_usb_device_properties cxusb_mygica_d689_properties; 1403 static struct dvb_usb_device_properties cxusb_mygica_t230_properties; 1404 static struct dvb_usb_device_properties cxusb_mygica_t230c_properties; 1405 1406 static int cxusb_probe(struct usb_interface *intf, 1407 const struct usb_device_id *id) 1408 { 1409 if (0 == dvb_usb_device_init(intf, &cxusb_medion_properties, 1410 THIS_MODULE, NULL, adapter_nr) || 1411 0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgh064f_properties, 1412 THIS_MODULE, NULL, adapter_nr) || 1413 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dee1601_properties, 1414 THIS_MODULE, NULL, adapter_nr) || 1415 0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgz201_properties, 1416 THIS_MODULE, NULL, adapter_nr) || 1417 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dtt7579_properties, 1418 THIS_MODULE, NULL, adapter_nr) || 1419 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dualdig4_properties, 1420 THIS_MODULE, NULL, adapter_nr) || 1421 0 == dvb_usb_device_init(intf, &cxusb_bluebird_nano2_properties, 1422 THIS_MODULE, NULL, adapter_nr) || 1423 0 == dvb_usb_device_init(intf, 1424 &cxusb_bluebird_nano2_needsfirmware_properties, 1425 THIS_MODULE, NULL, adapter_nr) || 1426 0 == dvb_usb_device_init(intf, &cxusb_aver_a868r_properties, 1427 THIS_MODULE, NULL, adapter_nr) || 1428 0 == dvb_usb_device_init(intf, 1429 &cxusb_bluebird_dualdig4_rev2_properties, 1430 THIS_MODULE, NULL, adapter_nr) || 1431 0 == dvb_usb_device_init(intf, &cxusb_d680_dmb_properties, 1432 THIS_MODULE, NULL, adapter_nr) || 1433 0 == dvb_usb_device_init(intf, &cxusb_mygica_d689_properties, 1434 THIS_MODULE, NULL, adapter_nr) || 1435 0 == dvb_usb_device_init(intf, &cxusb_mygica_t230_properties, 1436 THIS_MODULE, NULL, adapter_nr) || 1437 0 == dvb_usb_device_init(intf, &cxusb_mygica_t230c_properties, 1438 THIS_MODULE, NULL, adapter_nr) || 1439 0) 1440 return 0; 1441 1442 return -EINVAL; 1443 } 1444 1445 static void cxusb_disconnect(struct usb_interface *intf) 1446 { 1447 struct dvb_usb_device *d = usb_get_intfdata(intf); 1448 struct cxusb_state *st = d->priv; 1449 struct i2c_client *client; 1450 1451 /* remove I2C client for tuner */ 1452 client = st->i2c_client_tuner; 1453 if (client) { 1454 module_put(client->dev.driver->owner); 1455 i2c_unregister_device(client); 1456 } 1457 1458 /* remove I2C client for demodulator */ 1459 client = st->i2c_client_demod; 1460 if (client) { 1461 module_put(client->dev.driver->owner); 1462 i2c_unregister_device(client); 1463 } 1464 1465 dvb_usb_device_exit(intf); 1466 } 1467 1468 enum cxusb_table_index { 1469 MEDION_MD95700, 1470 DVICO_BLUEBIRD_LG064F_COLD, 1471 DVICO_BLUEBIRD_LG064F_WARM, 1472 DVICO_BLUEBIRD_DUAL_1_COLD, 1473 DVICO_BLUEBIRD_DUAL_1_WARM, 1474 DVICO_BLUEBIRD_LGZ201_COLD, 1475 DVICO_BLUEBIRD_LGZ201_WARM, 1476 DVICO_BLUEBIRD_TH7579_COLD, 1477 DVICO_BLUEBIRD_TH7579_WARM, 1478 DIGITALNOW_BLUEBIRD_DUAL_1_COLD, 1479 DIGITALNOW_BLUEBIRD_DUAL_1_WARM, 1480 DVICO_BLUEBIRD_DUAL_2_COLD, 1481 DVICO_BLUEBIRD_DUAL_2_WARM, 1482 DVICO_BLUEBIRD_DUAL_4, 1483 DVICO_BLUEBIRD_DVB_T_NANO_2, 1484 DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM, 1485 AVERMEDIA_VOLAR_A868R, 1486 DVICO_BLUEBIRD_DUAL_4_REV_2, 1487 CONEXANT_D680_DMB, 1488 MYGICA_D689, 1489 MYGICA_T230, 1490 MYGICA_T230C, 1491 NR__cxusb_table_index 1492 }; 1493 1494 static struct usb_device_id cxusb_table[NR__cxusb_table_index + 1] = { 1495 [MEDION_MD95700] = { 1496 USB_DEVICE(USB_VID_MEDION, USB_PID_MEDION_MD95700) 1497 }, 1498 [DVICO_BLUEBIRD_LG064F_COLD] = { 1499 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_COLD) 1500 }, 1501 [DVICO_BLUEBIRD_LG064F_WARM] = { 1502 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_WARM) 1503 }, 1504 [DVICO_BLUEBIRD_DUAL_1_COLD] = { 1505 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_COLD) 1506 }, 1507 [DVICO_BLUEBIRD_DUAL_1_WARM] = { 1508 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_WARM) 1509 }, 1510 [DVICO_BLUEBIRD_LGZ201_COLD] = { 1511 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_COLD) 1512 }, 1513 [DVICO_BLUEBIRD_LGZ201_WARM] = { 1514 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_WARM) 1515 }, 1516 [DVICO_BLUEBIRD_TH7579_COLD] = { 1517 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_COLD) 1518 }, 1519 [DVICO_BLUEBIRD_TH7579_WARM] = { 1520 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_WARM) 1521 }, 1522 [DIGITALNOW_BLUEBIRD_DUAL_1_COLD] = { 1523 USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_COLD) 1524 }, 1525 [DIGITALNOW_BLUEBIRD_DUAL_1_WARM] = { 1526 USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_WARM) 1527 }, 1528 [DVICO_BLUEBIRD_DUAL_2_COLD] = { 1529 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_COLD) 1530 }, 1531 [DVICO_BLUEBIRD_DUAL_2_WARM] = { 1532 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_WARM) 1533 }, 1534 [DVICO_BLUEBIRD_DUAL_4] = { 1535 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4) 1536 }, 1537 [DVICO_BLUEBIRD_DVB_T_NANO_2] = { 1538 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2) 1539 }, 1540 [DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM] = { 1541 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM) 1542 }, 1543 [AVERMEDIA_VOLAR_A868R] = { 1544 USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_A868R) 1545 }, 1546 [DVICO_BLUEBIRD_DUAL_4_REV_2] = { 1547 USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4_REV_2) 1548 }, 1549 [CONEXANT_D680_DMB] = { 1550 USB_DEVICE(USB_VID_CONEXANT, USB_PID_CONEXANT_D680_DMB) 1551 }, 1552 [MYGICA_D689] = { 1553 USB_DEVICE(USB_VID_CONEXANT, USB_PID_MYGICA_D689) 1554 }, 1555 [MYGICA_T230] = { 1556 USB_DEVICE(USB_VID_CONEXANT, USB_PID_MYGICA_T230) 1557 }, 1558 [MYGICA_T230C] = { 1559 USB_DEVICE(USB_VID_CONEXANT, USB_PID_MYGICA_T230+1) 1560 }, 1561 {} /* Terminating entry */ 1562 }; 1563 MODULE_DEVICE_TABLE (usb, cxusb_table); 1564 1565 static struct dvb_usb_device_properties cxusb_medion_properties = { 1566 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1567 1568 .usb_ctrl = CYPRESS_FX2, 1569 1570 .size_of_priv = sizeof(struct cxusb_state), 1571 1572 .num_adapters = 1, 1573 .adapter = { 1574 { 1575 .num_frontends = 1, 1576 .fe = {{ 1577 .streaming_ctrl = cxusb_streaming_ctrl, 1578 .frontend_attach = cxusb_cx22702_frontend_attach, 1579 .tuner_attach = cxusb_fmd1216me_tuner_attach, 1580 /* parameter for the MPEG2-data transfer */ 1581 .stream = { 1582 .type = USB_BULK, 1583 .count = 5, 1584 .endpoint = 0x02, 1585 .u = { 1586 .bulk = { 1587 .buffersize = 8192, 1588 } 1589 } 1590 }, 1591 }}, 1592 }, 1593 }, 1594 .power_ctrl = cxusb_power_ctrl, 1595 1596 .i2c_algo = &cxusb_i2c_algo, 1597 1598 .generic_bulk_ctrl_endpoint = 0x01, 1599 1600 .num_device_descs = 1, 1601 .devices = { 1602 { "Medion MD95700 (MDUSBTV-HYBRID)", 1603 { NULL }, 1604 { &cxusb_table[MEDION_MD95700], NULL }, 1605 }, 1606 } 1607 }; 1608 1609 static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties = { 1610 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1611 1612 .usb_ctrl = DEVICE_SPECIFIC, 1613 .firmware = "dvb-usb-bluebird-01.fw", 1614 .download_firmware = bluebird_patch_dvico_firmware_download, 1615 /* use usb alt setting 0 for EP4 transfer (dvb-t), 1616 use usb alt setting 7 for EP2 transfer (atsc) */ 1617 1618 .size_of_priv = sizeof(struct cxusb_state), 1619 1620 .num_adapters = 1, 1621 .adapter = { 1622 { 1623 .num_frontends = 1, 1624 .fe = {{ 1625 .streaming_ctrl = cxusb_streaming_ctrl, 1626 .frontend_attach = cxusb_lgdt3303_frontend_attach, 1627 .tuner_attach = cxusb_lgh064f_tuner_attach, 1628 1629 /* parameter for the MPEG2-data transfer */ 1630 .stream = { 1631 .type = USB_BULK, 1632 .count = 5, 1633 .endpoint = 0x02, 1634 .u = { 1635 .bulk = { 1636 .buffersize = 8192, 1637 } 1638 } 1639 }, 1640 }}, 1641 }, 1642 }, 1643 1644 .power_ctrl = cxusb_bluebird_power_ctrl, 1645 1646 .i2c_algo = &cxusb_i2c_algo, 1647 1648 .rc.core = { 1649 .rc_interval = 100, 1650 .rc_codes = RC_MAP_DVICO_PORTABLE, 1651 .module_name = KBUILD_MODNAME, 1652 .rc_query = cxusb_rc_query, 1653 .allowed_protos = RC_PROTO_BIT_NEC, 1654 }, 1655 1656 .generic_bulk_ctrl_endpoint = 0x01, 1657 1658 .num_device_descs = 1, 1659 .devices = { 1660 { "DViCO FusionHDTV5 USB Gold", 1661 { &cxusb_table[DVICO_BLUEBIRD_LG064F_COLD], NULL }, 1662 { &cxusb_table[DVICO_BLUEBIRD_LG064F_WARM], NULL }, 1663 }, 1664 } 1665 }; 1666 1667 static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties = { 1668 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1669 1670 .usb_ctrl = DEVICE_SPECIFIC, 1671 .firmware = "dvb-usb-bluebird-01.fw", 1672 .download_firmware = bluebird_patch_dvico_firmware_download, 1673 /* use usb alt setting 0 for EP4 transfer (dvb-t), 1674 use usb alt setting 7 for EP2 transfer (atsc) */ 1675 1676 .size_of_priv = sizeof(struct cxusb_state), 1677 1678 .num_adapters = 1, 1679 .adapter = { 1680 { 1681 .num_frontends = 1, 1682 .fe = {{ 1683 .streaming_ctrl = cxusb_streaming_ctrl, 1684 .frontend_attach = cxusb_dee1601_frontend_attach, 1685 .tuner_attach = cxusb_dee1601_tuner_attach, 1686 /* parameter for the MPEG2-data transfer */ 1687 .stream = { 1688 .type = USB_BULK, 1689 .count = 5, 1690 .endpoint = 0x04, 1691 .u = { 1692 .bulk = { 1693 .buffersize = 8192, 1694 } 1695 } 1696 }, 1697 }}, 1698 }, 1699 }, 1700 1701 .power_ctrl = cxusb_bluebird_power_ctrl, 1702 1703 .i2c_algo = &cxusb_i2c_algo, 1704 1705 .rc.core = { 1706 .rc_interval = 100, 1707 .rc_codes = RC_MAP_DVICO_MCE, 1708 .module_name = KBUILD_MODNAME, 1709 .rc_query = cxusb_rc_query, 1710 .allowed_protos = RC_PROTO_BIT_NEC, 1711 }, 1712 1713 .generic_bulk_ctrl_endpoint = 0x01, 1714 1715 .num_device_descs = 3, 1716 .devices = { 1717 { "DViCO FusionHDTV DVB-T Dual USB", 1718 { &cxusb_table[DVICO_BLUEBIRD_DUAL_1_COLD], NULL }, 1719 { &cxusb_table[DVICO_BLUEBIRD_DUAL_1_WARM], NULL }, 1720 }, 1721 { "DigitalNow DVB-T Dual USB", 1722 { &cxusb_table[DIGITALNOW_BLUEBIRD_DUAL_1_COLD], NULL }, 1723 { &cxusb_table[DIGITALNOW_BLUEBIRD_DUAL_1_WARM], NULL }, 1724 }, 1725 { "DViCO FusionHDTV DVB-T Dual Digital 2", 1726 { &cxusb_table[DVICO_BLUEBIRD_DUAL_2_COLD], NULL }, 1727 { &cxusb_table[DVICO_BLUEBIRD_DUAL_2_WARM], NULL }, 1728 }, 1729 } 1730 }; 1731 1732 static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties = { 1733 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1734 1735 .usb_ctrl = DEVICE_SPECIFIC, 1736 .firmware = "dvb-usb-bluebird-01.fw", 1737 .download_firmware = bluebird_patch_dvico_firmware_download, 1738 /* use usb alt setting 0 for EP4 transfer (dvb-t), 1739 use usb alt setting 7 for EP2 transfer (atsc) */ 1740 1741 .size_of_priv = sizeof(struct cxusb_state), 1742 1743 .num_adapters = 2, 1744 .adapter = { 1745 { 1746 .num_frontends = 1, 1747 .fe = {{ 1748 .streaming_ctrl = cxusb_streaming_ctrl, 1749 .frontend_attach = cxusb_mt352_frontend_attach, 1750 .tuner_attach = cxusb_lgz201_tuner_attach, 1751 1752 /* parameter for the MPEG2-data transfer */ 1753 .stream = { 1754 .type = USB_BULK, 1755 .count = 5, 1756 .endpoint = 0x04, 1757 .u = { 1758 .bulk = { 1759 .buffersize = 8192, 1760 } 1761 } 1762 }, 1763 }}, 1764 }, 1765 }, 1766 .power_ctrl = cxusb_bluebird_power_ctrl, 1767 1768 .i2c_algo = &cxusb_i2c_algo, 1769 1770 .rc.core = { 1771 .rc_interval = 100, 1772 .rc_codes = RC_MAP_DVICO_PORTABLE, 1773 .module_name = KBUILD_MODNAME, 1774 .rc_query = cxusb_rc_query, 1775 .allowed_protos = RC_PROTO_BIT_NEC, 1776 }, 1777 1778 .generic_bulk_ctrl_endpoint = 0x01, 1779 .num_device_descs = 1, 1780 .devices = { 1781 { "DViCO FusionHDTV DVB-T USB (LGZ201)", 1782 { &cxusb_table[DVICO_BLUEBIRD_LGZ201_COLD], NULL }, 1783 { &cxusb_table[DVICO_BLUEBIRD_LGZ201_WARM], NULL }, 1784 }, 1785 } 1786 }; 1787 1788 static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties = { 1789 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1790 1791 .usb_ctrl = DEVICE_SPECIFIC, 1792 .firmware = "dvb-usb-bluebird-01.fw", 1793 .download_firmware = bluebird_patch_dvico_firmware_download, 1794 /* use usb alt setting 0 for EP4 transfer (dvb-t), 1795 use usb alt setting 7 for EP2 transfer (atsc) */ 1796 1797 .size_of_priv = sizeof(struct cxusb_state), 1798 1799 .num_adapters = 1, 1800 .adapter = { 1801 { 1802 .num_frontends = 1, 1803 .fe = {{ 1804 .streaming_ctrl = cxusb_streaming_ctrl, 1805 .frontend_attach = cxusb_mt352_frontend_attach, 1806 .tuner_attach = cxusb_dtt7579_tuner_attach, 1807 1808 /* parameter for the MPEG2-data transfer */ 1809 .stream = { 1810 .type = USB_BULK, 1811 .count = 5, 1812 .endpoint = 0x04, 1813 .u = { 1814 .bulk = { 1815 .buffersize = 8192, 1816 } 1817 } 1818 }, 1819 }}, 1820 }, 1821 }, 1822 .power_ctrl = cxusb_bluebird_power_ctrl, 1823 1824 .i2c_algo = &cxusb_i2c_algo, 1825 1826 .rc.core = { 1827 .rc_interval = 100, 1828 .rc_codes = RC_MAP_DVICO_PORTABLE, 1829 .module_name = KBUILD_MODNAME, 1830 .rc_query = cxusb_rc_query, 1831 .allowed_protos = RC_PROTO_BIT_NEC, 1832 }, 1833 1834 .generic_bulk_ctrl_endpoint = 0x01, 1835 1836 .num_device_descs = 1, 1837 .devices = { 1838 { "DViCO FusionHDTV DVB-T USB (TH7579)", 1839 { &cxusb_table[DVICO_BLUEBIRD_TH7579_COLD], NULL }, 1840 { &cxusb_table[DVICO_BLUEBIRD_TH7579_WARM], NULL }, 1841 }, 1842 } 1843 }; 1844 1845 static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties = { 1846 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1847 1848 .usb_ctrl = CYPRESS_FX2, 1849 1850 .size_of_priv = sizeof(struct cxusb_state), 1851 1852 .num_adapters = 1, 1853 .adapter = { 1854 { 1855 .num_frontends = 1, 1856 .fe = {{ 1857 .streaming_ctrl = cxusb_streaming_ctrl, 1858 .frontend_attach = cxusb_dualdig4_frontend_attach, 1859 .tuner_attach = cxusb_dvico_xc3028_tuner_attach, 1860 /* parameter for the MPEG2-data transfer */ 1861 .stream = { 1862 .type = USB_BULK, 1863 .count = 5, 1864 .endpoint = 0x02, 1865 .u = { 1866 .bulk = { 1867 .buffersize = 8192, 1868 } 1869 } 1870 }, 1871 }}, 1872 }, 1873 }, 1874 1875 .power_ctrl = cxusb_power_ctrl, 1876 1877 .i2c_algo = &cxusb_i2c_algo, 1878 1879 .generic_bulk_ctrl_endpoint = 0x01, 1880 1881 .rc.core = { 1882 .rc_interval = 100, 1883 .rc_codes = RC_MAP_DVICO_MCE, 1884 .module_name = KBUILD_MODNAME, 1885 .rc_query = cxusb_bluebird2_rc_query, 1886 .allowed_protos = RC_PROTO_BIT_NEC, 1887 }, 1888 1889 .num_device_descs = 1, 1890 .devices = { 1891 { "DViCO FusionHDTV DVB-T Dual Digital 4", 1892 { NULL }, 1893 { &cxusb_table[DVICO_BLUEBIRD_DUAL_4], NULL }, 1894 }, 1895 } 1896 }; 1897 1898 static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties = { 1899 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1900 1901 .usb_ctrl = CYPRESS_FX2, 1902 .identify_state = bluebird_fx2_identify_state, 1903 1904 .size_of_priv = sizeof(struct cxusb_state), 1905 1906 .num_adapters = 1, 1907 .adapter = { 1908 { 1909 .num_frontends = 1, 1910 .fe = {{ 1911 .streaming_ctrl = cxusb_streaming_ctrl, 1912 .frontend_attach = cxusb_nano2_frontend_attach, 1913 .tuner_attach = cxusb_dvico_xc3028_tuner_attach, 1914 /* parameter for the MPEG2-data transfer */ 1915 .stream = { 1916 .type = USB_BULK, 1917 .count = 5, 1918 .endpoint = 0x02, 1919 .u = { 1920 .bulk = { 1921 .buffersize = 8192, 1922 } 1923 } 1924 }, 1925 }}, 1926 }, 1927 }, 1928 1929 .power_ctrl = cxusb_nano2_power_ctrl, 1930 1931 .i2c_algo = &cxusb_i2c_algo, 1932 1933 .generic_bulk_ctrl_endpoint = 0x01, 1934 1935 .rc.core = { 1936 .rc_interval = 100, 1937 .rc_codes = RC_MAP_DVICO_PORTABLE, 1938 .module_name = KBUILD_MODNAME, 1939 .rc_query = cxusb_bluebird2_rc_query, 1940 .allowed_protos = RC_PROTO_BIT_NEC, 1941 }, 1942 1943 .num_device_descs = 1, 1944 .devices = { 1945 { "DViCO FusionHDTV DVB-T NANO2", 1946 { NULL }, 1947 { &cxusb_table[DVICO_BLUEBIRD_DVB_T_NANO_2], NULL }, 1948 }, 1949 } 1950 }; 1951 1952 static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties = { 1953 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1954 1955 .usb_ctrl = DEVICE_SPECIFIC, 1956 .firmware = "dvb-usb-bluebird-02.fw", 1957 .download_firmware = bluebird_patch_dvico_firmware_download, 1958 .identify_state = bluebird_fx2_identify_state, 1959 1960 .size_of_priv = sizeof(struct cxusb_state), 1961 1962 .num_adapters = 1, 1963 .adapter = { 1964 { 1965 .num_frontends = 1, 1966 .fe = {{ 1967 .streaming_ctrl = cxusb_streaming_ctrl, 1968 .frontend_attach = cxusb_nano2_frontend_attach, 1969 .tuner_attach = cxusb_dvico_xc3028_tuner_attach, 1970 /* parameter for the MPEG2-data transfer */ 1971 .stream = { 1972 .type = USB_BULK, 1973 .count = 5, 1974 .endpoint = 0x02, 1975 .u = { 1976 .bulk = { 1977 .buffersize = 8192, 1978 } 1979 } 1980 }, 1981 }}, 1982 }, 1983 }, 1984 1985 .power_ctrl = cxusb_nano2_power_ctrl, 1986 1987 .i2c_algo = &cxusb_i2c_algo, 1988 1989 .generic_bulk_ctrl_endpoint = 0x01, 1990 1991 .rc.core = { 1992 .rc_interval = 100, 1993 .rc_codes = RC_MAP_DVICO_PORTABLE, 1994 .module_name = KBUILD_MODNAME, 1995 .rc_query = cxusb_rc_query, 1996 .allowed_protos = RC_PROTO_BIT_NEC, 1997 }, 1998 1999 .num_device_descs = 1, 2000 .devices = { 2001 { "DViCO FusionHDTV DVB-T NANO2 w/o firmware", 2002 { &cxusb_table[DVICO_BLUEBIRD_DVB_T_NANO_2], NULL }, 2003 { &cxusb_table[DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM], NULL }, 2004 }, 2005 } 2006 }; 2007 2008 static struct dvb_usb_device_properties cxusb_aver_a868r_properties = { 2009 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 2010 2011 .usb_ctrl = CYPRESS_FX2, 2012 2013 .size_of_priv = sizeof(struct cxusb_state), 2014 2015 .num_adapters = 1, 2016 .adapter = { 2017 { 2018 .num_frontends = 1, 2019 .fe = {{ 2020 .streaming_ctrl = cxusb_aver_streaming_ctrl, 2021 .frontend_attach = cxusb_aver_lgdt3303_frontend_attach, 2022 .tuner_attach = cxusb_mxl5003s_tuner_attach, 2023 /* parameter for the MPEG2-data transfer */ 2024 .stream = { 2025 .type = USB_BULK, 2026 .count = 5, 2027 .endpoint = 0x04, 2028 .u = { 2029 .bulk = { 2030 .buffersize = 8192, 2031 } 2032 } 2033 }, 2034 }}, 2035 }, 2036 }, 2037 .power_ctrl = cxusb_aver_power_ctrl, 2038 2039 .i2c_algo = &cxusb_i2c_algo, 2040 2041 .generic_bulk_ctrl_endpoint = 0x01, 2042 2043 .num_device_descs = 1, 2044 .devices = { 2045 { "AVerMedia AVerTVHD Volar (A868R)", 2046 { NULL }, 2047 { &cxusb_table[AVERMEDIA_VOLAR_A868R], NULL }, 2048 }, 2049 } 2050 }; 2051 2052 static 2053 struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties = { 2054 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 2055 2056 .usb_ctrl = CYPRESS_FX2, 2057 2058 .size_of_priv = sizeof(struct cxusb_state), 2059 2060 .num_adapters = 1, 2061 .adapter = { 2062 { 2063 .size_of_priv = sizeof(struct dib0700_adapter_state), 2064 .num_frontends = 1, 2065 .fe = {{ 2066 .streaming_ctrl = cxusb_streaming_ctrl, 2067 .frontend_attach = cxusb_dualdig4_rev2_frontend_attach, 2068 .tuner_attach = cxusb_dualdig4_rev2_tuner_attach, 2069 /* parameter for the MPEG2-data transfer */ 2070 .stream = { 2071 .type = USB_BULK, 2072 .count = 7, 2073 .endpoint = 0x02, 2074 .u = { 2075 .bulk = { 2076 .buffersize = 4096, 2077 } 2078 } 2079 }, 2080 }}, 2081 }, 2082 }, 2083 2084 .power_ctrl = cxusb_bluebird_power_ctrl, 2085 2086 .i2c_algo = &cxusb_i2c_algo, 2087 2088 .generic_bulk_ctrl_endpoint = 0x01, 2089 2090 .rc.core = { 2091 .rc_interval = 100, 2092 .rc_codes = RC_MAP_DVICO_MCE, 2093 .module_name = KBUILD_MODNAME, 2094 .rc_query = cxusb_rc_query, 2095 .allowed_protos = RC_PROTO_BIT_NEC, 2096 }, 2097 2098 .num_device_descs = 1, 2099 .devices = { 2100 { "DViCO FusionHDTV DVB-T Dual Digital 4 (rev 2)", 2101 { NULL }, 2102 { &cxusb_table[DVICO_BLUEBIRD_DUAL_4_REV_2], NULL }, 2103 }, 2104 } 2105 }; 2106 2107 static struct dvb_usb_device_properties cxusb_d680_dmb_properties = { 2108 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 2109 2110 .usb_ctrl = CYPRESS_FX2, 2111 2112 .size_of_priv = sizeof(struct cxusb_state), 2113 2114 .num_adapters = 1, 2115 .adapter = { 2116 { 2117 .num_frontends = 1, 2118 .fe = {{ 2119 .streaming_ctrl = cxusb_d680_dmb_streaming_ctrl, 2120 .frontend_attach = cxusb_d680_dmb_frontend_attach, 2121 .tuner_attach = cxusb_d680_dmb_tuner_attach, 2122 2123 /* parameter for the MPEG2-data transfer */ 2124 .stream = { 2125 .type = USB_BULK, 2126 .count = 5, 2127 .endpoint = 0x02, 2128 .u = { 2129 .bulk = { 2130 .buffersize = 8192, 2131 } 2132 } 2133 }, 2134 }}, 2135 }, 2136 }, 2137 2138 .power_ctrl = cxusb_d680_dmb_power_ctrl, 2139 2140 .i2c_algo = &cxusb_i2c_algo, 2141 2142 .generic_bulk_ctrl_endpoint = 0x01, 2143 2144 .rc.core = { 2145 .rc_interval = 100, 2146 .rc_codes = RC_MAP_D680_DMB, 2147 .module_name = KBUILD_MODNAME, 2148 .rc_query = cxusb_d680_dmb_rc_query, 2149 .allowed_protos = RC_PROTO_BIT_UNKNOWN, 2150 }, 2151 2152 .num_device_descs = 1, 2153 .devices = { 2154 { 2155 "Conexant DMB-TH Stick", 2156 { NULL }, 2157 { &cxusb_table[CONEXANT_D680_DMB], NULL }, 2158 }, 2159 } 2160 }; 2161 2162 static struct dvb_usb_device_properties cxusb_mygica_d689_properties = { 2163 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 2164 2165 .usb_ctrl = CYPRESS_FX2, 2166 2167 .size_of_priv = sizeof(struct cxusb_state), 2168 2169 .num_adapters = 1, 2170 .adapter = { 2171 { 2172 .num_frontends = 1, 2173 .fe = {{ 2174 .streaming_ctrl = cxusb_d680_dmb_streaming_ctrl, 2175 .frontend_attach = cxusb_mygica_d689_frontend_attach, 2176 .tuner_attach = cxusb_mygica_d689_tuner_attach, 2177 2178 /* parameter for the MPEG2-data transfer */ 2179 .stream = { 2180 .type = USB_BULK, 2181 .count = 5, 2182 .endpoint = 0x02, 2183 .u = { 2184 .bulk = { 2185 .buffersize = 8192, 2186 } 2187 } 2188 }, 2189 }}, 2190 }, 2191 }, 2192 2193 .power_ctrl = cxusb_d680_dmb_power_ctrl, 2194 2195 .i2c_algo = &cxusb_i2c_algo, 2196 2197 .generic_bulk_ctrl_endpoint = 0x01, 2198 2199 .rc.core = { 2200 .rc_interval = 100, 2201 .rc_codes = RC_MAP_D680_DMB, 2202 .module_name = KBUILD_MODNAME, 2203 .rc_query = cxusb_d680_dmb_rc_query, 2204 .allowed_protos = RC_PROTO_BIT_UNKNOWN, 2205 }, 2206 2207 .num_device_descs = 1, 2208 .devices = { 2209 { 2210 "Mygica D689 DMB-TH", 2211 { NULL }, 2212 { &cxusb_table[MYGICA_D689], NULL }, 2213 }, 2214 } 2215 }; 2216 2217 static struct dvb_usb_device_properties cxusb_mygica_t230_properties = { 2218 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 2219 2220 .usb_ctrl = CYPRESS_FX2, 2221 2222 .size_of_priv = sizeof(struct cxusb_state), 2223 2224 .num_adapters = 1, 2225 .adapter = { 2226 { 2227 .num_frontends = 1, 2228 .fe = {{ 2229 .streaming_ctrl = cxusb_streaming_ctrl, 2230 .frontend_attach = cxusb_mygica_t230_frontend_attach, 2231 2232 /* parameter for the MPEG2-data transfer */ 2233 .stream = { 2234 .type = USB_BULK, 2235 .count = 5, 2236 .endpoint = 0x02, 2237 .u = { 2238 .bulk = { 2239 .buffersize = 8192, 2240 } 2241 } 2242 }, 2243 } }, 2244 }, 2245 }, 2246 2247 .power_ctrl = cxusb_d680_dmb_power_ctrl, 2248 2249 .i2c_algo = &cxusb_i2c_algo, 2250 2251 .generic_bulk_ctrl_endpoint = 0x01, 2252 2253 .rc.core = { 2254 .rc_interval = 100, 2255 .rc_codes = RC_MAP_TOTAL_MEDIA_IN_HAND_02, 2256 .module_name = KBUILD_MODNAME, 2257 .rc_query = cxusb_d680_dmb_rc_query, 2258 .allowed_protos = RC_PROTO_BIT_UNKNOWN, 2259 }, 2260 2261 .num_device_descs = 1, 2262 .devices = { 2263 { 2264 "Mygica T230 DVB-T/T2/C", 2265 { NULL }, 2266 { &cxusb_table[MYGICA_T230], NULL }, 2267 }, 2268 } 2269 }; 2270 2271 static struct dvb_usb_device_properties cxusb_mygica_t230c_properties = { 2272 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 2273 2274 .usb_ctrl = CYPRESS_FX2, 2275 2276 .size_of_priv = sizeof(struct cxusb_state), 2277 2278 .num_adapters = 1, 2279 .adapter = { 2280 { 2281 .num_frontends = 1, 2282 .fe = {{ 2283 .streaming_ctrl = cxusb_streaming_ctrl, 2284 .frontend_attach = cxusb_mygica_t230c_frontend_attach, 2285 2286 /* parameter for the MPEG2-data transfer */ 2287 .stream = { 2288 .type = USB_BULK, 2289 .count = 5, 2290 .endpoint = 0x02, 2291 .u = { 2292 .bulk = { 2293 .buffersize = 8192, 2294 } 2295 } 2296 }, 2297 } }, 2298 }, 2299 }, 2300 2301 .power_ctrl = cxusb_d680_dmb_power_ctrl, 2302 2303 .i2c_algo = &cxusb_i2c_algo, 2304 2305 .generic_bulk_ctrl_endpoint = 0x01, 2306 2307 .rc.core = { 2308 .rc_interval = 100, 2309 .rc_codes = RC_MAP_TOTAL_MEDIA_IN_HAND_02, 2310 .module_name = KBUILD_MODNAME, 2311 .rc_query = cxusb_d680_dmb_rc_query, 2312 .allowed_protos = RC_PROTO_BIT_UNKNOWN, 2313 }, 2314 2315 .num_device_descs = 1, 2316 .devices = { 2317 { 2318 "Mygica T230C DVB-T/T2/C", 2319 { NULL }, 2320 { &cxusb_table[MYGICA_T230C], NULL }, 2321 }, 2322 } 2323 }; 2324 2325 static struct usb_driver cxusb_driver = { 2326 .name = "dvb_usb_cxusb", 2327 .probe = cxusb_probe, 2328 .disconnect = cxusb_disconnect, 2329 .id_table = cxusb_table, 2330 }; 2331 2332 module_usb_driver(cxusb_driver); 2333 2334 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>"); 2335 MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>"); 2336 MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>"); 2337 MODULE_DESCRIPTION("Driver for Conexant USB2.0 hybrid reference design"); 2338 MODULE_VERSION("1.0-alpha"); 2339 MODULE_LICENSE("GPL"); 2340