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