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