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