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