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