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