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  */
  35
  36 #include <linux/kernel.h>
  37 #include <linux/module.h>
  38 #include <linux/init.h>
  39 #include <linux/delay.h>
  40 #include <linux/string.h>
  41 #include <linux/slab.h>
  42 #include <asm/byteorder.h>
  43
  44 #include "dvb_frontend.h"
  45 #include "dvb_math.h"
  46 #include "lgdt330x_priv.h"
  47 #include "lgdt330x.h"
  48
  49 /* Use Equalizer Mean Squared Error instead of Phaser Tracker MSE */
  50 /* #define USE_EQMSE */
  51
  52 static int debug;
  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
  64         /* Configuration settings */
  65         const struct lgdt330x_config* config;
  66
  67         struct dvb_frontend frontend;
  68
  69         /* Demodulator private data */
  70         enum fe_modulation current_modulation;
  71         u32 snr; /* Result of last SNR calculation */
  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", __func__, 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 int 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", __func__, state->config->demod_address, reg, ret);
 121                 if (ret >= 0)
 122                         ret = -EIO;
 123         } else {
 124                 ret = 0;
 125         }
 126         return ret;
 127 }
 128
 129 /* Software reset */
 130 static int lgdt3302_SwReset(struct lgdt330x_state* state)
 131 {
 132         u8 ret;
 133         u8 reset[] = {
 134                 IRQ_MASK,
 135                 0x00 /* bit 6 is active low software reset
 136                       * bits 5-0 are 1 to mask interrupts */
 137         };
 138
 139         ret = i2c_write_demod_bytes(state,
 140                                     reset, sizeof(reset));
 141         if (ret == 0) {
 142
 143                 /* force reset high (inactive) and unmask interrupts */
 144                 reset[1] = 0x7f;
 145                 ret = i2c_write_demod_bytes(state,
 146                                             reset, sizeof(reset));
 147         }
 148         return ret;
 149 }
 150
 151 static int lgdt3303_SwReset(struct lgdt330x_state* state)
 152 {
 153         u8 ret;
 154         u8 reset[] = {
 155                 0x02,
 156                 0x00 /* bit 0 is active low software reset */
 157         };
 158
 159         ret = i2c_write_demod_bytes(state,
 160                                     reset, sizeof(reset));
 161         if (ret == 0) {
 162
 163                 /* force reset high (inactive) */
 164                 reset[1] = 0x01;
 165                 ret = i2c_write_demod_bytes(state,
 166                                             reset, sizeof(reset));
 167         }
 168         return ret;
 169 }
 170
 171 static int lgdt330x_SwReset(struct lgdt330x_state* state)
 172 {
 173         switch (state->config->demod_chip) {
 174         case LGDT3302:
 175                 return lgdt3302_SwReset(state);
 176         case LGDT3303:
 177                 return lgdt3303_SwReset(state);
 178         default:
 179                 return -ENODEV;
 180         }
 181 }
 182
 183 static int lgdt330x_init(struct dvb_frontend* fe)
 184 {
 185         /* Hardware reset is done using gpio[0] of cx23880x chip.
 186          * I'd like to do it here, but don't know how to find chip address.
 187          * cx88-cards.c arranges for the reset bit to be inactive (high).
 188          * Maybe there needs to be a callable function in cx88-core or
 189          * the caller of this function needs to do it. */
 190
 191         /*
 192          * Array of byte pairs <address, value>
 193          * to initialize each different chip
 194          */
 195         static u8 lgdt3302_init_data[] = {
 196                 /* Use 50MHz parameter values from spec sheet since xtal is 50 */
 197                 /* Change the value of NCOCTFV[25:0] of carrier
 198                    recovery center frequency register */
 199                 VSB_CARRIER_FREQ0, 0x00,
 200                 VSB_CARRIER_FREQ1, 0x87,
 201                 VSB_CARRIER_FREQ2, 0x8e,
 202                 VSB_CARRIER_FREQ3, 0x01,
 203                 /* Change the TPCLK pin polarity
 204                    data is valid on falling clock */
 205                 DEMUX_CONTROL, 0xfb,
 206                 /* Change the value of IFBW[11:0] of
 207                    AGC IF/RF loop filter bandwidth register */
 208                 AGC_RF_BANDWIDTH0, 0x40,
 209                 AGC_RF_BANDWIDTH1, 0x93,
 210                 AGC_RF_BANDWIDTH2, 0x00,
 211                 /* Change the value of bit 6, 'nINAGCBY' and
 212                    'NSSEL[1:0] of ACG function control register 2 */
 213                 AGC_FUNC_CTRL2, 0xc6,
 214                 /* Change the value of bit 6 'RFFIX'
 215                    of AGC function control register 3 */
 216                 AGC_FUNC_CTRL3, 0x40,
 217                 /* Set the value of 'INLVTHD' register 0x2a/0x2c
 218                    to 0x7fe */
 219                 AGC_DELAY0, 0x07,
 220                 AGC_DELAY2, 0xfe,
 221                 /* Change the value of IAGCBW[15:8]
 222                    of inner AGC loop filter bandwidth */
 223                 AGC_LOOP_BANDWIDTH0, 0x08,
 224                 AGC_LOOP_BANDWIDTH1, 0x9a
 225         };
 226
 227         static u8 lgdt3303_init_data[] = {
 228                 0x4c, 0x14
 229         };
 230
 231         static u8 flip_1_lgdt3303_init_data[] = {
 232                 0x4c, 0x14,
 233                 0x87, 0xf3
 234         };
 235
 236         static u8 flip_2_lgdt3303_init_data[] = {
 237                 0x4c, 0x14,
 238                 0x87, 0xda
 239         };
 240
 241         struct lgdt330x_state* state = fe->demodulator_priv;
 242         char  *chip_name;
 243         int    err;
 244
 245         switch (state->config->demod_chip) {
 246         case LGDT3302:
 247                 chip_name = "LGDT3302";
 248                 err = i2c_write_demod_bytes(state, lgdt3302_init_data,
 249                                             sizeof(lgdt3302_init_data));
 250                 break;
 251         case LGDT3303:
 252                 chip_name = "LGDT3303";
 253                 switch (state->config->clock_polarity_flip) {
 254                 case 2:
 255                         err = i2c_write_demod_bytes(state,
 256                                         flip_2_lgdt3303_init_data,
 257                                         sizeof(flip_2_lgdt3303_init_data));
 258                         break;
 259                 case 1:
 260                         err = i2c_write_demod_bytes(state,
 261                                         flip_1_lgdt3303_init_data,
 262                                         sizeof(flip_1_lgdt3303_init_data));
 263                         break;
 264                 case 0:
 265                 default:
 266                         err = i2c_write_demod_bytes(state, lgdt3303_init_data,
 267                                                     sizeof(lgdt3303_init_data));
 268                 }
 269                 break;
 270         default:
 271                 chip_name = "undefined";
 272                 printk (KERN_WARNING "Only LGDT3302 and LGDT3303 are supported chips.\n");
 273                 err = -ENODEV;
 274         }
 275         dprintk("%s entered as %s\n", __func__, chip_name);
 276         if (err < 0)
 277                 return err;
 278         return lgdt330x_SwReset(state);
 279 }
 280
 281 static int lgdt330x_read_ber(struct dvb_frontend* fe, u32* ber)
 282 {
 283         *ber = 0; /* Not supplied by the demod chips */
 284         return 0;
 285 }
 286
 287 static int lgdt330x_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
 288 {
 289         struct lgdt330x_state* state = fe->demodulator_priv;
 290         int err;
 291         u8 buf[2];
 292
 293         *ucblocks = 0;
 294
 295         switch (state->config->demod_chip) {
 296         case LGDT3302:
 297                 err = i2c_read_demod_bytes(state, LGDT3302_PACKET_ERR_COUNTER1,
 298                                            buf, sizeof(buf));
 299                 break;
 300         case LGDT3303:
 301                 err = i2c_read_demod_bytes(state, LGDT3303_PACKET_ERR_COUNTER1,
 302                                            buf, sizeof(buf));
 303                 break;
 304         default:
 305                 printk(KERN_WARNING
 306                        "Only LGDT3302 and LGDT3303 are supported chips.\n");
 307                 err = -ENODEV;
 308         }
 309         if (err < 0)
 310                 return err;
 311
 312         *ucblocks = (buf[0] << 8) | buf[1];
 313         return 0;
 314 }
 315
 316 static int lgdt330x_set_parameters(struct dvb_frontend *fe)
 317 {
 318         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
 319         /*
 320          * Array of byte pairs <address, value>
 321          * to initialize 8VSB for lgdt3303 chip 50 MHz IF
 322          */
 323         static u8 lgdt3303_8vsb_44_data[] = {
 324                 0x04, 0x00,
 325                 0x0d, 0x40,
 326                 0x0e, 0x87,
 327                 0x0f, 0x8e,
 328                 0x10, 0x01,
 329                 0x47, 0x8b };
 330
 331         /*
 332          * Array of byte pairs <address, value>
 333          * to initialize QAM for lgdt3303 chip
 334          */
 335         static u8 lgdt3303_qam_data[] = {
 336                 0x04, 0x00,
 337                 0x0d, 0x00,
 338                 0x0e, 0x00,
 339                 0x0f, 0x00,
 340                 0x10, 0x00,
 341                 0x51, 0x63,
 342                 0x47, 0x66,
 343                 0x48, 0x66,
 344                 0x4d, 0x1a,
 345                 0x49, 0x08,
 346                 0x4a, 0x9b };
 347
 348         struct lgdt330x_state* state = fe->demodulator_priv;
 349
 350         static u8 top_ctrl_cfg[]   = { TOP_CONTROL, 0x03 };
 351
 352         int err = 0;
 353         /* Change only if we are actually changing the modulation */
 354         if (state->current_modulation != p->modulation) {
 355                 switch (p->modulation) {
 356                 case VSB_8:
 357                         dprintk("%s: VSB_8 MODE\n", __func__);
 358
 359                         /* Select VSB mode */
 360                         top_ctrl_cfg[1] = 0x03;
 361
 362                         /* Select ANT connector if supported by card */
 363                         if (state->config->pll_rf_set)
 364                                 state->config->pll_rf_set(fe, 1);
 365
 366                         if (state->config->demod_chip == LGDT3303) {
 367                                 err = i2c_write_demod_bytes(state, lgdt3303_8vsb_44_data,
 368                                                             sizeof(lgdt3303_8vsb_44_data));
 369                         }
 370                         break;
 371
 372                 case QAM_64:
 373                         dprintk("%s: QAM_64 MODE\n", __func__);
 374
 375                         /* Select QAM_64 mode */
 376                         top_ctrl_cfg[1] = 0x00;
 377
 378                         /* Select CABLE connector if supported by card */
 379                         if (state->config->pll_rf_set)
 380                                 state->config->pll_rf_set(fe, 0);
 381
 382                         if (state->config->demod_chip == LGDT3303) {
 383                                 err = i2c_write_demod_bytes(state, lgdt3303_qam_data,
 384                                                                                         sizeof(lgdt3303_qam_data));
 385                         }
 386                         break;
 387
 388                 case QAM_256:
 389                         dprintk("%s: QAM_256 MODE\n", __func__);
 390
 391                         /* Select QAM_256 mode */
 392                         top_ctrl_cfg[1] = 0x01;
 393
 394                         /* Select CABLE connector if supported by card */
 395                         if (state->config->pll_rf_set)
 396                                 state->config->pll_rf_set(fe, 0);
 397
 398                         if (state->config->demod_chip == LGDT3303) {
 399                                 err = i2c_write_demod_bytes(state, lgdt3303_qam_data,
 400                                                                                         sizeof(lgdt3303_qam_data));
 401                         }
 402                         break;
 403                 default:
 404                         printk(KERN_WARNING "lgdt330x: %s: Modulation type(%d) UNSUPPORTED\n", __func__, p->modulation);
 405                         return -1;
 406                 }
 407                 if (err < 0)
 408                         printk(KERN_WARNING "lgdt330x: %s: error blasting "
 409                                "bytes to lgdt3303 for modulation type(%d)\n",
 410                                __func__, p->modulation);
 411
 412                 /*
 413                  * select serial or parallel MPEG harware interface
 414                  * Serial:   0x04 for LGDT3302 or 0x40 for LGDT3303
 415                  * Parallel: 0x00
 416                  */
 417                 top_ctrl_cfg[1] |= state->config->serial_mpeg;
 418
 419                 /* Select the requested mode */
 420                 i2c_write_demod_bytes(state, top_ctrl_cfg,
 421                                       sizeof(top_ctrl_cfg));
 422                 if (state->config->set_ts_params)
 423                         state->config->set_ts_params(fe, 0);
 424                 state->current_modulation = p->modulation;
 425         }
 426
 427         /* Tune to the specified frequency */
 428         if (fe->ops.tuner_ops.set_params) {
 429                 fe->ops.tuner_ops.set_params(fe);
 430                 if (fe->ops.i2c_gate_ctrl) fe->ops.i2c_gate_ctrl(fe, 0);
 431         }
 432
 433         /* Keep track of the new frequency */
 434         /* FIXME this is the wrong way to do this...           */
 435         /* The tuner is shared with the video4linux analog API */
 436         state->current_frequency = p->frequency;
 437
 438         lgdt330x_SwReset(state);
 439         return 0;
 440 }
 441
 442 static int lgdt330x_get_frontend(struct dvb_frontend *fe,
 443                                  struct dtv_frontend_properties *p)
 444 {
 445         struct lgdt330x_state *state = fe->demodulator_priv;
 446
 447         p->frequency = state->current_frequency;
 448         return 0;
 449 }
 450
 451 static int lgdt3302_read_status(struct dvb_frontend *fe,
 452                                 enum fe_status *status)
 453 {
 454         struct lgdt330x_state* state = fe->demodulator_priv;
 455         u8 buf[3];
 456
 457         *status = 0; /* Reset status result */
 458
 459         /* AGC status register */
 460         i2c_read_demod_bytes(state, AGC_STATUS, buf, 1);
 461         dprintk("%s: AGC_STATUS = 0x%02x\n", __func__, buf[0]);
 462         if ((buf[0] & 0x0c) == 0x8){
 463                 /* Test signal does not exist flag */
 464                 /* as well as the AGC lock flag.   */
 465                 *status |= FE_HAS_SIGNAL;
 466         }
 467
 468         /*
 469          * You must set the Mask bits to 1 in the IRQ_MASK in order
 470          * to see that status bit in the IRQ_STATUS register.
 471          * This is done in SwReset();
 472          */
 473         /* signal status */
 474         i2c_read_demod_bytes(state, TOP_CONTROL, buf, sizeof(buf));
 475         dprintk("%s: TOP_CONTROL = 0x%02x, IRO_MASK = 0x%02x, IRQ_STATUS = 0x%02x\n", __func__, buf[0], buf[1], buf[2]);
 476
 477
 478         /* sync status */
 479         if ((buf[2] & 0x03) == 0x01) {
 480                 *status |= FE_HAS_SYNC;
 481         }
 482
 483         /* FEC error status */
 484         if ((buf[2] & 0x0c) == 0x08) {
 485                 *status |= FE_HAS_LOCK;
 486                 *status |= FE_HAS_VITERBI;
 487         }
 488
 489         /* Carrier Recovery Lock Status Register */
 490         i2c_read_demod_bytes(state, CARRIER_LOCK, buf, 1);
 491         dprintk("%s: CARRIER_LOCK = 0x%02x\n", __func__, buf[0]);
 492         switch (state->current_modulation) {
 493         case QAM_256:
 494         case QAM_64:
 495                 /* Need to understand why there are 3 lock levels here */
 496                 if ((buf[0] & 0x07) == 0x07)
 497                         *status |= FE_HAS_CARRIER;
 498                 break;
 499         case VSB_8:
 500                 if ((buf[0] & 0x80) == 0x80)
 501                         *status |= FE_HAS_CARRIER;
 502                 break;
 503         default:
 504                 printk(KERN_WARNING "lgdt330x: %s: Modulation set to unsupported value\n", __func__);
 505         }
 506
 507         return 0;
 508 }
 509
 510 static int lgdt3303_read_status(struct dvb_frontend *fe,
 511                                 enum fe_status *status)
 512 {
 513         struct lgdt330x_state* state = fe->demodulator_priv;
 514         int err;
 515         u8 buf[3];
 516
 517         *status = 0; /* Reset status result */
 518
 519         /* lgdt3303 AGC status register */
 520         err = i2c_read_demod_bytes(state, 0x58, buf, 1);
 521         if (err < 0)
 522                 return err;
 523
 524         dprintk("%s: AGC_STATUS = 0x%02x\n", __func__, buf[0]);
 525         if ((buf[0] & 0x21) == 0x01){
 526                 /* Test input signal does not exist flag */
 527                 /* as well as the AGC lock flag.   */
 528                 *status |= FE_HAS_SIGNAL;
 529         }
 530
 531         /* Carrier Recovery Lock Status Register */
 532         i2c_read_demod_bytes(state, CARRIER_LOCK, buf, 1);
 533         dprintk("%s: CARRIER_LOCK = 0x%02x\n", __func__, buf[0]);
 534         switch (state->current_modulation) {
 535         case QAM_256:
 536         case QAM_64:
 537                 /* Need to understand why there are 3 lock levels here */
 538                 if ((buf[0] & 0x07) == 0x07)
 539                         *status |= FE_HAS_CARRIER;
 540                 else
 541                         break;
 542                 i2c_read_demod_bytes(state, 0x8a, buf, 1);
 543                 if ((buf[0] & 0x04) == 0x04)
 544                         *status |= FE_HAS_SYNC;
 545                 if ((buf[0] & 0x01) == 0x01)
 546                         *status |= FE_HAS_LOCK;
 547                 if ((buf[0] & 0x08) == 0x08)
 548                         *status |= FE_HAS_VITERBI;
 549                 break;
 550         case VSB_8:
 551                 if ((buf[0] & 0x80) == 0x80)
 552                         *status |= FE_HAS_CARRIER;
 553                 else
 554                         break;
 555                 i2c_read_demod_bytes(state, 0x38, buf, 1);
 556                 if ((buf[0] & 0x02) == 0x00)
 557                         *status |= FE_HAS_SYNC;
 558                 if ((buf[0] & 0x01) == 0x01) {
 559                         *status |= FE_HAS_LOCK;
 560                         *status |= FE_HAS_VITERBI;
 561                 }
 562                 break;
 563         default:
 564                 printk(KERN_WARNING "lgdt330x: %s: Modulation set to unsupported value\n", __func__);
 565         }
 566         return 0;
 567 }
 568
 569 /* Calculate SNR estimation (scaled by 2^24)
 570
 571    8-VSB SNR equations from LGDT3302 and LGDT3303 datasheets, QAM
 572    equations from LGDT3303 datasheet.  VSB is the same between the '02
 573    and '03, so maybe QAM is too?  Perhaps someone with a newer datasheet
 574    that has QAM information could verify?
 575
 576    For 8-VSB: (two ways, take your pick)
 577    LGDT3302:
 578      SNR_EQ = 10 * log10(25 * 24^2 / EQ_MSE)
 579    LGDT3303:
 580      SNR_EQ = 10 * log10(25 * 32^2 / EQ_MSE)
 581    LGDT3302 & LGDT3303:
 582      SNR_PT = 10 * log10(25 * 32^2 / PT_MSE)  (we use this one)
 583    For 64-QAM:
 584      SNR    = 10 * log10( 688128   / MSEQAM)
 585    For 256-QAM:
 586      SNR    = 10 * log10( 696320   / MSEQAM)
 587
 588    We re-write the snr equation as:
 589      SNR * 2^24 = 10*(c - intlog10(MSE))
 590    Where for 256-QAM, c = log10(696320) * 2^24, and so on. */
 591
 592 static u32 calculate_snr(u32 mse, u32 c)
 593 {
 594         if (mse == 0) /* No signal */
 595                 return 0;
 596
 597         mse = intlog10(mse);
 598         if (mse > c) {
 599                 /* Negative SNR, which is possible, but realisticly the
 600                 demod will lose lock before the signal gets this bad.  The
 601                 API only allows for unsigned values, so just return 0 */
 602                 return 0;
 603         }
 604         return 10*(c - mse);
 605 }
 606
 607 static int lgdt3302_read_snr(struct dvb_frontend* fe, u16* snr)
 608 {
 609         struct lgdt330x_state* state = (struct lgdt330x_state*) fe->demodulator_priv;
 610         u8 buf[5];      /* read data buffer */
 611         u32 noise;      /* noise value */
 612         u32 c;          /* per-modulation SNR calculation constant */
 613
 614         switch(state->current_modulation) {
 615         case VSB_8:
 616                 i2c_read_demod_bytes(state, LGDT3302_EQPH_ERR0, buf, 5);
 617 #ifdef USE_EQMSE
 618                 /* Use Equalizer Mean-Square Error Register */
 619                 /* SNR for ranges from -15.61 to +41.58 */
 620                 noise = ((buf[0] & 7) << 16) | (buf[1] << 8) | buf[2];
 621                 c = 69765745; /* log10(25*24^2)*2^24 */
 622 #else
 623                 /* Use Phase Tracker Mean-Square Error Register */
 624                 /* SNR for ranges from -13.11 to +44.08 */
 625                 noise = ((buf[0] & 7<<3) << 13) | (buf[3] << 8) | buf[4];
 626                 c = 73957994; /* log10(25*32^2)*2^24 */
 627 #endif
 628                 break;
 629         case QAM_64:
 630         case QAM_256:
 631                 i2c_read_demod_bytes(state, CARRIER_MSEQAM1, buf, 2);
 632                 noise = ((buf[0] & 3) << 8) | buf[1];
 633                 c = state->current_modulation == QAM_64 ? 97939837 : 98026066;
 634                 /* log10(688128)*2^24 and log10(696320)*2^24 */
 635                 break;
 636         default:
 637                 printk(KERN_ERR "lgdt330x: %s: Modulation set to unsupported value\n",
 638                        __func__);
 639                 return -EREMOTEIO; /* return -EDRIVER_IS_GIBBERED; */
 640         }
 641
 642         state->snr = calculate_snr(noise, c);
 643         *snr = (state->snr) >> 16; /* Convert from 8.24 fixed-point to 8.8 */
 644
 645         dprintk("%s: noise = 0x%08x, snr = %d.%02d dB\n", __func__, noise,
 646                 state->snr >> 24, (((state->snr>>8) & 0xffff) * 100) >> 16);
 647
 648         return 0;
 649 }
 650
 651 static int lgdt3303_read_snr(struct dvb_frontend* fe, u16* snr)
 652 {
 653         struct lgdt330x_state* state = (struct lgdt330x_state*) fe->demodulator_priv;
 654         u8 buf[5];      /* read data buffer */
 655         u32 noise;      /* noise value */
 656         u32 c;          /* per-modulation SNR calculation constant */
 657
 658         switch(state->current_modulation) {
 659         case VSB_8:
 660                 i2c_read_demod_bytes(state, LGDT3303_EQPH_ERR0, buf, 5);
 661 #ifdef USE_EQMSE
 662                 /* Use Equalizer Mean-Square Error Register */
 663                 /* SNR for ranges from -16.12 to +44.08 */
 664                 noise = ((buf[0] & 0x78) << 13) | (buf[1] << 8) | buf[2];
 665                 c = 73957994; /* log10(25*32^2)*2^24 */
 666 #else
 667                 /* Use Phase Tracker Mean-Square Error Register */
 668                 /* SNR for ranges from -13.11 to +44.08 */
 669                 noise = ((buf[0] & 7) << 16) | (buf[3] << 8) | buf[4];
 670                 c = 73957994; /* log10(25*32^2)*2^24 */
 671 #endif
 672                 break;
 673         case QAM_64:
 674         case QAM_256:
 675                 i2c_read_demod_bytes(state, CARRIER_MSEQAM1, buf, 2);
 676                 noise = (buf[0] << 8) | buf[1];
 677                 c = state->current_modulation == QAM_64 ? 97939837 : 98026066;
 678                 /* log10(688128)*2^24 and log10(696320)*2^24 */
 679                 break;
 680         default:
 681                 printk(KERN_ERR "lgdt330x: %s: Modulation set to unsupported value\n",
 682                        __func__);
 683                 return -EREMOTEIO; /* return -EDRIVER_IS_GIBBERED; */
 684         }
 685
 686         state->snr = calculate_snr(noise, c);
 687         *snr = (state->snr) >> 16; /* Convert from 8.24 fixed-point to 8.8 */
 688
 689         dprintk("%s: noise = 0x%08x, snr = %d.%02d dB\n", __func__, noise,
 690                 state->snr >> 24, (((state->snr >> 8) & 0xffff) * 100) >> 16);
 691
 692         return 0;
 693 }
 694
 695 static int lgdt330x_read_signal_strength(struct dvb_frontend* fe, u16* strength)
 696 {
 697         /* Calculate Strength from SNR up to 35dB */
 698         /* Even though the SNR can go higher than 35dB, there is some comfort */
 699         /* factor in having a range of strong signals that can show at 100%   */
 700         struct lgdt330x_state* state = (struct lgdt330x_state*) fe->demodulator_priv;
 701         u16 snr;
 702         int ret;
 703
 704         ret = fe->ops.read_snr(fe, &snr);
 705         if (ret != 0)
 706                 return ret;
 707         /* Rather than use the 8.8 value snr, use state->snr which is 8.24 */
 708         /* scale the range 0 - 35*2^24 into 0 - 65535 */
 709         if (state->snr >= 8960 * 0x10000)
 710                 *strength = 0xffff;
 711         else
 712                 *strength = state->snr / 8960;
 713
 714         return 0;
 715 }
 716
 717 static int lgdt330x_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings* fe_tune_settings)
 718 {
 719         /* I have no idea about this - it may not be needed */
 720         fe_tune_settings->min_delay_ms = 500;
 721         fe_tune_settings->step_size = 0;
 722         fe_tune_settings->max_drift = 0;
 723         return 0;
 724 }
 725
 726 static void lgdt330x_release(struct dvb_frontend* fe)
 727 {
 728         struct lgdt330x_state* state = (struct lgdt330x_state*) fe->demodulator_priv;
 729         kfree(state);
 730 }
 731
 732 static struct dvb_frontend_ops lgdt3302_ops;
 733 static struct dvb_frontend_ops lgdt3303_ops;
 734
 735 struct dvb_frontend* lgdt330x_attach(const struct lgdt330x_config* config,
 736                                      struct i2c_adapter* i2c)
 737 {
 738         struct lgdt330x_state* state = NULL;
 739         u8 buf[1];
 740
 741         /* Allocate memory for the internal state */
 742         state = kzalloc(sizeof(struct lgdt330x_state), GFP_KERNEL);
 743         if (state == NULL)
 744                 goto error;
 745
 746         /* Setup the state */
 747         state->config = config;
 748         state->i2c = i2c;
 749
 750         /* Create dvb_frontend */
 751         switch (config->demod_chip) {
 752         case LGDT3302:
 753                 memcpy(&state->frontend.ops, &lgdt3302_ops, sizeof(struct dvb_frontend_ops));
 754                 break;
 755         case LGDT3303:
 756                 memcpy(&state->frontend.ops, &lgdt3303_ops, sizeof(struct dvb_frontend_ops));
 757                 break;
 758         default:
 759                 goto error;
 760         }
 761         state->frontend.demodulator_priv = state;
 762
 763         /* Verify communication with demod chip */
 764         if (i2c_read_demod_bytes(state, 2, buf, 1))
 765                 goto error;
 766
 767         state->current_frequency = -1;
 768         state->current_modulation = -1;
 769
 770         return &state->frontend;
 771
 772 error:
 773         kfree(state);
 774         dprintk("%s: ERROR\n",__func__);
 775         return NULL;
 776 }
 777
 778 static struct dvb_frontend_ops lgdt3302_ops = {
 779         .delsys = { SYS_ATSC, SYS_DVBC_ANNEX_B },
 780         .info = {
 781                 .name= "LG Electronics LGDT3302 VSB/QAM Frontend",
 782                 .frequency_min= 54000000,
 783                 .frequency_max= 858000000,
 784                 .frequency_stepsize= 62500,
 785                 .symbol_rate_min    = 5056941,  /* QAM 64 */
 786                 .symbol_rate_max    = 10762000, /* VSB 8  */
 787                 .caps = FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_8VSB
 788         },
 789         .init                 = lgdt330x_init,
 790         .set_frontend         = lgdt330x_set_parameters,
 791         .get_frontend         = lgdt330x_get_frontend,
 792         .get_tune_settings    = lgdt330x_get_tune_settings,
 793         .read_status          = lgdt3302_read_status,
 794         .read_ber             = lgdt330x_read_ber,
 795         .read_signal_strength = lgdt330x_read_signal_strength,
 796         .read_snr             = lgdt3302_read_snr,
 797         .read_ucblocks        = lgdt330x_read_ucblocks,
 798         .release              = lgdt330x_release,
 799 };
 800
 801 static struct dvb_frontend_ops lgdt3303_ops = {
 802         .delsys = { SYS_ATSC, SYS_DVBC_ANNEX_B },
 803         .info = {
 804                 .name= "LG Electronics LGDT3303 VSB/QAM Frontend",
 805                 .frequency_min= 54000000,
 806                 .frequency_max= 858000000,
 807                 .frequency_stepsize= 62500,
 808                 .symbol_rate_min    = 5056941,  /* QAM 64 */
 809                 .symbol_rate_max    = 10762000, /* VSB 8  */
 810                 .caps = FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_8VSB
 811         },
 812         .init                 = lgdt330x_init,
 813         .set_frontend         = lgdt330x_set_parameters,
 814         .get_frontend         = lgdt330x_get_frontend,
 815         .get_tune_settings    = lgdt330x_get_tune_settings,
 816         .read_status          = lgdt3303_read_status,
 817         .read_ber             = lgdt330x_read_ber,
 818         .read_signal_strength = lgdt330x_read_signal_strength,
 819         .read_snr             = lgdt3303_read_snr,
 820         .read_ucblocks        = lgdt330x_read_ucblocks,
 821         .release              = lgdt330x_release,
 822 };
 823
 824 MODULE_DESCRIPTION("LGDT330X (ATSC 8VSB & ITU-T J.83 AnnexB 64/256 QAM) Demodulator Driver");
 825 MODULE_AUTHOR("Wilson Michaels");
 826 MODULE_LICENSE("GPL");
 827
 828 EXPORT_SYMBOL(lgdt330x_attach);