root/drivers/media/dvb-frontends/lgdt330x.c

DEFINITIONS

1. i2c_write_demod_bytes
2. i2c_read_demod_bytes
3. lgdt3302_sw_reset
4. lgdt3303_sw_reset
5. lgdt330x_sw_reset
6. lgdt330x_init
7. lgdt330x_read_ucblocks
8. lgdt330x_set_parameters
9. lgdt330x_get_frontend
10. calculate_snr
11. lgdt3302_read_snr
12. lgdt3303_read_snr
13. lgdt330x_read_snr
14. lgdt330x_read_signal_strength
15. lgdt3302_read_status
16. lgdt3303_read_status
17. lgdt330x_get_tune_settings
18. lgdt330x_release
19. lgdt330x_get_dvb_frontend
20. lgdt330x_probe
21. lgdt330x_attach
22. lgdt330x_remove

   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");