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