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

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