drivers/media/dvb-frontends/si2165.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  Driver for Silicon Labs Si2161 DVB-T and Si2165 DVB-C/-T Demodulator
   4  *
   5  *  Copyright (C) 2013-2017 Matthias Schwarzott <zzam@gentoo.org>
   6  *
   7  *  References:
   8  *  http://www.silabs.com/Support%20Documents/TechnicalDocs/Si2165-short.pdf
   9  */
  10
  11 #include <linux/delay.h>
  12 #include <linux/errno.h>
  13 #include <linux/init.h>
  14 #include <linux/kernel.h>
  15 #include <linux/module.h>
  16 #include <linux/string.h>
  17 #include <linux/slab.h>
  18 #include <linux/firmware.h>
  19 #include <linux/regmap.h>
  20
  21 #include <media/dvb_frontend.h>
  22 #include <media/dvb_math.h>
  23 #include "si2165_priv.h"
  24 #include "si2165.h"
  25
  26 /*
  27  * Hauppauge WinTV-HVR-930C-HD B130 / PCTV QuatroStick 521e 1113xx
  28  * uses 16 MHz xtal
  29  *
  30  * Hauppauge WinTV-HVR-930C-HD B131 / PCTV QuatroStick 522e 1114xx
  31  * uses 24 MHz clock provided by tuner
  32  */
  33
  34 struct si2165_state {
  35         struct i2c_client *client;
  36
  37         struct regmap *regmap;
  38
  39         struct dvb_frontend fe;
  40
  41         struct si2165_config config;
  42
  43         u8 chip_revcode;
  44         u8 chip_type;
  45
  46         /* calculated by xtal and div settings */
  47         u32 fvco_hz;
  48         u32 sys_clk;
  49         u32 adc_clk;
  50
  51         /* DVBv3 stats */
  52         u64 ber_prev;
  53
  54         bool has_dvbc;
  55         bool has_dvbt;
  56         bool firmware_loaded;
  57 };
  58
  59 static int si2165_write(struct si2165_state *state, const u16 reg,
  60                         const u8 *src, const int count)
  61 {
  62         int ret;
  63
  64         dev_dbg(&state->client->dev, "i2c write: reg: 0x%04x, data: %*ph\n",
  65                 reg, count, src);
  66
  67         ret = regmap_bulk_write(state->regmap, reg, src, count);
  68
  69         if (ret)
  70                 dev_err(&state->client->dev, "%s: ret == %d\n", __func__, ret);
  71
  72         return ret;
  73 }
  74
  75 static int si2165_read(struct si2165_state *state,
  76                        const u16 reg, u8 *val, const int count)
  77 {
  78         int ret = regmap_bulk_read(state->regmap, reg, val, count);
  79
  80         if (ret) {
  81                 dev_err(&state->client->dev, "%s: error (addr %02x reg %04x error (ret == %i)\n",
  82                         __func__, state->config.i2c_addr, reg, ret);
  83                 return ret;
  84         }
  85
  86         dev_dbg(&state->client->dev, "i2c read: reg: 0x%04x, data: %*ph\n",
  87                 reg, count, val);
  88
  89         return 0;
  90 }
  91
  92 static int si2165_readreg8(struct si2165_state *state,
  93                            const u16 reg, u8 *val)
  94 {
  95         unsigned int val_tmp;
  96         int ret = regmap_read(state->regmap, reg, &val_tmp);
  97         *val = (u8)val_tmp;
  98         dev_dbg(&state->client->dev, "reg read: R(0x%04x)=0x%02x\n", reg, *val);
  99         return ret;
 100 }
 101
 102 static int si2165_readreg16(struct si2165_state *state,
 103                             const u16 reg, u16 *val)
 104 {
 105         u8 buf[2];
 106
 107         int ret = si2165_read(state, reg, buf, 2);
 108         *val = buf[0] | buf[1] << 8;
 109         dev_dbg(&state->client->dev, "reg read: R(0x%04x)=0x%04x\n", reg, *val);
 110         return ret;
 111 }
 112
 113 static int si2165_readreg24(struct si2165_state *state,
 114                             const u16 reg, u32 *val)
 115 {
 116         u8 buf[3];
 117
 118         int ret = si2165_read(state, reg, buf, 3);
 119         *val = buf[0] | buf[1] << 8 | buf[2] << 16;
 120         dev_dbg(&state->client->dev, "reg read: R(0x%04x)=0x%06x\n", reg, *val);
 121         return ret;
 122 }
 123
 124 static int si2165_writereg8(struct si2165_state *state, const u16 reg, u8 val)
 125 {
 126         return regmap_write(state->regmap, reg, val);
 127 }
 128
 129 static int si2165_writereg16(struct si2165_state *state, const u16 reg, u16 val)
 130 {
 131         u8 buf[2] = { val & 0xff, (val >> 8) & 0xff };
 132
 133         return si2165_write(state, reg, buf, 2);
 134 }
 135
 136 static int si2165_writereg24(struct si2165_state *state, const u16 reg, u32 val)
 137 {
 138         u8 buf[3] = { val & 0xff, (val >> 8) & 0xff, (val >> 16) & 0xff };
 139
 140         return si2165_write(state, reg, buf, 3);
 141 }
 142
 143 static int si2165_writereg32(struct si2165_state *state, const u16 reg, u32 val)
 144 {
 145         u8 buf[4] = {
 146                 val & 0xff,
 147                 (val >> 8) & 0xff,
 148                 (val >> 16) & 0xff,
 149                 (val >> 24) & 0xff
 150         };
 151         return si2165_write(state, reg, buf, 4);
 152 }
 153
 154 static int si2165_writereg_mask8(struct si2165_state *state, const u16 reg,
 155                                  u8 val, u8 mask)
 156 {
 157         if (mask != 0xff) {
 158                 u8 tmp;
 159                 int ret = si2165_readreg8(state, reg, &tmp);
 160
 161                 if (ret < 0)
 162                         return ret;
 163
 164                 val &= mask;
 165                 tmp &= ~mask;
 166                 val |= tmp;
 167         }
 168         return si2165_writereg8(state, reg, val);
 169 }
 170
 171 #define REG16(reg, val) \
 172         { (reg), (val) & 0xff }, \
 173         { (reg) + 1, (val) >> 8 & 0xff }
 174 struct si2165_reg_value_pair {
 175         u16 reg;
 176         u8 val;
 177 };
 178
 179 static int si2165_write_reg_list(struct si2165_state *state,
 180                                  const struct si2165_reg_value_pair *regs,
 181                                  int count)
 182 {
 183         int i;
 184         int ret;
 185
 186         for (i = 0; i < count; i++) {
 187                 ret = si2165_writereg8(state, regs[i].reg, regs[i].val);
 188                 if (ret < 0)
 189                         return ret;
 190         }
 191         return 0;
 192 }
 193
 194 static int si2165_get_tune_settings(struct dvb_frontend *fe,
 195                                     struct dvb_frontend_tune_settings *s)
 196 {
 197         s->min_delay_ms = 1000;
 198         return 0;
 199 }
 200
 201 static int si2165_init_pll(struct si2165_state *state)
 202 {
 203         u32 ref_freq_hz = state->config.ref_freq_hz;
 204         u8 divr = 1; /* 1..7 */
 205         u8 divp = 1; /* only 1 or 4 */
 206         u8 divn = 56; /* 1..63 */
 207         u8 divm = 8;
 208         u8 divl = 12;
 209         u8 buf[4];
 210
 211         /*
 212          * hardcoded values can be deleted if calculation is verified
 213          * or it yields the same values as the windows driver
 214          */
 215         switch (ref_freq_hz) {
 216         case 16000000u:
 217                 divn = 56;
 218                 break;
 219         case 24000000u:
 220                 divr = 2;
 221                 divp = 4;
 222                 divn = 19;
 223                 break;
 224         default:
 225                 /* ref_freq / divr must be between 4 and 16 MHz */
 226                 if (ref_freq_hz > 16000000u)
 227                         divr = 2;
 228
 229                 /*
 230                  * now select divn and divp such that
 231                  * fvco is in 1624..1824 MHz
 232                  */
 233                 if (1624000000u * divr > ref_freq_hz * 2u * 63u)
 234                         divp = 4;
 235
 236                 /* is this already correct regarding rounding? */
 237                 divn = 1624000000u * divr / (ref_freq_hz * 2u * divp);
 238                 break;
 239         }
 240
 241         /* adc_clk and sys_clk depend on xtal and pll settings */
 242         state->fvco_hz = ref_freq_hz / divr
 243                         * 2u * divn * divp;
 244         state->adc_clk = state->fvco_hz / (divm * 4u);
 245         state->sys_clk = state->fvco_hz / (divl * 2u);
 246
 247         /* write all 4 pll registers 0x00a0..0x00a3 at once */
 248         buf[0] = divl;
 249         buf[1] = divm;
 250         buf[2] = (divn & 0x3f) | ((divp == 1) ? 0x40 : 0x00) | 0x80;
 251         buf[3] = divr;
 252         return si2165_write(state, REG_PLL_DIVL, buf, 4);
 253 }
 254
 255 static int si2165_adjust_pll_divl(struct si2165_state *state, u8 divl)
 256 {
 257         state->sys_clk = state->fvco_hz / (divl * 2u);
 258         return si2165_writereg8(state, REG_PLL_DIVL, divl);
 259 }
 260
 261 static u32 si2165_get_fe_clk(struct si2165_state *state)
 262 {
 263         /* assume Oversampling mode Ovr4 is used */
 264         return state->adc_clk;
 265 }
 266
 267 static int si2165_wait_init_done(struct si2165_state *state)
 268 {
 269         int ret;
 270         u8 val = 0;
 271         int i;
 272
 273         for (i = 0; i < 3; ++i) {
 274                 ret = si2165_readreg8(state, REG_INIT_DONE, &val);
 275                 if (ret < 0)
 276                         return ret;
 277                 if (val == 0x01)
 278                         return 0;
 279                 usleep_range(1000, 50000);
 280         }
 281         dev_err(&state->client->dev, "init_done was not set\n");
 282         return -EINVAL;
 283 }
 284
 285 static int si2165_upload_firmware_block(struct si2165_state *state,
 286                                         const u8 *data, u32 len, u32 *poffset,
 287                                         u32 block_count)
 288 {
 289         int ret;
 290         u8 buf_ctrl[4] = { 0x00, 0x00, 0x00, 0xc0 };
 291         u8 wordcount;
 292         u32 cur_block = 0;
 293         u32 offset = poffset ? *poffset : 0;
 294
 295         if (len < 4)
 296                 return -EINVAL;
 297         if (len % 4 != 0)
 298                 return -EINVAL;
 299
 300         dev_dbg(&state->client->dev,
 301                 "fw load: %s: called with len=0x%x offset=0x%x blockcount=0x%x\n",
 302                 __func__, len, offset, block_count);
 303         while (offset + 12 <= len && cur_block < block_count) {
 304                 dev_dbg(&state->client->dev,
 305                         "fw load: %s: in while len=0x%x offset=0x%x cur_block=0x%x blockcount=0x%x\n",
 306                         __func__, len, offset, cur_block, block_count);
 307                 wordcount = data[offset];
 308                 if (wordcount < 1 || data[offset + 1] ||
 309                     data[offset + 2] || data[offset + 3]) {
 310                         dev_warn(&state->client->dev,
 311                                  "bad fw data[0..3] = %*ph\n",
 312                                  4, data);
 313                         return -EINVAL;
 314                 }
 315
 316                 if (offset + 8 + wordcount * 4 > len) {
 317                         dev_warn(&state->client->dev,
 318                                  "len is too small for block len=%d, wordcount=%d\n",
 319                                 len, wordcount);
 320                         return -EINVAL;
 321                 }
 322
 323                 buf_ctrl[0] = wordcount - 1;
 324
 325                 ret = si2165_write(state, REG_DCOM_CONTROL_BYTE, buf_ctrl, 4);
 326                 if (ret < 0)
 327                         goto error;
 328                 ret = si2165_write(state, REG_DCOM_ADDR, data + offset + 4, 4);
 329                 if (ret < 0)
 330                         goto error;
 331
 332                 offset += 8;
 333
 334                 while (wordcount > 0) {
 335                         ret = si2165_write(state, REG_DCOM_DATA,
 336                                            data + offset, 4);
 337                         if (ret < 0)
 338                                 goto error;
 339                         wordcount--;
 340                         offset += 4;
 341                 }
 342                 cur_block++;
 343         }
 344
 345         dev_dbg(&state->client->dev,
 346                 "fw load: %s: after while len=0x%x offset=0x%x cur_block=0x%x blockcount=0x%x\n",
 347                 __func__, len, offset, cur_block, block_count);
 348
 349         if (poffset)
 350                 *poffset = offset;
 351
 352         dev_dbg(&state->client->dev,
 353                 "fw load: %s: returned offset=0x%x\n",
 354                 __func__, offset);
 355
 356         return 0;
 357 error:
 358         return ret;
 359 }
 360
 361 static int si2165_upload_firmware(struct si2165_state *state)
 362 {
 363         /* int ret; */
 364         u8 val[3];
 365         u16 val16;
 366         int ret;
 367
 368         const struct firmware *fw = NULL;
 369         u8 *fw_file;
 370         const u8 *data;
 371         u32 len;
 372         u32 offset;
 373         u8 patch_version;
 374         u8 block_count;
 375         u16 crc_expected;
 376
 377         switch (state->chip_revcode) {
 378         case 0x03: /* revision D */
 379                 fw_file = SI2165_FIRMWARE_REV_D;
 380                 break;
 381         default:
 382                 dev_info(&state->client->dev, "no firmware file for revision=%d\n",
 383                          state->chip_revcode);
 384                 return 0;
 385         }
 386
 387         /* request the firmware, this will block and timeout */
 388         ret = request_firmware(&fw, fw_file, &state->client->dev);
 389         if (ret) {
 390                 dev_warn(&state->client->dev, "firmware file '%s' not found\n",
 391                          fw_file);
 392                 goto error;
 393         }
 394
 395         data = fw->data;
 396         len = fw->size;
 397
 398         dev_info(&state->client->dev, "downloading firmware from file '%s' size=%d\n",
 399                  fw_file, len);
 400
 401         if (len % 4 != 0) {
 402                 dev_warn(&state->client->dev, "firmware size is not multiple of 4\n");
 403                 ret = -EINVAL;
 404                 goto error;
 405         }
 406
 407         /* check header (8 bytes) */
 408         if (len < 8) {
 409                 dev_warn(&state->client->dev, "firmware header is missing\n");
 410                 ret = -EINVAL;
 411                 goto error;
 412         }
 413
 414         if (data[0] != 1 || data[1] != 0) {
 415                 dev_warn(&state->client->dev, "firmware file version is wrong\n");
 416                 ret = -EINVAL;
 417                 goto error;
 418         }
 419
 420         patch_version = data[2];
 421         block_count = data[4];
 422         crc_expected = data[7] << 8 | data[6];
 423
 424         /* start uploading fw */
 425         /* boot/wdog status */
 426         ret = si2165_writereg8(state, REG_WDOG_AND_BOOT, 0x00);
 427         if (ret < 0)
 428                 goto error;
 429         /* reset */
 430         ret = si2165_writereg8(state, REG_RST_ALL, 0x00);
 431         if (ret < 0)
 432                 goto error;
 433         /* boot/wdog status */
 434         ret = si2165_readreg8(state, REG_WDOG_AND_BOOT, val);
 435         if (ret < 0)
 436                 goto error;
 437
 438         /* enable reset on error */
 439         ret = si2165_readreg8(state, REG_EN_RST_ERROR, val);
 440         if (ret < 0)
 441                 goto error;
 442         ret = si2165_readreg8(state, REG_EN_RST_ERROR, val);
 443         if (ret < 0)
 444                 goto error;
 445         ret = si2165_writereg8(state, REG_EN_RST_ERROR, 0x02);
 446         if (ret < 0)
 447                 goto error;
 448
 449         /* start right after the header */
 450         offset = 8;
 451
 452         dev_info(&state->client->dev, "%s: extracted patch_version=0x%02x, block_count=0x%02x, crc_expected=0x%04x\n",
 453                  __func__, patch_version, block_count, crc_expected);
 454
 455         ret = si2165_upload_firmware_block(state, data, len, &offset, 1);
 456         if (ret < 0)
 457                 goto error;
 458
 459         ret = si2165_writereg8(state, REG_PATCH_VERSION, patch_version);
 460         if (ret < 0)
 461                 goto error;
 462
 463         /* reset crc */
 464         ret = si2165_writereg8(state, REG_RST_CRC, 0x01);
 465         if (ret)
 466                 goto error;
 467
 468         ret = si2165_upload_firmware_block(state, data, len,
 469                                            &offset, block_count);
 470         if (ret < 0) {
 471                 dev_err(&state->client->dev,
 472                         "firmware could not be uploaded\n");
 473                 goto error;
 474         }
 475
 476         /* read crc */
 477         ret = si2165_readreg16(state, REG_CRC, &val16);
 478         if (ret)
 479                 goto error;
 480
 481         if (val16 != crc_expected) {
 482                 dev_err(&state->client->dev,
 483                         "firmware crc mismatch %04x != %04x\n",
 484                         val16, crc_expected);
 485                 ret = -EINVAL;
 486                 goto error;
 487         }
 488
 489         ret = si2165_upload_firmware_block(state, data, len, &offset, 5);
 490         if (ret)
 491                 goto error;
 492
 493         if (len != offset) {
 494                 dev_err(&state->client->dev,
 495                         "firmware len mismatch %04x != %04x\n",
 496                         len, offset);
 497                 ret = -EINVAL;
 498                 goto error;
 499         }
 500
 501         /* reset watchdog error register */
 502         ret = si2165_writereg_mask8(state, REG_WDOG_AND_BOOT, 0x02, 0x02);
 503         if (ret < 0)
 504                 goto error;
 505
 506         /* enable reset on error */
 507         ret = si2165_writereg_mask8(state, REG_EN_RST_ERROR, 0x01, 0x01);
 508         if (ret < 0)
 509                 goto error;
 510
 511         dev_info(&state->client->dev, "fw load finished\n");
 512
 513         ret = 0;
 514         state->firmware_loaded = true;
 515 error:
 516         if (fw) {
 517                 release_firmware(fw);
 518                 fw = NULL;
 519         }
 520
 521         return ret;
 522 }
 523
 524 static int si2165_init(struct dvb_frontend *fe)
 525 {
 526         int ret = 0;
 527         struct si2165_state *state = fe->demodulator_priv;
 528         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 529         u8 val;
 530         u8 patch_version = 0x00;
 531
 532         dev_dbg(&state->client->dev, "%s: called\n", __func__);
 533
 534         /* powerup */
 535         ret = si2165_writereg8(state, REG_CHIP_MODE, state->config.chip_mode);
 536         if (ret < 0)
 537                 goto error;
 538         /* dsp_clock_enable */
 539         ret = si2165_writereg8(state, REG_DSP_CLOCK, 0x01);
 540         if (ret < 0)
 541                 goto error;
 542         /* verify chip_mode */
 543         ret = si2165_readreg8(state, REG_CHIP_MODE, &val);
 544         if (ret < 0)
 545                 goto error;
 546         if (val != state->config.chip_mode) {
 547                 dev_err(&state->client->dev, "could not set chip_mode\n");
 548                 return -EINVAL;
 549         }
 550
 551         /* agc */
 552         ret = si2165_writereg8(state, REG_AGC_IF_TRI, 0x00);
 553         if (ret < 0)
 554                 goto error;
 555         ret = si2165_writereg8(state, REG_AGC_IF_SLR, 0x01);
 556         if (ret < 0)
 557                 goto error;
 558         ret = si2165_writereg8(state, REG_AGC2_OUTPUT, 0x00);
 559         if (ret < 0)
 560                 goto error;
 561         ret = si2165_writereg8(state, REG_AGC2_CLKDIV, 0x07);
 562         if (ret < 0)
 563                 goto error;
 564         /* rssi pad */
 565         ret = si2165_writereg8(state, REG_RSSI_PAD_CTRL, 0x00);
 566         if (ret < 0)
 567                 goto error;
 568         ret = si2165_writereg8(state, REG_RSSI_ENABLE, 0x00);
 569         if (ret < 0)
 570                 goto error;
 571
 572         ret = si2165_init_pll(state);
 573         if (ret < 0)
 574                 goto error;
 575
 576         /* enable chip_init */
 577         ret = si2165_writereg8(state, REG_CHIP_INIT, 0x01);
 578         if (ret < 0)
 579                 goto error;
 580         /* set start_init */
 581         ret = si2165_writereg8(state, REG_START_INIT, 0x01);
 582         if (ret < 0)
 583                 goto error;
 584         ret = si2165_wait_init_done(state);
 585         if (ret < 0)
 586                 goto error;
 587
 588         /* disable chip_init */
 589         ret = si2165_writereg8(state, REG_CHIP_INIT, 0x00);
 590         if (ret < 0)
 591                 goto error;
 592
 593         /* ber_pkt - default 65535 */
 594         ret = si2165_writereg16(state, REG_BER_PKT,
 595                                 STATISTICS_PERIOD_PKT_COUNT);
 596         if (ret < 0)
 597                 goto error;
 598
 599         ret = si2165_readreg8(state, REG_PATCH_VERSION, &patch_version);
 600         if (ret < 0)
 601                 goto error;
 602
 603         ret = si2165_writereg8(state, REG_AUTO_RESET, 0x00);
 604         if (ret < 0)
 605                 goto error;
 606
 607         /* dsp_addr_jump */
 608         ret = si2165_writereg32(state, REG_ADDR_JUMP, 0xf4000000);
 609         if (ret < 0)
 610                 goto error;
 611         /* boot/wdog status */
 612         ret = si2165_readreg8(state, REG_WDOG_AND_BOOT, &val);
 613         if (ret < 0)
 614                 goto error;
 615
 616         if (patch_version == 0x00) {
 617                 ret = si2165_upload_firmware(state);
 618                 if (ret < 0)
 619                         goto error;
 620         }
 621
 622         /* ts output config */
 623         ret = si2165_writereg8(state, REG_TS_DATA_MODE, 0x20);
 624         if (ret < 0)
 625                 return ret;
 626         ret = si2165_writereg16(state, REG_TS_TRI, 0x00fe);
 627         if (ret < 0)
 628                 return ret;
 629         ret = si2165_writereg24(state, REG_TS_SLR, 0x555555);
 630         if (ret < 0)
 631                 return ret;
 632         ret = si2165_writereg8(state, REG_TS_CLK_MODE, 0x01);
 633         if (ret < 0)
 634                 return ret;
 635         ret = si2165_writereg8(state, REG_TS_PARALLEL_MODE, 0x00);
 636         if (ret < 0)
 637                 return ret;
 638
 639         c = &state->fe.dtv_property_cache;
 640         c->cnr.len = 1;
 641         c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 642         c->post_bit_error.len = 1;
 643         c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 644         c->post_bit_count.len = 1;
 645         c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 646
 647         return 0;
 648 error:
 649         return ret;
 650 }
 651
 652 static int si2165_sleep(struct dvb_frontend *fe)
 653 {
 654         int ret;
 655         struct si2165_state *state = fe->demodulator_priv;
 656
 657         /* dsp clock disable */
 658         ret = si2165_writereg8(state, REG_DSP_CLOCK, 0x00);
 659         if (ret < 0)
 660                 return ret;
 661         /* chip mode */
 662         ret = si2165_writereg8(state, REG_CHIP_MODE, SI2165_MODE_OFF);
 663         if (ret < 0)
 664                 return ret;
 665         return 0;
 666 }
 667
 668 static int si2165_read_status(struct dvb_frontend *fe, enum fe_status *status)
 669 {
 670         int ret;
 671         u8 u8tmp;
 672         u32 u32tmp;
 673         struct si2165_state *state = fe->demodulator_priv;
 674         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 675         u32 delsys = c->delivery_system;
 676
 677         *status = 0;
 678
 679         switch (delsys) {
 680         case SYS_DVBT:
 681                 /* check fast signal type */
 682                 ret = si2165_readreg8(state, REG_CHECK_SIGNAL, &u8tmp);
 683                 if (ret < 0)
 684                         return ret;
 685                 switch (u8tmp & 0x3) {
 686                 case 0: /* searching */
 687                 case 1: /* nothing */
 688                         break;
 689                 case 2: /* digital signal */
 690                         *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER;
 691                         break;
 692                 }
 693                 break;
 694         case SYS_DVBC_ANNEX_A:
 695                 /* check packet sync lock */
 696                 ret = si2165_readreg8(state, REG_PS_LOCK, &u8tmp);
 697                 if (ret < 0)
 698                         return ret;
 699                 if (u8tmp & 0x01) {
 700                         *status |= FE_HAS_SIGNAL;
 701                         *status |= FE_HAS_CARRIER;
 702                         *status |= FE_HAS_VITERBI;
 703                         *status |= FE_HAS_SYNC;
 704                 }
 705                 break;
 706         }
 707
 708         /* check fec_lock */
 709         ret = si2165_readreg8(state, REG_FEC_LOCK, &u8tmp);
 710         if (ret < 0)
 711                 return ret;
 712         if (u8tmp & 0x01) {
 713                 *status |= FE_HAS_SIGNAL;
 714                 *status |= FE_HAS_CARRIER;
 715                 *status |= FE_HAS_VITERBI;
 716                 *status |= FE_HAS_SYNC;
 717                 *status |= FE_HAS_LOCK;
 718         }
 719
 720         /* CNR */
 721         if (delsys == SYS_DVBC_ANNEX_A && *status & FE_HAS_VITERBI) {
 722                 ret = si2165_readreg24(state, REG_C_N, &u32tmp);
 723                 if (ret < 0)
 724                         return ret;
 725                 /*
 726                  * svalue =
 727                  * 1000 * c_n/dB =
 728                  * 1000 * 10 * log10(2^24 / regval) =
 729                  * 1000 * 10 * (log10(2^24) - log10(regval)) =
 730                  * 1000 * 10 * (intlog10(2^24) - intlog10(regval)) / 2^24
 731                  *
 732                  * intlog10(x) = log10(x) * 2^24
 733                  * intlog10(2^24) = log10(2^24) * 2^24 = 121210686
 734                  */
 735                 u32tmp = (1000 * 10 * (121210686 - (u64)intlog10(u32tmp)))
 736                                 >> 24;
 737                 c->cnr.stat[0].scale = FE_SCALE_DECIBEL;
 738                 c->cnr.stat[0].svalue = u32tmp;
 739         } else
 740                 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 741
 742         /* BER */
 743         if (*status & FE_HAS_VITERBI) {
 744                 if (c->post_bit_error.stat[0].scale == FE_SCALE_NOT_AVAILABLE) {
 745                         /* start new sampling period to get rid of old data*/
 746                         ret = si2165_writereg8(state, REG_BER_RST, 0x01);
 747                         if (ret < 0)
 748                                 return ret;
 749
 750                         /* set scale to enter read code on next call */
 751                         c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
 752                         c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;
 753                         c->post_bit_error.stat[0].uvalue = 0;
 754                         c->post_bit_count.stat[0].uvalue = 0;
 755
 756                         /*
 757                          * reset DVBv3 value to deliver a good result
 758                          * for the first call
 759                          */
 760                         state->ber_prev = 0;
 761
 762                 } else {
 763                         ret = si2165_readreg8(state, REG_BER_AVAIL, &u8tmp);
 764                         if (ret < 0)
 765                                 return ret;
 766
 767                         if (u8tmp & 1) {
 768                                 u32 biterrcnt;
 769
 770                                 ret = si2165_readreg24(state, REG_BER_BIT,
 771                                                         &biterrcnt);
 772                                 if (ret < 0)
 773                                         return ret;
 774
 775                                 c->post_bit_error.stat[0].uvalue +=
 776                                         biterrcnt;
 777                                 c->post_bit_count.stat[0].uvalue +=
 778                                         STATISTICS_PERIOD_BIT_COUNT;
 779
 780                                 /* start new sampling period */
 781                                 ret = si2165_writereg8(state,
 782                                                         REG_BER_RST, 0x01);
 783                                 if (ret < 0)
 784                                         return ret;
 785
 786                                 dev_dbg(&state->client->dev,
 787                                         "post_bit_error=%u post_bit_count=%u\n",
 788                                         biterrcnt, STATISTICS_PERIOD_BIT_COUNT);
 789                         }
 790                 }
 791         } else {
 792                 c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 793                 c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 794         }
 795
 796         return 0;
 797 }
 798
 799 static int si2165_read_snr(struct dvb_frontend *fe, u16 *snr)
 800 {
 801         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 802
 803         if (c->cnr.stat[0].scale == FE_SCALE_DECIBEL)
 804                 *snr = div_s64(c->cnr.stat[0].svalue, 100);
 805         else
 806                 *snr = 0;
 807         return 0;
 808 }
 809
 810 static int si2165_read_ber(struct dvb_frontend *fe, u32 *ber)
 811 {
 812         struct si2165_state *state = fe->demodulator_priv;
 813         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 814
 815         if (c->post_bit_error.stat[0].scale != FE_SCALE_COUNTER) {
 816                 *ber = 0;
 817                 return 0;
 818         }
 819
 820         *ber = c->post_bit_error.stat[0].uvalue - state->ber_prev;
 821         state->ber_prev = c->post_bit_error.stat[0].uvalue;
 822
 823         return 0;
 824 }
 825
 826 static int si2165_set_oversamp(struct si2165_state *state, u32 dvb_rate)
 827 {
 828         u64 oversamp;
 829         u32 reg_value;
 830
 831         if (!dvb_rate)
 832                 return -EINVAL;
 833
 834         oversamp = si2165_get_fe_clk(state);
 835         oversamp <<= 23;
 836         do_div(oversamp, dvb_rate);
 837         reg_value = oversamp & 0x3fffffff;
 838
 839         dev_dbg(&state->client->dev, "Write oversamp=%#x\n", reg_value);
 840         return si2165_writereg32(state, REG_OVERSAMP, reg_value);
 841 }
 842
 843 static int si2165_set_if_freq_shift(struct si2165_state *state)
 844 {
 845         struct dvb_frontend *fe = &state->fe;
 846         u64 if_freq_shift;
 847         s32 reg_value = 0;
 848         u32 fe_clk = si2165_get_fe_clk(state);
 849         u32 IF = 0;
 850
 851         if (!fe->ops.tuner_ops.get_if_frequency) {
 852                 dev_err(&state->client->dev,
 853                         "Error: get_if_frequency() not defined at tuner. Can't work without it!\n");
 854                 return -EINVAL;
 855         }
 856
 857         if (!fe_clk)
 858                 return -EINVAL;
 859
 860         fe->ops.tuner_ops.get_if_frequency(fe, &IF);
 861         if_freq_shift = IF;
 862         if_freq_shift <<= 29;
 863
 864         do_div(if_freq_shift, fe_clk);
 865         reg_value = (s32)if_freq_shift;
 866
 867         if (state->config.inversion)
 868                 reg_value = -reg_value;
 869
 870         reg_value = reg_value & 0x1fffffff;
 871
 872         /* if_freq_shift, usbdump contained 0x023ee08f; */
 873         return si2165_writereg32(state, REG_IF_FREQ_SHIFT, reg_value);
 874 }
 875
 876 static const struct si2165_reg_value_pair dvbt_regs[] = {
 877         /* standard = DVB-T */
 878         { REG_DVB_STANDARD, 0x01 },
 879         /* impulsive_noise_remover */
 880         { REG_IMPULSIVE_NOISE_REM, 0x01 },
 881         { REG_AUTO_RESET, 0x00 },
 882         /* agc2 */
 883         { REG_AGC2_MIN, 0x41 },
 884         { REG_AGC2_KACQ, 0x0e },
 885         { REG_AGC2_KLOC, 0x10 },
 886         /* agc */
 887         { REG_AGC_UNFREEZE_THR, 0x03 },
 888         { REG_AGC_CRESTF_DBX8, 0x78 },
 889         /* agc */
 890         { REG_AAF_CRESTF_DBX8, 0x78 },
 891         { REG_ACI_CRESTF_DBX8, 0x68 },
 892         /* freq_sync_range */
 893         REG16(REG_FREQ_SYNC_RANGE, 0x0064),
 894         /* gp_reg0 */
 895         { REG_GP_REG0_MSB, 0x00 }
 896 };
 897
 898 static int si2165_set_frontend_dvbt(struct dvb_frontend *fe)
 899 {
 900         int ret;
 901         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
 902         struct si2165_state *state = fe->demodulator_priv;
 903         u32 dvb_rate = 0;
 904         u16 bw10k;
 905         u32 bw_hz = p->bandwidth_hz;
 906
 907         dev_dbg(&state->client->dev, "%s: called\n", __func__);
 908
 909         if (!state->has_dvbt)
 910                 return -EINVAL;
 911
 912         /* no bandwidth auto-detection */
 913         if (bw_hz == 0)
 914                 return -EINVAL;
 915
 916         dvb_rate = bw_hz * 8 / 7;
 917         bw10k = bw_hz / 10000;
 918
 919         ret = si2165_adjust_pll_divl(state, 12);
 920         if (ret < 0)
 921                 return ret;
 922
 923         /* bandwidth in 10KHz steps */
 924         ret = si2165_writereg16(state, REG_T_BANDWIDTH, bw10k);
 925         if (ret < 0)
 926                 return ret;
 927         ret = si2165_set_oversamp(state, dvb_rate);
 928         if (ret < 0)
 929                 return ret;
 930
 931         ret = si2165_write_reg_list(state, dvbt_regs, ARRAY_SIZE(dvbt_regs));
 932         if (ret < 0)
 933                 return ret;
 934
 935         return 0;
 936 }
 937
 938 static const struct si2165_reg_value_pair dvbc_regs[] = {
 939         /* standard = DVB-C */
 940         { REG_DVB_STANDARD, 0x05 },
 941
 942         /* agc2 */
 943         { REG_AGC2_MIN, 0x50 },
 944         { REG_AGC2_KACQ, 0x0e },
 945         { REG_AGC2_KLOC, 0x10 },
 946         /* agc */
 947         { REG_AGC_UNFREEZE_THR, 0x03 },
 948         { REG_AGC_CRESTF_DBX8, 0x68 },
 949         /* agc */
 950         { REG_AAF_CRESTF_DBX8, 0x68 },
 951         { REG_ACI_CRESTF_DBX8, 0x50 },
 952
 953         { REG_EQ_AUTO_CONTROL, 0x0d },
 954
 955         { REG_KP_LOCK, 0x05 },
 956         { REG_CENTRAL_TAP, 0x09 },
 957         REG16(REG_UNKNOWN_350, 0x3e80),
 958
 959         { REG_AUTO_RESET, 0x01 },
 960         REG16(REG_UNKNOWN_24C, 0x0000),
 961         REG16(REG_UNKNOWN_27C, 0x0000),
 962         { REG_SWEEP_STEP, 0x03 },
 963         { REG_AGC_IF_TRI, 0x00 },
 964 };
 965
 966 static int si2165_set_frontend_dvbc(struct dvb_frontend *fe)
 967 {
 968         struct si2165_state *state = fe->demodulator_priv;
 969         int ret;
 970         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
 971         const u32 dvb_rate = p->symbol_rate;
 972         u8 u8tmp;
 973
 974         if (!state->has_dvbc)
 975                 return -EINVAL;
 976
 977         if (dvb_rate == 0)
 978                 return -EINVAL;
 979
 980         ret = si2165_adjust_pll_divl(state, 14);
 981         if (ret < 0)
 982                 return ret;
 983
 984         /* Oversampling */
 985         ret = si2165_set_oversamp(state, dvb_rate);
 986         if (ret < 0)
 987                 return ret;
 988
 989         switch (p->modulation) {
 990         case QPSK:
 991                 u8tmp = 0x3;
 992                 break;
 993         case QAM_16:
 994                 u8tmp = 0x7;
 995                 break;
 996         case QAM_32:
 997                 u8tmp = 0x8;
 998                 break;
 999         case QAM_64:
1000                 u8tmp = 0x9;
1001                 break;
1002         case QAM_128:
1003                 u8tmp = 0xa;
1004                 break;
1005         case QAM_256:
1006         default:
1007                 u8tmp = 0xb;
1008                 break;
1009         }
1010         ret = si2165_writereg8(state, REG_REQ_CONSTELLATION, u8tmp);
1011         if (ret < 0)
1012                 return ret;
1013
1014         ret = si2165_writereg32(state, REG_LOCK_TIMEOUT, 0x007a1200);
1015         if (ret < 0)
1016                 return ret;
1017
1018         ret = si2165_write_reg_list(state, dvbc_regs, ARRAY_SIZE(dvbc_regs));
1019         if (ret < 0)
1020                 return ret;
1021
1022         return 0;
1023 }
1024
1025 static const struct si2165_reg_value_pair adc_rewrite[] = {
1026         { REG_ADC_RI1, 0x46 },
1027         { REG_ADC_RI3, 0x00 },
1028         { REG_ADC_RI5, 0x0a },
1029         { REG_ADC_RI6, 0xff },
1030         { REG_ADC_RI8, 0x70 }
1031 };
1032
1033 static int si2165_set_frontend(struct dvb_frontend *fe)
1034 {
1035         struct si2165_state *state = fe->demodulator_priv;
1036         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1037         u32 delsys = p->delivery_system;
1038         int ret;
1039         u8 val[3];
1040
1041         /* initial setting of if freq shift */
1042         ret = si2165_set_if_freq_shift(state);
1043         if (ret < 0)
1044                 return ret;
1045
1046         switch (delsys) {
1047         case SYS_DVBT:
1048                 ret = si2165_set_frontend_dvbt(fe);
1049                 if (ret < 0)
1050                         return ret;
1051                 break;
1052         case SYS_DVBC_ANNEX_A:
1053                 ret = si2165_set_frontend_dvbc(fe);
1054                 if (ret < 0)
1055                         return ret;
1056                 break;
1057         default:
1058                 return -EINVAL;
1059         }
1060
1061         /* dsp_addr_jump */
1062         ret = si2165_writereg32(state, REG_ADDR_JUMP, 0xf4000000);
1063         if (ret < 0)
1064                 return ret;
1065
1066         if (fe->ops.tuner_ops.set_params)
1067                 fe->ops.tuner_ops.set_params(fe);
1068
1069         /* recalc if_freq_shift if IF might has changed */
1070         ret = si2165_set_if_freq_shift(state);
1071         if (ret < 0)
1072                 return ret;
1073
1074         /* boot/wdog status */
1075         ret = si2165_readreg8(state, REG_WDOG_AND_BOOT, val);
1076         if (ret < 0)
1077                 return ret;
1078         ret = si2165_writereg8(state, REG_WDOG_AND_BOOT, 0x00);
1079         if (ret < 0)
1080                 return ret;
1081
1082         /* reset all */
1083         ret = si2165_writereg8(state, REG_RST_ALL, 0x00);
1084         if (ret < 0)
1085                 return ret;
1086         /* gp_reg0 */
1087         ret = si2165_writereg32(state, REG_GP_REG0_LSB, 0x00000000);
1088         if (ret < 0)
1089                 return ret;
1090
1091         /* write adc values after each reset*/
1092         ret = si2165_write_reg_list(state, adc_rewrite,
1093                                     ARRAY_SIZE(adc_rewrite));
1094         if (ret < 0)
1095                 return ret;
1096
1097         /* start_synchro */
1098         ret = si2165_writereg8(state, REG_START_SYNCHRO, 0x01);
1099         if (ret < 0)
1100                 return ret;
1101         /* boot/wdog status */
1102         ret = si2165_readreg8(state, REG_WDOG_AND_BOOT, val);
1103         if (ret < 0)
1104                 return ret;
1105
1106         return 0;
1107 }
1108
1109 static const struct dvb_frontend_ops si2165_ops = {
1110         .info = {
1111                 .name = "Silicon Labs ",
1112                  /* For DVB-C */
1113                 .symbol_rate_min = 1000000,
1114                 .symbol_rate_max = 7200000,
1115                 /* For DVB-T */
1116                 .frequency_stepsize_hz = 166667,
1117                 .caps = FE_CAN_FEC_1_2 |
1118                         FE_CAN_FEC_2_3 |
1119                         FE_CAN_FEC_3_4 |
1120                         FE_CAN_FEC_5_6 |
1121                         FE_CAN_FEC_7_8 |
1122                         FE_CAN_FEC_AUTO |
1123                         FE_CAN_QPSK |
1124                         FE_CAN_QAM_16 |
1125                         FE_CAN_QAM_32 |
1126                         FE_CAN_QAM_64 |
1127                         FE_CAN_QAM_128 |
1128                         FE_CAN_QAM_256 |
1129                         FE_CAN_GUARD_INTERVAL_AUTO |
1130                         FE_CAN_HIERARCHY_AUTO |
1131                         FE_CAN_MUTE_TS |
1132                         FE_CAN_TRANSMISSION_MODE_AUTO |
1133                         FE_CAN_RECOVER
1134         },
1135
1136         .get_tune_settings = si2165_get_tune_settings,
1137
1138         .init = si2165_init,
1139         .sleep = si2165_sleep,
1140
1141         .set_frontend      = si2165_set_frontend,
1142         .read_status       = si2165_read_status,
1143         .read_snr          = si2165_read_snr,
1144         .read_ber          = si2165_read_ber,
1145 };
1146
1147 static int si2165_probe(struct i2c_client *client,
1148                         const struct i2c_device_id *id)
1149 {
1150         struct si2165_state *state = NULL;
1151         struct si2165_platform_data *pdata = client->dev.platform_data;
1152         int n;
1153         int ret = 0;
1154         u8 val;
1155         char rev_char;
1156         const char *chip_name;
1157         static const struct regmap_config regmap_config = {
1158                 .reg_bits = 16,
1159                 .val_bits = 8,
1160                 .max_register = 0x08ff,
1161         };
1162
1163         /* allocate memory for the internal state */
1164         state = kzalloc(sizeof(*state), GFP_KERNEL);
1165         if (!state) {
1166                 ret = -ENOMEM;
1167                 goto error;
1168         }
1169
1170         /* create regmap */
1171         state->regmap = devm_regmap_init_i2c(client, &regmap_config);
1172         if (IS_ERR(state->regmap)) {
1173                 ret = PTR_ERR(state->regmap);
1174                 goto error;
1175         }
1176
1177         /* setup the state */
1178         state->client = client;
1179         state->config.i2c_addr = client->addr;
1180         state->config.chip_mode = pdata->chip_mode;
1181         state->config.ref_freq_hz = pdata->ref_freq_hz;
1182         state->config.inversion = pdata->inversion;
1183
1184         if (state->config.ref_freq_hz < 4000000 ||
1185             state->config.ref_freq_hz > 27000000) {
1186                 dev_err(&state->client->dev, "ref_freq of %d Hz not supported by this driver\n",
1187                         state->config.ref_freq_hz);
1188                 ret = -EINVAL;
1189                 goto error;
1190         }
1191
1192         /* create dvb_frontend */
1193         memcpy(&state->fe.ops, &si2165_ops,
1194                sizeof(struct dvb_frontend_ops));
1195         state->fe.ops.release = NULL;
1196         state->fe.demodulator_priv = state;
1197         i2c_set_clientdata(client, state);
1198
1199         /* powerup */
1200         ret = si2165_writereg8(state, REG_CHIP_MODE, state->config.chip_mode);
1201         if (ret < 0)
1202                 goto nodev_error;
1203
1204         ret = si2165_readreg8(state, REG_CHIP_MODE, &val);
1205         if (ret < 0)
1206                 goto nodev_error;
1207         if (val != state->config.chip_mode)
1208                 goto nodev_error;
1209
1210         ret = si2165_readreg8(state, REG_CHIP_REVCODE, &state->chip_revcode);
1211         if (ret < 0)
1212                 goto nodev_error;
1213
1214         ret = si2165_readreg8(state, REV_CHIP_TYPE, &state->chip_type);
1215         if (ret < 0)
1216                 goto nodev_error;
1217
1218         /* powerdown */
1219         ret = si2165_writereg8(state, REG_CHIP_MODE, SI2165_MODE_OFF);
1220         if (ret < 0)
1221                 goto nodev_error;
1222
1223         if (state->chip_revcode < 26)
1224                 rev_char = 'A' + state->chip_revcode;
1225         else
1226                 rev_char = '?';
1227
1228         switch (state->chip_type) {
1229         case 0x06:
1230                 chip_name = "Si2161";
1231                 state->has_dvbt = true;
1232                 break;
1233         case 0x07:
1234                 chip_name = "Si2165";
1235                 state->has_dvbt = true;
1236                 state->has_dvbc = true;
1237                 break;
1238         default:
1239                 dev_err(&state->client->dev, "Unsupported Silicon Labs chip (type %d, rev %d)\n",
1240                         state->chip_type, state->chip_revcode);
1241                 goto nodev_error;
1242         }
1243
1244         dev_info(&state->client->dev,
1245                  "Detected Silicon Labs %s-%c (type %d, rev %d)\n",
1246                 chip_name, rev_char, state->chip_type,
1247                 state->chip_revcode);
1248
1249         strlcat(state->fe.ops.info.name, chip_name,
1250                 sizeof(state->fe.ops.info.name));
1251
1252         n = 0;
1253         if (state->has_dvbt) {
1254                 state->fe.ops.delsys[n++] = SYS_DVBT;
1255                 strlcat(state->fe.ops.info.name, " DVB-T",
1256                         sizeof(state->fe.ops.info.name));
1257         }
1258         if (state->has_dvbc) {
1259                 state->fe.ops.delsys[n++] = SYS_DVBC_ANNEX_A;
1260                 strlcat(state->fe.ops.info.name, " DVB-C",
1261                         sizeof(state->fe.ops.info.name));
1262         }
1263
1264         /* return fe pointer */
1265         *pdata->fe = &state->fe;
1266
1267         return 0;
1268
1269 nodev_error:
1270         ret = -ENODEV;
1271 error:
1272         kfree(state);
1273         dev_dbg(&client->dev, "failed=%d\n", ret);
1274         return ret;
1275 }
1276
1277 static int si2165_remove(struct i2c_client *client)
1278 {
1279         struct si2165_state *state = i2c_get_clientdata(client);
1280
1281         dev_dbg(&client->dev, "\n");
1282
1283         kfree(state);
1284         return 0;
1285 }
1286
1287 static const struct i2c_device_id si2165_id_table[] = {
1288         {"si2165", 0},
1289         {}
1290 };
1291 MODULE_DEVICE_TABLE(i2c, si2165_id_table);
1292
1293 static struct i2c_driver si2165_driver = {
1294         .driver = {
1295                 .name   = "si2165",
1296         },
1297         .probe          = si2165_probe,
1298         .remove         = si2165_remove,
1299         .id_table       = si2165_id_table,
1300 };
1301
1302 module_i2c_driver(si2165_driver);
1303
1304 MODULE_DESCRIPTION("Silicon Labs Si2165 DVB-C/-T Demodulator driver");
1305 MODULE_AUTHOR("Matthias Schwarzott <zzam@gentoo.org>");
1306 MODULE_LICENSE("GPL");
1307 MODULE_FIRMWARE(SI2165_FIRMWARE_REV_D);