drivers/media/dvb-frontends/lgdt330x.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *    Support for LGDT3302 and LGDT3303 - VSB/QAM
   4  *
   5  *    Copyright (C) 2005 Wilson Michaels <wilsonmichaels@earthlink.net>
   6  */
   7
   8 /*
   9  *                      NOTES ABOUT THIS DRIVER
  10  *
  11  * This Linux driver supports:
  12  *   DViCO FusionHDTV 3 Gold-Q
  13  *   DViCO FusionHDTV 3 Gold-T
  14  *   DViCO FusionHDTV 5 Gold
  15  *   DViCO FusionHDTV 5 Lite
  16  *   DViCO FusionHDTV 5 USB Gold
  17  *   Air2PC/AirStar 2 ATSC 3rd generation (HD5000)
  18  *   pcHDTV HD5500
  19  *
  20  */
  21
  22 #include <linux/kernel.h>
  23 #include <linux/module.h>
  24 #include <linux/init.h>
  25 #include <linux/delay.h>
  26 #include <linux/string.h>
  27 #include <linux/slab.h>
  28 #include <asm/byteorder.h>
  29
  30 #include <media/dvb_frontend.h>
  31 #include <media/dvb_math.h>
  32 #include "lgdt330x_priv.h"
  33 #include "lgdt330x.h"
  34
  35 /* Use Equalizer Mean Squared Error instead of Phaser Tracker MSE */
  36 /* #define USE_EQMSE */
  37
  38 static int debug;
  39 module_param(debug, int, 0644);
  40 MODULE_PARM_DESC(debug, "Turn on/off lgdt330x frontend debugging (default:off).");
  41
  42 #define dprintk(state, fmt, arg...) do {                                \
  43         if (debug)                                                      \
  44                 dev_printk(KERN_DEBUG, &state->client->dev, fmt, ##arg);\
  45 } while (0)
  46
  47 struct lgdt330x_state {
  48         struct i2c_client *client;
  49
  50         /* Configuration settings */
  51         struct lgdt330x_config config;
  52
  53         struct dvb_frontend frontend;
  54
  55         /* Demodulator private data */
  56         enum fe_modulation current_modulation;
  57         u32 snr;        /* Result of last SNR calculation */
  58         u16 ucblocks;
  59         unsigned long last_stats_time;
  60
  61         /* Tuner private data */
  62         u32 current_frequency;
  63 };
  64
  65 static int i2c_write_demod_bytes(struct lgdt330x_state *state,
  66                                  const u8 *buf, /* data bytes to send */
  67                                  int len  /* number of bytes to send */)
  68 {
  69         int i;
  70         int err;
  71
  72         for (i = 0; i < len - 1; i += 2) {
  73                 err = i2c_master_send(state->client, buf, 2);
  74                 if (err != 2) {
  75                         dev_warn(&state->client->dev,
  76                                  "%s: error (addr %02x <- %02x, err = %i)\n",
  77                                 __func__, buf[0], buf[1], err);
  78                         if (err < 0)
  79                                 return err;
  80                         else
  81                                 return -EREMOTEIO;
  82                 }
  83                 buf += 2;
  84         }
  85         return 0;
  86 }
  87
  88 /*
  89  * This routine writes the register (reg) to the demod bus
  90  * then reads the data returned for (len) bytes.
  91  */
  92 static int i2c_read_demod_bytes(struct lgdt330x_state *state,
  93                                 enum I2C_REG reg, u8 *buf, int len)
  94 {
  95         u8 wr[] = { reg };
  96         struct i2c_msg msg[] = {
  97                 {
  98                         .addr = state->client->addr,
  99                         .flags = 0,
 100                         .buf = wr,
 101                         .len = 1
 102                 }, {
 103                         .addr = state->client->addr,
 104                         .flags = I2C_M_RD,
 105                         .buf = buf,
 106                         .len = len
 107                 },
 108         };
 109         int ret;
 110
 111         ret = i2c_transfer(state->client->adapter, msg, 2);
 112         if (ret != 2) {
 113                 dev_warn(&state->client->dev,
 114                          "%s: addr 0x%02x select 0x%02x error (ret == %i)\n",
 115                          __func__, state->client->addr, reg, ret);
 116                 if (ret >= 0)
 117                         ret = -EIO;
 118         } else {
 119                 ret = 0;
 120         }
 121         return ret;
 122 }
 123
 124 /* Software reset */
 125 static int lgdt3302_sw_reset(struct lgdt330x_state *state)
 126 {
 127         u8 ret;
 128         u8 reset[] = {
 129                 IRQ_MASK,
 130                 /*
 131                  * bit 6 is active low software reset
 132                  * bits 5-0 are 1 to mask interrupts
 133                  */
 134                 0x00
 135         };
 136
 137         ret = i2c_write_demod_bytes(state,
 138                                     reset, sizeof(reset));
 139         if (ret == 0) {
 140                 /* force reset high (inactive) and unmask interrupts */
 141                 reset[1] = 0x7f;
 142                 ret = i2c_write_demod_bytes(state,
 143                                             reset, sizeof(reset));
 144         }
 145         return ret;
 146 }
 147
 148 static int lgdt3303_sw_reset(struct lgdt330x_state *state)
 149 {
 150         u8 ret;
 151         u8 reset[] = {
 152                 0x02,
 153                 0x00 /* bit 0 is active low software reset */
 154         };
 155
 156         ret = i2c_write_demod_bytes(state,
 157                                     reset, sizeof(reset));
 158         if (ret == 0) {
 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_sw_reset(struct lgdt330x_state *state)
 168 {
 169         switch (state->config.demod_chip) {
 170         case LGDT3302:
 171                 return lgdt3302_sw_reset(state);
 172         case LGDT3303:
 173                 return lgdt3303_sw_reset(state);
 174         default:
 175                 return -ENODEV;
 176         }
 177 }
 178
 179 static int lgdt330x_init(struct dvb_frontend *fe)
 180 {
 181         struct lgdt330x_state *state = fe->demodulator_priv;
 182         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
 183         char  *chip_name;
 184         int    err;
 185         /*
 186          * Array of byte pairs <address, value>
 187          * to initialize each different chip
 188          */
 189         static const u8 lgdt3302_init_data[] = {
 190                 /* Use 50MHz param values from spec sheet since xtal is 50 */
 191                 /*
 192                  * Change the value of NCOCTFV[25:0] of carrier
 193                  * recovery center frequency register
 194                  */
 195                 VSB_CARRIER_FREQ0, 0x00,
 196                 VSB_CARRIER_FREQ1, 0x87,
 197                 VSB_CARRIER_FREQ2, 0x8e,
 198                 VSB_CARRIER_FREQ3, 0x01,
 199                 /*
 200                  * Change the TPCLK pin polarity
 201                  * data is valid on falling clock
 202                  */
 203                 DEMUX_CONTROL, 0xfb,
 204                 /*
 205                  * Change the value of IFBW[11:0] of
 206                  * AGC IF/RF loop filter bandwidth register
 207                  */
 208                 AGC_RF_BANDWIDTH0, 0x40,
 209                 AGC_RF_BANDWIDTH1, 0x93,
 210                 AGC_RF_BANDWIDTH2, 0x00,
 211                 /*
 212                  * Change the value of bit 6, 'nINAGCBY' and
 213                  * 'NSSEL[1:0] of ACG function control register 2
 214                  */
 215                 AGC_FUNC_CTRL2, 0xc6,
 216                 /*
 217                  * Change the value of bit 6 'RFFIX'
 218                  * of AGC function control register 3
 219                  */
 220                 AGC_FUNC_CTRL3, 0x40,
 221                 /*
 222                  * Set the value of 'INLVTHD' register 0x2a/0x2c
 223                  * to 0x7fe
 224                  */
 225                 AGC_DELAY0, 0x07,
 226                 AGC_DELAY2, 0xfe,
 227                 /*
 228                  * Change the value of IAGCBW[15:8]
 229                  * of inner AGC loop filter bandwidth
 230                  */
 231                 AGC_LOOP_BANDWIDTH0, 0x08,
 232                 AGC_LOOP_BANDWIDTH1, 0x9a
 233         };
 234         static const u8 lgdt3303_init_data[] = {
 235                 0x4c, 0x14
 236         };
 237         static const u8 flip_1_lgdt3303_init_data[] = {
 238                 0x4c, 0x14,
 239                 0x87, 0xf3
 240         };
 241         static const u8 flip_2_lgdt3303_init_data[] = {
 242                 0x4c, 0x14,
 243                 0x87, 0xda
 244         };
 245
 246         /*
 247          * Hardware reset is done using gpio[0] of cx23880x chip.
 248          * I'd like to do it here, but don't know how to find chip address.
 249          * cx88-cards.c arranges for the reset bit to be inactive (high).
 250          * Maybe there needs to be a callable function in cx88-core or
 251          * the caller of this function needs to do it.
 252          */
 253
 254         switch (state->config.demod_chip) {
 255         case LGDT3302:
 256                 chip_name = "LGDT3302";
 257                 err = i2c_write_demod_bytes(state, lgdt3302_init_data,
 258                                             sizeof(lgdt3302_init_data));
 259                 break;
 260         case LGDT3303:
 261                 chip_name = "LGDT3303";
 262                 switch (state->config.clock_polarity_flip) {
 263                 case 2:
 264                         err = i2c_write_demod_bytes(state,
 265                                                     flip_2_lgdt3303_init_data,
 266                                                     sizeof(flip_2_lgdt3303_init_data));
 267                         break;
 268                 case 1:
 269                         err = i2c_write_demod_bytes(state,
 270                                                     flip_1_lgdt3303_init_data,
 271                                                     sizeof(flip_1_lgdt3303_init_data));
 272                         break;
 273                 case 0:
 274                 default:
 275                         err = i2c_write_demod_bytes(state, lgdt3303_init_data,
 276                                                     sizeof(lgdt3303_init_data));
 277                 }
 278                 break;
 279         default:
 280                 chip_name = "undefined";
 281                 dev_warn(&state->client->dev,
 282                          "Only LGDT3302 and LGDT3303 are supported chips.\n");
 283                 err = -ENODEV;
 284         }
 285         dprintk(state, "Initialized the %s chip\n", chip_name);
 286         if (err < 0)
 287                 return err;
 288
 289         p->cnr.len = 1;
 290         p->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 291         p->block_error.len = 1;
 292         p->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 293         p->block_count.len = 1;
 294         p->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 295         state->last_stats_time = 0;
 296
 297         return lgdt330x_sw_reset(state);
 298 }
 299
 300 static int lgdt330x_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
 301 {
 302         struct lgdt330x_state *state = fe->demodulator_priv;
 303
 304         *ucblocks = state->ucblocks;
 305
 306         return 0;
 307 }
 308
 309 static int lgdt330x_set_parameters(struct dvb_frontend *fe)
 310 {
 311         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
 312         struct lgdt330x_state *state = fe->demodulator_priv;
 313         /*
 314          * Array of byte pairs <address, value>
 315          * to initialize 8VSB for lgdt3303 chip 50 MHz IF
 316          */
 317         static const u8 lgdt3303_8vsb_44_data[] = {
 318                 0x04, 0x00,
 319                 0x0d, 0x40,
 320                 0x0e, 0x87,
 321                 0x0f, 0x8e,
 322                 0x10, 0x01,
 323                 0x47, 0x8b
 324         };
 325         /*
 326          * Array of byte pairs <address, value>
 327          * to initialize QAM for lgdt3303 chip
 328          */
 329         static const u8 lgdt3303_qam_data[] = {
 330                 0x04, 0x00,
 331                 0x0d, 0x00,
 332                 0x0e, 0x00,
 333                 0x0f, 0x00,
 334                 0x10, 0x00,
 335                 0x51, 0x63,
 336                 0x47, 0x66,
 337                 0x48, 0x66,
 338                 0x4d, 0x1a,
 339                 0x49, 0x08,
 340                 0x4a, 0x9b
 341         };
 342         u8 top_ctrl_cfg[]   = { TOP_CONTROL, 0x03 };
 343
 344         int err = 0;
 345         /* Change only if we are actually changing the modulation */
 346         if (state->current_modulation != p->modulation) {
 347                 switch (p->modulation) {
 348                 case VSB_8:
 349                         dprintk(state, "VSB_8 MODE\n");
 350
 351                         /* Select VSB mode */
 352                         top_ctrl_cfg[1] = 0x03;
 353
 354                         /* Select ANT connector if supported by card */
 355                         if (state->config.pll_rf_set)
 356                                 state->config.pll_rf_set(fe, 1);
 357
 358                         if (state->config.demod_chip == LGDT3303) {
 359                                 err = i2c_write_demod_bytes(state,
 360                                                             lgdt3303_8vsb_44_data,
 361                                                             sizeof(lgdt3303_8vsb_44_data));
 362                         }
 363                         break;
 364
 365                 case QAM_64:
 366                         dprintk(state, "QAM_64 MODE\n");
 367
 368                         /* Select QAM_64 mode */
 369                         top_ctrl_cfg[1] = 0x00;
 370
 371                         /* Select CABLE connector if supported by card */
 372                         if (state->config.pll_rf_set)
 373                                 state->config.pll_rf_set(fe, 0);
 374
 375                         if (state->config.demod_chip == LGDT3303) {
 376                                 err = i2c_write_demod_bytes(state,
 377                                                             lgdt3303_qam_data,
 378                                                             sizeof(lgdt3303_qam_data));
 379                         }
 380                         break;
 381
 382                 case QAM_256:
 383                         dprintk(state, "QAM_256 MODE\n");
 384
 385                         /* Select QAM_256 mode */
 386                         top_ctrl_cfg[1] = 0x01;
 387
 388                         /* Select CABLE connector if supported by card */
 389                         if (state->config.pll_rf_set)
 390                                 state->config.pll_rf_set(fe, 0);
 391
 392                         if (state->config.demod_chip == LGDT3303) {
 393                                 err = i2c_write_demod_bytes(state,
 394                                                             lgdt3303_qam_data,
 395                                                             sizeof(lgdt3303_qam_data));
 396                         }
 397                         break;
 398                 default:
 399                         dev_warn(&state->client->dev,
 400                                  "%s: Modulation type(%d) UNSUPPORTED\n",
 401                                  __func__, p->modulation);
 402                         return -1;
 403                 }
 404                 if (err < 0)
 405                         dev_warn(&state->client->dev,
 406                                  "%s: error blasting bytes to lgdt3303 for modulation type(%d)\n",
 407                                  __func__, p->modulation);
 408
 409                 /*
 410                  * select serial or parallel MPEG hardware interface
 411                  * Serial:   0x04 for LGDT3302 or 0x40 for LGDT3303
 412                  * Parallel: 0x00
 413                  */
 414                 top_ctrl_cfg[1] |= state->config.serial_mpeg;
 415
 416                 /* Select the requested mode */
 417                 i2c_write_demod_bytes(state, top_ctrl_cfg,
 418                                       sizeof(top_ctrl_cfg));
 419                 if (state->config.set_ts_params)
 420                         state->config.set_ts_params(fe, 0);
 421                 state->current_modulation = p->modulation;
 422         }
 423
 424         /* Tune to the specified frequency */
 425         if (fe->ops.tuner_ops.set_params) {
 426                 fe->ops.tuner_ops.set_params(fe);
 427                 if (fe->ops.i2c_gate_ctrl)
 428                         fe->ops.i2c_gate_ctrl(fe, 0);
 429         }
 430
 431         /* Keep track of the new frequency */
 432         /*
 433          * FIXME this is the wrong way to do this...
 434          * The tuner is shared with the video4linux analog API
 435          */
 436         state->current_frequency = p->frequency;
 437
 438         lgdt330x_sw_reset(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 /*
 452  * Calculate SNR estimation (scaled by 2^24)
 453  *
 454  * 8-VSB SNR equations from LGDT3302 and LGDT3303 datasheets, QAM
 455  * equations from LGDT3303 datasheet.  VSB is the same between the '02
 456  * and '03, so maybe QAM is too?  Perhaps someone with a newer datasheet
 457  * that has QAM information could verify?
 458  *
 459  * For 8-VSB: (two ways, take your pick)
 460  * LGDT3302:
 461  *   SNR_EQ = 10 * log10(25 * 24^2 / EQ_MSE)
 462  * LGDT3303:
 463  *   SNR_EQ = 10 * log10(25 * 32^2 / EQ_MSE)
 464  * LGDT3302 & LGDT3303:
 465  *   SNR_PT = 10 * log10(25 * 32^2 / PT_MSE)  (we use this one)
 466  * For 64-QAM:
 467  *   SNR    = 10 * log10( 688128   / MSEQAM)
 468  * For 256-QAM:
 469  *   SNR    = 10 * log10( 696320   / MSEQAM)
 470  *
 471  * We re-write the snr equation as:
 472  *   SNR * 2^24 = 10*(c - intlog10(MSE))
 473  * Where for 256-QAM, c = log10(696320) * 2^24, and so on.
 474  */
 475 static u32 calculate_snr(u32 mse, u32 c)
 476 {
 477         if (mse == 0) /* No signal */
 478                 return 0;
 479
 480         mse = intlog10(mse);
 481         if (mse > c) {
 482                 /*
 483                  * Negative SNR, which is possible, but realisticly the
 484                  * demod will lose lock before the signal gets this bad.
 485                  * The API only allows for unsigned values, so just return 0
 486                  */
 487                 return 0;
 488         }
 489         return 10 * (c - mse);
 490 }
 491
 492 static int lgdt3302_read_snr(struct dvb_frontend *fe)
 493 {
 494         struct lgdt330x_state *state = fe->demodulator_priv;
 495         u8 buf[5];      /* read data buffer */
 496         u32 noise;      /* noise value */
 497         u32 c;          /* per-modulation SNR calculation constant */
 498
 499         switch (state->current_modulation) {
 500         case VSB_8:
 501                 i2c_read_demod_bytes(state, LGDT3302_EQPH_ERR0, buf, 5);
 502 #ifdef USE_EQMSE
 503                 /* Use Equalizer Mean-Square Error Register */
 504                 /* SNR for ranges from -15.61 to +41.58 */
 505                 noise = ((buf[0] & 7) << 16) | (buf[1] << 8) | buf[2];
 506                 c = 69765745; /* log10(25*24^2)*2^24 */
 507 #else
 508                 /* Use Phase Tracker Mean-Square Error Register */
 509                 /* SNR for ranges from -13.11 to +44.08 */
 510                 noise = ((buf[0] & 7 << 3) << 13) | (buf[3] << 8) | buf[4];
 511                 c = 73957994; /* log10(25*32^2)*2^24 */
 512 #endif
 513                 break;
 514         case QAM_64:
 515         case QAM_256:
 516                 i2c_read_demod_bytes(state, CARRIER_MSEQAM1, buf, 2);
 517                 noise = ((buf[0] & 3) << 8) | buf[1];
 518                 c = state->current_modulation == QAM_64 ? 97939837 : 98026066;
 519                 /* log10(688128)*2^24 and log10(696320)*2^24 */
 520                 break;
 521         default:
 522                 dev_err(&state->client->dev,
 523                         "%s: Modulation set to unsupported value\n",
 524                         __func__);
 525
 526                 state->snr = 0;
 527
 528                 return -EREMOTEIO; /* return -EDRIVER_IS_GIBBERED; */
 529         }
 530
 531         state->snr = calculate_snr(noise, c);
 532
 533         dprintk(state, "noise = 0x%08x, snr = %d.%02d dB\n", noise,
 534                 state->snr >> 24, (((state->snr >> 8) & 0xffff) * 100) >> 16);
 535
 536         return 0;
 537 }
 538
 539 static int lgdt3303_read_snr(struct dvb_frontend *fe)
 540 {
 541         struct lgdt330x_state *state = fe->demodulator_priv;
 542         u8 buf[5];      /* read data buffer */
 543         u32 noise;      /* noise value */
 544         u32 c;          /* per-modulation SNR calculation constant */
 545
 546         switch (state->current_modulation) {
 547         case VSB_8:
 548                 i2c_read_demod_bytes(state, LGDT3303_EQPH_ERR0, buf, 5);
 549 #ifdef USE_EQMSE
 550                 /* Use Equalizer Mean-Square Error Register */
 551                 /* SNR for ranges from -16.12 to +44.08 */
 552                 noise = ((buf[0] & 0x78) << 13) | (buf[1] << 8) | buf[2];
 553                 c = 73957994; /* log10(25*32^2)*2^24 */
 554 #else
 555                 /* Use Phase Tracker Mean-Square Error Register */
 556                 /* SNR for ranges from -13.11 to +44.08 */
 557                 noise = ((buf[0] & 7) << 16) | (buf[3] << 8) | buf[4];
 558                 c = 73957994; /* log10(25*32^2)*2^24 */
 559 #endif
 560                 break;
 561         case QAM_64:
 562         case QAM_256:
 563                 i2c_read_demod_bytes(state, CARRIER_MSEQAM1, buf, 2);
 564                 noise = (buf[0] << 8) | buf[1];
 565                 c = state->current_modulation == QAM_64 ? 97939837 : 98026066;
 566                 /* log10(688128)*2^24 and log10(696320)*2^24 */
 567                 break;
 568         default:
 569                 dev_err(&state->client->dev,
 570                         "%s: Modulation set to unsupported value\n",
 571                         __func__);
 572                 state->snr = 0;
 573                 return -EREMOTEIO; /* return -EDRIVER_IS_GIBBERED; */
 574         }
 575
 576         state->snr = calculate_snr(noise, c);
 577
 578         dprintk(state, "noise = 0x%08x, snr = %d.%02d dB\n", noise,
 579                 state->snr >> 24, (((state->snr >> 8) & 0xffff) * 100) >> 16);
 580
 581         return 0;
 582 }
 583
 584 static int lgdt330x_read_snr(struct dvb_frontend *fe, u16 *snr)
 585 {
 586         struct lgdt330x_state *state = fe->demodulator_priv;
 587
 588         *snr = (state->snr) >> 16; /* Convert from 8.24 fixed-point to 8.8 */
 589
 590         return 0;
 591 }
 592
 593 static int lgdt330x_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
 594 {
 595         /* Calculate Strength from SNR up to 35dB */
 596         /*
 597          * Even though the SNR can go higher than 35dB, there is some comfort
 598          * factor in having a range of strong signals that can show at 100%
 599          */
 600         struct lgdt330x_state *state = fe->demodulator_priv;
 601         u16 snr;
 602         int ret;
 603
 604         ret = fe->ops.read_snr(fe, &snr);
 605         if (ret != 0)
 606                 return ret;
 607         /* Rather than use the 8.8 value snr, use state->snr which is 8.24 */
 608         /* scale the range 0 - 35*2^24 into 0 - 65535 */
 609         if (state->snr >= 8960 * 0x10000)
 610                 *strength = 0xffff;
 611         else
 612                 *strength = state->snr / 8960;
 613
 614         return 0;
 615 }
 616
 617
 618 static int lgdt3302_read_status(struct dvb_frontend *fe,
 619                                 enum fe_status *status)
 620 {
 621         struct lgdt330x_state *state = fe->demodulator_priv;
 622         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
 623         u8 buf[3];
 624         int err;
 625
 626         *status = 0; /* Reset status result */
 627
 628         /* AGC status register */
 629         i2c_read_demod_bytes(state, AGC_STATUS, buf, 1);
 630         dprintk(state, "AGC_STATUS = 0x%02x\n", buf[0]);
 631         if ((buf[0] & 0x0c) == 0x8) {
 632                 /*
 633                  * Test signal does not exist flag
 634                  * as well as the AGC lock flag.
 635                  */
 636                 *status |= FE_HAS_SIGNAL;
 637         }
 638
 639         /*
 640          * You must set the Mask bits to 1 in the IRQ_MASK in order
 641          * to see that status bit in the IRQ_STATUS register.
 642          * This is done in SwReset();
 643          */
 644
 645         /* signal status */
 646         i2c_read_demod_bytes(state, TOP_CONTROL, buf, sizeof(buf));
 647         dprintk(state,
 648                 "TOP_CONTROL = 0x%02x, IRO_MASK = 0x%02x, IRQ_STATUS = 0x%02x\n",
 649                 buf[0], buf[1], buf[2]);
 650
 651         /* sync status */
 652         if ((buf[2] & 0x03) == 0x01)
 653                 *status |= FE_HAS_SYNC;
 654
 655         /* FEC error status */
 656         if ((buf[2] & 0x0c) == 0x08)
 657                 *status |= FE_HAS_LOCK | FE_HAS_VITERBI;
 658
 659         /* Carrier Recovery Lock Status Register */
 660         i2c_read_demod_bytes(state, CARRIER_LOCK, buf, 1);
 661         dprintk(state, "CARRIER_LOCK = 0x%02x\n", buf[0]);
 662         switch (state->current_modulation) {
 663         case QAM_256:
 664         case QAM_64:
 665                 /* Need to understand why there are 3 lock levels here */
 666                 if ((buf[0] & 0x07) == 0x07)
 667                         *status |= FE_HAS_CARRIER;
 668                 break;
 669         case VSB_8:
 670                 if ((buf[0] & 0x80) == 0x80)
 671                         *status |= FE_HAS_CARRIER;
 672                 break;
 673         default:
 674                 dev_warn(&state->client->dev,
 675                          "%s: Modulation set to unsupported value\n",
 676                          __func__);
 677         }
 678
 679         if (!(*status & FE_HAS_LOCK)) {
 680                 p->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 681                 p->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 682                 p->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 683                 return 0;
 684         }
 685
 686         if (state->last_stats_time &&
 687             time_is_after_jiffies(state->last_stats_time))
 688                 return 0;
 689
 690         state->last_stats_time = jiffies + msecs_to_jiffies(1000);
 691
 692         err = lgdt3302_read_snr(fe);
 693         if (!err) {
 694                 p->cnr.stat[0].scale = FE_SCALE_DECIBEL;
 695                 p->cnr.stat[0].svalue = (((u64)state->snr) * 1000) >> 24;
 696         } else {
 697                 p->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 698         }
 699
 700         err = i2c_read_demod_bytes(state, LGDT3302_PACKET_ERR_COUNTER1,
 701                                            buf, sizeof(buf));
 702         if (!err) {
 703                 state->ucblocks = (buf[0] << 8) | buf[1];
 704
 705                 dprintk(state, "UCB = 0x%02x\n", state->ucblocks);
 706
 707                 p->block_error.stat[0].uvalue += state->ucblocks;
 708                 /* FIXME: what's the basis for block count */
 709                 p->block_count.stat[0].uvalue += 10000;
 710
 711                 p->block_error.stat[0].scale = FE_SCALE_COUNTER;
 712                 p->block_count.stat[0].scale = FE_SCALE_COUNTER;
 713         } else {
 714                 p->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 715                 p->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 716         }
 717
 718         return 0;
 719 }
 720
 721 static int lgdt3303_read_status(struct dvb_frontend *fe,
 722                                 enum fe_status *status)
 723 {
 724         struct lgdt330x_state *state = fe->demodulator_priv;
 725         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
 726         u8 buf[3];
 727         int err;
 728
 729         *status = 0; /* Reset status result */
 730
 731         /* lgdt3303 AGC status register */
 732         err = i2c_read_demod_bytes(state, 0x58, buf, 1);
 733         if (err < 0)
 734                 return err;
 735
 736         dprintk(state, "AGC_STATUS = 0x%02x\n", buf[0]);
 737         if ((buf[0] & 0x21) == 0x01) {
 738                 /*
 739                  * Test input signal does not exist flag
 740                  * as well as the AGC lock flag.
 741                  */
 742                 *status |= FE_HAS_SIGNAL;
 743         }
 744
 745         /* Carrier Recovery Lock Status Register */
 746         i2c_read_demod_bytes(state, CARRIER_LOCK, buf, 1);
 747         dprintk(state, "CARRIER_LOCK = 0x%02x\n", buf[0]);
 748         switch (state->current_modulation) {
 749         case QAM_256:
 750         case QAM_64:
 751                 /* Need to understand why there are 3 lock levels here */
 752                 if ((buf[0] & 0x07) == 0x07)
 753                         *status |= FE_HAS_CARRIER;
 754                 else
 755                         break;
 756                 i2c_read_demod_bytes(state, 0x8a, buf, 1);
 757                 dprintk(state, "QAM LOCK = 0x%02x\n", buf[0]);
 758
 759                 if ((buf[0] & 0x04) == 0x04)
 760                         *status |= FE_HAS_SYNC;
 761                 if ((buf[0] & 0x01) == 0x01)
 762                         *status |= FE_HAS_LOCK;
 763                 if ((buf[0] & 0x08) == 0x08)
 764                         *status |= FE_HAS_VITERBI;
 765                 break;
 766         case VSB_8:
 767                 if ((buf[0] & 0x80) == 0x80)
 768                         *status |= FE_HAS_CARRIER;
 769                 else
 770                         break;
 771                 i2c_read_demod_bytes(state, 0x38, buf, 1);
 772                 dprintk(state, "8-VSB LOCK = 0x%02x\n", buf[0]);
 773
 774                 if ((buf[0] & 0x02) == 0x00)
 775                         *status |= FE_HAS_SYNC;
 776                 if ((buf[0] & 0x01) == 0x01)
 777                         *status |= FE_HAS_VITERBI | FE_HAS_LOCK;
 778                 break;
 779         default:
 780                 dev_warn(&state->client->dev,
 781                          "%s: Modulation set to unsupported value\n",
 782                          __func__);
 783         }
 784
 785         if (!(*status & FE_HAS_LOCK)) {
 786                 p->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 787                 p->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 788                 p->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 789                 return 0;
 790         }
 791
 792         if (state->last_stats_time &&
 793             time_is_after_jiffies(state->last_stats_time))
 794                 return 0;
 795
 796         state->last_stats_time = jiffies + msecs_to_jiffies(1000);
 797
 798         err = lgdt3303_read_snr(fe);
 799         if (!err) {
 800                 p->cnr.stat[0].scale = FE_SCALE_DECIBEL;
 801                 p->cnr.stat[0].svalue = (((u64)state->snr) * 1000) >> 24;
 802         } else {
 803                 p->cnr.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 804         }
 805
 806         err = i2c_read_demod_bytes(state, LGDT3303_PACKET_ERR_COUNTER1,
 807                                            buf, sizeof(buf));
 808         if (!err) {
 809                 state->ucblocks = (buf[0] << 8) | buf[1];
 810
 811                 dprintk(state, "UCB = 0x%02x\n", state->ucblocks);
 812
 813                 p->block_error.stat[0].uvalue += state->ucblocks;
 814                 /* FIXME: what's the basis for block count */
 815                 p->block_count.stat[0].uvalue += 10000;
 816
 817                 p->block_error.stat[0].scale = FE_SCALE_COUNTER;
 818                 p->block_count.stat[0].scale = FE_SCALE_COUNTER;
 819         } else {
 820                 p->block_error.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 821                 p->block_count.stat[0].scale = FE_SCALE_NOT_AVAILABLE;
 822         }
 823
 824         return 0;
 825 }
 826
 827 static int
 828 lgdt330x_get_tune_settings(struct dvb_frontend *fe,
 829                            struct dvb_frontend_tune_settings *fe_tune_settings)
 830 {
 831         /* I have no idea about this - it may not be needed */
 832         fe_tune_settings->min_delay_ms = 500;
 833         fe_tune_settings->step_size = 0;
 834         fe_tune_settings->max_drift = 0;
 835         return 0;
 836 }
 837
 838 static void lgdt330x_release(struct dvb_frontend *fe)
 839 {
 840         struct lgdt330x_state *state = fe->demodulator_priv;
 841         struct i2c_client *client = state->client;
 842
 843         dev_dbg(&client->dev, "\n");
 844
 845         i2c_unregister_device(client);
 846 }
 847
 848 static struct dvb_frontend *lgdt330x_get_dvb_frontend(struct i2c_client *client)
 849 {
 850         struct lgdt330x_state *state = i2c_get_clientdata(client);
 851
 852         dev_dbg(&client->dev, "\n");
 853
 854         return &state->frontend;
 855 }
 856
 857 static const struct dvb_frontend_ops lgdt3302_ops;
 858 static const struct dvb_frontend_ops lgdt3303_ops;
 859
 860 static int lgdt330x_probe(struct i2c_client *client,
 861                           const struct i2c_device_id *id)
 862 {
 863         struct lgdt330x_state *state = NULL;
 864         u8 buf[1];
 865
 866         /* Allocate memory for the internal state */
 867         state = kzalloc(sizeof(*state), GFP_KERNEL);
 868         if (!state)
 869                 goto error;
 870
 871         /* Setup the state */
 872         memcpy(&state->config, client->dev.platform_data,
 873                sizeof(state->config));
 874         i2c_set_clientdata(client, state);
 875         state->client = client;
 876
 877         /* Create dvb_frontend */
 878         switch (state->config.demod_chip) {
 879         case LGDT3302:
 880                 memcpy(&state->frontend.ops, &lgdt3302_ops,
 881                        sizeof(struct dvb_frontend_ops));
 882                 break;
 883         case LGDT3303:
 884                 memcpy(&state->frontend.ops, &lgdt3303_ops,
 885                        sizeof(struct dvb_frontend_ops));
 886                 break;
 887         default:
 888                 goto error;
 889         }
 890         state->frontend.demodulator_priv = state;
 891
 892         /* Setup get frontend callback */
 893         state->config.get_dvb_frontend = lgdt330x_get_dvb_frontend;
 894
 895         /* Verify communication with demod chip */
 896         if (i2c_read_demod_bytes(state, 2, buf, 1))
 897                 goto error;
 898
 899         state->current_frequency = -1;
 900         state->current_modulation = -1;
 901
 902         dev_info(&state->client->dev,
 903                 "Demod loaded for LGDT330%s chip\n",
 904                 state->config.demod_chip == LGDT3302 ? "2" : "3");
 905
 906         return 0;
 907
 908 error:
 909         kfree(state);
 910         if (debug)
 911                 dev_printk(KERN_DEBUG, &client->dev, "Error loading lgdt330x driver\n");
 912         return -ENODEV;
 913 }
 914 struct dvb_frontend *lgdt330x_attach(const struct lgdt330x_config *_config,
 915                                      u8 demod_address,
 916                                      struct i2c_adapter *i2c)
 917 {
 918         struct i2c_client *client;
 919         struct i2c_board_info board_info = {};
 920         struct lgdt330x_config config = *_config;
 921
 922         strscpy(board_info.type, "lgdt330x", sizeof(board_info.type));
 923         board_info.addr = demod_address;
 924         board_info.platform_data = &config;
 925         client = i2c_new_device(i2c, &board_info);
 926         if (!client || !client->dev.driver)
 927                 return NULL;
 928
 929         return lgdt330x_get_dvb_frontend(client);
 930 }
 931 EXPORT_SYMBOL(lgdt330x_attach);
 932
 933 static const struct dvb_frontend_ops lgdt3302_ops = {
 934         .delsys = { SYS_ATSC, SYS_DVBC_ANNEX_B },
 935         .info = {
 936                 .name = "LG Electronics LGDT3302 VSB/QAM Frontend",
 937                 .frequency_min_hz =  54 * MHz,
 938                 .frequency_max_hz = 858 * MHz,
 939                 .frequency_stepsize_hz = 62500,
 940                 .symbol_rate_min    = 5056941,  /* QAM 64 */
 941                 .symbol_rate_max    = 10762000, /* VSB 8  */
 942                 .caps = FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_8VSB
 943         },
 944         .init                 = lgdt330x_init,
 945         .set_frontend         = lgdt330x_set_parameters,
 946         .get_frontend         = lgdt330x_get_frontend,
 947         .get_tune_settings    = lgdt330x_get_tune_settings,
 948         .read_status          = lgdt3302_read_status,
 949         .read_signal_strength = lgdt330x_read_signal_strength,
 950         .read_snr             = lgdt330x_read_snr,
 951         .read_ucblocks        = lgdt330x_read_ucblocks,
 952         .release              = lgdt330x_release,
 953 };
 954
 955 static const struct dvb_frontend_ops lgdt3303_ops = {
 956         .delsys = { SYS_ATSC, SYS_DVBC_ANNEX_B },
 957         .info = {
 958                 .name = "LG Electronics LGDT3303 VSB/QAM Frontend",
 959                 .frequency_min_hz =  54 * MHz,
 960                 .frequency_max_hz = 858 * MHz,
 961                 .frequency_stepsize_hz = 62500,
 962                 .symbol_rate_min    = 5056941,  /* QAM 64 */
 963                 .symbol_rate_max    = 10762000, /* VSB 8  */
 964                 .caps = FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_8VSB
 965         },
 966         .init                 = lgdt330x_init,
 967         .set_frontend         = lgdt330x_set_parameters,
 968         .get_frontend         = lgdt330x_get_frontend,
 969         .get_tune_settings    = lgdt330x_get_tune_settings,
 970         .read_status          = lgdt3303_read_status,
 971         .read_signal_strength = lgdt330x_read_signal_strength,
 972         .read_snr             = lgdt330x_read_snr,
 973         .read_ucblocks        = lgdt330x_read_ucblocks,
 974         .release              = lgdt330x_release,
 975 };
 976
 977 static int lgdt330x_remove(struct i2c_client *client)
 978 {
 979         struct lgdt330x_state *state = i2c_get_clientdata(client);
 980
 981         dev_dbg(&client->dev, "\n");
 982
 983         kfree(state);
 984
 985         return 0;
 986 }
 987
 988 static const struct i2c_device_id lgdt330x_id_table[] = {
 989         {"lgdt330x", 0},
 990         {}
 991 };
 992 MODULE_DEVICE_TABLE(i2c, lgdt330x_id_table);
 993
 994 static struct i2c_driver lgdt330x_driver = {
 995         .driver = {
 996                 .name   = "lgdt330x",
 997                 .suppress_bind_attrs = true,
 998         },
 999         .probe          = lgdt330x_probe,
1000         .remove         = lgdt330x_remove,
1001         .id_table       = lgdt330x_id_table,
1002 };
1003
1004 module_i2c_driver(lgdt330x_driver);
1005
1006
1007 MODULE_DESCRIPTION("LGDT330X (ATSC 8VSB & ITU-T J.83 AnnexB 64/256 QAM) Demodulator Driver");
1008 MODULE_AUTHOR("Wilson Michaels");
1009 MODULE_LICENSE("GPL");