1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Afatech AF9035 DVB USB driver 4 * 5 * Copyright (C) 2009 Antti Palosaari <crope@iki.fi> 6 * Copyright (C) 2012 Antti Palosaari <crope@iki.fi> 7 */ 8 9 #include "af9035.h" 10 11 /* Max transfer size done by I2C transfer functions */ 12 #define MAX_XFER_SIZE 64 13 14 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr); 15 16 static u16 af9035_checksum(const u8 *buf, size_t len) 17 { 18 size_t i; 19 u16 checksum = 0; 20 21 for (i = 1; i < len; i++) { 22 if (i % 2) 23 checksum += buf[i] << 8; 24 else 25 checksum += buf[i]; 26 } 27 checksum = ~checksum; 28 29 return checksum; 30 } 31 32 static int af9035_ctrl_msg(struct dvb_usb_device *d, struct usb_req *req) 33 { 34 #define REQ_HDR_LEN 4 /* send header size */ 35 #define ACK_HDR_LEN 3 /* rece header size */ 36 #define CHECKSUM_LEN 2 37 #define USB_TIMEOUT 2000 38 struct state *state = d_to_priv(d); 39 struct usb_interface *intf = d->intf; 40 int ret, wlen, rlen; 41 u16 checksum, tmp_checksum; 42 43 mutex_lock(&d->usb_mutex); 44 45 /* buffer overflow check */ 46 if (req->wlen > (BUF_LEN - REQ_HDR_LEN - CHECKSUM_LEN) || 47 req->rlen > (BUF_LEN - ACK_HDR_LEN - CHECKSUM_LEN)) { 48 dev_err(&intf->dev, "too much data wlen=%d rlen=%d\n", 49 req->wlen, req->rlen); 50 ret = -EINVAL; 51 goto exit; 52 } 53 54 state->buf[0] = REQ_HDR_LEN + req->wlen + CHECKSUM_LEN - 1; 55 state->buf[1] = req->mbox; 56 state->buf[2] = req->cmd; 57 state->buf[3] = state->seq++; 58 memcpy(&state->buf[REQ_HDR_LEN], req->wbuf, req->wlen); 59 60 wlen = REQ_HDR_LEN + req->wlen + CHECKSUM_LEN; 61 rlen = ACK_HDR_LEN + req->rlen + CHECKSUM_LEN; 62 63 /* calc and add checksum */ 64 checksum = af9035_checksum(state->buf, state->buf[0] - 1); 65 state->buf[state->buf[0] - 1] = (checksum >> 8); 66 state->buf[state->buf[0] - 0] = (checksum & 0xff); 67 68 /* no ack for these packets */ 69 if (req->cmd == CMD_FW_DL) 70 rlen = 0; 71 72 ret = dvb_usbv2_generic_rw_locked(d, 73 state->buf, wlen, state->buf, rlen); 74 if (ret) 75 goto exit; 76 77 /* no ack for those packets */ 78 if (req->cmd == CMD_FW_DL) 79 goto exit; 80 81 /* verify checksum */ 82 checksum = af9035_checksum(state->buf, rlen - 2); 83 tmp_checksum = (state->buf[rlen - 2] << 8) | state->buf[rlen - 1]; 84 if (tmp_checksum != checksum) { 85 dev_err(&intf->dev, "command=%02x checksum mismatch (%04x != %04x)\n", 86 req->cmd, tmp_checksum, checksum); 87 ret = -EIO; 88 goto exit; 89 } 90 91 /* check status */ 92 if (state->buf[2]) { 93 /* fw returns status 1 when IR code was not received */ 94 if (req->cmd == CMD_IR_GET || state->buf[2] == 1) { 95 ret = 1; 96 goto exit; 97 } 98 99 dev_dbg(&intf->dev, "command=%02x failed fw error=%d\n", 100 req->cmd, state->buf[2]); 101 ret = -EIO; 102 goto exit; 103 } 104 105 /* read request, copy returned data to return buf */ 106 if (req->rlen) 107 memcpy(req->rbuf, &state->buf[ACK_HDR_LEN], req->rlen); 108 exit: 109 mutex_unlock(&d->usb_mutex); 110 return ret; 111 } 112 113 /* write multiple registers */ 114 static int af9035_wr_regs(struct dvb_usb_device *d, u32 reg, u8 *val, int len) 115 { 116 struct usb_interface *intf = d->intf; 117 u8 wbuf[MAX_XFER_SIZE]; 118 u8 mbox = (reg >> 16) & 0xff; 119 struct usb_req req = { CMD_MEM_WR, mbox, 6 + len, wbuf, 0, NULL }; 120 121 if (6 + len > sizeof(wbuf)) { 122 dev_warn(&intf->dev, "i2c wr: len=%d is too big!\n", len); 123 return -EOPNOTSUPP; 124 } 125 126 wbuf[0] = len; 127 wbuf[1] = 2; 128 wbuf[2] = 0; 129 wbuf[3] = 0; 130 wbuf[4] = (reg >> 8) & 0xff; 131 wbuf[5] = (reg >> 0) & 0xff; 132 memcpy(&wbuf[6], val, len); 133 134 return af9035_ctrl_msg(d, &req); 135 } 136 137 /* read multiple registers */ 138 static int af9035_rd_regs(struct dvb_usb_device *d, u32 reg, u8 *val, int len) 139 { 140 u8 wbuf[] = { len, 2, 0, 0, (reg >> 8) & 0xff, reg & 0xff }; 141 u8 mbox = (reg >> 16) & 0xff; 142 struct usb_req req = { CMD_MEM_RD, mbox, sizeof(wbuf), wbuf, len, val }; 143 144 return af9035_ctrl_msg(d, &req); 145 } 146 147 /* write single register */ 148 static int af9035_wr_reg(struct dvb_usb_device *d, u32 reg, u8 val) 149 { 150 return af9035_wr_regs(d, reg, &val, 1); 151 } 152 153 /* read single register */ 154 static int af9035_rd_reg(struct dvb_usb_device *d, u32 reg, u8 *val) 155 { 156 return af9035_rd_regs(d, reg, val, 1); 157 } 158 159 /* write single register with mask */ 160 static int af9035_wr_reg_mask(struct dvb_usb_device *d, u32 reg, u8 val, 161 u8 mask) 162 { 163 int ret; 164 u8 tmp; 165 166 /* no need for read if whole reg is written */ 167 if (mask != 0xff) { 168 ret = af9035_rd_regs(d, reg, &tmp, 1); 169 if (ret) 170 return ret; 171 172 val &= mask; 173 tmp &= ~mask; 174 val |= tmp; 175 } 176 177 return af9035_wr_regs(d, reg, &val, 1); 178 } 179 180 static int af9035_add_i2c_dev(struct dvb_usb_device *d, const char *type, 181 u8 addr, void *platform_data, struct i2c_adapter *adapter) 182 { 183 int ret, num; 184 struct state *state = d_to_priv(d); 185 struct usb_interface *intf = d->intf; 186 struct i2c_client *client; 187 struct i2c_board_info board_info = { 188 .addr = addr, 189 .platform_data = platform_data, 190 }; 191 192 strscpy(board_info.type, type, I2C_NAME_SIZE); 193 194 /* find first free client */ 195 for (num = 0; num < AF9035_I2C_CLIENT_MAX; num++) { 196 if (state->i2c_client[num] == NULL) 197 break; 198 } 199 200 dev_dbg(&intf->dev, "num=%d\n", num); 201 202 if (num == AF9035_I2C_CLIENT_MAX) { 203 dev_err(&intf->dev, "I2C client out of index\n"); 204 ret = -ENODEV; 205 goto err; 206 } 207 208 request_module("%s", board_info.type); 209 210 /* register I2C device */ 211 client = i2c_new_client_device(adapter, &board_info); 212 if (!i2c_client_has_driver(client)) { 213 dev_err(&intf->dev, "failed to bind i2c device to %s driver\n", type); 214 ret = -ENODEV; 215 goto err; 216 } 217 218 /* increase I2C driver usage count */ 219 if (!try_module_get(client->dev.driver->owner)) { 220 i2c_unregister_device(client); 221 ret = -ENODEV; 222 goto err; 223 } 224 225 state->i2c_client[num] = client; 226 return 0; 227 err: 228 dev_dbg(&intf->dev, "failed=%d\n", ret); 229 return ret; 230 } 231 232 static void af9035_del_i2c_dev(struct dvb_usb_device *d) 233 { 234 int num; 235 struct state *state = d_to_priv(d); 236 struct usb_interface *intf = d->intf; 237 struct i2c_client *client; 238 239 /* find last used client */ 240 num = AF9035_I2C_CLIENT_MAX; 241 while (num--) { 242 if (state->i2c_client[num] != NULL) 243 break; 244 } 245 246 dev_dbg(&intf->dev, "num=%d\n", num); 247 248 if (num == -1) { 249 dev_err(&intf->dev, "I2C client out of index\n"); 250 goto err; 251 } 252 253 client = state->i2c_client[num]; 254 255 /* decrease I2C driver usage count */ 256 module_put(client->dev.driver->owner); 257 258 /* unregister I2C device */ 259 i2c_unregister_device(client); 260 261 state->i2c_client[num] = NULL; 262 return; 263 err: 264 dev_dbg(&intf->dev, "failed\n"); 265 } 266 267 static int af9035_i2c_master_xfer(struct i2c_adapter *adap, 268 struct i2c_msg msg[], int num) 269 { 270 struct dvb_usb_device *d = i2c_get_adapdata(adap); 271 struct state *state = d_to_priv(d); 272 int ret; 273 274 if (mutex_lock_interruptible(&d->i2c_mutex) < 0) 275 return -EAGAIN; 276 277 /* 278 * AF9035 I2C sub header is 5 bytes long. Meaning of those bytes are: 279 * 0: data len 280 * 1: I2C addr << 1 281 * 2: reg addr len 282 * byte 3 and 4 can be used as reg addr 283 * 3: reg addr MSB 284 * used when reg addr len is set to 2 285 * 4: reg addr LSB 286 * used when reg addr len is set to 1 or 2 287 * 288 * For the simplify we do not use register addr at all. 289 * NOTE: As a firmware knows tuner type there is very small possibility 290 * there could be some tuner I2C hacks done by firmware and this may 291 * lead problems if firmware expects those bytes are used. 292 * 293 * TODO: Here is few hacks. AF9035 chip integrates AF9033 demodulator. 294 * IT9135 chip integrates AF9033 demodulator and RF tuner. For dual 295 * tuner devices, there is also external AF9033 demodulator connected 296 * via external I2C bus. All AF9033 demod I2C traffic, both single and 297 * dual tuner configuration, is covered by firmware - actual USB IO 298 * looks just like a memory access. 299 * In case of IT913x chip, there is own tuner driver. It is implemented 300 * currently as a I2C driver, even tuner IP block is likely build 301 * directly into the demodulator memory space and there is no own I2C 302 * bus. I2C subsystem does not allow register multiple devices to same 303 * bus, having same slave address. Due to that we reuse demod address, 304 * shifted by one bit, on that case. 305 * 306 * For IT930x we use a different command and the sub header is 307 * different as well: 308 * 0: data len 309 * 1: I2C bus (0x03 seems to be only value used) 310 * 2: I2C addr << 1 311 */ 312 #define AF9035_IS_I2C_XFER_WRITE_READ(_msg, _num) \ 313 (_num == 2 && !(_msg[0].flags & I2C_M_RD) && (_msg[1].flags & I2C_M_RD)) 314 #define AF9035_IS_I2C_XFER_WRITE(_msg, _num) \ 315 (_num == 1 && !(_msg[0].flags & I2C_M_RD)) 316 #define AF9035_IS_I2C_XFER_READ(_msg, _num) \ 317 (_num == 1 && (_msg[0].flags & I2C_M_RD)) 318 319 if (AF9035_IS_I2C_XFER_WRITE_READ(msg, num)) { 320 if (msg[0].len > 40 || msg[1].len > 40) { 321 /* TODO: correct limits > 40 */ 322 ret = -EOPNOTSUPP; 323 } else if ((msg[0].addr == state->af9033_i2c_addr[0]) || 324 (msg[0].addr == state->af9033_i2c_addr[1])) { 325 /* demod access via firmware interface */ 326 u32 reg; 327 328 if (msg[0].len < 3 || msg[1].len < 1) { 329 ret = -EOPNOTSUPP; 330 goto unlock; 331 } 332 333 reg = msg[0].buf[0] << 16 | msg[0].buf[1] << 8 | 334 msg[0].buf[2]; 335 336 if (msg[0].addr == state->af9033_i2c_addr[1]) 337 reg |= 0x100000; 338 339 ret = af9035_rd_regs(d, reg, &msg[1].buf[0], 340 msg[1].len); 341 } else if (state->no_read) { 342 memset(msg[1].buf, 0, msg[1].len); 343 ret = 0; 344 } else { 345 /* I2C write + read */ 346 u8 buf[MAX_XFER_SIZE]; 347 struct usb_req req = { CMD_I2C_RD, 0, 5 + msg[0].len, 348 buf, msg[1].len, msg[1].buf }; 349 350 if (state->chip_type == 0x9306) { 351 req.cmd = CMD_GENERIC_I2C_RD; 352 req.wlen = 3 + msg[0].len; 353 } 354 req.mbox |= ((msg[0].addr & 0x80) >> 3); 355 356 buf[0] = msg[1].len; 357 if (state->chip_type == 0x9306) { 358 buf[1] = 0x03; /* I2C bus */ 359 buf[2] = msg[0].addr << 1; 360 memcpy(&buf[3], msg[0].buf, msg[0].len); 361 } else { 362 buf[1] = msg[0].addr << 1; 363 buf[3] = 0x00; /* reg addr MSB */ 364 buf[4] = 0x00; /* reg addr LSB */ 365 366 /* Keep prev behavior for write req len > 2*/ 367 if (msg[0].len > 2) { 368 buf[2] = 0x00; /* reg addr len */ 369 memcpy(&buf[5], msg[0].buf, msg[0].len); 370 371 /* Use reg addr fields if write req len <= 2 */ 372 } else { 373 req.wlen = 5; 374 buf[2] = msg[0].len; 375 if (msg[0].len == 2) { 376 buf[3] = msg[0].buf[0]; 377 buf[4] = msg[0].buf[1]; 378 } else if (msg[0].len == 1) { 379 buf[4] = msg[0].buf[0]; 380 } 381 } 382 } 383 ret = af9035_ctrl_msg(d, &req); 384 } 385 } else if (AF9035_IS_I2C_XFER_WRITE(msg, num)) { 386 if (msg[0].len > 40) { 387 /* TODO: correct limits > 40 */ 388 ret = -EOPNOTSUPP; 389 } else if ((msg[0].addr == state->af9033_i2c_addr[0]) || 390 (msg[0].addr == state->af9033_i2c_addr[1])) { 391 /* demod access via firmware interface */ 392 u32 reg; 393 394 if (msg[0].len < 3) { 395 ret = -EOPNOTSUPP; 396 goto unlock; 397 } 398 399 reg = msg[0].buf[0] << 16 | msg[0].buf[1] << 8 | 400 msg[0].buf[2]; 401 402 if (msg[0].addr == state->af9033_i2c_addr[1]) 403 reg |= 0x100000; 404 405 ret = af9035_wr_regs(d, reg, &msg[0].buf[3], msg[0].len - 3); 406 } else { 407 /* I2C write */ 408 u8 buf[MAX_XFER_SIZE]; 409 struct usb_req req = { CMD_I2C_WR, 0, 5 + msg[0].len, 410 buf, 0, NULL }; 411 412 if (state->chip_type == 0x9306) { 413 req.cmd = CMD_GENERIC_I2C_WR; 414 req.wlen = 3 + msg[0].len; 415 } 416 417 req.mbox |= ((msg[0].addr & 0x80) >> 3); 418 buf[0] = msg[0].len; 419 if (state->chip_type == 0x9306) { 420 buf[1] = 0x03; /* I2C bus */ 421 buf[2] = msg[0].addr << 1; 422 memcpy(&buf[3], msg[0].buf, msg[0].len); 423 } else { 424 buf[1] = msg[0].addr << 1; 425 buf[2] = 0x00; /* reg addr len */ 426 buf[3] = 0x00; /* reg addr MSB */ 427 buf[4] = 0x00; /* reg addr LSB */ 428 memcpy(&buf[5], msg[0].buf, msg[0].len); 429 } 430 ret = af9035_ctrl_msg(d, &req); 431 } 432 } else if (AF9035_IS_I2C_XFER_READ(msg, num)) { 433 if (msg[0].len > 40) { 434 /* TODO: correct limits > 40 */ 435 ret = -EOPNOTSUPP; 436 } else if (state->no_read) { 437 memset(msg[0].buf, 0, msg[0].len); 438 ret = 0; 439 } else { 440 /* I2C read */ 441 u8 buf[5]; 442 struct usb_req req = { CMD_I2C_RD, 0, sizeof(buf), 443 buf, msg[0].len, msg[0].buf }; 444 445 if (state->chip_type == 0x9306) { 446 req.cmd = CMD_GENERIC_I2C_RD; 447 req.wlen = 3; 448 } 449 req.mbox |= ((msg[0].addr & 0x80) >> 3); 450 buf[0] = msg[0].len; 451 if (state->chip_type == 0x9306) { 452 buf[1] = 0x03; /* I2C bus */ 453 buf[2] = msg[0].addr << 1; 454 } else { 455 buf[1] = msg[0].addr << 1; 456 buf[2] = 0x00; /* reg addr len */ 457 buf[3] = 0x00; /* reg addr MSB */ 458 buf[4] = 0x00; /* reg addr LSB */ 459 } 460 ret = af9035_ctrl_msg(d, &req); 461 } 462 } else { 463 /* 464 * We support only three kind of I2C transactions: 465 * 1) 1 x write + 1 x read (repeated start) 466 * 2) 1 x write 467 * 3) 1 x read 468 */ 469 ret = -EOPNOTSUPP; 470 } 471 472 unlock: 473 mutex_unlock(&d->i2c_mutex); 474 475 if (ret < 0) 476 return ret; 477 else 478 return num; 479 } 480 481 static u32 af9035_i2c_functionality(struct i2c_adapter *adapter) 482 { 483 return I2C_FUNC_I2C; 484 } 485 486 static const struct i2c_algorithm af9035_i2c_algo = { 487 .master_xfer = af9035_i2c_master_xfer, 488 .functionality = af9035_i2c_functionality, 489 }; 490 491 static int af9035_identify_state(struct dvb_usb_device *d, const char **name) 492 { 493 struct state *state = d_to_priv(d); 494 struct usb_interface *intf = d->intf; 495 int ret, i, ts_mode_invalid; 496 unsigned int utmp, eeprom_addr; 497 u8 tmp; 498 u8 wbuf[1] = { 1 }; 499 u8 rbuf[4]; 500 struct usb_req req = { CMD_FW_QUERYINFO, 0, sizeof(wbuf), wbuf, 501 sizeof(rbuf), rbuf }; 502 503 ret = af9035_rd_regs(d, 0x1222, rbuf, 3); 504 if (ret < 0) 505 goto err; 506 507 state->chip_version = rbuf[0]; 508 state->chip_type = rbuf[2] << 8 | rbuf[1] << 0; 509 510 ret = af9035_rd_reg(d, 0x384f, &state->prechip_version); 511 if (ret < 0) 512 goto err; 513 514 dev_info(&intf->dev, "prechip_version=%02x chip_version=%02x chip_type=%04x\n", 515 state->prechip_version, state->chip_version, state->chip_type); 516 517 if (state->chip_type == 0x9135) { 518 if (state->chip_version == 0x02) { 519 *name = AF9035_FIRMWARE_IT9135_V2; 520 utmp = 0x00461d; 521 } else { 522 *name = AF9035_FIRMWARE_IT9135_V1; 523 utmp = 0x00461b; 524 } 525 526 /* Check if eeprom exists */ 527 ret = af9035_rd_reg(d, utmp, &tmp); 528 if (ret < 0) 529 goto err; 530 531 if (tmp == 0x00) { 532 dev_dbg(&intf->dev, "no eeprom\n"); 533 state->no_eeprom = true; 534 goto check_firmware_status; 535 } 536 537 eeprom_addr = EEPROM_BASE_IT9135; 538 } else if (state->chip_type == 0x9306) { 539 *name = AF9035_FIRMWARE_IT9303; 540 state->no_eeprom = true; 541 goto check_firmware_status; 542 } else { 543 *name = AF9035_FIRMWARE_AF9035; 544 eeprom_addr = EEPROM_BASE_AF9035; 545 } 546 547 /* Read and store eeprom */ 548 for (i = 0; i < 256; i += 32) { 549 ret = af9035_rd_regs(d, eeprom_addr + i, &state->eeprom[i], 32); 550 if (ret < 0) 551 goto err; 552 } 553 554 dev_dbg(&intf->dev, "eeprom dump:\n"); 555 for (i = 0; i < 256; i += 16) 556 dev_dbg(&intf->dev, "%*ph\n", 16, &state->eeprom[i]); 557 558 /* check for dual tuner mode */ 559 tmp = state->eeprom[EEPROM_TS_MODE]; 560 ts_mode_invalid = 0; 561 switch (tmp) { 562 case 0: 563 break; 564 case 1: 565 case 3: 566 state->dual_mode = true; 567 break; 568 case 5: 569 if (state->chip_type != 0x9135 && state->chip_type != 0x9306) 570 state->dual_mode = true; /* AF9035 */ 571 else 572 ts_mode_invalid = 1; 573 break; 574 default: 575 ts_mode_invalid = 1; 576 } 577 578 dev_dbg(&intf->dev, "ts mode=%d dual mode=%d\n", tmp, state->dual_mode); 579 580 if (ts_mode_invalid) 581 dev_info(&intf->dev, "ts mode=%d not supported, defaulting to single tuner mode!", tmp); 582 583 check_firmware_status: 584 ret = af9035_ctrl_msg(d, &req); 585 if (ret < 0) 586 goto err; 587 588 dev_dbg(&intf->dev, "reply=%*ph\n", 4, rbuf); 589 if (rbuf[0] || rbuf[1] || rbuf[2] || rbuf[3]) 590 ret = WARM; 591 else 592 ret = COLD; 593 594 return ret; 595 596 err: 597 dev_dbg(&intf->dev, "failed=%d\n", ret); 598 599 return ret; 600 } 601 602 static int af9035_download_firmware_old(struct dvb_usb_device *d, 603 const struct firmware *fw) 604 { 605 struct usb_interface *intf = d->intf; 606 int ret, i, j, len; 607 u8 wbuf[1]; 608 struct usb_req req = { 0, 0, 0, NULL, 0, NULL }; 609 struct usb_req req_fw_dl = { CMD_FW_DL, 0, 0, wbuf, 0, NULL }; 610 u8 hdr_core; 611 u16 hdr_addr, hdr_data_len, hdr_checksum; 612 #define MAX_DATA 58 613 #define HDR_SIZE 7 614 615 /* 616 * Thanks to Daniel Glöckner <daniel-gl@gmx.net> about that info! 617 * 618 * byte 0: MCS 51 core 619 * There are two inside the AF9035 (1=Link and 2=OFDM) with separate 620 * address spaces 621 * byte 1-2: Big endian destination address 622 * byte 3-4: Big endian number of data bytes following the header 623 * byte 5-6: Big endian header checksum, apparently ignored by the chip 624 * Calculated as ~(h[0]*256+h[1]+h[2]*256+h[3]+h[4]*256) 625 */ 626 627 for (i = fw->size; i > HDR_SIZE;) { 628 hdr_core = fw->data[fw->size - i + 0]; 629 hdr_addr = fw->data[fw->size - i + 1] << 8; 630 hdr_addr |= fw->data[fw->size - i + 2] << 0; 631 hdr_data_len = fw->data[fw->size - i + 3] << 8; 632 hdr_data_len |= fw->data[fw->size - i + 4] << 0; 633 hdr_checksum = fw->data[fw->size - i + 5] << 8; 634 hdr_checksum |= fw->data[fw->size - i + 6] << 0; 635 636 dev_dbg(&intf->dev, "core=%d addr=%04x data_len=%d checksum=%04x\n", 637 hdr_core, hdr_addr, hdr_data_len, hdr_checksum); 638 639 if (((hdr_core != 1) && (hdr_core != 2)) || 640 (hdr_data_len > i)) { 641 dev_dbg(&intf->dev, "bad firmware\n"); 642 break; 643 } 644 645 /* download begin packet */ 646 req.cmd = CMD_FW_DL_BEGIN; 647 ret = af9035_ctrl_msg(d, &req); 648 if (ret < 0) 649 goto err; 650 651 /* download firmware packet(s) */ 652 for (j = HDR_SIZE + hdr_data_len; j > 0; j -= MAX_DATA) { 653 len = j; 654 if (len > MAX_DATA) 655 len = MAX_DATA; 656 req_fw_dl.wlen = len; 657 req_fw_dl.wbuf = (u8 *) &fw->data[fw->size - i + 658 HDR_SIZE + hdr_data_len - j]; 659 ret = af9035_ctrl_msg(d, &req_fw_dl); 660 if (ret < 0) 661 goto err; 662 } 663 664 /* download end packet */ 665 req.cmd = CMD_FW_DL_END; 666 ret = af9035_ctrl_msg(d, &req); 667 if (ret < 0) 668 goto err; 669 670 i -= hdr_data_len + HDR_SIZE; 671 672 dev_dbg(&intf->dev, "data uploaded=%zu\n", fw->size - i); 673 } 674 675 /* print warn if firmware is bad, continue and see what happens */ 676 if (i) 677 dev_warn(&intf->dev, "bad firmware\n"); 678 679 return 0; 680 681 err: 682 dev_dbg(&intf->dev, "failed=%d\n", ret); 683 684 return ret; 685 } 686 687 static int af9035_download_firmware_new(struct dvb_usb_device *d, 688 const struct firmware *fw) 689 { 690 struct usb_interface *intf = d->intf; 691 int ret, i, i_prev; 692 struct usb_req req_fw_dl = { CMD_FW_SCATTER_WR, 0, 0, NULL, 0, NULL }; 693 #define HDR_SIZE 7 694 695 /* 696 * There seems to be following firmware header. Meaning of bytes 0-3 697 * is unknown. 698 * 699 * 0: 3 700 * 1: 0, 1 701 * 2: 0 702 * 3: 1, 2, 3 703 * 4: addr MSB 704 * 5: addr LSB 705 * 6: count of data bytes ? 706 */ 707 for (i = HDR_SIZE, i_prev = 0; i <= fw->size; i++) { 708 if (i == fw->size || 709 (fw->data[i + 0] == 0x03 && 710 (fw->data[i + 1] == 0x00 || 711 fw->data[i + 1] == 0x01) && 712 fw->data[i + 2] == 0x00)) { 713 req_fw_dl.wlen = i - i_prev; 714 req_fw_dl.wbuf = (u8 *) &fw->data[i_prev]; 715 i_prev = i; 716 ret = af9035_ctrl_msg(d, &req_fw_dl); 717 if (ret < 0) 718 goto err; 719 720 dev_dbg(&intf->dev, "data uploaded=%d\n", i); 721 } 722 } 723 724 return 0; 725 726 err: 727 dev_dbg(&intf->dev, "failed=%d\n", ret); 728 729 return ret; 730 } 731 732 static int af9035_download_firmware(struct dvb_usb_device *d, 733 const struct firmware *fw) 734 { 735 struct usb_interface *intf = d->intf; 736 struct state *state = d_to_priv(d); 737 int ret; 738 u8 wbuf[1]; 739 u8 rbuf[4]; 740 u8 tmp; 741 struct usb_req req = { 0, 0, 0, NULL, 0, NULL }; 742 struct usb_req req_fw_ver = { CMD_FW_QUERYINFO, 0, 1, wbuf, 4, rbuf }; 743 744 dev_dbg(&intf->dev, "\n"); 745 746 /* 747 * In case of dual tuner configuration we need to do some extra 748 * initialization in order to download firmware to slave demod too, 749 * which is done by master demod. 750 * Master feeds also clock and controls power via GPIO. 751 */ 752 if (state->dual_mode) { 753 /* configure gpioh1, reset & power slave demod */ 754 ret = af9035_wr_reg_mask(d, 0x00d8b0, 0x01, 0x01); 755 if (ret < 0) 756 goto err; 757 758 ret = af9035_wr_reg_mask(d, 0x00d8b1, 0x01, 0x01); 759 if (ret < 0) 760 goto err; 761 762 ret = af9035_wr_reg_mask(d, 0x00d8af, 0x00, 0x01); 763 if (ret < 0) 764 goto err; 765 766 usleep_range(10000, 50000); 767 768 ret = af9035_wr_reg_mask(d, 0x00d8af, 0x01, 0x01); 769 if (ret < 0) 770 goto err; 771 772 /* tell the slave I2C address */ 773 tmp = state->eeprom[EEPROM_2ND_DEMOD_ADDR]; 774 775 /* Use default I2C address if eeprom has no address set */ 776 if (!tmp) 777 tmp = 0x1d << 1; /* 8-bit format used by chip */ 778 779 if ((state->chip_type == 0x9135) || 780 (state->chip_type == 0x9306)) { 781 ret = af9035_wr_reg(d, 0x004bfb, tmp); 782 if (ret < 0) 783 goto err; 784 } else { 785 ret = af9035_wr_reg(d, 0x00417f, tmp); 786 if (ret < 0) 787 goto err; 788 789 /* enable clock out */ 790 ret = af9035_wr_reg_mask(d, 0x00d81a, 0x01, 0x01); 791 if (ret < 0) 792 goto err; 793 } 794 } 795 796 if (fw->data[0] == 0x01) 797 ret = af9035_download_firmware_old(d, fw); 798 else 799 ret = af9035_download_firmware_new(d, fw); 800 if (ret < 0) 801 goto err; 802 803 /* firmware loaded, request boot */ 804 req.cmd = CMD_FW_BOOT; 805 ret = af9035_ctrl_msg(d, &req); 806 if (ret < 0) 807 goto err; 808 809 /* ensure firmware starts */ 810 wbuf[0] = 1; 811 ret = af9035_ctrl_msg(d, &req_fw_ver); 812 if (ret < 0) 813 goto err; 814 815 if (!(rbuf[0] || rbuf[1] || rbuf[2] || rbuf[3])) { 816 dev_err(&intf->dev, "firmware did not run\n"); 817 ret = -ENODEV; 818 goto err; 819 } 820 821 dev_info(&intf->dev, "firmware version=%d.%d.%d.%d", 822 rbuf[0], rbuf[1], rbuf[2], rbuf[3]); 823 824 return 0; 825 826 err: 827 dev_dbg(&intf->dev, "failed=%d\n", ret); 828 829 return ret; 830 } 831 832 static int af9035_read_config(struct dvb_usb_device *d) 833 { 834 struct usb_interface *intf = d->intf; 835 struct state *state = d_to_priv(d); 836 int ret, i; 837 u8 tmp; 838 u16 tmp16; 839 840 /* Demod I2C address */ 841 state->af9033_i2c_addr[0] = 0x1c; 842 state->af9033_i2c_addr[1] = 0x1d; 843 state->af9033_config[0].adc_multiplier = AF9033_ADC_MULTIPLIER_2X; 844 state->af9033_config[1].adc_multiplier = AF9033_ADC_MULTIPLIER_2X; 845 state->af9033_config[0].ts_mode = AF9033_TS_MODE_USB; 846 state->af9033_config[1].ts_mode = AF9033_TS_MODE_SERIAL; 847 state->it930x_addresses = 0; 848 849 if (state->chip_type == 0x9135) { 850 /* feed clock for integrated RF tuner */ 851 state->af9033_config[0].dyn0_clk = true; 852 state->af9033_config[1].dyn0_clk = true; 853 854 if (state->chip_version == 0x02) { 855 state->af9033_config[0].tuner = AF9033_TUNER_IT9135_60; 856 state->af9033_config[1].tuner = AF9033_TUNER_IT9135_60; 857 } else { 858 state->af9033_config[0].tuner = AF9033_TUNER_IT9135_38; 859 state->af9033_config[1].tuner = AF9033_TUNER_IT9135_38; 860 } 861 862 if (state->no_eeprom) { 863 /* Remote controller to NEC polling by default */ 864 state->ir_mode = 0x05; 865 state->ir_type = 0x00; 866 867 goto skip_eeprom; 868 } 869 } else if (state->chip_type == 0x9306) { 870 /* 871 * IT930x is an USB bridge, only single demod-single tuner 872 * configurations seen so far. 873 */ 874 if ((le16_to_cpu(d->udev->descriptor.idVendor) == USB_VID_AVERMEDIA) && 875 (le16_to_cpu(d->udev->descriptor.idProduct) == USB_PID_AVERMEDIA_TD310)) { 876 state->it930x_addresses = 1; 877 /* TD310 RC works with NEC defaults */ 878 state->ir_mode = 0x05; 879 state->ir_type = 0x00; 880 } 881 return 0; 882 } 883 884 /* Remote controller */ 885 state->ir_mode = state->eeprom[EEPROM_IR_MODE]; 886 state->ir_type = state->eeprom[EEPROM_IR_TYPE]; 887 888 if (state->dual_mode) { 889 /* Read 2nd demodulator I2C address. 8-bit format on eeprom */ 890 tmp = state->eeprom[EEPROM_2ND_DEMOD_ADDR]; 891 if (tmp) 892 state->af9033_i2c_addr[1] = tmp >> 1; 893 894 dev_dbg(&intf->dev, "2nd demod I2C addr=%02x\n", 895 state->af9033_i2c_addr[1]); 896 } 897 898 for (i = 0; i < state->dual_mode + 1; i++) { 899 unsigned int eeprom_offset = 0; 900 901 /* tuner */ 902 tmp = state->eeprom[EEPROM_1_TUNER_ID + eeprom_offset]; 903 dev_dbg(&intf->dev, "[%d]tuner=%02x\n", i, tmp); 904 905 /* tuner sanity check */ 906 if (state->chip_type == 0x9135) { 907 if (state->chip_version == 0x02) { 908 /* IT9135 BX (v2) */ 909 switch (tmp) { 910 case AF9033_TUNER_IT9135_60: 911 case AF9033_TUNER_IT9135_61: 912 case AF9033_TUNER_IT9135_62: 913 state->af9033_config[i].tuner = tmp; 914 break; 915 } 916 } else { 917 /* IT9135 AX (v1) */ 918 switch (tmp) { 919 case AF9033_TUNER_IT9135_38: 920 case AF9033_TUNER_IT9135_51: 921 case AF9033_TUNER_IT9135_52: 922 state->af9033_config[i].tuner = tmp; 923 break; 924 } 925 } 926 } else { 927 /* AF9035 */ 928 state->af9033_config[i].tuner = tmp; 929 } 930 931 if (state->af9033_config[i].tuner != tmp) { 932 dev_info(&intf->dev, "[%d] overriding tuner from %02x to %02x\n", 933 i, tmp, state->af9033_config[i].tuner); 934 } 935 936 switch (state->af9033_config[i].tuner) { 937 case AF9033_TUNER_TUA9001: 938 case AF9033_TUNER_FC0011: 939 case AF9033_TUNER_MXL5007T: 940 case AF9033_TUNER_TDA18218: 941 case AF9033_TUNER_FC2580: 942 case AF9033_TUNER_FC0012: 943 state->af9033_config[i].spec_inv = 1; 944 break; 945 case AF9033_TUNER_IT9135_38: 946 case AF9033_TUNER_IT9135_51: 947 case AF9033_TUNER_IT9135_52: 948 case AF9033_TUNER_IT9135_60: 949 case AF9033_TUNER_IT9135_61: 950 case AF9033_TUNER_IT9135_62: 951 break; 952 default: 953 dev_warn(&intf->dev, "tuner id=%02x not supported, please report!", 954 tmp); 955 } 956 957 /* disable dual mode if driver does not support it */ 958 if (i == 1) 959 switch (state->af9033_config[i].tuner) { 960 case AF9033_TUNER_FC0012: 961 case AF9033_TUNER_IT9135_38: 962 case AF9033_TUNER_IT9135_51: 963 case AF9033_TUNER_IT9135_52: 964 case AF9033_TUNER_IT9135_60: 965 case AF9033_TUNER_IT9135_61: 966 case AF9033_TUNER_IT9135_62: 967 case AF9033_TUNER_MXL5007T: 968 break; 969 default: 970 state->dual_mode = false; 971 dev_info(&intf->dev, "driver does not support 2nd tuner and will disable it"); 972 } 973 974 /* tuner IF frequency */ 975 tmp = state->eeprom[EEPROM_1_IF_L + eeprom_offset]; 976 tmp16 = tmp << 0; 977 tmp = state->eeprom[EEPROM_1_IF_H + eeprom_offset]; 978 tmp16 |= tmp << 8; 979 dev_dbg(&intf->dev, "[%d]IF=%d\n", i, tmp16); 980 981 eeprom_offset += 0x10; /* shift for the 2nd tuner params */ 982 } 983 984 skip_eeprom: 985 /* get demod clock */ 986 ret = af9035_rd_reg(d, 0x00d800, &tmp); 987 if (ret < 0) 988 goto err; 989 990 tmp = (tmp >> 0) & 0x0f; 991 992 for (i = 0; i < ARRAY_SIZE(state->af9033_config); i++) { 993 if (state->chip_type == 0x9135) 994 state->af9033_config[i].clock = clock_lut_it9135[tmp]; 995 else 996 state->af9033_config[i].clock = clock_lut_af9035[tmp]; 997 } 998 999 state->no_read = false; 1000 /* Some MXL5007T devices cannot properly handle tuner I2C read ops. */ 1001 if (state->af9033_config[0].tuner == AF9033_TUNER_MXL5007T && 1002 le16_to_cpu(d->udev->descriptor.idVendor) == USB_VID_AVERMEDIA) 1003 1004 switch (le16_to_cpu(d->udev->descriptor.idProduct)) { 1005 case USB_PID_AVERMEDIA_A867: 1006 case USB_PID_AVERMEDIA_TWINSTAR: 1007 dev_info(&intf->dev, 1008 "Device may have issues with I2C read operations. Enabling fix.\n"); 1009 state->no_read = true; 1010 break; 1011 } 1012 1013 return 0; 1014 1015 err: 1016 dev_dbg(&intf->dev, "failed=%d\n", ret); 1017 1018 return ret; 1019 } 1020 1021 static int af9035_tua9001_tuner_callback(struct dvb_usb_device *d, 1022 int cmd, int arg) 1023 { 1024 struct usb_interface *intf = d->intf; 1025 int ret; 1026 u8 val; 1027 1028 dev_dbg(&intf->dev, "cmd=%d arg=%d\n", cmd, arg); 1029 1030 /* 1031 * CEN always enabled by hardware wiring 1032 * RESETN GPIOT3 1033 * RXEN GPIOT2 1034 */ 1035 1036 switch (cmd) { 1037 case TUA9001_CMD_RESETN: 1038 if (arg) 1039 val = 0x00; 1040 else 1041 val = 0x01; 1042 1043 ret = af9035_wr_reg_mask(d, 0x00d8e7, val, 0x01); 1044 if (ret < 0) 1045 goto err; 1046 break; 1047 case TUA9001_CMD_RXEN: 1048 if (arg) 1049 val = 0x01; 1050 else 1051 val = 0x00; 1052 1053 ret = af9035_wr_reg_mask(d, 0x00d8eb, val, 0x01); 1054 if (ret < 0) 1055 goto err; 1056 break; 1057 } 1058 1059 return 0; 1060 1061 err: 1062 dev_dbg(&intf->dev, "failed=%d\n", ret); 1063 1064 return ret; 1065 } 1066 1067 1068 static int af9035_fc0011_tuner_callback(struct dvb_usb_device *d, 1069 int cmd, int arg) 1070 { 1071 struct usb_interface *intf = d->intf; 1072 int ret; 1073 1074 switch (cmd) { 1075 case FC0011_FE_CALLBACK_POWER: 1076 /* Tuner enable */ 1077 ret = af9035_wr_reg_mask(d, 0xd8eb, 1, 1); 1078 if (ret < 0) 1079 goto err; 1080 1081 ret = af9035_wr_reg_mask(d, 0xd8ec, 1, 1); 1082 if (ret < 0) 1083 goto err; 1084 1085 ret = af9035_wr_reg_mask(d, 0xd8ed, 1, 1); 1086 if (ret < 0) 1087 goto err; 1088 1089 /* LED */ 1090 ret = af9035_wr_reg_mask(d, 0xd8d0, 1, 1); 1091 if (ret < 0) 1092 goto err; 1093 1094 ret = af9035_wr_reg_mask(d, 0xd8d1, 1, 1); 1095 if (ret < 0) 1096 goto err; 1097 1098 usleep_range(10000, 50000); 1099 break; 1100 case FC0011_FE_CALLBACK_RESET: 1101 ret = af9035_wr_reg(d, 0xd8e9, 1); 1102 if (ret < 0) 1103 goto err; 1104 1105 ret = af9035_wr_reg(d, 0xd8e8, 1); 1106 if (ret < 0) 1107 goto err; 1108 1109 ret = af9035_wr_reg(d, 0xd8e7, 1); 1110 if (ret < 0) 1111 goto err; 1112 1113 usleep_range(10000, 20000); 1114 1115 ret = af9035_wr_reg(d, 0xd8e7, 0); 1116 if (ret < 0) 1117 goto err; 1118 1119 usleep_range(10000, 20000); 1120 break; 1121 default: 1122 ret = -EINVAL; 1123 goto err; 1124 } 1125 1126 return 0; 1127 1128 err: 1129 dev_dbg(&intf->dev, "failed=%d\n", ret); 1130 1131 return ret; 1132 } 1133 1134 static int af9035_tuner_callback(struct dvb_usb_device *d, int cmd, int arg) 1135 { 1136 struct state *state = d_to_priv(d); 1137 1138 switch (state->af9033_config[0].tuner) { 1139 case AF9033_TUNER_FC0011: 1140 return af9035_fc0011_tuner_callback(d, cmd, arg); 1141 case AF9033_TUNER_TUA9001: 1142 return af9035_tua9001_tuner_callback(d, cmd, arg); 1143 default: 1144 break; 1145 } 1146 1147 return 0; 1148 } 1149 1150 static int af9035_frontend_callback(void *adapter_priv, int component, 1151 int cmd, int arg) 1152 { 1153 struct i2c_adapter *adap = adapter_priv; 1154 struct dvb_usb_device *d = i2c_get_adapdata(adap); 1155 struct usb_interface *intf = d->intf; 1156 1157 dev_dbg(&intf->dev, "component=%d cmd=%d arg=%d\n", 1158 component, cmd, arg); 1159 1160 switch (component) { 1161 case DVB_FRONTEND_COMPONENT_TUNER: 1162 return af9035_tuner_callback(d, cmd, arg); 1163 default: 1164 break; 1165 } 1166 1167 return 0; 1168 } 1169 1170 static int af9035_get_adapter_count(struct dvb_usb_device *d) 1171 { 1172 struct state *state = d_to_priv(d); 1173 1174 return state->dual_mode + 1; 1175 } 1176 1177 static int af9035_frontend_attach(struct dvb_usb_adapter *adap) 1178 { 1179 struct state *state = adap_to_priv(adap); 1180 struct dvb_usb_device *d = adap_to_d(adap); 1181 struct usb_interface *intf = d->intf; 1182 int ret; 1183 1184 dev_dbg(&intf->dev, "adap->id=%d\n", adap->id); 1185 1186 if (!state->af9033_config[adap->id].tuner) { 1187 /* unsupported tuner */ 1188 ret = -ENODEV; 1189 goto err; 1190 } 1191 1192 state->af9033_config[adap->id].fe = &adap->fe[0]; 1193 state->af9033_config[adap->id].ops = &state->ops; 1194 ret = af9035_add_i2c_dev(d, "af9033", state->af9033_i2c_addr[adap->id], 1195 &state->af9033_config[adap->id], &d->i2c_adap); 1196 if (ret) 1197 goto err; 1198 1199 if (adap->fe[0] == NULL) { 1200 ret = -ENODEV; 1201 goto err; 1202 } 1203 1204 /* disable I2C-gate */ 1205 adap->fe[0]->ops.i2c_gate_ctrl = NULL; 1206 adap->fe[0]->callback = af9035_frontend_callback; 1207 1208 return 0; 1209 1210 err: 1211 dev_dbg(&intf->dev, "failed=%d\n", ret); 1212 1213 return ret; 1214 } 1215 1216 /* 1217 * The I2C speed register is calculated with: 1218 * I2C speed register = (1000000000 / (24.4 * 16 * I2C_speed)) 1219 * 1220 * The default speed register for it930x is 7, with means a 1221 * speed of ~366 kbps 1222 */ 1223 #define I2C_SPEED_366K 7 1224 1225 static int it930x_frontend_attach(struct dvb_usb_adapter *adap) 1226 { 1227 struct state *state = adap_to_priv(adap); 1228 struct dvb_usb_device *d = adap_to_d(adap); 1229 struct usb_interface *intf = d->intf; 1230 int ret; 1231 struct si2168_config si2168_config; 1232 struct i2c_adapter *adapter; 1233 1234 dev_dbg(&intf->dev, "adap->id=%d\n", adap->id); 1235 1236 /* I2C master bus 2 clock speed 366k */ 1237 ret = af9035_wr_reg(d, 0x00f6a7, I2C_SPEED_366K); 1238 if (ret < 0) 1239 goto err; 1240 1241 /* I2C master bus 1,3 clock speed 366k */ 1242 ret = af9035_wr_reg(d, 0x00f103, I2C_SPEED_366K); 1243 if (ret < 0) 1244 goto err; 1245 1246 /* set gpio11 low */ 1247 ret = af9035_wr_reg_mask(d, 0xd8d4, 0x01, 0x01); 1248 if (ret < 0) 1249 goto err; 1250 1251 ret = af9035_wr_reg_mask(d, 0xd8d5, 0x01, 0x01); 1252 if (ret < 0) 1253 goto err; 1254 1255 ret = af9035_wr_reg_mask(d, 0xd8d3, 0x01, 0x01); 1256 if (ret < 0) 1257 goto err; 1258 1259 /* Tuner enable using gpiot2_en, gpiot2_on and gpiot2_o (reset) */ 1260 ret = af9035_wr_reg_mask(d, 0xd8b8, 0x01, 0x01); 1261 if (ret < 0) 1262 goto err; 1263 1264 ret = af9035_wr_reg_mask(d, 0xd8b9, 0x01, 0x01); 1265 if (ret < 0) 1266 goto err; 1267 1268 ret = af9035_wr_reg_mask(d, 0xd8b7, 0x00, 0x01); 1269 if (ret < 0) 1270 goto err; 1271 1272 msleep(200); 1273 1274 ret = af9035_wr_reg_mask(d, 0xd8b7, 0x01, 0x01); 1275 if (ret < 0) 1276 goto err; 1277 1278 memset(&si2168_config, 0, sizeof(si2168_config)); 1279 si2168_config.i2c_adapter = &adapter; 1280 si2168_config.fe = &adap->fe[0]; 1281 si2168_config.ts_mode = SI2168_TS_SERIAL; 1282 1283 state->af9033_config[adap->id].fe = &adap->fe[0]; 1284 state->af9033_config[adap->id].ops = &state->ops; 1285 ret = af9035_add_i2c_dev(d, "si2168", 1286 it930x_addresses_table[state->it930x_addresses].frontend_i2c_addr, 1287 &si2168_config, &d->i2c_adap); 1288 if (ret) 1289 goto err; 1290 1291 if (adap->fe[0] == NULL) { 1292 ret = -ENODEV; 1293 goto err; 1294 } 1295 state->i2c_adapter_demod = adapter; 1296 1297 return 0; 1298 1299 err: 1300 dev_dbg(&intf->dev, "failed=%d\n", ret); 1301 1302 return ret; 1303 } 1304 1305 static int af9035_frontend_detach(struct dvb_usb_adapter *adap) 1306 { 1307 struct state *state = adap_to_priv(adap); 1308 struct dvb_usb_device *d = adap_to_d(adap); 1309 struct usb_interface *intf = d->intf; 1310 1311 dev_dbg(&intf->dev, "adap->id=%d\n", adap->id); 1312 1313 if (adap->id == 1) { 1314 if (state->i2c_client[1]) 1315 af9035_del_i2c_dev(d); 1316 } else if (adap->id == 0) { 1317 if (state->i2c_client[0]) 1318 af9035_del_i2c_dev(d); 1319 } 1320 1321 return 0; 1322 } 1323 1324 static const struct fc0011_config af9035_fc0011_config = { 1325 .i2c_address = 0x60, 1326 }; 1327 1328 static struct mxl5007t_config af9035_mxl5007t_config[] = { 1329 { 1330 .xtal_freq_hz = MxL_XTAL_24_MHZ, 1331 .if_freq_hz = MxL_IF_4_57_MHZ, 1332 .invert_if = 0, 1333 .loop_thru_enable = 0, 1334 .clk_out_enable = 0, 1335 .clk_out_amp = MxL_CLKOUT_AMP_0_94V, 1336 }, { 1337 .xtal_freq_hz = MxL_XTAL_24_MHZ, 1338 .if_freq_hz = MxL_IF_4_57_MHZ, 1339 .invert_if = 0, 1340 .loop_thru_enable = 1, 1341 .clk_out_enable = 1, 1342 .clk_out_amp = MxL_CLKOUT_AMP_0_94V, 1343 } 1344 }; 1345 1346 static struct tda18218_config af9035_tda18218_config = { 1347 .i2c_address = 0x60, 1348 .i2c_wr_max = 21, 1349 }; 1350 1351 static const struct fc0012_config af9035_fc0012_config[] = { 1352 { 1353 .i2c_address = 0x63, 1354 .xtal_freq = FC_XTAL_36_MHZ, 1355 .dual_master = true, 1356 .loop_through = true, 1357 .clock_out = true, 1358 }, { 1359 .i2c_address = 0x63 | 0x80, /* I2C bus select hack */ 1360 .xtal_freq = FC_XTAL_36_MHZ, 1361 .dual_master = true, 1362 } 1363 }; 1364 1365 static int af9035_tuner_attach(struct dvb_usb_adapter *adap) 1366 { 1367 struct state *state = adap_to_priv(adap); 1368 struct dvb_usb_device *d = adap_to_d(adap); 1369 struct usb_interface *intf = d->intf; 1370 int ret; 1371 struct dvb_frontend *fe; 1372 struct i2c_msg msg[1]; 1373 u8 tuner_addr; 1374 1375 dev_dbg(&intf->dev, "adap->id=%d\n", adap->id); 1376 1377 /* 1378 * XXX: Hack used in that function: we abuse unused I2C address bit [7] 1379 * to carry info about used I2C bus for dual tuner configuration. 1380 */ 1381 1382 switch (state->af9033_config[adap->id].tuner) { 1383 case AF9033_TUNER_TUA9001: { 1384 struct tua9001_platform_data tua9001_pdata = { 1385 .dvb_frontend = adap->fe[0], 1386 }; 1387 1388 /* 1389 * AF9035 gpiot3 = TUA9001 RESETN 1390 * AF9035 gpiot2 = TUA9001 RXEN 1391 */ 1392 1393 /* configure gpiot2 and gpiot2 as output */ 1394 ret = af9035_wr_reg_mask(d, 0x00d8ec, 0x01, 0x01); 1395 if (ret < 0) 1396 goto err; 1397 1398 ret = af9035_wr_reg_mask(d, 0x00d8ed, 0x01, 0x01); 1399 if (ret < 0) 1400 goto err; 1401 1402 ret = af9035_wr_reg_mask(d, 0x00d8e8, 0x01, 0x01); 1403 if (ret < 0) 1404 goto err; 1405 1406 ret = af9035_wr_reg_mask(d, 0x00d8e9, 0x01, 0x01); 1407 if (ret < 0) 1408 goto err; 1409 1410 /* attach tuner */ 1411 ret = af9035_add_i2c_dev(d, "tua9001", 0x60, &tua9001_pdata, 1412 &d->i2c_adap); 1413 if (ret) 1414 goto err; 1415 1416 fe = adap->fe[0]; 1417 break; 1418 } 1419 case AF9033_TUNER_FC0011: 1420 fe = dvb_attach(fc0011_attach, adap->fe[0], 1421 &d->i2c_adap, &af9035_fc0011_config); 1422 break; 1423 case AF9033_TUNER_MXL5007T: 1424 if (adap->id == 0) { 1425 ret = af9035_wr_reg(d, 0x00d8e0, 1); 1426 if (ret < 0) 1427 goto err; 1428 1429 ret = af9035_wr_reg(d, 0x00d8e1, 1); 1430 if (ret < 0) 1431 goto err; 1432 1433 ret = af9035_wr_reg(d, 0x00d8df, 0); 1434 if (ret < 0) 1435 goto err; 1436 1437 msleep(30); 1438 1439 ret = af9035_wr_reg(d, 0x00d8df, 1); 1440 if (ret < 0) 1441 goto err; 1442 1443 msleep(300); 1444 1445 ret = af9035_wr_reg(d, 0x00d8c0, 1); 1446 if (ret < 0) 1447 goto err; 1448 1449 ret = af9035_wr_reg(d, 0x00d8c1, 1); 1450 if (ret < 0) 1451 goto err; 1452 1453 ret = af9035_wr_reg(d, 0x00d8bf, 0); 1454 if (ret < 0) 1455 goto err; 1456 1457 ret = af9035_wr_reg(d, 0x00d8b4, 1); 1458 if (ret < 0) 1459 goto err; 1460 1461 ret = af9035_wr_reg(d, 0x00d8b5, 1); 1462 if (ret < 0) 1463 goto err; 1464 1465 ret = af9035_wr_reg(d, 0x00d8b3, 1); 1466 if (ret < 0) 1467 goto err; 1468 1469 tuner_addr = 0x60; 1470 } else { 1471 tuner_addr = 0x60 | 0x80; /* I2C bus hack */ 1472 } 1473 1474 /* attach tuner */ 1475 fe = dvb_attach(mxl5007t_attach, adap->fe[0], &d->i2c_adap, 1476 tuner_addr, &af9035_mxl5007t_config[adap->id]); 1477 break; 1478 case AF9033_TUNER_TDA18218: 1479 /* attach tuner */ 1480 fe = dvb_attach(tda18218_attach, adap->fe[0], 1481 &d->i2c_adap, &af9035_tda18218_config); 1482 break; 1483 case AF9033_TUNER_FC2580: { 1484 struct fc2580_platform_data fc2580_pdata = { 1485 .dvb_frontend = adap->fe[0], 1486 }; 1487 1488 /* Tuner enable using gpiot2_o, gpiot2_en and gpiot2_on */ 1489 ret = af9035_wr_reg_mask(d, 0xd8eb, 0x01, 0x01); 1490 if (ret < 0) 1491 goto err; 1492 1493 ret = af9035_wr_reg_mask(d, 0xd8ec, 0x01, 0x01); 1494 if (ret < 0) 1495 goto err; 1496 1497 ret = af9035_wr_reg_mask(d, 0xd8ed, 0x01, 0x01); 1498 if (ret < 0) 1499 goto err; 1500 1501 usleep_range(10000, 50000); 1502 /* attach tuner */ 1503 ret = af9035_add_i2c_dev(d, "fc2580", 0x56, &fc2580_pdata, 1504 &d->i2c_adap); 1505 if (ret) 1506 goto err; 1507 1508 fe = adap->fe[0]; 1509 break; 1510 } 1511 case AF9033_TUNER_FC0012: 1512 /* 1513 * AF9035 gpiot2 = FC0012 enable 1514 * XXX: there seems to be something on gpioh8 too, but on my 1515 * test I didn't find any difference. 1516 */ 1517 1518 if (adap->id == 0) { 1519 /* configure gpiot2 as output and high */ 1520 ret = af9035_wr_reg_mask(d, 0xd8eb, 0x01, 0x01); 1521 if (ret < 0) 1522 goto err; 1523 1524 ret = af9035_wr_reg_mask(d, 0xd8ec, 0x01, 0x01); 1525 if (ret < 0) 1526 goto err; 1527 1528 ret = af9035_wr_reg_mask(d, 0xd8ed, 0x01, 0x01); 1529 if (ret < 0) 1530 goto err; 1531 } else { 1532 /* 1533 * FIXME: That belongs for the FC0012 driver. 1534 * Write 02 to FC0012 master tuner register 0d directly 1535 * in order to make slave tuner working. 1536 */ 1537 msg[0].addr = 0x63; 1538 msg[0].flags = 0; 1539 msg[0].len = 2; 1540 msg[0].buf = "\x0d\x02"; 1541 ret = i2c_transfer(&d->i2c_adap, msg, 1); 1542 if (ret < 0) 1543 goto err; 1544 } 1545 1546 usleep_range(10000, 50000); 1547 1548 fe = dvb_attach(fc0012_attach, adap->fe[0], &d->i2c_adap, 1549 &af9035_fc0012_config[adap->id]); 1550 break; 1551 case AF9033_TUNER_IT9135_38: 1552 case AF9033_TUNER_IT9135_51: 1553 case AF9033_TUNER_IT9135_52: 1554 case AF9033_TUNER_IT9135_60: 1555 case AF9033_TUNER_IT9135_61: 1556 case AF9033_TUNER_IT9135_62: 1557 { 1558 struct platform_device *pdev; 1559 const char *name; 1560 struct it913x_platform_data it913x_pdata = { 1561 .regmap = state->af9033_config[adap->id].regmap, 1562 .fe = adap->fe[0], 1563 }; 1564 1565 switch (state->af9033_config[adap->id].tuner) { 1566 case AF9033_TUNER_IT9135_38: 1567 case AF9033_TUNER_IT9135_51: 1568 case AF9033_TUNER_IT9135_52: 1569 name = "it9133ax-tuner"; 1570 break; 1571 case AF9033_TUNER_IT9135_60: 1572 case AF9033_TUNER_IT9135_61: 1573 case AF9033_TUNER_IT9135_62: 1574 name = "it9133bx-tuner"; 1575 break; 1576 default: 1577 ret = -ENODEV; 1578 goto err; 1579 } 1580 1581 if (state->dual_mode) { 1582 if (adap->id == 0) 1583 it913x_pdata.role = IT913X_ROLE_DUAL_MASTER; 1584 else 1585 it913x_pdata.role = IT913X_ROLE_DUAL_SLAVE; 1586 } else { 1587 it913x_pdata.role = IT913X_ROLE_SINGLE; 1588 } 1589 1590 request_module("%s", "it913x"); 1591 pdev = platform_device_register_data(&d->intf->dev, name, 1592 PLATFORM_DEVID_AUTO, 1593 &it913x_pdata, 1594 sizeof(it913x_pdata)); 1595 if (IS_ERR(pdev) || !pdev->dev.driver) { 1596 ret = -ENODEV; 1597 goto err; 1598 } 1599 if (!try_module_get(pdev->dev.driver->owner)) { 1600 platform_device_unregister(pdev); 1601 ret = -ENODEV; 1602 goto err; 1603 } 1604 1605 state->platform_device_tuner[adap->id] = pdev; 1606 fe = adap->fe[0]; 1607 break; 1608 } 1609 default: 1610 fe = NULL; 1611 } 1612 1613 if (fe == NULL) { 1614 ret = -ENODEV; 1615 goto err; 1616 } 1617 1618 return 0; 1619 1620 err: 1621 dev_dbg(&intf->dev, "failed=%d\n", ret); 1622 1623 return ret; 1624 } 1625 1626 static int it930x_tuner_attach(struct dvb_usb_adapter *adap) 1627 { 1628 struct state *state = adap_to_priv(adap); 1629 struct dvb_usb_device *d = adap_to_d(adap); 1630 struct usb_interface *intf = d->intf; 1631 int ret; 1632 struct si2157_config si2157_config; 1633 1634 dev_dbg(&intf->dev, "adap->id=%d\n", adap->id); 1635 1636 memset(&si2157_config, 0, sizeof(si2157_config)); 1637 si2157_config.fe = adap->fe[0]; 1638 1639 /* 1640 * HACK: The Logilink VG0022A and TerraTec TC2 Stick have 1641 * a bug: when the si2157 firmware that came with the device 1642 * is replaced by a new one, the I2C transfers to the tuner 1643 * will return just 0xff. 1644 * 1645 * Probably, the vendor firmware has some patch specifically 1646 * designed for this device. So, we can't replace by the 1647 * generic firmware. The right solution would be to extract 1648 * the si2157 firmware from the original driver and ask the 1649 * driver to load the specifically designed firmware, but, 1650 * while we don't have that, the next best solution is to just 1651 * keep the original firmware at the device. 1652 */ 1653 if ((le16_to_cpu(d->udev->descriptor.idVendor) == USB_VID_DEXATEK && 1654 le16_to_cpu(d->udev->descriptor.idProduct) == 0x0100) || 1655 (le16_to_cpu(d->udev->descriptor.idVendor) == USB_VID_TERRATEC && 1656 le16_to_cpu(d->udev->descriptor.idProduct) == USB_PID_TERRATEC_CINERGY_TC2_STICK)) 1657 si2157_config.dont_load_firmware = true; 1658 1659 si2157_config.if_port = it930x_addresses_table[state->it930x_addresses].tuner_if_port; 1660 ret = af9035_add_i2c_dev(d, "si2157", 1661 it930x_addresses_table[state->it930x_addresses].tuner_i2c_addr, 1662 &si2157_config, state->i2c_adapter_demod); 1663 if (ret) 1664 goto err; 1665 1666 return 0; 1667 1668 err: 1669 dev_dbg(&intf->dev, "failed=%d\n", ret); 1670 1671 return ret; 1672 } 1673 1674 1675 static int it930x_tuner_detach(struct dvb_usb_adapter *adap) 1676 { 1677 struct state *state = adap_to_priv(adap); 1678 struct dvb_usb_device *d = adap_to_d(adap); 1679 struct usb_interface *intf = d->intf; 1680 1681 dev_dbg(&intf->dev, "adap->id=%d\n", adap->id); 1682 1683 if (adap->id == 1) { 1684 if (state->i2c_client[3]) 1685 af9035_del_i2c_dev(d); 1686 } else if (adap->id == 0) { 1687 if (state->i2c_client[1]) 1688 af9035_del_i2c_dev(d); 1689 } 1690 1691 return 0; 1692 } 1693 1694 1695 static int af9035_tuner_detach(struct dvb_usb_adapter *adap) 1696 { 1697 struct state *state = adap_to_priv(adap); 1698 struct dvb_usb_device *d = adap_to_d(adap); 1699 struct usb_interface *intf = d->intf; 1700 1701 dev_dbg(&intf->dev, "adap->id=%d\n", adap->id); 1702 1703 switch (state->af9033_config[adap->id].tuner) { 1704 case AF9033_TUNER_TUA9001: 1705 case AF9033_TUNER_FC2580: 1706 if (adap->id == 1) { 1707 if (state->i2c_client[3]) 1708 af9035_del_i2c_dev(d); 1709 } else if (adap->id == 0) { 1710 if (state->i2c_client[1]) 1711 af9035_del_i2c_dev(d); 1712 } 1713 break; 1714 case AF9033_TUNER_IT9135_38: 1715 case AF9033_TUNER_IT9135_51: 1716 case AF9033_TUNER_IT9135_52: 1717 case AF9033_TUNER_IT9135_60: 1718 case AF9033_TUNER_IT9135_61: 1719 case AF9033_TUNER_IT9135_62: 1720 { 1721 struct platform_device *pdev; 1722 1723 pdev = state->platform_device_tuner[adap->id]; 1724 if (pdev) { 1725 module_put(pdev->dev.driver->owner); 1726 platform_device_unregister(pdev); 1727 } 1728 break; 1729 } 1730 } 1731 1732 return 0; 1733 } 1734 1735 static int af9035_init(struct dvb_usb_device *d) 1736 { 1737 struct state *state = d_to_priv(d); 1738 struct usb_interface *intf = d->intf; 1739 int ret, i; 1740 u16 frame_size = (d->udev->speed == USB_SPEED_FULL ? 5 : 87) * 188 / 4; 1741 u8 packet_size = (d->udev->speed == USB_SPEED_FULL ? 64 : 512) / 4; 1742 struct reg_val_mask tab[] = { 1743 { 0x80f99d, 0x01, 0x01 }, 1744 { 0x80f9a4, 0x01, 0x01 }, 1745 { 0x00dd11, 0x00, 0x20 }, 1746 { 0x00dd11, 0x00, 0x40 }, 1747 { 0x00dd13, 0x00, 0x20 }, 1748 { 0x00dd13, 0x00, 0x40 }, 1749 { 0x00dd11, 0x20, 0x20 }, 1750 { 0x00dd88, (frame_size >> 0) & 0xff, 0xff}, 1751 { 0x00dd89, (frame_size >> 8) & 0xff, 0xff}, 1752 { 0x00dd0c, packet_size, 0xff}, 1753 { 0x00dd11, state->dual_mode << 6, 0x40 }, 1754 { 0x00dd8a, (frame_size >> 0) & 0xff, 0xff}, 1755 { 0x00dd8b, (frame_size >> 8) & 0xff, 0xff}, 1756 { 0x00dd0d, packet_size, 0xff }, 1757 { 0x80f9a3, state->dual_mode, 0x01 }, 1758 { 0x80f9cd, state->dual_mode, 0x01 }, 1759 { 0x80f99d, 0x00, 0x01 }, 1760 { 0x80f9a4, 0x00, 0x01 }, 1761 }; 1762 1763 dev_dbg(&intf->dev, "USB speed=%d frame_size=%04x packet_size=%02x\n", 1764 d->udev->speed, frame_size, packet_size); 1765 1766 /* init endpoints */ 1767 for (i = 0; i < ARRAY_SIZE(tab); i++) { 1768 ret = af9035_wr_reg_mask(d, tab[i].reg, tab[i].val, 1769 tab[i].mask); 1770 if (ret < 0) 1771 goto err; 1772 } 1773 1774 return 0; 1775 1776 err: 1777 dev_dbg(&intf->dev, "failed=%d\n", ret); 1778 1779 return ret; 1780 } 1781 1782 static int it930x_init(struct dvb_usb_device *d) 1783 { 1784 struct state *state = d_to_priv(d); 1785 struct usb_interface *intf = d->intf; 1786 int ret, i; 1787 u16 frame_size = (d->udev->speed == USB_SPEED_FULL ? 5 : 816) * 188 / 4; 1788 u8 packet_size = (d->udev->speed == USB_SPEED_FULL ? 64 : 512) / 4; 1789 struct reg_val_mask tab[] = { 1790 { 0x00da1a, 0x00, 0x01 }, /* ignore_sync_byte */ 1791 { 0x00f41f, 0x04, 0x04 }, /* dvbt_inten */ 1792 { 0x00da10, 0x00, 0x01 }, /* mpeg_full_speed */ 1793 { 0x00f41a, 0x01, 0x01 }, /* dvbt_en */ 1794 { 0x00da1d, 0x01, 0x01 }, /* mp2_sw_rst, reset EP4 */ 1795 { 0x00dd11, 0x00, 0x20 }, /* ep4_tx_en, disable EP4 */ 1796 { 0x00dd13, 0x00, 0x20 }, /* ep4_tx_nak, disable EP4 NAK */ 1797 { 0x00dd11, 0x20, 0x20 }, /* ep4_tx_en, enable EP4 */ 1798 { 0x00dd11, 0x00, 0x40 }, /* ep5_tx_en, disable EP5 */ 1799 { 0x00dd13, 0x00, 0x40 }, /* ep5_tx_nak, disable EP5 NAK */ 1800 { 0x00dd11, state->dual_mode << 6, 0x40 }, /* enable EP5 */ 1801 { 0x00dd88, (frame_size >> 0) & 0xff, 0xff}, 1802 { 0x00dd89, (frame_size >> 8) & 0xff, 0xff}, 1803 { 0x00dd0c, packet_size, 0xff}, 1804 { 0x00dd8a, (frame_size >> 0) & 0xff, 0xff}, 1805 { 0x00dd8b, (frame_size >> 8) & 0xff, 0xff}, 1806 { 0x00dd0d, packet_size, 0xff }, 1807 { 0x00da1d, 0x00, 0x01 }, /* mp2_sw_rst, disable */ 1808 { 0x00d833, 0x01, 0xff }, /* slew rate ctrl: slew rate boosts */ 1809 { 0x00d830, 0x00, 0xff }, /* Bit 0 of output driving control */ 1810 { 0x00d831, 0x01, 0xff }, /* Bit 1 of output driving control */ 1811 { 0x00d832, 0x00, 0xff }, /* Bit 2 of output driving control */ 1812 1813 /* suspend gpio1 for TS-C */ 1814 { 0x00d8b0, 0x01, 0xff }, /* gpio1 */ 1815 { 0x00d8b1, 0x01, 0xff }, /* gpio1 */ 1816 { 0x00d8af, 0x00, 0xff }, /* gpio1 */ 1817 1818 /* suspend gpio7 for TS-D */ 1819 { 0x00d8c4, 0x01, 0xff }, /* gpio7 */ 1820 { 0x00d8c5, 0x01, 0xff }, /* gpio7 */ 1821 { 0x00d8c3, 0x00, 0xff }, /* gpio7 */ 1822 1823 /* suspend gpio13 for TS-B */ 1824 { 0x00d8dc, 0x01, 0xff }, /* gpio13 */ 1825 { 0x00d8dd, 0x01, 0xff }, /* gpio13 */ 1826 { 0x00d8db, 0x00, 0xff }, /* gpio13 */ 1827 1828 /* suspend gpio14 for TS-E */ 1829 { 0x00d8e4, 0x01, 0xff }, /* gpio14 */ 1830 { 0x00d8e5, 0x01, 0xff }, /* gpio14 */ 1831 { 0x00d8e3, 0x00, 0xff }, /* gpio14 */ 1832 1833 /* suspend gpio15 for TS-A */ 1834 { 0x00d8e8, 0x01, 0xff }, /* gpio15 */ 1835 { 0x00d8e9, 0x01, 0xff }, /* gpio15 */ 1836 { 0x00d8e7, 0x00, 0xff }, /* gpio15 */ 1837 1838 { 0x00da58, 0x00, 0x01 }, /* ts_in_src, serial */ 1839 { 0x00da73, 0x01, 0xff }, /* ts0_aggre_mode */ 1840 { 0x00da78, 0x47, 0xff }, /* ts0_sync_byte */ 1841 { 0x00da4c, 0x01, 0xff }, /* ts0_en */ 1842 { 0x00da5a, 0x1f, 0xff }, /* ts_fail_ignore */ 1843 }; 1844 1845 dev_dbg(&intf->dev, "USB speed=%d frame_size=%04x packet_size=%02x\n", 1846 d->udev->speed, frame_size, packet_size); 1847 1848 /* init endpoints */ 1849 for (i = 0; i < ARRAY_SIZE(tab); i++) { 1850 ret = af9035_wr_reg_mask(d, tab[i].reg, 1851 tab[i].val, tab[i].mask); 1852 1853 if (ret < 0) 1854 goto err; 1855 } 1856 1857 return 0; 1858 err: 1859 dev_dbg(&intf->dev, "failed=%d\n", ret); 1860 1861 return ret; 1862 } 1863 1864 1865 #if IS_ENABLED(CONFIG_RC_CORE) 1866 static int af9035_rc_query(struct dvb_usb_device *d) 1867 { 1868 struct usb_interface *intf = d->intf; 1869 int ret; 1870 enum rc_proto proto; 1871 u32 key; 1872 u8 buf[4]; 1873 struct usb_req req = { CMD_IR_GET, 0, 0, NULL, 4, buf }; 1874 1875 ret = af9035_ctrl_msg(d, &req); 1876 if (ret == 1) 1877 return 0; 1878 else if (ret < 0) 1879 goto err; 1880 1881 if ((buf[2] + buf[3]) == 0xff) { 1882 if ((buf[0] + buf[1]) == 0xff) { 1883 /* NEC standard 16bit */ 1884 key = RC_SCANCODE_NEC(buf[0], buf[2]); 1885 proto = RC_PROTO_NEC; 1886 } else { 1887 /* NEC extended 24bit */ 1888 key = RC_SCANCODE_NECX(buf[0] << 8 | buf[1], buf[2]); 1889 proto = RC_PROTO_NECX; 1890 } 1891 } else { 1892 /* NEC full code 32bit */ 1893 key = RC_SCANCODE_NEC32(buf[0] << 24 | buf[1] << 16 | 1894 buf[2] << 8 | buf[3]); 1895 proto = RC_PROTO_NEC32; 1896 } 1897 1898 dev_dbg(&intf->dev, "%*ph\n", 4, buf); 1899 1900 rc_keydown(d->rc_dev, proto, key, 0); 1901 1902 return 0; 1903 1904 err: 1905 dev_dbg(&intf->dev, "failed=%d\n", ret); 1906 1907 return ret; 1908 } 1909 1910 static int af9035_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc) 1911 { 1912 struct state *state = d_to_priv(d); 1913 struct usb_interface *intf = d->intf; 1914 1915 dev_dbg(&intf->dev, "ir_mode=%02x ir_type=%02x\n", 1916 state->ir_mode, state->ir_type); 1917 1918 /* don't activate rc if in HID mode or if not available */ 1919 if (state->ir_mode == 0x05) { 1920 switch (state->ir_type) { 1921 case 0: /* NEC */ 1922 default: 1923 rc->allowed_protos = RC_PROTO_BIT_NEC | 1924 RC_PROTO_BIT_NECX | RC_PROTO_BIT_NEC32; 1925 break; 1926 case 1: /* RC6 */ 1927 rc->allowed_protos = RC_PROTO_BIT_RC6_MCE; 1928 break; 1929 } 1930 1931 rc->query = af9035_rc_query; 1932 rc->interval = 500; 1933 1934 /* load empty to enable rc */ 1935 if (!rc->map_name) 1936 rc->map_name = RC_MAP_EMPTY; 1937 } 1938 1939 return 0; 1940 } 1941 #else 1942 #define af9035_get_rc_config NULL 1943 #endif 1944 1945 static int af9035_get_stream_config(struct dvb_frontend *fe, u8 *ts_type, 1946 struct usb_data_stream_properties *stream) 1947 { 1948 struct dvb_usb_device *d = fe_to_d(fe); 1949 struct usb_interface *intf = d->intf; 1950 1951 dev_dbg(&intf->dev, "adap=%d\n", fe_to_adap(fe)->id); 1952 1953 if (d->udev->speed == USB_SPEED_FULL) 1954 stream->u.bulk.buffersize = 5 * 188; 1955 1956 return 0; 1957 } 1958 1959 static int af9035_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff) 1960 { 1961 struct state *state = adap_to_priv(adap); 1962 1963 return state->ops.pid_filter_ctrl(adap->fe[0], onoff); 1964 } 1965 1966 static int af9035_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid, 1967 int onoff) 1968 { 1969 struct state *state = adap_to_priv(adap); 1970 1971 return state->ops.pid_filter(adap->fe[0], index, pid, onoff); 1972 } 1973 1974 static int af9035_probe(struct usb_interface *intf, 1975 const struct usb_device_id *id) 1976 { 1977 struct usb_device *udev = interface_to_usbdev(intf); 1978 char manufacturer[sizeof("Afatech")]; 1979 1980 memset(manufacturer, 0, sizeof(manufacturer)); 1981 usb_string(udev, udev->descriptor.iManufacturer, 1982 manufacturer, sizeof(manufacturer)); 1983 /* 1984 * There is two devices having same ID but different chipset. One uses 1985 * AF9015 and the other IT9135 chipset. Only difference seen on lsusb 1986 * is iManufacturer string. 1987 * 1988 * idVendor 0x0ccd TerraTec Electronic GmbH 1989 * idProduct 0x0099 1990 * bcdDevice 2.00 1991 * iManufacturer 1 Afatech 1992 * iProduct 2 DVB-T 2 1993 * 1994 * idVendor 0x0ccd TerraTec Electronic GmbH 1995 * idProduct 0x0099 1996 * bcdDevice 2.00 1997 * iManufacturer 1 ITE Technologies, Inc. 1998 * iProduct 2 DVB-T TV Stick 1999 */ 2000 if ((le16_to_cpu(udev->descriptor.idVendor) == USB_VID_TERRATEC) && 2001 (le16_to_cpu(udev->descriptor.idProduct) == 0x0099)) { 2002 if (!strcmp("Afatech", manufacturer)) { 2003 dev_dbg(&udev->dev, "rejecting device\n"); 2004 return -ENODEV; 2005 } 2006 } 2007 2008 return dvb_usbv2_probe(intf, id); 2009 } 2010 2011 /* interface 0 is used by DVB-T receiver and 2012 interface 1 is for remote controller (HID) */ 2013 static const struct dvb_usb_device_properties af9035_props = { 2014 .driver_name = KBUILD_MODNAME, 2015 .owner = THIS_MODULE, 2016 .adapter_nr = adapter_nr, 2017 .size_of_priv = sizeof(struct state), 2018 2019 .generic_bulk_ctrl_endpoint = 0x02, 2020 .generic_bulk_ctrl_endpoint_response = 0x81, 2021 2022 .identify_state = af9035_identify_state, 2023 .download_firmware = af9035_download_firmware, 2024 2025 .i2c_algo = &af9035_i2c_algo, 2026 .read_config = af9035_read_config, 2027 .frontend_attach = af9035_frontend_attach, 2028 .frontend_detach = af9035_frontend_detach, 2029 .tuner_attach = af9035_tuner_attach, 2030 .tuner_detach = af9035_tuner_detach, 2031 .init = af9035_init, 2032 .get_rc_config = af9035_get_rc_config, 2033 .get_stream_config = af9035_get_stream_config, 2034 2035 .get_adapter_count = af9035_get_adapter_count, 2036 .adapter = { 2037 { 2038 .caps = DVB_USB_ADAP_HAS_PID_FILTER | 2039 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 2040 2041 .pid_filter_count = 32, 2042 .pid_filter_ctrl = af9035_pid_filter_ctrl, 2043 .pid_filter = af9035_pid_filter, 2044 2045 .stream = DVB_USB_STREAM_BULK(0x84, 6, 87 * 188), 2046 }, { 2047 .caps = DVB_USB_ADAP_HAS_PID_FILTER | 2048 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF, 2049 2050 .pid_filter_count = 32, 2051 .pid_filter_ctrl = af9035_pid_filter_ctrl, 2052 .pid_filter = af9035_pid_filter, 2053 2054 .stream = DVB_USB_STREAM_BULK(0x85, 6, 87 * 188), 2055 }, 2056 }, 2057 }; 2058 2059 static const struct dvb_usb_device_properties it930x_props = { 2060 .driver_name = KBUILD_MODNAME, 2061 .owner = THIS_MODULE, 2062 .adapter_nr = adapter_nr, 2063 .size_of_priv = sizeof(struct state), 2064 2065 .generic_bulk_ctrl_endpoint = 0x02, 2066 .generic_bulk_ctrl_endpoint_response = 0x81, 2067 2068 .identify_state = af9035_identify_state, 2069 .download_firmware = af9035_download_firmware, 2070 2071 .i2c_algo = &af9035_i2c_algo, 2072 .read_config = af9035_read_config, 2073 .frontend_attach = it930x_frontend_attach, 2074 .frontend_detach = af9035_frontend_detach, 2075 .tuner_attach = it930x_tuner_attach, 2076 .tuner_detach = it930x_tuner_detach, 2077 .init = it930x_init, 2078 /* 2079 * dvb_usbv2_remote_init() calls rc_config() only for those devices 2080 * which have non-empty rc_map, so it's safe to enable it for every IT930x 2081 */ 2082 .get_rc_config = af9035_get_rc_config, 2083 .get_stream_config = af9035_get_stream_config, 2084 2085 .get_adapter_count = af9035_get_adapter_count, 2086 .adapter = { 2087 { 2088 .stream = DVB_USB_STREAM_BULK(0x84, 4, 816 * 188), 2089 }, { 2090 .stream = DVB_USB_STREAM_BULK(0x85, 4, 816 * 188), 2091 }, 2092 }, 2093 }; 2094 2095 static const struct usb_device_id af9035_id_table[] = { 2096 /* AF9035 devices */ 2097 { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_9035, 2098 &af9035_props, "Afatech AF9035 reference design", NULL) }, 2099 { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_1000, 2100 &af9035_props, "Afatech AF9035 reference design", NULL) }, 2101 { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_1001, 2102 &af9035_props, "Afatech AF9035 reference design", NULL) }, 2103 { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_1002, 2104 &af9035_props, "Afatech AF9035 reference design", NULL) }, 2105 { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9035_1003, 2106 &af9035_props, "Afatech AF9035 reference design", NULL) }, 2107 { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_STICK, 2108 &af9035_props, "TerraTec Cinergy T Stick", NULL) }, 2109 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835, 2110 &af9035_props, "AVerMedia AVerTV Volar HD/PRO (A835)", NULL) }, 2111 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_B835, 2112 &af9035_props, "AVerMedia AVerTV Volar HD/PRO (A835)", NULL) }, 2113 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_1867, 2114 &af9035_props, "AVerMedia HD Volar (A867)", NULL) }, 2115 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A867, 2116 &af9035_props, "AVerMedia HD Volar (A867)", NULL) }, 2117 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_TWINSTAR, 2118 &af9035_props, "AVerMedia Twinstar (A825)", NULL) }, 2119 { DVB_USB_DEVICE(USB_VID_ASUS, USB_PID_ASUS_U3100MINI_PLUS, 2120 &af9035_props, "Asus U3100Mini Plus", NULL) }, 2121 { DVB_USB_DEVICE(USB_VID_TERRATEC, 0x00aa, 2122 &af9035_props, "TerraTec Cinergy T Stick (rev. 2)", NULL) }, 2123 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, 0x0337, 2124 &af9035_props, "AVerMedia HD Volar (A867)", NULL) }, 2125 { DVB_USB_DEVICE(USB_VID_GTEK, USB_PID_EVOLVEO_XTRATV_STICK, 2126 &af9035_props, "EVOLVEO XtraTV stick", NULL) }, 2127 2128 /* IT9135 devices */ 2129 { DVB_USB_DEVICE(USB_VID_ITETECH, USB_PID_ITETECH_IT9135, 2130 &af9035_props, "ITE 9135 Generic", RC_MAP_IT913X_V1) }, 2131 { DVB_USB_DEVICE(USB_VID_ITETECH, USB_PID_ITETECH_IT9135_9005, 2132 &af9035_props, "ITE 9135(9005) Generic", RC_MAP_IT913X_V2) }, 2133 { DVB_USB_DEVICE(USB_VID_ITETECH, USB_PID_ITETECH_IT9135_9006, 2134 &af9035_props, "ITE 9135(9006) Generic", RC_MAP_IT913X_V1) }, 2135 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835B_1835, 2136 &af9035_props, "Avermedia A835B(1835)", RC_MAP_IT913X_V2) }, 2137 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835B_2835, 2138 &af9035_props, "Avermedia A835B(2835)", RC_MAP_IT913X_V2) }, 2139 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835B_3835, 2140 &af9035_props, "Avermedia A835B(3835)", RC_MAP_IT913X_V2) }, 2141 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A835B_4835, 2142 &af9035_props, "Avermedia A835B(4835)", RC_MAP_IT913X_V2) }, 2143 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_TD110, 2144 &af9035_props, "Avermedia AverTV Volar HD 2 (TD110)", RC_MAP_AVERMEDIA_RM_KS) }, 2145 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_H335, 2146 &af9035_props, "Avermedia H335", RC_MAP_IT913X_V2) }, 2147 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_UB499_2T_T09, 2148 &af9035_props, "Kworld UB499-2T T09", RC_MAP_IT913X_V1) }, 2149 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV22_IT9137, 2150 &af9035_props, "Sveon STV22 Dual DVB-T HDTV", 2151 RC_MAP_IT913X_V1) }, 2152 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_CTVDIGDUAL_V2, 2153 &af9035_props, "Digital Dual TV Receiver CTVDIGDUAL_V2", 2154 RC_MAP_IT913X_V1) }, 2155 { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_T1, 2156 &af9035_props, "TerraTec T1", RC_MAP_IT913X_V1) }, 2157 /* XXX: that same ID [0ccd:0099] is used by af9015 driver too */ 2158 { DVB_USB_DEVICE(USB_VID_TERRATEC, 0x0099, 2159 &af9035_props, "TerraTec Cinergy T Stick Dual RC (rev. 2)", 2160 NULL) }, 2161 { DVB_USB_DEVICE(USB_VID_LEADTEK, 0x6a05, 2162 &af9035_props, "Leadtek WinFast DTV Dongle Dual", NULL) }, 2163 { DVB_USB_DEVICE(USB_VID_HAUPPAUGE, 0xf900, 2164 &af9035_props, "Hauppauge WinTV-MiniStick 2", NULL) }, 2165 { DVB_USB_DEVICE(USB_VID_PCTV, USB_PID_PCTV_78E, 2166 &af9035_props, "PCTV AndroiDTV (78e)", RC_MAP_IT913X_V1) }, 2167 { DVB_USB_DEVICE(USB_VID_PCTV, USB_PID_PCTV_79E, 2168 &af9035_props, "PCTV microStick (79e)", RC_MAP_IT913X_V2) }, 2169 2170 /* IT930x devices */ 2171 { DVB_USB_DEVICE(USB_VID_ITETECH, USB_PID_ITETECH_IT9303, 2172 &it930x_props, "ITE 9303 Generic", NULL) }, 2173 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_TD310, 2174 &it930x_props, "AVerMedia TD310 DVB-T2", RC_MAP_AVERMEDIA_RM_KS) }, 2175 { DVB_USB_DEVICE(USB_VID_DEXATEK, 0x0100, 2176 &it930x_props, "Logilink VG0022A", NULL) }, 2177 { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_TC2_STICK, 2178 &it930x_props, "TerraTec Cinergy TC2 Stick", NULL) }, 2179 { } 2180 }; 2181 MODULE_DEVICE_TABLE(usb, af9035_id_table); 2182 2183 static struct usb_driver af9035_usb_driver = { 2184 .name = KBUILD_MODNAME, 2185 .id_table = af9035_id_table, 2186 .probe = af9035_probe, 2187 .disconnect = dvb_usbv2_disconnect, 2188 .suspend = dvb_usbv2_suspend, 2189 .resume = dvb_usbv2_resume, 2190 .reset_resume = dvb_usbv2_reset_resume, 2191 .no_dynamic_id = 1, 2192 .soft_unbind = 1, 2193 }; 2194 2195 module_usb_driver(af9035_usb_driver); 2196 2197 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); 2198 MODULE_DESCRIPTION("Afatech AF9035 driver"); 2199 MODULE_LICENSE("GPL"); 2200 MODULE_FIRMWARE(AF9035_FIRMWARE_AF9035); 2201 MODULE_FIRMWARE(AF9035_FIRMWARE_IT9135_V1); 2202 MODULE_FIRMWARE(AF9035_FIRMWARE_IT9135_V2); 2203 MODULE_FIRMWARE(AF9035_FIRMWARE_IT9303); 2204