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