1 /* DVB USB compliant linux driver for Technotrend DVB USB boxes and clones 2 * (e.g. Pinnacle 400e DVB-S USB2.0). 3 * 4 * The Pinnacle 400e uses the same protocol as the Technotrend USB1.1 boxes. 5 * 6 * TDA8263 + TDA10086 7 * 8 * I2C addresses: 9 * 0x08 - LNBP21PD - LNB power supply 10 * 0x0e - TDA10086 - Demodulator 11 * 0x50 - FX2 eeprom 12 * 0x60 - TDA8263 - Tuner 13 * 0x78 ??? 14 * 15 * Copyright (c) 2002 Holger Waechtler <holger@convergence.de> 16 * Copyright (c) 2003 Felix Domke <tmbinc@elitedvb.net> 17 * Copyright (C) 2005-6 Patrick Boettcher <pb@linuxtv.org> 18 * 19 * This program is free software; you can redistribute it and/or modify it 20 * under the terms of the GNU General Public License as published by the Free 21 * Software Foundation, version 2. 22 * 23 * see Documentation/dvb/README.dvb-usb for more information 24 */ 25 #define DVB_USB_LOG_PREFIX "ttusb2" 26 #include "dvb-usb.h" 27 28 #include "ttusb2.h" 29 30 #include "tda826x.h" 31 #include "tda10086.h" 32 #include "tda1002x.h" 33 #include "tda10048.h" 34 #include "tda827x.h" 35 #include "lnbp21.h" 36 /* CA */ 37 #include "dvb_ca_en50221.h" 38 39 /* debug */ 40 static int dvb_usb_ttusb2_debug; 41 #define deb_info(args...) dprintk(dvb_usb_ttusb2_debug,0x01,args) 42 module_param_named(debug,dvb_usb_ttusb2_debug, int, 0644); 43 MODULE_PARM_DESC(debug, "set debugging level (1=info (or-able))." DVB_USB_DEBUG_STATUS); 44 static int dvb_usb_ttusb2_debug_ci; 45 module_param_named(debug_ci,dvb_usb_ttusb2_debug_ci, int, 0644); 46 MODULE_PARM_DESC(debug_ci, "set debugging ci." DVB_USB_DEBUG_STATUS); 47 48 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); 49 50 #define ci_dbg(format, arg...) \ 51 do { \ 52 if (dvb_usb_ttusb2_debug_ci) \ 53 printk(KERN_DEBUG DVB_USB_LOG_PREFIX \ 54 ": %s " format "\n" , __func__, ## arg); \ 55 } while (0) 56 57 enum { 58 TT3650_CMD_CI_TEST = 0x40, 59 TT3650_CMD_CI_RD_CTRL, 60 TT3650_CMD_CI_WR_CTRL, 61 TT3650_CMD_CI_RD_ATTR, 62 TT3650_CMD_CI_WR_ATTR, 63 TT3650_CMD_CI_RESET, 64 TT3650_CMD_CI_SET_VIDEO_PORT 65 }; 66 67 struct ttusb2_state { 68 struct dvb_ca_en50221 ca; 69 struct mutex ca_mutex; 70 u8 id; 71 u16 last_rc_key; 72 }; 73 74 static int ttusb2_msg(struct dvb_usb_device *d, u8 cmd, 75 u8 *wbuf, int wlen, u8 *rbuf, int rlen) 76 { 77 struct ttusb2_state *st = d->priv; 78 u8 *s, *r = NULL; 79 int ret = 0; 80 81 s = kzalloc(wlen+4, GFP_KERNEL); 82 if (!s) 83 return -ENOMEM; 84 85 r = kzalloc(64, GFP_KERNEL); 86 if (!r) { 87 kfree(s); 88 return -ENOMEM; 89 } 90 91 s[0] = 0xaa; 92 s[1] = ++st->id; 93 s[2] = cmd; 94 s[3] = wlen; 95 memcpy(&s[4],wbuf,wlen); 96 97 ret = dvb_usb_generic_rw(d, s, wlen+4, r, 64, 0); 98 99 if (ret != 0 || 100 r[0] != 0x55 || 101 r[1] != s[1] || 102 r[2] != cmd || 103 (rlen > 0 && r[3] != rlen)) { 104 warn("there might have been an error during control message transfer. (rlen = %d, was %d)",rlen,r[3]); 105 kfree(s); 106 kfree(r); 107 return -EIO; 108 } 109 110 if (rlen > 0) 111 memcpy(rbuf, &r[4], rlen); 112 113 kfree(s); 114 kfree(r); 115 116 return 0; 117 } 118 119 /* ci */ 120 static int tt3650_ci_msg(struct dvb_usb_device *d, u8 cmd, u8 *data, unsigned int write_len, unsigned int read_len) 121 { 122 int ret; 123 u8 rx[60];/* (64 -4) */ 124 ret = ttusb2_msg(d, cmd, data, write_len, rx, read_len); 125 if (!ret) 126 memcpy(data, rx, read_len); 127 return ret; 128 } 129 130 static int tt3650_ci_msg_locked(struct dvb_ca_en50221 *ca, u8 cmd, u8 *data, unsigned int write_len, unsigned int read_len) 131 { 132 struct dvb_usb_device *d = ca->data; 133 struct ttusb2_state *state = d->priv; 134 int ret; 135 136 mutex_lock(&state->ca_mutex); 137 ret = tt3650_ci_msg(d, cmd, data, write_len, read_len); 138 mutex_unlock(&state->ca_mutex); 139 140 return ret; 141 } 142 143 static int tt3650_ci_read_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address) 144 { 145 u8 buf[3]; 146 int ret = 0; 147 148 if (slot) 149 return -EINVAL; 150 151 buf[0] = (address >> 8) & 0x0F; 152 buf[1] = address; 153 154 155 ret = tt3650_ci_msg_locked(ca, TT3650_CMD_CI_RD_ATTR, buf, 2, 3); 156 157 ci_dbg("%04x -> %d 0x%02x", address, ret, buf[2]); 158 159 if (ret < 0) 160 return ret; 161 162 return buf[2]; 163 } 164 165 static int tt3650_ci_write_attribute_mem(struct dvb_ca_en50221 *ca, int slot, int address, u8 value) 166 { 167 u8 buf[3]; 168 169 ci_dbg("%d 0x%04x 0x%02x", slot, address, value); 170 171 if (slot) 172 return -EINVAL; 173 174 buf[0] = (address >> 8) & 0x0F; 175 buf[1] = address; 176 buf[2] = value; 177 178 return tt3650_ci_msg_locked(ca, TT3650_CMD_CI_WR_ATTR, buf, 3, 3); 179 } 180 181 static int tt3650_ci_read_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address) 182 { 183 u8 buf[2]; 184 int ret; 185 186 if (slot) 187 return -EINVAL; 188 189 buf[0] = address & 3; 190 191 ret = tt3650_ci_msg_locked(ca, TT3650_CMD_CI_RD_CTRL, buf, 1, 2); 192 193 ci_dbg("0x%02x -> %d 0x%02x", address, ret, buf[1]); 194 195 if (ret < 0) 196 return ret; 197 198 return buf[1]; 199 } 200 201 static int tt3650_ci_write_cam_control(struct dvb_ca_en50221 *ca, int slot, u8 address, u8 value) 202 { 203 u8 buf[2]; 204 205 ci_dbg("%d 0x%02x 0x%02x", slot, address, value); 206 207 if (slot) 208 return -EINVAL; 209 210 buf[0] = address; 211 buf[1] = value; 212 213 return tt3650_ci_msg_locked(ca, TT3650_CMD_CI_WR_CTRL, buf, 2, 2); 214 } 215 216 static int tt3650_ci_set_video_port(struct dvb_ca_en50221 *ca, int slot, int enable) 217 { 218 u8 buf[1]; 219 int ret; 220 221 ci_dbg("%d %d", slot, enable); 222 223 if (slot) 224 return -EINVAL; 225 226 buf[0] = enable; 227 228 ret = tt3650_ci_msg_locked(ca, TT3650_CMD_CI_SET_VIDEO_PORT, buf, 1, 1); 229 if (ret < 0) 230 return ret; 231 232 if (enable != buf[0]) { 233 err("CI not %sabled.", enable ? "en" : "dis"); 234 return -EIO; 235 } 236 237 return 0; 238 } 239 240 static int tt3650_ci_slot_shutdown(struct dvb_ca_en50221 *ca, int slot) 241 { 242 return tt3650_ci_set_video_port(ca, slot, 0); 243 } 244 245 static int tt3650_ci_slot_ts_enable(struct dvb_ca_en50221 *ca, int slot) 246 { 247 return tt3650_ci_set_video_port(ca, slot, 1); 248 } 249 250 static int tt3650_ci_slot_reset(struct dvb_ca_en50221 *ca, int slot) 251 { 252 struct dvb_usb_device *d = ca->data; 253 struct ttusb2_state *state = d->priv; 254 u8 buf[1]; 255 int ret; 256 257 ci_dbg("%d", slot); 258 259 if (slot) 260 return -EINVAL; 261 262 buf[0] = 0; 263 264 mutex_lock(&state->ca_mutex); 265 266 ret = tt3650_ci_msg(d, TT3650_CMD_CI_RESET, buf, 1, 1); 267 if (ret) 268 goto failed; 269 270 msleep(500); 271 272 buf[0] = 1; 273 274 ret = tt3650_ci_msg(d, TT3650_CMD_CI_RESET, buf, 1, 1); 275 if (ret) 276 goto failed; 277 278 msleep(500); 279 280 buf[0] = 0; /* FTA */ 281 282 ret = tt3650_ci_msg(d, TT3650_CMD_CI_SET_VIDEO_PORT, buf, 1, 1); 283 284 msleep(1100); 285 286 failed: 287 mutex_unlock(&state->ca_mutex); 288 289 return ret; 290 } 291 292 static int tt3650_ci_poll_slot_status(struct dvb_ca_en50221 *ca, int slot, int open) 293 { 294 u8 buf[1]; 295 int ret; 296 297 if (slot) 298 return -EINVAL; 299 300 ret = tt3650_ci_msg_locked(ca, TT3650_CMD_CI_TEST, buf, 0, 1); 301 if (ret) 302 return ret; 303 304 if (1 == buf[0]) { 305 return DVB_CA_EN50221_POLL_CAM_PRESENT | 306 DVB_CA_EN50221_POLL_CAM_READY; 307 } 308 return 0; 309 } 310 311 static void tt3650_ci_uninit(struct dvb_usb_device *d) 312 { 313 struct ttusb2_state *state; 314 315 ci_dbg(""); 316 317 if (NULL == d) 318 return; 319 320 state = d->priv; 321 if (NULL == state) 322 return; 323 324 if (NULL == state->ca.data) 325 return; 326 327 dvb_ca_en50221_release(&state->ca); 328 329 memset(&state->ca, 0, sizeof(state->ca)); 330 } 331 332 static int tt3650_ci_init(struct dvb_usb_adapter *a) 333 { 334 struct dvb_usb_device *d = a->dev; 335 struct ttusb2_state *state = d->priv; 336 int ret; 337 338 ci_dbg(""); 339 340 mutex_init(&state->ca_mutex); 341 342 state->ca.owner = THIS_MODULE; 343 state->ca.read_attribute_mem = tt3650_ci_read_attribute_mem; 344 state->ca.write_attribute_mem = tt3650_ci_write_attribute_mem; 345 state->ca.read_cam_control = tt3650_ci_read_cam_control; 346 state->ca.write_cam_control = tt3650_ci_write_cam_control; 347 state->ca.slot_reset = tt3650_ci_slot_reset; 348 state->ca.slot_shutdown = tt3650_ci_slot_shutdown; 349 state->ca.slot_ts_enable = tt3650_ci_slot_ts_enable; 350 state->ca.poll_slot_status = tt3650_ci_poll_slot_status; 351 state->ca.data = d; 352 353 ret = dvb_ca_en50221_init(&a->dvb_adap, 354 &state->ca, 355 /* flags */ 0, 356 /* n_slots */ 1); 357 if (ret) { 358 err("Cannot initialize CI: Error %d.", ret); 359 memset(&state->ca, 0, sizeof(state->ca)); 360 return ret; 361 } 362 363 info("CI initialized."); 364 365 return 0; 366 } 367 368 static int ttusb2_i2c_xfer(struct i2c_adapter *adap,struct i2c_msg msg[],int num) 369 { 370 struct dvb_usb_device *d = i2c_get_adapdata(adap); 371 static u8 obuf[60], ibuf[60]; 372 int i, write_read, read; 373 374 if (mutex_lock_interruptible(&d->i2c_mutex) < 0) 375 return -EAGAIN; 376 377 if (num > 2) 378 warn("more than 2 i2c messages at a time is not handled yet. TODO."); 379 380 for (i = 0; i < num; i++) { 381 write_read = i+1 < num && (msg[i+1].flags & I2C_M_RD); 382 read = msg[i].flags & I2C_M_RD; 383 384 obuf[0] = (msg[i].addr << 1) | (write_read | read); 385 if (read) 386 obuf[1] = 0; 387 else 388 obuf[1] = msg[i].len; 389 390 /* read request */ 391 if (write_read) 392 obuf[2] = msg[i+1].len; 393 else if (read) 394 obuf[2] = msg[i].len; 395 else 396 obuf[2] = 0; 397 398 memcpy(&obuf[3], msg[i].buf, msg[i].len); 399 400 if (ttusb2_msg(d, CMD_I2C_XFER, obuf, obuf[1]+3, ibuf, obuf[2] + 3) < 0) { 401 err("i2c transfer failed."); 402 break; 403 } 404 405 if (write_read) { 406 memcpy(msg[i+1].buf, &ibuf[3], msg[i+1].len); 407 i++; 408 } else if (read) 409 memcpy(msg[i].buf, &ibuf[3], msg[i].len); 410 } 411 412 mutex_unlock(&d->i2c_mutex); 413 return i; 414 } 415 416 static u32 ttusb2_i2c_func(struct i2c_adapter *adapter) 417 { 418 return I2C_FUNC_I2C; 419 } 420 421 static struct i2c_algorithm ttusb2_i2c_algo = { 422 .master_xfer = ttusb2_i2c_xfer, 423 .functionality = ttusb2_i2c_func, 424 }; 425 426 /* command to poll IR receiver (copied from pctv452e.c) */ 427 #define CMD_GET_IR_CODE 0x1b 428 429 /* IR */ 430 static int tt3650_rc_query(struct dvb_usb_device *d) 431 { 432 int ret; 433 u8 rx[9]; /* A CMD_GET_IR_CODE reply is 9 bytes long */ 434 struct ttusb2_state *st = d->priv; 435 ret = ttusb2_msg(d, CMD_GET_IR_CODE, NULL, 0, rx, sizeof(rx)); 436 if (ret != 0) 437 return ret; 438 439 if (rx[8] & 0x01) { 440 /* got a "press" event */ 441 st->last_rc_key = RC_SCANCODE_RC5(rx[3], rx[2]); 442 deb_info("%s: cmd=0x%02x sys=0x%02x\n", __func__, rx[2], rx[3]); 443 rc_keydown(d->rc_dev, RC_TYPE_RC5, st->last_rc_key, rx[1]); 444 } else if (st->last_rc_key) { 445 rc_keyup(d->rc_dev); 446 st->last_rc_key = 0; 447 } 448 449 return 0; 450 } 451 452 453 /* Callbacks for DVB USB */ 454 static int ttusb2_identify_state (struct usb_device *udev, struct 455 dvb_usb_device_properties *props, struct dvb_usb_device_description **desc, 456 int *cold) 457 { 458 *cold = udev->descriptor.iManufacturer == 0 && udev->descriptor.iProduct == 0; 459 return 0; 460 } 461 462 static int ttusb2_power_ctrl(struct dvb_usb_device *d, int onoff) 463 { 464 u8 b = onoff; 465 ttusb2_msg(d, CMD_POWER, &b, 0, NULL, 0); 466 return ttusb2_msg(d, CMD_POWER, &b, 1, NULL, 0); 467 } 468 469 470 static struct tda10086_config tda10086_config = { 471 .demod_address = 0x0e, 472 .invert = 0, 473 .diseqc_tone = 1, 474 .xtal_freq = TDA10086_XTAL_16M, 475 }; 476 477 static struct tda10023_config tda10023_config = { 478 .demod_address = 0x0c, 479 .invert = 0, 480 .xtal = 16000000, 481 .pll_m = 11, 482 .pll_p = 3, 483 .pll_n = 1, 484 .deltaf = 0xa511, 485 }; 486 487 static struct tda10048_config tda10048_config = { 488 .demod_address = 0x10 >> 1, 489 .output_mode = TDA10048_PARALLEL_OUTPUT, 490 .inversion = TDA10048_INVERSION_ON, 491 .dtv6_if_freq_khz = TDA10048_IF_4000, 492 .dtv7_if_freq_khz = TDA10048_IF_4500, 493 .dtv8_if_freq_khz = TDA10048_IF_5000, 494 .clk_freq_khz = TDA10048_CLK_16000, 495 .no_firmware = 1, 496 .set_pll = true , 497 .pll_m = 5, 498 .pll_n = 3, 499 .pll_p = 0, 500 }; 501 502 static struct tda827x_config tda827x_config = { 503 .config = 0, 504 }; 505 506 static int ttusb2_frontend_tda10086_attach(struct dvb_usb_adapter *adap) 507 { 508 if (usb_set_interface(adap->dev->udev,0,3) < 0) 509 err("set interface to alts=3 failed"); 510 511 if ((adap->fe_adap[0].fe = dvb_attach(tda10086_attach, &tda10086_config, &adap->dev->i2c_adap)) == NULL) { 512 deb_info("TDA10086 attach failed\n"); 513 return -ENODEV; 514 } 515 516 return 0; 517 } 518 519 static int ttusb2_ct3650_i2c_gate_ctrl(struct dvb_frontend *fe, int enable) 520 { 521 struct dvb_usb_adapter *adap = fe->dvb->priv; 522 523 return adap->fe_adap[0].fe->ops.i2c_gate_ctrl(adap->fe_adap[0].fe, enable); 524 } 525 526 static int ttusb2_frontend_tda10023_attach(struct dvb_usb_adapter *adap) 527 { 528 if (usb_set_interface(adap->dev->udev, 0, 3) < 0) 529 err("set interface to alts=3 failed"); 530 531 if (adap->fe_adap[0].fe == NULL) { 532 /* FE 0 DVB-C */ 533 adap->fe_adap[0].fe = dvb_attach(tda10023_attach, 534 &tda10023_config, &adap->dev->i2c_adap, 0x48); 535 536 if (adap->fe_adap[0].fe == NULL) { 537 deb_info("TDA10023 attach failed\n"); 538 return -ENODEV; 539 } 540 tt3650_ci_init(adap); 541 } else { 542 adap->fe_adap[1].fe = dvb_attach(tda10048_attach, 543 &tda10048_config, &adap->dev->i2c_adap); 544 545 if (adap->fe_adap[1].fe == NULL) { 546 deb_info("TDA10048 attach failed\n"); 547 return -ENODEV; 548 } 549 550 /* tuner is behind TDA10023 I2C-gate */ 551 adap->fe_adap[1].fe->ops.i2c_gate_ctrl = ttusb2_ct3650_i2c_gate_ctrl; 552 553 } 554 555 return 0; 556 } 557 558 static int ttusb2_tuner_tda827x_attach(struct dvb_usb_adapter *adap) 559 { 560 struct dvb_frontend *fe; 561 562 /* MFE: select correct FE to attach tuner since that's called twice */ 563 if (adap->fe_adap[1].fe == NULL) 564 fe = adap->fe_adap[0].fe; 565 else 566 fe = adap->fe_adap[1].fe; 567 568 /* attach tuner */ 569 if (dvb_attach(tda827x_attach, fe, 0x61, &adap->dev->i2c_adap, &tda827x_config) == NULL) { 570 printk(KERN_ERR "%s: No tda827x found!\n", __func__); 571 return -ENODEV; 572 } 573 return 0; 574 } 575 576 static int ttusb2_tuner_tda826x_attach(struct dvb_usb_adapter *adap) 577 { 578 if (dvb_attach(tda826x_attach, adap->fe_adap[0].fe, 0x60, &adap->dev->i2c_adap, 0) == NULL) { 579 deb_info("TDA8263 attach failed\n"); 580 return -ENODEV; 581 } 582 583 if (dvb_attach(lnbp21_attach, adap->fe_adap[0].fe, &adap->dev->i2c_adap, 0, 0) == NULL) { 584 deb_info("LNBP21 attach failed\n"); 585 return -ENODEV; 586 } 587 return 0; 588 } 589 590 /* DVB USB Driver stuff */ 591 static struct dvb_usb_device_properties ttusb2_properties; 592 static struct dvb_usb_device_properties ttusb2_properties_s2400; 593 static struct dvb_usb_device_properties ttusb2_properties_ct3650; 594 595 static void ttusb2_usb_disconnect(struct usb_interface *intf) 596 { 597 struct dvb_usb_device *d = usb_get_intfdata(intf); 598 599 tt3650_ci_uninit(d); 600 dvb_usb_device_exit(intf); 601 } 602 603 static int ttusb2_probe(struct usb_interface *intf, 604 const struct usb_device_id *id) 605 { 606 if (0 == dvb_usb_device_init(intf, &ttusb2_properties, 607 THIS_MODULE, NULL, adapter_nr) || 608 0 == dvb_usb_device_init(intf, &ttusb2_properties_s2400, 609 THIS_MODULE, NULL, adapter_nr) || 610 0 == dvb_usb_device_init(intf, &ttusb2_properties_ct3650, 611 THIS_MODULE, NULL, adapter_nr)) 612 return 0; 613 return -ENODEV; 614 } 615 616 static struct usb_device_id ttusb2_table [] = { 617 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PCTV_400E) }, 618 { USB_DEVICE(USB_VID_PINNACLE, USB_PID_PCTV_450E) }, 619 { USB_DEVICE(USB_VID_TECHNOTREND, 620 USB_PID_TECHNOTREND_CONNECT_S2400) }, 621 { USB_DEVICE(USB_VID_TECHNOTREND, 622 USB_PID_TECHNOTREND_CONNECT_CT3650) }, 623 { USB_DEVICE(USB_VID_TECHNOTREND, 624 USB_PID_TECHNOTREND_CONNECT_S2400_8KEEPROM) }, 625 {} /* Terminating entry */ 626 }; 627 MODULE_DEVICE_TABLE (usb, ttusb2_table); 628 629 static struct dvb_usb_device_properties ttusb2_properties = { 630 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 631 632 .usb_ctrl = CYPRESS_FX2, 633 .firmware = "dvb-usb-pctv-400e-01.fw", 634 635 .size_of_priv = sizeof(struct ttusb2_state), 636 637 .num_adapters = 1, 638 .adapter = { 639 { 640 .num_frontends = 1, 641 .fe = {{ 642 .streaming_ctrl = NULL, // ttusb2_streaming_ctrl, 643 644 .frontend_attach = ttusb2_frontend_tda10086_attach, 645 .tuner_attach = ttusb2_tuner_tda826x_attach, 646 647 /* parameter for the MPEG2-data transfer */ 648 .stream = { 649 .type = USB_ISOC, 650 .count = 5, 651 .endpoint = 0x02, 652 .u = { 653 .isoc = { 654 .framesperurb = 4, 655 .framesize = 940, 656 .interval = 1, 657 } 658 } 659 } 660 }}, 661 } 662 }, 663 664 .power_ctrl = ttusb2_power_ctrl, 665 .identify_state = ttusb2_identify_state, 666 667 .i2c_algo = &ttusb2_i2c_algo, 668 669 .generic_bulk_ctrl_endpoint = 0x01, 670 671 .num_device_descs = 2, 672 .devices = { 673 { "Pinnacle 400e DVB-S USB2.0", 674 { &ttusb2_table[0], NULL }, 675 { NULL }, 676 }, 677 { "Pinnacle 450e DVB-S USB2.0", 678 { &ttusb2_table[1], NULL }, 679 { NULL }, 680 }, 681 } 682 }; 683 684 static struct dvb_usb_device_properties ttusb2_properties_s2400 = { 685 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 686 687 .usb_ctrl = CYPRESS_FX2, 688 .firmware = "dvb-usb-tt-s2400-01.fw", 689 690 .size_of_priv = sizeof(struct ttusb2_state), 691 692 .num_adapters = 1, 693 .adapter = { 694 { 695 .num_frontends = 1, 696 .fe = {{ 697 .streaming_ctrl = NULL, 698 699 .frontend_attach = ttusb2_frontend_tda10086_attach, 700 .tuner_attach = ttusb2_tuner_tda826x_attach, 701 702 /* parameter for the MPEG2-data transfer */ 703 .stream = { 704 .type = USB_ISOC, 705 .count = 5, 706 .endpoint = 0x02, 707 .u = { 708 .isoc = { 709 .framesperurb = 4, 710 .framesize = 940, 711 .interval = 1, 712 } 713 } 714 } 715 }}, 716 } 717 }, 718 719 .power_ctrl = ttusb2_power_ctrl, 720 .identify_state = ttusb2_identify_state, 721 722 .i2c_algo = &ttusb2_i2c_algo, 723 724 .generic_bulk_ctrl_endpoint = 0x01, 725 726 .num_device_descs = 2, 727 .devices = { 728 { "Technotrend TT-connect S-2400", 729 { &ttusb2_table[2], NULL }, 730 { NULL }, 731 }, 732 { "Technotrend TT-connect S-2400 (8kB EEPROM)", 733 { &ttusb2_table[4], NULL }, 734 { NULL }, 735 }, 736 } 737 }; 738 739 static struct dvb_usb_device_properties ttusb2_properties_ct3650 = { 740 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 741 742 .usb_ctrl = CYPRESS_FX2, 743 744 .size_of_priv = sizeof(struct ttusb2_state), 745 746 .rc.core = { 747 .rc_interval = 150, /* Less than IR_KEYPRESS_TIMEOUT */ 748 .rc_codes = RC_MAP_TT_1500, 749 .rc_query = tt3650_rc_query, 750 .allowed_protos = RC_BIT_RC5, 751 }, 752 753 .num_adapters = 1, 754 .adapter = { 755 { 756 .num_frontends = 2, 757 .fe = {{ 758 .streaming_ctrl = NULL, 759 760 .frontend_attach = ttusb2_frontend_tda10023_attach, 761 .tuner_attach = ttusb2_tuner_tda827x_attach, 762 763 /* parameter for the MPEG2-data transfer */ 764 .stream = { 765 .type = USB_ISOC, 766 .count = 5, 767 .endpoint = 0x02, 768 .u = { 769 .isoc = { 770 .framesperurb = 4, 771 .framesize = 940, 772 .interval = 1, 773 } 774 } 775 } 776 }, { 777 .streaming_ctrl = NULL, 778 779 .frontend_attach = ttusb2_frontend_tda10023_attach, 780 .tuner_attach = ttusb2_tuner_tda827x_attach, 781 782 /* parameter for the MPEG2-data transfer */ 783 .stream = { 784 .type = USB_ISOC, 785 .count = 5, 786 .endpoint = 0x02, 787 .u = { 788 .isoc = { 789 .framesperurb = 4, 790 .framesize = 940, 791 .interval = 1, 792 } 793 } 794 } 795 }}, 796 }, 797 }, 798 799 .power_ctrl = ttusb2_power_ctrl, 800 .identify_state = ttusb2_identify_state, 801 802 .i2c_algo = &ttusb2_i2c_algo, 803 804 .generic_bulk_ctrl_endpoint = 0x01, 805 806 .num_device_descs = 1, 807 .devices = { 808 { "Technotrend TT-connect CT-3650", 809 .warm_ids = { &ttusb2_table[3], NULL }, 810 }, 811 } 812 }; 813 814 static struct usb_driver ttusb2_driver = { 815 .name = "dvb_usb_ttusb2", 816 .probe = ttusb2_probe, 817 .disconnect = ttusb2_usb_disconnect, 818 .id_table = ttusb2_table, 819 }; 820 821 module_usb_driver(ttusb2_driver); 822 823 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>"); 824 MODULE_DESCRIPTION("Driver for Pinnacle PCTV 400e DVB-S USB2.0"); 825 MODULE_VERSION("1.0"); 826 MODULE_LICENSE("GPL"); 827