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