drivers/media/dvb/frontends/af9013.c

   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
  37 int af9013_debug;
  38
  39 struct 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
  55 static u8 regmask[8] = { 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
  56
  57 static 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
  79 static 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
  86 static 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 */
  94 static 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 */
 100 static 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
 126 static 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
 142 static 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
 155 static 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
 195 error:
 196         return ret;
 197 }
 198
 199 static 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
 223 static 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
 255 error:
 256         return ret;
 257 }
 258
 259 static 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);
 302 error:
 303         return ret;
 304 }
 305
 306 static 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         }
 387 error:
 388         return ret;
 389 }
 390
 391 static 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
 546 static 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         }
 584 error:
 585         return ret;
 586 }
 587
 588 static 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         }
 609 error:
 610         return ret;
 611 }
 612
 613 static 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
 620 static 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, &params->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
 691 error:
 692         return ret;
 693 }
 694
 695 static 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
 811 error:
 812         return ret;
 813 }
 814
 815 static 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
 880 exit:
 881 error:
 882         return ret;
 883 }
 884
 885 static 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
 960 error:
 961         return ret;
 962 }
 963
 964 static 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
 995 error:
 996         return ret;
 997 }
 998
 999 static 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
1020 error:
1021         return ret;
1022 }
1023
1024 static 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
1034 static 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
1088 error:
1089         return ret;
1090 }
1091
1092
1093 static 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
1102 static 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
1111 static 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
1120 static 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
1129 static 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);
1140 error:
1141         return ret;
1142 }
1143
1144 static 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
1318 error:
1319         return ret;
1320 }
1321
1322 static struct dvb_frontend_ops af9013_ops;
1323
1324 static 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
1417 error_release:
1418         release_firmware(fw);
1419 error:
1420 exit:
1421         if (!ret)
1422                 info("found a '%s' in warm state.", af9013_ops.info.name);
1423         return ret;
1424 }
1425
1426 static 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
1440 static void af9013_release(struct dvb_frontend *fe)
1441 {
1442         struct af9013_state *state = fe->demodulator_priv;
1443         kfree(state);
1444 }
1445
1446 static struct dvb_frontend_ops af9013_ops;
1447
1448 struct 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;
1524 error:
1525         kfree(state);
1526         return NULL;
1527 }
1528 EXPORT_SYMBOL(af9013_attach);
1529
1530 static 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
1567 module_param_named(debug, af9013_debug, int, 0644);
1568 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
1569
1570 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1571 MODULE_DESCRIPTION("Afatech AF9013 DVB-T demodulator driver");
1572 MODULE_LICENSE("GPL");