Pileus Git - ~andy/linux/blob - drivers/media/dvb/dvb-usb/af9015.c

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