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