SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/media/dvb/dvb-usb/af9015.c

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