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