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