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