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