1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 STB0899 Multistandard Frontend driver 4 Copyright (C) Manu Abraham (abraham.manu@gmail.com) 5 6 Copyright (C) ST Microelectronics 7 8*/ 9 10#include <linux/init.h> 11#include <linux/jiffies.h> 12#include <linux/kernel.h> 13#include <linux/module.h> 14#include <linux/slab.h> 15#include <linux/string.h> 16 17#include <linux/dvb/frontend.h> 18#include <media/dvb_frontend.h> 19 20#include "stb0899_drv.h" 21#include "stb0899_priv.h" 22#include "stb0899_reg.h" 23 24/* Max transfer size done by I2C transfer functions */ 25#define MAX_XFER_SIZE 64 26 27static unsigned int verbose = 0;//1; 28module_param(verbose, int, 0644); 29 30/* C/N in dB/10, NIRM/NIRL */ 31static const struct stb0899_tab stb0899_cn_tab[] = { 32 { 200, 2600 }, 33 { 190, 2700 }, 34 { 180, 2860 }, 35 { 170, 3020 }, 36 { 160, 3210 }, 37 { 150, 3440 }, 38 { 140, 3710 }, 39 { 130, 4010 }, 40 { 120, 4360 }, 41 { 110, 4740 }, 42 { 100, 5190 }, 43 { 90, 5670 }, 44 { 80, 6200 }, 45 { 70, 6770 }, 46 { 60, 7360 }, 47 { 50, 7970 }, 48 { 40, 8250 }, 49 { 30, 9000 }, 50 { 20, 9450 }, 51 { 15, 9600 }, 52}; 53 54/* DVB-S AGCIQ_VALUE vs. signal level in dBm/10. 55 * As measured, connected to a modulator. 56 * -8.0 to -50.0 dBm directly connected, 57 * -52.0 to -74.8 with extra attenuation. 58 * Cut-off to AGCIQ_VALUE = 0x80 below -74.8dBm. 59 * Crude linear extrapolation below -84.8dBm and above -8.0dBm. 60 */ 61static const struct stb0899_tab stb0899_dvbsrf_tab[] = { 62 { -750, -128 }, 63 { -748, -94 }, 64 { -745, -92 }, 65 { -735, -90 }, 66 { -720, -87 }, 67 { -670, -77 }, 68 { -640, -70 }, 69 { -610, -62 }, 70 { -600, -60 }, 71 { -590, -56 }, 72 { -560, -41 }, 73 { -540, -25 }, 74 { -530, -17 }, 75 { -520, -11 }, 76 { -500, 1 }, 77 { -490, 6 }, 78 { -480, 10 }, 79 { -440, 22 }, 80 { -420, 27 }, 81 { -400, 31 }, 82 { -380, 34 }, 83 { -340, 40 }, 84 { -320, 43 }, 85 { -280, 48 }, 86 { -250, 52 }, 87 { -230, 55 }, 88 { -180, 61 }, 89 { -140, 66 }, 90 { -90, 73 }, 91 { -80, 74 }, 92 { 500, 127 } 93}; 94 95/* DVB-S2 IF_AGC_GAIN vs. signal level in dBm/10. 96 * As measured, connected to a modulator. 97 * -8.0 to -50.1 dBm directly connected, 98 * -53.0 to -76.6 with extra attenuation. 99 * Cut-off to IF_AGC_GAIN = 0x3fff below -76.6dBm. 100 * Crude linear extrapolation below -76.6dBm and above -8.0dBm. 101 */ 102static const struct stb0899_tab stb0899_dvbs2rf_tab[] = { 103 { 700, 0 }, 104 { -80, 3217 }, 105 { -150, 3893 }, 106 { -190, 4217 }, 107 { -240, 4621 }, 108 { -280, 4945 }, 109 { -320, 5273 }, 110 { -350, 5545 }, 111 { -370, 5741 }, 112 { -410, 6147 }, 113 { -450, 6671 }, 114 { -490, 7413 }, 115 { -501, 7665 }, 116 { -530, 8767 }, 117 { -560, 10219 }, 118 { -580, 10939 }, 119 { -590, 11518 }, 120 { -600, 11723 }, 121 { -650, 12659 }, 122 { -690, 13219 }, 123 { -730, 13645 }, 124 { -750, 13909 }, 125 { -766, 14153 }, 126 { -950, 16383 } 127}; 128 129/* DVB-S2 Es/N0 quant in dB/100 vs read value * 100*/ 130static struct stb0899_tab stb0899_quant_tab[] = { 131 { 0, 0 }, 132 { 0, 100 }, 133 { 600, 200 }, 134 { 950, 299 }, 135 { 1200, 398 }, 136 { 1400, 501 }, 137 { 1560, 603 }, 138 { 1690, 700 }, 139 { 1810, 804 }, 140 { 1910, 902 }, 141 { 2000, 1000 }, 142 { 2080, 1096 }, 143 { 2160, 1202 }, 144 { 2230, 1303 }, 145 { 2350, 1496 }, 146 { 2410, 1603 }, 147 { 2460, 1698 }, 148 { 2510, 1799 }, 149 { 2600, 1995 }, 150 { 2650, 2113 }, 151 { 2690, 2213 }, 152 { 2720, 2291 }, 153 { 2760, 2399 }, 154 { 2800, 2512 }, 155 { 2860, 2692 }, 156 { 2930, 2917 }, 157 { 2960, 3020 }, 158 { 3010, 3199 }, 159 { 3040, 3311 }, 160 { 3060, 3388 }, 161 { 3120, 3631 }, 162 { 3190, 3936 }, 163 { 3400, 5012 }, 164 { 3610, 6383 }, 165 { 3800, 7943 }, 166 { 4210, 12735 }, 167 { 4500, 17783 }, 168 { 4690, 22131 }, 169 { 4810, 25410 } 170}; 171 172/* DVB-S2 Es/N0 estimate in dB/100 vs read value */ 173static struct stb0899_tab stb0899_est_tab[] = { 174 { 0, 0 }, 175 { 0, 1 }, 176 { 301, 2 }, 177 { 1204, 16 }, 178 { 1806, 64 }, 179 { 2408, 256 }, 180 { 2709, 512 }, 181 { 3010, 1023 }, 182 { 3311, 2046 }, 183 { 3612, 4093 }, 184 { 3823, 6653 }, 185 { 3913, 8185 }, 186 { 4010, 10233 }, 187 { 4107, 12794 }, 188 { 4214, 16368 }, 189 { 4266, 18450 }, 190 { 4311, 20464 }, 191 { 4353, 22542 }, 192 { 4391, 24604 }, 193 { 4425, 26607 }, 194 { 4457, 28642 }, 195 { 4487, 30690 }, 196 { 4515, 32734 }, 197 { 4612, 40926 }, 198 { 4692, 49204 }, 199 { 4816, 65464 }, 200 { 4913, 81846 }, 201 { 4993, 98401 }, 202 { 5060, 114815 }, 203 { 5118, 131220 }, 204 { 5200, 158489 }, 205 { 5300, 199526 }, 206 { 5400, 251189 }, 207 { 5500, 316228 }, 208 { 5600, 398107 }, 209 { 5720, 524807 }, 210 { 5721, 526017 }, 211}; 212 213static int _stb0899_read_reg(struct stb0899_state *state, unsigned int reg) 214{ 215 int ret; 216 217 u8 b0[] = { reg >> 8, reg & 0xff }; 218 u8 buf; 219 220 struct i2c_msg msg[] = { 221 { 222 .addr = state->config->demod_address, 223 .flags = 0, 224 .buf = b0, 225 .len = 2 226 },{ 227 .addr = state->config->demod_address, 228 .flags = I2C_M_RD, 229 .buf = &buf, 230 .len = 1 231 } 232 }; 233 234 ret = i2c_transfer(state->i2c, msg, 2); 235 if (ret != 2) { 236 if (ret != -ERESTARTSYS) 237 dprintk(state->verbose, FE_ERROR, 1, 238 "Read error, Reg=[0x%02x], Status=%d", 239 reg, ret); 240 241 return ret < 0 ? ret : -EREMOTEIO; 242 } 243 if (unlikely(*state->verbose >= FE_DEBUGREG)) 244 dprintk(state->verbose, FE_ERROR, 1, "Reg=[0x%02x], data=%02x", 245 reg, buf); 246 247 return (unsigned int)buf; 248} 249 250int stb0899_read_reg(struct stb0899_state *state, unsigned int reg) 251{ 252 int result; 253 254 result = _stb0899_read_reg(state, reg); 255 /* 256 * Bug ID 9: 257 * access to 0xf2xx/0xf6xx 258 * must be followed by read from 0xf2ff/0xf6ff. 259 */ 260 if ((reg != 0xf2ff) && (reg != 0xf6ff) && 261 (((reg & 0xff00) == 0xf200) || ((reg & 0xff00) == 0xf600))) 262 _stb0899_read_reg(state, (reg | 0x00ff)); 263 264 return result; 265} 266 267u32 _stb0899_read_s2reg(struct stb0899_state *state, 268 u32 stb0899_i2cdev, 269 u32 stb0899_base_addr, 270 u16 stb0899_reg_offset) 271{ 272 int status; 273 u32 data; 274 u8 buf[7] = { 0 }; 275 u16 tmpaddr; 276 277 u8 buf_0[] = { 278 GETBYTE(stb0899_i2cdev, BYTE1), /* 0xf3 S2 Base Address (MSB) */ 279 GETBYTE(stb0899_i2cdev, BYTE0), /* 0xfc S2 Base Address (LSB) */ 280 GETBYTE(stb0899_base_addr, BYTE0), /* 0x00 Base Address (LSB) */ 281 GETBYTE(stb0899_base_addr, BYTE1), /* 0x04 Base Address (LSB) */ 282 GETBYTE(stb0899_base_addr, BYTE2), /* 0x00 Base Address (MSB) */ 283 GETBYTE(stb0899_base_addr, BYTE3), /* 0x00 Base Address (MSB) */ 284 }; 285 u8 buf_1[] = { 286 0x00, /* 0xf3 Reg Offset */ 287 0x00, /* 0x44 Reg Offset */ 288 }; 289 290 struct i2c_msg msg_0 = { 291 .addr = state->config->demod_address, 292 .flags = 0, 293 .buf = buf_0, 294 .len = 6 295 }; 296 297 struct i2c_msg msg_1 = { 298 .addr = state->config->demod_address, 299 .flags = 0, 300 .buf = buf_1, 301 .len = 2 302 }; 303 304 struct i2c_msg msg_r = { 305 .addr = state->config->demod_address, 306 .flags = I2C_M_RD, 307 .buf = buf, 308 .len = 4 309 }; 310 311 tmpaddr = stb0899_reg_offset & 0xff00; 312 if (!(stb0899_reg_offset & 0x8)) 313 tmpaddr = stb0899_reg_offset | 0x20; 314 315 buf_1[0] = GETBYTE(tmpaddr, BYTE1); 316 buf_1[1] = GETBYTE(tmpaddr, BYTE0); 317 318 status = i2c_transfer(state->i2c, &msg_0, 1); 319 if (status < 1) { 320 if (status != -ERESTARTSYS) 321 printk(KERN_ERR "%s ERR(1), Device=[0x%04x], Base address=[0x%08x], Offset=[0x%04x], Status=%d\n", 322 __func__, stb0899_i2cdev, stb0899_base_addr, stb0899_reg_offset, status); 323 324 goto err; 325 } 326 327 /* Dummy */ 328 status = i2c_transfer(state->i2c, &msg_1, 1); 329 if (status < 1) 330 goto err; 331 332 status = i2c_transfer(state->i2c, &msg_r, 1); 333 if (status < 1) 334 goto err; 335 336 buf_1[0] = GETBYTE(stb0899_reg_offset, BYTE1); 337 buf_1[1] = GETBYTE(stb0899_reg_offset, BYTE0); 338 339 /* Actual */ 340 status = i2c_transfer(state->i2c, &msg_1, 1); 341 if (status < 1) { 342 if (status != -ERESTARTSYS) 343 printk(KERN_ERR "%s ERR(2), Device=[0x%04x], Base address=[0x%08x], Offset=[0x%04x], Status=%d\n", 344 __func__, stb0899_i2cdev, stb0899_base_addr, stb0899_reg_offset, status); 345 goto err; 346 } 347 348 status = i2c_transfer(state->i2c, &msg_r, 1); 349 if (status < 1) { 350 if (status != -ERESTARTSYS) 351 printk(KERN_ERR "%s ERR(3), Device=[0x%04x], Base address=[0x%08x], Offset=[0x%04x], Status=%d\n", 352 __func__, stb0899_i2cdev, stb0899_base_addr, stb0899_reg_offset, status); 353 return status < 0 ? status : -EREMOTEIO; 354 } 355 356 data = MAKEWORD32(buf[3], buf[2], buf[1], buf[0]); 357 if (unlikely(*state->verbose >= FE_DEBUGREG)) 358 printk(KERN_DEBUG "%s Device=[0x%04x], Base address=[0x%08x], Offset=[0x%04x], Data=[0x%08x]\n", 359 __func__, stb0899_i2cdev, stb0899_base_addr, stb0899_reg_offset, data); 360 361 return data; 362 363err: 364 return status < 0 ? status : -EREMOTEIO; 365} 366 367int stb0899_write_s2reg(struct stb0899_state *state, 368 u32 stb0899_i2cdev, 369 u32 stb0899_base_addr, 370 u16 stb0899_reg_offset, 371 u32 stb0899_data) 372{ 373 int status; 374 375 /* Base Address Setup */ 376 u8 buf_0[] = { 377 GETBYTE(stb0899_i2cdev, BYTE1), /* 0xf3 S2 Base Address (MSB) */ 378 GETBYTE(stb0899_i2cdev, BYTE0), /* 0xfc S2 Base Address (LSB) */ 379 GETBYTE(stb0899_base_addr, BYTE0), /* 0x00 Base Address (LSB) */ 380 GETBYTE(stb0899_base_addr, BYTE1), /* 0x04 Base Address (LSB) */ 381 GETBYTE(stb0899_base_addr, BYTE2), /* 0x00 Base Address (MSB) */ 382 GETBYTE(stb0899_base_addr, BYTE3), /* 0x00 Base Address (MSB) */ 383 }; 384 u8 buf_1[] = { 385 0x00, /* 0xf3 Reg Offset */ 386 0x00, /* 0x44 Reg Offset */ 387 0x00, /* data */ 388 0x00, /* data */ 389 0x00, /* data */ 390 0x00, /* data */ 391 }; 392 393 struct i2c_msg msg_0 = { 394 .addr = state->config->demod_address, 395 .flags = 0, 396 .buf = buf_0, 397 .len = 6 398 }; 399 400 struct i2c_msg msg_1 = { 401 .addr = state->config->demod_address, 402 .flags = 0, 403 .buf = buf_1, 404 .len = 6 405 }; 406 407 buf_1[0] = GETBYTE(stb0899_reg_offset, BYTE1); 408 buf_1[1] = GETBYTE(stb0899_reg_offset, BYTE0); 409 buf_1[2] = GETBYTE(stb0899_data, BYTE0); 410 buf_1[3] = GETBYTE(stb0899_data, BYTE1); 411 buf_1[4] = GETBYTE(stb0899_data, BYTE2); 412 buf_1[5] = GETBYTE(stb0899_data, BYTE3); 413 414 if (unlikely(*state->verbose >= FE_DEBUGREG)) 415 printk(KERN_DEBUG "%s Device=[0x%04x], Base Address=[0x%08x], Offset=[0x%04x], Data=[0x%08x]\n", 416 __func__, stb0899_i2cdev, stb0899_base_addr, stb0899_reg_offset, stb0899_data); 417 418 status = i2c_transfer(state->i2c, &msg_0, 1); 419 if (unlikely(status < 1)) { 420 if (status != -ERESTARTSYS) 421 printk(KERN_ERR "%s ERR (1), Device=[0x%04x], Base Address=[0x%08x], Offset=[0x%04x], Data=[0x%08x], status=%d\n", 422 __func__, stb0899_i2cdev, stb0899_base_addr, stb0899_reg_offset, stb0899_data, status); 423 goto err; 424 } 425 status = i2c_transfer(state->i2c, &msg_1, 1); 426 if (unlikely(status < 1)) { 427 if (status != -ERESTARTSYS) 428 printk(KERN_ERR "%s ERR (2), Device=[0x%04x], Base Address=[0x%08x], Offset=[0x%04x], Data=[0x%08x], status=%d\n", 429 __func__, stb0899_i2cdev, stb0899_base_addr, stb0899_reg_offset, stb0899_data, status); 430 431 return status < 0 ? status : -EREMOTEIO; 432 } 433 434 return 0; 435 436err: 437 return status < 0 ? status : -EREMOTEIO; 438} 439 440int stb0899_read_regs(struct stb0899_state *state, unsigned int reg, u8 *buf, u32 count) 441{ 442 int status; 443 444 u8 b0[] = { reg >> 8, reg & 0xff }; 445 446 struct i2c_msg msg[] = { 447 { 448 .addr = state->config->demod_address, 449 .flags = 0, 450 .buf = b0, 451 .len = 2 452 },{ 453 .addr = state->config->demod_address, 454 .flags = I2C_M_RD, 455 .buf = buf, 456 .len = count 457 } 458 }; 459 460 status = i2c_transfer(state->i2c, msg, 2); 461 if (status != 2) { 462 if (status != -ERESTARTSYS) 463 printk(KERN_ERR "%s Read error, Reg=[0x%04x], Count=%u, Status=%d\n", 464 __func__, reg, count, status); 465 goto err; 466 } 467 /* 468 * Bug ID 9: 469 * access to 0xf2xx/0xf6xx 470 * must be followed by read from 0xf2ff/0xf6ff. 471 */ 472 if ((reg != 0xf2ff) && (reg != 0xf6ff) && 473 (((reg & 0xff00) == 0xf200) || ((reg & 0xff00) == 0xf600))) 474 _stb0899_read_reg(state, (reg | 0x00ff)); 475 476 dprintk(state->verbose, FE_DEBUGREG, 1, 477 "%s [0x%04x]: %*ph", __func__, reg, count, buf); 478 479 return 0; 480err: 481 return status < 0 ? status : -EREMOTEIO; 482} 483 484int stb0899_write_regs(struct stb0899_state *state, unsigned int reg, u8 *data, u32 count) 485{ 486 int ret; 487 u8 buf[MAX_XFER_SIZE]; 488 struct i2c_msg i2c_msg = { 489 .addr = state->config->demod_address, 490 .flags = 0, 491 .buf = buf, 492 .len = 2 + count 493 }; 494 495 if (2 + count > sizeof(buf)) { 496 printk(KERN_WARNING 497 "%s: i2c wr reg=%04x: len=%d is too big!\n", 498 KBUILD_MODNAME, reg, count); 499 return -EINVAL; 500 } 501 502 buf[0] = reg >> 8; 503 buf[1] = reg & 0xff; 504 memcpy(&buf[2], data, count); 505 506 dprintk(state->verbose, FE_DEBUGREG, 1, 507 "%s [0x%04x]: %*ph", __func__, reg, count, data); 508 ret = i2c_transfer(state->i2c, &i2c_msg, 1); 509 510 /* 511 * Bug ID 9: 512 * access to 0xf2xx/0xf6xx 513 * must be followed by read from 0xf2ff/0xf6ff. 514 */ 515 if ((((reg & 0xff00) == 0xf200) || ((reg & 0xff00) == 0xf600))) 516 stb0899_read_reg(state, (reg | 0x00ff)); 517 518 if (ret != 1) { 519 if (ret != -ERESTARTSYS) 520 dprintk(state->verbose, FE_ERROR, 1, "Reg=[0x%04x], Data=[0x%02x ...], Count=%u, Status=%d", 521 reg, data[0], count, ret); 522 return ret < 0 ? ret : -EREMOTEIO; 523 } 524 525 return 0; 526} 527 528int stb0899_write_reg(struct stb0899_state *state, unsigned int reg, u8 data) 529{ 530 u8 tmp = data; 531 return stb0899_write_regs(state, reg, &tmp, 1); 532} 533 534/* 535 * stb0899_get_mclk 536 * Get STB0899 master clock frequency 537 * ExtClk: external clock frequency (Hz) 538 */ 539static u32 stb0899_get_mclk(struct stb0899_state *state) 540{ 541 u32 mclk = 0, div = 0; 542 543 div = stb0899_read_reg(state, STB0899_NCOARSE); 544 mclk = (div + 1) * state->config->xtal_freq / 6; 545 dprintk(state->verbose, FE_DEBUG, 1, "div=%d, mclk=%d", div, mclk); 546 547 return mclk; 548} 549 550/* 551 * stb0899_set_mclk 552 * Set STB0899 master Clock frequency 553 * Mclk: demodulator master clock 554 * ExtClk: external clock frequency (Hz) 555 */ 556static void stb0899_set_mclk(struct stb0899_state *state, u32 Mclk) 557{ 558 struct stb0899_internal *internal = &state->internal; 559 u8 mdiv = 0; 560 561 dprintk(state->verbose, FE_DEBUG, 1, "state->config=%p", state->config); 562 mdiv = ((6 * Mclk) / state->config->xtal_freq) - 1; 563 dprintk(state->verbose, FE_DEBUG, 1, "mdiv=%d", mdiv); 564 565 stb0899_write_reg(state, STB0899_NCOARSE, mdiv); 566 internal->master_clk = stb0899_get_mclk(state); 567 568 dprintk(state->verbose, FE_DEBUG, 1, "MasterCLOCK=%d", internal->master_clk); 569} 570 571static int stb0899_postproc(struct stb0899_state *state, u8 ctl, int enable) 572{ 573 struct stb0899_config *config = state->config; 574 const struct stb0899_postproc *postproc = config->postproc; 575 576 /* post process event */ 577 if (postproc) { 578 if (enable) { 579 if (postproc[ctl].level == STB0899_GPIOPULLUP) 580 stb0899_write_reg(state, postproc[ctl].gpio, 0x02); 581 else 582 stb0899_write_reg(state, postproc[ctl].gpio, 0x82); 583 } else { 584 if (postproc[ctl].level == STB0899_GPIOPULLUP) 585 stb0899_write_reg(state, postproc[ctl].gpio, 0x82); 586 else 587 stb0899_write_reg(state, postproc[ctl].gpio, 0x02); 588 } 589 } 590 return 0; 591} 592 593static void stb0899_detach(struct dvb_frontend *fe) 594{ 595 struct stb0899_state *state = fe->demodulator_priv; 596 597 /* post process event */ 598 stb0899_postproc(state, STB0899_POSTPROC_GPIO_POWER, 0); 599} 600 601static void stb0899_release(struct dvb_frontend *fe) 602{ 603 struct stb0899_state *state = fe->demodulator_priv; 604 605 dprintk(state->verbose, FE_DEBUG, 1, "Release Frontend"); 606 kfree(state); 607} 608 609/* 610 * stb0899_get_alpha 611 * return: rolloff 612 */ 613static int stb0899_get_alpha(struct stb0899_state *state) 614{ 615 u8 mode_coeff; 616 617 mode_coeff = stb0899_read_reg(state, STB0899_DEMOD); 618 619 if (STB0899_GETFIELD(MODECOEFF, mode_coeff) == 1) 620 return 20; 621 else 622 return 35; 623} 624 625/* 626 * stb0899_init_calc 627 */ 628static void stb0899_init_calc(struct stb0899_state *state) 629{ 630 struct stb0899_internal *internal = &state->internal; 631 int master_clk; 632 u8 agc[2]; 633 u32 reg; 634 635 /* Read registers (in burst mode) */ 636 stb0899_read_regs(state, STB0899_AGC1REF, agc, 2); /* AGC1R and AGC2O */ 637 638 /* Initial calculations */ 639 master_clk = stb0899_get_mclk(state); 640 internal->t_agc1 = 0; 641 internal->t_agc2 = 0; 642 internal->master_clk = master_clk; 643 internal->mclk = master_clk / 65536L; 644 internal->rolloff = stb0899_get_alpha(state); 645 646 /* DVBS2 Initial calculations */ 647 /* Set AGC value to the middle */ 648 internal->agc_gain = 8154; 649 reg = STB0899_READ_S2REG(STB0899_S2DEMOD, IF_AGC_CNTRL); 650 STB0899_SETFIELD_VAL(IF_GAIN_INIT, reg, internal->agc_gain); 651 stb0899_write_s2reg(state, STB0899_S2DEMOD, STB0899_BASE_IF_AGC_CNTRL, STB0899_OFF0_IF_AGC_CNTRL, reg); 652 653 reg = STB0899_READ_S2REG(STB0899_S2DEMOD, RRC_ALPHA); 654 internal->rrc_alpha = STB0899_GETFIELD(RRC_ALPHA, reg); 655 656 internal->center_freq = 0; 657 internal->av_frame_coarse = 10; 658 internal->av_frame_fine = 20; 659 internal->step_size = 2; 660/* 661 if ((pParams->SpectralInv == FE_IQ_NORMAL) || (pParams->SpectralInv == FE_IQ_AUTO)) 662 pParams->IQLocked = 0; 663 else 664 pParams->IQLocked = 1; 665*/ 666} 667 668static int stb0899_wait_diseqc_fifo_empty(struct stb0899_state *state, int timeout) 669{ 670 u8 reg = 0; 671 unsigned long start = jiffies; 672 673 while (1) { 674 reg = stb0899_read_reg(state, STB0899_DISSTATUS); 675 if (!STB0899_GETFIELD(FIFOFULL, reg)) 676 break; 677 if (time_after(jiffies, start + timeout)) { 678 dprintk(state->verbose, FE_ERROR, 1, "timed out !!"); 679 return -ETIMEDOUT; 680 } 681 } 682 683 return 0; 684} 685 686static int stb0899_send_diseqc_msg(struct dvb_frontend *fe, struct dvb_diseqc_master_cmd *cmd) 687{ 688 struct stb0899_state *state = fe->demodulator_priv; 689 u8 reg, i; 690 691 if (cmd->msg_len > sizeof(cmd->msg)) 692 return -EINVAL; 693 694 /* enable FIFO precharge */ 695 reg = stb0899_read_reg(state, STB0899_DISCNTRL1); 696 STB0899_SETFIELD_VAL(DISPRECHARGE, reg, 1); 697 stb0899_write_reg(state, STB0899_DISCNTRL1, reg); 698 for (i = 0; i < cmd->msg_len; i++) { 699 /* wait for FIFO empty */ 700 if (stb0899_wait_diseqc_fifo_empty(state, 100) < 0) 701 return -ETIMEDOUT; 702 703 stb0899_write_reg(state, STB0899_DISFIFO, cmd->msg[i]); 704 } 705 reg = stb0899_read_reg(state, STB0899_DISCNTRL1); 706 STB0899_SETFIELD_VAL(DISPRECHARGE, reg, 0); 707 stb0899_write_reg(state, STB0899_DISCNTRL1, reg); 708 msleep(100); 709 return 0; 710} 711 712static int stb0899_wait_diseqc_rxidle(struct stb0899_state *state, int timeout) 713{ 714 u8 reg = 0; 715 unsigned long start = jiffies; 716 717 while (!STB0899_GETFIELD(RXEND, reg)) { 718 reg = stb0899_read_reg(state, STB0899_DISRX_ST0); 719 if (time_after(jiffies, start + timeout)) { 720 dprintk(state->verbose, FE_ERROR, 1, "timed out!!"); 721 return -ETIMEDOUT; 722 } 723 msleep(10); 724 } 725 726 return 0; 727} 728 729static int stb0899_recv_slave_reply(struct dvb_frontend *fe, struct dvb_diseqc_slave_reply *reply) 730{ 731 struct stb0899_state *state = fe->demodulator_priv; 732 u8 reg, length = 0, i; 733 int result; 734 735 if (stb0899_wait_diseqc_rxidle(state, 100) < 0) 736 return -ETIMEDOUT; 737 738 reg = stb0899_read_reg(state, STB0899_DISRX_ST0); 739 if (STB0899_GETFIELD(RXEND, reg)) { 740 741 reg = stb0899_read_reg(state, STB0899_DISRX_ST1); 742 length = STB0899_GETFIELD(FIFOBYTENBR, reg); 743 744 if (length > sizeof (reply->msg)) { 745 result = -EOVERFLOW; 746 goto exit; 747 } 748 reply->msg_len = length; 749 750 /* extract data */ 751 for (i = 0; i < length; i++) 752 reply->msg[i] = stb0899_read_reg(state, STB0899_DISFIFO); 753 } 754 755 return 0; 756exit: 757 758 return result; 759} 760 761static int stb0899_wait_diseqc_txidle(struct stb0899_state *state, int timeout) 762{ 763 u8 reg = 0; 764 unsigned long start = jiffies; 765 766 while (!STB0899_GETFIELD(TXIDLE, reg)) { 767 reg = stb0899_read_reg(state, STB0899_DISSTATUS); 768 if (time_after(jiffies, start + timeout)) { 769 dprintk(state->verbose, FE_ERROR, 1, "timed out!!"); 770 return -ETIMEDOUT; 771 } 772 msleep(10); 773 } 774 return 0; 775} 776 777static int stb0899_send_diseqc_burst(struct dvb_frontend *fe, 778 enum fe_sec_mini_cmd burst) 779{ 780 struct stb0899_state *state = fe->demodulator_priv; 781 u8 reg, old_state; 782 783 /* wait for diseqc idle */ 784 if (stb0899_wait_diseqc_txidle(state, 100) < 0) 785 return -ETIMEDOUT; 786 787 reg = stb0899_read_reg(state, STB0899_DISCNTRL1); 788 old_state = reg; 789 /* set to burst mode */ 790 STB0899_SETFIELD_VAL(DISEQCMODE, reg, 0x03); 791 STB0899_SETFIELD_VAL(DISPRECHARGE, reg, 0x01); 792 stb0899_write_reg(state, STB0899_DISCNTRL1, reg); 793 switch (burst) { 794 case SEC_MINI_A: 795 /* unmodulated */ 796 stb0899_write_reg(state, STB0899_DISFIFO, 0x00); 797 break; 798 case SEC_MINI_B: 799 /* modulated */ 800 stb0899_write_reg(state, STB0899_DISFIFO, 0xff); 801 break; 802 } 803 reg = stb0899_read_reg(state, STB0899_DISCNTRL1); 804 STB0899_SETFIELD_VAL(DISPRECHARGE, reg, 0x00); 805 stb0899_write_reg(state, STB0899_DISCNTRL1, reg); 806 /* wait for diseqc idle */ 807 if (stb0899_wait_diseqc_txidle(state, 100) < 0) 808 return -ETIMEDOUT; 809 810 /* restore state */ 811 stb0899_write_reg(state, STB0899_DISCNTRL1, old_state); 812 813 return 0; 814} 815 816static int stb0899_diseqc_init(struct stb0899_state *state) 817{ 818/* 819 struct dvb_diseqc_slave_reply rx_data; 820*/ 821 u8 f22_tx, reg; 822 823 u32 mclk, tx_freq = 22000;/* count = 0, i; */ 824 reg = stb0899_read_reg(state, STB0899_DISCNTRL2); 825 STB0899_SETFIELD_VAL(ONECHIP_TRX, reg, 0); 826 stb0899_write_reg(state, STB0899_DISCNTRL2, reg); 827 828 /* disable Tx spy */ 829 reg = stb0899_read_reg(state, STB0899_DISCNTRL1); 830 STB0899_SETFIELD_VAL(DISEQCRESET, reg, 1); 831 stb0899_write_reg(state, STB0899_DISCNTRL1, reg); 832 833 reg = stb0899_read_reg(state, STB0899_DISCNTRL1); 834 STB0899_SETFIELD_VAL(DISEQCRESET, reg, 0); 835 stb0899_write_reg(state, STB0899_DISCNTRL1, reg); 836 837 mclk = stb0899_get_mclk(state); 838 f22_tx = mclk / (tx_freq * 32); 839 stb0899_write_reg(state, STB0899_DISF22, f22_tx); /* DiSEqC Tx freq */ 840 state->rx_freq = 20000; 841 842 return 0; 843} 844 845static int stb0899_sleep(struct dvb_frontend *fe) 846{ 847 struct stb0899_state *state = fe->demodulator_priv; 848/* 849 u8 reg; 850*/ 851 dprintk(state->verbose, FE_DEBUG, 1, "Going to Sleep .. (Really tired .. :-))"); 852 /* post process event */ 853 stb0899_postproc(state, STB0899_POSTPROC_GPIO_POWER, 0); 854 855 return 0; 856} 857 858static int stb0899_wakeup(struct dvb_frontend *fe) 859{ 860 int rc; 861 struct stb0899_state *state = fe->demodulator_priv; 862 863 if ((rc = stb0899_write_reg(state, STB0899_SYNTCTRL, STB0899_SELOSCI))) 864 return rc; 865 /* Activate all clocks; DVB-S2 registers are inaccessible otherwise. */ 866 if ((rc = stb0899_write_reg(state, STB0899_STOPCLK1, 0x00))) 867 return rc; 868 if ((rc = stb0899_write_reg(state, STB0899_STOPCLK2, 0x00))) 869 return rc; 870 871 /* post process event */ 872 stb0899_postproc(state, STB0899_POSTPROC_GPIO_POWER, 1); 873 874 return 0; 875} 876 877static int stb0899_init(struct dvb_frontend *fe) 878{ 879 int i; 880 struct stb0899_state *state = fe->demodulator_priv; 881 struct stb0899_config *config = state->config; 882 883 dprintk(state->verbose, FE_DEBUG, 1, "Initializing STB0899 ... "); 884 885 /* init device */ 886 dprintk(state->verbose, FE_DEBUG, 1, "init device"); 887 for (i = 0; config->init_dev[i].address != 0xffff; i++) 888 stb0899_write_reg(state, config->init_dev[i].address, config->init_dev[i].data); 889 890 dprintk(state->verbose, FE_DEBUG, 1, "init S2 demod"); 891 /* init S2 demod */ 892 for (i = 0; config->init_s2_demod[i].offset != 0xffff; i++) 893 stb0899_write_s2reg(state, STB0899_S2DEMOD, 894 config->init_s2_demod[i].base_address, 895 config->init_s2_demod[i].offset, 896 config->init_s2_demod[i].data); 897 898 dprintk(state->verbose, FE_DEBUG, 1, "init S1 demod"); 899 /* init S1 demod */ 900 for (i = 0; config->init_s1_demod[i].address != 0xffff; i++) 901 stb0899_write_reg(state, config->init_s1_demod[i].address, config->init_s1_demod[i].data); 902 903 dprintk(state->verbose, FE_DEBUG, 1, "init S2 FEC"); 904 /* init S2 fec */ 905 for (i = 0; config->init_s2_fec[i].offset != 0xffff; i++) 906 stb0899_write_s2reg(state, STB0899_S2FEC, 907 config->init_s2_fec[i].base_address, 908 config->init_s2_fec[i].offset, 909 config->init_s2_fec[i].data); 910 911 dprintk(state->verbose, FE_DEBUG, 1, "init TST"); 912 /* init test */ 913 for (i = 0; config->init_tst[i].address != 0xffff; i++) 914 stb0899_write_reg(state, config->init_tst[i].address, config->init_tst[i].data); 915 916 stb0899_init_calc(state); 917 stb0899_diseqc_init(state); 918 919 return 0; 920} 921 922static int stb0899_table_lookup(const struct stb0899_tab *tab, int max, int val) 923{ 924 int res = 0; 925 int min = 0, med; 926 927 if (val < tab[min].read) 928 res = tab[min].real; 929 else if (val >= tab[max].read) 930 res = tab[max].real; 931 else { 932 while ((max - min) > 1) { 933 med = (max + min) / 2; 934 if (val >= tab[min].read && val < tab[med].read) 935 max = med; 936 else 937 min = med; 938 } 939 res = ((val - tab[min].read) * 940 (tab[max].real - tab[min].real) / 941 (tab[max].read - tab[min].read)) + 942 tab[min].real; 943 } 944 945 return res; 946} 947 948static int stb0899_read_signal_strength(struct dvb_frontend *fe, u16 *strength) 949{ 950 struct stb0899_state *state = fe->demodulator_priv; 951 struct stb0899_internal *internal = &state->internal; 952 953 int val; 954 u32 reg; 955 *strength = 0; 956 switch (state->delsys) { 957 case SYS_DVBS: 958 case SYS_DSS: 959 if (internal->lock) { 960 reg = stb0899_read_reg(state, STB0899_VSTATUS); 961 if (STB0899_GETFIELD(VSTATUS_LOCKEDVIT, reg)) { 962 963 reg = stb0899_read_reg(state, STB0899_AGCIQIN); 964 val = (s32)(s8)STB0899_GETFIELD(AGCIQVALUE, reg); 965 966 *strength = stb0899_table_lookup(stb0899_dvbsrf_tab, ARRAY_SIZE(stb0899_dvbsrf_tab) - 1, val); 967 *strength += 750; 968 dprintk(state->verbose, FE_DEBUG, 1, "AGCIQVALUE = 0x%02x, C = %d * 0.1 dBm", 969 val & 0xff, *strength); 970 } 971 } 972 break; 973 case SYS_DVBS2: 974 if (internal->lock) { 975 reg = STB0899_READ_S2REG(STB0899_S2DEMOD, IF_AGC_GAIN); 976 val = STB0899_GETFIELD(IF_AGC_GAIN, reg); 977 978 *strength = stb0899_table_lookup(stb0899_dvbs2rf_tab, ARRAY_SIZE(stb0899_dvbs2rf_tab) - 1, val); 979 *strength += 950; 980 dprintk(state->verbose, FE_DEBUG, 1, "IF_AGC_GAIN = 0x%04x, C = %d * 0.1 dBm", 981 val & 0x3fff, *strength); 982 } 983 break; 984 default: 985 dprintk(state->verbose, FE_DEBUG, 1, "Unsupported delivery system"); 986 return -EINVAL; 987 } 988 989 return 0; 990} 991 992static int stb0899_read_snr(struct dvb_frontend *fe, u16 *snr) 993{ 994 struct stb0899_state *state = fe->demodulator_priv; 995 struct stb0899_internal *internal = &state->internal; 996 997 unsigned int val, quant, quantn = -1, est, estn = -1; 998 u8 buf[2]; 999 u32 reg; 1000 1001 *snr = 0; 1002 reg = stb0899_read_reg(state, STB0899_VSTATUS); 1003 switch (state->delsys) { 1004 case SYS_DVBS: 1005 case SYS_DSS: 1006 if (internal->lock) { 1007 if (STB0899_GETFIELD(VSTATUS_LOCKEDVIT, reg)) { 1008 1009 stb0899_read_regs(state, STB0899_NIRM, buf, 2); 1010 val = MAKEWORD16(buf[0], buf[1]); 1011 1012 *snr = stb0899_table_lookup(stb0899_cn_tab, ARRAY_SIZE(stb0899_cn_tab) - 1, val); 1013 dprintk(state->verbose, FE_DEBUG, 1, "NIR = 0x%02x%02x = %u, C/N = %d * 0.1 dBm\n", 1014 buf[0], buf[1], val, *snr); 1015 } 1016 } 1017 break; 1018 case SYS_DVBS2: 1019 if (internal->lock) { 1020 reg = STB0899_READ_S2REG(STB0899_S2DEMOD, UWP_CNTRL1); 1021 quant = STB0899_GETFIELD(UWP_ESN0_QUANT, reg); 1022 reg = STB0899_READ_S2REG(STB0899_S2DEMOD, UWP_STAT2); 1023 est = STB0899_GETFIELD(ESN0_EST, reg); 1024 if (est == 1) 1025 val = 301; /* C/N = 30.1 dB */ 1026 else if (est == 2) 1027 val = 270; /* C/N = 27.0 dB */ 1028 else { 1029 /* quantn = 100 * log(quant^2) */ 1030 quantn = stb0899_table_lookup(stb0899_quant_tab, ARRAY_SIZE(stb0899_quant_tab) - 1, quant * 100); 1031 /* estn = 100 * log(est) */ 1032 estn = stb0899_table_lookup(stb0899_est_tab, ARRAY_SIZE(stb0899_est_tab) - 1, est); 1033 /* snr(dBm/10) = -10*(log(est)-log(quant^2)) => snr(dBm/10) = (100*log(quant^2)-100*log(est))/10 */ 1034 val = (quantn - estn) / 10; 1035 } 1036 *snr = val; 1037 dprintk(state->verbose, FE_DEBUG, 1, "Es/N0 quant = %d (%d) estimate = %u (%d), C/N = %d * 0.1 dBm", 1038 quant, quantn, est, estn, val); 1039 } 1040 break; 1041 default: 1042 dprintk(state->verbose, FE_DEBUG, 1, "Unsupported delivery system"); 1043 return -EINVAL; 1044 } 1045 1046 return 0; 1047} 1048 1049static int stb0899_read_status(struct dvb_frontend *fe, enum fe_status *status) 1050{ 1051 struct stb0899_state *state = fe->demodulator_priv; 1052 struct stb0899_internal *internal = &state->internal; 1053 u8 reg; 1054 *status = 0; 1055 1056 switch (state->delsys) { 1057 case SYS_DVBS: 1058 case SYS_DSS: 1059 dprintk(state->verbose, FE_DEBUG, 1, "Delivery system DVB-S/DSS"); 1060 if (internal->lock) { 1061 reg = stb0899_read_reg(state, STB0899_VSTATUS); 1062 if (STB0899_GETFIELD(VSTATUS_LOCKEDVIT, reg)) { 1063 dprintk(state->verbose, FE_DEBUG, 1, "--------> FE_HAS_CARRIER | FE_HAS_LOCK"); 1064 *status |= FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_LOCK; 1065 1066 reg = stb0899_read_reg(state, STB0899_PLPARM); 1067 if (STB0899_GETFIELD(VITCURPUN, reg)) { 1068 dprintk(state->verbose, FE_DEBUG, 1, "--------> FE_HAS_VITERBI | FE_HAS_SYNC"); 1069 *status |= FE_HAS_VITERBI | FE_HAS_SYNC; 1070 /* post process event */ 1071 stb0899_postproc(state, STB0899_POSTPROC_GPIO_LOCK, 1); 1072 } 1073 } 1074 } 1075 break; 1076 case SYS_DVBS2: 1077 dprintk(state->verbose, FE_DEBUG, 1, "Delivery system DVB-S2"); 1078 if (internal->lock) { 1079 reg = STB0899_READ_S2REG(STB0899_S2DEMOD, DMD_STAT2); 1080 if (STB0899_GETFIELD(UWP_LOCK, reg) && STB0899_GETFIELD(CSM_LOCK, reg)) { 1081 *status |= FE_HAS_CARRIER; 1082 dprintk(state->verbose, FE_DEBUG, 1, 1083 "UWP & CSM Lock ! ---> DVB-S2 FE_HAS_CARRIER"); 1084 1085 reg = stb0899_read_reg(state, STB0899_CFGPDELSTATUS1); 1086 if (STB0899_GETFIELD(CFGPDELSTATUS_LOCK, reg)) { 1087 *status |= FE_HAS_LOCK; 1088 dprintk(state->verbose, FE_DEBUG, 1, 1089 "Packet Delineator Locked ! -----> DVB-S2 FE_HAS_LOCK"); 1090 1091 } 1092 if (STB0899_GETFIELD(CONTINUOUS_STREAM, reg)) { 1093 *status |= FE_HAS_VITERBI; 1094 dprintk(state->verbose, FE_DEBUG, 1, 1095 "Packet Delineator found VITERBI ! -----> DVB-S2 FE_HAS_VITERBI"); 1096 } 1097 if (STB0899_GETFIELD(ACCEPTED_STREAM, reg)) { 1098 *status |= FE_HAS_SYNC; 1099 dprintk(state->verbose, FE_DEBUG, 1, 1100 "Packet Delineator found SYNC ! -----> DVB-S2 FE_HAS_SYNC"); 1101 /* post process event */ 1102 stb0899_postproc(state, STB0899_POSTPROC_GPIO_LOCK, 1); 1103 } 1104 } 1105 } 1106 break; 1107 default: 1108 dprintk(state->verbose, FE_DEBUG, 1, "Unsupported delivery system"); 1109 return -EINVAL; 1110 } 1111 return 0; 1112} 1113 1114/* 1115 * stb0899_get_error 1116 * viterbi error for DVB-S/DSS 1117 * packet error for DVB-S2 1118 * Bit Error Rate or Packet Error Rate * 10 ^ 7 1119 */ 1120static int stb0899_read_ber(struct dvb_frontend *fe, u32 *ber) 1121{ 1122 struct stb0899_state *state = fe->demodulator_priv; 1123 struct stb0899_internal *internal = &state->internal; 1124 1125 u8 lsb, msb; 1126 1127 *ber = 0; 1128 1129 switch (state->delsys) { 1130 case SYS_DVBS: 1131 case SYS_DSS: 1132 if (internal->lock) { 1133 lsb = stb0899_read_reg(state, STB0899_ECNT1L); 1134 msb = stb0899_read_reg(state, STB0899_ECNT1M); 1135 *ber = MAKEWORD16(msb, lsb); 1136 /* Viterbi Check */ 1137 if (STB0899_GETFIELD(VSTATUS_PRFVIT, internal->v_status)) { 1138 /* Error Rate */ 1139 *ber *= 9766; 1140 /* ber = ber * 10 ^ 7 */ 1141 *ber /= (-1 + (1 << (2 * STB0899_GETFIELD(NOE, internal->err_ctrl)))); 1142 *ber /= 8; 1143 } 1144 } 1145 break; 1146 case SYS_DVBS2: 1147 if (internal->lock) { 1148 lsb = stb0899_read_reg(state, STB0899_ECNT1L); 1149 msb = stb0899_read_reg(state, STB0899_ECNT1M); 1150 *ber = MAKEWORD16(msb, lsb); 1151 /* ber = ber * 10 ^ 7 */ 1152 *ber *= 10000000; 1153 *ber /= (-1 + (1 << (4 + 2 * STB0899_GETFIELD(NOE, internal->err_ctrl)))); 1154 } 1155 break; 1156 default: 1157 dprintk(state->verbose, FE_DEBUG, 1, "Unsupported delivery system"); 1158 return -EINVAL; 1159 } 1160 1161 return 0; 1162} 1163 1164static int stb0899_set_voltage(struct dvb_frontend *fe, 1165 enum fe_sec_voltage voltage) 1166{ 1167 struct stb0899_state *state = fe->demodulator_priv; 1168 1169 switch (voltage) { 1170 case SEC_VOLTAGE_13: 1171 stb0899_write_reg(state, STB0899_GPIO00CFG, 0x82); 1172 stb0899_write_reg(state, STB0899_GPIO01CFG, 0x02); 1173 stb0899_write_reg(state, STB0899_GPIO02CFG, 0x00); 1174 break; 1175 case SEC_VOLTAGE_18: 1176 stb0899_write_reg(state, STB0899_GPIO00CFG, 0x02); 1177 stb0899_write_reg(state, STB0899_GPIO01CFG, 0x02); 1178 stb0899_write_reg(state, STB0899_GPIO02CFG, 0x82); 1179 break; 1180 case SEC_VOLTAGE_OFF: 1181 stb0899_write_reg(state, STB0899_GPIO00CFG, 0x82); 1182 stb0899_write_reg(state, STB0899_GPIO01CFG, 0x82); 1183 stb0899_write_reg(state, STB0899_GPIO02CFG, 0x82); 1184 break; 1185 default: 1186 return -EINVAL; 1187 } 1188 1189 return 0; 1190} 1191 1192static int stb0899_set_tone(struct dvb_frontend *fe, enum fe_sec_tone_mode tone) 1193{ 1194 struct stb0899_state *state = fe->demodulator_priv; 1195 struct stb0899_internal *internal = &state->internal; 1196 1197 u8 div, reg; 1198 1199 /* wait for diseqc idle */ 1200 if (stb0899_wait_diseqc_txidle(state, 100) < 0) 1201 return -ETIMEDOUT; 1202 1203 switch (tone) { 1204 case SEC_TONE_ON: 1205 div = (internal->master_clk / 100) / 5632; 1206 div = (div + 5) / 10; 1207 stb0899_write_reg(state, STB0899_DISEQCOCFG, 0x66); 1208 reg = stb0899_read_reg(state, STB0899_ACRPRESC); 1209 STB0899_SETFIELD_VAL(ACRPRESC, reg, 0x03); 1210 stb0899_write_reg(state, STB0899_ACRPRESC, reg); 1211 stb0899_write_reg(state, STB0899_ACRDIV1, div); 1212 break; 1213 case SEC_TONE_OFF: 1214 stb0899_write_reg(state, STB0899_DISEQCOCFG, 0x20); 1215 break; 1216 default: 1217 return -EINVAL; 1218 } 1219 return 0; 1220} 1221 1222int stb0899_i2c_gate_ctrl(struct dvb_frontend *fe, int enable) 1223{ 1224 int i2c_stat; 1225 struct stb0899_state *state = fe->demodulator_priv; 1226 1227 i2c_stat = stb0899_read_reg(state, STB0899_I2CRPT); 1228 if (i2c_stat < 0) 1229 goto err; 1230 1231 if (enable) { 1232 dprintk(state->verbose, FE_DEBUG, 1, "Enabling I2C Repeater ..."); 1233 i2c_stat |= STB0899_I2CTON; 1234 if (stb0899_write_reg(state, STB0899_I2CRPT, i2c_stat) < 0) 1235 goto err; 1236 } else { 1237 dprintk(state->verbose, FE_DEBUG, 1, "Disabling I2C Repeater ..."); 1238 i2c_stat &= ~STB0899_I2CTON; 1239 if (stb0899_write_reg(state, STB0899_I2CRPT, i2c_stat) < 0) 1240 goto err; 1241 } 1242 return 0; 1243err: 1244 dprintk(state->verbose, FE_ERROR, 1, "I2C Repeater control failed"); 1245 return -EREMOTEIO; 1246} 1247 1248 1249static inline void CONVERT32(u32 x, char *str) 1250{ 1251 *str++ = (x >> 24) & 0xff; 1252 *str++ = (x >> 16) & 0xff; 1253 *str++ = (x >> 8) & 0xff; 1254 *str++ = (x >> 0) & 0xff; 1255 *str = '\0'; 1256} 1257 1258static int stb0899_get_dev_id(struct stb0899_state *state) 1259{ 1260 u8 chip_id, release; 1261 u16 id; 1262 u32 demod_ver = 0, fec_ver = 0; 1263 char demod_str[5] = { 0 }; 1264 char fec_str[5] = { 0 }; 1265 1266 id = stb0899_read_reg(state, STB0899_DEV_ID); 1267 dprintk(state->verbose, FE_DEBUG, 1, "ID reg=[0x%02x]", id); 1268 chip_id = STB0899_GETFIELD(CHIP_ID, id); 1269 release = STB0899_GETFIELD(CHIP_REL, id); 1270 1271 dprintk(state->verbose, FE_ERROR, 1, "Device ID=[%d], Release=[%d]", 1272 chip_id, release); 1273 1274 CONVERT32(STB0899_READ_S2REG(STB0899_S2DEMOD, DMD_CORE_ID), (char *)&demod_str); 1275 1276 demod_ver = STB0899_READ_S2REG(STB0899_S2DEMOD, DMD_VERSION_ID); 1277 dprintk(state->verbose, FE_ERROR, 1, "Demodulator Core ID=[%s], Version=[%d]", (char *) &demod_str, demod_ver); 1278 CONVERT32(STB0899_READ_S2REG(STB0899_S2FEC, FEC_CORE_ID_REG), (char *)&fec_str); 1279 fec_ver = STB0899_READ_S2REG(STB0899_S2FEC, FEC_VER_ID_REG); 1280 if (! (chip_id > 0)) { 1281 dprintk(state->verbose, FE_ERROR, 1, "couldn't find a STB 0899"); 1282 1283 return -ENODEV; 1284 } 1285 dprintk(state->verbose, FE_ERROR, 1, "FEC Core ID=[%s], Version=[%d]", (char*) &fec_str, fec_ver); 1286 1287 return 0; 1288} 1289 1290static void stb0899_set_delivery(struct stb0899_state *state) 1291{ 1292 u8 reg; 1293 u8 stop_clk[2]; 1294 1295 stop_clk[0] = stb0899_read_reg(state, STB0899_STOPCLK1); 1296 stop_clk[1] = stb0899_read_reg(state, STB0899_STOPCLK2); 1297 1298 switch (state->delsys) { 1299 case SYS_DVBS: 1300 dprintk(state->verbose, FE_DEBUG, 1, "Delivery System -- DVB-S"); 1301 /* FECM/Viterbi ON */ 1302 reg = stb0899_read_reg(state, STB0899_FECM); 1303 STB0899_SETFIELD_VAL(FECM_RSVD0, reg, 0); 1304 STB0899_SETFIELD_VAL(FECM_VITERBI_ON, reg, 1); 1305 stb0899_write_reg(state, STB0899_FECM, reg); 1306 1307 stb0899_write_reg(state, STB0899_RSULC, 0xb1); 1308 stb0899_write_reg(state, STB0899_TSULC, 0x40); 1309 stb0899_write_reg(state, STB0899_RSLLC, 0x42); 1310 stb0899_write_reg(state, STB0899_TSLPL, 0x12); 1311 1312 reg = stb0899_read_reg(state, STB0899_TSTRES); 1313 STB0899_SETFIELD_VAL(FRESLDPC, reg, 1); 1314 stb0899_write_reg(state, STB0899_TSTRES, reg); 1315 1316 STB0899_SETFIELD_VAL(STOP_CHK8PSK, stop_clk[0], 1); 1317 STB0899_SETFIELD_VAL(STOP_CKFEC108, stop_clk[0], 1); 1318 STB0899_SETFIELD_VAL(STOP_CKFEC216, stop_clk[0], 1); 1319 1320 STB0899_SETFIELD_VAL(STOP_CKPKDLIN108, stop_clk[1], 1); 1321 STB0899_SETFIELD_VAL(STOP_CKPKDLIN216, stop_clk[1], 1); 1322 1323 STB0899_SETFIELD_VAL(STOP_CKINTBUF216, stop_clk[0], 1); 1324 STB0899_SETFIELD_VAL(STOP_CKCORE216, stop_clk[0], 0); 1325 1326 STB0899_SETFIELD_VAL(STOP_CKS2DMD108, stop_clk[1], 1); 1327 break; 1328 case SYS_DVBS2: 1329 /* FECM/Viterbi OFF */ 1330 reg = stb0899_read_reg(state, STB0899_FECM); 1331 STB0899_SETFIELD_VAL(FECM_RSVD0, reg, 0); 1332 STB0899_SETFIELD_VAL(FECM_VITERBI_ON, reg, 0); 1333 stb0899_write_reg(state, STB0899_FECM, reg); 1334 1335 stb0899_write_reg(state, STB0899_RSULC, 0xb1); 1336 stb0899_write_reg(state, STB0899_TSULC, 0x42); 1337 stb0899_write_reg(state, STB0899_RSLLC, 0x40); 1338 stb0899_write_reg(state, STB0899_TSLPL, 0x02); 1339 1340 reg = stb0899_read_reg(state, STB0899_TSTRES); 1341 STB0899_SETFIELD_VAL(FRESLDPC, reg, 0); 1342 stb0899_write_reg(state, STB0899_TSTRES, reg); 1343 1344 STB0899_SETFIELD_VAL(STOP_CHK8PSK, stop_clk[0], 1); 1345 STB0899_SETFIELD_VAL(STOP_CKFEC108, stop_clk[0], 0); 1346 STB0899_SETFIELD_VAL(STOP_CKFEC216, stop_clk[0], 0); 1347 1348 STB0899_SETFIELD_VAL(STOP_CKPKDLIN108, stop_clk[1], 0); 1349 STB0899_SETFIELD_VAL(STOP_CKPKDLIN216, stop_clk[1], 0); 1350 1351 STB0899_SETFIELD_VAL(STOP_CKINTBUF216, stop_clk[0], 0); 1352 STB0899_SETFIELD_VAL(STOP_CKCORE216, stop_clk[0], 0); 1353 1354 STB0899_SETFIELD_VAL(STOP_CKS2DMD108, stop_clk[1], 0); 1355 break; 1356 case SYS_DSS: 1357 /* FECM/Viterbi ON */ 1358 reg = stb0899_read_reg(state, STB0899_FECM); 1359 STB0899_SETFIELD_VAL(FECM_RSVD0, reg, 1); 1360 STB0899_SETFIELD_VAL(FECM_VITERBI_ON, reg, 1); 1361 stb0899_write_reg(state, STB0899_FECM, reg); 1362 1363 stb0899_write_reg(state, STB0899_RSULC, 0xa1); 1364 stb0899_write_reg(state, STB0899_TSULC, 0x61); 1365 stb0899_write_reg(state, STB0899_RSLLC, 0x42); 1366 1367 reg = stb0899_read_reg(state, STB0899_TSTRES); 1368 STB0899_SETFIELD_VAL(FRESLDPC, reg, 1); 1369 stb0899_write_reg(state, STB0899_TSTRES, reg); 1370 1371 STB0899_SETFIELD_VAL(STOP_CHK8PSK, stop_clk[0], 1); 1372 STB0899_SETFIELD_VAL(STOP_CKFEC108, stop_clk[0], 1); 1373 STB0899_SETFIELD_VAL(STOP_CKFEC216, stop_clk[0], 1); 1374 1375 STB0899_SETFIELD_VAL(STOP_CKPKDLIN108, stop_clk[1], 1); 1376 STB0899_SETFIELD_VAL(STOP_CKPKDLIN216, stop_clk[1], 1); 1377 1378 STB0899_SETFIELD_VAL(STOP_CKCORE216, stop_clk[0], 0); 1379 1380 STB0899_SETFIELD_VAL(STOP_CKS2DMD108, stop_clk[1], 1); 1381 break; 1382 default: 1383 dprintk(state->verbose, FE_ERROR, 1, "Unsupported delivery system"); 1384 break; 1385 } 1386 STB0899_SETFIELD_VAL(STOP_CKADCI108, stop_clk[0], 0); 1387 stb0899_write_regs(state, STB0899_STOPCLK1, stop_clk, 2); 1388} 1389 1390/* 1391 * stb0899_set_iterations 1392 * set the LDPC iteration scale function 1393 */ 1394static void stb0899_set_iterations(struct stb0899_state *state) 1395{ 1396 struct stb0899_internal *internal = &state->internal; 1397 struct stb0899_config *config = state->config; 1398 1399 s32 iter_scale; 1400 u32 reg; 1401 1402 iter_scale = 17 * (internal->master_clk / 1000); 1403 iter_scale += 410000; 1404 iter_scale /= (internal->srate / 1000000); 1405 iter_scale /= 1000; 1406 1407 if (iter_scale > config->ldpc_max_iter) 1408 iter_scale = config->ldpc_max_iter; 1409 1410 reg = STB0899_READ_S2REG(STB0899_S2FEC, MAX_ITER); 1411 STB0899_SETFIELD_VAL(MAX_ITERATIONS, reg, iter_scale); 1412 stb0899_write_s2reg(state, STB0899_S2FEC, STB0899_BASE_MAX_ITER, STB0899_OFF0_MAX_ITER, reg); 1413} 1414 1415static enum dvbfe_search stb0899_search(struct dvb_frontend *fe) 1416{ 1417 struct stb0899_state *state = fe->demodulator_priv; 1418 struct stb0899_params *i_params = &state->params; 1419 struct stb0899_internal *internal = &state->internal; 1420 struct stb0899_config *config = state->config; 1421 struct dtv_frontend_properties *props = &fe->dtv_property_cache; 1422 1423 u32 SearchRange, gain; 1424 1425 i_params->freq = props->frequency; 1426 i_params->srate = props->symbol_rate; 1427 state->delsys = props->delivery_system; 1428 dprintk(state->verbose, FE_DEBUG, 1, "delivery system=%d", state->delsys); 1429 1430 SearchRange = 10000000; 1431 dprintk(state->verbose, FE_DEBUG, 1, "Frequency=%d, Srate=%d", i_params->freq, i_params->srate); 1432 /* checking Search Range is meaningless for a fixed 3 Mhz */ 1433 if (INRANGE(i_params->srate, 1000000, 45000000)) { 1434 dprintk(state->verbose, FE_DEBUG, 1, "Parameters IN RANGE"); 1435 stb0899_set_delivery(state); 1436 1437 if (state->config->tuner_set_rfsiggain) { 1438 if (internal->srate > 15000000) 1439 gain = 8; /* 15Mb < srate < 45Mb, gain = 8dB */ 1440 else if (internal->srate > 5000000) 1441 gain = 12; /* 5Mb < srate < 15Mb, gain = 12dB */ 1442 else 1443 gain = 14; /* 1Mb < srate < 5Mb, gain = 14db */ 1444 state->config->tuner_set_rfsiggain(fe, gain); 1445 } 1446 1447 if (i_params->srate <= 5000000) 1448 stb0899_set_mclk(state, config->lo_clk); 1449 else 1450 stb0899_set_mclk(state, config->hi_clk); 1451 1452 switch (state->delsys) { 1453 case SYS_DVBS: 1454 case SYS_DSS: 1455 dprintk(state->verbose, FE_DEBUG, 1, "DVB-S delivery system"); 1456 internal->freq = i_params->freq; 1457 internal->srate = i_params->srate; 1458 /* 1459 * search = user search range + 1460 * 500Khz + 1461 * 2 * Tuner_step_size + 1462 * 10% of the symbol rate 1463 */ 1464 internal->srch_range = SearchRange + 1500000 + (i_params->srate / 5); 1465 internal->derot_percent = 30; 1466 1467 /* What to do for tuners having no bandwidth setup ? */ 1468 /* enable tuner I/O */ 1469 stb0899_i2c_gate_ctrl(&state->frontend, 1); 1470 1471 if (state->config->tuner_set_bandwidth) 1472 state->config->tuner_set_bandwidth(fe, (13 * (stb0899_carr_width(state) + SearchRange)) / 10); 1473 if (state->config->tuner_get_bandwidth) 1474 state->config->tuner_get_bandwidth(fe, &internal->tuner_bw); 1475 1476 /* disable tuner I/O */ 1477 stb0899_i2c_gate_ctrl(&state->frontend, 0); 1478 1479 /* Set DVB-S1 AGC */ 1480 stb0899_write_reg(state, STB0899_AGCRFCFG, 0x11); 1481 1482 /* Run the search algorithm */ 1483 dprintk(state->verbose, FE_DEBUG, 1, "running DVB-S search algo .."); 1484 if (stb0899_dvbs_algo(state) == RANGEOK) { 1485 internal->lock = 1; 1486 dprintk(state->verbose, FE_DEBUG, 1, 1487 "-------------------------------------> DVB-S LOCK !"); 1488 1489// stb0899_write_reg(state, STB0899_ERRCTRL1, 0x3d); /* Viterbi Errors */ 1490// internal->v_status = stb0899_read_reg(state, STB0899_VSTATUS); 1491// internal->err_ctrl = stb0899_read_reg(state, STB0899_ERRCTRL1); 1492// dprintk(state->verbose, FE_DEBUG, 1, "VSTATUS=0x%02x", internal->v_status); 1493// dprintk(state->verbose, FE_DEBUG, 1, "ERR_CTRL=0x%02x", internal->err_ctrl); 1494 1495 return DVBFE_ALGO_SEARCH_SUCCESS; 1496 } else { 1497 internal->lock = 0; 1498 1499 return DVBFE_ALGO_SEARCH_FAILED; 1500 } 1501 break; 1502 case SYS_DVBS2: 1503 internal->freq = i_params->freq; 1504 internal->srate = i_params->srate; 1505 internal->srch_range = SearchRange; 1506 1507 /* enable tuner I/O */ 1508 stb0899_i2c_gate_ctrl(&state->frontend, 1); 1509 1510 if (state->config->tuner_set_bandwidth) 1511 state->config->tuner_set_bandwidth(fe, (stb0899_carr_width(state) + SearchRange)); 1512 if (state->config->tuner_get_bandwidth) 1513 state->config->tuner_get_bandwidth(fe, &internal->tuner_bw); 1514 1515 /* disable tuner I/O */ 1516 stb0899_i2c_gate_ctrl(&state->frontend, 0); 1517 1518// pParams->SpectralInv = pSearch->IQ_Inversion; 1519 1520 /* Set DVB-S2 AGC */ 1521 stb0899_write_reg(state, STB0899_AGCRFCFG, 0x1c); 1522 1523 /* Set IterScale =f(MCLK,SYMB) */ 1524 stb0899_set_iterations(state); 1525 1526 /* Run the search algorithm */ 1527 dprintk(state->verbose, FE_DEBUG, 1, "running DVB-S2 search algo .."); 1528 if (stb0899_dvbs2_algo(state) == DVBS2_FEC_LOCK) { 1529 internal->lock = 1; 1530 dprintk(state->verbose, FE_DEBUG, 1, 1531 "-------------------------------------> DVB-S2 LOCK !"); 1532 1533// stb0899_write_reg(state, STB0899_ERRCTRL1, 0xb6); /* Packet Errors */ 1534// internal->v_status = stb0899_read_reg(state, STB0899_VSTATUS); 1535// internal->err_ctrl = stb0899_read_reg(state, STB0899_ERRCTRL1); 1536 1537 return DVBFE_ALGO_SEARCH_SUCCESS; 1538 } else { 1539 internal->lock = 0; 1540 1541 return DVBFE_ALGO_SEARCH_FAILED; 1542 } 1543 break; 1544 default: 1545 dprintk(state->verbose, FE_ERROR, 1, "Unsupported delivery system"); 1546 return DVBFE_ALGO_SEARCH_INVALID; 1547 } 1548 } 1549 1550 return DVBFE_ALGO_SEARCH_ERROR; 1551} 1552 1553static int stb0899_get_frontend(struct dvb_frontend *fe, 1554 struct dtv_frontend_properties *p) 1555{ 1556 struct stb0899_state *state = fe->demodulator_priv; 1557 struct stb0899_internal *internal = &state->internal; 1558 1559 dprintk(state->verbose, FE_DEBUG, 1, "Get params"); 1560 p->symbol_rate = internal->srate; 1561 p->frequency = internal->freq; 1562 1563 return 0; 1564} 1565 1566static enum dvbfe_algo stb0899_frontend_algo(struct dvb_frontend *fe) 1567{ 1568 return DVBFE_ALGO_CUSTOM; 1569} 1570 1571static const struct dvb_frontend_ops stb0899_ops = { 1572 .delsys = { SYS_DVBS, SYS_DVBS2, SYS_DSS }, 1573 .info = { 1574 .name = "STB0899 Multistandard", 1575 .frequency_min_hz = 950 * MHz, 1576 .frequency_max_hz = 2150 * MHz, 1577 .symbol_rate_min = 5000000, 1578 .symbol_rate_max = 45000000, 1579 1580 .caps = FE_CAN_INVERSION_AUTO | 1581 FE_CAN_FEC_AUTO | 1582 FE_CAN_2G_MODULATION | 1583 FE_CAN_QPSK 1584 }, 1585 1586 .detach = stb0899_detach, 1587 .release = stb0899_release, 1588 .init = stb0899_init, 1589 .sleep = stb0899_sleep, 1590// .wakeup = stb0899_wakeup, 1591 1592 .i2c_gate_ctrl = stb0899_i2c_gate_ctrl, 1593 1594 .get_frontend_algo = stb0899_frontend_algo, 1595 .search = stb0899_search, 1596 .get_frontend = stb0899_get_frontend, 1597 1598 1599 .read_status = stb0899_read_status, 1600 .read_snr = stb0899_read_snr, 1601 .read_signal_strength = stb0899_read_signal_strength, 1602 .read_ber = stb0899_read_ber, 1603 1604 .set_voltage = stb0899_set_voltage, 1605 .set_tone = stb0899_set_tone, 1606 1607 .diseqc_send_master_cmd = stb0899_send_diseqc_msg, 1608 .diseqc_recv_slave_reply = stb0899_recv_slave_reply, 1609 .diseqc_send_burst = stb0899_send_diseqc_burst, 1610}; 1611 1612struct dvb_frontend *stb0899_attach(struct stb0899_config *config, struct i2c_adapter *i2c) 1613{ 1614 struct stb0899_state *state = NULL; 1615 1616 state = kzalloc(sizeof (struct stb0899_state), GFP_KERNEL); 1617 if (state == NULL) 1618 goto error; 1619 1620 state->verbose = &verbose; 1621 state->config = config; 1622 state->i2c = i2c; 1623 state->frontend.ops = stb0899_ops; 1624 state->frontend.demodulator_priv = state; 1625 /* use configured inversion as default -- we'll later autodetect inversion */ 1626 state->internal.inversion = config->inversion; 1627 1628 stb0899_wakeup(&state->frontend); 1629 if (stb0899_get_dev_id(state) == -ENODEV) { 1630 printk("%s: Exiting .. !\n", __func__); 1631 goto error; 1632 } 1633 1634 printk("%s: Attaching STB0899 \n", __func__); 1635 return &state->frontend; 1636 1637error: 1638 kfree(state); 1639 return NULL; 1640} 1641EXPORT_SYMBOL_GPL(stb0899_attach); 1642MODULE_PARM_DESC(verbose, "Set Verbosity level"); 1643MODULE_AUTHOR("Manu Abraham"); 1644MODULE_DESCRIPTION("STB0899 Multi-Std frontend"); 1645MODULE_LICENSE("GPL"); 1646