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 void af9015_set_remote_config(struct usb_device *udev,
 792                 struct dvb_usb_device_properties *props)
 793 {
 794         const struct af9015_setup *table = NULL;
 795
 796         if (dvb_usb_af9015_remote) {
 797                 /* load remote defined as module param */
 798                 table = af9015_setup_match(dvb_usb_af9015_remote,
 799                                 af9015_setup_modparam);
 800         } else {
 801                 u16 vendor = le16_to_cpu(udev->descriptor.idVendor);
 802
 803                 if (vendor == USB_VID_AFATECH) {
 804                         /* Check USB manufacturer and product strings and try
 805                            to determine correct remote in case of chip vendor
 806                            reference IDs are used.
 807                            DO NOT ADD ANYTHING NEW HERE. Use hashes instead.
 808                          */
 809                         char manufacturer[10];
 810                         memset(manufacturer, 0, sizeof(manufacturer));
 811                         usb_string(udev, udev->descriptor.iManufacturer,
 812                                 manufacturer, sizeof(manufacturer));
 813                         if (!strcmp("Geniatech", manufacturer)) {
 814                                 /* iManufacturer 1 Geniatech
 815                                    iProduct      2 AF9015 */
 816                                 table = af9015_setup_match(
 817                                         AF9015_REMOTE_MYGICTV_U718,
 818                                         af9015_setup_modparam);
 819                         } else if (!strcmp("MSI", manufacturer)) {
 820                                 /* iManufacturer 1 MSI
 821                                    iProduct      2 MSI K-VOX */
 822                                 table = af9015_setup_match(
 823                                         AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3,
 824                                         af9015_setup_modparam);
 825                         } else if (udev->descriptor.idProduct ==
 826                                 cpu_to_le16(USB_PID_TREKSTOR_DVBT)) {
 827                                 table = &(const struct af9015_setup){ 0,
 828                                         af9015_rc_keys_trekstor,
 829                                         ARRAY_SIZE(af9015_rc_keys_trekstor),
 830                                         af9015_ir_table_trekstor,
 831                                         ARRAY_SIZE(af9015_ir_table_trekstor)
 832                                 };
 833                         }
 834                 } else
 835                         table = af9015_setup_match(vendor, af9015_setup_usbids);
 836         }
 837
 838         if (table) {
 839                 props->rc_key_map = table->rc_key_map;
 840                 props->rc_key_map_size = table->rc_key_map_size;
 841                 af9015_config.ir_table = table->ir_table;
 842                 af9015_config.ir_table_size = table->ir_table_size;
 843         }
 844 }
 845
 846 static int af9015_read_config(struct usb_device *udev)
 847 {
 848         int ret;
 849         u8 val, i, offset = 0;
 850         struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
 851
 852         /* IR remote controller */
 853         req.addr = AF9015_EEPROM_IR_MODE;
 854         /* first message will timeout often due to possible hw bug */
 855         for (i = 0; i < 4; i++) {
 856                 ret = af9015_rw_udev(udev, &req);
 857                 if (!ret)
 858                         break;
 859         }
 860         if (ret)
 861                 goto error;
 862
 863         ret = af9015_eeprom_hash(udev);
 864         if (ret)
 865                 goto error;
 866
 867         deb_info("%s: IR mode:%d\n", __func__, val);
 868         for (i = 0; i < af9015_properties_count; i++) {
 869                 if (val == AF9015_IR_MODE_DISABLED) {
 870                         af9015_properties[i].rc_key_map = NULL;
 871                         af9015_properties[i].rc_key_map_size  = 0;
 872                 } else
 873                         af9015_set_remote_config(udev, &af9015_properties[i]);
 874         }
 875
 876         /* TS mode - one or two receivers */
 877         req.addr = AF9015_EEPROM_TS_MODE;
 878         ret = af9015_rw_udev(udev, &req);
 879         if (ret)
 880                 goto error;
 881         af9015_config.dual_mode = val;
 882         deb_info("%s: TS mode:%d\n", __func__, af9015_config.dual_mode);
 883
 884         /* Set adapter0 buffer size according to USB port speed, adapter1 buffer
 885            size can be static because it is enabled only USB2.0 */
 886         for (i = 0; i < af9015_properties_count; i++) {
 887                 /* USB1.1 set smaller buffersize and disable 2nd adapter */
 888                 if (udev->speed == USB_SPEED_FULL) {
 889                         af9015_properties[i].adapter[0].stream.u.bulk.buffersize
 890                                 = TS_USB11_FRAME_SIZE;
 891                         /* disable 2nd adapter because we don't have
 892                            PID-filters */
 893                         af9015_config.dual_mode = 0;
 894                 } else {
 895                         af9015_properties[i].adapter[0].stream.u.bulk.buffersize
 896                                 = TS_USB20_FRAME_SIZE;
 897                 }
 898         }
 899
 900         if (af9015_config.dual_mode) {
 901                 /* read 2nd demodulator I2C address */
 902                 req.addr = AF9015_EEPROM_DEMOD2_I2C;
 903                 ret = af9015_rw_udev(udev, &req);
 904                 if (ret)
 905                         goto error;
 906                 af9015_af9013_config[1].demod_address = val;
 907
 908                 /* enable 2nd adapter */
 909                 for (i = 0; i < af9015_properties_count; i++)
 910                         af9015_properties[i].num_adapters = 2;
 911
 912         } else {
 913                  /* disable 2nd adapter */
 914                 for (i = 0; i < af9015_properties_count; i++)
 915                         af9015_properties[i].num_adapters = 1;
 916         }
 917
 918         for (i = 0; i < af9015_properties[0].num_adapters; i++) {
 919                 if (i == 1)
 920                         offset = AF9015_EEPROM_OFFSET;
 921                 /* xtal */
 922                 req.addr = AF9015_EEPROM_XTAL_TYPE1 + offset;
 923                 ret = af9015_rw_udev(udev, &req);
 924                 if (ret)
 925                         goto error;
 926                 switch (val) {
 927                 case 0:
 928                         af9015_af9013_config[i].adc_clock = 28800;
 929                         break;
 930                 case 1:
 931                         af9015_af9013_config[i].adc_clock = 20480;
 932                         break;
 933                 case 2:
 934                         af9015_af9013_config[i].adc_clock = 28000;
 935                         break;
 936                 case 3:
 937                         af9015_af9013_config[i].adc_clock = 25000;
 938                         break;
 939                 };
 940                 deb_info("%s: [%d] xtal:%d set adc_clock:%d\n", __func__, i,
 941                         val, af9015_af9013_config[i].adc_clock);
 942
 943                 /* tuner IF */
 944                 req.addr = AF9015_EEPROM_IF1H + offset;
 945                 ret = af9015_rw_udev(udev, &req);
 946                 if (ret)
 947                         goto error;
 948                 af9015_af9013_config[i].tuner_if = val << 8;
 949                 req.addr = AF9015_EEPROM_IF1L + offset;
 950                 ret = af9015_rw_udev(udev, &req);
 951                 if (ret)
 952                         goto error;
 953                 af9015_af9013_config[i].tuner_if += val;
 954                 deb_info("%s: [%d] IF1:%d\n", __func__, i,
 955                         af9015_af9013_config[0].tuner_if);
 956
 957                 /* MT2060 IF1 */
 958                 req.addr = AF9015_EEPROM_MT2060_IF1H  + offset;
 959                 ret = af9015_rw_udev(udev, &req);
 960                 if (ret)
 961                         goto error;
 962                 af9015_config.mt2060_if1[i] = val << 8;
 963                 req.addr = AF9015_EEPROM_MT2060_IF1L + offset;
 964                 ret = af9015_rw_udev(udev, &req);
 965                 if (ret)
 966                         goto error;
 967                 af9015_config.mt2060_if1[i] += val;
 968                 deb_info("%s: [%d] MT2060 IF1:%d\n", __func__, i,
 969                         af9015_config.mt2060_if1[i]);
 970
 971                 /* tuner */
 972                 req.addr =  AF9015_EEPROM_TUNER_ID1 + offset;
 973                 ret = af9015_rw_udev(udev, &req);
 974                 if (ret)
 975                         goto error;
 976                 switch (val) {
 977                 case AF9013_TUNER_ENV77H11D5:
 978                 case AF9013_TUNER_MT2060:
 979                 case AF9013_TUNER_QT1010:
 980                 case AF9013_TUNER_UNKNOWN:
 981                 case AF9013_TUNER_MT2060_2:
 982                 case AF9013_TUNER_TDA18271:
 983                 case AF9013_TUNER_QT1010A:
 984                         af9015_af9013_config[i].rf_spec_inv = 1;
 985                         break;
 986                 case AF9013_TUNER_MXL5003D:
 987                 case AF9013_TUNER_MXL5005D:
 988                 case AF9013_TUNER_MXL5005R:
 989                         af9015_af9013_config[i].rf_spec_inv = 0;
 990                         break;
 991                 case AF9013_TUNER_MC44S803:
 992                         af9015_af9013_config[i].gpio[1] = AF9013_GPIO_LO;
 993                         af9015_af9013_config[i].rf_spec_inv = 1;
 994                         break;
 995                 default:
 996                         warn("tuner id:%d not supported, please report!", val);
 997                         return -ENODEV;
 998                 };
 999
1000                 af9015_af9013_config[i].tuner = val;
1001                 deb_info("%s: [%d] tuner id:%d\n", __func__, i, val);
1002         }
1003
1004 error:
1005         if (ret)
1006                 err("eeprom read failed:%d", ret);
1007
1008         /* AverMedia AVerTV Volar Black HD (A850) device have bad EEPROM
1009            content :-( Override some wrong values here. */
1010         if (le16_to_cpu(udev->descriptor.idVendor) == USB_VID_AVERMEDIA &&
1011             le16_to_cpu(udev->descriptor.idProduct) == USB_PID_AVERMEDIA_A850) {
1012                 deb_info("%s: AverMedia A850: overriding config\n", __func__);
1013                 /* disable dual mode */
1014                 af9015_config.dual_mode = 0;
1015                  /* disable 2nd adapter */
1016                 for (i = 0; i < af9015_properties_count; i++)
1017                         af9015_properties[i].num_adapters = 1;
1018
1019                 /* set correct IF */
1020                 af9015_af9013_config[0].tuner_if = 4570;
1021         }
1022
1023         return ret;
1024 }
1025
1026 static int af9015_identify_state(struct usb_device *udev,
1027                                  struct dvb_usb_device_properties *props,
1028                                  struct dvb_usb_device_description **desc,
1029                                  int *cold)
1030 {
1031         int ret;
1032         u8 reply;
1033         struct req_t req = {GET_CONFIG, 0, 0, 0, 0, 1, &reply};
1034
1035         ret = af9015_rw_udev(udev, &req);
1036         if (ret)
1037                 return ret;
1038
1039         deb_info("%s: reply:%02x\n", __func__, reply);
1040         if (reply == 0x02)
1041                 *cold = 0;
1042         else
1043                 *cold = 1;
1044
1045         return ret;
1046 }
1047
1048 static int af9015_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
1049 {
1050         u8 buf[8];
1051         struct req_t req = {GET_IR_CODE, 0, 0, 0, 0, sizeof(buf), buf};
1052         struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
1053         int i, ret;
1054
1055         memset(buf, 0, sizeof(buf));
1056
1057         ret = af9015_ctrl_msg(d, &req);
1058         if (ret)
1059                 return ret;
1060
1061         *event = 0;
1062         *state = REMOTE_NO_KEY_PRESSED;
1063
1064         for (i = 0; i < d->props.rc_key_map_size; i++) {
1065                 if (!buf[1] && rc5_custom(&keymap[i]) == buf[0] &&
1066                     rc5_data(&keymap[i]) == buf[2]) {
1067                         *event = keymap[i].event;
1068                         *state = REMOTE_KEY_PRESSED;
1069                         break;
1070                 }
1071         }
1072         if (!buf[1])
1073                 deb_rc("%s: %02x %02x %02x %02x %02x %02x %02x %02x\n",
1074                         __func__, buf[0], buf[1], buf[2], buf[3], buf[4],
1075                         buf[5], buf[6], buf[7]);
1076
1077         return 0;
1078 }
1079
1080 /* init 2nd I2C adapter */
1081 static int af9015_i2c_init(struct dvb_usb_device *d)
1082 {
1083         int ret;
1084         struct af9015_state *state = d->priv;
1085         deb_info("%s:\n", __func__);
1086
1087         strncpy(state->i2c_adap.name, d->desc->name,
1088                 sizeof(state->i2c_adap.name));
1089 #ifdef I2C_ADAP_CLASS_TV_DIGITAL
1090         state->i2c_adap.class = I2C_ADAP_CLASS_TV_DIGITAL,
1091 #else
1092         state->i2c_adap.class = I2C_CLASS_TV_DIGITAL,
1093 #endif
1094         state->i2c_adap.algo      = d->props.i2c_algo;
1095         state->i2c_adap.algo_data = NULL;
1096         state->i2c_adap.dev.parent = &d->udev->dev;
1097
1098         i2c_set_adapdata(&state->i2c_adap, d);
1099
1100         ret = i2c_add_adapter(&state->i2c_adap);
1101         if (ret < 0)
1102                 err("could not add i2c adapter");
1103
1104         return ret;
1105 }
1106
1107 static int af9015_af9013_frontend_attach(struct dvb_usb_adapter *adap)
1108 {
1109         int ret;
1110         struct af9015_state *state = adap->dev->priv;
1111         struct i2c_adapter *i2c_adap;
1112
1113         if (adap->id == 0) {
1114                 /* select I2C adapter */
1115                 i2c_adap = &adap->dev->i2c_adap;
1116
1117                 deb_info("%s: init I2C\n", __func__);
1118                 ret = af9015_i2c_init(adap->dev);
1119         } else {
1120                 /* select I2C adapter */
1121                 i2c_adap = &state->i2c_adap;
1122
1123                 /* copy firmware to 2nd demodulator */
1124                 if (af9015_config.dual_mode) {
1125                         ret = af9015_copy_firmware(adap->dev);
1126                         if (ret) {
1127                                 err("firmware copy to 2nd frontend " \
1128                                         "failed, will disable it");
1129                                 af9015_config.dual_mode = 0;
1130                                 return -ENODEV;
1131                         }
1132                 } else {
1133                         return -ENODEV;
1134                 }
1135         }
1136
1137         /* attach demodulator */
1138         adap->fe = dvb_attach(af9013_attach, &af9015_af9013_config[adap->id],
1139                 i2c_adap);
1140
1141         return adap->fe == NULL ? -ENODEV : 0;
1142 }
1143
1144 static struct mt2060_config af9015_mt2060_config = {
1145         .i2c_address = 0xc0,
1146         .clock_out = 0,
1147 };
1148
1149 static struct qt1010_config af9015_qt1010_config = {
1150         .i2c_address = 0xc4,
1151 };
1152
1153 static struct tda18271_config af9015_tda18271_config = {
1154         .gate = TDA18271_GATE_DIGITAL,
1155         .small_i2c = 1,
1156 };
1157
1158 static struct mxl5005s_config af9015_mxl5003_config = {
1159         .i2c_address     = 0xc6,
1160         .if_freq         = IF_FREQ_4570000HZ,
1161         .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
1162         .agc_mode        = MXL_SINGLE_AGC,
1163         .tracking_filter = MXL_TF_DEFAULT,
1164         .rssi_enable     = MXL_RSSI_ENABLE,
1165         .cap_select      = MXL_CAP_SEL_ENABLE,
1166         .div_out         = MXL_DIV_OUT_4,
1167         .clock_out       = MXL_CLOCK_OUT_DISABLE,
1168         .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1169         .top             = MXL5005S_TOP_25P2,
1170         .mod_mode        = MXL_DIGITAL_MODE,
1171         .if_mode         = MXL_ZERO_IF,
1172         .AgcMasterByte   = 0x00,
1173 };
1174
1175 static struct mxl5005s_config af9015_mxl5005_config = {
1176         .i2c_address     = 0xc6,
1177         .if_freq         = IF_FREQ_4570000HZ,
1178         .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
1179         .agc_mode        = MXL_SINGLE_AGC,
1180         .tracking_filter = MXL_TF_OFF,
1181         .rssi_enable     = MXL_RSSI_ENABLE,
1182         .cap_select      = MXL_CAP_SEL_ENABLE,
1183         .div_out         = MXL_DIV_OUT_4,
1184         .clock_out       = MXL_CLOCK_OUT_DISABLE,
1185         .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1186         .top             = MXL5005S_TOP_25P2,
1187         .mod_mode        = MXL_DIGITAL_MODE,
1188         .if_mode         = MXL_ZERO_IF,
1189         .AgcMasterByte   = 0x00,
1190 };
1191
1192 static struct mc44s803_config af9015_mc44s803_config = {
1193         .i2c_address = 0xc0,
1194         .dig_out = 1,
1195 };
1196
1197 static int af9015_tuner_attach(struct dvb_usb_adapter *adap)
1198 {
1199         struct af9015_state *state = adap->dev->priv;
1200         struct i2c_adapter *i2c_adap;
1201         int ret;
1202         deb_info("%s: \n", __func__);
1203
1204         /* select I2C adapter */
1205         if (adap->id == 0)
1206                 i2c_adap = &adap->dev->i2c_adap;
1207         else
1208                 i2c_adap = &state->i2c_adap;
1209
1210         switch (af9015_af9013_config[adap->id].tuner) {
1211         case AF9013_TUNER_MT2060:
1212         case AF9013_TUNER_MT2060_2:
1213                 ret = dvb_attach(mt2060_attach, adap->fe, i2c_adap,
1214                         &af9015_mt2060_config,
1215                         af9015_config.mt2060_if1[adap->id])
1216                         == NULL ? -ENODEV : 0;
1217                 break;
1218         case AF9013_TUNER_QT1010:
1219         case AF9013_TUNER_QT1010A:
1220                 ret = dvb_attach(qt1010_attach, adap->fe, i2c_adap,
1221                         &af9015_qt1010_config) == NULL ? -ENODEV : 0;
1222                 break;
1223         case AF9013_TUNER_TDA18271:
1224                 ret = dvb_attach(tda18271_attach, adap->fe, 0xc0, i2c_adap,
1225                         &af9015_tda18271_config) == NULL ? -ENODEV : 0;
1226                 break;
1227         case AF9013_TUNER_MXL5003D:
1228                 ret = dvb_attach(mxl5005s_attach, adap->fe, i2c_adap,
1229                         &af9015_mxl5003_config) == NULL ? -ENODEV : 0;
1230                 break;
1231         case AF9013_TUNER_MXL5005D:
1232         case AF9013_TUNER_MXL5005R:
1233                 ret = dvb_attach(mxl5005s_attach, adap->fe, i2c_adap,
1234                         &af9015_mxl5005_config) == NULL ? -ENODEV : 0;
1235                 break;
1236         case AF9013_TUNER_ENV77H11D5:
1237                 ret = dvb_attach(dvb_pll_attach, adap->fe, 0xc0, i2c_adap,
1238                         DVB_PLL_TDA665X) == NULL ? -ENODEV : 0;
1239                 break;
1240         case AF9013_TUNER_MC44S803:
1241                 ret = dvb_attach(mc44s803_attach, adap->fe, i2c_adap,
1242                         &af9015_mc44s803_config) == NULL ? -ENODEV : 0;
1243                 break;
1244         case AF9013_TUNER_UNKNOWN:
1245         default:
1246                 ret = -ENODEV;
1247                 err("Unknown tuner id:%d",
1248                         af9015_af9013_config[adap->id].tuner);
1249         }
1250         return ret;
1251 }
1252
1253 static struct usb_device_id af9015_usb_table[] = {
1254 /*  0 */{USB_DEVICE(USB_VID_AFATECH,   USB_PID_AFATECH_AF9015_9015)},
1255         {USB_DEVICE(USB_VID_AFATECH,   USB_PID_AFATECH_AF9015_9016)},
1256         {USB_DEVICE(USB_VID_LEADTEK,   USB_PID_WINFAST_DTV_DONGLE_GOLD)},
1257         {USB_DEVICE(USB_VID_PINNACLE,  USB_PID_PINNACLE_PCTV71E)},
1258         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_399U)},
1259 /*  5 */{USB_DEVICE(USB_VID_VISIONPLUS,
1260                 USB_PID_TINYTWIN)},
1261         {USB_DEVICE(USB_VID_VISIONPLUS,
1262                 USB_PID_AZUREWAVE_AD_TU700)},
1263         {USB_DEVICE(USB_VID_TERRATEC,  USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2)},
1264         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_PC160_2T)},
1265         {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X)},
1266 /* 10 */{USB_DEVICE(USB_VID_XTENSIONS, USB_PID_XTENSIONS_XD_380)},
1267         {USB_DEVICE(USB_VID_MSI_2,     USB_PID_MSI_DIGIVOX_DUO)},
1268         {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X_2)},
1269         {USB_DEVICE(USB_VID_TELESTAR,  USB_PID_TELESTAR_STARSTICK_2)},
1270         {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A309)},
1271 /* 15 */{USB_DEVICE(USB_VID_MSI_2,     USB_PID_MSI_DIGI_VOX_MINI_III)},
1272         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_395U)},
1273         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_395U_2)},
1274         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_395U_3)},
1275         {USB_DEVICE(USB_VID_AFATECH,   USB_PID_TREKSTOR_DVBT)},
1276 /* 20 */{USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850)},
1277         {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A805)},
1278         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_CONCEPTRONIC_CTVDIGRCU)},
1279         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_MC810)},
1280         {USB_DEVICE(USB_VID_KYE,       USB_PID_GENIUS_TVGO_DVB_T03)},
1281 /* 25 */{USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_399U_2)},
1282         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_KWORLD_PC160_T)},
1283         {USB_DEVICE(USB_VID_KWORLD_2,  USB_PID_SVEON_STV20)},
1284         {0},
1285 };
1286 MODULE_DEVICE_TABLE(usb, af9015_usb_table);
1287
1288 static struct dvb_usb_device_properties af9015_properties[] = {
1289         {
1290                 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1291
1292                 .usb_ctrl = DEVICE_SPECIFIC,
1293                 .download_firmware = af9015_download_firmware,
1294                 .firmware = "dvb-usb-af9015.fw",
1295                 .no_reconnect = 1,
1296
1297                 .size_of_priv = sizeof(struct af9015_state),
1298
1299                 .num_adapters = 2,
1300                 .adapter = {
1301                         {
1302                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1303                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1304
1305                                 .pid_filter_count = 32,
1306                                 .pid_filter       = af9015_pid_filter,
1307                                 .pid_filter_ctrl  = af9015_pid_filter_ctrl,
1308
1309                                 .frontend_attach =
1310                                         af9015_af9013_frontend_attach,
1311                                 .tuner_attach    = af9015_tuner_attach,
1312                                 .stream = {
1313                                         .type = USB_BULK,
1314                                         .count = 6,
1315                                         .endpoint = 0x84,
1316                                 },
1317                         },
1318                         {
1319                                 .frontend_attach =
1320                                         af9015_af9013_frontend_attach,
1321                                 .tuner_attach    = af9015_tuner_attach,
1322                                 .stream = {
1323                                         .type = USB_BULK,
1324                                         .count = 6,
1325                                         .endpoint = 0x85,
1326                                         .u = {
1327                                                 .bulk = {
1328                                                         .buffersize =
1329                                                 TS_USB20_FRAME_SIZE,
1330                                                 }
1331                                         }
1332                                 },
1333                         }
1334                 },
1335
1336                 .identify_state = af9015_identify_state,
1337
1338                 .rc_query         = af9015_rc_query,
1339                 .rc_interval      = 150,
1340
1341                 .i2c_algo = &af9015_i2c_algo,
1342
1343                 .num_device_descs = 9, /* max 9 */
1344                 .devices = {
1345                         {
1346                                 .name = "Afatech AF9015 DVB-T USB2.0 stick",
1347                                 .cold_ids = {&af9015_usb_table[0],
1348                                              &af9015_usb_table[1], NULL},
1349                                 .warm_ids = {NULL},
1350                         },
1351                         {
1352                                 .name = "Leadtek WinFast DTV Dongle Gold",
1353                                 .cold_ids = {&af9015_usb_table[2], NULL},
1354                                 .warm_ids = {NULL},
1355                         },
1356                         {
1357                                 .name = "Pinnacle PCTV 71e",
1358                                 .cold_ids = {&af9015_usb_table[3], NULL},
1359                                 .warm_ids = {NULL},
1360                         },
1361                         {
1362                                 .name = "KWorld PlusTV Dual DVB-T Stick " \
1363                                         "(DVB-T 399U)",
1364                                 .cold_ids = {&af9015_usb_table[4],
1365                                              &af9015_usb_table[25], NULL},
1366                                 .warm_ids = {NULL},
1367                         },
1368                         {
1369                                 .name = "DigitalNow TinyTwin DVB-T Receiver",
1370                                 .cold_ids = {&af9015_usb_table[5], NULL},
1371                                 .warm_ids = {NULL},
1372                         },
1373                         {
1374                                 .name = "TwinHan AzureWave AD-TU700(704J)",
1375                                 .cold_ids = {&af9015_usb_table[6], NULL},
1376                                 .warm_ids = {NULL},
1377                         },
1378                         {
1379                                 .name = "TerraTec Cinergy T USB XE",
1380                                 .cold_ids = {&af9015_usb_table[7], NULL},
1381                                 .warm_ids = {NULL},
1382                         },
1383                         {
1384                                 .name = "KWorld PlusTV Dual DVB-T PCI " \
1385                                         "(DVB-T PC160-2T)",
1386                                 .cold_ids = {&af9015_usb_table[8], NULL},
1387                                 .warm_ids = {NULL},
1388                         },
1389                         {
1390                                 .name = "AVerMedia AVerTV DVB-T Volar X",
1391                                 .cold_ids = {&af9015_usb_table[9], NULL},
1392                                 .warm_ids = {NULL},
1393                         },
1394                 }
1395         }, {
1396                 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1397
1398                 .usb_ctrl = DEVICE_SPECIFIC,
1399                 .download_firmware = af9015_download_firmware,
1400                 .firmware = "dvb-usb-af9015.fw",
1401                 .no_reconnect = 1,
1402
1403                 .size_of_priv = sizeof(struct af9015_state),
1404
1405                 .num_adapters = 2,
1406                 .adapter = {
1407                         {
1408                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1409                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1410
1411                                 .pid_filter_count = 32,
1412                                 .pid_filter       = af9015_pid_filter,
1413                                 .pid_filter_ctrl  = af9015_pid_filter_ctrl,
1414
1415                                 .frontend_attach =
1416                                         af9015_af9013_frontend_attach,
1417                                 .tuner_attach    = af9015_tuner_attach,
1418                                 .stream = {
1419                                         .type = USB_BULK,
1420                                         .count = 6,
1421                                         .endpoint = 0x84,
1422                                 },
1423                         },
1424                         {
1425                                 .frontend_attach =
1426                                         af9015_af9013_frontend_attach,
1427                                 .tuner_attach    = af9015_tuner_attach,
1428                                 .stream = {
1429                                         .type = USB_BULK,
1430                                         .count = 6,
1431                                         .endpoint = 0x85,
1432                                         .u = {
1433                                                 .bulk = {
1434                                                         .buffersize =
1435                                                 TS_USB20_FRAME_SIZE,
1436                                                 }
1437                                         }
1438                                 },
1439                         }
1440                 },
1441
1442                 .identify_state = af9015_identify_state,
1443
1444                 .rc_query         = af9015_rc_query,
1445                 .rc_interval      = 150,
1446
1447                 .i2c_algo = &af9015_i2c_algo,
1448
1449                 .num_device_descs = 9, /* max 9 */
1450                 .devices = {
1451                         {
1452                                 .name = "Xtensions XD-380",
1453                                 .cold_ids = {&af9015_usb_table[10], NULL},
1454                                 .warm_ids = {NULL},
1455                         },
1456                         {
1457                                 .name = "MSI DIGIVOX Duo",
1458                                 .cold_ids = {&af9015_usb_table[11], NULL},
1459                                 .warm_ids = {NULL},
1460                         },
1461                         {
1462                                 .name = "Fujitsu-Siemens Slim Mobile USB DVB-T",
1463                                 .cold_ids = {&af9015_usb_table[12], NULL},
1464                                 .warm_ids = {NULL},
1465                         },
1466                         {
1467                                 .name = "Telestar Starstick 2",
1468                                 .cold_ids = {&af9015_usb_table[13], NULL},
1469                                 .warm_ids = {NULL},
1470                         },
1471                         {
1472                                 .name = "AVerMedia A309",
1473                                 .cold_ids = {&af9015_usb_table[14], NULL},
1474                                 .warm_ids = {NULL},
1475                         },
1476                         {
1477                                 .name = "MSI Digi VOX mini III",
1478                                 .cold_ids = {&af9015_usb_table[15], NULL},
1479                                 .warm_ids = {NULL},
1480                         },
1481                         {
1482                                 .name = "KWorld USB DVB-T TV Stick II " \
1483                                         "(VS-DVB-T 395U)",
1484                                 .cold_ids = {&af9015_usb_table[16],
1485                                              &af9015_usb_table[17],
1486                                              &af9015_usb_table[18], NULL},
1487                                 .warm_ids = {NULL},
1488                         },
1489                         {
1490                                 .name = "TrekStor DVB-T USB Stick",
1491                                 .cold_ids = {&af9015_usb_table[19], NULL},
1492                                 .warm_ids = {NULL},
1493                         },
1494                         {
1495                                 .name = "AverMedia AVerTV Volar Black HD " \
1496                                         "(A850)",
1497                                 .cold_ids = {&af9015_usb_table[20], NULL},
1498                                 .warm_ids = {NULL},
1499                         },
1500                 }
1501         }, {
1502                 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1503
1504                 .usb_ctrl = DEVICE_SPECIFIC,
1505                 .download_firmware = af9015_download_firmware,
1506                 .firmware = "dvb-usb-af9015.fw",
1507                 .no_reconnect = 1,
1508
1509                 .size_of_priv = sizeof(struct af9015_state),
1510
1511                 .num_adapters = 2,
1512                 .adapter = {
1513                         {
1514                                 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1515                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1516
1517                                 .pid_filter_count = 32,
1518                                 .pid_filter       = af9015_pid_filter,
1519                                 .pid_filter_ctrl  = af9015_pid_filter_ctrl,
1520
1521                                 .frontend_attach =
1522                                         af9015_af9013_frontend_attach,
1523                                 .tuner_attach    = af9015_tuner_attach,
1524                                 .stream = {
1525                                         .type = USB_BULK,
1526                                         .count = 6,
1527                                         .endpoint = 0x84,
1528                                 },
1529                         },
1530                         {
1531                                 .frontend_attach =
1532                                         af9015_af9013_frontend_attach,
1533                                 .tuner_attach    = af9015_tuner_attach,
1534                                 .stream = {
1535                                         .type = USB_BULK,
1536                                         .count = 6,
1537                                         .endpoint = 0x85,
1538                                         .u = {
1539                                                 .bulk = {
1540                                                         .buffersize =
1541                                                 TS_USB20_FRAME_SIZE,
1542                                                 }
1543                                         }
1544                                 },
1545                         }
1546                 },
1547
1548                 .identify_state = af9015_identify_state,
1549
1550                 .rc_query         = af9015_rc_query,
1551                 .rc_interval      = 150,
1552
1553                 .i2c_algo = &af9015_i2c_algo,
1554
1555                 .num_device_descs = 6, /* max 9 */
1556                 .devices = {
1557                         {
1558                                 .name = "AverMedia AVerTV Volar GPS 805 (A805)",
1559                                 .cold_ids = {&af9015_usb_table[21], NULL},
1560                                 .warm_ids = {NULL},
1561                         },
1562                         {
1563                                 .name = "Conceptronic USB2.0 DVB-T CTVDIGRCU " \
1564                                         "V3.0",
1565                                 .cold_ids = {&af9015_usb_table[22], NULL},
1566                                 .warm_ids = {NULL},
1567                         },
1568                         {
1569                                 .name = "KWorld Digial MC-810",
1570                                 .cold_ids = {&af9015_usb_table[23], NULL},
1571                                 .warm_ids = {NULL},
1572                         },
1573                         {
1574                                 .name = "Genius TVGo DVB-T03",
1575                                 .cold_ids = {&af9015_usb_table[24], NULL},
1576                                 .warm_ids = {NULL},
1577                         },
1578                         {
1579                                 .name = "KWorld PlusTV DVB-T PCI Pro Card " \
1580                                         "(DVB-T PC160-T)",
1581                                 .cold_ids = {&af9015_usb_table[26], NULL},
1582                                 .warm_ids = {NULL},
1583                         },
1584                         {
1585                                 .name = "Sveon STV20 Tuner USB DVB-T HDTV",
1586                                 .cold_ids = {&af9015_usb_table[27], NULL},
1587                                 .warm_ids = {NULL},
1588                         },
1589                 }
1590         },
1591 };
1592
1593 static int af9015_usb_probe(struct usb_interface *intf,
1594                             const struct usb_device_id *id)
1595 {
1596         int ret = 0;
1597         struct dvb_usb_device *d = NULL;
1598         struct usb_device *udev = interface_to_usbdev(intf);
1599         u8 i;
1600
1601         deb_info("%s: interface:%d\n", __func__,
1602                 intf->cur_altsetting->desc.bInterfaceNumber);
1603
1604         /* interface 0 is used by DVB-T receiver and
1605            interface 1 is for remote controller (HID) */
1606         if (intf->cur_altsetting->desc.bInterfaceNumber == 0) {
1607                 ret = af9015_read_config(udev);
1608                 if (ret)
1609                         return ret;
1610
1611                 for (i = 0; i < af9015_properties_count; i++) {
1612                         ret = dvb_usb_device_init(intf, &af9015_properties[i],
1613                                 THIS_MODULE, &d, adapter_nr);
1614                         if (!ret)
1615                                 break;
1616                         if (ret != -ENODEV)
1617                                 return ret;
1618                 }
1619                 if (ret)
1620                         return ret;
1621
1622                 if (d)
1623                         ret = af9015_init(d);
1624         }
1625
1626         return ret;
1627 }
1628
1629 static void af9015_i2c_exit(struct dvb_usb_device *d)
1630 {
1631         struct af9015_state *state = d->priv;
1632         deb_info("%s: \n", __func__);
1633
1634         /* remove 2nd I2C adapter */
1635         if (d->state & DVB_USB_STATE_I2C)
1636                 i2c_del_adapter(&state->i2c_adap);
1637 }
1638
1639 static void af9015_usb_device_exit(struct usb_interface *intf)
1640 {
1641         struct dvb_usb_device *d = usb_get_intfdata(intf);
1642         deb_info("%s: \n", __func__);
1643
1644         /* remove 2nd I2C adapter */
1645         if (d != NULL && d->desc != NULL)
1646                 af9015_i2c_exit(d);
1647
1648         dvb_usb_device_exit(intf);
1649 }
1650
1651 /* usb specific object needed to register this driver with the usb subsystem */
1652 static struct usb_driver af9015_usb_driver = {
1653         .name = "dvb_usb_af9015",
1654         .probe = af9015_usb_probe,
1655         .disconnect = af9015_usb_device_exit,
1656         .id_table = af9015_usb_table,
1657 };
1658
1659 /* module stuff */
1660 static int __init af9015_usb_module_init(void)
1661 {
1662         int ret;
1663         ret = usb_register(&af9015_usb_driver);
1664         if (ret)
1665                 err("module init failed:%d", ret);
1666
1667         return ret;
1668 }
1669
1670 static void __exit af9015_usb_module_exit(void)
1671 {
1672         /* deregister this driver from the USB subsystem */
1673         usb_deregister(&af9015_usb_driver);
1674 }
1675
1676 module_init(af9015_usb_module_init);
1677 module_exit(af9015_usb_module_exit);
1678
1679 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1680 MODULE_DESCRIPTION("Driver for Afatech AF9015 DVB-T");
1681 MODULE_LICENSE("GPL");