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