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