drivers/media/dvb-frontends/stb0899_drv.c

   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
  27 static unsigned int verbose = 0;//1;
  28 module_param(verbose, int, 0644);
  29
  30 /* C/N in dB/10, NIRM/NIRL */
  31 static 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  */
  61 static 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  */
 102 static 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*/
 130 static 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 */
 173 static 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
 213 static 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
 250 int 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
 267 u32 _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
 363 err:
 364         return status < 0 ? status : -EREMOTEIO;
 365 }
 366
 367 int 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
 436 err:
 437         return status < 0 ? status : -EREMOTEIO;
 438 }
 439
 440 int 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;
 480 err:
 481         return status < 0 ? status : -EREMOTEIO;
 482 }
 483
 484 int 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
 528 int 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  */
 539 static 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  */
 556 static 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
 571 static 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
 593 static 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
 601 static 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  */
 613 static 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  */
 628 static 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
 668 static 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
 686 static 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
 712 static 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
 729 static 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;
 756 exit:
 757
 758         return result;
 759 }
 760
 761 static 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
 777 static 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
 816 static 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
 845 static 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
 858 static 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
 877 static 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
 922 static 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
 948 static 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
 992 static 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
1049 static 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  */
1120 static 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
1164 static 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
1192 static 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
1222 int 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;
1243 err:
1244         dprintk(state->verbose, FE_ERROR, 1, "I2C Repeater control failed");
1245         return -EREMOTEIO;
1246 }
1247
1248
1249 static 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
1258 static 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
1290 static 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  */
1394 static 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
1415 static 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
1553 static 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
1566 static enum dvbfe_algo stb0899_frontend_algo(struct dvb_frontend *fe)
1567 {
1568         return DVBFE_ALGO_CUSTOM;
1569 }
1570
1571 static 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
1612 struct 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
1637 error:
1638         kfree(state);
1639         return NULL;
1640 }
1641 EXPORT_SYMBOL_GPL(stb0899_attach);
1642 MODULE_PARM_DESC(verbose, "Set Verbosity level");
1643 MODULE_AUTHOR("Manu Abraham");
1644 MODULE_DESCRIPTION("STB0899 Multi-Std frontend");
1645 MODULE_LICENSE("GPL");