drivers/media/dvb-frontends/rtl2830.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Realtek RTL2830 DVB-T demodulator driver
   4  *
   5  * Copyright (C) 2011 Antti Palosaari <crope@iki.fi>
   6  */
   7
   8 #include "rtl2830_priv.h"
   9
  10 /* Our regmap is bypassing I2C adapter lock, thus we do it! */
  11 static int rtl2830_bulk_write(struct i2c_client *client, unsigned int reg,
  12                               const void *val, size_t val_count)
  13 {
  14         struct rtl2830_dev *dev = i2c_get_clientdata(client);
  15         int ret;
  16
  17         i2c_lock_bus(client->adapter, I2C_LOCK_SEGMENT);
  18         ret = regmap_bulk_write(dev->regmap, reg, val, val_count);
  19         i2c_unlock_bus(client->adapter, I2C_LOCK_SEGMENT);
  20         return ret;
  21 }
  22
  23 static int rtl2830_update_bits(struct i2c_client *client, unsigned int reg,
  24                                unsigned int mask, unsigned int val)
  25 {
  26         struct rtl2830_dev *dev = i2c_get_clientdata(client);
  27         int ret;
  28
  29         i2c_lock_bus(client->adapter, I2C_LOCK_SEGMENT);
  30         ret = regmap_update_bits(dev->regmap, reg, mask, val);
  31         i2c_unlock_bus(client->adapter, I2C_LOCK_SEGMENT);
  32         return ret;
  33 }
  34
  35 static int rtl2830_bulk_read(struct i2c_client *client, unsigned int reg,
  36                              void *val, size_t val_count)
  37 {
  38         struct rtl2830_dev *dev = i2c_get_clientdata(client);
  39         int ret;
  40
  41         i2c_lock_bus(client->adapter, I2C_LOCK_SEGMENT);
  42         ret = regmap_bulk_read(dev->regmap, reg, val, val_count);
  43         i2c_unlock_bus(client->adapter, I2C_LOCK_SEGMENT);
  44         return ret;
  45 }
  46
  47 static int rtl2830_init(struct dvb_frontend *fe)
  48 {
  49         struct i2c_client *client = fe->demodulator_priv;
  50         struct rtl2830_dev *dev = i2c_get_clientdata(client);
  51         struct dtv_frontend_properties *c = &dev->fe.dtv_property_cache;
  52         int ret, i;
  53         struct rtl2830_reg_val_mask tab[] = {
  54                 {0x00d, 0x01, 0x03},
  55                 {0x00d, 0x10, 0x10},
  56                 {0x104, 0x00, 0x1e},
  57                 {0x105, 0x80, 0x80},
  58                 {0x110, 0x02, 0x03},
  59                 {0x110, 0x08, 0x0c},
  60                 {0x17b, 0x00, 0x40},
  61                 {0x17d, 0x05, 0x0f},
  62                 {0x17d, 0x50, 0xf0},
  63                 {0x18c, 0x08, 0x0f},
  64                 {0x18d, 0x00, 0xc0},
  65                 {0x188, 0x05, 0x0f},
  66                 {0x189, 0x00, 0xfc},
  67                 {0x2d5, 0x02, 0x02},
  68                 {0x2f1, 0x02, 0x06},
  69                 {0x2f1, 0x20, 0xf8},
  70                 {0x16d, 0x00, 0x01},
  71                 {0x1a6, 0x00, 0x80},
  72                 {0x106, dev->pdata->vtop, 0x3f},
  73                 {0x107, dev->pdata->krf, 0x3f},
  74                 {0x112, 0x28, 0xff},
  75                 {0x103, dev->pdata->agc_targ_val, 0xff},
  76                 {0x00a, 0x02, 0x07},
  77                 {0x140, 0x0c, 0x3c},
  78                 {0x140, 0x40, 0xc0},
  79                 {0x15b, 0x05, 0x07},
  80                 {0x15b, 0x28, 0x38},
  81                 {0x15c, 0x05, 0x07},
  82                 {0x15c, 0x28, 0x38},
  83                 {0x115, dev->pdata->spec_inv, 0x01},
  84                 {0x16f, 0x01, 0x07},
  85                 {0x170, 0x18, 0x38},
  86                 {0x172, 0x0f, 0x0f},
  87                 {0x173, 0x08, 0x38},
  88                 {0x175, 0x01, 0x07},
  89                 {0x176, 0x00, 0xc0},
  90         };
  91
  92         for (i = 0; i < ARRAY_SIZE(tab); i++) {
  93                 ret = rtl2830_update_bits(client, tab[i].reg, tab[i].mask,
  94                                           tab[i].val);
  95                 if (ret)
  96                         goto err;
  97         }
  98
  99         ret = rtl2830_bulk_write(client, 0x18f, "\x28\x00", 2);
 100         if (ret)
 101                 goto err;
 102
 103         ret = rtl2830_bulk_write(client, 0x195,
 104                                  "\x04\x06\x0a\x12\x0a\x12\x1e\x28", 8);
 105         if (ret)
 106                 goto err;
 107
 108         /* TODO: spec init */
 109
 110         /* soft reset */
 111         ret = rtl2830_update_bits(client, 0x101, 0x04, 0x04);
 112         if (ret)
 113                 goto err;
 114
 115         ret = rtl2830_update_bits(client, 0x101, 0x04, 0x00);
 116         if (ret)
 117                 goto err;
 118
 119         /* init stats here in order signal app which stats are supported */
 120         c->strength.len = 1;
 121         c->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 122         c->cnr.len = 1;
 123         c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 124         c->post_bit_error.len = 1;
 125         c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 126         c->post_bit_count.len = 1;
 127         c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 128
 129         dev->sleeping = false;
 130
 131         return ret;
 132 err:
 133         dev_dbg(&client->dev, "failed=%d\n", ret);
 134         return ret;
 135 }
 136
 137 static int rtl2830_sleep(struct dvb_frontend *fe)
 138 {
 139         struct i2c_client *client = fe->demodulator_priv;
 140         struct rtl2830_dev *dev = i2c_get_clientdata(client);
 141
 142         dev->sleeping = true;
 143         dev->fe_status = 0;
 144
 145         return 0;
 146 }
 147
 148 static int rtl2830_get_tune_settings(struct dvb_frontend *fe,
 149                                      struct dvb_frontend_tune_settings *s)
 150 {
 151         s->min_delay_ms = 500;
 152         s->step_size = fe->ops.info.frequency_stepsize_hz * 2;
 153         s->max_drift = (fe->ops.info.frequency_stepsize_hz * 2) + 1;
 154
 155         return 0;
 156 }
 157
 158 static int rtl2830_set_frontend(struct dvb_frontend *fe)
 159 {
 160         struct i2c_client *client = fe->demodulator_priv;
 161         struct rtl2830_dev *dev = i2c_get_clientdata(client);
 162         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 163         int ret, i;
 164         u64 num;
 165         u8 buf[3], u8tmp;
 166         u32 if_ctl, if_frequency;
 167         static const u8 bw_params1[3][34] = {
 168                 {
 169                 0x1f, 0xf0, 0x1f, 0xf0, 0x1f, 0xfa, 0x00, 0x17, 0x00, 0x41,
 170                 0x00, 0x64, 0x00, 0x67, 0x00, 0x38, 0x1f, 0xde, 0x1f, 0x7a,
 171                 0x1f, 0x47, 0x1f, 0x7c, 0x00, 0x30, 0x01, 0x4b, 0x02, 0x82,
 172                 0x03, 0x73, 0x03, 0xcf, /* 6 MHz */
 173                 }, {
 174                 0x1f, 0xfa, 0x1f, 0xda, 0x1f, 0xc1, 0x1f, 0xb3, 0x1f, 0xca,
 175                 0x00, 0x07, 0x00, 0x4d, 0x00, 0x6d, 0x00, 0x40, 0x1f, 0xca,
 176                 0x1f, 0x4d, 0x1f, 0x2a, 0x1f, 0xb2, 0x00, 0xec, 0x02, 0x7e,
 177                 0x03, 0xd0, 0x04, 0x53, /* 7 MHz */
 178                 }, {
 179                 0x00, 0x10, 0x00, 0x0e, 0x1f, 0xf7, 0x1f, 0xc9, 0x1f, 0xa0,
 180                 0x1f, 0xa6, 0x1f, 0xec, 0x00, 0x4e, 0x00, 0x7d, 0x00, 0x3a,
 181                 0x1f, 0x98, 0x1f, 0x10, 0x1f, 0x40, 0x00, 0x75, 0x02, 0x5f,
 182                 0x04, 0x24, 0x04, 0xdb, /* 8 MHz */
 183                 },
 184         };
 185         static const u8 bw_params2[3][6] = {
 186                 {0xc3, 0x0c, 0x44, 0x33, 0x33, 0x30}, /* 6 MHz */
 187                 {0xb8, 0xe3, 0x93, 0x99, 0x99, 0x98}, /* 7 MHz */
 188                 {0xae, 0xba, 0xf3, 0x26, 0x66, 0x64}, /* 8 MHz */
 189         };
 190
 191         dev_dbg(&client->dev, "frequency=%u bandwidth_hz=%u inversion=%u\n",
 192                 c->frequency, c->bandwidth_hz, c->inversion);
 193
 194         /* program tuner */
 195         if (fe->ops.tuner_ops.set_params)
 196                 fe->ops.tuner_ops.set_params(fe);
 197
 198         switch (c->bandwidth_hz) {
 199         case 6000000:
 200                 i = 0;
 201                 break;
 202         case 7000000:
 203                 i = 1;
 204                 break;
 205         case 8000000:
 206                 i = 2;
 207                 break;
 208         default:
 209                 dev_err(&client->dev, "invalid bandwidth_hz %u\n",
 210                         c->bandwidth_hz);
 211                 return -EINVAL;
 212         }
 213
 214         ret = rtl2830_update_bits(client, 0x008, 0x06, i << 1);
 215         if (ret)
 216                 goto err;
 217
 218         /* program if frequency */
 219         if (fe->ops.tuner_ops.get_if_frequency)
 220                 ret = fe->ops.tuner_ops.get_if_frequency(fe, &if_frequency);
 221         else
 222                 ret = -EINVAL;
 223         if (ret)
 224                 goto err;
 225
 226         num = if_frequency % dev->pdata->clk;
 227         num *= 0x400000;
 228         num = div_u64(num, dev->pdata->clk);
 229         num = -num;
 230         if_ctl = num & 0x3fffff;
 231         dev_dbg(&client->dev, "if_frequency=%d if_ctl=%08x\n",
 232                 if_frequency, if_ctl);
 233
 234         buf[0] = (if_ctl >> 16) & 0x3f;
 235         buf[1] = (if_ctl >>  8) & 0xff;
 236         buf[2] = (if_ctl >>  0) & 0xff;
 237
 238         ret = rtl2830_bulk_read(client, 0x119, &u8tmp, 1);
 239         if (ret)
 240                 goto err;
 241
 242         buf[0] |= u8tmp & 0xc0;  /* [7:6] */
 243
 244         ret = rtl2830_bulk_write(client, 0x119, buf, 3);
 245         if (ret)
 246                 goto err;
 247
 248         /* 1/2 split I2C write */
 249         ret = rtl2830_bulk_write(client, 0x11c, &bw_params1[i][0], 17);
 250         if (ret)
 251                 goto err;
 252
 253         /* 2/2 split I2C write */
 254         ret = rtl2830_bulk_write(client, 0x12d, &bw_params1[i][17], 17);
 255         if (ret)
 256                 goto err;
 257
 258         ret = rtl2830_bulk_write(client, 0x19d, bw_params2[i], 6);
 259         if (ret)
 260                 goto err;
 261
 262         return ret;
 263 err:
 264         dev_dbg(&client->dev, "failed=%d\n", ret);
 265         return ret;
 266 }
 267
 268 static int rtl2830_get_frontend(struct dvb_frontend *fe,
 269                                 struct dtv_frontend_properties *c)
 270 {
 271         struct i2c_client *client = fe->demodulator_priv;
 272         struct rtl2830_dev *dev = i2c_get_clientdata(client);
 273         int ret;
 274         u8 buf[3];
 275
 276         if (dev->sleeping)
 277                 return 0;
 278
 279         ret = rtl2830_bulk_read(client, 0x33c, buf, 2);
 280         if (ret)
 281                 goto err;
 282
 283         ret = rtl2830_bulk_read(client, 0x351, &buf[2], 1);
 284         if (ret)
 285                 goto err;
 286
 287         dev_dbg(&client->dev, "TPS=%*ph\n", 3, buf);
 288
 289         switch ((buf[0] >> 2) & 3) {
 290         case 0:
 291                 c->modulation = QPSK;
 292                 break;
 293         case 1:
 294                 c->modulation = QAM_16;
 295                 break;
 296         case 2:
 297                 c->modulation = QAM_64;
 298                 break;
 299         }
 300
 301         switch ((buf[2] >> 2) & 1) {
 302         case 0:
 303                 c->transmission_mode = TRANSMISSION_MODE_2K;
 304                 break;
 305         case 1:
 306                 c->transmission_mode = TRANSMISSION_MODE_8K;
 307         }
 308
 309         switch ((buf[2] >> 0) & 3) {
 310         case 0:
 311                 c->guard_interval = GUARD_INTERVAL_1_32;
 312                 break;
 313         case 1:
 314                 c->guard_interval = GUARD_INTERVAL_1_16;
 315                 break;
 316         case 2:
 317                 c->guard_interval = GUARD_INTERVAL_1_8;
 318                 break;
 319         case 3:
 320                 c->guard_interval = GUARD_INTERVAL_1_4;
 321                 break;
 322         }
 323
 324         switch ((buf[0] >> 4) & 7) {
 325         case 0:
 326                 c->hierarchy = HIERARCHY_NONE;
 327                 break;
 328         case 1:
 329                 c->hierarchy = HIERARCHY_1;
 330                 break;
 331         case 2:
 332                 c->hierarchy = HIERARCHY_2;
 333                 break;
 334         case 3:
 335                 c->hierarchy = HIERARCHY_4;
 336                 break;
 337         }
 338
 339         switch ((buf[1] >> 3) & 7) {
 340         case 0:
 341                 c->code_rate_HP = FEC_1_2;
 342                 break;
 343         case 1:
 344                 c->code_rate_HP = FEC_2_3;
 345                 break;
 346         case 2:
 347                 c->code_rate_HP = FEC_3_4;
 348                 break;
 349         case 3:
 350                 c->code_rate_HP = FEC_5_6;
 351                 break;
 352         case 4:
 353                 c->code_rate_HP = FEC_7_8;
 354                 break;
 355         }
 356
 357         switch ((buf[1] >> 0) & 7) {
 358         case 0:
 359                 c->code_rate_LP = FEC_1_2;
 360                 break;
 361         case 1:
 362                 c->code_rate_LP = FEC_2_3;
 363                 break;
 364         case 2:
 365                 c->code_rate_LP = FEC_3_4;
 366                 break;
 367         case 3:
 368                 c->code_rate_LP = FEC_5_6;
 369                 break;
 370         case 4:
 371                 c->code_rate_LP = FEC_7_8;
 372                 break;
 373         }
 374
 375         return 0;
 376 err:
 377         dev_dbg(&client->dev, "failed=%d\n", ret);
 378         return ret;
 379 }
 380
 381 static int rtl2830_read_status(struct dvb_frontend *fe, enum fe_status *status)
 382 {
 383         struct i2c_client *client = fe->demodulator_priv;
 384         struct rtl2830_dev *dev = i2c_get_clientdata(client);
 385         struct dtv_frontend_properties *c = &dev->fe.dtv_property_cache;
 386         int ret, stmp;
 387         unsigned int utmp;
 388         u8 u8tmp, buf[2];
 389
 390         *status = 0;
 391
 392         if (dev->sleeping)
 393                 return 0;
 394
 395         ret = rtl2830_bulk_read(client, 0x351, &u8tmp, 1);
 396         if (ret)
 397                 goto err;
 398
 399         u8tmp = (u8tmp >> 3) & 0x0f; /* [6:3] */
 400         if (u8tmp == 11) {
 401                 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER |
 402                         FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK;
 403         } else if (u8tmp == 10) {
 404                 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER |
 405                         FE_HAS_VITERBI;
 406         }
 407
 408         dev->fe_status = *status;
 409
 410         /* Signal strength */
 411         if (dev->fe_status & FE_HAS_SIGNAL) {
 412                 /* Read IF AGC */
 413                 ret = rtl2830_bulk_read(client, 0x359, buf, 2);
 414                 if (ret)
 415                         goto err;
 416
 417                 stmp = buf[0] << 8 | buf[1] << 0;
 418                 stmp = sign_extend32(stmp, 13);
 419                 utmp = clamp_val(-4 * stmp + 32767, 0x0000, 0xffff);
 420
 421                 dev_dbg(&client->dev, "IF AGC=%d\n", stmp);
 422
 423                 c->strength.stat[0].scale = FE_SCALE_RELATIVE;
 424                 c->strength.stat[0].uvalue = utmp;
 425         } else {
 426                 c->strength.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 427         }
 428
 429         /* CNR */
 430         if (dev->fe_status & FE_HAS_VITERBI) {
 431                 unsigned int hierarchy, constellation;
 432                 #define CONSTELLATION_NUM 3
 433                 #define HIERARCHY_NUM 4
 434                 static const u32 constant[CONSTELLATION_NUM][HIERARCHY_NUM] = {
 435                         {70705899, 70705899, 70705899, 70705899},
 436                         {82433173, 82433173, 87483115, 94445660},
 437                         {92888734, 92888734, 95487525, 99770748},
 438                 };
 439
 440                 ret = rtl2830_bulk_read(client, 0x33c, &u8tmp, 1);
 441                 if (ret)
 442                         goto err;
 443
 444                 constellation = (u8tmp >> 2) & 0x03; /* [3:2] */
 445                 if (constellation > CONSTELLATION_NUM - 1)
 446                         goto err;
 447
 448                 hierarchy = (u8tmp >> 4) & 0x07; /* [6:4] */
 449                 if (hierarchy > HIERARCHY_NUM - 1)
 450                         goto err;
 451
 452                 ret = rtl2830_bulk_read(client, 0x40c, buf, 2);
 453                 if (ret)
 454                         goto err;
 455
 456                 utmp = buf[0] << 8 | buf[1] << 0;
 457                 if (utmp)
 458                         stmp = (constant[constellation][hierarchy] -
 459                                intlog10(utmp)) / ((1 << 24) / 10000);
 460                 else
 461                         stmp = 0;
 462
 463                 dev_dbg(&client->dev, "CNR raw=%u\n", utmp);
 464
 465                 c->cnr.stat[0].scale = FE_SCALE_DECIBEL;
 466                 c->cnr.stat[0].svalue = stmp;
 467         } else {
 468                 c->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 469         }
 470
 471         /* BER */
 472         if (dev->fe_status & FE_HAS_LOCK) {
 473                 ret = rtl2830_bulk_read(client, 0x34e, buf, 2);
 474                 if (ret)
 475                         goto err;
 476
 477                 utmp = buf[0] << 8 | buf[1] << 0;
 478                 dev->post_bit_error += utmp;
 479                 dev->post_bit_count += 1000000;
 480
 481                 dev_dbg(&client->dev, "BER errors=%u total=1000000\n", utmp);
 482
 483                 c->post_bit_error.stat[0].scale = FE_SCALE_COUNTER;
 484                 c->post_bit_error.stat[0].uvalue = dev->post_bit_error;
 485                 c->post_bit_count.stat[0].scale = FE_SCALE_COUNTER;
 486                 c->post_bit_count.stat[0].uvalue = dev->post_bit_count;
 487         } else {
 488                 c->post_bit_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 489                 c->post_bit_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 490         }
 491
 492
 493         return ret;
 494 err:
 495         dev_dbg(&client->dev, "failed=%d\n", ret);
 496         return ret;
 497 }
 498
 499 static int rtl2830_read_snr(struct dvb_frontend *fe, u16 *snr)
 500 {
 501         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 502
 503         if (c->cnr.stat[0].scale == FE_SCALE_DECIBEL)
 504                 *snr = div_s64(c->cnr.stat[0].svalue, 100);
 505         else
 506                 *snr = 0;
 507
 508         return 0;
 509 }
 510
 511 static int rtl2830_read_ber(struct dvb_frontend *fe, u32 *ber)
 512 {
 513         struct i2c_client *client = fe->demodulator_priv;
 514         struct rtl2830_dev *dev = i2c_get_clientdata(client);
 515
 516         *ber = (dev->post_bit_error - dev->post_bit_error_prev);
 517         dev->post_bit_error_prev = dev->post_bit_error;
 518
 519         return 0;
 520 }
 521
 522 static int rtl2830_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
 523 {
 524         *ucblocks = 0;
 525
 526         return 0;
 527 }
 528
 529 static int rtl2830_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
 530 {
 531         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 532
 533         if (c->strength.stat[0].scale == FE_SCALE_RELATIVE)
 534                 *strength = c->strength.stat[0].uvalue;
 535         else
 536                 *strength = 0;
 537
 538         return 0;
 539 }
 540
 541 static const struct dvb_frontend_ops rtl2830_ops = {
 542         .delsys = {SYS_DVBT},
 543         .info = {
 544                 .name = "Realtek RTL2830 (DVB-T)",
 545                 .caps = FE_CAN_FEC_1_2 |
 546                         FE_CAN_FEC_2_3 |
 547                         FE_CAN_FEC_3_4 |
 548                         FE_CAN_FEC_5_6 |
 549                         FE_CAN_FEC_7_8 |
 550                         FE_CAN_FEC_AUTO |
 551                         FE_CAN_QPSK |
 552                         FE_CAN_QAM_16 |
 553                         FE_CAN_QAM_64 |
 554                         FE_CAN_QAM_AUTO |
 555                         FE_CAN_TRANSMISSION_MODE_AUTO |
 556                         FE_CAN_GUARD_INTERVAL_AUTO |
 557                         FE_CAN_HIERARCHY_AUTO |
 558                         FE_CAN_RECOVER |
 559                         FE_CAN_MUTE_TS
 560         },
 561
 562         .init = rtl2830_init,
 563         .sleep = rtl2830_sleep,
 564
 565         .get_tune_settings = rtl2830_get_tune_settings,
 566
 567         .set_frontend = rtl2830_set_frontend,
 568         .get_frontend = rtl2830_get_frontend,
 569
 570         .read_status = rtl2830_read_status,
 571         .read_snr = rtl2830_read_snr,
 572         .read_ber = rtl2830_read_ber,
 573         .read_ucblocks = rtl2830_read_ucblocks,
 574         .read_signal_strength = rtl2830_read_signal_strength,
 575 };
 576
 577 static int rtl2830_pid_filter_ctrl(struct dvb_frontend *fe, int onoff)
 578 {
 579         struct i2c_client *client = fe->demodulator_priv;
 580         int ret;
 581         u8 u8tmp;
 582
 583         dev_dbg(&client->dev, "onoff=%d\n", onoff);
 584
 585         /* enable / disable PID filter */
 586         if (onoff)
 587                 u8tmp = 0x80;
 588         else
 589                 u8tmp = 0x00;
 590
 591         ret = rtl2830_update_bits(client, 0x061, 0x80, u8tmp);
 592         if (ret)
 593                 goto err;
 594
 595         return 0;
 596 err:
 597         dev_dbg(&client->dev, "failed=%d\n", ret);
 598         return ret;
 599 }
 600
 601 static int rtl2830_pid_filter(struct dvb_frontend *fe, u8 index, u16 pid, int onoff)
 602 {
 603         struct i2c_client *client = fe->demodulator_priv;
 604         struct rtl2830_dev *dev = i2c_get_clientdata(client);
 605         int ret;
 606         u8 buf[4];
 607
 608         dev_dbg(&client->dev, "index=%d pid=%04x onoff=%d\n",
 609                 index, pid, onoff);
 610
 611         /* skip invalid PIDs (0x2000) */
 612         if (pid > 0x1fff || index > 32)
 613                 return 0;
 614
 615         if (onoff)
 616                 set_bit(index, &dev->filters);
 617         else
 618                 clear_bit(index, &dev->filters);
 619
 620         /* enable / disable PIDs */
 621         buf[0] = (dev->filters >>  0) & 0xff;
 622         buf[1] = (dev->filters >>  8) & 0xff;
 623         buf[2] = (dev->filters >> 16) & 0xff;
 624         buf[3] = (dev->filters >> 24) & 0xff;
 625         ret = rtl2830_bulk_write(client, 0x062, buf, 4);
 626         if (ret)
 627                 goto err;
 628
 629         /* add PID */
 630         buf[0] = (pid >> 8) & 0xff;
 631         buf[1] = (pid >> 0) & 0xff;
 632         ret = rtl2830_bulk_write(client, 0x066 + 2 * index, buf, 2);
 633         if (ret)
 634                 goto err;
 635
 636         return 0;
 637 err:
 638         dev_dbg(&client->dev, "failed=%d\n", ret);
 639         return ret;
 640 }
 641
 642 /*
 643  * I2C gate/mux/repeater logic
 644  * We must use unlocked __i2c_transfer() here (through regmap) because of I2C
 645  * adapter lock is already taken by tuner driver.
 646  * Gate is closed automatically after single I2C transfer.
 647  */
 648 static int rtl2830_select(struct i2c_mux_core *muxc, u32 chan_id)
 649 {
 650         struct i2c_client *client = i2c_mux_priv(muxc);
 651         struct rtl2830_dev *dev = i2c_get_clientdata(client);
 652         int ret;
 653
 654         dev_dbg(&client->dev, "\n");
 655
 656         /* open I2C repeater for 1 transfer, closes automatically */
 657         /* XXX: regmap_update_bits() does not lock I2C adapter */
 658         ret = regmap_update_bits(dev->regmap, 0x101, 0x08, 0x08);
 659         if (ret)
 660                 goto err;
 661
 662         return 0;
 663 err:
 664         dev_dbg(&client->dev, "failed=%d\n", ret);
 665         return ret;
 666 }
 667
 668 static struct dvb_frontend *rtl2830_get_dvb_frontend(struct i2c_client *client)
 669 {
 670         struct rtl2830_dev *dev = i2c_get_clientdata(client);
 671
 672         dev_dbg(&client->dev, "\n");
 673
 674         return &dev->fe;
 675 }
 676
 677 static struct i2c_adapter *rtl2830_get_i2c_adapter(struct i2c_client *client)
 678 {
 679         struct rtl2830_dev *dev = i2c_get_clientdata(client);
 680
 681         dev_dbg(&client->dev, "\n");
 682
 683         return dev->muxc->adapter[0];
 684 }
 685
 686 /*
 687  * We implement own I2C access routines for regmap in order to get manual access
 688  * to I2C adapter lock, which is needed for I2C mux adapter.
 689  */
 690 static int rtl2830_regmap_read(void *context, const void *reg_buf,
 691                                size_t reg_size, void *val_buf, size_t val_size)
 692 {
 693         struct i2c_client *client = context;
 694         int ret;
 695         struct i2c_msg msg[2] = {
 696                 {
 697                         .addr = client->addr,
 698                         .flags = 0,
 699                         .len = reg_size,
 700                         .buf = (u8 *)reg_buf,
 701                 }, {
 702                         .addr = client->addr,
 703                         .flags = I2C_M_RD,
 704                         .len = val_size,
 705                         .buf = val_buf,
 706                 }
 707         };
 708
 709         ret = __i2c_transfer(client->adapter, msg, 2);
 710         if (ret != 2) {
 711                 dev_warn(&client->dev, "i2c reg read failed %d\n", ret);
 712                 if (ret >= 0)
 713                         ret = -EREMOTEIO;
 714                 return ret;
 715         }
 716         return 0;
 717 }
 718
 719 static int rtl2830_regmap_write(void *context, const void *data, size_t count)
 720 {
 721         struct i2c_client *client = context;
 722         int ret;
 723         struct i2c_msg msg[1] = {
 724                 {
 725                         .addr = client->addr,
 726                         .flags = 0,
 727                         .len = count,
 728                         .buf = (u8 *)data,
 729                 }
 730         };
 731
 732         ret = __i2c_transfer(client->adapter, msg, 1);
 733         if (ret != 1) {
 734                 dev_warn(&client->dev, "i2c reg write failed %d\n", ret);
 735                 if (ret >= 0)
 736                         ret = -EREMOTEIO;
 737                 return ret;
 738         }
 739         return 0;
 740 }
 741
 742 static int rtl2830_regmap_gather_write(void *context, const void *reg,
 743                                        size_t reg_len, const void *val,
 744                                        size_t val_len)
 745 {
 746         struct i2c_client *client = context;
 747         int ret;
 748         u8 buf[256];
 749         struct i2c_msg msg[1] = {
 750                 {
 751                         .addr = client->addr,
 752                         .flags = 0,
 753                         .len = 1 + val_len,
 754                         .buf = buf,
 755                 }
 756         };
 757
 758         buf[0] = *(u8 const *)reg;
 759         memcpy(&buf[1], val, val_len);
 760
 761         ret = __i2c_transfer(client->adapter, msg, 1);
 762         if (ret != 1) {
 763                 dev_warn(&client->dev, "i2c reg write failed %d\n", ret);
 764                 if (ret >= 0)
 765                         ret = -EREMOTEIO;
 766                 return ret;
 767         }
 768         return 0;
 769 }
 770
 771 static int rtl2830_probe(struct i2c_client *client,
 772                          const struct i2c_device_id *id)
 773 {
 774         struct rtl2830_platform_data *pdata = client->dev.platform_data;
 775         struct rtl2830_dev *dev;
 776         int ret;
 777         u8 u8tmp;
 778         static const struct regmap_bus regmap_bus = {
 779                 .read = rtl2830_regmap_read,
 780                 .write = rtl2830_regmap_write,
 781                 .gather_write = rtl2830_regmap_gather_write,
 782                 .val_format_endian_default = REGMAP_ENDIAN_NATIVE,
 783         };
 784         static const struct regmap_range_cfg regmap_range_cfg[] = {
 785                 {
 786                         .selector_reg     = 0x00,
 787                         .selector_mask    = 0xff,
 788                         .selector_shift   = 0,
 789                         .window_start     = 0,
 790                         .window_len       = 0x100,
 791                         .range_min        = 0 * 0x100,
 792                         .range_max        = 5 * 0x100,
 793                 },
 794         };
 795         static const struct regmap_config regmap_config = {
 796                 .reg_bits    =  8,
 797                 .val_bits    =  8,
 798                 .max_register = 5 * 0x100,
 799                 .ranges = regmap_range_cfg,
 800                 .num_ranges = ARRAY_SIZE(regmap_range_cfg),
 801         };
 802
 803         dev_dbg(&client->dev, "\n");
 804
 805         if (pdata == NULL) {
 806                 ret = -EINVAL;
 807                 goto err;
 808         }
 809
 810         /* allocate memory for the internal state */
 811         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
 812         if (dev == NULL) {
 813                 ret = -ENOMEM;
 814                 goto err;
 815         }
 816
 817         /* setup the state */
 818         i2c_set_clientdata(client, dev);
 819         dev->client = client;
 820         dev->pdata = client->dev.platform_data;
 821         dev->sleeping = true;
 822         dev->regmap = regmap_init(&client->dev, &regmap_bus, client,
 823                                   &regmap_config);
 824         if (IS_ERR(dev->regmap)) {
 825                 ret = PTR_ERR(dev->regmap);
 826                 goto err_kfree;
 827         }
 828
 829         /* check if the demod is there */
 830         ret = rtl2830_bulk_read(client, 0x000, &u8tmp, 1);
 831         if (ret)
 832                 goto err_regmap_exit;
 833
 834         /* create muxed i2c adapter for tuner */
 835         dev->muxc = i2c_mux_alloc(client->adapter, &client->dev, 1, 0, 0,
 836                                   rtl2830_select, NULL);
 837         if (!dev->muxc) {
 838                 ret = -ENOMEM;
 839                 goto err_regmap_exit;
 840         }
 841         dev->muxc->priv = client;
 842         ret = i2c_mux_add_adapter(dev->muxc, 0, 0, 0);
 843         if (ret)
 844                 goto err_regmap_exit;
 845
 846         /* create dvb frontend */
 847         memcpy(&dev->fe.ops, &rtl2830_ops, sizeof(dev->fe.ops));
 848         dev->fe.demodulator_priv = client;
 849
 850         /* setup callbacks */
 851         pdata->get_dvb_frontend = rtl2830_get_dvb_frontend;
 852         pdata->get_i2c_adapter = rtl2830_get_i2c_adapter;
 853         pdata->pid_filter = rtl2830_pid_filter;
 854         pdata->pid_filter_ctrl = rtl2830_pid_filter_ctrl;
 855
 856         dev_info(&client->dev, "Realtek RTL2830 successfully attached\n");
 857
 858         return 0;
 859 err_regmap_exit:
 860         regmap_exit(dev->regmap);
 861 err_kfree:
 862         kfree(dev);
 863 err:
 864         dev_dbg(&client->dev, "failed=%d\n", ret);
 865         return ret;
 866 }
 867
 868 static int rtl2830_remove(struct i2c_client *client)
 869 {
 870         struct rtl2830_dev *dev = i2c_get_clientdata(client);
 871
 872         dev_dbg(&client->dev, "\n");
 873
 874         i2c_mux_del_adapters(dev->muxc);
 875         regmap_exit(dev->regmap);
 876         kfree(dev);
 877
 878         return 0;
 879 }
 880
 881 static const struct i2c_device_id rtl2830_id_table[] = {
 882         {"rtl2830", 0},
 883         {}
 884 };
 885 MODULE_DEVICE_TABLE(i2c, rtl2830_id_table);
 886
 887 static struct i2c_driver rtl2830_driver = {
 888         .driver = {
 889                 .name                   = "rtl2830",
 890                 .suppress_bind_attrs    = true,
 891         },
 892         .probe          = rtl2830_probe,
 893         .remove         = rtl2830_remove,
 894         .id_table       = rtl2830_id_table,
 895 };
 896
 897 module_i2c_driver(rtl2830_driver);
 898
 899 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
 900 MODULE_DESCRIPTION("Realtek RTL2830 DVB-T demodulator driver");
 901 MODULE_LICENSE("GPL");