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 "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 */ 50int dvb_usb_cxusb_debug; 51module_param_named(debug, dvb_usb_cxusb_debug, int, 0644); 52MODULE_PARM_DESC(debug, "set debugging level (see cxusb.h)." 53 DVB_USB_DEBUG_STATUS); 54 55DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); 56 57enum 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 81static struct usb_device_id cxusb_table[]; 82 83int 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 */ 111static 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 131static 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 147static 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 154static void cxusb_nano2_led(struct dvb_usb_device *d, int onoff) 155{ 156 cxusb_bluebird_gpio_rw(d, 0x40, onoff ? 0 : 0x40); 157} 158 159static 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 */ 179static 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 280unlock: 281 mutex_unlock(&d->i2c_mutex); 282 return ret; 283} 284 285static u32 cxusb_i2c_func(struct i2c_adapter *adapter) 286{ 287 return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL; 288} 289 290static struct i2c_algorithm cxusb_i2c_algo = { 291 .master_xfer = cxusb_i2c_xfer, 292 .functionality = cxusb_i2c_func, 293}; 294 295static 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 307static 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 326ret_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 336static 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 383static 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 393static 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 404static 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 419static 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 445static 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 455static 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 478static 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 501static 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 517static 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 530static 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 549static 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 562static 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 583static 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 604static struct cx22702_config cxusb_cx22702_config = { 605 .demod_address = 0x63, 606 .output_mode = CX22702_PARALLEL_OUTPUT, 607}; 608 609static struct lgdt330x_config cxusb_lgdt3303_config = { 610 .demod_chip = LGDT3303, 611}; 612 613static struct lgdt330x_config cxusb_aver_lgdt3303_config = { 614 .demod_chip = LGDT3303, 615 .clock_polarity_flip = 2, 616}; 617 618static struct mt352_config cxusb_dee1601_config = { 619 .demod_address = 0x0f, 620 .demod_init = cxusb_dee1601_demod_init, 621}; 622 623static struct zl10353_config cxusb_zl10353_dee1601_config = { 624 .demod_address = 0x0f, 625 .parallel_ts = 1, 626}; 627 628static 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 634static struct zl10353_config cxusb_zl10353_xc3028_config = { 635 .demod_address = 0x0f, 636 .if2 = 45600, 637 .no_tuner = 1, 638 .parallel_ts = 1, 639}; 640 641static 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 649static 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 */ 657static 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 */ 675static 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 692static struct max2165_config mygica_d689_max2165_cfg = { 693 .i2c_address = 0x60, 694 .osc_clk = 20 695}; 696 697/* Callbacks for DVB USB */ 698static 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 718static 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 725static 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 732static 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 739static 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 746static 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 771static 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 796static 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 803static 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 812static 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 821static 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 834static 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 890ret_unlock: 891 mutex_unlock(&dvbdev->i2c_mutex); 892 893 return ret; 894} 895 896static 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 922static 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 939static 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 951static 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 967static 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 988static 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) { 1024no_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 1034static 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 1072static 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 1092static 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 1110struct dib0700_adapter_state { 1111 int (*set_param_save)(struct dvb_frontend *fe); 1112 struct dib7000p_ops dib7000p_ops; 1113}; 1114 1115static 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 1144static 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 1152static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff) 1153{ 1154 return 0; 1155} 1156 1157static 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 1164static 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 1188static 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 1210static 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 1237static 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 1251static 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 1299static 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 1313static 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 */ 1360static 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 1382static const int dvico_firmware_id_offsets[] = { 6638, 3204 }; 1383static 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 1422int 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 1490ret_unlock: 1491 mutex_unlock(&cxdev->open_lock); 1492 1493 return ret; 1494} 1495 1496void 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 1516unlock: 1517 mutex_unlock(&cxdev->open_lock); 1518} 1519 1520/* DVB USB Driver stuff */ 1521static struct dvb_usb_device_properties cxusb_medion_properties; 1522static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties; 1523static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties; 1524static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties; 1525static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties; 1526static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties; 1527static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties; 1528static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties; 1529static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties; 1530static struct dvb_usb_device_properties cxusb_aver_a868r_properties; 1531static struct dvb_usb_device_properties cxusb_d680_dmb_properties; 1532static struct dvb_usb_device_properties cxusb_mygica_d689_properties; 1533 1534static 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 1545static 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 1552static 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 1572static 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 1597static 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 1663ret_uninit: 1664 dvb_usb_device_exit(intf); 1665 1666 return ret; 1667} 1668 1669static 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 1695static struct usb_device_id cxusb_table[] = { 1696 DVB_USB_DEV(MEDION, MEDION_MD95700), 1697 DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_LG064F_COLD), 1698 DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_LG064F_WARM), 1699 DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_DUAL_1_COLD), 1700 DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_DUAL_1_WARM), 1701 DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_LGZ201_COLD), 1702 DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_LGZ201_WARM), 1703 DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_TH7579_COLD), 1704 DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_TH7579_WARM), 1705 DVB_USB_DEV(DVICO, DIGITALNOW_BLUEBIRD_DUAL_1_COLD), 1706 DVB_USB_DEV(DVICO, DIGITALNOW_BLUEBIRD_DUAL_1_WARM), 1707 DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_DUAL_2_COLD), 1708 DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_DUAL_2_WARM), 1709 DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_DUAL_4), 1710 DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_DVB_T_NANO_2), 1711 DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM), 1712 DVB_USB_DEV(AVERMEDIA, AVERMEDIA_VOLAR_A868R), 1713 DVB_USB_DEV(DVICO, DVICO_BLUEBIRD_DUAL_4_REV_2), 1714 DVB_USB_DEV(CONEXANT, CONEXANT_D680_DMB), 1715 DVB_USB_DEV(CONEXANT, MYGICA_D689), 1716 { } 1717}; 1718 1719MODULE_DEVICE_TABLE(usb, cxusb_table); 1720 1721static struct dvb_usb_device_properties cxusb_medion_properties = { 1722 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1723 1724 .usb_ctrl = CYPRESS_FX2, 1725 1726 .size_of_priv = sizeof(struct cxusb_medion_dev), 1727 .priv_init = cxusb_medion_priv_init, 1728 .priv_destroy = cxusb_medion_priv_destroy, 1729 1730 .num_adapters = 1, 1731 .adapter = { 1732 { 1733 .num_frontends = 1, 1734 .fe = {{ 1735 .streaming_ctrl = cxusb_streaming_ctrl, 1736 .frontend_attach = cxusb_cx22702_frontend_attach, 1737 .tuner_attach = cxusb_fmd1216me_tuner_attach, 1738 /* parameter for the MPEG2-data transfer */ 1739 .stream = { 1740 .type = USB_BULK, 1741 .count = 5, 1742 .endpoint = 0x02, 1743 .u = { 1744 .bulk = { 1745 .buffersize = 8192, 1746 } 1747 } 1748 }, 1749 } }, 1750 }, 1751 }, 1752 .power_ctrl = cxusb_power_ctrl, 1753 1754 .i2c_algo = &cxusb_i2c_algo, 1755 1756 .generic_bulk_ctrl_endpoint = 0x01, 1757 1758 .num_device_descs = 1, 1759 .devices = { 1760 { 1761 "Medion MD95700 (MDUSBTV-HYBRID)", 1762 { NULL }, 1763 { &cxusb_table[MEDION_MD95700], NULL }, 1764 }, 1765 } 1766}; 1767 1768static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties = { 1769 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1770 1771 .usb_ctrl = DEVICE_SPECIFIC, 1772 .firmware = "dvb-usb-bluebird-01.fw", 1773 .download_firmware = bluebird_patch_dvico_firmware_download, 1774 /* 1775 * use usb alt setting 0 for EP4 transfer (dvb-t), 1776 * use usb alt setting 7 for EP2 transfer (atsc) 1777 */ 1778 1779 .size_of_priv = sizeof(struct cxusb_state), 1780 1781 .num_adapters = 1, 1782 .adapter = { 1783 { 1784 .num_frontends = 1, 1785 .fe = {{ 1786 .streaming_ctrl = cxusb_streaming_ctrl, 1787 .frontend_attach = cxusb_lgdt3303_frontend_attach, 1788 .tuner_attach = cxusb_lgh064f_tuner_attach, 1789 1790 /* parameter for the MPEG2-data transfer */ 1791 .stream = { 1792 .type = USB_BULK, 1793 .count = 5, 1794 .endpoint = 0x02, 1795 .u = { 1796 .bulk = { 1797 .buffersize = 8192, 1798 } 1799 } 1800 }, 1801 } }, 1802 }, 1803 }, 1804 1805 .power_ctrl = cxusb_bluebird_power_ctrl, 1806 1807 .i2c_algo = &cxusb_i2c_algo, 1808 1809 .rc.core = { 1810 .rc_interval = 100, 1811 .rc_codes = RC_MAP_DVICO_PORTABLE, 1812 .module_name = KBUILD_MODNAME, 1813 .rc_query = cxusb_rc_query, 1814 .allowed_protos = RC_PROTO_BIT_NEC, 1815 }, 1816 1817 .generic_bulk_ctrl_endpoint = 0x01, 1818 1819 .num_device_descs = 1, 1820 .devices = { 1821 { "DViCO FusionHDTV5 USB Gold", 1822 { &cxusb_table[DVICO_BLUEBIRD_LG064F_COLD], NULL }, 1823 { &cxusb_table[DVICO_BLUEBIRD_LG064F_WARM], NULL }, 1824 }, 1825 } 1826}; 1827 1828static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties = { 1829 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1830 1831 .usb_ctrl = DEVICE_SPECIFIC, 1832 .firmware = "dvb-usb-bluebird-01.fw", 1833 .download_firmware = bluebird_patch_dvico_firmware_download, 1834 /* 1835 * use usb alt setting 0 for EP4 transfer (dvb-t), 1836 * use usb alt setting 7 for EP2 transfer (atsc) 1837 */ 1838 1839 .size_of_priv = sizeof(struct cxusb_state), 1840 1841 .num_adapters = 1, 1842 .adapter = { 1843 { 1844 .num_frontends = 1, 1845 .fe = {{ 1846 .streaming_ctrl = cxusb_streaming_ctrl, 1847 .frontend_attach = cxusb_dee1601_frontend_attach, 1848 .tuner_attach = cxusb_dee1601_tuner_attach, 1849 /* parameter for the MPEG2-data transfer */ 1850 .stream = { 1851 .type = USB_BULK, 1852 .count = 5, 1853 .endpoint = 0x04, 1854 .u = { 1855 .bulk = { 1856 .buffersize = 8192, 1857 } 1858 } 1859 }, 1860 } }, 1861 }, 1862 }, 1863 1864 .power_ctrl = cxusb_bluebird_power_ctrl, 1865 1866 .i2c_algo = &cxusb_i2c_algo, 1867 1868 .rc.core = { 1869 .rc_interval = 100, 1870 .rc_codes = RC_MAP_DVICO_MCE, 1871 .module_name = KBUILD_MODNAME, 1872 .rc_query = cxusb_rc_query, 1873 .allowed_protos = RC_PROTO_BIT_NEC, 1874 }, 1875 1876 .generic_bulk_ctrl_endpoint = 0x01, 1877 1878 .num_device_descs = 3, 1879 .devices = { 1880 { "DViCO FusionHDTV DVB-T Dual USB", 1881 { &cxusb_table[DVICO_BLUEBIRD_DUAL_1_COLD], NULL }, 1882 { &cxusb_table[DVICO_BLUEBIRD_DUAL_1_WARM], NULL }, 1883 }, 1884 { "DigitalNow DVB-T Dual USB", 1885 { &cxusb_table[DIGITALNOW_BLUEBIRD_DUAL_1_COLD], NULL }, 1886 { &cxusb_table[DIGITALNOW_BLUEBIRD_DUAL_1_WARM], NULL }, 1887 }, 1888 { "DViCO FusionHDTV DVB-T Dual Digital 2", 1889 { &cxusb_table[DVICO_BLUEBIRD_DUAL_2_COLD], NULL }, 1890 { &cxusb_table[DVICO_BLUEBIRD_DUAL_2_WARM], NULL }, 1891 }, 1892 } 1893}; 1894 1895static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties = { 1896 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1897 1898 .usb_ctrl = DEVICE_SPECIFIC, 1899 .firmware = "dvb-usb-bluebird-01.fw", 1900 .download_firmware = bluebird_patch_dvico_firmware_download, 1901 /* 1902 * use usb alt setting 0 for EP4 transfer (dvb-t), 1903 * use usb alt setting 7 for EP2 transfer (atsc) 1904 */ 1905 1906 .size_of_priv = sizeof(struct cxusb_state), 1907 1908 .num_adapters = 1, 1909 .adapter = { 1910 { 1911 .num_frontends = 1, 1912 .fe = {{ 1913 .streaming_ctrl = cxusb_streaming_ctrl, 1914 .frontend_attach = cxusb_mt352_frontend_attach, 1915 .tuner_attach = cxusb_lgz201_tuner_attach, 1916 1917 /* parameter for the MPEG2-data transfer */ 1918 .stream = { 1919 .type = USB_BULK, 1920 .count = 5, 1921 .endpoint = 0x04, 1922 .u = { 1923 .bulk = { 1924 .buffersize = 8192, 1925 } 1926 } 1927 }, 1928 } }, 1929 }, 1930 }, 1931 .power_ctrl = cxusb_bluebird_power_ctrl, 1932 1933 .i2c_algo = &cxusb_i2c_algo, 1934 1935 .rc.core = { 1936 .rc_interval = 100, 1937 .rc_codes = RC_MAP_DVICO_PORTABLE, 1938 .module_name = KBUILD_MODNAME, 1939 .rc_query = cxusb_rc_query, 1940 .allowed_protos = RC_PROTO_BIT_NEC, 1941 }, 1942 1943 .generic_bulk_ctrl_endpoint = 0x01, 1944 .num_device_descs = 1, 1945 .devices = { 1946 { "DViCO FusionHDTV DVB-T USB (LGZ201)", 1947 { &cxusb_table[DVICO_BLUEBIRD_LGZ201_COLD], NULL }, 1948 { &cxusb_table[DVICO_BLUEBIRD_LGZ201_WARM], NULL }, 1949 }, 1950 } 1951}; 1952 1953static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties = { 1954 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1955 1956 .usb_ctrl = DEVICE_SPECIFIC, 1957 .firmware = "dvb-usb-bluebird-01.fw", 1958 .download_firmware = bluebird_patch_dvico_firmware_download, 1959 1960 /* 1961 * use usb alt setting 0 for EP4 transfer (dvb-t), 1962 * use usb alt setting 7 for EP2 transfer (atsc) 1963 */ 1964 1965 .size_of_priv = sizeof(struct cxusb_state), 1966 1967 .num_adapters = 1, 1968 .adapter = { 1969 { 1970 .num_frontends = 1, 1971 .fe = {{ 1972 .streaming_ctrl = cxusb_streaming_ctrl, 1973 .frontend_attach = cxusb_mt352_frontend_attach, 1974 .tuner_attach = cxusb_dtt7579_tuner_attach, 1975 1976 /* parameter for the MPEG2-data transfer */ 1977 .stream = { 1978 .type = USB_BULK, 1979 .count = 5, 1980 .endpoint = 0x04, 1981 .u = { 1982 .bulk = { 1983 .buffersize = 8192, 1984 } 1985 } 1986 }, 1987 } }, 1988 }, 1989 }, 1990 .power_ctrl = cxusb_bluebird_power_ctrl, 1991 1992 .i2c_algo = &cxusb_i2c_algo, 1993 1994 .rc.core = { 1995 .rc_interval = 100, 1996 .rc_codes = RC_MAP_DVICO_PORTABLE, 1997 .module_name = KBUILD_MODNAME, 1998 .rc_query = cxusb_rc_query, 1999 .allowed_protos = RC_PROTO_BIT_NEC, 2000 }, 2001 2002 .generic_bulk_ctrl_endpoint = 0x01, 2003 2004 .num_device_descs = 1, 2005 .devices = { 2006 { "DViCO FusionHDTV DVB-T USB (TH7579)", 2007 { &cxusb_table[DVICO_BLUEBIRD_TH7579_COLD], NULL }, 2008 { &cxusb_table[DVICO_BLUEBIRD_TH7579_WARM], NULL }, 2009 }, 2010 } 2011}; 2012 2013static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties = { 2014 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 2015 2016 .usb_ctrl = CYPRESS_FX2, 2017 2018 .size_of_priv = sizeof(struct cxusb_state), 2019 2020 .num_adapters = 1, 2021 .adapter = { 2022 { 2023 .num_frontends = 1, 2024 .fe = {{ 2025 .streaming_ctrl = cxusb_streaming_ctrl, 2026 .frontend_attach = cxusb_dualdig4_frontend_attach, 2027 .tuner_attach = cxusb_dvico_xc3028_tuner_attach, 2028 /* parameter for the MPEG2-data transfer */ 2029 .stream = { 2030 .type = USB_BULK, 2031 .count = 5, 2032 .endpoint = 0x02, 2033 .u = { 2034 .bulk = { 2035 .buffersize = 8192, 2036 } 2037 } 2038 }, 2039 } }, 2040 }, 2041 }, 2042 2043 .power_ctrl = cxusb_power_ctrl, 2044 2045 .i2c_algo = &cxusb_i2c_algo, 2046 2047 .generic_bulk_ctrl_endpoint = 0x01, 2048 2049 .rc.core = { 2050 .rc_interval = 100, 2051 .rc_codes = RC_MAP_DVICO_MCE, 2052 .module_name = KBUILD_MODNAME, 2053 .rc_query = cxusb_bluebird2_rc_query, 2054 .allowed_protos = RC_PROTO_BIT_NEC, 2055 }, 2056 2057 .num_device_descs = 1, 2058 .devices = { 2059 { "DViCO FusionHDTV DVB-T Dual Digital 4", 2060 { NULL }, 2061 { &cxusb_table[DVICO_BLUEBIRD_DUAL_4], NULL }, 2062 }, 2063 } 2064}; 2065 2066static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties = { 2067 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 2068 2069 .usb_ctrl = CYPRESS_FX2, 2070 .identify_state = bluebird_fx2_identify_state, 2071 2072 .size_of_priv = sizeof(struct cxusb_state), 2073 2074 .num_adapters = 1, 2075 .adapter = { 2076 { 2077 .num_frontends = 1, 2078 .fe = {{ 2079 .streaming_ctrl = cxusb_streaming_ctrl, 2080 .frontend_attach = cxusb_nano2_frontend_attach, 2081 .tuner_attach = cxusb_dvico_xc3028_tuner_attach, 2082 /* parameter for the MPEG2-data transfer */ 2083 .stream = { 2084 .type = USB_BULK, 2085 .count = 5, 2086 .endpoint = 0x02, 2087 .u = { 2088 .bulk = { 2089 .buffersize = 8192, 2090 } 2091 } 2092 }, 2093 } }, 2094 }, 2095 }, 2096 2097 .power_ctrl = cxusb_nano2_power_ctrl, 2098 2099 .i2c_algo = &cxusb_i2c_algo, 2100 2101 .generic_bulk_ctrl_endpoint = 0x01, 2102 2103 .rc.core = { 2104 .rc_interval = 100, 2105 .rc_codes = RC_MAP_DVICO_PORTABLE, 2106 .module_name = KBUILD_MODNAME, 2107 .rc_query = cxusb_bluebird2_rc_query, 2108 .allowed_protos = RC_PROTO_BIT_NEC, 2109 }, 2110 2111 .num_device_descs = 1, 2112 .devices = { 2113 { "DViCO FusionHDTV DVB-T NANO2", 2114 { NULL }, 2115 { &cxusb_table[DVICO_BLUEBIRD_DVB_T_NANO_2], NULL }, 2116 }, 2117 } 2118}; 2119 2120static struct dvb_usb_device_properties 2121cxusb_bluebird_nano2_needsfirmware_properties = { 2122 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 2123 2124 .usb_ctrl = DEVICE_SPECIFIC, 2125 .firmware = "dvb-usb-bluebird-02.fw", 2126 .download_firmware = bluebird_patch_dvico_firmware_download, 2127 .identify_state = bluebird_fx2_identify_state, 2128 2129 .size_of_priv = sizeof(struct cxusb_state), 2130 2131 .num_adapters = 1, 2132 .adapter = { 2133 { 2134 .num_frontends = 1, 2135 .fe = {{ 2136 .streaming_ctrl = cxusb_streaming_ctrl, 2137 .frontend_attach = cxusb_nano2_frontend_attach, 2138 .tuner_attach = cxusb_dvico_xc3028_tuner_attach, 2139 /* parameter for the MPEG2-data transfer */ 2140 .stream = { 2141 .type = USB_BULK, 2142 .count = 5, 2143 .endpoint = 0x02, 2144 .u = { 2145 .bulk = { 2146 .buffersize = 8192, 2147 } 2148 } 2149 }, 2150 } }, 2151 }, 2152 }, 2153 2154 .power_ctrl = cxusb_nano2_power_ctrl, 2155 2156 .i2c_algo = &cxusb_i2c_algo, 2157 2158 .generic_bulk_ctrl_endpoint = 0x01, 2159 2160 .rc.core = { 2161 .rc_interval = 100, 2162 .rc_codes = RC_MAP_DVICO_PORTABLE, 2163 .module_name = KBUILD_MODNAME, 2164 .rc_query = cxusb_rc_query, 2165 .allowed_protos = RC_PROTO_BIT_NEC, 2166 }, 2167 2168 .num_device_descs = 1, 2169 .devices = { { 2170 "DViCO FusionHDTV DVB-T NANO2 w/o firmware", 2171 { &cxusb_table[DVICO_BLUEBIRD_DVB_T_NANO_2], NULL }, 2172 { &cxusb_table[DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM], 2173 NULL }, 2174 }, 2175 } 2176}; 2177 2178static struct dvb_usb_device_properties cxusb_aver_a868r_properties = { 2179 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 2180 2181 .usb_ctrl = CYPRESS_FX2, 2182 2183 .size_of_priv = sizeof(struct cxusb_state), 2184 2185 .num_adapters = 1, 2186 .adapter = { 2187 { 2188 .num_frontends = 1, 2189 .fe = {{ 2190 .streaming_ctrl = cxusb_aver_streaming_ctrl, 2191 .frontend_attach = cxusb_aver_lgdt3303_frontend_attach, 2192 .tuner_attach = cxusb_mxl5003s_tuner_attach, 2193 /* parameter for the MPEG2-data transfer */ 2194 .stream = { 2195 .type = USB_BULK, 2196 .count = 5, 2197 .endpoint = 0x04, 2198 .u = { 2199 .bulk = { 2200 .buffersize = 8192, 2201 } 2202 } 2203 }, 2204 } }, 2205 }, 2206 }, 2207 .power_ctrl = cxusb_aver_power_ctrl, 2208 2209 .i2c_algo = &cxusb_i2c_algo, 2210 2211 .generic_bulk_ctrl_endpoint = 0x01, 2212 2213 .num_device_descs = 1, 2214 .devices = { 2215 { "AVerMedia AVerTVHD Volar (A868R)", 2216 { NULL }, 2217 { &cxusb_table[AVERMEDIA_VOLAR_A868R], NULL }, 2218 }, 2219 } 2220}; 2221 2222static 2223struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties = { 2224 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 2225 2226 .usb_ctrl = CYPRESS_FX2, 2227 2228 .size_of_priv = sizeof(struct cxusb_state), 2229 2230 .num_adapters = 1, 2231 .adapter = { 2232 { 2233 .size_of_priv = sizeof(struct dib0700_adapter_state), 2234 .num_frontends = 1, 2235 .fe = {{ 2236 .streaming_ctrl = cxusb_streaming_ctrl, 2237 .frontend_attach = cxusb_dualdig4_rev2_frontend_attach, 2238 .tuner_attach = cxusb_dualdig4_rev2_tuner_attach, 2239 /* parameter for the MPEG2-data transfer */ 2240 .stream = { 2241 .type = USB_BULK, 2242 .count = 7, 2243 .endpoint = 0x02, 2244 .u = { 2245 .bulk = { 2246 .buffersize = 4096, 2247 } 2248 } 2249 }, 2250 } }, 2251 }, 2252 }, 2253 2254 .power_ctrl = cxusb_bluebird_power_ctrl, 2255 2256 .i2c_algo = &cxusb_i2c_algo, 2257 2258 .generic_bulk_ctrl_endpoint = 0x01, 2259 2260 .rc.core = { 2261 .rc_interval = 100, 2262 .rc_codes = RC_MAP_DVICO_MCE, 2263 .module_name = KBUILD_MODNAME, 2264 .rc_query = cxusb_rc_query, 2265 .allowed_protos = RC_PROTO_BIT_NEC, 2266 }, 2267 2268 .num_device_descs = 1, 2269 .devices = { 2270 { "DViCO FusionHDTV DVB-T Dual Digital 4 (rev 2)", 2271 { NULL }, 2272 { &cxusb_table[DVICO_BLUEBIRD_DUAL_4_REV_2], NULL }, 2273 }, 2274 } 2275}; 2276 2277static struct dvb_usb_device_properties cxusb_d680_dmb_properties = { 2278 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 2279 2280 .usb_ctrl = CYPRESS_FX2, 2281 2282 .size_of_priv = sizeof(struct cxusb_state), 2283 2284 .num_adapters = 1, 2285 .adapter = { 2286 { 2287 .num_frontends = 1, 2288 .fe = {{ 2289 .streaming_ctrl = cxusb_d680_dmb_streaming_ctrl, 2290 .frontend_attach = cxusb_d680_dmb_frontend_attach, 2291 .tuner_attach = cxusb_d680_dmb_tuner_attach, 2292 2293 /* parameter for the MPEG2-data transfer */ 2294 .stream = { 2295 .type = USB_BULK, 2296 .count = 5, 2297 .endpoint = 0x02, 2298 .u = { 2299 .bulk = { 2300 .buffersize = 8192, 2301 } 2302 } 2303 }, 2304 } }, 2305 }, 2306 }, 2307 2308 .power_ctrl = cxusb_d680_dmb_power_ctrl, 2309 2310 .i2c_algo = &cxusb_i2c_algo, 2311 2312 .generic_bulk_ctrl_endpoint = 0x01, 2313 2314 .rc.core = { 2315 .rc_interval = 100, 2316 .rc_codes = RC_MAP_TOTAL_MEDIA_IN_HAND_02, 2317 .module_name = KBUILD_MODNAME, 2318 .rc_query = cxusb_d680_dmb_rc_query, 2319 .allowed_protos = RC_PROTO_BIT_UNKNOWN, 2320 }, 2321 2322 .num_device_descs = 1, 2323 .devices = { 2324 { 2325 "Conexant DMB-TH Stick", 2326 { NULL }, 2327 { &cxusb_table[CONEXANT_D680_DMB], NULL }, 2328 }, 2329 } 2330}; 2331 2332static struct dvb_usb_device_properties cxusb_mygica_d689_properties = { 2333 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 2334 2335 .usb_ctrl = CYPRESS_FX2, 2336 2337 .size_of_priv = sizeof(struct cxusb_state), 2338 2339 .num_adapters = 1, 2340 .adapter = { 2341 { 2342 .num_frontends = 1, 2343 .fe = {{ 2344 .streaming_ctrl = cxusb_d680_dmb_streaming_ctrl, 2345 .frontend_attach = cxusb_mygica_d689_frontend_attach, 2346 .tuner_attach = cxusb_mygica_d689_tuner_attach, 2347 2348 /* parameter for the MPEG2-data transfer */ 2349 .stream = { 2350 .type = USB_BULK, 2351 .count = 5, 2352 .endpoint = 0x02, 2353 .u = { 2354 .bulk = { 2355 .buffersize = 8192, 2356 } 2357 } 2358 }, 2359 } }, 2360 }, 2361 }, 2362 2363 .power_ctrl = cxusb_d680_dmb_power_ctrl, 2364 2365 .i2c_algo = &cxusb_i2c_algo, 2366 2367 .generic_bulk_ctrl_endpoint = 0x01, 2368 2369 .rc.core = { 2370 .rc_interval = 100, 2371 .rc_codes = RC_MAP_D680_DMB, 2372 .module_name = KBUILD_MODNAME, 2373 .rc_query = cxusb_d680_dmb_rc_query, 2374 .allowed_protos = RC_PROTO_BIT_UNKNOWN, 2375 }, 2376 2377 .num_device_descs = 1, 2378 .devices = { 2379 { 2380 "Mygica D689 DMB-TH", 2381 { NULL }, 2382 { &cxusb_table[MYGICA_D689], NULL }, 2383 }, 2384 } 2385}; 2386 2387static struct usb_driver cxusb_driver = { 2388 .name = "dvb_usb_cxusb", 2389 .probe = cxusb_probe, 2390 .disconnect = cxusb_disconnect, 2391 .id_table = cxusb_table, 2392}; 2393 2394module_usb_driver(cxusb_driver); 2395 2396MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>"); 2397MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>"); 2398MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>"); 2399MODULE_AUTHOR("Maciej S. Szmigiero <mail@maciej.szmigiero.name>"); 2400MODULE_DESCRIPTION("Driver for Conexant USB2.0 hybrid reference design"); 2401MODULE_LICENSE("GPL"); 2402