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