stv0900_core.c revision ee1ebcfea6ee16491f88e8023554dd214e1ba85c
1/* 2 * stv0900_core.c 3 * 4 * Driver for ST STV0900 satellite demodulator IC. 5 * 6 * Copyright (C) ST Microelectronics. 7 * Copyright (C) 2009 NetUP Inc. 8 * Copyright (C) 2009 Igor M. Liplianin <liplianin@netup.ru> 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * 19 * GNU General Public License for more details. 20 * 21 * You should have received a copy of the GNU General Public License 22 * along with this program; if not, write to the Free Software 23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 24 */ 25 26#include <linux/kernel.h> 27#include <linux/module.h> 28#include <linux/string.h> 29#include <linux/slab.h> 30#include <linux/i2c.h> 31 32#include "stv0900.h" 33#include "stv0900_reg.h" 34#include "stv0900_priv.h" 35#include "stv0900_init.h" 36 37static int stvdebug = 1; 38module_param_named(debug, stvdebug, int, 0644); 39 40/* internal params node */ 41struct stv0900_inode { 42 /* pointer for internal params, one for each pair of demods */ 43 struct stv0900_internal *internal; 44 struct stv0900_inode *next_inode; 45}; 46 47/* first internal params */ 48static struct stv0900_inode *stv0900_first_inode; 49 50/* find chip by i2c adapter and i2c address */ 51static struct stv0900_inode *find_inode(struct i2c_adapter *i2c_adap, 52 u8 i2c_addr) 53{ 54 struct stv0900_inode *temp_chip = stv0900_first_inode; 55 56 if (temp_chip != NULL) { 57 /* 58 Search of the last stv0900 chip or 59 find it by i2c adapter and i2c address */ 60 while ((temp_chip != NULL) && 61 ((temp_chip->internal->i2c_adap != i2c_adap) || 62 (temp_chip->internal->i2c_addr != i2c_addr))) 63 64 temp_chip = temp_chip->next_inode; 65 66 } 67 68 return temp_chip; 69} 70 71/* deallocating chip */ 72static void remove_inode(struct stv0900_internal *internal) 73{ 74 struct stv0900_inode *prev_node = stv0900_first_inode; 75 struct stv0900_inode *del_node = find_inode(internal->i2c_adap, 76 internal->i2c_addr); 77 78 if (del_node != NULL) { 79 if (del_node == stv0900_first_inode) { 80 stv0900_first_inode = del_node->next_inode; 81 } else { 82 while (prev_node->next_inode != del_node) 83 prev_node = prev_node->next_inode; 84 85 if (del_node->next_inode == NULL) 86 prev_node->next_inode = NULL; 87 else 88 prev_node->next_inode = 89 prev_node->next_inode->next_inode; 90 } 91 92 kfree(del_node); 93 } 94} 95 96/* allocating new chip */ 97static struct stv0900_inode *append_internal(struct stv0900_internal *internal) 98{ 99 struct stv0900_inode *new_node = stv0900_first_inode; 100 101 if (new_node == NULL) { 102 new_node = kmalloc(sizeof(struct stv0900_inode), GFP_KERNEL); 103 stv0900_first_inode = new_node; 104 } else { 105 while (new_node->next_inode != NULL) 106 new_node = new_node->next_inode; 107 108 new_node->next_inode = kmalloc(sizeof(struct stv0900_inode), GFP_KERNEL); 109 if (new_node->next_inode != NULL) 110 new_node = new_node->next_inode; 111 else 112 new_node = NULL; 113 } 114 115 if (new_node != NULL) { 116 new_node->internal = internal; 117 new_node->next_inode = NULL; 118 } 119 120 return new_node; 121} 122 123s32 ge2comp(s32 a, s32 width) 124{ 125 if (width == 32) 126 return a; 127 else 128 return (a >= (1 << (width - 1))) ? (a - (1 << width)) : a; 129} 130 131void stv0900_write_reg(struct stv0900_internal *i_params, u16 reg_addr, 132 u8 reg_data) 133{ 134 u8 data[3]; 135 int ret; 136 struct i2c_msg i2cmsg = { 137 .addr = i_params->i2c_addr, 138 .flags = 0, 139 .len = 3, 140 .buf = data, 141 }; 142 143 data[0] = MSB(reg_addr); 144 data[1] = LSB(reg_addr); 145 data[2] = reg_data; 146 147 ret = i2c_transfer(i_params->i2c_adap, &i2cmsg, 1); 148 if (ret != 1) 149 dprintk(KERN_ERR "%s: i2c error %d\n", __func__, ret); 150} 151 152u8 stv0900_read_reg(struct stv0900_internal *i_params, u16 reg) 153{ 154 int ret; 155 u8 b0[] = { MSB(reg), LSB(reg) }; 156 u8 buf = 0; 157 struct i2c_msg msg[] = { 158 { 159 .addr = i_params->i2c_addr, 160 .flags = 0, 161 .buf = b0, 162 .len = 2, 163 }, { 164 .addr = i_params->i2c_addr, 165 .flags = I2C_M_RD, 166 .buf = &buf, 167 .len = 1, 168 }, 169 }; 170 171 ret = i2c_transfer(i_params->i2c_adap, msg, 2); 172 if (ret != 2) 173 dprintk(KERN_ERR "%s: i2c error %d, reg[0x%02x]\n", 174 __func__, ret, reg); 175 176 return buf; 177} 178 179void extract_mask_pos(u32 label, u8 *mask, u8 *pos) 180{ 181 u8 position = 0, i = 0; 182 183 (*mask) = label & 0xff; 184 185 while ((position == 0) && (i < 8)) { 186 position = ((*mask) >> i) & 0x01; 187 i++; 188 } 189 190 (*pos) = (i - 1); 191} 192 193void stv0900_write_bits(struct stv0900_internal *i_params, u32 label, u8 val) 194{ 195 u8 reg, mask, pos; 196 197 reg = stv0900_read_reg(i_params, (label >> 16) & 0xffff); 198 extract_mask_pos(label, &mask, &pos); 199 200 val = mask & (val << pos); 201 202 reg = (reg & (~mask)) | val; 203 stv0900_write_reg(i_params, (label >> 16) & 0xffff, reg); 204 205} 206 207u8 stv0900_get_bits(struct stv0900_internal *i_params, u32 label) 208{ 209 u8 val = 0xff; 210 u8 mask, pos; 211 212 extract_mask_pos(label, &mask, &pos); 213 214 val = stv0900_read_reg(i_params, label >> 16); 215 val = (val & mask) >> pos; 216 217 return val; 218} 219 220enum fe_stv0900_error stv0900_initialize(struct stv0900_internal *i_params) 221{ 222 s32 i; 223 enum fe_stv0900_error error; 224 225 if (i_params != NULL) { 226 i_params->chip_id = stv0900_read_reg(i_params, R0900_MID); 227 if (i_params->errs == STV0900_NO_ERROR) { 228 /*Startup sequence*/ 229 stv0900_write_reg(i_params, R0900_P1_DMDISTATE, 0x5c); 230 stv0900_write_reg(i_params, R0900_P2_DMDISTATE, 0x5c); 231 stv0900_write_reg(i_params, R0900_P1_TNRCFG, 0x6c); 232 stv0900_write_reg(i_params, R0900_P2_TNRCFG, 0x6f); 233 stv0900_write_reg(i_params, R0900_P1_I2CRPT, 0x24); 234 stv0900_write_reg(i_params, R0900_P2_I2CRPT, 0x24); 235 stv0900_write_reg(i_params, R0900_NCOARSE, 0x13); 236 msleep(3); 237 stv0900_write_reg(i_params, R0900_I2CCFG, 0x08); 238 239 switch (i_params->clkmode) { 240 case 0: 241 case 2: 242 stv0900_write_reg(i_params, R0900_SYNTCTRL, 0x20 243 | i_params->clkmode); 244 break; 245 default: 246 /* preserve SELOSCI bit */ 247 i = 0x02 & stv0900_read_reg(i_params, R0900_SYNTCTRL); 248 stv0900_write_reg(i_params, R0900_SYNTCTRL, 0x20 | i); 249 break; 250 } 251 252 msleep(3); 253 for (i = 0; i < 182; i++) 254 stv0900_write_reg(i_params, STV0900_InitVal[i][0], STV0900_InitVal[i][1]); 255 256 if (stv0900_read_reg(i_params, R0900_MID) >= 0x20) { 257 stv0900_write_reg(i_params, R0900_TSGENERAL, 0x0c); 258 for (i = 0; i < 32; i++) 259 stv0900_write_reg(i_params, STV0900_Cut20_AddOnVal[i][0], STV0900_Cut20_AddOnVal[i][1]); 260 } 261 262 stv0900_write_reg(i_params, R0900_P1_FSPYCFG, 0x6c); 263 stv0900_write_reg(i_params, R0900_P2_FSPYCFG, 0x6c); 264 stv0900_write_reg(i_params, R0900_TSTRES0, 0x80); 265 stv0900_write_reg(i_params, R0900_TSTRES0, 0x00); 266 } 267 error = i_params->errs; 268 } else 269 error = STV0900_INVALID_HANDLE; 270 271 return error; 272 273} 274 275u32 stv0900_get_mclk_freq(struct stv0900_internal *i_params, u32 ext_clk) 276{ 277 u32 mclk = 90000000, div = 0, ad_div = 0; 278 279 div = stv0900_get_bits(i_params, F0900_M_DIV); 280 ad_div = ((stv0900_get_bits(i_params, F0900_SELX1RATIO) == 1) ? 4 : 6); 281 282 mclk = (div + 1) * ext_clk / ad_div; 283 284 dprintk(KERN_INFO "%s: Calculated Mclk = %d\n", __func__, mclk); 285 286 return mclk; 287} 288 289enum fe_stv0900_error stv0900_set_mclk(struct stv0900_internal *i_params, u32 mclk) 290{ 291 enum fe_stv0900_error error = STV0900_NO_ERROR; 292 u32 m_div, clk_sel; 293 294 dprintk(KERN_INFO "%s: Mclk set to %d, Quartz = %d\n", __func__, mclk, 295 i_params->quartz); 296 297 if (i_params == NULL) 298 error = STV0900_INVALID_HANDLE; 299 else { 300 if (i_params->errs) 301 error = STV0900_I2C_ERROR; 302 else { 303 clk_sel = ((stv0900_get_bits(i_params, F0900_SELX1RATIO) == 1) ? 4 : 6); 304 m_div = ((clk_sel * mclk) / i_params->quartz) - 1; 305 stv0900_write_bits(i_params, F0900_M_DIV, m_div); 306 i_params->mclk = stv0900_get_mclk_freq(i_params, 307 i_params->quartz); 308 309 /*Set the DiseqC frequency to 22KHz */ 310 /* 311 Formula: 312 DiseqC_TX_Freq= MasterClock/(32*F22TX_Reg) 313 DiseqC_RX_Freq= MasterClock/(32*F22RX_Reg) 314 */ 315 m_div = i_params->mclk / 704000; 316 stv0900_write_reg(i_params, R0900_P1_F22TX, m_div); 317 stv0900_write_reg(i_params, R0900_P1_F22RX, m_div); 318 319 stv0900_write_reg(i_params, R0900_P2_F22TX, m_div); 320 stv0900_write_reg(i_params, R0900_P2_F22RX, m_div); 321 322 if ((i_params->errs)) 323 error = STV0900_I2C_ERROR; 324 } 325 } 326 327 return error; 328} 329 330u32 stv0900_get_err_count(struct stv0900_internal *i_params, int cntr, 331 enum fe_stv0900_demod_num demod) 332{ 333 u32 lsb, msb, hsb, err_val; 334 s32 err1field_hsb, err1field_msb, err1field_lsb; 335 s32 err2field_hsb, err2field_msb, err2field_lsb; 336 337 dmd_reg(err1field_hsb, F0900_P1_ERR_CNT12, F0900_P2_ERR_CNT12); 338 dmd_reg(err1field_msb, F0900_P1_ERR_CNT11, F0900_P2_ERR_CNT11); 339 dmd_reg(err1field_lsb, F0900_P1_ERR_CNT10, F0900_P2_ERR_CNT10); 340 341 dmd_reg(err2field_hsb, F0900_P1_ERR_CNT22, F0900_P2_ERR_CNT22); 342 dmd_reg(err2field_msb, F0900_P1_ERR_CNT21, F0900_P2_ERR_CNT21); 343 dmd_reg(err2field_lsb, F0900_P1_ERR_CNT20, F0900_P2_ERR_CNT20); 344 345 switch (cntr) { 346 case 0: 347 default: 348 hsb = stv0900_get_bits(i_params, err1field_hsb); 349 msb = stv0900_get_bits(i_params, err1field_msb); 350 lsb = stv0900_get_bits(i_params, err1field_lsb); 351 break; 352 case 1: 353 hsb = stv0900_get_bits(i_params, err2field_hsb); 354 msb = stv0900_get_bits(i_params, err2field_msb); 355 lsb = stv0900_get_bits(i_params, err2field_lsb); 356 break; 357 } 358 359 err_val = (hsb << 16) + (msb << 8) + (lsb); 360 361 return err_val; 362} 363 364static int stv0900_i2c_gate_ctrl(struct dvb_frontend *fe, int enable) 365{ 366 struct stv0900_state *state = fe->demodulator_priv; 367 struct stv0900_internal *i_params = state->internal; 368 enum fe_stv0900_demod_num demod = state->demod; 369 370 u32 fi2c; 371 372 dmd_reg(fi2c, F0900_P1_I2CT_ON, F0900_P2_I2CT_ON); 373 if (enable) 374 stv0900_write_bits(i_params, fi2c, 1); 375 376 return 0; 377} 378 379static void stv0900_set_ts_parallel_serial(struct stv0900_internal *i_params, 380 enum fe_stv0900_clock_type path1_ts, 381 enum fe_stv0900_clock_type path2_ts) 382{ 383 384 dprintk(KERN_INFO "%s\n", __func__); 385 386 if (i_params->chip_id >= 0x20) { 387 switch (path1_ts) { 388 case STV0900_PARALLEL_PUNCT_CLOCK: 389 case STV0900_DVBCI_CLOCK: 390 switch (path2_ts) { 391 case STV0900_SERIAL_PUNCT_CLOCK: 392 case STV0900_SERIAL_CONT_CLOCK: 393 default: 394 stv0900_write_reg(i_params, R0900_TSGENERAL, 395 0x00); 396 break; 397 case STV0900_PARALLEL_PUNCT_CLOCK: 398 case STV0900_DVBCI_CLOCK: 399 stv0900_write_reg(i_params, R0900_TSGENERAL, 400 0x06); 401 stv0900_write_bits(i_params, 402 F0900_P1_TSFIFO_MANSPEED, 3); 403 stv0900_write_bits(i_params, 404 F0900_P2_TSFIFO_MANSPEED, 0); 405 stv0900_write_reg(i_params, 406 R0900_P1_TSSPEED, 0x14); 407 stv0900_write_reg(i_params, 408 R0900_P2_TSSPEED, 0x28); 409 break; 410 } 411 break; 412 case STV0900_SERIAL_PUNCT_CLOCK: 413 case STV0900_SERIAL_CONT_CLOCK: 414 default: 415 switch (path2_ts) { 416 case STV0900_SERIAL_PUNCT_CLOCK: 417 case STV0900_SERIAL_CONT_CLOCK: 418 default: 419 stv0900_write_reg(i_params, 420 R0900_TSGENERAL, 0x0C); 421 break; 422 case STV0900_PARALLEL_PUNCT_CLOCK: 423 case STV0900_DVBCI_CLOCK: 424 stv0900_write_reg(i_params, 425 R0900_TSGENERAL, 0x0A); 426 dprintk(KERN_INFO "%s: 0x0a\n", __func__); 427 break; 428 } 429 break; 430 } 431 } else { 432 switch (path1_ts) { 433 case STV0900_PARALLEL_PUNCT_CLOCK: 434 case STV0900_DVBCI_CLOCK: 435 switch (path2_ts) { 436 case STV0900_SERIAL_PUNCT_CLOCK: 437 case STV0900_SERIAL_CONT_CLOCK: 438 default: 439 stv0900_write_reg(i_params, R0900_TSGENERAL1X, 440 0x10); 441 break; 442 case STV0900_PARALLEL_PUNCT_CLOCK: 443 case STV0900_DVBCI_CLOCK: 444 stv0900_write_reg(i_params, R0900_TSGENERAL1X, 445 0x16); 446 stv0900_write_bits(i_params, 447 F0900_P1_TSFIFO_MANSPEED, 3); 448 stv0900_write_bits(i_params, 449 F0900_P2_TSFIFO_MANSPEED, 0); 450 stv0900_write_reg(i_params, R0900_P1_TSSPEED, 451 0x14); 452 stv0900_write_reg(i_params, R0900_P2_TSSPEED, 453 0x28); 454 break; 455 } 456 457 break; 458 case STV0900_SERIAL_PUNCT_CLOCK: 459 case STV0900_SERIAL_CONT_CLOCK: 460 default: 461 switch (path2_ts) { 462 case STV0900_SERIAL_PUNCT_CLOCK: 463 case STV0900_SERIAL_CONT_CLOCK: 464 default: 465 stv0900_write_reg(i_params, R0900_TSGENERAL1X, 466 0x14); 467 break; 468 case STV0900_PARALLEL_PUNCT_CLOCK: 469 case STV0900_DVBCI_CLOCK: 470 stv0900_write_reg(i_params, R0900_TSGENERAL1X, 471 0x12); 472 dprintk(KERN_INFO "%s: 0x12\n", __func__); 473 break; 474 } 475 476 break; 477 } 478 } 479 480 switch (path1_ts) { 481 case STV0900_PARALLEL_PUNCT_CLOCK: 482 stv0900_write_bits(i_params, F0900_P1_TSFIFO_SERIAL, 0x00); 483 stv0900_write_bits(i_params, F0900_P1_TSFIFO_DVBCI, 0x00); 484 break; 485 case STV0900_DVBCI_CLOCK: 486 stv0900_write_bits(i_params, F0900_P1_TSFIFO_SERIAL, 0x00); 487 stv0900_write_bits(i_params, F0900_P1_TSFIFO_DVBCI, 0x01); 488 break; 489 case STV0900_SERIAL_PUNCT_CLOCK: 490 stv0900_write_bits(i_params, F0900_P1_TSFIFO_SERIAL, 0x01); 491 stv0900_write_bits(i_params, F0900_P1_TSFIFO_DVBCI, 0x00); 492 break; 493 case STV0900_SERIAL_CONT_CLOCK: 494 stv0900_write_bits(i_params, F0900_P1_TSFIFO_SERIAL, 0x01); 495 stv0900_write_bits(i_params, F0900_P1_TSFIFO_DVBCI, 0x01); 496 break; 497 default: 498 break; 499 } 500 501 switch (path2_ts) { 502 case STV0900_PARALLEL_PUNCT_CLOCK: 503 stv0900_write_bits(i_params, F0900_P2_TSFIFO_SERIAL, 0x00); 504 stv0900_write_bits(i_params, F0900_P2_TSFIFO_DVBCI, 0x00); 505 break; 506 case STV0900_DVBCI_CLOCK: 507 stv0900_write_bits(i_params, F0900_P2_TSFIFO_SERIAL, 0x00); 508 stv0900_write_bits(i_params, F0900_P2_TSFIFO_DVBCI, 0x01); 509 break; 510 case STV0900_SERIAL_PUNCT_CLOCK: 511 stv0900_write_bits(i_params, F0900_P2_TSFIFO_SERIAL, 0x01); 512 stv0900_write_bits(i_params, F0900_P2_TSFIFO_DVBCI, 0x00); 513 break; 514 case STV0900_SERIAL_CONT_CLOCK: 515 stv0900_write_bits(i_params, F0900_P2_TSFIFO_SERIAL, 0x01); 516 stv0900_write_bits(i_params, F0900_P2_TSFIFO_DVBCI, 0x01); 517 break; 518 default: 519 break; 520 } 521 522 stv0900_write_bits(i_params, F0900_P2_RST_HWARE, 1); 523 stv0900_write_bits(i_params, F0900_P2_RST_HWARE, 0); 524 stv0900_write_bits(i_params, F0900_P1_RST_HWARE, 1); 525 stv0900_write_bits(i_params, F0900_P1_RST_HWARE, 0); 526} 527 528void stv0900_set_tuner(struct dvb_frontend *fe, u32 frequency, 529 u32 bandwidth) 530{ 531 struct dvb_frontend_ops *frontend_ops = NULL; 532 struct dvb_tuner_ops *tuner_ops = NULL; 533 534 if (&fe->ops) 535 frontend_ops = &fe->ops; 536 537 if (&frontend_ops->tuner_ops) 538 tuner_ops = &frontend_ops->tuner_ops; 539 540 if (tuner_ops->set_frequency) { 541 if ((tuner_ops->set_frequency(fe, frequency)) < 0) 542 dprintk("%s: Invalid parameter\n", __func__); 543 else 544 dprintk("%s: Frequency=%d\n", __func__, frequency); 545 546 } 547 548 if (tuner_ops->set_bandwidth) { 549 if ((tuner_ops->set_bandwidth(fe, bandwidth)) < 0) 550 dprintk("%s: Invalid parameter\n", __func__); 551 else 552 dprintk("%s: Bandwidth=%d\n", __func__, bandwidth); 553 554 } 555} 556 557void stv0900_set_bandwidth(struct dvb_frontend *fe, u32 bandwidth) 558{ 559 struct dvb_frontend_ops *frontend_ops = NULL; 560 struct dvb_tuner_ops *tuner_ops = NULL; 561 562 if (&fe->ops) 563 frontend_ops = &fe->ops; 564 565 if (&frontend_ops->tuner_ops) 566 tuner_ops = &frontend_ops->tuner_ops; 567 568 if (tuner_ops->set_bandwidth) { 569 if ((tuner_ops->set_bandwidth(fe, bandwidth)) < 0) 570 dprintk("%s: Invalid parameter\n", __func__); 571 else 572 dprintk("%s: Bandwidth=%d\n", __func__, bandwidth); 573 574 } 575} 576 577static s32 stv0900_get_rf_level(struct stv0900_internal *i_params, 578 const struct stv0900_table *lookup, 579 enum fe_stv0900_demod_num demod) 580{ 581 s32 agc_gain = 0, 582 imin, 583 imax, 584 i, 585 rf_lvl = 0; 586 587 dprintk(KERN_INFO "%s\n", __func__); 588 589 if ((lookup != NULL) && lookup->size) { 590 switch (demod) { 591 case STV0900_DEMOD_1: 592 default: 593 agc_gain = MAKEWORD(stv0900_get_bits(i_params, F0900_P1_AGCIQ_VALUE1), 594 stv0900_get_bits(i_params, F0900_P1_AGCIQ_VALUE0)); 595 break; 596 case STV0900_DEMOD_2: 597 agc_gain = MAKEWORD(stv0900_get_bits(i_params, F0900_P2_AGCIQ_VALUE1), 598 stv0900_get_bits(i_params, F0900_P2_AGCIQ_VALUE0)); 599 break; 600 } 601 602 imin = 0; 603 imax = lookup->size - 1; 604 if (INRANGE(lookup->table[imin].regval, agc_gain, lookup->table[imax].regval)) { 605 while ((imax - imin) > 1) { 606 i = (imax + imin) >> 1; 607 608 if (INRANGE(lookup->table[imin].regval, agc_gain, lookup->table[i].regval)) 609 imax = i; 610 else 611 imin = i; 612 } 613 614 rf_lvl = (((s32)agc_gain - lookup->table[imin].regval) 615 * (lookup->table[imax].realval - lookup->table[imin].realval) 616 / (lookup->table[imax].regval - lookup->table[imin].regval)) 617 + lookup->table[imin].realval; 618 } else if (agc_gain > lookup->table[0].regval) 619 rf_lvl = 5; 620 else if (agc_gain < lookup->table[lookup->size-1].regval) 621 rf_lvl = -100; 622 623 } 624 625 dprintk(KERN_INFO "%s: RFLevel = %d\n", __func__, rf_lvl); 626 627 return rf_lvl; 628} 629 630static int stv0900_read_signal_strength(struct dvb_frontend *fe, u16 *strength) 631{ 632 struct stv0900_state *state = fe->demodulator_priv; 633 struct stv0900_internal *internal = state->internal; 634 s32 rflevel = stv0900_get_rf_level(internal, &stv0900_rf, 635 state->demod); 636 637 *strength = (rflevel + 100) * (16383 / 105); 638 639 return 0; 640} 641 642 643static s32 stv0900_carr_get_quality(struct dvb_frontend *fe, 644 const struct stv0900_table *lookup) 645{ 646 struct stv0900_state *state = fe->demodulator_priv; 647 struct stv0900_internal *i_params = state->internal; 648 enum fe_stv0900_demod_num demod = state->demod; 649 650 s32 c_n = -100, 651 regval, imin, imax, 652 i, 653 lock_flag_field, 654 noise_field1, 655 noise_field0; 656 657 dprintk(KERN_INFO "%s\n", __func__); 658 659 dmd_reg(lock_flag_field, F0900_P1_LOCK_DEFINITIF, 660 F0900_P2_LOCK_DEFINITIF); 661 if (stv0900_get_standard(fe, demod) == STV0900_DVBS2_STANDARD) { 662 dmd_reg(noise_field1, F0900_P1_NOSPLHT_NORMED1, 663 F0900_P2_NOSPLHT_NORMED1); 664 dmd_reg(noise_field0, F0900_P1_NOSPLHT_NORMED0, 665 F0900_P2_NOSPLHT_NORMED0); 666 } else { 667 dmd_reg(noise_field1, F0900_P1_NOSDATAT_NORMED1, 668 F0900_P2_NOSDATAT_NORMED1); 669 dmd_reg(noise_field0, F0900_P1_NOSDATAT_NORMED0, 670 F0900_P2_NOSDATAT_NORMED0); 671 } 672 673 if (stv0900_get_bits(i_params, lock_flag_field)) { 674 if ((lookup != NULL) && lookup->size) { 675 regval = 0; 676 msleep(5); 677 for (i = 0; i < 16; i++) { 678 regval += MAKEWORD(stv0900_get_bits(i_params, 679 noise_field1), 680 stv0900_get_bits(i_params, 681 noise_field0)); 682 msleep(1); 683 } 684 685 regval /= 16; 686 imin = 0; 687 imax = lookup->size - 1; 688 if (INRANGE(lookup->table[imin].regval, 689 regval, 690 lookup->table[imax].regval)) { 691 while ((imax - imin) > 1) { 692 i = (imax + imin) >> 1; 693 if (INRANGE(lookup->table[imin].regval, 694 regval, 695 lookup->table[i].regval)) 696 imax = i; 697 else 698 imin = i; 699 } 700 701 c_n = ((regval - lookup->table[imin].regval) 702 * (lookup->table[imax].realval 703 - lookup->table[imin].realval) 704 / (lookup->table[imax].regval 705 - lookup->table[imin].regval)) 706 + lookup->table[imin].realval; 707 } else if (regval < lookup->table[imin].regval) 708 c_n = 1000; 709 } 710 } 711 712 return c_n; 713} 714 715static int stv0900_read_ucblocks(struct dvb_frontend *fe, u32 * ucblocks) 716{ 717 struct stv0900_state *state = fe->demodulator_priv; 718 struct stv0900_internal *i_params = state->internal; 719 enum fe_stv0900_demod_num demod = state->demod; 720 u8 err_val1, err_val0; 721 s32 err_field1, err_field0; 722 u32 header_err_val = 0; 723 724 *ucblocks = 0x0; 725 if (stv0900_get_standard(fe, demod) == STV0900_DVBS2_STANDARD) { 726 /* DVB-S2 delineator errors count */ 727 728 /* retreiving number for errnous headers */ 729 dmd_reg(err_field0, R0900_P1_BBFCRCKO0, 730 R0900_P2_BBFCRCKO0); 731 dmd_reg(err_field1, R0900_P1_BBFCRCKO1, 732 R0900_P2_BBFCRCKO1); 733 734 err_val1 = stv0900_read_reg(i_params, err_field1); 735 err_val0 = stv0900_read_reg(i_params, err_field0); 736 header_err_val = (err_val1<<8) | err_val0; 737 738 /* retreiving number for errnous packets */ 739 dmd_reg(err_field0, R0900_P1_UPCRCKO0, 740 R0900_P2_UPCRCKO0); 741 dmd_reg(err_field1, R0900_P1_UPCRCKO1, 742 R0900_P2_UPCRCKO1); 743 744 err_val1 = stv0900_read_reg(i_params, err_field1); 745 err_val0 = stv0900_read_reg(i_params, err_field0); 746 *ucblocks = (err_val1<<8) | err_val0; 747 *ucblocks += header_err_val; 748 } 749 750 return 0; 751} 752 753static int stv0900_read_snr(struct dvb_frontend *fe, u16 *snr) 754{ 755 *snr = stv0900_carr_get_quality(fe, 756 (const struct stv0900_table *)&stv0900_s2_cn); 757 *snr += 30; 758 *snr *= (16383 / 1030); 759 760 return 0; 761} 762 763static u32 stv0900_get_ber(struct stv0900_internal *i_params, 764 enum fe_stv0900_demod_num demod) 765{ 766 u32 ber = 10000000, i; 767 s32 dmd_state_reg; 768 s32 demod_state; 769 s32 vstatus_reg; 770 s32 prvit_field; 771 s32 pdel_status_reg; 772 s32 pdel_lock_field; 773 774 dmd_reg(dmd_state_reg, F0900_P1_HEADER_MODE, F0900_P2_HEADER_MODE); 775 dmd_reg(vstatus_reg, R0900_P1_VSTATUSVIT, R0900_P2_VSTATUSVIT); 776 dmd_reg(prvit_field, F0900_P1_PRFVIT, F0900_P2_PRFVIT); 777 dmd_reg(pdel_status_reg, R0900_P1_PDELSTATUS1, R0900_P2_PDELSTATUS1); 778 dmd_reg(pdel_lock_field, F0900_P1_PKTDELIN_LOCK, 779 F0900_P2_PKTDELIN_LOCK); 780 781 demod_state = stv0900_get_bits(i_params, dmd_state_reg); 782 783 switch (demod_state) { 784 case STV0900_SEARCH: 785 case STV0900_PLH_DETECTED: 786 default: 787 ber = 10000000; 788 break; 789 case STV0900_DVBS_FOUND: 790 ber = 0; 791 for (i = 0; i < 5; i++) { 792 msleep(5); 793 ber += stv0900_get_err_count(i_params, 0, demod); 794 } 795 796 ber /= 5; 797 if (stv0900_get_bits(i_params, prvit_field)) { 798 ber *= 9766; 799 ber = ber >> 13; 800 } 801 802 break; 803 case STV0900_DVBS2_FOUND: 804 ber = 0; 805 for (i = 0; i < 5; i++) { 806 msleep(5); 807 ber += stv0900_get_err_count(i_params, 0, demod); 808 } 809 810 ber /= 5; 811 if (stv0900_get_bits(i_params, pdel_lock_field)) { 812 ber *= 9766; 813 ber = ber >> 13; 814 } 815 816 break; 817 } 818 819 return ber; 820} 821 822static int stv0900_read_ber(struct dvb_frontend *fe, u32 *ber) 823{ 824 struct stv0900_state *state = fe->demodulator_priv; 825 struct stv0900_internal *internal = state->internal; 826 827 *ber = stv0900_get_ber(internal, state->demod); 828 829 return 0; 830} 831 832int stv0900_get_demod_lock(struct stv0900_internal *i_params, 833 enum fe_stv0900_demod_num demod, s32 time_out) 834{ 835 s32 timer = 0, 836 lock = 0, 837 header_field, 838 lock_field; 839 840 enum fe_stv0900_search_state dmd_state; 841 842 dmd_reg(header_field, F0900_P1_HEADER_MODE, F0900_P2_HEADER_MODE); 843 dmd_reg(lock_field, F0900_P1_LOCK_DEFINITIF, F0900_P2_LOCK_DEFINITIF); 844 while ((timer < time_out) && (lock == 0)) { 845 dmd_state = stv0900_get_bits(i_params, header_field); 846 dprintk("Demod State = %d\n", dmd_state); 847 switch (dmd_state) { 848 case STV0900_SEARCH: 849 case STV0900_PLH_DETECTED: 850 default: 851 lock = 0; 852 break; 853 case STV0900_DVBS2_FOUND: 854 case STV0900_DVBS_FOUND: 855 lock = stv0900_get_bits(i_params, lock_field); 856 break; 857 } 858 859 if (lock == 0) 860 msleep(10); 861 862 timer += 10; 863 } 864 865 if (lock) 866 dprintk("DEMOD LOCK OK\n"); 867 else 868 dprintk("DEMOD LOCK FAIL\n"); 869 870 return lock; 871} 872 873void stv0900_stop_all_s2_modcod(struct stv0900_internal *i_params, 874 enum fe_stv0900_demod_num demod) 875{ 876 s32 regflist, 877 i; 878 879 dprintk(KERN_INFO "%s\n", __func__); 880 881 dmd_reg(regflist, R0900_P1_MODCODLST0, R0900_P2_MODCODLST0); 882 883 for (i = 0; i < 16; i++) 884 stv0900_write_reg(i_params, regflist + i, 0xff); 885} 886 887void stv0900_activate_s2_modcode(struct stv0900_internal *i_params, 888 enum fe_stv0900_demod_num demod) 889{ 890 u32 matype, 891 mod_code, 892 fmod, 893 reg_index, 894 field_index; 895 896 dprintk(KERN_INFO "%s\n", __func__); 897 898 if (i_params->chip_id <= 0x11) { 899 msleep(5); 900 901 switch (demod) { 902 case STV0900_DEMOD_1: 903 default: 904 mod_code = stv0900_read_reg(i_params, 905 R0900_P1_PLHMODCOD); 906 matype = mod_code & 0x3; 907 mod_code = (mod_code & 0x7f) >> 2; 908 909 reg_index = R0900_P1_MODCODLSTF - mod_code / 2; 910 field_index = mod_code % 2; 911 break; 912 case STV0900_DEMOD_2: 913 mod_code = stv0900_read_reg(i_params, 914 R0900_P2_PLHMODCOD); 915 matype = mod_code & 0x3; 916 mod_code = (mod_code & 0x7f) >> 2; 917 918 reg_index = R0900_P2_MODCODLSTF - mod_code / 2; 919 field_index = mod_code % 2; 920 break; 921 } 922 923 924 switch (matype) { 925 case 0: 926 default: 927 fmod = 14; 928 break; 929 case 1: 930 fmod = 13; 931 break; 932 case 2: 933 fmod = 11; 934 break; 935 case 3: 936 fmod = 7; 937 break; 938 } 939 940 if ((INRANGE(STV0900_QPSK_12, mod_code, STV0900_8PSK_910)) 941 && (matype <= 1)) { 942 if (field_index == 0) 943 stv0900_write_reg(i_params, reg_index, 944 0xf0 | fmod); 945 else 946 stv0900_write_reg(i_params, reg_index, 947 (fmod << 4) | 0xf); 948 } 949 } else if (i_params->chip_id >= 0x12) { 950 switch (demod) { 951 case STV0900_DEMOD_1: 952 default: 953 for (reg_index = 0; reg_index < 7; reg_index++) 954 stv0900_write_reg(i_params, R0900_P1_MODCODLST0 + reg_index, 0xff); 955 956 stv0900_write_reg(i_params, R0900_P1_MODCODLSTE, 0xff); 957 stv0900_write_reg(i_params, R0900_P1_MODCODLSTF, 0xcf); 958 for (reg_index = 0; reg_index < 8; reg_index++) 959 stv0900_write_reg(i_params, R0900_P1_MODCODLST7 + reg_index, 0xcc); 960 961 break; 962 case STV0900_DEMOD_2: 963 for (reg_index = 0; reg_index < 7; reg_index++) 964 stv0900_write_reg(i_params, R0900_P2_MODCODLST0 + reg_index, 0xff); 965 966 stv0900_write_reg(i_params, R0900_P2_MODCODLSTE, 0xff); 967 stv0900_write_reg(i_params, R0900_P2_MODCODLSTF, 0xcf); 968 for (reg_index = 0; reg_index < 8; reg_index++) 969 stv0900_write_reg(i_params, R0900_P2_MODCODLST7 + reg_index, 0xcc); 970 971 break; 972 } 973 974 } 975} 976 977void stv0900_activate_s2_modcode_single(struct stv0900_internal *i_params, 978 enum fe_stv0900_demod_num demod) 979{ 980 u32 reg_index; 981 982 dprintk(KERN_INFO "%s\n", __func__); 983 984 switch (demod) { 985 case STV0900_DEMOD_1: 986 default: 987 stv0900_write_reg(i_params, R0900_P1_MODCODLST0, 0xff); 988 stv0900_write_reg(i_params, R0900_P1_MODCODLST1, 0xf0); 989 stv0900_write_reg(i_params, R0900_P1_MODCODLSTF, 0x0f); 990 for (reg_index = 0; reg_index < 13; reg_index++) 991 stv0900_write_reg(i_params, 992 R0900_P1_MODCODLST2 + reg_index, 0); 993 994 break; 995 case STV0900_DEMOD_2: 996 stv0900_write_reg(i_params, R0900_P2_MODCODLST0, 0xff); 997 stv0900_write_reg(i_params, R0900_P2_MODCODLST1, 0xf0); 998 stv0900_write_reg(i_params, R0900_P2_MODCODLSTF, 0x0f); 999 for (reg_index = 0; reg_index < 13; reg_index++) 1000 stv0900_write_reg(i_params, 1001 R0900_P2_MODCODLST2 + reg_index, 0); 1002 1003 break; 1004 } 1005} 1006 1007static enum dvbfe_algo stv0900_frontend_algo(struct dvb_frontend *fe) 1008{ 1009 return DVBFE_ALGO_CUSTOM; 1010} 1011 1012static int stb0900_set_property(struct dvb_frontend *fe, 1013 struct dtv_property *tvp) 1014{ 1015 dprintk(KERN_INFO "%s(..)\n", __func__); 1016 1017 return 0; 1018} 1019 1020static int stb0900_get_property(struct dvb_frontend *fe, 1021 struct dtv_property *tvp) 1022{ 1023 dprintk(KERN_INFO "%s(..)\n", __func__); 1024 1025 return 0; 1026} 1027 1028void stv0900_start_search(struct stv0900_internal *i_params, 1029 enum fe_stv0900_demod_num demod) 1030{ 1031 1032 switch (demod) { 1033 case STV0900_DEMOD_1: 1034 default: 1035 stv0900_write_bits(i_params, F0900_P1_I2C_DEMOD_MODE, 0x1f); 1036 1037 if (i_params->chip_id == 0x10) 1038 stv0900_write_reg(i_params, R0900_P1_CORRELEXP, 0xaa); 1039 1040 if (i_params->chip_id < 0x20) 1041 stv0900_write_reg(i_params, R0900_P1_CARHDR, 0x55); 1042 1043 if (i_params->dmd1_symbol_rate <= 5000000) { 1044 stv0900_write_reg(i_params, R0900_P1_CARCFG, 0x44); 1045 stv0900_write_reg(i_params, R0900_P1_CFRUP1, 0x0f); 1046 stv0900_write_reg(i_params, R0900_P1_CFRUP0, 0xff); 1047 stv0900_write_reg(i_params, R0900_P1_CFRLOW1, 0xf0); 1048 stv0900_write_reg(i_params, R0900_P1_CFRLOW0, 0x00); 1049 stv0900_write_reg(i_params, R0900_P1_RTCS2, 0x68); 1050 } else { 1051 stv0900_write_reg(i_params, R0900_P1_CARCFG, 0xc4); 1052 stv0900_write_reg(i_params, R0900_P1_RTCS2, 0x44); 1053 } 1054 1055 stv0900_write_reg(i_params, R0900_P1_CFRINIT1, 0); 1056 stv0900_write_reg(i_params, R0900_P1_CFRINIT0, 0); 1057 1058 if (i_params->chip_id >= 0x20) { 1059 stv0900_write_reg(i_params, R0900_P1_EQUALCFG, 0x41); 1060 stv0900_write_reg(i_params, R0900_P1_FFECFG, 0x41); 1061 1062 if ((i_params->dmd1_srch_standard == STV0900_SEARCH_DVBS1) || (i_params->dmd1_srch_standard == STV0900_SEARCH_DSS) || (i_params->dmd1_srch_standard == STV0900_AUTO_SEARCH)) { 1063 stv0900_write_reg(i_params, R0900_P1_VITSCALE, 0x82); 1064 stv0900_write_reg(i_params, R0900_P1_VAVSRVIT, 0x0); 1065 } 1066 } 1067 1068 stv0900_write_reg(i_params, R0900_P1_SFRSTEP, 0x00); 1069 stv0900_write_reg(i_params, R0900_P1_TMGTHRISE, 0xe0); 1070 stv0900_write_reg(i_params, R0900_P1_TMGTHFALL, 0xc0); 1071 stv0900_write_bits(i_params, F0900_P1_SCAN_ENABLE, 0); 1072 stv0900_write_bits(i_params, F0900_P1_CFR_AUTOSCAN, 0); 1073 stv0900_write_bits(i_params, F0900_P1_S1S2_SEQUENTIAL, 0); 1074 stv0900_write_reg(i_params, R0900_P1_RTC, 0x88); 1075 if (i_params->chip_id >= 0x20) { 1076 if (i_params->dmd1_symbol_rate < 2000000) { 1077 stv0900_write_reg(i_params, R0900_P1_CARFREQ, 0x39); 1078 stv0900_write_reg(i_params, R0900_P1_CARHDR, 0x40); 1079 } 1080 1081 if (i_params->dmd1_symbol_rate < 10000000) { 1082 stv0900_write_reg(i_params, R0900_P1_CARFREQ, 0x4c); 1083 stv0900_write_reg(i_params, R0900_P1_CARHDR, 0x20); 1084 } else { 1085 stv0900_write_reg(i_params, R0900_P1_CARFREQ, 0x4b); 1086 stv0900_write_reg(i_params, R0900_P1_CARHDR, 0x20); 1087 } 1088 1089 } else { 1090 if (i_params->dmd1_symbol_rate < 10000000) 1091 stv0900_write_reg(i_params, R0900_P1_CARFREQ, 0xef); 1092 else 1093 stv0900_write_reg(i_params, R0900_P1_CARFREQ, 0xed); 1094 } 1095 1096 switch (i_params->dmd1_srch_algo) { 1097 case STV0900_WARM_START: 1098 stv0900_write_reg(i_params, R0900_P1_DMDISTATE, 0x1f); 1099 stv0900_write_reg(i_params, R0900_P1_DMDISTATE, 0x18); 1100 break; 1101 case STV0900_COLD_START: 1102 stv0900_write_reg(i_params, R0900_P1_DMDISTATE, 0x1f); 1103 stv0900_write_reg(i_params, R0900_P1_DMDISTATE, 0x15); 1104 break; 1105 default: 1106 break; 1107 } 1108 1109 break; 1110 case STV0900_DEMOD_2: 1111 stv0900_write_bits(i_params, F0900_P2_I2C_DEMOD_MODE, 0x1f); 1112 if (i_params->chip_id == 0x10) 1113 stv0900_write_reg(i_params, R0900_P2_CORRELEXP, 0xaa); 1114 1115 if (i_params->chip_id < 0x20) 1116 stv0900_write_reg(i_params, R0900_P2_CARHDR, 0x55); 1117 1118 if (i_params->dmd2_symbol_rate <= 5000000) { 1119 stv0900_write_reg(i_params, R0900_P2_CARCFG, 0x44); 1120 stv0900_write_reg(i_params, R0900_P2_CFRUP1, 0x0f); 1121 stv0900_write_reg(i_params, R0900_P2_CFRUP0, 0xff); 1122 stv0900_write_reg(i_params, R0900_P2_CFRLOW1, 0xf0); 1123 stv0900_write_reg(i_params, R0900_P2_CFRLOW0, 0x00); 1124 stv0900_write_reg(i_params, R0900_P2_RTCS2, 0x68); 1125 } else { 1126 stv0900_write_reg(i_params, R0900_P2_CARCFG, 0xc4); 1127 stv0900_write_reg(i_params, R0900_P2_RTCS2, 0x44); 1128 } 1129 1130 stv0900_write_reg(i_params, R0900_P2_CFRINIT1, 0); 1131 stv0900_write_reg(i_params, R0900_P2_CFRINIT0, 0); 1132 1133 if (i_params->chip_id >= 0x20) { 1134 stv0900_write_reg(i_params, R0900_P2_EQUALCFG, 0x41); 1135 stv0900_write_reg(i_params, R0900_P2_FFECFG, 0x41); 1136 if ((i_params->dmd2_srch_stndrd == STV0900_SEARCH_DVBS1) || (i_params->dmd2_srch_stndrd == STV0900_SEARCH_DSS) || (i_params->dmd2_srch_stndrd == STV0900_AUTO_SEARCH)) { 1137 stv0900_write_reg(i_params, R0900_P2_VITSCALE, 0x82); 1138 stv0900_write_reg(i_params, R0900_P2_VAVSRVIT, 0x0); 1139 } 1140 } 1141 1142 stv0900_write_reg(i_params, R0900_P2_SFRSTEP, 0x00); 1143 stv0900_write_reg(i_params, R0900_P2_TMGTHRISE, 0xe0); 1144 stv0900_write_reg(i_params, R0900_P2_TMGTHFALL, 0xc0); 1145 stv0900_write_bits(i_params, F0900_P2_SCAN_ENABLE, 0); 1146 stv0900_write_bits(i_params, F0900_P2_CFR_AUTOSCAN, 0); 1147 stv0900_write_bits(i_params, F0900_P2_S1S2_SEQUENTIAL, 0); 1148 stv0900_write_reg(i_params, R0900_P2_RTC, 0x88); 1149 if (i_params->chip_id >= 0x20) { 1150 if (i_params->dmd2_symbol_rate < 2000000) { 1151 stv0900_write_reg(i_params, R0900_P2_CARFREQ, 0x39); 1152 stv0900_write_reg(i_params, R0900_P2_CARHDR, 0x40); 1153 } 1154 1155 if (i_params->dmd2_symbol_rate < 10000000) { 1156 stv0900_write_reg(i_params, R0900_P2_CARFREQ, 0x4c); 1157 stv0900_write_reg(i_params, R0900_P2_CARHDR, 0x20); 1158 } else { 1159 stv0900_write_reg(i_params, R0900_P2_CARFREQ, 0x4b); 1160 stv0900_write_reg(i_params, R0900_P2_CARHDR, 0x20); 1161 } 1162 1163 } else { 1164 if (i_params->dmd2_symbol_rate < 10000000) 1165 stv0900_write_reg(i_params, R0900_P2_CARFREQ, 0xef); 1166 else 1167 stv0900_write_reg(i_params, R0900_P2_CARFREQ, 0xed); 1168 } 1169 1170 switch (i_params->dmd2_srch_algo) { 1171 case STV0900_WARM_START: 1172 stv0900_write_reg(i_params, R0900_P2_DMDISTATE, 0x1f); 1173 stv0900_write_reg(i_params, R0900_P2_DMDISTATE, 0x18); 1174 break; 1175 case STV0900_COLD_START: 1176 stv0900_write_reg(i_params, R0900_P2_DMDISTATE, 0x1f); 1177 stv0900_write_reg(i_params, R0900_P2_DMDISTATE, 0x15); 1178 break; 1179 default: 1180 break; 1181 } 1182 1183 break; 1184 } 1185} 1186 1187u8 stv0900_get_optim_carr_loop(s32 srate, enum fe_stv0900_modcode modcode, 1188 s32 pilot, u8 chip_id) 1189{ 1190 u8 aclc_value = 0x29; 1191 s32 i; 1192 const struct stv0900_car_loop_optim *car_loop_s2; 1193 1194 dprintk(KERN_INFO "%s\n", __func__); 1195 1196 if (chip_id <= 0x12) 1197 car_loop_s2 = FE_STV0900_S2CarLoop; 1198 else if (chip_id == 0x20) 1199 car_loop_s2 = FE_STV0900_S2CarLoopCut20; 1200 else 1201 car_loop_s2 = FE_STV0900_S2CarLoop; 1202 1203 if (modcode < STV0900_QPSK_12) { 1204 i = 0; 1205 while ((i < 3) && (modcode != FE_STV0900_S2LowQPCarLoopCut20[i].modcode)) 1206 i++; 1207 1208 if (i >= 3) 1209 i = 2; 1210 } else { 1211 i = 0; 1212 while ((i < 14) && (modcode != car_loop_s2[i].modcode)) 1213 i++; 1214 1215 if (i >= 14) { 1216 i = 0; 1217 while ((i < 11) && (modcode != FE_STV0900_S2APSKCarLoopCut20[i].modcode)) 1218 i++; 1219 1220 if (i >= 11) 1221 i = 10; 1222 } 1223 } 1224 1225 if (modcode <= STV0900_QPSK_25) { 1226 if (pilot) { 1227 if (srate <= 3000000) 1228 aclc_value = FE_STV0900_S2LowQPCarLoopCut20[i].car_loop_pilots_on_2; 1229 else if (srate <= 7000000) 1230 aclc_value = FE_STV0900_S2LowQPCarLoopCut20[i].car_loop_pilots_on_5; 1231 else if (srate <= 15000000) 1232 aclc_value = FE_STV0900_S2LowQPCarLoopCut20[i].car_loop_pilots_on_10; 1233 else if (srate <= 25000000) 1234 aclc_value = FE_STV0900_S2LowQPCarLoopCut20[i].car_loop_pilots_on_20; 1235 else 1236 aclc_value = FE_STV0900_S2LowQPCarLoopCut20[i].car_loop_pilots_on_30; 1237 } else { 1238 if (srate <= 3000000) 1239 aclc_value = FE_STV0900_S2LowQPCarLoopCut20[i].car_loop_pilots_off_2; 1240 else if (srate <= 7000000) 1241 aclc_value = FE_STV0900_S2LowQPCarLoopCut20[i].car_loop_pilots_off_5; 1242 else if (srate <= 15000000) 1243 aclc_value = FE_STV0900_S2LowQPCarLoopCut20[i].car_loop_pilots_off_10; 1244 else if (srate <= 25000000) 1245 aclc_value = FE_STV0900_S2LowQPCarLoopCut20[i].car_loop_pilots_off_20; 1246 else 1247 aclc_value = FE_STV0900_S2LowQPCarLoopCut20[i].car_loop_pilots_off_30; 1248 } 1249 1250 } else if (modcode <= STV0900_8PSK_910) { 1251 if (pilot) { 1252 if (srate <= 3000000) 1253 aclc_value = car_loop_s2[i].car_loop_pilots_on_2; 1254 else if (srate <= 7000000) 1255 aclc_value = car_loop_s2[i].car_loop_pilots_on_5; 1256 else if (srate <= 15000000) 1257 aclc_value = car_loop_s2[i].car_loop_pilots_on_10; 1258 else if (srate <= 25000000) 1259 aclc_value = car_loop_s2[i].car_loop_pilots_on_20; 1260 else 1261 aclc_value = car_loop_s2[i].car_loop_pilots_on_30; 1262 } else { 1263 if (srate <= 3000000) 1264 aclc_value = car_loop_s2[i].car_loop_pilots_off_2; 1265 else if (srate <= 7000000) 1266 aclc_value = car_loop_s2[i].car_loop_pilots_off_5; 1267 else if (srate <= 15000000) 1268 aclc_value = car_loop_s2[i].car_loop_pilots_off_10; 1269 else if (srate <= 25000000) 1270 aclc_value = car_loop_s2[i].car_loop_pilots_off_20; 1271 else 1272 aclc_value = car_loop_s2[i].car_loop_pilots_off_30; 1273 } 1274 1275 } else { 1276 if (srate <= 3000000) 1277 aclc_value = FE_STV0900_S2APSKCarLoopCut20[i].car_loop_pilots_on_2; 1278 else if (srate <= 7000000) 1279 aclc_value = FE_STV0900_S2APSKCarLoopCut20[i].car_loop_pilots_on_5; 1280 else if (srate <= 15000000) 1281 aclc_value = FE_STV0900_S2APSKCarLoopCut20[i].car_loop_pilots_on_10; 1282 else if (srate <= 25000000) 1283 aclc_value = FE_STV0900_S2APSKCarLoopCut20[i].car_loop_pilots_on_20; 1284 else 1285 aclc_value = FE_STV0900_S2APSKCarLoopCut20[i].car_loop_pilots_on_30; 1286 } 1287 1288 return aclc_value; 1289} 1290 1291u8 stv0900_get_optim_short_carr_loop(s32 srate, enum fe_stv0900_modulation modulation, u8 chip_id) 1292{ 1293 s32 mod_index = 0; 1294 1295 u8 aclc_value = 0x0b; 1296 1297 dprintk(KERN_INFO "%s\n", __func__); 1298 1299 switch (modulation) { 1300 case STV0900_QPSK: 1301 default: 1302 mod_index = 0; 1303 break; 1304 case STV0900_8PSK: 1305 mod_index = 1; 1306 break; 1307 case STV0900_16APSK: 1308 mod_index = 2; 1309 break; 1310 case STV0900_32APSK: 1311 mod_index = 3; 1312 break; 1313 } 1314 1315 switch (chip_id) { 1316 case 0x20: 1317 if (srate <= 3000000) 1318 aclc_value = FE_STV0900_S2ShortCarLoop[mod_index].car_loop_cut20_2; 1319 else if (srate <= 7000000) 1320 aclc_value = FE_STV0900_S2ShortCarLoop[mod_index].car_loop_cut20_5; 1321 else if (srate <= 15000000) 1322 aclc_value = FE_STV0900_S2ShortCarLoop[mod_index].car_loop_cut20_10; 1323 else if (srate <= 25000000) 1324 aclc_value = FE_STV0900_S2ShortCarLoop[mod_index].car_loop_cut20_20; 1325 else 1326 aclc_value = FE_STV0900_S2ShortCarLoop[mod_index].car_loop_cut20_30; 1327 1328 break; 1329 case 0x12: 1330 default: 1331 if (srate <= 3000000) 1332 aclc_value = FE_STV0900_S2ShortCarLoop[mod_index].car_loop_cut12_2; 1333 else if (srate <= 7000000) 1334 aclc_value = FE_STV0900_S2ShortCarLoop[mod_index].car_loop_cut12_5; 1335 else if (srate <= 15000000) 1336 aclc_value = FE_STV0900_S2ShortCarLoop[mod_index].car_loop_cut12_10; 1337 else if (srate <= 25000000) 1338 aclc_value = FE_STV0900_S2ShortCarLoop[mod_index].car_loop_cut12_20; 1339 else 1340 aclc_value = FE_STV0900_S2ShortCarLoop[mod_index].car_loop_cut12_30; 1341 1342 break; 1343 } 1344 1345 return aclc_value; 1346} 1347 1348static enum fe_stv0900_error stv0900_st_dvbs2_single(struct stv0900_internal *i_params, 1349 enum fe_stv0900_demod_mode LDPC_Mode, 1350 enum fe_stv0900_demod_num demod) 1351{ 1352 enum fe_stv0900_error error = STV0900_NO_ERROR; 1353 1354 dprintk(KERN_INFO "%s\n", __func__); 1355 1356 switch (LDPC_Mode) { 1357 case STV0900_DUAL: 1358 default: 1359 if ((i_params->demod_mode != STV0900_DUAL) 1360 || (stv0900_get_bits(i_params, F0900_DDEMOD) != 1)) { 1361 stv0900_write_reg(i_params, R0900_GENCFG, 0x1d); 1362 1363 i_params->demod_mode = STV0900_DUAL; 1364 1365 stv0900_write_bits(i_params, F0900_FRESFEC, 1); 1366 stv0900_write_bits(i_params, F0900_FRESFEC, 0); 1367 } 1368 1369 break; 1370 case STV0900_SINGLE: 1371 if (demod == STV0900_DEMOD_2) 1372 stv0900_write_reg(i_params, R0900_GENCFG, 0x06); 1373 else 1374 stv0900_write_reg(i_params, R0900_GENCFG, 0x04); 1375 1376 i_params->demod_mode = STV0900_SINGLE; 1377 1378 stv0900_write_bits(i_params, F0900_FRESFEC, 1); 1379 stv0900_write_bits(i_params, F0900_FRESFEC, 0); 1380 stv0900_write_bits(i_params, F0900_P1_ALGOSWRST, 1); 1381 stv0900_write_bits(i_params, F0900_P1_ALGOSWRST, 0); 1382 stv0900_write_bits(i_params, F0900_P2_ALGOSWRST, 1); 1383 stv0900_write_bits(i_params, F0900_P2_ALGOSWRST, 0); 1384 break; 1385 } 1386 1387 return error; 1388} 1389 1390static enum fe_stv0900_error stv0900_init_internal(struct dvb_frontend *fe, 1391 struct stv0900_init_params *p_init) 1392{ 1393 struct stv0900_state *state = fe->demodulator_priv; 1394 enum fe_stv0900_error error = STV0900_NO_ERROR; 1395 enum fe_stv0900_error demodError = STV0900_NO_ERROR; 1396 int selosci; 1397 1398 struct stv0900_inode *temp_int = find_inode(state->i2c_adap, 1399 state->config->demod_address); 1400 1401 dprintk(KERN_INFO "%s\n", __func__); 1402 1403 if (temp_int != NULL) { 1404 state->internal = temp_int->internal; 1405 (state->internal->dmds_used)++; 1406 dprintk(KERN_INFO "%s: Find Internal Structure!\n", __func__); 1407 return STV0900_NO_ERROR; 1408 } else { 1409 state->internal = kmalloc(sizeof(struct stv0900_internal), GFP_KERNEL); 1410 temp_int = append_internal(state->internal); 1411 state->internal->dmds_used = 1; 1412 state->internal->i2c_adap = state->i2c_adap; 1413 state->internal->i2c_addr = state->config->demod_address; 1414 state->internal->clkmode = state->config->clkmode; 1415 state->internal->errs = STV0900_NO_ERROR; 1416 dprintk(KERN_INFO "%s: Create New Internal Structure!\n", __func__); 1417 } 1418 1419 if (state->internal != NULL) { 1420 demodError = stv0900_initialize(state->internal); 1421 if (demodError == STV0900_NO_ERROR) { 1422 error = STV0900_NO_ERROR; 1423 } else { 1424 if (demodError == STV0900_INVALID_HANDLE) 1425 error = STV0900_INVALID_HANDLE; 1426 else 1427 error = STV0900_I2C_ERROR; 1428 } 1429 1430 if (state->internal != NULL) { 1431 if (error == STV0900_NO_ERROR) { 1432 state->internal->demod_mode = p_init->demod_mode; 1433 1434 stv0900_st_dvbs2_single(state->internal, state->internal->demod_mode, STV0900_DEMOD_1); 1435 1436 state->internal->chip_id = stv0900_read_reg(state->internal, R0900_MID); 1437 state->internal->rolloff = p_init->rolloff; 1438 state->internal->quartz = p_init->dmd_ref_clk; 1439 1440 stv0900_write_bits(state->internal, F0900_P1_ROLLOFF_CONTROL, p_init->rolloff); 1441 stv0900_write_bits(state->internal, F0900_P2_ROLLOFF_CONTROL, p_init->rolloff); 1442 1443 stv0900_set_ts_parallel_serial(state->internal, p_init->path1_ts_clock, p_init->path2_ts_clock); 1444 stv0900_write_bits(state->internal, F0900_P1_TUN_MADDRESS, p_init->tun1_maddress); 1445 switch (p_init->tuner1_adc) { 1446 case 1: 1447 stv0900_write_reg(state->internal, R0900_TSTTNR1, 0x26); 1448 break; 1449 default: 1450 break; 1451 } 1452 1453 stv0900_write_bits(state->internal, F0900_P2_TUN_MADDRESS, p_init->tun2_maddress); 1454 switch (p_init->tuner2_adc) { 1455 case 1: 1456 stv0900_write_reg(state->internal, R0900_TSTTNR3, 0x26); 1457 break; 1458 default: 1459 break; 1460 } 1461 1462 stv0900_write_bits(state->internal, F0900_P1_TUN_IQSWAP, p_init->tun1_iq_inversion); 1463 stv0900_write_bits(state->internal, F0900_P2_TUN_IQSWAP, p_init->tun2_iq_inversion); 1464 stv0900_set_mclk(state->internal, 135000000); 1465 msleep(3); 1466 1467 switch (state->internal->clkmode) { 1468 case 0: 1469 case 2: 1470 stv0900_write_reg(state->internal, R0900_SYNTCTRL, 0x20 | state->internal->clkmode); 1471 break; 1472 default: 1473 selosci = 0x02 & stv0900_read_reg(state->internal, R0900_SYNTCTRL); 1474 stv0900_write_reg(state->internal, R0900_SYNTCTRL, 0x20 | selosci); 1475 break; 1476 } 1477 msleep(3); 1478 1479 state->internal->mclk = stv0900_get_mclk_freq(state->internal, state->internal->quartz); 1480 if (state->internal->errs) 1481 error = STV0900_I2C_ERROR; 1482 } 1483 } else { 1484 error = STV0900_INVALID_HANDLE; 1485 } 1486 } 1487 1488 return error; 1489} 1490 1491static int stv0900_status(struct stv0900_internal *i_params, 1492 enum fe_stv0900_demod_num demod) 1493{ 1494 enum fe_stv0900_search_state demod_state; 1495 s32 mode_field, delin_field, lock_field, fifo_field, lockedvit_field; 1496 int locked = FALSE; 1497 1498 dmd_reg(mode_field, F0900_P1_HEADER_MODE, F0900_P2_HEADER_MODE); 1499 dmd_reg(lock_field, F0900_P1_LOCK_DEFINITIF, F0900_P2_LOCK_DEFINITIF); 1500 dmd_reg(delin_field, F0900_P1_PKTDELIN_LOCK, F0900_P2_PKTDELIN_LOCK); 1501 dmd_reg(fifo_field, F0900_P1_TSFIFO_LINEOK, F0900_P2_TSFIFO_LINEOK); 1502 dmd_reg(lockedvit_field, F0900_P1_LOCKEDVIT, F0900_P2_LOCKEDVIT); 1503 1504 demod_state = stv0900_get_bits(i_params, mode_field); 1505 switch (demod_state) { 1506 case STV0900_SEARCH: 1507 case STV0900_PLH_DETECTED: 1508 default: 1509 locked = FALSE; 1510 break; 1511 case STV0900_DVBS2_FOUND: 1512 locked = stv0900_get_bits(i_params, lock_field) && 1513 stv0900_get_bits(i_params, delin_field) && 1514 stv0900_get_bits(i_params, fifo_field); 1515 break; 1516 case STV0900_DVBS_FOUND: 1517 locked = stv0900_get_bits(i_params, lock_field) && 1518 stv0900_get_bits(i_params, lockedvit_field) && 1519 stv0900_get_bits(i_params, fifo_field); 1520 break; 1521 } 1522 1523 return locked; 1524} 1525 1526static enum dvbfe_search stv0900_search(struct dvb_frontend *fe, 1527 struct dvb_frontend_parameters *params) 1528{ 1529 struct stv0900_state *state = fe->demodulator_priv; 1530 struct stv0900_internal *i_params = state->internal; 1531 struct dtv_frontend_properties *c = &fe->dtv_property_cache; 1532 1533 struct stv0900_search_params p_search; 1534 struct stv0900_signal_info p_result; 1535 1536 enum fe_stv0900_error error = STV0900_NO_ERROR; 1537 1538 dprintk(KERN_INFO "%s: ", __func__); 1539 1540 p_result.locked = FALSE; 1541 p_search.path = state->demod; 1542 p_search.frequency = c->frequency; 1543 p_search.symbol_rate = c->symbol_rate; 1544 p_search.search_range = 10000000; 1545 p_search.fec = STV0900_FEC_UNKNOWN; 1546 p_search.standard = STV0900_AUTO_SEARCH; 1547 p_search.iq_inversion = STV0900_IQ_AUTO; 1548 p_search.search_algo = STV0900_BLIND_SEARCH; 1549 1550 if ((INRANGE(100000, p_search.symbol_rate, 70000000)) && 1551 (INRANGE(100000, p_search.search_range, 50000000))) { 1552 switch (p_search.path) { 1553 case STV0900_DEMOD_1: 1554 default: 1555 i_params->dmd1_srch_standard = p_search.standard; 1556 i_params->dmd1_symbol_rate = p_search.symbol_rate; 1557 i_params->dmd1_srch_range = p_search.search_range; 1558 i_params->tuner1_freq = p_search.frequency; 1559 i_params->dmd1_srch_algo = p_search.search_algo; 1560 i_params->dmd1_srch_iq_inv = p_search.iq_inversion; 1561 i_params->dmd1_fec = p_search.fec; 1562 break; 1563 1564 case STV0900_DEMOD_2: 1565 i_params->dmd2_srch_stndrd = p_search.standard; 1566 i_params->dmd2_symbol_rate = p_search.symbol_rate; 1567 i_params->dmd2_srch_range = p_search.search_range; 1568 i_params->tuner2_freq = p_search.frequency; 1569 i_params->dmd2_srch_algo = p_search.search_algo; 1570 i_params->dmd2_srch_iq_inv = p_search.iq_inversion; 1571 i_params->dmd2_fec = p_search.fec; 1572 break; 1573 } 1574 1575 if ((stv0900_algo(fe) == STV0900_RANGEOK) && 1576 (i_params->errs == STV0900_NO_ERROR)) { 1577 switch (p_search.path) { 1578 case STV0900_DEMOD_1: 1579 default: 1580 p_result.locked = i_params->dmd1_rslts.locked; 1581 p_result.standard = i_params->dmd1_rslts.standard; 1582 p_result.frequency = i_params->dmd1_rslts.frequency; 1583 p_result.symbol_rate = i_params->dmd1_rslts.symbol_rate; 1584 p_result.fec = i_params->dmd1_rslts.fec; 1585 p_result.modcode = i_params->dmd1_rslts.modcode; 1586 p_result.pilot = i_params->dmd1_rslts.pilot; 1587 p_result.frame_length = i_params->dmd1_rslts.frame_length; 1588 p_result.spectrum = i_params->dmd1_rslts.spectrum; 1589 p_result.rolloff = i_params->dmd1_rslts.rolloff; 1590 p_result.modulation = i_params->dmd1_rslts.modulation; 1591 break; 1592 case STV0900_DEMOD_2: 1593 p_result.locked = i_params->dmd2_rslts.locked; 1594 p_result.standard = i_params->dmd2_rslts.standard; 1595 p_result.frequency = i_params->dmd2_rslts.frequency; 1596 p_result.symbol_rate = i_params->dmd2_rslts.symbol_rate; 1597 p_result.fec = i_params->dmd2_rslts.fec; 1598 p_result.modcode = i_params->dmd2_rslts.modcode; 1599 p_result.pilot = i_params->dmd2_rslts.pilot; 1600 p_result.frame_length = i_params->dmd2_rslts.frame_length; 1601 p_result.spectrum = i_params->dmd2_rslts.spectrum; 1602 p_result.rolloff = i_params->dmd2_rslts.rolloff; 1603 p_result.modulation = i_params->dmd2_rslts.modulation; 1604 break; 1605 } 1606 1607 } else { 1608 p_result.locked = FALSE; 1609 switch (p_search.path) { 1610 case STV0900_DEMOD_1: 1611 switch (i_params->dmd1_err) { 1612 case STV0900_I2C_ERROR: 1613 error = STV0900_I2C_ERROR; 1614 break; 1615 case STV0900_NO_ERROR: 1616 default: 1617 error = STV0900_SEARCH_FAILED; 1618 break; 1619 } 1620 break; 1621 case STV0900_DEMOD_2: 1622 switch (i_params->dmd2_err) { 1623 case STV0900_I2C_ERROR: 1624 error = STV0900_I2C_ERROR; 1625 break; 1626 case STV0900_NO_ERROR: 1627 default: 1628 error = STV0900_SEARCH_FAILED; 1629 break; 1630 } 1631 break; 1632 } 1633 } 1634 1635 } else 1636 error = STV0900_BAD_PARAMETER; 1637 1638 if ((p_result.locked == TRUE) && (error == STV0900_NO_ERROR)) { 1639 dprintk(KERN_INFO "Search Success\n"); 1640 return DVBFE_ALGO_SEARCH_SUCCESS; 1641 } else { 1642 dprintk(KERN_INFO "Search Fail\n"); 1643 return DVBFE_ALGO_SEARCH_FAILED; 1644 } 1645 1646 return DVBFE_ALGO_SEARCH_ERROR; 1647} 1648 1649static int stv0900_read_status(struct dvb_frontend *fe, enum fe_status *status) 1650{ 1651 struct stv0900_state *state = fe->demodulator_priv; 1652 1653 dprintk("%s: ", __func__); 1654 1655 if ((stv0900_status(state->internal, state->demod)) == TRUE) { 1656 dprintk("DEMOD LOCK OK\n"); 1657 *status = FE_HAS_CARRIER 1658 | FE_HAS_VITERBI 1659 | FE_HAS_SYNC 1660 | FE_HAS_LOCK; 1661 } else 1662 dprintk("DEMOD LOCK FAIL\n"); 1663 1664 return 0; 1665} 1666 1667static int stv0900_track(struct dvb_frontend *fe, 1668 struct dvb_frontend_parameters *p) 1669{ 1670 return 0; 1671} 1672 1673static int stv0900_stop_ts(struct dvb_frontend *fe, int stop_ts) 1674{ 1675 1676 struct stv0900_state *state = fe->demodulator_priv; 1677 struct stv0900_internal *i_params = state->internal; 1678 enum fe_stv0900_demod_num demod = state->demod; 1679 s32 rst_field; 1680 1681 dmd_reg(rst_field, F0900_P1_RST_HWARE, F0900_P2_RST_HWARE); 1682 1683 if (stop_ts == TRUE) 1684 stv0900_write_bits(i_params, rst_field, 1); 1685 else 1686 stv0900_write_bits(i_params, rst_field, 0); 1687 1688 return 0; 1689} 1690 1691static int stv0900_diseqc_init(struct dvb_frontend *fe) 1692{ 1693 struct stv0900_state *state = fe->demodulator_priv; 1694 struct stv0900_internal *i_params = state->internal; 1695 enum fe_stv0900_demod_num demod = state->demod; 1696 s32 mode_field, reset_field; 1697 1698 dmd_reg(mode_field, F0900_P1_DISTX_MODE, F0900_P2_DISTX_MODE); 1699 dmd_reg(reset_field, F0900_P1_DISEQC_RESET, F0900_P2_DISEQC_RESET); 1700 1701 stv0900_write_bits(i_params, mode_field, state->config->diseqc_mode); 1702 stv0900_write_bits(i_params, reset_field, 1); 1703 stv0900_write_bits(i_params, reset_field, 0); 1704 1705 return 0; 1706} 1707 1708static int stv0900_init(struct dvb_frontend *fe) 1709{ 1710 dprintk(KERN_INFO "%s\n", __func__); 1711 1712 stv0900_stop_ts(fe, 1); 1713 stv0900_diseqc_init(fe); 1714 1715 return 0; 1716} 1717 1718static int stv0900_diseqc_send(struct stv0900_internal *i_params , u8 *Data, 1719 u32 NbData, enum fe_stv0900_demod_num demod) 1720{ 1721 s32 i = 0; 1722 1723 switch (demod) { 1724 case STV0900_DEMOD_1: 1725 default: 1726 stv0900_write_bits(i_params, F0900_P1_DIS_PRECHARGE, 1); 1727 while (i < NbData) { 1728 while (stv0900_get_bits(i_params, F0900_P1_FIFO_FULL)) 1729 ;/* checkpatch complains */ 1730 stv0900_write_reg(i_params, R0900_P1_DISTXDATA, Data[i]); 1731 i++; 1732 } 1733 1734 stv0900_write_bits(i_params, F0900_P1_DIS_PRECHARGE, 0); 1735 i = 0; 1736 while ((stv0900_get_bits(i_params, F0900_P1_TX_IDLE) != 1) && (i < 10)) { 1737 msleep(10); 1738 i++; 1739 } 1740 1741 break; 1742 case STV0900_DEMOD_2: 1743 stv0900_write_bits(i_params, F0900_P2_DIS_PRECHARGE, 1); 1744 1745 while (i < NbData) { 1746 while (stv0900_get_bits(i_params, F0900_P2_FIFO_FULL)) 1747 ;/* checkpatch complains */ 1748 stv0900_write_reg(i_params, R0900_P2_DISTXDATA, Data[i]); 1749 i++; 1750 } 1751 1752 stv0900_write_bits(i_params, F0900_P2_DIS_PRECHARGE, 0); 1753 i = 0; 1754 while ((stv0900_get_bits(i_params, F0900_P2_TX_IDLE) != 1) && (i < 10)) { 1755 msleep(10); 1756 i++; 1757 } 1758 1759 break; 1760 } 1761 1762 return 0; 1763} 1764 1765static int stv0900_send_master_cmd(struct dvb_frontend *fe, 1766 struct dvb_diseqc_master_cmd *cmd) 1767{ 1768 struct stv0900_state *state = fe->demodulator_priv; 1769 1770 return stv0900_diseqc_send(state->internal, 1771 cmd->msg, 1772 cmd->msg_len, 1773 state->demod); 1774} 1775 1776static int stv0900_send_burst(struct dvb_frontend *fe, fe_sec_mini_cmd_t burst) 1777{ 1778 struct stv0900_state *state = fe->demodulator_priv; 1779 struct stv0900_internal *i_params = state->internal; 1780 enum fe_stv0900_demod_num demod = state->demod; 1781 s32 mode_field; 1782 u32 diseqc_fifo; 1783 1784 dmd_reg(mode_field, F0900_P1_DISTX_MODE, F0900_P2_DISTX_MODE); 1785 dmd_reg(diseqc_fifo, R0900_P1_DISTXDATA, R0900_P2_DISTXDATA); 1786 1787 switch (burst) { 1788 case SEC_MINI_A: 1789 stv0900_write_bits(i_params, mode_field, 3);/* Unmodulated */ 1790 stv0900_write_reg(i_params, diseqc_fifo, 0x00); 1791 break; 1792 case SEC_MINI_B: 1793 stv0900_write_bits(i_params, mode_field, 2);/* Modulated */ 1794 stv0900_write_reg(i_params, diseqc_fifo, 0xff); 1795 break; 1796 } 1797 1798 return 0; 1799} 1800 1801static int stv0900_recv_slave_reply(struct dvb_frontend *fe, 1802 struct dvb_diseqc_slave_reply *reply) 1803{ 1804 struct stv0900_state *state = fe->demodulator_priv; 1805 struct stv0900_internal *i_params = state->internal; 1806 s32 i = 0; 1807 1808 switch (state->demod) { 1809 case STV0900_DEMOD_1: 1810 default: 1811 reply->msg_len = 0; 1812 1813 while ((stv0900_get_bits(i_params, F0900_P1_RX_END) != 1) && (i < 10)) { 1814 msleep(10); 1815 i++; 1816 } 1817 1818 if (stv0900_get_bits(i_params, F0900_P1_RX_END)) { 1819 reply->msg_len = stv0900_get_bits(i_params, F0900_P1_FIFO_BYTENBR); 1820 1821 for (i = 0; i < reply->msg_len; i++) 1822 reply->msg[i] = stv0900_read_reg(i_params, R0900_P1_DISRXDATA); 1823 } 1824 break; 1825 case STV0900_DEMOD_2: 1826 reply->msg_len = 0; 1827 1828 while ((stv0900_get_bits(i_params, F0900_P2_RX_END) != 1) && (i < 10)) { 1829 msleep(10); 1830 i++; 1831 } 1832 1833 if (stv0900_get_bits(i_params, F0900_P2_RX_END)) { 1834 reply->msg_len = stv0900_get_bits(i_params, F0900_P2_FIFO_BYTENBR); 1835 1836 for (i = 0; i < reply->msg_len; i++) 1837 reply->msg[i] = stv0900_read_reg(i_params, R0900_P2_DISRXDATA); 1838 } 1839 break; 1840 } 1841 1842 return 0; 1843} 1844 1845static int stv0900_set_tone(struct dvb_frontend *fe, fe_sec_tone_mode_t tone) 1846{ 1847 struct stv0900_state *state = fe->demodulator_priv; 1848 struct stv0900_internal *i_params = state->internal; 1849 enum fe_stv0900_demod_num demod = state->demod; 1850 s32 mode_field, reset_field; 1851 1852 dprintk(KERN_INFO "%s: %s\n", __func__, ((tone == 0) ? "Off" : "On")); 1853 1854 dmd_reg(mode_field, F0900_P1_DISTX_MODE, F0900_P2_DISTX_MODE); 1855 dmd_reg(reset_field, F0900_P1_DISEQC_RESET, F0900_P2_DISEQC_RESET); 1856 1857 if (tone) { 1858 /*Set the DiseqC mode to 22Khz continues tone*/ 1859 stv0900_write_bits(i_params, mode_field, 0); 1860 stv0900_write_bits(i_params, reset_field, 1); 1861 /*release DiseqC reset to enable the 22KHz tone*/ 1862 stv0900_write_bits(i_params, reset_field, 0); 1863 } else { 1864 stv0900_write_bits(i_params, mode_field, 0); 1865 /*maintain the DiseqC reset to disable the 22KHz tone*/ 1866 stv0900_write_bits(i_params, reset_field, 1); 1867 } 1868 1869 return 0; 1870} 1871 1872static void stv0900_release(struct dvb_frontend *fe) 1873{ 1874 struct stv0900_state *state = fe->demodulator_priv; 1875 1876 dprintk(KERN_INFO "%s\n", __func__); 1877 1878 if ((--(state->internal->dmds_used)) <= 0) { 1879 1880 dprintk(KERN_INFO "%s: Actually removing\n", __func__); 1881 1882 remove_inode(state->internal); 1883 kfree(state->internal); 1884 } 1885 1886 kfree(state); 1887} 1888 1889static struct dvb_frontend_ops stv0900_ops = { 1890 1891 .info = { 1892 .name = "STV0900 frontend", 1893 .type = FE_QPSK, 1894 .frequency_min = 950000, 1895 .frequency_max = 2150000, 1896 .frequency_stepsize = 125, 1897 .frequency_tolerance = 0, 1898 .symbol_rate_min = 1000000, 1899 .symbol_rate_max = 45000000, 1900 .symbol_rate_tolerance = 500, 1901 .caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | 1902 FE_CAN_FEC_3_4 | FE_CAN_FEC_5_6 | 1903 FE_CAN_FEC_7_8 | FE_CAN_QPSK | 1904 FE_CAN_2G_MODULATION | 1905 FE_CAN_FEC_AUTO 1906 }, 1907 .release = stv0900_release, 1908 .init = stv0900_init, 1909 .get_frontend_algo = stv0900_frontend_algo, 1910 .i2c_gate_ctrl = stv0900_i2c_gate_ctrl, 1911 .diseqc_send_master_cmd = stv0900_send_master_cmd, 1912 .diseqc_send_burst = stv0900_send_burst, 1913 .diseqc_recv_slave_reply = stv0900_recv_slave_reply, 1914 .set_tone = stv0900_set_tone, 1915 .set_property = stb0900_set_property, 1916 .get_property = stb0900_get_property, 1917 .search = stv0900_search, 1918 .track = stv0900_track, 1919 .read_status = stv0900_read_status, 1920 .read_ber = stv0900_read_ber, 1921 .read_signal_strength = stv0900_read_signal_strength, 1922 .read_snr = stv0900_read_snr, 1923 .read_ucblocks = stv0900_read_ucblocks, 1924}; 1925 1926struct dvb_frontend *stv0900_attach(const struct stv0900_config *config, 1927 struct i2c_adapter *i2c, 1928 int demod) 1929{ 1930 struct stv0900_state *state = NULL; 1931 struct stv0900_init_params init_params; 1932 enum fe_stv0900_error err_stv0900; 1933 1934 state = kzalloc(sizeof(struct stv0900_state), GFP_KERNEL); 1935 if (state == NULL) 1936 goto error; 1937 1938 state->demod = demod; 1939 state->config = config; 1940 state->i2c_adap = i2c; 1941 1942 memcpy(&state->frontend.ops, &stv0900_ops, 1943 sizeof(struct dvb_frontend_ops)); 1944 state->frontend.demodulator_priv = state; 1945 1946 switch (demod) { 1947 case 0: 1948 case 1: 1949 init_params.dmd_ref_clk = config->xtal; 1950 init_params.demod_mode = STV0900_DUAL; 1951 init_params.rolloff = STV0900_35; 1952 init_params.path1_ts_clock = config->path1_mode; 1953 init_params.tun1_maddress = config->tun1_maddress; 1954 init_params.tun1_iq_inversion = STV0900_IQ_NORMAL; 1955 init_params.tuner1_adc = config->tun1_adc; 1956 init_params.path2_ts_clock = config->path2_mode; 1957 init_params.tun2_maddress = config->tun2_maddress; 1958 init_params.tuner2_adc = config->tun2_adc; 1959 init_params.tun2_iq_inversion = STV0900_IQ_SWAPPED; 1960 1961 err_stv0900 = stv0900_init_internal(&state->frontend, 1962 &init_params); 1963 1964 if (err_stv0900) 1965 goto error; 1966 1967 break; 1968 default: 1969 goto error; 1970 break; 1971 } 1972 1973 dprintk("%s: Attaching STV0900 demodulator(%d) \n", __func__, demod); 1974 return &state->frontend; 1975 1976error: 1977 dprintk("%s: Failed to attach STV0900 demodulator(%d) \n", 1978 __func__, demod); 1979 kfree(state); 1980 return NULL; 1981} 1982EXPORT_SYMBOL(stv0900_attach); 1983 1984MODULE_PARM_DESC(debug, "Set debug"); 1985 1986MODULE_AUTHOR("Igor M. Liplianin"); 1987MODULE_DESCRIPTION("ST STV0900 frontend"); 1988MODULE_LICENSE("GPL"); 1989