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