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