git.oblomov.eu Git - linux-2.6/blob - drivers/media/dvb/frontends/lgdt330x.c

   1 /*
   2  *    Support for LGDT3302 and LGDT3303 - VSB/QAM
   3  *
   4  *    Copyright (C) 2005 Wilson Michaels <wilsonmichaels@earthlink.net>
   5  *
   6  *    This program is free software; you can redistribute it and/or modify
   7  *    it under the terms of the GNU General Public License as published by
   8  *    the Free Software Foundation; either version 2 of the License, or
   9  *    (at your option) any later version.
  10  *
  11  *    This program is distributed in the hope that it will be useful,
  12  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *    GNU General Public License for more details.
  15  *
  16  *    You should have received a copy of the GNU General Public License
  17  *    along with this program; if not, write to the Free Software
  18  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  *
  20  */
  21
  22 /*
  23  *                      NOTES ABOUT THIS DRIVER
  24  *
  25  * This Linux driver supports:
  26  *   DViCO FusionHDTV 3 Gold-Q
  27  *   DViCO FusionHDTV 3 Gold-T
  28  *   DViCO FusionHDTV 5 Gold
  29  *   DViCO FusionHDTV 5 Lite
  30  *   DViCO FusionHDTV 5 USB Gold
  31  *   Air2PC/AirStar 2 ATSC 3rd generation (HD5000)
  32  *   pcHDTV HD5500
  33  *
  34  * TODO:
  35  * signal strength always returns 0.
  36  *
  37  */
  38
  39 #include <linux/kernel.h>
  40 #include <linux/module.h>
  41 #include <linux/moduleparam.h>
  42 #include <linux/init.h>
  43 #include <linux/delay.h>
  44 #include <linux/string.h>
  45 #include <linux/slab.h>
  46 #include <asm/byteorder.h>
  47
  48 #include "dvb_frontend.h"
  49 #include "lgdt330x_priv.h"
  50 #include "lgdt330x.h"
  51
  52 static int debug = 0;
  53 module_param(debug, int, 0644);
  54 MODULE_PARM_DESC(debug,"Turn on/off lgdt330x frontend debugging (default:off).");
  55 #define dprintk(args...) \
  56 do { \
  57 if (debug) printk(KERN_DEBUG "lgdt330x: " args); \
  58 } while (0)
  59
  60 struct lgdt330x_state
  61 {
  62         struct i2c_adapter* i2c;
  63         struct dvb_frontend_ops ops;
  64
  65         /* Configuration settings */
  66         const struct lgdt330x_config* config;
  67
  68         struct dvb_frontend frontend;
  69
  70         /* Demodulator private data */
  71         fe_modulation_t current_modulation;
  72
  73         /* Tuner private data */
  74         u32 current_frequency;
  75 };
  76
  77 static int i2c_write_demod_bytes (struct lgdt330x_state* state,
  78                                   u8 *buf, /* data bytes to send */
  79                                   int len  /* number of bytes to send */ )
  80 {
  81         struct i2c_msg msg =
  82                 { .addr = state->config->demod_address,
  83                   .flags = 0,
  84                   .buf = buf,
  85                   .len = 2 };
  86         int i;
  87         int err;
  88
  89         for (i=0; i<len-1; i+=2){
  90                 if ((err = i2c_transfer(state->i2c, &msg, 1)) != 1) {
  91                         printk(KERN_WARNING "lgdt330x: %s error (addr %02x <- %02x, err = %i)\n", __FUNCTION__, msg.buf[0], msg.buf[1], err);
  92                         if (err < 0)
  93                                 return err;
  94                         else
  95                                 return -EREMOTEIO;
  96                 }
  97                 msg.buf += 2;
  98         }
  99         return 0;
 100 }
 101
 102 /*
 103  * This routine writes the register (reg) to the demod bus
 104  * then reads the data returned for (len) bytes.
 105  */
 106
 107 static u8 i2c_read_demod_bytes (struct lgdt330x_state* state,
 108                                enum I2C_REG reg, u8* buf, int len)
 109 {
 110         u8 wr [] = { reg };
 111         struct i2c_msg msg [] = {
 112                 { .addr = state->config->demod_address,
 113                   .flags = 0, .buf = wr,  .len = 1 },
 114                 { .addr = state->config->demod_address,
 115                   .flags = I2C_M_RD, .buf = buf, .len = len },
 116         };
 117         int ret;
 118         ret = i2c_transfer(state->i2c, msg, 2);
 119         if (ret != 2) {
 120                 printk(KERN_WARNING "lgdt330x: %s: addr 0x%02x select 0x%02x error (ret == %i)\n", __FUNCTION__, state->config->demod_address, reg, ret);
 121         } else {
 122                 ret = 0;
 123         }
 124         return ret;
 125 }
 126
 127 /* Software reset */
 128 static int lgdt3302_SwReset(struct lgdt330x_state* state)
 129 {
 130         u8 ret;
 131         u8 reset[] = {
 132                 IRQ_MASK,
 133                 0x00 /* bit 6 is active low software reset
 134                       * bits 5-0 are 1 to mask interrupts */
 135         };
 136
 137         ret = i2c_write_demod_bytes(state,
 138                                     reset, sizeof(reset));
 139         if (ret == 0) {
 140
 141                 /* force reset high (inactive) and unmask interrupts */
 142                 reset[1] = 0x7f;
 143                 ret = i2c_write_demod_bytes(state,
 144                                             reset, sizeof(reset));
 145         }
 146         return ret;
 147 }
 148
 149 static int lgdt3303_SwReset(struct lgdt330x_state* state)
 150 {
 151         u8 ret;
 152         u8 reset[] = {
 153                 0x02,
 154                 0x00 /* bit 0 is active low software reset */
 155         };
 156
 157         ret = i2c_write_demod_bytes(state,
 158                                     reset, sizeof(reset));
 159         if (ret == 0) {
 160
 161                 /* force reset high (inactive) */
 162                 reset[1] = 0x01;
 163                 ret = i2c_write_demod_bytes(state,
 164                                             reset, sizeof(reset));
 165         }
 166         return ret;
 167 }
 168
 169 static int lgdt330x_SwReset(struct lgdt330x_state* state)
 170 {
 171         switch (state->config->demod_chip) {
 172         case LGDT3302:
 173                 return lgdt3302_SwReset(state);
 174         case LGDT3303:
 175                 return lgdt3303_SwReset(state);
 176         default:
 177                 return -ENODEV;
 178         }
 179 }
 180
 181 static int lgdt330x_init(struct dvb_frontend* fe)
 182 {
 183         /* Hardware reset is done using gpio[0] of cx23880x chip.
 184          * I'd like to do it here, but don't know how to find chip address.
 185          * cx88-cards.c arranges for the reset bit to be inactive (high).
 186          * Maybe there needs to be a callable function in cx88-core or
 187          * the caller of this function needs to do it. */
 188
 189         /*
 190          * Array of byte pairs <address, value>
 191          * to initialize each different chip
 192          */
 193         static u8 lgdt3302_init_data[] = {
 194                 /* Use 50MHz parameter values from spec sheet since xtal is 50 */
 195                 /* Change the value of NCOCTFV[25:0] of carrier
 196                    recovery center frequency register */
 197                 VSB_CARRIER_FREQ0, 0x00,
 198                 VSB_CARRIER_FREQ1, 0x87,
 199                 VSB_CARRIER_FREQ2, 0x8e,
 200                 VSB_CARRIER_FREQ3, 0x01,
 201                 /* Change the TPCLK pin polarity
 202                    data is valid on falling clock */
 203                 DEMUX_CONTROL, 0xfb,
 204                 /* Change the value of IFBW[11:0] of
 205                    AGC IF/RF loop filter bandwidth register */
 206                 AGC_RF_BANDWIDTH0, 0x40,
 207                 AGC_RF_BANDWIDTH1, 0x93,
 208                 AGC_RF_BANDWIDTH2, 0x00,
 209                 /* Change the value of bit 6, 'nINAGCBY' and
 210                    'NSSEL[1:0] of ACG function control register 2 */
 211                 AGC_FUNC_CTRL2, 0xc6,
 212                 /* Change the value of bit 6 'RFFIX'
 213                    of AGC function control register 3 */
 214                 AGC_FUNC_CTRL3, 0x40,
 215                 /* Set the value of 'INLVTHD' register 0x2a/0x2c
 216                    to 0x7fe */
 217                 AGC_DELAY0, 0x07,
 218                 AGC_DELAY2, 0xfe,
 219                 /* Change the value of IAGCBW[15:8]
 220                    of inner AGC loop filter bandwith */
 221                 AGC_LOOP_BANDWIDTH0, 0x08,
 222                 AGC_LOOP_BANDWIDTH1, 0x9a
 223         };
 224
 225         static u8 lgdt3303_init_data[] = {
 226                 0x4c, 0x14
 227         };
 228
 229         static u8 flip_lgdt3303_init_data[] = {
 230                 0x4c, 0x14,
 231                 0x87, 0xf3
 232         };
 233
 234         struct lgdt330x_state* state = fe->demodulator_priv;
 235         char  *chip_name;
 236         int    err;
 237
 238         switch (state->config->demod_chip) {
 239         case LGDT3302:
 240                 chip_name = "LGDT3302";
 241                 err = i2c_write_demod_bytes(state, lgdt3302_init_data,
 242                                             sizeof(lgdt3302_init_data));
 243                 break;
 244         case LGDT3303:
 245                 chip_name = "LGDT3303";
 246                 if (state->config->clock_polarity_flip) {
 247                         err = i2c_write_demod_bytes(state, flip_lgdt3303_init_data,
 248                                                     sizeof(flip_lgdt3303_init_data));
 249                 } else {
 250                         err = i2c_write_demod_bytes(state, lgdt3303_init_data,
 251                                                     sizeof(lgdt3303_init_data));
 252                 }
 253                 break;
 254         default:
 255                 chip_name = "undefined";
 256                 printk (KERN_WARNING "Only LGDT3302 and LGDT3303 are supported chips.\n");
 257                 err = -ENODEV;
 258         }
 259         dprintk("%s entered as %s\n", __FUNCTION__, chip_name);
 260         if (err < 0)
 261                 return err;
 262         return lgdt330x_SwReset(state);
 263 }
 264
 265 static int lgdt330x_read_ber(struct dvb_frontend* fe, u32* ber)
 266 {
 267         *ber = 0; /* Not supplied by the demod chips */
 268         return 0;
 269 }
 270
 271 static int lgdt330x_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
 272 {
 273         struct lgdt330x_state* state = fe->demodulator_priv;
 274         int err;
 275         u8 buf[2];
 276
 277         switch (state->config->demod_chip) {
 278         case LGDT3302:
 279                 err = i2c_read_demod_bytes(state, LGDT3302_PACKET_ERR_COUNTER1,
 280                                            buf, sizeof(buf));
 281                 break;
 282         case LGDT3303:
 283                 err = i2c_read_demod_bytes(state, LGDT3303_PACKET_ERR_COUNTER1,
 284                                            buf, sizeof(buf));
 285                 break;
 286         default:
 287                 printk(KERN_WARNING
 288                        "Only LGDT3302 and LGDT3303 are supported chips.\n");
 289                 err = -ENODEV;
 290         }
 291
 292         *ucblocks = (buf[0] << 8) | buf[1];
 293         return 0;
 294 }
 295
 296 static int lgdt330x_set_parameters(struct dvb_frontend* fe,
 297                                    struct dvb_frontend_parameters *param)
 298 {
 299         /*
 300          * Array of byte pairs <address, value>
 301          * to initialize 8VSB for lgdt3303 chip 50 MHz IF
 302          */
 303         static u8 lgdt3303_8vsb_44_data[] = {
 304                 0x04, 0x00,
 305                 0x0d, 0x40,
 306         0x0e, 0x87,
 307         0x0f, 0x8e,
 308         0x10, 0x01,
 309         0x47, 0x8b };
 310
 311         /*
 312          * Array of byte pairs <address, value>
 313          * to initialize QAM for lgdt3303 chip
 314          */
 315         static u8 lgdt3303_qam_data[] = {
 316                 0x04, 0x00,
 317                 0x0d, 0x00,
 318                 0x0e, 0x00,
 319                 0x0f, 0x00,
 320                 0x10, 0x00,
 321                 0x51, 0x63,
 322                 0x47, 0x66,
 323                 0x48, 0x66,
 324                 0x4d, 0x1a,
 325                 0x49, 0x08,
 326                 0x4a, 0x9b };
 327
 328         struct lgdt330x_state* state = fe->demodulator_priv;
 329
 330         static u8 top_ctrl_cfg[]   = { TOP_CONTROL, 0x03 };
 331
 332         int err;
 333         /* Change only if we are actually changing the modulation */
 334         if (state->current_modulation != param->u.vsb.modulation) {
 335                 switch(param->u.vsb.modulation) {
 336                 case VSB_8:
 337                         dprintk("%s: VSB_8 MODE\n", __FUNCTION__);
 338
 339                         /* Select VSB mode */
 340                         top_ctrl_cfg[1] = 0x03;
 341
 342                         /* Select ANT connector if supported by card */
 343                         if (state->config->pll_rf_set)
 344                                 state->config->pll_rf_set(fe, 1);
 345
 346                         if (state->config->demod_chip == LGDT3303) {
 347                                 err = i2c_write_demod_bytes(state, lgdt3303_8vsb_44_data,
 348                                                             sizeof(lgdt3303_8vsb_44_data));
 349                         }
 350                         break;
 351
 352                 case QAM_64:
 353                         dprintk("%s: QAM_64 MODE\n", __FUNCTION__);
 354
 355                         /* Select QAM_64 mode */
 356                         top_ctrl_cfg[1] = 0x00;
 357
 358                         /* Select CABLE connector if supported by card */
 359                         if (state->config->pll_rf_set)
 360                                 state->config->pll_rf_set(fe, 0);
 361
 362                         if (state->config->demod_chip == LGDT3303) {
 363                                 err = i2c_write_demod_bytes(state, lgdt3303_qam_data,
 364                                                                                         sizeof(lgdt3303_qam_data));
 365                         }
 366                         break;
 367
 368                 case QAM_256:
 369                         dprintk("%s: QAM_256 MODE\n", __FUNCTION__);
 370
 371                         /* Select QAM_256 mode */
 372                         top_ctrl_cfg[1] = 0x01;
 373
 374                         /* Select CABLE connector if supported by card */
 375                         if (state->config->pll_rf_set)
 376                                 state->config->pll_rf_set(fe, 0);
 377
 378                         if (state->config->demod_chip == LGDT3303) {
 379                                 err = i2c_write_demod_bytes(state, lgdt3303_qam_data,
 380                                                                                         sizeof(lgdt3303_qam_data));
 381                         }
 382                         break;
 383                 default:
 384                         printk(KERN_WARNING "lgdt330x: %s: Modulation type(%d) UNSUPPORTED\n", __FUNCTION__, param->u.vsb.modulation);
 385                         return -1;
 386                 }
 387                 /*
 388                  * select serial or parallel MPEG harware interface
 389                  * Serial:   0x04 for LGDT3302 or 0x40 for LGDT3303
 390                  * Parallel: 0x00
 391                  */
 392                 top_ctrl_cfg[1] |= state->config->serial_mpeg;
 393
 394                 /* Select the requested mode */
 395                 i2c_write_demod_bytes(state, top_ctrl_cfg,
 396                                       sizeof(top_ctrl_cfg));
 397                 if (state->config->set_ts_params)
 398                         state->config->set_ts_params(fe, 0);
 399                 state->current_modulation = param->u.vsb.modulation;
 400         }
 401
 402         /* Tune to the specified frequency */
 403         if (fe->ops->tuner_ops.set_params) {
 404                 fe->ops->tuner_ops.set_params(fe, param);
 405                 if (fe->ops->i2c_gate_ctrl) fe->ops->i2c_gate_ctrl(fe, 0);
 406         }
 407
 408         /* Keep track of the new frequency */
 409         /* FIXME this is the wrong way to do this...           */
 410         /* The tuner is shared with the video4linux analog API */
 411         state->current_frequency = param->frequency;
 412
 413         lgdt330x_SwReset(state);
 414         return 0;
 415 }
 416
 417 static int lgdt330x_get_frontend(struct dvb_frontend* fe,
 418                                  struct dvb_frontend_parameters* param)
 419 {
 420         struct lgdt330x_state *state = fe->demodulator_priv;
 421         param->frequency = state->current_frequency;
 422         return 0;
 423 }
 424
 425 static int lgdt3302_read_status(struct dvb_frontend* fe, fe_status_t* status)
 426 {
 427         struct lgdt330x_state* state = fe->demodulator_priv;
 428         u8 buf[3];
 429
 430         *status = 0; /* Reset status result */
 431
 432         /* AGC status register */
 433         i2c_read_demod_bytes(state, AGC_STATUS, buf, 1);
 434         dprintk("%s: AGC_STATUS = 0x%02x\n", __FUNCTION__, buf[0]);
 435         if ((buf[0] & 0x0c) == 0x8){
 436                 /* Test signal does not exist flag */
 437                 /* as well as the AGC lock flag.   */
 438                 *status |= FE_HAS_SIGNAL;
 439         } else {
 440                 /* Without a signal all other status bits are meaningless */
 441                 return 0;
 442         }
 443
 444         /*
 445          * You must set the Mask bits to 1 in the IRQ_MASK in order
 446          * to see that status bit in the IRQ_STATUS register.
 447          * This is done in SwReset();
 448          */
 449         /* signal status */
 450         i2c_read_demod_bytes(state, TOP_CONTROL, buf, sizeof(buf));
 451         dprintk("%s: TOP_CONTROL = 0x%02x, IRO_MASK = 0x%02x, IRQ_STATUS = 0x%02x\n", __FUNCTION__, buf[0], buf[1], buf[2]);
 452
 453
 454         /* sync status */
 455         if ((buf[2] & 0x03) == 0x01) {
 456                 *status |= FE_HAS_SYNC;
 457         }
 458
 459         /* FEC error status */
 460         if ((buf[2] & 0x0c) == 0x08) {
 461                 *status |= FE_HAS_LOCK;
 462                 *status |= FE_HAS_VITERBI;
 463         }
 464
 465         /* Carrier Recovery Lock Status Register */
 466         i2c_read_demod_bytes(state, CARRIER_LOCK, buf, 1);
 467         dprintk("%s: CARRIER_LOCK = 0x%02x\n", __FUNCTION__, buf[0]);
 468         switch (state->current_modulation) {
 469         case QAM_256:
 470         case QAM_64:
 471                 /* Need to undestand why there are 3 lock levels here */
 472                 if ((buf[0] & 0x07) == 0x07)
 473                         *status |= FE_HAS_CARRIER;
 474                 break;
 475         case VSB_8:
 476                 if ((buf[0] & 0x80) == 0x80)
 477                         *status |= FE_HAS_CARRIER;
 478                 break;
 479         default:
 480                 printk("KERN_WARNING lgdt330x: %s: Modulation set to unsupported value\n", __FUNCTION__);
 481         }
 482
 483         return 0;
 484 }
 485
 486 static int lgdt3303_read_status(struct dvb_frontend* fe, fe_status_t* status)
 487 {
 488         struct lgdt330x_state* state = fe->demodulator_priv;
 489         int err;
 490         u8 buf[3];
 491
 492         *status = 0; /* Reset status result */
 493
 494         /* lgdt3303 AGC status register */
 495         err = i2c_read_demod_bytes(state, 0x58, buf, 1);
 496         if (err < 0)
 497                 return err;
 498
 499         dprintk("%s: AGC_STATUS = 0x%02x\n", __FUNCTION__, buf[0]);
 500         if ((buf[0] & 0x21) == 0x01){
 501                 /* Test input signal does not exist flag */
 502                 /* as well as the AGC lock flag.   */
 503                 *status |= FE_HAS_SIGNAL;
 504         } else {
 505                 /* Without a signal all other status bits are meaningless */
 506                 return 0;
 507         }
 508
 509         /* Carrier Recovery Lock Status Register */
 510         i2c_read_demod_bytes(state, CARRIER_LOCK, buf, 1);
 511         dprintk("%s: CARRIER_LOCK = 0x%02x\n", __FUNCTION__, buf[0]);
 512         switch (state->current_modulation) {
 513         case QAM_256:
 514         case QAM_64:
 515                 /* Need to undestand why there are 3 lock levels here */
 516                 if ((buf[0] & 0x07) == 0x07)
 517                         *status |= FE_HAS_CARRIER;
 518                 else
 519                         break;
 520                 i2c_read_demod_bytes(state, 0x8a, buf, 1);
 521                 if ((buf[0] & 0x04) == 0x04)
 522                         *status |= FE_HAS_SYNC;
 523                 if ((buf[0] & 0x01) == 0x01)
 524                         *status |= FE_HAS_LOCK;
 525                 if ((buf[0] & 0x08) == 0x08)
 526                         *status |= FE_HAS_VITERBI;
 527                 break;
 528         case VSB_8:
 529                 if ((buf[0] & 0x80) == 0x80)
 530                         *status |= FE_HAS_CARRIER;
 531                 else
 532                         break;
 533                 i2c_read_demod_bytes(state, 0x38, buf, 1);
 534                 if ((buf[0] & 0x02) == 0x00)
 535                         *status |= FE_HAS_SYNC;
 536                 if ((buf[0] & 0x01) == 0x01) {
 537                         *status |= FE_HAS_LOCK;
 538                         *status |= FE_HAS_VITERBI;
 539                 }
 540                 break;
 541         default:
 542                 printk("KERN_WARNING lgdt330x: %s: Modulation set to unsupported value\n", __FUNCTION__);
 543         }
 544         return 0;
 545 }
 546
 547 static int lgdt330x_read_signal_strength(struct dvb_frontend* fe, u16* strength)
 548 {
 549         /* not directly available. */
 550         *strength = 0;
 551         return 0;
 552 }
 553
 554 static int lgdt3302_read_snr(struct dvb_frontend* fe, u16* snr)
 555 {
 556 #ifdef SNR_IN_DB
 557         /*
 558          * Spec sheet shows formula for SNR_EQ = 10 log10(25 * 24**2 / noise)
 559          * and SNR_PH = 10 log10(25 * 32**2 / noise) for equalizer and phase tracker
 560          * respectively. The following tables are built on these formulas.
 561          * The usual definition is SNR = 20 log10(signal/noise)
 562          * If the specification is wrong the value retuned is 1/2 the actual SNR in db.
 563          *
 564          * This table is a an ordered list of noise values computed by the
 565          * formula from the spec sheet such that the index into the table
 566          * starting at 43 or 45 is the SNR value in db. There are duplicate noise
 567          * value entries at the beginning because the SNR varies more than
 568          * 1 db for a change of 1 digit in noise at very small values of noise.
 569          *
 570          * Examples from SNR_EQ table:
 571          * noise SNR
 572          *   0    43
 573          *   1    42
 574          *   2    39
 575          *   3    37
 576          *   4    36
 577          *   5    35
 578          *   6    34
 579          *   7    33
 580          *   8    33
 581          *   9    32
 582          *   10   32
 583          *   11   31
 584          *   12   31
 585          *   13   30
 586          */
 587
 588         static const u32 SNR_EQ[] =
 589                 { 1,     2,      2,      2, 3,      3,      4,     4,     5,     7,
 590                   9,     11,     13,     17, 21,     26,     33,    41,    52,    65,
 591                   81,    102,    129,    162, 204,    257,    323,   406,   511,   644,
 592                   810,   1020,   1284,   1616, 2035,   2561,   3224,  4059,  5110,  6433,
 593                   8098,  10195,  12835,  16158, 20341,  25608,  32238, 40585, 51094, 64323,
 594                   80978, 101945, 128341, 161571, 203406, 256073, 0x40000
 595                 };
 596
 597         static const u32 SNR_PH[] =
 598                 { 1,     2,      2,      2,      3,      3,     4,     5,     6,     8,
 599                   10,    12,     15,     19,     23,     29, 37,    46,    58,    73,
 600                   91,    115,    144,    182,    229,    288, 362,   456,   574,   722,
 601                   909,   1144,   1440,   1813,   2282,   2873, 3617,  4553,  5732,  7216,
 602                   9084,  11436,  14396,  18124,  22817,  28724,  36161, 45524, 57312, 72151,
 603                   90833, 114351, 143960, 181235, 228161, 0x080000
 604                 };
 605
 606         static u8 buf[5];/* read data buffer */
 607         static u32 noise;   /* noise value */
 608         static u32 snr_db;  /* index into SNR_EQ[] */
 609         struct lgdt330x_state* state = (struct lgdt330x_state*) fe->demodulator_priv;
 610
 611         /* read both equalizer and phase tracker noise data */
 612         i2c_read_demod_bytes(state, EQPH_ERR0, buf, sizeof(buf));
 613
 614         if (state->current_modulation == VSB_8) {
 615                 /* Equalizer Mean-Square Error Register for VSB */
 616                 noise = ((buf[0] & 7) << 16) | (buf[1] << 8) | buf[2];
 617
 618                 /*
 619                  * Look up noise value in table.
 620                  * A better search algorithm could be used...
 621                  * watch out there are duplicate entries.
 622                  */
 623                 for (snr_db = 0; snr_db < sizeof(SNR_EQ); snr_db++) {
 624                         if (noise < SNR_EQ[snr_db]) {
 625                                 *snr = 43 - snr_db;
 626                                 break;
 627                         }
 628                 }
 629         } else {
 630                 /* Phase Tracker Mean-Square Error Register for QAM */
 631                 noise = ((buf[0] & 7<<3) << 13) | (buf[3] << 8) | buf[4];
 632
 633                 /* Look up noise value in table. */
 634                 for (snr_db = 0; snr_db < sizeof(SNR_PH); snr_db++) {
 635                         if (noise < SNR_PH[snr_db]) {
 636                                 *snr = 45 - snr_db;
 637                                 break;
 638                         }
 639                 }
 640         }
 641 #else
 642         /* Return the raw noise value */
 643         static u8 buf[5];/* read data buffer */
 644         static u32 noise;   /* noise value */
 645         struct lgdt330x_state* state = (struct lgdt330x_state*) fe->demodulator_priv;
 646
 647         /* read both equalizer and pase tracker noise data */
 648         i2c_read_demod_bytes(state, EQPH_ERR0, buf, sizeof(buf));
 649
 650         if (state->current_modulation == VSB_8) {
 651                 /* Phase Tracker Mean-Square Error Register for VSB */
 652                 noise = ((buf[0] & 7<<3) << 13) | (buf[3] << 8) | buf[4];
 653         } else {
 654
 655                 /* Carrier Recovery Mean-Square Error for QAM */
 656                 i2c_read_demod_bytes(state, 0x1a, buf, 2);
 657                 noise = ((buf[0] & 3) << 8) | buf[1];
 658         }
 659
 660         /* Small values for noise mean signal is better so invert noise */
 661         *snr = ~noise;
 662 #endif
 663
 664         dprintk("%s: noise = 0x%05x, snr = %idb\n",__FUNCTION__, noise, *snr);
 665
 666         return 0;
 667 }
 668
 669 static int lgdt3303_read_snr(struct dvb_frontend* fe, u16* snr)
 670 {
 671         /* Return the raw noise value */
 672         static u8 buf[5];/* read data buffer */
 673         static u32 noise;   /* noise value */
 674         struct lgdt330x_state* state = (struct lgdt330x_state*) fe->demodulator_priv;
 675
 676         if (state->current_modulation == VSB_8) {
 677
 678                 /* Phase Tracker Mean-Square Error Register for VSB */
 679                 noise = ((buf[0] & 7) << 16) | (buf[3] << 8) | buf[4];
 680         } else {
 681
 682                 /* Carrier Recovery Mean-Square Error for QAM */
 683                 i2c_read_demod_bytes(state, 0x1a, buf, 2);
 684                 noise = (buf[0] << 8) | buf[1];
 685         }
 686
 687         /* Small values for noise mean signal is better so invert noise */
 688         *snr = ~noise;
 689
 690         dprintk("%s: noise = 0x%05x, snr = %idb\n",__FUNCTION__, noise, *snr);
 691
 692         return 0;
 693 }
 694
 695 static int lgdt330x_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings* fe_tune_settings)
 696 {
 697         /* I have no idea about this - it may not be needed */
 698         fe_tune_settings->min_delay_ms = 500;
 699         fe_tune_settings->step_size = 0;
 700         fe_tune_settings->max_drift = 0;
 701         return 0;
 702 }
 703
 704 static void lgdt330x_release(struct dvb_frontend* fe)
 705 {
 706         struct lgdt330x_state* state = (struct lgdt330x_state*) fe->demodulator_priv;
 707         kfree(state);
 708 }
 709
 710 static struct dvb_frontend_ops lgdt3302_ops;
 711 static struct dvb_frontend_ops lgdt3303_ops;
 712
 713 struct dvb_frontend* lgdt330x_attach(const struct lgdt330x_config* config,
 714                                      struct i2c_adapter* i2c)
 715 {
 716         struct lgdt330x_state* state = NULL;
 717         u8 buf[1];
 718
 719         /* Allocate memory for the internal state */
 720         state = kzalloc(sizeof(struct lgdt330x_state), GFP_KERNEL);
 721         if (state == NULL)
 722                 goto error;
 723
 724         /* Setup the state */
 725         state->config = config;
 726         state->i2c = i2c;
 727         switch (config->demod_chip) {
 728         case LGDT3302:
 729                 memcpy(&state->ops, &lgdt3302_ops, sizeof(struct dvb_frontend_ops));
 730                 break;
 731         case LGDT3303:
 732                 memcpy(&state->ops, &lgdt3303_ops, sizeof(struct dvb_frontend_ops));
 733                 break;
 734         default:
 735                 goto error;
 736         }
 737
 738         /* Verify communication with demod chip */
 739         if (i2c_read_demod_bytes(state, 2, buf, 1))
 740                 goto error;
 741
 742         state->current_frequency = -1;
 743         state->current_modulation = -1;
 744
 745         /* Create dvb_frontend */
 746         state->frontend.ops = &state->ops;
 747         state->frontend.demodulator_priv = state;
 748         return &state->frontend;
 749
 750 error:
 751         kfree(state);
 752         dprintk("%s: ERROR\n",__FUNCTION__);
 753         return NULL;
 754 }
 755
 756 static struct dvb_frontend_ops lgdt3302_ops = {
 757         .info = {
 758                 .name= "LG Electronics LGDT3302 VSB/QAM Frontend",
 759                 .type = FE_ATSC,
 760                 .frequency_min= 54000000,
 761                 .frequency_max= 858000000,
 762                 .frequency_stepsize= 62500,
 763                 .symbol_rate_min    = 5056941,  /* QAM 64 */
 764                 .symbol_rate_max    = 10762000, /* VSB 8  */
 765                 .caps = FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_8VSB
 766         },
 767         .init                 = lgdt330x_init,
 768         .set_frontend         = lgdt330x_set_parameters,
 769         .get_frontend         = lgdt330x_get_frontend,
 770         .get_tune_settings    = lgdt330x_get_tune_settings,
 771         .read_status          = lgdt3302_read_status,
 772         .read_ber             = lgdt330x_read_ber,
 773         .read_signal_strength = lgdt330x_read_signal_strength,
 774         .read_snr             = lgdt3302_read_snr,
 775         .read_ucblocks        = lgdt330x_read_ucblocks,
 776         .release              = lgdt330x_release,
 777 };
 778
 779 static struct dvb_frontend_ops lgdt3303_ops = {
 780         .info = {
 781                 .name= "LG Electronics LGDT3303 VSB/QAM Frontend",
 782                 .type = FE_ATSC,
 783                 .frequency_min= 54000000,
 784                 .frequency_max= 858000000,
 785                 .frequency_stepsize= 62500,
 786                 .symbol_rate_min    = 5056941,  /* QAM 64 */
 787                 .symbol_rate_max    = 10762000, /* VSB 8  */
 788                 .caps = FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_8VSB
 789         },
 790         .init                 = lgdt330x_init,
 791         .set_frontend         = lgdt330x_set_parameters,
 792         .get_frontend         = lgdt330x_get_frontend,
 793         .get_tune_settings    = lgdt330x_get_tune_settings,
 794         .read_status          = lgdt3303_read_status,
 795         .read_ber             = lgdt330x_read_ber,
 796         .read_signal_strength = lgdt330x_read_signal_strength,
 797         .read_snr             = lgdt3303_read_snr,
 798         .read_ucblocks        = lgdt330x_read_ucblocks,
 799         .release              = lgdt330x_release,
 800 };
 801
 802 MODULE_DESCRIPTION("LGDT330X (ATSC 8VSB & ITU-T J.83 AnnexB 64/256 QAM) Demodulator Driver");
 803 MODULE_AUTHOR("Wilson Michaels");
 804 MODULE_LICENSE("GPL");
 805
 806 EXPORT_SYMBOL(lgdt330x_attach);
 807
 808 /*
 809  * Local variables:
 810  * c-basic-offset: 8
 811  * End:
 812  */