drivers/media/usb/dvb-usb/dw2102.c

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