drivers/media/dvb-frontends/m88ds3103.c

   1 /*
   2  * Montage M88DS3103 demodulator driver
   3  *
   4  * Copyright (C) 2013 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
  17 #include "m88ds3103_priv.h"
  18
  19 static struct dvb_frontend_ops m88ds3103_ops;
  20
  21 /* write multiple registers */
  22 static int m88ds3103_wr_regs(struct m88ds3103_priv *priv,
  23                 u8 reg, const u8 *val, int len)
  24 {
  25 #define MAX_WR_LEN 32
  26 #define MAX_WR_XFER_LEN (MAX_WR_LEN + 1)
  27         int ret;
  28         u8 buf[MAX_WR_XFER_LEN];
  29         struct i2c_msg msg[1] = {
  30                 {
  31                         .addr = priv->cfg->i2c_addr,
  32                         .flags = 0,
  33                         .len = 1 + len,
  34                         .buf = buf,
  35                 }
  36         };
  37
  38         if (WARN_ON(len > MAX_WR_LEN))
  39                 return -EINVAL;
  40
  41         buf[0] = reg;
  42         memcpy(&buf[1], val, len);
  43
  44         mutex_lock(&priv->i2c_mutex);
  45         ret = i2c_transfer(priv->i2c, msg, 1);
  46         mutex_unlock(&priv->i2c_mutex);
  47         if (ret == 1) {
  48                 ret = 0;
  49         } else {
  50                 dev_warn(&priv->i2c->dev,
  51                                 "%s: i2c wr failed=%d reg=%02x len=%d\n",
  52                                 KBUILD_MODNAME, ret, reg, len);
  53                 ret = -EREMOTEIO;
  54         }
  55
  56         return ret;
  57 }
  58
  59 /* read multiple registers */
  60 static int m88ds3103_rd_regs(struct m88ds3103_priv *priv,
  61                 u8 reg, u8 *val, int len)
  62 {
  63 #define MAX_RD_LEN 3
  64 #define MAX_RD_XFER_LEN (MAX_RD_LEN)
  65         int ret;
  66         u8 buf[MAX_RD_XFER_LEN];
  67         struct i2c_msg msg[2] = {
  68                 {
  69                         .addr = priv->cfg->i2c_addr,
  70                         .flags = 0,
  71                         .len = 1,
  72                         .buf = &reg,
  73                 }, {
  74                         .addr = priv->cfg->i2c_addr,
  75                         .flags = I2C_M_RD,
  76                         .len = len,
  77                         .buf = buf,
  78                 }
  79         };
  80
  81         if (WARN_ON(len > MAX_RD_LEN))
  82                 return -EINVAL;
  83
  84         mutex_lock(&priv->i2c_mutex);
  85         ret = i2c_transfer(priv->i2c, msg, 2);
  86         mutex_unlock(&priv->i2c_mutex);
  87         if (ret == 2) {
  88                 memcpy(val, buf, len);
  89                 ret = 0;
  90         } else {
  91                 dev_warn(&priv->i2c->dev,
  92                                 "%s: i2c rd failed=%d reg=%02x len=%d\n",
  93                                 KBUILD_MODNAME, ret, reg, len);
  94                 ret = -EREMOTEIO;
  95         }
  96
  97         return ret;
  98 }
  99
 100 /* write single register */
 101 static int m88ds3103_wr_reg(struct m88ds3103_priv *priv, u8 reg, u8 val)
 102 {
 103         return m88ds3103_wr_regs(priv, reg, &val, 1);
 104 }
 105
 106 /* read single register */
 107 static int m88ds3103_rd_reg(struct m88ds3103_priv *priv, u8 reg, u8 *val)
 108 {
 109         return m88ds3103_rd_regs(priv, reg, val, 1);
 110 }
 111
 112 /* write single register with mask */
 113 static int m88ds3103_wr_reg_mask(struct m88ds3103_priv *priv,
 114                 u8 reg, u8 val, u8 mask)
 115 {
 116         int ret;
 117         u8 u8tmp;
 118
 119         /* no need for read if whole reg is written */
 120         if (mask != 0xff) {
 121                 ret = m88ds3103_rd_regs(priv, reg, &u8tmp, 1);
 122                 if (ret)
 123                         return ret;
 124
 125                 val &= mask;
 126                 u8tmp &= ~mask;
 127                 val |= u8tmp;
 128         }
 129
 130         return m88ds3103_wr_regs(priv, reg, &val, 1);
 131 }
 132
 133 /* read single register with mask */
 134 static int m88ds3103_rd_reg_mask(struct m88ds3103_priv *priv,
 135                 u8 reg, u8 *val, u8 mask)
 136 {
 137         int ret, i;
 138         u8 u8tmp;
 139
 140         ret = m88ds3103_rd_regs(priv, reg, &u8tmp, 1);
 141         if (ret)
 142                 return ret;
 143
 144         u8tmp &= mask;
 145
 146         /* find position of the first bit */
 147         for (i = 0; i < 8; i++) {
 148                 if ((mask >> i) & 0x01)
 149                         break;
 150         }
 151         *val = u8tmp >> i;
 152
 153         return 0;
 154 }
 155
 156 /* write reg val table using reg addr auto increment */
 157 static int m88ds3103_wr_reg_val_tab(struct m88ds3103_priv *priv,
 158                 const struct m88ds3103_reg_val *tab, int tab_len)
 159 {
 160         int ret, i, j;
 161         u8 buf[83];
 162         dev_dbg(&priv->i2c->dev, "%s: tab_len=%d\n", __func__, tab_len);
 163
 164         if (tab_len > 83) {
 165                 ret = -EINVAL;
 166                 goto err;
 167         }
 168
 169         for (i = 0, j = 0; i < tab_len; i++, j++) {
 170                 buf[j] = tab[i].val;
 171
 172                 if (i == tab_len - 1 || tab[i].reg != tab[i + 1].reg - 1 ||
 173                                 !((j + 1) % (priv->cfg->i2c_wr_max - 1))) {
 174                         ret = m88ds3103_wr_regs(priv, tab[i].reg - j, buf, j + 1);
 175                         if (ret)
 176                                 goto err;
 177
 178                         j = -1;
 179                 }
 180         }
 181
 182         return 0;
 183 err:
 184         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 185         return ret;
 186 }
 187
 188 static int m88ds3103_read_status(struct dvb_frontend *fe, fe_status_t *status)
 189 {
 190         struct m88ds3103_priv *priv = fe->demodulator_priv;
 191         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 192         int ret;
 193         u8 u8tmp;
 194
 195         *status = 0;
 196
 197         if (!priv->warm) {
 198                 ret = -EAGAIN;
 199                 goto err;
 200         }
 201
 202         switch (c->delivery_system) {
 203         case SYS_DVBS:
 204                 ret = m88ds3103_rd_reg_mask(priv, 0xd1, &u8tmp, 0x07);
 205                 if (ret)
 206                         goto err;
 207
 208                 if (u8tmp == 0x07)
 209                         *status = FE_HAS_SIGNAL | FE_HAS_CARRIER |
 210                                         FE_HAS_VITERBI | FE_HAS_SYNC |
 211                                         FE_HAS_LOCK;
 212                 break;
 213         case SYS_DVBS2:
 214                 ret = m88ds3103_rd_reg_mask(priv, 0x0d, &u8tmp, 0x8f);
 215                 if (ret)
 216                         goto err;
 217
 218                 if (u8tmp == 0x8f)
 219                         *status = FE_HAS_SIGNAL | FE_HAS_CARRIER |
 220                                         FE_HAS_VITERBI | FE_HAS_SYNC |
 221                                         FE_HAS_LOCK;
 222                 break;
 223         default:
 224                 dev_dbg(&priv->i2c->dev, "%s: invalid delivery_system\n",
 225                                 __func__);
 226                 ret = -EINVAL;
 227                 goto err;
 228         }
 229
 230         priv->fe_status = *status;
 231
 232         dev_dbg(&priv->i2c->dev, "%s: lock=%02x status=%02x\n",
 233                         __func__, u8tmp, *status);
 234
 235         return 0;
 236 err:
 237         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 238         return ret;
 239 }
 240
 241 static int m88ds3103_set_frontend(struct dvb_frontend *fe)
 242 {
 243         struct m88ds3103_priv *priv = fe->demodulator_priv;
 244         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 245         int ret, len;
 246         const struct m88ds3103_reg_val *init;
 247         u8 u8tmp, u8tmp1, u8tmp2;
 248         u8 buf[2];
 249         u16 u16tmp, divide_ratio;
 250         u32 tuner_frequency, target_mclk, ts_clk;
 251         s32 s32tmp;
 252         dev_dbg(&priv->i2c->dev,
 253                         "%s: delivery_system=%d modulation=%d frequency=%d symbol_rate=%d inversion=%d pilot=%d rolloff=%d\n",
 254                         __func__, c->delivery_system,
 255                         c->modulation, c->frequency, c->symbol_rate,
 256                         c->inversion, c->pilot, c->rolloff);
 257
 258         if (!priv->warm) {
 259                 ret = -EAGAIN;
 260                 goto err;
 261         }
 262
 263         /* program tuner */
 264         if (fe->ops.tuner_ops.set_params) {
 265                 ret = fe->ops.tuner_ops.set_params(fe);
 266                 if (ret)
 267                         goto err;
 268         }
 269
 270         if (fe->ops.tuner_ops.get_frequency) {
 271                 ret = fe->ops.tuner_ops.get_frequency(fe, &tuner_frequency);
 272                 if (ret)
 273                         goto err;
 274         }
 275
 276         /* reset */
 277         ret = m88ds3103_wr_reg(priv, 0x07, 0x80);
 278         if (ret)
 279                 goto err;
 280
 281         ret = m88ds3103_wr_reg(priv, 0x07, 0x00);
 282         if (ret)
 283                 goto err;
 284
 285         ret = m88ds3103_wr_reg(priv, 0xb2, 0x01);
 286         if (ret)
 287                 goto err;
 288
 289         ret = m88ds3103_wr_reg(priv, 0x00, 0x01);
 290         if (ret)
 291                 goto err;
 292
 293         switch (c->delivery_system) {
 294         case SYS_DVBS:
 295                 len = ARRAY_SIZE(m88ds3103_dvbs_init_reg_vals);
 296                 init = m88ds3103_dvbs_init_reg_vals;
 297                 target_mclk = 96000;
 298                 break;
 299         case SYS_DVBS2:
 300                 len = ARRAY_SIZE(m88ds3103_dvbs2_init_reg_vals);
 301                 init = m88ds3103_dvbs2_init_reg_vals;
 302
 303                 switch (priv->cfg->ts_mode) {
 304                 case M88DS3103_TS_SERIAL:
 305                 case M88DS3103_TS_SERIAL_D7:
 306                         if (c->symbol_rate < 18000000)
 307                                 target_mclk = 96000;
 308                         else
 309                                 target_mclk = 144000;
 310                         break;
 311                 case M88DS3103_TS_PARALLEL:
 312                 case M88DS3103_TS_PARALLEL_12:
 313                 case M88DS3103_TS_PARALLEL_16:
 314                 case M88DS3103_TS_PARALLEL_19_2:
 315                 case M88DS3103_TS_CI:
 316                         if (c->symbol_rate < 18000000)
 317                                 target_mclk = 96000;
 318                         else if (c->symbol_rate < 28000000)
 319                                 target_mclk = 144000;
 320                         else
 321                                 target_mclk = 192000;
 322                         break;
 323                 default:
 324                         dev_dbg(&priv->i2c->dev, "%s: invalid ts_mode\n",
 325                                         __func__);
 326                         ret = -EINVAL;
 327                         goto err;
 328                 }
 329                 break;
 330         default:
 331                 dev_dbg(&priv->i2c->dev, "%s: invalid delivery_system\n",
 332                                 __func__);
 333                 ret = -EINVAL;
 334                 goto err;
 335         }
 336
 337         /* program init table */
 338         if (c->delivery_system != priv->delivery_system) {
 339                 ret = m88ds3103_wr_reg_val_tab(priv, init, len);
 340                 if (ret)
 341                         goto err;
 342         }
 343
 344         u8tmp1 = 0; /* silence compiler warning */
 345         switch (priv->cfg->ts_mode) {
 346         case M88DS3103_TS_SERIAL:
 347                 u8tmp1 = 0x00;
 348                 ts_clk = 0;
 349                 u8tmp = 0x46;
 350                 break;
 351         case M88DS3103_TS_SERIAL_D7:
 352                 u8tmp1 = 0x20;
 353                 ts_clk = 0;
 354                 u8tmp = 0x46;
 355                 break;
 356         case M88DS3103_TS_PARALLEL:
 357                 ts_clk = 24000;
 358                 u8tmp = 0x42;
 359                 break;
 360         case M88DS3103_TS_PARALLEL_12:
 361                 ts_clk = 12000;
 362                 u8tmp = 0x42;
 363                 break;
 364         case M88DS3103_TS_PARALLEL_16:
 365                 ts_clk = 16000;
 366                 u8tmp = 0x42;
 367                 break;
 368         case M88DS3103_TS_PARALLEL_19_2:
 369                 ts_clk = 19200;
 370                 u8tmp = 0x42;
 371                 break;
 372         case M88DS3103_TS_CI:
 373                 ts_clk = 6000;
 374                 u8tmp = 0x43;
 375                 break;
 376         default:
 377                 dev_dbg(&priv->i2c->dev, "%s: invalid ts_mode\n", __func__);
 378                 ret = -EINVAL;
 379                 goto err;
 380         }
 381
 382         /* TS mode */
 383         ret = m88ds3103_wr_reg(priv, 0xfd, u8tmp);
 384         if (ret)
 385                 goto err;
 386
 387         switch (priv->cfg->ts_mode) {
 388         case M88DS3103_TS_SERIAL:
 389         case M88DS3103_TS_SERIAL_D7:
 390                 ret = m88ds3103_wr_reg_mask(priv, 0x29, u8tmp1, 0x20);
 391                 if (ret)
 392                         goto err;
 393         }
 394
 395         if (ts_clk) {
 396                 divide_ratio = DIV_ROUND_UP(target_mclk, ts_clk);
 397                 u8tmp1 = divide_ratio / 2;
 398                 u8tmp2 = DIV_ROUND_UP(divide_ratio, 2);
 399         } else {
 400                 divide_ratio = 0;
 401                 u8tmp1 = 0;
 402                 u8tmp2 = 0;
 403         }
 404
 405         dev_dbg(&priv->i2c->dev,
 406                         "%s: target_mclk=%d ts_clk=%d divide_ratio=%d\n",
 407                         __func__, target_mclk, ts_clk, divide_ratio);
 408
 409         u8tmp1--;
 410         u8tmp2--;
 411         /* u8tmp1[5:2] => fe[3:0], u8tmp1[1:0] => ea[7:6] */
 412         u8tmp1 &= 0x3f;
 413         /* u8tmp2[5:0] => ea[5:0] */
 414         u8tmp2 &= 0x3f;
 415
 416         ret = m88ds3103_rd_reg(priv, 0xfe, &u8tmp);
 417         if (ret)
 418                 goto err;
 419
 420         u8tmp = ((u8tmp  & 0xf0) << 0) | u8tmp1 >> 2;
 421         ret = m88ds3103_wr_reg(priv, 0xfe, u8tmp);
 422         if (ret)
 423                 goto err;
 424
 425         u8tmp = ((u8tmp1 & 0x03) << 6) | u8tmp2 >> 0;
 426         ret = m88ds3103_wr_reg(priv, 0xea, u8tmp);
 427         if (ret)
 428                 goto err;
 429
 430         switch (target_mclk) {
 431         case 72000:
 432                 u8tmp1 = 0x00; /* 0b00 */
 433                 u8tmp2 = 0x03; /* 0b11 */
 434                 break;
 435         case 96000:
 436                 u8tmp1 = 0x02; /* 0b10 */
 437                 u8tmp2 = 0x01; /* 0b01 */
 438                 break;
 439         case 115200:
 440                 u8tmp1 = 0x01; /* 0b01 */
 441                 u8tmp2 = 0x01; /* 0b01 */
 442                 break;
 443         case 144000:
 444                 u8tmp1 = 0x00; /* 0b00 */
 445                 u8tmp2 = 0x01; /* 0b01 */
 446                 break;
 447         case 192000:
 448                 u8tmp1 = 0x03; /* 0b11 */
 449                 u8tmp2 = 0x00; /* 0b00 */
 450                 break;
 451         default:
 452                 dev_dbg(&priv->i2c->dev, "%s: invalid target_mclk\n", __func__);
 453                 ret = -EINVAL;
 454                 goto err;
 455         }
 456
 457         ret = m88ds3103_wr_reg_mask(priv, 0x22, u8tmp1 << 6, 0xc0);
 458         if (ret)
 459                 goto err;
 460
 461         ret = m88ds3103_wr_reg_mask(priv, 0x24, u8tmp2 << 6, 0xc0);
 462         if (ret)
 463                 goto err;
 464
 465         if (c->symbol_rate <= 3000000)
 466                 u8tmp = 0x20;
 467         else if (c->symbol_rate <= 10000000)
 468                 u8tmp = 0x10;
 469         else
 470                 u8tmp = 0x06;
 471
 472         ret = m88ds3103_wr_reg(priv, 0xc3, 0x08);
 473         if (ret)
 474                 goto err;
 475
 476         ret = m88ds3103_wr_reg(priv, 0xc8, u8tmp);
 477         if (ret)
 478                 goto err;
 479
 480         ret = m88ds3103_wr_reg(priv, 0xc4, 0x08);
 481         if (ret)
 482                 goto err;
 483
 484         ret = m88ds3103_wr_reg(priv, 0xc7, 0x00);
 485         if (ret)
 486                 goto err;
 487
 488         u16tmp = DIV_ROUND_CLOSEST((c->symbol_rate / 1000) << 15, M88DS3103_MCLK_KHZ / 2);
 489         buf[0] = (u16tmp >> 0) & 0xff;
 490         buf[1] = (u16tmp >> 8) & 0xff;
 491         ret = m88ds3103_wr_regs(priv, 0x61, buf, 2);
 492         if (ret)
 493                 goto err;
 494
 495         ret = m88ds3103_wr_reg_mask(priv, 0x4d, priv->cfg->spec_inv << 1, 0x02);
 496         if (ret)
 497                 goto err;
 498
 499         ret = m88ds3103_wr_reg_mask(priv, 0x30, priv->cfg->agc_inv << 4, 0x10);
 500         if (ret)
 501                 goto err;
 502
 503         ret = m88ds3103_wr_reg(priv, 0x33, priv->cfg->agc);
 504         if (ret)
 505                 goto err;
 506
 507         dev_dbg(&priv->i2c->dev, "%s: carrier offset=%d\n", __func__,
 508                         (tuner_frequency - c->frequency));
 509
 510         s32tmp = 0x10000 * (tuner_frequency - c->frequency);
 511         s32tmp = DIV_ROUND_CLOSEST(s32tmp, M88DS3103_MCLK_KHZ);
 512         if (s32tmp < 0)
 513                 s32tmp += 0x10000;
 514
 515         buf[0] = (s32tmp >> 0) & 0xff;
 516         buf[1] = (s32tmp >> 8) & 0xff;
 517         ret = m88ds3103_wr_regs(priv, 0x5e, buf, 2);
 518         if (ret)
 519                 goto err;
 520
 521         ret = m88ds3103_wr_reg(priv, 0x00, 0x00);
 522         if (ret)
 523                 goto err;
 524
 525         ret = m88ds3103_wr_reg(priv, 0xb2, 0x00);
 526         if (ret)
 527                 goto err;
 528
 529         priv->delivery_system = c->delivery_system;
 530
 531         return 0;
 532 err:
 533         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 534         return ret;
 535 }
 536
 537 static int m88ds3103_init(struct dvb_frontend *fe)
 538 {
 539         struct m88ds3103_priv *priv = fe->demodulator_priv;
 540         int ret, len, remaining;
 541         const struct firmware *fw = NULL;
 542         u8 *fw_file = M88DS3103_FIRMWARE;
 543         u8 u8tmp;
 544         dev_dbg(&priv->i2c->dev, "%s:\n", __func__);
 545
 546         /* set cold state by default */
 547         priv->warm = false;
 548
 549         /* wake up device from sleep */
 550         ret = m88ds3103_wr_reg_mask(priv, 0x08, 0x01, 0x01);
 551         if (ret)
 552                 goto err;
 553
 554         ret = m88ds3103_wr_reg_mask(priv, 0x04, 0x00, 0x01);
 555         if (ret)
 556                 goto err;
 557
 558         ret = m88ds3103_wr_reg_mask(priv, 0x23, 0x00, 0x10);
 559         if (ret)
 560                 goto err;
 561
 562         /* reset */
 563         ret = m88ds3103_wr_reg(priv, 0x07, 0x60);
 564         if (ret)
 565                 goto err;
 566
 567         ret = m88ds3103_wr_reg(priv, 0x07, 0x00);
 568         if (ret)
 569                 goto err;
 570
 571         /* firmware status */
 572         ret = m88ds3103_rd_reg(priv, 0xb9, &u8tmp);
 573         if (ret)
 574                 goto err;
 575
 576         dev_dbg(&priv->i2c->dev, "%s: firmware=%02x\n", __func__, u8tmp);
 577
 578         if (u8tmp)
 579                 goto skip_fw_download;
 580
 581         /* cold state - try to download firmware */
 582         dev_info(&priv->i2c->dev, "%s: found a '%s' in cold state\n",
 583                         KBUILD_MODNAME, m88ds3103_ops.info.name);
 584
 585         /* request the firmware, this will block and timeout */
 586         ret = request_firmware(&fw, fw_file, priv->i2c->dev.parent);
 587         if (ret) {
 588                 dev_err(&priv->i2c->dev, "%s: firmare file '%s' not found\n",
 589                                 KBUILD_MODNAME, fw_file);
 590                 goto err;
 591         }
 592
 593         dev_info(&priv->i2c->dev, "%s: downloading firmware from file '%s'\n",
 594                         KBUILD_MODNAME, fw_file);
 595
 596         ret = m88ds3103_wr_reg(priv, 0xb2, 0x01);
 597         if (ret)
 598                 goto err;
 599
 600         for (remaining = fw->size; remaining > 0;
 601                         remaining -= (priv->cfg->i2c_wr_max - 1)) {
 602                 len = remaining;
 603                 if (len > (priv->cfg->i2c_wr_max - 1))
 604                         len = (priv->cfg->i2c_wr_max - 1);
 605
 606                 ret = m88ds3103_wr_regs(priv, 0xb0,
 607                                 &fw->data[fw->size - remaining], len);
 608                 if (ret) {
 609                         dev_err(&priv->i2c->dev,
 610                                         "%s: firmware download failed=%d\n",
 611                                         KBUILD_MODNAME, ret);
 612                         goto err;
 613                 }
 614         }
 615
 616         ret = m88ds3103_wr_reg(priv, 0xb2, 0x00);
 617         if (ret)
 618                 goto err;
 619
 620         release_firmware(fw);
 621         fw = NULL;
 622
 623         ret = m88ds3103_rd_reg(priv, 0xb9, &u8tmp);
 624         if (ret)
 625                 goto err;
 626
 627         if (!u8tmp) {
 628                 dev_info(&priv->i2c->dev, "%s: firmware did not run\n",
 629                                 KBUILD_MODNAME);
 630                 ret = -EFAULT;
 631                 goto err;
 632         }
 633
 634         dev_info(&priv->i2c->dev, "%s: found a '%s' in warm state\n",
 635                         KBUILD_MODNAME, m88ds3103_ops.info.name);
 636         dev_info(&priv->i2c->dev, "%s: firmware version %X.%X\n",
 637                         KBUILD_MODNAME, (u8tmp >> 4) & 0xf, (u8tmp >> 0 & 0xf));
 638
 639 skip_fw_download:
 640         /* warm state */
 641         priv->warm = true;
 642
 643         return 0;
 644 err:
 645         if (fw)
 646                 release_firmware(fw);
 647
 648         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 649         return ret;
 650 }
 651
 652 static int m88ds3103_sleep(struct dvb_frontend *fe)
 653 {
 654         struct m88ds3103_priv *priv = fe->demodulator_priv;
 655         int ret;
 656         dev_dbg(&priv->i2c->dev, "%s:\n", __func__);
 657
 658         priv->delivery_system = SYS_UNDEFINED;
 659
 660         /* TS Hi-Z */
 661         ret = m88ds3103_wr_reg_mask(priv, 0x27, 0x00, 0x01);
 662         if (ret)
 663                 goto err;
 664
 665         /* sleep */
 666         ret = m88ds3103_wr_reg_mask(priv, 0x08, 0x00, 0x01);
 667         if (ret)
 668                 goto err;
 669
 670         ret = m88ds3103_wr_reg_mask(priv, 0x04, 0x01, 0x01);
 671         if (ret)
 672                 goto err;
 673
 674         ret = m88ds3103_wr_reg_mask(priv, 0x23, 0x10, 0x10);
 675         if (ret)
 676                 goto err;
 677
 678         return 0;
 679 err:
 680         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 681         return ret;
 682 }
 683
 684 static int m88ds3103_get_frontend(struct dvb_frontend *fe)
 685 {
 686         struct m88ds3103_priv *priv = fe->demodulator_priv;
 687         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 688         int ret;
 689         u8 buf[3];
 690         dev_dbg(&priv->i2c->dev, "%s:\n", __func__);
 691
 692         if (!priv->warm || !(priv->fe_status & FE_HAS_LOCK)) {
 693                 ret = -EAGAIN;
 694                 goto err;
 695         }
 696
 697         switch (c->delivery_system) {
 698         case SYS_DVBS:
 699                 ret = m88ds3103_rd_reg(priv, 0xe0, &buf[0]);
 700                 if (ret)
 701                         goto err;
 702
 703                 ret = m88ds3103_rd_reg(priv, 0xe6, &buf[1]);
 704                 if (ret)
 705                         goto err;
 706
 707                 switch ((buf[0] >> 2) & 0x01) {
 708                 case 0:
 709                         c->inversion = INVERSION_OFF;
 710                         break;
 711                 case 1:
 712                         c->inversion = INVERSION_ON;
 713                         break;
 714                 }
 715
 716                 switch ((buf[1] >> 5) & 0x07) {
 717                 case 0:
 718                         c->fec_inner = FEC_7_8;
 719                         break;
 720                 case 1:
 721                         c->fec_inner = FEC_5_6;
 722                         break;
 723                 case 2:
 724                         c->fec_inner = FEC_3_4;
 725                         break;
 726                 case 3:
 727                         c->fec_inner = FEC_2_3;
 728                         break;
 729                 case 4:
 730                         c->fec_inner = FEC_1_2;
 731                         break;
 732                 default:
 733                         dev_dbg(&priv->i2c->dev, "%s: invalid fec_inner\n",
 734                                         __func__);
 735                 }
 736
 737                 c->modulation = QPSK;
 738
 739                 break;
 740         case SYS_DVBS2:
 741                 ret = m88ds3103_rd_reg(priv, 0x7e, &buf[0]);
 742                 if (ret)
 743                         goto err;
 744
 745                 ret = m88ds3103_rd_reg(priv, 0x89, &buf[1]);
 746                 if (ret)
 747                         goto err;
 748
 749                 ret = m88ds3103_rd_reg(priv, 0xf2, &buf[2]);
 750                 if (ret)
 751                         goto err;
 752
 753                 switch ((buf[0] >> 0) & 0x0f) {
 754                 case 2:
 755                         c->fec_inner = FEC_2_5;
 756                         break;
 757                 case 3:
 758                         c->fec_inner = FEC_1_2;
 759                         break;
 760                 case 4:
 761                         c->fec_inner = FEC_3_5;
 762                         break;
 763                 case 5:
 764                         c->fec_inner = FEC_2_3;
 765                         break;
 766                 case 6:
 767                         c->fec_inner = FEC_3_4;
 768                         break;
 769                 case 7:
 770                         c->fec_inner = FEC_4_5;
 771                         break;
 772                 case 8:
 773                         c->fec_inner = FEC_5_6;
 774                         break;
 775                 case 9:
 776                         c->fec_inner = FEC_8_9;
 777                         break;
 778                 case 10:
 779                         c->fec_inner = FEC_9_10;
 780                         break;
 781                 default:
 782                         dev_dbg(&priv->i2c->dev, "%s: invalid fec_inner\n",
 783                                         __func__);
 784                 }
 785
 786                 switch ((buf[0] >> 5) & 0x01) {
 787                 case 0:
 788                         c->pilot = PILOT_OFF;
 789                         break;
 790                 case 1:
 791                         c->pilot = PILOT_ON;
 792                         break;
 793                 }
 794
 795                 switch ((buf[0] >> 6) & 0x07) {
 796                 case 0:
 797                         c->modulation = QPSK;
 798                         break;
 799                 case 1:
 800                         c->modulation = PSK_8;
 801                         break;
 802                 case 2:
 803                         c->modulation = APSK_16;
 804                         break;
 805                 case 3:
 806                         c->modulation = APSK_32;
 807                         break;
 808                 default:
 809                         dev_dbg(&priv->i2c->dev, "%s: invalid modulation\n",
 810                                         __func__);
 811                 }
 812
 813                 switch ((buf[1] >> 7) & 0x01) {
 814                 case 0:
 815                         c->inversion = INVERSION_OFF;
 816                         break;
 817                 case 1:
 818                         c->inversion = INVERSION_ON;
 819                         break;
 820                 }
 821
 822                 switch ((buf[2] >> 0) & 0x03) {
 823                 case 0:
 824                         c->rolloff = ROLLOFF_35;
 825                         break;
 826                 case 1:
 827                         c->rolloff = ROLLOFF_25;
 828                         break;
 829                 case 2:
 830                         c->rolloff = ROLLOFF_20;
 831                         break;
 832                 default:
 833                         dev_dbg(&priv->i2c->dev, "%s: invalid rolloff\n",
 834                                         __func__);
 835                 }
 836                 break;
 837         default:
 838                 dev_dbg(&priv->i2c->dev, "%s: invalid delivery_system\n",
 839                                 __func__);
 840                 ret = -EINVAL;
 841                 goto err;
 842         }
 843
 844         ret = m88ds3103_rd_regs(priv, 0x6d, buf, 2);
 845         if (ret)
 846                 goto err;
 847
 848         c->symbol_rate = 1ull * ((buf[1] << 8) | (buf[0] << 0)) *
 849                         M88DS3103_MCLK_KHZ * 1000 / 0x10000;
 850
 851         return 0;
 852 err:
 853         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 854         return ret;
 855 }
 856
 857 static int m88ds3103_read_snr(struct dvb_frontend *fe, u16 *snr)
 858 {
 859         struct m88ds3103_priv *priv = fe->demodulator_priv;
 860         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 861         int ret, i, tmp;
 862         u8 buf[3];
 863         u16 noise, signal;
 864         u32 noise_tot, signal_tot;
 865         dev_dbg(&priv->i2c->dev, "%s:\n", __func__);
 866         /* reports SNR in resolution of 0.1 dB */
 867
 868         /* more iterations for more accurate estimation */
 869         #define M88DS3103_SNR_ITERATIONS 3
 870
 871         switch (c->delivery_system) {
 872         case SYS_DVBS:
 873                 tmp = 0;
 874
 875                 for (i = 0; i < M88DS3103_SNR_ITERATIONS; i++) {
 876                         ret = m88ds3103_rd_reg(priv, 0xff, &buf[0]);
 877                         if (ret)
 878                                 goto err;
 879
 880                         tmp += buf[0];
 881                 }
 882
 883                 /* use of one register limits max value to 15 dB */
 884                 /* SNR(X) dB = 10 * ln(X) / ln(10) dB */
 885                 tmp = DIV_ROUND_CLOSEST(tmp, 8 * M88DS3103_SNR_ITERATIONS);
 886                 if (tmp)
 887                         *snr = 100ul * intlog2(tmp) / intlog2(10);
 888                 else
 889                         *snr = 0;
 890                 break;
 891         case SYS_DVBS2:
 892                 noise_tot = 0;
 893                 signal_tot = 0;
 894
 895                 for (i = 0; i < M88DS3103_SNR_ITERATIONS; i++) {
 896                         ret = m88ds3103_rd_regs(priv, 0x8c, buf, 3);
 897                         if (ret)
 898                                 goto err;
 899
 900                         noise = buf[1] << 6;    /* [13:6] */
 901                         noise |= buf[0] & 0x3f; /*  [5:0] */
 902                         noise >>= 2;
 903                         signal = buf[2] * buf[2];
 904                         signal >>= 1;
 905
 906                         noise_tot += noise;
 907                         signal_tot += signal;
 908                 }
 909
 910                 noise = noise_tot / M88DS3103_SNR_ITERATIONS;
 911                 signal = signal_tot / M88DS3103_SNR_ITERATIONS;
 912
 913                 /* SNR(X) dB = 10 * log10(X) dB */
 914                 if (signal > noise) {
 915                         tmp = signal / noise;
 916                         *snr = 100ul * intlog10(tmp) / (1 << 24);
 917                 } else {
 918                         *snr = 0;
 919                 }
 920                 break;
 921         default:
 922                 dev_dbg(&priv->i2c->dev, "%s: invalid delivery_system\n",
 923                                 __func__);
 924                 ret = -EINVAL;
 925                 goto err;
 926         }
 927
 928         return 0;
 929 err:
 930         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 931         return ret;
 932 }
 933
 934
 935 static int m88ds3103_set_tone(struct dvb_frontend *fe,
 936         fe_sec_tone_mode_t fe_sec_tone_mode)
 937 {
 938         struct m88ds3103_priv *priv = fe->demodulator_priv;
 939         int ret;
 940         u8 u8tmp, tone, reg_a1_mask;
 941         dev_dbg(&priv->i2c->dev, "%s: fe_sec_tone_mode=%d\n", __func__,
 942                         fe_sec_tone_mode);
 943
 944         if (!priv->warm) {
 945                 ret = -EAGAIN;
 946                 goto err;
 947         }
 948
 949         switch (fe_sec_tone_mode) {
 950         case SEC_TONE_ON:
 951                 tone = 0;
 952                 reg_a1_mask = 0x87;
 953                 break;
 954         case SEC_TONE_OFF:
 955                 tone = 1;
 956                 reg_a1_mask = 0x00;
 957                 break;
 958         default:
 959                 dev_dbg(&priv->i2c->dev, "%s: invalid fe_sec_tone_mode\n",
 960                                 __func__);
 961                 ret = -EINVAL;
 962                 goto err;
 963         }
 964
 965         u8tmp = tone << 7 | priv->cfg->envelope_mode << 5;
 966         ret = m88ds3103_wr_reg_mask(priv, 0xa2, u8tmp, 0xe0);
 967         if (ret)
 968                 goto err;
 969
 970         u8tmp = 1 << 2;
 971         ret = m88ds3103_wr_reg_mask(priv, 0xa1, u8tmp, reg_a1_mask);
 972         if (ret)
 973                 goto err;
 974
 975         return 0;
 976 err:
 977         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
 978         return ret;
 979 }
 980
 981 static int m88ds3103_diseqc_send_master_cmd(struct dvb_frontend *fe,
 982                 struct dvb_diseqc_master_cmd *diseqc_cmd)
 983 {
 984         struct m88ds3103_priv *priv = fe->demodulator_priv;
 985         int ret, i;
 986         u8 u8tmp;
 987         dev_dbg(&priv->i2c->dev, "%s: msg=%*ph\n", __func__,
 988                         diseqc_cmd->msg_len, diseqc_cmd->msg);
 989
 990         if (!priv->warm) {
 991                 ret = -EAGAIN;
 992                 goto err;
 993         }
 994
 995         if (diseqc_cmd->msg_len < 3 || diseqc_cmd->msg_len > 6) {
 996                 ret = -EINVAL;
 997                 goto err;
 998         }
 999
1000         u8tmp = priv->cfg->envelope_mode << 5;
1001         ret = m88ds3103_wr_reg_mask(priv, 0xa2, u8tmp, 0xe0);
1002         if (ret)
1003                 goto err;
1004
1005         ret = m88ds3103_wr_regs(priv, 0xa3, diseqc_cmd->msg,
1006                         diseqc_cmd->msg_len);
1007         if (ret)
1008                 goto err;
1009
1010         ret = m88ds3103_wr_reg(priv, 0xa1,
1011                         (diseqc_cmd->msg_len - 1) << 3 | 0x07);
1012         if (ret)
1013                 goto err;
1014
1015         /* DiSEqC message typical period is 54 ms */
1016         usleep_range(40000, 60000);
1017
1018         /* wait DiSEqC TX ready */
1019         for (i = 20, u8tmp = 1; i && u8tmp; i--) {
1020                 usleep_range(5000, 10000);
1021
1022                 ret = m88ds3103_rd_reg_mask(priv, 0xa1, &u8tmp, 0x40);
1023                 if (ret)
1024                         goto err;
1025         }
1026
1027         dev_dbg(&priv->i2c->dev, "%s: loop=%d\n", __func__, i);
1028
1029         if (i == 0) {
1030                 dev_dbg(&priv->i2c->dev, "%s: diseqc tx timeout\n", __func__);
1031
1032                 ret = m88ds3103_wr_reg_mask(priv, 0xa1, 0x40, 0xc0);
1033                 if (ret)
1034                         goto err;
1035         }
1036
1037         ret = m88ds3103_wr_reg_mask(priv, 0xa2, 0x80, 0xc0);
1038         if (ret)
1039                 goto err;
1040
1041         if (i == 0) {
1042                 ret = -ETIMEDOUT;
1043                 goto err;
1044         }
1045
1046         return 0;
1047 err:
1048         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
1049         return ret;
1050 }
1051
1052 static int m88ds3103_diseqc_send_burst(struct dvb_frontend *fe,
1053         fe_sec_mini_cmd_t fe_sec_mini_cmd)
1054 {
1055         struct m88ds3103_priv *priv = fe->demodulator_priv;
1056         int ret, i;
1057         u8 u8tmp, burst;
1058         dev_dbg(&priv->i2c->dev, "%s: fe_sec_mini_cmd=%d\n", __func__,
1059                         fe_sec_mini_cmd);
1060
1061         if (!priv->warm) {
1062                 ret = -EAGAIN;
1063                 goto err;
1064         }
1065
1066         u8tmp = priv->cfg->envelope_mode << 5;
1067         ret = m88ds3103_wr_reg_mask(priv, 0xa2, u8tmp, 0xe0);
1068         if (ret)
1069                 goto err;
1070
1071         switch (fe_sec_mini_cmd) {
1072         case SEC_MINI_A:
1073                 burst = 0x02;
1074                 break;
1075         case SEC_MINI_B:
1076                 burst = 0x01;
1077                 break;
1078         default:
1079                 dev_dbg(&priv->i2c->dev, "%s: invalid fe_sec_mini_cmd\n",
1080                                 __func__);
1081                 ret = -EINVAL;
1082                 goto err;
1083         }
1084
1085         ret = m88ds3103_wr_reg(priv, 0xa1, burst);
1086         if (ret)
1087                 goto err;
1088
1089         /* DiSEqC ToneBurst period is 12.5 ms */
1090         usleep_range(11000, 20000);
1091
1092         /* wait DiSEqC TX ready */
1093         for (i = 5, u8tmp = 1; i && u8tmp; i--) {
1094                 usleep_range(800, 2000);
1095
1096                 ret = m88ds3103_rd_reg_mask(priv, 0xa1, &u8tmp, 0x40);
1097                 if (ret)
1098                         goto err;
1099         }
1100
1101         dev_dbg(&priv->i2c->dev, "%s: loop=%d\n", __func__, i);
1102
1103         ret = m88ds3103_wr_reg_mask(priv, 0xa2, 0x80, 0xc0);
1104         if (ret)
1105                 goto err;
1106
1107         if (i == 0) {
1108                 dev_dbg(&priv->i2c->dev, "%s: diseqc tx timeout\n", __func__);
1109                 ret = -ETIMEDOUT;
1110                 goto err;
1111         }
1112
1113         return 0;
1114 err:
1115         dev_dbg(&priv->i2c->dev, "%s: failed=%d\n", __func__, ret);
1116         return ret;
1117 }
1118
1119 static int m88ds3103_get_tune_settings(struct dvb_frontend *fe,
1120         struct dvb_frontend_tune_settings *s)
1121 {
1122         s->min_delay_ms = 3000;
1123
1124         return 0;
1125 }
1126
1127 static void m88ds3103_release(struct dvb_frontend *fe)
1128 {
1129         struct m88ds3103_priv *priv = fe->demodulator_priv;
1130         i2c_del_mux_adapter(priv->i2c_adapter);
1131         kfree(priv);
1132 }
1133
1134 static int m88ds3103_select(struct i2c_adapter *adap, void *mux_priv, u32 chan)
1135 {
1136         struct m88ds3103_priv *priv = mux_priv;
1137         int ret;
1138         struct i2c_msg gate_open_msg[1] = {
1139                 {
1140                         .addr = priv->cfg->i2c_addr,
1141                         .flags = 0,
1142                         .len = 2,
1143                         .buf = "\x03\x11",
1144                 }
1145         };
1146
1147         mutex_lock(&priv->i2c_mutex);
1148
1149         /* open tuner I2C repeater for 1 xfer, closes automatically */
1150         ret = __i2c_transfer(priv->i2c, gate_open_msg, 1);
1151         if (ret != 1) {
1152                 dev_warn(&priv->i2c->dev, "%s: i2c wr failed=%d\n",
1153                                 KBUILD_MODNAME, ret);
1154                 if (ret >= 0)
1155                         ret = -EREMOTEIO;
1156
1157                 return ret;
1158         }
1159
1160         return 0;
1161 }
1162
1163 static int m88ds3103_deselect(struct i2c_adapter *adap, void *mux_priv,
1164                 u32 chan)
1165 {
1166         struct m88ds3103_priv *priv = mux_priv;
1167
1168         mutex_unlock(&priv->i2c_mutex);
1169
1170         return 0;
1171 }
1172
1173 struct dvb_frontend *m88ds3103_attach(const struct m88ds3103_config *cfg,
1174                 struct i2c_adapter *i2c, struct i2c_adapter **tuner_i2c_adapter)
1175 {
1176         int ret;
1177         struct m88ds3103_priv *priv;
1178         u8 chip_id, u8tmp;
1179
1180         /* allocate memory for the internal priv */
1181         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1182         if (!priv) {
1183                 ret = -ENOMEM;
1184                 dev_err(&i2c->dev, "%s: kzalloc() failed\n", KBUILD_MODNAME);
1185                 goto err;
1186         }
1187
1188         priv->cfg = cfg;
1189         priv->i2c = i2c;
1190         mutex_init(&priv->i2c_mutex);
1191
1192         ret = m88ds3103_rd_reg(priv, 0x01, &chip_id);
1193         if (ret)
1194                 goto err;
1195
1196         dev_dbg(&priv->i2c->dev, "%s: chip_id=%02x\n", __func__, chip_id);
1197
1198         switch (chip_id) {
1199         case 0xd0:
1200                 break;
1201         default:
1202                 goto err;
1203         }
1204
1205         switch (priv->cfg->clock_out) {
1206         case M88DS3103_CLOCK_OUT_DISABLED:
1207                 u8tmp = 0x80;
1208                 break;
1209         case M88DS3103_CLOCK_OUT_ENABLED:
1210                 u8tmp = 0x00;
1211                 break;
1212         case M88DS3103_CLOCK_OUT_ENABLED_DIV2:
1213                 u8tmp = 0x10;
1214                 break;
1215         default:
1216                 goto err;
1217         }
1218
1219         ret = m88ds3103_wr_reg(priv, 0x29, u8tmp);
1220         if (ret)
1221                 goto err;
1222
1223         /* sleep */
1224         ret = m88ds3103_wr_reg_mask(priv, 0x08, 0x00, 0x01);
1225         if (ret)
1226                 goto err;
1227
1228         ret = m88ds3103_wr_reg_mask(priv, 0x04, 0x01, 0x01);
1229         if (ret)
1230                 goto err;
1231
1232         ret = m88ds3103_wr_reg_mask(priv, 0x23, 0x10, 0x10);
1233         if (ret)
1234                 goto err;
1235
1236         /* create mux i2c adapter for tuner */
1237         priv->i2c_adapter = i2c_add_mux_adapter(i2c, &i2c->dev, priv, 0, 0, 0,
1238                         m88ds3103_select, m88ds3103_deselect);
1239         if (priv->i2c_adapter == NULL)
1240                 goto err;
1241
1242         *tuner_i2c_adapter = priv->i2c_adapter;
1243
1244         /* create dvb_frontend */
1245         memcpy(&priv->fe.ops, &m88ds3103_ops, sizeof(struct dvb_frontend_ops));
1246         priv->fe.demodulator_priv = priv;
1247
1248         return &priv->fe;
1249 err:
1250         dev_dbg(&i2c->dev, "%s: failed=%d\n", __func__, ret);
1251         kfree(priv);
1252         return NULL;
1253 }
1254 EXPORT_SYMBOL(m88ds3103_attach);
1255
1256 static struct dvb_frontend_ops m88ds3103_ops = {
1257         .delsys = { SYS_DVBS, SYS_DVBS2 },
1258         .info = {
1259                 .name = "Montage M88DS3103",
1260                 .frequency_min =  950000,
1261                 .frequency_max = 2150000,
1262                 .frequency_tolerance = 5000,
1263                 .symbol_rate_min =  1000000,
1264                 .symbol_rate_max = 45000000,
1265                 .caps = FE_CAN_INVERSION_AUTO |
1266                         FE_CAN_FEC_1_2 |
1267                         FE_CAN_FEC_2_3 |
1268                         FE_CAN_FEC_3_4 |
1269                         FE_CAN_FEC_4_5 |
1270                         FE_CAN_FEC_5_6 |
1271                         FE_CAN_FEC_6_7 |
1272                         FE_CAN_FEC_7_8 |
1273                         FE_CAN_FEC_8_9 |
1274                         FE_CAN_FEC_AUTO |
1275                         FE_CAN_QPSK |
1276                         FE_CAN_RECOVER |
1277                         FE_CAN_2G_MODULATION
1278         },
1279
1280         .release = m88ds3103_release,
1281
1282         .get_tune_settings = m88ds3103_get_tune_settings,
1283
1284         .init = m88ds3103_init,
1285         .sleep = m88ds3103_sleep,
1286
1287         .set_frontend = m88ds3103_set_frontend,
1288         .get_frontend = m88ds3103_get_frontend,
1289
1290         .read_status = m88ds3103_read_status,
1291         .read_snr = m88ds3103_read_snr,
1292
1293         .diseqc_send_master_cmd = m88ds3103_diseqc_send_master_cmd,
1294         .diseqc_send_burst = m88ds3103_diseqc_send_burst,
1295
1296         .set_tone = m88ds3103_set_tone,
1297 };
1298
1299 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1300 MODULE_DESCRIPTION("Montage M88DS3103 DVB-S/S2 demodulator driver");
1301 MODULE_LICENSE("GPL");
1302 MODULE_FIRMWARE(M88DS3103_FIRMWARE);