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

   1 /*
   2  * Afatech AF9035 DVB USB driver
   3  *
   4  * Copyright (C) 2009 Antti Palosaari <crope@iki.fi>
   5  * Copyright (C) 2012 Antti Palosaari <crope@iki.fi>
   6  *
   7  *    This program is free software; you can redistribute it and/or modify
   8  *    it under the terms of the GNU General Public License as published by
   9  *    the Free Software Foundation; either version 2 of the License, or
  10  *    (at your option) any later version.
  11  *
  12  *    This program is distributed in the hope that it will be useful,
  13  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *    GNU General Public License for more details.
  16  *
  17  *    You should have received a copy of the GNU General Public License along
  18  *    with this program; if not, write to the Free Software Foundation, Inc.,
  19  *    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "af9035.h"
  23
  24 /* Max transfer size done by I2C transfer functions */
  25 #define MAX_XFER_SIZE  64
  26
  27 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
  28
  29 static u16 af9035_checksum(const u8 *buf, size_t len)
  30 {
  31         size_t i;
  32         u16 checksum = 0;
  33
  34         for (i = 1; i < len; i++) {
  35                 if (i % 2)
  36                         checksum += buf[i] << 8;
  37                 else
  38                         checksum += buf[i];
  39         }
  40         checksum = ~checksum;
  41
  42         return checksum;
  43 }
  44
  45 static int af9035_ctrl_msg(struct dvb_usb_device *d, struct usb_req *req)
  46 {
  47 #define REQ_HDR_LEN 4 /* send header size */
  48 #define ACK_HDR_LEN 3 /* rece header size */
  49 #define CHECKSUM_LEN 2
  50 #define USB_TIMEOUT 2000
  51         struct state *state = d_to_priv(d);
  52         int ret, wlen, rlen;
  53         u16 checksum, tmp_checksum;
  54
  55         mutex_lock(&d->usb_mutex);
  56
  57         /* buffer overflow check */
  58         if (req->wlen > (BUF_LEN - REQ_HDR_LEN - CHECKSUM_LEN) ||
  59                         req->rlen > (BUF_LEN - ACK_HDR_LEN - CHECKSUM_LEN)) {
  60                 dev_err(&d->udev->dev, "%s: too much data wlen=%d rlen=%d\n",
  61                                 __func__, req->wlen, req->rlen);
  62                 ret = -EINVAL;
  63                 goto exit;
  64         }
  65
  66         state->buf[0] = REQ_HDR_LEN + req->wlen + CHECKSUM_LEN - 1;
  67         state->buf[1] = req->mbox;
  68         state->buf[2] = req->cmd;
  69         state->buf[3] = state->seq++;
  70         memcpy(&state->buf[REQ_HDR_LEN], req->wbuf, req->wlen);
  71
  72         wlen = REQ_HDR_LEN + req->wlen + CHECKSUM_LEN;
  73         rlen = ACK_HDR_LEN + req->rlen + CHECKSUM_LEN;
  74
  75         /* calc and add checksum */
  76         checksum = af9035_checksum(state->buf, state->buf[0] - 1);
  77         state->buf[state->buf[0] - 1] = (checksum >> 8);
  78         state->buf[state->buf[0] - 0] = (checksum & 0xff);
  79
  80         /* no ack for these packets */
  81         if (req->cmd == CMD_FW_DL)
  82                 rlen = 0;
  83
  84         ret = dvb_usbv2_generic_rw_locked(d,
  85                         state->buf, wlen, state->buf, rlen);
  86         if (ret)
  87                 goto exit;
  88
  89         /* no ack for those packets */
  90         if (req->cmd == CMD_FW_DL)
  91                 goto exit;
  92
  93         /* verify checksum */
  94         checksum = af9035_checksum(state->buf, rlen - 2);
  95         tmp_checksum = (state->buf[rlen - 2] << 8) | state->buf[rlen - 1];
  96         if (tmp_checksum != checksum) {
  97                 dev_err(&d->udev->dev, "%s: command=%02x checksum mismatch " \
  98                                 "(%04x != %04x)\n", KBUILD_MODNAME, req->cmd,
  99                                 tmp_checksum, checksum);
 100                 ret = -EIO;
 101                 goto exit;
 102         }
 103
 104         /* check status */
 105         if (state->buf[2]) {
 106                 /* fw returns status 1 when IR code was not received */
 107                 if (req->cmd == CMD_IR_GET || state->buf[2] == 1) {
 108                         ret = 1;
 109                         goto exit;
 110                 }
 111
 112                 dev_dbg(&d->udev->dev, "%s: command=%02x failed fw error=%d\n",
 113                                 __func__, req->cmd, state->buf[2]);
 114                 ret = -EIO;
 115                 goto exit;
 116         }
 117
 118         /* read request, copy returned data to return buf */
 119         if (req->rlen)
 120                 memcpy(req->rbuf, &state->buf[ACK_HDR_LEN], req->rlen);
 121 exit:
 122         mutex_unlock(&d->usb_mutex);
 123         if (ret < 0)
 124                 dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
 125         return ret;
 126 }
 127
 128 /* write multiple registers */
 129 static int af9035_wr_regs(struct dvb_usb_device *d, u32 reg, u8 *val, int len)
 130 {
 131         u8 wbuf[MAX_XFER_SIZE];
 132         u8 mbox = (reg >> 16) & 0xff;
 133         struct usb_req req = { CMD_MEM_WR, mbox, 6 + len, wbuf, 0, NULL };
 134
 135         if (6 + len > sizeof(wbuf)) {
 136                 dev_warn(&d->udev->dev, "%s: i2c wr: len=%d is too big!\n",
 137                          KBUILD_MODNAME, len);
 138                 return -EOPNOTSUPP;
 139         }
 140
 141         wbuf[0] = len;
 142         wbuf[1] = 2;
 143         wbuf[2] = 0;
 144         wbuf[3] = 0;
 145         wbuf[4] = (reg >> 8) & 0xff;
 146         wbuf[5] = (reg >> 0) & 0xff;
 147         memcpy(&wbuf[6], val, len);
 148
 149         return af9035_ctrl_msg(d, &req);
 150 }
 151
 152 /* read multiple registers */
 153 static int af9035_rd_regs(struct dvb_usb_device *d, u32 reg, u8 *val, int len)
 154 {
 155         u8 wbuf[] = { len, 2, 0, 0, (reg >> 8) & 0xff, reg & 0xff };
 156         u8 mbox = (reg >> 16) & 0xff;
 157         struct usb_req req = { CMD_MEM_RD, mbox, sizeof(wbuf), wbuf, len, val };
 158
 159         return af9035_ctrl_msg(d, &req);
 160 }
 161
 162 /* write single register */
 163 static int af9035_wr_reg(struct dvb_usb_device *d, u32 reg, u8 val)
 164 {
 165         return af9035_wr_regs(d, reg, &val, 1);
 166 }
 167
 168 /* read single register */
 169 static int af9035_rd_reg(struct dvb_usb_device *d, u32 reg, u8 *val)
 170 {
 171         return af9035_rd_regs(d, reg, val, 1);
 172 }
 173
 174 /* write single register with mask */
 175 static int af9035_wr_reg_mask(struct dvb_usb_device *d, u32 reg, u8 val,
 176                 u8 mask)
 177 {
 178         int ret;
 179         u8 tmp;
 180
 181         /* no need for read if whole reg is written */
 182         if (mask != 0xff) {
 183                 ret = af9035_rd_regs(d, reg, &tmp, 1);
 184                 if (ret)
 185                         return ret;
 186
 187                 val &= mask;
 188                 tmp &= ~mask;
 189                 val |= tmp;
 190         }
 191
 192         return af9035_wr_regs(d, reg, &val, 1);
 193 }
 194
 195 static int af9035_i2c_master_xfer(struct i2c_adapter *adap,
 196                 struct i2c_msg msg[], int num)
 197 {
 198         struct dvb_usb_device *d = i2c_get_adapdata(adap);
 199         struct state *state = d_to_priv(d);
 200         int ret;
 201
 202         if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
 203                 return -EAGAIN;
 204
 205         /*
 206          * I2C sub header is 5 bytes long. Meaning of those bytes are:
 207          * 0: data len
 208          * 1: I2C addr << 1
 209          * 2: reg addr len
 210          *    byte 3 and 4 can be used as reg addr
 211          * 3: reg addr MSB
 212          *    used when reg addr len is set to 2
 213          * 4: reg addr LSB
 214          *    used when reg addr len is set to 1 or 2
 215          *
 216          * For the simplify we do not use register addr at all.
 217          * NOTE: As a firmware knows tuner type there is very small possibility
 218          * there could be some tuner I2C hacks done by firmware and this may
 219          * lead problems if firmware expects those bytes are used.
 220          */
 221         if (num == 2 && !(msg[0].flags & I2C_M_RD) &&
 222                         (msg[1].flags & I2C_M_RD)) {
 223                 if (msg[0].len > 40 || msg[1].len > 40) {
 224                         /* TODO: correct limits > 40 */
 225                         ret = -EOPNOTSUPP;
 226                 } else if ((msg[0].addr == state->af9033_config[0].i2c_addr) ||
 227                            (msg[0].addr == state->af9033_config[1].i2c_addr)) {
 228                         /* demod access via firmware interface */
 229                         u32 reg = msg[0].buf[0] << 16 | msg[0].buf[1] << 8 |
 230                                         msg[0].buf[2];
 231
 232                         if (msg[0].addr == state->af9033_config[1].i2c_addr)
 233                                 reg |= 0x100000;
 234
 235                         ret = af9035_rd_regs(d, reg, &msg[1].buf[0],
 236                                         msg[1].len);
 237                 } else {
 238                         /* I2C */
 239                         u8 buf[MAX_XFER_SIZE];
 240                         struct usb_req req = { CMD_I2C_RD, 0, 5 + msg[0].len,
 241                                         buf, msg[1].len, msg[1].buf };
 242
 243                         if (5 + msg[0].len > sizeof(buf)) {
 244                                 dev_warn(&d->udev->dev,
 245                                          "%s: i2c xfer: len=%d is too big!\n",
 246                                          KBUILD_MODNAME, msg[0].len);
 247                                 ret = -EOPNOTSUPP;
 248                                 goto unlock;
 249                         }
 250                         req.mbox |= ((msg[0].addr & 0x80)  >>  3);
 251                         buf[0] = msg[1].len;
 252                         buf[1] = msg[0].addr << 1;
 253                         buf[2] = 0x00; /* reg addr len */
 254                         buf[3] = 0x00; /* reg addr MSB */
 255                         buf[4] = 0x00; /* reg addr LSB */
 256                         memcpy(&buf[5], msg[0].buf, msg[0].len);
 257                         ret = af9035_ctrl_msg(d, &req);
 258                 }
 259         } else if (num == 1 && !(msg[0].flags & I2C_M_RD)) {
 260                 if (msg[0].len > 40) {
 261                         /* TODO: correct limits > 40 */
 262                         ret = -EOPNOTSUPP;
 263                 } else if ((msg[0].addr == state->af9033_config[0].i2c_addr) ||
 264                            (msg[0].addr == state->af9033_config[1].i2c_addr)) {
 265                         /* demod access via firmware interface */
 266                         u32 reg = msg[0].buf[0] << 16 | msg[0].buf[1] << 8 |
 267                                         msg[0].buf[2];
 268
 269                         if (msg[0].addr == state->af9033_config[1].i2c_addr)
 270                                 reg |= 0x100000;
 271
 272                         ret = af9035_wr_regs(d, reg, &msg[0].buf[3],
 273                                         msg[0].len - 3);
 274                 } else {
 275                         /* I2C */
 276                         u8 buf[MAX_XFER_SIZE];
 277                         struct usb_req req = { CMD_I2C_WR, 0, 5 + msg[0].len,
 278                                         buf, 0, NULL };
 279
 280                         if (5 + msg[0].len > sizeof(buf)) {
 281                                 dev_warn(&d->udev->dev,
 282                                          "%s: i2c xfer: len=%d is too big!\n",
 283                                          KBUILD_MODNAME, msg[0].len);
 284                                 ret = -EOPNOTSUPP;
 285                                 goto unlock;
 286                         }
 287                         req.mbox |= ((msg[0].addr & 0x80)  >>  3);
 288                         buf[0] = msg[0].len;
 289                         buf[1] = msg[0].addr << 1;
 290                         buf[2] = 0x00; /* reg addr len */
 291                         buf[3] = 0x00; /* reg addr MSB */
 292                         buf[4] = 0x00; /* reg addr LSB */
 293                         memcpy(&buf[5], msg[0].buf, msg[0].len);
 294                         ret = af9035_ctrl_msg(d, &req);
 295                 }
 296         } else {
 297                 /*
 298                  * We support only two kind of I2C transactions:
 299                  * 1) 1 x read + 1 x write
 300                  * 2) 1 x write
 301                  */
 302                 ret = -EOPNOTSUPP;
 303         }
 304
 305 unlock:
 306         mutex_unlock(&d->i2c_mutex);
 307
 308         if (ret < 0)
 309                 return ret;
 310         else
 311                 return num;
 312 }
 313
 314 static u32 af9035_i2c_functionality(struct i2c_adapter *adapter)
 315 {
 316         return I2C_FUNC_I2C;
 317 }
 318
 319 static struct i2c_algorithm af9035_i2c_algo = {
 320         .master_xfer = af9035_i2c_master_xfer,
 321         .functionality = af9035_i2c_functionality,
 322 };
 323
 324 static int af9035_identify_state(struct dvb_usb_device *d, const char **name)
 325 {
 326         struct state *state = d_to_priv(d);
 327         int ret;
 328         u8 wbuf[1] = { 1 };
 329         u8 rbuf[4];
 330         struct usb_req req = { CMD_FW_QUERYINFO, 0, sizeof(wbuf), wbuf,
 331                         sizeof(rbuf), rbuf };
 332
 333         ret = af9035_rd_regs(d, 0x1222, rbuf, 3);
 334         if (ret < 0)
 335                 goto err;
 336
 337         state->chip_version = rbuf[0];
 338         state->chip_type = rbuf[2] << 8 | rbuf[1] << 0;
 339
 340         ret = af9035_rd_reg(d, 0x384f, &state->prechip_version);
 341         if (ret < 0)
 342                 goto err;
 343
 344         dev_info(&d->udev->dev,
 345                         "%s: prechip_version=%02x chip_version=%02x chip_type=%04x\n",
 346                         __func__, state->prechip_version, state->chip_version,
 347                         state->chip_type);
 348
 349         if (state->chip_type == 0x9135) {
 350                 if (state->chip_version == 0x02)
 351                         *name = AF9035_FIRMWARE_IT9135_V2;
 352                 else
 353                         *name = AF9035_FIRMWARE_IT9135_V1;
 354                 state->eeprom_addr = EEPROM_BASE_IT9135;
 355         } else {
 356                 *name = AF9035_FIRMWARE_AF9035;
 357                 state->eeprom_addr = EEPROM_BASE_AF9035;
 358         }
 359
 360         ret = af9035_ctrl_msg(d, &req);
 361         if (ret < 0)
 362                 goto err;
 363
 364         dev_dbg(&d->udev->dev, "%s: reply=%*ph\n", __func__, 4, rbuf);
 365         if (rbuf[0] || rbuf[1] || rbuf[2] || rbuf[3])
 366                 ret = WARM;
 367         else
 368                 ret = COLD;
 369
 370         return ret;
 371
 372 err:
 373         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
 374
 375         return ret;
 376 }
 377
 378 static int af9035_download_firmware_old(struct dvb_usb_device *d,
 379                 const struct firmware *fw)
 380 {
 381         int ret, i, j, len;
 382         u8 wbuf[1];
 383         struct usb_req req = { 0, 0, 0, NULL, 0, NULL };
 384         struct usb_req req_fw_dl = { CMD_FW_DL, 0, 0, wbuf, 0, NULL };
 385         u8 hdr_core;
 386         u16 hdr_addr, hdr_data_len, hdr_checksum;
 387         #define MAX_DATA 58
 388         #define HDR_SIZE 7
 389
 390         /*
 391          * Thanks to Daniel Glöckner <daniel-gl@gmx.net> about that info!
 392          *
 393          * byte 0: MCS 51 core
 394          *  There are two inside the AF9035 (1=Link and 2=OFDM) with separate
 395          *  address spaces
 396          * byte 1-2: Big endian destination address
 397          * byte 3-4: Big endian number of data bytes following the header
 398          * byte 5-6: Big endian header checksum, apparently ignored by the chip
 399          *  Calculated as ~(h[0]*256+h[1]+h[2]*256+h[3]+h[4]*256)
 400          */
 401
 402         for (i = fw->size; i > HDR_SIZE;) {
 403                 hdr_core = fw->data[fw->size - i + 0];
 404                 hdr_addr = fw->data[fw->size - i + 1] << 8;
 405                 hdr_addr |= fw->data[fw->size - i + 2] << 0;
 406                 hdr_data_len = fw->data[fw->size - i + 3] << 8;
 407                 hdr_data_len |= fw->data[fw->size - i + 4] << 0;
 408                 hdr_checksum = fw->data[fw->size - i + 5] << 8;
 409                 hdr_checksum |= fw->data[fw->size - i + 6] << 0;
 410
 411                 dev_dbg(&d->udev->dev, "%s: core=%d addr=%04x data_len=%d " \
 412                                 "checksum=%04x\n", __func__, hdr_core, hdr_addr,
 413                                 hdr_data_len, hdr_checksum);
 414
 415                 if (((hdr_core != 1) && (hdr_core != 2)) ||
 416                                 (hdr_data_len > i)) {
 417                         dev_dbg(&d->udev->dev, "%s: bad firmware\n", __func__);
 418                         break;
 419                 }
 420
 421                 /* download begin packet */
 422                 req.cmd = CMD_FW_DL_BEGIN;
 423                 ret = af9035_ctrl_msg(d, &req);
 424                 if (ret < 0)
 425                         goto err;
 426
 427                 /* download firmware packet(s) */
 428                 for (j = HDR_SIZE + hdr_data_len; j > 0; j -= MAX_DATA) {
 429                         len = j;
 430                         if (len > MAX_DATA)
 431                                 len = MAX_DATA;
 432                         req_fw_dl.wlen = len;
 433                         req_fw_dl.wbuf = (u8 *) &fw->data[fw->size - i +
 434                                         HDR_SIZE + hdr_data_len - j];
 435                         ret = af9035_ctrl_msg(d, &req_fw_dl);
 436                         if (ret < 0)
 437                                 goto err;
 438                 }
 439
 440                 /* download end packet */
 441                 req.cmd = CMD_FW_DL_END;
 442                 ret = af9035_ctrl_msg(d, &req);
 443                 if (ret < 0)
 444                         goto err;
 445
 446                 i -= hdr_data_len + HDR_SIZE;
 447
 448                 dev_dbg(&d->udev->dev, "%s: data uploaded=%zu\n",
 449                                 __func__, fw->size - i);
 450         }
 451
 452         /* print warn if firmware is bad, continue and see what happens */
 453         if (i)
 454                 dev_warn(&d->udev->dev, "%s: bad firmware\n", KBUILD_MODNAME);
 455
 456         return 0;
 457
 458 err:
 459         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
 460
 461         return ret;
 462 }
 463
 464 static int af9035_download_firmware_new(struct dvb_usb_device *d,
 465                 const struct firmware *fw)
 466 {
 467         int ret, i, i_prev;
 468         struct usb_req req_fw_dl = { CMD_FW_SCATTER_WR, 0, 0, NULL, 0, NULL };
 469         #define HDR_SIZE 7
 470
 471         /*
 472          * There seems to be following firmware header. Meaning of bytes 0-3
 473          * is unknown.
 474          *
 475          * 0: 3
 476          * 1: 0, 1
 477          * 2: 0
 478          * 3: 1, 2, 3
 479          * 4: addr MSB
 480          * 5: addr LSB
 481          * 6: count of data bytes ?
 482          */
 483         for (i = HDR_SIZE, i_prev = 0; i <= fw->size; i++) {
 484                 if (i == fw->size ||
 485                                 (fw->data[i + 0] == 0x03 &&
 486                                 (fw->data[i + 1] == 0x00 ||
 487                                 fw->data[i + 1] == 0x01) &&
 488                                 fw->data[i + 2] == 0x00)) {
 489                         req_fw_dl.wlen = i - i_prev;
 490                         req_fw_dl.wbuf = (u8 *) &fw->data[i_prev];
 491                         i_prev = i;
 492                         ret = af9035_ctrl_msg(d, &req_fw_dl);
 493                         if (ret < 0)
 494                                 goto err;
 495
 496                         dev_dbg(&d->udev->dev, "%s: data uploaded=%d\n",
 497                                         __func__, i);
 498                 }
 499         }
 500
 501         return 0;
 502
 503 err:
 504         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
 505
 506         return ret;
 507 }
 508
 509 static int af9035_download_firmware(struct dvb_usb_device *d,
 510                 const struct firmware *fw)
 511 {
 512         struct state *state = d_to_priv(d);
 513         int ret;
 514         u8 wbuf[1];
 515         u8 rbuf[4];
 516         u8 tmp;
 517         struct usb_req req = { 0, 0, 0, NULL, 0, NULL };
 518         struct usb_req req_fw_ver = { CMD_FW_QUERYINFO, 0, 1, wbuf, 4, rbuf } ;
 519         dev_dbg(&d->udev->dev, "%s:\n", __func__);
 520
 521         /*
 522          * In case of dual tuner configuration we need to do some extra
 523          * initialization in order to download firmware to slave demod too,
 524          * which is done by master demod.
 525          * Master feeds also clock and controls power via GPIO.
 526          */
 527         ret = af9035_rd_reg(d, state->eeprom_addr + EEPROM_DUAL_MODE, &tmp);
 528         if (ret < 0)
 529                 goto err;
 530
 531         if (tmp) {
 532                 /* configure gpioh1, reset & power slave demod */
 533                 ret = af9035_wr_reg_mask(d, 0x00d8b0, 0x01, 0x01);
 534                 if (ret < 0)
 535                         goto err;
 536
 537                 ret = af9035_wr_reg_mask(d, 0x00d8b1, 0x01, 0x01);
 538                 if (ret < 0)
 539                         goto err;
 540
 541                 ret = af9035_wr_reg_mask(d, 0x00d8af, 0x00, 0x01);
 542                 if (ret < 0)
 543                         goto err;
 544
 545                 usleep_range(10000, 50000);
 546
 547                 ret = af9035_wr_reg_mask(d, 0x00d8af, 0x01, 0x01);
 548                 if (ret < 0)
 549                         goto err;
 550
 551                 /* tell the slave I2C address */
 552                 ret = af9035_rd_reg(d,
 553                                 state->eeprom_addr + EEPROM_2ND_DEMOD_ADDR,
 554                                 &tmp);
 555                 if (ret < 0)
 556                         goto err;
 557
 558                 if (state->chip_type == 0x9135) {
 559                         ret = af9035_wr_reg(d, 0x004bfb, tmp);
 560                         if (ret < 0)
 561                                 goto err;
 562                 } else {
 563                         ret = af9035_wr_reg(d, 0x00417f, tmp);
 564                         if (ret < 0)
 565                                 goto err;
 566
 567                         /* enable clock out */
 568                         ret = af9035_wr_reg_mask(d, 0x00d81a, 0x01, 0x01);
 569                         if (ret < 0)
 570                                 goto err;
 571                 }
 572         }
 573
 574         if (fw->data[0] == 0x01)
 575                 ret = af9035_download_firmware_old(d, fw);
 576         else
 577                 ret = af9035_download_firmware_new(d, fw);
 578         if (ret < 0)
 579                 goto err;
 580
 581         /* firmware loaded, request boot */
 582         req.cmd = CMD_FW_BOOT;
 583         ret = af9035_ctrl_msg(d, &req);
 584         if (ret < 0)
 585                 goto err;
 586
 587         /* ensure firmware starts */
 588         wbuf[0] = 1;
 589         ret = af9035_ctrl_msg(d, &req_fw_ver);
 590         if (ret < 0)
 591                 goto err;
 592
 593         if (!(rbuf[0] || rbuf[1] || rbuf[2] || rbuf[3])) {
 594                 dev_err(&d->udev->dev, "%s: firmware did not run\n",
 595                                 KBUILD_MODNAME);
 596                 ret = -ENODEV;
 597                 goto err;
 598         }
 599
 600         dev_info(&d->udev->dev, "%s: firmware version=%d.%d.%d.%d",
 601                         KBUILD_MODNAME, rbuf[0], rbuf[1], rbuf[2], rbuf[3]);
 602
 603         return 0;
 604
 605 err:
 606         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
 607
 608         return ret;
 609 }
 610
 611 static int af9035_read_config(struct dvb_usb_device *d)
 612 {
 613         struct state *state = d_to_priv(d);
 614         int ret, i;
 615         u8 tmp;
 616         u16 tmp16, addr;
 617
 618         /* demod I2C "address" */
 619         state->af9033_config[0].i2c_addr = 0x38;
 620         state->af9033_config[0].adc_multiplier = AF9033_ADC_MULTIPLIER_2X;
 621         state->af9033_config[1].adc_multiplier = AF9033_ADC_MULTIPLIER_2X;
 622         state->af9033_config[0].ts_mode = AF9033_TS_MODE_USB;
 623         state->af9033_config[1].ts_mode = AF9033_TS_MODE_SERIAL;
 624
 625         /* eeprom memory mapped location */
 626         if (state->chip_type == 0x9135) {
 627                 if (state->chip_version == 0x02) {
 628                         state->af9033_config[0].tuner = AF9033_TUNER_IT9135_60;
 629                         state->af9033_config[1].tuner = AF9033_TUNER_IT9135_60;
 630                         tmp16 = 0x00461d;
 631                 } else {
 632                         state->af9033_config[0].tuner = AF9033_TUNER_IT9135_38;
 633                         state->af9033_config[1].tuner = AF9033_TUNER_IT9135_38;
 634                         tmp16 = 0x00461b;
 635                 }
 636
 637                 /* check if eeprom exists */
 638                 ret = af9035_rd_reg(d, tmp16, &tmp);
 639                 if (ret < 0)
 640                         goto err;
 641
 642                 if (tmp == 0x00) {
 643                         dev_dbg(&d->udev->dev, "%s: no eeprom\n", __func__);
 644                         goto skip_eeprom;
 645                 }
 646         }
 647
 648         /* check if there is dual tuners */
 649         ret = af9035_rd_reg(d, state->eeprom_addr + EEPROM_DUAL_MODE, &tmp);
 650         if (ret < 0)
 651                 goto err;
 652
 653         state->dual_mode = tmp;
 654         dev_dbg(&d->udev->dev, "%s: dual mode=%d\n", __func__,
 655                         state->dual_mode);
 656
 657         if (state->dual_mode) {
 658                 /* read 2nd demodulator I2C address */
 659                 ret = af9035_rd_reg(d,
 660                                 state->eeprom_addr + EEPROM_2ND_DEMOD_ADDR,
 661                                 &tmp);
 662                 if (ret < 0)
 663                         goto err;
 664
 665                 state->af9033_config[1].i2c_addr = tmp;
 666                 dev_dbg(&d->udev->dev, "%s: 2nd demod I2C addr=%02x\n",
 667                                 __func__, tmp);
 668         }
 669
 670         addr = state->eeprom_addr;
 671
 672         for (i = 0; i < state->dual_mode + 1; i++) {
 673                 /* tuner */
 674                 ret = af9035_rd_reg(d, addr + EEPROM_1_TUNER_ID, &tmp);
 675                 if (ret < 0)
 676                         goto err;
 677
 678                 if (tmp == 0x00)
 679                         dev_dbg(&d->udev->dev,
 680                                         "%s: [%d]tuner not set, using default\n",
 681                                         __func__, i);
 682                 else
 683                         state->af9033_config[i].tuner = tmp;
 684
 685                 dev_dbg(&d->udev->dev, "%s: [%d]tuner=%02x\n",
 686                                 __func__, i, state->af9033_config[i].tuner);
 687
 688                 switch (state->af9033_config[i].tuner) {
 689                 case AF9033_TUNER_TUA9001:
 690                 case AF9033_TUNER_FC0011:
 691                 case AF9033_TUNER_MXL5007T:
 692                 case AF9033_TUNER_TDA18218:
 693                 case AF9033_TUNER_FC2580:
 694                 case AF9033_TUNER_FC0012:
 695                         state->af9033_config[i].spec_inv = 1;
 696                         break;
 697                 case AF9033_TUNER_IT9135_38:
 698                 case AF9033_TUNER_IT9135_51:
 699                 case AF9033_TUNER_IT9135_52:
 700                 case AF9033_TUNER_IT9135_60:
 701                 case AF9033_TUNER_IT9135_61:
 702                 case AF9033_TUNER_IT9135_62:
 703                         break;
 704                 default:
 705                         dev_warn(&d->udev->dev,
 706                                         "%s: tuner id=%02x not supported, please report!",
 707                                         KBUILD_MODNAME, tmp);
 708                 }
 709
 710                 /* disable dual mode if driver does not support it */
 711                 if (i == 1)
 712                         switch (state->af9033_config[i].tuner) {
 713                         case AF9033_TUNER_FC0012:
 714                         case AF9033_TUNER_IT9135_38:
 715                         case AF9033_TUNER_IT9135_51:
 716                         case AF9033_TUNER_IT9135_52:
 717                         case AF9033_TUNER_IT9135_60:
 718                         case AF9033_TUNER_IT9135_61:
 719                         case AF9033_TUNER_IT9135_62:
 720                         case AF9033_TUNER_MXL5007T:
 721                                 break;
 722                         default:
 723                                 state->dual_mode = false;
 724                                 dev_info(&d->udev->dev,
 725                                                 "%s: driver does not support 2nd tuner and will disable it",
 726                                                 KBUILD_MODNAME);
 727                 }
 728
 729                 /* tuner IF frequency */
 730                 ret = af9035_rd_reg(d, addr + EEPROM_1_IF_L, &tmp);
 731                 if (ret < 0)
 732                         goto err;
 733
 734                 tmp16 = tmp;
 735
 736                 ret = af9035_rd_reg(d, addr + EEPROM_1_IF_H, &tmp);
 737                 if (ret < 0)
 738                         goto err;
 739
 740                 tmp16 |= tmp << 8;
 741
 742                 dev_dbg(&d->udev->dev, "%s: [%d]IF=%d\n", __func__, i, tmp16);
 743
 744                 addr += 0x10; /* shift for the 2nd tuner params */
 745         }
 746
 747 skip_eeprom:
 748         /* get demod clock */
 749         ret = af9035_rd_reg(d, 0x00d800, &tmp);
 750         if (ret < 0)
 751                 goto err;
 752
 753         tmp = (tmp >> 0) & 0x0f;
 754
 755         for (i = 0; i < ARRAY_SIZE(state->af9033_config); i++) {
 756                 if (state->chip_type == 0x9135)
 757                         state->af9033_config[i].clock = clock_lut_it9135[tmp];
 758                 else
 759                         state->af9033_config[i].clock = clock_lut_af9035[tmp];
 760         }
 761
 762         return 0;
 763
 764 err:
 765         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
 766
 767         return ret;
 768 }
 769
 770 static int af9035_tua9001_tuner_callback(struct dvb_usb_device *d,
 771                 int cmd, int arg)
 772 {
 773         int ret;
 774         u8 val;
 775
 776         dev_dbg(&d->udev->dev, "%s: cmd=%d arg=%d\n", __func__, cmd, arg);
 777
 778         /*
 779          * CEN     always enabled by hardware wiring
 780          * RESETN  GPIOT3
 781          * RXEN    GPIOT2
 782          */
 783
 784         switch (cmd) {
 785         case TUA9001_CMD_RESETN:
 786                 if (arg)
 787                         val = 0x00;
 788                 else
 789                         val = 0x01;
 790
 791                 ret = af9035_wr_reg_mask(d, 0x00d8e7, val, 0x01);
 792                 if (ret < 0)
 793                         goto err;
 794                 break;
 795         case TUA9001_CMD_RXEN:
 796                 if (arg)
 797                         val = 0x01;
 798                 else
 799                         val = 0x00;
 800
 801                 ret = af9035_wr_reg_mask(d, 0x00d8eb, val, 0x01);
 802                 if (ret < 0)
 803                         goto err;
 804                 break;
 805         }
 806
 807         return 0;
 808
 809 err:
 810         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
 811
 812         return ret;
 813 }
 814
 815
 816 static int af9035_fc0011_tuner_callback(struct dvb_usb_device *d,
 817                 int cmd, int arg)
 818 {
 819         int ret;
 820
 821         switch (cmd) {
 822         case FC0011_FE_CALLBACK_POWER:
 823                 /* Tuner enable */
 824                 ret = af9035_wr_reg_mask(d, 0xd8eb, 1, 1);
 825                 if (ret < 0)
 826                         goto err;
 827
 828                 ret = af9035_wr_reg_mask(d, 0xd8ec, 1, 1);
 829                 if (ret < 0)
 830                         goto err;
 831
 832                 ret = af9035_wr_reg_mask(d, 0xd8ed, 1, 1);
 833                 if (ret < 0)
 834                         goto err;
 835
 836                 /* LED */
 837                 ret = af9035_wr_reg_mask(d, 0xd8d0, 1, 1);
 838                 if (ret < 0)
 839                         goto err;
 840
 841                 ret = af9035_wr_reg_mask(d, 0xd8d1, 1, 1);
 842                 if (ret < 0)
 843                         goto err;
 844
 845                 usleep_range(10000, 50000);
 846                 break;
 847         case FC0011_FE_CALLBACK_RESET:
 848                 ret = af9035_wr_reg(d, 0xd8e9, 1);
 849                 if (ret < 0)
 850                         goto err;
 851
 852                 ret = af9035_wr_reg(d, 0xd8e8, 1);
 853                 if (ret < 0)
 854                         goto err;
 855
 856                 ret = af9035_wr_reg(d, 0xd8e7, 1);
 857                 if (ret < 0)
 858                         goto err;
 859
 860                 usleep_range(10000, 20000);
 861
 862                 ret = af9035_wr_reg(d, 0xd8e7, 0);
 863                 if (ret < 0)
 864                         goto err;
 865
 866                 usleep_range(10000, 20000);
 867                 break;
 868         default:
 869                 ret = -EINVAL;
 870                 goto err;
 871         }
 872
 873         return 0;
 874
 875 err:
 876         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
 877
 878         return ret;
 879 }
 880
 881 static int af9035_tuner_callback(struct dvb_usb_device *d, int cmd, int arg)
 882 {
 883         struct state *state = d_to_priv(d);
 884
 885         switch (state->af9033_config[0].tuner) {
 886         case AF9033_TUNER_FC0011:
 887                 return af9035_fc0011_tuner_callback(d, cmd, arg);
 888         case AF9033_TUNER_TUA9001:
 889                 return af9035_tua9001_tuner_callback(d, cmd, arg);
 890         default:
 891                 break;
 892         }
 893
 894         return 0;
 895 }
 896
 897 static int af9035_frontend_callback(void *adapter_priv, int component,
 898                                     int cmd, int arg)
 899 {
 900         struct i2c_adapter *adap = adapter_priv;
 901         struct dvb_usb_device *d = i2c_get_adapdata(adap);
 902
 903         dev_dbg(&d->udev->dev, "%s: component=%d cmd=%d arg=%d\n",
 904                         __func__, component, cmd, arg);
 905
 906         switch (component) {
 907         case DVB_FRONTEND_COMPONENT_TUNER:
 908                 return af9035_tuner_callback(d, cmd, arg);
 909         default:
 910                 break;
 911         }
 912
 913         return 0;
 914 }
 915
 916 static int af9035_get_adapter_count(struct dvb_usb_device *d)
 917 {
 918         struct state *state = d_to_priv(d);
 919
 920         /* disable 2nd adapter as we don't have PID filters implemented */
 921         if (d->udev->speed == USB_SPEED_FULL)
 922                 return 1;
 923         else
 924                 return state->dual_mode + 1;
 925 }
 926
 927 static int af9035_frontend_attach(struct dvb_usb_adapter *adap)
 928 {
 929         struct state *state = adap_to_priv(adap);
 930         struct dvb_usb_device *d = adap_to_d(adap);
 931         int ret;
 932         dev_dbg(&d->udev->dev, "%s:\n", __func__);
 933
 934         if (!state->af9033_config[adap->id].tuner) {
 935                 /* unsupported tuner */
 936                 ret = -ENODEV;
 937                 goto err;
 938         }
 939
 940         /* attach demodulator */
 941         adap->fe[0] = dvb_attach(af9033_attach, &state->af9033_config[adap->id],
 942                         &d->i2c_adap);
 943         if (adap->fe[0] == NULL) {
 944                 ret = -ENODEV;
 945                 goto err;
 946         }
 947
 948         /* disable I2C-gate */
 949         adap->fe[0]->ops.i2c_gate_ctrl = NULL;
 950         adap->fe[0]->callback = af9035_frontend_callback;
 951
 952         return 0;
 953
 954 err:
 955         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
 956
 957         return ret;
 958 }
 959
 960 static struct tua9001_config af9035_tua9001_config = {
 961         .i2c_addr = 0x60,
 962 };
 963
 964 static const struct fc0011_config af9035_fc0011_config = {
 965         .i2c_address = 0x60,
 966 };
 967
 968 static struct mxl5007t_config af9035_mxl5007t_config[] = {
 969         {
 970                 .xtal_freq_hz = MxL_XTAL_24_MHZ,
 971                 .if_freq_hz = MxL_IF_4_57_MHZ,
 972                 .invert_if = 0,
 973                 .loop_thru_enable = 0,
 974                 .clk_out_enable = 0,
 975                 .clk_out_amp = MxL_CLKOUT_AMP_0_94V,
 976         }, {
 977                 .xtal_freq_hz = MxL_XTAL_24_MHZ,
 978                 .if_freq_hz = MxL_IF_4_57_MHZ,
 979                 .invert_if = 0,
 980                 .loop_thru_enable = 1,
 981                 .clk_out_enable = 1,
 982                 .clk_out_amp = MxL_CLKOUT_AMP_0_94V,
 983         }
 984 };
 985
 986 static struct tda18218_config af9035_tda18218_config = {
 987         .i2c_address = 0x60,
 988         .i2c_wr_max = 21,
 989 };
 990
 991 static const struct fc2580_config af9035_fc2580_config = {
 992         .i2c_addr = 0x56,
 993         .clock = 16384000,
 994 };
 995
 996 static const struct fc0012_config af9035_fc0012_config[] = {
 997         {
 998                 .i2c_address = 0x63,
 999                 .xtal_freq = FC_XTAL_36_MHZ,
1000                 .dual_master = true,
1001                 .loop_through = true,
1002                 .clock_out = true,
1003         }, {
1004                 .i2c_address = 0x63 | 0x80, /* I2C bus select hack */
1005                 .xtal_freq = FC_XTAL_36_MHZ,
1006                 .dual_master = true,
1007         }
1008 };
1009
1010 static int af9035_tuner_attach(struct dvb_usb_adapter *adap)
1011 {
1012         struct state *state = adap_to_priv(adap);
1013         struct dvb_usb_device *d = adap_to_d(adap);
1014         int ret;
1015         struct dvb_frontend *fe;
1016         struct i2c_msg msg[1];
1017         u8 tuner_addr;
1018         dev_dbg(&d->udev->dev, "%s:\n", __func__);
1019
1020         /*
1021          * XXX: Hack used in that function: we abuse unused I2C address bit [7]
1022          * to carry info about used I2C bus for dual tuner configuration.
1023          */
1024
1025         switch (state->af9033_config[adap->id].tuner) {
1026         case AF9033_TUNER_TUA9001:
1027                 /* AF9035 gpiot3 = TUA9001 RESETN
1028                    AF9035 gpiot2 = TUA9001 RXEN */
1029
1030                 /* configure gpiot2 and gpiot2 as output */
1031                 ret = af9035_wr_reg_mask(d, 0x00d8ec, 0x01, 0x01);
1032                 if (ret < 0)
1033                         goto err;
1034
1035                 ret = af9035_wr_reg_mask(d, 0x00d8ed, 0x01, 0x01);
1036                 if (ret < 0)
1037                         goto err;
1038
1039                 ret = af9035_wr_reg_mask(d, 0x00d8e8, 0x01, 0x01);
1040                 if (ret < 0)
1041                         goto err;
1042
1043                 ret = af9035_wr_reg_mask(d, 0x00d8e9, 0x01, 0x01);
1044                 if (ret < 0)
1045                         goto err;
1046
1047                 /* attach tuner */
1048                 fe = dvb_attach(tua9001_attach, adap->fe[0],
1049                                 &d->i2c_adap, &af9035_tua9001_config);
1050                 break;
1051         case AF9033_TUNER_FC0011:
1052                 fe = dvb_attach(fc0011_attach, adap->fe[0],
1053                                 &d->i2c_adap, &af9035_fc0011_config);
1054                 break;
1055         case AF9033_TUNER_MXL5007T:
1056                 if (adap->id == 0) {
1057                         ret = af9035_wr_reg(d, 0x00d8e0, 1);
1058                         if (ret < 0)
1059                                 goto err;
1060
1061                         ret = af9035_wr_reg(d, 0x00d8e1, 1);
1062                         if (ret < 0)
1063                                 goto err;
1064
1065                         ret = af9035_wr_reg(d, 0x00d8df, 0);
1066                         if (ret < 0)
1067                                 goto err;
1068
1069                         msleep(30);
1070
1071                         ret = af9035_wr_reg(d, 0x00d8df, 1);
1072                         if (ret < 0)
1073                                 goto err;
1074
1075                         msleep(300);
1076
1077                         ret = af9035_wr_reg(d, 0x00d8c0, 1);
1078                         if (ret < 0)
1079                                 goto err;
1080
1081                         ret = af9035_wr_reg(d, 0x00d8c1, 1);
1082                         if (ret < 0)
1083                                 goto err;
1084
1085                         ret = af9035_wr_reg(d, 0x00d8bf, 0);
1086                         if (ret < 0)
1087                                 goto err;
1088
1089                         ret = af9035_wr_reg(d, 0x00d8b4, 1);
1090                         if (ret < 0)
1091                                 goto err;
1092
1093                         ret = af9035_wr_reg(d, 0x00d8b5, 1);
1094                         if (ret < 0)
1095                                 goto err;
1096
1097                         ret = af9035_wr_reg(d, 0x00d8b3, 1);
1098                         if (ret < 0)
1099                                 goto err;
1100
1101                         tuner_addr = 0x60;
1102                 } else {
1103                         tuner_addr = 0x60 | 0x80; /* I2C bus hack */
1104                 }
1105
1106                 /* attach tuner */
1107                 fe = dvb_attach(mxl5007t_attach, adap->fe[0], &d->i2c_adap,
1108                                 tuner_addr, &af9035_mxl5007t_config[adap->id]);
1109                 break;
1110         case AF9033_TUNER_TDA18218:
1111                 /* attach tuner */
1112                 fe = dvb_attach(tda18218_attach, adap->fe[0],
1113                                 &d->i2c_adap, &af9035_tda18218_config);
1114                 break;
1115         case AF9033_TUNER_FC2580:
1116                 /* Tuner enable using gpiot2_o, gpiot2_en and gpiot2_on  */
1117                 ret = af9035_wr_reg_mask(d, 0xd8eb, 0x01, 0x01);
1118                 if (ret < 0)
1119                         goto err;
1120
1121                 ret = af9035_wr_reg_mask(d, 0xd8ec, 0x01, 0x01);
1122                 if (ret < 0)
1123                         goto err;
1124
1125                 ret = af9035_wr_reg_mask(d, 0xd8ed, 0x01, 0x01);
1126                 if (ret < 0)
1127                         goto err;
1128
1129                 usleep_range(10000, 50000);
1130                 /* attach tuner */
1131                 fe = dvb_attach(fc2580_attach, adap->fe[0],
1132                                 &d->i2c_adap, &af9035_fc2580_config);
1133                 break;
1134         case AF9033_TUNER_FC0012:
1135                 /*
1136                  * AF9035 gpiot2 = FC0012 enable
1137                  * XXX: there seems to be something on gpioh8 too, but on my
1138                  * my test I didn't find any difference.
1139                  */
1140
1141                 if (adap->id == 0) {
1142                         /* configure gpiot2 as output and high */
1143                         ret = af9035_wr_reg_mask(d, 0xd8eb, 0x01, 0x01);
1144                         if (ret < 0)
1145                                 goto err;
1146
1147                         ret = af9035_wr_reg_mask(d, 0xd8ec, 0x01, 0x01);
1148                         if (ret < 0)
1149                                 goto err;
1150
1151                         ret = af9035_wr_reg_mask(d, 0xd8ed, 0x01, 0x01);
1152                         if (ret < 0)
1153                                 goto err;
1154                 } else {
1155                         /*
1156                          * FIXME: That belongs for the FC0012 driver.
1157                          * Write 02 to FC0012 master tuner register 0d directly
1158                          * in order to make slave tuner working.
1159                          */
1160                         msg[0].addr = 0x63;
1161                         msg[0].flags = 0;
1162                         msg[0].len = 2;
1163                         msg[0].buf = "\x0d\x02";
1164                         ret = i2c_transfer(&d->i2c_adap, msg, 1);
1165                         if (ret < 0)
1166                                 goto err;
1167                 }
1168
1169                 usleep_range(10000, 50000);
1170
1171                 fe = dvb_attach(fc0012_attach, adap->fe[0], &d->i2c_adap,
1172                                 &af9035_fc0012_config[adap->id]);
1173                 break;
1174         case AF9033_TUNER_IT9135_38:
1175         case AF9033_TUNER_IT9135_51:
1176         case AF9033_TUNER_IT9135_52:
1177         case AF9033_TUNER_IT9135_60:
1178         case AF9033_TUNER_IT9135_61:
1179         case AF9033_TUNER_IT9135_62:
1180                 /* attach tuner */
1181                 fe = dvb_attach(it913x_attach, adap->fe[0], &d->i2c_adap,
1182                                 state->af9033_config[adap->id].i2c_addr,
1183                                 state->af9033_config[0].tuner);
1184                 break;
1185         default:
1186                 fe = NULL;
1187         }
1188
1189         if (fe == NULL) {
1190                 ret = -ENODEV;
1191                 goto err;
1192         }
1193
1194         return 0;
1195
1196 err:
1197         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
1198
1199         return ret;
1200 }
1201
1202 static int af9035_init(struct dvb_usb_device *d)
1203 {
1204         struct state *state = d_to_priv(d);
1205         int ret, i;
1206         u16 frame_size = (d->udev->speed == USB_SPEED_FULL ? 5 : 87) * 188 / 4;
1207         u8 packet_size = (d->udev->speed == USB_SPEED_FULL ? 64 : 512) / 4;
1208         struct reg_val_mask tab[] = {
1209                 { 0x80f99d, 0x01, 0x01 },
1210                 { 0x80f9a4, 0x01, 0x01 },
1211                 { 0x00dd11, 0x00, 0x20 },
1212                 { 0x00dd11, 0x00, 0x40 },
1213                 { 0x00dd13, 0x00, 0x20 },
1214                 { 0x00dd13, 0x00, 0x40 },
1215                 { 0x00dd11, 0x20, 0x20 },
1216                 { 0x00dd88, (frame_size >> 0) & 0xff, 0xff},
1217                 { 0x00dd89, (frame_size >> 8) & 0xff, 0xff},
1218                 { 0x00dd0c, packet_size, 0xff},
1219                 { 0x00dd11, state->dual_mode << 6, 0x40 },
1220                 { 0x00dd8a, (frame_size >> 0) & 0xff, 0xff},
1221                 { 0x00dd8b, (frame_size >> 8) & 0xff, 0xff},
1222                 { 0x00dd0d, packet_size, 0xff },
1223                 { 0x80f9a3, state->dual_mode, 0x01 },
1224                 { 0x80f9cd, state->dual_mode, 0x01 },
1225                 { 0x80f99d, 0x00, 0x01 },
1226                 { 0x80f9a4, 0x00, 0x01 },
1227         };
1228
1229         dev_dbg(&d->udev->dev, "%s: USB speed=%d frame_size=%04x " \
1230                         "packet_size=%02x\n", __func__,
1231                         d->udev->speed, frame_size, packet_size);
1232
1233         /* init endpoints */
1234         for (i = 0; i < ARRAY_SIZE(tab); i++) {
1235                 ret = af9035_wr_reg_mask(d, tab[i].reg, tab[i].val,
1236                                 tab[i].mask);
1237                 if (ret < 0)
1238                         goto err;
1239         }
1240
1241         return 0;
1242
1243 err:
1244         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
1245
1246         return ret;
1247 }
1248
1249 #if IS_ENABLED(CONFIG_RC_CORE)
1250 static int af9035_rc_query(struct dvb_usb_device *d)
1251 {
1252         int ret;
1253         u32 key;
1254         u8 buf[4];
1255         struct usb_req req = { CMD_IR_GET, 0, 0, NULL, 4, buf };
1256
1257         ret = af9035_ctrl_msg(d, &req);
1258         if (ret == 1)
1259                 return 0;
1260         else if (ret < 0)
1261                 goto err;
1262
1263         if ((buf[2] + buf[3]) == 0xff) {
1264                 if ((buf[0] + buf[1]) == 0xff) {
1265                         /* NEC standard 16bit */
1266                         key = buf[0] << 8 | buf[2];
1267                 } else {
1268                         /* NEC extended 24bit */
1269                         key = buf[0] << 16 | buf[1] << 8 | buf[2];
1270                 }
1271         } else {
1272                 /* NEC full code 32bit */
1273                 key = buf[0] << 24 | buf[1] << 16 | buf[2] << 8 | buf[3];
1274         }
1275
1276         dev_dbg(&d->udev->dev, "%s: %*ph\n", __func__, 4, buf);
1277
1278         rc_keydown(d->rc_dev, key, 0);
1279
1280         return 0;
1281
1282 err:
1283         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
1284
1285         return ret;
1286 }
1287
1288 static int af9035_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc)
1289 {
1290         struct state *state = d_to_priv(d);
1291         int ret;
1292         u8 tmp;
1293
1294         ret = af9035_rd_reg(d, state->eeprom_addr + EEPROM_IR_MODE, &tmp);
1295         if (ret < 0)
1296                 goto err;
1297
1298         dev_dbg(&d->udev->dev, "%s: ir_mode=%02x\n", __func__, tmp);
1299
1300         /* don't activate rc if in HID mode or if not available */
1301         if (tmp == 5) {
1302                 ret = af9035_rd_reg(d, state->eeprom_addr + EEPROM_IR_TYPE,
1303                                 &tmp);
1304                 if (ret < 0)
1305                         goto err;
1306
1307                 dev_dbg(&d->udev->dev, "%s: ir_type=%02x\n", __func__, tmp);
1308
1309                 switch (tmp) {
1310                 case 0: /* NEC */
1311                 default:
1312                         rc->allowed_protos = RC_BIT_NEC;
1313                         break;
1314                 case 1: /* RC6 */
1315                         rc->allowed_protos = RC_BIT_RC6_MCE;
1316                         break;
1317                 }
1318
1319                 rc->query = af9035_rc_query;
1320                 rc->interval = 500;
1321
1322                 /* load empty to enable rc */
1323                 if (!rc->map_name)
1324                         rc->map_name = RC_MAP_EMPTY;
1325         }
1326
1327         return 0;
1328
1329 err:
1330         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
1331
1332         return ret;
1333 }
1334 #else
1335         #define af9035_get_rc_config NULL
1336 #endif
1337
1338 static int af9035_get_stream_config(struct dvb_frontend *fe, u8 *ts_type,
1339                 struct usb_data_stream_properties *stream)
1340 {
1341         struct dvb_usb_device *d = fe_to_d(fe);
1342         dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, fe_to_adap(fe)->id);
1343
1344         if (d->udev->speed == USB_SPEED_FULL)
1345                 stream->u.bulk.buffersize = 5 * 188;
1346
1347         return 0;
1348 }
1349
1350 /*
1351  * FIXME: PID filter is property of demodulator and should be moved to the
1352  * correct driver. Also we support only adapter #0 PID filter and will
1353  * disable adapter #1 if USB1.1 is used.
1354  */
1355 static int af9035_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
1356 {
1357         struct dvb_usb_device *d = adap_to_d(adap);
1358         int ret;
1359
1360         dev_dbg(&d->udev->dev, "%s: onoff=%d\n", __func__, onoff);
1361
1362         ret = af9035_wr_reg_mask(d, 0x80f993, onoff, 0x01);
1363         if (ret < 0)
1364                 goto err;
1365
1366         return 0;
1367
1368 err:
1369         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
1370
1371         return ret;
1372 }
1373
1374 static int af9035_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
1375                 int onoff)
1376 {
1377         struct dvb_usb_device *d = adap_to_d(adap);
1378         int ret;
1379         u8 wbuf[2] = {(pid >> 0) & 0xff, (pid >> 8) & 0xff};
1380
1381         dev_dbg(&d->udev->dev, "%s: index=%d pid=%04x onoff=%d\n",
1382                         __func__, index, pid, onoff);
1383
1384         ret = af9035_wr_regs(d, 0x80f996, wbuf, 2);
1385         if (ret < 0)
1386                 goto err;
1387
1388         ret = af9035_wr_reg(d, 0x80f994, onoff);
1389         if (ret < 0)
1390                 goto err;
1391
1392         ret = af9035_wr_reg(d, 0x80f995, index);
1393         if (ret < 0)
1394                 goto err;
1395
1396         return 0;
1397
1398 err:
1399         dev_dbg(&d->udev->dev, "%s: failed=%d\n", __func__, ret);
1400
1401         return ret;
1402 }
1403
1404 static int af9035_probe(struct usb_interface *intf,
1405                 const struct usb_device_id *id)
1406 {
1407         struct usb_device *udev = interface_to_usbdev(intf);
1408         char manufacturer[sizeof("Afatech")];
1409
1410         memset(manufacturer, 0, sizeof(manufacturer));
1411         usb_string(udev, udev->descriptor.iManufacturer,
1412                         manufacturer, sizeof(manufacturer));
1413         /*
1414          * There is two devices having same ID but different chipset. One uses
1415          * AF9015 and the other IT9135 chipset. Only difference seen on lsusb
1416          * is iManufacturer string.
1417          *
1418          * idVendor           0x0ccd TerraTec Electronic GmbH
1419          * idProduct          0x0099
1420          * bcdDevice            2.00
1421          * iManufacturer           1 Afatech
1422          * iProduct                2 DVB-T 2
1423          *
1424          * idVendor           0x0ccd TerraTec Electronic GmbH
1425          * idProduct          0x0099
1426          * bcdDevice            2.00
1427          * iManufacturer           1 ITE Technologies, Inc.
1428          * iProduct                2 DVB-T TV Stick
1429          */
1430         if ((le16_to_cpu(udev->descriptor.idVendor) == USB_VID_TERRATEC) &&
1431                         (le16_to_cpu(udev->descriptor.idProduct) == 0x0099)) {
1432                 if (!strcmp("Afatech", manufacturer)) {
1433                         dev_dbg(&udev->dev, "%s: rejecting device\n", __func__);
1434                         return -ENODEV;
1435                 }
1436         }
1437
1438         return dvb_usbv2_probe(intf, id);
1439 }
1440
1441 /* interface 0 is used by DVB-T receiver and
1442    interface 1 is for remote controller (HID) */
1443 static const struct dvb_usb_device_properties af9035_props = {
1444         .driver_name = KBUILD_MODNAME,
1445         .owner = THIS_MODULE,
1446         .adapter_nr = adapter_nr,
1447         .size_of_priv = sizeof(struct state),
1448
1449         .generic_bulk_ctrl_endpoint = 0x02,
1450         .generic_bulk_ctrl_endpoint_response = 0x81,
1451
1452         .identify_state = af9035_identify_state,
1453         .download_firmware = af9035_download_firmware,
1454
1455         .i2c_algo = &af9035_i2c_algo,
1456         .read_config = af9035_read_config,
1457         .frontend_attach = af9035_frontend_attach,
1458         .tuner_attach = af9035_tuner_attach,
1459         .init = af9035_init,
1460         .get_rc_config = af9035_get_rc_config,
1461         .get_stream_config = af9035_get_stream_config,
1462
1463         .get_adapter_count = af9035_get_adapter_count,
1464         .adapter = {
1465                 {
1466                         .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1467                                 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1468
1469                         .pid_filter_count = 32,
1470                         .pid_filter_ctrl = af9035_pid_filter_ctrl,
1471                         .pid_filter = af9035_pid_filter,
1472
1473                         .stream = DVB_USB_STREAM_BULK(0x84, 6, 87 * 188),
1474                 }, {
1475                         .stream = DVB_USB_STREAM_BULK(0x85, 6, 87 * 188),
1476                 },
1477         },
1478 };
1479
1480 static const struct usb_device_id af9035_id_table[] = {
1481         /* AF9035 devices */
1482         { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_9035,
1483                 &af9035_props, "Afatech AF9035 reference design", NULL) },
1484         { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_1000,
1485                 &af9035_props, "Afatech AF9035 reference design", NULL) },
1486         { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_1001,
1487                 &af9035_props, "Afatech AF9035 reference design", NULL) },
1488         { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_1002,
1489                 &af9035_props, "Afatech AF9035 reference design", NULL) },
1490         { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_1003,
1491                 &af9035_props, "Afatech AF9035 reference design", NULL) },
1492         { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_STICK,
1493                 &af9035_props, "TerraTec Cinergy T Stick", NULL) },
1494         { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835,
1495                 &af9035_props, "AVerMedia AVerTV Volar HD/PRO (A835)", NULL) },
1496         { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_B835,
1497                 &af9035_props, "AVerMedia AVerTV Volar HD/PRO (A835)", NULL) },
1498         { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_1867,
1499                 &af9035_props, "AVerMedia HD Volar (A867)", NULL) },
1500         { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A867,
1501                 &af9035_props, "AVerMedia HD Volar (A867)", NULL) },
1502         { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_TWINSTAR,
1503                 &af9035_props, "AVerMedia Twinstar (A825)", NULL) },
1504         { DVB_USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3100MINI_PLUS,
1505                 &af9035_props, "Asus U3100Mini Plus", NULL) },
1506         { DVB_USB_DEVICE(USB_VID_TERRATEC, 0x00aa,
1507                 &af9035_props, "TerraTec Cinergy T Stick (rev. 2)", NULL) },
1508         /* IT9135 devices */
1509 #if 0
1510         { DVB_USB_DEVICE(0x048d, 0x9135,
1511                 &af9035_props, "IT9135 reference design", NULL) },
1512         { DVB_USB_DEVICE(0x048d, 0x9006,
1513                 &af9035_props, "IT9135 reference design", NULL) },
1514 #endif
1515         /* XXX: that same ID [0ccd:0099] is used by af9015 driver too */
1516         { DVB_USB_DEVICE(USB_VID_TERRATEC, 0x0099,
1517                 &af9035_props, "TerraTec Cinergy T Stick Dual RC (rev. 2)", NULL) },
1518         { DVB_USB_DEVICE(USB_VID_LEADTEK, 0x6a05,
1519                 &af9035_props, "Leadtek WinFast DTV Dongle Dual", NULL) },
1520         { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xf900,
1521                 &af9035_props, "Hauppauge WinTV-MiniStick 2", NULL) },
1522         { }
1523 };
1524 MODULE_DEVICE_TABLE(usb, af9035_id_table);
1525
1526 static struct usb_driver af9035_usb_driver = {
1527         .name = KBUILD_MODNAME,
1528         .id_table = af9035_id_table,
1529         .probe = af9035_probe,
1530         .disconnect = dvb_usbv2_disconnect,
1531         .suspend = dvb_usbv2_suspend,
1532         .resume = dvb_usbv2_resume,
1533         .reset_resume = dvb_usbv2_reset_resume,
1534         .no_dynamic_id = 1,
1535         .soft_unbind = 1,
1536 };
1537
1538 module_usb_driver(af9035_usb_driver);
1539
1540 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1541 MODULE_DESCRIPTION("Afatech AF9035 driver");
1542 MODULE_LICENSE("GPL");
1543 MODULE_FIRMWARE(AF9035_FIRMWARE_AF9035);
1544 MODULE_FIRMWARE(AF9035_FIRMWARE_IT9135_V1);
1545 MODULE_FIRMWARE(AF9035_FIRMWARE_IT9135_V2);