1 /* 2 * Afatech AF9013 demodulator driver 3 * 4 * Copyright (C) 2007 Antti Palosaari <crope@iki.fi> 5 * Copyright (C) 2011 Antti Palosaari <crope@iki.fi> 6 * 7 * Thanks to Afatech who kindly provided information. 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 */ 20 21 #include "af9013_priv.h" 22 23 struct af9013_state { 24 struct i2c_client *client; 25 struct regmap *regmap; 26 struct dvb_frontend fe; 27 u32 clk; 28 u8 tuner; 29 u32 if_frequency; 30 u8 ts_mode; 31 u8 ts_output_pin; 32 bool spec_inv; 33 u8 api_version[4]; 34 u8 gpio[4]; 35 36 /* tuner/demod RF and IF AGC limits used for signal strength calc */ 37 u8 signal_strength_en, rf_50, rf_80, if_50, if_80; 38 u16 signal_strength; 39 u32 ber; 40 u32 ucblocks; 41 u16 snr; 42 u32 bandwidth_hz; 43 enum fe_status fe_status; 44 unsigned long set_frontend_jiffies; 45 unsigned long read_status_jiffies; 46 bool first_tune; 47 bool i2c_gate_state; 48 unsigned int statistics_step:3; 49 struct delayed_work statistics_work; 50 }; 51 52 static int af9013_set_gpio(struct af9013_state *state, u8 gpio, u8 gpioval) 53 { 54 struct i2c_client *client = state->client; 55 int ret; 56 u8 pos; 57 u16 addr; 58 59 dev_dbg(&client->dev, "gpio %u, gpioval %02x\n", gpio, gpioval); 60 61 /* 62 * GPIO0 & GPIO1 0xd735 63 * GPIO2 & GPIO3 0xd736 64 */ 65 66 switch (gpio) { 67 case 0: 68 case 1: 69 addr = 0xd735; 70 break; 71 case 2: 72 case 3: 73 addr = 0xd736; 74 break; 75 76 default: 77 ret = -EINVAL; 78 goto err; 79 } 80 81 switch (gpio) { 82 case 0: 83 case 2: 84 pos = 0; 85 break; 86 case 1: 87 case 3: 88 default: 89 pos = 4; 90 break; 91 } 92 93 ret = regmap_update_bits(state->regmap, addr, 0x0f << pos, 94 gpioval << pos); 95 if (ret) 96 goto err; 97 98 return 0; 99 err: 100 dev_dbg(&client->dev, "failed %d\n", ret); 101 return ret; 102 } 103 104 static int af9013_power_ctrl(struct af9013_state *state, u8 onoff) 105 { 106 struct i2c_client *client = state->client; 107 int ret; 108 unsigned int utmp; 109 110 dev_dbg(&client->dev, "onoff %d\n", onoff); 111 112 /* enable reset */ 113 ret = regmap_update_bits(state->regmap, 0xd417, 0x10, 0x10); 114 if (ret) 115 goto err; 116 117 /* start reset mechanism */ 118 ret = regmap_write(state->regmap, 0xaeff, 0x01); 119 if (ret) 120 goto err; 121 122 /* wait reset performs */ 123 ret = regmap_read_poll_timeout(state->regmap, 0xd417, utmp, 124 (utmp >> 1) & 0x01, 5000, 1000000); 125 if (ret) 126 goto err; 127 128 if (!((utmp >> 1) & 0x01)) 129 return -ETIMEDOUT; 130 131 if (onoff) { 132 /* clear reset */ 133 ret = regmap_update_bits(state->regmap, 0xd417, 0x02, 0x00); 134 if (ret) 135 goto err; 136 /* disable reset */ 137 ret = regmap_update_bits(state->regmap, 0xd417, 0x10, 0x00); 138 if (ret) 139 goto err; 140 /* power on */ 141 ret = regmap_update_bits(state->regmap, 0xd73a, 0x08, 0x00); 142 if (ret) 143 goto err; 144 } else { 145 /* power off */ 146 ret = regmap_update_bits(state->regmap, 0xd73a, 0x08, 0x08); 147 if (ret) 148 goto err; 149 } 150 151 return 0; 152 err: 153 dev_dbg(&client->dev, "failed %d\n", ret); 154 return ret; 155 } 156 157 static int af9013_statistics_ber_unc_start(struct dvb_frontend *fe) 158 { 159 struct af9013_state *state = fe->demodulator_priv; 160 struct i2c_client *client = state->client; 161 int ret; 162 163 dev_dbg(&client->dev, "\n"); 164 165 /* reset and start BER counter */ 166 ret = regmap_update_bits(state->regmap, 0xd391, 0x10, 0x10); 167 if (ret) 168 goto err; 169 170 return 0; 171 err: 172 dev_dbg(&client->dev, "failed %d\n", ret); 173 return ret; 174 } 175 176 static int af9013_statistics_ber_unc_result(struct dvb_frontend *fe) 177 { 178 struct af9013_state *state = fe->demodulator_priv; 179 struct i2c_client *client = state->client; 180 int ret; 181 unsigned int utmp; 182 u8 buf[5]; 183 184 dev_dbg(&client->dev, "\n"); 185 186 /* check if error bit count is ready */ 187 ret = regmap_read(state->regmap, 0xd391, &utmp); 188 if (ret) 189 goto err; 190 191 if (!((utmp >> 4) & 0x01)) { 192 dev_dbg(&client->dev, "not ready\n"); 193 return 0; 194 } 195 196 ret = regmap_bulk_read(state->regmap, 0xd387, buf, 5); 197 if (ret) 198 goto err; 199 200 state->ber = (buf[2] << 16) | (buf[1] << 8) | buf[0]; 201 state->ucblocks += (buf[4] << 8) | buf[3]; 202 203 return 0; 204 err: 205 dev_dbg(&client->dev, "failed %d\n", ret); 206 return ret; 207 } 208 209 static int af9013_statistics_snr_start(struct dvb_frontend *fe) 210 { 211 struct af9013_state *state = fe->demodulator_priv; 212 struct i2c_client *client = state->client; 213 int ret; 214 215 dev_dbg(&client->dev, "\n"); 216 217 /* start SNR meas */ 218 ret = regmap_update_bits(state->regmap, 0xd2e1, 0x08, 0x08); 219 if (ret) 220 goto err; 221 222 return 0; 223 err: 224 dev_dbg(&client->dev, "failed %d\n", ret); 225 return ret; 226 } 227 228 static int af9013_statistics_snr_result(struct dvb_frontend *fe) 229 { 230 struct af9013_state *state = fe->demodulator_priv; 231 struct i2c_client *client = state->client; 232 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 233 int ret, i, len; 234 unsigned int utmp; 235 u8 buf[3]; 236 u32 snr_val; 237 const struct af9013_snr *uninitialized_var(snr_lut); 238 239 dev_dbg(&client->dev, "\n"); 240 241 /* check if SNR ready */ 242 ret = regmap_read(state->regmap, 0xd2e1, &utmp); 243 if (ret) 244 goto err; 245 246 if (!((utmp >> 3) & 0x01)) { 247 dev_dbg(&client->dev, "not ready\n"); 248 return 0; 249 } 250 251 /* read value */ 252 ret = regmap_bulk_read(state->regmap, 0xd2e3, buf, 3); 253 if (ret) 254 goto err; 255 256 snr_val = (buf[2] << 16) | (buf[1] << 8) | buf[0]; 257 258 /* read current modulation */ 259 ret = regmap_read(state->regmap, 0xd3c1, &utmp); 260 if (ret) 261 goto err; 262 263 switch ((utmp >> 6) & 3) { 264 case 0: 265 len = ARRAY_SIZE(qpsk_snr_lut); 266 snr_lut = qpsk_snr_lut; 267 break; 268 case 1: 269 len = ARRAY_SIZE(qam16_snr_lut); 270 snr_lut = qam16_snr_lut; 271 break; 272 case 2: 273 len = ARRAY_SIZE(qam64_snr_lut); 274 snr_lut = qam64_snr_lut; 275 break; 276 default: 277 goto err; 278 } 279 280 for (i = 0; i < len; i++) { 281 utmp = snr_lut[i].snr; 282 283 if (snr_val < snr_lut[i].val) 284 break; 285 } 286 state->snr = utmp * 10; /* dB/10 */ 287 288 c->cnr.stat[0].svalue = 1000 * utmp; 289 c->cnr.stat[0].scale = FE_SCALE_DECIBEL; 290 291 return 0; 292 err: 293 dev_dbg(&client->dev, "failed %d\n", ret); 294 return ret; 295 } 296 297 static int af9013_statistics_signal_strength(struct dvb_frontend *fe) 298 { 299 struct af9013_state *state = fe->demodulator_priv; 300 struct i2c_client *client = state->client; 301 int ret = 0; 302 u8 buf[2], rf_gain, if_gain; 303 int signal_strength; 304 305 dev_dbg(&client->dev, "\n"); 306 307 if (!state->signal_strength_en) 308 return 0; 309 310 ret = regmap_bulk_read(state->regmap, 0xd07c, buf, 2); 311 if (ret) 312 goto err; 313 314 rf_gain = buf[0]; 315 if_gain = buf[1]; 316 317 signal_strength = (0xffff / \ 318 (9 * (state->rf_50 + state->if_50) - \ 319 11 * (state->rf_80 + state->if_80))) * \ 320 (10 * (rf_gain + if_gain) - \ 321 11 * (state->rf_80 + state->if_80)); 322 if (signal_strength < 0) 323 signal_strength = 0; 324 else if (signal_strength > 0xffff) 325 signal_strength = 0xffff; 326 327 state->signal_strength = signal_strength; 328 329 return 0; 330 err: 331 dev_dbg(&client->dev, "failed %d\n", ret); 332 return ret; 333 } 334 335 static void af9013_statistics_work(struct work_struct *work) 336 { 337 struct af9013_state *state = container_of(work, 338 struct af9013_state, statistics_work.work); 339 unsigned int next_msec; 340 341 /* update only signal strength when demod is not locked */ 342 if (!(state->fe_status & FE_HAS_LOCK)) { 343 state->statistics_step = 0; 344 state->ber = 0; 345 state->snr = 0; 346 } 347 348 switch (state->statistics_step) { 349 default: 350 state->statistics_step = 0; 351 /* fall-through */ 352 case 0: 353 af9013_statistics_signal_strength(&state->fe); 354 state->statistics_step++; 355 next_msec = 300; 356 break; 357 case 1: 358 af9013_statistics_snr_start(&state->fe); 359 state->statistics_step++; 360 next_msec = 200; 361 break; 362 case 2: 363 af9013_statistics_ber_unc_start(&state->fe); 364 state->statistics_step++; 365 next_msec = 1000; 366 break; 367 case 3: 368 af9013_statistics_snr_result(&state->fe); 369 state->statistics_step++; 370 next_msec = 400; 371 break; 372 case 4: 373 af9013_statistics_ber_unc_result(&state->fe); 374 state->statistics_step++; 375 next_msec = 100; 376 break; 377 } 378 379 schedule_delayed_work(&state->statistics_work, 380 msecs_to_jiffies(next_msec)); 381 } 382 383 static int af9013_get_tune_settings(struct dvb_frontend *fe, 384 struct dvb_frontend_tune_settings *fesettings) 385 { 386 fesettings->min_delay_ms = 800; 387 fesettings->step_size = 0; 388 fesettings->max_drift = 0; 389 390 return 0; 391 } 392 393 static int af9013_set_frontend(struct dvb_frontend *fe) 394 { 395 struct af9013_state *state = fe->demodulator_priv; 396 struct i2c_client *client = state->client; 397 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 398 int ret, i, sampling_freq; 399 bool auto_mode, spec_inv; 400 u8 buf[6]; 401 u32 if_frequency, freq_cw; 402 403 dev_dbg(&client->dev, "frequency %u, bandwidth_hz %u\n", 404 c->frequency, c->bandwidth_hz); 405 406 /* program tuner */ 407 if (fe->ops.tuner_ops.set_params) { 408 ret = fe->ops.tuner_ops.set_params(fe); 409 if (ret) 410 goto err; 411 } 412 413 /* program CFOE coefficients */ 414 if (c->bandwidth_hz != state->bandwidth_hz) { 415 for (i = 0; i < ARRAY_SIZE(coeff_lut); i++) { 416 if (coeff_lut[i].clock == state->clk && 417 coeff_lut[i].bandwidth_hz == c->bandwidth_hz) { 418 break; 419 } 420 } 421 422 /* Return an error if can't find bandwidth or the right clock */ 423 if (i == ARRAY_SIZE(coeff_lut)) { 424 ret = -EINVAL; 425 goto err; 426 } 427 428 ret = regmap_bulk_write(state->regmap, 0xae00, coeff_lut[i].val, 429 sizeof(coeff_lut[i].val)); 430 if (ret) 431 goto err; 432 } 433 434 /* program frequency control */ 435 if (c->bandwidth_hz != state->bandwidth_hz || state->first_tune) { 436 /* get used IF frequency */ 437 if (fe->ops.tuner_ops.get_if_frequency) { 438 ret = fe->ops.tuner_ops.get_if_frequency(fe, 439 &if_frequency); 440 if (ret) 441 goto err; 442 } else { 443 if_frequency = state->if_frequency; 444 } 445 446 dev_dbg(&client->dev, "if_frequency %u\n", if_frequency); 447 448 sampling_freq = if_frequency; 449 450 while (sampling_freq > (state->clk / 2)) 451 sampling_freq -= state->clk; 452 453 if (sampling_freq < 0) { 454 sampling_freq *= -1; 455 spec_inv = state->spec_inv; 456 } else { 457 spec_inv = !state->spec_inv; 458 } 459 460 freq_cw = DIV_ROUND_CLOSEST_ULL((u64)sampling_freq * 0x800000, 461 state->clk); 462 463 if (spec_inv) 464 freq_cw = 0x800000 - freq_cw; 465 466 buf[0] = (freq_cw >> 0) & 0xff; 467 buf[1] = (freq_cw >> 8) & 0xff; 468 buf[2] = (freq_cw >> 16) & 0x7f; 469 470 freq_cw = 0x800000 - freq_cw; 471 472 buf[3] = (freq_cw >> 0) & 0xff; 473 buf[4] = (freq_cw >> 8) & 0xff; 474 buf[5] = (freq_cw >> 16) & 0x7f; 475 476 ret = regmap_bulk_write(state->regmap, 0xd140, buf, 3); 477 if (ret) 478 goto err; 479 480 ret = regmap_bulk_write(state->regmap, 0x9be7, buf, 6); 481 if (ret) 482 goto err; 483 } 484 485 /* clear TPS lock flag */ 486 ret = regmap_update_bits(state->regmap, 0xd330, 0x08, 0x08); 487 if (ret) 488 goto err; 489 490 /* clear MPEG2 lock flag */ 491 ret = regmap_update_bits(state->regmap, 0xd507, 0x40, 0x00); 492 if (ret) 493 goto err; 494 495 /* empty channel function */ 496 ret = regmap_update_bits(state->regmap, 0x9bfe, 0x01, 0x00); 497 if (ret) 498 goto err; 499 500 /* empty DVB-T channel function */ 501 ret = regmap_update_bits(state->regmap, 0x9bc2, 0x01, 0x00); 502 if (ret) 503 goto err; 504 505 /* transmission parameters */ 506 auto_mode = false; 507 memset(buf, 0, 3); 508 509 switch (c->transmission_mode) { 510 case TRANSMISSION_MODE_AUTO: 511 auto_mode = true; 512 break; 513 case TRANSMISSION_MODE_2K: 514 break; 515 case TRANSMISSION_MODE_8K: 516 buf[0] |= (1 << 0); 517 break; 518 default: 519 dev_dbg(&client->dev, "invalid transmission_mode\n"); 520 auto_mode = true; 521 } 522 523 switch (c->guard_interval) { 524 case GUARD_INTERVAL_AUTO: 525 auto_mode = true; 526 break; 527 case GUARD_INTERVAL_1_32: 528 break; 529 case GUARD_INTERVAL_1_16: 530 buf[0] |= (1 << 2); 531 break; 532 case GUARD_INTERVAL_1_8: 533 buf[0] |= (2 << 2); 534 break; 535 case GUARD_INTERVAL_1_4: 536 buf[0] |= (3 << 2); 537 break; 538 default: 539 dev_dbg(&client->dev, "invalid guard_interval\n"); 540 auto_mode = true; 541 } 542 543 switch (c->hierarchy) { 544 case HIERARCHY_AUTO: 545 auto_mode = true; 546 break; 547 case HIERARCHY_NONE: 548 break; 549 case HIERARCHY_1: 550 buf[0] |= (1 << 4); 551 break; 552 case HIERARCHY_2: 553 buf[0] |= (2 << 4); 554 break; 555 case HIERARCHY_4: 556 buf[0] |= (3 << 4); 557 break; 558 default: 559 dev_dbg(&client->dev, "invalid hierarchy\n"); 560 auto_mode = true; 561 } 562 563 switch (c->modulation) { 564 case QAM_AUTO: 565 auto_mode = true; 566 break; 567 case QPSK: 568 break; 569 case QAM_16: 570 buf[1] |= (1 << 6); 571 break; 572 case QAM_64: 573 buf[1] |= (2 << 6); 574 break; 575 default: 576 dev_dbg(&client->dev, "invalid modulation\n"); 577 auto_mode = true; 578 } 579 580 /* Use HP. How and which case we can switch to LP? */ 581 buf[1] |= (1 << 4); 582 583 switch (c->code_rate_HP) { 584 case FEC_AUTO: 585 auto_mode = true; 586 break; 587 case FEC_1_2: 588 break; 589 case FEC_2_3: 590 buf[2] |= (1 << 0); 591 break; 592 case FEC_3_4: 593 buf[2] |= (2 << 0); 594 break; 595 case FEC_5_6: 596 buf[2] |= (3 << 0); 597 break; 598 case FEC_7_8: 599 buf[2] |= (4 << 0); 600 break; 601 default: 602 dev_dbg(&client->dev, "invalid code_rate_HP\n"); 603 auto_mode = true; 604 } 605 606 switch (c->code_rate_LP) { 607 case FEC_AUTO: 608 auto_mode = true; 609 break; 610 case FEC_1_2: 611 break; 612 case FEC_2_3: 613 buf[2] |= (1 << 3); 614 break; 615 case FEC_3_4: 616 buf[2] |= (2 << 3); 617 break; 618 case FEC_5_6: 619 buf[2] |= (3 << 3); 620 break; 621 case FEC_7_8: 622 buf[2] |= (4 << 3); 623 break; 624 case FEC_NONE: 625 break; 626 default: 627 dev_dbg(&client->dev, "invalid code_rate_LP\n"); 628 auto_mode = true; 629 } 630 631 switch (c->bandwidth_hz) { 632 case 6000000: 633 break; 634 case 7000000: 635 buf[1] |= (1 << 2); 636 break; 637 case 8000000: 638 buf[1] |= (2 << 2); 639 break; 640 default: 641 dev_dbg(&client->dev, "invalid bandwidth_hz\n"); 642 ret = -EINVAL; 643 goto err; 644 } 645 646 ret = regmap_bulk_write(state->regmap, 0xd3c0, buf, 3); 647 if (ret) 648 goto err; 649 650 if (auto_mode) { 651 /* clear easy mode flag */ 652 ret = regmap_write(state->regmap, 0xaefd, 0x00); 653 if (ret) 654 goto err; 655 656 dev_dbg(&client->dev, "auto params\n"); 657 } else { 658 /* set easy mode flag */ 659 ret = regmap_write(state->regmap, 0xaefd, 0x01); 660 if (ret) 661 goto err; 662 663 ret = regmap_write(state->regmap, 0xaefe, 0x00); 664 if (ret) 665 goto err; 666 667 dev_dbg(&client->dev, "manual params\n"); 668 } 669 670 /* Reset FSM */ 671 ret = regmap_write(state->regmap, 0xffff, 0x00); 672 if (ret) 673 goto err; 674 675 state->bandwidth_hz = c->bandwidth_hz; 676 state->set_frontend_jiffies = jiffies; 677 state->first_tune = false; 678 679 return 0; 680 err: 681 dev_dbg(&client->dev, "failed %d\n", ret); 682 return ret; 683 } 684 685 static int af9013_get_frontend(struct dvb_frontend *fe, 686 struct dtv_frontend_properties *c) 687 { 688 struct af9013_state *state = fe->demodulator_priv; 689 struct i2c_client *client = state->client; 690 int ret; 691 u8 buf[3]; 692 693 dev_dbg(&client->dev, "\n"); 694 695 ret = regmap_bulk_read(state->regmap, 0xd3c0, buf, 3); 696 if (ret) 697 goto err; 698 699 switch ((buf[1] >> 6) & 3) { 700 case 0: 701 c->modulation = QPSK; 702 break; 703 case 1: 704 c->modulation = QAM_16; 705 break; 706 case 2: 707 c->modulation = QAM_64; 708 break; 709 } 710 711 switch ((buf[0] >> 0) & 3) { 712 case 0: 713 c->transmission_mode = TRANSMISSION_MODE_2K; 714 break; 715 case 1: 716 c->transmission_mode = TRANSMISSION_MODE_8K; 717 } 718 719 switch ((buf[0] >> 2) & 3) { 720 case 0: 721 c->guard_interval = GUARD_INTERVAL_1_32; 722 break; 723 case 1: 724 c->guard_interval = GUARD_INTERVAL_1_16; 725 break; 726 case 2: 727 c->guard_interval = GUARD_INTERVAL_1_8; 728 break; 729 case 3: 730 c->guard_interval = GUARD_INTERVAL_1_4; 731 break; 732 } 733 734 switch ((buf[0] >> 4) & 7) { 735 case 0: 736 c->hierarchy = HIERARCHY_NONE; 737 break; 738 case 1: 739 c->hierarchy = HIERARCHY_1; 740 break; 741 case 2: 742 c->hierarchy = HIERARCHY_2; 743 break; 744 case 3: 745 c->hierarchy = HIERARCHY_4; 746 break; 747 } 748 749 switch ((buf[2] >> 0) & 7) { 750 case 0: 751 c->code_rate_HP = FEC_1_2; 752 break; 753 case 1: 754 c->code_rate_HP = FEC_2_3; 755 break; 756 case 2: 757 c->code_rate_HP = FEC_3_4; 758 break; 759 case 3: 760 c->code_rate_HP = FEC_5_6; 761 break; 762 case 4: 763 c->code_rate_HP = FEC_7_8; 764 break; 765 } 766 767 switch ((buf[2] >> 3) & 7) { 768 case 0: 769 c->code_rate_LP = FEC_1_2; 770 break; 771 case 1: 772 c->code_rate_LP = FEC_2_3; 773 break; 774 case 2: 775 c->code_rate_LP = FEC_3_4; 776 break; 777 case 3: 778 c->code_rate_LP = FEC_5_6; 779 break; 780 case 4: 781 c->code_rate_LP = FEC_7_8; 782 break; 783 } 784 785 switch ((buf[1] >> 2) & 3) { 786 case 0: 787 c->bandwidth_hz = 6000000; 788 break; 789 case 1: 790 c->bandwidth_hz = 7000000; 791 break; 792 case 2: 793 c->bandwidth_hz = 8000000; 794 break; 795 } 796 797 return 0; 798 err: 799 dev_dbg(&client->dev, "failed %d\n", ret); 800 return ret; 801 } 802 803 static int af9013_read_status(struct dvb_frontend *fe, enum fe_status *status) 804 { 805 struct af9013_state *state = fe->demodulator_priv; 806 struct i2c_client *client = state->client; 807 int ret; 808 unsigned int utmp; 809 810 /* 811 * Return status from the cache if it is younger than 2000ms with the 812 * exception of last tune is done during 4000ms. 813 */ 814 if (time_is_after_jiffies( 815 state->read_status_jiffies + msecs_to_jiffies(2000)) && 816 time_is_before_jiffies( 817 state->set_frontend_jiffies + msecs_to_jiffies(4000)) 818 ) { 819 *status = state->fe_status; 820 return 0; 821 } else { 822 *status = 0; 823 } 824 825 /* MPEG2 lock */ 826 ret = regmap_read(state->regmap, 0xd507, &utmp); 827 if (ret) 828 goto err; 829 830 if ((utmp >> 6) & 0x01) 831 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI | 832 FE_HAS_SYNC | FE_HAS_LOCK; 833 834 if (!*status) { 835 /* TPS lock */ 836 ret = regmap_read(state->regmap, 0xd330, &utmp); 837 if (ret) 838 goto err; 839 840 if ((utmp >> 3) & 0x01) 841 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER | 842 FE_HAS_VITERBI; 843 } 844 845 state->fe_status = *status; 846 state->read_status_jiffies = jiffies; 847 848 return 0; 849 err: 850 dev_dbg(&client->dev, "failed %d\n", ret); 851 return ret; 852 } 853 854 static int af9013_read_snr(struct dvb_frontend *fe, u16 *snr) 855 { 856 struct af9013_state *state = fe->demodulator_priv; 857 *snr = state->snr; 858 return 0; 859 } 860 861 static int af9013_read_signal_strength(struct dvb_frontend *fe, u16 *strength) 862 { 863 struct af9013_state *state = fe->demodulator_priv; 864 *strength = state->signal_strength; 865 return 0; 866 } 867 868 static int af9013_read_ber(struct dvb_frontend *fe, u32 *ber) 869 { 870 struct af9013_state *state = fe->demodulator_priv; 871 *ber = state->ber; 872 return 0; 873 } 874 875 static int af9013_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks) 876 { 877 struct af9013_state *state = fe->demodulator_priv; 878 *ucblocks = state->ucblocks; 879 return 0; 880 } 881 882 static int af9013_init(struct dvb_frontend *fe) 883 { 884 struct af9013_state *state = fe->demodulator_priv; 885 struct i2c_client *client = state->client; 886 int ret, i, len; 887 unsigned int utmp; 888 u8 buf[3]; 889 const struct af9013_reg_bit *init; 890 891 dev_dbg(&client->dev, "\n"); 892 893 /* power on */ 894 ret = af9013_power_ctrl(state, 1); 895 if (ret) 896 goto err; 897 898 /* enable ADC */ 899 ret = regmap_write(state->regmap, 0xd73a, 0xa4); 900 if (ret) 901 goto err; 902 903 /* write API version to firmware */ 904 ret = regmap_bulk_write(state->regmap, 0x9bf2, state->api_version, 4); 905 if (ret) 906 goto err; 907 908 /* program ADC control */ 909 switch (state->clk) { 910 case 28800000: /* 28.800 MHz */ 911 utmp = 0; 912 break; 913 case 20480000: /* 20.480 MHz */ 914 utmp = 1; 915 break; 916 case 28000000: /* 28.000 MHz */ 917 utmp = 2; 918 break; 919 case 25000000: /* 25.000 MHz */ 920 utmp = 3; 921 break; 922 default: 923 ret = -EINVAL; 924 goto err; 925 } 926 927 ret = regmap_update_bits(state->regmap, 0x9bd2, 0x0f, utmp); 928 if (ret) 929 goto err; 930 931 utmp = div_u64((u64)state->clk * 0x80000, 1000000); 932 buf[0] = (utmp >> 0) & 0xff; 933 buf[1] = (utmp >> 8) & 0xff; 934 buf[2] = (utmp >> 16) & 0xff; 935 ret = regmap_bulk_write(state->regmap, 0xd180, buf, 3); 936 if (ret) 937 goto err; 938 939 /* set I2C master clock */ 940 ret = regmap_write(state->regmap, 0xd416, 0x14); 941 if (ret) 942 goto err; 943 944 /* set 16 embx */ 945 ret = regmap_update_bits(state->regmap, 0xd700, 0x02, 0x02); 946 if (ret) 947 goto err; 948 949 /* set no trigger */ 950 ret = regmap_update_bits(state->regmap, 0xd700, 0x04, 0x00); 951 if (ret) 952 goto err; 953 954 /* set read-update bit for constellation */ 955 ret = regmap_update_bits(state->regmap, 0xd371, 0x02, 0x02); 956 if (ret) 957 goto err; 958 959 /* settings for mp2if */ 960 if (state->ts_mode == AF9013_TS_MODE_USB) { 961 /* AF9015 split PSB to 1.5k + 0.5k */ 962 ret = regmap_update_bits(state->regmap, 0xd50b, 0x04, 0x04); 963 if (ret) 964 goto err; 965 } else { 966 /* AF9013 set mpeg to full speed */ 967 ret = regmap_update_bits(state->regmap, 0xd502, 0x10, 0x10); 968 if (ret) 969 goto err; 970 } 971 972 ret = regmap_update_bits(state->regmap, 0xd520, 0x10, 0x10); 973 if (ret) 974 goto err; 975 976 /* load OFSM settings */ 977 dev_dbg(&client->dev, "load ofsm settings\n"); 978 len = ARRAY_SIZE(ofsm_init); 979 init = ofsm_init; 980 for (i = 0; i < len; i++) { 981 u16 reg = init[i].addr; 982 u8 mask = GENMASK(init[i].pos + init[i].len - 1, init[i].pos); 983 u8 val = init[i].val << init[i].pos; 984 985 ret = regmap_update_bits(state->regmap, reg, mask, val); 986 if (ret) 987 goto err; 988 } 989 990 /* load tuner specific settings */ 991 dev_dbg(&client->dev, "load tuner specific settings\n"); 992 switch (state->tuner) { 993 case AF9013_TUNER_MXL5003D: 994 len = ARRAY_SIZE(tuner_init_mxl5003d); 995 init = tuner_init_mxl5003d; 996 break; 997 case AF9013_TUNER_MXL5005D: 998 case AF9013_TUNER_MXL5005R: 999 case AF9013_TUNER_MXL5007T: 1000 len = ARRAY_SIZE(tuner_init_mxl5005); 1001 init = tuner_init_mxl5005; 1002 break; 1003 case AF9013_TUNER_ENV77H11D5: 1004 len = ARRAY_SIZE(tuner_init_env77h11d5); 1005 init = tuner_init_env77h11d5; 1006 break; 1007 case AF9013_TUNER_MT2060: 1008 len = ARRAY_SIZE(tuner_init_mt2060); 1009 init = tuner_init_mt2060; 1010 break; 1011 case AF9013_TUNER_MC44S803: 1012 len = ARRAY_SIZE(tuner_init_mc44s803); 1013 init = tuner_init_mc44s803; 1014 break; 1015 case AF9013_TUNER_QT1010: 1016 case AF9013_TUNER_QT1010A: 1017 len = ARRAY_SIZE(tuner_init_qt1010); 1018 init = tuner_init_qt1010; 1019 break; 1020 case AF9013_TUNER_MT2060_2: 1021 len = ARRAY_SIZE(tuner_init_mt2060_2); 1022 init = tuner_init_mt2060_2; 1023 break; 1024 case AF9013_TUNER_TDA18271: 1025 case AF9013_TUNER_TDA18218: 1026 len = ARRAY_SIZE(tuner_init_tda18271); 1027 init = tuner_init_tda18271; 1028 break; 1029 case AF9013_TUNER_UNKNOWN: 1030 default: 1031 len = ARRAY_SIZE(tuner_init_unknown); 1032 init = tuner_init_unknown; 1033 break; 1034 } 1035 1036 for (i = 0; i < len; i++) { 1037 u16 reg = init[i].addr; 1038 u8 mask = GENMASK(init[i].pos + init[i].len - 1, init[i].pos); 1039 u8 val = init[i].val << init[i].pos; 1040 1041 ret = regmap_update_bits(state->regmap, reg, mask, val); 1042 if (ret) 1043 goto err; 1044 } 1045 1046 /* TS interface */ 1047 if (state->ts_output_pin == 7) 1048 utmp = 1 << 3 | state->ts_mode << 1; 1049 else 1050 utmp = 0 << 3 | state->ts_mode << 1; 1051 ret = regmap_update_bits(state->regmap, 0xd500, 0x0e, utmp); 1052 if (ret) 1053 goto err; 1054 1055 /* enable lock led */ 1056 ret = regmap_update_bits(state->regmap, 0xd730, 0x01, 0x01); 1057 if (ret) 1058 goto err; 1059 1060 /* check if we support signal strength */ 1061 if (!state->signal_strength_en) { 1062 ret = regmap_read(state->regmap, 0x9bee, &utmp); 1063 if (ret) 1064 goto err; 1065 1066 state->signal_strength_en = (utmp >> 0) & 0x01; 1067 } 1068 1069 /* read values needed for signal strength calculation */ 1070 if (state->signal_strength_en && !state->rf_50) { 1071 ret = regmap_bulk_read(state->regmap, 0x9bbd, &state->rf_50, 1); 1072 if (ret) 1073 goto err; 1074 ret = regmap_bulk_read(state->regmap, 0x9bd0, &state->rf_80, 1); 1075 if (ret) 1076 goto err; 1077 ret = regmap_bulk_read(state->regmap, 0x9be2, &state->if_50, 1); 1078 if (ret) 1079 goto err; 1080 ret = regmap_bulk_read(state->regmap, 0x9be4, &state->if_80, 1); 1081 if (ret) 1082 goto err; 1083 } 1084 1085 /* SNR */ 1086 ret = regmap_write(state->regmap, 0xd2e2, 0x01); 1087 if (ret) 1088 goto err; 1089 1090 /* BER / UCB */ 1091 buf[0] = (10000 >> 0) & 0xff; 1092 buf[1] = (10000 >> 8) & 0xff; 1093 ret = regmap_bulk_write(state->regmap, 0xd385, buf, 2); 1094 if (ret) 1095 goto err; 1096 1097 /* enable FEC monitor */ 1098 ret = regmap_update_bits(state->regmap, 0xd392, 0x02, 0x02); 1099 if (ret) 1100 goto err; 1101 1102 state->first_tune = true; 1103 schedule_delayed_work(&state->statistics_work, msecs_to_jiffies(400)); 1104 1105 return 0; 1106 err: 1107 dev_dbg(&client->dev, "failed %d\n", ret); 1108 return ret; 1109 } 1110 1111 static int af9013_sleep(struct dvb_frontend *fe) 1112 { 1113 struct af9013_state *state = fe->demodulator_priv; 1114 struct i2c_client *client = state->client; 1115 int ret; 1116 1117 dev_dbg(&client->dev, "\n"); 1118 1119 /* stop statistics polling */ 1120 cancel_delayed_work_sync(&state->statistics_work); 1121 1122 /* disable lock led */ 1123 ret = regmap_update_bits(state->regmap, 0xd730, 0x01, 0x00); 1124 if (ret) 1125 goto err; 1126 1127 /* power off */ 1128 ret = af9013_power_ctrl(state, 0); 1129 if (ret) 1130 goto err; 1131 1132 return 0; 1133 err: 1134 dev_dbg(&client->dev, "failed %d\n", ret); 1135 return ret; 1136 } 1137 1138 static int af9013_i2c_gate_ctrl(struct dvb_frontend *fe, int enable) 1139 { 1140 int ret; 1141 struct af9013_state *state = fe->demodulator_priv; 1142 struct i2c_client *client = state->client; 1143 1144 dev_dbg(&client->dev, "enable %d\n", enable); 1145 1146 /* gate already open or close */ 1147 if (state->i2c_gate_state == enable) 1148 return 0; 1149 1150 if (state->ts_mode == AF9013_TS_MODE_USB) 1151 ret = regmap_update_bits(state->regmap, 0xd417, 0x08, 1152 enable << 3); 1153 else 1154 ret = regmap_update_bits(state->regmap, 0xd607, 0x04, 1155 enable << 2); 1156 if (ret) 1157 goto err; 1158 1159 state->i2c_gate_state = enable; 1160 1161 return 0; 1162 err: 1163 dev_dbg(&client->dev, "failed %d\n", ret); 1164 return ret; 1165 } 1166 1167 static void af9013_release(struct dvb_frontend *fe) 1168 { 1169 struct af9013_state *state = fe->demodulator_priv; 1170 struct i2c_client *client = state->client; 1171 1172 dev_dbg(&client->dev, "\n"); 1173 1174 i2c_unregister_device(client); 1175 } 1176 1177 static const struct dvb_frontend_ops af9013_ops; 1178 1179 static int af9013_download_firmware(struct af9013_state *state) 1180 { 1181 struct i2c_client *client = state->client; 1182 int ret, i, len, remaining; 1183 unsigned int utmp; 1184 const struct firmware *fw; 1185 u16 checksum = 0; 1186 u8 fw_params[4]; 1187 u8 *fw_file = AF9013_FIRMWARE; 1188 1189 msleep(100); 1190 /* check whether firmware is already running */ 1191 ret = regmap_read(state->regmap, 0x98be, &utmp); 1192 if (ret) 1193 goto err; 1194 1195 dev_dbg(&client->dev, "firmware status %02x\n", utmp); 1196 1197 if (utmp == 0x0c) /* fw is running, no need for download */ 1198 return 0; 1199 1200 dev_info(&client->dev, "found a '%s' in cold state, will try to load a firmware\n", 1201 af9013_ops.info.name); 1202 1203 /* request the firmware, this will block and timeout */ 1204 ret = request_firmware(&fw, fw_file, &client->dev); 1205 if (ret) { 1206 dev_info(&client->dev, "firmware file '%s' not found %d\n", 1207 fw_file, ret); 1208 goto err; 1209 } 1210 1211 dev_info(&client->dev, "downloading firmware from file '%s'\n", 1212 fw_file); 1213 1214 /* calc checksum */ 1215 for (i = 0; i < fw->size; i++) 1216 checksum += fw->data[i]; 1217 1218 fw_params[0] = checksum >> 8; 1219 fw_params[1] = checksum & 0xff; 1220 fw_params[2] = fw->size >> 8; 1221 fw_params[3] = fw->size & 0xff; 1222 1223 /* write fw checksum & size */ 1224 ret = regmap_bulk_write(state->regmap, 0x50fc, fw_params, 1225 sizeof(fw_params)); 1226 1227 if (ret) 1228 goto err_release_firmware; 1229 1230 #define FW_ADDR 0x5100 /* firmware start address */ 1231 #define LEN_MAX 16 /* max packet size */ 1232 for (remaining = fw->size; remaining > 0; remaining -= LEN_MAX) { 1233 len = remaining; 1234 if (len > LEN_MAX) 1235 len = LEN_MAX; 1236 1237 ret = regmap_bulk_write(state->regmap, 1238 FW_ADDR + fw->size - remaining, 1239 &fw->data[fw->size - remaining], len); 1240 if (ret) { 1241 dev_err(&client->dev, "firmware download failed %d\n", 1242 ret); 1243 goto err_release_firmware; 1244 } 1245 } 1246 1247 release_firmware(fw); 1248 1249 /* request boot firmware */ 1250 ret = regmap_write(state->regmap, 0xe205, 0x01); 1251 if (ret) 1252 goto err; 1253 1254 /* Check firmware status. 0c=OK, 04=fail */ 1255 ret = regmap_read_poll_timeout(state->regmap, 0x98be, utmp, 1256 (utmp == 0x0c || utmp == 0x04), 1257 5000, 1000000); 1258 if (ret) 1259 goto err; 1260 1261 dev_dbg(&client->dev, "firmware status %02x\n", utmp); 1262 1263 if (utmp == 0x04) { 1264 ret = -ENODEV; 1265 dev_err(&client->dev, "firmware did not run\n"); 1266 goto err; 1267 } else if (utmp != 0x0c) { 1268 ret = -ENODEV; 1269 dev_err(&client->dev, "firmware boot timeout\n"); 1270 goto err; 1271 } 1272 1273 dev_info(&client->dev, "found a '%s' in warm state\n", 1274 af9013_ops.info.name); 1275 1276 return 0; 1277 err_release_firmware: 1278 release_firmware(fw); 1279 err: 1280 dev_dbg(&client->dev, "failed %d\n", ret); 1281 return ret; 1282 } 1283 1284 /* 1285 * XXX: That is wrapper to af9013_probe() via driver core in order to provide 1286 * proper I2C client for legacy media attach binding. 1287 * New users must use I2C client binding directly! 1288 */ 1289 struct dvb_frontend *af9013_attach(const struct af9013_config *config, 1290 struct i2c_adapter *i2c) 1291 { 1292 struct i2c_client *client; 1293 struct i2c_board_info board_info; 1294 struct af9013_platform_data pdata; 1295 1296 pdata.clk = config->clock; 1297 pdata.tuner = config->tuner; 1298 pdata.if_frequency = config->if_frequency; 1299 pdata.ts_mode = config->ts_mode; 1300 pdata.ts_output_pin = 7; 1301 pdata.spec_inv = config->spec_inv; 1302 memcpy(&pdata.api_version, config->api_version, sizeof(pdata.api_version)); 1303 memcpy(&pdata.gpio, config->gpio, sizeof(pdata.gpio)); 1304 pdata.attach_in_use = true; 1305 1306 memset(&board_info, 0, sizeof(board_info)); 1307 strlcpy(board_info.type, "af9013", sizeof(board_info.type)); 1308 board_info.addr = config->i2c_addr; 1309 board_info.platform_data = &pdata; 1310 client = i2c_new_device(i2c, &board_info); 1311 if (!client || !client->dev.driver) 1312 return NULL; 1313 1314 return pdata.get_dvb_frontend(client); 1315 } 1316 EXPORT_SYMBOL(af9013_attach); 1317 1318 static const struct dvb_frontend_ops af9013_ops = { 1319 .delsys = { SYS_DVBT }, 1320 .info = { 1321 .name = "Afatech AF9013", 1322 .frequency_min = 174000000, 1323 .frequency_max = 862000000, 1324 .frequency_stepsize = 250000, 1325 .frequency_tolerance = 0, 1326 .caps = FE_CAN_FEC_1_2 | 1327 FE_CAN_FEC_2_3 | 1328 FE_CAN_FEC_3_4 | 1329 FE_CAN_FEC_5_6 | 1330 FE_CAN_FEC_7_8 | 1331 FE_CAN_FEC_AUTO | 1332 FE_CAN_QPSK | 1333 FE_CAN_QAM_16 | 1334 FE_CAN_QAM_64 | 1335 FE_CAN_QAM_AUTO | 1336 FE_CAN_TRANSMISSION_MODE_AUTO | 1337 FE_CAN_GUARD_INTERVAL_AUTO | 1338 FE_CAN_HIERARCHY_AUTO | 1339 FE_CAN_RECOVER | 1340 FE_CAN_MUTE_TS 1341 }, 1342 1343 .release = af9013_release, 1344 1345 .init = af9013_init, 1346 .sleep = af9013_sleep, 1347 1348 .get_tune_settings = af9013_get_tune_settings, 1349 .set_frontend = af9013_set_frontend, 1350 .get_frontend = af9013_get_frontend, 1351 1352 .read_status = af9013_read_status, 1353 .read_snr = af9013_read_snr, 1354 .read_signal_strength = af9013_read_signal_strength, 1355 .read_ber = af9013_read_ber, 1356 .read_ucblocks = af9013_read_ucblocks, 1357 1358 .i2c_gate_ctrl = af9013_i2c_gate_ctrl, 1359 }; 1360 1361 static struct dvb_frontend *af9013_get_dvb_frontend(struct i2c_client *client) 1362 { 1363 struct af9013_state *state = i2c_get_clientdata(client); 1364 1365 dev_dbg(&client->dev, "\n"); 1366 1367 return &state->fe; 1368 } 1369 1370 /* Own I2C access routines needed for regmap as chip uses extra command byte */ 1371 static int af9013_wregs(struct i2c_client *client, u8 cmd, u16 reg, 1372 const u8 *val, int len) 1373 { 1374 int ret; 1375 u8 buf[21]; 1376 struct i2c_msg msg[1] = { 1377 { 1378 .addr = client->addr, 1379 .flags = 0, 1380 .len = 3 + len, 1381 .buf = buf, 1382 } 1383 }; 1384 1385 if (3 + len > sizeof(buf)) { 1386 ret = -EINVAL; 1387 goto err; 1388 } 1389 1390 buf[0] = (reg >> 8) & 0xff; 1391 buf[1] = (reg >> 0) & 0xff; 1392 buf[2] = cmd; 1393 memcpy(&buf[3], val, len); 1394 ret = i2c_transfer(client->adapter, msg, 1); 1395 if (ret < 0) { 1396 goto err; 1397 } else if (ret != 1) { 1398 ret = -EREMOTEIO; 1399 goto err; 1400 } 1401 1402 return 0; 1403 err: 1404 dev_dbg(&client->dev, "failed %d\n", ret); 1405 return ret; 1406 } 1407 1408 static int af9013_rregs(struct i2c_client *client, u8 cmd, u16 reg, 1409 u8 *val, int len) 1410 { 1411 int ret; 1412 u8 buf[3]; 1413 struct i2c_msg msg[2] = { 1414 { 1415 .addr = client->addr, 1416 .flags = 0, 1417 .len = 3, 1418 .buf = buf, 1419 }, { 1420 .addr = client->addr, 1421 .flags = I2C_M_RD, 1422 .len = len, 1423 .buf = val, 1424 } 1425 }; 1426 1427 buf[0] = (reg >> 8) & 0xff; 1428 buf[1] = (reg >> 0) & 0xff; 1429 buf[2] = cmd; 1430 ret = i2c_transfer(client->adapter, msg, 2); 1431 if (ret < 0) { 1432 goto err; 1433 } else if (ret != 2) { 1434 ret = -EREMOTEIO; 1435 goto err; 1436 } 1437 1438 return 0; 1439 err: 1440 dev_dbg(&client->dev, "failed %d\n", ret); 1441 return ret; 1442 } 1443 1444 static int af9013_regmap_write(void *context, const void *data, size_t count) 1445 { 1446 struct i2c_client *client = context; 1447 struct af9013_state *state = i2c_get_clientdata(client); 1448 int ret, i; 1449 u8 cmd; 1450 u16 reg = ((u8 *)data)[0] << 8|((u8 *)data)[1] << 0; 1451 u8 *val = &((u8 *)data)[2]; 1452 const unsigned int len = count - 2; 1453 1454 if (state->ts_mode == AF9013_TS_MODE_USB && (reg & 0xff00) != 0xae00) { 1455 cmd = 0 << 7|0 << 6|(len - 1) << 2|1 << 1|1 << 0; 1456 ret = af9013_wregs(client, cmd, reg, val, len); 1457 if (ret) 1458 goto err; 1459 } else if (reg >= 0x5100 && reg < 0x8fff) { 1460 /* Firmware download */ 1461 cmd = 1 << 7|1 << 6|(len - 1) << 2|1 << 1|1 << 0; 1462 ret = af9013_wregs(client, cmd, reg, val, len); 1463 if (ret) 1464 goto err; 1465 } else { 1466 cmd = 0 << 7|0 << 6|(1 - 1) << 2|1 << 1|1 << 0; 1467 for (i = 0; i < len; i++) { 1468 ret = af9013_wregs(client, cmd, reg + i, val + i, 1); 1469 if (ret) 1470 goto err; 1471 } 1472 } 1473 1474 return 0; 1475 err: 1476 dev_dbg(&client->dev, "failed %d\n", ret); 1477 return ret; 1478 } 1479 1480 static int af9013_regmap_read(void *context, const void *reg_buf, 1481 size_t reg_size, void *val_buf, size_t val_size) 1482 { 1483 struct i2c_client *client = context; 1484 struct af9013_state *state = i2c_get_clientdata(client); 1485 int ret, i; 1486 u8 cmd; 1487 u16 reg = ((u8 *)reg_buf)[0] << 8|((u8 *)reg_buf)[1] << 0; 1488 u8 *val = &((u8 *)val_buf)[0]; 1489 const unsigned int len = val_size; 1490 1491 if (state->ts_mode == AF9013_TS_MODE_USB && (reg & 0xff00) != 0xae00) { 1492 cmd = 0 << 7|0 << 6|(len - 1) << 2|1 << 1|0 << 0; 1493 ret = af9013_rregs(client, cmd, reg, val_buf, len); 1494 if (ret) 1495 goto err; 1496 } else { 1497 cmd = 0 << 7|0 << 6|(1 - 1) << 2|1 << 1|0 << 0; 1498 for (i = 0; i < len; i++) { 1499 ret = af9013_rregs(client, cmd, reg + i, val + i, 1); 1500 if (ret) 1501 goto err; 1502 } 1503 } 1504 1505 return 0; 1506 err: 1507 dev_dbg(&client->dev, "failed %d\n", ret); 1508 return ret; 1509 } 1510 1511 static int af9013_probe(struct i2c_client *client, 1512 const struct i2c_device_id *id) 1513 { 1514 struct af9013_state *state; 1515 struct af9013_platform_data *pdata = client->dev.platform_data; 1516 struct dtv_frontend_properties *c; 1517 int ret, i; 1518 u8 firmware_version[4]; 1519 static const struct regmap_bus regmap_bus = { 1520 .read = af9013_regmap_read, 1521 .write = af9013_regmap_write, 1522 }; 1523 static const struct regmap_config regmap_config = { 1524 .reg_bits = 16, 1525 .val_bits = 8, 1526 }; 1527 1528 state = kzalloc(sizeof(*state), GFP_KERNEL); 1529 if (!state) { 1530 ret = -ENOMEM; 1531 goto err; 1532 } 1533 1534 /* Setup the state */ 1535 state->client = client; 1536 i2c_set_clientdata(client, state); 1537 state->clk = pdata->clk; 1538 state->tuner = pdata->tuner; 1539 state->if_frequency = pdata->if_frequency; 1540 state->ts_mode = pdata->ts_mode; 1541 state->ts_output_pin = pdata->ts_output_pin; 1542 state->spec_inv = pdata->spec_inv; 1543 memcpy(&state->api_version, pdata->api_version, sizeof(state->api_version)); 1544 memcpy(&state->gpio, pdata->gpio, sizeof(state->gpio)); 1545 INIT_DELAYED_WORK(&state->statistics_work, af9013_statistics_work); 1546 state->regmap = regmap_init(&client->dev, ®map_bus, client, 1547 ®map_config); 1548 if (IS_ERR(state->regmap)) { 1549 ret = PTR_ERR(state->regmap); 1550 goto err_kfree; 1551 } 1552 1553 /* Download firmware */ 1554 if (state->ts_mode != AF9013_TS_MODE_USB) { 1555 ret = af9013_download_firmware(state); 1556 if (ret) 1557 goto err_regmap_exit; 1558 } 1559 1560 /* Firmware version */ 1561 ret = regmap_bulk_read(state->regmap, 0x5103, firmware_version, 1562 sizeof(firmware_version)); 1563 if (ret) 1564 goto err_regmap_exit; 1565 1566 /* Set GPIOs */ 1567 for (i = 0; i < sizeof(state->gpio); i++) { 1568 ret = af9013_set_gpio(state, i, state->gpio[i]); 1569 if (ret) 1570 goto err_regmap_exit; 1571 } 1572 1573 /* Create dvb frontend */ 1574 memcpy(&state->fe.ops, &af9013_ops, sizeof(state->fe.ops)); 1575 if (!pdata->attach_in_use) 1576 state->fe.ops.release = NULL; 1577 state->fe.demodulator_priv = state; 1578 1579 /* Setup callbacks */ 1580 pdata->get_dvb_frontend = af9013_get_dvb_frontend; 1581 1582 /* Init stats to indicate which stats are supported */ 1583 c = &state->fe.dtv_property_cache; 1584 c->cnr.len = 1; 1585 1586 dev_info(&client->dev, "Afatech AF9013 successfully attached\n"); 1587 dev_info(&client->dev, "firmware version: %d.%d.%d.%d\n", 1588 firmware_version[0], firmware_version[1], 1589 firmware_version[2], firmware_version[3]); 1590 return 0; 1591 err_regmap_exit: 1592 regmap_exit(state->regmap); 1593 err_kfree: 1594 kfree(state); 1595 err: 1596 dev_dbg(&client->dev, "failed %d\n", ret); 1597 return ret; 1598 } 1599 1600 static int af9013_remove(struct i2c_client *client) 1601 { 1602 struct af9013_state *state = i2c_get_clientdata(client); 1603 1604 dev_dbg(&client->dev, "\n"); 1605 1606 /* Stop statistics polling */ 1607 cancel_delayed_work_sync(&state->statistics_work); 1608 1609 regmap_exit(state->regmap); 1610 1611 kfree(state); 1612 1613 return 0; 1614 } 1615 1616 static const struct i2c_device_id af9013_id_table[] = { 1617 {"af9013", 0}, 1618 {} 1619 }; 1620 MODULE_DEVICE_TABLE(i2c, af9013_id_table); 1621 1622 static struct i2c_driver af9013_driver = { 1623 .driver = { 1624 .name = "af9013", 1625 .suppress_bind_attrs = true, 1626 }, 1627 .probe = af9013_probe, 1628 .remove = af9013_remove, 1629 .id_table = af9013_id_table, 1630 }; 1631 1632 module_i2c_driver(af9013_driver); 1633 1634 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); 1635 MODULE_DESCRIPTION("Afatech AF9013 DVB-T demodulator driver"); 1636 MODULE_LICENSE("GPL"); 1637 MODULE_FIRMWARE(AF9013_FIRMWARE); 1638