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