kernel/drivers/media/dvb-frontends/rtl2832.c

   1 /*
   2  * Realtek RTL2832 DVB-T demodulator driver
   3  *
   4  * Copyright (C) 2012 Thomas Mair <thomas.mair86@gmail.com>
   5  * Copyright (C) 2012-2014 Antti Palosaari <crope@iki.fi>
   6  *
   7  *      This program is free software; you can redistribute it and/or modify
   8  *      it under the terms of the GNU General Public License as published by
   9  *      the Free Software Foundation; either version 2 of the License, or
  10  *      (at your option) any later version.
  11  *
  12  *      This program is distributed in the hope that it will be useful,
  13  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *      GNU General Public License for more details.
  16  *
  17  *      You should have received a copy of the GNU General Public License along
  18  *      with this program; if not, write to the Free Software Foundation, Inc.,
  19  *      51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "rtl2832_priv.h"
  23
  24 #define REG_MASK(b) (BIT(b + 1) - 1)
  25
  26 static const struct rtl2832_reg_entry registers[] = {
  27         [DVBT_SOFT_RST]         = {0x101,  2, 2},
  28         [DVBT_IIC_REPEAT]       = {0x101,  3, 3},
  29         [DVBT_TR_WAIT_MIN_8K]   = {0x188, 11, 2},
  30         [DVBT_RSD_BER_FAIL_VAL] = {0x18f, 15, 0},
  31         [DVBT_EN_BK_TRK]        = {0x1a6,  7, 7},
  32         [DVBT_AD_EN_REG]        = {0x008,  7, 7},
  33         [DVBT_AD_EN_REG1]       = {0x008,  6, 6},
  34         [DVBT_EN_BBIN]          = {0x1b1,  0, 0},
  35         [DVBT_MGD_THD0]         = {0x195,  7, 0},
  36         [DVBT_MGD_THD1]         = {0x196,  7, 0},
  37         [DVBT_MGD_THD2]         = {0x197,  7, 0},
  38         [DVBT_MGD_THD3]         = {0x198,  7, 0},
  39         [DVBT_MGD_THD4]         = {0x199,  7, 0},
  40         [DVBT_MGD_THD5]         = {0x19a,  7, 0},
  41         [DVBT_MGD_THD6]         = {0x19b,  7, 0},
  42         [DVBT_MGD_THD7]         = {0x19c,  7, 0},
  43         [DVBT_EN_CACQ_NOTCH]    = {0x161,  4, 4},
  44         [DVBT_AD_AV_REF]        = {0x009,  6, 0},
  45         [DVBT_REG_PI]           = {0x00a,  2, 0},
  46         [DVBT_PIP_ON]           = {0x021,  3, 3},
  47         [DVBT_SCALE1_B92]       = {0x292,  7, 0},
  48         [DVBT_SCALE1_B93]       = {0x293,  7, 0},
  49         [DVBT_SCALE1_BA7]       = {0x2a7,  7, 0},
  50         [DVBT_SCALE1_BA9]       = {0x2a9,  7, 0},
  51         [DVBT_SCALE1_BAA]       = {0x2aa,  7, 0},
  52         [DVBT_SCALE1_BAB]       = {0x2ab,  7, 0},
  53         [DVBT_SCALE1_BAC]       = {0x2ac,  7, 0},
  54         [DVBT_SCALE1_BB0]       = {0x2b0,  7, 0},
  55         [DVBT_SCALE1_BB1]       = {0x2b1,  7, 0},
  56         [DVBT_KB_P1]            = {0x164,  3, 1},
  57         [DVBT_KB_P2]            = {0x164,  6, 4},
  58         [DVBT_KB_P3]            = {0x165,  2, 0},
  59         [DVBT_OPT_ADC_IQ]       = {0x006,  5, 4},
  60         [DVBT_AD_AVI]           = {0x009,  1, 0},
  61         [DVBT_AD_AVQ]           = {0x009,  3, 2},
  62         [DVBT_K1_CR_STEP12]     = {0x2ad,  9, 4},
  63         [DVBT_TRK_KS_P2]        = {0x16f,  2, 0},
  64         [DVBT_TRK_KS_I2]        = {0x170,  5, 3},
  65         [DVBT_TR_THD_SET2]      = {0x172,  3, 0},
  66         [DVBT_TRK_KC_P2]        = {0x173,  5, 3},
  67         [DVBT_TRK_KC_I2]        = {0x175,  2, 0},
  68         [DVBT_CR_THD_SET2]      = {0x176,  7, 6},
  69         [DVBT_PSET_IFFREQ]      = {0x119, 21, 0},
  70         [DVBT_SPEC_INV]         = {0x115,  0, 0},
  71         [DVBT_RSAMP_RATIO]      = {0x19f, 27, 2},
  72         [DVBT_CFREQ_OFF_RATIO]  = {0x19d, 23, 4},
  73         [DVBT_FSM_STAGE]        = {0x351,  6, 3},
  74         [DVBT_RX_CONSTEL]       = {0x33c,  3, 2},
  75         [DVBT_RX_HIER]          = {0x33c,  6, 4},
  76         [DVBT_RX_C_RATE_LP]     = {0x33d,  2, 0},
  77         [DVBT_RX_C_RATE_HP]     = {0x33d,  5, 3},
  78         [DVBT_GI_IDX]           = {0x351,  1, 0},
  79         [DVBT_FFT_MODE_IDX]     = {0x351,  2, 2},
  80         [DVBT_RSD_BER_EST]      = {0x34e, 15, 0},
  81         [DVBT_CE_EST_EVM]       = {0x40c, 15, 0},
  82         [DVBT_RF_AGC_VAL]       = {0x35b, 13, 0},
  83         [DVBT_IF_AGC_VAL]       = {0x359, 13, 0},
  84         [DVBT_DAGC_VAL]         = {0x305,  7, 0},
  85         [DVBT_SFREQ_OFF]        = {0x318, 13, 0},
  86         [DVBT_CFREQ_OFF]        = {0x35f, 17, 0},
  87         [DVBT_POLAR_RF_AGC]     = {0x00e,  1, 1},
  88         [DVBT_POLAR_IF_AGC]     = {0x00e,  0, 0},
  89         [DVBT_AAGC_HOLD]        = {0x104,  5, 5},
  90         [DVBT_EN_RF_AGC]        = {0x104,  6, 6},
  91         [DVBT_EN_IF_AGC]        = {0x104,  7, 7},
  92         [DVBT_IF_AGC_MIN]       = {0x108,  7, 0},
  93         [DVBT_IF_AGC_MAX]       = {0x109,  7, 0},
  94         [DVBT_RF_AGC_MIN]       = {0x10a,  7, 0},
  95         [DVBT_RF_AGC_MAX]       = {0x10b,  7, 0},
  96         [DVBT_IF_AGC_MAN]       = {0x10c,  6, 6},
  97         [DVBT_IF_AGC_MAN_VAL]   = {0x10c, 13, 0},
  98         [DVBT_RF_AGC_MAN]       = {0x10e,  6, 6},
  99         [DVBT_RF_AGC_MAN_VAL]   = {0x10e, 13, 0},
 100         [DVBT_DAGC_TRG_VAL]     = {0x112,  7, 0},
 101         [DVBT_AGC_TARG_VAL_0]   = {0x102,  0, 0},
 102         [DVBT_AGC_TARG_VAL_8_1] = {0x103,  7, 0},
 103         [DVBT_AAGC_LOOP_GAIN]   = {0x1c7,  5, 1},
 104         [DVBT_LOOP_GAIN2_3_0]   = {0x104,  4, 1},
 105         [DVBT_LOOP_GAIN2_4]     = {0x105,  7, 7},
 106         [DVBT_LOOP_GAIN3]       = {0x1c8,  4, 0},
 107         [DVBT_VTOP1]            = {0x106,  5, 0},
 108         [DVBT_VTOP2]            = {0x1c9,  5, 0},
 109         [DVBT_VTOP3]            = {0x1ca,  5, 0},
 110         [DVBT_KRF1]             = {0x1cb,  7, 0},
 111         [DVBT_KRF2]             = {0x107,  7, 0},
 112         [DVBT_KRF3]             = {0x1cd,  7, 0},
 113         [DVBT_KRF4]             = {0x1ce,  7, 0},
 114         [DVBT_EN_GI_PGA]        = {0x1e5,  0, 0},
 115         [DVBT_THD_LOCK_UP]      = {0x1d9,  8, 0},
 116         [DVBT_THD_LOCK_DW]      = {0x1db,  8, 0},
 117         [DVBT_THD_UP1]          = {0x1dd,  7, 0},
 118         [DVBT_THD_DW1]          = {0x1de,  7, 0},
 119         [DVBT_INTER_CNT_LEN]    = {0x1d8,  3, 0},
 120         [DVBT_GI_PGA_STATE]     = {0x1e6,  3, 3},
 121         [DVBT_EN_AGC_PGA]       = {0x1d7,  0, 0},
 122         [DVBT_CKOUTPAR]         = {0x17b,  5, 5},
 123         [DVBT_CKOUT_PWR]        = {0x17b,  6, 6},
 124         [DVBT_SYNC_DUR]         = {0x17b,  7, 7},
 125         [DVBT_ERR_DUR]          = {0x17c,  0, 0},
 126         [DVBT_SYNC_LVL]         = {0x17c,  1, 1},
 127         [DVBT_ERR_LVL]          = {0x17c,  2, 2},
 128         [DVBT_VAL_LVL]          = {0x17c,  3, 3},
 129         [DVBT_SERIAL]           = {0x17c,  4, 4},
 130         [DVBT_SER_LSB]          = {0x17c,  5, 5},
 131         [DVBT_CDIV_PH0]         = {0x17d,  3, 0},
 132         [DVBT_CDIV_PH1]         = {0x17d,  7, 4},
 133         [DVBT_MPEG_IO_OPT_2_2]  = {0x006,  7, 7},
 134         [DVBT_MPEG_IO_OPT_1_0]  = {0x007,  7, 6},
 135         [DVBT_CKOUTPAR_PIP]     = {0x0b7,  4, 4},
 136         [DVBT_CKOUT_PWR_PIP]    = {0x0b7,  3, 3},
 137         [DVBT_SYNC_LVL_PIP]     = {0x0b7,  2, 2},
 138         [DVBT_ERR_LVL_PIP]      = {0x0b7,  1, 1},
 139         [DVBT_VAL_LVL_PIP]      = {0x0b7,  0, 0},
 140         [DVBT_CKOUTPAR_PID]     = {0x0b9,  4, 4},
 141         [DVBT_CKOUT_PWR_PID]    = {0x0b9,  3, 3},
 142         [DVBT_SYNC_LVL_PID]     = {0x0b9,  2, 2},
 143         [DVBT_ERR_LVL_PID]      = {0x0b9,  1, 1},
 144         [DVBT_VAL_LVL_PID]      = {0x0b9,  0, 0},
 145         [DVBT_SM_PASS]          = {0x193, 11, 0},
 146         [DVBT_AD7_SETTING]      = {0x011, 15, 0},
 147         [DVBT_RSSI_R]           = {0x301,  6, 0},
 148         [DVBT_ACI_DET_IND]      = {0x312,  0, 0},
 149         [DVBT_REG_MON]          = {0x00d,  1, 0},
 150         [DVBT_REG_MONSEL]       = {0x00d,  2, 2},
 151         [DVBT_REG_GPE]          = {0x00d,  7, 7},
 152         [DVBT_REG_GPO]          = {0x010,  0, 0},
 153         [DVBT_REG_4MSEL]        = {0x013,  0, 0},
 154 };
 155
 156 /* Our regmap is bypassing I2C adapter lock, thus we do it! */
 157 static int rtl2832_bulk_write(struct i2c_client *client, unsigned int reg,
 158                               const void *val, size_t val_count)
 159 {
 160         struct rtl2832_dev *dev = i2c_get_clientdata(client);
 161         int ret;
 162
 163         i2c_lock_adapter(client->adapter);
 164         ret = regmap_bulk_write(dev->regmap, reg, val, val_count);
 165         i2c_unlock_adapter(client->adapter);
 166         return ret;
 167 }
 168
 169 static int rtl2832_update_bits(struct i2c_client *client, unsigned int reg,
 170                                unsigned int mask, unsigned int val)
 171 {
 172         struct rtl2832_dev *dev = i2c_get_clientdata(client);
 173         int ret;
 174
 175         i2c_lock_adapter(client->adapter);
 176         ret = regmap_update_bits(dev->regmap, reg, mask, val);
 177         i2c_unlock_adapter(client->adapter);
 178         return ret;
 179 }
 180
 181 static int rtl2832_bulk_read(struct i2c_client *client, unsigned int reg,
 182                              void *val, size_t val_count)
 183 {
 184         struct rtl2832_dev *dev = i2c_get_clientdata(client);
 185         int ret;
 186
 187         i2c_lock_adapter(client->adapter);
 188         ret = regmap_bulk_read(dev->regmap, reg, val, val_count);
 189         i2c_unlock_adapter(client->adapter);
 190         return ret;
 191 }
 192
 193 static int rtl2832_rd_demod_reg(struct rtl2832_dev *dev, int reg, u32 *val)
 194 {
 195         struct i2c_client *client = dev->client;
 196         int ret, i;
 197         u16 reg_start_addr;
 198         u8 msb, lsb, reading[4], len;
 199         u32 reading_tmp, mask;
 200
 201         reg_start_addr = registers[reg].start_address;
 202         msb = registers[reg].msb;
 203         lsb = registers[reg].lsb;
 204         len = (msb >> 3) + 1;
 205         mask = REG_MASK(msb - lsb);
 206
 207         ret = rtl2832_bulk_read(client, reg_start_addr, reading, len);
 208         if (ret)
 209                 goto err;
 210
 211         reading_tmp = 0;
 212         for (i = 0; i < len; i++)
 213                 reading_tmp |= reading[i] << ((len - 1 - i) * 8);
 214
 215         *val = (reading_tmp >> lsb) & mask;
 216
 217         return 0;
 218 err:
 219         dev_dbg(&client->dev, "failed=%d\n", ret);
 220         return ret;
 221 }
 222
 223 static int rtl2832_wr_demod_reg(struct rtl2832_dev *dev, int reg, u32 val)
 224 {
 225         struct i2c_client *client = dev->client;
 226         int ret, i;
 227         u16 reg_start_addr;
 228         u8 msb, lsb, reading[4], writing[4], len;
 229         u32 reading_tmp, writing_tmp, mask;
 230
 231         reg_start_addr = registers[reg].start_address;
 232         msb = registers[reg].msb;
 233         lsb = registers[reg].lsb;
 234         len = (msb >> 3) + 1;
 235         mask = REG_MASK(msb - lsb);
 236
 237         ret = rtl2832_bulk_read(client, reg_start_addr, reading, len);
 238         if (ret)
 239                 goto err;
 240
 241         reading_tmp = 0;
 242         for (i = 0; i < len; i++)
 243                 reading_tmp |= reading[i] << ((len - 1 - i) * 8);
 244
 245         writing_tmp = reading_tmp & ~(mask << lsb);
 246         writing_tmp |= ((val & mask) << lsb);
 247
 248         for (i = 0; i < len; i++)
 249                 writing[i] = (writing_tmp >> ((len - 1 - i) * 8)) & 0xff;
 250
 251         ret = rtl2832_bulk_write(client, reg_start_addr, writing, len);
 252         if (ret)
 253                 goto err;
 254
 255         return 0;
 256 err:
 257         dev_dbg(&client->dev, "failed=%d\n", ret);
 258         return ret;
 259 }
 260
 261 static int rtl2832_set_if(struct dvb_frontend *fe, u32 if_freq)
 262 {
 263         struct rtl2832_dev *dev = fe->demodulator_priv;
 264         struct i2c_client *client = dev->client;
 265         int ret;
 266         u64 pset_iffreq;
 267         u8 en_bbin = (if_freq == 0 ? 0x1 : 0x0);
 268
 269         /*
 270         * PSET_IFFREQ = - floor((IfFreqHz % CrystalFreqHz) * pow(2, 22)
 271         *               / CrystalFreqHz)
 272         */
 273         pset_iffreq = if_freq % dev->pdata->clk;
 274         pset_iffreq *= 0x400000;
 275         pset_iffreq = div_u64(pset_iffreq, dev->pdata->clk);
 276         pset_iffreq = -pset_iffreq;
 277         pset_iffreq = pset_iffreq & 0x3fffff;
 278         dev_dbg(&client->dev, "if_frequency=%d pset_iffreq=%08x\n",
 279                 if_freq, (unsigned)pset_iffreq);
 280
 281         ret = rtl2832_wr_demod_reg(dev, DVBT_EN_BBIN, en_bbin);
 282         if (ret)
 283                 goto err;
 284
 285         ret = rtl2832_wr_demod_reg(dev, DVBT_PSET_IFFREQ, pset_iffreq);
 286         if (ret)
 287                 goto err;
 288
 289         return 0;
 290 err:
 291         dev_dbg(&client->dev, "failed=%d\n", ret);
 292         return ret;
 293 }
 294
 295 static int rtl2832_init(struct dvb_frontend *fe)
 296 {
 297         struct rtl2832_dev *dev = fe->demodulator_priv;
 298         struct i2c_client *client = dev->client;
 299         struct dtv_frontend_properties *c = &dev->fe.dtv_property_cache;
 300         const struct rtl2832_reg_value *init;
 301         int i, ret, len;
 302         /* initialization values for the demodulator registers */
 303         struct rtl2832_reg_value rtl2832_initial_regs[] = {
 304                 {DVBT_AD_EN_REG,                0x1},
 305                 {DVBT_AD_EN_REG1,               0x1},
 306                 {DVBT_RSD_BER_FAIL_VAL,         0x2800},
 307                 {DVBT_MGD_THD0,                 0x10},
 308                 {DVBT_MGD_THD1,                 0x20},
 309                 {DVBT_MGD_THD2,                 0x20},
 310                 {DVBT_MGD_THD3,                 0x40},
 311                 {DVBT_MGD_THD4,                 0x22},
 312                 {DVBT_MGD_THD5,                 0x32},
 313                 {DVBT_MGD_THD6,                 0x37},
 314                 {DVBT_MGD_THD7,                 0x39},
 315                 {DVBT_EN_BK_TRK,                0x0},
 316                 {DVBT_EN_CACQ_NOTCH,            0x0},
 317                 {DVBT_AD_AV_REF,                0x2a},
 318                 {DVBT_REG_PI,                   0x6},
 319                 {DVBT_PIP_ON,                   0x0},
 320                 {DVBT_CDIV_PH0,                 0x8},
 321                 {DVBT_CDIV_PH1,                 0x8},
 322                 {DVBT_SCALE1_B92,               0x4},
 323                 {DVBT_SCALE1_B93,               0xb0},
 324                 {DVBT_SCALE1_BA7,               0x78},
 325                 {DVBT_SCALE1_BA9,               0x28},
 326                 {DVBT_SCALE1_BAA,               0x59},
 327                 {DVBT_SCALE1_BAB,               0x83},
 328                 {DVBT_SCALE1_BAC,               0xd4},
 329                 {DVBT_SCALE1_BB0,               0x65},
 330                 {DVBT_SCALE1_BB1,               0x43},
 331                 {DVBT_KB_P1,                    0x1},
 332                 {DVBT_KB_P2,                    0x4},
 333                 {DVBT_KB_P3,                    0x7},
 334                 {DVBT_K1_CR_STEP12,             0xa},
 335                 {DVBT_REG_GPE,                  0x1},
 336                 {DVBT_SERIAL,                   0x0},
 337                 {DVBT_CDIV_PH0,                 0x9},
 338                 {DVBT_CDIV_PH1,                 0x9},
 339                 {DVBT_MPEG_IO_OPT_2_2,          0x0},
 340                 {DVBT_MPEG_IO_OPT_1_0,          0x0},
 341                 {DVBT_TRK_KS_P2,                0x4},
 342                 {DVBT_TRK_KS_I2,                0x7},
 343                 {DVBT_TR_THD_SET2,              0x6},
 344                 {DVBT_TRK_KC_I2,                0x5},
 345                 {DVBT_CR_THD_SET2,              0x1},
 346         };
 347
 348         dev_dbg(&client->dev, "\n");
 349
 350         for (i = 0; i < ARRAY_SIZE(rtl2832_initial_regs); i++) {
 351                 ret = rtl2832_wr_demod_reg(dev, rtl2832_initial_regs[i].reg,
 352                         rtl2832_initial_regs[i].value);
 353                 if (ret)
 354                         goto err;
 355         }
 356
 357         /* load tuner specific settings */
 358         dev_dbg(&client->dev, "load settings for tuner=%02x\n",
 359                 dev->pdata->tuner);
 360         switch (dev->pdata->tuner) {
 361         case RTL2832_TUNER_FC2580:
 362                 len = ARRAY_SIZE(rtl2832_tuner_init_fc2580);
 363                 init = rtl2832_tuner_init_fc2580;
 364                 break;
 365         case RTL2832_TUNER_FC0012:
 366         case RTL2832_TUNER_FC0013:
 367                 len = ARRAY_SIZE(rtl2832_tuner_init_fc0012);
 368                 init = rtl2832_tuner_init_fc0012;
 369                 break;
 370         case RTL2832_TUNER_TUA9001:
 371                 len = ARRAY_SIZE(rtl2832_tuner_init_tua9001);
 372                 init = rtl2832_tuner_init_tua9001;
 373                 break;
 374         case RTL2832_TUNER_E4000:
 375                 len = ARRAY_SIZE(rtl2832_tuner_init_e4000);
 376                 init = rtl2832_tuner_init_e4000;
 377                 break;
 378         case RTL2832_TUNER_R820T:
 379         case RTL2832_TUNER_R828D:
 380                 len = ARRAY_SIZE(rtl2832_tuner_init_r820t);
 381                 init = rtl2832_tuner_init_r820t;
 382                 break;
 383         case RTL2832_TUNER_SI2157:
 384                 len = ARRAY_SIZE(rtl2832_tuner_init_si2157);
 385                 init = rtl2832_tuner_init_si2157;
 386                 break;
 387         default:
 388                 ret = -EINVAL;
 389                 goto err;
 390         }
 391
 392         for (i = 0; i < len; i++) {
 393                 ret = rtl2832_wr_demod_reg(dev, init[i].reg, init[i].value);
 394                 if (ret)
 395                         goto err;
 396         }
 397
 398         /* init stats here in order signal app which stats are supported */
 399         c->strength.len = 1;
 400         c->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 401         c->cnr.len = 1;
 402         c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 403         c->post_bit_error.len = 1;
 404         c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 405         c->post_bit_count.len = 1;
 406         c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 407         /* start statistics polling */
 408         schedule_delayed_work(&dev->stat_work, msecs_to_jiffies(2000));
 409         dev->sleeping = false;
 410
 411         return 0;
 412 err:
 413         dev_dbg(&client->dev, "failed=%d\n", ret);
 414         return ret;
 415 }
 416
 417 static int rtl2832_sleep(struct dvb_frontend *fe)
 418 {
 419         struct rtl2832_dev *dev = fe->demodulator_priv;
 420         struct i2c_client *client = dev->client;
 421         int ret;
 422
 423         dev_dbg(&client->dev, "\n");
 424
 425         dev->sleeping = true;
 426         /* stop statistics polling */
 427         cancel_delayed_work_sync(&dev->stat_work);
 428         dev->fe_status = 0;
 429
 430         ret = rtl2832_wr_demod_reg(dev, DVBT_SOFT_RST, 0x1);
 431         if (ret)
 432                 goto err;
 433
 434         return 0;
 435 err:
 436         dev_dbg(&client->dev, "failed=%d\n", ret);
 437         return ret;
 438 }
 439
 440 static int rtl2832_get_tune_settings(struct dvb_frontend *fe,
 441         struct dvb_frontend_tune_settings *s)
 442 {
 443         struct rtl2832_dev *dev = fe->demodulator_priv;
 444         struct i2c_client *client = dev->client;
 445
 446         dev_dbg(&client->dev, "\n");
 447         s->min_delay_ms = 1000;
 448         s->step_size = fe->ops.info.frequency_stepsize * 2;
 449         s->max_drift = (fe->ops.info.frequency_stepsize * 2) + 1;
 450         return 0;
 451 }
 452
 453 static int rtl2832_set_frontend(struct dvb_frontend *fe)
 454 {
 455         struct rtl2832_dev *dev = fe->demodulator_priv;
 456         struct i2c_client *client = dev->client;
 457         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 458         int ret, i, j;
 459         u64 bw_mode, num, num2;
 460         u32 resamp_ratio, cfreq_off_ratio;
 461         static u8 bw_params[3][32] = {
 462         /* 6 MHz bandwidth */
 463                 {
 464                 0xf5, 0xff, 0x15, 0x38, 0x5d, 0x6d, 0x52, 0x07, 0xfa, 0x2f,
 465                 0x53, 0xf5, 0x3f, 0xca, 0x0b, 0x91, 0xea, 0x30, 0x63, 0xb2,
 466                 0x13, 0xda, 0x0b, 0xc4, 0x18, 0x7e, 0x16, 0x66, 0x08, 0x67,
 467                 0x19, 0xe0,
 468                 },
 469
 470         /*  7 MHz bandwidth */
 471                 {
 472                 0xe7, 0xcc, 0xb5, 0xba, 0xe8, 0x2f, 0x67, 0x61, 0x00, 0xaf,
 473                 0x86, 0xf2, 0xbf, 0x59, 0x04, 0x11, 0xb6, 0x33, 0xa4, 0x30,
 474                 0x15, 0x10, 0x0a, 0x42, 0x18, 0xf8, 0x17, 0xd9, 0x07, 0x22,
 475                 0x19, 0x10,
 476                 },
 477
 478         /*  8 MHz bandwidth */
 479                 {
 480                 0x09, 0xf6, 0xd2, 0xa7, 0x9a, 0xc9, 0x27, 0x77, 0x06, 0xbf,
 481                 0xec, 0xf4, 0x4f, 0x0b, 0xfc, 0x01, 0x63, 0x35, 0x54, 0xa7,
 482                 0x16, 0x66, 0x08, 0xb4, 0x19, 0x6e, 0x19, 0x65, 0x05, 0xc8,
 483                 0x19, 0xe0,
 484                 },
 485         };
 486
 487         dev_dbg(&client->dev, "frequency=%u bandwidth_hz=%u inversion=%u\n",
 488                 c->frequency, c->bandwidth_hz, c->inversion);
 489
 490         /* program tuner */
 491         if (fe->ops.tuner_ops.set_params)
 492                 fe->ops.tuner_ops.set_params(fe);
 493
 494         /* PIP mode related */
 495         ret = rtl2832_bulk_write(client, 0x192, "\x00\x0f\xff", 3);
 496         if (ret)
 497                 goto err;
 498
 499         /* If the frontend has get_if_frequency(), use it */
 500         if (fe->ops.tuner_ops.get_if_frequency) {
 501                 u32 if_freq;
 502
 503                 ret = fe->ops.tuner_ops.get_if_frequency(fe, &if_freq);
 504                 if (ret)
 505                         goto err;
 506
 507                 ret = rtl2832_set_if(fe, if_freq);
 508                 if (ret)
 509                         goto err;
 510         }
 511
 512         switch (c->bandwidth_hz) {
 513         case 6000000:
 514                 i = 0;
 515                 bw_mode = 48000000;
 516                 break;
 517         case 7000000:
 518                 i = 1;
 519                 bw_mode = 56000000;
 520                 break;
 521         case 8000000:
 522                 i = 2;
 523                 bw_mode = 64000000;
 524                 break;
 525         default:
 526                 dev_err(&client->dev, "invalid bandwidth_hz %u\n",
 527                         c->bandwidth_hz);
 528                 ret = -EINVAL;
 529                 goto err;
 530         }
 531
 532         for (j = 0; j < sizeof(bw_params[0]); j++) {
 533                 ret = rtl2832_bulk_write(client, 0x11c + j, &bw_params[i][j], 1);
 534                 if (ret)
 535                         goto err;
 536         }
 537
 538         /* calculate and set resample ratio
 539         * RSAMP_RATIO = floor(CrystalFreqHz * 7 * pow(2, 22)
 540         *       / ConstWithBandwidthMode)
 541         */
 542         num = dev->pdata->clk * 7;
 543         num *= 0x400000;
 544         num = div_u64(num, bw_mode);
 545         resamp_ratio =  num & 0x3ffffff;
 546         ret = rtl2832_wr_demod_reg(dev, DVBT_RSAMP_RATIO, resamp_ratio);
 547         if (ret)
 548                 goto err;
 549
 550         /* calculate and set cfreq off ratio
 551         * CFREQ_OFF_RATIO = - floor(ConstWithBandwidthMode * pow(2, 20)
 552         *       / (CrystalFreqHz * 7))
 553         */
 554         num = bw_mode << 20;
 555         num2 = dev->pdata->clk * 7;
 556         num = div_u64(num, num2);
 557         num = -num;
 558         cfreq_off_ratio = num & 0xfffff;
 559         ret = rtl2832_wr_demod_reg(dev, DVBT_CFREQ_OFF_RATIO, cfreq_off_ratio);
 560         if (ret)
 561                 goto err;
 562
 563         /* soft reset */
 564         ret = rtl2832_wr_demod_reg(dev, DVBT_SOFT_RST, 0x1);
 565         if (ret)
 566                 goto err;
 567
 568         ret = rtl2832_wr_demod_reg(dev, DVBT_SOFT_RST, 0x0);
 569         if (ret)
 570                 goto err;
 571
 572         return 0;
 573 err:
 574         dev_dbg(&client->dev, "failed=%d\n", ret);
 575         return ret;
 576 }
 577
 578 static int rtl2832_get_frontend(struct dvb_frontend *fe)
 579 {
 580         struct rtl2832_dev *dev = fe->demodulator_priv;
 581         struct i2c_client *client = dev->client;
 582         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 583         int ret;
 584         u8 buf[3];
 585
 586         if (dev->sleeping)
 587                 return 0;
 588
 589         ret = rtl2832_bulk_read(client, 0x33c, buf, 2);
 590         if (ret)
 591                 goto err;
 592
 593         ret = rtl2832_bulk_read(client, 0x351, &buf[2], 1);
 594         if (ret)
 595                 goto err;
 596
 597         dev_dbg(&client->dev, "TPS=%*ph\n", 3, buf);
 598
 599         switch ((buf[0] >> 2) & 3) {
 600         case 0:
 601                 c->modulation = QPSK;
 602                 break;
 603         case 1:
 604                 c->modulation = QAM_16;
 605                 break;
 606         case 2:
 607                 c->modulation = QAM_64;
 608                 break;
 609         }
 610
 611         switch ((buf[2] >> 2) & 1) {
 612         case 0:
 613                 c->transmission_mode = TRANSMISSION_MODE_2K;
 614                 break;
 615         case 1:
 616                 c->transmission_mode = TRANSMISSION_MODE_8K;
 617         }
 618
 619         switch ((buf[2] >> 0) & 3) {
 620         case 0:
 621                 c->guard_interval = GUARD_INTERVAL_1_32;
 622                 break;
 623         case 1:
 624                 c->guard_interval = GUARD_INTERVAL_1_16;
 625                 break;
 626         case 2:
 627                 c->guard_interval = GUARD_INTERVAL_1_8;
 628                 break;
 629         case 3:
 630                 c->guard_interval = GUARD_INTERVAL_1_4;
 631                 break;
 632         }
 633
 634         switch ((buf[0] >> 4) & 7) {
 635         case 0:
 636                 c->hierarchy = HIERARCHY_NONE;
 637                 break;
 638         case 1:
 639                 c->hierarchy = HIERARCHY_1;
 640                 break;
 641         case 2:
 642                 c->hierarchy = HIERARCHY_2;
 643                 break;
 644         case 3:
 645                 c->hierarchy = HIERARCHY_4;
 646                 break;
 647         }
 648
 649         switch ((buf[1] >> 3) & 7) {
 650         case 0:
 651                 c->code_rate_HP = FEC_1_2;
 652                 break;
 653         case 1:
 654                 c->code_rate_HP = FEC_2_3;
 655                 break;
 656         case 2:
 657                 c->code_rate_HP = FEC_3_4;
 658                 break;
 659         case 3:
 660                 c->code_rate_HP = FEC_5_6;
 661                 break;
 662         case 4:
 663                 c->code_rate_HP = FEC_7_8;
 664                 break;
 665         }
 666
 667         switch ((buf[1] >> 0) & 7) {
 668         case 0:
 669                 c->code_rate_LP = FEC_1_2;
 670                 break;
 671         case 1:
 672                 c->code_rate_LP = FEC_2_3;
 673                 break;
 674         case 2:
 675                 c->code_rate_LP = FEC_3_4;
 676                 break;
 677         case 3:
 678                 c->code_rate_LP = FEC_5_6;
 679                 break;
 680         case 4:
 681                 c->code_rate_LP = FEC_7_8;
 682                 break;
 683         }
 684
 685         return 0;
 686 err:
 687         dev_dbg(&client->dev, "failed=%d\n", ret);
 688         return ret;
 689 }
 690
 691 static int rtl2832_read_status(struct dvb_frontend *fe, enum fe_status *status)
 692 {
 693         struct rtl2832_dev *dev = fe->demodulator_priv;
 694         struct i2c_client *client = dev->client;
 695         int ret;
 696         u32 uninitialized_var(tmp);
 697
 698         dev_dbg(&client->dev, "\n");
 699
 700         *status = 0;
 701         if (dev->sleeping)
 702                 return 0;
 703
 704         ret = rtl2832_rd_demod_reg(dev, DVBT_FSM_STAGE, &tmp);
 705         if (ret)
 706                 goto err;
 707
 708         if (tmp == 11) {
 709                 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER |
 710                                 FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK;
 711         } else if (tmp == 10) {
 712                 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER |
 713                                 FE_HAS_VITERBI;
 714         }
 715
 716         dev->fe_status = *status;
 717         return 0;
 718 err:
 719         dev_dbg(&client->dev, "failed=%d\n", ret);
 720         return ret;
 721 }
 722
 723 static int rtl2832_read_snr(struct dvb_frontend *fe, u16 *snr)
 724 {
 725         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 726
 727         /* report SNR in resolution of 0.1 dB */
 728         if (c->cnr.stat[0].scale == FE_SCALE_DECIBEL)
 729                 *snr = div_s64(c->cnr.stat[0].svalue, 100);
 730         else
 731                 *snr = 0;
 732
 733         return 0;
 734 }
 735
 736 static int rtl2832_read_ber(struct dvb_frontend *fe, u32 *ber)
 737 {
 738         struct rtl2832_dev *dev = fe->demodulator_priv;
 739
 740         *ber = (dev->post_bit_error - dev->post_bit_error_prev);
 741         dev->post_bit_error_prev = dev->post_bit_error;
 742
 743         return 0;
 744 }
 745
 746 static void rtl2832_stat_work(struct work_struct *work)
 747 {
 748         struct rtl2832_dev *dev = container_of(work, struct rtl2832_dev, stat_work.work);
 749         struct i2c_client *client = dev->client;
 750         struct dtv_frontend_properties *c = &dev->fe.dtv_property_cache;
 751         int ret, tmp;
 752         u8 u8tmp, buf[2];
 753         u16 u16tmp;
 754
 755         dev_dbg(&client->dev, "\n");
 756
 757         /* signal strength */
 758         if (dev->fe_status & FE_HAS_SIGNAL) {
 759                 /* read digital AGC */
 760                 ret = rtl2832_bulk_read(client, 0x305, &u8tmp, 1);
 761                 if (ret)
 762                         goto err;
 763
 764                 dev_dbg(&client->dev, "digital agc=%02x", u8tmp);
 765
 766                 u8tmp = ~u8tmp;
 767                 u16tmp = u8tmp << 8 | u8tmp << 0;
 768
 769                 c->strength.stat[0].scale = FE_SCALE_RELATIVE;
 770                 c->strength.stat[0].uvalue = u16tmp;
 771         } else {
 772                 c->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 773         }
 774
 775         /* CNR */
 776         if (dev->fe_status & FE_HAS_VITERBI) {
 777                 unsigned hierarchy, constellation;
 778                 #define CONSTELLATION_NUM 3
 779                 #define HIERARCHY_NUM 4
 780                 static const u32 constant[CONSTELLATION_NUM][HIERARCHY_NUM] = {
 781                         {85387325, 85387325, 85387325, 85387325},
 782                         {86676178, 86676178, 87167949, 87795660},
 783                         {87659938, 87659938, 87885178, 88241743},
 784                 };
 785
 786                 ret = rtl2832_bulk_read(client, 0x33c, &u8tmp, 1);
 787                 if (ret)
 788                         goto err;
 789
 790                 constellation = (u8tmp >> 2) & 0x03; /* [3:2] */
 791                 if (constellation > CONSTELLATION_NUM - 1)
 792                         goto err_schedule_delayed_work;
 793
 794                 hierarchy = (u8tmp >> 4) & 0x07; /* [6:4] */
 795                 if (hierarchy > HIERARCHY_NUM - 1)
 796                         goto err_schedule_delayed_work;
 797
 798                 ret = rtl2832_bulk_read(client, 0x40c, buf, 2);
 799                 if (ret)
 800                         goto err;
 801
 802                 u16tmp = buf[0] << 8 | buf[1] << 0;
 803                 if (u16tmp)
 804                         tmp = (constant[constellation][hierarchy] -
 805                                intlog10(u16tmp)) / ((1 << 24) / 10000);
 806                 else
 807                         tmp = 0;
 808
 809                 dev_dbg(&client->dev, "cnr raw=%u\n", u16tmp);
 810
 811                 c->cnr.stat[0].scale = FE_SCALE_DECIBEL;
 812                 c->cnr.stat[0].svalue = tmp;
 813         } else {
 814                 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 815         }
 816
 817         /* BER */
 818         if (dev->fe_status & FE_HAS_LOCK) {
 819                 ret = rtl2832_bulk_read(client, 0x34e, buf, 2);
 820                 if (ret)
 821                         goto err;
 822
 823                 u16tmp = buf[0] << 8 | buf[1] << 0;
 824                 dev->post_bit_error += u16tmp;
 825                 dev->post_bit_count += 1000000;
 826
 827                 dev_dbg(&client->dev, "ber errors=%u total=1000000\n", u16tmp);
 828
 829                 c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
 830                 c->post_bit_error.stat[0].uvalue = dev->post_bit_error;
 831                 c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;
 832                 c->post_bit_count.stat[0].uvalue = dev->post_bit_count;
 833         } else {
 834                 c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 835                 c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 836         }
 837
 838 err_schedule_delayed_work:
 839         schedule_delayed_work(&dev->stat_work, msecs_to_jiffies(2000));
 840         return;
 841 err:
 842         dev_dbg(&client->dev, "failed=%d\n", ret);
 843 }
 844
 845 /*
 846  * I2C gate/mux/repeater logic
 847  * We must use unlocked __i2c_transfer() here (through regmap) because of I2C
 848  * adapter lock is already taken by tuner driver.
 849  * There is delay mechanism to avoid unneeded I2C gate open / close. Gate close
 850  * is delayed here a little bit in order to see if there is sequence of I2C
 851  * messages sent to same I2C bus.
 852  */
 853 static void rtl2832_i2c_gate_work(struct work_struct *work)
 854 {
 855         struct rtl2832_dev *dev = container_of(work, struct rtl2832_dev, i2c_gate_work.work);
 856         struct i2c_client *client = dev->client;
 857         int ret;
 858
 859         /* close gate */
 860         ret = rtl2832_update_bits(dev->client, 0x101, 0x08, 0x00);
 861         if (ret)
 862                 goto err;
 863
 864         return;
 865 err:
 866         dev_dbg(&client->dev, "failed=%d\n", ret);
 867 }
 868
 869 static int rtl2832_select(struct i2c_adapter *adap, void *mux_priv, u32 chan_id)
 870 {
 871         struct rtl2832_dev *dev = mux_priv;
 872         struct i2c_client *client = dev->client;
 873         int ret;
 874
 875         /* terminate possible gate closing */
 876         cancel_delayed_work(&dev->i2c_gate_work);
 877
 878         /*
 879          * I2C adapter lock is already taken and due to that we will use
 880          * regmap_update_bits() which does not lock again I2C adapter.
 881          */
 882         ret = regmap_update_bits(dev->regmap, 0x101, 0x08, 0x08);
 883         if (ret)
 884                 goto err;
 885
 886         return 0;
 887 err:
 888         dev_dbg(&client->dev, "failed=%d\n", ret);
 889         return ret;
 890 }
 891
 892 static int rtl2832_deselect(struct i2c_adapter *adap, void *mux_priv,
 893                             u32 chan_id)
 894 {
 895         struct rtl2832_dev *dev = mux_priv;
 896
 897         schedule_delayed_work(&dev->i2c_gate_work, usecs_to_jiffies(100));
 898         return 0;
 899 }
 900
 901 static struct dvb_frontend_ops rtl2832_ops = {
 902         .delsys = { SYS_DVBT },
 903         .info = {
 904                 .name = "Realtek RTL2832 (DVB-T)",
 905                 .frequency_min    = 174000000,
 906                 .frequency_max    = 862000000,
 907                 .frequency_stepsize = 166667,
 908                 .caps = FE_CAN_FEC_1_2 |
 909                         FE_CAN_FEC_2_3 |
 910                         FE_CAN_FEC_3_4 |
 911                         FE_CAN_FEC_5_6 |
 912                         FE_CAN_FEC_7_8 |
 913                         FE_CAN_FEC_AUTO |
 914                         FE_CAN_QPSK |
 915                         FE_CAN_QAM_16 |
 916                         FE_CAN_QAM_64 |
 917                         FE_CAN_QAM_AUTO |
 918                         FE_CAN_TRANSMISSION_MODE_AUTO |
 919                         FE_CAN_GUARD_INTERVAL_AUTO |
 920                         FE_CAN_HIERARCHY_AUTO |
 921                         FE_CAN_RECOVER |
 922                         FE_CAN_MUTE_TS
 923          },
 924
 925         .init = rtl2832_init,
 926         .sleep = rtl2832_sleep,
 927
 928         .get_tune_settings = rtl2832_get_tune_settings,
 929
 930         .set_frontend = rtl2832_set_frontend,
 931         .get_frontend = rtl2832_get_frontend,
 932
 933         .read_status = rtl2832_read_status,
 934         .read_snr = rtl2832_read_snr,
 935         .read_ber = rtl2832_read_ber,
 936 };
 937
 938 static bool rtl2832_volatile_reg(struct device *dev, unsigned int reg)
 939 {
 940         switch (reg) {
 941         case 0x305:
 942         case 0x33c:
 943         case 0x34e:
 944         case 0x351:
 945         case 0x40c ... 0x40d:
 946                 return true;
 947         default:
 948                 break;
 949         }
 950
 951         return false;
 952 }
 953
 954 /*
 955  * We implement own I2C access routines for regmap in order to get manual access
 956  * to I2C adapter lock, which is needed for I2C mux adapter.
 957  */
 958 static int rtl2832_regmap_read(void *context, const void *reg_buf,
 959                                size_t reg_size, void *val_buf, size_t val_size)
 960 {
 961         struct i2c_client *client = context;
 962         int ret;
 963         struct i2c_msg msg[2] = {
 964                 {
 965                         .addr = client->addr,
 966                         .flags = 0,
 967                         .len = reg_size,
 968                         .buf = (u8 *)reg_buf,
 969                 }, {
 970                         .addr = client->addr,
 971                         .flags = I2C_M_RD,
 972                         .len = val_size,
 973                         .buf = val_buf,
 974                 }
 975         };
 976
 977         ret = __i2c_transfer(client->adapter, msg, 2);
 978         if (ret != 2) {
 979                 dev_warn(&client->dev, "i2c reg read failed %d\n", ret);
 980                 if (ret >= 0)
 981                         ret = -EREMOTEIO;
 982                 return ret;
 983         }
 984         return 0;
 985 }
 986
 987 static int rtl2832_regmap_write(void *context, const void *data, size_t count)
 988 {
 989         struct i2c_client *client = context;
 990         int ret;
 991         struct i2c_msg msg[1] = {
 992                 {
 993                         .addr = client->addr,
 994                         .flags = 0,
 995                         .len = count,
 996                         .buf = (u8 *)data,
 997                 }
 998         };
 999
1000         ret = __i2c_transfer(client->adapter, msg, 1);
1001         if (ret != 1) {
1002                 dev_warn(&client->dev, "i2c reg write failed %d\n", ret);
1003                 if (ret >= 0)
1004                         ret = -EREMOTEIO;
1005                 return ret;
1006         }
1007         return 0;
1008 }
1009
1010 static int rtl2832_regmap_gather_write(void *context, const void *reg,
1011                                        size_t reg_len, const void *val,
1012                                        size_t val_len)
1013 {
1014         struct i2c_client *client = context;
1015         int ret;
1016         u8 buf[256];
1017         struct i2c_msg msg[1] = {
1018                 {
1019                         .addr = client->addr,
1020                         .flags = 0,
1021                         .len = 1 + val_len,
1022                         .buf = buf,
1023                 }
1024         };
1025
1026         buf[0] = *(u8 const *)reg;
1027         memcpy(&buf[1], val, val_len);
1028
1029         ret = __i2c_transfer(client->adapter, msg, 1);
1030         if (ret != 1) {
1031                 dev_warn(&client->dev, "i2c reg write failed %d\n", ret);
1032                 if (ret >= 0)
1033                         ret = -EREMOTEIO;
1034                 return ret;
1035         }
1036         return 0;
1037 }
1038
1039 /*
1040  * FIXME: Hack. Implement own regmap locking in order to silence lockdep
1041  * recursive lock warning. That happens when regmap I2C client calls I2C mux
1042  * adapter, which leads demod I2C repeater enable via demod regmap. Operation
1043  * takes two regmap locks recursively - but those are different regmap instances
1044  * in a two different I2C drivers, so it is not deadlock. Proper fix is to make
1045  * regmap aware of lockdep.
1046  */
1047 static void rtl2832_regmap_lock(void *__dev)
1048 {
1049         struct rtl2832_dev *dev = __dev;
1050         struct i2c_client *client = dev->client;
1051
1052         dev_dbg(&client->dev, "\n");
1053         mutex_lock(&dev->regmap_mutex);
1054 }
1055
1056 static void rtl2832_regmap_unlock(void *__dev)
1057 {
1058         struct rtl2832_dev *dev = __dev;
1059         struct i2c_client *client = dev->client;
1060
1061         dev_dbg(&client->dev, "\n");
1062         mutex_unlock(&dev->regmap_mutex);
1063 }
1064
1065 static struct dvb_frontend *rtl2832_get_dvb_frontend(struct i2c_client *client)
1066 {
1067         struct rtl2832_dev *dev = i2c_get_clientdata(client);
1068
1069         dev_dbg(&client->dev, "\n");
1070         return &dev->fe;
1071 }
1072
1073 static struct i2c_adapter *rtl2832_get_i2c_adapter(struct i2c_client *client)
1074 {
1075         struct rtl2832_dev *dev = i2c_get_clientdata(client);
1076
1077         dev_dbg(&client->dev, "\n");
1078         return dev->i2c_adapter_tuner;
1079 }
1080
1081 static int rtl2832_enable_slave_ts(struct i2c_client *client)
1082 {
1083         struct rtl2832_dev *dev = i2c_get_clientdata(client);
1084         int ret;
1085
1086         dev_dbg(&client->dev, "\n");
1087
1088         ret = rtl2832_bulk_write(client, 0x10c, "\x5f\xff", 2);
1089         if (ret)
1090                 goto err;
1091
1092         ret = rtl2832_wr_demod_reg(dev, DVBT_PIP_ON, 0x1);
1093         if (ret)
1094                 goto err;
1095
1096         ret = rtl2832_bulk_write(client, 0x0bc, "\x18", 1);
1097         if (ret)
1098                 goto err;
1099
1100         ret = rtl2832_bulk_write(client, 0x022, "\x01", 1);
1101         if (ret)
1102                 goto err;
1103
1104         ret = rtl2832_bulk_write(client, 0x026, "\x1f", 1);
1105         if (ret)
1106                 goto err;
1107
1108         ret = rtl2832_bulk_write(client, 0x027, "\xff", 1);
1109         if (ret)
1110                 goto err;
1111
1112         ret = rtl2832_bulk_write(client, 0x192, "\x7f\xf7\xff", 3);
1113         if (ret)
1114                 goto err;
1115
1116         /* soft reset */
1117         ret = rtl2832_wr_demod_reg(dev, DVBT_SOFT_RST, 0x1);
1118         if (ret)
1119                 goto err;
1120
1121         ret = rtl2832_wr_demod_reg(dev, DVBT_SOFT_RST, 0x0);
1122         if (ret)
1123                 goto err;
1124
1125         return 0;
1126 err:
1127         dev_dbg(&client->dev, "failed=%d\n", ret);
1128         return ret;
1129 }
1130
1131 static int rtl2832_pid_filter_ctrl(struct dvb_frontend *fe, int onoff)
1132 {
1133         struct rtl2832_dev *dev = fe->demodulator_priv;
1134         struct i2c_client *client = dev->client;
1135         int ret;
1136         u8 u8tmp;
1137
1138         dev_dbg(&client->dev, "onoff=%d\n", onoff);
1139
1140         /* enable / disable PID filter */
1141         if (onoff)
1142                 u8tmp = 0x80;
1143         else
1144                 u8tmp = 0x00;
1145
1146         ret = rtl2832_update_bits(client, 0x061, 0xc0, u8tmp);
1147         if (ret)
1148                 goto err;
1149
1150         return 0;
1151 err:
1152         dev_dbg(&client->dev, "failed=%d\n", ret);
1153         return ret;
1154 }
1155
1156 static int rtl2832_pid_filter(struct dvb_frontend *fe, u8 index, u16 pid,
1157                               int onoff)
1158 {
1159         struct rtl2832_dev *dev = fe->demodulator_priv;
1160         struct i2c_client *client = dev->client;
1161         int ret;
1162         u8 buf[4];
1163
1164         dev_dbg(&client->dev, "index=%d pid=%04x onoff=%d\n",
1165                 index, pid, onoff);
1166
1167         /* skip invalid PIDs (0x2000) */
1168         if (pid > 0x1fff || index > 32)
1169                 return 0;
1170
1171         if (onoff)
1172                 set_bit(index, &dev->filters);
1173         else
1174                 clear_bit(index, &dev->filters);
1175
1176         /* enable / disable PIDs */
1177         buf[0] = (dev->filters >>  0) & 0xff;
1178         buf[1] = (dev->filters >>  8) & 0xff;
1179         buf[2] = (dev->filters >> 16) & 0xff;
1180         buf[3] = (dev->filters >> 24) & 0xff;
1181         ret = rtl2832_bulk_write(client, 0x062, buf, 4);
1182         if (ret)
1183                 goto err;
1184
1185         /* add PID */
1186         buf[0] = (pid >> 8) & 0xff;
1187         buf[1] = (pid >> 0) & 0xff;
1188         ret = rtl2832_bulk_write(client, 0x066 + 2 * index, buf, 2);
1189         if (ret)
1190                 goto err;
1191
1192         return 0;
1193 err:
1194         dev_dbg(&client->dev, "failed=%d\n", ret);
1195         return ret;
1196 }
1197
1198 static int rtl2832_probe(struct i2c_client *client,
1199                 const struct i2c_device_id *id)
1200 {
1201         struct rtl2832_platform_data *pdata = client->dev.platform_data;
1202         struct i2c_adapter *i2c = client->adapter;
1203         struct rtl2832_dev *dev;
1204         int ret;
1205         u8 tmp;
1206         static const struct regmap_bus regmap_bus = {
1207                 .read = rtl2832_regmap_read,
1208                 .write = rtl2832_regmap_write,
1209                 .gather_write = rtl2832_regmap_gather_write,
1210                 .val_format_endian_default = REGMAP_ENDIAN_NATIVE,
1211         };
1212         static const struct regmap_range_cfg regmap_range_cfg[] = {
1213                 {
1214                         .selector_reg     = 0x00,
1215                         .selector_mask    = 0xff,
1216                         .selector_shift   = 0,
1217                         .window_start     = 0,
1218                         .window_len       = 0x100,
1219                         .range_min        = 0 * 0x100,
1220                         .range_max        = 5 * 0x100,
1221                 },
1222         };
1223
1224         dev_dbg(&client->dev, "\n");
1225
1226         /* allocate memory for the internal state */
1227         dev = kzalloc(sizeof(struct rtl2832_dev), GFP_KERNEL);
1228         if (dev == NULL) {
1229                 ret = -ENOMEM;
1230                 goto err;
1231         }
1232
1233         /* setup the state */
1234         i2c_set_clientdata(client, dev);
1235         dev->client = client;
1236         dev->pdata = client->dev.platform_data;
1237         dev->sleeping = true;
1238         INIT_DELAYED_WORK(&dev->i2c_gate_work, rtl2832_i2c_gate_work);
1239         INIT_DELAYED_WORK(&dev->stat_work, rtl2832_stat_work);
1240         /* create regmap */
1241         mutex_init(&dev->regmap_mutex);
1242         dev->regmap_config.reg_bits =  8,
1243         dev->regmap_config.val_bits =  8,
1244         dev->regmap_config.lock = rtl2832_regmap_lock,
1245         dev->regmap_config.unlock = rtl2832_regmap_unlock,
1246         dev->regmap_config.lock_arg = dev,
1247         dev->regmap_config.volatile_reg = rtl2832_volatile_reg,
1248         dev->regmap_config.max_register = 5 * 0x100,
1249         dev->regmap_config.ranges = regmap_range_cfg,
1250         dev->regmap_config.num_ranges = ARRAY_SIZE(regmap_range_cfg),
1251         dev->regmap_config.cache_type = REGCACHE_NONE,
1252         dev->regmap = regmap_init(&client->dev, &regmap_bus, client,
1253                                   &dev->regmap_config);
1254         if (IS_ERR(dev->regmap)) {
1255                 ret = PTR_ERR(dev->regmap);
1256                 goto err_kfree;
1257         }
1258
1259         /* check if the demod is there */
1260         ret = rtl2832_bulk_read(client, 0x000, &tmp, 1);
1261         if (ret)
1262                 goto err_regmap_exit;
1263
1264         /* create muxed i2c adapter for demod tuner bus */
1265         dev->i2c_adapter_tuner = i2c_add_mux_adapter(i2c, &i2c->dev, dev,
1266                         0, 0, 0, rtl2832_select, rtl2832_deselect);
1267         if (dev->i2c_adapter_tuner == NULL) {
1268                 ret = -ENODEV;
1269                 goto err_regmap_exit;
1270         }
1271
1272         /* create dvb_frontend */
1273         memcpy(&dev->fe.ops, &rtl2832_ops, sizeof(struct dvb_frontend_ops));
1274         dev->fe.demodulator_priv = dev;
1275
1276         /* setup callbacks */
1277         pdata->get_dvb_frontend = rtl2832_get_dvb_frontend;
1278         pdata->get_i2c_adapter = rtl2832_get_i2c_adapter;
1279         pdata->enable_slave_ts = rtl2832_enable_slave_ts;
1280         pdata->pid_filter = rtl2832_pid_filter;
1281         pdata->pid_filter_ctrl = rtl2832_pid_filter_ctrl;
1282         pdata->bulk_read = rtl2832_bulk_read;
1283         pdata->bulk_write = rtl2832_bulk_write;
1284         pdata->update_bits = rtl2832_update_bits;
1285
1286         dev_info(&client->dev, "Realtek RTL2832 successfully attached\n");
1287         return 0;
1288 err_regmap_exit:
1289         regmap_exit(dev->regmap);
1290 err_kfree:
1291         kfree(dev);
1292 err:
1293         dev_dbg(&client->dev, "failed=%d\n", ret);
1294         return ret;
1295 }
1296
1297 static int rtl2832_remove(struct i2c_client *client)
1298 {
1299         struct rtl2832_dev *dev = i2c_get_clientdata(client);
1300
1301         dev_dbg(&client->dev, "\n");
1302
1303         cancel_delayed_work_sync(&dev->i2c_gate_work);
1304
1305         i2c_del_mux_adapter(dev->i2c_adapter_tuner);
1306
1307         regmap_exit(dev->regmap);
1308
1309         kfree(dev);
1310
1311         return 0;
1312 }
1313
1314 static const struct i2c_device_id rtl2832_id_table[] = {
1315         {"rtl2832", 0},
1316         {}
1317 };
1318 MODULE_DEVICE_TABLE(i2c, rtl2832_id_table);
1319
1320 static struct i2c_driver rtl2832_driver = {
1321         .driver = {
1322                 .name   = "rtl2832",
1323         },
1324         .probe          = rtl2832_probe,
1325         .remove         = rtl2832_remove,
1326         .id_table       = rtl2832_id_table,
1327 };
1328
1329 module_i2c_driver(rtl2832_driver);
1330
1331 MODULE_AUTHOR("Thomas Mair <mair.thomas86@gmail.com>");
1332 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1333 MODULE_DESCRIPTION("Realtek RTL2832 DVB-T demodulator driver");
1334 MODULE_LICENSE("GPL");