drivers/media/dvb-frontends/af9013.c

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