drivers/media/dvb/frontends/cx24116.c

   1 /*
   2     Conexant cx24116/cx24118 - DVBS/S2 Satellite demod/tuner driver
   3
   4     Copyright (C) 2006-2008 Steven Toth <stoth@hauppauge.com>
   5     Copyright (C) 2006-2007 Georg Acher
   6     Copyright (C) 2007-2008 Darron Broad
   7         March 2007
   8             Fixed some bugs.
   9             Added diseqc support.
  10             Added corrected signal strength support.
  11         August 2007
  12             Sync with legacy version.
  13             Some clean ups.
  14     Copyright (C) 2008 Igor Liplianin
  15         September, 9th 2008
  16             Fixed locking on high symbol rates (>30000).
  17             Implement MPEG initialization parameter.
  18
  19     This program is free software; you can redistribute it and/or modify
  20     it under the terms of the GNU General Public License as published by
  21     the Free Software Foundation; either version 2 of the License, or
  22     (at your option) any later version.
  23
  24     This program is distributed in the hope that it will be useful,
  25     but WITHOUT ANY WARRANTY; without even the implied warranty of
  26     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27     GNU General Public License for more details.
  28
  29     You should have received a copy of the GNU General Public License
  30     along with this program; if not, write to the Free Software
  31     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  32 */
  33
  34 #include <linux/slab.h>
  35 #include <linux/kernel.h>
  36 #include <linux/module.h>
  37 #include <linux/moduleparam.h>
  38 #include <linux/init.h>
  39 #include <linux/firmware.h>
  40
  41 #include "dvb_frontend.h"
  42 #include "cx24116.h"
  43
  44 static int debug;
  45 module_param(debug, int, 0644);
  46 MODULE_PARM_DESC(debug, "Activates frontend debugging (default:0)");
  47
  48 #define dprintk(args...) \
  49         do { \
  50                 if (debug) \
  51                         printk(KERN_INFO "cx24116: " args); \
  52         } while (0)
  53
  54 #define CX24116_DEFAULT_FIRMWARE "dvb-fe-cx24116.fw"
  55 #define CX24116_SEARCH_RANGE_KHZ 5000
  56
  57 /* known registers */
  58 #define CX24116_REG_COMMAND (0x00)      /* command args 0x00..0x1e */
  59 #define CX24116_REG_EXECUTE (0x1f)      /* execute command */
  60 #define CX24116_REG_MAILBOX (0x96)      /* FW or multipurpose mailbox? */
  61 #define CX24116_REG_RESET   (0x20)      /* reset status > 0     */
  62 #define CX24116_REG_SIGNAL  (0x9e)      /* signal low           */
  63 #define CX24116_REG_SSTATUS (0x9d)      /* signal high / status */
  64 #define CX24116_REG_QUALITY8 (0xa3)
  65 #define CX24116_REG_QSTATUS (0xbc)
  66 #define CX24116_REG_QUALITY0 (0xd5)
  67 #define CX24116_REG_BER0    (0xc9)
  68 #define CX24116_REG_BER8    (0xc8)
  69 #define CX24116_REG_BER16   (0xc7)
  70 #define CX24116_REG_BER24   (0xc6)
  71 #define CX24116_REG_UCB0    (0xcb)
  72 #define CX24116_REG_UCB8    (0xca)
  73 #define CX24116_REG_CLKDIV  (0xf3)
  74 #define CX24116_REG_RATEDIV (0xf9)
  75
  76 /* configured fec (not tuned) or actual FEC (tuned) 1=1/2 2=2/3 etc */
  77 #define CX24116_REG_FECSTATUS (0x9c)
  78
  79 /* FECSTATUS bits */
  80 /* mask to determine configured fec (not tuned) or actual fec (tuned) */
  81 #define CX24116_FEC_FECMASK   (0x1f)
  82
  83 /* Select DVB-S demodulator, else DVB-S2 */
  84 #define CX24116_FEC_DVBS      (0x20)
  85 #define CX24116_FEC_UNKNOWN   (0x40)    /* Unknown/unused */
  86
  87 /* Pilot mode requested when tuning else always reset when tuned */
  88 #define CX24116_FEC_PILOT     (0x80)
  89
  90 /* arg buffer size */
  91 #define CX24116_ARGLEN (0x1e)
  92
  93 /* rolloff */
  94 #define CX24116_ROLLOFF_020 (0x00)
  95 #define CX24116_ROLLOFF_025 (0x01)
  96 #define CX24116_ROLLOFF_035 (0x02)
  97
  98 /* pilot bit */
  99 #define CX24116_PILOT_OFF (0x00)
 100 #define CX24116_PILOT_ON (0x40)
 101
 102 /* signal status */
 103 #define CX24116_HAS_SIGNAL   (0x01)
 104 #define CX24116_HAS_CARRIER  (0x02)
 105 #define CX24116_HAS_VITERBI  (0x04)
 106 #define CX24116_HAS_SYNCLOCK (0x08)
 107 #define CX24116_HAS_UNKNOWN1 (0x10)
 108 #define CX24116_HAS_UNKNOWN2 (0x20)
 109 #define CX24116_STATUS_MASK  (0x0f)
 110 #define CX24116_SIGNAL_MASK  (0xc0)
 111
 112 #define CX24116_DISEQC_TONEOFF   (0)    /* toneburst never sent */
 113 #define CX24116_DISEQC_TONECACHE (1)    /* toneburst cached     */
 114 #define CX24116_DISEQC_MESGCACHE (2)    /* message cached       */
 115
 116 /* arg offset for DiSEqC */
 117 #define CX24116_DISEQC_BURST  (1)
 118 #define CX24116_DISEQC_ARG2_2 (2)   /* unknown value=2 */
 119 #define CX24116_DISEQC_ARG3_0 (3)   /* unknown value=0 */
 120 #define CX24116_DISEQC_ARG4_0 (4)   /* unknown value=0 */
 121 #define CX24116_DISEQC_MSGLEN (5)
 122 #define CX24116_DISEQC_MSGOFS (6)
 123
 124 /* DiSEqC burst */
 125 #define CX24116_DISEQC_MINI_A (0)
 126 #define CX24116_DISEQC_MINI_B (1)
 127
 128 /* DiSEqC tone burst */
 129 static int toneburst = 1;
 130 module_param(toneburst, int, 0644);
 131 MODULE_PARM_DESC(toneburst, "DiSEqC toneburst 0=OFF, 1=TONE CACHE, "\
 132         "2=MESSAGE CACHE (default:1)");
 133
 134 /* SNR measurements */
 135 static int esno_snr;
 136 module_param(esno_snr, int, 0644);
 137 MODULE_PARM_DESC(debug, "SNR return units, 0=PERCENTAGE 0-100, "\
 138         "1=ESNO(db * 10) (default:0)");
 139
 140 enum cmds {
 141         CMD_SET_VCO     = 0x10,
 142         CMD_TUNEREQUEST = 0x11,
 143         CMD_MPEGCONFIG  = 0x13,
 144         CMD_TUNERINIT   = 0x14,
 145         CMD_BANDWIDTH   = 0x15,
 146         CMD_GETAGC      = 0x19,
 147         CMD_LNBCONFIG   = 0x20,
 148         CMD_LNBSEND     = 0x21, /* Formerly CMD_SEND_DISEQC */
 149         CMD_SET_TONEPRE = 0x22,
 150         CMD_SET_TONE    = 0x23,
 151         CMD_UPDFWVERS   = 0x35,
 152         CMD_TUNERSLEEP  = 0x36,
 153         CMD_AGCCONTROL  = 0x3b, /* Unknown */
 154 };
 155
 156 /* The Demod/Tuner can't easily provide these, we cache them */
 157 struct cx24116_tuning {
 158         u32 frequency;
 159         u32 symbol_rate;
 160         fe_spectral_inversion_t inversion;
 161         fe_code_rate_t fec;
 162
 163         fe_delivery_system_t delsys;
 164         fe_modulation_t modulation;
 165         fe_pilot_t pilot;
 166         fe_rolloff_t rolloff;
 167
 168         /* Demod values */
 169         u8 fec_val;
 170         u8 fec_mask;
 171         u8 inversion_val;
 172         u8 pilot_val;
 173         u8 rolloff_val;
 174 };
 175
 176 /* Basic commands that are sent to the firmware */
 177 struct cx24116_cmd {
 178         u8 len;
 179         u8 args[CX24116_ARGLEN];
 180 };
 181
 182 struct cx24116_state {
 183         struct i2c_adapter *i2c;
 184         const struct cx24116_config *config;
 185
 186         struct dvb_frontend frontend;
 187
 188         struct cx24116_tuning dcur;
 189         struct cx24116_tuning dnxt;
 190
 191         u8 skip_fw_load;
 192         u8 burst;
 193         struct cx24116_cmd dsec_cmd;
 194 };
 195
 196 static int cx24116_writereg(struct cx24116_state *state, int reg, int data)
 197 {
 198         u8 buf[] = { reg, data };
 199         struct i2c_msg msg = { .addr = state->config->demod_address,
 200                 .flags = 0, .buf = buf, .len = 2 };
 201         int err;
 202
 203         if (debug > 1)
 204                 printk("cx24116: %s: write reg 0x%02x, value 0x%02x\n",
 205                         __func__, reg, data);
 206
 207         err = i2c_transfer(state->i2c, &msg, 1);
 208         if (err != 1) {
 209                 printk(KERN_ERR "%s: writereg error(err == %i, reg == 0x%02x,"
 210                          " value == 0x%02x)\n", __func__, err, reg, data);
 211                 return -EREMOTEIO;
 212         }
 213
 214         return 0;
 215 }
 216
 217 /* Bulk byte writes to a single I2C address, for 32k firmware load */
 218 static int cx24116_writeregN(struct cx24116_state *state, int reg,
 219                              const u8 *data, u16 len)
 220 {
 221         int ret = -EREMOTEIO;
 222         struct i2c_msg msg;
 223         u8 *buf;
 224
 225         buf = kmalloc(len + 1, GFP_KERNEL);
 226         if (buf == NULL) {
 227                 printk("Unable to kmalloc\n");
 228                 ret = -ENOMEM;
 229                 goto error;
 230         }
 231
 232         *(buf) = reg;
 233         memcpy(buf + 1, data, len);
 234
 235         msg.addr = state->config->demod_address;
 236         msg.flags = 0;
 237         msg.buf = buf;
 238         msg.len = len + 1;
 239
 240         if (debug > 1)
 241                 printk(KERN_INFO "cx24116: %s:  write regN 0x%02x, len = %d\n",
 242                         __func__, reg, len);
 243
 244         ret = i2c_transfer(state->i2c, &msg, 1);
 245         if (ret != 1) {
 246                 printk(KERN_ERR "%s: writereg error(err == %i, reg == 0x%02x\n",
 247                          __func__, ret, reg);
 248                 ret = -EREMOTEIO;
 249         }
 250
 251 error:
 252         kfree(buf);
 253
 254         return ret;
 255 }
 256
 257 static int cx24116_readreg(struct cx24116_state *state, u8 reg)
 258 {
 259         int ret;
 260         u8 b0[] = { reg };
 261         u8 b1[] = { 0 };
 262         struct i2c_msg msg[] = {
 263                 { .addr = state->config->demod_address, .flags = 0,
 264                         .buf = b0, .len = 1 },
 265                 { .addr = state->config->demod_address, .flags = I2C_M_RD,
 266                         .buf = b1, .len = 1 }
 267         };
 268
 269         ret = i2c_transfer(state->i2c, msg, 2);
 270
 271         if (ret != 2) {
 272                 printk(KERN_ERR "%s: reg=0x%x (error=%d)\n",
 273                         __func__, reg, ret);
 274                 return ret;
 275         }
 276
 277         if (debug > 1)
 278                 printk(KERN_INFO "cx24116: read reg 0x%02x, value 0x%02x\n",
 279                         reg, b1[0]);
 280
 281         return b1[0];
 282 }
 283
 284 static int cx24116_set_inversion(struct cx24116_state *state,
 285         fe_spectral_inversion_t inversion)
 286 {
 287         dprintk("%s(%d)\n", __func__, inversion);
 288
 289         switch (inversion) {
 290         case INVERSION_OFF:
 291                 state->dnxt.inversion_val = 0x00;
 292                 break;
 293         case INVERSION_ON:
 294                 state->dnxt.inversion_val = 0x04;
 295                 break;
 296         case INVERSION_AUTO:
 297                 state->dnxt.inversion_val = 0x0C;
 298                 break;
 299         default:
 300                 return -EINVAL;
 301         }
 302
 303         state->dnxt.inversion = inversion;
 304
 305         return 0;
 306 }
 307
 308 /*
 309  * modfec (modulation and FEC)
 310  * ===========================
 311  *
 312  * MOD          FEC             mask/val    standard
 313  * ----         --------        ----------- --------
 314  * QPSK         FEC_1_2         0x02 0x02+X DVB-S
 315  * QPSK         FEC_2_3         0x04 0x02+X DVB-S
 316  * QPSK         FEC_3_4         0x08 0x02+X DVB-S
 317  * QPSK         FEC_4_5         0x10 0x02+X DVB-S (?)
 318  * QPSK         FEC_5_6         0x20 0x02+X DVB-S
 319  * QPSK         FEC_6_7         0x40 0x02+X DVB-S
 320  * QPSK         FEC_7_8         0x80 0x02+X DVB-S
 321  * QPSK         FEC_8_9         0x01 0x02+X DVB-S (?) (NOT SUPPORTED?)
 322  * QPSK         AUTO            0xff 0x02+X DVB-S
 323  *
 324  * For DVB-S high byte probably represents FEC
 325  * and low byte selects the modulator. The high
 326  * byte is search range mask. Bit 5 may turn
 327  * on DVB-S and remaining bits represent some
 328  * kind of calibration (how/what i do not know).
 329  *
 330  * Eg.(2/3) szap "Zone Horror"
 331  *
 332  * mask/val = 0x04, 0x20
 333  * status 1f | signal c3c0 | snr a333 | ber 00000098 | unc 0 | FE_HAS_LOCK
 334  *
 335  * mask/val = 0x04, 0x30
 336  * status 1f | signal c3c0 | snr a333 | ber 00000000 | unc 0 | FE_HAS_LOCK
 337  *
 338  * After tuning FECSTATUS contains actual FEC
 339  * in use numbered 1 through to 8 for 1/2 .. 2/3 etc
 340  *
 341  * NBC=NOT/NON BACKWARD COMPATIBLE WITH DVB-S (DVB-S2 only)
 342  *
 343  * NBC-QPSK     FEC_1_2         0x00, 0x04      DVB-S2
 344  * NBC-QPSK     FEC_3_5         0x00, 0x05      DVB-S2
 345  * NBC-QPSK     FEC_2_3         0x00, 0x06      DVB-S2
 346  * NBC-QPSK     FEC_3_4         0x00, 0x07      DVB-S2
 347  * NBC-QPSK     FEC_4_5         0x00, 0x08      DVB-S2
 348  * NBC-QPSK     FEC_5_6         0x00, 0x09      DVB-S2
 349  * NBC-QPSK     FEC_8_9         0x00, 0x0a      DVB-S2
 350  * NBC-QPSK     FEC_9_10        0x00, 0x0b      DVB-S2
 351  *
 352  * NBC-8PSK     FEC_3_5         0x00, 0x0c      DVB-S2
 353  * NBC-8PSK     FEC_2_3         0x00, 0x0d      DVB-S2
 354  * NBC-8PSK     FEC_3_4         0x00, 0x0e      DVB-S2
 355  * NBC-8PSK     FEC_5_6         0x00, 0x0f      DVB-S2
 356  * NBC-8PSK     FEC_8_9         0x00, 0x10      DVB-S2
 357  * NBC-8PSK     FEC_9_10        0x00, 0x11      DVB-S2
 358  *
 359  * For DVB-S2 low bytes selects both modulator
 360  * and FEC. High byte is meaningless here. To
 361  * set pilot, bit 6 (0x40) is set. When inspecting
 362  * FECSTATUS bit 7 (0x80) represents the pilot
 363  * selection whilst not tuned. When tuned, actual FEC
 364  * in use is found in FECSTATUS as per above. Pilot
 365  * value is reset.
 366  */
 367
 368 /* A table of modulation, fec and configuration bytes for the demod.
 369  * Not all S2 mmodulation schemes are support and not all rates with
 370  * a scheme are support. Especially, no auto detect when in S2 mode.
 371  */
 372 static struct cx24116_modfec {
 373         fe_delivery_system_t delivery_system;
 374         fe_modulation_t modulation;
 375         fe_code_rate_t fec;
 376         u8 mask;        /* In DVBS mode this is used to autodetect */
 377         u8 val;         /* Passed to the firmware to indicate mode selection */
 378 } CX24116_MODFEC_MODES[] = {
 379  /* QPSK. For unknown rates we set hardware to auto detect 0xfe 0x30 */
 380
 381  /*mod   fec       mask  val */
 382  { SYS_DVBS, QPSK, FEC_NONE, 0xfe, 0x30 },
 383  { SYS_DVBS, QPSK, FEC_1_2,  0x02, 0x2e }, /* 00000010 00101110 */
 384  { SYS_DVBS, QPSK, FEC_2_3,  0x04, 0x2f }, /* 00000100 00101111 */
 385  { SYS_DVBS, QPSK, FEC_3_4,  0x08, 0x30 }, /* 00001000 00110000 */
 386  { SYS_DVBS, QPSK, FEC_4_5,  0xfe, 0x30 }, /* 000?0000 ?        */
 387  { SYS_DVBS, QPSK, FEC_5_6,  0x20, 0x31 }, /* 00100000 00110001 */
 388  { SYS_DVBS, QPSK, FEC_6_7,  0xfe, 0x30 }, /* 0?000000 ?        */
 389  { SYS_DVBS, QPSK, FEC_7_8,  0x80, 0x32 }, /* 10000000 00110010 */
 390  { SYS_DVBS, QPSK, FEC_8_9,  0xfe, 0x30 }, /* 0000000? ?        */
 391  { SYS_DVBS, QPSK, FEC_AUTO, 0xfe, 0x30 },
 392  /* NBC-QPSK */
 393  { SYS_DVBS2, QPSK, FEC_1_2,  0x00, 0x04 },
 394  { SYS_DVBS2, QPSK, FEC_3_5,  0x00, 0x05 },
 395  { SYS_DVBS2, QPSK, FEC_2_3,  0x00, 0x06 },
 396  { SYS_DVBS2, QPSK, FEC_3_4,  0x00, 0x07 },
 397  { SYS_DVBS2, QPSK, FEC_4_5,  0x00, 0x08 },
 398  { SYS_DVBS2, QPSK, FEC_5_6,  0x00, 0x09 },
 399  { SYS_DVBS2, QPSK, FEC_8_9,  0x00, 0x0a },
 400  { SYS_DVBS2, QPSK, FEC_9_10, 0x00, 0x0b },
 401  /* 8PSK */
 402  { SYS_DVBS2, PSK_8, FEC_3_5,  0x00, 0x0c },
 403  { SYS_DVBS2, PSK_8, FEC_2_3,  0x00, 0x0d },
 404  { SYS_DVBS2, PSK_8, FEC_3_4,  0x00, 0x0e },
 405  { SYS_DVBS2, PSK_8, FEC_5_6,  0x00, 0x0f },
 406  { SYS_DVBS2, PSK_8, FEC_8_9,  0x00, 0x10 },
 407  { SYS_DVBS2, PSK_8, FEC_9_10, 0x00, 0x11 },
 408  /*
 409   * `val' can be found in the FECSTATUS register when tuning.
 410   * FECSTATUS will give the actual FEC in use if tuning was successful.
 411   */
 412 };
 413
 414 static int cx24116_lookup_fecmod(struct cx24116_state *state,
 415         fe_delivery_system_t d, fe_modulation_t m, fe_code_rate_t f)
 416 {
 417         int i, ret = -EOPNOTSUPP;
 418
 419         dprintk("%s(0x%02x,0x%02x)\n", __func__, m, f);
 420
 421         for (i = 0; i < ARRAY_SIZE(CX24116_MODFEC_MODES); i++) {
 422                 if ((d == CX24116_MODFEC_MODES[i].delivery_system) &&
 423                         (m == CX24116_MODFEC_MODES[i].modulation) &&
 424                         (f == CX24116_MODFEC_MODES[i].fec)) {
 425                                 ret = i;
 426                                 break;
 427                         }
 428         }
 429
 430         return ret;
 431 }
 432
 433 static int cx24116_set_fec(struct cx24116_state *state,
 434         fe_delivery_system_t delsys, fe_modulation_t mod, fe_code_rate_t fec)
 435 {
 436         int ret = 0;
 437
 438         dprintk("%s(0x%02x,0x%02x)\n", __func__, mod, fec);
 439
 440         ret = cx24116_lookup_fecmod(state, delsys, mod, fec);
 441
 442         if (ret < 0)
 443                 return ret;
 444
 445         state->dnxt.fec = fec;
 446         state->dnxt.fec_val = CX24116_MODFEC_MODES[ret].val;
 447         state->dnxt.fec_mask = CX24116_MODFEC_MODES[ret].mask;
 448         dprintk("%s() mask/val = 0x%02x/0x%02x\n", __func__,
 449                 state->dnxt.fec_mask, state->dnxt.fec_val);
 450
 451         return 0;
 452 }
 453
 454 static int cx24116_set_symbolrate(struct cx24116_state *state, u32 rate)
 455 {
 456         dprintk("%s(%d)\n", __func__, rate);
 457
 458         /*  check if symbol rate is within limits */
 459         if ((rate > state->frontend.ops.info.symbol_rate_max) ||
 460             (rate < state->frontend.ops.info.symbol_rate_min)) {
 461                 dprintk("%s() unsupported symbol_rate = %d\n", __func__, rate);
 462                 return -EOPNOTSUPP;
 463         }
 464
 465         state->dnxt.symbol_rate = rate;
 466         dprintk("%s() symbol_rate = %d\n", __func__, rate);
 467
 468         return 0;
 469 }
 470
 471 static int cx24116_load_firmware(struct dvb_frontend *fe,
 472         const struct firmware *fw);
 473
 474 static int cx24116_firmware_ondemand(struct dvb_frontend *fe)
 475 {
 476         struct cx24116_state *state = fe->demodulator_priv;
 477         const struct firmware *fw;
 478         int ret = 0;
 479
 480         dprintk("%s()\n", __func__);
 481
 482         if (cx24116_readreg(state, 0x20) > 0) {
 483
 484                 if (state->skip_fw_load)
 485                         return 0;
 486
 487                 /* Load firmware */
 488                 /* request the firmware, this will block until loaded */
 489                 printk(KERN_INFO "%s: Waiting for firmware upload (%s)...\n",
 490                         __func__, CX24116_DEFAULT_FIRMWARE);
 491                 ret = request_firmware(&fw, CX24116_DEFAULT_FIRMWARE,
 492                         &state->i2c->dev);
 493                 printk(KERN_INFO "%s: Waiting for firmware upload(2)...\n",
 494                         __func__);
 495                 if (ret) {
 496                         printk(KERN_ERR "%s: No firmware uploaded "
 497                                 "(timeout or file not found?)\n", __func__);
 498                         return ret;
 499                 }
 500
 501                 /* Make sure we don't recurse back through here
 502                  * during loading */
 503                 state->skip_fw_load = 1;
 504
 505                 ret = cx24116_load_firmware(fe, fw);
 506                 if (ret)
 507                         printk(KERN_ERR "%s: Writing firmware to device failed\n",
 508                                 __func__);
 509
 510                 release_firmware(fw);
 511
 512                 printk(KERN_INFO "%s: Firmware upload %s\n", __func__,
 513                         ret == 0 ? "complete" : "failed");
 514
 515                 /* Ensure firmware is always loaded if required */
 516                 state->skip_fw_load = 0;
 517         }
 518
 519         return ret;
 520 }
 521
 522 /* Take a basic firmware command structure, format it
 523  * and forward it for processing
 524  */
 525 static int cx24116_cmd_execute(struct dvb_frontend *fe, struct cx24116_cmd *cmd)
 526 {
 527         struct cx24116_state *state = fe->demodulator_priv;
 528         int i, ret;
 529
 530         dprintk("%s()\n", __func__);
 531
 532         /* Load the firmware if required */
 533         ret = cx24116_firmware_ondemand(fe);
 534         if (ret != 0) {
 535                 printk(KERN_ERR "%s(): Unable initialise the firmware\n",
 536                         __func__);
 537                 return ret;
 538         }
 539
 540         /* Write the command */
 541         for (i = 0; i < cmd->len ; i++) {
 542                 dprintk("%s: 0x%02x == 0x%02x\n", __func__, i, cmd->args[i]);
 543                 cx24116_writereg(state, i, cmd->args[i]);
 544         }
 545
 546         /* Start execution and wait for cmd to terminate */
 547         cx24116_writereg(state, CX24116_REG_EXECUTE, 0x01);
 548         while (cx24116_readreg(state, CX24116_REG_EXECUTE)) {
 549                 msleep(10);
 550                 if (i++ > 64) {
 551                         /* Avoid looping forever if the firmware does
 552                                 not respond */
 553                         printk(KERN_WARNING "%s() Firmware not responding\n",
 554                                 __func__);
 555                         return -EREMOTEIO;
 556                 }
 557         }
 558         return 0;
 559 }
 560
 561 static int cx24116_load_firmware(struct dvb_frontend *fe,
 562         const struct firmware *fw)
 563 {
 564         struct cx24116_state *state = fe->demodulator_priv;
 565         struct cx24116_cmd cmd;
 566         int i, ret;
 567         unsigned char vers[4];
 568
 569         dprintk("%s\n", __func__);
 570         dprintk("Firmware is %zu bytes (%02x %02x .. %02x %02x)\n",
 571                         fw->size,
 572                         fw->data[0],
 573                         fw->data[1],
 574                         fw->data[fw->size-2],
 575                         fw->data[fw->size-1]);
 576
 577         /* Toggle 88x SRST pin to reset demod */
 578         if (state->config->reset_device)
 579                 state->config->reset_device(fe);
 580
 581         /* Begin the firmware load process */
 582         /* Prepare the demod, load the firmware, cleanup after load */
 583
 584         /* Init PLL */
 585         cx24116_writereg(state, 0xE5, 0x00);
 586         cx24116_writereg(state, 0xF1, 0x08);
 587         cx24116_writereg(state, 0xF2, 0x13);
 588
 589         /* Start PLL */
 590         cx24116_writereg(state, 0xe0, 0x03);
 591         cx24116_writereg(state, 0xe0, 0x00);
 592
 593         /* Unknown */
 594         cx24116_writereg(state, CX24116_REG_CLKDIV, 0x46);
 595         cx24116_writereg(state, CX24116_REG_RATEDIV, 0x00);
 596
 597         /* Unknown */
 598         cx24116_writereg(state, 0xF0, 0x03);
 599         cx24116_writereg(state, 0xF4, 0x81);
 600         cx24116_writereg(state, 0xF5, 0x00);
 601         cx24116_writereg(state, 0xF6, 0x00);
 602
 603         /* write the entire firmware as one transaction */
 604         cx24116_writeregN(state, 0xF7, fw->data, fw->size);
 605
 606         cx24116_writereg(state, 0xF4, 0x10);
 607         cx24116_writereg(state, 0xF0, 0x00);
 608         cx24116_writereg(state, 0xF8, 0x06);
 609
 610         /* Firmware CMD 10: VCO config */
 611         cmd.args[0x00] = CMD_SET_VCO;
 612         cmd.args[0x01] = 0x05;
 613         cmd.args[0x02] = 0xdc;
 614         cmd.args[0x03] = 0xda;
 615         cmd.args[0x04] = 0xae;
 616         cmd.args[0x05] = 0xaa;
 617         cmd.args[0x06] = 0x04;
 618         cmd.args[0x07] = 0x9d;
 619         cmd.args[0x08] = 0xfc;
 620         cmd.args[0x09] = 0x06;
 621         cmd.len = 0x0a;
 622         ret = cx24116_cmd_execute(fe, &cmd);
 623         if (ret != 0)
 624                 return ret;
 625
 626         cx24116_writereg(state, CX24116_REG_SSTATUS, 0x00);
 627
 628         /* Firmware CMD 14: Tuner config */
 629         cmd.args[0x00] = CMD_TUNERINIT;
 630         cmd.args[0x01] = 0x00;
 631         cmd.args[0x02] = 0x00;
 632         cmd.len = 0x03;
 633         ret = cx24116_cmd_execute(fe, &cmd);
 634         if (ret != 0)
 635                 return ret;
 636
 637         cx24116_writereg(state, 0xe5, 0x00);
 638
 639         /* Firmware CMD 13: MPEG config */
 640         cmd.args[0x00] = CMD_MPEGCONFIG;
 641         cmd.args[0x01] = 0x01;
 642         cmd.args[0x02] = 0x75;
 643         cmd.args[0x03] = 0x00;
 644         if (state->config->mpg_clk_pos_pol)
 645                 cmd.args[0x04] = state->config->mpg_clk_pos_pol;
 646         else
 647                 cmd.args[0x04] = 0x02;
 648         cmd.args[0x05] = 0x00;
 649         cmd.len = 0x06;
 650         ret = cx24116_cmd_execute(fe, &cmd);
 651         if (ret != 0)
 652                 return ret;
 653
 654         /* Firmware CMD 35: Get firmware version */
 655         cmd.args[0x00] = CMD_UPDFWVERS;
 656         cmd.len = 0x02;
 657         for (i = 0; i < 4; i++) {
 658                 cmd.args[0x01] = i;
 659                 ret = cx24116_cmd_execute(fe, &cmd);
 660                 if (ret != 0)
 661                         return ret;
 662                 vers[i] = cx24116_readreg(state, CX24116_REG_MAILBOX);
 663         }
 664         printk(KERN_INFO "%s: FW version %i.%i.%i.%i\n", __func__,
 665                 vers[0], vers[1], vers[2], vers[3]);
 666
 667         return 0;
 668 }
 669
 670 static int cx24116_set_voltage(struct dvb_frontend *fe,
 671         fe_sec_voltage_t voltage)
 672 {
 673         /* The isl6421 module will override this function in the fops. */
 674         dprintk("%s() This should never appear if the isl6421 module "
 675                 "is loaded correctly\n", __func__);
 676
 677         return -EOPNOTSUPP;
 678 }
 679
 680 static int cx24116_read_status(struct dvb_frontend *fe, fe_status_t *status)
 681 {
 682         struct cx24116_state *state = fe->demodulator_priv;
 683
 684         int lock = cx24116_readreg(state, CX24116_REG_SSTATUS) &
 685                 CX24116_STATUS_MASK;
 686
 687         dprintk("%s: status = 0x%02x\n", __func__, lock);
 688
 689         *status = 0;
 690
 691         if (lock & CX24116_HAS_SIGNAL)
 692                 *status |= FE_HAS_SIGNAL;
 693         if (lock & CX24116_HAS_CARRIER)
 694                 *status |= FE_HAS_CARRIER;
 695         if (lock & CX24116_HAS_VITERBI)
 696                 *status |= FE_HAS_VITERBI;
 697         if (lock & CX24116_HAS_SYNCLOCK)
 698                 *status |= FE_HAS_SYNC | FE_HAS_LOCK;
 699
 700         return 0;
 701 }
 702
 703 static int cx24116_read_ber(struct dvb_frontend *fe, u32 *ber)
 704 {
 705         struct cx24116_state *state = fe->demodulator_priv;
 706
 707         dprintk("%s()\n", __func__);
 708
 709         *ber =  (cx24116_readreg(state, CX24116_REG_BER24) << 24) |
 710                 (cx24116_readreg(state, CX24116_REG_BER16) << 16) |
 711                 (cx24116_readreg(state, CX24116_REG_BER8)  << 8)  |
 712                  cx24116_readreg(state, CX24116_REG_BER0);
 713
 714         return 0;
 715 }
 716
 717 /* TODO Determine function and scale appropriately */
 718 static int cx24116_read_signal_strength(struct dvb_frontend *fe,
 719         u16 *signal_strength)
 720 {
 721         struct cx24116_state *state = fe->demodulator_priv;
 722         struct cx24116_cmd cmd;
 723         int ret;
 724         u16 sig_reading;
 725
 726         dprintk("%s()\n", __func__);
 727
 728         /* Firmware CMD 19: Get AGC */
 729         cmd.args[0x00] = CMD_GETAGC;
 730         cmd.len = 0x01;
 731         ret = cx24116_cmd_execute(fe, &cmd);
 732         if (ret != 0)
 733                 return ret;
 734
 735         sig_reading =
 736                 (cx24116_readreg(state,
 737                         CX24116_REG_SSTATUS) & CX24116_SIGNAL_MASK) |
 738                 (cx24116_readreg(state, CX24116_REG_SIGNAL) << 6);
 739         *signal_strength = 0 - sig_reading;
 740
 741         dprintk("%s: raw / cooked = 0x%04x / 0x%04x\n",
 742                 __func__, sig_reading, *signal_strength);
 743
 744         return 0;
 745 }
 746
 747 /* SNR (0..100)% = (sig & 0xf0) * 10 + (sig & 0x0f) * 10 / 16 */
 748 static int cx24116_read_snr_pct(struct dvb_frontend *fe, u16 *snr)
 749 {
 750         struct cx24116_state *state = fe->demodulator_priv;
 751         u8 snr_reading;
 752         static const u32 snr_tab[] = { /* 10 x Table (rounded up) */
 753                 0x00000, 0x0199A, 0x03333, 0x04ccD, 0x06667,
 754                 0x08000, 0x0999A, 0x0b333, 0x0cccD, 0x0e667,
 755                 0x10000, 0x1199A, 0x13333, 0x14ccD, 0x16667,
 756                 0x18000 };
 757
 758         dprintk("%s()\n", __func__);
 759
 760         snr_reading = cx24116_readreg(state, CX24116_REG_QUALITY0);
 761
 762         if (snr_reading >= 0xa0 /* 100% */)
 763                 *snr = 0xffff;
 764         else
 765                 *snr = snr_tab[(snr_reading & 0xf0) >> 4] +
 766                         (snr_tab[(snr_reading & 0x0f)] >> 4);
 767
 768         dprintk("%s: raw / cooked = 0x%02x / 0x%04x\n", __func__,
 769                 snr_reading, *snr);
 770
 771         return 0;
 772 }
 773
 774 /* The reelbox patches show the value in the registers represents
 775  * ESNO, from 0->30db (values 0->300). We provide this value by
 776  * default.
 777  */
 778 static int cx24116_read_snr_esno(struct dvb_frontend *fe, u16 *snr)
 779 {
 780         struct cx24116_state *state = fe->demodulator_priv;
 781
 782         dprintk("%s()\n", __func__);
 783
 784         *snr = cx24116_readreg(state, CX24116_REG_QUALITY8) << 8 |
 785                 cx24116_readreg(state, CX24116_REG_QUALITY0);
 786
 787         dprintk("%s: raw 0x%04x\n", __func__, *snr);
 788
 789         return 0;
 790 }
 791
 792 static int cx24116_read_snr(struct dvb_frontend *fe, u16 *snr)
 793 {
 794         if (esno_snr == 1)
 795                 return cx24116_read_snr_esno(fe, snr);
 796         else
 797                 return cx24116_read_snr_pct(fe, snr);
 798 }
 799
 800 static int cx24116_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
 801 {
 802         struct cx24116_state *state = fe->demodulator_priv;
 803
 804         dprintk("%s()\n", __func__);
 805
 806         *ucblocks = (cx24116_readreg(state, CX24116_REG_UCB8) << 8) |
 807                 cx24116_readreg(state, CX24116_REG_UCB0);
 808
 809         return 0;
 810 }
 811
 812 /* Overwrite the current tuning params, we are about to tune */
 813 static void cx24116_clone_params(struct dvb_frontend *fe)
 814 {
 815         struct cx24116_state *state = fe->demodulator_priv;
 816         memcpy(&state->dcur, &state->dnxt, sizeof(state->dcur));
 817 }
 818
 819 /* Wait for LNB */
 820 static int cx24116_wait_for_lnb(struct dvb_frontend *fe)
 821 {
 822         struct cx24116_state *state = fe->demodulator_priv;
 823         int i;
 824
 825         dprintk("%s() qstatus = 0x%02x\n", __func__,
 826                 cx24116_readreg(state, CX24116_REG_QSTATUS));
 827
 828         /* Wait for up to 300 ms */
 829         for (i = 0; i < 30 ; i++) {
 830                 if (cx24116_readreg(state, CX24116_REG_QSTATUS) & 0x20)
 831                         return 0;
 832                 msleep(10);
 833         }
 834
 835         dprintk("%s(): LNB not ready\n", __func__);
 836
 837         return -ETIMEDOUT; /* -EBUSY ? */
 838 }
 839
 840 static int cx24116_set_tone(struct dvb_frontend *fe,
 841         fe_sec_tone_mode_t tone)
 842 {
 843         struct cx24116_cmd cmd;
 844         int ret;
 845
 846         dprintk("%s(%d)\n", __func__, tone);
 847         if ((tone != SEC_TONE_ON) && (tone != SEC_TONE_OFF)) {
 848                 printk(KERN_ERR "%s: Invalid, tone=%d\n", __func__, tone);
 849                 return -EINVAL;
 850         }
 851
 852         /* Wait for LNB ready */
 853         ret = cx24116_wait_for_lnb(fe);
 854         if (ret != 0)
 855                 return ret;
 856
 857         /* Min delay time after DiSEqC send */
 858         msleep(15); /* XXX determine is FW does this, see send_diseqc/burst */
 859
 860         /* This is always done before the tone is set */
 861         cmd.args[0x00] = CMD_SET_TONEPRE;
 862         cmd.args[0x01] = 0x00;
 863         cmd.len = 0x02;
 864         ret = cx24116_cmd_execute(fe, &cmd);
 865         if (ret != 0)
 866                 return ret;
 867
 868         /* Now we set the tone */
 869         cmd.args[0x00] = CMD_SET_TONE;
 870         cmd.args[0x01] = 0x00;
 871         cmd.args[0x02] = 0x00;
 872
 873         switch (tone) {
 874         case SEC_TONE_ON:
 875                 dprintk("%s: setting tone on\n", __func__);
 876                 cmd.args[0x03] = 0x01;
 877                 break;
 878         case SEC_TONE_OFF:
 879                 dprintk("%s: setting tone off\n", __func__);
 880                 cmd.args[0x03] = 0x00;
 881                 break;
 882         }
 883         cmd.len = 0x04;
 884
 885         /* Min delay time before DiSEqC send */
 886         msleep(15); /* XXX determine is FW does this, see send_diseqc/burst */
 887
 888         return cx24116_cmd_execute(fe, &cmd);
 889 }
 890
 891 /* Initialise DiSEqC */
 892 static int cx24116_diseqc_init(struct dvb_frontend *fe)
 893 {
 894         struct cx24116_state *state = fe->demodulator_priv;
 895         struct cx24116_cmd cmd;
 896         int ret;
 897
 898         /* Firmware CMD 20: LNB/DiSEqC config */
 899         cmd.args[0x00] = CMD_LNBCONFIG;
 900         cmd.args[0x01] = 0x00;
 901         cmd.args[0x02] = 0x10;
 902         cmd.args[0x03] = 0x00;
 903         cmd.args[0x04] = 0x8f;
 904         cmd.args[0x05] = 0x28;
 905         cmd.args[0x06] = (toneburst == CX24116_DISEQC_TONEOFF) ? 0x00 : 0x01;
 906         cmd.args[0x07] = 0x01;
 907         cmd.len = 0x08;
 908         ret = cx24116_cmd_execute(fe, &cmd);
 909         if (ret != 0)
 910                 return ret;
 911
 912         /* Prepare a DiSEqC command */
 913         state->dsec_cmd.args[0x00] = CMD_LNBSEND;
 914
 915         /* DiSEqC burst */
 916         state->dsec_cmd.args[CX24116_DISEQC_BURST]  = CX24116_DISEQC_MINI_A;
 917
 918         /* Unknown */
 919         state->dsec_cmd.args[CX24116_DISEQC_ARG2_2] = 0x02;
 920         state->dsec_cmd.args[CX24116_DISEQC_ARG3_0] = 0x00;
 921         /* Continuation flag? */
 922         state->dsec_cmd.args[CX24116_DISEQC_ARG4_0] = 0x00;
 923
 924         /* DiSEqC message length */
 925         state->dsec_cmd.args[CX24116_DISEQC_MSGLEN] = 0x00;
 926
 927         /* Command length */
 928         state->dsec_cmd.len = CX24116_DISEQC_MSGOFS;
 929
 930         return 0;
 931 }
 932
 933 /* Send DiSEqC message with derived burst (hack) || previous burst */
 934 static int cx24116_send_diseqc_msg(struct dvb_frontend *fe,
 935         struct dvb_diseqc_master_cmd *d)
 936 {
 937         struct cx24116_state *state = fe->demodulator_priv;
 938         int i, ret;
 939
 940         /* Dump DiSEqC message */
 941         if (debug) {
 942                 printk(KERN_INFO "cx24116: %s(", __func__);
 943                 for (i = 0 ; i < d->msg_len ;) {
 944                         printk(KERN_INFO "0x%02x", d->msg[i]);
 945                         if (++i < d->msg_len)
 946                                 printk(KERN_INFO ", ");
 947                 }
 948                 printk(") toneburst=%d\n", toneburst);
 949         }
 950
 951         /* Validate length */
 952         if (d->msg_len > (CX24116_ARGLEN - CX24116_DISEQC_MSGOFS))
 953                 return -EINVAL;
 954
 955         /* DiSEqC message */
 956         for (i = 0; i < d->msg_len; i++)
 957                 state->dsec_cmd.args[CX24116_DISEQC_MSGOFS + i] = d->msg[i];
 958
 959         /* DiSEqC message length */
 960         state->dsec_cmd.args[CX24116_DISEQC_MSGLEN] = d->msg_len;
 961
 962         /* Command length */
 963         state->dsec_cmd.len = CX24116_DISEQC_MSGOFS +
 964                 state->dsec_cmd.args[CX24116_DISEQC_MSGLEN];
 965
 966         /* DiSEqC toneburst */
 967         if (toneburst == CX24116_DISEQC_MESGCACHE)
 968                 /* Message is cached */
 969                 return 0;
 970
 971         else if (toneburst == CX24116_DISEQC_TONEOFF)
 972                 /* Message is sent without burst */
 973                 state->dsec_cmd.args[CX24116_DISEQC_BURST] = 0;
 974
 975         else if (toneburst == CX24116_DISEQC_TONECACHE) {
 976                 /*
 977                  * Message is sent with derived else cached burst
 978                  *
 979                  * WRITE PORT GROUP COMMAND 38
 980                  *
 981                  * 0/A/A: E0 10 38 F0..F3
 982                  * 1/B/B: E0 10 38 F4..F7
 983                  * 2/C/A: E0 10 38 F8..FB
 984                  * 3/D/B: E0 10 38 FC..FF
 985                  *
 986                  * databyte[3]= 8421:8421
 987                  *              ABCD:WXYZ
 988                  *              CLR :SET
 989                  *
 990                  *              WX= PORT SELECT 0..3    (X=TONEBURST)
 991                  *              Y = VOLTAGE             (0=13V, 1=18V)
 992                  *              Z = BAND                (0=LOW, 1=HIGH(22K))
 993                  */
 994                 if (d->msg_len >= 4 && d->msg[2] == 0x38)
 995                         state->dsec_cmd.args[CX24116_DISEQC_BURST] =
 996                                 ((d->msg[3] & 4) >> 2);
 997                 if (debug)
 998                         dprintk("%s burst=%d\n", __func__,
 999                                 state->dsec_cmd.args[CX24116_DISEQC_BURST]);
1000         }
1001
1002         /* Wait for LNB ready */
1003         ret = cx24116_wait_for_lnb(fe);
1004         if (ret != 0)
1005                 return ret;
1006
1007         /* Wait for voltage/min repeat delay */
1008         msleep(100);
1009
1010         /* Command */
1011         ret = cx24116_cmd_execute(fe, &state->dsec_cmd);
1012         if (ret != 0)
1013                 return ret;
1014         /*
1015          * Wait for send
1016          *
1017          * Eutelsat spec:
1018          * >15ms delay          + (XXX determine if FW does this, see set_tone)
1019          *  13.5ms per byte     +
1020          * >15ms delay          +
1021          *  12.5ms burst        +
1022          * >15ms delay            (XXX determine if FW does this, see set_tone)
1023          */
1024         msleep((state->dsec_cmd.args[CX24116_DISEQC_MSGLEN] << 4) +
1025                 ((toneburst == CX24116_DISEQC_TONEOFF) ? 30 : 60));
1026
1027         return 0;
1028 }
1029
1030 /* Send DiSEqC burst */
1031 static int cx24116_diseqc_send_burst(struct dvb_frontend *fe,
1032         fe_sec_mini_cmd_t burst)
1033 {
1034         struct cx24116_state *state = fe->demodulator_priv;
1035         int ret;
1036
1037         dprintk("%s(%d) toneburst=%d\n", __func__, burst, toneburst);
1038
1039         /* DiSEqC burst */
1040         if (burst == SEC_MINI_A)
1041                 state->dsec_cmd.args[CX24116_DISEQC_BURST] =
1042                         CX24116_DISEQC_MINI_A;
1043         else if (burst == SEC_MINI_B)
1044                 state->dsec_cmd.args[CX24116_DISEQC_BURST] =
1045                         CX24116_DISEQC_MINI_B;
1046         else
1047                 return -EINVAL;
1048
1049         /* DiSEqC toneburst */
1050         if (toneburst != CX24116_DISEQC_MESGCACHE)
1051                 /* Burst is cached */
1052                 return 0;
1053
1054         /* Burst is to be sent with cached message */
1055
1056         /* Wait for LNB ready */
1057         ret = cx24116_wait_for_lnb(fe);
1058         if (ret != 0)
1059                 return ret;
1060
1061         /* Wait for voltage/min repeat delay */
1062         msleep(100);
1063
1064         /* Command */
1065         ret = cx24116_cmd_execute(fe, &state->dsec_cmd);
1066         if (ret != 0)
1067                 return ret;
1068
1069         /*
1070          * Wait for send
1071          *
1072          * Eutelsat spec:
1073          * >15ms delay          + (XXX determine if FW does this, see set_tone)
1074          *  13.5ms per byte     +
1075          * >15ms delay          +
1076          *  12.5ms burst        +
1077          * >15ms delay            (XXX determine if FW does this, see set_tone)
1078          */
1079         msleep((state->dsec_cmd.args[CX24116_DISEQC_MSGLEN] << 4) + 60);
1080
1081         return 0;
1082 }
1083
1084 static void cx24116_release(struct dvb_frontend *fe)
1085 {
1086         struct cx24116_state *state = fe->demodulator_priv;
1087         dprintk("%s\n", __func__);
1088         kfree(state);
1089 }
1090
1091 static struct dvb_frontend_ops cx24116_ops;
1092
1093 struct dvb_frontend *cx24116_attach(const struct cx24116_config *config,
1094         struct i2c_adapter *i2c)
1095 {
1096         struct cx24116_state *state = NULL;
1097         int ret;
1098
1099         dprintk("%s\n", __func__);
1100
1101         /* allocate memory for the internal state */
1102         state = kmalloc(sizeof(struct cx24116_state), GFP_KERNEL);
1103         if (state == NULL)
1104                 goto error1;
1105
1106         /* setup the state */
1107         memset(state, 0, sizeof(struct cx24116_state));
1108
1109         state->config = config;
1110         state->i2c = i2c;
1111
1112         /* check if the demod is present */
1113         ret = (cx24116_readreg(state, 0xFF) << 8) |
1114                 cx24116_readreg(state, 0xFE);
1115         if (ret != 0x0501) {
1116                 printk(KERN_INFO "Invalid probe, probably not a CX24116 device\n");
1117                 goto error2;
1118         }
1119
1120         /* create dvb_frontend */
1121         memcpy(&state->frontend.ops, &cx24116_ops,
1122                 sizeof(struct dvb_frontend_ops));
1123         state->frontend.demodulator_priv = state;
1124         return &state->frontend;
1125
1126 error2: kfree(state);
1127 error1: return NULL;
1128 }
1129 EXPORT_SYMBOL(cx24116_attach);
1130
1131 /*
1132  * Initialise or wake up device
1133  *
1134  * Power config will reset and load initial firmware if required
1135  */
1136 static int cx24116_initfe(struct dvb_frontend *fe)
1137 {
1138         struct cx24116_state *state = fe->demodulator_priv;
1139         struct cx24116_cmd cmd;
1140         int ret;
1141
1142         dprintk("%s()\n", __func__);
1143
1144         /* Power on */
1145         cx24116_writereg(state, 0xe0, 0);
1146         cx24116_writereg(state, 0xe1, 0);
1147         cx24116_writereg(state, 0xea, 0);
1148
1149         /* Firmware CMD 36: Power config */
1150         cmd.args[0x00] = CMD_TUNERSLEEP;
1151         cmd.args[0x01] = 0;
1152         cmd.len = 0x02;
1153         ret = cx24116_cmd_execute(fe, &cmd);
1154         if (ret != 0)
1155                 return ret;
1156
1157         return cx24116_diseqc_init(fe);
1158 }
1159
1160 /*
1161  * Put device to sleep
1162  */
1163 static int cx24116_sleep(struct dvb_frontend *fe)
1164 {
1165         struct cx24116_state *state = fe->demodulator_priv;
1166         struct cx24116_cmd cmd;
1167         int ret;
1168
1169         dprintk("%s()\n", __func__);
1170
1171         /* Firmware CMD 36: Power config */
1172         cmd.args[0x00] = CMD_TUNERSLEEP;
1173         cmd.args[0x01] = 1;
1174         cmd.len = 0x02;
1175         ret = cx24116_cmd_execute(fe, &cmd);
1176         if (ret != 0)
1177                 return ret;
1178
1179         /* Power off (Shutdown clocks) */
1180         cx24116_writereg(state, 0xea, 0xff);
1181         cx24116_writereg(state, 0xe1, 1);
1182         cx24116_writereg(state, 0xe0, 1);
1183
1184         return 0;
1185 }
1186
1187 static int cx24116_set_property(struct dvb_frontend *fe,
1188         struct dtv_property *tvp)
1189 {
1190         dprintk("%s(..)\n", __func__);
1191         return 0;
1192 }
1193
1194 static int cx24116_get_property(struct dvb_frontend *fe,
1195         struct dtv_property *tvp)
1196 {
1197         dprintk("%s(..)\n", __func__);
1198         return 0;
1199 }
1200
1201 /* dvb-core told us to tune, the tv property cache will be complete,
1202  * it's safe for is to pull values and use them for tuning purposes.
1203  */
1204 static int cx24116_set_frontend(struct dvb_frontend *fe,
1205         struct dvb_frontend_parameters *p)
1206 {
1207         struct cx24116_state *state = fe->demodulator_priv;
1208         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
1209         struct cx24116_cmd cmd;
1210         fe_status_t tunerstat;
1211         int i, status, ret, retune = 1;
1212
1213         dprintk("%s()\n", __func__);
1214
1215         switch (c->delivery_system) {
1216         case SYS_DVBS:
1217                 dprintk("%s: DVB-S delivery system selected\n", __func__);
1218
1219                 /* Only QPSK is supported for DVB-S */
1220                 if (c->modulation != QPSK) {
1221                         dprintk("%s: unsupported modulation selected (%d)\n",
1222                                 __func__, c->modulation);
1223                         return -EOPNOTSUPP;
1224                 }
1225
1226                 /* Pilot doesn't exist in DVB-S, turn bit off */
1227                 state->dnxt.pilot_val = CX24116_PILOT_OFF;
1228
1229                 /* DVB-S only supports 0.35 */
1230                 if (c->rolloff != ROLLOFF_35) {
1231                         dprintk("%s: unsupported rolloff selected (%d)\n",
1232                                 __func__, c->rolloff);
1233                         return -EOPNOTSUPP;
1234                 }
1235                 state->dnxt.rolloff_val = CX24116_ROLLOFF_035;
1236                 break;
1237
1238         case SYS_DVBS2:
1239                 dprintk("%s: DVB-S2 delivery system selected\n", __func__);
1240
1241                 /*
1242                  * NBC 8PSK/QPSK with DVB-S is supported for DVB-S2,
1243                  * but not hardware auto detection
1244                  */
1245                 if (c->modulation != PSK_8 && c->modulation != QPSK) {
1246                         dprintk("%s: unsupported modulation selected (%d)\n",
1247                                 __func__, c->modulation);
1248                         return -EOPNOTSUPP;
1249                 }
1250
1251                 switch (c->pilot) {
1252                 case PILOT_AUTO:        /* Not supported but emulated */
1253                         state->dnxt.pilot_val = (c->modulation == QPSK)
1254                                 ? CX24116_PILOT_OFF : CX24116_PILOT_ON;
1255                         retune++;
1256                         break;
1257                 case PILOT_OFF:
1258                         state->dnxt.pilot_val = CX24116_PILOT_OFF;
1259                         break;
1260                 case PILOT_ON:
1261                         state->dnxt.pilot_val = CX24116_PILOT_ON;
1262                         break;
1263                 default:
1264                         dprintk("%s: unsupported pilot mode selected (%d)\n",
1265                                 __func__, c->pilot);
1266                         return -EOPNOTSUPP;
1267                 }
1268
1269                 switch (c->rolloff) {
1270                 case ROLLOFF_20:
1271                         state->dnxt.rolloff_val = CX24116_ROLLOFF_020;
1272                         break;
1273                 case ROLLOFF_25:
1274                         state->dnxt.rolloff_val = CX24116_ROLLOFF_025;
1275                         break;
1276                 case ROLLOFF_35:
1277                         state->dnxt.rolloff_val = CX24116_ROLLOFF_035;
1278                         break;
1279                 case ROLLOFF_AUTO:      /* Rolloff must be explicit */
1280                 default:
1281                         dprintk("%s: unsupported rolloff selected (%d)\n",
1282                                 __func__, c->rolloff);
1283                         return -EOPNOTSUPP;
1284                 }
1285                 break;
1286
1287         default:
1288                 dprintk("%s: unsupported delivery system selected (%d)\n",
1289                         __func__, c->delivery_system);
1290                 return -EOPNOTSUPP;
1291         }
1292         state->dnxt.delsys = c->delivery_system;
1293         state->dnxt.modulation = c->modulation;
1294         state->dnxt.frequency = c->frequency;
1295         state->dnxt.pilot = c->pilot;
1296         state->dnxt.rolloff = c->rolloff;
1297
1298         ret = cx24116_set_inversion(state, c->inversion);
1299         if (ret !=  0)
1300                 return ret;
1301
1302         /* FEC_NONE/AUTO for DVB-S2 is not supported and detected here */
1303         ret = cx24116_set_fec(state, c->delivery_system, c->modulation, c->fec_inner);
1304         if (ret !=  0)
1305                 return ret;
1306
1307         ret = cx24116_set_symbolrate(state, c->symbol_rate);
1308         if (ret !=  0)
1309                 return ret;
1310
1311         /* discard the 'current' tuning parameters and prepare to tune */
1312         cx24116_clone_params(fe);
1313
1314         dprintk("%s:   delsys      = %d\n", __func__, state->dcur.delsys);
1315         dprintk("%s:   modulation  = %d\n", __func__, state->dcur.modulation);
1316         dprintk("%s:   frequency   = %d\n", __func__, state->dcur.frequency);
1317         dprintk("%s:   pilot       = %d (val = 0x%02x)\n", __func__,
1318                 state->dcur.pilot, state->dcur.pilot_val);
1319         dprintk("%s:   retune      = %d\n", __func__, retune);
1320         dprintk("%s:   rolloff     = %d (val = 0x%02x)\n", __func__,
1321                 state->dcur.rolloff, state->dcur.rolloff_val);
1322         dprintk("%s:   symbol_rate = %d\n", __func__, state->dcur.symbol_rate);
1323         dprintk("%s:   FEC         = %d (mask/val = 0x%02x/0x%02x)\n", __func__,
1324                 state->dcur.fec, state->dcur.fec_mask, state->dcur.fec_val);
1325         dprintk("%s:   Inversion   = %d (val = 0x%02x)\n", __func__,
1326                 state->dcur.inversion, state->dcur.inversion_val);
1327
1328         /* This is also done in advise/acquire on HVR4000 but not on LITE */
1329         if (state->config->set_ts_params)
1330                 state->config->set_ts_params(fe, 0);
1331
1332         /* Set/Reset B/W */
1333         cmd.args[0x00] = CMD_BANDWIDTH;
1334         cmd.args[0x01] = 0x01;
1335         cmd.len = 0x02;
1336         ret = cx24116_cmd_execute(fe, &cmd);
1337         if (ret != 0)
1338                 return ret;
1339
1340         /* Prepare a tune request */
1341         cmd.args[0x00] = CMD_TUNEREQUEST;
1342
1343         /* Frequency */
1344         cmd.args[0x01] = (state->dcur.frequency & 0xff0000) >> 16;
1345         cmd.args[0x02] = (state->dcur.frequency & 0x00ff00) >> 8;
1346         cmd.args[0x03] = (state->dcur.frequency & 0x0000ff);
1347
1348         /* Symbol Rate */
1349         cmd.args[0x04] = ((state->dcur.symbol_rate / 1000) & 0xff00) >> 8;
1350         cmd.args[0x05] = ((state->dcur.symbol_rate / 1000) & 0x00ff);
1351
1352         /* Automatic Inversion */
1353         cmd.args[0x06] = state->dcur.inversion_val;
1354
1355         /* Modulation / FEC / Pilot */
1356         cmd.args[0x07] = state->dcur.fec_val | state->dcur.pilot_val;
1357
1358         cmd.args[0x08] = CX24116_SEARCH_RANGE_KHZ >> 8;
1359         cmd.args[0x09] = CX24116_SEARCH_RANGE_KHZ & 0xff;
1360         cmd.args[0x0a] = 0x00;
1361         cmd.args[0x0b] = 0x00;
1362         cmd.args[0x0c] = state->dcur.rolloff_val;
1363         cmd.args[0x0d] = state->dcur.fec_mask;
1364
1365         if (state->dcur.symbol_rate > 30000000) {
1366                 cmd.args[0x0e] = 0x04;
1367                 cmd.args[0x0f] = 0x00;
1368                 cmd.args[0x10] = 0x01;
1369                 cmd.args[0x11] = 0x77;
1370                 cmd.args[0x12] = 0x36;
1371                 cx24116_writereg(state, CX24116_REG_CLKDIV, 0x44);
1372                 cx24116_writereg(state, CX24116_REG_RATEDIV, 0x01);
1373         } else {
1374                 cmd.args[0x0e] = 0x06;
1375                 cmd.args[0x0f] = 0x00;
1376                 cmd.args[0x10] = 0x00;
1377                 cmd.args[0x11] = 0xFA;
1378                 cmd.args[0x12] = 0x24;
1379                 cx24116_writereg(state, CX24116_REG_CLKDIV, 0x46);
1380                 cx24116_writereg(state, CX24116_REG_RATEDIV, 0x00);
1381         }
1382
1383         cmd.len = 0x13;
1384
1385         /* We need to support pilot and non-pilot tuning in the
1386          * driver automatically. This is a workaround for because
1387          * the demod does not support autodetect.
1388          */
1389         do {
1390                 /* Reset status register */
1391                 status = cx24116_readreg(state, CX24116_REG_SSTATUS)
1392                         & CX24116_SIGNAL_MASK;
1393                 cx24116_writereg(state, CX24116_REG_SSTATUS, status);
1394
1395                 /* Tune */
1396                 ret = cx24116_cmd_execute(fe, &cmd);
1397                 if (ret != 0)
1398                         break;
1399
1400                 /*
1401                  * Wait for up to 500 ms before retrying
1402                  *
1403                  * If we are able to tune then generally it occurs within 100ms.
1404                  * If it takes longer, try a different toneburst setting.
1405                  */
1406                 for (i = 0; i < 50 ; i++) {
1407                         cx24116_read_status(fe, &tunerstat);
1408                         status = tunerstat & (FE_HAS_SIGNAL | FE_HAS_SYNC);
1409                         if (status == (FE_HAS_SIGNAL | FE_HAS_SYNC)) {
1410                                 dprintk("%s: Tuned\n", __func__);
1411                                 goto tuned;
1412                         }
1413                         msleep(10);
1414                 }
1415
1416                 dprintk("%s: Not tuned\n", __func__);
1417
1418                 /* Toggle pilot bit when in auto-pilot */
1419                 if (state->dcur.pilot == PILOT_AUTO)
1420                         cmd.args[0x07] ^= CX24116_PILOT_ON;
1421         } while (--retune);
1422
1423 tuned:  /* Set/Reset B/W */
1424         cmd.args[0x00] = CMD_BANDWIDTH;
1425         cmd.args[0x01] = 0x00;
1426         cmd.len = 0x02;
1427         ret = cx24116_cmd_execute(fe, &cmd);
1428         if (ret != 0)
1429                 return ret;
1430
1431         return ret;
1432 }
1433
1434 static int cx24116_tune(struct dvb_frontend *fe, struct dvb_frontend_parameters *params,
1435         unsigned int mode_flags, unsigned int *delay, fe_status_t *status)
1436 {
1437         *delay = HZ / 5;
1438         if (params) {
1439                 int ret = cx24116_set_frontend(fe, params);
1440                 if (ret)
1441                         return ret;
1442         }
1443         return cx24116_read_status(fe, status);
1444 }
1445
1446 static int cx24116_get_algo(struct dvb_frontend *fe)
1447 {
1448         return DVBFE_ALGO_HW;
1449 }
1450
1451 static struct dvb_frontend_ops cx24116_ops = {
1452
1453         .info = {
1454                 .name = "Conexant CX24116/CX24118",
1455                 .type = FE_QPSK,
1456                 .frequency_min = 950000,
1457                 .frequency_max = 2150000,
1458                 .frequency_stepsize = 1011, /* kHz for QPSK frontends */
1459                 .frequency_tolerance = 5000,
1460                 .symbol_rate_min = 1000000,
1461                 .symbol_rate_max = 45000000,
1462                 .caps = FE_CAN_INVERSION_AUTO |
1463                         FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
1464                         FE_CAN_FEC_4_5 | FE_CAN_FEC_5_6 | FE_CAN_FEC_6_7 |
1465                         FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
1466                         FE_CAN_2G_MODULATION |
1467                         FE_CAN_QPSK | FE_CAN_RECOVER
1468         },
1469
1470         .release = cx24116_release,
1471
1472         .init = cx24116_initfe,
1473         .sleep = cx24116_sleep,
1474         .read_status = cx24116_read_status,
1475         .read_ber = cx24116_read_ber,
1476         .read_signal_strength = cx24116_read_signal_strength,
1477         .read_snr = cx24116_read_snr,
1478         .read_ucblocks = cx24116_read_ucblocks,
1479         .set_tone = cx24116_set_tone,
1480         .set_voltage = cx24116_set_voltage,
1481         .diseqc_send_master_cmd = cx24116_send_diseqc_msg,
1482         .diseqc_send_burst = cx24116_diseqc_send_burst,
1483         .get_frontend_algo = cx24116_get_algo,
1484         .tune = cx24116_tune,
1485
1486         .set_property = cx24116_set_property,
1487         .get_property = cx24116_get_property,
1488         .set_frontend = cx24116_set_frontend,
1489 };
1490
1491 MODULE_DESCRIPTION("DVB Frontend module for Conexant cx24116/cx24118 hardware");
1492 MODULE_AUTHOR("Steven Toth");
1493 MODULE_LICENSE("GPL");
1494