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