1/* 2 Driver for ST STV0299 demodulator 3 4 Copyright (C) 2001-2002 Convergence Integrated Media GmbH 5 <ralph@convergence.de>, 6 <holger@convergence.de>, 7 <js@convergence.de> 8 9 10 Philips SU1278/SH 11 12 Copyright (C) 2002 by Peter Schildmann <peter.schildmann@web.de> 13 14 15 LG TDQF-S001F 16 17 Copyright (C) 2002 Felix Domke <tmbinc@elitedvb.net> 18 & Andreas Oberritter <obi@linuxtv.org> 19 20 21 Support for Samsung TBMU24112IMB used on Technisat SkyStar2 rev. 2.6B 22 23 Copyright (C) 2003 Vadim Catana <skystar@moldova.cc>: 24 25 Support for Philips SU1278 on Technotrend hardware 26 27 Copyright (C) 2004 Andrew de Quincey <adq_dvb@lidskialf.net> 28 29 This program is free software; you can redistribute it and/or modify 30 it under the terms of the GNU General Public License as published by 31 the Free Software Foundation; either version 2 of the License, or 32 (at your option) any later version. 33 34 This program is distributed in the hope that it will be useful, 35 but WITHOUT ANY WARRANTY; without even the implied warranty of 36 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 37 GNU General Public License for more details. 38 39 You should have received a copy of the GNU General Public License 40 along with this program; if not, write to the Free Software 41 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 42 43*/ 44 45#include <linux/init.h> 46#include <linux/kernel.h> 47#include <linux/module.h> 48#include <linux/string.h> 49#include <linux/slab.h> 50#include <linux/jiffies.h> 51#include <asm/div64.h> 52 53#include "dvb_frontend.h" 54#include "stv0299.h" 55 56struct stv0299_state { 57 struct i2c_adapter* i2c; 58 const struct stv0299_config* config; 59 struct dvb_frontend frontend; 60 61 u8 initialised:1; 62 u32 tuner_frequency; 63 u32 symbol_rate; 64 fe_code_rate_t fec_inner; 65 int errmode; 66 u32 ucblocks; 67}; 68 69#define STATUS_BER 0 70#define STATUS_UCBLOCKS 1 71 72static int debug; 73static int debug_legacy_dish_switch; 74#define dprintk(args...) \ 75 do { \ 76 if (debug) printk(KERN_DEBUG "stv0299: " args); \ 77 } while (0) 78 79 80static int stv0299_writeregI (struct stv0299_state* state, u8 reg, u8 data) 81{ 82 int ret; 83 u8 buf [] = { reg, data }; 84 struct i2c_msg msg = { .addr = state->config->demod_address, .flags = 0, .buf = buf, .len = 2 }; 85 86 ret = i2c_transfer (state->i2c, &msg, 1); 87 88 if (ret != 1) 89 dprintk("%s: writereg error (reg == 0x%02x, val == 0x%02x, " 90 "ret == %i)\n", __func__, reg, data, ret); 91 92 return (ret != 1) ? -EREMOTEIO : 0; 93} 94 95static int stv0299_write(struct dvb_frontend* fe, u8 *buf, int len) 96{ 97 struct stv0299_state* state = fe->demodulator_priv; 98 99 if (len != 2) 100 return -EINVAL; 101 102 return stv0299_writeregI(state, buf[0], buf[1]); 103} 104 105static u8 stv0299_readreg (struct stv0299_state* state, u8 reg) 106{ 107 int ret; 108 u8 b0 [] = { reg }; 109 u8 b1 [] = { 0 }; 110 struct i2c_msg msg [] = { { .addr = state->config->demod_address, .flags = 0, .buf = b0, .len = 1 }, 111 { .addr = state->config->demod_address, .flags = I2C_M_RD, .buf = b1, .len = 1 } }; 112 113 ret = i2c_transfer (state->i2c, msg, 2); 114 115 if (ret != 2) 116 dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n", 117 __func__, reg, ret); 118 119 return b1[0]; 120} 121 122static int stv0299_readregs (struct stv0299_state* state, u8 reg1, u8 *b, u8 len) 123{ 124 int ret; 125 struct i2c_msg msg [] = { { .addr = state->config->demod_address, .flags = 0, .buf = ®1, .len = 1 }, 126 { .addr = state->config->demod_address, .flags = I2C_M_RD, .buf = b, .len = len } }; 127 128 ret = i2c_transfer (state->i2c, msg, 2); 129 130 if (ret != 2) 131 dprintk("%s: readreg error (ret == %i)\n", __func__, ret); 132 133 return ret == 2 ? 0 : ret; 134} 135 136static int stv0299_set_FEC (struct stv0299_state* state, fe_code_rate_t fec) 137{ 138 dprintk ("%s\n", __func__); 139 140 switch (fec) { 141 case FEC_AUTO: 142 { 143 return stv0299_writeregI (state, 0x31, 0x1f); 144 } 145 case FEC_1_2: 146 { 147 return stv0299_writeregI (state, 0x31, 0x01); 148 } 149 case FEC_2_3: 150 { 151 return stv0299_writeregI (state, 0x31, 0x02); 152 } 153 case FEC_3_4: 154 { 155 return stv0299_writeregI (state, 0x31, 0x04); 156 } 157 case FEC_5_6: 158 { 159 return stv0299_writeregI (state, 0x31, 0x08); 160 } 161 case FEC_7_8: 162 { 163 return stv0299_writeregI (state, 0x31, 0x10); 164 } 165 default: 166 { 167 return -EINVAL; 168 } 169 } 170} 171 172static fe_code_rate_t stv0299_get_fec (struct stv0299_state* state) 173{ 174 static fe_code_rate_t fec_tab [] = { FEC_2_3, FEC_3_4, FEC_5_6, 175 FEC_7_8, FEC_1_2 }; 176 u8 index; 177 178 dprintk ("%s\n", __func__); 179 180 index = stv0299_readreg (state, 0x1b); 181 index &= 0x7; 182 183 if (index > 4) 184 return FEC_AUTO; 185 186 return fec_tab [index]; 187} 188 189static int stv0299_wait_diseqc_fifo (struct stv0299_state* state, int timeout) 190{ 191 unsigned long start = jiffies; 192 193 dprintk ("%s\n", __func__); 194 195 while (stv0299_readreg(state, 0x0a) & 1) { 196 if (jiffies - start > timeout) { 197 dprintk ("%s: timeout!!\n", __func__); 198 return -ETIMEDOUT; 199 } 200 msleep(10); 201 }; 202 203 return 0; 204} 205 206static int stv0299_wait_diseqc_idle (struct stv0299_state* state, int timeout) 207{ 208 unsigned long start = jiffies; 209 210 dprintk ("%s\n", __func__); 211 212 while ((stv0299_readreg(state, 0x0a) & 3) != 2 ) { 213 if (jiffies - start > timeout) { 214 dprintk ("%s: timeout!!\n", __func__); 215 return -ETIMEDOUT; 216 } 217 msleep(10); 218 }; 219 220 return 0; 221} 222 223static int stv0299_set_symbolrate (struct dvb_frontend* fe, u32 srate) 224{ 225 struct stv0299_state* state = fe->demodulator_priv; 226 u64 big = srate; 227 u32 ratio; 228 229 // check rate is within limits 230 if ((srate < 1000000) || (srate > 45000000)) return -EINVAL; 231 232 // calculate value to program 233 big = big << 20; 234 big += (state->config->mclk-1); // round correctly 235 do_div(big, state->config->mclk); 236 ratio = big << 4; 237 238 return state->config->set_symbol_rate(fe, srate, ratio); 239} 240 241static int stv0299_get_symbolrate (struct stv0299_state* state) 242{ 243 u32 Mclk = state->config->mclk / 4096L; 244 u32 srate; 245 s32 offset; 246 u8 sfr[3]; 247 s8 rtf; 248 249 dprintk ("%s\n", __func__); 250 251 stv0299_readregs (state, 0x1f, sfr, 3); 252 stv0299_readregs (state, 0x1a, (u8 *)&rtf, 1); 253 254 srate = (sfr[0] << 8) | sfr[1]; 255 srate *= Mclk; 256 srate /= 16; 257 srate += (sfr[2] >> 4) * Mclk / 256; 258 offset = (s32) rtf * (srate / 4096L); 259 offset /= 128; 260 261 dprintk ("%s : srate = %i\n", __func__, srate); 262 dprintk ("%s : ofset = %i\n", __func__, offset); 263 264 srate += offset; 265 266 srate += 1000; 267 srate /= 2000; 268 srate *= 2000; 269 270 return srate; 271} 272 273static int stv0299_send_diseqc_msg (struct dvb_frontend* fe, 274 struct dvb_diseqc_master_cmd *m) 275{ 276 struct stv0299_state* state = fe->demodulator_priv; 277 u8 val; 278 int i; 279 280 dprintk ("%s\n", __func__); 281 282 if (stv0299_wait_diseqc_idle (state, 100) < 0) 283 return -ETIMEDOUT; 284 285 val = stv0299_readreg (state, 0x08); 286 287 if (stv0299_writeregI (state, 0x08, (val & ~0x7) | 0x6)) /* DiSEqC mode */ 288 return -EREMOTEIO; 289 290 for (i=0; i<m->msg_len; i++) { 291 if (stv0299_wait_diseqc_fifo (state, 100) < 0) 292 return -ETIMEDOUT; 293 294 if (stv0299_writeregI (state, 0x09, m->msg[i])) 295 return -EREMOTEIO; 296 } 297 298 if (stv0299_wait_diseqc_idle (state, 100) < 0) 299 return -ETIMEDOUT; 300 301 return 0; 302} 303 304static int stv0299_send_diseqc_burst (struct dvb_frontend* fe, fe_sec_mini_cmd_t burst) 305{ 306 struct stv0299_state* state = fe->demodulator_priv; 307 u8 val; 308 309 dprintk ("%s\n", __func__); 310 311 if (stv0299_wait_diseqc_idle (state, 100) < 0) 312 return -ETIMEDOUT; 313 314 val = stv0299_readreg (state, 0x08); 315 316 if (stv0299_writeregI (state, 0x08, (val & ~0x7) | 0x2)) /* burst mode */ 317 return -EREMOTEIO; 318 319 if (stv0299_writeregI (state, 0x09, burst == SEC_MINI_A ? 0x00 : 0xff)) 320 return -EREMOTEIO; 321 322 if (stv0299_wait_diseqc_idle (state, 100) < 0) 323 return -ETIMEDOUT; 324 325 if (stv0299_writeregI (state, 0x08, val)) 326 return -EREMOTEIO; 327 328 return 0; 329} 330 331static int stv0299_set_tone (struct dvb_frontend* fe, fe_sec_tone_mode_t tone) 332{ 333 struct stv0299_state* state = fe->demodulator_priv; 334 u8 val; 335 336 if (stv0299_wait_diseqc_idle (state, 100) < 0) 337 return -ETIMEDOUT; 338 339 val = stv0299_readreg (state, 0x08); 340 341 switch (tone) { 342 case SEC_TONE_ON: 343 return stv0299_writeregI (state, 0x08, val | 0x3); 344 345 case SEC_TONE_OFF: 346 return stv0299_writeregI (state, 0x08, (val & ~0x3) | 0x02); 347 348 default: 349 return -EINVAL; 350 } 351} 352 353static int stv0299_set_voltage (struct dvb_frontend* fe, fe_sec_voltage_t voltage) 354{ 355 struct stv0299_state* state = fe->demodulator_priv; 356 u8 reg0x08; 357 u8 reg0x0c; 358 359 dprintk("%s: %s\n", __func__, 360 voltage == SEC_VOLTAGE_13 ? "SEC_VOLTAGE_13" : 361 voltage == SEC_VOLTAGE_18 ? "SEC_VOLTAGE_18" : "??"); 362 363 reg0x08 = stv0299_readreg (state, 0x08); 364 reg0x0c = stv0299_readreg (state, 0x0c); 365 366 /** 367 * H/V switching over OP0, OP1 and OP2 are LNB power enable bits 368 */ 369 reg0x0c &= 0x0f; 370 reg0x08 = (reg0x08 & 0x3f) | (state->config->lock_output << 6); 371 372 switch (voltage) { 373 case SEC_VOLTAGE_13: 374 if (state->config->volt13_op0_op1 == STV0299_VOLT13_OP0) 375 reg0x0c |= 0x10; /* OP1 off, OP0 on */ 376 else 377 reg0x0c |= 0x40; /* OP1 on, OP0 off */ 378 break; 379 case SEC_VOLTAGE_18: 380 reg0x0c |= 0x50; /* OP1 on, OP0 on */ 381 break; 382 case SEC_VOLTAGE_OFF: 383 /* LNB power off! */ 384 reg0x08 = 0x00; 385 reg0x0c = 0x00; 386 break; 387 default: 388 return -EINVAL; 389 }; 390 391 if (state->config->op0_off) 392 reg0x0c &= ~0x10; 393 394 stv0299_writeregI(state, 0x08, reg0x08); 395 return stv0299_writeregI(state, 0x0c, reg0x0c); 396} 397 398static int stv0299_send_legacy_dish_cmd (struct dvb_frontend* fe, unsigned long cmd) 399{ 400 struct stv0299_state* state = fe->demodulator_priv; 401 u8 reg0x08; 402 u8 reg0x0c; 403 u8 lv_mask = 0x40; 404 u8 last = 1; 405 int i; 406 struct timeval nexttime; 407 struct timeval tv[10]; 408 409 reg0x08 = stv0299_readreg (state, 0x08); 410 reg0x0c = stv0299_readreg (state, 0x0c); 411 reg0x0c &= 0x0f; 412 stv0299_writeregI (state, 0x08, (reg0x08 & 0x3f) | (state->config->lock_output << 6)); 413 if (state->config->volt13_op0_op1 == STV0299_VOLT13_OP0) 414 lv_mask = 0x10; 415 416 cmd = cmd << 1; 417 if (debug_legacy_dish_switch) 418 printk ("%s switch command: 0x%04lx\n",__func__, cmd); 419 420 do_gettimeofday (&nexttime); 421 if (debug_legacy_dish_switch) 422 memcpy (&tv[0], &nexttime, sizeof (struct timeval)); 423 stv0299_writeregI (state, 0x0c, reg0x0c | 0x50); /* set LNB to 18V */ 424 425 dvb_frontend_sleep_until(&nexttime, 32000); 426 427 for (i=0; i<9; i++) { 428 if (debug_legacy_dish_switch) 429 do_gettimeofday (&tv[i+1]); 430 if((cmd & 0x01) != last) { 431 /* set voltage to (last ? 13V : 18V) */ 432 stv0299_writeregI (state, 0x0c, reg0x0c | (last ? lv_mask : 0x50)); 433 last = (last) ? 0 : 1; 434 } 435 436 cmd = cmd >> 1; 437 438 if (i != 8) 439 dvb_frontend_sleep_until(&nexttime, 8000); 440 } 441 if (debug_legacy_dish_switch) { 442 printk ("%s(%d): switch delay (should be 32k followed by all 8k\n", 443 __func__, fe->dvb->num); 444 for (i = 1; i < 10; i++) 445 printk ("%d: %d\n", i, timeval_usec_diff(tv[i-1] , tv[i])); 446 } 447 448 return 0; 449} 450 451static int stv0299_init (struct dvb_frontend* fe) 452{ 453 struct stv0299_state* state = fe->demodulator_priv; 454 int i; 455 u8 reg; 456 u8 val; 457 458 dprintk("stv0299: init chip\n"); 459 460 for (i = 0; ; i += 2) { 461 reg = state->config->inittab[i]; 462 val = state->config->inittab[i+1]; 463 if (reg == 0xff && val == 0xff) 464 break; 465 if (reg == 0x0c && state->config->op0_off) 466 val &= ~0x10; 467 stv0299_writeregI(state, reg, val); 468 } 469 470 return 0; 471} 472 473static int stv0299_read_status(struct dvb_frontend* fe, fe_status_t* status) 474{ 475 struct stv0299_state* state = fe->demodulator_priv; 476 477 u8 signal = 0xff - stv0299_readreg (state, 0x18); 478 u8 sync = stv0299_readreg (state, 0x1b); 479 480 dprintk ("%s : FE_READ_STATUS : VSTATUS: 0x%02x\n", __func__, sync); 481 *status = 0; 482 483 if (signal > 10) 484 *status |= FE_HAS_SIGNAL; 485 486 if (sync & 0x80) 487 *status |= FE_HAS_CARRIER; 488 489 if (sync & 0x10) 490 *status |= FE_HAS_VITERBI; 491 492 if (sync & 0x08) 493 *status |= FE_HAS_SYNC; 494 495 if ((sync & 0x98) == 0x98) 496 *status |= FE_HAS_LOCK; 497 498 return 0; 499} 500 501static int stv0299_read_ber(struct dvb_frontend* fe, u32* ber) 502{ 503 struct stv0299_state* state = fe->demodulator_priv; 504 505 if (state->errmode != STATUS_BER) 506 return -ENOSYS; 507 508 *ber = stv0299_readreg(state, 0x1e) | (stv0299_readreg(state, 0x1d) << 8); 509 510 return 0; 511} 512 513static int stv0299_read_signal_strength(struct dvb_frontend* fe, u16* strength) 514{ 515 struct stv0299_state* state = fe->demodulator_priv; 516 517 s32 signal = 0xffff - ((stv0299_readreg (state, 0x18) << 8) 518 | stv0299_readreg (state, 0x19)); 519 520 dprintk ("%s : FE_READ_SIGNAL_STRENGTH : AGC2I: 0x%02x%02x, signal=0x%04x\n", __func__, 521 stv0299_readreg (state, 0x18), 522 stv0299_readreg (state, 0x19), (int) signal); 523 524 signal = signal * 5 / 4; 525 *strength = (signal > 0xffff) ? 0xffff : (signal < 0) ? 0 : signal; 526 527 return 0; 528} 529 530static int stv0299_read_snr(struct dvb_frontend* fe, u16* snr) 531{ 532 struct stv0299_state* state = fe->demodulator_priv; 533 534 s32 xsnr = 0xffff - ((stv0299_readreg (state, 0x24) << 8) 535 | stv0299_readreg (state, 0x25)); 536 xsnr = 3 * (xsnr - 0xa100); 537 *snr = (xsnr > 0xffff) ? 0xffff : (xsnr < 0) ? 0 : xsnr; 538 539 return 0; 540} 541 542static int stv0299_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks) 543{ 544 struct stv0299_state* state = fe->demodulator_priv; 545 546 if (state->errmode != STATUS_UCBLOCKS) 547 return -ENOSYS; 548 549 state->ucblocks += stv0299_readreg(state, 0x1e); 550 state->ucblocks += (stv0299_readreg(state, 0x1d) << 8); 551 *ucblocks = state->ucblocks; 552 553 return 0; 554} 555 556static int stv0299_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters * p) 557{ 558 struct stv0299_state* state = fe->demodulator_priv; 559 int invval = 0; 560 561 dprintk ("%s : FE_SET_FRONTEND\n", __func__); 562 if (state->config->set_ts_params) 563 state->config->set_ts_params(fe, 0); 564 565 // set the inversion 566 if (p->inversion == INVERSION_OFF) invval = 0; 567 else if (p->inversion == INVERSION_ON) invval = 1; 568 else { 569 printk("stv0299 does not support auto-inversion\n"); 570 return -EINVAL; 571 } 572 if (state->config->invert) invval = (~invval) & 1; 573 stv0299_writeregI(state, 0x0c, (stv0299_readreg(state, 0x0c) & 0xfe) | invval); 574 575 if (fe->ops.tuner_ops.set_params) { 576 fe->ops.tuner_ops.set_params(fe, p); 577 if (fe->ops.i2c_gate_ctrl) fe->ops.i2c_gate_ctrl(fe, 0); 578 } 579 580 stv0299_set_FEC (state, p->u.qpsk.fec_inner); 581 stv0299_set_symbolrate (fe, p->u.qpsk.symbol_rate); 582 stv0299_writeregI(state, 0x22, 0x00); 583 stv0299_writeregI(state, 0x23, 0x00); 584 585 state->tuner_frequency = p->frequency; 586 state->fec_inner = p->u.qpsk.fec_inner; 587 state->symbol_rate = p->u.qpsk.symbol_rate; 588 589 return 0; 590} 591 592static int stv0299_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters * p) 593{ 594 struct stv0299_state* state = fe->demodulator_priv; 595 s32 derot_freq; 596 int invval; 597 598 derot_freq = (s32)(s16) ((stv0299_readreg (state, 0x22) << 8) 599 | stv0299_readreg (state, 0x23)); 600 601 derot_freq *= (state->config->mclk >> 16); 602 derot_freq += 500; 603 derot_freq /= 1000; 604 605 p->frequency += derot_freq; 606 607 invval = stv0299_readreg (state, 0x0c) & 1; 608 if (state->config->invert) invval = (~invval) & 1; 609 p->inversion = invval ? INVERSION_ON : INVERSION_OFF; 610 611 p->u.qpsk.fec_inner = stv0299_get_fec (state); 612 p->u.qpsk.symbol_rate = stv0299_get_symbolrate (state); 613 614 return 0; 615} 616 617static int stv0299_sleep(struct dvb_frontend* fe) 618{ 619 struct stv0299_state* state = fe->demodulator_priv; 620 621 stv0299_writeregI(state, 0x02, 0x80); 622 state->initialised = 0; 623 624 return 0; 625} 626 627static int stv0299_i2c_gate_ctrl(struct dvb_frontend* fe, int enable) 628{ 629 struct stv0299_state* state = fe->demodulator_priv; 630 631 if (enable) { 632 stv0299_writeregI(state, 0x05, 0xb5); 633 } else { 634 stv0299_writeregI(state, 0x05, 0x35); 635 } 636 udelay(1); 637 return 0; 638} 639 640static int stv0299_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings* fesettings) 641{ 642 struct stv0299_state* state = fe->demodulator_priv; 643 644 fesettings->min_delay_ms = state->config->min_delay_ms; 645 if (fesettings->parameters.u.qpsk.symbol_rate < 10000000) { 646 fesettings->step_size = fesettings->parameters.u.qpsk.symbol_rate / 32000; 647 fesettings->max_drift = 5000; 648 } else { 649 fesettings->step_size = fesettings->parameters.u.qpsk.symbol_rate / 16000; 650 fesettings->max_drift = fesettings->parameters.u.qpsk.symbol_rate / 2000; 651 } 652 return 0; 653} 654 655static void stv0299_release(struct dvb_frontend* fe) 656{ 657 struct stv0299_state* state = fe->demodulator_priv; 658 kfree(state); 659} 660 661static struct dvb_frontend_ops stv0299_ops; 662 663struct dvb_frontend* stv0299_attach(const struct stv0299_config* config, 664 struct i2c_adapter* i2c) 665{ 666 struct stv0299_state* state = NULL; 667 int id; 668 669 /* allocate memory for the internal state */ 670 state = kzalloc(sizeof(struct stv0299_state), GFP_KERNEL); 671 if (state == NULL) goto error; 672 673 /* setup the state */ 674 state->config = config; 675 state->i2c = i2c; 676 state->initialised = 0; 677 state->tuner_frequency = 0; 678 state->symbol_rate = 0; 679 state->fec_inner = 0; 680 state->errmode = STATUS_BER; 681 682 /* check if the demod is there */ 683 stv0299_writeregI(state, 0x02, 0x34); /* standby off */ 684 msleep(200); 685 id = stv0299_readreg(state, 0x00); 686 687 /* register 0x00 contains 0xa1 for STV0299 and STV0299B */ 688 /* register 0x00 might contain 0x80 when returning from standby */ 689 if (id != 0xa1 && id != 0x80) goto error; 690 691 /* create dvb_frontend */ 692 memcpy(&state->frontend.ops, &stv0299_ops, sizeof(struct dvb_frontend_ops)); 693 state->frontend.demodulator_priv = state; 694 return &state->frontend; 695 696error: 697 kfree(state); 698 return NULL; 699} 700 701static struct dvb_frontend_ops stv0299_ops = { 702 703 .info = { 704 .name = "ST STV0299 DVB-S", 705 .type = FE_QPSK, 706 .frequency_min = 950000, 707 .frequency_max = 2150000, 708 .frequency_stepsize = 125, /* kHz for QPSK frontends */ 709 .frequency_tolerance = 0, 710 .symbol_rate_min = 1000000, 711 .symbol_rate_max = 45000000, 712 .symbol_rate_tolerance = 500, /* ppm */ 713 .caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 | 714 FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | 715 FE_CAN_QPSK | 716 FE_CAN_FEC_AUTO 717 }, 718 719 .release = stv0299_release, 720 721 .init = stv0299_init, 722 .sleep = stv0299_sleep, 723 .write = stv0299_write, 724 .i2c_gate_ctrl = stv0299_i2c_gate_ctrl, 725 726 .set_frontend = stv0299_set_frontend, 727 .get_frontend = stv0299_get_frontend, 728 .get_tune_settings = stv0299_get_tune_settings, 729 730 .read_status = stv0299_read_status, 731 .read_ber = stv0299_read_ber, 732 .read_signal_strength = stv0299_read_signal_strength, 733 .read_snr = stv0299_read_snr, 734 .read_ucblocks = stv0299_read_ucblocks, 735 736 .diseqc_send_master_cmd = stv0299_send_diseqc_msg, 737 .diseqc_send_burst = stv0299_send_diseqc_burst, 738 .set_tone = stv0299_set_tone, 739 .set_voltage = stv0299_set_voltage, 740 .dishnetwork_send_legacy_command = stv0299_send_legacy_dish_cmd, 741}; 742 743module_param(debug_legacy_dish_switch, int, 0444); 744MODULE_PARM_DESC(debug_legacy_dish_switch, "Enable timing analysis for Dish Network legacy switches"); 745 746module_param(debug, int, 0644); 747MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off)."); 748 749MODULE_DESCRIPTION("ST STV0299 DVB Demodulator driver"); 750MODULE_AUTHOR("Ralph Metzler, Holger Waechtler, Peter Schildmann, Felix Domke, " 751 "Andreas Oberritter, Andrew de Quincey, Kenneth Aafly"); 752MODULE_LICENSE("GPL"); 753 754EXPORT_SYMBOL(stv0299_attach); 755