kernel/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 #define AF9015_EEPROM_SIZE 256
 401
 402 /* hash (and dump) eeprom */
 403 static int af9015_eeprom_hash(struct dvb_usb_device *d)
 404 {
 405         struct af9015_state *state = d_to_priv(d);
 406         int ret, i;
 407         u8 buf[AF9015_EEPROM_SIZE];
 408         struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, NULL};
 409
 410         /* read eeprom */
 411         for (i = 0; i < AF9015_EEPROM_SIZE; i++) {
 412                 req.addr = i;
 413                 req.data = &buf[i];
 414                 ret = af9015_ctrl_msg(d, &req);
 415                 if (ret < 0)
 416                         goto err;
 417         }
 418
 419         /* calculate checksum */
 420         for (i = 0; i < AF9015_EEPROM_SIZE / sizeof(u32); i++) {
 421                 state->eeprom_sum *= GOLDEN_RATIO_PRIME_32;
 422                 state->eeprom_sum += le32_to_cpu(((__le32 *)buf)[i]);
 423         }
 424
 425         for (i = 0; i < AF9015_EEPROM_SIZE; i += 16)
 426                 dev_dbg(&d->udev->dev, "%s: %*ph\n", __func__, 16, buf + i);
 427
 428         dev_dbg(&d->udev->dev, "%s: eeprom sum=%.8x\n",
 429                         __func__, state->eeprom_sum);
 430         return 0;
 431 err:
 432         dev_err(&d->udev->dev, "%s: eeprom failed=%d\n", KBUILD_MODNAME, ret);
 433         return ret;
 434 }
 435
 436 static int af9015_read_config(struct dvb_usb_device *d)
 437 {
 438         struct af9015_state *state = d_to_priv(d);
 439         int ret;
 440         u8 val, i, offset = 0;
 441         struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
 442
 443         dev_dbg(&d->udev->dev, "%s:\n", __func__);
 444
 445         /* IR remote controller */
 446         req.addr = AF9015_EEPROM_IR_MODE;
 447         /* first message will timeout often due to possible hw bug */
 448         for (i = 0; i < 4; i++) {
 449                 ret = af9015_ctrl_msg(d, &req);
 450                 if (!ret)
 451                         break;
 452         }
 453         if (ret)
 454                 goto error;
 455
 456         ret = af9015_eeprom_hash(d);
 457         if (ret)
 458                 goto error;
 459
 460         state->ir_mode = val;
 461         dev_dbg(&d->udev->dev, "%s: IR mode=%d\n", __func__, val);
 462
 463         /* TS mode - one or two receivers */
 464         req.addr = AF9015_EEPROM_TS_MODE;
 465         ret = af9015_ctrl_msg(d, &req);
 466         if (ret)
 467                 goto error;
 468
 469         state->dual_mode = val;
 470         dev_dbg(&d->udev->dev, "%s: TS mode=%d\n", __func__, state->dual_mode);
 471
 472         /* disable 2nd adapter because we don't have PID-filters */
 473         if (d->udev->speed == USB_SPEED_FULL)
 474                 state->dual_mode = 0;
 475
 476         if (state->dual_mode) {
 477                 /* read 2nd demodulator I2C address */
 478                 req.addr = AF9015_EEPROM_DEMOD2_I2C;
 479                 ret = af9015_ctrl_msg(d, &req);
 480                 if (ret)
 481                         goto error;
 482
 483                 state->af9013_config[1].i2c_addr = val;
 484         }
 485
 486         for (i = 0; i < state->dual_mode + 1; i++) {
 487                 if (i == 1)
 488                         offset = AF9015_EEPROM_OFFSET;
 489                 /* xtal */
 490                 req.addr = AF9015_EEPROM_XTAL_TYPE1 + offset;
 491                 ret = af9015_ctrl_msg(d, &req);
 492                 if (ret)
 493                         goto error;
 494                 switch (val) {
 495                 case 0:
 496                         state->af9013_config[i].clock = 28800000;
 497                         break;
 498                 case 1:
 499                         state->af9013_config[i].clock = 20480000;
 500                         break;
 501                 case 2:
 502                         state->af9013_config[i].clock = 28000000;
 503                         break;
 504                 case 3:
 505                         state->af9013_config[i].clock = 25000000;
 506                         break;
 507                 }
 508                 dev_dbg(&d->udev->dev, "%s: [%d] xtal=%d set clock=%d\n",
 509                                 __func__, i, val,
 510                                 state->af9013_config[i].clock);
 511
 512                 /* IF frequency */
 513                 req.addr = AF9015_EEPROM_IF1H + offset;
 514                 ret = af9015_ctrl_msg(d, &req);
 515                 if (ret)
 516                         goto error;
 517
 518                 state->af9013_config[i].if_frequency = val << 8;
 519
 520                 req.addr = AF9015_EEPROM_IF1L + offset;
 521                 ret = af9015_ctrl_msg(d, &req);
 522                 if (ret)
 523                         goto error;
 524
 525                 state->af9013_config[i].if_frequency += val;
 526                 state->af9013_config[i].if_frequency *= 1000;
 527                 dev_dbg(&d->udev->dev, "%s: [%d] IF frequency=%d\n", __func__,
 528                                 i, state->af9013_config[i].if_frequency);
 529
 530                 /* MT2060 IF1 */
 531                 req.addr = AF9015_EEPROM_MT2060_IF1H  + offset;
 532                 ret = af9015_ctrl_msg(d, &req);
 533                 if (ret)
 534                         goto error;
 535                 state->mt2060_if1[i] = val << 8;
 536                 req.addr = AF9015_EEPROM_MT2060_IF1L + offset;
 537                 ret = af9015_ctrl_msg(d, &req);
 538                 if (ret)
 539                         goto error;
 540                 state->mt2060_if1[i] += val;
 541                 dev_dbg(&d->udev->dev, "%s: [%d] MT2060 IF1=%d\n", __func__, i,
 542                                 state->mt2060_if1[i]);
 543
 544                 /* tuner */
 545                 req.addr =  AF9015_EEPROM_TUNER_ID1 + offset;
 546                 ret = af9015_ctrl_msg(d, &req);
 547                 if (ret)
 548                         goto error;
 549                 switch (val) {
 550                 case AF9013_TUNER_ENV77H11D5:
 551                 case AF9013_TUNER_MT2060:
 552                 case AF9013_TUNER_QT1010:
 553                 case AF9013_TUNER_UNKNOWN:
 554                 case AF9013_TUNER_MT2060_2:
 555                 case AF9013_TUNER_TDA18271:
 556                 case AF9013_TUNER_QT1010A:
 557                 case AF9013_TUNER_TDA18218:
 558                         state->af9013_config[i].spec_inv = 1;
 559                         break;
 560                 case AF9013_TUNER_MXL5003D:
 561                 case AF9013_TUNER_MXL5005D:
 562                 case AF9013_TUNER_MXL5005R:
 563                 case AF9013_TUNER_MXL5007T:
 564                         state->af9013_config[i].spec_inv = 0;
 565                         break;
 566                 case AF9013_TUNER_MC44S803:
 567                         state->af9013_config[i].gpio[1] = AF9013_GPIO_LO;
 568                         state->af9013_config[i].spec_inv = 1;
 569                         break;
 570                 default:
 571                         dev_err(&d->udev->dev, "%s: tuner id=%d not " \
 572                                         "supported, please report!\n",
 573                                         KBUILD_MODNAME, val);
 574                         return -ENODEV;
 575                 }
 576
 577                 state->af9013_config[i].tuner = val;
 578                 dev_dbg(&d->udev->dev, "%s: [%d] tuner id=%d\n",
 579                                 __func__, i, val);
 580         }
 581
 582 error:
 583         if (ret)
 584                 dev_err(&d->udev->dev, "%s: eeprom read failed=%d\n",
 585                                 KBUILD_MODNAME, ret);
 586
 587         /* AverMedia AVerTV Volar Black HD (A850) device have bad EEPROM
 588            content :-( Override some wrong values here. Ditto for the
 589            AVerTV Red HD+ (A850T) device. */
 590         if (le16_to_cpu(d->udev->descriptor.idVendor) == USB_VID_AVERMEDIA &&
 591                 ((le16_to_cpu(d->udev->descriptor.idProduct) ==
 592                         USB_PID_AVERMEDIA_A850) ||
 593                 (le16_to_cpu(d->udev->descriptor.idProduct) ==
 594                         USB_PID_AVERMEDIA_A850T))) {
 595                 dev_dbg(&d->udev->dev,
 596                                 "%s: AverMedia A850: overriding config\n",
 597                                 __func__);
 598                 /* disable dual mode */
 599                 state->dual_mode = 0;
 600
 601                 /* set correct IF */
 602                 state->af9013_config[0].if_frequency = 4570000;
 603         }
 604
 605         return ret;
 606 }
 607
 608 static int af9015_get_stream_config(struct dvb_frontend *fe, u8 *ts_type,
 609                 struct usb_data_stream_properties *stream)
 610 {
 611         struct dvb_usb_device *d = fe_to_d(fe);
 612         dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, fe_to_adap(fe)->id);
 613
 614         if (d->udev->speed == USB_SPEED_FULL)
 615                 stream->u.bulk.buffersize = TS_USB11_FRAME_SIZE;
 616
 617         return 0;
 618 }
 619
 620 static int af9015_get_adapter_count(struct dvb_usb_device *d)
 621 {
 622         struct af9015_state *state = d_to_priv(d);
 623         return state->dual_mode + 1;
 624 }
 625
 626 /* override demod callbacks for resource locking */
 627 static int af9015_af9013_set_frontend(struct dvb_frontend *fe)
 628 {
 629         int ret;
 630         struct af9015_state *state = fe_to_priv(fe);
 631
 632         if (mutex_lock_interruptible(&state->fe_mutex))
 633                 return -EAGAIN;
 634
 635         ret = state->set_frontend[fe_to_adap(fe)->id](fe);
 636
 637         mutex_unlock(&state->fe_mutex);
 638
 639         return ret;
 640 }
 641
 642 /* override demod callbacks for resource locking */
 643 static int af9015_af9013_read_status(struct dvb_frontend *fe,
 644         fe_status_t *status)
 645 {
 646         int ret;
 647         struct af9015_state *state = fe_to_priv(fe);
 648
 649         if (mutex_lock_interruptible(&state->fe_mutex))
 650                 return -EAGAIN;
 651
 652         ret = state->read_status[fe_to_adap(fe)->id](fe, status);
 653
 654         mutex_unlock(&state->fe_mutex);
 655
 656         return ret;
 657 }
 658
 659 /* override demod callbacks for resource locking */
 660 static int af9015_af9013_init(struct dvb_frontend *fe)
 661 {
 662         int ret;
 663         struct af9015_state *state = fe_to_priv(fe);
 664
 665         if (mutex_lock_interruptible(&state->fe_mutex))
 666                 return -EAGAIN;
 667
 668         ret = state->init[fe_to_adap(fe)->id](fe);
 669
 670         mutex_unlock(&state->fe_mutex);
 671
 672         return ret;
 673 }
 674
 675 /* override demod callbacks for resource locking */
 676 static int af9015_af9013_sleep(struct dvb_frontend *fe)
 677 {
 678         int ret;
 679         struct af9015_state *state = fe_to_priv(fe);
 680
 681         if (mutex_lock_interruptible(&state->fe_mutex))
 682                 return -EAGAIN;
 683
 684         ret = state->sleep[fe_to_adap(fe)->id](fe);
 685
 686         mutex_unlock(&state->fe_mutex);
 687
 688         return ret;
 689 }
 690
 691 /* override tuner callbacks for resource locking */
 692 static int af9015_tuner_init(struct dvb_frontend *fe)
 693 {
 694         int ret;
 695         struct af9015_state *state = fe_to_priv(fe);
 696
 697         if (mutex_lock_interruptible(&state->fe_mutex))
 698                 return -EAGAIN;
 699
 700         ret = state->tuner_init[fe_to_adap(fe)->id](fe);
 701
 702         mutex_unlock(&state->fe_mutex);
 703
 704         return ret;
 705 }
 706
 707 /* override tuner callbacks for resource locking */
 708 static int af9015_tuner_sleep(struct dvb_frontend *fe)
 709 {
 710         int ret;
 711         struct af9015_state *state = fe_to_priv(fe);
 712
 713         if (mutex_lock_interruptible(&state->fe_mutex))
 714                 return -EAGAIN;
 715
 716         ret = state->tuner_sleep[fe_to_adap(fe)->id](fe);
 717
 718         mutex_unlock(&state->fe_mutex);
 719
 720         return ret;
 721 }
 722
 723 static int af9015_copy_firmware(struct dvb_usb_device *d)
 724 {
 725         struct af9015_state *state = d_to_priv(d);
 726         int ret;
 727         u8 fw_params[4];
 728         u8 val, i;
 729         struct req_t req = {COPY_FIRMWARE, 0, 0x5100, 0, 0, sizeof(fw_params),
 730                 fw_params };
 731         dev_dbg(&d->udev->dev, "%s:\n", __func__);
 732
 733         fw_params[0] = state->firmware_size >> 8;
 734         fw_params[1] = state->firmware_size & 0xff;
 735         fw_params[2] = state->firmware_checksum >> 8;
 736         fw_params[3] = state->firmware_checksum & 0xff;
 737
 738         /* wait 2nd demodulator ready */
 739         msleep(100);
 740
 741         ret = af9015_read_reg_i2c(d, state->af9013_config[1].i2c_addr,
 742                         0x98be, &val);
 743         if (ret)
 744                 goto error;
 745         else
 746                 dev_dbg(&d->udev->dev, "%s: firmware status=%02x\n",
 747                                 __func__, val);
 748
 749         if (val == 0x0c) /* fw is running, no need for download */
 750                 goto exit;
 751
 752         /* set I2C master clock to fast (to speed up firmware copy) */
 753         ret = af9015_write_reg(d, 0xd416, 0x04); /* 0x04 * 400ns */
 754         if (ret)
 755                 goto error;
 756
 757         msleep(50);
 758
 759         /* copy firmware */
 760         ret = af9015_ctrl_msg(d, &req);
 761         if (ret)
 762                 dev_err(&d->udev->dev, "%s: firmware copy cmd failed=%d\n",
 763                                 KBUILD_MODNAME, ret);
 764
 765         dev_dbg(&d->udev->dev, "%s: firmware copy done\n", __func__);
 766
 767         /* set I2C master clock back to normal */
 768         ret = af9015_write_reg(d, 0xd416, 0x14); /* 0x14 * 400ns */
 769         if (ret)
 770                 goto error;
 771
 772         /* request boot firmware */
 773         ret = af9015_write_reg_i2c(d, state->af9013_config[1].i2c_addr,
 774                         0xe205, 1);
 775         dev_dbg(&d->udev->dev, "%s: firmware boot cmd status=%d\n",
 776                         __func__, ret);
 777         if (ret)
 778                 goto error;
 779
 780         for (i = 0; i < 15; i++) {
 781                 msleep(100);
 782
 783                 /* check firmware status */
 784                 ret = af9015_read_reg_i2c(d, state->af9013_config[1].i2c_addr,
 785                                 0x98be, &val);
 786                 dev_dbg(&d->udev->dev, "%s: firmware status cmd status=%d " \
 787                                 "firmware status=%02x\n", __func__, ret, val);
 788                 if (ret)
 789                         goto error;
 790
 791                 if (val == 0x0c || val == 0x04) /* success or fail */
 792                         break;
 793         }
 794
 795         if (val == 0x04) {
 796                 dev_err(&d->udev->dev, "%s: firmware did not run\n",
 797                                 KBUILD_MODNAME);
 798                 ret = -ETIMEDOUT;
 799         } else if (val != 0x0c) {
 800                 dev_err(&d->udev->dev, "%s: firmware boot timeout\n",
 801                                 KBUILD_MODNAME);
 802                 ret = -ETIMEDOUT;
 803         }
 804
 805 error:
 806 exit:
 807         return ret;
 808 }
 809
 810 static int af9015_af9013_frontend_attach(struct dvb_usb_adapter *adap)
 811 {
 812         int ret;
 813         struct af9015_state *state = adap_to_priv(adap);
 814
 815         if (adap->id == 0) {
 816                 state->af9013_config[0].ts_mode = AF9013_TS_USB;
 817                 memcpy(state->af9013_config[0].api_version, "\x0\x1\x9\x0", 4);
 818                 state->af9013_config[0].gpio[0] = AF9013_GPIO_HI;
 819                 state->af9013_config[0].gpio[3] = AF9013_GPIO_TUNER_ON;
 820         } else if (adap->id == 1) {
 821                 state->af9013_config[1].ts_mode = AF9013_TS_SERIAL;
 822                 memcpy(state->af9013_config[1].api_version, "\x0\x1\x9\x0", 4);
 823                 state->af9013_config[1].gpio[0] = AF9013_GPIO_TUNER_ON;
 824                 state->af9013_config[1].gpio[1] = AF9013_GPIO_LO;
 825
 826                 /* copy firmware to 2nd demodulator */
 827                 if (state->dual_mode) {
 828                         ret = af9015_copy_firmware(adap_to_d(adap));
 829                         if (ret) {
 830                                 dev_err(&adap_to_d(adap)->udev->dev,
 831                                                 "%s: firmware copy to 2nd " \
 832                                                 "frontend failed, will " \
 833                                                 "disable it\n", KBUILD_MODNAME);
 834                                 state->dual_mode = 0;
 835                                 return -ENODEV;
 836                         }
 837                 } else {
 838                         return -ENODEV;
 839                 }
 840         }
 841
 842         /* attach demodulator */
 843         adap->fe[0] = dvb_attach(af9013_attach,
 844                 &state->af9013_config[adap->id], &adap_to_d(adap)->i2c_adap);
 845
 846         /*
 847          * AF9015 firmware does not like if it gets interrupted by I2C adapter
 848          * request on some critical phases. During normal operation I2C adapter
 849          * is used only 2nd demodulator and tuner on dual tuner devices.
 850          * Override demodulator callbacks and use mutex for limit access to
 851          * those "critical" paths to keep AF9015 happy.
 852          */
 853         if (adap->fe[0]) {
 854                 state->set_frontend[adap->id] =
 855                         adap->fe[0]->ops.set_frontend;
 856                 adap->fe[0]->ops.set_frontend =
 857                         af9015_af9013_set_frontend;
 858
 859                 state->read_status[adap->id] =
 860                         adap->fe[0]->ops.read_status;
 861                 adap->fe[0]->ops.read_status =
 862                         af9015_af9013_read_status;
 863
 864                 state->init[adap->id] = adap->fe[0]->ops.init;
 865                 adap->fe[0]->ops.init = af9015_af9013_init;
 866
 867                 state->sleep[adap->id] = adap->fe[0]->ops.sleep;
 868                 adap->fe[0]->ops.sleep = af9015_af9013_sleep;
 869         }
 870
 871         return adap->fe[0] == NULL ? -ENODEV : 0;
 872 }
 873
 874 static struct mt2060_config af9015_mt2060_config = {
 875         .i2c_address = 0xc0,
 876         .clock_out = 0,
 877 };
 878
 879 static struct qt1010_config af9015_qt1010_config = {
 880         .i2c_address = 0xc4,
 881 };
 882
 883 static struct tda18271_config af9015_tda18271_config = {
 884         .gate = TDA18271_GATE_DIGITAL,
 885         .small_i2c = TDA18271_16_BYTE_CHUNK_INIT,
 886 };
 887
 888 static struct mxl5005s_config af9015_mxl5003_config = {
 889         .i2c_address     = 0xc6,
 890         .if_freq         = IF_FREQ_4570000HZ,
 891         .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
 892         .agc_mode        = MXL_SINGLE_AGC,
 893         .tracking_filter = MXL_TF_DEFAULT,
 894         .rssi_enable     = MXL_RSSI_ENABLE,
 895         .cap_select      = MXL_CAP_SEL_ENABLE,
 896         .div_out         = MXL_DIV_OUT_4,
 897         .clock_out       = MXL_CLOCK_OUT_DISABLE,
 898         .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
 899         .top             = MXL5005S_TOP_25P2,
 900         .mod_mode        = MXL_DIGITAL_MODE,
 901         .if_mode         = MXL_ZERO_IF,
 902         .AgcMasterByte   = 0x00,
 903 };
 904
 905 static struct mxl5005s_config af9015_mxl5005_config = {
 906         .i2c_address     = 0xc6,
 907         .if_freq         = IF_FREQ_4570000HZ,
 908         .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
 909         .agc_mode        = MXL_SINGLE_AGC,
 910         .tracking_filter = MXL_TF_OFF,
 911         .rssi_enable     = MXL_RSSI_ENABLE,
 912         .cap_select      = MXL_CAP_SEL_ENABLE,
 913         .div_out         = MXL_DIV_OUT_4,
 914         .clock_out       = MXL_CLOCK_OUT_DISABLE,
 915         .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
 916         .top             = MXL5005S_TOP_25P2,
 917         .mod_mode        = MXL_DIGITAL_MODE,
 918         .if_mode         = MXL_ZERO_IF,
 919         .AgcMasterByte   = 0x00,
 920 };
 921
 922 static struct mc44s803_config af9015_mc44s803_config = {
 923         .i2c_address = 0xc0,
 924         .dig_out = 1,
 925 };
 926
 927 static struct tda18218_config af9015_tda18218_config = {
 928         .i2c_address = 0xc0,
 929         .i2c_wr_max = 21, /* max wr bytes AF9015 I2C adap can handle at once */
 930 };
 931
 932 static struct mxl5007t_config af9015_mxl5007t_config = {
 933         .xtal_freq_hz = MxL_XTAL_24_MHZ,
 934         .if_freq_hz = MxL_IF_4_57_MHZ,
 935 };
 936
 937 static int af9015_tuner_attach(struct dvb_usb_adapter *adap)
 938 {
 939         struct dvb_usb_device *d = adap_to_d(adap);
 940         struct af9015_state *state = d_to_priv(d);
 941         int ret;
 942         dev_dbg(&d->udev->dev, "%s:\n", __func__);
 943
 944         switch (state->af9013_config[adap->id].tuner) {
 945         case AF9013_TUNER_MT2060:
 946         case AF9013_TUNER_MT2060_2:
 947                 ret = dvb_attach(mt2060_attach, adap->fe[0],
 948                         &adap_to_d(adap)->i2c_adap, &af9015_mt2060_config,
 949                         state->mt2060_if1[adap->id])
 950                         == NULL ? -ENODEV : 0;
 951                 break;
 952         case AF9013_TUNER_QT1010:
 953         case AF9013_TUNER_QT1010A:
 954                 ret = dvb_attach(qt1010_attach, adap->fe[0],
 955                         &adap_to_d(adap)->i2c_adap,
 956                         &af9015_qt1010_config) == NULL ? -ENODEV : 0;
 957                 break;
 958         case AF9013_TUNER_TDA18271:
 959                 ret = dvb_attach(tda18271_attach, adap->fe[0], 0xc0,
 960                         &adap_to_d(adap)->i2c_adap,
 961                         &af9015_tda18271_config) == NULL ? -ENODEV : 0;
 962                 break;
 963         case AF9013_TUNER_TDA18218:
 964                 ret = dvb_attach(tda18218_attach, adap->fe[0],
 965                         &adap_to_d(adap)->i2c_adap,
 966                         &af9015_tda18218_config) == NULL ? -ENODEV : 0;
 967                 break;
 968         case AF9013_TUNER_MXL5003D:
 969                 ret = dvb_attach(mxl5005s_attach, adap->fe[0],
 970                         &adap_to_d(adap)->i2c_adap,
 971                         &af9015_mxl5003_config) == NULL ? -ENODEV : 0;
 972                 break;
 973         case AF9013_TUNER_MXL5005D:
 974         case AF9013_TUNER_MXL5005R:
 975                 ret = dvb_attach(mxl5005s_attach, adap->fe[0],
 976                         &adap_to_d(adap)->i2c_adap,
 977                         &af9015_mxl5005_config) == NULL ? -ENODEV : 0;
 978                 break;
 979         case AF9013_TUNER_ENV77H11D5:
 980                 ret = dvb_attach(dvb_pll_attach, adap->fe[0], 0xc0,
 981                         &adap_to_d(adap)->i2c_adap,
 982                         DVB_PLL_TDA665X) == NULL ? -ENODEV : 0;
 983                 break;
 984         case AF9013_TUNER_MC44S803:
 985                 ret = dvb_attach(mc44s803_attach, adap->fe[0],
 986                         &adap_to_d(adap)->i2c_adap,
 987                         &af9015_mc44s803_config) == NULL ? -ENODEV : 0;
 988                 break;
 989         case AF9013_TUNER_MXL5007T:
 990                 ret = dvb_attach(mxl5007t_attach, adap->fe[0],
 991                         &adap_to_d(adap)->i2c_adap,
 992                         0xc0, &af9015_mxl5007t_config) == NULL ? -ENODEV : 0;
 993                 break;
 994         case AF9013_TUNER_UNKNOWN:
 995         default:
 996                 dev_err(&d->udev->dev, "%s: unknown tuner id=%d\n",
 997                                 KBUILD_MODNAME,
 998                                 state->af9013_config[adap->id].tuner);
 999                 ret = -ENODEV;
1000         }
1001
1002         if (adap->fe[0]->ops.tuner_ops.init) {
1003                 state->tuner_init[adap->id] =
1004                         adap->fe[0]->ops.tuner_ops.init;
1005                 adap->fe[0]->ops.tuner_ops.init = af9015_tuner_init;
1006         }
1007
1008         if (adap->fe[0]->ops.tuner_ops.sleep) {
1009                 state->tuner_sleep[adap->id] =
1010                         adap->fe[0]->ops.tuner_ops.sleep;
1011                 adap->fe[0]->ops.tuner_ops.sleep = af9015_tuner_sleep;
1012         }
1013
1014         return ret;
1015 }
1016
1017 static int af9015_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
1018 {
1019         struct dvb_usb_device *d = adap_to_d(adap);
1020         int ret;
1021         dev_dbg(&d->udev->dev, "%s: onoff=%d\n", __func__, onoff);
1022
1023         if (onoff)
1024                 ret = af9015_set_reg_bit(d, 0xd503, 0);
1025         else
1026                 ret = af9015_clear_reg_bit(d, 0xd503, 0);
1027
1028         return ret;
1029 }
1030
1031 static int af9015_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
1032         int onoff)
1033 {
1034         struct dvb_usb_device *d = adap_to_d(adap);
1035         int ret;
1036         u8 idx;
1037         dev_dbg(&d->udev->dev, "%s: index=%d pid=%04x onoff=%d\n",
1038                         __func__, index, pid, onoff);
1039
1040         ret = af9015_write_reg(d, 0xd505, (pid & 0xff));
1041         if (ret)
1042                 goto error;
1043
1044         ret = af9015_write_reg(d, 0xd506, (pid >> 8));
1045         if (ret)
1046                 goto error;
1047
1048         idx = ((index & 0x1f) | (1 << 5));
1049         ret = af9015_write_reg(d, 0xd504, idx);
1050
1051 error:
1052         return ret;
1053 }
1054
1055 static int af9015_init_endpoint(struct dvb_usb_device *d)
1056 {
1057         struct af9015_state *state = d_to_priv(d);
1058         int ret;
1059         u16 frame_size;
1060         u8  packet_size;
1061         dev_dbg(&d->udev->dev, "%s: USB speed=%d\n", __func__, d->udev->speed);
1062
1063         if (d->udev->speed == USB_SPEED_FULL) {
1064                 frame_size = TS_USB11_FRAME_SIZE/4;
1065                 packet_size = TS_USB11_MAX_PACKET_SIZE/4;
1066         } else {
1067                 frame_size = TS_USB20_FRAME_SIZE/4;
1068                 packet_size = TS_USB20_MAX_PACKET_SIZE/4;
1069         }
1070
1071         ret = af9015_set_reg_bit(d, 0xd507, 2); /* assert EP4 reset */
1072         if (ret)
1073                 goto error;
1074         ret = af9015_set_reg_bit(d, 0xd50b, 1); /* assert EP5 reset */
1075         if (ret)
1076                 goto error;
1077         ret = af9015_clear_reg_bit(d, 0xdd11, 5); /* disable EP4 */
1078         if (ret)
1079                 goto error;
1080         ret = af9015_clear_reg_bit(d, 0xdd11, 6); /* disable EP5 */
1081         if (ret)
1082                 goto error;
1083         ret = af9015_set_reg_bit(d, 0xdd11, 5); /* enable EP4 */
1084         if (ret)
1085                 goto error;
1086         if (state->dual_mode) {
1087                 ret = af9015_set_reg_bit(d, 0xdd11, 6); /* enable EP5 */
1088                 if (ret)
1089                         goto error;
1090         }
1091         ret = af9015_clear_reg_bit(d, 0xdd13, 5); /* disable EP4 NAK */
1092         if (ret)
1093                 goto error;
1094         if (state->dual_mode) {
1095                 ret = af9015_clear_reg_bit(d, 0xdd13, 6); /* disable EP5 NAK */
1096                 if (ret)
1097                         goto error;
1098         }
1099         /* EP4 xfer length */
1100         ret = af9015_write_reg(d, 0xdd88, frame_size & 0xff);
1101         if (ret)
1102                 goto error;
1103         ret = af9015_write_reg(d, 0xdd89, frame_size >> 8);
1104         if (ret)
1105                 goto error;
1106         /* EP5 xfer length */
1107         ret = af9015_write_reg(d, 0xdd8a, frame_size & 0xff);
1108         if (ret)
1109                 goto error;
1110         ret = af9015_write_reg(d, 0xdd8b, frame_size >> 8);
1111         if (ret)
1112                 goto error;
1113         ret = af9015_write_reg(d, 0xdd0c, packet_size); /* EP4 packet size */
1114         if (ret)
1115                 goto error;
1116         ret = af9015_write_reg(d, 0xdd0d, packet_size); /* EP5 packet size */
1117         if (ret)
1118                 goto error;
1119         ret = af9015_clear_reg_bit(d, 0xd507, 2); /* negate EP4 reset */
1120         if (ret)
1121                 goto error;
1122         if (state->dual_mode) {
1123                 ret = af9015_clear_reg_bit(d, 0xd50b, 1); /* negate EP5 reset */
1124                 if (ret)
1125                         goto error;
1126         }
1127
1128         /* enable / disable mp2if2 */
1129         if (state->dual_mode)
1130                 ret = af9015_set_reg_bit(d, 0xd50b, 0);
1131         else
1132                 ret = af9015_clear_reg_bit(d, 0xd50b, 0);
1133
1134 error:
1135         if (ret)
1136                 dev_err(&d->udev->dev, "%s: endpoint init failed=%d\n",
1137                                 KBUILD_MODNAME, ret);
1138
1139         return ret;
1140 }
1141
1142 static int af9015_init(struct dvb_usb_device *d)
1143 {
1144         struct af9015_state *state = d_to_priv(d);
1145         int ret;
1146         dev_dbg(&d->udev->dev, "%s:\n", __func__);
1147
1148         mutex_init(&state->fe_mutex);
1149
1150         /* init RC canary */
1151         ret = af9015_write_reg(d, 0x98e9, 0xff);
1152         if (ret)
1153                 goto error;
1154
1155         ret = af9015_init_endpoint(d);
1156         if (ret)
1157                 goto error;
1158
1159 error:
1160         return ret;
1161 }
1162
1163 #if IS_ENABLED(CONFIG_RC_CORE)
1164 struct af9015_rc_setup {
1165         unsigned int id;
1166         char *rc_codes;
1167 };
1168
1169 static char *af9015_rc_setup_match(unsigned int id,
1170         const struct af9015_rc_setup *table)
1171 {
1172         for (; table->rc_codes; table++)
1173                 if (table->id == id)
1174                         return table->rc_codes;
1175         return NULL;
1176 }
1177
1178 static const struct af9015_rc_setup af9015_rc_setup_modparam[] = {
1179         { AF9015_REMOTE_A_LINK_DTU_M, RC_MAP_ALINK_DTU_M },
1180         { AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3, RC_MAP_MSI_DIGIVOX_II },
1181         { AF9015_REMOTE_MYGICTV_U718, RC_MAP_TOTAL_MEDIA_IN_HAND },
1182         { AF9015_REMOTE_DIGITTRADE_DVB_T, RC_MAP_DIGITTRADE },
1183         { AF9015_REMOTE_AVERMEDIA_KS, RC_MAP_AVERMEDIA_RM_KS },
1184         { }
1185 };
1186
1187 static const struct af9015_rc_setup af9015_rc_setup_hashes[] = {
1188         { 0xb8feb708, RC_MAP_MSI_DIGIVOX_II },
1189         { 0xa3703d00, RC_MAP_ALINK_DTU_M },
1190         { 0x9b7dc64e, RC_MAP_TOTAL_MEDIA_IN_HAND }, /* MYGICTV U718 */
1191         { 0x5d49e3db, RC_MAP_DIGITTRADE }, /* LC-Power LC-USB-DVBT */
1192         { }
1193 };
1194
1195 static int af9015_rc_query(struct dvb_usb_device *d)
1196 {
1197         struct af9015_state *state = d_to_priv(d);
1198         int ret;
1199         u8 buf[17];
1200
1201         /* read registers needed to detect remote controller code */
1202         ret = af9015_read_regs(d, 0x98d9, buf, sizeof(buf));
1203         if (ret)
1204                 goto error;
1205
1206         /* If any of these are non-zero, assume invalid data */
1207         if (buf[1] || buf[2] || buf[3]) {
1208                 dev_dbg(&d->udev->dev, "%s: invalid data\n", __func__);
1209                 return ret;
1210         }
1211
1212         /* Check for repeat of previous code */
1213         if ((state->rc_repeat != buf[6] || buf[0]) &&
1214                         !memcmp(&buf[12], state->rc_last, 4)) {
1215                 dev_dbg(&d->udev->dev, "%s: key repeated\n", __func__);
1216                 rc_repeat(d->rc_dev);
1217                 state->rc_repeat = buf[6];
1218                 return ret;
1219         }
1220
1221         /* Only process key if canary killed */
1222         if (buf[16] != 0xff && buf[0] != 0x01) {
1223                 dev_dbg(&d->udev->dev, "%s: key pressed %*ph\n",
1224                                 __func__, 4, buf + 12);
1225
1226                 /* Reset the canary */
1227                 ret = af9015_write_reg(d, 0x98e9, 0xff);
1228                 if (ret)
1229                         goto error;
1230
1231                 /* Remember this key */
1232                 memcpy(state->rc_last, &buf[12], 4);
1233                 if (buf[14] == (u8) ~buf[15]) {
1234                         if (buf[12] == (u8) ~buf[13]) {
1235                                 /* NEC */
1236                                 state->rc_keycode = RC_SCANCODE_NEC(buf[12],
1237                                                                     buf[14]);
1238                         } else {
1239                                 /* NEC extended*/
1240                                 state->rc_keycode = RC_SCANCODE_NECX(buf[12] << 8 |
1241                                                                      buf[13],
1242                                                                      buf[14]);
1243                         }
1244                 } else {
1245                         /* 32 bit NEC */
1246                         state->rc_keycode = RC_SCANCODE_NEC32(buf[12] << 24 |
1247                                                               buf[13] << 16 |
1248                                                               buf[14] << 8  |
1249                                                               buf[15]);
1250                 }
1251                 rc_keydown(d->rc_dev, RC_TYPE_NEC, state->rc_keycode, 0);
1252         } else {
1253                 dev_dbg(&d->udev->dev, "%s: no key press\n", __func__);
1254                 /* Invalidate last keypress */
1255                 /* Not really needed, but helps with debug */
1256                 state->rc_last[2] = state->rc_last[3];
1257         }
1258
1259         state->rc_repeat = buf[6];
1260         state->rc_failed = false;
1261
1262 error:
1263         if (ret) {
1264                 dev_warn(&d->udev->dev, "%s: rc query failed=%d\n",
1265                                 KBUILD_MODNAME, ret);
1266
1267                 /* allow random errors as dvb-usb will stop polling on error */
1268                 if (!state->rc_failed)
1269                         ret = 0;
1270
1271                 state->rc_failed = true;
1272         }
1273
1274         return ret;
1275 }
1276
1277 static int af9015_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc)
1278 {
1279         struct af9015_state *state = d_to_priv(d);
1280         u16 vid = le16_to_cpu(d->udev->descriptor.idVendor);
1281
1282         if (state->ir_mode == AF9015_IR_MODE_DISABLED)
1283                 return 0;
1284
1285         /* try to load remote based module param */
1286         if (!rc->map_name)
1287                 rc->map_name = af9015_rc_setup_match(dvb_usb_af9015_remote,
1288                                 af9015_rc_setup_modparam);
1289
1290         /* try to load remote based eeprom hash */
1291         if (!rc->map_name)
1292                 rc->map_name = af9015_rc_setup_match(state->eeprom_sum,
1293                                 af9015_rc_setup_hashes);
1294
1295         /* try to load remote based USB iManufacturer string */
1296         if (!rc->map_name && vid == USB_VID_AFATECH) {
1297                 /* Check USB manufacturer and product strings and try
1298                    to determine correct remote in case of chip vendor
1299                    reference IDs are used.
1300                    DO NOT ADD ANYTHING NEW HERE. Use hashes instead. */
1301                 char manufacturer[10];
1302                 memset(manufacturer, 0, sizeof(manufacturer));
1303                 usb_string(d->udev, d->udev->descriptor.iManufacturer,
1304                         manufacturer, sizeof(manufacturer));
1305                 if (!strcmp("MSI", manufacturer)) {
1306                         /* iManufacturer 1 MSI
1307                            iProduct      2 MSI K-VOX */
1308                         rc->map_name = af9015_rc_setup_match(
1309                                         AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3,
1310                                         af9015_rc_setup_modparam);
1311                 }
1312         }
1313
1314         /* load empty to enable rc */
1315         if (!rc->map_name)
1316                 rc->map_name = RC_MAP_EMPTY;
1317
1318         rc->allowed_protos = RC_BIT_NEC;
1319         rc->query = af9015_rc_query;
1320         rc->interval = 500;
1321
1322         return 0;
1323 }
1324 #else
1325         #define af9015_get_rc_config NULL
1326 #endif
1327
1328 static int af9015_probe(struct usb_interface *intf,
1329                 const struct usb_device_id *id)
1330 {
1331         struct usb_device *udev = interface_to_usbdev(intf);
1332         char manufacturer[sizeof("ITE Technologies, Inc.")];
1333
1334         memset(manufacturer, 0, sizeof(manufacturer));
1335         usb_string(udev, udev->descriptor.iManufacturer,
1336                         manufacturer, sizeof(manufacturer));
1337         /*
1338          * There is two devices having same ID but different chipset. One uses
1339          * AF9015 and the other IT9135 chipset. Only difference seen on lsusb
1340          * is iManufacturer string.
1341          *
1342          * idVendor           0x0ccd TerraTec Electronic GmbH
1343          * idProduct          0x0099
1344          * bcdDevice            2.00
1345          * iManufacturer           1 Afatech
1346          * iProduct                2 DVB-T 2
1347          *
1348          * idVendor           0x0ccd TerraTec Electronic GmbH
1349          * idProduct          0x0099
1350          * bcdDevice            2.00
1351          * iManufacturer           1 ITE Technologies, Inc.
1352          * iProduct                2 DVB-T TV Stick
1353          */
1354         if ((le16_to_cpu(udev->descriptor.idVendor) == USB_VID_TERRATEC) &&
1355                         (le16_to_cpu(udev->descriptor.idProduct) == 0x0099)) {
1356                 if (!strcmp("ITE Technologies, Inc.", manufacturer)) {
1357                         dev_dbg(&udev->dev, "%s: rejecting device\n", __func__);
1358                         return -ENODEV;
1359                 }
1360         }
1361
1362         return dvb_usbv2_probe(intf, id);
1363 }
1364
1365 /* interface 0 is used by DVB-T receiver and
1366    interface 1 is for remote controller (HID) */
1367 static struct dvb_usb_device_properties af9015_props = {
1368         .driver_name = KBUILD_MODNAME,
1369         .owner = THIS_MODULE,
1370         .adapter_nr = adapter_nr,
1371         .size_of_priv = sizeof(struct af9015_state),
1372
1373         .generic_bulk_ctrl_endpoint = 0x02,
1374         .generic_bulk_ctrl_endpoint_response = 0x81,
1375
1376         .identify_state = af9015_identify_state,
1377         .firmware = AF9015_FIRMWARE,
1378         .download_firmware = af9015_download_firmware,
1379
1380         .i2c_algo = &af9015_i2c_algo,
1381         .read_config = af9015_read_config,
1382         .frontend_attach = af9015_af9013_frontend_attach,
1383         .tuner_attach = af9015_tuner_attach,
1384         .init = af9015_init,
1385         .get_rc_config = af9015_get_rc_config,
1386         .get_stream_config = af9015_get_stream_config,
1387
1388         .get_adapter_count = af9015_get_adapter_count,
1389         .adapter = {
1390                 {
1391                         .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1392                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1393                         .pid_filter_count = 32,
1394                         .pid_filter = af9015_pid_filter,
1395                         .pid_filter_ctrl = af9015_pid_filter_ctrl,
1396
1397                         .stream = DVB_USB_STREAM_BULK(0x84, 8, TS_USB20_FRAME_SIZE),
1398                 }, {
1399                         .stream = DVB_USB_STREAM_BULK(0x85, 8, TS_USB20_FRAME_SIZE),
1400                 },
1401         },
1402 };
1403
1404 static const struct usb_device_id af9015_id_table[] = {
1405         { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9015,
1406                 &af9015_props, "Afatech AF9015 reference design", NULL) },
1407         { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9016,
1408                 &af9015_props, "Afatech AF9015 reference design", NULL) },
1409         { DVB_USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_GOLD,
1410                 &af9015_props, "Leadtek WinFast DTV Dongle Gold", RC_MAP_LEADTEK_Y04G0051) },
1411         { DVB_USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV71E,
1412                 &af9015_props, "Pinnacle PCTV 71e", NULL) },
1413         { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U,
1414                 &af9015_props, "KWorld PlusTV Dual DVB-T Stick (DVB-T 399U)", NULL) },
1415         { DVB_USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TINYTWIN,
1416                 &af9015_props, "DigitalNow TinyTwin", RC_MAP_AZUREWAVE_AD_TU700) },
1417         { DVB_USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_AZUREWAVE_AD_TU700,
1418                 &af9015_props, "TwinHan AzureWave AD-TU700(704J)", RC_MAP_AZUREWAVE_AD_TU700) },
1419         { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2,
1420                 &af9015_props, "TerraTec Cinergy T USB XE", NULL) },
1421         { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_2T,
1422                 &af9015_props, "KWorld PlusTV Dual DVB-T PCI (DVB-T PC160-2T)", NULL) },
1423         { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X,
1424                 &af9015_props, "AVerMedia AVerTV DVB-T Volar X", RC_MAP_AVERMEDIA_M135A) },
1425         { DVB_USB_DEVICE(USB_VID_XTENSIONS, USB_PID_XTENSIONS_XD_380,
1426                 &af9015_props, "Xtensions XD-380", NULL) },
1427         { DVB_USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGIVOX_DUO,
1428                 &af9015_props, "MSI DIGIVOX Duo", RC_MAP_MSI_DIGIVOX_III) },
1429         { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X_2,
1430                 &af9015_props, "Fujitsu-Siemens Slim Mobile USB DVB-T", NULL) },
1431         { DVB_USB_DEVICE(USB_VID_TELESTAR,  USB_PID_TELESTAR_STARSTICK_2,
1432                 &af9015_props, "Telestar Starstick 2", NULL) },
1433         { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A309,
1434                 &af9015_props, "AVerMedia A309", NULL) },
1435         { DVB_USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGI_VOX_MINI_III,
1436                 &af9015_props, "MSI Digi VOX mini III", RC_MAP_MSI_DIGIVOX_III) },
1437         { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U,
1438                 &af9015_props, "KWorld USB DVB-T TV Stick II (VS-DVB-T 395U)", NULL) },
1439         { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_2,
1440                 &af9015_props, "KWorld USB DVB-T TV Stick II (VS-DVB-T 395U)", NULL) },
1441         { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_3,
1442                 &af9015_props, "KWorld USB DVB-T TV Stick II (VS-DVB-T 395U)", NULL) },
1443         { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_TREKSTOR_DVBT,
1444                 &af9015_props, "TrekStor DVB-T USB Stick", RC_MAP_TREKSTOR) },
1445         { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850,
1446                 &af9015_props, "AverMedia AVerTV Volar Black HD (A850)", NULL) },
1447         { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A805,
1448                 &af9015_props, "AverMedia AVerTV Volar GPS 805 (A805)", NULL) },
1449         { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_CONCEPTRONIC_CTVDIGRCU,
1450                 &af9015_props, "Conceptronic USB2.0 DVB-T CTVDIGRCU V3.0", NULL) },
1451         { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_MC810,
1452                 &af9015_props, "KWorld Digial MC-810", NULL) },
1453         { DVB_USB_DEVICE(USB_VID_KYE, USB_PID_GENIUS_TVGO_DVB_T03,
1454                 &af9015_props, "Genius TVGo DVB-T03", NULL) },
1455         { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U_2,
1456                 &af9015_props, "KWorld PlusTV Dual DVB-T Stick (DVB-T 399U)", NULL) },
1457         { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_T,
1458                 &af9015_props, "KWorld PlusTV DVB-T PCI Pro Card (DVB-T PC160-T)", NULL) },
1459         { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV20,
1460                 &af9015_props, "Sveon STV20 Tuner USB DVB-T HDTV", NULL) },
1461         { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_TINYTWIN_2,
1462                 &af9015_props, "DigitalNow TinyTwin v2", RC_MAP_DIGITALNOW_TINYTWIN) },
1463         { DVB_USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV2000DS,
1464                 &af9015_props, "Leadtek WinFast DTV2000DS", RC_MAP_LEADTEK_Y04G0051) },
1465         { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_UB383_T,
1466                 &af9015_props, "KWorld USB DVB-T Stick Mobile (UB383-T)", NULL) },
1467         { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_4,
1468                 &af9015_props, "KWorld USB DVB-T TV Stick II (VS-DVB-T 395U)", NULL) },
1469         { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A815M,
1470                 &af9015_props, "AverMedia AVerTV Volar M (A815Mac)", NULL) },
1471         { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_STICK_RC,
1472                 &af9015_props, "TerraTec Cinergy T Stick RC", RC_MAP_TERRATEC_SLIM_2) },
1473         /* XXX: that same ID [0ccd:0099] is used by af9035 driver too */
1474         { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_STICK_DUAL_RC,
1475                 &af9015_props, "TerraTec Cinergy T Stick Dual RC", RC_MAP_TERRATEC_SLIM) },
1476         { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850T,
1477                 &af9015_props, "AverMedia AVerTV Red HD+ (A850T)", NULL) },
1478         { DVB_USB_DEVICE(USB_VID_GTEK, USB_PID_TINYTWIN_3,
1479                 &af9015_props, "DigitalNow TinyTwin v3", RC_MAP_DIGITALNOW_TINYTWIN) },
1480         { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV22,
1481                 &af9015_props, "Sveon STV22 Dual USB DVB-T Tuner HDTV", RC_MAP_MSI_DIGIVOX_III) },
1482         { }
1483 };
1484 MODULE_DEVICE_TABLE(usb, af9015_id_table);
1485
1486 /* usb specific object needed to register this driver with the usb subsystem */
1487 static struct usb_driver af9015_usb_driver = {
1488         .name = KBUILD_MODNAME,
1489         .id_table = af9015_id_table,
1490         .probe = af9015_probe,
1491         .disconnect = dvb_usbv2_disconnect,
1492         .suspend = dvb_usbv2_suspend,
1493         .resume = dvb_usbv2_resume,
1494         .reset_resume = dvb_usbv2_reset_resume,
1495         .no_dynamic_id = 1,
1496         .soft_unbind = 1,
1497 };
1498
1499 module_usb_driver(af9015_usb_driver);
1500
1501 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1502 MODULE_DESCRIPTION("Afatech AF9015 driver");
1503 MODULE_LICENSE("GPL");
1504 MODULE_FIRMWARE(AF9015_FIRMWARE);