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