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