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

   1 /*
   2  * DVB USB Linux driver for Afatech AF9015 DVB-T USB2.0 receiver
   3  *
   4  * Copyright (C) 2007 Antti Palosaari <crope@iki.fi>
   5  *
   6  * Thanks to Afatech who kindly provided information.
   7  *
   8  *    This program is free software; you can redistribute it and/or modify
   9  *    it under the terms of the GNU General Public License as published by
  10  *    the Free Software Foundation; either version 2 of the License, or
  11  *    (at your option) any later version.
  12  *
  13  *    This program is distributed in the hope that it will be useful,
  14  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *    GNU General Public License for more details.
  17  *
  18  *    You should have received a copy of the GNU General Public License
  19  *    along with this program; if not, write to the Free Software
  20  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21  *
  22  */
  23
  24 #include <linux/hash.h>
  25 #include <linux/slab.h>
  26
  27 #include "af9015.h"
  28 #include "af9013.h"
  29 #include "mt2060.h"
  30 #include "qt1010.h"
  31 #include "tda18271.h"
  32 #include "mxl5005s.h"
  33 #include "mc44s803.h"
  34 #include "tda18218.h"
  35 #include "mxl5007t.h"
  36
  37 static int dvb_usb_af9015_debug;
  38 module_param_named(debug, dvb_usb_af9015_debug, int, 0644);
  39 MODULE_PARM_DESC(debug, "set debugging level" DVB_USB_DEBUG_STATUS);
  40 static int dvb_usb_af9015_remote;
  41 module_param_named(remote, dvb_usb_af9015_remote, int, 0644);
  42 MODULE_PARM_DESC(remote, "select remote");
  43 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  44
  45 static DEFINE_MUTEX(af9015_usb_mutex);
  46
  47 static struct af9015_config af9015_config;
  48 static struct dvb_usb_device_properties af9015_properties[3];
  49 static int af9015_properties_count = ARRAY_SIZE(af9015_properties);
  50
  51 static struct af9013_config af9015_af9013_config[] = {
  52         {
  53                 .i2c_addr = AF9015_I2C_DEMOD,
  54                 .ts_mode = AF9013_TS_USB,
  55                 .api_version = { 0, 1, 9, 0 },
  56                 .gpio[0] = AF9013_GPIO_HI,
  57                 .gpio[3] = AF9013_GPIO_TUNER_ON,
  58
  59         }, {
  60                 .ts_mode = AF9013_TS_SERIAL,
  61                 .api_version = { 0, 1, 9, 0 },
  62                 .gpio[0] = AF9013_GPIO_TUNER_ON,
  63                 .gpio[1] = AF9013_GPIO_LO,
  64         }
  65 };
  66
  67 static int af9015_rw_udev(struct usb_device *udev, struct req_t *req)
  68 {
  69 #define BUF_LEN 63
  70 #define REQ_HDR_LEN 8 /* send header size */
  71 #define ACK_HDR_LEN 2 /* rece header size */
  72         int act_len, ret;
  73         u8 buf[BUF_LEN];
  74         u8 write = 1;
  75         u8 msg_len = REQ_HDR_LEN;
  76         static u8 seq; /* packet sequence number */
  77
  78         if (mutex_lock_interruptible(&af9015_usb_mutex) < 0)
  79                 return -EAGAIN;
  80
  81         buf[0] = req->cmd;
  82         buf[1] = seq++;
  83         buf[2] = req->i2c_addr;
  84         buf[3] = req->addr >> 8;
  85         buf[4] = req->addr & 0xff;
  86         buf[5] = req->mbox;
  87         buf[6] = req->addr_len;
  88         buf[7] = req->data_len;
  89
  90         switch (req->cmd) {
  91         case GET_CONFIG:
  92         case READ_MEMORY:
  93         case RECONNECT_USB:
  94                 write = 0;
  95                 break;
  96         case READ_I2C:
  97                 write = 0;
  98                 buf[2] |= 0x01; /* set I2C direction */
  99         case WRITE_I2C:
 100                 buf[0] = READ_WRITE_I2C;
 101                 break;
 102         case WRITE_MEMORY:
 103                 if (((req->addr & 0xff00) == 0xff00) ||
 104                     ((req->addr & 0xff00) == 0xae00))
 105                         buf[0] = WRITE_VIRTUAL_MEMORY;
 106         case WRITE_VIRTUAL_MEMORY:
 107         case COPY_FIRMWARE:
 108         case DOWNLOAD_FIRMWARE:
 109         case BOOT:
 110                 break;
 111         default:
 112                 err("unknown command:%d", req->cmd);
 113                 ret = -1;
 114                 goto error_unlock;
 115         }
 116
 117         /* buffer overflow check */
 118         if ((write && (req->data_len > BUF_LEN - REQ_HDR_LEN)) ||
 119                 (!write && (req->data_len > BUF_LEN - ACK_HDR_LEN))) {
 120                 err("too much data; cmd:%d len:%d", req->cmd, req->data_len);
 121                 ret = -EINVAL;
 122                 goto error_unlock;
 123         }
 124
 125         /* write requested */
 126         if (write) {
 127                 memcpy(&buf[REQ_HDR_LEN], req->data, req->data_len);
 128                 msg_len += req->data_len;
 129         }
 130
 131         deb_xfer(">>> ");
 132         debug_dump(buf, msg_len, deb_xfer);
 133
 134         /* send req */
 135         ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 0x02), buf, msg_len,
 136                 &act_len, AF9015_USB_TIMEOUT);
 137         if (ret)
 138                 err("bulk message failed:%d (%d/%d)", ret, msg_len, act_len);
 139         else
 140                 if (act_len != msg_len)
 141                         ret = -1; /* all data is not send */
 142         if (ret)
 143                 goto error_unlock;
 144
 145         /* no ack for those packets */
 146         if (req->cmd == DOWNLOAD_FIRMWARE || req->cmd == RECONNECT_USB)
 147                 goto exit_unlock;
 148
 149         /* write receives seq + status = 2 bytes
 150            read receives seq + status + data = 2 + N bytes */
 151         msg_len = ACK_HDR_LEN;
 152         if (!write)
 153                 msg_len += req->data_len;
 154
 155         ret = usb_bulk_msg(udev, usb_rcvbulkpipe(udev, 0x81), buf, msg_len,
 156                 &act_len, AF9015_USB_TIMEOUT);
 157         if (ret) {
 158                 err("recv bulk message failed:%d", ret);
 159                 ret = -1;
 160                 goto error_unlock;
 161         }
 162
 163         deb_xfer("<<< ");
 164         debug_dump(buf, act_len, deb_xfer);
 165
 166         /* check status */
 167         if (buf[1]) {
 168                 err("command failed:%d", buf[1]);
 169                 ret = -1;
 170                 goto error_unlock;
 171         }
 172
 173         /* read request, copy returned data to return buf */
 174         if (!write)
 175                 memcpy(req->data, &buf[ACK_HDR_LEN], req->data_len);
 176
 177 error_unlock:
 178 exit_unlock:
 179         mutex_unlock(&af9015_usb_mutex);
 180
 181         return ret;
 182 }
 183
 184 static int af9015_ctrl_msg(struct dvb_usb_device *d, struct req_t *req)
 185 {
 186         return af9015_rw_udev(d->udev, req);
 187 }
 188
 189 static int af9015_write_regs(struct dvb_usb_device *d, u16 addr, u8 *val,
 190         u8 len)
 191 {
 192         struct req_t req = {WRITE_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, len,
 193                 val};
 194         return af9015_ctrl_msg(d, &req);
 195 }
 196
 197 static int af9015_write_reg(struct dvb_usb_device *d, u16 addr, u8 val)
 198 {
 199         return af9015_write_regs(d, addr, &val, 1);
 200 }
 201
 202 static int af9015_read_regs(struct dvb_usb_device *d, u16 addr, u8 *val, u8 len)
 203 {
 204         struct req_t req = {READ_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, len,
 205                 val};
 206         return af9015_ctrl_msg(d, &req);
 207 }
 208
 209 static int af9015_read_reg(struct dvb_usb_device *d, u16 addr, u8 *val)
 210 {
 211         return af9015_read_regs(d, addr, val, 1);
 212 }
 213
 214 static int af9015_write_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
 215         u8 val)
 216 {
 217         struct req_t req = {WRITE_I2C, addr, reg, 1, 1, 1, &val};
 218
 219         if (addr == af9015_af9013_config[0].i2c_addr ||
 220             addr == af9015_af9013_config[1].i2c_addr)
 221                 req.addr_len = 3;
 222
 223         return af9015_ctrl_msg(d, &req);
 224 }
 225
 226 static int af9015_read_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
 227         u8 *val)
 228 {
 229         struct req_t req = {READ_I2C, addr, reg, 0, 1, 1, val};
 230
 231         if (addr == af9015_af9013_config[0].i2c_addr ||
 232             addr == af9015_af9013_config[1].i2c_addr)
 233                 req.addr_len = 3;
 234
 235         return af9015_ctrl_msg(d, &req);
 236 }
 237
 238 static int af9015_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 239         int num)
 240 {
 241         struct dvb_usb_device *d = i2c_get_adapdata(adap);
 242         int ret = 0, i = 0;
 243         u16 addr;
 244         u8 uninitialized_var(mbox), addr_len;
 245         struct req_t req;
 246
 247 /*
 248 The bus lock is needed because there is two tuners both using same I2C-address.
 249 Due to that the only way to select correct tuner is use demodulator I2C-gate.
 250
 251 ................................................
 252 . AF9015 includes integrated AF9013 demodulator.
 253 . ____________                   ____________  .                ____________
 254 .|     uC     |                 |   demod    | .               |    tuner   |
 255 .|------------|                 |------------| .               |------------|
 256 .|   AF9015   |                 |  AF9013/5  | .               |   MXL5003  |
 257 .|            |--+----I2C-------|-----/ -----|-.-----I2C-------|            |
 258 .|            |  |              | addr 0x38  | .               |  addr 0xc6 |
 259 .|____________|  |              |____________| .               |____________|
 260 .................|..............................
 261                  |               ____________                   ____________
 262                  |              |   demod    |                 |    tuner   |
 263                  |              |------------|                 |------------|
 264                  |              |   AF9013   |                 |   MXL5003  |
 265                  +----I2C-------|-----/ -----|-------I2C-------|            |
 266                                 | addr 0x3a  |                 |  addr 0xc6 |
 267                                 |____________|                 |____________|
 268 */
 269         if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
 270                 return -EAGAIN;
 271
 272         while (i < num) {
 273                 if (msg[i].addr == af9015_af9013_config[0].i2c_addr ||
 274                     msg[i].addr == af9015_af9013_config[1].i2c_addr) {
 275                         addr = msg[i].buf[0] << 8;
 276                         addr += msg[i].buf[1];
 277                         mbox = msg[i].buf[2];
 278                         addr_len = 3;
 279                 } else {
 280                         addr = msg[i].buf[0];
 281                         addr_len = 1;
 282                         /* mbox is don't care in that case */
 283                 }
 284
 285                 if (num > i + 1 && (msg[i+1].flags & I2C_M_RD)) {
 286                         if (msg[i].len > 3 || msg[i+1].len > 61) {
 287                                 ret = -EOPNOTSUPP;
 288                                 goto error;
 289                         }
 290                         if (msg[i].addr == af9015_af9013_config[0].i2c_addr)
 291                                 req.cmd = READ_MEMORY;
 292                         else
 293                                 req.cmd = READ_I2C;
 294                         req.i2c_addr = msg[i].addr;
 295                         req.addr = addr;
 296                         req.mbox = mbox;
 297                         req.addr_len = addr_len;
 298                         req.data_len = msg[i+1].len;
 299                         req.data = &msg[i+1].buf[0];
 300                         ret = af9015_ctrl_msg(d, &req);
 301                         i += 2;
 302                 } else if (msg[i].flags & I2C_M_RD) {
 303                         if (msg[i].len > 61) {
 304                                 ret = -EOPNOTSUPP;
 305                                 goto error;
 306                         }
 307                         if (msg[i].addr ==
 308                                 af9015_af9013_config[0].i2c_addr) {
 309                                 ret = -EINVAL;
 310                                 goto error;
 311                         }
 312                         req.cmd = READ_I2C;
 313                         req.i2c_addr = msg[i].addr;
 314                         req.addr = addr;
 315                         req.mbox = mbox;
 316                         req.addr_len = addr_len;
 317                         req.data_len = msg[i].len;
 318                         req.data = &msg[i].buf[0];
 319                         ret = af9015_ctrl_msg(d, &req);
 320                         i += 1;
 321                 } else {
 322                         if (msg[i].len > 21) {
 323                                 ret = -EOPNOTSUPP;
 324                                 goto error;
 325                         }
 326                         if (msg[i].addr == af9015_af9013_config[0].i2c_addr)
 327                                 req.cmd = WRITE_MEMORY;
 328                         else
 329                                 req.cmd = WRITE_I2C;
 330                         req.i2c_addr = msg[i].addr;
 331                         req.addr = addr;
 332                         req.mbox = mbox;
 333                         req.addr_len = addr_len;
 334                         req.data_len = msg[i].len-addr_len;
 335                         req.data = &msg[i].buf[addr_len];
 336                         ret = af9015_ctrl_msg(d, &req);
 337                         i += 1;
 338                 }
 339                 if (ret)
 340                         goto error;
 341
 342         }
 343         ret = i;
 344
 345 error:
 346         mutex_unlock(&d->i2c_mutex);
 347
 348         return ret;
 349 }
 350
 351 static u32 af9015_i2c_func(struct i2c_adapter *adapter)
 352 {
 353         return I2C_FUNC_I2C;
 354 }
 355
 356 static struct i2c_algorithm af9015_i2c_algo = {
 357         .master_xfer = af9015_i2c_xfer,
 358         .functionality = af9015_i2c_func,
 359 };
 360
 361 static int af9015_do_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit, u8 op)
 362 {
 363         int ret;
 364         u8 val, mask = 0x01;
 365
 366         ret = af9015_read_reg(d, addr, &val);
 367         if (ret)
 368                 return ret;
 369
 370         mask <<= bit;
 371         if (op) {
 372                 /* set bit */
 373                 val |= mask;
 374         } else {
 375                 /* clear bit */
 376                 mask ^= 0xff;
 377                 val &= mask;
 378         }
 379
 380         return af9015_write_reg(d, addr, val);
 381 }
 382
 383 static int af9015_set_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit)
 384 {
 385         return af9015_do_reg_bit(d, addr, bit, 1);
 386 }
 387
 388 static int af9015_clear_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit)
 389 {
 390         return af9015_do_reg_bit(d, addr, bit, 0);
 391 }
 392
 393 static int af9015_init_endpoint(struct dvb_usb_device *d)
 394 {
 395         int ret;
 396         u16 frame_size;
 397         u8  packet_size;
 398         deb_info("%s: USB speed:%d\n", __func__, d->udev->speed);
 399
 400         /* Windows driver uses packet count 21 for USB1.1 and 348 for USB2.0.
 401            We use smaller - about 1/4 from the original, 5 and 87. */
 402 #define TS_PACKET_SIZE            188
 403
 404 #define TS_USB20_PACKET_COUNT      87
 405 #define TS_USB20_FRAME_SIZE       (TS_PACKET_SIZE*TS_USB20_PACKET_COUNT)
 406
 407 #define TS_USB11_PACKET_COUNT       5
 408 #define TS_USB11_FRAME_SIZE       (TS_PACKET_SIZE*TS_USB11_PACKET_COUNT)
 409
 410 #define TS_USB20_MAX_PACKET_SIZE  512
 411 #define TS_USB11_MAX_PACKET_SIZE   64
 412
 413         if (d->udev->speed == USB_SPEED_FULL) {
 414                 frame_size = TS_USB11_FRAME_SIZE/4;
 415                 packet_size = TS_USB11_MAX_PACKET_SIZE/4;
 416         } else {
 417                 frame_size = TS_USB20_FRAME_SIZE/4;
 418                 packet_size = TS_USB20_MAX_PACKET_SIZE/4;
 419         }
 420
 421         ret = af9015_set_reg_bit(d, 0xd507, 2); /* assert EP4 reset */
 422         if (ret)
 423                 goto error;
 424         ret = af9015_set_reg_bit(d, 0xd50b, 1); /* assert EP5 reset */
 425         if (ret)
 426                 goto error;
 427         ret = af9015_clear_reg_bit(d, 0xdd11, 5); /* disable EP4 */
 428         if (ret)
 429                 goto error;
 430         ret = af9015_clear_reg_bit(d, 0xdd11, 6); /* disable EP5 */
 431         if (ret)
 432                 goto error;
 433         ret = af9015_set_reg_bit(d, 0xdd11, 5); /* enable EP4 */
 434         if (ret)
 435                 goto error;
 436         if (af9015_config.dual_mode) {
 437                 ret = af9015_set_reg_bit(d, 0xdd11, 6); /* enable EP5 */
 438                 if (ret)
 439                         goto error;
 440         }
 441         ret = af9015_clear_reg_bit(d, 0xdd13, 5); /* disable EP4 NAK */
 442         if (ret)
 443                 goto error;
 444         if (af9015_config.dual_mode) {
 445                 ret = af9015_clear_reg_bit(d, 0xdd13, 6); /* disable EP5 NAK */
 446                 if (ret)
 447                         goto error;
 448         }
 449         /* EP4 xfer length */
 450         ret = af9015_write_reg(d, 0xdd88, frame_size & 0xff);
 451         if (ret)
 452                 goto error;
 453         ret = af9015_write_reg(d, 0xdd89, frame_size >> 8);
 454         if (ret)
 455                 goto error;
 456         /* EP5 xfer length */
 457         ret = af9015_write_reg(d, 0xdd8a, frame_size & 0xff);
 458         if (ret)
 459                 goto error;
 460         ret = af9015_write_reg(d, 0xdd8b, frame_size >> 8);
 461         if (ret)
 462                 goto error;
 463         ret = af9015_write_reg(d, 0xdd0c, packet_size); /* EP4 packet size */
 464         if (ret)
 465                 goto error;
 466         ret = af9015_write_reg(d, 0xdd0d, packet_size); /* EP5 packet size */
 467         if (ret)
 468                 goto error;
 469         ret = af9015_clear_reg_bit(d, 0xd507, 2); /* negate EP4 reset */
 470         if (ret)
 471                 goto error;
 472         if (af9015_config.dual_mode) {
 473                 ret = af9015_clear_reg_bit(d, 0xd50b, 1); /* negate EP5 reset */
 474                 if (ret)
 475                         goto error;
 476         }
 477
 478         /* enable / disable mp2if2 */
 479         if (af9015_config.dual_mode)
 480                 ret = af9015_set_reg_bit(d, 0xd50b, 0);
 481         else
 482                 ret = af9015_clear_reg_bit(d, 0xd50b, 0);
 483
 484 error:
 485         if (ret)
 486                 err("endpoint init failed:%d", ret);
 487         return ret;
 488 }
 489
 490 static int af9015_copy_firmware(struct dvb_usb_device *d)
 491 {
 492         int ret;
 493         u8 fw_params[4];
 494         u8 val, i;
 495         struct req_t req = {COPY_FIRMWARE, 0, 0x5100, 0, 0, sizeof(fw_params),
 496                 fw_params };
 497         deb_info("%s:\n", __func__);
 498
 499         fw_params[0] = af9015_config.firmware_size >> 8;
 500         fw_params[1] = af9015_config.firmware_size & 0xff;
 501         fw_params[2] = af9015_config.firmware_checksum >> 8;
 502         fw_params[3] = af9015_config.firmware_checksum & 0xff;
 503
 504         /* wait 2nd demodulator ready */
 505         msleep(100);
 506
 507         ret = af9015_read_reg_i2c(d,
 508                 af9015_af9013_config[1].i2c_addr, 0x98be, &val);
 509         if (ret)
 510                 goto error;
 511         else
 512                 deb_info("%s: firmware status:%02x\n", __func__, val);
 513
 514         if (val == 0x0c) /* fw is running, no need for download */
 515                 goto exit;
 516
 517         /* set I2C master clock to fast (to speed up firmware copy) */
 518         ret = af9015_write_reg(d, 0xd416, 0x04); /* 0x04 * 400ns */
 519         if (ret)
 520                 goto error;
 521
 522         msleep(50);
 523
 524         /* copy firmware */
 525         ret = af9015_ctrl_msg(d, &req);
 526         if (ret)
 527                 err("firmware copy cmd failed:%d", ret);
 528         deb_info("%s: firmware copy done\n", __func__);
 529
 530         /* set I2C master clock back to normal */
 531         ret = af9015_write_reg(d, 0xd416, 0x14); /* 0x14 * 400ns */
 532         if (ret)
 533                 goto error;
 534
 535         /* request boot firmware */
 536         ret = af9015_write_reg_i2c(d, af9015_af9013_config[1].i2c_addr,
 537                 0xe205, 1);
 538         deb_info("%s: firmware boot cmd status:%d\n", __func__, ret);
 539         if (ret)
 540                 goto error;
 541
 542         for (i = 0; i < 15; i++) {
 543                 msleep(100);
 544
 545                 /* check firmware status */
 546                 ret = af9015_read_reg_i2c(d,
 547                         af9015_af9013_config[1].i2c_addr, 0x98be, &val);
 548                 deb_info("%s: firmware status cmd status:%d fw status:%02x\n",
 549                         __func__, ret, val);
 550                 if (ret)
 551                         goto error;
 552
 553                 if (val == 0x0c || val == 0x04) /* success or fail */
 554                         break;
 555         }
 556
 557         if (val == 0x04) {
 558                 err("firmware did not run");
 559                 ret = -1;
 560         } else if (val != 0x0c) {
 561                 err("firmware boot timeout");
 562                 ret = -1;
 563         }
 564
 565 error:
 566 exit:
 567         return ret;
 568 }
 569
 570 /* hash (and dump) eeprom */
 571 static int af9015_eeprom_hash(struct usb_device *udev)
 572 {
 573         static const unsigned int eeprom_size = 256;
 574         unsigned int reg;
 575         int ret;
 576         u8 val, *eeprom;
 577         struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
 578
 579         eeprom = kmalloc(eeprom_size, GFP_KERNEL);
 580         if (eeprom == NULL)
 581                 return -ENOMEM;
 582
 583         for (reg = 0; reg < eeprom_size; reg++) {
 584                 req.addr = reg;
 585                 ret = af9015_rw_udev(udev, &req);
 586                 if (ret)
 587                         goto free;
 588                 eeprom[reg] = val;
 589         }
 590
 591         if (dvb_usb_af9015_debug & 0x01)
 592                 print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, eeprom,
 593                                 eeprom_size);
 594
 595         BUG_ON(eeprom_size % 4);
 596
 597         af9015_config.eeprom_sum = 0;
 598         for (reg = 0; reg < eeprom_size / sizeof(u32); reg++) {
 599                 af9015_config.eeprom_sum *= GOLDEN_RATIO_PRIME_32;
 600                 af9015_config.eeprom_sum += le32_to_cpu(((u32 *)eeprom)[reg]);
 601         }
 602
 603         deb_info("%s: eeprom sum=%.8x\n", __func__, af9015_config.eeprom_sum);
 604
 605         ret = 0;
 606 free:
 607         kfree(eeprom);
 608         return ret;
 609 }
 610
 611 static int af9015_init(struct dvb_usb_device *d)
 612 {
 613         int ret;
 614         deb_info("%s:\n", __func__);
 615
 616         /* init RC canary */
 617         ret = af9015_write_reg(d, 0x98e9, 0xff);
 618         if (ret)
 619                 goto error;
 620
 621         ret = af9015_init_endpoint(d);
 622         if (ret)
 623                 goto error;
 624
 625 error:
 626         return ret;
 627 }
 628
 629 static int af9015_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
 630 {
 631         int ret;
 632         deb_info("%s: onoff:%d\n", __func__, onoff);
 633
 634         if (onoff)
 635                 ret = af9015_set_reg_bit(adap->dev, 0xd503, 0);
 636         else
 637                 ret = af9015_clear_reg_bit(adap->dev, 0xd503, 0);
 638
 639         return ret;
 640 }
 641
 642 static int af9015_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
 643         int onoff)
 644 {
 645         int ret;
 646         u8 idx;
 647
 648         deb_info("%s: set pid filter, index %d, pid %x, onoff %d\n",
 649                 __func__, index, pid, onoff);
 650
 651         ret = af9015_write_reg(adap->dev, 0xd505, (pid & 0xff));
 652         if (ret)
 653                 goto error;
 654
 655         ret = af9015_write_reg(adap->dev, 0xd506, (pid >> 8));
 656         if (ret)
 657                 goto error;
 658
 659         idx = ((index & 0x1f) | (1 << 5));
 660         ret = af9015_write_reg(adap->dev, 0xd504, idx);
 661
 662 error:
 663         return ret;
 664 }
 665
 666 static int af9015_download_firmware(struct usb_device *udev,
 667         const struct firmware *fw)
 668 {
 669         int i, len, remaining, ret;
 670         struct req_t req = {DOWNLOAD_FIRMWARE, 0, 0, 0, 0, 0, NULL};
 671         u16 checksum = 0;
 672
 673         deb_info("%s:\n", __func__);
 674
 675         /* calc checksum */
 676         for (i = 0; i < fw->size; i++)
 677                 checksum += fw->data[i];
 678
 679         af9015_config.firmware_size = fw->size;
 680         af9015_config.firmware_checksum = checksum;
 681
 682         #define FW_ADDR 0x5100 /* firmware start address */
 683         #define LEN_MAX 55 /* max packet size */
 684         for (remaining = fw->size; remaining > 0; remaining -= LEN_MAX) {
 685                 len = remaining;
 686                 if (len > LEN_MAX)
 687                         len = LEN_MAX;
 688
 689                 req.data_len = len;
 690                 req.data = (u8 *) &fw->data[fw->size - remaining];
 691                 req.addr = FW_ADDR + fw->size - remaining;
 692
 693                 ret = af9015_rw_udev(udev, &req);
 694                 if (ret) {
 695                         err("firmware download failed:%d", ret);
 696                         goto error;
 697                 }
 698         }
 699
 700         /* firmware loaded, request boot */
 701         req.cmd = BOOT;
 702         ret = af9015_rw_udev(udev, &req);
 703         if (ret) {
 704                 err("firmware boot failed:%d", ret);
 705                 goto error;
 706         }
 707
 708 error:
 709         return ret;
 710 }
 711
 712 struct af9015_rc_setup {
 713         unsigned int id;
 714         char *rc_codes;
 715 };
 716
 717 static char *af9015_rc_setup_match(unsigned int id,
 718         const struct af9015_rc_setup *table)
 719 {
 720         for (; table->rc_codes; table++)
 721                 if (table->id == id)
 722                         return table->rc_codes;
 723         return NULL;
 724 }
 725
 726 static const struct af9015_rc_setup af9015_rc_setup_modparam[] = {
 727         { AF9015_REMOTE_A_LINK_DTU_M, RC_MAP_ALINK_DTU_M },
 728         { AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3, RC_MAP_MSI_DIGIVOX_II },
 729         { AF9015_REMOTE_MYGICTV_U718, RC_MAP_TOTAL_MEDIA_IN_HAND },
 730         { AF9015_REMOTE_DIGITTRADE_DVB_T, RC_MAP_DIGITTRADE },
 731         { AF9015_REMOTE_AVERMEDIA_KS, RC_MAP_AVERMEDIA_RM_KS },
 732         { }
 733 };
 734
 735 static const struct af9015_rc_setup af9015_rc_setup_hashes[] = {
 736         { 0xb8feb708, RC_MAP_MSI_DIGIVOX_II },
 737         { 0xa3703d00, RC_MAP_ALINK_DTU_M },
 738         { 0x9b7dc64e, RC_MAP_TOTAL_MEDIA_IN_HAND }, /* MYGICTV U718 */
 739         { 0x5d49e3db, RC_MAP_DIGITTRADE }, /* LC-Power LC-USB-DVBT */
 740         { }
 741 };
 742
 743 static const struct af9015_rc_setup af9015_rc_setup_usbids[] = {
 744         { (USB_VID_TERRATEC << 16) | USB_PID_TERRATEC_CINERGY_T_STICK_RC,
 745                 RC_MAP_TERRATEC_SLIM_2 },
 746         { (USB_VID_TERRATEC << 16) | USB_PID_TERRATEC_CINERGY_T_STICK_DUAL_RC,
 747                 RC_MAP_TERRATEC_SLIM },
 748         { (USB_VID_VISIONPLUS << 16) | USB_PID_AZUREWAVE_AD_TU700,
 749                 RC_MAP_AZUREWAVE_AD_TU700 },
 750         { (USB_VID_VISIONPLUS << 16) | USB_PID_TINYTWIN,
 751                 RC_MAP_AZUREWAVE_AD_TU700 },
 752         { (USB_VID_MSI_2 << 16) | USB_PID_MSI_DIGI_VOX_MINI_III,
 753                 RC_MAP_MSI_DIGIVOX_III },
 754         { (USB_VID_MSI_2 << 16) | USB_PID_MSI_DIGIVOX_DUO,
 755                 RC_MAP_MSI_DIGIVOX_III },
 756         { (USB_VID_LEADTEK << 16) | USB_PID_WINFAST_DTV_DONGLE_GOLD,
 757                 RC_MAP_LEADTEK_Y04G0051 },
 758         { (USB_VID_LEADTEK << 16) | USB_PID_WINFAST_DTV2000DS,
 759                 RC_MAP_LEADTEK_Y04G0051 },
 760         { (USB_VID_AVERMEDIA << 16) | USB_PID_AVERMEDIA_VOLAR_X,
 761                 RC_MAP_AVERMEDIA_M135A },
 762         { (USB_VID_AFATECH << 16) | USB_PID_TREKSTOR_DVBT,
 763                 RC_MAP_TREKSTOR },
 764         { (USB_VID_KWORLD_2 << 16) | USB_PID_TINYTWIN_2,
 765                 RC_MAP_DIGITALNOW_TINYTWIN },
 766         { (USB_VID_GTEK << 16) | USB_PID_TINYTWIN_3,
 767                 RC_MAP_DIGITALNOW_TINYTWIN },
 768         { (USB_VID_KWORLD_2 << 16) | USB_PID_SVEON_STV22,
 769                 RC_MAP_MSI_DIGIVOX_III },
 770         { }
 771 };
 772
 773 static void af9015_set_remote_config(struct usb_device *udev,
 774                 struct dvb_usb_device_properties *props)
 775 {
 776         u16 vid = le16_to_cpu(udev->descriptor.idVendor);
 777         u16 pid = le16_to_cpu(udev->descriptor.idProduct);
 778
 779         /* try to load remote based module param */
 780         props->rc.core.rc_codes = af9015_rc_setup_match(
 781                 dvb_usb_af9015_remote, af9015_rc_setup_modparam);
 782
 783         /* try to load remote based eeprom hash */
 784         if (!props->rc.core.rc_codes)
 785                 props->rc.core.rc_codes = af9015_rc_setup_match(
 786                         af9015_config.eeprom_sum, af9015_rc_setup_hashes);
 787
 788         /* try to load remote based USB ID */
 789         if (!props->rc.core.rc_codes)
 790                 props->rc.core.rc_codes = af9015_rc_setup_match(
 791                         (vid << 16) | pid, af9015_rc_setup_usbids);
 792
 793         /* try to load remote based USB iManufacturer string */
 794         if (!props->rc.core.rc_codes && vid == USB_VID_AFATECH) {
 795                 /* Check USB manufacturer and product strings and try
 796                    to determine correct remote in case of chip vendor
 797                    reference IDs are used.
 798                    DO NOT ADD ANYTHING NEW HERE. Use hashes instead. */
 799                 char manufacturer[10];
 800                 memset(manufacturer, 0, sizeof(manufacturer));
 801                 usb_string(udev, udev->descriptor.iManufacturer,
 802                         manufacturer, sizeof(manufacturer));
 803                 if (!strcmp("MSI", manufacturer)) {
 804                         /* iManufacturer 1 MSI
 805                            iProduct      2 MSI K-VOX */
 806                         props->rc.core.rc_codes = af9015_rc_setup_match(
 807                                 AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3,
 808                                 af9015_rc_setup_modparam);
 809                 }
 810         }
 811
 812         /* finally load "empty" just for leaving IR receiver enabled */
 813         if (!props->rc.core.rc_codes)
 814                 props->rc.core.rc_codes = RC_MAP_EMPTY;
 815
 816         return;
 817 }
 818
 819 static int af9015_read_config(struct usb_device *udev)
 820 {
 821         int ret;
 822         u8 val, i, offset = 0;
 823         struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
 824
 825         /* IR remote controller */
 826         req.addr = AF9015_EEPROM_IR_MODE;
 827         /* first message will timeout often due to possible hw bug */
 828         for (i = 0; i < 4; i++) {
 829                 ret = af9015_rw_udev(udev, &req);
 830                 if (!ret)
 831                         break;
 832         }
 833         if (ret)
 834                 goto error;
 835
 836         ret = af9015_eeprom_hash(udev);
 837         if (ret)
 838                 goto error;
 839
 840         deb_info("%s: IR mode=%d\n", __func__, val);
 841         for (i = 0; i < af9015_properties_count; i++) {
 842                 if (val == AF9015_IR_MODE_DISABLED)
 843                         af9015_properties[i].rc.core.rc_codes = NULL;
 844                 else
 845                         af9015_set_remote_config(udev, &af9015_properties[i]);
 846         }
 847
 848         /* TS mode - one or two receivers */
 849         req.addr = AF9015_EEPROM_TS_MODE;
 850         ret = af9015_rw_udev(udev, &req);
 851         if (ret)
 852                 goto error;
 853         af9015_config.dual_mode = val;
 854         deb_info("%s: TS mode=%d\n", __func__, af9015_config.dual_mode);
 855
 856         /* Set adapter0 buffer size according to USB port speed, adapter1 buffer
 857            size can be static because it is enabled only USB2.0 */
 858         for (i = 0; i < af9015_properties_count; i++) {
 859                 /* USB1.1 set smaller buffersize and disable 2nd adapter */
 860                 if (udev->speed == USB_SPEED_FULL) {
 861                         af9015_properties[i].adapter[0].fe[0].stream.u.bulk.buffersize
 862                                 = TS_USB11_FRAME_SIZE;
 863                         /* disable 2nd adapter because we don't have
 864                            PID-filters */
 865                         af9015_config.dual_mode = 0;
 866                 } else {
 867                         af9015_properties[i].adapter[0].fe[0].stream.u.bulk.buffersize
 868                                 = TS_USB20_FRAME_SIZE;
 869                 }
 870         }
 871
 872         if (af9015_config.dual_mode) {
 873                 /* read 2nd demodulator I2C address */
 874                 req.addr = AF9015_EEPROM_DEMOD2_I2C;
 875                 ret = af9015_rw_udev(udev, &req);
 876                 if (ret)
 877                         goto error;
 878                 af9015_af9013_config[1].i2c_addr = val;
 879
 880                 /* enable 2nd adapter */
 881                 for (i = 0; i < af9015_properties_count; i++)
 882                         af9015_properties[i].num_adapters = 2;
 883
 884         } else {
 885                  /* disable 2nd adapter */
 886                 for (i = 0; i < af9015_properties_count; i++)
 887                         af9015_properties[i].num_adapters = 1;
 888         }
 889
 890         for (i = 0; i < af9015_properties[0].num_adapters; i++) {
 891                 if (i == 1)
 892                         offset = AF9015_EEPROM_OFFSET;
 893                 /* xtal */
 894                 req.addr = AF9015_EEPROM_XTAL_TYPE1 + offset;
 895                 ret = af9015_rw_udev(udev, &req);
 896                 if (ret)
 897                         goto error;
 898                 switch (val) {
 899                 case 0:
 900                         af9015_af9013_config[i].clock = 28800000;
 901                         break;
 902                 case 1:
 903                         af9015_af9013_config[i].clock = 20480000;
 904                         break;
 905                 case 2:
 906                         af9015_af9013_config[i].clock = 28000000;
 907                         break;
 908                 case 3:
 909                         af9015_af9013_config[i].clock = 25000000;
 910                         break;
 911                 };
 912                 deb_info("%s: [%d] xtal=%d set clock=%d\n", __func__, i,
 913                         val, af9015_af9013_config[i].clock);
 914
 915                 /* IF frequency */
 916                 req.addr = AF9015_EEPROM_IF1H + offset;
 917                 ret = af9015_rw_udev(udev, &req);
 918                 if (ret)
 919                         goto error;
 920
 921                 af9015_af9013_config[i].if_frequency = val << 8;
 922
 923                 req.addr = AF9015_EEPROM_IF1L + offset;
 924                 ret = af9015_rw_udev(udev, &req);
 925                 if (ret)
 926                         goto error;
 927
 928                 af9015_af9013_config[i].if_frequency += val;
 929                 af9015_af9013_config[i].if_frequency *= 1000;
 930                 deb_info("%s: [%d] IF frequency=%d\n", __func__, i,
 931                         af9015_af9013_config[0].if_frequency);
 932
 933                 /* MT2060 IF1 */
 934                 req.addr = AF9015_EEPROM_MT2060_IF1H  + offset;
 935                 ret = af9015_rw_udev(udev, &req);
 936                 if (ret)
 937                         goto error;
 938                 af9015_config.mt2060_if1[i] = val << 8;
 939                 req.addr = AF9015_EEPROM_MT2060_IF1L + offset;
 940                 ret = af9015_rw_udev(udev, &req);
 941                 if (ret)
 942                         goto error;
 943                 af9015_config.mt2060_if1[i] += val;
 944                 deb_info("%s: [%d] MT2060 IF1=%d\n", __func__, i,
 945                         af9015_config.mt2060_if1[i]);
 946
 947                 /* tuner */
 948                 req.addr =  AF9015_EEPROM_TUNER_ID1 + offset;
 949                 ret = af9015_rw_udev(udev, &req);
 950                 if (ret)
 951                         goto error;
 952                 switch (val) {
 953                 case AF9013_TUNER_ENV77H11D5:
 954                 case AF9013_TUNER_MT2060:
 955                 case AF9013_TUNER_QT1010:
 956                 case AF9013_TUNER_UNKNOWN:
 957                 case AF9013_TUNER_MT2060_2:
 958                 case AF9013_TUNER_TDA18271:
 959                 case AF9013_TUNER_QT1010A:
 960                 case AF9013_TUNER_TDA18218:
 961                         af9015_af9013_config[i].spec_inv = 1;
 962                         break;
 963                 case AF9013_TUNER_MXL5003D:
 964                 case AF9013_TUNER_MXL5005D:
 965                 case AF9013_TUNER_MXL5005R:
 966                 case AF9013_TUNER_MXL5007T:
 967                         af9015_af9013_config[i].spec_inv = 0;
 968                         break;
 969                 case AF9013_TUNER_MC44S803:
 970                         af9015_af9013_config[i].gpio[1] = AF9013_GPIO_LO;
 971                         af9015_af9013_config[i].spec_inv = 1;
 972                         break;
 973                 default:
 974                         warn("tuner id=%d not supported, please report!", val);
 975                         return -ENODEV;
 976                 };
 977
 978                 af9015_af9013_config[i].tuner = val;
 979                 deb_info("%s: [%d] tuner id=%d\n", __func__, i, val);
 980         }
 981
 982 error:
 983         if (ret)
 984                 err("eeprom read failed=%d", ret);
 985
 986         /* AverMedia AVerTV Volar Black HD (A850) device have bad EEPROM
 987            content :-( Override some wrong values here. Ditto for the
 988            AVerTV Red HD+ (A850T) device. */
 989         if (le16_to_cpu(udev->descriptor.idVendor) == USB_VID_AVERMEDIA &&
 990                 ((le16_to_cpu(udev->descriptor.idProduct) ==
 991                         USB_PID_AVERMEDIA_A850) ||
 992                 (le16_to_cpu(udev->descriptor.idProduct) ==
 993                         USB_PID_AVERMEDIA_A850T))) {
 994                 deb_info("%s: AverMedia A850: overriding config\n", __func__);
 995                 /* disable dual mode */
 996                 af9015_config.dual_mode = 0;
 997                  /* disable 2nd adapter */
 998                 for (i = 0; i < af9015_properties_count; i++)
 999                         af9015_properties[i].num_adapters = 1;
1000
1001                 /* set correct IF */
1002                 af9015_af9013_config[0].if_frequency = 4570000;
1003         }
1004
1005         return ret;
1006 }
1007
1008 static int af9015_identify_state(struct usb_device *udev,
1009                                  struct dvb_usb_device_properties *props,
1010                                  struct dvb_usb_device_description **desc,
1011                                  int *cold)
1012 {
1013         int ret;
1014         u8 reply;
1015         struct req_t req = {GET_CONFIG, 0, 0, 0, 0, 1, &reply};
1016
1017         ret = af9015_rw_udev(udev, &req);
1018         if (ret)
1019                 return ret;
1020
1021         deb_info("%s: reply:%02x\n", __func__, reply);
1022         if (reply == 0x02)
1023                 *cold = 0;
1024         else
1025                 *cold = 1;
1026
1027         return ret;
1028 }
1029
1030 static int af9015_rc_query(struct dvb_usb_device *d)
1031 {
1032         struct af9015_state *priv = d->priv;
1033         int ret;
1034         u8 buf[17];
1035
1036         /* read registers needed to detect remote controller code */
1037         ret = af9015_read_regs(d, 0x98d9, buf, sizeof(buf));
1038         if (ret)
1039                 goto error;
1040
1041         /* If any of these are non-zero, assume invalid data */
1042         if (buf[1] || buf[2] || buf[3])
1043                 return ret;
1044
1045         /* Check for repeat of previous code */
1046         if ((priv->rc_repeat != buf[6] || buf[0]) &&
1047                                         !memcmp(&buf[12], priv->rc_last, 4)) {
1048                 deb_rc("%s: key repeated\n", __func__);
1049                 rc_keydown(d->rc_dev, priv->rc_keycode, 0);
1050                 priv->rc_repeat = buf[6];
1051                 return ret;
1052         }
1053
1054         /* Only process key if canary killed */
1055         if (buf[16] != 0xff && buf[0] != 0x01) {
1056                 deb_rc("%s: key pressed %02x %02x %02x %02x\n", __func__,
1057                         buf[12], buf[13], buf[14], buf[15]);
1058
1059                 /* Reset the canary */
1060                 ret = af9015_write_reg(d, 0x98e9, 0xff);
1061                 if (ret)
1062                         goto error;
1063
1064                 /* Remember this key */
1065                 memcpy(priv->rc_last, &buf[12], 4);
1066                 if (buf[14] == (u8) ~buf[15]) {
1067                         if (buf[12] == (u8) ~buf[13]) {
1068                                 /* NEC */
1069                                 priv->rc_keycode = buf[12] << 8 | buf[14];
1070                         } else {
1071                                 /* NEC extended*/
1072                                 priv->rc_keycode = buf[12] << 16 |
1073                                         buf[13] << 8 | buf[14];
1074                         }
1075                 } else {
1076                         /* 32 bit NEC */
1077                         priv->rc_keycode = buf[12] << 24 | buf[13] << 16 |
1078                                         buf[14] << 8 | buf[15];
1079                 }
1080                 rc_keydown(d->rc_dev, priv->rc_keycode, 0);
1081         } else {
1082                 deb_rc("%s: no key press\n", __func__);
1083                 /* Invalidate last keypress */
1084                 /* Not really needed, but helps with debug */
1085                 priv->rc_last[2] = priv->rc_last[3];
1086         }
1087
1088         priv->rc_repeat = buf[6];
1089
1090 error:
1091         if (ret)
1092                 err("%s: failed:%d", __func__, ret);
1093
1094         return ret;
1095 }
1096
1097 /* override demod callbacks for resource locking */
1098 static int af9015_af9013_set_frontend(struct dvb_frontend *fe)
1099 {
1100         int ret;
1101         struct dvb_usb_adapter *adap = fe->dvb->priv;
1102         struct af9015_state *priv = adap->dev->priv;
1103
1104         if (mutex_lock_interruptible(&adap->dev->usb_mutex))
1105                 return -EAGAIN;
1106
1107         ret = priv->set_frontend[adap->id](fe);
1108
1109         mutex_unlock(&adap->dev->usb_mutex);
1110
1111         return ret;
1112 }
1113
1114 /* override demod callbacks for resource locking */
1115 static int af9015_af9013_read_status(struct dvb_frontend *fe,
1116         fe_status_t *status)
1117 {
1118         int ret;
1119         struct dvb_usb_adapter *adap = fe->dvb->priv;
1120         struct af9015_state *priv = adap->dev->priv;
1121
1122         if (mutex_lock_interruptible(&adap->dev->usb_mutex))
1123                 return -EAGAIN;
1124
1125         ret = priv->read_status[adap->id](fe, status);
1126
1127         mutex_unlock(&adap->dev->usb_mutex);
1128
1129         return ret;
1130 }
1131
1132 /* override demod callbacks for resource locking */
1133 static int af9015_af9013_init(struct dvb_frontend *fe)
1134 {
1135         int ret;
1136         struct dvb_usb_adapter *adap = fe->dvb->priv;
1137         struct af9015_state *priv = adap->dev->priv;
1138
1139         if (mutex_lock_interruptible(&adap->dev->usb_mutex))
1140                 return -EAGAIN;
1141
1142         ret = priv->init[adap->id](fe);
1143
1144         mutex_unlock(&adap->dev->usb_mutex);
1145
1146         return ret;
1147 }
1148
1149 /* override demod callbacks for resource locking */
1150 static int af9015_af9013_sleep(struct dvb_frontend *fe)
1151 {
1152         int ret;
1153         struct dvb_usb_adapter *adap = fe->dvb->priv;
1154         struct af9015_state *priv = adap->dev->priv;
1155
1156         if (mutex_lock_interruptible(&adap->dev->usb_mutex))
1157                 return -EAGAIN;
1158
1159         ret = priv->sleep[adap->id](fe);
1160
1161         mutex_unlock(&adap->dev->usb_mutex);
1162
1163         return ret;
1164 }
1165
1166 /* override tuner callbacks for resource locking */
1167 static int af9015_tuner_init(struct dvb_frontend *fe)
1168 {
1169         int ret;
1170         struct dvb_usb_adapter *adap = fe->dvb->priv;
1171         struct af9015_state *priv = adap->dev->priv;
1172
1173         if (mutex_lock_interruptible(&adap->dev->usb_mutex))
1174                 return -EAGAIN;
1175
1176         ret = priv->tuner_init[adap->id](fe);
1177
1178         mutex_unlock(&adap->dev->usb_mutex);
1179
1180         return ret;
1181 }
1182
1183 /* override tuner callbacks for resource locking */
1184 static int af9015_tuner_sleep(struct dvb_frontend *fe)
1185 {
1186         int ret;
1187         struct dvb_usb_adapter *adap = fe->dvb->priv;
1188         struct af9015_state *priv = adap->dev->priv;
1189
1190         if (mutex_lock_interruptible(&adap->dev->usb_mutex))
1191                 return -EAGAIN;
1192
1193         ret = priv->tuner_sleep[adap->id](fe);
1194
1195         mutex_unlock(&adap->dev->usb_mutex);
1196
1197         return ret;
1198 }
1199
1200
1201 static int af9015_af9013_frontend_attach(struct dvb_usb_adapter *adap)
1202 {
1203         int ret;
1204         struct af9015_state *state = adap->dev->priv;
1205
1206         if (adap->id == 1) {
1207                 /* copy firmware to 2nd demodulator */
1208                 if (af9015_config.dual_mode) {
1209                         ret = af9015_copy_firmware(adap->dev);
1210                         if (ret) {
1211                                 err("firmware copy to 2nd frontend " \
1212                                         "failed, will disable it");
1213                                 af9015_config.dual_mode = 0;
1214                                 return -ENODEV;
1215                         }
1216                 } else {
1217                         return -ENODEV;
1218                 }
1219         }
1220
1221         /* attach demodulator */
1222         adap->fe_adap[0].fe = dvb_attach(af9013_attach,
1223                 &af9015_af9013_config[adap->id], &adap->dev->i2c_adap);
1224
1225         /*
1226          * AF9015 firmware does not like if it gets interrupted by I2C adapter
1227          * request on some critical phases. During normal operation I2C adapter
1228          * is used only 2nd demodulator and tuner on dual tuner devices.
1229          * Override demodulator callbacks and use mutex for limit access to
1230          * those "critical" paths to keep AF9015 happy.
1231          * Note: we abuse unused usb_mutex here.
1232          */
1233         if (adap->fe_adap[0].fe) {
1234                 state->set_frontend[adap->id] =
1235                         adap->fe_adap[0].fe->ops.set_frontend;
1236                 adap->fe_adap[0].fe->ops.set_frontend =
1237                         af9015_af9013_set_frontend;
1238
1239                 state->read_status[adap->id] =
1240                         adap->fe_adap[0].fe->ops.read_status;
1241                 adap->fe_adap[0].fe->ops.read_status =
1242                         af9015_af9013_read_status;
1243
1244                 state->init[adap->id] = adap->fe_adap[0].fe->ops.init;
1245                 adap->fe_adap[0].fe->ops.init = af9015_af9013_init;
1246
1247                 state->sleep[adap->id] = adap->fe_adap[0].fe->ops.sleep;
1248                 adap->fe_adap[0].fe->ops.sleep = af9015_af9013_sleep;
1249         }
1250
1251         return adap->fe_adap[0].fe == NULL ? -ENODEV : 0;
1252 }
1253
1254 static struct mt2060_config af9015_mt2060_config = {
1255         .i2c_address = 0xc0,
1256         .clock_out = 0,
1257 };
1258
1259 static struct qt1010_config af9015_qt1010_config = {
1260         .i2c_address = 0xc4,
1261 };
1262
1263 static struct tda18271_config af9015_tda18271_config = {
1264         .gate = TDA18271_GATE_DIGITAL,
1265         .small_i2c = TDA18271_16_BYTE_CHUNK_INIT,
1266 };
1267
1268 static struct mxl5005s_config af9015_mxl5003_config = {
1269         .i2c_address     = 0xc6,
1270         .if_freq         = IF_FREQ_4570000HZ,
1271         .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
1272         .agc_mode        = MXL_SINGLE_AGC,
1273         .tracking_filter = MXL_TF_DEFAULT,
1274         .rssi_enable     = MXL_RSSI_ENABLE,
1275         .cap_select      = MXL_CAP_SEL_ENABLE,
1276         .div_out         = MXL_DIV_OUT_4,
1277         .clock_out       = MXL_CLOCK_OUT_DISABLE,
1278         .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1279         .top             = MXL5005S_TOP_25P2,
1280         .mod_mode        = MXL_DIGITAL_MODE,
1281         .if_mode         = MXL_ZERO_IF,
1282         .AgcMasterByte   = 0x00,
1283 };
1284
1285 static struct mxl5005s_config af9015_mxl5005_config = {
1286         .i2c_address     = 0xc6,
1287         .if_freq         = IF_FREQ_4570000HZ,
1288         .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
1289         .agc_mode        = MXL_SINGLE_AGC,
1290         .tracking_filter = MXL_TF_OFF,
1291         .rssi_enable     = MXL_RSSI_ENABLE,
1292         .cap_select      = MXL_CAP_SEL_ENABLE,
1293         .div_out         = MXL_DIV_OUT_4,
1294         .clock_out       = MXL_CLOCK_OUT_DISABLE,
1295         .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1296         .top             = MXL5005S_TOP_25P2,
1297         .mod_mode        = MXL_DIGITAL_MODE,
1298         .if_mode         = MXL_ZERO_IF,
1299         .AgcMasterByte   = 0x00,
1300 };
1301
1302 static struct mc44s803_config af9015_mc44s803_config = {
1303         .i2c_address = 0xc0,
1304         .dig_out = 1,
1305 };
1306
1307 static struct tda18218_config af9015_tda18218_config = {
1308         .i2c_address = 0xc0,
1309         .i2c_wr_max = 21, /* max wr bytes AF9015 I2C adap can handle at once */
1310 };
1311
1312 static struct mxl5007t_config af9015_mxl5007t_config = {
1313         .xtal_freq_hz = MxL_XTAL_24_MHZ,
1314         .if_freq_hz = MxL_IF_4_57_MHZ,
1315 };
1316
1317 static int af9015_tuner_attach(struct dvb_usb_adapter *adap)
1318 {
1319         int ret;
1320         struct af9015_state *state = adap->dev->priv;
1321         deb_info("%s:\n", __func__);
1322
1323         switch (af9015_af9013_config[adap->id].tuner) {
1324         case AF9013_TUNER_MT2060:
1325         case AF9013_TUNER_MT2060_2:
1326                 ret = dvb_attach(mt2060_attach, adap->fe_adap[0].fe,
1327                         &adap->dev->i2c_adap, &af9015_mt2060_config,
1328                         af9015_config.mt2060_if1[adap->id])
1329                         == NULL ? -ENODEV : 0;
1330                 break;
1331         case AF9013_TUNER_QT1010:
1332         case AF9013_TUNER_QT1010A:
1333                 ret = dvb_attach(qt1010_attach, adap->fe_adap[0].fe,
1334                         &adap->dev->i2c_adap,
1335                         &af9015_qt1010_config) == NULL ? -ENODEV : 0;
1336                 break;
1337         case AF9013_TUNER_TDA18271:
1338                 ret = dvb_attach(tda18271_attach, adap->fe_adap[0].fe, 0xc0,
1339                         &adap->dev->i2c_adap,
1340                         &af9015_tda18271_config) == NULL ? -ENODEV : 0;
1341                 break;
1342         case AF9013_TUNER_TDA18218:
1343                 ret = dvb_attach(tda18218_attach, adap->fe_adap[0].fe,
1344                         &adap->dev->i2c_adap,
1345                         &af9015_tda18218_config) == NULL ? -ENODEV : 0;
1346                 break;
1347         case AF9013_TUNER_MXL5003D:
1348                 ret = dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe,
1349                         &adap->dev->i2c_adap,
1350                         &af9015_mxl5003_config) == NULL ? -ENODEV : 0;
1351                 break;
1352         case AF9013_TUNER_MXL5005D:
1353         case AF9013_TUNER_MXL5005R:
1354                 ret = dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe,
1355                         &adap->dev->i2c_adap,
1356                         &af9015_mxl5005_config) == NULL ? -ENODEV : 0;
1357                 break;
1358         case AF9013_TUNER_ENV77H11D5:
1359                 ret = dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0xc0,
1360                         &adap->dev->i2c_adap,
1361                         DVB_PLL_TDA665X) == NULL ? -ENODEV : 0;
1362                 break;
1363         case AF9013_TUNER_MC44S803:
1364                 ret = dvb_attach(mc44s803_attach, adap->fe_adap[0].fe,
1365                         &adap->dev->i2c_adap,
1366                         &af9015_mc44s803_config) == NULL ? -ENODEV : 0;
1367                 break;
1368         case AF9013_TUNER_MXL5007T:
1369                 ret = dvb_attach(mxl5007t_attach, adap->fe_adap[0].fe,
1370                         &adap->dev->i2c_adap,
1371                         0xc0, &af9015_mxl5007t_config) == NULL ? -ENODEV : 0;
1372                 break;
1373         case AF9013_TUNER_UNKNOWN:
1374         default:
1375                 ret = -ENODEV;
1376                 err("Unknown tuner id:%d",
1377                         af9015_af9013_config[adap->id].tuner);
1378         }
1379
1380         if (adap->fe_adap[0].fe->ops.tuner_ops.init) {
1381                 state->tuner_init[adap->id] =
1382                         adap->fe_adap[0].fe->ops.tuner_ops.init;
1383                 adap->fe_adap[0].fe->ops.tuner_ops.init = af9015_tuner_init;
1384         }
1385
1386         if (adap->fe_adap[0].fe->ops.tuner_ops.sleep) {
1387                 state->tuner_sleep[adap->id] =
1388                         adap->fe_adap[0].fe->ops.tuner_ops.sleep;
1389                 adap->fe_adap[0].fe->ops.tuner_ops.sleep = af9015_tuner_sleep;
1390         }
1391
1392         return ret;
1393 }
1394
1395 enum af9015_usb_table_entry {
1396         AFATECH_9015,
1397         AFATECH_9016,
1398         WINFAST_DTV_GOLD,
1399         PINNACLE_PCTV_71E,
1400         KWORLD_PLUSTV_399U,
1401         TINYTWIN,
1402         AZUREWAVE_TU700,
1403         TERRATEC_AF9015,
1404         KWORLD_PLUSTV_PC160,
1405         AVERTV_VOLAR_X,
1406         XTENSIONS_380U,
1407         MSI_DIGIVOX_DUO,
1408         AVERTV_VOLAR_X_REV2,
1409         TELESTAR_STARSTICK_2,
1410         AVERMEDIA_A309_USB,
1411         MSI_DIGIVOX_MINI_III,
1412         KWORLD_E396,
1413         KWORLD_E39B,
1414         KWORLD_E395,
1415         TREKSTOR_DVBT,
1416         AVERTV_A850,
1417         AVERTV_A805,
1418         CONCEPTRONIC_CTVDIGRCU,
1419         KWORLD_MC810,
1420         GENIUS_TVGO_DVB_T03,
1421         KWORLD_399U_2,
1422         KWORLD_PC160_T,
1423         SVEON_STV20,
1424         TINYTWIN_2,
1425         WINFAST_DTV2000DS,
1426         KWORLD_UB383_T,
1427         KWORLD_E39A,
1428         AVERMEDIA_A815M,
1429         CINERGY_T_STICK_RC,
1430         CINERGY_T_DUAL_RC,
1431         AVERTV_A850T,
1432         TINYTWIN_3,
1433         SVEON_STV22,
1434 };
1435
1436 static struct usb_device_id af9015_usb_table[] = {
1437         [AFATECH_9015] = {
1438                 USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9015)},
1439         [AFATECH_9016] = {
1440                 USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9016)},
1441         [WINFAST_DTV_GOLD] = {
1442                 USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_GOLD)},
1443         [PINNACLE_PCTV_71E] = {
1444                 USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV71E)},
1445         [KWORLD_PLUSTV_399U] = {
1446                 USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U)},
1447         [TINYTWIN] = {
1448                 USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TINYTWIN)},
1449         [AZUREWAVE_TU700] = {
1450                 USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_AZUREWAVE_AD_TU700)},
1451         [TERRATEC_AF9015] = {
1452                 USB_DEVICE(USB_VID_TERRATEC,
1453                                 USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2)},
1454         [KWORLD_PLUSTV_PC160] = {
1455                 USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_2T)},
1456         [AVERTV_VOLAR_X] = {
1457                 USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X)},
1458         [XTENSIONS_380U] = {
1459                 USB_DEVICE(USB_VID_XTENSIONS, USB_PID_XTENSIONS_XD_380)},
1460         [MSI_DIGIVOX_DUO] = {
1461                 USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGIVOX_DUO)},
1462         [AVERTV_VOLAR_X_REV2] = {
1463                 USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X_2)},
1464         [TELESTAR_STARSTICK_2] = {
1465                 USB_DEVICE(USB_VID_TELESTAR,  USB_PID_TELESTAR_STARSTICK_2)},
1466         [AVERMEDIA_A309_USB] = {
1467                 USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A309)},
1468         [MSI_DIGIVOX_MINI_III] = {
1469                 USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGI_VOX_MINI_III)},
1470         [KWORLD_E396] = {
1471                 USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U)},
1472         [KWORLD_E39B] = {
1473                 USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_2)},
1474         [KWORLD_E395] = {
1475                 USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_3)},
1476         [TREKSTOR_DVBT] = {
1477                 USB_DEVICE(USB_VID_AFATECH, USB_PID_TREKSTOR_DVBT)},
1478         [AVERTV_A850] = {
1479                 USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850)},
1480         [AVERTV_A805] = {
1481                 USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A805)},
1482         [CONCEPTRONIC_CTVDIGRCU] = {
1483                 USB_DEVICE(USB_VID_KWORLD_2, USB_PID_CONCEPTRONIC_CTVDIGRCU)},
1484         [KWORLD_MC810] = {
1485                 USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_MC810)},
1486         [GENIUS_TVGO_DVB_T03] = {
1487                 USB_DEVICE(USB_VID_KYE, USB_PID_GENIUS_TVGO_DVB_T03)},
1488         [KWORLD_399U_2] = {
1489                 USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U_2)},
1490         [KWORLD_PC160_T] = {
1491                 USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_T)},
1492         [SVEON_STV20] = {
1493                 USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV20)},
1494         [TINYTWIN_2] = {
1495                 USB_DEVICE(USB_VID_KWORLD_2, USB_PID_TINYTWIN_2)},
1496         [WINFAST_DTV2000DS] = {
1497                 USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV2000DS)},
1498         [KWORLD_UB383_T] = {
1499                 USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_UB383_T)},
1500         [KWORLD_E39A] = {
1501                 USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_4)},
1502         [AVERMEDIA_A815M] = {
1503                 USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A815M)},
1504         [CINERGY_T_STICK_RC] = {
1505                 USB_DEVICE(USB_VID_TERRATEC,
1506                                 USB_PID_TERRATEC_CINERGY_T_STICK_RC)},
1507         [CINERGY_T_DUAL_RC] = {
1508                 USB_DEVICE(USB_VID_TERRATEC,
1509                                 USB_PID_TERRATEC_CINERGY_T_STICK_DUAL_RC)},
1510         [AVERTV_A850T] = {
1511                 USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850T)},
1512         [TINYTWIN_3] = {
1513                 USB_DEVICE(USB_VID_GTEK, USB_PID_TINYTWIN_3)},
1514         [SVEON_STV22] = {
1515                 USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV22)},
1516         { }
1517 };
1518 MODULE_DEVICE_TABLE(usb, af9015_usb_table);
1519
1520 #define AF9015_RC_INTERVAL 500
1521 static struct dvb_usb_device_properties af9015_properties[] = {
1522         {
1523                 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1524
1525                 .usb_ctrl = DEVICE_SPECIFIC,
1526                 .download_firmware = af9015_download_firmware,
1527                 .firmware = "dvb-usb-af9015.fw",
1528                 .no_reconnect = 1,
1529
1530                 .size_of_priv = sizeof(struct af9015_state),
1531
1532                 .num_adapters = 2,
1533                 .adapter = {
1534                         {
1535                                 .num_frontends = 1,
1536                                 .fe = {
1537                                         {
1538                                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1539                                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1540
1541                                                 .pid_filter_count = 32,
1542                                                 .pid_filter       = af9015_pid_filter,
1543                                                 .pid_filter_ctrl  = af9015_pid_filter_ctrl,
1544
1545                                                 .frontend_attach = af9015_af9013_frontend_attach,
1546                                                 .tuner_attach    = af9015_tuner_attach,
1547                                                 .stream = {
1548                                                         .type = USB_BULK,
1549                                                         .count = 6,
1550                                                         .endpoint = 0x84,
1551                                                 },
1552                                         }
1553                                 },
1554                         },
1555                         {
1556                                 .num_frontends = 1,
1557                                 .fe = {
1558                                         {
1559                                                 .frontend_attach = af9015_af9013_frontend_attach,
1560                                                 .tuner_attach    = af9015_tuner_attach,
1561                                                 .stream = {
1562                                                         .type = USB_BULK,
1563                                                         .count = 6,
1564                                                         .endpoint = 0x85,
1565                                                         .u = {
1566                                                                 .bulk = {
1567                                                                         .buffersize = TS_USB20_FRAME_SIZE,
1568                                                                 }
1569                                                         }
1570                                                 },
1571                                         }
1572                                 },
1573                         }
1574                 },
1575
1576                 .identify_state = af9015_identify_state,
1577
1578                 .rc.core = {
1579                         .protocol         = RC_TYPE_NEC,
1580                         .module_name      = "af9015",
1581                         .rc_query         = af9015_rc_query,
1582                         .rc_interval      = AF9015_RC_INTERVAL,
1583                         .allowed_protos   = RC_TYPE_NEC,
1584                 },
1585
1586                 .i2c_algo = &af9015_i2c_algo,
1587
1588                 .num_device_descs = 12, /* check max from dvb-usb.h */
1589                 .devices = {
1590                         {
1591                                 .name = "Afatech AF9015 DVB-T USB2.0 stick",
1592                                 .cold_ids = {
1593                                         &af9015_usb_table[AFATECH_9015],
1594                                         &af9015_usb_table[AFATECH_9016],
1595                                 },
1596                         }, {
1597                                 .name = "Leadtek WinFast DTV Dongle Gold",
1598                                 .cold_ids = {
1599                                         &af9015_usb_table[WINFAST_DTV_GOLD],
1600                                 },
1601                         }, {
1602                                 .name = "Pinnacle PCTV 71e",
1603                                 .cold_ids = {
1604                                         &af9015_usb_table[PINNACLE_PCTV_71E],
1605                                 },
1606                         }, {
1607                                 .name = "KWorld PlusTV Dual DVB-T Stick " \
1608                                         "(DVB-T 399U)",
1609                                 .cold_ids = {
1610                                         &af9015_usb_table[KWORLD_PLUSTV_399U],
1611                                         &af9015_usb_table[KWORLD_399U_2],
1612                                 },
1613                         }, {
1614                                 .name = "DigitalNow TinyTwin DVB-T Receiver",
1615                                 .cold_ids = {
1616                                         &af9015_usb_table[TINYTWIN],
1617                                         &af9015_usb_table[TINYTWIN_2],
1618                                         &af9015_usb_table[TINYTWIN_3],
1619                                 },
1620                         }, {
1621                                 .name = "TwinHan AzureWave AD-TU700(704J)",
1622                                 .cold_ids = {
1623                                         &af9015_usb_table[AZUREWAVE_TU700],
1624                                 },
1625                         }, {
1626                                 .name = "TerraTec Cinergy T USB XE",
1627                                 .cold_ids = {
1628                                         &af9015_usb_table[TERRATEC_AF9015],
1629                                 },
1630                         }, {
1631                                 .name = "KWorld PlusTV Dual DVB-T PCI " \
1632                                         "(DVB-T PC160-2T)",
1633                                 .cold_ids = {
1634                                         &af9015_usb_table[KWORLD_PLUSTV_PC160],
1635                                 },
1636                         }, {
1637                                 .name = "AVerMedia AVerTV DVB-T Volar X",
1638                                 .cold_ids = {
1639                                         &af9015_usb_table[AVERTV_VOLAR_X],
1640                                 },
1641                         }, {
1642                                 .name = "TerraTec Cinergy T Stick RC",
1643                                 .cold_ids = {
1644                                         &af9015_usb_table[CINERGY_T_STICK_RC],
1645                                 },
1646                         }, {
1647                                 .name = "TerraTec Cinergy T Stick Dual RC",
1648                                 .cold_ids = {
1649                                         &af9015_usb_table[CINERGY_T_DUAL_RC],
1650                                 },
1651                         }, {
1652                                 .name = "AverMedia AVerTV Red HD+ (A850T)",
1653                                 .cold_ids = {
1654                                         &af9015_usb_table[AVERTV_A850T],
1655                                 },
1656                         },
1657                 }
1658         }, {
1659                 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1660
1661                 .usb_ctrl = DEVICE_SPECIFIC,
1662                 .download_firmware = af9015_download_firmware,
1663                 .firmware = "dvb-usb-af9015.fw",
1664                 .no_reconnect = 1,
1665
1666                 .size_of_priv = sizeof(struct af9015_state),
1667
1668                 .num_adapters = 2,
1669                 .adapter = {
1670                         {
1671                                 .num_frontends = 1,
1672                                 .fe = {
1673                                         {
1674                                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1675                                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1676
1677                                                 .pid_filter_count = 32,
1678                                                 .pid_filter       = af9015_pid_filter,
1679                                                 .pid_filter_ctrl  = af9015_pid_filter_ctrl,
1680
1681                                                 .frontend_attach = af9015_af9013_frontend_attach,
1682                                                 .tuner_attach    = af9015_tuner_attach,
1683                                                 .stream = {
1684                                                         .type = USB_BULK,
1685                                                         .count = 6,
1686                                                         .endpoint = 0x84,
1687                                                 },
1688                                         }
1689                                 },
1690                         },
1691                         {
1692                                 .num_frontends = 1,
1693                                 .fe = {
1694                                         {
1695                                                 .frontend_attach = af9015_af9013_frontend_attach,
1696                                                 .tuner_attach    = af9015_tuner_attach,
1697                                                 .stream = {
1698                                                         .type = USB_BULK,
1699                                                         .count = 6,
1700                                                         .endpoint = 0x85,
1701                                                         .u = {
1702                                                                 .bulk = {
1703                                                                         .buffersize = TS_USB20_FRAME_SIZE,
1704                                                                 }
1705                                                         }
1706                                                 },
1707                                         }
1708                                 },
1709                         }
1710                 },
1711
1712                 .identify_state = af9015_identify_state,
1713
1714                 .rc.core = {
1715                         .protocol         = RC_TYPE_NEC,
1716                         .module_name      = "af9015",
1717                         .rc_query         = af9015_rc_query,
1718                         .rc_interval      = AF9015_RC_INTERVAL,
1719                         .allowed_protos   = RC_TYPE_NEC,
1720                 },
1721
1722                 .i2c_algo = &af9015_i2c_algo,
1723
1724                 .num_device_descs = 10, /* check max from dvb-usb.h */
1725                 .devices = {
1726                         {
1727                                 .name = "Xtensions XD-380",
1728                                 .cold_ids = {
1729                                         &af9015_usb_table[XTENSIONS_380U],
1730                                 },
1731                         }, {
1732                                 .name = "MSI DIGIVOX Duo",
1733                                 .cold_ids = {
1734                                         &af9015_usb_table[MSI_DIGIVOX_DUO],
1735                                 },
1736                         }, {
1737                                 .name = "Fujitsu-Siemens Slim Mobile USB DVB-T",
1738                                 .cold_ids = {
1739                                         &af9015_usb_table[AVERTV_VOLAR_X_REV2],
1740                                 },
1741                         }, {
1742                                 .name = "Telestar Starstick 2",
1743                                 .cold_ids = {
1744                                         &af9015_usb_table[TELESTAR_STARSTICK_2],
1745                                 },
1746                         }, {
1747                                 .name = "AVerMedia A309",
1748                                 .cold_ids = {
1749                                         &af9015_usb_table[AVERMEDIA_A309_USB],
1750                                 },
1751                         }, {
1752                                 .name = "MSI Digi VOX mini III",
1753                                 .cold_ids = {
1754                                         &af9015_usb_table[MSI_DIGIVOX_MINI_III],
1755                                 },
1756                         }, {
1757                                 .name = "KWorld USB DVB-T TV Stick II " \
1758                                         "(VS-DVB-T 395U)",
1759                                 .cold_ids = {
1760                                         &af9015_usb_table[KWORLD_E396],
1761                                         &af9015_usb_table[KWORLD_E39B],
1762                                         &af9015_usb_table[KWORLD_E395],
1763                                         &af9015_usb_table[KWORLD_E39A],
1764                                 },
1765                         }, {
1766                                 .name = "TrekStor DVB-T USB Stick",
1767                                 .cold_ids = {
1768                                         &af9015_usb_table[TREKSTOR_DVBT],
1769                                 },
1770                         }, {
1771                                 .name = "AverMedia AVerTV Volar Black HD " \
1772                                         "(A850)",
1773                                 .cold_ids = {
1774                                         &af9015_usb_table[AVERTV_A850],
1775                                 },
1776                         }, {
1777                                 .name = "Sveon STV22 Dual USB DVB-T Tuner HDTV",
1778                                 .cold_ids = {
1779                                         &af9015_usb_table[SVEON_STV22],
1780                                 },
1781                         },
1782                 }
1783         }, {
1784                 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1785
1786                 .usb_ctrl = DEVICE_SPECIFIC,
1787                 .download_firmware = af9015_download_firmware,
1788                 .firmware = "dvb-usb-af9015.fw",
1789                 .no_reconnect = 1,
1790
1791                 .size_of_priv = sizeof(struct af9015_state),
1792
1793                 .num_adapters = 2,
1794                 .adapter = {
1795                         {
1796                                 .num_frontends = 1,
1797                                 .fe = {
1798                                         {
1799                                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1800                                                         DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1801
1802                                                 .pid_filter_count = 32,
1803                                                 .pid_filter       = af9015_pid_filter,
1804                                                 .pid_filter_ctrl  = af9015_pid_filter_ctrl,
1805
1806                                                 .frontend_attach = af9015_af9013_frontend_attach,
1807                                                 .tuner_attach    = af9015_tuner_attach,
1808                                                 .stream = {
1809                                                         .type = USB_BULK,
1810                                                         .count = 6,
1811                                                         .endpoint = 0x84,
1812                                                 },
1813                                         }
1814                                 },
1815                         },
1816                         {
1817                                 .num_frontends = 1,
1818                                 .fe = {
1819                                         {
1820                                                 .frontend_attach = af9015_af9013_frontend_attach,
1821                                                 .tuner_attach    = af9015_tuner_attach,
1822                                                 .stream = {
1823                                                         .type = USB_BULK,
1824                                                         .count = 6,
1825                                                         .endpoint = 0x85,
1826                                                         .u = {
1827                                                                 .bulk = {
1828                                                                         .buffersize = TS_USB20_FRAME_SIZE,
1829                                                                 }
1830                                                         }
1831                                                 },
1832                                         }
1833                                 },
1834                         }
1835                 },
1836
1837                 .identify_state = af9015_identify_state,
1838
1839                 .rc.core = {
1840                         .protocol         = RC_TYPE_NEC,
1841                         .module_name      = "af9015",
1842                         .rc_query         = af9015_rc_query,
1843                         .rc_interval      = AF9015_RC_INTERVAL,
1844                         .allowed_protos   = RC_TYPE_NEC,
1845                 },
1846
1847                 .i2c_algo = &af9015_i2c_algo,
1848
1849                 .num_device_descs = 9, /* check max from dvb-usb.h */
1850                 .devices = {
1851                         {
1852                                 .name = "AverMedia AVerTV Volar GPS 805 (A805)",
1853                                 .cold_ids = {
1854                                         &af9015_usb_table[AVERTV_A805],
1855                                 },
1856                         }, {
1857                                 .name = "Conceptronic USB2.0 DVB-T CTVDIGRCU " \
1858                                         "V3.0",
1859                                 .cold_ids = {
1860                                         &af9015_usb_table[CONCEPTRONIC_CTVDIGRCU],
1861                                 },
1862                         }, {
1863                                 .name = "KWorld Digial MC-810",
1864                                 .cold_ids = {
1865                                         &af9015_usb_table[KWORLD_MC810],
1866                                 },
1867                         }, {
1868                                 .name = "Genius TVGo DVB-T03",
1869                                 .cold_ids = {
1870                                         &af9015_usb_table[GENIUS_TVGO_DVB_T03],
1871                                 },
1872                         }, {
1873                                 .name = "KWorld PlusTV DVB-T PCI Pro Card " \
1874                                         "(DVB-T PC160-T)",
1875                                 .cold_ids = {
1876                                         &af9015_usb_table[KWORLD_PC160_T],
1877                                 },
1878                         }, {
1879                                 .name = "Sveon STV20 Tuner USB DVB-T HDTV",
1880                                 .cold_ids = {
1881                                         &af9015_usb_table[SVEON_STV20],
1882                                 },
1883                         }, {
1884                                 .name = "Leadtek WinFast DTV2000DS",
1885                                 .cold_ids = {
1886                                         &af9015_usb_table[WINFAST_DTV2000DS],
1887                                 },
1888                         }, {
1889                                 .name = "KWorld USB DVB-T Stick Mobile " \
1890                                         "(UB383-T)",
1891                                 .cold_ids = {
1892                                         &af9015_usb_table[KWORLD_UB383_T],
1893                                 },
1894                         }, {
1895                                 .name = "AverMedia AVerTV Volar M (A815Mac)",
1896                                 .cold_ids = {
1897                                         &af9015_usb_table[AVERMEDIA_A815M],
1898                                 },
1899                         },
1900                 }
1901         },
1902 };
1903
1904 static int af9015_usb_probe(struct usb_interface *intf,
1905                             const struct usb_device_id *id)
1906 {
1907         int ret = 0;
1908         struct dvb_usb_device *d = NULL;
1909         struct usb_device *udev = interface_to_usbdev(intf);
1910         u8 i;
1911
1912         deb_info("%s: interface:%d\n", __func__,
1913                 intf->cur_altsetting->desc.bInterfaceNumber);
1914
1915         /* interface 0 is used by DVB-T receiver and
1916            interface 1 is for remote controller (HID) */
1917         if (intf->cur_altsetting->desc.bInterfaceNumber == 0) {
1918                 ret = af9015_read_config(udev);
1919                 if (ret)
1920                         return ret;
1921
1922                 for (i = 0; i < af9015_properties_count; i++) {
1923                         ret = dvb_usb_device_init(intf, &af9015_properties[i],
1924                                 THIS_MODULE, &d, adapter_nr);
1925                         if (!ret)
1926                                 break;
1927                         if (ret != -ENODEV)
1928                                 return ret;
1929                 }
1930                 if (ret)
1931                         return ret;
1932
1933                 if (d)
1934                         ret = af9015_init(d);
1935         }
1936
1937         return ret;
1938 }
1939
1940 /* usb specific object needed to register this driver with the usb subsystem */
1941 static struct usb_driver af9015_usb_driver = {
1942         .name = "dvb_usb_af9015",
1943         .probe = af9015_usb_probe,
1944         .disconnect = dvb_usb_device_exit,
1945         .id_table = af9015_usb_table,
1946 };
1947
1948 module_usb_driver(af9015_usb_driver);
1949
1950 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1951 MODULE_DESCRIPTION("Afatech AF9015 driver");
1952 MODULE_LICENSE("GPL");