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