drivers/media/dvb-frontends/rtl2830.c

   1 /*
   2  * Realtek RTL2830 DVB-T demodulator driver
   3  *
   4  * Copyright (C) 2011 Antti Palosaari <crope@iki.fi>
   5  *
   6  *    This program is free software; you can redistribute it and/or modify
   7  *    it under the terms of the GNU General Public License as published by
   8  *    the Free Software Foundation; either version 2 of the License, or
   9  *    (at your option) any later version.
  10  *
  11  *    This program is distributed in the hope that it will be useful,
  12  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *    GNU General Public License for more details.
  15  *
  16  *    You should have received a copy of the GNU General Public License along
  17  *    with this program; if not, write to the Free Software Foundation, Inc.,
  18  *    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  */
  20
  21
  22 /*
  23  * Driver implements own I2C-adapter for tuner I2C access. That's since chip
  24  * have unusual I2C-gate control which closes gate automatically after each
  25  * I2C transfer. Using own I2C adapter we can workaround that.
  26  */
  27
  28 #include "rtl2830_priv.h"
  29
  30 /* Max transfer size done by I2C transfer functions */
  31 #define MAX_XFER_SIZE  64
  32
  33 /* write multiple hardware registers */
  34 static int rtl2830_wr(struct rtl2830_priv *priv, u8 reg, const u8 *val, int len)
  35 {
  36         int ret;
  37         u8 buf[MAX_XFER_SIZE];
  38         struct i2c_msg msg[1] = {
  39                 {
  40                         .addr = priv->cfg.i2c_addr,
  41                         .flags = 0,
  42                         .len = 1 + len,
  43                         .buf = buf,
  44                 }
  45         };
  46
  47         if (1 + len > sizeof(buf)) {
  48                 dev_warn(&priv->i2c->dev,
  49                          "%s: i2c wr reg=%04x: len=%d is too big!\n",
  50                          KBUILD_MODNAME, reg, len);
  51                 return -EINVAL;
  52         }
  53
  54         buf[0] = reg;
  55         memcpy(&buf[1], val, len);
  56
  57         ret = i2c_transfer(priv->i2c, msg, 1);
  58         if (ret == 1) {
  59                 ret = 0;
  60         } else {
  61                 dev_warn(&priv->i2c->dev, "%s: i2c wr failed=%d reg=%02x " \
  62                                 "len=%d\n", KBUILD_MODNAME, ret, reg, len);
  63                 ret = -EREMOTEIO;
  64         }
  65         return ret;
  66 }
  67
  68 /* read multiple hardware registers */
  69 static int rtl2830_rd(struct rtl2830_priv *priv, u8 reg, u8 *val, int len)
  70 {
  71         int ret;
  72         struct i2c_msg msg[2] = {
  73                 {
  74                         .addr = priv->cfg.i2c_addr,
  75                         .flags = 0,
  76                         .len = 1,
  77                         .buf = &reg,
  78                 }, {
  79                         .addr = priv->cfg.i2c_addr,
  80                         .flags = I2C_M_RD,
  81                         .len = len,
  82                         .buf = val,
  83                 }
  84         };
  85
  86         ret = i2c_transfer(priv->i2c, msg, 2);
  87         if (ret == 2) {
  88                 ret = 0;
  89         } else {
  90                 dev_warn(&priv->i2c->dev, "%s: i2c rd failed=%d reg=%02x " \
  91                                 "len=%d\n", KBUILD_MODNAME, ret, reg, len);
  92                 ret = -EREMOTEIO;
  93         }
  94         return ret;
  95 }
  96
  97 /* write multiple registers */
  98 static int rtl2830_wr_regs(struct rtl2830_priv *priv, u16 reg, const u8 *val,
  99                 int len)
 100 {
 101         int ret;
 102         u8 reg2 = (reg >> 0) & 0xff;
 103         u8 page = (reg >> 8) & 0xff;
 104
 105         /* switch bank if needed */
 106         if (page != priv->page) {
 107                 ret = rtl2830_wr(priv, 0x00, &page, 1);
 108                 if (ret)
 109                         return ret;
 110
 111                 priv->page = page;
 112         }
 113
 114         return rtl2830_wr(priv, reg2, val, len);
 115 }
 116
 117 /* read multiple registers */
 118 static int rtl2830_rd_regs(struct rtl2830_priv *priv, u16 reg, u8 *val, int len)
 119 {
 120         int ret;
 121         u8 reg2 = (reg >> 0) & 0xff;
 122         u8 page = (reg >> 8) & 0xff;
 123
 124         /* switch bank if needed */
 125         if (page != priv->page) {
 126                 ret = rtl2830_wr(priv, 0x00, &page, 1);
 127                 if (ret)
 128                         return ret;
 129
 130                 priv->page = page;
 131         }
 132
 133         return rtl2830_rd(priv, reg2, val, len);
 134 }
 135
 136 /* read single register */
 137 static int rtl2830_rd_reg(struct rtl2830_priv *priv, u16 reg, u8 *val)
 138 {
 139         return rtl2830_rd_regs(priv, reg, val, 1);
 140 }
 141
 142 /* write single register with mask */
 143 static int rtl2830_wr_reg_mask(struct rtl2830_priv *priv, u16 reg, u8 val, u8 mask)
 144 {
 145         int ret;
 146         u8 tmp;
 147
 148         /* no need for read if whole reg is written */
 149         if (mask != 0xff) {
 150                 ret = rtl2830_rd_regs(priv, reg, &tmp, 1);
 151                 if (ret)
 152                         return ret;
 153
 154                 val &= mask;
 155                 tmp &= ~mask;
 156                 val |= tmp;
 157         }
 158
 159         return rtl2830_wr_regs(priv, reg, &val, 1);
 160 }
 161
 162 /* read single register with mask */
 163 static int rtl2830_rd_reg_mask(struct rtl2830_priv *priv, u16 reg, u8 *val, u8 mask)
 164 {
 165         int ret, i;
 166         u8 tmp;
 167
 168         ret = rtl2830_rd_regs(priv, reg, &tmp, 1);
 169         if (ret)
 170                 return ret;
 171
 172         tmp &= mask;
 173
 174         /* find position of the first bit */
 175         for (i = 0; i < 8; i++) {
 176                 if ((mask >> i) & 0x01)
 177                         break;
 178         }
 179         *val = tmp >> i;
 180
 181         return 0;
 182 }
 183
 184 static int rtl2830_init(struct dvb_frontend *fe)
 185 {
 186         struct rtl2830_priv *priv = fe->demodulator_priv;
 187         int ret, i;
 188         struct rtl2830_reg_val_mask tab[] = {
 189                 { 0x00d, 0x01, 0x03 },
 190                 { 0x00d, 0x10, 0x10 },
 191                 { 0x104, 0x00, 0x1e },
 192                 { 0x105, 0x80, 0x80 },
 193                 { 0x110, 0x02, 0x03 },
 194                 { 0x110, 0x08, 0x0c },
 195                 { 0x17b, 0x00, 0x40 },
 196                 { 0x17d, 0x05, 0x0f },
 197                 { 0x17d, 0x50, 0xf0 },
 198                 { 0x18c, 0x08, 0x0f },
 199                 { 0x18d, 0x00, 0xc0 },
 200                 { 0x188, 0x05, 0x0f },
 201                 { 0x189, 0x00, 0xfc },
 202                 { 0x2d5, 0x02, 0x02 },
 203                 { 0x2f1, 0x02, 0x06 },
 204                 { 0x2f1, 0x20, 0xf8 },
 205                 { 0x16d, 0x00, 0x01 },
 206                 { 0x1a6, 0x00, 0x80 },
 207                 { 0x106, priv->cfg.vtop, 0x3f },
 208                 { 0x107, priv->cfg.krf, 0x3f },
 209                 { 0x112, 0x28, 0xff },
 210                 { 0x103, priv->cfg.agc_targ_val, 0xff },
 211                 { 0x00a, 0x02, 0x07 },
 212                 { 0x140, 0x0c, 0x3c },
 213                 { 0x140, 0x40, 0xc0 },
 214                 { 0x15b, 0x05, 0x07 },
 215                 { 0x15b, 0x28, 0x38 },
 216                 { 0x15c, 0x05, 0x07 },
 217                 { 0x15c, 0x28, 0x38 },
 218                 { 0x115, priv->cfg.spec_inv, 0x01 },
 219                 { 0x16f, 0x01, 0x07 },
 220                 { 0x170, 0x18, 0x38 },
 221                 { 0x172, 0x0f, 0x0f },
 222                 { 0x173, 0x08, 0x38 },
 223                 { 0x175, 0x01, 0x07 },
 224                 { 0x176, 0x00, 0xc0 },
 225         };
 226
 227         for (i = 0; i < ARRAY_SIZE(tab); i++) {
 228                 ret = rtl2830_wr_reg_mask(priv, tab[i].reg, tab[i].val,
 229                         tab[i].mask);
 230                 if (ret)
 231                         goto err;
 232         }
 233
 234         ret = rtl2830_wr_regs(priv, 0x18f, "\x28\x00", 2);
 235         if (ret)
 236                 goto err;
 237
 238         ret = rtl2830_wr_regs(priv, 0x195,
 239                 "\x04\x06\x0a\x12\x0a\x12\x1e\x28", 8);
 240         if (ret)
 241                 goto err;
 242
 243         /* TODO: spec init */
 244
 245         /* soft reset */
 246         ret = rtl2830_wr_reg_mask(priv, 0x101, 0x04, 0x04);
 247         if (ret)
 248                 goto err;
 249
 250         ret = rtl2830_wr_reg_mask(priv, 0x101, 0x00, 0x04);
 251         if (ret)
 252                 goto err;
 253
 254         priv->sleeping = false;
 255
 256         return ret;
 257 err:
 258         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 259         return ret;
 260 }
 261
 262 static int rtl2830_sleep(struct dvb_frontend *fe)
 263 {
 264         struct rtl2830_priv *priv = fe->demodulator_priv;
 265         priv->sleeping = true;
 266         return 0;
 267 }
 268
 269 static int rtl2830_get_tune_settings(struct dvb_frontend *fe,
 270         struct dvb_frontend_tune_settings *s)
 271 {
 272         s->min_delay_ms = 500;
 273         s->step_size = fe->ops.info.frequency_stepsize * 2;
 274         s->max_drift = (fe->ops.info.frequency_stepsize * 2) + 1;
 275
 276         return 0;
 277 }
 278
 279 static int rtl2830_set_frontend(struct dvb_frontend *fe)
 280 {
 281         struct rtl2830_priv *priv = fe->demodulator_priv;
 282         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 283         int ret, i;
 284         u64 num;
 285         u8 buf[3], tmp;
 286         u32 if_ctl, if_frequency;
 287         static const u8 bw_params1[3][34] = {
 288                 {
 289                 0x1f, 0xf0, 0x1f, 0xf0, 0x1f, 0xfa, 0x00, 0x17, 0x00, 0x41,
 290                 0x00, 0x64, 0x00, 0x67, 0x00, 0x38, 0x1f, 0xde, 0x1f, 0x7a,
 291                 0x1f, 0x47, 0x1f, 0x7c, 0x00, 0x30, 0x01, 0x4b, 0x02, 0x82,
 292                 0x03, 0x73, 0x03, 0xcf, /* 6 MHz */
 293                 }, {
 294                 0x1f, 0xfa, 0x1f, 0xda, 0x1f, 0xc1, 0x1f, 0xb3, 0x1f, 0xca,
 295                 0x00, 0x07, 0x00, 0x4d, 0x00, 0x6d, 0x00, 0x40, 0x1f, 0xca,
 296                 0x1f, 0x4d, 0x1f, 0x2a, 0x1f, 0xb2, 0x00, 0xec, 0x02, 0x7e,
 297                 0x03, 0xd0, 0x04, 0x53, /* 7 MHz */
 298                 }, {
 299                 0x00, 0x10, 0x00, 0x0e, 0x1f, 0xf7, 0x1f, 0xc9, 0x1f, 0xa0,
 300                 0x1f, 0xa6, 0x1f, 0xec, 0x00, 0x4e, 0x00, 0x7d, 0x00, 0x3a,
 301                 0x1f, 0x98, 0x1f, 0x10, 0x1f, 0x40, 0x00, 0x75, 0x02, 0x5f,
 302                 0x04, 0x24, 0x04, 0xdb, /* 8 MHz */
 303                 },
 304         };
 305         static const u8 bw_params2[3][6] = {
 306                 {0xc3, 0x0c, 0x44, 0x33, 0x33, 0x30}, /* 6 MHz */
 307                 {0xb8, 0xe3, 0x93, 0x99, 0x99, 0x98}, /* 7 MHz */
 308                 {0xae, 0xba, 0xf3, 0x26, 0x66, 0x64}, /* 8 MHz */
 309         };
 310
 311         dev_dbg(&priv->i2c->dev,
 312                         "%s: frequency=%d bandwidth_hz=%d inversion=%d\n",
 313                         __func__, c->frequency, c->bandwidth_hz, c->inversion);
 314
 315         /* program tuner */
 316         if (fe->ops.tuner_ops.set_params)
 317                 fe->ops.tuner_ops.set_params(fe);
 318
 319         switch (c->bandwidth_hz) {
 320         case 6000000:
 321                 i = 0;
 322                 break;
 323         case 7000000:
 324                 i = 1;
 325                 break;
 326         case 8000000:
 327                 i = 2;
 328                 break;
 329         default:
 330                 dev_dbg(&priv->i2c->dev, "%s: invalid bandwidth\n", __func__);
 331                 return -EINVAL;
 332         }
 333
 334         ret = rtl2830_wr_reg_mask(priv, 0x008, i << 1, 0x06);
 335         if (ret)
 336                 goto err;
 337
 338         /* program if frequency */
 339         if (fe->ops.tuner_ops.get_if_frequency)
 340                 ret = fe->ops.tuner_ops.get_if_frequency(fe, &if_frequency);
 341         else
 342                 ret = -EINVAL;
 343
 344         if (ret < 0)
 345                 goto err;
 346
 347         num = if_frequency % priv->cfg.xtal;
 348         num *= 0x400000;
 349         num = div_u64(num, priv->cfg.xtal);
 350         num = -num;
 351         if_ctl = num & 0x3fffff;
 352         dev_dbg(&priv->i2c->dev, "%s: if_frequency=%d if_ctl=%08x\n",
 353                         __func__, if_frequency, if_ctl);
 354
 355         ret = rtl2830_rd_reg_mask(priv, 0x119, &tmp, 0xc0); /* b[7:6] */
 356         if (ret)
 357                 goto err;
 358
 359         buf[0] = tmp << 6;
 360         buf[0] |= (if_ctl >> 16) & 0x3f;
 361         buf[1] = (if_ctl >>  8) & 0xff;
 362         buf[2] = (if_ctl >>  0) & 0xff;
 363
 364         ret = rtl2830_wr_regs(priv, 0x119, buf, 3);
 365         if (ret)
 366                 goto err;
 367
 368         /* 1/2 split I2C write */
 369         ret = rtl2830_wr_regs(priv, 0x11c, &bw_params1[i][0], 17);
 370         if (ret)
 371                 goto err;
 372
 373         /* 2/2 split I2C write */
 374         ret = rtl2830_wr_regs(priv, 0x12d, &bw_params1[i][17], 17);
 375         if (ret)
 376                 goto err;
 377
 378         ret = rtl2830_wr_regs(priv, 0x19d, bw_params2[i], 6);
 379         if (ret)
 380                 goto err;
 381
 382         return ret;
 383 err:
 384         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 385         return ret;
 386 }
 387
 388 static int rtl2830_get_frontend(struct dvb_frontend *fe)
 389 {
 390         struct rtl2830_priv *priv = fe->demodulator_priv;
 391         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 392         int ret;
 393         u8 buf[3];
 394
 395         if (priv->sleeping)
 396                 return 0;
 397
 398         ret = rtl2830_rd_regs(priv, 0x33c, buf, 2);
 399         if (ret)
 400                 goto err;
 401
 402         ret = rtl2830_rd_reg(priv, 0x351, &buf[2]);
 403         if (ret)
 404                 goto err;
 405
 406         dev_dbg(&priv->i2c->dev, "%s: TPS=%*ph\n", __func__, 3, buf);
 407
 408         switch ((buf[0] >> 2) & 3) {
 409         case 0:
 410                 c->modulation = QPSK;
 411                 break;
 412         case 1:
 413                 c->modulation = QAM_16;
 414                 break;
 415         case 2:
 416                 c->modulation = QAM_64;
 417                 break;
 418         }
 419
 420         switch ((buf[2] >> 2) & 1) {
 421         case 0:
 422                 c->transmission_mode = TRANSMISSION_MODE_2K;
 423                 break;
 424         case 1:
 425                 c->transmission_mode = TRANSMISSION_MODE_8K;
 426         }
 427
 428         switch ((buf[2] >> 0) & 3) {
 429         case 0:
 430                 c->guard_interval = GUARD_INTERVAL_1_32;
 431                 break;
 432         case 1:
 433                 c->guard_interval = GUARD_INTERVAL_1_16;
 434                 break;
 435         case 2:
 436                 c->guard_interval = GUARD_INTERVAL_1_8;
 437                 break;
 438         case 3:
 439                 c->guard_interval = GUARD_INTERVAL_1_4;
 440                 break;
 441         }
 442
 443         switch ((buf[0] >> 4) & 7) {
 444         case 0:
 445                 c->hierarchy = HIERARCHY_NONE;
 446                 break;
 447         case 1:
 448                 c->hierarchy = HIERARCHY_1;
 449                 break;
 450         case 2:
 451                 c->hierarchy = HIERARCHY_2;
 452                 break;
 453         case 3:
 454                 c->hierarchy = HIERARCHY_4;
 455                 break;
 456         }
 457
 458         switch ((buf[1] >> 3) & 7) {
 459         case 0:
 460                 c->code_rate_HP = FEC_1_2;
 461                 break;
 462         case 1:
 463                 c->code_rate_HP = FEC_2_3;
 464                 break;
 465         case 2:
 466                 c->code_rate_HP = FEC_3_4;
 467                 break;
 468         case 3:
 469                 c->code_rate_HP = FEC_5_6;
 470                 break;
 471         case 4:
 472                 c->code_rate_HP = FEC_7_8;
 473                 break;
 474         }
 475
 476         switch ((buf[1] >> 0) & 7) {
 477         case 0:
 478                 c->code_rate_LP = FEC_1_2;
 479                 break;
 480         case 1:
 481                 c->code_rate_LP = FEC_2_3;
 482                 break;
 483         case 2:
 484                 c->code_rate_LP = FEC_3_4;
 485                 break;
 486         case 3:
 487                 c->code_rate_LP = FEC_5_6;
 488                 break;
 489         case 4:
 490                 c->code_rate_LP = FEC_7_8;
 491                 break;
 492         }
 493
 494         return 0;
 495 err:
 496         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 497         return ret;
 498 }
 499
 500 static int rtl2830_read_status(struct dvb_frontend *fe, fe_status_t *status)
 501 {
 502         struct rtl2830_priv *priv = fe->demodulator_priv;
 503         int ret;
 504         u8 tmp;
 505         *status = 0;
 506
 507         if (priv->sleeping)
 508                 return 0;
 509
 510         ret = rtl2830_rd_reg_mask(priv, 0x351, &tmp, 0x78); /* [6:3] */
 511         if (ret)
 512                 goto err;
 513
 514         if (tmp == 11) {
 515                 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER |
 516                         FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK;
 517         } else if (tmp == 10) {
 518                 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER |
 519                         FE_HAS_VITERBI;
 520         }
 521
 522         return ret;
 523 err:
 524         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 525         return ret;
 526 }
 527
 528 static int rtl2830_read_snr(struct dvb_frontend *fe, u16 *snr)
 529 {
 530         struct rtl2830_priv *priv = fe->demodulator_priv;
 531         int ret, hierarchy, constellation;
 532         u8 buf[2], tmp;
 533         u16 tmp16;
 534 #define CONSTELLATION_NUM 3
 535 #define HIERARCHY_NUM 4
 536         static const u32 snr_constant[CONSTELLATION_NUM][HIERARCHY_NUM] = {
 537                 { 70705899, 70705899, 70705899, 70705899 },
 538                 { 82433173, 82433173, 87483115, 94445660 },
 539                 { 92888734, 92888734, 95487525, 99770748 },
 540         };
 541
 542         if (priv->sleeping)
 543                 return 0;
 544
 545         /* reports SNR in resolution of 0.1 dB */
 546
 547         ret = rtl2830_rd_reg(priv, 0x33c, &tmp);
 548         if (ret)
 549                 goto err;
 550
 551         constellation = (tmp >> 2) & 0x03; /* [3:2] */
 552         if (constellation > CONSTELLATION_NUM - 1)
 553                 goto err;
 554
 555         hierarchy = (tmp >> 4) & 0x07; /* [6:4] */
 556         if (hierarchy > HIERARCHY_NUM - 1)
 557                 goto err;
 558
 559         ret = rtl2830_rd_regs(priv, 0x40c, buf, 2);
 560         if (ret)
 561                 goto err;
 562
 563         tmp16 = buf[0] << 8 | buf[1];
 564
 565         if (tmp16)
 566                 *snr = (snr_constant[constellation][hierarchy] -
 567                                 intlog10(tmp16)) / ((1 << 24) / 100);
 568         else
 569                 *snr = 0;
 570
 571         return 0;
 572 err:
 573         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 574         return ret;
 575 }
 576
 577 static int rtl2830_read_ber(struct dvb_frontend *fe, u32 *ber)
 578 {
 579         struct rtl2830_priv *priv = fe->demodulator_priv;
 580         int ret;
 581         u8 buf[2];
 582
 583         if (priv->sleeping)
 584                 return 0;
 585
 586         ret = rtl2830_rd_regs(priv, 0x34e, buf, 2);
 587         if (ret)
 588                 goto err;
 589
 590         *ber = buf[0] << 8 | buf[1];
 591
 592         return 0;
 593 err:
 594         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 595         return ret;
 596 }
 597
 598 static int rtl2830_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
 599 {
 600         *ucblocks = 0;
 601         return 0;
 602 }
 603
 604 static int rtl2830_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
 605 {
 606         struct rtl2830_priv *priv = fe->demodulator_priv;
 607         int ret;
 608         u8 buf[2];
 609         u16 if_agc_raw, if_agc;
 610
 611         if (priv->sleeping)
 612                 return 0;
 613
 614         ret = rtl2830_rd_regs(priv, 0x359, buf, 2);
 615         if (ret)
 616                 goto err;
 617
 618         if_agc_raw = (buf[0] << 8 | buf[1]) & 0x3fff;
 619
 620         if (if_agc_raw & (1 << 9))
 621                 if_agc = -(~(if_agc_raw - 1) & 0x1ff);
 622         else
 623                 if_agc = if_agc_raw;
 624
 625         *strength = (u8) (55 - if_agc / 182);
 626         *strength |= *strength << 8;
 627
 628         return 0;
 629 err:
 630         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 631         return ret;
 632 }
 633
 634 static struct dvb_frontend_ops rtl2830_ops;
 635
 636 static u32 rtl2830_tuner_i2c_func(struct i2c_adapter *adapter)
 637 {
 638         return I2C_FUNC_I2C;
 639 }
 640
 641 static int rtl2830_tuner_i2c_xfer(struct i2c_adapter *i2c_adap,
 642         struct i2c_msg msg[], int num)
 643 {
 644         struct rtl2830_priv *priv = i2c_get_adapdata(i2c_adap);
 645         int ret;
 646
 647         /* open i2c-gate */
 648         ret = rtl2830_wr_reg_mask(priv, 0x101, 0x08, 0x08);
 649         if (ret)
 650                 goto err;
 651
 652         ret = i2c_transfer(priv->i2c, msg, num);
 653         if (ret < 0)
 654                 dev_warn(&priv->i2c->dev, "%s: tuner i2c failed=%d\n",
 655                         KBUILD_MODNAME, ret);
 656
 657         return ret;
 658 err:
 659         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 660         return ret;
 661 }
 662
 663 static struct i2c_algorithm rtl2830_tuner_i2c_algo = {
 664         .master_xfer   = rtl2830_tuner_i2c_xfer,
 665         .functionality = rtl2830_tuner_i2c_func,
 666 };
 667
 668 struct i2c_adapter *rtl2830_get_tuner_i2c_adapter(struct dvb_frontend *fe)
 669 {
 670         struct rtl2830_priv *priv = fe->demodulator_priv;
 671         return &priv->tuner_i2c_adapter;
 672 }
 673 EXPORT_SYMBOL(rtl2830_get_tuner_i2c_adapter);
 674
 675 static void rtl2830_release(struct dvb_frontend *fe)
 676 {
 677         struct rtl2830_priv *priv = fe->demodulator_priv;
 678
 679         i2c_del_adapter(&priv->tuner_i2c_adapter);
 680         kfree(priv);
 681 }
 682
 683 struct dvb_frontend *rtl2830_attach(const struct rtl2830_config *cfg,
 684         struct i2c_adapter *i2c)
 685 {
 686         struct rtl2830_priv *priv = NULL;
 687         int ret = 0;
 688         u8 tmp;
 689
 690         /* allocate memory for the internal state */
 691         priv = kzalloc(sizeof(struct rtl2830_priv), GFP_KERNEL);
 692         if (priv == NULL)
 693                 goto err;
 694
 695         /* setup the priv */
 696         priv->i2c = i2c;
 697         memcpy(&priv->cfg, cfg, sizeof(struct rtl2830_config));
 698
 699         /* check if the demod is there */
 700         ret = rtl2830_rd_reg(priv, 0x000, &tmp);
 701         if (ret)
 702                 goto err;
 703
 704         /* create dvb_frontend */
 705         memcpy(&priv->fe.ops, &rtl2830_ops, sizeof(struct dvb_frontend_ops));
 706         priv->fe.demodulator_priv = priv;
 707
 708         /* create tuner i2c adapter */
 709         strlcpy(priv->tuner_i2c_adapter.name, "RTL2830 tuner I2C adapter",
 710                 sizeof(priv->tuner_i2c_adapter.name));
 711         priv->tuner_i2c_adapter.algo = &rtl2830_tuner_i2c_algo;
 712         priv->tuner_i2c_adapter.algo_data = NULL;
 713         priv->tuner_i2c_adapter.dev.parent = &i2c->dev;
 714         i2c_set_adapdata(&priv->tuner_i2c_adapter, priv);
 715         if (i2c_add_adapter(&priv->tuner_i2c_adapter) < 0) {
 716                 dev_err(&i2c->dev,
 717                                 "%s: tuner i2c bus could not be initialized\n",
 718                                 KBUILD_MODNAME);
 719                 goto err;
 720         }
 721
 722         priv->sleeping = true;
 723
 724         return &priv->fe;
 725 err:
 726         dev_dbg(&i2c->dev, "%s: failed=%d\n", __func__, ret);
 727         kfree(priv);
 728         return NULL;
 729 }
 730 EXPORT_SYMBOL(rtl2830_attach);
 731
 732 static struct dvb_frontend_ops rtl2830_ops = {
 733         .delsys = { SYS_DVBT },
 734         .info = {
 735                 .name = "Realtek RTL2830 (DVB-T)",
 736                 .caps = FE_CAN_FEC_1_2 |
 737                         FE_CAN_FEC_2_3 |
 738                         FE_CAN_FEC_3_4 |
 739                         FE_CAN_FEC_5_6 |
 740                         FE_CAN_FEC_7_8 |
 741                         FE_CAN_FEC_AUTO |
 742                         FE_CAN_QPSK |
 743                         FE_CAN_QAM_16 |
 744                         FE_CAN_QAM_64 |
 745                         FE_CAN_QAM_AUTO |
 746                         FE_CAN_TRANSMISSION_MODE_AUTO |
 747                         FE_CAN_GUARD_INTERVAL_AUTO |
 748                         FE_CAN_HIERARCHY_AUTO |
 749                         FE_CAN_RECOVER |
 750                         FE_CAN_MUTE_TS
 751         },
 752
 753         .release = rtl2830_release,
 754
 755         .init = rtl2830_init,
 756         .sleep = rtl2830_sleep,
 757
 758         .get_tune_settings = rtl2830_get_tune_settings,
 759
 760         .set_frontend = rtl2830_set_frontend,
 761         .get_frontend = rtl2830_get_frontend,
 762
 763         .read_status = rtl2830_read_status,
 764         .read_snr = rtl2830_read_snr,
 765         .read_ber = rtl2830_read_ber,
 766         .read_ucblocks = rtl2830_read_ucblocks,
 767         .read_signal_strength = rtl2830_read_signal_strength,
 768 };
 769
 770 /*
 771  * I2C gate/repeater logic
 772  * We must use unlocked i2c_transfer() here because I2C lock is already taken
 773  * by tuner driver. Gate is closed automatically after single I2C xfer.
 774  */
 775 static int rtl2830_select(struct i2c_adapter *adap, void *mux_priv, u32 chan_id)
 776 {
 777         struct i2c_client *client = mux_priv;
 778         struct rtl2830_priv *priv = i2c_get_clientdata(client);
 779         struct i2c_msg select_reg_page_msg[1] = {
 780                 {
 781                         .addr = priv->cfg.i2c_addr,
 782                         .flags = 0,
 783                         .len = 2,
 784                         .buf = "\x00\x01",
 785                 }
 786         };
 787         struct i2c_msg gate_open_msg[1] = {
 788                 {
 789                         .addr = priv->cfg.i2c_addr,
 790                         .flags = 0,
 791                         .len = 2,
 792                         .buf = "\x01\x08",
 793                 }
 794         };
 795         int ret;
 796
 797         /* select register page */
 798         ret = __i2c_transfer(adap, select_reg_page_msg, 1);
 799         if (ret != 1) {
 800                 dev_warn(&client->dev, "i2c write failed %d\n", ret);
 801                 if (ret >= 0)
 802                         ret = -EREMOTEIO;
 803                 goto err;
 804         }
 805
 806         priv->page = 1;
 807
 808         /* open tuner I2C repeater for 1 xfer, closes automatically */
 809         ret = __i2c_transfer(adap, gate_open_msg, 1);
 810         if (ret != 1) {
 811                 dev_warn(&client->dev, "i2c write failed %d\n", ret);
 812                 if (ret >= 0)
 813                         ret = -EREMOTEIO;
 814                 goto err;
 815         }
 816
 817         return 0;
 818
 819 err:
 820         dev_dbg(&client->dev, "%s: failed=%d\n", __func__, ret);
 821         return ret;
 822 }
 823
 824 static struct dvb_frontend *rtl2830_get_dvb_frontend(struct i2c_client *client)
 825 {
 826         struct rtl2830_priv *priv = i2c_get_clientdata(client);
 827
 828         dev_dbg(&client->dev, "\n");
 829
 830         return &priv->fe;
 831 }
 832
 833 static struct i2c_adapter *rtl2830_get_i2c_adapter(struct i2c_client *client)
 834 {
 835         struct rtl2830_priv *priv = i2c_get_clientdata(client);
 836
 837         dev_dbg(&client->dev, "\n");
 838
 839         return priv->adapter;
 840 }
 841
 842 static int rtl2830_probe(struct i2c_client *client,
 843                 const struct i2c_device_id *id)
 844 {
 845         struct rtl2830_platform_data *pdata = client->dev.platform_data;
 846         struct i2c_adapter *i2c = client->adapter;
 847         struct rtl2830_priv *priv;
 848         int ret;
 849         u8 u8tmp;
 850
 851         dev_dbg(&client->dev, "\n");
 852
 853         if (pdata == NULL) {
 854                 ret = -EINVAL;
 855                 goto err;
 856         }
 857
 858         /* allocate memory for the internal state */
 859         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 860         if (priv == NULL) {
 861                 ret = -ENOMEM;
 862                 goto err;
 863         }
 864
 865         /* setup the state */
 866         i2c_set_clientdata(client, priv);
 867         priv->i2c = i2c;
 868         priv->sleeping = true;
 869         priv->cfg.i2c_addr = client->addr;
 870         priv->cfg.xtal = pdata->clk;
 871         priv->cfg.spec_inv = pdata->spec_inv;
 872         priv->cfg.vtop = pdata->vtop;
 873         priv->cfg.krf = pdata->krf;
 874         priv->cfg.agc_targ_val = pdata->agc_targ_val;
 875
 876         /* check if the demod is there */
 877         ret = rtl2830_rd_reg(priv, 0x000, &u8tmp);
 878         if (ret)
 879                 goto err_kfree;
 880
 881         /* create muxed i2c adapter for tuner */
 882         priv->adapter = i2c_add_mux_adapter(client->adapter, &client->dev,
 883                         client, 0, 0, 0, rtl2830_select, NULL);
 884         if (priv->adapter == NULL) {
 885                 ret = -ENODEV;
 886                 goto err_kfree;
 887         }
 888
 889         /* create dvb frontend */
 890         memcpy(&priv->fe.ops, &rtl2830_ops, sizeof(priv->fe.ops));
 891         priv->fe.ops.release = NULL;
 892         priv->fe.demodulator_priv = priv;
 893
 894         /* setup callbacks */
 895         pdata->get_dvb_frontend = rtl2830_get_dvb_frontend;
 896         pdata->get_i2c_adapter = rtl2830_get_i2c_adapter;
 897
 898         dev_info(&client->dev, "Realtek RTL2830 successfully attached\n");
 899         return 0;
 900
 901 err_kfree:
 902         kfree(priv);
 903 err:
 904         dev_dbg(&client->dev, "failed=%d\n", ret);
 905         return ret;
 906 }
 907
 908 static int rtl2830_remove(struct i2c_client *client)
 909 {
 910         struct rtl2830_priv *priv = i2c_get_clientdata(client);
 911
 912         dev_dbg(&client->dev, "\n");
 913
 914         i2c_del_mux_adapter(priv->adapter);
 915         kfree(priv);
 916         return 0;
 917 }
 918
 919 static const struct i2c_device_id rtl2830_id_table[] = {
 920         {"rtl2830", 0},
 921         {}
 922 };
 923 MODULE_DEVICE_TABLE(i2c, rtl2830_id_table);
 924
 925 static struct i2c_driver rtl2830_driver = {
 926         .driver = {
 927                 .owner  = THIS_MODULE,
 928                 .name   = "rtl2830",
 929         },
 930         .probe          = rtl2830_probe,
 931         .remove         = rtl2830_remove,
 932         .id_table       = rtl2830_id_table,
 933 };
 934
 935 module_i2c_driver(rtl2830_driver);
 936
 937 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
 938 MODULE_DESCRIPTION("Realtek RTL2830 DVB-T demodulator driver");
 939 MODULE_LICENSE("GPL");