1 /* DVB USB framework compliant Linux driver for the 2 * DVBWorld DVB-S 2101, 2102, DVB-S2 2104, DVB-C 3101, 3 * TeVii S600, S630, S650, S660, S480, S421, S632 4 * Prof 1100, 7500, 5 * Geniatech SU3000, T220, 6 * TechnoTrend S2-4600 Cards 7 * Copyright (C) 2008-2012 Igor M. Liplianin (liplianin@me.by) 8 * 9 * This program is free software; you can redistribute it and/or modify it 10 * under the terms of the GNU General Public License as published by the 11 * Free Software Foundation, version 2. 12 * 13 * see Documentation/dvb/README.dvb-usb for more information 14 */ 15 #include "dw2102.h" 16 #include "si21xx.h" 17 #include "stv0299.h" 18 #include "z0194a.h" 19 #include "stv0288.h" 20 #include "stb6000.h" 21 #include "eds1547.h" 22 #include "cx24116.h" 23 #include "tda1002x.h" 24 #include "mt312.h" 25 #include "zl10039.h" 26 #include "ts2020.h" 27 #include "ds3000.h" 28 #include "stv0900.h" 29 #include "stv6110.h" 30 #include "stb6100.h" 31 #include "stb6100_proc.h" 32 #include "m88rs2000.h" 33 #include "tda18271.h" 34 #include "cxd2820r.h" 35 #include "m88ds3103.h" 36 #include "ts2020.h" 37 38 /* Max transfer size done by I2C transfer functions */ 39 #define MAX_XFER_SIZE 64 40 41 #ifndef USB_PID_DW2102 42 #define USB_PID_DW2102 0x2102 43 #endif 44 45 #ifndef USB_PID_DW2104 46 #define USB_PID_DW2104 0x2104 47 #endif 48 49 #ifndef USB_PID_DW3101 50 #define USB_PID_DW3101 0x3101 51 #endif 52 53 #ifndef USB_PID_CINERGY_S 54 #define USB_PID_CINERGY_S 0x0064 55 #endif 56 57 #ifndef USB_PID_TEVII_S630 58 #define USB_PID_TEVII_S630 0xd630 59 #endif 60 61 #ifndef USB_PID_TEVII_S650 62 #define USB_PID_TEVII_S650 0xd650 63 #endif 64 65 #ifndef USB_PID_TEVII_S660 66 #define USB_PID_TEVII_S660 0xd660 67 #endif 68 69 #ifndef USB_PID_TEVII_S480_1 70 #define USB_PID_TEVII_S480_1 0xd481 71 #endif 72 73 #ifndef USB_PID_TEVII_S480_2 74 #define USB_PID_TEVII_S480_2 0xd482 75 #endif 76 77 #ifndef USB_PID_PROF_1100 78 #define USB_PID_PROF_1100 0xb012 79 #endif 80 81 #ifndef USB_PID_TEVII_S421 82 #define USB_PID_TEVII_S421 0xd421 83 #endif 84 85 #ifndef USB_PID_TEVII_S632 86 #define USB_PID_TEVII_S632 0xd632 87 #endif 88 89 #ifndef USB_PID_GOTVIEW_SAT_HD 90 #define USB_PID_GOTVIEW_SAT_HD 0x5456 91 #endif 92 93 #define DW210X_READ_MSG 0 94 #define DW210X_WRITE_MSG 1 95 96 #define REG_1F_SYMBOLRATE_BYTE0 0x1f 97 #define REG_20_SYMBOLRATE_BYTE1 0x20 98 #define REG_21_SYMBOLRATE_BYTE2 0x21 99 /* on my own*/ 100 #define DW2102_VOLTAGE_CTRL (0x1800) 101 #define SU3000_STREAM_CTRL (0x1900) 102 #define DW2102_RC_QUERY (0x1a00) 103 #define DW2102_LED_CTRL (0x1b00) 104 105 #define DW2101_FIRMWARE "dvb-usb-dw2101.fw" 106 #define DW2102_FIRMWARE "dvb-usb-dw2102.fw" 107 #define DW2104_FIRMWARE "dvb-usb-dw2104.fw" 108 #define DW3101_FIRMWARE "dvb-usb-dw3101.fw" 109 #define S630_FIRMWARE "dvb-usb-s630.fw" 110 #define S660_FIRMWARE "dvb-usb-s660.fw" 111 #define P1100_FIRMWARE "dvb-usb-p1100.fw" 112 #define P7500_FIRMWARE "dvb-usb-p7500.fw" 113 114 #define err_str "did not find the firmware file. (%s) " \ 115 "Please see linux/Documentation/dvb/ for more details " \ 116 "on firmware-problems." 117 118 struct dw2102_state { 119 u8 initialized; 120 struct i2c_client *i2c_client_tuner; 121 int (*old_set_voltage)(struct dvb_frontend *f, fe_sec_voltage_t v); 122 }; 123 124 /* debug */ 125 static int dvb_usb_dw2102_debug; 126 module_param_named(debug, dvb_usb_dw2102_debug, int, 0644); 127 MODULE_PARM_DESC(debug, "set debugging level (1=info 2=xfer 4=rc(or-able))." 128 DVB_USB_DEBUG_STATUS); 129 130 /* demod probe */ 131 static int demod_probe = 1; 132 module_param_named(demod, demod_probe, int, 0644); 133 MODULE_PARM_DESC(demod, "demod to probe (1=cx24116 2=stv0903+stv6110 " 134 "4=stv0903+stb6100(or-able))."); 135 136 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); 137 138 static int dw210x_op_rw(struct usb_device *dev, u8 request, u16 value, 139 u16 index, u8 * data, u16 len, int flags) 140 { 141 int ret; 142 u8 *u8buf; 143 unsigned int pipe = (flags == DW210X_READ_MSG) ? 144 usb_rcvctrlpipe(dev, 0) : usb_sndctrlpipe(dev, 0); 145 u8 request_type = (flags == DW210X_READ_MSG) ? USB_DIR_IN : USB_DIR_OUT; 146 147 u8buf = kmalloc(len, GFP_KERNEL); 148 if (!u8buf) 149 return -ENOMEM; 150 151 152 if (flags == DW210X_WRITE_MSG) 153 memcpy(u8buf, data, len); 154 ret = usb_control_msg(dev, pipe, request, request_type | USB_TYPE_VENDOR, 155 value, index , u8buf, len, 2000); 156 157 if (flags == DW210X_READ_MSG) 158 memcpy(data, u8buf, len); 159 160 kfree(u8buf); 161 return ret; 162 } 163 164 /* I2C */ 165 static int dw2102_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[], 166 int num) 167 { 168 struct dvb_usb_device *d = i2c_get_adapdata(adap); 169 int i = 0; 170 u8 buf6[] = {0x2c, 0x05, 0xc0, 0, 0, 0, 0}; 171 u16 value; 172 173 if (!d) 174 return -ENODEV; 175 if (mutex_lock_interruptible(&d->i2c_mutex) < 0) 176 return -EAGAIN; 177 178 switch (num) { 179 case 2: 180 /* read stv0299 register */ 181 value = msg[0].buf[0];/* register */ 182 for (i = 0; i < msg[1].len; i++) { 183 dw210x_op_rw(d->udev, 0xb5, value + i, 0, 184 buf6, 2, DW210X_READ_MSG); 185 msg[1].buf[i] = buf6[0]; 186 } 187 break; 188 case 1: 189 switch (msg[0].addr) { 190 case 0x68: 191 /* write to stv0299 register */ 192 buf6[0] = 0x2a; 193 buf6[1] = msg[0].buf[0]; 194 buf6[2] = msg[0].buf[1]; 195 dw210x_op_rw(d->udev, 0xb2, 0, 0, 196 buf6, 3, DW210X_WRITE_MSG); 197 break; 198 case 0x60: 199 if (msg[0].flags == 0) { 200 /* write to tuner pll */ 201 buf6[0] = 0x2c; 202 buf6[1] = 5; 203 buf6[2] = 0xc0; 204 buf6[3] = msg[0].buf[0]; 205 buf6[4] = msg[0].buf[1]; 206 buf6[5] = msg[0].buf[2]; 207 buf6[6] = msg[0].buf[3]; 208 dw210x_op_rw(d->udev, 0xb2, 0, 0, 209 buf6, 7, DW210X_WRITE_MSG); 210 } else { 211 /* read from tuner */ 212 dw210x_op_rw(d->udev, 0xb5, 0, 0, 213 buf6, 1, DW210X_READ_MSG); 214 msg[0].buf[0] = buf6[0]; 215 } 216 break; 217 case (DW2102_RC_QUERY): 218 dw210x_op_rw(d->udev, 0xb8, 0, 0, 219 buf6, 2, DW210X_READ_MSG); 220 msg[0].buf[0] = buf6[0]; 221 msg[0].buf[1] = buf6[1]; 222 break; 223 case (DW2102_VOLTAGE_CTRL): 224 buf6[0] = 0x30; 225 buf6[1] = msg[0].buf[0]; 226 dw210x_op_rw(d->udev, 0xb2, 0, 0, 227 buf6, 2, DW210X_WRITE_MSG); 228 break; 229 } 230 231 break; 232 } 233 234 mutex_unlock(&d->i2c_mutex); 235 return num; 236 } 237 238 static int dw2102_serit_i2c_transfer(struct i2c_adapter *adap, 239 struct i2c_msg msg[], int num) 240 { 241 struct dvb_usb_device *d = i2c_get_adapdata(adap); 242 u8 buf6[] = {0, 0, 0, 0, 0, 0, 0}; 243 244 if (!d) 245 return -ENODEV; 246 if (mutex_lock_interruptible(&d->i2c_mutex) < 0) 247 return -EAGAIN; 248 249 switch (num) { 250 case 2: 251 /* read si2109 register by number */ 252 buf6[0] = msg[0].addr << 1; 253 buf6[1] = msg[0].len; 254 buf6[2] = msg[0].buf[0]; 255 dw210x_op_rw(d->udev, 0xc2, 0, 0, 256 buf6, msg[0].len + 2, DW210X_WRITE_MSG); 257 /* read si2109 register */ 258 dw210x_op_rw(d->udev, 0xc3, 0xd0, 0, 259 buf6, msg[1].len + 2, DW210X_READ_MSG); 260 memcpy(msg[1].buf, buf6 + 2, msg[1].len); 261 262 break; 263 case 1: 264 switch (msg[0].addr) { 265 case 0x68: 266 /* write to si2109 register */ 267 buf6[0] = msg[0].addr << 1; 268 buf6[1] = msg[0].len; 269 memcpy(buf6 + 2, msg[0].buf, msg[0].len); 270 dw210x_op_rw(d->udev, 0xc2, 0, 0, buf6, 271 msg[0].len + 2, DW210X_WRITE_MSG); 272 break; 273 case(DW2102_RC_QUERY): 274 dw210x_op_rw(d->udev, 0xb8, 0, 0, 275 buf6, 2, DW210X_READ_MSG); 276 msg[0].buf[0] = buf6[0]; 277 msg[0].buf[1] = buf6[1]; 278 break; 279 case(DW2102_VOLTAGE_CTRL): 280 buf6[0] = 0x30; 281 buf6[1] = msg[0].buf[0]; 282 dw210x_op_rw(d->udev, 0xb2, 0, 0, 283 buf6, 2, DW210X_WRITE_MSG); 284 break; 285 } 286 break; 287 } 288 289 mutex_unlock(&d->i2c_mutex); 290 return num; 291 } 292 293 static int dw2102_earda_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[], int num) 294 { 295 struct dvb_usb_device *d = i2c_get_adapdata(adap); 296 int ret; 297 298 if (!d) 299 return -ENODEV; 300 if (mutex_lock_interruptible(&d->i2c_mutex) < 0) 301 return -EAGAIN; 302 303 switch (num) { 304 case 2: { 305 /* read */ 306 /* first write first register number */ 307 u8 ibuf[MAX_XFER_SIZE], obuf[3]; 308 309 if (2 + msg[1].len > sizeof(ibuf)) { 310 warn("i2c rd: len=%d is too big!\n", 311 msg[1].len); 312 ret = -EOPNOTSUPP; 313 goto unlock; 314 } 315 316 obuf[0] = msg[0].addr << 1; 317 obuf[1] = msg[0].len; 318 obuf[2] = msg[0].buf[0]; 319 dw210x_op_rw(d->udev, 0xc2, 0, 0, 320 obuf, msg[0].len + 2, DW210X_WRITE_MSG); 321 /* second read registers */ 322 dw210x_op_rw(d->udev, 0xc3, 0xd1 , 0, 323 ibuf, msg[1].len + 2, DW210X_READ_MSG); 324 memcpy(msg[1].buf, ibuf + 2, msg[1].len); 325 326 break; 327 } 328 case 1: 329 switch (msg[0].addr) { 330 case 0x68: { 331 /* write to register */ 332 u8 obuf[MAX_XFER_SIZE]; 333 334 if (2 + msg[0].len > sizeof(obuf)) { 335 warn("i2c wr: len=%d is too big!\n", 336 msg[1].len); 337 ret = -EOPNOTSUPP; 338 goto unlock; 339 } 340 341 obuf[0] = msg[0].addr << 1; 342 obuf[1] = msg[0].len; 343 memcpy(obuf + 2, msg[0].buf, msg[0].len); 344 dw210x_op_rw(d->udev, 0xc2, 0, 0, 345 obuf, msg[0].len + 2, DW210X_WRITE_MSG); 346 break; 347 } 348 case 0x61: { 349 /* write to tuner */ 350 u8 obuf[MAX_XFER_SIZE]; 351 352 if (2 + msg[0].len > sizeof(obuf)) { 353 warn("i2c wr: len=%d is too big!\n", 354 msg[1].len); 355 ret = -EOPNOTSUPP; 356 goto unlock; 357 } 358 359 obuf[0] = msg[0].addr << 1; 360 obuf[1] = msg[0].len; 361 memcpy(obuf + 2, msg[0].buf, msg[0].len); 362 dw210x_op_rw(d->udev, 0xc2, 0, 0, 363 obuf, msg[0].len + 2, DW210X_WRITE_MSG); 364 break; 365 } 366 case(DW2102_RC_QUERY): { 367 u8 ibuf[2]; 368 dw210x_op_rw(d->udev, 0xb8, 0, 0, 369 ibuf, 2, DW210X_READ_MSG); 370 memcpy(msg[0].buf, ibuf , 2); 371 break; 372 } 373 case(DW2102_VOLTAGE_CTRL): { 374 u8 obuf[2]; 375 obuf[0] = 0x30; 376 obuf[1] = msg[0].buf[0]; 377 dw210x_op_rw(d->udev, 0xb2, 0, 0, 378 obuf, 2, DW210X_WRITE_MSG); 379 break; 380 } 381 } 382 383 break; 384 } 385 ret = num; 386 387 unlock: 388 mutex_unlock(&d->i2c_mutex); 389 return ret; 390 } 391 392 static int dw2104_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[], int num) 393 { 394 struct dvb_usb_device *d = i2c_get_adapdata(adap); 395 int len, i, j, ret; 396 397 if (!d) 398 return -ENODEV; 399 if (mutex_lock_interruptible(&d->i2c_mutex) < 0) 400 return -EAGAIN; 401 402 for (j = 0; j < num; j++) { 403 switch (msg[j].addr) { 404 case(DW2102_RC_QUERY): { 405 u8 ibuf[2]; 406 dw210x_op_rw(d->udev, 0xb8, 0, 0, 407 ibuf, 2, DW210X_READ_MSG); 408 memcpy(msg[j].buf, ibuf , 2); 409 break; 410 } 411 case(DW2102_VOLTAGE_CTRL): { 412 u8 obuf[2]; 413 obuf[0] = 0x30; 414 obuf[1] = msg[j].buf[0]; 415 dw210x_op_rw(d->udev, 0xb2, 0, 0, 416 obuf, 2, DW210X_WRITE_MSG); 417 break; 418 } 419 /*case 0x55: cx24116 420 case 0x6a: stv0903 421 case 0x68: ds3000, stv0903 422 case 0x60: ts2020, stv6110, stb6100 */ 423 default: { 424 if (msg[j].flags == I2C_M_RD) { 425 /* read registers */ 426 u8 ibuf[MAX_XFER_SIZE]; 427 428 if (2 + msg[j].len > sizeof(ibuf)) { 429 warn("i2c rd: len=%d is too big!\n", 430 msg[j].len); 431 ret = -EOPNOTSUPP; 432 goto unlock; 433 } 434 435 dw210x_op_rw(d->udev, 0xc3, 436 (msg[j].addr << 1) + 1, 0, 437 ibuf, msg[j].len + 2, 438 DW210X_READ_MSG); 439 memcpy(msg[j].buf, ibuf + 2, msg[j].len); 440 mdelay(10); 441 } else if (((msg[j].buf[0] == 0xb0) && 442 (msg[j].addr == 0x68)) || 443 ((msg[j].buf[0] == 0xf7) && 444 (msg[j].addr == 0x55))) { 445 /* write firmware */ 446 u8 obuf[19]; 447 obuf[0] = msg[j].addr << 1; 448 obuf[1] = (msg[j].len > 15 ? 17 : msg[j].len); 449 obuf[2] = msg[j].buf[0]; 450 len = msg[j].len - 1; 451 i = 1; 452 do { 453 memcpy(obuf + 3, msg[j].buf + i, 454 (len > 16 ? 16 : len)); 455 dw210x_op_rw(d->udev, 0xc2, 0, 0, 456 obuf, (len > 16 ? 16 : len) + 3, 457 DW210X_WRITE_MSG); 458 i += 16; 459 len -= 16; 460 } while (len > 0); 461 } else { 462 /* write registers */ 463 u8 obuf[MAX_XFER_SIZE]; 464 465 if (2 + msg[j].len > sizeof(obuf)) { 466 warn("i2c wr: len=%d is too big!\n", 467 msg[j].len); 468 ret = -EOPNOTSUPP; 469 goto unlock; 470 } 471 472 obuf[0] = msg[j].addr << 1; 473 obuf[1] = msg[j].len; 474 memcpy(obuf + 2, msg[j].buf, msg[j].len); 475 dw210x_op_rw(d->udev, 0xc2, 0, 0, 476 obuf, msg[j].len + 2, 477 DW210X_WRITE_MSG); 478 } 479 break; 480 } 481 } 482 483 } 484 ret = num; 485 486 unlock: 487 mutex_unlock(&d->i2c_mutex); 488 return ret; 489 } 490 491 static int dw3101_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[], 492 int num) 493 { 494 struct dvb_usb_device *d = i2c_get_adapdata(adap); 495 int ret; 496 int i; 497 498 if (!d) 499 return -ENODEV; 500 if (mutex_lock_interruptible(&d->i2c_mutex) < 0) 501 return -EAGAIN; 502 503 switch (num) { 504 case 2: { 505 /* read */ 506 /* first write first register number */ 507 u8 ibuf[MAX_XFER_SIZE], obuf[3]; 508 509 if (2 + msg[1].len > sizeof(ibuf)) { 510 warn("i2c rd: len=%d is too big!\n", 511 msg[1].len); 512 ret = -EOPNOTSUPP; 513 goto unlock; 514 } 515 obuf[0] = msg[0].addr << 1; 516 obuf[1] = msg[0].len; 517 obuf[2] = msg[0].buf[0]; 518 dw210x_op_rw(d->udev, 0xc2, 0, 0, 519 obuf, msg[0].len + 2, DW210X_WRITE_MSG); 520 /* second read registers */ 521 dw210x_op_rw(d->udev, 0xc3, 0x19 , 0, 522 ibuf, msg[1].len + 2, DW210X_READ_MSG); 523 memcpy(msg[1].buf, ibuf + 2, msg[1].len); 524 525 break; 526 } 527 case 1: 528 switch (msg[0].addr) { 529 case 0x60: 530 case 0x0c: { 531 /* write to register */ 532 u8 obuf[MAX_XFER_SIZE]; 533 534 if (2 + msg[0].len > sizeof(obuf)) { 535 warn("i2c wr: len=%d is too big!\n", 536 msg[0].len); 537 ret = -EOPNOTSUPP; 538 goto unlock; 539 } 540 obuf[0] = msg[0].addr << 1; 541 obuf[1] = msg[0].len; 542 memcpy(obuf + 2, msg[0].buf, msg[0].len); 543 dw210x_op_rw(d->udev, 0xc2, 0, 0, 544 obuf, msg[0].len + 2, DW210X_WRITE_MSG); 545 break; 546 } 547 case(DW2102_RC_QUERY): { 548 u8 ibuf[2]; 549 dw210x_op_rw(d->udev, 0xb8, 0, 0, 550 ibuf, 2, DW210X_READ_MSG); 551 memcpy(msg[0].buf, ibuf , 2); 552 break; 553 } 554 } 555 556 break; 557 } 558 559 for (i = 0; i < num; i++) { 560 deb_xfer("%02x:%02x: %s ", i, msg[i].addr, 561 msg[i].flags == 0 ? ">>>" : "<<<"); 562 debug_dump(msg[i].buf, msg[i].len, deb_xfer); 563 } 564 ret = num; 565 566 unlock: 567 mutex_unlock(&d->i2c_mutex); 568 return ret; 569 } 570 571 static int s6x0_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[], 572 int num) 573 { 574 struct dvb_usb_device *d = i2c_get_adapdata(adap); 575 struct usb_device *udev; 576 int len, i, j, ret; 577 578 if (!d) 579 return -ENODEV; 580 udev = d->udev; 581 if (mutex_lock_interruptible(&d->i2c_mutex) < 0) 582 return -EAGAIN; 583 584 for (j = 0; j < num; j++) { 585 switch (msg[j].addr) { 586 case (DW2102_RC_QUERY): { 587 u8 ibuf[5]; 588 dw210x_op_rw(d->udev, 0xb8, 0, 0, 589 ibuf, 5, DW210X_READ_MSG); 590 memcpy(msg[j].buf, ibuf + 3, 2); 591 break; 592 } 593 case (DW2102_VOLTAGE_CTRL): { 594 u8 obuf[2]; 595 596 obuf[0] = 1; 597 obuf[1] = msg[j].buf[1];/* off-on */ 598 dw210x_op_rw(d->udev, 0x8a, 0, 0, 599 obuf, 2, DW210X_WRITE_MSG); 600 obuf[0] = 3; 601 obuf[1] = msg[j].buf[0];/* 13v-18v */ 602 dw210x_op_rw(d->udev, 0x8a, 0, 0, 603 obuf, 2, DW210X_WRITE_MSG); 604 break; 605 } 606 case (DW2102_LED_CTRL): { 607 u8 obuf[2]; 608 609 obuf[0] = 5; 610 obuf[1] = msg[j].buf[0]; 611 dw210x_op_rw(d->udev, 0x8a, 0, 0, 612 obuf, 2, DW210X_WRITE_MSG); 613 break; 614 } 615 /*case 0x55: cx24116 616 case 0x6a: stv0903 617 case 0x68: ds3000, stv0903, rs2000 618 case 0x60: ts2020, stv6110, stb6100 619 case 0xa0: eeprom */ 620 default: { 621 if (msg[j].flags == I2C_M_RD) { 622 /* read registers */ 623 u8 ibuf[MAX_XFER_SIZE]; 624 625 if (msg[j].len > sizeof(ibuf)) { 626 warn("i2c rd: len=%d is too big!\n", 627 msg[j].len); 628 ret = -EOPNOTSUPP; 629 goto unlock; 630 } 631 632 dw210x_op_rw(d->udev, 0x91, 0, 0, 633 ibuf, msg[j].len, 634 DW210X_READ_MSG); 635 memcpy(msg[j].buf, ibuf, msg[j].len); 636 break; 637 } else if ((msg[j].buf[0] == 0xb0) && 638 (msg[j].addr == 0x68)) { 639 /* write firmware */ 640 u8 obuf[19]; 641 obuf[0] = (msg[j].len > 16 ? 642 18 : msg[j].len + 1); 643 obuf[1] = msg[j].addr << 1; 644 obuf[2] = msg[j].buf[0]; 645 len = msg[j].len - 1; 646 i = 1; 647 do { 648 memcpy(obuf + 3, msg[j].buf + i, 649 (len > 16 ? 16 : len)); 650 dw210x_op_rw(d->udev, 0x80, 0, 0, 651 obuf, (len > 16 ? 16 : len) + 3, 652 DW210X_WRITE_MSG); 653 i += 16; 654 len -= 16; 655 } while (len > 0); 656 } else if (j < (num - 1)) { 657 /* write register addr before read */ 658 u8 obuf[MAX_XFER_SIZE]; 659 660 if (2 + msg[j].len > sizeof(obuf)) { 661 warn("i2c wr: len=%d is too big!\n", 662 msg[j].len); 663 ret = -EOPNOTSUPP; 664 goto unlock; 665 } 666 667 obuf[0] = msg[j + 1].len; 668 obuf[1] = (msg[j].addr << 1); 669 memcpy(obuf + 2, msg[j].buf, msg[j].len); 670 dw210x_op_rw(d->udev, 671 le16_to_cpu(udev->descriptor.idProduct) == 672 0x7500 ? 0x92 : 0x90, 0, 0, 673 obuf, msg[j].len + 2, 674 DW210X_WRITE_MSG); 675 break; 676 } else { 677 /* write registers */ 678 u8 obuf[MAX_XFER_SIZE]; 679 680 if (2 + msg[j].len > sizeof(obuf)) { 681 warn("i2c wr: len=%d is too big!\n", 682 msg[j].len); 683 ret = -EOPNOTSUPP; 684 goto unlock; 685 } 686 obuf[0] = msg[j].len + 1; 687 obuf[1] = (msg[j].addr << 1); 688 memcpy(obuf + 2, msg[j].buf, msg[j].len); 689 dw210x_op_rw(d->udev, 0x80, 0, 0, 690 obuf, msg[j].len + 2, 691 DW210X_WRITE_MSG); 692 break; 693 } 694 break; 695 } 696 } 697 } 698 ret = num; 699 700 unlock: 701 mutex_unlock(&d->i2c_mutex); 702 return ret; 703 } 704 705 static int su3000_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[], 706 int num) 707 { 708 struct dvb_usb_device *d = i2c_get_adapdata(adap); 709 u8 obuf[0x40], ibuf[0x40]; 710 711 if (!d) 712 return -ENODEV; 713 if (mutex_lock_interruptible(&d->i2c_mutex) < 0) 714 return -EAGAIN; 715 716 switch (num) { 717 case 1: 718 switch (msg[0].addr) { 719 case SU3000_STREAM_CTRL: 720 obuf[0] = msg[0].buf[0] + 0x36; 721 obuf[1] = 3; 722 obuf[2] = 0; 723 if (dvb_usb_generic_rw(d, obuf, 3, ibuf, 0, 0) < 0) 724 err("i2c transfer failed."); 725 break; 726 case DW2102_RC_QUERY: 727 obuf[0] = 0x10; 728 if (dvb_usb_generic_rw(d, obuf, 1, ibuf, 2, 0) < 0) 729 err("i2c transfer failed."); 730 msg[0].buf[1] = ibuf[0]; 731 msg[0].buf[0] = ibuf[1]; 732 break; 733 default: 734 /* always i2c write*/ 735 obuf[0] = 0x08; 736 obuf[1] = msg[0].addr; 737 obuf[2] = msg[0].len; 738 739 memcpy(&obuf[3], msg[0].buf, msg[0].len); 740 741 if (dvb_usb_generic_rw(d, obuf, msg[0].len + 3, 742 ibuf, 1, 0) < 0) 743 err("i2c transfer failed."); 744 745 } 746 break; 747 case 2: 748 /* always i2c read */ 749 obuf[0] = 0x09; 750 obuf[1] = msg[0].len; 751 obuf[2] = msg[1].len; 752 obuf[3] = msg[0].addr; 753 memcpy(&obuf[4], msg[0].buf, msg[0].len); 754 755 if (dvb_usb_generic_rw(d, obuf, msg[0].len + 4, 756 ibuf, msg[1].len + 1, 0) < 0) 757 err("i2c transfer failed."); 758 759 memcpy(msg[1].buf, &ibuf[1], msg[1].len); 760 break; 761 default: 762 warn("more than 2 i2c messages at a time is not handled yet."); 763 break; 764 } 765 mutex_unlock(&d->i2c_mutex); 766 return num; 767 } 768 769 static u32 dw210x_i2c_func(struct i2c_adapter *adapter) 770 { 771 return I2C_FUNC_I2C; 772 } 773 774 static struct i2c_algorithm dw2102_i2c_algo = { 775 .master_xfer = dw2102_i2c_transfer, 776 .functionality = dw210x_i2c_func, 777 }; 778 779 static struct i2c_algorithm dw2102_serit_i2c_algo = { 780 .master_xfer = dw2102_serit_i2c_transfer, 781 .functionality = dw210x_i2c_func, 782 }; 783 784 static struct i2c_algorithm dw2102_earda_i2c_algo = { 785 .master_xfer = dw2102_earda_i2c_transfer, 786 .functionality = dw210x_i2c_func, 787 }; 788 789 static struct i2c_algorithm dw2104_i2c_algo = { 790 .master_xfer = dw2104_i2c_transfer, 791 .functionality = dw210x_i2c_func, 792 }; 793 794 static struct i2c_algorithm dw3101_i2c_algo = { 795 .master_xfer = dw3101_i2c_transfer, 796 .functionality = dw210x_i2c_func, 797 }; 798 799 static struct i2c_algorithm s6x0_i2c_algo = { 800 .master_xfer = s6x0_i2c_transfer, 801 .functionality = dw210x_i2c_func, 802 }; 803 804 static struct i2c_algorithm su3000_i2c_algo = { 805 .master_xfer = su3000_i2c_transfer, 806 .functionality = dw210x_i2c_func, 807 }; 808 809 static int dw210x_read_mac_address(struct dvb_usb_device *d, u8 mac[6]) 810 { 811 int i; 812 u8 ibuf[] = {0, 0}; 813 u8 eeprom[256], eepromline[16]; 814 815 for (i = 0; i < 256; i++) { 816 if (dw210x_op_rw(d->udev, 0xb6, 0xa0 , i, ibuf, 2, DW210X_READ_MSG) < 0) { 817 err("read eeprom failed."); 818 return -1; 819 } else { 820 eepromline[i%16] = ibuf[0]; 821 eeprom[i] = ibuf[0]; 822 } 823 if ((i % 16) == 15) { 824 deb_xfer("%02x: ", i - 15); 825 debug_dump(eepromline, 16, deb_xfer); 826 } 827 } 828 829 memcpy(mac, eeprom + 8, 6); 830 return 0; 831 }; 832 833 static int s6x0_read_mac_address(struct dvb_usb_device *d, u8 mac[6]) 834 { 835 int i, ret; 836 u8 ibuf[] = { 0 }, obuf[] = { 0 }; 837 u8 eeprom[256], eepromline[16]; 838 struct i2c_msg msg[] = { 839 { 840 .addr = 0xa0 >> 1, 841 .flags = 0, 842 .buf = obuf, 843 .len = 1, 844 }, { 845 .addr = 0xa0 >> 1, 846 .flags = I2C_M_RD, 847 .buf = ibuf, 848 .len = 1, 849 } 850 }; 851 852 for (i = 0; i < 256; i++) { 853 obuf[0] = i; 854 ret = s6x0_i2c_transfer(&d->i2c_adap, msg, 2); 855 if (ret != 2) { 856 err("read eeprom failed."); 857 return -1; 858 } else { 859 eepromline[i % 16] = ibuf[0]; 860 eeprom[i] = ibuf[0]; 861 } 862 863 if ((i % 16) == 15) { 864 deb_xfer("%02x: ", i - 15); 865 debug_dump(eepromline, 16, deb_xfer); 866 } 867 } 868 869 memcpy(mac, eeprom + 16, 6); 870 return 0; 871 }; 872 873 static int su3000_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff) 874 { 875 static u8 command_start[] = {0x00}; 876 static u8 command_stop[] = {0x01}; 877 struct i2c_msg msg = { 878 .addr = SU3000_STREAM_CTRL, 879 .flags = 0, 880 .buf = onoff ? command_start : command_stop, 881 .len = 1 882 }; 883 884 i2c_transfer(&adap->dev->i2c_adap, &msg, 1); 885 886 return 0; 887 } 888 889 static int su3000_power_ctrl(struct dvb_usb_device *d, int i) 890 { 891 struct dw2102_state *state = (struct dw2102_state *)d->priv; 892 u8 obuf[] = {0xde, 0}; 893 894 info("%s: %d, initialized %d\n", __func__, i, state->initialized); 895 896 if (i && !state->initialized) { 897 state->initialized = 1; 898 /* reset board */ 899 dvb_usb_generic_rw(d, obuf, 2, NULL, 0, 0); 900 } 901 902 return 0; 903 } 904 905 static int su3000_read_mac_address(struct dvb_usb_device *d, u8 mac[6]) 906 { 907 int i; 908 u8 obuf[] = { 0x1f, 0xf0 }; 909 u8 ibuf[] = { 0 }; 910 struct i2c_msg msg[] = { 911 { 912 .addr = 0x51, 913 .flags = 0, 914 .buf = obuf, 915 .len = 2, 916 }, { 917 .addr = 0x51, 918 .flags = I2C_M_RD, 919 .buf = ibuf, 920 .len = 1, 921 922 } 923 }; 924 925 for (i = 0; i < 6; i++) { 926 obuf[1] = 0xf0 + i; 927 if (i2c_transfer(&d->i2c_adap, msg, 2) != 2) 928 break; 929 else 930 mac[i] = ibuf[0]; 931 } 932 933 return 0; 934 } 935 936 static int su3000_identify_state(struct usb_device *udev, 937 struct dvb_usb_device_properties *props, 938 struct dvb_usb_device_description **desc, 939 int *cold) 940 { 941 info("%s\n", __func__); 942 943 *cold = 0; 944 return 0; 945 } 946 947 static int dw210x_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t voltage) 948 { 949 static u8 command_13v[] = {0x00, 0x01}; 950 static u8 command_18v[] = {0x01, 0x01}; 951 static u8 command_off[] = {0x00, 0x00}; 952 struct i2c_msg msg = { 953 .addr = DW2102_VOLTAGE_CTRL, 954 .flags = 0, 955 .buf = command_off, 956 .len = 2, 957 }; 958 959 struct dvb_usb_adapter *udev_adap = 960 (struct dvb_usb_adapter *)(fe->dvb->priv); 961 if (voltage == SEC_VOLTAGE_18) 962 msg.buf = command_18v; 963 else if (voltage == SEC_VOLTAGE_13) 964 msg.buf = command_13v; 965 966 i2c_transfer(&udev_adap->dev->i2c_adap, &msg, 1); 967 968 return 0; 969 } 970 971 static int s660_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t voltage) 972 { 973 struct dvb_usb_adapter *d = 974 (struct dvb_usb_adapter *)(fe->dvb->priv); 975 struct dw2102_state *st = (struct dw2102_state *)d->dev->priv; 976 977 dw210x_set_voltage(fe, voltage); 978 if (st->old_set_voltage) 979 st->old_set_voltage(fe, voltage); 980 981 return 0; 982 } 983 984 static void dw210x_led_ctrl(struct dvb_frontend *fe, int offon) 985 { 986 static u8 led_off[] = { 0 }; 987 static u8 led_on[] = { 1 }; 988 struct i2c_msg msg = { 989 .addr = DW2102_LED_CTRL, 990 .flags = 0, 991 .buf = led_off, 992 .len = 1 993 }; 994 struct dvb_usb_adapter *udev_adap = 995 (struct dvb_usb_adapter *)(fe->dvb->priv); 996 997 if (offon) 998 msg.buf = led_on; 999 i2c_transfer(&udev_adap->dev->i2c_adap, &msg, 1); 1000 } 1001 1002 static struct stv0299_config sharp_z0194a_config = { 1003 .demod_address = 0x68, 1004 .inittab = sharp_z0194a_inittab, 1005 .mclk = 88000000UL, 1006 .invert = 1, 1007 .skip_reinit = 0, 1008 .lock_output = STV0299_LOCKOUTPUT_1, 1009 .volt13_op0_op1 = STV0299_VOLT13_OP1, 1010 .min_delay_ms = 100, 1011 .set_symbol_rate = sharp_z0194a_set_symbol_rate, 1012 }; 1013 1014 static struct cx24116_config dw2104_config = { 1015 .demod_address = 0x55, 1016 .mpg_clk_pos_pol = 0x01, 1017 }; 1018 1019 static struct si21xx_config serit_sp1511lhb_config = { 1020 .demod_address = 0x68, 1021 .min_delay_ms = 100, 1022 1023 }; 1024 1025 static struct tda10023_config dw3101_tda10023_config = { 1026 .demod_address = 0x0c, 1027 .invert = 1, 1028 }; 1029 1030 static struct mt312_config zl313_config = { 1031 .demod_address = 0x0e, 1032 }; 1033 1034 static struct ds3000_config dw2104_ds3000_config = { 1035 .demod_address = 0x68, 1036 }; 1037 1038 static struct ts2020_config dw2104_ts2020_config = { 1039 .tuner_address = 0x60, 1040 .clk_out_div = 1, 1041 .frequency_div = 1060000, 1042 }; 1043 1044 static struct ds3000_config s660_ds3000_config = { 1045 .demod_address = 0x68, 1046 .ci_mode = 1, 1047 .set_lock_led = dw210x_led_ctrl, 1048 }; 1049 1050 static struct ts2020_config s660_ts2020_config = { 1051 .tuner_address = 0x60, 1052 .clk_out_div = 1, 1053 .frequency_div = 1146000, 1054 }; 1055 1056 static struct stv0900_config dw2104a_stv0900_config = { 1057 .demod_address = 0x6a, 1058 .demod_mode = 0, 1059 .xtal = 27000000, 1060 .clkmode = 3,/* 0-CLKI, 2-XTALI, else AUTO */ 1061 .diseqc_mode = 2,/* 2/3 PWM */ 1062 .tun1_maddress = 0,/* 0x60 */ 1063 .tun1_adc = 0,/* 2 Vpp */ 1064 .path1_mode = 3, 1065 }; 1066 1067 static struct stb6100_config dw2104a_stb6100_config = { 1068 .tuner_address = 0x60, 1069 .refclock = 27000000, 1070 }; 1071 1072 static struct stv0900_config dw2104_stv0900_config = { 1073 .demod_address = 0x68, 1074 .demod_mode = 0, 1075 .xtal = 8000000, 1076 .clkmode = 3, 1077 .diseqc_mode = 2, 1078 .tun1_maddress = 0, 1079 .tun1_adc = 1,/* 1 Vpp */ 1080 .path1_mode = 3, 1081 }; 1082 1083 static struct stv6110_config dw2104_stv6110_config = { 1084 .i2c_address = 0x60, 1085 .mclk = 16000000, 1086 .clk_div = 1, 1087 }; 1088 1089 static struct stv0900_config prof_7500_stv0900_config = { 1090 .demod_address = 0x6a, 1091 .demod_mode = 0, 1092 .xtal = 27000000, 1093 .clkmode = 3,/* 0-CLKI, 2-XTALI, else AUTO */ 1094 .diseqc_mode = 2,/* 2/3 PWM */ 1095 .tun1_maddress = 0,/* 0x60 */ 1096 .tun1_adc = 0,/* 2 Vpp */ 1097 .path1_mode = 3, 1098 .tun1_type = 3, 1099 .set_lock_led = dw210x_led_ctrl, 1100 }; 1101 1102 static struct ds3000_config su3000_ds3000_config = { 1103 .demod_address = 0x68, 1104 .ci_mode = 1, 1105 .set_lock_led = dw210x_led_ctrl, 1106 }; 1107 1108 static struct cxd2820r_config cxd2820r_config = { 1109 .i2c_address = 0x6c, /* (0xd8 >> 1) */ 1110 .ts_mode = 0x38, 1111 .ts_clock_inv = 1, 1112 }; 1113 1114 static struct tda18271_config tda18271_config = { 1115 .output_opt = TDA18271_OUTPUT_LT_OFF, 1116 .gate = TDA18271_GATE_DIGITAL, 1117 }; 1118 1119 static const struct m88ds3103_config tt_s2_4600_m88ds3103_config = { 1120 .i2c_addr = 0x68, 1121 .clock = 27000000, 1122 .i2c_wr_max = 33, 1123 .ts_mode = M88DS3103_TS_CI, 1124 .ts_clk = 16000, 1125 .ts_clk_pol = 0, 1126 .spec_inv = 0, 1127 .agc_inv = 0, 1128 .clock_out = M88DS3103_CLOCK_OUT_ENABLED, 1129 .envelope_mode = 0, 1130 .agc = 0x99, 1131 .lnb_hv_pol = 1, 1132 .lnb_en_pol = 0, 1133 }; 1134 1135 static u8 m88rs2000_inittab[] = { 1136 DEMOD_WRITE, 0x9a, 0x30, 1137 DEMOD_WRITE, 0x00, 0x01, 1138 WRITE_DELAY, 0x19, 0x00, 1139 DEMOD_WRITE, 0x00, 0x00, 1140 DEMOD_WRITE, 0x9a, 0xb0, 1141 DEMOD_WRITE, 0x81, 0xc1, 1142 DEMOD_WRITE, 0x81, 0x81, 1143 DEMOD_WRITE, 0x86, 0xc6, 1144 DEMOD_WRITE, 0x9a, 0x30, 1145 DEMOD_WRITE, 0xf0, 0x80, 1146 DEMOD_WRITE, 0xf1, 0xbf, 1147 DEMOD_WRITE, 0xb0, 0x45, 1148 DEMOD_WRITE, 0xb2, 0x01, 1149 DEMOD_WRITE, 0x9a, 0xb0, 1150 0xff, 0xaa, 0xff 1151 }; 1152 1153 static struct m88rs2000_config s421_m88rs2000_config = { 1154 .demod_addr = 0x68, 1155 .inittab = m88rs2000_inittab, 1156 }; 1157 1158 static int dw2104_frontend_attach(struct dvb_usb_adapter *d) 1159 { 1160 struct dvb_tuner_ops *tuner_ops = NULL; 1161 1162 if (demod_probe & 4) { 1163 d->fe_adap[0].fe = dvb_attach(stv0900_attach, &dw2104a_stv0900_config, 1164 &d->dev->i2c_adap, 0); 1165 if (d->fe_adap[0].fe != NULL) { 1166 if (dvb_attach(stb6100_attach, d->fe_adap[0].fe, 1167 &dw2104a_stb6100_config, 1168 &d->dev->i2c_adap)) { 1169 tuner_ops = &d->fe_adap[0].fe->ops.tuner_ops; 1170 tuner_ops->set_frequency = stb6100_set_freq; 1171 tuner_ops->get_frequency = stb6100_get_freq; 1172 tuner_ops->set_bandwidth = stb6100_set_bandw; 1173 tuner_ops->get_bandwidth = stb6100_get_bandw; 1174 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage; 1175 info("Attached STV0900+STB6100!\n"); 1176 return 0; 1177 } 1178 } 1179 } 1180 1181 if (demod_probe & 2) { 1182 d->fe_adap[0].fe = dvb_attach(stv0900_attach, &dw2104_stv0900_config, 1183 &d->dev->i2c_adap, 0); 1184 if (d->fe_adap[0].fe != NULL) { 1185 if (dvb_attach(stv6110_attach, d->fe_adap[0].fe, 1186 &dw2104_stv6110_config, 1187 &d->dev->i2c_adap)) { 1188 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage; 1189 info("Attached STV0900+STV6110A!\n"); 1190 return 0; 1191 } 1192 } 1193 } 1194 1195 if (demod_probe & 1) { 1196 d->fe_adap[0].fe = dvb_attach(cx24116_attach, &dw2104_config, 1197 &d->dev->i2c_adap); 1198 if (d->fe_adap[0].fe != NULL) { 1199 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage; 1200 info("Attached cx24116!\n"); 1201 return 0; 1202 } 1203 } 1204 1205 d->fe_adap[0].fe = dvb_attach(ds3000_attach, &dw2104_ds3000_config, 1206 &d->dev->i2c_adap); 1207 if (d->fe_adap[0].fe != NULL) { 1208 dvb_attach(ts2020_attach, d->fe_adap[0].fe, 1209 &dw2104_ts2020_config, &d->dev->i2c_adap); 1210 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage; 1211 info("Attached DS3000!\n"); 1212 return 0; 1213 } 1214 1215 return -EIO; 1216 } 1217 1218 static struct dvb_usb_device_properties dw2102_properties; 1219 static struct dvb_usb_device_properties dw2104_properties; 1220 static struct dvb_usb_device_properties s6x0_properties; 1221 1222 static int dw2102_frontend_attach(struct dvb_usb_adapter *d) 1223 { 1224 if (dw2102_properties.i2c_algo == &dw2102_serit_i2c_algo) { 1225 /*dw2102_properties.adapter->tuner_attach = NULL;*/ 1226 d->fe_adap[0].fe = dvb_attach(si21xx_attach, &serit_sp1511lhb_config, 1227 &d->dev->i2c_adap); 1228 if (d->fe_adap[0].fe != NULL) { 1229 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage; 1230 info("Attached si21xx!\n"); 1231 return 0; 1232 } 1233 } 1234 1235 if (dw2102_properties.i2c_algo == &dw2102_earda_i2c_algo) { 1236 d->fe_adap[0].fe = dvb_attach(stv0288_attach, &earda_config, 1237 &d->dev->i2c_adap); 1238 if (d->fe_adap[0].fe != NULL) { 1239 if (dvb_attach(stb6000_attach, d->fe_adap[0].fe, 0x61, 1240 &d->dev->i2c_adap)) { 1241 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage; 1242 info("Attached stv0288!\n"); 1243 return 0; 1244 } 1245 } 1246 } 1247 1248 if (dw2102_properties.i2c_algo == &dw2102_i2c_algo) { 1249 /*dw2102_properties.adapter->tuner_attach = dw2102_tuner_attach;*/ 1250 d->fe_adap[0].fe = dvb_attach(stv0299_attach, &sharp_z0194a_config, 1251 &d->dev->i2c_adap); 1252 if (d->fe_adap[0].fe != NULL) { 1253 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage; 1254 info("Attached stv0299!\n"); 1255 return 0; 1256 } 1257 } 1258 return -EIO; 1259 } 1260 1261 static int dw3101_frontend_attach(struct dvb_usb_adapter *d) 1262 { 1263 d->fe_adap[0].fe = dvb_attach(tda10023_attach, &dw3101_tda10023_config, 1264 &d->dev->i2c_adap, 0x48); 1265 if (d->fe_adap[0].fe != NULL) { 1266 info("Attached tda10023!\n"); 1267 return 0; 1268 } 1269 return -EIO; 1270 } 1271 1272 static int zl100313_frontend_attach(struct dvb_usb_adapter *d) 1273 { 1274 d->fe_adap[0].fe = dvb_attach(mt312_attach, &zl313_config, 1275 &d->dev->i2c_adap); 1276 if (d->fe_adap[0].fe != NULL) { 1277 if (dvb_attach(zl10039_attach, d->fe_adap[0].fe, 0x60, 1278 &d->dev->i2c_adap)) { 1279 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage; 1280 info("Attached zl100313+zl10039!\n"); 1281 return 0; 1282 } 1283 } 1284 1285 return -EIO; 1286 } 1287 1288 static int stv0288_frontend_attach(struct dvb_usb_adapter *d) 1289 { 1290 u8 obuf[] = {7, 1}; 1291 1292 d->fe_adap[0].fe = dvb_attach(stv0288_attach, &earda_config, 1293 &d->dev->i2c_adap); 1294 1295 if (d->fe_adap[0].fe == NULL) 1296 return -EIO; 1297 1298 if (NULL == dvb_attach(stb6000_attach, d->fe_adap[0].fe, 0x61, &d->dev->i2c_adap)) 1299 return -EIO; 1300 1301 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage; 1302 1303 dw210x_op_rw(d->dev->udev, 0x8a, 0, 0, obuf, 2, DW210X_WRITE_MSG); 1304 1305 info("Attached stv0288+stb6000!\n"); 1306 1307 return 0; 1308 1309 } 1310 1311 static int ds3000_frontend_attach(struct dvb_usb_adapter *d) 1312 { 1313 struct dw2102_state *st = d->dev->priv; 1314 u8 obuf[] = {7, 1}; 1315 1316 d->fe_adap[0].fe = dvb_attach(ds3000_attach, &s660_ds3000_config, 1317 &d->dev->i2c_adap); 1318 1319 if (d->fe_adap[0].fe == NULL) 1320 return -EIO; 1321 1322 dvb_attach(ts2020_attach, d->fe_adap[0].fe, &s660_ts2020_config, 1323 &d->dev->i2c_adap); 1324 1325 st->old_set_voltage = d->fe_adap[0].fe->ops.set_voltage; 1326 d->fe_adap[0].fe->ops.set_voltage = s660_set_voltage; 1327 1328 dw210x_op_rw(d->dev->udev, 0x8a, 0, 0, obuf, 2, DW210X_WRITE_MSG); 1329 1330 info("Attached ds3000+ts2020!\n"); 1331 1332 return 0; 1333 } 1334 1335 static int prof_7500_frontend_attach(struct dvb_usb_adapter *d) 1336 { 1337 u8 obuf[] = {7, 1}; 1338 1339 d->fe_adap[0].fe = dvb_attach(stv0900_attach, &prof_7500_stv0900_config, 1340 &d->dev->i2c_adap, 0); 1341 if (d->fe_adap[0].fe == NULL) 1342 return -EIO; 1343 1344 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage; 1345 1346 dw210x_op_rw(d->dev->udev, 0x8a, 0, 0, obuf, 2, DW210X_WRITE_MSG); 1347 1348 info("Attached STV0900+STB6100A!\n"); 1349 1350 return 0; 1351 } 1352 1353 static int su3000_frontend_attach(struct dvb_usb_adapter *d) 1354 { 1355 u8 obuf[3] = { 0xe, 0x80, 0 }; 1356 u8 ibuf[] = { 0 }; 1357 1358 if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0) 1359 err("command 0x0e transfer failed."); 1360 1361 obuf[0] = 0xe; 1362 obuf[1] = 0x02; 1363 obuf[2] = 1; 1364 1365 if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0) 1366 err("command 0x0e transfer failed."); 1367 msleep(300); 1368 1369 obuf[0] = 0xe; 1370 obuf[1] = 0x83; 1371 obuf[2] = 0; 1372 1373 if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0) 1374 err("command 0x0e transfer failed."); 1375 1376 obuf[0] = 0xe; 1377 obuf[1] = 0x83; 1378 obuf[2] = 1; 1379 1380 if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0) 1381 err("command 0x0e transfer failed."); 1382 1383 obuf[0] = 0x51; 1384 1385 if (dvb_usb_generic_rw(d->dev, obuf, 1, ibuf, 1, 0) < 0) 1386 err("command 0x51 transfer failed."); 1387 1388 d->fe_adap[0].fe = dvb_attach(ds3000_attach, &su3000_ds3000_config, 1389 &d->dev->i2c_adap); 1390 if (d->fe_adap[0].fe == NULL) 1391 return -EIO; 1392 1393 if (dvb_attach(ts2020_attach, d->fe_adap[0].fe, 1394 &dw2104_ts2020_config, 1395 &d->dev->i2c_adap)) { 1396 info("Attached DS3000/TS2020!\n"); 1397 return 0; 1398 } 1399 1400 info("Failed to attach DS3000/TS2020!\n"); 1401 return -EIO; 1402 } 1403 1404 static int t220_frontend_attach(struct dvb_usb_adapter *d) 1405 { 1406 u8 obuf[3] = { 0xe, 0x87, 0 }; 1407 u8 ibuf[] = { 0 }; 1408 1409 if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0) 1410 err("command 0x0e transfer failed."); 1411 1412 obuf[0] = 0xe; 1413 obuf[1] = 0x86; 1414 obuf[2] = 1; 1415 1416 if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0) 1417 err("command 0x0e transfer failed."); 1418 1419 obuf[0] = 0xe; 1420 obuf[1] = 0x80; 1421 obuf[2] = 0; 1422 1423 if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0) 1424 err("command 0x0e transfer failed."); 1425 1426 msleep(50); 1427 1428 obuf[0] = 0xe; 1429 obuf[1] = 0x80; 1430 obuf[2] = 1; 1431 1432 if (dvb_usb_generic_rw(d->dev, obuf, 3, ibuf, 1, 0) < 0) 1433 err("command 0x0e transfer failed."); 1434 1435 obuf[0] = 0x51; 1436 1437 if (dvb_usb_generic_rw(d->dev, obuf, 1, ibuf, 1, 0) < 0) 1438 err("command 0x51 transfer failed."); 1439 1440 d->fe_adap[0].fe = dvb_attach(cxd2820r_attach, &cxd2820r_config, 1441 &d->dev->i2c_adap, NULL); 1442 if (d->fe_adap[0].fe != NULL) { 1443 if (dvb_attach(tda18271_attach, d->fe_adap[0].fe, 0x60, 1444 &d->dev->i2c_adap, &tda18271_config)) { 1445 info("Attached TDA18271HD/CXD2820R!\n"); 1446 return 0; 1447 } 1448 } 1449 1450 info("Failed to attach TDA18271HD/CXD2820R!\n"); 1451 return -EIO; 1452 } 1453 1454 static int m88rs2000_frontend_attach(struct dvb_usb_adapter *d) 1455 { 1456 u8 obuf[] = { 0x51 }; 1457 u8 ibuf[] = { 0 }; 1458 1459 if (dvb_usb_generic_rw(d->dev, obuf, 1, ibuf, 1, 0) < 0) 1460 err("command 0x51 transfer failed."); 1461 1462 d->fe_adap[0].fe = dvb_attach(m88rs2000_attach, &s421_m88rs2000_config, 1463 &d->dev->i2c_adap); 1464 1465 if (d->fe_adap[0].fe == NULL) 1466 return -EIO; 1467 1468 if (dvb_attach(ts2020_attach, d->fe_adap[0].fe, 1469 &dw2104_ts2020_config, 1470 &d->dev->i2c_adap)) { 1471 info("Attached RS2000/TS2020!\n"); 1472 return 0; 1473 } 1474 1475 info("Failed to attach RS2000/TS2020!\n"); 1476 return -EIO; 1477 } 1478 1479 static int tt_s2_4600_frontend_attach(struct dvb_usb_adapter *adap) 1480 { 1481 struct dvb_usb_device *d = adap->dev; 1482 struct dw2102_state *state = d->priv; 1483 u8 obuf[3] = { 0xe, 0x80, 0 }; 1484 u8 ibuf[] = { 0 }; 1485 struct i2c_adapter *i2c_adapter; 1486 struct i2c_client *client; 1487 struct i2c_board_info info; 1488 struct ts2020_config ts2020_config = {}; 1489 1490 if (dvb_usb_generic_rw(d, obuf, 3, ibuf, 1, 0) < 0) 1491 err("command 0x0e transfer failed."); 1492 1493 obuf[0] = 0xe; 1494 obuf[1] = 0x02; 1495 obuf[2] = 1; 1496 1497 if (dvb_usb_generic_rw(d, obuf, 3, ibuf, 1, 0) < 0) 1498 err("command 0x0e transfer failed."); 1499 msleep(300); 1500 1501 obuf[0] = 0xe; 1502 obuf[1] = 0x83; 1503 obuf[2] = 0; 1504 1505 if (dvb_usb_generic_rw(d, obuf, 3, ibuf, 1, 0) < 0) 1506 err("command 0x0e transfer failed."); 1507 1508 obuf[0] = 0xe; 1509 obuf[1] = 0x83; 1510 obuf[2] = 1; 1511 1512 if (dvb_usb_generic_rw(d, obuf, 3, ibuf, 1, 0) < 0) 1513 err("command 0x0e transfer failed."); 1514 1515 obuf[0] = 0x51; 1516 1517 if (dvb_usb_generic_rw(d, obuf, 1, ibuf, 1, 0) < 0) 1518 err("command 0x51 transfer failed."); 1519 1520 memset(&info, 0, sizeof(struct i2c_board_info)); 1521 1522 adap->fe_adap[0].fe = dvb_attach(m88ds3103_attach, 1523 &tt_s2_4600_m88ds3103_config, 1524 &d->i2c_adap, 1525 &i2c_adapter); 1526 if (adap->fe_adap[0].fe == NULL) 1527 return -ENODEV; 1528 1529 /* attach tuner */ 1530 ts2020_config.fe = adap->fe_adap[0].fe; 1531 strlcpy(info.type, "ts2022", I2C_NAME_SIZE); 1532 info.addr = 0x60; 1533 info.platform_data = &ts2020_config; 1534 request_module("ts2020"); 1535 client = i2c_new_device(i2c_adapter, &info); 1536 1537 if (client == NULL || client->dev.driver == NULL) { 1538 dvb_frontend_detach(adap->fe_adap[0].fe); 1539 return -ENODEV; 1540 } 1541 1542 if (!try_module_get(client->dev.driver->owner)) { 1543 i2c_unregister_device(client); 1544 dvb_frontend_detach(adap->fe_adap[0].fe); 1545 return -ENODEV; 1546 } 1547 1548 /* delegate signal strength measurement to tuner */ 1549 adap->fe_adap[0].fe->ops.read_signal_strength = 1550 adap->fe_adap[0].fe->ops.tuner_ops.get_rf_strength; 1551 1552 state->i2c_client_tuner = client; 1553 1554 return 0; 1555 } 1556 1557 static int dw2102_tuner_attach(struct dvb_usb_adapter *adap) 1558 { 1559 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x60, 1560 &adap->dev->i2c_adap, DVB_PLL_OPERA1); 1561 return 0; 1562 } 1563 1564 static int dw3101_tuner_attach(struct dvb_usb_adapter *adap) 1565 { 1566 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x60, 1567 &adap->dev->i2c_adap, DVB_PLL_TUA6034); 1568 1569 return 0; 1570 } 1571 1572 static int dw2102_rc_query(struct dvb_usb_device *d) 1573 { 1574 u8 key[2]; 1575 struct i2c_msg msg = { 1576 .addr = DW2102_RC_QUERY, 1577 .flags = I2C_M_RD, 1578 .buf = key, 1579 .len = 2 1580 }; 1581 1582 if (d->props.i2c_algo->master_xfer(&d->i2c_adap, &msg, 1) == 1) { 1583 if (msg.buf[0] != 0xff) { 1584 deb_rc("%s: rc code: %x, %x\n", 1585 __func__, key[0], key[1]); 1586 rc_keydown(d->rc_dev, RC_TYPE_UNKNOWN, key[0], 0); 1587 } 1588 } 1589 1590 return 0; 1591 } 1592 1593 static int prof_rc_query(struct dvb_usb_device *d) 1594 { 1595 u8 key[2]; 1596 struct i2c_msg msg = { 1597 .addr = DW2102_RC_QUERY, 1598 .flags = I2C_M_RD, 1599 .buf = key, 1600 .len = 2 1601 }; 1602 1603 if (d->props.i2c_algo->master_xfer(&d->i2c_adap, &msg, 1) == 1) { 1604 if (msg.buf[0] != 0xff) { 1605 deb_rc("%s: rc code: %x, %x\n", 1606 __func__, key[0], key[1]); 1607 rc_keydown(d->rc_dev, RC_TYPE_UNKNOWN, key[0]^0xff, 0); 1608 } 1609 } 1610 1611 return 0; 1612 } 1613 1614 static int su3000_rc_query(struct dvb_usb_device *d) 1615 { 1616 u8 key[2]; 1617 struct i2c_msg msg = { 1618 .addr = DW2102_RC_QUERY, 1619 .flags = I2C_M_RD, 1620 .buf = key, 1621 .len = 2 1622 }; 1623 1624 if (d->props.i2c_algo->master_xfer(&d->i2c_adap, &msg, 1) == 1) { 1625 if (msg.buf[0] != 0xff) { 1626 deb_rc("%s: rc code: %x, %x\n", 1627 __func__, key[0], key[1]); 1628 rc_keydown(d->rc_dev, RC_TYPE_RC5, 1629 RC_SCANCODE_RC5(key[1], key[0]), 0); 1630 } 1631 } 1632 1633 return 0; 1634 } 1635 1636 enum dw2102_table_entry { 1637 CYPRESS_DW2102, 1638 CYPRESS_DW2101, 1639 CYPRESS_DW2104, 1640 TEVII_S650, 1641 TERRATEC_CINERGY_S, 1642 CYPRESS_DW3101, 1643 TEVII_S630, 1644 PROF_1100, 1645 TEVII_S660, 1646 PROF_7500, 1647 GENIATECH_SU3000, 1648 TERRATEC_CINERGY_S2, 1649 TEVII_S480_1, 1650 TEVII_S480_2, 1651 X3M_SPC1400HD, 1652 TEVII_S421, 1653 TEVII_S632, 1654 TERRATEC_CINERGY_S2_R2, 1655 GOTVIEW_SAT_HD, 1656 GENIATECH_T220, 1657 TECHNOTREND_S2_4600, 1658 TEVII_S482_1, 1659 TEVII_S482_2, 1660 }; 1661 1662 static struct usb_device_id dw2102_table[] = { 1663 [CYPRESS_DW2102] = {USB_DEVICE(USB_VID_CYPRESS, USB_PID_DW2102)}, 1664 [CYPRESS_DW2101] = {USB_DEVICE(USB_VID_CYPRESS, 0x2101)}, 1665 [CYPRESS_DW2104] = {USB_DEVICE(USB_VID_CYPRESS, USB_PID_DW2104)}, 1666 [TEVII_S650] = {USB_DEVICE(0x9022, USB_PID_TEVII_S650)}, 1667 [TERRATEC_CINERGY_S] = {USB_DEVICE(USB_VID_TERRATEC, USB_PID_CINERGY_S)}, 1668 [CYPRESS_DW3101] = {USB_DEVICE(USB_VID_CYPRESS, USB_PID_DW3101)}, 1669 [TEVII_S630] = {USB_DEVICE(0x9022, USB_PID_TEVII_S630)}, 1670 [PROF_1100] = {USB_DEVICE(0x3011, USB_PID_PROF_1100)}, 1671 [TEVII_S660] = {USB_DEVICE(0x9022, USB_PID_TEVII_S660)}, 1672 [PROF_7500] = {USB_DEVICE(0x3034, 0x7500)}, 1673 [GENIATECH_SU3000] = {USB_DEVICE(0x1f4d, 0x3000)}, 1674 [TERRATEC_CINERGY_S2] = {USB_DEVICE(USB_VID_TERRATEC, 0x00a8)}, 1675 [TEVII_S480_1] = {USB_DEVICE(0x9022, USB_PID_TEVII_S480_1)}, 1676 [TEVII_S480_2] = {USB_DEVICE(0x9022, USB_PID_TEVII_S480_2)}, 1677 [X3M_SPC1400HD] = {USB_DEVICE(0x1f4d, 0x3100)}, 1678 [TEVII_S421] = {USB_DEVICE(0x9022, USB_PID_TEVII_S421)}, 1679 [TEVII_S632] = {USB_DEVICE(0x9022, USB_PID_TEVII_S632)}, 1680 [TERRATEC_CINERGY_S2_R2] = {USB_DEVICE(USB_VID_TERRATEC, 0x00b0)}, 1681 [GOTVIEW_SAT_HD] = {USB_DEVICE(0x1FE1, USB_PID_GOTVIEW_SAT_HD)}, 1682 [GENIATECH_T220] = {USB_DEVICE(0x1f4d, 0xD220)}, 1683 [TECHNOTREND_S2_4600] = {USB_DEVICE(USB_VID_TECHNOTREND, 1684 USB_PID_TECHNOTREND_CONNECT_S2_4600)}, 1685 [TEVII_S482_1] = {USB_DEVICE(0x9022, 0xd483)}, 1686 [TEVII_S482_2] = {USB_DEVICE(0x9022, 0xd484)}, 1687 { } 1688 }; 1689 1690 MODULE_DEVICE_TABLE(usb, dw2102_table); 1691 1692 static int dw2102_load_firmware(struct usb_device *dev, 1693 const struct firmware *frmwr) 1694 { 1695 u8 *b, *p; 1696 int ret = 0, i; 1697 u8 reset; 1698 u8 reset16[] = {0, 0, 0, 0, 0, 0, 0}; 1699 const struct firmware *fw; 1700 1701 switch (le16_to_cpu(dev->descriptor.idProduct)) { 1702 case 0x2101: 1703 ret = request_firmware(&fw, DW2101_FIRMWARE, &dev->dev); 1704 if (ret != 0) { 1705 err(err_str, DW2101_FIRMWARE); 1706 return ret; 1707 } 1708 break; 1709 default: 1710 fw = frmwr; 1711 break; 1712 } 1713 info("start downloading DW210X firmware"); 1714 p = kmalloc(fw->size, GFP_KERNEL); 1715 reset = 1; 1716 /*stop the CPU*/ 1717 dw210x_op_rw(dev, 0xa0, 0x7f92, 0, &reset, 1, DW210X_WRITE_MSG); 1718 dw210x_op_rw(dev, 0xa0, 0xe600, 0, &reset, 1, DW210X_WRITE_MSG); 1719 1720 if (p != NULL) { 1721 memcpy(p, fw->data, fw->size); 1722 for (i = 0; i < fw->size; i += 0x40) { 1723 b = (u8 *) p + i; 1724 if (dw210x_op_rw(dev, 0xa0, i, 0, b , 0x40, 1725 DW210X_WRITE_MSG) != 0x40) { 1726 err("error while transferring firmware"); 1727 ret = -EINVAL; 1728 break; 1729 } 1730 } 1731 /* restart the CPU */ 1732 reset = 0; 1733 if (ret || dw210x_op_rw(dev, 0xa0, 0x7f92, 0, &reset, 1, 1734 DW210X_WRITE_MSG) != 1) { 1735 err("could not restart the USB controller CPU."); 1736 ret = -EINVAL; 1737 } 1738 if (ret || dw210x_op_rw(dev, 0xa0, 0xe600, 0, &reset, 1, 1739 DW210X_WRITE_MSG) != 1) { 1740 err("could not restart the USB controller CPU."); 1741 ret = -EINVAL; 1742 } 1743 /* init registers */ 1744 switch (le16_to_cpu(dev->descriptor.idProduct)) { 1745 case USB_PID_TEVII_S650: 1746 dw2104_properties.rc.core.rc_codes = RC_MAP_TEVII_NEC; 1747 case USB_PID_DW2104: 1748 reset = 1; 1749 dw210x_op_rw(dev, 0xc4, 0x0000, 0, &reset, 1, 1750 DW210X_WRITE_MSG); 1751 /* break omitted intentionally */ 1752 case USB_PID_DW3101: 1753 reset = 0; 1754 dw210x_op_rw(dev, 0xbf, 0x0040, 0, &reset, 0, 1755 DW210X_WRITE_MSG); 1756 break; 1757 case USB_PID_CINERGY_S: 1758 case USB_PID_DW2102: 1759 dw210x_op_rw(dev, 0xbf, 0x0040, 0, &reset, 0, 1760 DW210X_WRITE_MSG); 1761 dw210x_op_rw(dev, 0xb9, 0x0000, 0, &reset16[0], 2, 1762 DW210X_READ_MSG); 1763 /* check STV0299 frontend */ 1764 dw210x_op_rw(dev, 0xb5, 0, 0, &reset16[0], 2, 1765 DW210X_READ_MSG); 1766 if ((reset16[0] == 0xa1) || (reset16[0] == 0x80)) { 1767 dw2102_properties.i2c_algo = &dw2102_i2c_algo; 1768 dw2102_properties.adapter->fe[0].tuner_attach = &dw2102_tuner_attach; 1769 break; 1770 } else { 1771 /* check STV0288 frontend */ 1772 reset16[0] = 0xd0; 1773 reset16[1] = 1; 1774 reset16[2] = 0; 1775 dw210x_op_rw(dev, 0xc2, 0, 0, &reset16[0], 3, 1776 DW210X_WRITE_MSG); 1777 dw210x_op_rw(dev, 0xc3, 0xd1, 0, &reset16[0], 3, 1778 DW210X_READ_MSG); 1779 if (reset16[2] == 0x11) { 1780 dw2102_properties.i2c_algo = &dw2102_earda_i2c_algo; 1781 break; 1782 } 1783 } 1784 case 0x2101: 1785 dw210x_op_rw(dev, 0xbc, 0x0030, 0, &reset16[0], 2, 1786 DW210X_READ_MSG); 1787 dw210x_op_rw(dev, 0xba, 0x0000, 0, &reset16[0], 7, 1788 DW210X_READ_MSG); 1789 dw210x_op_rw(dev, 0xba, 0x0000, 0, &reset16[0], 7, 1790 DW210X_READ_MSG); 1791 dw210x_op_rw(dev, 0xb9, 0x0000, 0, &reset16[0], 2, 1792 DW210X_READ_MSG); 1793 break; 1794 } 1795 1796 msleep(100); 1797 kfree(p); 1798 } 1799 return ret; 1800 } 1801 1802 static struct dvb_usb_device_properties dw2102_properties = { 1803 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1804 .usb_ctrl = DEVICE_SPECIFIC, 1805 .firmware = DW2102_FIRMWARE, 1806 .no_reconnect = 1, 1807 1808 .i2c_algo = &dw2102_serit_i2c_algo, 1809 1810 .rc.core = { 1811 .rc_interval = 150, 1812 .rc_codes = RC_MAP_DM1105_NEC, 1813 .module_name = "dw2102", 1814 .allowed_protos = RC_BIT_NEC, 1815 .rc_query = dw2102_rc_query, 1816 }, 1817 1818 .generic_bulk_ctrl_endpoint = 0x81, 1819 /* parameter for the MPEG2-data transfer */ 1820 .num_adapters = 1, 1821 .download_firmware = dw2102_load_firmware, 1822 .read_mac_address = dw210x_read_mac_address, 1823 .adapter = { 1824 { 1825 .num_frontends = 1, 1826 .fe = {{ 1827 .frontend_attach = dw2102_frontend_attach, 1828 .stream = { 1829 .type = USB_BULK, 1830 .count = 8, 1831 .endpoint = 0x82, 1832 .u = { 1833 .bulk = { 1834 .buffersize = 4096, 1835 } 1836 } 1837 }, 1838 }}, 1839 } 1840 }, 1841 .num_device_descs = 3, 1842 .devices = { 1843 {"DVBWorld DVB-S 2102 USB2.0", 1844 {&dw2102_table[CYPRESS_DW2102], NULL}, 1845 {NULL}, 1846 }, 1847 {"DVBWorld DVB-S 2101 USB2.0", 1848 {&dw2102_table[CYPRESS_DW2101], NULL}, 1849 {NULL}, 1850 }, 1851 {"TerraTec Cinergy S USB", 1852 {&dw2102_table[TERRATEC_CINERGY_S], NULL}, 1853 {NULL}, 1854 }, 1855 } 1856 }; 1857 1858 static struct dvb_usb_device_properties dw2104_properties = { 1859 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1860 .usb_ctrl = DEVICE_SPECIFIC, 1861 .firmware = DW2104_FIRMWARE, 1862 .no_reconnect = 1, 1863 1864 .i2c_algo = &dw2104_i2c_algo, 1865 .rc.core = { 1866 .rc_interval = 150, 1867 .rc_codes = RC_MAP_DM1105_NEC, 1868 .module_name = "dw2102", 1869 .allowed_protos = RC_BIT_NEC, 1870 .rc_query = dw2102_rc_query, 1871 }, 1872 1873 .generic_bulk_ctrl_endpoint = 0x81, 1874 /* parameter for the MPEG2-data transfer */ 1875 .num_adapters = 1, 1876 .download_firmware = dw2102_load_firmware, 1877 .read_mac_address = dw210x_read_mac_address, 1878 .adapter = { 1879 { 1880 .num_frontends = 1, 1881 .fe = {{ 1882 .frontend_attach = dw2104_frontend_attach, 1883 .stream = { 1884 .type = USB_BULK, 1885 .count = 8, 1886 .endpoint = 0x82, 1887 .u = { 1888 .bulk = { 1889 .buffersize = 4096, 1890 } 1891 } 1892 }, 1893 }}, 1894 } 1895 }, 1896 .num_device_descs = 2, 1897 .devices = { 1898 { "DVBWorld DW2104 USB2.0", 1899 {&dw2102_table[CYPRESS_DW2104], NULL}, 1900 {NULL}, 1901 }, 1902 { "TeVii S650 USB2.0", 1903 {&dw2102_table[TEVII_S650], NULL}, 1904 {NULL}, 1905 }, 1906 } 1907 }; 1908 1909 static struct dvb_usb_device_properties dw3101_properties = { 1910 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1911 .usb_ctrl = DEVICE_SPECIFIC, 1912 .firmware = DW3101_FIRMWARE, 1913 .no_reconnect = 1, 1914 1915 .i2c_algo = &dw3101_i2c_algo, 1916 .rc.core = { 1917 .rc_interval = 150, 1918 .rc_codes = RC_MAP_DM1105_NEC, 1919 .module_name = "dw2102", 1920 .allowed_protos = RC_BIT_NEC, 1921 .rc_query = dw2102_rc_query, 1922 }, 1923 1924 .generic_bulk_ctrl_endpoint = 0x81, 1925 /* parameter for the MPEG2-data transfer */ 1926 .num_adapters = 1, 1927 .download_firmware = dw2102_load_firmware, 1928 .read_mac_address = dw210x_read_mac_address, 1929 .adapter = { 1930 { 1931 .num_frontends = 1, 1932 .fe = {{ 1933 .frontend_attach = dw3101_frontend_attach, 1934 .tuner_attach = dw3101_tuner_attach, 1935 .stream = { 1936 .type = USB_BULK, 1937 .count = 8, 1938 .endpoint = 0x82, 1939 .u = { 1940 .bulk = { 1941 .buffersize = 4096, 1942 } 1943 } 1944 }, 1945 }}, 1946 } 1947 }, 1948 .num_device_descs = 1, 1949 .devices = { 1950 { "DVBWorld DVB-C 3101 USB2.0", 1951 {&dw2102_table[CYPRESS_DW3101], NULL}, 1952 {NULL}, 1953 }, 1954 } 1955 }; 1956 1957 static struct dvb_usb_device_properties s6x0_properties = { 1958 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 1959 .usb_ctrl = DEVICE_SPECIFIC, 1960 .size_of_priv = sizeof(struct dw2102_state), 1961 .firmware = S630_FIRMWARE, 1962 .no_reconnect = 1, 1963 1964 .i2c_algo = &s6x0_i2c_algo, 1965 .rc.core = { 1966 .rc_interval = 150, 1967 .rc_codes = RC_MAP_TEVII_NEC, 1968 .module_name = "dw2102", 1969 .allowed_protos = RC_BIT_NEC, 1970 .rc_query = dw2102_rc_query, 1971 }, 1972 1973 .generic_bulk_ctrl_endpoint = 0x81, 1974 .num_adapters = 1, 1975 .download_firmware = dw2102_load_firmware, 1976 .read_mac_address = s6x0_read_mac_address, 1977 .adapter = { 1978 { 1979 .num_frontends = 1, 1980 .fe = {{ 1981 .frontend_attach = zl100313_frontend_attach, 1982 .stream = { 1983 .type = USB_BULK, 1984 .count = 8, 1985 .endpoint = 0x82, 1986 .u = { 1987 .bulk = { 1988 .buffersize = 4096, 1989 } 1990 } 1991 }, 1992 }}, 1993 } 1994 }, 1995 .num_device_descs = 1, 1996 .devices = { 1997 {"TeVii S630 USB", 1998 {&dw2102_table[TEVII_S630], NULL}, 1999 {NULL}, 2000 }, 2001 } 2002 }; 2003 2004 static struct dvb_usb_device_properties *p1100; 2005 static struct dvb_usb_device_description d1100 = { 2006 "Prof 1100 USB ", 2007 {&dw2102_table[PROF_1100], NULL}, 2008 {NULL}, 2009 }; 2010 2011 static struct dvb_usb_device_properties *s660; 2012 static struct dvb_usb_device_description d660 = { 2013 "TeVii S660 USB", 2014 {&dw2102_table[TEVII_S660], NULL}, 2015 {NULL}, 2016 }; 2017 2018 static struct dvb_usb_device_description d480_1 = { 2019 "TeVii S480.1 USB", 2020 {&dw2102_table[TEVII_S480_1], NULL}, 2021 {NULL}, 2022 }; 2023 2024 static struct dvb_usb_device_description d480_2 = { 2025 "TeVii S480.2 USB", 2026 {&dw2102_table[TEVII_S480_2], NULL}, 2027 {NULL}, 2028 }; 2029 2030 static struct dvb_usb_device_properties *p7500; 2031 static struct dvb_usb_device_description d7500 = { 2032 "Prof 7500 USB DVB-S2", 2033 {&dw2102_table[PROF_7500], NULL}, 2034 {NULL}, 2035 }; 2036 2037 static struct dvb_usb_device_properties *s421; 2038 static struct dvb_usb_device_description d421 = { 2039 "TeVii S421 PCI", 2040 {&dw2102_table[TEVII_S421], NULL}, 2041 {NULL}, 2042 }; 2043 2044 static struct dvb_usb_device_description d632 = { 2045 "TeVii S632 USB", 2046 {&dw2102_table[TEVII_S632], NULL}, 2047 {NULL}, 2048 }; 2049 2050 static struct dvb_usb_device_properties su3000_properties = { 2051 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 2052 .usb_ctrl = DEVICE_SPECIFIC, 2053 .size_of_priv = sizeof(struct dw2102_state), 2054 .power_ctrl = su3000_power_ctrl, 2055 .num_adapters = 1, 2056 .identify_state = su3000_identify_state, 2057 .i2c_algo = &su3000_i2c_algo, 2058 2059 .rc.core = { 2060 .rc_interval = 150, 2061 .rc_codes = RC_MAP_SU3000, 2062 .module_name = "dw2102", 2063 .allowed_protos = RC_BIT_RC5, 2064 .rc_query = su3000_rc_query, 2065 }, 2066 2067 .read_mac_address = su3000_read_mac_address, 2068 2069 .generic_bulk_ctrl_endpoint = 0x01, 2070 2071 .adapter = { 2072 { 2073 .num_frontends = 1, 2074 .fe = {{ 2075 .streaming_ctrl = su3000_streaming_ctrl, 2076 .frontend_attach = su3000_frontend_attach, 2077 .stream = { 2078 .type = USB_BULK, 2079 .count = 8, 2080 .endpoint = 0x82, 2081 .u = { 2082 .bulk = { 2083 .buffersize = 4096, 2084 } 2085 } 2086 } 2087 }}, 2088 } 2089 }, 2090 .num_device_descs = 5, 2091 .devices = { 2092 { "SU3000HD DVB-S USB2.0", 2093 { &dw2102_table[GENIATECH_SU3000], NULL }, 2094 { NULL }, 2095 }, 2096 { "Terratec Cinergy S2 USB HD", 2097 { &dw2102_table[TERRATEC_CINERGY_S2], NULL }, 2098 { NULL }, 2099 }, 2100 { "X3M TV SPC1400HD PCI", 2101 { &dw2102_table[X3M_SPC1400HD], NULL }, 2102 { NULL }, 2103 }, 2104 { "Terratec Cinergy S2 USB HD Rev.2", 2105 { &dw2102_table[TERRATEC_CINERGY_S2_R2], NULL }, 2106 { NULL }, 2107 }, 2108 { "GOTVIEW Satellite HD", 2109 { &dw2102_table[GOTVIEW_SAT_HD], NULL }, 2110 { NULL }, 2111 }, 2112 } 2113 }; 2114 2115 static struct dvb_usb_device_properties t220_properties = { 2116 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 2117 .usb_ctrl = DEVICE_SPECIFIC, 2118 .size_of_priv = sizeof(struct dw2102_state), 2119 .power_ctrl = su3000_power_ctrl, 2120 .num_adapters = 1, 2121 .identify_state = su3000_identify_state, 2122 .i2c_algo = &su3000_i2c_algo, 2123 2124 .rc.core = { 2125 .rc_interval = 150, 2126 .rc_codes = RC_MAP_SU3000, 2127 .module_name = "dw2102", 2128 .allowed_protos = RC_BIT_RC5, 2129 .rc_query = su3000_rc_query, 2130 }, 2131 2132 .read_mac_address = su3000_read_mac_address, 2133 2134 .generic_bulk_ctrl_endpoint = 0x01, 2135 2136 .adapter = { 2137 { 2138 .num_frontends = 1, 2139 .fe = { { 2140 .streaming_ctrl = su3000_streaming_ctrl, 2141 .frontend_attach = t220_frontend_attach, 2142 .stream = { 2143 .type = USB_BULK, 2144 .count = 8, 2145 .endpoint = 0x82, 2146 .u = { 2147 .bulk = { 2148 .buffersize = 4096, 2149 } 2150 } 2151 } 2152 } }, 2153 } 2154 }, 2155 .num_device_descs = 1, 2156 .devices = { 2157 { "Geniatech T220 DVB-T/T2 USB2.0", 2158 { &dw2102_table[GENIATECH_T220], NULL }, 2159 { NULL }, 2160 }, 2161 } 2162 }; 2163 2164 static struct dvb_usb_device_properties tt_s2_4600_properties = { 2165 .caps = DVB_USB_IS_AN_I2C_ADAPTER, 2166 .usb_ctrl = DEVICE_SPECIFIC, 2167 .size_of_priv = sizeof(struct dw2102_state), 2168 .power_ctrl = su3000_power_ctrl, 2169 .num_adapters = 1, 2170 .identify_state = su3000_identify_state, 2171 .i2c_algo = &su3000_i2c_algo, 2172 2173 .rc.core = { 2174 .rc_interval = 250, 2175 .rc_codes = RC_MAP_TT_1500, 2176 .module_name = "dw2102", 2177 .allowed_protos = RC_BIT_RC5, 2178 .rc_query = su3000_rc_query, 2179 }, 2180 2181 .read_mac_address = su3000_read_mac_address, 2182 2183 .generic_bulk_ctrl_endpoint = 0x01, 2184 2185 .adapter = { 2186 { 2187 .num_frontends = 1, 2188 .fe = {{ 2189 .streaming_ctrl = su3000_streaming_ctrl, 2190 .frontend_attach = tt_s2_4600_frontend_attach, 2191 .stream = { 2192 .type = USB_BULK, 2193 .count = 8, 2194 .endpoint = 0x82, 2195 .u = { 2196 .bulk = { 2197 .buffersize = 4096, 2198 } 2199 } 2200 } 2201 } }, 2202 } 2203 }, 2204 .num_device_descs = 3, 2205 .devices = { 2206 { "TechnoTrend TT-connect S2-4600", 2207 { &dw2102_table[TECHNOTREND_S2_4600], NULL }, 2208 { NULL }, 2209 }, 2210 { "TeVii S482 (tuner 1)", 2211 { &dw2102_table[TEVII_S482_1], NULL }, 2212 { NULL }, 2213 }, 2214 { "TeVii S482 (tuner 2)", 2215 { &dw2102_table[TEVII_S482_2], NULL }, 2216 { NULL }, 2217 }, 2218 } 2219 }; 2220 2221 static int dw2102_probe(struct usb_interface *intf, 2222 const struct usb_device_id *id) 2223 { 2224 p1100 = kmemdup(&s6x0_properties, 2225 sizeof(struct dvb_usb_device_properties), GFP_KERNEL); 2226 if (!p1100) 2227 return -ENOMEM; 2228 /* copy default structure */ 2229 /* fill only different fields */ 2230 p1100->firmware = P1100_FIRMWARE; 2231 p1100->devices[0] = d1100; 2232 p1100->rc.core.rc_query = prof_rc_query; 2233 p1100->rc.core.rc_codes = RC_MAP_TBS_NEC; 2234 p1100->adapter->fe[0].frontend_attach = stv0288_frontend_attach; 2235 2236 s660 = kmemdup(&s6x0_properties, 2237 sizeof(struct dvb_usb_device_properties), GFP_KERNEL); 2238 if (!s660) { 2239 kfree(p1100); 2240 return -ENOMEM; 2241 } 2242 s660->firmware = S660_FIRMWARE; 2243 s660->num_device_descs = 3; 2244 s660->devices[0] = d660; 2245 s660->devices[1] = d480_1; 2246 s660->devices[2] = d480_2; 2247 s660->adapter->fe[0].frontend_attach = ds3000_frontend_attach; 2248 2249 p7500 = kmemdup(&s6x0_properties, 2250 sizeof(struct dvb_usb_device_properties), GFP_KERNEL); 2251 if (!p7500) { 2252 kfree(p1100); 2253 kfree(s660); 2254 return -ENOMEM; 2255 } 2256 p7500->firmware = P7500_FIRMWARE; 2257 p7500->devices[0] = d7500; 2258 p7500->rc.core.rc_query = prof_rc_query; 2259 p7500->rc.core.rc_codes = RC_MAP_TBS_NEC; 2260 p7500->adapter->fe[0].frontend_attach = prof_7500_frontend_attach; 2261 2262 2263 s421 = kmemdup(&su3000_properties, 2264 sizeof(struct dvb_usb_device_properties), GFP_KERNEL); 2265 if (!s421) { 2266 kfree(p1100); 2267 kfree(s660); 2268 kfree(p7500); 2269 return -ENOMEM; 2270 } 2271 s421->num_device_descs = 2; 2272 s421->devices[0] = d421; 2273 s421->devices[1] = d632; 2274 s421->adapter->fe[0].frontend_attach = m88rs2000_frontend_attach; 2275 2276 if (0 == dvb_usb_device_init(intf, &dw2102_properties, 2277 THIS_MODULE, NULL, adapter_nr) || 2278 0 == dvb_usb_device_init(intf, &dw2104_properties, 2279 THIS_MODULE, NULL, adapter_nr) || 2280 0 == dvb_usb_device_init(intf, &dw3101_properties, 2281 THIS_MODULE, NULL, adapter_nr) || 2282 0 == dvb_usb_device_init(intf, &s6x0_properties, 2283 THIS_MODULE, NULL, adapter_nr) || 2284 0 == dvb_usb_device_init(intf, p1100, 2285 THIS_MODULE, NULL, adapter_nr) || 2286 0 == dvb_usb_device_init(intf, s660, 2287 THIS_MODULE, NULL, adapter_nr) || 2288 0 == dvb_usb_device_init(intf, p7500, 2289 THIS_MODULE, NULL, adapter_nr) || 2290 0 == dvb_usb_device_init(intf, s421, 2291 THIS_MODULE, NULL, adapter_nr) || 2292 0 == dvb_usb_device_init(intf, &su3000_properties, 2293 THIS_MODULE, NULL, adapter_nr) || 2294 0 == dvb_usb_device_init(intf, &t220_properties, 2295 THIS_MODULE, NULL, adapter_nr) || 2296 0 == dvb_usb_device_init(intf, &tt_s2_4600_properties, 2297 THIS_MODULE, NULL, adapter_nr)) 2298 return 0; 2299 2300 return -ENODEV; 2301 } 2302 2303 static void dw2102_disconnect(struct usb_interface *intf) 2304 { 2305 struct dvb_usb_device *d = usb_get_intfdata(intf); 2306 struct dw2102_state *st = (struct dw2102_state *)d->priv; 2307 struct i2c_client *client; 2308 2309 /* remove I2C client for tuner */ 2310 client = st->i2c_client_tuner; 2311 if (client) { 2312 module_put(client->dev.driver->owner); 2313 i2c_unregister_device(client); 2314 } 2315 2316 dvb_usb_device_exit(intf); 2317 } 2318 2319 static struct usb_driver dw2102_driver = { 2320 .name = "dw2102", 2321 .probe = dw2102_probe, 2322 .disconnect = dw2102_disconnect, 2323 .id_table = dw2102_table, 2324 }; 2325 2326 module_usb_driver(dw2102_driver); 2327 2328 MODULE_AUTHOR("Igor M. Liplianin (c) liplianin@me.by"); 2329 MODULE_DESCRIPTION("Driver for DVBWorld DVB-S 2101, 2102, DVB-S2 2104," 2330 " DVB-C 3101 USB2.0," 2331 " TeVii S600, S630, S650, S660, S480, S421, S632" 2332 " Prof 1100, 7500 USB2.0," 2333 " Geniatech SU3000, T220," 2334 " TechnoTrend S2-4600 devices"); 2335 MODULE_VERSION("0.1"); 2336 MODULE_LICENSE("GPL"); 2337 MODULE_FIRMWARE(DW2101_FIRMWARE); 2338 MODULE_FIRMWARE(DW2102_FIRMWARE); 2339 MODULE_FIRMWARE(DW2104_FIRMWARE); 2340 MODULE_FIRMWARE(DW3101_FIRMWARE); 2341 MODULE_FIRMWARE(S630_FIRMWARE); 2342 MODULE_FIRMWARE(S660_FIRMWARE); 2343 MODULE_FIRMWARE(P1100_FIRMWARE); 2344 MODULE_FIRMWARE(P7500_FIRMWARE); 2345