drivers/media/dvb/frontends/cx24123.c

   1 /*
   2     Conexant cx24123/cx24109 - DVB QPSK Satellite demod/tuner driver
   3
   4     Copyright (C) 2005 Steven Toth <stoth@hauppauge.com>
   5
   6     Support for KWorld DVB-S 100 by Vadim Catana <skystar@moldova.cc>
   7
   8     This program is free software; you can redistribute it and/or modify
   9     it under the terms of the GNU General Public License as published by
  10     the Free Software Foundation; either version 2 of the License, or
  11     (at your option) any later version.
  12
  13     This program is distributed in the hope that it will be useful,
  14     but WITHOUT ANY WARRANTY; without even the implied warranty of
  15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16     GNU General Public License for more details.
  17
  18     You should have received a copy of the GNU General Public License
  19     along with this program; if not, write to the Free Software
  20     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include <linux/slab.h>
  24 #include <linux/kernel.h>
  25 #include <linux/module.h>
  26 #include <linux/moduleparam.h>
  27 #include <linux/init.h>
  28
  29 #include "dvb_frontend.h"
  30 #include "cx24123.h"
  31
  32 #define XTAL 10111000
  33
  34 static int debug;
  35 #define dprintk(args...) \
  36         do { \
  37                 if (debug) printk (KERN_DEBUG "cx24123: " args); \
  38         } while (0)
  39
  40 struct cx24123_state
  41 {
  42         struct i2c_adapter* i2c;
  43         struct dvb_frontend_ops ops;
  44         const struct cx24123_config* config;
  45
  46         struct dvb_frontend frontend;
  47
  48         u32 lastber;
  49         u16 snr;
  50         u8  lnbreg;
  51
  52         /* Some PLL specifics for tuning */
  53         u32 VCAarg;
  54         u32 VGAarg;
  55         u32 bandselectarg;
  56         u32 pllarg;
  57         u32 FILTune;
  58
  59         /* The Demod/Tuner can't easily provide these, we cache them */
  60         u32 currentfreq;
  61         u32 currentsymbolrate;
  62 };
  63
  64 /* Various tuner defaults need to be established for a given symbol rate Sps */
  65 static struct
  66 {
  67         u32 symbolrate_low;
  68         u32 symbolrate_high;
  69         u32 VCAprogdata;
  70         u32 VGAprogdata;
  71         u32 FILTune;
  72 } cx24123_AGC_vals[] =
  73 {
  74         {
  75                 .symbolrate_low         = 1000000,
  76                 .symbolrate_high        = 4999999,
  77                 /* the specs recommend other values for VGA offsets,
  78                    but tests show they are wrong */
  79                 .VGAprogdata            = (1 << 19) | (0x180 << 9) | 0x1e0,
  80                 .VCAprogdata            = (2 << 19) | (0x07 << 9) | 0x07,
  81                 .FILTune                = 0x27f /* 0.41 V */
  82         },
  83         {
  84                 .symbolrate_low         =  5000000,
  85                 .symbolrate_high        = 14999999,
  86                 .VGAprogdata            = (1 << 19) | (0x180 << 9) | 0x1e0,
  87                 .VCAprogdata            = (2 << 19) | (0x07 << 9) | 0x1f,
  88                 .FILTune                = 0x317 /* 0.90 V */
  89         },
  90         {
  91                 .symbolrate_low         = 15000000,
  92                 .symbolrate_high        = 45000000,
  93                 .VGAprogdata            = (1 << 19) | (0x100 << 9) | 0x180,
  94                 .VCAprogdata            = (2 << 19) | (0x07 << 9) | 0x3f,
  95                 .FILTune                = 0x145 /* 2.70 V */
  96         },
  97 };
  98
  99 /*
 100  * Various tuner defaults need to be established for a given frequency kHz.
 101  * fixme: The bounds on the bands do not match the doc in real life.
 102  * fixme: Some of them have been moved, other might need adjustment.
 103  */
 104 static struct
 105 {
 106         u32 freq_low;
 107         u32 freq_high;
 108         u32 VCOdivider;
 109         u32 progdata;
 110 } cx24123_bandselect_vals[] =
 111 {
 112         {
 113                 .freq_low       = 950000,
 114                 .freq_high      = 1018999,
 115                 .VCOdivider     = 4,
 116                 .progdata       = (0 << 18) | (0 << 9) | 0x40,
 117         },
 118         {
 119                 .freq_low       = 1019000,
 120                 .freq_high      = 1074999,
 121                 .VCOdivider     = 4,
 122                 .progdata       = (0 << 18) | (0 << 9) | 0x80,
 123         },
 124         {
 125                 .freq_low       = 1075000,
 126                 .freq_high      = 1227999,
 127                 .VCOdivider     = 2,
 128                 .progdata       = (0 << 18) | (1 << 9) | 0x01,
 129         },
 130         {
 131                 .freq_low       = 1228000,
 132                 .freq_high      = 1349999,
 133                 .VCOdivider     = 2,
 134                 .progdata       = (0 << 18) | (1 << 9) | 0x02,
 135         },
 136         {
 137                 .freq_low       = 1350000,
 138                 .freq_high      = 1481999,
 139                 .VCOdivider     = 2,
 140                 .progdata       = (0 << 18) | (1 << 9) | 0x04,
 141         },
 142         {
 143                 .freq_low       = 1482000,
 144                 .freq_high      = 1595999,
 145                 .VCOdivider     = 2,
 146                 .progdata       = (0 << 18) | (1 << 9) | 0x08,
 147         },
 148         {
 149                 .freq_low       = 1596000,
 150                 .freq_high      = 1717999,
 151                 .VCOdivider     = 2,
 152                 .progdata       = (0 << 18) | (1 << 9) | 0x10,
 153         },
 154         {
 155                 .freq_low       = 1718000,
 156                 .freq_high      = 1855999,
 157                 .VCOdivider     = 2,
 158                 .progdata       = (0 << 18) | (1 << 9) | 0x20,
 159         },
 160         {
 161                 .freq_low       = 1856000,
 162                 .freq_high      = 2035999,
 163                 .VCOdivider     = 2,
 164                 .progdata       = (0 << 18) | (1 << 9) | 0x40,
 165         },
 166         {
 167                 .freq_low       = 2036000,
 168                 .freq_high      = 2149999,
 169                 .VCOdivider     = 2,
 170                 .progdata       = (0 << 18) | (1 << 9) | 0x80,
 171         },
 172 };
 173
 174 static struct {
 175         u8 reg;
 176         u8 data;
 177 } cx24123_regdata[] =
 178 {
 179         {0x00, 0x03}, /* Reset system */
 180         {0x00, 0x00}, /* Clear reset */
 181         {0x03, 0x07}, /* QPSK, DVB, Auto Acquisition (default) */
 182         {0x04, 0x10}, /* MPEG */
 183         {0x05, 0x04}, /* MPEG */
 184         {0x06, 0x31}, /* MPEG (default) */
 185         {0x0b, 0x00}, /* Freq search start point (default) */
 186         {0x0c, 0x00}, /* Demodulator sample gain (default) */
 187         {0x0d, 0x02}, /* Frequency search range = Fsymbol / 4 (default) */
 188         {0x0e, 0x03}, /* Default non-inverted, FEC 3/4 (default) */
 189         {0x0f, 0xfe}, /* FEC search mask (all supported codes) */
 190         {0x10, 0x01}, /* Default search inversion, no repeat (default) */
 191         {0x16, 0x00}, /* Enable reading of frequency */
 192         {0x17, 0x01}, /* Enable EsNO Ready Counter */
 193         {0x1c, 0x80}, /* Enable error counter */
 194         {0x20, 0x00}, /* Tuner burst clock rate = 500KHz */
 195         {0x21, 0x15}, /* Tuner burst mode, word length = 0x15 */
 196         {0x28, 0x00}, /* Enable FILTERV with positive pol., DiSEqC 2.x off */
 197         {0x29, 0x00}, /* DiSEqC LNB_DC off */
 198         {0x2a, 0xb0}, /* DiSEqC Parameters (default) */
 199         {0x2b, 0x73}, /* DiSEqC Tone Frequency (default) */
 200         {0x2c, 0x00}, /* DiSEqC Message (0x2c - 0x31) */
 201         {0x2d, 0x00},
 202         {0x2e, 0x00},
 203         {0x2f, 0x00},
 204         {0x30, 0x00},
 205         {0x31, 0x00},
 206         {0x32, 0x8c}, /* DiSEqC Parameters (default) */
 207         {0x33, 0x00}, /* Interrupts off (0x33 - 0x34) */
 208         {0x34, 0x00},
 209         {0x35, 0x03}, /* DiSEqC Tone Amplitude (default) */
 210         {0x36, 0x02}, /* DiSEqC Parameters (default) */
 211         {0x37, 0x3a}, /* DiSEqC Parameters (default) */
 212         {0x3a, 0x00}, /* Enable AGC accumulator (for signal strength) */
 213         {0x44, 0x00}, /* Constellation (default) */
 214         {0x45, 0x00}, /* Symbol count (default) */
 215         {0x46, 0x0d}, /* Symbol rate estimator on (default) */
 216         {0x56, 0x41}, /* Various (default) */
 217         {0x57, 0xff}, /* Error Counter Window (default) */
 218         {0x67, 0x83}, /* Non-DCII symbol clock */
 219 };
 220
 221 static int cx24123_writereg(struct cx24123_state* state, int reg, int data)
 222 {
 223         u8 buf[] = { reg, data };
 224         struct i2c_msg msg = { .addr = state->config->demod_address, .flags = 0, .buf = buf, .len = 2 };
 225         int err;
 226
 227         if (debug>1)
 228                 printk("cx24123: %s:  write reg 0x%02x, value 0x%02x\n",
 229                                                 __FUNCTION__,reg, data);
 230
 231         if ((err = i2c_transfer(state->i2c, &msg, 1)) != 1) {
 232                 printk("%s: writereg error(err == %i, reg == 0x%02x,"
 233                          " data == 0x%02x)\n", __FUNCTION__, err, reg, data);
 234                 return -EREMOTEIO;
 235         }
 236
 237         return 0;
 238 }
 239
 240 static int cx24123_writelnbreg(struct cx24123_state* state, int reg, int data)
 241 {
 242         u8 buf[] = { reg, data };
 243         /* fixme: put the intersil addr int the config */
 244         struct i2c_msg msg = { .addr = 0x08, .flags = 0, .buf = buf, .len = 2 };
 245         int err;
 246
 247         if (debug>1)
 248                 printk("cx24123: %s:  writeln addr=0x08, reg 0x%02x, value 0x%02x\n",
 249                                                 __FUNCTION__,reg, data);
 250
 251         if ((err = i2c_transfer(state->i2c, &msg, 1)) != 1) {
 252                 printk("%s: writelnbreg error (err == %i, reg == 0x%02x,"
 253                          " data == 0x%02x)\n", __FUNCTION__, err, reg, data);
 254                 return -EREMOTEIO;
 255         }
 256
 257         /* cache the write, no way to read back */
 258         state->lnbreg = data;
 259
 260         return 0;
 261 }
 262
 263 static int cx24123_readreg(struct cx24123_state* state, u8 reg)
 264 {
 265         int ret;
 266         u8 b0[] = { reg };
 267         u8 b1[] = { 0 };
 268         struct i2c_msg msg[] = {
 269                 { .addr = state->config->demod_address, .flags = 0, .buf = b0, .len = 1 },
 270                 { .addr = state->config->demod_address, .flags = I2C_M_RD, .buf = b1, .len = 1 }
 271         };
 272
 273         ret = i2c_transfer(state->i2c, msg, 2);
 274
 275         if (ret != 2) {
 276                 printk("%s: reg=0x%x (error=%d)\n", __FUNCTION__, reg, ret);
 277                 return ret;
 278         }
 279
 280         if (debug>1)
 281                 printk("cx24123: read reg 0x%02x, value 0x%02x\n",reg, ret);
 282
 283         return b1[0];
 284 }
 285
 286 static int cx24123_readlnbreg(struct cx24123_state* state, u8 reg)
 287 {
 288         return state->lnbreg;
 289 }
 290
 291 static int cx24123_set_inversion(struct cx24123_state* state, fe_spectral_inversion_t inversion)
 292 {
 293         u8 nom_reg = cx24123_readreg(state, 0x0e);
 294         u8 auto_reg = cx24123_readreg(state, 0x10);
 295
 296         switch (inversion) {
 297         case INVERSION_OFF:
 298                 dprintk("%s:  inversion off\n",__FUNCTION__);
 299                 cx24123_writereg(state, 0x0e, nom_reg & ~0x80);
 300                 cx24123_writereg(state, 0x10, auto_reg | 0x80);
 301                 break;
 302         case INVERSION_ON:
 303                 dprintk("%s:  inversion on\n",__FUNCTION__);
 304                 cx24123_writereg(state, 0x0e, nom_reg | 0x80);
 305                 cx24123_writereg(state, 0x10, auto_reg | 0x80);
 306                 break;
 307         case INVERSION_AUTO:
 308                 dprintk("%s:  inversion auto\n",__FUNCTION__);
 309                 cx24123_writereg(state, 0x10, auto_reg & ~0x80);
 310                 break;
 311         default:
 312                 return -EINVAL;
 313         }
 314
 315         return 0;
 316 }
 317
 318 static int cx24123_get_inversion(struct cx24123_state* state, fe_spectral_inversion_t *inversion)
 319 {
 320         u8 val;
 321
 322         val = cx24123_readreg(state, 0x1b) >> 7;
 323
 324         if (val == 0) {
 325                 dprintk("%s:  read inversion off\n",__FUNCTION__);
 326                 *inversion = INVERSION_OFF;
 327         } else {
 328                 dprintk("%s:  read inversion on\n",__FUNCTION__);
 329                 *inversion = INVERSION_ON;
 330         }
 331
 332         return 0;
 333 }
 334
 335 static int cx24123_set_fec(struct cx24123_state* state, fe_code_rate_t fec)
 336 {
 337         u8 nom_reg = cx24123_readreg(state, 0x0e) & ~0x07;
 338
 339         if ( (fec < FEC_NONE) || (fec > FEC_AUTO) )
 340                 fec = FEC_AUTO;
 341
 342         switch (fec) {
 343         case FEC_1_2:
 344                 dprintk("%s:  set FEC to 1/2\n",__FUNCTION__);
 345                 cx24123_writereg(state, 0x0e, nom_reg | 0x01);
 346                 cx24123_writereg(state, 0x0f, 0x02);
 347                 break;
 348         case FEC_2_3:
 349                 dprintk("%s:  set FEC to 2/3\n",__FUNCTION__);
 350                 cx24123_writereg(state, 0x0e, nom_reg | 0x02);
 351                 cx24123_writereg(state, 0x0f, 0x04);
 352                 break;
 353         case FEC_3_4:
 354                 dprintk("%s:  set FEC to 3/4\n",__FUNCTION__);
 355                 cx24123_writereg(state, 0x0e, nom_reg | 0x03);
 356                 cx24123_writereg(state, 0x0f, 0x08);
 357                 break;
 358         case FEC_4_5:
 359                 dprintk("%s:  set FEC to 4/5\n",__FUNCTION__);
 360                 cx24123_writereg(state, 0x0e, nom_reg | 0x04);
 361                 cx24123_writereg(state, 0x0f, 0x10);
 362                 break;
 363         case FEC_5_6:
 364                 dprintk("%s:  set FEC to 5/6\n",__FUNCTION__);
 365                 cx24123_writereg(state, 0x0e, nom_reg | 0x05);
 366                 cx24123_writereg(state, 0x0f, 0x20);
 367                 break;
 368         case FEC_6_7:
 369                 dprintk("%s:  set FEC to 6/7\n",__FUNCTION__);
 370                 cx24123_writereg(state, 0x0e, nom_reg | 0x06);
 371                 cx24123_writereg(state, 0x0f, 0x40);
 372                 break;
 373         case FEC_7_8:
 374                 dprintk("%s:  set FEC to 7/8\n",__FUNCTION__);
 375                 cx24123_writereg(state, 0x0e, nom_reg | 0x07);
 376                 cx24123_writereg(state, 0x0f, 0x80);
 377                 break;
 378         case FEC_AUTO:
 379                 dprintk("%s:  set FEC to auto\n",__FUNCTION__);
 380                 cx24123_writereg(state, 0x0f, 0xfe);
 381                 break;
 382         default:
 383                 return -EOPNOTSUPP;
 384         }
 385
 386         return 0;
 387 }
 388
 389 static int cx24123_get_fec(struct cx24123_state* state, fe_code_rate_t *fec)
 390 {
 391         int ret;
 392
 393         ret = cx24123_readreg (state, 0x1b);
 394         if (ret < 0)
 395                 return ret;
 396         ret = ret & 0x07;
 397
 398         switch (ret) {
 399         case 1:
 400                 *fec = FEC_1_2;
 401                 break;
 402         case 2:
 403                 *fec = FEC_2_3;
 404                 break;
 405         case 3:
 406                 *fec = FEC_3_4;
 407                 break;
 408         case 4:
 409                 *fec = FEC_4_5;
 410                 break;
 411         case 5:
 412                 *fec = FEC_5_6;
 413                 break;
 414         case 6:
 415                 *fec = FEC_6_7;
 416                 break;
 417         case 7:
 418                 *fec = FEC_7_8;
 419                 break;
 420         default:
 421                 /* this can happen when there's no lock */
 422                 *fec = FEC_NONE;
 423         }
 424
 425         return 0;
 426 }
 427
 428 /* Approximation of closest integer of log2(a/b). It actually gives the
 429    lowest integer i such that 2^i >= round(a/b) */
 430 static u32 cx24123_int_log2(u32 a, u32 b)
 431 {
 432         u32 exp, nearest = 0;
 433         u32 div = a / b;
 434         if(a % b >= b / 2) ++div;
 435         if(div < (1 << 31))
 436         {
 437                 for(exp = 1; div > exp; nearest++)
 438                         exp += exp;
 439         }
 440         return nearest;
 441 }
 442
 443 static int cx24123_set_symbolrate(struct cx24123_state* state, u32 srate)
 444 {
 445         u32 tmp, sample_rate, ratio, sample_gain;
 446         u8 pll_mult;
 447
 448         /*  check if symbol rate is within limits */
 449         if ((srate > state->ops.info.symbol_rate_max) ||
 450             (srate < state->ops.info.symbol_rate_min))
 451                 return -EOPNOTSUPP;;
 452
 453         /* choose the sampling rate high enough for the required operation,
 454            while optimizing the power consumed by the demodulator */
 455         if (srate < (XTAL*2)/2)
 456                 pll_mult = 2;
 457         else if (srate < (XTAL*3)/2)
 458                 pll_mult = 3;
 459         else if (srate < (XTAL*4)/2)
 460                 pll_mult = 4;
 461         else if (srate < (XTAL*5)/2)
 462                 pll_mult = 5;
 463         else if (srate < (XTAL*6)/2)
 464                 pll_mult = 6;
 465         else if (srate < (XTAL*7)/2)
 466                 pll_mult = 7;
 467         else if (srate < (XTAL*8)/2)
 468                 pll_mult = 8;
 469         else
 470                 pll_mult = 9;
 471
 472
 473         sample_rate = pll_mult * XTAL;
 474
 475         /*
 476             SYSSymbolRate[21:0] = (srate << 23) / sample_rate
 477
 478             We have to use 32 bit unsigned arithmetic without precision loss.
 479             The maximum srate is 45000000 or 0x02AEA540. This number has
 480             only 6 clear bits on top, hence we can shift it left only 6 bits
 481             at a time. Borrowed from cx24110.c
 482         */
 483
 484         tmp = srate << 6;
 485         ratio = tmp / sample_rate;
 486
 487         tmp = (tmp % sample_rate) << 6;
 488         ratio = (ratio << 6) + (tmp / sample_rate);
 489
 490         tmp = (tmp % sample_rate) << 6;
 491         ratio = (ratio << 6) + (tmp / sample_rate);
 492
 493         tmp = (tmp % sample_rate) << 5;
 494         ratio = (ratio << 5) + (tmp / sample_rate);
 495
 496
 497         cx24123_writereg(state, 0x01, pll_mult * 6);
 498
 499         cx24123_writereg(state, 0x08, (ratio >> 16) & 0x3f );
 500         cx24123_writereg(state, 0x09, (ratio >>  8) & 0xff );
 501         cx24123_writereg(state, 0x0a, (ratio      ) & 0xff );
 502
 503         /* also set the demodulator sample gain */
 504         sample_gain = cx24123_int_log2(sample_rate, srate);
 505         tmp = cx24123_readreg(state, 0x0c) & ~0xe0;
 506         cx24123_writereg(state, 0x0c, tmp | sample_gain << 5);
 507
 508         dprintk("%s: srate=%d, ratio=0x%08x, sample_rate=%i sample_gain=%d\n", __FUNCTION__, srate, ratio, sample_rate, sample_gain);
 509
 510         return 0;
 511 }
 512
 513 /*
 514  * Based on the required frequency and symbolrate, the tuner AGC has to be configured
 515  * and the correct band selected. Calculate those values
 516  */
 517 static int cx24123_pll_calculate(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
 518 {
 519         struct cx24123_state *state = fe->demodulator_priv;
 520         u32 ndiv = 0, adiv = 0, vco_div = 0;
 521         int i = 0;
 522         int pump = 2;
 523
 524         /* Defaults for low freq, low rate */
 525         state->VCAarg = cx24123_AGC_vals[0].VCAprogdata;
 526         state->VGAarg = cx24123_AGC_vals[0].VGAprogdata;
 527         state->bandselectarg = cx24123_bandselect_vals[0].progdata;
 528         vco_div = cx24123_bandselect_vals[0].VCOdivider;
 529
 530         /* For the given symbol rate, determine the VCA, VGA and FILTUNE programming bits */
 531         for (i = 0; i < sizeof(cx24123_AGC_vals) / sizeof(cx24123_AGC_vals[0]); i++)
 532         {
 533                 if ((cx24123_AGC_vals[i].symbolrate_low <= p->u.qpsk.symbol_rate) &&
 534                     (cx24123_AGC_vals[i].symbolrate_high >= p->u.qpsk.symbol_rate) ) {
 535                         state->VCAarg = cx24123_AGC_vals[i].VCAprogdata;
 536                         state->VGAarg = cx24123_AGC_vals[i].VGAprogdata;
 537                         state->FILTune = cx24123_AGC_vals[i].FILTune;
 538                 }
 539         }
 540
 541         /* For the given frequency, determine the bandselect programming bits */
 542         for (i = 0; i < sizeof(cx24123_bandselect_vals) / sizeof(cx24123_bandselect_vals[0]); i++)
 543         {
 544                 if ((cx24123_bandselect_vals[i].freq_low <= p->frequency) &&
 545                     (cx24123_bandselect_vals[i].freq_high >= p->frequency) ) {
 546                         state->bandselectarg = cx24123_bandselect_vals[i].progdata;
 547                         vco_div = cx24123_bandselect_vals[i].VCOdivider;
 548
 549                         /* determine the charge pump current */
 550                         if ( p->frequency < (cx24123_bandselect_vals[i].freq_low + cx24123_bandselect_vals[i].freq_high)/2 )
 551                                 pump = 0x01;
 552                         else
 553                                 pump = 0x02;
 554                 }
 555         }
 556
 557         /* Determine the N/A dividers for the requested lband freq (in kHz). */
 558         /* Note: the reference divider R=10, frequency is in KHz, XTAL is in Hz */
 559         ndiv = ( ((p->frequency * vco_div * 10) / (2 * XTAL / 1000)) / 32) & 0x1ff;
 560         adiv = ( ((p->frequency * vco_div * 10) / (2 * XTAL / 1000)) % 32) & 0x1f;
 561
 562         if (adiv == 0)
 563                 ndiv++;
 564
 565         /* control bits 11, refdiv 11, charge pump polarity 1, charge pump current, ndiv, adiv */
 566         state->pllarg = (3 << 19) | (3 << 17) | (1 << 16) | (pump << 14) | (ndiv << 5) | adiv;
 567
 568         return 0;
 569 }
 570
 571 /*
 572  * Tuner data is 21 bits long, must be left-aligned in data.
 573  * Tuner cx24109 is written through a dedicated 3wire interface on the demod chip.
 574  */
 575 static int cx24123_pll_writereg(struct dvb_frontend* fe, struct dvb_frontend_parameters *p, u32 data)
 576 {
 577         struct cx24123_state *state = fe->demodulator_priv;
 578         unsigned long timeout;
 579
 580         dprintk("%s:  pll writereg called, data=0x%08x\n",__FUNCTION__,data);
 581
 582         /* align the 21 bytes into to bit23 boundary */
 583         data = data << 3;
 584
 585         /* Reset the demod pll word length to 0x15 bits */
 586         cx24123_writereg(state, 0x21, 0x15);
 587
 588         /* write the msb 8 bits, wait for the send to be completed */
 589         timeout = jiffies + msecs_to_jiffies(40);
 590         cx24123_writereg(state, 0x22, (data >> 16) & 0xff);
 591         while ((cx24123_readreg(state, 0x20) & 0x40) == 0) {
 592                 if (time_after(jiffies, timeout)) {
 593                         printk("%s:  demodulator is not responding, possibly hung, aborting.\n", __FUNCTION__);
 594                         return -EREMOTEIO;
 595                 }
 596                 msleep(10);
 597         }
 598
 599         /* send another 8 bytes, wait for the send to be completed */
 600         timeout = jiffies + msecs_to_jiffies(40);
 601         cx24123_writereg(state, 0x22, (data>>8) & 0xff );
 602         while ((cx24123_readreg(state, 0x20) & 0x40) == 0) {
 603                 if (time_after(jiffies, timeout)) {
 604                         printk("%s:  demodulator is not responding, possibly hung, aborting.\n", __FUNCTION__);
 605                         return -EREMOTEIO;
 606                 }
 607                 msleep(10);
 608         }
 609
 610         /* send the lower 5 bits of this byte, padded with 3 LBB, wait for the send to be completed */
 611         timeout = jiffies + msecs_to_jiffies(40);
 612         cx24123_writereg(state, 0x22, (data) & 0xff );
 613         while ((cx24123_readreg(state, 0x20) & 0x80)) {
 614                 if (time_after(jiffies, timeout)) {
 615                         printk("%s:  demodulator is not responding, possibly hung, aborting.\n", __FUNCTION__);
 616                         return -EREMOTEIO;
 617                 }
 618                 msleep(10);
 619         }
 620
 621         /* Trigger the demod to configure the tuner */
 622         cx24123_writereg(state, 0x20, cx24123_readreg(state, 0x20) | 2);
 623         cx24123_writereg(state, 0x20, cx24123_readreg(state, 0x20) & 0xfd);
 624
 625         return 0;
 626 }
 627
 628 static int cx24123_pll_tune(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
 629 {
 630         struct cx24123_state *state = fe->demodulator_priv;
 631         u8 val;
 632
 633         dprintk("frequency=%i\n", p->frequency);
 634
 635         if (cx24123_pll_calculate(fe, p) != 0) {
 636                 printk("%s: cx24123_pll_calcutate failed\n",__FUNCTION__);
 637                 return -EINVAL;
 638         }
 639
 640         /* Write the new VCO/VGA */
 641         cx24123_pll_writereg(fe, p, state->VCAarg);
 642         cx24123_pll_writereg(fe, p, state->VGAarg);
 643
 644         /* Write the new bandselect and pll args */
 645         cx24123_pll_writereg(fe, p, state->bandselectarg);
 646         cx24123_pll_writereg(fe, p, state->pllarg);
 647
 648         /* set the FILTUNE voltage */
 649         val = cx24123_readreg(state, 0x28) & ~0x3;
 650         cx24123_writereg(state, 0x27, state->FILTune >> 2);
 651         cx24123_writereg(state, 0x28, val | (state->FILTune & 0x3));
 652
 653         dprintk("%s:  pll tune VCA=%d, band=%d, pll=%d\n",__FUNCTION__,state->VCAarg,
 654                         state->bandselectarg,state->pllarg);
 655
 656         return 0;
 657 }
 658
 659 static int cx24123_initfe(struct dvb_frontend* fe)
 660 {
 661         struct cx24123_state *state = fe->demodulator_priv;
 662         int i;
 663
 664         dprintk("%s:  init frontend\n",__FUNCTION__);
 665
 666         /* Configure the demod to a good set of defaults */
 667         for (i = 0; i < sizeof(cx24123_regdata) / sizeof(cx24123_regdata[0]); i++)
 668                 cx24123_writereg(state, cx24123_regdata[i].reg, cx24123_regdata[i].data);
 669
 670         if (state->config->pll_init)
 671                 state->config->pll_init(fe);
 672
 673         /* Configure the LNB for 14V */
 674         if (state->config->use_isl6421)
 675                 cx24123_writelnbreg(state, 0x0, 0x2a);
 676
 677         return 0;
 678 }
 679
 680 static int cx24123_set_voltage(struct dvb_frontend* fe, fe_sec_voltage_t voltage)
 681 {
 682         struct cx24123_state *state = fe->demodulator_priv;
 683         u8 val;
 684
 685         switch (state->config->use_isl6421) {
 686
 687         case 1:
 688
 689                 val = cx24123_readlnbreg(state, 0x0);
 690
 691                 switch (voltage) {
 692                 case SEC_VOLTAGE_13:
 693                         dprintk("%s:  isl6421 voltage = 13V\n",__FUNCTION__);
 694                         return cx24123_writelnbreg(state, 0x0, val & 0x32); /* V 13v */
 695                 case SEC_VOLTAGE_18:
 696                         dprintk("%s:  isl6421 voltage = 18V\n",__FUNCTION__);
 697                         return cx24123_writelnbreg(state, 0x0, val | 0x04); /* H 18v */
 698                 case SEC_VOLTAGE_OFF:
 699                         dprintk("%s:  isl5421 voltage off\n",__FUNCTION__);
 700                         return cx24123_writelnbreg(state, 0x0, val & 0x30);
 701                 default:
 702                         return -EINVAL;
 703                 };
 704
 705         case 0:
 706
 707                 val = cx24123_readreg(state, 0x29);
 708
 709                 switch (voltage) {
 710                 case SEC_VOLTAGE_13:
 711                         dprintk("%s: setting voltage 13V\n", __FUNCTION__);
 712                         if (state->config->enable_lnb_voltage)
 713                                 state->config->enable_lnb_voltage(fe, 1);
 714                         return cx24123_writereg(state, 0x29, val | 0x80);
 715                 case SEC_VOLTAGE_18:
 716                         dprintk("%s: setting voltage 18V\n", __FUNCTION__);
 717                         if (state->config->enable_lnb_voltage)
 718                                 state->config->enable_lnb_voltage(fe, 1);
 719                         return cx24123_writereg(state, 0x29, val & 0x7f);
 720                 case SEC_VOLTAGE_OFF:
 721                         dprintk("%s: setting voltage off\n", __FUNCTION__);
 722                         if (state->config->enable_lnb_voltage)
 723                                 state->config->enable_lnb_voltage(fe, 0);
 724                         return 0;
 725                 default:
 726                         return -EINVAL;
 727                 };
 728         }
 729
 730         return 0;
 731 }
 732
 733 /* wait for diseqc queue to become ready (or timeout) */
 734 static void cx24123_wait_for_diseqc(struct cx24123_state *state)
 735 {
 736         unsigned long timeout = jiffies + msecs_to_jiffies(200);
 737         while (!(cx24123_readreg(state, 0x29) & 0x40)) {
 738                 if(time_after(jiffies, timeout)) {
 739                         printk("%s: diseqc queue not ready, command may be lost.\n", __FUNCTION__);
 740                         break;
 741                 }
 742                 msleep(10);
 743         }
 744 }
 745
 746 static int cx24123_send_diseqc_msg(struct dvb_frontend* fe, struct dvb_diseqc_master_cmd *cmd)
 747 {
 748         struct cx24123_state *state = fe->demodulator_priv;
 749         int i, val;
 750
 751         dprintk("%s:\n",__FUNCTION__);
 752
 753         /* check if continuous tone has been stopped */
 754         if (state->config->use_isl6421)
 755                 val = cx24123_readlnbreg(state, 0x00) & 0x10;
 756         else
 757                 val = cx24123_readreg(state, 0x29) & 0x10;
 758
 759
 760         if (val) {
 761                 printk("%s: ERROR: attempt to send diseqc command before tone is off\n", __FUNCTION__);
 762                 return -ENOTSUPP;
 763         }
 764
 765         /* wait for diseqc queue ready */
 766         cx24123_wait_for_diseqc(state);
 767
 768         /* select tone mode */
 769         cx24123_writereg(state, 0x2a, cx24123_readreg(state, 0x2a) & 0xf8);
 770
 771         for (i = 0; i < cmd->msg_len; i++)
 772                 cx24123_writereg(state, 0x2C + i, cmd->msg[i]);
 773
 774         val = cx24123_readreg(state, 0x29);
 775         cx24123_writereg(state, 0x29, ((val & 0x90) | 0x40) | ((cmd->msg_len-3) & 3));
 776
 777         /* wait for diseqc message to finish sending */
 778         cx24123_wait_for_diseqc(state);
 779
 780         return 0;
 781 }
 782
 783 static int cx24123_diseqc_send_burst(struct dvb_frontend* fe, fe_sec_mini_cmd_t burst)
 784 {
 785         struct cx24123_state *state = fe->demodulator_priv;
 786         int val;
 787
 788         dprintk("%s:\n", __FUNCTION__);
 789
 790         /* check if continuous tone has been stoped */
 791         if (state->config->use_isl6421)
 792                 val = cx24123_readlnbreg(state, 0x00) & 0x10;
 793         else
 794                 val = cx24123_readreg(state, 0x29) & 0x10;
 795
 796
 797         if (val) {
 798                 printk("%s: ERROR: attempt to send diseqc command before tone is off\n", __FUNCTION__);
 799                 return -ENOTSUPP;
 800         }
 801
 802         cx24123_wait_for_diseqc(state);
 803
 804         /* select tone mode */
 805         val = cx24123_readreg(state, 0x2a) & 0xf8;
 806         cx24123_writereg(state, 0x2a, val | 0x04);
 807
 808         val = cx24123_readreg(state, 0x29);
 809
 810         if (burst == SEC_MINI_A)
 811                 cx24123_writereg(state, 0x29, ((val & 0x90) | 0x40 | 0x00));
 812         else if (burst == SEC_MINI_B)
 813                 cx24123_writereg(state, 0x29, ((val & 0x90) | 0x40 | 0x08));
 814         else
 815                 return -EINVAL;
 816
 817         cx24123_wait_for_diseqc(state);
 818
 819         return 0;
 820 }
 821
 822 static int cx24123_read_status(struct dvb_frontend* fe, fe_status_t* status)
 823 {
 824         struct cx24123_state *state = fe->demodulator_priv;
 825
 826         int sync = cx24123_readreg(state, 0x14);
 827         int lock = cx24123_readreg(state, 0x20);
 828
 829         *status = 0;
 830         if (lock & 0x01)
 831                 *status |= FE_HAS_SIGNAL;
 832         if (sync & 0x02)
 833                 *status |= FE_HAS_CARRIER;
 834         if (sync & 0x04)
 835                 *status |= FE_HAS_VITERBI;
 836         if (sync & 0x08)
 837                 *status |= FE_HAS_SYNC;
 838         if (sync & 0x80)
 839                 *status |= FE_HAS_LOCK;
 840
 841         return 0;
 842 }
 843
 844 /*
 845  * Configured to return the measurement of errors in blocks, because no UCBLOCKS value
 846  * is available, so this value doubles up to satisfy both measurements
 847  */
 848 static int cx24123_read_ber(struct dvb_frontend* fe, u32* ber)
 849 {
 850         struct cx24123_state *state = fe->demodulator_priv;
 851
 852         state->lastber =
 853                 ((cx24123_readreg(state, 0x1c) & 0x3f) << 16) |
 854                 (cx24123_readreg(state, 0x1d) << 8 |
 855                 cx24123_readreg(state, 0x1e));
 856
 857         /* Do the signal quality processing here, it's derived from the BER. */
 858         /* Scale the BER from a 24bit to a SNR 16 bit where higher = better */
 859         if (state->lastber < 5000)
 860                 state->snr = 655*100;
 861         else if ( (state->lastber >=   5000) && (state->lastber <  55000) )
 862                 state->snr = 655*90;
 863         else if ( (state->lastber >=  55000) && (state->lastber < 150000) )
 864                 state->snr = 655*80;
 865         else if ( (state->lastber >= 150000) && (state->lastber < 250000) )
 866                 state->snr = 655*70;
 867         else if ( (state->lastber >= 250000) && (state->lastber < 450000) )
 868                 state->snr = 655*65;
 869         else
 870                 state->snr = 0;
 871
 872         dprintk("%s:  BER = %d, S/N index = %d\n",__FUNCTION__,state->lastber, state->snr);
 873
 874         *ber = state->lastber;
 875
 876         return 0;
 877 }
 878
 879 static int cx24123_read_signal_strength(struct dvb_frontend* fe, u16* signal_strength)
 880 {
 881         struct cx24123_state *state = fe->demodulator_priv;
 882         *signal_strength = cx24123_readreg(state, 0x3b) << 8; /* larger = better */
 883
 884         dprintk("%s:  Signal strength = %d\n",__FUNCTION__,*signal_strength);
 885
 886         return 0;
 887 }
 888
 889 static int cx24123_read_snr(struct dvb_frontend* fe, u16* snr)
 890 {
 891         struct cx24123_state *state = fe->demodulator_priv;
 892         *snr = state->snr;
 893
 894         dprintk("%s:  read S/N index = %d\n",__FUNCTION__,*snr);
 895
 896         return 0;
 897 }
 898
 899 static int cx24123_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
 900 {
 901         struct cx24123_state *state = fe->demodulator_priv;
 902         *ucblocks = state->lastber;
 903
 904         dprintk("%s:  ucblocks (ber) = %d\n",__FUNCTION__,*ucblocks);
 905
 906         return 0;
 907 }
 908
 909 static int cx24123_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
 910 {
 911         struct cx24123_state *state = fe->demodulator_priv;
 912
 913         dprintk("%s:  set_frontend\n",__FUNCTION__);
 914
 915         if (state->config->set_ts_params)
 916                 state->config->set_ts_params(fe, 0);
 917
 918         state->currentfreq=p->frequency;
 919         state->currentsymbolrate = p->u.qpsk.symbol_rate;
 920
 921         cx24123_set_inversion(state, p->inversion);
 922         cx24123_set_fec(state, p->u.qpsk.fec_inner);
 923         cx24123_set_symbolrate(state, p->u.qpsk.symbol_rate);
 924         cx24123_pll_tune(fe, p);
 925
 926         /* Enable automatic aquisition and reset cycle */
 927         cx24123_writereg(state, 0x03, (cx24123_readreg(state, 0x03) | 0x07));
 928         cx24123_writereg(state, 0x00, 0x10);
 929         cx24123_writereg(state, 0x00, 0);
 930
 931         return 0;
 932 }
 933
 934 static int cx24123_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters *p)
 935 {
 936         struct cx24123_state *state = fe->demodulator_priv;
 937
 938         dprintk("%s:  get_frontend\n",__FUNCTION__);
 939
 940         if (cx24123_get_inversion(state, &p->inversion) != 0) {
 941                 printk("%s: Failed to get inversion status\n",__FUNCTION__);
 942                 return -EREMOTEIO;
 943         }
 944         if (cx24123_get_fec(state, &p->u.qpsk.fec_inner) != 0) {
 945                 printk("%s: Failed to get fec status\n",__FUNCTION__);
 946                 return -EREMOTEIO;
 947         }
 948         p->frequency = state->currentfreq;
 949         p->u.qpsk.symbol_rate = state->currentsymbolrate;
 950
 951         return 0;
 952 }
 953
 954 static int cx24123_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
 955 {
 956         struct cx24123_state *state = fe->demodulator_priv;
 957         u8 val;
 958
 959         switch (state->config->use_isl6421) {
 960         case 1:
 961
 962                 val = cx24123_readlnbreg(state, 0x0);
 963
 964                 switch (tone) {
 965                 case SEC_TONE_ON:
 966                         dprintk("%s:  isl6421 sec tone on\n",__FUNCTION__);
 967                         return cx24123_writelnbreg(state, 0x0, val | 0x10);
 968                 case SEC_TONE_OFF:
 969                         dprintk("%s:  isl6421 sec tone off\n",__FUNCTION__);
 970                         return cx24123_writelnbreg(state, 0x0, val & 0x2f);
 971                 default:
 972                         printk("%s: CASE reached default with tone=%d\n", __FUNCTION__, tone);
 973                         return -EINVAL;
 974                 }
 975
 976         case 0:
 977
 978                 val = cx24123_readreg(state, 0x29);
 979
 980                 switch (tone) {
 981                 case SEC_TONE_ON:
 982                         dprintk("%s: setting tone on\n", __FUNCTION__);
 983                         return cx24123_writereg(state, 0x29, val | 0x10);
 984                 case SEC_TONE_OFF:
 985                         dprintk("%s: setting tone off\n",__FUNCTION__);
 986                         return cx24123_writereg(state, 0x29, val & 0xef);
 987                 default:
 988                         printk("%s: CASE reached default with tone=%d\n", __FUNCTION__, tone);
 989                         return -EINVAL;
 990                 }
 991         }
 992
 993         return 0;
 994 }
 995
 996 static void cx24123_release(struct dvb_frontend* fe)
 997 {
 998         struct cx24123_state* state = fe->demodulator_priv;
 999         dprintk("%s\n",__FUNCTION__);
1000         kfree(state);
1001 }
1002
1003 static struct dvb_frontend_ops cx24123_ops;
1004
1005 struct dvb_frontend* cx24123_attach(const struct cx24123_config* config,
1006                                     struct i2c_adapter* i2c)
1007 {
1008         struct cx24123_state* state = NULL;
1009         int ret;
1010
1011         dprintk("%s\n",__FUNCTION__);
1012
1013         /* allocate memory for the internal state */
1014         state = kmalloc(sizeof(struct cx24123_state), GFP_KERNEL);
1015         if (state == NULL) {
1016                 printk("Unable to kmalloc\n");
1017                 goto error;
1018         }
1019
1020         /* setup the state */
1021         state->config = config;
1022         state->i2c = i2c;
1023         memcpy(&state->ops, &cx24123_ops, sizeof(struct dvb_frontend_ops));
1024         state->lastber = 0;
1025         state->snr = 0;
1026         state->lnbreg = 0;
1027         state->VCAarg = 0;
1028         state->VGAarg = 0;
1029         state->bandselectarg = 0;
1030         state->pllarg = 0;
1031         state->currentfreq = 0;
1032         state->currentsymbolrate = 0;
1033
1034         /* check if the demod is there */
1035         ret = cx24123_readreg(state, 0x00);
1036         if ((ret != 0xd1) && (ret != 0xe1)) {
1037                 printk("Version != d1 or e1\n");
1038                 goto error;
1039         }
1040
1041         /* create dvb_frontend */
1042         state->frontend.ops = &state->ops;
1043         state->frontend.demodulator_priv = state;
1044         return &state->frontend;
1045
1046 error:
1047         kfree(state);
1048
1049         return NULL;
1050 }
1051
1052 static struct dvb_frontend_ops cx24123_ops = {
1053
1054         .info = {
1055                 .name = "Conexant CX24123/CX24109",
1056                 .type = FE_QPSK,
1057                 .frequency_min = 950000,
1058                 .frequency_max = 2150000,
1059                 .frequency_stepsize = 1011, /* kHz for QPSK frontends */
1060                 .frequency_tolerance = 5000,
1061                 .symbol_rate_min = 1000000,
1062                 .symbol_rate_max = 45000000,
1063                 .caps = FE_CAN_INVERSION_AUTO |
1064                         FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
1065                         FE_CAN_FEC_4_5 | FE_CAN_FEC_5_6 | FE_CAN_FEC_6_7 |
1066                         FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
1067                         FE_CAN_QPSK | FE_CAN_RECOVER
1068         },
1069
1070         .release = cx24123_release,
1071
1072         .init = cx24123_initfe,
1073         .set_frontend = cx24123_set_frontend,
1074         .get_frontend = cx24123_get_frontend,
1075         .read_status = cx24123_read_status,
1076         .read_ber = cx24123_read_ber,
1077         .read_signal_strength = cx24123_read_signal_strength,
1078         .read_snr = cx24123_read_snr,
1079         .read_ucblocks = cx24123_read_ucblocks,
1080         .diseqc_send_master_cmd = cx24123_send_diseqc_msg,
1081         .diseqc_send_burst = cx24123_diseqc_send_burst,
1082         .set_tone = cx24123_set_tone,
1083         .set_voltage = cx24123_set_voltage,
1084 };
1085
1086 module_param(debug, int, 0644);
1087 MODULE_PARM_DESC(debug, "Activates frontend debugging (default:0)");
1088
1089 MODULE_DESCRIPTION("DVB Frontend module for Conexant cx24123/cx24109 hardware");
1090 MODULE_AUTHOR("Steven Toth");
1091 MODULE_LICENSE("GPL");
1092
1093 EXPORT_SYMBOL(cx24123_attach);