drivers/media/dvb/dvb-usb/af9015.c

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