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 30 struct 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 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 /* write multiple registers */ 52 static 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 */ 90 static 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 */ 125 static 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 143 err: 144 return 0; 145 } 146 147 /* read multiple registers */ 148 static 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 165 err: 166 return 0; 167 } 168 169 /* write single register */ 170 static 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 */ 176 static int af9013_rd_reg(struct af9013_state *priv, u16 reg, u8 *val) 177 { 178 return af9013_rd_regs(priv, reg, val, 1); 179 } 180 181 static 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 188 static 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 209 static 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 225 static 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; 273 err: 274 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 275 return ret; 276 } 277 278 static 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 305 static 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: onoff=%d\n", __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; 354 err: 355 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 356 return ret; 357 } 358 359 static 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; 372 err: 373 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 374 return ret; 375 } 376 377 static 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; 403 err: 404 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 405 return ret; 406 } 407 408 static 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; 421 err: 422 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 423 return ret; 424 } 425 426 static 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; 484 err: 485 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 486 return ret; 487 } 488 489 static 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; 521 err: 522 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 523 return ret; 524 } 525 526 static 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 573 static 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 583 static 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 /* Return an error if can't find bandwidth or the right clock */ 609 if (i == ARRAY_SIZE(coeff_lut)) 610 return -EINVAL; 611 612 ret = af9013_wr_regs(state, 0xae00, coeff_lut[i].val, 613 sizeof(coeff_lut[i].val)); 614 } 615 616 /* program frequency control */ 617 if (c->bandwidth_hz != state->bandwidth_hz || state->first_tune) { 618 /* get used IF frequency */ 619 if (fe->ops.tuner_ops.get_if_frequency) 620 fe->ops.tuner_ops.get_if_frequency(fe, &if_frequency); 621 else 622 if_frequency = state->config.if_frequency; 623 624 dev_dbg(&state->i2c->dev, "%s: if_frequency=%d\n", 625 __func__, if_frequency); 626 627 sampling_freq = if_frequency; 628 629 while (sampling_freq > (state->config.clock / 2)) 630 sampling_freq -= state->config.clock; 631 632 if (sampling_freq < 0) { 633 sampling_freq *= -1; 634 spec_inv = state->config.spec_inv; 635 } else { 636 spec_inv = !state->config.spec_inv; 637 } 638 639 freq_cw = af9013_div(state, sampling_freq, state->config.clock, 640 23); 641 642 if (spec_inv) 643 freq_cw = 0x800000 - freq_cw; 644 645 buf[0] = (freq_cw >> 0) & 0xff; 646 buf[1] = (freq_cw >> 8) & 0xff; 647 buf[2] = (freq_cw >> 16) & 0x7f; 648 649 freq_cw = 0x800000 - freq_cw; 650 651 buf[3] = (freq_cw >> 0) & 0xff; 652 buf[4] = (freq_cw >> 8) & 0xff; 653 buf[5] = (freq_cw >> 16) & 0x7f; 654 655 ret = af9013_wr_regs(state, 0xd140, buf, 3); 656 if (ret) 657 goto err; 658 659 ret = af9013_wr_regs(state, 0x9be7, buf, 6); 660 if (ret) 661 goto err; 662 } 663 664 /* clear TPS lock flag */ 665 ret = af9013_wr_reg_bits(state, 0xd330, 3, 1, 1); 666 if (ret) 667 goto err; 668 669 /* clear MPEG2 lock flag */ 670 ret = af9013_wr_reg_bits(state, 0xd507, 6, 1, 0); 671 if (ret) 672 goto err; 673 674 /* empty channel function */ 675 ret = af9013_wr_reg_bits(state, 0x9bfe, 0, 1, 0); 676 if (ret) 677 goto err; 678 679 /* empty DVB-T channel function */ 680 ret = af9013_wr_reg_bits(state, 0x9bc2, 0, 1, 0); 681 if (ret) 682 goto err; 683 684 /* transmission parameters */ 685 auto_mode = false; 686 memset(buf, 0, 3); 687 688 switch (c->transmission_mode) { 689 case TRANSMISSION_MODE_AUTO: 690 auto_mode = true; 691 break; 692 case TRANSMISSION_MODE_2K: 693 break; 694 case TRANSMISSION_MODE_8K: 695 buf[0] |= (1 << 0); 696 break; 697 default: 698 dev_dbg(&state->i2c->dev, "%s: invalid transmission_mode\n", 699 __func__); 700 auto_mode = true; 701 } 702 703 switch (c->guard_interval) { 704 case GUARD_INTERVAL_AUTO: 705 auto_mode = true; 706 break; 707 case GUARD_INTERVAL_1_32: 708 break; 709 case GUARD_INTERVAL_1_16: 710 buf[0] |= (1 << 2); 711 break; 712 case GUARD_INTERVAL_1_8: 713 buf[0] |= (2 << 2); 714 break; 715 case GUARD_INTERVAL_1_4: 716 buf[0] |= (3 << 2); 717 break; 718 default: 719 dev_dbg(&state->i2c->dev, "%s: invalid guard_interval\n", 720 __func__); 721 auto_mode = true; 722 } 723 724 switch (c->hierarchy) { 725 case HIERARCHY_AUTO: 726 auto_mode = true; 727 break; 728 case HIERARCHY_NONE: 729 break; 730 case HIERARCHY_1: 731 buf[0] |= (1 << 4); 732 break; 733 case HIERARCHY_2: 734 buf[0] |= (2 << 4); 735 break; 736 case HIERARCHY_4: 737 buf[0] |= (3 << 4); 738 break; 739 default: 740 dev_dbg(&state->i2c->dev, "%s: invalid hierarchy\n", __func__); 741 auto_mode = true; 742 } 743 744 switch (c->modulation) { 745 case QAM_AUTO: 746 auto_mode = true; 747 break; 748 case QPSK: 749 break; 750 case QAM_16: 751 buf[1] |= (1 << 6); 752 break; 753 case QAM_64: 754 buf[1] |= (2 << 6); 755 break; 756 default: 757 dev_dbg(&state->i2c->dev, "%s: invalid modulation\n", __func__); 758 auto_mode = true; 759 } 760 761 /* Use HP. How and which case we can switch to LP? */ 762 buf[1] |= (1 << 4); 763 764 switch (c->code_rate_HP) { 765 case FEC_AUTO: 766 auto_mode = true; 767 break; 768 case FEC_1_2: 769 break; 770 case FEC_2_3: 771 buf[2] |= (1 << 0); 772 break; 773 case FEC_3_4: 774 buf[2] |= (2 << 0); 775 break; 776 case FEC_5_6: 777 buf[2] |= (3 << 0); 778 break; 779 case FEC_7_8: 780 buf[2] |= (4 << 0); 781 break; 782 default: 783 dev_dbg(&state->i2c->dev, "%s: invalid code_rate_HP\n", 784 __func__); 785 auto_mode = true; 786 } 787 788 switch (c->code_rate_LP) { 789 case FEC_AUTO: 790 auto_mode = true; 791 break; 792 case FEC_1_2: 793 break; 794 case FEC_2_3: 795 buf[2] |= (1 << 3); 796 break; 797 case FEC_3_4: 798 buf[2] |= (2 << 3); 799 break; 800 case FEC_5_6: 801 buf[2] |= (3 << 3); 802 break; 803 case FEC_7_8: 804 buf[2] |= (4 << 3); 805 break; 806 case FEC_NONE: 807 break; 808 default: 809 dev_dbg(&state->i2c->dev, "%s: invalid code_rate_LP\n", 810 __func__); 811 auto_mode = true; 812 } 813 814 switch (c->bandwidth_hz) { 815 case 6000000: 816 break; 817 case 7000000: 818 buf[1] |= (1 << 2); 819 break; 820 case 8000000: 821 buf[1] |= (2 << 2); 822 break; 823 default: 824 dev_dbg(&state->i2c->dev, "%s: invalid bandwidth_hz\n", 825 __func__); 826 ret = -EINVAL; 827 goto err; 828 } 829 830 ret = af9013_wr_regs(state, 0xd3c0, buf, 3); 831 if (ret) 832 goto err; 833 834 if (auto_mode) { 835 /* clear easy mode flag */ 836 ret = af9013_wr_reg(state, 0xaefd, 0); 837 if (ret) 838 goto err; 839 840 dev_dbg(&state->i2c->dev, "%s: auto params\n", __func__); 841 } else { 842 /* set easy mode flag */ 843 ret = af9013_wr_reg(state, 0xaefd, 1); 844 if (ret) 845 goto err; 846 847 ret = af9013_wr_reg(state, 0xaefe, 0); 848 if (ret) 849 goto err; 850 851 dev_dbg(&state->i2c->dev, "%s: manual params\n", __func__); 852 } 853 854 /* tune */ 855 ret = af9013_wr_reg(state, 0xffff, 0); 856 if (ret) 857 goto err; 858 859 state->bandwidth_hz = c->bandwidth_hz; 860 state->set_frontend_jiffies = jiffies; 861 state->first_tune = false; 862 863 return ret; 864 err: 865 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 866 return ret; 867 } 868 869 static int af9013_get_frontend(struct dvb_frontend *fe, 870 struct dtv_frontend_properties *c) 871 { 872 struct af9013_state *state = fe->demodulator_priv; 873 int ret; 874 u8 buf[3]; 875 876 dev_dbg(&state->i2c->dev, "%s:\n", __func__); 877 878 ret = af9013_rd_regs(state, 0xd3c0, buf, 3); 879 if (ret) 880 goto err; 881 882 switch ((buf[1] >> 6) & 3) { 883 case 0: 884 c->modulation = QPSK; 885 break; 886 case 1: 887 c->modulation = QAM_16; 888 break; 889 case 2: 890 c->modulation = QAM_64; 891 break; 892 } 893 894 switch ((buf[0] >> 0) & 3) { 895 case 0: 896 c->transmission_mode = TRANSMISSION_MODE_2K; 897 break; 898 case 1: 899 c->transmission_mode = TRANSMISSION_MODE_8K; 900 } 901 902 switch ((buf[0] >> 2) & 3) { 903 case 0: 904 c->guard_interval = GUARD_INTERVAL_1_32; 905 break; 906 case 1: 907 c->guard_interval = GUARD_INTERVAL_1_16; 908 break; 909 case 2: 910 c->guard_interval = GUARD_INTERVAL_1_8; 911 break; 912 case 3: 913 c->guard_interval = GUARD_INTERVAL_1_4; 914 break; 915 } 916 917 switch ((buf[0] >> 4) & 7) { 918 case 0: 919 c->hierarchy = HIERARCHY_NONE; 920 break; 921 case 1: 922 c->hierarchy = HIERARCHY_1; 923 break; 924 case 2: 925 c->hierarchy = HIERARCHY_2; 926 break; 927 case 3: 928 c->hierarchy = HIERARCHY_4; 929 break; 930 } 931 932 switch ((buf[2] >> 0) & 7) { 933 case 0: 934 c->code_rate_HP = FEC_1_2; 935 break; 936 case 1: 937 c->code_rate_HP = FEC_2_3; 938 break; 939 case 2: 940 c->code_rate_HP = FEC_3_4; 941 break; 942 case 3: 943 c->code_rate_HP = FEC_5_6; 944 break; 945 case 4: 946 c->code_rate_HP = FEC_7_8; 947 break; 948 } 949 950 switch ((buf[2] >> 3) & 7) { 951 case 0: 952 c->code_rate_LP = FEC_1_2; 953 break; 954 case 1: 955 c->code_rate_LP = FEC_2_3; 956 break; 957 case 2: 958 c->code_rate_LP = FEC_3_4; 959 break; 960 case 3: 961 c->code_rate_LP = FEC_5_6; 962 break; 963 case 4: 964 c->code_rate_LP = FEC_7_8; 965 break; 966 } 967 968 switch ((buf[1] >> 2) & 3) { 969 case 0: 970 c->bandwidth_hz = 6000000; 971 break; 972 case 1: 973 c->bandwidth_hz = 7000000; 974 break; 975 case 2: 976 c->bandwidth_hz = 8000000; 977 break; 978 } 979 980 return ret; 981 err: 982 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 983 return ret; 984 } 985 986 static int af9013_read_status(struct dvb_frontend *fe, enum fe_status *status) 987 { 988 struct af9013_state *state = fe->demodulator_priv; 989 int ret; 990 u8 tmp; 991 992 /* 993 * Return status from the cache if it is younger than 2000ms with the 994 * exception of last tune is done during 4000ms. 995 */ 996 if (time_is_after_jiffies( 997 state->read_status_jiffies + msecs_to_jiffies(2000)) && 998 time_is_before_jiffies( 999 state->set_frontend_jiffies + msecs_to_jiffies(4000)) 1000 ) { 1001 *status = state->fe_status; 1002 return 0; 1003 } else { 1004 *status = 0; 1005 } 1006 1007 /* MPEG2 lock */ 1008 ret = af9013_rd_reg_bits(state, 0xd507, 6, 1, &tmp); 1009 if (ret) 1010 goto err; 1011 1012 if (tmp) 1013 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI | 1014 FE_HAS_SYNC | FE_HAS_LOCK; 1015 1016 if (!*status) { 1017 /* TPS lock */ 1018 ret = af9013_rd_reg_bits(state, 0xd330, 3, 1, &tmp); 1019 if (ret) 1020 goto err; 1021 1022 if (tmp) 1023 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER | 1024 FE_HAS_VITERBI; 1025 } 1026 1027 state->fe_status = *status; 1028 state->read_status_jiffies = jiffies; 1029 1030 return ret; 1031 err: 1032 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 1033 return ret; 1034 } 1035 1036 static int af9013_read_snr(struct dvb_frontend *fe, u16 *snr) 1037 { 1038 struct af9013_state *state = fe->demodulator_priv; 1039 *snr = state->snr; 1040 return 0; 1041 } 1042 1043 static int af9013_read_signal_strength(struct dvb_frontend *fe, u16 *strength) 1044 { 1045 struct af9013_state *state = fe->demodulator_priv; 1046 *strength = state->signal_strength; 1047 return 0; 1048 } 1049 1050 static int af9013_read_ber(struct dvb_frontend *fe, u32 *ber) 1051 { 1052 struct af9013_state *state = fe->demodulator_priv; 1053 *ber = state->ber; 1054 return 0; 1055 } 1056 1057 static int af9013_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks) 1058 { 1059 struct af9013_state *state = fe->demodulator_priv; 1060 *ucblocks = state->ucblocks; 1061 return 0; 1062 } 1063 1064 static int af9013_init(struct dvb_frontend *fe) 1065 { 1066 struct af9013_state *state = fe->demodulator_priv; 1067 int ret, i, len; 1068 u8 buf[3], tmp; 1069 u32 adc_cw; 1070 const struct af9013_reg_bit *init; 1071 1072 dev_dbg(&state->i2c->dev, "%s:\n", __func__); 1073 1074 /* power on */ 1075 ret = af9013_power_ctrl(state, 1); 1076 if (ret) 1077 goto err; 1078 1079 /* enable ADC */ 1080 ret = af9013_wr_reg(state, 0xd73a, 0xa4); 1081 if (ret) 1082 goto err; 1083 1084 /* write API version to firmware */ 1085 ret = af9013_wr_regs(state, 0x9bf2, state->config.api_version, 4); 1086 if (ret) 1087 goto err; 1088 1089 /* program ADC control */ 1090 switch (state->config.clock) { 1091 case 28800000: /* 28.800 MHz */ 1092 tmp = 0; 1093 break; 1094 case 20480000: /* 20.480 MHz */ 1095 tmp = 1; 1096 break; 1097 case 28000000: /* 28.000 MHz */ 1098 tmp = 2; 1099 break; 1100 case 25000000: /* 25.000 MHz */ 1101 tmp = 3; 1102 break; 1103 default: 1104 dev_err(&state->i2c->dev, "%s: invalid clock\n", 1105 KBUILD_MODNAME); 1106 return -EINVAL; 1107 } 1108 1109 adc_cw = af9013_div(state, state->config.clock, 1000000ul, 19); 1110 buf[0] = (adc_cw >> 0) & 0xff; 1111 buf[1] = (adc_cw >> 8) & 0xff; 1112 buf[2] = (adc_cw >> 16) & 0xff; 1113 1114 ret = af9013_wr_regs(state, 0xd180, buf, 3); 1115 if (ret) 1116 goto err; 1117 1118 ret = af9013_wr_reg_bits(state, 0x9bd2, 0, 4, tmp); 1119 if (ret) 1120 goto err; 1121 1122 /* set I2C master clock */ 1123 ret = af9013_wr_reg(state, 0xd416, 0x14); 1124 if (ret) 1125 goto err; 1126 1127 /* set 16 embx */ 1128 ret = af9013_wr_reg_bits(state, 0xd700, 1, 1, 1); 1129 if (ret) 1130 goto err; 1131 1132 /* set no trigger */ 1133 ret = af9013_wr_reg_bits(state, 0xd700, 2, 1, 0); 1134 if (ret) 1135 goto err; 1136 1137 /* set read-update bit for constellation */ 1138 ret = af9013_wr_reg_bits(state, 0xd371, 1, 1, 1); 1139 if (ret) 1140 goto err; 1141 1142 /* settings for mp2if */ 1143 if (state->config.ts_mode == AF9013_TS_USB) { 1144 /* AF9015 split PSB to 1.5k + 0.5k */ 1145 ret = af9013_wr_reg_bits(state, 0xd50b, 2, 1, 1); 1146 if (ret) 1147 goto err; 1148 } else { 1149 /* AF9013 change the output bit to data7 */ 1150 ret = af9013_wr_reg_bits(state, 0xd500, 3, 1, 1); 1151 if (ret) 1152 goto err; 1153 1154 /* AF9013 set mpeg to full speed */ 1155 ret = af9013_wr_reg_bits(state, 0xd502, 4, 1, 1); 1156 if (ret) 1157 goto err; 1158 } 1159 1160 ret = af9013_wr_reg_bits(state, 0xd520, 4, 1, 1); 1161 if (ret) 1162 goto err; 1163 1164 /* load OFSM settings */ 1165 dev_dbg(&state->i2c->dev, "%s: load ofsm settings\n", __func__); 1166 len = ARRAY_SIZE(ofsm_init); 1167 init = ofsm_init; 1168 for (i = 0; i < len; i++) { 1169 ret = af9013_wr_reg_bits(state, init[i].addr, init[i].pos, 1170 init[i].len, init[i].val); 1171 if (ret) 1172 goto err; 1173 } 1174 1175 /* load tuner specific settings */ 1176 dev_dbg(&state->i2c->dev, "%s: load tuner specific settings\n", 1177 __func__); 1178 switch (state->config.tuner) { 1179 case AF9013_TUNER_MXL5003D: 1180 len = ARRAY_SIZE(tuner_init_mxl5003d); 1181 init = tuner_init_mxl5003d; 1182 break; 1183 case AF9013_TUNER_MXL5005D: 1184 case AF9013_TUNER_MXL5005R: 1185 case AF9013_TUNER_MXL5007T: 1186 len = ARRAY_SIZE(tuner_init_mxl5005); 1187 init = tuner_init_mxl5005; 1188 break; 1189 case AF9013_TUNER_ENV77H11D5: 1190 len = ARRAY_SIZE(tuner_init_env77h11d5); 1191 init = tuner_init_env77h11d5; 1192 break; 1193 case AF9013_TUNER_MT2060: 1194 len = ARRAY_SIZE(tuner_init_mt2060); 1195 init = tuner_init_mt2060; 1196 break; 1197 case AF9013_TUNER_MC44S803: 1198 len = ARRAY_SIZE(tuner_init_mc44s803); 1199 init = tuner_init_mc44s803; 1200 break; 1201 case AF9013_TUNER_QT1010: 1202 case AF9013_TUNER_QT1010A: 1203 len = ARRAY_SIZE(tuner_init_qt1010); 1204 init = tuner_init_qt1010; 1205 break; 1206 case AF9013_TUNER_MT2060_2: 1207 len = ARRAY_SIZE(tuner_init_mt2060_2); 1208 init = tuner_init_mt2060_2; 1209 break; 1210 case AF9013_TUNER_TDA18271: 1211 case AF9013_TUNER_TDA18218: 1212 len = ARRAY_SIZE(tuner_init_tda18271); 1213 init = tuner_init_tda18271; 1214 break; 1215 case AF9013_TUNER_UNKNOWN: 1216 default: 1217 len = ARRAY_SIZE(tuner_init_unknown); 1218 init = tuner_init_unknown; 1219 break; 1220 } 1221 1222 for (i = 0; i < len; i++) { 1223 ret = af9013_wr_reg_bits(state, init[i].addr, init[i].pos, 1224 init[i].len, init[i].val); 1225 if (ret) 1226 goto err; 1227 } 1228 1229 /* TS mode */ 1230 ret = af9013_wr_reg_bits(state, 0xd500, 1, 2, state->config.ts_mode); 1231 if (ret) 1232 goto err; 1233 1234 /* enable lock led */ 1235 ret = af9013_wr_reg_bits(state, 0xd730, 0, 1, 1); 1236 if (ret) 1237 goto err; 1238 1239 /* check if we support signal strength */ 1240 if (!state->signal_strength_en) { 1241 ret = af9013_rd_reg_bits(state, 0x9bee, 0, 1, 1242 &state->signal_strength_en); 1243 if (ret) 1244 goto err; 1245 } 1246 1247 /* read values needed for signal strength calculation */ 1248 if (state->signal_strength_en && !state->rf_50) { 1249 ret = af9013_rd_reg(state, 0x9bbd, &state->rf_50); 1250 if (ret) 1251 goto err; 1252 1253 ret = af9013_rd_reg(state, 0x9bd0, &state->rf_80); 1254 if (ret) 1255 goto err; 1256 1257 ret = af9013_rd_reg(state, 0x9be2, &state->if_50); 1258 if (ret) 1259 goto err; 1260 1261 ret = af9013_rd_reg(state, 0x9be4, &state->if_80); 1262 if (ret) 1263 goto err; 1264 } 1265 1266 /* SNR */ 1267 ret = af9013_wr_reg(state, 0xd2e2, 1); 1268 if (ret) 1269 goto err; 1270 1271 /* BER / UCB */ 1272 buf[0] = (10000 >> 0) & 0xff; 1273 buf[1] = (10000 >> 8) & 0xff; 1274 ret = af9013_wr_regs(state, 0xd385, buf, 2); 1275 if (ret) 1276 goto err; 1277 1278 /* enable FEC monitor */ 1279 ret = af9013_wr_reg_bits(state, 0xd392, 1, 1, 1); 1280 if (ret) 1281 goto err; 1282 1283 state->first_tune = true; 1284 schedule_delayed_work(&state->statistics_work, msecs_to_jiffies(400)); 1285 1286 return ret; 1287 err: 1288 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 1289 return ret; 1290 } 1291 1292 static int af9013_sleep(struct dvb_frontend *fe) 1293 { 1294 struct af9013_state *state = fe->demodulator_priv; 1295 int ret; 1296 1297 dev_dbg(&state->i2c->dev, "%s:\n", __func__); 1298 1299 /* stop statistics polling */ 1300 cancel_delayed_work_sync(&state->statistics_work); 1301 1302 /* disable lock led */ 1303 ret = af9013_wr_reg_bits(state, 0xd730, 0, 1, 0); 1304 if (ret) 1305 goto err; 1306 1307 /* power off */ 1308 ret = af9013_power_ctrl(state, 0); 1309 if (ret) 1310 goto err; 1311 1312 return ret; 1313 err: 1314 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 1315 return ret; 1316 } 1317 1318 static int af9013_i2c_gate_ctrl(struct dvb_frontend *fe, int enable) 1319 { 1320 int ret; 1321 struct af9013_state *state = fe->demodulator_priv; 1322 1323 dev_dbg(&state->i2c->dev, "%s: enable=%d\n", __func__, enable); 1324 1325 /* gate already open or close */ 1326 if (state->i2c_gate_state == enable) 1327 return 0; 1328 1329 if (state->config.ts_mode == AF9013_TS_USB) 1330 ret = af9013_wr_reg_bits(state, 0xd417, 3, 1, enable); 1331 else 1332 ret = af9013_wr_reg_bits(state, 0xd607, 2, 1, enable); 1333 if (ret) 1334 goto err; 1335 1336 state->i2c_gate_state = enable; 1337 1338 return ret; 1339 err: 1340 dev_dbg(&state->i2c->dev, "%s: failed=%d\n", __func__, ret); 1341 return ret; 1342 } 1343 1344 static void af9013_release(struct dvb_frontend *fe) 1345 { 1346 struct af9013_state *state = fe->demodulator_priv; 1347 1348 /* stop statistics polling */ 1349 cancel_delayed_work_sync(&state->statistics_work); 1350 1351 kfree(state); 1352 } 1353 1354 static struct dvb_frontend_ops af9013_ops; 1355 1356 static int af9013_download_firmware(struct af9013_state *state) 1357 { 1358 int i, len, remaining, ret; 1359 const struct firmware *fw; 1360 u16 checksum = 0; 1361 u8 val; 1362 u8 fw_params[4]; 1363 u8 *fw_file = AF9013_FIRMWARE; 1364 1365 msleep(100); 1366 /* check whether firmware is already running */ 1367 ret = af9013_rd_reg(state, 0x98be, &val); 1368 if (ret) 1369 goto err; 1370 else 1371 dev_dbg(&state->i2c->dev, "%s: firmware status=%02x\n", 1372 __func__, val); 1373 1374 if (val == 0x0c) /* fw is running, no need for download */ 1375 goto exit; 1376 1377 dev_info(&state->i2c->dev, "%s: found a '%s' in cold state, will try " \ 1378 "to load a firmware\n", 1379 KBUILD_MODNAME, af9013_ops.info.name); 1380 1381 /* request the firmware, this will block and timeout */ 1382 ret = request_firmware(&fw, fw_file, state->i2c->dev.parent); 1383 if (ret) { 1384 dev_info(&state->i2c->dev, "%s: did not find the firmware " \ 1385 "file. (%s) Please see linux/Documentation/dvb/ for " \ 1386 "more details on firmware-problems. (%d)\n", 1387 KBUILD_MODNAME, fw_file, ret); 1388 goto err; 1389 } 1390 1391 dev_info(&state->i2c->dev, "%s: downloading firmware from file '%s'\n", 1392 KBUILD_MODNAME, fw_file); 1393 1394 /* calc checksum */ 1395 for (i = 0; i < fw->size; i++) 1396 checksum += fw->data[i]; 1397 1398 fw_params[0] = checksum >> 8; 1399 fw_params[1] = checksum & 0xff; 1400 fw_params[2] = fw->size >> 8; 1401 fw_params[3] = fw->size & 0xff; 1402 1403 /* write fw checksum & size */ 1404 ret = af9013_write_ofsm_regs(state, 0x50fc, 1405 fw_params, sizeof(fw_params)); 1406 if (ret) 1407 goto err_release; 1408 1409 #define FW_ADDR 0x5100 /* firmware start address */ 1410 #define LEN_MAX 16 /* max packet size */ 1411 for (remaining = fw->size; remaining > 0; remaining -= LEN_MAX) { 1412 len = remaining; 1413 if (len > LEN_MAX) 1414 len = LEN_MAX; 1415 1416 ret = af9013_write_ofsm_regs(state, 1417 FW_ADDR + fw->size - remaining, 1418 (u8 *) &fw->data[fw->size - remaining], len); 1419 if (ret) { 1420 dev_err(&state->i2c->dev, 1421 "%s: firmware download failed=%d\n", 1422 KBUILD_MODNAME, ret); 1423 goto err_release; 1424 } 1425 } 1426 1427 /* request boot firmware */ 1428 ret = af9013_wr_reg(state, 0xe205, 1); 1429 if (ret) 1430 goto err_release; 1431 1432 for (i = 0; i < 15; i++) { 1433 msleep(100); 1434 1435 /* check firmware status */ 1436 ret = af9013_rd_reg(state, 0x98be, &val); 1437 if (ret) 1438 goto err_release; 1439 1440 dev_dbg(&state->i2c->dev, "%s: firmware status=%02x\n", 1441 __func__, val); 1442 1443 if (val == 0x0c || val == 0x04) /* success or fail */ 1444 break; 1445 } 1446 1447 if (val == 0x04) { 1448 dev_err(&state->i2c->dev, "%s: firmware did not run\n", 1449 KBUILD_MODNAME); 1450 ret = -ENODEV; 1451 } else if (val != 0x0c) { 1452 dev_err(&state->i2c->dev, "%s: firmware boot timeout\n", 1453 KBUILD_MODNAME); 1454 ret = -ENODEV; 1455 } 1456 1457 err_release: 1458 release_firmware(fw); 1459 err: 1460 exit: 1461 if (!ret) 1462 dev_info(&state->i2c->dev, "%s: found a '%s' in warm state\n", 1463 KBUILD_MODNAME, af9013_ops.info.name); 1464 return ret; 1465 } 1466 1467 struct dvb_frontend *af9013_attach(const struct af9013_config *config, 1468 struct i2c_adapter *i2c) 1469 { 1470 int ret; 1471 struct af9013_state *state = NULL; 1472 u8 buf[4], i; 1473 1474 /* allocate memory for the internal state */ 1475 state = kzalloc(sizeof(struct af9013_state), GFP_KERNEL); 1476 if (state == NULL) 1477 goto err; 1478 1479 /* setup the state */ 1480 state->i2c = i2c; 1481 memcpy(&state->config, config, sizeof(struct af9013_config)); 1482 1483 /* download firmware */ 1484 if (state->config.ts_mode != AF9013_TS_USB) { 1485 ret = af9013_download_firmware(state); 1486 if (ret) 1487 goto err; 1488 } 1489 1490 /* firmware version */ 1491 ret = af9013_rd_regs(state, 0x5103, buf, 4); 1492 if (ret) 1493 goto err; 1494 1495 dev_info(&state->i2c->dev, "%s: firmware version %d.%d.%d.%d\n", 1496 KBUILD_MODNAME, buf[0], buf[1], buf[2], buf[3]); 1497 1498 /* set GPIOs */ 1499 for (i = 0; i < sizeof(state->config.gpio); i++) { 1500 ret = af9013_set_gpio(state, i, state->config.gpio[i]); 1501 if (ret) 1502 goto err; 1503 } 1504 1505 /* create dvb_frontend */ 1506 memcpy(&state->fe.ops, &af9013_ops, 1507 sizeof(struct dvb_frontend_ops)); 1508 state->fe.demodulator_priv = state; 1509 1510 INIT_DELAYED_WORK(&state->statistics_work, af9013_statistics_work); 1511 1512 return &state->fe; 1513 err: 1514 kfree(state); 1515 return NULL; 1516 } 1517 EXPORT_SYMBOL(af9013_attach); 1518 1519 static struct dvb_frontend_ops af9013_ops = { 1520 .delsys = { SYS_DVBT }, 1521 .info = { 1522 .name = "Afatech AF9013", 1523 .frequency_min = 174000000, 1524 .frequency_max = 862000000, 1525 .frequency_stepsize = 250000, 1526 .frequency_tolerance = 0, 1527 .caps = FE_CAN_FEC_1_2 | 1528 FE_CAN_FEC_2_3 | 1529 FE_CAN_FEC_3_4 | 1530 FE_CAN_FEC_5_6 | 1531 FE_CAN_FEC_7_8 | 1532 FE_CAN_FEC_AUTO | 1533 FE_CAN_QPSK | 1534 FE_CAN_QAM_16 | 1535 FE_CAN_QAM_64 | 1536 FE_CAN_QAM_AUTO | 1537 FE_CAN_TRANSMISSION_MODE_AUTO | 1538 FE_CAN_GUARD_INTERVAL_AUTO | 1539 FE_CAN_HIERARCHY_AUTO | 1540 FE_CAN_RECOVER | 1541 FE_CAN_MUTE_TS 1542 }, 1543 1544 .release = af9013_release, 1545 1546 .init = af9013_init, 1547 .sleep = af9013_sleep, 1548 1549 .get_tune_settings = af9013_get_tune_settings, 1550 .set_frontend = af9013_set_frontend, 1551 .get_frontend = af9013_get_frontend, 1552 1553 .read_status = af9013_read_status, 1554 .read_snr = af9013_read_snr, 1555 .read_signal_strength = af9013_read_signal_strength, 1556 .read_ber = af9013_read_ber, 1557 .read_ucblocks = af9013_read_ucblocks, 1558 1559 .i2c_gate_ctrl = af9013_i2c_gate_ctrl, 1560 }; 1561 1562 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>"); 1563 MODULE_DESCRIPTION("Afatech AF9013 DVB-T demodulator driver"); 1564 MODULE_LICENSE("GPL"); 1565 MODULE_FIRMWARE(AF9013_FIRMWARE); 1566