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