1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * NXP TDA10071 + Conexant CX24118A DVB-S/S2 demodulator + tuner driver 4 * 5 * Copyright (C) 2011 Antti Palosaari <crope@iki.fi> 6 */ 7 8 #include "tda10071_priv.h" 9 10 static const struct dvb_frontend_ops tda10071_ops; 11 12 /* 13 * XXX: regmap_update_bits() does not fit our needs as it does not support 14 * partially volatile registers. Also it performs register read even mask is as 15 * wide as register value. 16 */ 17 /* write single register with mask */ 18 static int tda10071_wr_reg_mask(struct tda10071_dev *dev, 19 u8 reg, u8 val, u8 mask) 20 { 21 int ret; 22 u8 tmp; 23 24 /* no need for read if whole reg is written */ 25 if (mask != 0xff) { 26 ret = regmap_bulk_read(dev->regmap, reg, &tmp, 1); 27 if (ret) 28 return ret; 29 30 val &= mask; 31 tmp &= ~mask; 32 val |= tmp; 33 } 34 35 return regmap_bulk_write(dev->regmap, reg, &val, 1); 36 } 37 38 /* execute firmware command */ 39 static int tda10071_cmd_execute(struct tda10071_dev *dev, 40 struct tda10071_cmd *cmd) 41 { 42 struct i2c_client *client = dev->client; 43 int ret, i; 44 unsigned int uitmp; 45 46 if (!dev->warm) { 47 ret = -EFAULT; 48 goto error; 49 } 50 51 mutex_lock(&dev->cmd_execute_mutex); 52 53 /* write cmd and args for firmware */ 54 ret = regmap_bulk_write(dev->regmap, 0x00, cmd->args, cmd->len); 55 if (ret) 56 goto error_mutex_unlock; 57 58 /* start cmd execution */ 59 ret = regmap_write(dev->regmap, 0x1f, 1); 60 if (ret) 61 goto error_mutex_unlock; 62 63 /* wait cmd execution terminate */ 64 for (i = 1000, uitmp = 1; i && uitmp; i--) { 65 ret = regmap_read(dev->regmap, 0x1f, &uitmp); 66 if (ret) 67 goto error_mutex_unlock; 68 69 usleep_range(200, 5000); 70 } 71 72 mutex_unlock(&dev->cmd_execute_mutex); 73 dev_dbg(&client->dev, "loop=%d\n", i); 74 75 if (i == 0) { 76 ret = -ETIMEDOUT; 77 goto error; 78 } 79 80 return ret; 81 error_mutex_unlock: 82 mutex_unlock(&dev->cmd_execute_mutex); 83 error: 84 dev_dbg(&client->dev, "failed=%d\n", ret); 85 return ret; 86 } 87 88 static int tda10071_set_tone(struct dvb_frontend *fe, 89 enum fe_sec_tone_mode fe_sec_tone_mode) 90 { 91 struct tda10071_dev *dev = fe->demodulator_priv; 92 struct i2c_client *client = dev->client; 93 struct tda10071_cmd cmd; 94 int ret; 95 u8 tone; 96 97 if (!dev->warm) { 98 ret = -EFAULT; 99 goto error; 100 } 101 102 dev_dbg(&client->dev, "tone_mode=%d\n", fe_sec_tone_mode); 103 104 switch (fe_sec_tone_mode) { 105 case SEC_TONE_ON: 106 tone = 1; 107 break; 108 case SEC_TONE_OFF: 109 tone = 0; 110 break; 111 default: 112 dev_dbg(&client->dev, "invalid fe_sec_tone_mode\n"); 113 ret = -EINVAL; 114 goto error; 115 } 116 117 cmd.args[0] = CMD_LNB_PCB_CONFIG; 118 cmd.args[1] = 0; 119 cmd.args[2] = 0x00; 120 cmd.args[3] = 0x00; 121 cmd.args[4] = tone; 122 cmd.len = 5; 123 ret = tda10071_cmd_execute(dev, &cmd); 124 if (ret) 125 goto error; 126 127 return ret; 128 error: 129 dev_dbg(&client->dev, "failed=%d\n", ret); 130 return ret; 131 } 132 133 static int tda10071_set_voltage(struct dvb_frontend *fe, 134 enum fe_sec_voltage fe_sec_voltage) 135 { 136 struct tda10071_dev *dev = fe->demodulator_priv; 137 struct i2c_client *client = dev->client; 138 struct tda10071_cmd cmd; 139 int ret; 140 u8 voltage; 141 142 if (!dev->warm) { 143 ret = -EFAULT; 144 goto error; 145 } 146 147 dev_dbg(&client->dev, "voltage=%d\n", fe_sec_voltage); 148 149 switch (fe_sec_voltage) { 150 case SEC_VOLTAGE_13: 151 voltage = 0; 152 break; 153 case SEC_VOLTAGE_18: 154 voltage = 1; 155 break; 156 case SEC_VOLTAGE_OFF: 157 voltage = 0; 158 break; 159 default: 160 dev_dbg(&client->dev, "invalid fe_sec_voltage\n"); 161 ret = -EINVAL; 162 goto error; 163 } 164 165 cmd.args[0] = CMD_LNB_SET_DC_LEVEL; 166 cmd.args[1] = 0; 167 cmd.args[2] = voltage; 168 cmd.len = 3; 169 ret = tda10071_cmd_execute(dev, &cmd); 170 if (ret) 171 goto error; 172 173 return ret; 174 error: 175 dev_dbg(&client->dev, "failed=%d\n", ret); 176 return ret; 177 } 178 179 static int tda10071_diseqc_send_master_cmd(struct dvb_frontend *fe, 180 struct dvb_diseqc_master_cmd *diseqc_cmd) 181 { 182 struct tda10071_dev *dev = fe->demodulator_priv; 183 struct i2c_client *client = dev->client; 184 struct tda10071_cmd cmd; 185 int ret, i; 186 unsigned int uitmp; 187 188 if (!dev->warm) { 189 ret = -EFAULT; 190 goto error; 191 } 192 193 dev_dbg(&client->dev, "msg_len=%d\n", diseqc_cmd->msg_len); 194 195 if (diseqc_cmd->msg_len < 3 || diseqc_cmd->msg_len > 6) { 196 ret = -EINVAL; 197 goto error; 198 } 199 200 /* wait LNB TX */ 201 for (i = 500, uitmp = 0; i && !uitmp; i--) { 202 ret = regmap_read(dev->regmap, 0x47, &uitmp); 203 if (ret) 204 goto error; 205 uitmp = (uitmp >> 0) & 1; 206 usleep_range(10000, 20000); 207 } 208 209 dev_dbg(&client->dev, "loop=%d\n", i); 210 211 if (i == 0) { 212 ret = -ETIMEDOUT; 213 goto error; 214 } 215 216 ret = regmap_update_bits(dev->regmap, 0x47, 0x01, 0x00); 217 if (ret) 218 goto error; 219 220 cmd.args[0] = CMD_LNB_SEND_DISEQC; 221 cmd.args[1] = 0; 222 cmd.args[2] = 0; 223 cmd.args[3] = 0; 224 cmd.args[4] = 2; 225 cmd.args[5] = 0; 226 cmd.args[6] = diseqc_cmd->msg_len; 227 memcpy(&cmd.args[7], diseqc_cmd->msg, diseqc_cmd->msg_len); 228 cmd.len = 7 + diseqc_cmd->msg_len; 229 ret = tda10071_cmd_execute(dev, &cmd); 230 if (ret) 231 goto error; 232 233 return ret; 234 error: 235 dev_dbg(&client->dev, "failed=%d\n", ret); 236 return ret; 237 } 238 239 static int tda10071_diseqc_recv_slave_reply(struct dvb_frontend *fe, 240 struct dvb_diseqc_slave_reply *reply) 241 { 242 struct tda10071_dev *dev = fe->demodulator_priv; 243 struct i2c_client *client = dev->client; 244 struct tda10071_cmd cmd; 245 int ret, i; 246 unsigned int uitmp; 247 248 if (!dev->warm) { 249 ret = -EFAULT; 250 goto error; 251 } 252 253 dev_dbg(&client->dev, "\n"); 254 255 /* wait LNB RX */ 256 for (i = 500, uitmp = 0; i && !uitmp; i--) { 257 ret = regmap_read(dev->regmap, 0x47, &uitmp); 258 if (ret) 259 goto error; 260 uitmp = (uitmp >> 1) & 1; 261 usleep_range(10000, 20000); 262 } 263 264 dev_dbg(&client->dev, "loop=%d\n", i); 265 266 if (i == 0) { 267 ret = -ETIMEDOUT; 268 goto error; 269 } 270 271 /* reply len */ 272 ret = regmap_read(dev->regmap, 0x46, &uitmp); 273 if (ret) 274 goto error; 275 276 reply->msg_len = uitmp & 0x1f; /* [4:0] */ 277 if (reply->msg_len > sizeof(reply->msg)) 278 reply->msg_len = sizeof(reply->msg); /* truncate API max */ 279 280 /* read reply */ 281 cmd.args[0] = CMD_LNB_UPDATE_REPLY; 282 cmd.args[1] = 0; 283 cmd.len = 2; 284 ret = tda10071_cmd_execute(dev, &cmd); 285 if (ret) 286 goto error; 287 288 ret = regmap_bulk_read(dev->regmap, cmd.len, reply->msg, 289 reply->msg_len); 290 if (ret) 291 goto error; 292 293 return ret; 294 error: 295 dev_dbg(&client->dev, "failed=%d\n", ret); 296 return ret; 297 } 298 299 static int tda10071_diseqc_send_burst(struct dvb_frontend *fe, 300 enum fe_sec_mini_cmd fe_sec_mini_cmd) 301 { 302 struct tda10071_dev *dev = fe->demodulator_priv; 303 struct i2c_client *client = dev->client; 304 struct tda10071_cmd cmd; 305 int ret, i; 306 unsigned int uitmp; 307 u8 burst; 308 309 if (!dev->warm) { 310 ret = -EFAULT; 311 goto error; 312 } 313 314 dev_dbg(&client->dev, "fe_sec_mini_cmd=%d\n", fe_sec_mini_cmd); 315 316 switch (fe_sec_mini_cmd) { 317 case SEC_MINI_A: 318 burst = 0; 319 break; 320 case SEC_MINI_B: 321 burst = 1; 322 break; 323 default: 324 dev_dbg(&client->dev, "invalid fe_sec_mini_cmd\n"); 325 ret = -EINVAL; 326 goto error; 327 } 328 329 /* wait LNB TX */ 330 for (i = 500, uitmp = 0; i && !uitmp; i--) { 331 ret = regmap_read(dev->regmap, 0x47, &uitmp); 332 if (ret) 333 goto error; 334 uitmp = (uitmp >> 0) & 1; 335 usleep_range(10000, 20000); 336 } 337 338 dev_dbg(&client->dev, "loop=%d\n", i); 339 340 if (i == 0) { 341 ret = -ETIMEDOUT; 342 goto error; 343 } 344 345 ret = regmap_update_bits(dev->regmap, 0x47, 0x01, 0x00); 346 if (ret) 347 goto error; 348 349 cmd.args[0] = CMD_LNB_SEND_TONEBURST; 350 cmd.args[1] = 0; 351 cmd.args[2] = burst; 352 cmd.len = 3; 353 ret = tda10071_cmd_execute(dev, &cmd); 354 if (ret) 355 goto error; 356 357 return ret; 358 error: 359 dev_dbg(&client->dev, "failed=%d\n", ret); 360 return ret; 361 } 362 363 static int tda10071_read_status(struct dvb_frontend *fe, enum fe_status *status) 364 { 365 struct tda10071_dev *dev = fe->demodulator_priv; 366 struct i2c_client *client = dev->client; 367 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 368 struct tda10071_cmd cmd; 369 int ret; 370 unsigned int uitmp; 371 u8 buf[8]; 372 373 *status = 0; 374 375 if (!dev->warm) { 376 ret = 0; 377 goto error; 378 } 379 380 ret = regmap_read(dev->regmap, 0x39, &uitmp); 381 if (ret) 382 goto error; 383 384 /* 0x39[0] tuner PLL */ 385 if (uitmp & 0x02) /* demod PLL */ 386 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER; 387 if (uitmp & 0x04) /* viterbi or LDPC*/ 388 *status |= FE_HAS_VITERBI; 389 if (uitmp & 0x08) /* RS or BCH */ 390 *status |= FE_HAS_SYNC | FE_HAS_LOCK; 391 392 dev->fe_status = *status; 393 394 /* signal strength */ 395 if (dev->fe_status & FE_HAS_SIGNAL) { 396 cmd.args[0] = CMD_GET_AGCACC; 397 cmd.args[1] = 0; 398 cmd.len = 2; 399 ret = tda10071_cmd_execute(dev, &cmd); 400 if (ret) 401 goto error; 402 403 /* input power estimate dBm */ 404 ret = regmap_read(dev->regmap, 0x50, &uitmp); 405 if (ret) 406 goto error; 407 408 c->strength.stat[0].scale = FE_SCALE_DECIBEL; 409 c->strength.stat[0].svalue = (int) (uitmp - 256) * 1000; 410 } else { 411 c->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 412 } 413 414 /* CNR */ 415 if (dev->fe_status & FE_HAS_VITERBI) { 416 /* Es/No */ 417 ret = regmap_bulk_read(dev->regmap, 0x3a, buf, 2); 418 if (ret) 419 goto error; 420 421 c->cnr.stat[0].scale = FE_SCALE_DECIBEL; 422 c->cnr.stat[0].svalue = (buf[0] << 8 | buf[1] << 0) * 100; 423 } else { 424 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 425 } 426 427 /* UCB/PER/BER */ 428 if (dev->fe_status & FE_HAS_LOCK) { 429 /* TODO: report total bits/packets */ 430 u8 delivery_system, reg, len; 431 432 switch (dev->delivery_system) { 433 case SYS_DVBS: 434 reg = 0x4c; 435 len = 8; 436 delivery_system = 1; 437 break; 438 case SYS_DVBS2: 439 reg = 0x4d; 440 len = 4; 441 delivery_system = 0; 442 break; 443 default: 444 ret = -EINVAL; 445 goto error; 446 } 447 448 ret = regmap_read(dev->regmap, reg, &uitmp); 449 if (ret) 450 goto error; 451 452 if (dev->meas_count == uitmp) { 453 dev_dbg(&client->dev, "meas not ready=%02x\n", uitmp); 454 ret = 0; 455 goto error; 456 } else { 457 dev->meas_count = uitmp; 458 } 459 460 cmd.args[0] = CMD_BER_UPDATE_COUNTERS; 461 cmd.args[1] = 0; 462 cmd.args[2] = delivery_system; 463 cmd.len = 3; 464 ret = tda10071_cmd_execute(dev, &cmd); 465 if (ret) 466 goto error; 467 468 ret = regmap_bulk_read(dev->regmap, cmd.len, buf, len); 469 if (ret) 470 goto error; 471 472 if (dev->delivery_system == SYS_DVBS) { 473 dev->dvbv3_ber = buf[0] << 24 | buf[1] << 16 | 474 buf[2] << 8 | buf[3] << 0; 475 dev->post_bit_error += buf[0] << 24 | buf[1] << 16 | 476 buf[2] << 8 | buf[3] << 0; 477 c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER; 478 c->post_bit_error.stat[0].uvalue = dev->post_bit_error; 479 dev->block_error += buf[4] << 8 | buf[5] << 0; 480 c->block_error.stat[0].scale = FE_SCALE_COUNTER; 481 c->block_error.stat[0].uvalue = dev->block_error; 482 } else { 483 dev->dvbv3_ber = buf[0] << 8 | buf[1] << 0; 484 dev->post_bit_error += buf[0] << 8 | buf[1] << 0; 485 c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER; 486 c->post_bit_error.stat[0].uvalue = dev->post_bit_error; 487 c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 488 } 489 } else { 490 c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 491 c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 492 } 493 494 return ret; 495 error: 496 dev_dbg(&client->dev, "failed=%d\n", ret); 497 return ret; 498 } 499 500 static int tda10071_read_snr(struct dvb_frontend *fe, u16 *snr) 501 { 502 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 503 504 if (c->cnr.stat[0].scale == FE_SCALE_DECIBEL) 505 *snr = div_s64(c->cnr.stat[0].svalue, 100); 506 else 507 *snr = 0; 508 return 0; 509 } 510 511 static int tda10071_read_signal_strength(struct dvb_frontend *fe, u16 *strength) 512 { 513 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 514 unsigned int uitmp; 515 516 if (c->strength.stat[0].scale == FE_SCALE_DECIBEL) { 517 uitmp = div_s64(c->strength.stat[0].svalue, 1000) + 256; 518 uitmp = clamp(uitmp, 181U, 236U); /* -75dBm - -20dBm */ 519 /* scale value to 0x0000-0xffff */ 520 *strength = (uitmp-181) * 0xffff / (236-181); 521 } else { 522 *strength = 0; 523 } 524 return 0; 525 } 526 527 static int tda10071_read_ber(struct dvb_frontend *fe, u32 *ber) 528 { 529 struct tda10071_dev *dev = fe->demodulator_priv; 530 531 *ber = dev->dvbv3_ber; 532 return 0; 533 } 534 535 static int tda10071_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks) 536 { 537 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 538 539 if (c->block_error.stat[0].scale == FE_SCALE_COUNTER) 540 *ucblocks = c->block_error.stat[0].uvalue; 541 else 542 *ucblocks = 0; 543 return 0; 544 } 545 546 static int tda10071_set_frontend(struct dvb_frontend *fe) 547 { 548 struct tda10071_dev *dev = fe->demodulator_priv; 549 struct i2c_client *client = dev->client; 550 struct tda10071_cmd cmd; 551 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 552 int ret, i; 553 u8 mode, rolloff, pilot, inversion, div; 554 enum fe_modulation modulation; 555 556 dev_dbg(&client->dev, 557 "delivery_system=%d modulation=%d frequency=%u symbol_rate=%d inversion=%d pilot=%d rolloff=%d\n", 558 c->delivery_system, c->modulation, c->frequency, c->symbol_rate, 559 c->inversion, c->pilot, c->rolloff); 560 561 dev->delivery_system = SYS_UNDEFINED; 562 563 if (!dev->warm) { 564 ret = -EFAULT; 565 goto error; 566 } 567 568 switch (c->inversion) { 569 case INVERSION_OFF: 570 inversion = 1; 571 break; 572 case INVERSION_ON: 573 inversion = 0; 574 break; 575 case INVERSION_AUTO: 576 /* 2 = auto; try first on then off 577 * 3 = auto; try first off then on */ 578 inversion = 3; 579 break; 580 default: 581 dev_dbg(&client->dev, "invalid inversion\n"); 582 ret = -EINVAL; 583 goto error; 584 } 585 586 switch (c->delivery_system) { 587 case SYS_DVBS: 588 modulation = QPSK; 589 rolloff = 0; 590 pilot = 2; 591 break; 592 case SYS_DVBS2: 593 modulation = c->modulation; 594 595 switch (c->rolloff) { 596 case ROLLOFF_20: 597 rolloff = 2; 598 break; 599 case ROLLOFF_25: 600 rolloff = 1; 601 break; 602 case ROLLOFF_35: 603 rolloff = 0; 604 break; 605 case ROLLOFF_AUTO: 606 default: 607 dev_dbg(&client->dev, "invalid rolloff\n"); 608 ret = -EINVAL; 609 goto error; 610 } 611 612 switch (c->pilot) { 613 case PILOT_OFF: 614 pilot = 0; 615 break; 616 case PILOT_ON: 617 pilot = 1; 618 break; 619 case PILOT_AUTO: 620 pilot = 2; 621 break; 622 default: 623 dev_dbg(&client->dev, "invalid pilot\n"); 624 ret = -EINVAL; 625 goto error; 626 } 627 break; 628 default: 629 dev_dbg(&client->dev, "invalid delivery_system\n"); 630 ret = -EINVAL; 631 goto error; 632 } 633 634 for (i = 0, mode = 0xff; i < ARRAY_SIZE(TDA10071_MODCOD); i++) { 635 if (c->delivery_system == TDA10071_MODCOD[i].delivery_system && 636 modulation == TDA10071_MODCOD[i].modulation && 637 c->fec_inner == TDA10071_MODCOD[i].fec) { 638 mode = TDA10071_MODCOD[i].val; 639 dev_dbg(&client->dev, "mode found=%02x\n", mode); 640 break; 641 } 642 } 643 644 if (mode == 0xff) { 645 dev_dbg(&client->dev, "invalid parameter combination\n"); 646 ret = -EINVAL; 647 goto error; 648 } 649 650 if (c->symbol_rate <= 5000000) 651 div = 14; 652 else 653 div = 4; 654 655 ret = regmap_write(dev->regmap, 0x81, div); 656 if (ret) 657 goto error; 658 659 ret = regmap_write(dev->regmap, 0xe3, div); 660 if (ret) 661 goto error; 662 663 cmd.args[0] = CMD_CHANGE_CHANNEL; 664 cmd.args[1] = 0; 665 cmd.args[2] = mode; 666 cmd.args[3] = (c->frequency >> 16) & 0xff; 667 cmd.args[4] = (c->frequency >> 8) & 0xff; 668 cmd.args[5] = (c->frequency >> 0) & 0xff; 669 cmd.args[6] = ((c->symbol_rate / 1000) >> 8) & 0xff; 670 cmd.args[7] = ((c->symbol_rate / 1000) >> 0) & 0xff; 671 cmd.args[8] = ((tda10071_ops.info.frequency_tolerance_hz / 1000) >> 8) & 0xff; 672 cmd.args[9] = ((tda10071_ops.info.frequency_tolerance_hz / 1000) >> 0) & 0xff; 673 cmd.args[10] = rolloff; 674 cmd.args[11] = inversion; 675 cmd.args[12] = pilot; 676 cmd.args[13] = 0x00; 677 cmd.args[14] = 0x00; 678 cmd.len = 15; 679 ret = tda10071_cmd_execute(dev, &cmd); 680 if (ret) 681 goto error; 682 683 dev->delivery_system = c->delivery_system; 684 685 return ret; 686 error: 687 dev_dbg(&client->dev, "failed=%d\n", ret); 688 return ret; 689 } 690 691 static int tda10071_get_frontend(struct dvb_frontend *fe, 692 struct dtv_frontend_properties *c) 693 { 694 struct tda10071_dev *dev = fe->demodulator_priv; 695 struct i2c_client *client = dev->client; 696 int ret, i; 697 u8 buf[5], tmp; 698 699 if (!dev->warm || !(dev->fe_status & FE_HAS_LOCK)) { 700 ret = 0; 701 goto error; 702 } 703 704 ret = regmap_bulk_read(dev->regmap, 0x30, buf, 5); 705 if (ret) 706 goto error; 707 708 tmp = buf[0] & 0x3f; 709 for (i = 0; i < ARRAY_SIZE(TDA10071_MODCOD); i++) { 710 if (tmp == TDA10071_MODCOD[i].val) { 711 c->modulation = TDA10071_MODCOD[i].modulation; 712 c->fec_inner = TDA10071_MODCOD[i].fec; 713 c->delivery_system = TDA10071_MODCOD[i].delivery_system; 714 } 715 } 716 717 switch ((buf[1] >> 0) & 0x01) { 718 case 0: 719 c->inversion = INVERSION_ON; 720 break; 721 case 1: 722 c->inversion = INVERSION_OFF; 723 break; 724 } 725 726 switch ((buf[1] >> 7) & 0x01) { 727 case 0: 728 c->pilot = PILOT_OFF; 729 break; 730 case 1: 731 c->pilot = PILOT_ON; 732 break; 733 } 734 735 c->frequency = (buf[2] << 16) | (buf[3] << 8) | (buf[4] << 0); 736 737 ret = regmap_bulk_read(dev->regmap, 0x52, buf, 3); 738 if (ret) 739 goto error; 740 741 c->symbol_rate = ((buf[0] << 16) | (buf[1] << 8) | (buf[2] << 0)) * 1000; 742 743 return ret; 744 error: 745 dev_dbg(&client->dev, "failed=%d\n", ret); 746 return ret; 747 } 748 749 static int tda10071_init(struct dvb_frontend *fe) 750 { 751 struct tda10071_dev *dev = fe->demodulator_priv; 752 struct i2c_client *client = dev->client; 753 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 754 struct tda10071_cmd cmd; 755 int ret, i, len, remaining, fw_size; 756 unsigned int uitmp; 757 const struct firmware *fw; 758 u8 *fw_file = TDA10071_FIRMWARE; 759 u8 tmp, buf[4]; 760 struct tda10071_reg_val_mask tab[] = { 761 { 0xcd, 0x00, 0x07 }, 762 { 0x80, 0x00, 0x02 }, 763 { 0xcd, 0x00, 0xc0 }, 764 { 0xce, 0x00, 0x1b }, 765 { 0x9d, 0x00, 0x01 }, 766 { 0x9d, 0x00, 0x02 }, 767 { 0x9e, 0x00, 0x01 }, 768 { 0x87, 0x00, 0x80 }, 769 { 0xce, 0x00, 0x08 }, 770 { 0xce, 0x00, 0x10 }, 771 }; 772 struct tda10071_reg_val_mask tab2[] = { 773 { 0xf1, 0x70, 0xff }, 774 { 0x88, dev->pll_multiplier, 0x3f }, 775 { 0x89, 0x00, 0x10 }, 776 { 0x89, 0x10, 0x10 }, 777 { 0xc0, 0x01, 0x01 }, 778 { 0xc0, 0x00, 0x01 }, 779 { 0xe0, 0xff, 0xff }, 780 { 0xe0, 0x00, 0xff }, 781 { 0x96, 0x1e, 0x7e }, 782 { 0x8b, 0x08, 0x08 }, 783 { 0x8b, 0x00, 0x08 }, 784 { 0x8f, 0x1a, 0x7e }, 785 { 0x8c, 0x68, 0xff }, 786 { 0x8d, 0x08, 0xff }, 787 { 0x8e, 0x4c, 0xff }, 788 { 0x8f, 0x01, 0x01 }, 789 { 0x8b, 0x04, 0x04 }, 790 { 0x8b, 0x00, 0x04 }, 791 { 0x87, 0x05, 0x07 }, 792 { 0x80, 0x00, 0x20 }, 793 { 0xc8, 0x01, 0xff }, 794 { 0xb4, 0x47, 0xff }, 795 { 0xb5, 0x9c, 0xff }, 796 { 0xb6, 0x7d, 0xff }, 797 { 0xba, 0x00, 0x03 }, 798 { 0xb7, 0x47, 0xff }, 799 { 0xb8, 0x9c, 0xff }, 800 { 0xb9, 0x7d, 0xff }, 801 { 0xba, 0x00, 0x0c }, 802 { 0xc8, 0x00, 0xff }, 803 { 0xcd, 0x00, 0x04 }, 804 { 0xcd, 0x00, 0x20 }, 805 { 0xe8, 0x02, 0xff }, 806 { 0xcf, 0x20, 0xff }, 807 { 0x9b, 0xd7, 0xff }, 808 { 0x9a, 0x01, 0x03 }, 809 { 0xa8, 0x05, 0x0f }, 810 { 0xa8, 0x65, 0xf0 }, 811 { 0xa6, 0xa0, 0xf0 }, 812 { 0x9d, 0x50, 0xfc }, 813 { 0x9e, 0x20, 0xe0 }, 814 { 0xa3, 0x1c, 0x7c }, 815 { 0xd5, 0x03, 0x03 }, 816 }; 817 818 if (dev->warm) { 819 /* warm state - wake up device from sleep */ 820 821 for (i = 0; i < ARRAY_SIZE(tab); i++) { 822 ret = tda10071_wr_reg_mask(dev, tab[i].reg, 823 tab[i].val, tab[i].mask); 824 if (ret) 825 goto error; 826 } 827 828 cmd.args[0] = CMD_SET_SLEEP_MODE; 829 cmd.args[1] = 0; 830 cmd.args[2] = 0; 831 cmd.len = 3; 832 ret = tda10071_cmd_execute(dev, &cmd); 833 if (ret) 834 goto error; 835 } else { 836 /* cold state - try to download firmware */ 837 838 /* request the firmware, this will block and timeout */ 839 ret = request_firmware(&fw, fw_file, &client->dev); 840 if (ret) { 841 dev_err(&client->dev, 842 "did not find the firmware file '%s' (status %d). You can use <kernel_dir>/scripts/get_dvb_firmware to get the firmware\n", 843 fw_file, ret); 844 goto error; 845 } 846 847 /* init */ 848 for (i = 0; i < ARRAY_SIZE(tab2); i++) { 849 ret = tda10071_wr_reg_mask(dev, tab2[i].reg, 850 tab2[i].val, tab2[i].mask); 851 if (ret) 852 goto error_release_firmware; 853 } 854 855 /* download firmware */ 856 ret = regmap_write(dev->regmap, 0xe0, 0x7f); 857 if (ret) 858 goto error_release_firmware; 859 860 ret = regmap_write(dev->regmap, 0xf7, 0x81); 861 if (ret) 862 goto error_release_firmware; 863 864 ret = regmap_write(dev->regmap, 0xf8, 0x00); 865 if (ret) 866 goto error_release_firmware; 867 868 ret = regmap_write(dev->regmap, 0xf9, 0x00); 869 if (ret) 870 goto error_release_firmware; 871 872 dev_info(&client->dev, 873 "found a '%s' in cold state, will try to load a firmware\n", 874 tda10071_ops.info.name); 875 dev_info(&client->dev, "downloading firmware from file '%s'\n", 876 fw_file); 877 878 /* do not download last byte */ 879 fw_size = fw->size - 1; 880 881 for (remaining = fw_size; remaining > 0; 882 remaining -= (dev->i2c_wr_max - 1)) { 883 len = remaining; 884 if (len > (dev->i2c_wr_max - 1)) 885 len = (dev->i2c_wr_max - 1); 886 887 ret = regmap_bulk_write(dev->regmap, 0xfa, 888 (u8 *) &fw->data[fw_size - remaining], len); 889 if (ret) { 890 dev_err(&client->dev, 891 "firmware download failed=%d\n", ret); 892 goto error_release_firmware; 893 } 894 } 895 release_firmware(fw); 896 897 ret = regmap_write(dev->regmap, 0xf7, 0x0c); 898 if (ret) 899 goto error; 900 901 ret = regmap_write(dev->regmap, 0xe0, 0x00); 902 if (ret) 903 goto error; 904 905 /* wait firmware start */ 906 msleep(250); 907 908 /* firmware status */ 909 ret = regmap_read(dev->regmap, 0x51, &uitmp); 910 if (ret) 911 goto error; 912 913 if (uitmp) { 914 dev_info(&client->dev, "firmware did not run\n"); 915 ret = -EFAULT; 916 goto error; 917 } else { 918 dev->warm = true; 919 } 920 921 cmd.args[0] = CMD_GET_FW_VERSION; 922 cmd.len = 1; 923 ret = tda10071_cmd_execute(dev, &cmd); 924 if (ret) 925 goto error; 926 927 ret = regmap_bulk_read(dev->regmap, cmd.len, buf, 4); 928 if (ret) 929 goto error; 930 931 dev_info(&client->dev, "firmware version %d.%d.%d.%d\n", 932 buf[0], buf[1], buf[2], buf[3]); 933 dev_info(&client->dev, "found a '%s' in warm state\n", 934 tda10071_ops.info.name); 935 936 ret = regmap_bulk_read(dev->regmap, 0x81, buf, 2); 937 if (ret) 938 goto error; 939 940 cmd.args[0] = CMD_DEMOD_INIT; 941 cmd.args[1] = ((dev->clk / 1000) >> 8) & 0xff; 942 cmd.args[2] = ((dev->clk / 1000) >> 0) & 0xff; 943 cmd.args[3] = buf[0]; 944 cmd.args[4] = buf[1]; 945 cmd.args[5] = dev->pll_multiplier; 946 cmd.args[6] = dev->spec_inv; 947 cmd.args[7] = 0x00; 948 cmd.len = 8; 949 ret = tda10071_cmd_execute(dev, &cmd); 950 if (ret) 951 goto error; 952 953 if (dev->tuner_i2c_addr) 954 tmp = dev->tuner_i2c_addr; 955 else 956 tmp = 0x14; 957 958 cmd.args[0] = CMD_TUNER_INIT; 959 cmd.args[1] = 0x00; 960 cmd.args[2] = 0x00; 961 cmd.args[3] = 0x00; 962 cmd.args[4] = 0x00; 963 cmd.args[5] = tmp; 964 cmd.args[6] = 0x00; 965 cmd.args[7] = 0x03; 966 cmd.args[8] = 0x02; 967 cmd.args[9] = 0x02; 968 cmd.args[10] = 0x00; 969 cmd.args[11] = 0x00; 970 cmd.args[12] = 0x00; 971 cmd.args[13] = 0x00; 972 cmd.args[14] = 0x00; 973 cmd.len = 15; 974 ret = tda10071_cmd_execute(dev, &cmd); 975 if (ret) 976 goto error; 977 978 cmd.args[0] = CMD_MPEG_CONFIG; 979 cmd.args[1] = 0; 980 cmd.args[2] = dev->ts_mode; 981 cmd.args[3] = 0x00; 982 cmd.args[4] = 0x04; 983 cmd.args[5] = 0x00; 984 cmd.len = 6; 985 ret = tda10071_cmd_execute(dev, &cmd); 986 if (ret) 987 goto error; 988 989 ret = regmap_update_bits(dev->regmap, 0xf0, 0x01, 0x01); 990 if (ret) 991 goto error; 992 993 cmd.args[0] = CMD_LNB_CONFIG; 994 cmd.args[1] = 0; 995 cmd.args[2] = 150; 996 cmd.args[3] = 3; 997 cmd.args[4] = 22; 998 cmd.args[5] = 1; 999 cmd.args[6] = 1; 1000 cmd.args[7] = 30; 1001 cmd.args[8] = 30; 1002 cmd.args[9] = 30; 1003 cmd.args[10] = 30; 1004 cmd.len = 11; 1005 ret = tda10071_cmd_execute(dev, &cmd); 1006 if (ret) 1007 goto error; 1008 1009 cmd.args[0] = CMD_BER_CONTROL; 1010 cmd.args[1] = 0; 1011 cmd.args[2] = 14; 1012 cmd.args[3] = 14; 1013 cmd.len = 4; 1014 ret = tda10071_cmd_execute(dev, &cmd); 1015 if (ret) 1016 goto error; 1017 } 1018 1019 /* init stats here in order signal app which stats are supported */ 1020 c->strength.len = 1; 1021 c->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1022 c->cnr.len = 1; 1023 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1024 c->post_bit_error.len = 1; 1025 c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1026 c->block_error.len = 1; 1027 c->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE; 1028 1029 return ret; 1030 error_release_firmware: 1031 release_firmware(fw); 1032 error: 1033 dev_dbg(&client->dev, "failed=%d\n", ret); 1034 return ret; 1035 } 1036 1037 static int tda10071_sleep(struct dvb_frontend *fe) 1038 { 1039 struct tda10071_dev *dev = fe->demodulator_priv; 1040 struct i2c_client *client = dev->client; 1041 struct tda10071_cmd cmd; 1042 int ret, i; 1043 struct tda10071_reg_val_mask tab[] = { 1044 { 0xcd, 0x07, 0x07 }, 1045 { 0x80, 0x02, 0x02 }, 1046 { 0xcd, 0xc0, 0xc0 }, 1047 { 0xce, 0x1b, 0x1b }, 1048 { 0x9d, 0x01, 0x01 }, 1049 { 0x9d, 0x02, 0x02 }, 1050 { 0x9e, 0x01, 0x01 }, 1051 { 0x87, 0x80, 0x80 }, 1052 { 0xce, 0x08, 0x08 }, 1053 { 0xce, 0x10, 0x10 }, 1054 }; 1055 1056 if (!dev->warm) { 1057 ret = -EFAULT; 1058 goto error; 1059 } 1060 1061 cmd.args[0] = CMD_SET_SLEEP_MODE; 1062 cmd.args[1] = 0; 1063 cmd.args[2] = 1; 1064 cmd.len = 3; 1065 ret = tda10071_cmd_execute(dev, &cmd); 1066 if (ret) 1067 goto error; 1068 1069 for (i = 0; i < ARRAY_SIZE(tab); i++) { 1070 ret = tda10071_wr_reg_mask(dev, tab[i].reg, tab[i].val, 1071 tab[i].mask); 1072 if (ret) 1073 goto error; 1074 } 1075 1076 return ret; 1077 error: 1078 dev_dbg(&client->dev, "failed=%d\n", ret); 1079 return ret; 1080 } 1081 1082 static int tda10071_get_tune_settings(struct dvb_frontend *fe, 1083 struct dvb_frontend_tune_settings *s) 1084 { 1085 s->min_delay_ms = 8000; 1086 s->step_size = 0; 1087 s->max_drift = 0; 1088 1089 return 0; 1090 } 1091 1092 static const struct dvb_frontend_ops tda10071_ops = { 1093 .delsys = { SYS_DVBS, SYS_DVBS2 }, 1094 .info = { 1095 .name = "NXP TDA10071", 1096 .frequency_min_hz = 950 * MHz, 1097 .frequency_max_hz = 2150 * MHz, 1098 .frequency_tolerance_hz = 5 * MHz, 1099 .symbol_rate_min = 1000000, 1100 .symbol_rate_max = 45000000, 1101 .caps = FE_CAN_INVERSION_AUTO | 1102 FE_CAN_FEC_1_2 | 1103 FE_CAN_FEC_2_3 | 1104 FE_CAN_FEC_3_4 | 1105 FE_CAN_FEC_4_5 | 1106 FE_CAN_FEC_5_6 | 1107 FE_CAN_FEC_6_7 | 1108 FE_CAN_FEC_7_8 | 1109 FE_CAN_FEC_8_9 | 1110 FE_CAN_FEC_AUTO | 1111 FE_CAN_QPSK | 1112 FE_CAN_RECOVER | 1113 FE_CAN_2G_MODULATION 1114 }, 1115 1116 .get_tune_settings = tda10071_get_tune_settings, 1117 1118 .init = tda10071_init, 1119 .sleep = tda10071_sleep, 1120 1121 .set_frontend = tda10071_set_frontend, 1122 .get_frontend = tda10071_get_frontend, 1123 1124 .read_status = tda10071_read_status, 1125 .read_snr = tda10071_read_snr, 1126 .read_signal_strength = tda10071_read_signal_strength, 1127 .read_ber = tda10071_read_ber, 1128 .read_ucblocks = tda10071_read_ucblocks, 1129 1130 .diseqc_send_master_cmd = tda10071_diseqc_send_master_cmd, 1131 .diseqc_recv_slave_reply = tda10071_diseqc_recv_slave_reply, 1132 .diseqc_send_burst = tda10071_diseqc_send_burst, 1133 1134 .set_tone = tda10071_set_tone, 1135 .set_voltage = tda10071_set_voltage, 1136 }; 1137 1138 static struct dvb_frontend *tda10071_get_dvb_frontend(struct i2c_client *client) 1139 { 1140 struct tda10071_dev *dev = i2c_get_clientdata(client); 1141 1142 dev_dbg(&client->dev, "\n"); 1143 1144 return &dev->fe; 1145 } 1146 1147 static int tda10071_probe(struct i2c_client *client, 1148 const struct i2c_device_id *id) 1149 { 1150 struct tda10071_dev *dev; 1151 struct tda10071_platform_data *pdata = client->dev.platform_data; 1152 int ret; 1153 unsigned int uitmp; 1154 static const struct regmap_config regmap_config = { 1155 .reg_bits = 8, 1156 .val_bits = 8, 1157 }; 1158 1159 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 1160 if (!dev) { 1161 ret = -ENOMEM; 1162 goto err; 1163 } 1164 1165 dev->client = client; 1166 mutex_init(&dev->cmd_execute_mutex); 1167 dev->clk = pdata->clk; 1168 dev->i2c_wr_max = pdata->i2c_wr_max; 1169 dev->ts_mode = pdata->ts_mode; 1170 dev->spec_inv = pdata->spec_inv; 1171 dev->pll_multiplier = pdata->pll_multiplier; 1172 dev->tuner_i2c_addr = pdata->tuner_i2c_addr; 1173 dev->regmap = devm_regmap_init_i2c(client, ®map_config); 1174 if (IS_ERR(dev->regmap)) { 1175 ret = PTR_ERR(dev->regmap); 1176 goto err_kfree; 1177 } 1178 1179 /* chip ID */ 1180 ret = regmap_read(dev->regmap, 0xff, &uitmp); 1181 if (ret) 1182 goto err_kfree; 1183 if (uitmp != 0x0f) { 1184 ret = -ENODEV; 1185 goto err_kfree; 1186 } 1187 1188 /* chip type */ 1189 ret = regmap_read(dev->regmap, 0xdd, &uitmp); 1190 if (ret) 1191 goto err_kfree; 1192 if (uitmp != 0x00) { 1193 ret = -ENODEV; 1194 goto err_kfree; 1195 } 1196 1197 /* chip version */ 1198 ret = regmap_read(dev->regmap, 0xfe, &uitmp); 1199 if (ret) 1200 goto err_kfree; 1201 if (uitmp != 0x01) { 1202 ret = -ENODEV; 1203 goto err_kfree; 1204 } 1205 1206 /* create dvb_frontend */ 1207 memcpy(&dev->fe.ops, &tda10071_ops, sizeof(struct dvb_frontend_ops)); 1208 dev->fe.demodulator_priv = dev; 1209 i2c_set_clientdata(client, dev); 1210 1211 /* setup callbacks */ 1212 pdata->get_dvb_frontend = tda10071_get_dvb_frontend; 1213 1214 dev_info(&client->dev, "NXP TDA10071 successfully identified\n"); 1215 return 0; 1216 err_kfree: 1217 kfree(dev); 1218 err: 1219 dev_dbg(&client->dev, "failed=%d\n", ret); 1220 return ret; 1221 } 1222 1223 static int tda10071_remove(struct i2c_client *client) 1224 { 1225 struct tda10071_dev *dev = i2c_get_clientdata(client); 1226 1227 dev_dbg(&client->dev, "\n"); 1228 1229 kfree(dev); 1230 return 0; 1231 } 1232 1233 static const struct i2c_device_id tda10071_id_table[] = { 1234 {"tda10071_cx24118", 0}, 1235 {} 1236 }; 1237 MODULE_DEVICE_TABLE(i2c, tda10071_id_table); 1238 1239 static struct i2c_driver tda10071_driver = { 1240 .driver = { 1241 .name = "tda10071", 1242 .suppress_bind_attrs = true, 1243 }, 1244 .probe = tda10071_probe, 1245 .remove = tda10071_remove, 1246 .id_table = tda10071_id_table, 1247 }; 1248 1249 module_i2c_driver(tda10071_driver); 1250 1251 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); 1252 MODULE_DESCRIPTION("NXP TDA10071 DVB-S/S2 demodulator driver"); 1253 MODULE_LICENSE("GPL"); 1254 MODULE_FIRMWARE(TDA10071_FIRMWARE); 1255