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