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
  26 #include "af9015.h"
  27 #include "af9013.h"
  28 #include "mt2060.h"
  29 #include "qt1010.h"
  30 #include "tda18271.h"
  31 #include "mxl5005s.h"
  32 #include "mc44s803.h"
  33
  34 static int dvb_usb_af9015_debug;
  35 module_param_named(debug, dvb_usb_af9015_debug, int, 0644);
  36 MODULE_PARM_DESC(debug, "set debugging level" DVB_USB_DEBUG_STATUS);
  37 static int dvb_usb_af9015_remote;
  38 module_param_named(remote, dvb_usb_af9015_remote, int, 0644);
  39 MODULE_PARM_DESC(remote, "select remote");
  40 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  41
  42 static DEFINE_MUTEX(af9015_usb_mutex);
  43
  44 static struct af9015_config af9015_config;
  45 static struct dvb_usb_device_properties af9015_properties[3];
  46 static int af9015_properties_count = ARRAY_SIZE(af9015_properties);
  47
  48 static struct af9013_config af9015_af9013_config[] = {
  49         {
  50                 .demod_address = AF9015_I2C_DEMOD,
  51                 .output_mode = AF9013_OUTPUT_MODE_USB,
  52                 .api_version = { 0, 1, 9, 0 },
  53                 .gpio[0] = AF9013_GPIO_HI,
  54                 .gpio[3] = AF9013_GPIO_TUNER_ON,
  55
  56         }, {
  57                 .output_mode = AF9013_OUTPUT_MODE_SERIAL,
  58                 .api_version = { 0, 1, 9, 0 },
  59                 .gpio[0] = AF9013_GPIO_TUNER_ON,
  60                 .gpio[1] = AF9013_GPIO_LO,
  61         }
  62 };
  63
  64 static int af9015_rw_udev(struct usb_device *udev, struct req_t *req)
  65 {
  66 #define BUF_LEN 63
  67 #define REQ_HDR_LEN 8 /* send header size */
  68 #define ACK_HDR_LEN 2 /* rece header size */
  69         int act_len, ret;
  70         u8 buf[BUF_LEN];
  71         u8 write = 1;
  72         u8 msg_len = REQ_HDR_LEN;
  73         static u8 seq; /* packet sequence number */
  74
  75         if (mutex_lock_interruptible(&af9015_usb_mutex) < 0)
  76                 return -EAGAIN;
  77
  78         buf[0] = req->cmd;
  79         buf[1] = seq++;
  80         buf[2] = req->i2c_addr;
  81         buf[3] = req->addr >> 8;
  82         buf[4] = req->addr & 0xff;
  83         buf[5] = req->mbox;
  84         buf[6] = req->addr_len;
  85         buf[7] = req->data_len;
  86
  87         switch (req->cmd) {
  88         case GET_CONFIG:
  89         case READ_MEMORY:
  90         case RECONNECT_USB:
  91         case GET_IR_CODE:
  92                 write = 0;
  93                 break;
  94         case READ_I2C:
  95                 write = 0;
  96                 buf[2] |= 0x01; /* set I2C direction */
  97         case WRITE_I2C:
  98                 buf[0] = READ_WRITE_I2C;
  99                 break;
 100         case WRITE_MEMORY:
 101                 if (((req->addr & 0xff00) == 0xff00) ||
 102                     ((req->addr & 0xff00) == 0xae00))
 103                         buf[0] = WRITE_VIRTUAL_MEMORY;
 104         case WRITE_VIRTUAL_MEMORY:
 105         case COPY_FIRMWARE:
 106         case DOWNLOAD_FIRMWARE:
 107         case BOOT:
 108                 break;
 109         default:
 110                 err("unknown command:%d", req->cmd);
 111                 ret = -1;
 112                 goto error_unlock;
 113         }
 114
 115         /* buffer overflow check */
 116         if ((write && (req->data_len > BUF_LEN - REQ_HDR_LEN)) ||
 117                 (!write && (req->data_len > BUF_LEN - ACK_HDR_LEN))) {
 118                 err("too much data; cmd:%d len:%d", req->cmd, req->data_len);
 119                 ret = -EINVAL;
 120                 goto error_unlock;
 121         }
 122
 123         /* write requested */
 124         if (write) {
 125                 memcpy(&buf[REQ_HDR_LEN], req->data, req->data_len);
 126                 msg_len += req->data_len;
 127         }
 128
 129         deb_xfer(">>> ");
 130         debug_dump(buf, msg_len, deb_xfer);
 131
 132         /* send req */
 133         ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 0x02), buf, msg_len,
 134                 &act_len, AF9015_USB_TIMEOUT);
 135         if (ret)
 136                 err("bulk message failed:%d (%d/%d)", ret, msg_len, act_len);
 137         else
 138                 if (act_len != msg_len)
 139                         ret = -1; /* all data is not send */
 140         if (ret)
 141                 goto error_unlock;
 142
 143         /* no ack for those packets */
 144         if (req->cmd == DOWNLOAD_FIRMWARE || req->cmd == RECONNECT_USB)
 145                 goto exit_unlock;
 146
 147         /* write receives seq + status = 2 bytes
 148            read receives seq + status + data = 2 + N bytes */
 149         msg_len = ACK_HDR_LEN;
 150         if (!write)
 151                 msg_len += req->data_len;
 152
 153         ret = usb_bulk_msg(udev, usb_rcvbulkpipe(udev, 0x81), buf, msg_len,
 154                 &act_len, AF9015_USB_TIMEOUT);
 155         if (ret) {
 156                 err("recv bulk message failed:%d", ret);
 157                 ret = -1;
 158                 goto error_unlock;
 159         }
 160
 161         deb_xfer("<<< ");
 162         debug_dump(buf, act_len, deb_xfer);
 163
 164         /* remote controller query status is 1 if remote code is not received */
 165         if (req->cmd == GET_IR_CODE && buf[1] == 1) {
 166                 buf[1] = 0; /* clear command "error" status */
 167                 memset(&buf[2], 0, req->data_len);
 168                 buf[3] = 1; /* no remote code received mark */
 169         }
 170
 171         /* check status */
 172         if (buf[1]) {
 173                 err("command failed:%d", buf[1]);
 174                 ret = -1;
 175                 goto error_unlock;
 176         }
 177
 178         /* read request, copy returned data to return buf */
 179         if (!write)
 180                 memcpy(req->data, &buf[ACK_HDR_LEN], req->data_len);
 181
 182 error_unlock:
 183 exit_unlock:
 184         mutex_unlock(&af9015_usb_mutex);
 185
 186         return ret;
 187 }
 188
 189 static int af9015_ctrl_msg(struct dvb_usb_device *d, struct req_t *req)
 190 {
 191         return af9015_rw_udev(d->udev, req);
 192 }
 193
 194 static int af9015_write_regs(struct dvb_usb_device *d, u16 addr, u8 *val,
 195         u8 len)
 196 {
 197         struct req_t req = {WRITE_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, len,
 198                 val};
 199         return af9015_ctrl_msg(d, &req);
 200 }
 201
 202 static int af9015_write_reg(struct dvb_usb_device *d, u16 addr, u8 val)
 203 {
 204         return af9015_write_regs(d, addr, &val, 1);
 205 }
 206
 207 static int af9015_read_reg(struct dvb_usb_device *d, u16 addr, u8 *val)
 208 {
 209         struct req_t req = {READ_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, 1, val};
 210         return af9015_ctrl_msg(d, &req);
 211 }
 212
 213 static int af9015_write_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
 214         u8 val)
 215 {
 216         struct req_t req = {WRITE_I2C, addr, reg, 1, 1, 1, &val};
 217
 218         if (addr == af9015_af9013_config[0].demod_address ||
 219             addr == af9015_af9013_config[1].demod_address)
 220                 req.addr_len = 3;
 221
 222         return af9015_ctrl_msg(d, &req);
 223 }
 224
 225 static int af9015_read_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
 226         u8 *val)
 227 {
 228         struct req_t req = {READ_I2C, addr, reg, 0, 1, 1, val};
 229
 230         if (addr == af9015_af9013_config[0].demod_address ||
 231             addr == af9015_af9013_config[1].demod_address)
 232                 req.addr_len = 3;
 233
 234         return af9015_ctrl_msg(d, &req);
 235 }
 236
 237 static int af9015_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
 238         int num)
 239 {
 240         struct dvb_usb_device *d = i2c_get_adapdata(adap);
 241         int ret = 0, i = 0;
 242         u16 addr;
 243         u8 mbox, addr_len;
 244         struct req_t req;
 245
 246 /* TODO: implement bus lock
 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].demod_address ||
 274                     msg[i].addr == af9015_af9013_config[1].demod_address) {
 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 = 0;
 283                 }
 284
 285                 if (num > i + 1 && (msg[i+1].flags & I2C_M_RD)) {
 286                         if (msg[i].addr ==
 287                                 af9015_af9013_config[0].demod_address)
 288                                 req.cmd = READ_MEMORY;
 289                         else
 290                                 req.cmd = READ_I2C;
 291                         req.i2c_addr = msg[i].addr;
 292                         req.addr = addr;
 293                         req.mbox = mbox;
 294                         req.addr_len = addr_len;
 295                         req.data_len = msg[i+1].len;
 296                         req.data = &msg[i+1].buf[0];
 297                         ret = af9015_ctrl_msg(d, &req);
 298                         i += 2;
 299                 } else if (msg[i].flags & I2C_M_RD) {
 300                         ret = -EINVAL;
 301                         if (msg[i].addr ==
 302                                 af9015_af9013_config[0].demod_address)
 303                                 goto error;
 304                         else
 305                                 req.cmd = READ_I2C;
 306                         req.i2c_addr = msg[i].addr;
 307                         req.addr = addr;
 308                         req.mbox = mbox;
 309                         req.addr_len = addr_len;
 310                         req.data_len = msg[i].len;
 311                         req.data = &msg[i].buf[0];
 312                         ret = af9015_ctrl_msg(d, &req);
 313                         i += 1;
 314                 } else {
 315                         if (msg[i].addr ==
 316                                 af9015_af9013_config[0].demod_address)
 317                                 req.cmd = WRITE_MEMORY;
 318                         else
 319                                 req.cmd = WRITE_I2C;
 320                         req.i2c_addr = msg[i].addr;
 321                         req.addr = addr;
 322                         req.mbox = mbox;
 323                         req.addr_len = addr_len;
 324                         req.data_len = msg[i].len-addr_len;
 325                         req.data = &msg[i].buf[addr_len];
 326                         ret = af9015_ctrl_msg(d, &req);
 327                         i += 1;
 328                 }
 329                 if (ret)
 330                         goto error;
 331
 332         }
 333         ret = i;
 334
 335 error:
 336         mutex_unlock(&d->i2c_mutex);
 337
 338         return ret;
 339 }
 340
 341 static u32 af9015_i2c_func(struct i2c_adapter *adapter)
 342 {
 343         return I2C_FUNC_I2C;
 344 }
 345
 346 static struct i2c_algorithm af9015_i2c_algo = {
 347         .master_xfer = af9015_i2c_xfer,
 348         .functionality = af9015_i2c_func,
 349 };
 350
 351 static int af9015_do_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit, u8 op)
 352 {
 353         int ret;
 354         u8 val, mask = 0x01;
 355
 356         ret = af9015_read_reg(d, addr, &val);
 357         if (ret)
 358                 return ret;
 359
 360         mask <<= bit;
 361         if (op) {
 362                 /* set bit */
 363                 val |= mask;
 364         } else {
 365                 /* clear bit */
 366                 mask ^= 0xff;
 367                 val &= mask;
 368         }
 369
 370         return af9015_write_reg(d, addr, val);
 371 }
 372
 373 static int af9015_set_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit)
 374 {
 375         return af9015_do_reg_bit(d, addr, bit, 1);
 376 }
 377
 378 static int af9015_clear_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit)
 379 {
 380         return af9015_do_reg_bit(d, addr, bit, 0);
 381 }
 382
 383 static int af9015_init_endpoint(struct dvb_usb_device *d)
 384 {
 385         int ret;
 386         u16 frame_size;
 387         u8  packet_size;
 388         deb_info("%s: USB speed:%d\n", __func__, d->udev->speed);
 389
 390         /* Windows driver uses packet count 21 for USB1.1 and 348 for USB2.0.
 391            We use smaller - about 1/4 from the original, 5 and 87. */
 392 #define TS_PACKET_SIZE            188
 393
 394 #define TS_USB20_PACKET_COUNT      87
 395 #define TS_USB20_FRAME_SIZE       (TS_PACKET_SIZE*TS_USB20_PACKET_COUNT)
 396
 397 #define TS_USB11_PACKET_COUNT       5
 398 #define TS_USB11_FRAME_SIZE       (TS_PACKET_SIZE*TS_USB11_PACKET_COUNT)
 399
 400 #define TS_USB20_MAX_PACKET_SIZE  512
 401 #define TS_USB11_MAX_PACKET_SIZE   64
 402
 403         if (d->udev->speed == USB_SPEED_FULL) {
 404                 frame_size = TS_USB11_FRAME_SIZE/4;
 405                 packet_size = TS_USB11_MAX_PACKET_SIZE/4;
 406         } else {
 407                 frame_size = TS_USB20_FRAME_SIZE/4;
 408                 packet_size = TS_USB20_MAX_PACKET_SIZE/4;
 409         }
 410
 411         ret = af9015_set_reg_bit(d, 0xd507, 2); /* assert EP4 reset */
 412         if (ret)
 413                 goto error;
 414         ret = af9015_set_reg_bit(d, 0xd50b, 1); /* assert EP5 reset */
 415         if (ret)
 416                 goto error;
 417         ret = af9015_clear_reg_bit(d, 0xdd11, 5); /* disable EP4 */
 418         if (ret)
 419                 goto error;
 420         ret = af9015_clear_reg_bit(d, 0xdd11, 6); /* disable EP5 */
 421         if (ret)
 422                 goto error;
 423         ret = af9015_set_reg_bit(d, 0xdd11, 5); /* enable EP4 */
 424         if (ret)
 425                 goto error;
 426         if (af9015_config.dual_mode) {
 427                 ret = af9015_set_reg_bit(d, 0xdd11, 6); /* enable EP5 */
 428                 if (ret)
 429                         goto error;
 430         }
 431         ret = af9015_clear_reg_bit(d, 0xdd13, 5); /* disable EP4 NAK */
 432         if (ret)
 433                 goto error;
 434         if (af9015_config.dual_mode) {
 435                 ret = af9015_clear_reg_bit(d, 0xdd13, 6); /* disable EP5 NAK */
 436                 if (ret)
 437                         goto error;
 438         }
 439         /* EP4 xfer length */
 440         ret = af9015_write_reg(d, 0xdd88, frame_size & 0xff);
 441         if (ret)
 442                 goto error;
 443         ret = af9015_write_reg(d, 0xdd89, frame_size >> 8);
 444         if (ret)
 445                 goto error;
 446         /* EP5 xfer length */
 447         ret = af9015_write_reg(d, 0xdd8a, frame_size & 0xff);
 448         if (ret)
 449                 goto error;
 450         ret = af9015_write_reg(d, 0xdd8b, frame_size >> 8);
 451         if (ret)
 452                 goto error;
 453         ret = af9015_write_reg(d, 0xdd0c, packet_size); /* EP4 packet size */
 454         if (ret)
 455                 goto error;
 456         ret = af9015_write_reg(d, 0xdd0d, packet_size); /* EP5 packet size */
 457         if (ret)
 458                 goto error;
 459         ret = af9015_clear_reg_bit(d, 0xd507, 2); /* negate EP4 reset */
 460         if (ret)
 461                 goto error;
 462         if (af9015_config.dual_mode) {
 463                 ret = af9015_clear_reg_bit(d, 0xd50b, 1); /* negate EP5 reset */
 464                 if (ret)
 465                         goto error;
 466         }
 467
 468         /* enable / disable mp2if2 */
 469         if (af9015_config.dual_mode)
 470                 ret = af9015_set_reg_bit(d, 0xd50b, 0);
 471         else
 472                 ret = af9015_clear_reg_bit(d, 0xd50b, 0);
 473 error:
 474         if (ret)
 475                 err("endpoint init failed:%d", ret);
 476         return ret;
 477 }
 478
 479 static int af9015_copy_firmware(struct dvb_usb_device *d)
 480 {
 481         int ret;
 482         u8 fw_params[4];
 483         u8 val, i;
 484         struct req_t req = {COPY_FIRMWARE, 0, 0x5100, 0, 0, sizeof(fw_params),
 485                 fw_params };
 486         deb_info("%s:\n", __func__);
 487
 488         fw_params[0] = af9015_config.firmware_size >> 8;
 489         fw_params[1] = af9015_config.firmware_size & 0xff;
 490         fw_params[2] = af9015_config.firmware_checksum >> 8;
 491         fw_params[3] = af9015_config.firmware_checksum & 0xff;
 492
 493         /* wait 2nd demodulator ready */
 494         msleep(100);
 495
 496         ret = af9015_read_reg_i2c(d, 0x3a, 0x98be, &val);
 497         if (ret)
 498                 goto error;
 499         else
 500                 deb_info("%s: firmware status:%02x\n", __func__, val);
 501
 502         if (val == 0x0c) /* fw is running, no need for download */
 503                 goto exit;
 504
 505         /* set I2C master clock to fast (to speed up firmware copy) */
 506         ret = af9015_write_reg(d, 0xd416, 0x04); /* 0x04 * 400ns */
 507         if (ret)
 508                 goto error;
 509
 510         msleep(50);
 511
 512         /* copy firmware */
 513         ret = af9015_ctrl_msg(d, &req);
 514         if (ret)
 515                 err("firmware copy cmd failed:%d", ret);
 516         deb_info("%s: firmware copy done\n", __func__);
 517
 518         /* set I2C master clock back to normal */
 519         ret = af9015_write_reg(d, 0xd416, 0x14); /* 0x14 * 400ns */
 520         if (ret)
 521                 goto error;
 522
 523         /* request boot firmware */
 524         ret = af9015_write_reg_i2c(d, af9015_af9013_config[1].demod_address,
 525                 0xe205, 1);
 526         deb_info("%s: firmware boot cmd status:%d\n", __func__, ret);
 527         if (ret)
 528                 goto error;
 529
 530         for (i = 0; i < 15; i++) {
 531                 msleep(100);
 532
 533                 /* check firmware status */
 534                 ret = af9015_read_reg_i2c(d,
 535                         af9015_af9013_config[1].demod_address, 0x98be, &val);
 536                 deb_info("%s: firmware status cmd status:%d fw status:%02x\n",
 537                         __func__, ret, val);
 538                 if (ret)
 539                         goto error;
 540
 541                 if (val == 0x0c || val == 0x04) /* success or fail */
 542                         break;
 543         }
 544
 545         if (val == 0x04) {
 546                 err("firmware did not run");
 547                 ret = -1;
 548         } else if (val != 0x0c) {
 549                 err("firmware boot timeout");
 550                 ret = -1;
 551         }
 552
 553 error:
 554 exit:
 555         return ret;
 556 }
 557
 558 /* hash (and dump) eeprom */
 559 static int af9015_eeprom_hash(struct usb_device *udev)
 560 {
 561         static const unsigned int eeprom_size = 256;
 562         unsigned int reg;
 563         int ret;
 564         u8 val, *eeprom;
 565         struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
 566
 567         eeprom = kmalloc(eeprom_size, GFP_KERNEL);
 568         if (eeprom == NULL)
 569                 return -ENOMEM;
 570
 571         for (reg = 0; reg < eeprom_size; reg++) {
 572                 req.addr = reg;
 573                 ret = af9015_rw_udev(udev, &req);
 574                 if (ret)
 575                         goto free;
 576                 eeprom[reg] = val;
 577         }
 578
 579         if (dvb_usb_af9015_debug & 0x01)
 580                 print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, eeprom,
 581                                 eeprom_size);
 582
 583         BUG_ON(eeprom_size % 4);
 584
 585         af9015_config.eeprom_sum = 0;
 586         for (reg = 0; reg < eeprom_size / sizeof(u32); reg++) {
 587                 af9015_config.eeprom_sum *= GOLDEN_RATIO_PRIME_32;
 588                 af9015_config.eeprom_sum += le32_to_cpu(((u32 *)eeprom)[reg]);
 589         }
 590
 591         deb_info("%s: eeprom sum=%.8x\n", __func__, af9015_config.eeprom_sum);
 592
 593         ret = 0;
 594 free:
 595         kfree(eeprom);
 596         return ret;
 597 }
 598
 599 static int af9015_download_ir_table(struct dvb_usb_device *d)
 600 {
 601         int i, packets = 0, ret;
 602         u16 addr = 0x9a56; /* ir-table start address */
 603         struct req_t req = {WRITE_MEMORY, 0, 0, 0, 0, 1, NULL};
 604         u8 *data = NULL;
 605         deb_info("%s:\n", __func__);
 606
 607         data = af9015_config.ir_table;
 608         packets = af9015_config.ir_table_size;
 609
 610         /* no remote */
 611         if (!packets)
 612                 goto exit;
 613
 614         /* load remote ir-table */
 615         for (i = 0; i < packets; i++) {
 616                 req.addr = addr + i;
 617                 req.data = &data[i];
 618                 ret = af9015_ctrl_msg(d, &req);
 619                 if (ret) {
 620                         err("ir-table download failed at packet %d with " \
 621                                 "code %d", i, ret);
 622                         return ret;
 623                 }
 624         }
 625
 626 exit:
 627         return 0;
 628 }
 629
 630 static int af9015_init(struct dvb_usb_device *d)
 631 {
 632         int ret;
 633         deb_info("%s:\n", __func__);
 634
 635         ret = af9015_init_endpoint(d);
 636         if (ret)
 637                 goto error;
 638
 639         ret = af9015_download_ir_table(d);
 640         if (ret)
 641                 goto error;
 642
 643 error:
 644         return ret;
 645 }
 646
 647 static int af9015_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
 648 {
 649         int ret;
 650         deb_info("%s: onoff:%d\n", __func__, onoff);
 651
 652         if (onoff)
 653                 ret = af9015_set_reg_bit(adap->dev, 0xd503, 0);
 654         else
 655                 ret = af9015_clear_reg_bit(adap->dev, 0xd503, 0);
 656
 657         return ret;
 658 }
 659
 660 static int af9015_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
 661         int onoff)
 662 {
 663         int ret;
 664         u8 idx;
 665
 666         deb_info("%s: set pid filter, index %d, pid %x, onoff %d\n",
 667                 __func__, index, pid, onoff);
 668
 669         ret = af9015_write_reg(adap->dev, 0xd505, (pid & 0xff));
 670         if (ret)
 671                 goto error;
 672
 673         ret = af9015_write_reg(adap->dev, 0xd506, (pid >> 8));
 674         if (ret)
 675                 goto error;
 676
 677         idx = ((index & 0x1f) | (1 << 5));
 678         ret = af9015_write_reg(adap->dev, 0xd504, idx);
 679
 680 error:
 681         return ret;
 682 }
 683
 684 static int af9015_download_firmware(struct usb_device *udev,
 685         const struct firmware *fw)
 686 {
 687         int i, len, packets, remainder, ret;
 688         struct req_t req = {DOWNLOAD_FIRMWARE, 0, 0, 0, 0, 0, NULL};
 689         u16 addr = 0x5100; /* firmware start address */
 690         u16 checksum = 0;
 691
 692         deb_info("%s:\n", __func__);
 693
 694         /* calc checksum */
 695         for (i = 0; i < fw->size; i++)
 696                 checksum += fw->data[i];
 697
 698         af9015_config.firmware_size = fw->size;
 699         af9015_config.firmware_checksum = checksum;
 700
 701         #define FW_PACKET_MAX_DATA  55
 702
 703         packets = fw->size / FW_PACKET_MAX_DATA;
 704         remainder = fw->size % FW_PACKET_MAX_DATA;
 705         len = FW_PACKET_MAX_DATA;
 706         for (i = 0; i <= packets; i++) {
 707                 if (i == packets)  /* set size of the last packet */
 708                         len = remainder;
 709
 710                 req.data_len = len;
 711                 req.data = (u8 *)(fw->data + i * FW_PACKET_MAX_DATA);
 712                 req.addr = addr;
 713                 addr += FW_PACKET_MAX_DATA;
 714
 715                 ret = af9015_rw_udev(udev, &req);
 716                 if (ret) {
 717                         err("firmware download failed at packet %d with " \
 718                                 "code %d", i, ret);
 719                         goto error;
 720                 }
 721         }
 722
 723         /* firmware loaded, request boot */
 724         req.cmd = BOOT;
 725         ret = af9015_rw_udev(udev, &req);
 726         if (ret) {
 727                 err("firmware boot failed:%d", ret);
 728                 goto error;
 729         }
 730
 731 error:
 732         return ret;
 733 }
 734
 735 struct af9015_setup {
 736         unsigned int id;
 737         struct dvb_usb_rc_key *rc_key_map;
 738         unsigned int rc_key_map_size;
 739         u8 *ir_table;
 740         unsigned int ir_table_size;
 741 };
 742
 743 static const struct af9015_setup *af9015_setup_match(unsigned int id,
 744                 const struct af9015_setup *table)
 745 {
 746         for (; table->rc_key_map; table++)
 747                 if (table->id == id)
 748                         return table;
 749         return NULL;
 750 }
 751
 752 static const struct af9015_setup af9015_setup_modparam[] = {
 753         { AF9015_REMOTE_A_LINK_DTU_M,
 754                 af9015_rc_keys_a_link, ARRAY_SIZE(af9015_rc_keys_a_link),
 755                 af9015_ir_table_a_link, ARRAY_SIZE(af9015_ir_table_a_link) },
 756         { AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3,
 757                 af9015_rc_keys_msi, ARRAY_SIZE(af9015_rc_keys_msi),
 758                 af9015_ir_table_msi, ARRAY_SIZE(af9015_ir_table_msi) },
 759         { AF9015_REMOTE_MYGICTV_U718,
 760                 af9015_rc_keys_mygictv, ARRAY_SIZE(af9015_rc_keys_mygictv),
 761                 af9015_ir_table_mygictv, ARRAY_SIZE(af9015_ir_table_mygictv) },
 762         { AF9015_REMOTE_DIGITTRADE_DVB_T,
 763                 af9015_rc_keys_digittrade, ARRAY_SIZE(af9015_rc_keys_digittrade),
 764                 af9015_ir_table_digittrade, ARRAY_SIZE(af9015_ir_table_digittrade) },
 765         { AF9015_REMOTE_AVERMEDIA_KS,
 766                 af9015_rc_keys_avermedia, ARRAY_SIZE(af9015_rc_keys_avermedia),
 767                 af9015_ir_table_avermedia_ks, ARRAY_SIZE(af9015_ir_table_avermedia_ks) },
 768         { }
 769 };
 770
 771 /* don't add new entries here anymore, use hashes instead */
 772 static const struct af9015_setup af9015_setup_usbids[] = {
 773         { USB_VID_LEADTEK,
 774                 af9015_rc_keys_leadtek, ARRAY_SIZE(af9015_rc_keys_leadtek),
 775                 af9015_ir_table_leadtek, ARRAY_SIZE(af9015_ir_table_leadtek) },
 776         { USB_VID_VISIONPLUS,
 777                 af9015_rc_keys_twinhan, ARRAY_SIZE(af9015_rc_keys_twinhan),
 778                 af9015_ir_table_twinhan, ARRAY_SIZE(af9015_ir_table_twinhan) },
 779         { USB_VID_KWORLD_2, /* TODO: use correct rc keys */
 780                 af9015_rc_keys_twinhan, ARRAY_SIZE(af9015_rc_keys_twinhan),
 781                 af9015_ir_table_kworld, ARRAY_SIZE(af9015_ir_table_kworld) },
 782         { USB_VID_AVERMEDIA,
 783                 af9015_rc_keys_avermedia, ARRAY_SIZE(af9015_rc_keys_avermedia),
 784                 af9015_ir_table_avermedia, ARRAY_SIZE(af9015_ir_table_avermedia) },
 785         { USB_VID_MSI_2,
 786                 af9015_rc_keys_msi_digivox_iii, ARRAY_SIZE(af9015_rc_keys_msi_digivox_iii),
 787                 af9015_ir_table_msi_digivox_iii, ARRAY_SIZE(af9015_ir_table_msi_digivox_iii) },
 788         { }
 789 };
 790
 791 static const struct af9015_setup af9015_setup_hashes[] = {
 792         { 0xb8feb708,
 793                 af9015_rc_keys_msi, ARRAY_SIZE(af9015_rc_keys_msi),
 794                 af9015_ir_table_msi, ARRAY_SIZE(af9015_ir_table_msi) },
 795         { 0xa3703d00,
 796                 af9015_rc_keys_a_link, ARRAY_SIZE(af9015_rc_keys_a_link),
 797                 af9015_ir_table_a_link, ARRAY_SIZE(af9015_ir_table_a_link) },
 798         { 0x9b7dc64e,
 799                 af9015_rc_keys_mygictv, ARRAY_SIZE(af9015_rc_keys_mygictv),
 800                 af9015_ir_table_mygictv, ARRAY_SIZE(af9015_ir_table_mygictv) },
 801         { }
 802 };
 803
 804 static void af9015_set_remote_config(struct usb_device *udev,
 805                 struct dvb_usb_device_properties *props)
 806 {
 807         const struct af9015_setup *table = NULL;
 808
 809         if (dvb_usb_af9015_remote) {
 810                 /* load remote defined as module param */
 811                 table = af9015_setup_match(dvb_usb_af9015_remote,
 812                                 af9015_setup_modparam);
 813         } else {
 814                 u16 vendor = le16_to_cpu(udev->descriptor.idVendor);
 815
 816                 table = af9015_setup_match(af9015_config.eeprom_sum,
 817                                 af9015_setup_hashes);
 818
 819                 if (!table && vendor == USB_VID_AFATECH) {
 820                         /* Check USB manufacturer and product strings and try
 821                            to determine correct remote in case of chip vendor
 822                            reference IDs are used.
 823                            DO NOT ADD ANYTHING NEW HERE. Use hashes instead.
 824                          */
 825                         char manufacturer[10];
 826                         memset(manufacturer, 0, sizeof(manufacturer));
 827                         usb_string(udev, udev->descriptor.iManufacturer,
 828                                 manufacturer, sizeof(manufacturer));
 829                         if (!strcmp("MSI", manufacturer)) {
 830                                 /* iManufacturer 1 MSI
 831                                    iProduct      2 MSI K-VOX */
 832                                 table = af9015_setup_match(
 833                                         AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3,
 834                                         af9015_setup_modparam);
 835                         } else if (udev->descriptor.idProduct ==
 836                                 cpu_to_le16(USB_PID_TREKSTOR_DVBT)) {
 837                                 table = &(const struct af9015_setup){ 0,
 838                                         af9015_rc_keys_trekstor,
 839                                         ARRAY_SIZE(af9015_rc_keys_trekstor),
 840                                         af9015_ir_table_trekstor,
 841                                         ARRAY_SIZE(af9015_ir_table_trekstor)
 842                                 };
 843                         }
 844                 } else if (!table)
 845                         table = af9015_setup_match(vendor, af9015_setup_usbids);
 846         }
 847
 848         if (table) {
 849                 props->rc_key_map = table->rc_key_map;
 850                 props->rc_key_map_size = table->rc_key_map_size;
 851                 af9015_config.ir_table = table->ir_table;
 852                 af9015_config.ir_table_size = table->ir_table_size;
 853         }
 854 }
 855
 856 static int af9015_read_config(struct usb_device *udev)
 857 {
 858         int ret;
 859         u8 val, i, offset = 0;
 860         struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
 861
 862         /* IR remote controller */
 863         req.addr = AF9015_EEPROM_IR_MODE;
 864         /* first message will timeout often due to possible hw bug */
 865         for (i = 0; i < 4; i++) {
 866                 ret = af9015_rw_udev(udev, &req);
 867                 if (!ret)
 868                         break;
 869         }
 870         if (ret)
 871                 goto error;
 872
 873         ret = af9015_eeprom_hash(udev);
 874         if (ret)
 875                 goto error;
 876
 877         deb_info("%s: IR mode:%d\n", __func__, val);
 878         for (i = 0; i < af9015_properties_count; i++) {
 879                 if (val == AF9015_IR_MODE_DISABLED) {
 880                         af9015_properties[i].rc_key_map = NULL;
 881                         af9015_properties[i].rc_key_map_size  = 0;
 882                 } else
 883                         af9015_set_remote_config(udev, &af9015_properties[i]);
 884         }
 885
 886         /* TS mode - one or two receivers */
 887         req.addr = AF9015_EEPROM_TS_MODE;
 888         ret = af9015_rw_udev(udev, &req);
 889         if (ret)
 890                 goto error;
 891         af9015_config.dual_mode = val;
 892         deb_info("%s: TS mode:%d\n", __func__, af9015_config.dual_mode);
 893
 894         /* Set adapter0 buffer size according to USB port speed, adapter1 buffer
 895            size can be static because it is enabled only USB2.0 */
 896         for (i = 0; i < af9015_properties_count; i++) {
 897                 /* USB1.1 set smaller buffersize and disable 2nd adapter */
 898                 if (udev->speed == USB_SPEED_FULL) {
 899                         af9015_properties[i].adapter[0].stream.u.bulk.buffersize
 900                                 = TS_USB11_FRAME_SIZE;
 901                         /* disable 2nd adapter because we don't have
 902                            PID-filters */
 903                         af9015_config.dual_mode = 0;
 904                 } else {
 905                         af9015_properties[i].adapter[0].stream.u.bulk.buffersize
 906                                 = TS_USB20_FRAME_SIZE;
 907                 }
 908         }
 909
 910         if (af9015_config.dual_mode) {
 911                 /* read 2nd demodulator I2C address */
 912                 req.addr = AF9015_EEPROM_DEMOD2_I2C;
 913                 ret = af9015_rw_udev(udev, &req);
 914                 if (ret)
 915                         goto error;
 916                 af9015_af9013_config[1].demod_address = val;
 917
 918                 /* enable 2nd adapter */
 919                 for (i = 0; i < af9015_properties_count; i++)
 920                         af9015_properties[i].num_adapters = 2;
 921
 922         } else {
 923                  /* disable 2nd adapter */
 924                 for (i = 0; i < af9015_properties_count; i++)
 925                         af9015_properties[i].num_adapters = 1;
 926         }
 927
 928         for (i = 0; i < af9015_properties[0].num_adapters; i++) {
 929                 if (i == 1)
 930                         offset = AF9015_EEPROM_OFFSET;
 931                 /* xtal */
 932                 req.addr = AF9015_EEPROM_XTAL_TYPE1 + offset;
 933                 ret = af9015_rw_udev(udev, &req);
 934                 if (ret)
 935                         goto error;
 936                 switch (val) {
 937                 case 0:
 938                         af9015_af9013_config[i].adc_clock = 28800;
 939                         break;
 940                 case 1:
 941                         af9015_af9013_config[i].adc_clock = 20480;
 942                         break;
 943                 case 2:
 944                         af9015_af9013_config[i].adc_clock = 28000;
 945                         break;
 946                 case 3:
 947                         af9015_af9013_config[i].adc_clock = 25000;
 948                         break;
 949                 };
 950                 deb_info("%s: [%d] xtal:%d set adc_clock:%d\n", __func__, i,
 951                         val, af9015_af9013_config[i].adc_clock);
 952
 953                 /* tuner IF */
 954                 req.addr = AF9015_EEPROM_IF1H + offset;
 955                 ret = af9015_rw_udev(udev, &req);
 956                 if (ret)
 957                         goto error;
 958                 af9015_af9013_config[i].tuner_if = val << 8;
 959                 req.addr = AF9015_EEPROM_IF1L + offset;
 960                 ret = af9015_rw_udev(udev, &req);
 961                 if (ret)
 962                         goto error;
 963                 af9015_af9013_config[i].tuner_if += val;
 964                 deb_info("%s: [%d] IF1:%d\n", __func__, i,
 965                         af9015_af9013_config[0].tuner_if);
 966
 967                 /* MT2060 IF1 */
 968                 req.addr = AF9015_EEPROM_MT2060_IF1H  + offset;
 969                 ret = af9015_rw_udev(udev, &req);
 970                 if (ret)
 971                         goto error;
 972                 af9015_config.mt2060_if1[i] = val << 8;
 973                 req.addr = AF9015_EEPROM_MT2060_IF1L + offset;
 974                 ret = af9015_rw_udev(udev, &req);
 975                 if (ret)
 976                         goto error;
 977                 af9015_config.mt2060_if1[i] += val;
 978                 deb_info("%s: [%d] MT2060 IF1:%d\n", __func__, i,
 979                         af9015_config.mt2060_if1[i]);
 980
 981                 /* tuner */
 982                 req.addr =  AF9015_EEPROM_TUNER_ID1 + offset;
 983                 ret = af9015_rw_udev(udev, &req);
 984                 if (ret)
 985                         goto error;
 986                 switch (val) {
 987                 case AF9013_TUNER_ENV77H11D5:
 988                 case AF9013_TUNER_MT2060:
 989                 case AF9013_TUNER_QT1010:
 990                 case AF9013_TUNER_UNKNOWN:
 991                 case AF9013_TUNER_MT2060_2:
 992                 case AF9013_TUNER_TDA18271:
 993                 case AF9013_TUNER_QT1010A:
 994                         af9015_af9013_config[i].rf_spec_inv = 1;
 995                         break;
 996                 case AF9013_TUNER_MXL5003D:
 997                 case AF9013_TUNER_MXL5005D:
 998                 case AF9013_TUNER_MXL5005R:
 999                         af9015_af9013_config[i].rf_spec_inv = 0;
1000                         break;
1001                 case AF9013_TUNER_MC44S803:
1002                         af9015_af9013_config[i].gpio[1] = AF9013_GPIO_LO;
1003                         af9015_af9013_config[i].rf_spec_inv = 1;
1004                         break;
1005                 case AF9013_TUNER_TDA18218:
1006                         warn("tuner NXP TDA18218 not supported yet");
1007                         return -ENODEV;
1008                 default:
1009                         warn("tuner id:%d not supported, please report!", val);
1010                         return -ENODEV;
1011                 };
1012
1013                 af9015_af9013_config[i].tuner = val;
1014                 deb_info("%s: [%d] tuner id:%d\n", __func__, i, val);
1015         }
1016
1017 error:
1018         if (ret)
1019                 err("eeprom read failed:%d", ret);
1020
1021         /* AverMedia AVerTV Volar Black HD (A850) device have bad EEPROM
1022            content :-( Override some wrong values here. */
1023         if (le16_to_cpu(udev->descriptor.idVendor) == USB_VID_AVERMEDIA &&
1024             le16_to_cpu(udev->descriptor.idProduct) == USB_PID_AVERMEDIA_A850) {
1025                 deb_info("%s: AverMedia A850: overriding config\n", __func__);
1026                 /* disable dual mode */
1027                 af9015_config.dual_mode = 0;
1028                  /* disable 2nd adapter */
1029                 for (i = 0; i < af9015_properties_count; i++)
1030                         af9015_properties[i].num_adapters = 1;
1031
1032                 /* set correct IF */
1033                 af9015_af9013_config[0].tuner_if = 4570;
1034         }
1035
1036         return ret;
1037 }
1038
1039 static int af9015_identify_state(struct usb_device *udev,
1040                                  struct dvb_usb_device_properties *props,
1041                                  struct dvb_usb_device_description **desc,
1042                                  int *cold)
1043 {
1044         int ret;
1045         u8 reply;
1046         struct req_t req = {GET_CONFIG, 0, 0, 0, 0, 1, &reply};
1047
1048         ret = af9015_rw_udev(udev, &req);
1049         if (ret)
1050                 return ret;
1051
1052         deb_info("%s: reply:%02x\n", __func__, reply);
1053         if (reply == 0x02)
1054                 *cold = 0;
1055         else
1056                 *cold = 1;
1057
1058         return ret;
1059 }
1060
1061 static int af9015_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
1062 {
1063         u8 buf[8];
1064         struct req_t req = {GET_IR_CODE, 0, 0, 0, 0, sizeof(buf), buf};
1065         struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
1066         int i, ret;
1067
1068         memset(buf, 0, sizeof(buf));
1069
1070         ret = af9015_ctrl_msg(d, &req);
1071         if (ret)
1072                 return ret;
1073
1074         *event = 0;
1075         *state = REMOTE_NO_KEY_PRESSED;
1076
1077         for (i = 0; i < d->props.rc_key_map_size; i++) {
1078                 if (!buf[1] && rc5_custom(&keymap[i]) == buf[0] &&
1079                     rc5_data(&keymap[i]) == buf[2]) {
1080                         *event = keymap[i].event;
1081                         *state = REMOTE_KEY_PRESSED;
1082                         break;
1083                 }
1084         }
1085         if (!buf[1])
1086                 deb_rc("%s: %02x %02x %02x %02x %02x %02x %02x %02x\n",
1087                         __func__, buf[0], buf[1], buf[2], buf[3], buf[4],
1088                         buf[5], buf[6], buf[7]);
1089
1090         return 0;
1091 }
1092
1093 /* init 2nd I2C adapter */
1094 static int af9015_i2c_init(struct dvb_usb_device *d)
1095 {
1096         int ret;
1097         struct af9015_state *state = d->priv;
1098         deb_info("%s:\n", __func__);
1099
1100         strncpy(state->i2c_adap.name, d->desc->name,
1101                 sizeof(state->i2c_adap.name));
1102 #ifdef I2C_ADAP_CLASS_TV_DIGITAL
1103         state->i2c_adap.class = I2C_ADAP_CLASS_TV_DIGITAL,
1104 #else
1105         state->i2c_adap.class = I2C_CLASS_TV_DIGITAL,
1106 #endif
1107         state->i2c_adap.algo      = d->props.i2c_algo;
1108         state->i2c_adap.algo_data = NULL;
1109         state->i2c_adap.dev.parent = &d->udev->dev;
1110
1111         i2c_set_adapdata(&state->i2c_adap, d);
1112
1113         ret = i2c_add_adapter(&state->i2c_adap);
1114         if (ret < 0)
1115                 err("could not add i2c adapter");
1116
1117         return ret;
1118 }
1119
1120 static int af9015_af9013_frontend_attach(struct dvb_usb_adapter *adap)
1121 {
1122         int ret;
1123         struct af9015_state *state = adap->dev->priv;
1124         struct i2c_adapter *i2c_adap;
1125
1126         if (adap->id == 0) {
1127                 /* select I2C adapter */
1128                 i2c_adap = &adap->dev->i2c_adap;
1129
1130                 deb_info("%s: init I2C\n", __func__);
1131                 ret = af9015_i2c_init(adap->dev);
1132         } else {
1133                 /* select I2C adapter */
1134                 i2c_adap = &state->i2c_adap;
1135
1136                 /* copy firmware to 2nd demodulator */
1137                 if (af9015_config.dual_mode) {
1138                         ret = af9015_copy_firmware(adap->dev);
1139                         if (ret) {
1140                                 err("firmware copy to 2nd frontend " \
1141                                         "failed, will disable it");
1142                                 af9015_config.dual_mode = 0;
1143                                 return -ENODEV;
1144                         }
1145                 } else {
1146                         return -ENODEV;
1147                 }
1148         }
1149
1150         /* attach demodulator */
1151         adap->fe = dvb_attach(af9013_attach, &af9015_af9013_config[adap->id],
1152                 i2c_adap);
1153
1154         return adap->fe == NULL ? -ENODEV : 0;
1155 }
1156
1157 static struct mt2060_config af9015_mt2060_config = {
1158         .i2c_address = 0xc0,
1159         .clock_out = 0,
1160 };
1161
1162 static struct qt1010_config af9015_qt1010_config = {
1163         .i2c_address = 0xc4,
1164 };
1165
1166 static struct tda18271_config af9015_tda18271_config = {
1167         .gate = TDA18271_GATE_DIGITAL,
1168         .small_i2c = 1,
1169 };
1170
1171 static struct mxl5005s_config af9015_mxl5003_config = {
1172         .i2c_address     = 0xc6,
1173         .if_freq         = IF_FREQ_4570000HZ,
1174         .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
1175         .agc_mode        = MXL_SINGLE_AGC,
1176         .tracking_filter = MXL_TF_DEFAULT,
1177         .rssi_enable     = MXL_RSSI_ENABLE,
1178         .cap_select      = MXL_CAP_SEL_ENABLE,
1179         .div_out         = MXL_DIV_OUT_4,
1180         .clock_out       = MXL_CLOCK_OUT_DISABLE,
1181         .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1182         .top             = MXL5005S_TOP_25P2,
1183         .mod_mode        = MXL_DIGITAL_MODE,
1184         .if_mode         = MXL_ZERO_IF,
1185         .AgcMasterByte   = 0x00,
1186 };
1187
1188 static struct mxl5005s_config af9015_mxl5005_config = {
1189         .i2c_address     = 0xc6,
1190         .if_freq         = IF_FREQ_4570000HZ,
1191         .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
1192         .agc_mode        = MXL_SINGLE_AGC,
1193         .tracking_filter = MXL_TF_OFF,
1194         .rssi_enable     = MXL_RSSI_ENABLE,
1195         .cap_select      = MXL_CAP_SEL_ENABLE,
1196         .div_out         = MXL_DIV_OUT_4,
1197         .clock_out       = MXL_CLOCK_OUT_DISABLE,
1198         .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1199         .top             = MXL5005S_TOP_25P2,
1200         .mod_mode        = MXL_DIGITAL_MODE,
1201         .if_mode         = MXL_ZERO_IF,
1202         .AgcMasterByte   = 0x00,
1203 };
1204
1205 static struct mc44s803_config af9015_mc44s803_config = {
1206         .i2c_address = 0xc0,
1207         .dig_out = 1,
1208 };
1209
1210 static int af9015_tuner_attach(struct dvb_usb_adapter *adap)
1211 {
1212         struct af9015_state *state = adap->dev->priv;
1213         struct i2c_adapter *i2c_adap;
1214         int ret;
1215         deb_info("%s: \n", __func__);
1216
1217         /* select I2C adapter */
1218         if (adap->id == 0)
1219                 i2c_adap = &adap->dev->i2c_adap;
1220         else
1221                 i2c_adap = &state->i2c_adap;
1222
1223         switch (af9015_af9013_config[adap->id].tuner) {
1224         case AF9013_TUNER_MT2060:
1225         case AF9013_TUNER_MT2060_2:
1226                 ret = dvb_attach(mt2060_attach, adap->fe, i2c_adap,
1227                         &af9015_mt2060_config,
1228                         af9015_config.mt2060_if1[adap->id])
1229                         == NULL ? -ENODEV : 0;
1230                 break;
1231         case AF9013_TUNER_QT1010:
1232         case AF9013_TUNER_QT1010A:
1233                 ret = dvb_attach(qt1010_attach, adap->fe, i2c_adap,
1234                         &af9015_qt1010_config) == NULL ? -ENODEV : 0;
1235                 break;
1236         case AF9013_TUNER_TDA18271:
1237                 ret = dvb_attach(tda18271_attach, adap->fe, 0xc0, i2c_adap,
1238                         &af9015_tda18271_config) == NULL ? -ENODEV : 0;
1239                 break;
1240         case AF9013_TUNER_MXL5003D:
1241                 ret = dvb_attach(mxl5005s_attach, adap->fe, i2c_adap,
1242                         &af9015_mxl5003_config) == NULL ? -ENODEV : 0;
1243                 break;
1244         case AF9013_TUNER_MXL5005D:
1245         case AF9013_TUNER_MXL5005R:
1246                 ret = dvb_attach(mxl5005s_attach, adap->fe, i2c_adap,
1247                         &af9015_mxl5005_config) == NULL ? -ENODEV : 0;
1248                 break;
1249         case AF9013_TUNER_ENV77H11D5:
1250                 ret = dvb_attach(dvb_pll_attach, adap->fe, 0xc0, i2c_adap,
1251                         DVB_PLL_TDA665X) == NULL ? -ENODEV : 0;
1252                 break;
1253         case AF9013_TUNER_MC44S803:
1254                 ret = dvb_attach(mc44s803_attach, adap->fe, i2c_adap,
1255                         &af9015_mc44s803_config) == NULL ? -ENODEV : 0;
1256                 break;
1257         case AF9013_TUNER_UNKNOWN:
1258         default:
1259                 ret = -ENODEV;
1260                 err("Unknown tuner id:%d",
1261                         af9015_af9013_config[adap->id].tuner);
1262         }
1263         return ret;
1264 }
1265
1266 static struct usb_device_id af9015_usb_table[] = {
1267 /*  0 */{USB_DEVICE(USB_VID_AFATECH,   USB_PID_AFATECH_AF9015_9015)},
1268         {USB_DEVICE(USB_VID_AFATECH,   USB_PID_AFATECH_AF9015_9016)},
1269         {USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_GOLD)},
1270         {USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV71E)},
1271         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_399U)},
1272 /*  5 */{USB_DEVICE(USB_VID_VISIONPLUS,
1273                 USB_PID_TINYTWIN)},
1274         {USB_DEVICE(USB_VID_VISIONPLUS,
1275                 USB_PID_AZUREWAVE_AD_TU700)},
1276         {USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2)},
1277         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_PC160_2T)},
1278         {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X)},
1279 /* 10 */{USB_DEVICE(USB_VID_XTENSIONS, USB_PID_XTENSIONS_XD_380)},
1280         {USB_DEVICE(USB_VID_MSI_2,     USB_PID_MSI_DIGIVOX_DUO)},
1281         {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X_2)},
1282         {USB_DEVICE(USB_VID_TELESTAR,  USB_PID_TELESTAR_STARSTICK_2)},
1283         {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A309)},
1284 /* 15 */{USB_DEVICE(USB_VID_MSI_2,     USB_PID_MSI_DIGI_VOX_MINI_III)},
1285         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_395U)},
1286         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_395U_2)},
1287         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_395U_3)},
1288         {USB_DEVICE(USB_VID_AFATECH,   USB_PID_TREKSTOR_DVBT)},
1289 /* 20 */{USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850)},
1290         {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A805)},
1291         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_CONCEPTRONIC_CTVDIGRCU)},
1292         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_MC810)},
1293         {USB_DEVICE(USB_VID_KYE,       USB_PID_GENIUS_TVGO_DVB_T03)},
1294 /* 25 */{USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_399U_2)},
1295         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_PC160_T)},
1296         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_SVEON_STV20)},
1297         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_TINYTWIN_2)},
1298         {USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV2000DS)},
1299         {0},
1300 };
1301 MODULE_DEVICE_TABLE(usb, af9015_usb_table);
1302
1303 static struct dvb_usb_device_properties af9015_properties[] = {
1304         {
1305                 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1306
1307                 .usb_ctrl = DEVICE_SPECIFIC,
1308                 .download_firmware = af9015_download_firmware,
1309                 .firmware = "dvb-usb-af9015.fw",
1310                 .no_reconnect = 1,
1311
1312                 .size_of_priv = sizeof(struct af9015_state),
1313
1314                 .num_adapters = 2,
1315                 .adapter = {
1316                         {
1317                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1318                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1319
1320                                 .pid_filter_count = 32,
1321                                 .pid_filter       = af9015_pid_filter,
1322                                 .pid_filter_ctrl  = af9015_pid_filter_ctrl,
1323
1324                                 .frontend_attach =
1325                                         af9015_af9013_frontend_attach,
1326                                 .tuner_attach    = af9015_tuner_attach,
1327                                 .stream = {
1328                                         .type = USB_BULK,
1329                                         .count = 6,
1330                                         .endpoint = 0x84,
1331                                 },
1332                         },
1333                         {
1334                                 .frontend_attach =
1335                                         af9015_af9013_frontend_attach,
1336                                 .tuner_attach    = af9015_tuner_attach,
1337                                 .stream = {
1338                                         .type = USB_BULK,
1339                                         .count = 6,
1340                                         .endpoint = 0x85,
1341                                         .u = {
1342                                                 .bulk = {
1343                                                         .buffersize =
1344                                                 TS_USB20_FRAME_SIZE,
1345                                                 }
1346                                         }
1347                                 },
1348                         }
1349                 },
1350
1351                 .identify_state = af9015_identify_state,
1352
1353                 .rc_query         = af9015_rc_query,
1354                 .rc_interval      = 150,
1355
1356                 .i2c_algo = &af9015_i2c_algo,
1357
1358                 .num_device_descs = 9, /* max 9 */
1359                 .devices = {
1360                         {
1361                                 .name = "Afatech AF9015 DVB-T USB2.0 stick",
1362                                 .cold_ids = {&af9015_usb_table[0],
1363                                              &af9015_usb_table[1], NULL},
1364                                 .warm_ids = {NULL},
1365                         },
1366                         {
1367                                 .name = "Leadtek WinFast DTV Dongle Gold",
1368                                 .cold_ids = {&af9015_usb_table[2], NULL},
1369                                 .warm_ids = {NULL},
1370                         },
1371                         {
1372                                 .name = "Pinnacle PCTV 71e",
1373                                 .cold_ids = {&af9015_usb_table[3], NULL},
1374                                 .warm_ids = {NULL},
1375                         },
1376                         {
1377                                 .name = "KWorld PlusTV Dual DVB-T Stick " \
1378                                         "(DVB-T 399U)",
1379                                 .cold_ids = {&af9015_usb_table[4],
1380                                              &af9015_usb_table[25], NULL},
1381                                 .warm_ids = {NULL},
1382                         },
1383                         {
1384                                 .name = "DigitalNow TinyTwin DVB-T Receiver",
1385                                 .cold_ids = {&af9015_usb_table[5],
1386                                              &af9015_usb_table[28], NULL},
1387                                 .warm_ids = {NULL},
1388                         },
1389                         {
1390                                 .name = "TwinHan AzureWave AD-TU700(704J)",
1391                                 .cold_ids = {&af9015_usb_table[6], NULL},
1392                                 .warm_ids = {NULL},
1393                         },
1394                         {
1395                                 .name = "TerraTec Cinergy T USB XE",
1396                                 .cold_ids = {&af9015_usb_table[7], NULL},
1397                                 .warm_ids = {NULL},
1398                         },
1399                         {
1400                                 .name = "KWorld PlusTV Dual DVB-T PCI " \
1401                                         "(DVB-T PC160-2T)",
1402                                 .cold_ids = {&af9015_usb_table[8], NULL},
1403                                 .warm_ids = {NULL},
1404                         },
1405                         {
1406                                 .name = "AVerMedia AVerTV DVB-T Volar X",
1407                                 .cold_ids = {&af9015_usb_table[9], NULL},
1408                                 .warm_ids = {NULL},
1409                         },
1410                 }
1411         }, {
1412                 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1413
1414                 .usb_ctrl = DEVICE_SPECIFIC,
1415                 .download_firmware = af9015_download_firmware,
1416                 .firmware = "dvb-usb-af9015.fw",
1417                 .no_reconnect = 1,
1418
1419                 .size_of_priv = sizeof(struct af9015_state),
1420
1421                 .num_adapters = 2,
1422                 .adapter = {
1423                         {
1424                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1425                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1426
1427                                 .pid_filter_count = 32,
1428                                 .pid_filter       = af9015_pid_filter,
1429                                 .pid_filter_ctrl  = af9015_pid_filter_ctrl,
1430
1431                                 .frontend_attach =
1432                                         af9015_af9013_frontend_attach,
1433                                 .tuner_attach    = af9015_tuner_attach,
1434                                 .stream = {
1435                                         .type = USB_BULK,
1436                                         .count = 6,
1437                                         .endpoint = 0x84,
1438                                 },
1439                         },
1440                         {
1441                                 .frontend_attach =
1442                                         af9015_af9013_frontend_attach,
1443                                 .tuner_attach    = af9015_tuner_attach,
1444                                 .stream = {
1445                                         .type = USB_BULK,
1446                                         .count = 6,
1447                                         .endpoint = 0x85,
1448                                         .u = {
1449                                                 .bulk = {
1450                                                         .buffersize =
1451                                                 TS_USB20_FRAME_SIZE,
1452                                                 }
1453                                         }
1454                                 },
1455                         }
1456                 },
1457
1458                 .identify_state = af9015_identify_state,
1459
1460                 .rc_query         = af9015_rc_query,
1461                 .rc_interval      = 150,
1462
1463                 .i2c_algo = &af9015_i2c_algo,
1464
1465                 .num_device_descs = 9, /* max 9 */
1466                 .devices = {
1467                         {
1468                                 .name = "Xtensions XD-380",
1469                                 .cold_ids = {&af9015_usb_table[10], NULL},
1470                                 .warm_ids = {NULL},
1471                         },
1472                         {
1473                                 .name = "MSI DIGIVOX Duo",
1474                                 .cold_ids = {&af9015_usb_table[11], NULL},
1475                                 .warm_ids = {NULL},
1476                         },
1477                         {
1478                                 .name = "Fujitsu-Siemens Slim Mobile USB DVB-T",
1479                                 .cold_ids = {&af9015_usb_table[12], NULL},
1480                                 .warm_ids = {NULL},
1481                         },
1482                         {
1483                                 .name = "Telestar Starstick 2",
1484                                 .cold_ids = {&af9015_usb_table[13], NULL},
1485                                 .warm_ids = {NULL},
1486                         },
1487                         {
1488                                 .name = "AVerMedia A309",
1489                                 .cold_ids = {&af9015_usb_table[14], NULL},
1490                                 .warm_ids = {NULL},
1491                         },
1492                         {
1493                                 .name = "MSI Digi VOX mini III",
1494                                 .cold_ids = {&af9015_usb_table[15], NULL},
1495                                 .warm_ids = {NULL},
1496                         },
1497                         {
1498                                 .name = "KWorld USB DVB-T TV Stick II " \
1499                                         "(VS-DVB-T 395U)",
1500                                 .cold_ids = {&af9015_usb_table[16],
1501                                              &af9015_usb_table[17],
1502                                              &af9015_usb_table[18], NULL},
1503                                 .warm_ids = {NULL},
1504                         },
1505                         {
1506                                 .name = "TrekStor DVB-T USB Stick",
1507                                 .cold_ids = {&af9015_usb_table[19], NULL},
1508                                 .warm_ids = {NULL},
1509                         },
1510                         {
1511                                 .name = "AverMedia AVerTV Volar Black HD " \
1512                                         "(A850)",
1513                                 .cold_ids = {&af9015_usb_table[20], NULL},
1514                                 .warm_ids = {NULL},
1515                         },
1516                 }
1517         }, {
1518                 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1519
1520                 .usb_ctrl = DEVICE_SPECIFIC,
1521                 .download_firmware = af9015_download_firmware,
1522                 .firmware = "dvb-usb-af9015.fw",
1523                 .no_reconnect = 1,
1524
1525                 .size_of_priv = sizeof(struct af9015_state),
1526
1527                 .num_adapters = 2,
1528                 .adapter = {
1529                         {
1530                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1531                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1532
1533                                 .pid_filter_count = 32,
1534                                 .pid_filter       = af9015_pid_filter,
1535                                 .pid_filter_ctrl  = af9015_pid_filter_ctrl,
1536
1537                                 .frontend_attach =
1538                                         af9015_af9013_frontend_attach,
1539                                 .tuner_attach    = af9015_tuner_attach,
1540                                 .stream = {
1541                                         .type = USB_BULK,
1542                                         .count = 6,
1543                                         .endpoint = 0x84,
1544                                 },
1545                         },
1546                         {
1547                                 .frontend_attach =
1548                                         af9015_af9013_frontend_attach,
1549                                 .tuner_attach    = af9015_tuner_attach,
1550                                 .stream = {
1551                                         .type = USB_BULK,
1552                                         .count = 6,
1553                                         .endpoint = 0x85,
1554                                         .u = {
1555                                                 .bulk = {
1556                                                         .buffersize =
1557                                                 TS_USB20_FRAME_SIZE,
1558                                                 }
1559                                         }
1560                                 },
1561                         }
1562                 },
1563
1564                 .identify_state = af9015_identify_state,
1565
1566                 .rc_query         = af9015_rc_query,
1567                 .rc_interval      = 150,
1568
1569                 .i2c_algo = &af9015_i2c_algo,
1570
1571                 .num_device_descs = 7, /* max 9 */
1572                 .devices = {
1573                         {
1574                                 .name = "AverMedia AVerTV Volar GPS 805 (A805)",
1575                                 .cold_ids = {&af9015_usb_table[21], NULL},
1576                                 .warm_ids = {NULL},
1577                         },
1578                         {
1579                                 .name = "Conceptronic USB2.0 DVB-T CTVDIGRCU " \
1580                                         "V3.0",
1581                                 .cold_ids = {&af9015_usb_table[22], NULL},
1582                                 .warm_ids = {NULL},
1583                         },
1584                         {
1585                                 .name = "KWorld Digial MC-810",
1586                                 .cold_ids = {&af9015_usb_table[23], NULL},
1587                                 .warm_ids = {NULL},
1588                         },
1589                         {
1590                                 .name = "Genius TVGo DVB-T03",
1591                                 .cold_ids = {&af9015_usb_table[24], NULL},
1592                                 .warm_ids = {NULL},
1593                         },
1594                         {
1595                                 .name = "KWorld PlusTV DVB-T PCI Pro Card " \
1596                                         "(DVB-T PC160-T)",
1597                                 .cold_ids = {&af9015_usb_table[26], NULL},
1598                                 .warm_ids = {NULL},
1599                         },
1600                         {
1601                                 .name = "Sveon STV20 Tuner USB DVB-T HDTV",
1602                                 .cold_ids = {&af9015_usb_table[27], NULL},
1603                                 .warm_ids = {NULL},
1604                         },
1605                         {
1606                                 .name = "Leadtek WinFast DTV2000DS",
1607                                 .cold_ids = {&af9015_usb_table[29], NULL},
1608                                 .warm_ids = {NULL},
1609                         },
1610                 }
1611         },
1612 };
1613
1614 static int af9015_usb_probe(struct usb_interface *intf,
1615                             const struct usb_device_id *id)
1616 {
1617         int ret = 0;
1618         struct dvb_usb_device *d = NULL;
1619         struct usb_device *udev = interface_to_usbdev(intf);
1620         u8 i;
1621
1622         deb_info("%s: interface:%d\n", __func__,
1623                 intf->cur_altsetting->desc.bInterfaceNumber);
1624
1625         /* interface 0 is used by DVB-T receiver and
1626            interface 1 is for remote controller (HID) */
1627         if (intf->cur_altsetting->desc.bInterfaceNumber == 0) {
1628                 ret = af9015_read_config(udev);
1629                 if (ret)
1630                         return ret;
1631
1632                 for (i = 0; i < af9015_properties_count; i++) {
1633                         ret = dvb_usb_device_init(intf, &af9015_properties[i],
1634                                 THIS_MODULE, &d, adapter_nr);
1635                         if (!ret)
1636                                 break;
1637                         if (ret != -ENODEV)
1638                                 return ret;
1639                 }
1640                 if (ret)
1641                         return ret;
1642
1643                 if (d)
1644                         ret = af9015_init(d);
1645         }
1646
1647         return ret;
1648 }
1649
1650 static void af9015_i2c_exit(struct dvb_usb_device *d)
1651 {
1652         struct af9015_state *state = d->priv;
1653         deb_info("%s: \n", __func__);
1654
1655         /* remove 2nd I2C adapter */
1656         if (d->state & DVB_USB_STATE_I2C)
1657                 i2c_del_adapter(&state->i2c_adap);
1658 }
1659
1660 static void af9015_usb_device_exit(struct usb_interface *intf)
1661 {
1662         struct dvb_usb_device *d = usb_get_intfdata(intf);
1663         deb_info("%s: \n", __func__);
1664
1665         /* remove 2nd I2C adapter */
1666         if (d != NULL && d->desc != NULL)
1667                 af9015_i2c_exit(d);
1668
1669         dvb_usb_device_exit(intf);
1670 }
1671
1672 /* usb specific object needed to register this driver with the usb subsystem */
1673 static struct usb_driver af9015_usb_driver = {
1674         .name = "dvb_usb_af9015",
1675         .probe = af9015_usb_probe,
1676         .disconnect = af9015_usb_device_exit,
1677         .id_table = af9015_usb_table,
1678 };
1679
1680 /* module stuff */
1681 static int __init af9015_usb_module_init(void)
1682 {
1683         int ret;
1684         ret = usb_register(&af9015_usb_driver);
1685         if (ret)
1686                 err("module init failed:%d", ret);
1687
1688         return ret;
1689 }
1690
1691 static void __exit af9015_usb_module_exit(void)
1692 {
1693         /* deregister this driver from the USB subsystem */
1694         usb_deregister(&af9015_usb_driver);
1695 }
1696
1697 module_init(af9015_usb_module_init);
1698 module_exit(af9015_usb_module_exit);
1699
1700 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1701 MODULE_DESCRIPTION("Driver for Afatech AF9015 DVB-T");
1702 MODULE_LICENSE("GPL");