LXR linux/drivers/media/dvb/frontends/stv090x.c

   1/*
   2        STV0900/0903 Multistandard Broadcast Frontend driver
   3        Copyright (C) Manu Abraham <abraham.manu@gmail.com>
   4
   5        Copyright (C) ST Microelectronics
   6
   7        This program is free software; you can redistribute it and/or modify
   8        it under the terms of the GNU General Public License as published by
   9        the Free Software Foundation; either version 2 of the License, or
  10        (at your option) any later version.
  11
  12        This program is distributed in the hope that it will be useful,
  13        but WITHOUT ANY WARRANTY; without even the implied warranty of
  14        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15        GNU General Public License for more details.
  16
  17        You should have received a copy of the GNU General Public License
  18        along with this program; if not, write to the Free Software
  19        Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20*/
  21
  22#include <linux/init.h>
  23#include <linux/kernel.h>
  24#include <linux/module.h>
  25#include <linux/string.h>
  26#include <linux/mutex.h>
  27
  28#include <linux/dvb/frontend.h>
  29#include "dvb_frontend.h"
  30
  31#include "stv6110x.h" /* for demodulator internal modes */
  32
  33#include "stv090x_reg.h"
  34#include "stv090x.h"
  35#include "stv090x_priv.h"
  36
  37static unsigned int verbose;
  38module_param(verbose, int, 0644);
  39
  40struct mutex demod_lock;
  41
  42/* DVBS1 and DSS C/N Lookup table */
  43static const struct stv090x_tab stv090x_s1cn_tab[] = {
  44        {   0, 8917 }, /*  0.0dB */
  45        {   5, 8801 }, /*  0.5dB */
  46        {  10, 8667 }, /*  1.0dB */
  47        {  15, 8522 }, /*  1.5dB */
  48        {  20, 8355 }, /*  2.0dB */
  49        {  25, 8175 }, /*  2.5dB */
  50        {  30, 7979 }, /*  3.0dB */
  51        {  35, 7763 }, /*  3.5dB */
  52        {  40, 7530 }, /*  4.0dB */
  53        {  45, 7282 }, /*  4.5dB */
  54        {  50, 7026 }, /*  5.0dB */
  55        {  55, 6781 }, /*  5.5dB */
  56        {  60, 6514 }, /*  6.0dB */
  57        {  65, 6241 }, /*  6.5dB */
  58        {  70, 5965 }, /*  7.0dB */
  59        {  75, 5690 }, /*  7.5dB */
  60        {  80, 5424 }, /*  8.0dB */
  61        {  85, 5161 }, /*  8.5dB */
  62        {  90, 4902 }, /*  9.0dB */
  63        {  95, 4654 }, /*  9.5dB */
  64        { 100, 4417 }, /* 10.0dB */
  65        { 105, 4186 }, /* 10.5dB */
  66        { 110, 3968 }, /* 11.0dB */
  67        { 115, 3757 }, /* 11.5dB */
  68        { 120, 3558 }, /* 12.0dB */
  69        { 125, 3366 }, /* 12.5dB */
  70        { 130, 3185 }, /* 13.0dB */
  71        { 135, 3012 }, /* 13.5dB */
  72        { 140, 2850 }, /* 14.0dB */
  73        { 145, 2698 }, /* 14.5dB */
  74        { 150, 2550 }, /* 15.0dB */
  75        { 160, 2283 }, /* 16.0dB */
  76        { 170, 2042 }, /* 17.0dB */
  77        { 180, 1827 }, /* 18.0dB */
  78        { 190, 1636 }, /* 19.0dB */
  79        { 200, 1466 }, /* 20.0dB */
  80        { 210, 1315 }, /* 21.0dB */
  81        { 220, 1181 }, /* 22.0dB */
  82        { 230, 1064 }, /* 23.0dB */
  83        { 240,  960 }, /* 24.0dB */
  84        { 250,  869 }, /* 25.0dB */
  85        { 260,  792 }, /* 26.0dB */
  86        { 270,  724 }, /* 27.0dB */
  87        { 280,  665 }, /* 28.0dB */
  88        { 290,  616 }, /* 29.0dB */
  89        { 300,  573 }, /* 30.0dB */
  90        { 310,  537 }, /* 31.0dB */
  91        { 320,  507 }, /* 32.0dB */
  92        { 330,  483 }, /* 33.0dB */
  93        { 400,  398 }, /* 40.0dB */
  94        { 450,  381 }, /* 45.0dB */
  95        { 500,  377 }  /* 50.0dB */
  96};
  97
  98/* DVBS2 C/N Lookup table */
  99static const struct stv090x_tab stv090x_s2cn_tab[] = {
 100        { -30, 13348 }, /* -3.0dB */
 101        { -20, 12640 }, /* -2d.0B */
 102        { -10, 11883 }, /* -1.0dB */
 103        {   0, 11101 }, /* -0.0dB */
 104        {   5, 10718 }, /*  0.5dB */
 105        {  10, 10339 }, /*  1.0dB */
 106        {  15,  9947 }, /*  1.5dB */
 107        {  20,  9552 }, /*  2.0dB */
 108        {  25,  9183 }, /*  2.5dB */
 109        {  30,  8799 }, /*  3.0dB */
 110        {  35,  8422 }, /*  3.5dB */
 111        {  40,  8062 }, /*  4.0dB */
 112        {  45,  7707 }, /*  4.5dB */
 113        {  50,  7353 }, /*  5.0dB */
 114        {  55,  7025 }, /*  5.5dB */
 115        {  60,  6684 }, /*  6.0dB */
 116        {  65,  6331 }, /*  6.5dB */
 117        {  70,  6036 }, /*  7.0dB */
 118        {  75,  5727 }, /*  7.5dB */
 119        {  80,  5437 }, /*  8.0dB */
 120        {  85,  5164 }, /*  8.5dB */
 121        {  90,  4902 }, /*  9.0dB */
 122        {  95,  4653 }, /*  9.5dB */
 123        { 100,  4408 }, /* 10.0dB */
 124        { 105,  4187 }, /* 10.5dB */
 125        { 110,  3961 }, /* 11.0dB */
 126        { 115,  3751 }, /* 11.5dB */
 127        { 120,  3558 }, /* 12.0dB */
 128        { 125,  3368 }, /* 12.5dB */
 129        { 130,  3191 }, /* 13.0dB */
 130        { 135,  3017 }, /* 13.5dB */
 131        { 140,  2862 }, /* 14.0dB */
 132        { 145,  2710 }, /* 14.5dB */
 133        { 150,  2565 }, /* 15.0dB */
 134        { 160,  2300 }, /* 16.0dB */
 135        { 170,  2058 }, /* 17.0dB */
 136        { 180,  1849 }, /* 18.0dB */
 137        { 190,  1663 }, /* 19.0dB */
 138        { 200,  1495 }, /* 20.0dB */
 139        { 210,  1349 }, /* 21.0dB */
 140        { 220,  1222 }, /* 22.0dB */
 141        { 230,  1110 }, /* 23.0dB */
 142        { 240,  1011 }, /* 24.0dB */
 143        { 250,   925 }, /* 25.0dB */
 144        { 260,   853 }, /* 26.0dB */
 145        { 270,   789 }, /* 27.0dB */
 146        { 280,   734 }, /* 28.0dB */
 147        { 290,   690 }, /* 29.0dB */
 148        { 300,   650 }, /* 30.0dB */
 149        { 310,   619 }, /* 31.0dB */
 150        { 320,   593 }, /* 32.0dB */
 151        { 330,   571 }, /* 33.0dB */
 152        { 400,   498 }, /* 40.0dB */
 153        { 450,   484 }, /* 45.0dB */
 154        { 500,   481 }  /* 50.0dB */
 155};
 156
 157/* RF level C/N lookup table */
 158static const struct stv090x_tab stv090x_rf_tab[] = {
 159        {  -5, 0xcaa1 }, /*  -5dBm */
 160        { -10, 0xc229 }, /* -10dBm */
 161        { -15, 0xbb08 }, /* -15dBm */
 162        { -20, 0xb4bc }, /* -20dBm */
 163        { -25, 0xad5a }, /* -25dBm */
 164        { -30, 0xa298 }, /* -30dBm */
 165        { -35, 0x98a8 }, /* -35dBm */
 166        { -40, 0x8389 }, /* -40dBm */
 167        { -45, 0x59be }, /* -45dBm */
 168        { -50, 0x3a14 }, /* -50dBm */
 169        { -55, 0x2d11 }, /* -55dBm */
 170        { -60, 0x210d }, /* -60dBm */
 171        { -65, 0xa14f }, /* -65dBm */
 172        { -70, 0x07aa }  /* -70dBm */
 173};
 174
 175
 176static struct stv090x_reg stv0900_initval[] = {
 177
 178        { STV090x_OUTCFG,               0x00 },
 179        { STV090x_MODECFG,              0xff },
 180        { STV090x_AGCRF1CFG,            0x11 },
 181        { STV090x_AGCRF2CFG,            0x13 },
 182        { STV090x_TSGENERAL1X,          0x14 },
 183        { STV090x_TSTTNR2,              0x21 },
 184        { STV090x_TSTTNR4,              0x21 },
 185        { STV090x_P2_DISTXCTL,          0x22 },
 186        { STV090x_P2_F22TX,             0xc0 },
 187        { STV090x_P2_F22RX,             0xc0 },
 188        { STV090x_P2_DISRXCTL,          0x00 },
 189        { STV090x_P2_DMDCFGMD,          0xF9 },
 190        { STV090x_P2_DEMOD,             0x08 },
 191        { STV090x_P2_DMDCFG3,           0xc4 },
 192        { STV090x_P2_CARFREQ,           0xed },
 193        { STV090x_P2_LDT,               0xd0 },
 194        { STV090x_P2_LDT2,              0xb8 },
 195        { STV090x_P2_TMGCFG,            0xd2 },
 196        { STV090x_P2_TMGTHRISE,         0x20 },
 197        { STV090x_P1_TMGCFG,            0xd2 },
 198
 199        { STV090x_P2_TMGTHFALL,         0x00 },
 200        { STV090x_P2_FECSPY,            0x88 },
 201        { STV090x_P2_FSPYDATA,          0x3a },
 202        { STV090x_P2_FBERCPT4,          0x00 },
 203        { STV090x_P2_FSPYBER,           0x10 },
 204        { STV090x_P2_ERRCTRL1,          0x35 },
 205        { STV090x_P2_ERRCTRL2,          0xc1 },
 206        { STV090x_P2_CFRICFG,           0xf8 },
 207        { STV090x_P2_NOSCFG,            0x1c },
 208        { STV090x_P2_DMDTOM,            0x20 },
 209        { STV090x_P2_CORRELMANT,        0x70 },
 210        { STV090x_P2_CORRELABS,         0x88 },
 211        { STV090x_P2_AGC2O,             0x5b },
 212        { STV090x_P2_AGC2REF,           0x38 },
 213        { STV090x_P2_CARCFG,            0xe4 },
 214        { STV090x_P2_ACLC,              0x1A },
 215        { STV090x_P2_BCLC,              0x09 },
 216        { STV090x_P2_CARHDR,            0x08 },
 217        { STV090x_P2_KREFTMG,           0xc1 },
 218        { STV090x_P2_SFRUPRATIO,        0xf0 },
 219        { STV090x_P2_SFRLOWRATIO,       0x70 },
 220        { STV090x_P2_SFRSTEP,           0x58 },
 221        { STV090x_P2_TMGCFG2,           0x01 },
 222        { STV090x_P2_CAR2CFG,           0x26 },
 223        { STV090x_P2_BCLC2S2Q,          0x86 },
 224        { STV090x_P2_BCLC2S28,          0x86 },
 225        { STV090x_P2_SMAPCOEF7,         0x77 },
 226        { STV090x_P2_SMAPCOEF6,         0x85 },
 227        { STV090x_P2_SMAPCOEF5,         0x77 },
 228        { STV090x_P2_TSCFGL,            0x20 },
 229        { STV090x_P2_DMDCFG2,           0x3b },
 230        { STV090x_P2_MODCODLST0,        0xff },
 231        { STV090x_P2_MODCODLST1,        0xff },
 232        { STV090x_P2_MODCODLST2,        0xff },
 233        { STV090x_P2_MODCODLST3,        0xff },
 234        { STV090x_P2_MODCODLST4,        0xff },
 235        { STV090x_P2_MODCODLST5,        0xff },
 236        { STV090x_P2_MODCODLST6,        0xff },
 237        { STV090x_P2_MODCODLST7,        0xcc },
 238        { STV090x_P2_MODCODLST8,        0xcc },
 239        { STV090x_P2_MODCODLST9,        0xcc },
 240        { STV090x_P2_MODCODLSTA,        0xcc },
 241        { STV090x_P2_MODCODLSTB,        0xcc },
 242        { STV090x_P2_MODCODLSTC,        0xcc },
 243        { STV090x_P2_MODCODLSTD,        0xcc },
 244        { STV090x_P2_MODCODLSTE,        0xcc },
 245        { STV090x_P2_MODCODLSTF,        0xcf },
 246        { STV090x_P1_DISTXCTL,          0x22 },
 247        { STV090x_P1_F22TX,             0xc0 },
 248        { STV090x_P1_F22RX,             0xc0 },
 249        { STV090x_P1_DISRXCTL,          0x00 },
 250        { STV090x_P1_DMDCFGMD,          0xf9 },
 251        { STV090x_P1_DEMOD,             0x08 },
 252        { STV090x_P1_DMDCFG3,           0xc4 },
 253        { STV090x_P1_DMDTOM,            0x20 },
 254        { STV090x_P1_CARFREQ,           0xed },
 255        { STV090x_P1_LDT,               0xd0 },
 256        { STV090x_P1_LDT2,              0xb8 },
 257        { STV090x_P1_TMGCFG,            0xd2 },
 258        { STV090x_P1_TMGTHRISE,         0x20 },
 259        { STV090x_P1_TMGTHFALL,         0x00 },
 260        { STV090x_P1_SFRUPRATIO,        0xf0 },
 261        { STV090x_P1_SFRLOWRATIO,       0x70 },
 262        { STV090x_P1_TSCFGL,            0x20 },
 263        { STV090x_P1_FECSPY,            0x88 },
 264        { STV090x_P1_FSPYDATA,          0x3a },
 265        { STV090x_P1_FBERCPT4,          0x00 },
 266        { STV090x_P1_FSPYBER,           0x10 },
 267        { STV090x_P1_ERRCTRL1,          0x35 },
 268        { STV090x_P1_ERRCTRL2,          0xc1 },
 269        { STV090x_P1_CFRICFG,           0xf8 },
 270        { STV090x_P1_NOSCFG,            0x1c },
 271        { STV090x_P1_CORRELMANT,        0x70 },
 272        { STV090x_P1_CORRELABS,         0x88 },
 273        { STV090x_P1_AGC2O,             0x5b },
 274        { STV090x_P1_AGC2REF,           0x38 },
 275        { STV090x_P1_CARCFG,            0xe4 },
 276        { STV090x_P1_ACLC,              0x1A },
 277        { STV090x_P1_BCLC,              0x09 },
 278        { STV090x_P1_CARHDR,            0x08 },
 279        { STV090x_P1_KREFTMG,           0xc1 },
 280        { STV090x_P1_SFRSTEP,           0x58 },
 281        { STV090x_P1_TMGCFG2,           0x01 },
 282        { STV090x_P1_CAR2CFG,           0x26 },
 283        { STV090x_P1_BCLC2S2Q,          0x86 },
 284        { STV090x_P1_BCLC2S28,          0x86 },
 285        { STV090x_P1_SMAPCOEF7,         0x77 },
 286        { STV090x_P1_SMAPCOEF6,         0x85 },
 287        { STV090x_P1_SMAPCOEF5,         0x77 },
 288        { STV090x_P1_DMDCFG2,           0x3b },
 289        { STV090x_P1_MODCODLST0,        0xff },
 290        { STV090x_P1_MODCODLST1,        0xff },
 291        { STV090x_P1_MODCODLST2,        0xff },
 292        { STV090x_P1_MODCODLST3,        0xff },
 293        { STV090x_P1_MODCODLST4,        0xff },
 294        { STV090x_P1_MODCODLST5,        0xff },
 295        { STV090x_P1_MODCODLST6,        0xff },
 296        { STV090x_P1_MODCODLST7,        0xcc },
 297        { STV090x_P1_MODCODLST8,        0xcc },
 298        { STV090x_P1_MODCODLST9,        0xcc },
 299        { STV090x_P1_MODCODLSTA,        0xcc },
 300        { STV090x_P1_MODCODLSTB,        0xcc },
 301        { STV090x_P1_MODCODLSTC,        0xcc },
 302        { STV090x_P1_MODCODLSTD,        0xcc },
 303        { STV090x_P1_MODCODLSTE,        0xcc },
 304        { STV090x_P1_MODCODLSTF,        0xcf },
 305        { STV090x_GENCFG,               0x1d },
 306        { STV090x_NBITER_NF4,           0x37 },
 307        { STV090x_NBITER_NF5,           0x29 },
 308        { STV090x_NBITER_NF6,           0x37 },
 309        { STV090x_NBITER_NF7,           0x33 },
 310        { STV090x_NBITER_NF8,           0x31 },
 311        { STV090x_NBITER_NF9,           0x2f },
 312        { STV090x_NBITER_NF10,          0x39 },
 313        { STV090x_NBITER_NF11,          0x3a },
 314        { STV090x_NBITER_NF12,          0x29 },
 315        { STV090x_NBITER_NF13,          0x37 },
 316        { STV090x_NBITER_NF14,          0x33 },
 317        { STV090x_NBITER_NF15,          0x2f },
 318        { STV090x_NBITER_NF16,          0x39 },
 319        { STV090x_NBITER_NF17,          0x3a },
 320        { STV090x_NBITERNOERR,          0x04 },
 321        { STV090x_GAINLLR_NF4,          0x0C },
 322        { STV090x_GAINLLR_NF5,          0x0F },
 323        { STV090x_GAINLLR_NF6,          0x11 },
 324        { STV090x_GAINLLR_NF7,          0x14 },
 325        { STV090x_GAINLLR_NF8,          0x17 },
 326        { STV090x_GAINLLR_NF9,          0x19 },
 327        { STV090x_GAINLLR_NF10,         0x20 },
 328        { STV090x_GAINLLR_NF11,         0x21 },
 329        { STV090x_GAINLLR_NF12,         0x0D },
 330        { STV090x_GAINLLR_NF13,         0x0F },
 331        { STV090x_GAINLLR_NF14,         0x13 },
 332        { STV090x_GAINLLR_NF15,         0x1A },
 333        { STV090x_GAINLLR_NF16,         0x1F },
 334        { STV090x_GAINLLR_NF17,         0x21 },
 335        { STV090x_RCCFGH,               0x20 },
 336        { STV090x_P1_FECM,              0x01 }, /* disable DSS modes */
 337        { STV090x_P2_FECM,              0x01 }, /* disable DSS modes */
 338        { STV090x_P1_PRVIT,             0x2F }, /* disable PR 6/7 */
 339        { STV090x_P2_PRVIT,             0x2F }, /* disable PR 6/7 */
 340};
 341
 342static struct stv090x_reg stv0903_initval[] = {
 343        { STV090x_OUTCFG,               0x00 },
 344        { STV090x_AGCRF1CFG,            0x11 },
 345        { STV090x_STOPCLK1,             0x48 },
 346        { STV090x_STOPCLK2,             0x14 },
 347        { STV090x_TSTTNR1,              0x27 },
 348        { STV090x_TSTTNR2,              0x21 },
 349        { STV090x_P1_DISTXCTL,          0x22 },
 350        { STV090x_P1_F22TX,             0xc0 },
 351        { STV090x_P1_F22RX,             0xc0 },
 352        { STV090x_P1_DISRXCTL,          0x00 },
 353        { STV090x_P1_DMDCFGMD,          0xF9 },
 354        { STV090x_P1_DEMOD,             0x08 },
 355        { STV090x_P1_DMDCFG3,           0xc4 },
 356        { STV090x_P1_CARFREQ,           0xed },
 357        { STV090x_P1_TNRCFG2,           0x82 },
 358        { STV090x_P1_LDT,               0xd0 },
 359        { STV090x_P1_LDT2,              0xb8 },
 360        { STV090x_P1_TMGCFG,            0xd2 },
 361        { STV090x_P1_TMGTHRISE,         0x20 },
 362        { STV090x_P1_TMGTHFALL,         0x00 },
 363        { STV090x_P1_SFRUPRATIO,        0xf0 },
 364        { STV090x_P1_SFRLOWRATIO,       0x70 },
 365        { STV090x_P1_TSCFGL,            0x20 },
 366        { STV090x_P1_FECSPY,            0x88 },
 367        { STV090x_P1_FSPYDATA,          0x3a },
 368        { STV090x_P1_FBERCPT4,          0x00 },
 369        { STV090x_P1_FSPYBER,           0x10 },
 370        { STV090x_P1_ERRCTRL1,          0x35 },
 371        { STV090x_P1_ERRCTRL2,          0xc1 },
 372        { STV090x_P1_CFRICFG,           0xf8 },
 373        { STV090x_P1_NOSCFG,            0x1c },
 374        { STV090x_P1_DMDTOM,            0x20 },
 375        { STV090x_P1_CORRELMANT,        0x70 },
 376        { STV090x_P1_CORRELABS,         0x88 },
 377        { STV090x_P1_AGC2O,             0x5b },
 378        { STV090x_P1_AGC2REF,           0x38 },
 379        { STV090x_P1_CARCFG,            0xe4 },
 380        { STV090x_P1_ACLC,              0x1A },
 381        { STV090x_P1_BCLC,              0x09 },
 382        { STV090x_P1_CARHDR,            0x08 },
 383        { STV090x_P1_KREFTMG,           0xc1 },
 384        { STV090x_P1_SFRSTEP,           0x58 },
 385        { STV090x_P1_TMGCFG2,           0x01 },
 386        { STV090x_P1_CAR2CFG,           0x26 },
 387        { STV090x_P1_BCLC2S2Q,          0x86 },
 388        { STV090x_P1_BCLC2S28,          0x86 },
 389        { STV090x_P1_SMAPCOEF7,         0x77 },
 390        { STV090x_P1_SMAPCOEF6,         0x85 },
 391        { STV090x_P1_SMAPCOEF5,         0x77 },
 392        { STV090x_P1_DMDCFG2,           0x3b },
 393        { STV090x_P1_MODCODLST0,        0xff },
 394        { STV090x_P1_MODCODLST1,        0xff },
 395        { STV090x_P1_MODCODLST2,        0xff },
 396        { STV090x_P1_MODCODLST3,        0xff },
 397        { STV090x_P1_MODCODLST4,        0xff },
 398        { STV090x_P1_MODCODLST5,        0xff },
 399        { STV090x_P1_MODCODLST6,        0xff },
 400        { STV090x_P1_MODCODLST7,        0xcc },
 401        { STV090x_P1_MODCODLST8,        0xcc },
 402        { STV090x_P1_MODCODLST9,        0xcc },
 403        { STV090x_P1_MODCODLSTA,        0xcc },
 404        { STV090x_P1_MODCODLSTB,        0xcc },
 405        { STV090x_P1_MODCODLSTC,        0xcc },
 406        { STV090x_P1_MODCODLSTD,        0xcc },
 407        { STV090x_P1_MODCODLSTE,        0xcc },
 408        { STV090x_P1_MODCODLSTF,        0xcf },
 409        { STV090x_GENCFG,               0x1c },
 410        { STV090x_NBITER_NF4,           0x37 },
 411        { STV090x_NBITER_NF5,           0x29 },
 412        { STV090x_NBITER_NF6,           0x37 },
 413        { STV090x_NBITER_NF7,           0x33 },
 414        { STV090x_NBITER_NF8,           0x31 },
 415        { STV090x_NBITER_NF9,           0x2f },
 416        { STV090x_NBITER_NF10,          0x39 },
 417        { STV090x_NBITER_NF11,          0x3a },
 418        { STV090x_NBITER_NF12,          0x29 },
 419        { STV090x_NBITER_NF13,          0x37 },
 420        { STV090x_NBITER_NF14,          0x33 },
 421        { STV090x_NBITER_NF15,          0x2f },
 422        { STV090x_NBITER_NF16,          0x39 },
 423        { STV090x_NBITER_NF17,          0x3a },
 424        { STV090x_NBITERNOERR,          0x04 },
 425        { STV090x_GAINLLR_NF4,          0x0C },
 426        { STV090x_GAINLLR_NF5,          0x0F },
 427        { STV090x_GAINLLR_NF6,          0x11 },
 428        { STV090x_GAINLLR_NF7,          0x14 },
 429        { STV090x_GAINLLR_NF8,          0x17 },
 430        { STV090x_GAINLLR_NF9,          0x19 },
 431        { STV090x_GAINLLR_NF10,         0x20 },
 432        { STV090x_GAINLLR_NF11,         0x21 },
 433        { STV090x_GAINLLR_NF12,         0x0D },
 434        { STV090x_GAINLLR_NF13,         0x0F },
 435        { STV090x_GAINLLR_NF14,         0x13 },
 436        { STV090x_GAINLLR_NF15,         0x1A },
 437        { STV090x_GAINLLR_NF16,         0x1F },
 438        { STV090x_GAINLLR_NF17,         0x21 },
 439        { STV090x_RCCFGH,               0x20 },
 440        { STV090x_P1_FECM,              0x01 }, /*disable the DSS mode */
 441        { STV090x_P1_PRVIT,             0x2f }  /*disable puncture rate 6/7*/
 442};
 443
 444static struct stv090x_reg stv0900_cut20_val[] = {
 445
 446        { STV090x_P2_DMDCFG3,           0xe8 },
 447        { STV090x_P2_DMDCFG4,           0x10 },
 448        { STV090x_P2_CARFREQ,           0x38 },
 449        { STV090x_P2_CARHDR,            0x20 },
 450        { STV090x_P2_KREFTMG,           0x5a },
 451        { STV090x_P2_SMAPCOEF7,         0x06 },
 452        { STV090x_P2_SMAPCOEF6,         0x00 },
 453        { STV090x_P2_SMAPCOEF5,         0x04 },
 454        { STV090x_P2_NOSCFG,            0x0c },
 455        { STV090x_P1_DMDCFG3,           0xe8 },
 456        { STV090x_P1_DMDCFG4,           0x10 },
 457        { STV090x_P1_CARFREQ,           0x38 },
 458        { STV090x_P1_CARHDR,            0x20 },
 459        { STV090x_P1_KREFTMG,           0x5a },
 460        { STV090x_P1_SMAPCOEF7,         0x06 },
 461        { STV090x_P1_SMAPCOEF6,         0x00 },
 462        { STV090x_P1_SMAPCOEF5,         0x04 },
 463        { STV090x_P1_NOSCFG,            0x0c },
 464        { STV090x_GAINLLR_NF4,          0x21 },
 465        { STV090x_GAINLLR_NF5,          0x21 },
 466        { STV090x_GAINLLR_NF6,          0x20 },
 467        { STV090x_GAINLLR_NF7,          0x1F },
 468        { STV090x_GAINLLR_NF8,          0x1E },
 469        { STV090x_GAINLLR_NF9,          0x1E },
 470        { STV090x_GAINLLR_NF10,         0x1D },
 471        { STV090x_GAINLLR_NF11,         0x1B },
 472        { STV090x_GAINLLR_NF12,         0x20 },
 473        { STV090x_GAINLLR_NF13,         0x20 },
 474        { STV090x_GAINLLR_NF14,         0x20 },
 475        { STV090x_GAINLLR_NF15,         0x20 },
 476        { STV090x_GAINLLR_NF16,         0x20 },
 477        { STV090x_GAINLLR_NF17,         0x21 },
 478};
 479
 480static struct stv090x_reg stv0903_cut20_val[] = {
 481        { STV090x_P1_DMDCFG3,           0xe8 },
 482        { STV090x_P1_DMDCFG4,           0x10 },
 483        { STV090x_P1_CARFREQ,           0x38 },
 484        { STV090x_P1_CARHDR,            0x20 },
 485        { STV090x_P1_KREFTMG,           0x5a },
 486        { STV090x_P1_SMAPCOEF7,         0x06 },
 487        { STV090x_P1_SMAPCOEF6,         0x00 },
 488        { STV090x_P1_SMAPCOEF5,         0x04 },
 489        { STV090x_P1_NOSCFG,            0x0c },
 490        { STV090x_GAINLLR_NF4,          0x21 },
 491        { STV090x_GAINLLR_NF5,          0x21 },
 492        { STV090x_GAINLLR_NF6,          0x20 },
 493        { STV090x_GAINLLR_NF7,          0x1F },
 494        { STV090x_GAINLLR_NF8,          0x1E },
 495        { STV090x_GAINLLR_NF9,          0x1E },
 496        { STV090x_GAINLLR_NF10,         0x1D },
 497        { STV090x_GAINLLR_NF11,         0x1B },
 498        { STV090x_GAINLLR_NF12,         0x20 },
 499        { STV090x_GAINLLR_NF13,         0x20 },
 500        { STV090x_GAINLLR_NF14,         0x20 },
 501        { STV090x_GAINLLR_NF15,         0x20 },
 502        { STV090x_GAINLLR_NF16,         0x20 },
 503        { STV090x_GAINLLR_NF17,         0x21 }
 504};
 505
 506/* Cut 2.0 Long Frame Tracking CR loop */
 507static struct stv090x_long_frame_crloop stv090x_s2_crl_cut20[] = {
 508        /* MODCOD  2MPon 2MPoff 5MPon 5MPoff 10MPon 10MPoff 20MPon 20MPoff 30MPon 30MPoff */
 509        { STV090x_QPSK_12,  0x1f, 0x3f, 0x1e, 0x3f, 0x3d, 0x1f, 0x3d, 0x3e, 0x3d, 0x1e },
 510        { STV090x_QPSK_35,  0x2f, 0x3f, 0x2e, 0x2f, 0x3d, 0x0f, 0x0e, 0x2e, 0x3d, 0x0e },
 511        { STV090x_QPSK_23,  0x2f, 0x3f, 0x2e, 0x2f, 0x0e, 0x0f, 0x0e, 0x1e, 0x3d, 0x3d },
 512        { STV090x_QPSK_34,  0x3f, 0x3f, 0x3e, 0x1f, 0x0e, 0x3e, 0x0e, 0x1e, 0x3d, 0x3d },
 513        { STV090x_QPSK_45,  0x3f, 0x3f, 0x3e, 0x1f, 0x0e, 0x3e, 0x0e, 0x1e, 0x3d, 0x3d },
 514        { STV090x_QPSK_56,  0x3f, 0x3f, 0x3e, 0x1f, 0x0e, 0x3e, 0x0e, 0x1e, 0x3d, 0x3d },
 515        { STV090x_QPSK_89,  0x3f, 0x3f, 0x3e, 0x1f, 0x1e, 0x3e, 0x0e, 0x1e, 0x3d, 0x3d },
 516        { STV090x_QPSK_910, 0x3f, 0x3f, 0x3e, 0x1f, 0x1e, 0x3e, 0x0e, 0x1e, 0x3d, 0x3d },
 517        { STV090x_8PSK_35,  0x3c, 0x3e, 0x1c, 0x2e, 0x0c, 0x1e, 0x2b, 0x2d, 0x1b, 0x1d },
 518        { STV090x_8PSK_23,  0x1d, 0x3e, 0x3c, 0x2e, 0x2c, 0x1e, 0x0c, 0x2d, 0x2b, 0x1d },
 519        { STV090x_8PSK_34,  0x0e, 0x3e, 0x3d, 0x2e, 0x0d, 0x1e, 0x2c, 0x2d, 0x0c, 0x1d },
 520        { STV090x_8PSK_56,  0x2e, 0x3e, 0x1e, 0x2e, 0x2d, 0x1e, 0x3c, 0x2d, 0x2c, 0x1d },
 521        { STV090x_8PSK_89,  0x3e, 0x3e, 0x1e, 0x2e, 0x3d, 0x1e, 0x0d, 0x2d, 0x3c, 0x1d },
 522        { STV090x_8PSK_910, 0x3e, 0x3e, 0x1e, 0x2e, 0x3d, 0x1e, 0x1d, 0x2d, 0x0d, 0x1d }
 523};
 524
 525/* Cut 3.0 Long Frame Tracking CR loop */
 526static  struct stv090x_long_frame_crloop stv090x_s2_crl_cut30[] = {
 527        /* MODCOD  2MPon 2MPoff 5MPon 5MPoff 10MPon 10MPoff 20MPon 20MPoff 30MPon 30MPoff */
 528        { STV090x_QPSK_12,  0x3c, 0x2c, 0x0c, 0x2c, 0x1b, 0x2c, 0x1b, 0x1c, 0x0b, 0x3b },
 529        { STV090x_QPSK_35,  0x0d, 0x0d, 0x0c, 0x0d, 0x1b, 0x3c, 0x1b, 0x1c, 0x0b, 0x3b },
 530        { STV090x_QPSK_23,  0x1d, 0x0d, 0x0c, 0x1d, 0x2b, 0x3c, 0x1b, 0x1c, 0x0b, 0x3b },
 531        { STV090x_QPSK_34,  0x1d, 0x1d, 0x0c, 0x1d, 0x2b, 0x3c, 0x1b, 0x1c, 0x0b, 0x3b },
 532        { STV090x_QPSK_45,  0x2d, 0x1d, 0x1c, 0x1d, 0x2b, 0x3c, 0x2b, 0x0c, 0x1b, 0x3b },
 533        { STV090x_QPSK_56,  0x2d, 0x1d, 0x1c, 0x1d, 0x2b, 0x3c, 0x2b, 0x0c, 0x1b, 0x3b },
 534        { STV090x_QPSK_89,  0x3d, 0x2d, 0x1c, 0x1d, 0x3b, 0x3c, 0x2b, 0x0c, 0x1b, 0x3b },
 535        { STV090x_QPSK_910, 0x3d, 0x2d, 0x1c, 0x1d, 0x3b, 0x3c, 0x2b, 0x0c, 0x1b, 0x3b },
 536        { STV090x_8PSK_35,  0x39, 0x29, 0x39, 0x19, 0x19, 0x19, 0x19, 0x19, 0x09, 0x19 },
 537        { STV090x_8PSK_23,  0x2a, 0x39, 0x1a, 0x0a, 0x39, 0x0a, 0x29, 0x39, 0x29, 0x0a },
 538        { STV090x_8PSK_34,  0x2b, 0x3a, 0x1b, 0x1b, 0x3a, 0x1b, 0x1a, 0x0b, 0x1a, 0x3a },
 539        { STV090x_8PSK_56,  0x0c, 0x1b, 0x3b, 0x3b, 0x1b, 0x3b, 0x3a, 0x3b, 0x3a, 0x1b },
 540        { STV090x_8PSK_89,  0x0d, 0x3c, 0x2c, 0x2c, 0x2b, 0x0c, 0x0b, 0x3b, 0x0b, 0x1b },
 541        { STV090x_8PSK_910, 0x0d, 0x0d, 0x2c, 0x3c, 0x3b, 0x1c, 0x0b, 0x3b, 0x0b, 0x1b }
 542};
 543
 544/* Cut 2.0 Long Frame Tracking CR Loop */
 545static struct stv090x_long_frame_crloop stv090x_s2_apsk_crl_cut20[] = {
 546        /* MODCOD  2MPon 2MPoff 5MPon 5MPoff 10MPon 10MPoff 20MPon 20MPoff 30MPon 30MPoff */
 547        { STV090x_16APSK_23,  0x0c, 0x0c, 0x0c, 0x0c, 0x1d, 0x0c, 0x3c, 0x0c, 0x2c, 0x0c },
 548        { STV090x_16APSK_34,  0x0c, 0x0c, 0x0c, 0x0c, 0x0e, 0x0c, 0x2d, 0x0c, 0x1d, 0x0c },
 549        { STV090x_16APSK_45,  0x0c, 0x0c, 0x0c, 0x0c, 0x1e, 0x0c, 0x3d, 0x0c, 0x2d, 0x0c },
 550        { STV090x_16APSK_56,  0x0c, 0x0c, 0x0c, 0x0c, 0x1e, 0x0c, 0x3d, 0x0c, 0x2d, 0x0c },
 551        { STV090x_16APSK_89,  0x0c, 0x0c, 0x0c, 0x0c, 0x2e, 0x0c, 0x0e, 0x0c, 0x3d, 0x0c },
 552        { STV090x_16APSK_910, 0x0c, 0x0c, 0x0c, 0x0c, 0x2e, 0x0c, 0x0e, 0x0c, 0x3d, 0x0c },
 553        { STV090x_32APSK_34,  0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c },
 554        { STV090x_32APSK_45,  0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c },
 555        { STV090x_32APSK_56,  0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c },
 556        { STV090x_32APSK_89,  0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c },
 557        { STV090x_32APSK_910, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c }
 558};
 559
 560/* Cut 3.0 Long Frame Tracking CR Loop */
 561static struct stv090x_long_frame_crloop stv090x_s2_apsk_crl_cut30[] = {
 562        /* MODCOD  2MPon 2MPoff 5MPon 5MPoff 10MPon 10MPoff 20MPon 20MPoff 30MPon 30MPoff */
 563        { STV090x_16APSK_23,  0x0a, 0x0a, 0x0a, 0x0a, 0x1a, 0x0a, 0x3a, 0x0a, 0x2a, 0x0a },
 564        { STV090x_16APSK_34,  0x0a, 0x0a, 0x0a, 0x0a, 0x0b, 0x0a, 0x3b, 0x0a, 0x1b, 0x0a },
 565        { STV090x_16APSK_45,  0x0a, 0x0a, 0x0a, 0x0a, 0x1b, 0x0a, 0x3b, 0x0a, 0x2b, 0x0a },
 566        { STV090x_16APSK_56,  0x0a, 0x0a, 0x0a, 0x0a, 0x1b, 0x0a, 0x3b, 0x0a, 0x2b, 0x0a },
 567        { STV090x_16APSK_89,  0x0a, 0x0a, 0x0a, 0x0a, 0x2b, 0x0a, 0x0c, 0x0a, 0x3b, 0x0a },
 568        { STV090x_16APSK_910, 0x0a, 0x0a, 0x0a, 0x0a, 0x2b, 0x0a, 0x0c, 0x0a, 0x3b, 0x0a },
 569        { STV090x_32APSK_34,  0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a },
 570        { STV090x_32APSK_45,  0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a },
 571        { STV090x_32APSK_56,  0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a },
 572        { STV090x_32APSK_89,  0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a },
 573        { STV090x_32APSK_910, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a }
 574};
 575
 576static struct stv090x_long_frame_crloop stv090x_s2_lowqpsk_crl_cut20[] = {
 577        /* MODCOD  2MPon 2MPoff 5MPon 5MPoff 10MPon 10MPoff 20MPon 20MPoff 30MPon 30MPoff */
 578        { STV090x_QPSK_14,  0x0f, 0x3f, 0x0e, 0x3f, 0x2d, 0x2f, 0x2d, 0x1f, 0x3d, 0x3e },
 579        { STV090x_QPSK_13,  0x0f, 0x3f, 0x0e, 0x3f, 0x2d, 0x2f, 0x3d, 0x0f, 0x3d, 0x2e },
 580        { STV090x_QPSK_25,  0x1f, 0x3f, 0x1e, 0x3f, 0x3d, 0x1f, 0x3d, 0x3e, 0x3d, 0x2e }
 581};
 582
 583static struct stv090x_long_frame_crloop stv090x_s2_lowqpsk_crl_cut30[] = {
 584        /* MODCOD  2MPon 2MPoff 5MPon 5MPoff 10MPon 10MPoff 20MPon 20MPoff 30MPon 30MPoff */
 585        { STV090x_QPSK_14,  0x0c, 0x3c, 0x0b, 0x3c, 0x2a, 0x2c, 0x2a, 0x1c, 0x3a, 0x3b },
 586        { STV090x_QPSK_13,  0x0c, 0x3c, 0x0b, 0x3c, 0x2a, 0x2c, 0x3a, 0x0c, 0x3a, 0x2b },
 587        { STV090x_QPSK_25,  0x1c, 0x3c, 0x1b, 0x3c, 0x3a, 0x1c, 0x3a, 0x3b, 0x3a, 0x2b }
 588};
 589
 590/* Cut 2.0 Short Frame Tracking CR Loop */
 591static struct stv090x_short_frame_crloop stv090x_s2_short_crl_cut20[] = {
 592        /* MODCOD         2M    5M    10M   20M   30M */
 593        { STV090x_QPSK,   0x2f, 0x2e, 0x0e, 0x0e, 0x3d },
 594        { STV090x_8PSK,   0x3e, 0x0e, 0x2d, 0x0d, 0x3c },
 595        { STV090x_16APSK, 0x1e, 0x1e, 0x1e, 0x3d, 0x2d },
 596        { STV090x_32APSK, 0x1e, 0x1e, 0x1e, 0x3d, 0x2d }
 597};
 598
 599/* Cut 3.0 Short Frame Tracking CR Loop */
 600static struct stv090x_short_frame_crloop stv090x_s2_short_crl_cut30[] = {
 601        /* MODCOD         2M    5M    10M   20M   30M */
 602        { STV090x_QPSK,   0x2C, 0x2B, 0x0B, 0x0B, 0x3A },
 603        { STV090x_8PSK,   0x3B, 0x0B, 0x2A, 0x0A, 0x39 },
 604        { STV090x_16APSK, 0x1B, 0x1B, 0x1B, 0x3A, 0x2A },
 605        { STV090x_32APSK, 0x1B, 0x1B, 0x1B, 0x3A, 0x2A }
 606};
 607
 608static inline s32 comp2(s32 __x, s32 __width)
 609{
 610        if (__width == 32)
 611                return __x;
 612        else
 613                return (__x >= (1 << (__width - 1))) ? (__x - (1 << __width)) : __x;
 614}
 615
 616static int stv090x_read_reg(struct stv090x_state *state, unsigned int reg)
 617{
 618        const struct stv090x_config *config = state->config;
 619        int ret;
 620
 621        u8 b0[] = { reg >> 8, reg & 0xff };
 622        u8 buf;
 623
 624        struct i2c_msg msg[] = {
 625                { .addr = config->address, .flags       = 0,            .buf = b0,   .len = 2 },
 626                { .addr = config->address, .flags       = I2C_M_RD,     .buf = &buf, .len = 1 }
 627        };
 628
 629        ret = i2c_transfer(state->i2c, msg, 2);
 630        if (ret != 2) {
 631                if (ret != -ERESTARTSYS)
 632                        dprintk(FE_ERROR, 1,
 633                                "Read error, Reg=[0x%02x], Status=%d",
 634                                reg, ret);
 635
 636                return ret < 0 ? ret : -EREMOTEIO;
 637        }
 638        if (unlikely(*state->verbose >= FE_DEBUGREG))
 639                dprintk(FE_ERROR, 1, "Reg=[0x%02x], data=%02x",
 640                        reg, buf);
 641
 642        return (unsigned int) buf;
 643}
 644
 645static int stv090x_write_regs(struct stv090x_state *state, unsigned int reg, u8 *data, u32 count)
 646{
 647        const struct stv090x_config *config = state->config;
 648        int ret;
 649        u8 buf[2 + count];
 650        struct i2c_msg i2c_msg = { .addr = config->address, .flags = 0, .buf = buf, .len = 2 + count };
 651
 652        buf[0] = reg >> 8;
 653        buf[1] = reg & 0xff;
 654        memcpy(&buf[2], data, count);
 655
 656        if (unlikely(*state->verbose >= FE_DEBUGREG)) {
 657                int i;
 658
 659                printk(KERN_DEBUG "%s [0x%04x]:", __func__, reg);
 660                for (i = 0; i < count; i++)
 661                        printk(" %02x", data[i]);
 662                printk("\n");
 663        }
 664
 665        ret = i2c_transfer(state->i2c, &i2c_msg, 1);
 666        if (ret != 1) {
 667                if (ret != -ERESTARTSYS)
 668                        dprintk(FE_ERROR, 1, "Reg=[0x%04x], Data=[0x%02x ...], Count=%u, Status=%d",
 669                                reg, data[0], count, ret);
 670                return ret < 0 ? ret : -EREMOTEIO;
 671        }
 672
 673        return 0;
 674}
 675
 676static int stv090x_write_reg(struct stv090x_state *state, unsigned int reg, u8 data)
 677{
 678        return stv090x_write_regs(state, reg, &data, 1);
 679}
 680
 681static int stv090x_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
 682{
 683        struct stv090x_state *state = fe->demodulator_priv;
 684        u32 reg;
 685
 686        reg = STV090x_READ_DEMOD(state, I2CRPT);
 687        if (enable) {
 688                dprintk(FE_DEBUG, 1, "Enable Gate");
 689                STV090x_SETFIELD_Px(reg, I2CT_ON_FIELD, 1);
 690                if (STV090x_WRITE_DEMOD(state, I2CRPT, reg) < 0)
 691                        goto err;
 692
 693        } else {
 694                dprintk(FE_DEBUG, 1, "Disable Gate");
 695                STV090x_SETFIELD_Px(reg, I2CT_ON_FIELD, 0);
 696                if ((STV090x_WRITE_DEMOD(state, I2CRPT, reg)) < 0)
 697                        goto err;
 698        }
 699        return 0;
 700err:
 701        dprintk(FE_ERROR, 1, "I/O error");
 702        return -1;
 703}
 704
 705static void stv090x_get_lock_tmg(struct stv090x_state *state)
 706{
 707        switch (state->algo) {
 708        case STV090x_BLIND_SEARCH:
 709                dprintk(FE_DEBUG, 1, "Blind Search");
 710                if (state->srate <= 1500000) {  /*10Msps< SR <=15Msps*/
 711                        state->DemodTimeout = 1500;
 712                        state->FecTimeout = 400;
 713                } else if (state->srate <= 5000000) {  /*10Msps< SR <=15Msps*/
 714                        state->DemodTimeout = 1000;
 715                        state->FecTimeout = 300;
 716                } else {  /*SR >20Msps*/
 717                        state->DemodTimeout = 700;
 718                        state->FecTimeout = 100;
 719                }
 720                break;
 721
 722        case STV090x_COLD_SEARCH:
 723        case STV090x_WARM_SEARCH:
 724        default:
 725                dprintk(FE_DEBUG, 1, "Normal Search");
 726                if (state->srate <= 1000000) {  /*SR <=1Msps*/
 727                        state->DemodTimeout = 4500;
 728                        state->FecTimeout = 1700;
 729                } else if (state->srate <= 2000000) { /*1Msps < SR <= 2Msps */
 730                        state->DemodTimeout = 2500;
 731                        state->FecTimeout = 1100;
 732                } else if (state->srate <= 5000000) { /*2Msps < SR <= 5Msps */
 733                        state->DemodTimeout = 1000;
 734                        state->FecTimeout = 550;
 735                } else if (state->srate <= 10000000) { /*5Msps < SR <= 10Msps */
 736                        state->DemodTimeout = 700;
 737                        state->FecTimeout = 250;
 738                } else if (state->srate <= 20000000) { /*10Msps < SR <= 20Msps */
 739                        state->DemodTimeout = 400;
 740                        state->FecTimeout = 130;
 741                } else {   /*SR >20Msps*/
 742                        state->DemodTimeout = 300;
 743                        state->FecTimeout = 100;
 744                }
 745                break;
 746        }
 747
 748        if (state->algo == STV090x_WARM_SEARCH)
 749                state->DemodTimeout /= 2;
 750}
 751
 752static int stv090x_set_srate(struct stv090x_state *state, u32 srate)
 753{
 754        u32 sym;
 755
 756        if (srate > 60000000) {
 757                sym  = (srate << 4); /* SR * 2^16 / master_clk */
 758                sym /= (state->mclk >> 12);
 759        } else if (srate > 6000000) {
 760                sym  = (srate << 6);
 761                sym /= (state->mclk >> 10);
 762        } else {
 763                sym  = (srate << 9);
 764                sym /= (state->mclk >> 7);
 765        }
 766
 767        if (STV090x_WRITE_DEMOD(state, SFRINIT1, (sym >> 8) & 0x7f) < 0) /* MSB */
 768                goto err;
 769        if (STV090x_WRITE_DEMOD(state, SFRINIT0, (sym & 0xff)) < 0) /* LSB */
 770                goto err;
 771
 772        return 0;
 773err:
 774        dprintk(FE_ERROR, 1, "I/O error");
 775        return -1;
 776}
 777
 778static int stv090x_set_max_srate(struct stv090x_state *state, u32 clk, u32 srate)
 779{
 780        u32 sym;
 781
 782        srate = 105 * (srate / 100);
 783        if (srate > 60000000) {
 784                sym  = (srate << 4); /* SR * 2^16 / master_clk */
 785                sym /= (state->mclk >> 12);
 786        } else if (srate > 6000000) {
 787                sym  = (srate << 6);
 788                sym /= (state->mclk >> 10);
 789        } else {
 790                sym  = (srate << 9);
 791                sym /= (state->mclk >> 7);
 792        }
 793
 794        if (sym < 0x7fff) {
 795                if (STV090x_WRITE_DEMOD(state, SFRUP1, (sym >> 8) & 0x7f) < 0) /* MSB */
 796                        goto err;
 797                if (STV090x_WRITE_DEMOD(state, SFRUP0, sym & 0xff) < 0) /* LSB */
 798                        goto err;
 799        } else {
 800                if (STV090x_WRITE_DEMOD(state, SFRUP1, 0x7f) < 0) /* MSB */
 801                        goto err;
 802                if (STV090x_WRITE_DEMOD(state, SFRUP0, 0xff) < 0) /* LSB */
 803                        goto err;
 804        }
 805
 806        return 0;
 807err:
 808        dprintk(FE_ERROR, 1, "I/O error");
 809        return -1;
 810}
 811
 812static int stv090x_set_min_srate(struct stv090x_state *state, u32 clk, u32 srate)
 813{
 814        u32 sym;
 815
 816        srate = 95 * (srate / 100);
 817        if (srate > 60000000) {
 818                sym  = (srate << 4); /* SR * 2^16 / master_clk */
 819                sym /= (state->mclk >> 12);
 820        } else if (srate > 6000000) {
 821                sym  = (srate << 6);
 822                sym /= (state->mclk >> 10);
 823        } else {
 824                sym  = (srate << 9);
 825                sym /= (state->mclk >> 7);
 826        }
 827
 828        if (STV090x_WRITE_DEMOD(state, SFRLOW1, ((sym >> 8) & 0xff)) < 0) /* MSB */
 829                goto err;
 830        if (STV090x_WRITE_DEMOD(state, SFRLOW0, (sym & 0xff)) < 0) /* LSB */
 831                goto err;
 832        return 0;
 833err:
 834        dprintk(FE_ERROR, 1, "I/O error");
 835        return -1;
 836}
 837
 838static u32 stv090x_car_width(u32 srate, enum stv090x_rolloff rolloff)
 839{
 840        u32 ro;
 841
 842        switch (rolloff) {
 843        case STV090x_RO_20:
 844                ro = 20;
 845                break;
 846        case STV090x_RO_25:
 847                ro = 25;
 848                break;
 849        case STV090x_RO_35:
 850        default:
 851                ro = 35;
 852                break;
 853        }
 854
 855        return srate + (srate * ro) / 100;
 856}
 857
 858static int stv090x_set_vit_thacq(struct stv090x_state *state)
 859{
 860        if (STV090x_WRITE_DEMOD(state, VTH12, 0x96) < 0)
 861                goto err;
 862        if (STV090x_WRITE_DEMOD(state, VTH23, 0x64) < 0)
 863                goto err;
 864        if (STV090x_WRITE_DEMOD(state, VTH34, 0x36) < 0)
 865                goto err;
 866        if (STV090x_WRITE_DEMOD(state, VTH56, 0x23) < 0)
 867                goto err;
 868        if (STV090x_WRITE_DEMOD(state, VTH67, 0x1e) < 0)
 869                goto err;
 870        if (STV090x_WRITE_DEMOD(state, VTH78, 0x19) < 0)
 871                goto err;
 872        return 0;
 873err:
 874        dprintk(FE_ERROR, 1, "I/O error");
 875        return -1;
 876}
 877
 878static int stv090x_set_vit_thtracq(struct stv090x_state *state)
 879{
 880        if (STV090x_WRITE_DEMOD(state, VTH12, 0xd0) < 0)
 881                goto err;
 882        if (STV090x_WRITE_DEMOD(state, VTH23, 0x7d) < 0)
 883                goto err;
 884        if (STV090x_WRITE_DEMOD(state, VTH34, 0x53) < 0)
 885                goto err;
 886        if (STV090x_WRITE_DEMOD(state, VTH56, 0x2f) < 0)
 887                goto err;
 888        if (STV090x_WRITE_DEMOD(state, VTH67, 0x24) < 0)
 889                goto err;
 890        if (STV090x_WRITE_DEMOD(state, VTH78, 0x1f) < 0)
 891                goto err;
 892        return 0;
 893err:
 894        dprintk(FE_ERROR, 1, "I/O error");
 895        return -1;
 896}
 897
 898static int stv090x_set_viterbi(struct stv090x_state *state)
 899{
 900        switch (state->search_mode) {
 901        case STV090x_SEARCH_AUTO:
 902                if (STV090x_WRITE_DEMOD(state, FECM, 0x10) < 0) /* DVB-S and DVB-S2 */
 903                        goto err;
 904                if (STV090x_WRITE_DEMOD(state, PRVIT, 0x3f) < 0) /* all puncture rate */
 905                        goto err;
 906                break;
 907        case STV090x_SEARCH_DVBS1:
 908                if (STV090x_WRITE_DEMOD(state, FECM, 0x00) < 0) /* disable DSS */
 909                        goto err;
 910                switch (state->fec) {
 911                case STV090x_PR12:
 912                        if (STV090x_WRITE_DEMOD(state, PRVIT, 0x01) < 0)
 913                                goto err;
 914                        break;
 915
 916                case STV090x_PR23:
 917                        if (STV090x_WRITE_DEMOD(state, PRVIT, 0x02) < 0)
 918                                goto err;
 919                        break;
 920
 921                case STV090x_PR34:
 922                        if (STV090x_WRITE_DEMOD(state, PRVIT, 0x04) < 0)
 923                                goto err;
 924                        break;
 925
 926                case STV090x_PR56:
 927                        if (STV090x_WRITE_DEMOD(state, PRVIT, 0x08) < 0)
 928                                goto err;
 929                        break;
 930
 931                case STV090x_PR78:
 932                        if (STV090x_WRITE_DEMOD(state, PRVIT, 0x20) < 0)
 933                                goto err;
 934                        break;
 935
 936                default:
 937                        if (STV090x_WRITE_DEMOD(state, PRVIT, 0x2f) < 0) /* all */
 938                                goto err;
 939                        break;
 940                }
 941                break;
 942        case STV090x_SEARCH_DSS:
 943                if (STV090x_WRITE_DEMOD(state, FECM, 0x80) < 0)
 944                        goto err;
 945                switch (state->fec) {
 946                case STV090x_PR12:
 947                        if (STV090x_WRITE_DEMOD(state, PRVIT, 0x01) < 0)
 948                                goto err;
 949                        break;
 950
 951                case STV090x_PR23:
 952                        if (STV090x_WRITE_DEMOD(state, PRVIT, 0x02) < 0)
 953                                goto err;
 954                        break;
 955
 956                case STV090x_PR67:
 957                        if (STV090x_WRITE_DEMOD(state, PRVIT, 0x10) < 0)
 958                                goto err;
 959                        break;
 960
 961                default:
 962                        if (STV090x_WRITE_DEMOD(state, PRVIT, 0x13) < 0) /* 1/2, 2/3, 6/7 */
 963                                goto err;
 964                        break;
 965                }
 966                break;
 967        default:
 968                break;
 969        }
 970        return 0;
 971err:
 972        dprintk(FE_ERROR, 1, "I/O error");
 973        return -1;
 974}
 975
 976static int stv090x_stop_modcod(struct stv090x_state *state)
 977{
 978        if (STV090x_WRITE_DEMOD(state, MODCODLST0, 0xff) < 0)
 979                goto err;
 980        if (STV090x_WRITE_DEMOD(state, MODCODLST1, 0xff) < 0)
 981                goto err;
 982        if (STV090x_WRITE_DEMOD(state, MODCODLST2, 0xff) < 0)
 983                goto err;
 984        if (STV090x_WRITE_DEMOD(state, MODCODLST3, 0xff) < 0)
 985                goto err;
 986        if (STV090x_WRITE_DEMOD(state, MODCODLST4, 0xff) < 0)
 987                goto err;
 988        if (STV090x_WRITE_DEMOD(state, MODCODLST5, 0xff) < 0)
 989                goto err;
 990        if (STV090x_WRITE_DEMOD(state, MODCODLST6, 0xff) < 0)
 991                goto err;
 992        if (STV090x_WRITE_DEMOD(state, MODCODLST7, 0xff) < 0)
 993                goto err;
 994        if (STV090x_WRITE_DEMOD(state, MODCODLST8, 0xff) < 0)
 995                goto err;
 996        if (STV090x_WRITE_DEMOD(state, MODCODLST9, 0xff) < 0)
 997                goto err;
 998        if (STV090x_WRITE_DEMOD(state, MODCODLSTA, 0xff) < 0)
 999                goto err;
1000        if (STV090x_WRITE_DEMOD(state, MODCODLSTB, 0xff) < 0)

1001                goto err;
1002        if (STV090x_WRITE_DEMOD(state, MODCODLSTC, 0xff) < 0)
1003                goto err;
1004        if (STV090x_WRITE_DEMOD(state, MODCODLSTD, 0xff) < 0)
1005                goto err;
1006        if (STV090x_WRITE_DEMOD(state, MODCODLSTE, 0xff) < 0)
1007                goto err;
1008        if (STV090x_WRITE_DEMOD(state, MODCODLSTF, 0xff) < 0)
1009                goto err;
1010        return 0;
1011err:
1012        dprintk(FE_ERROR, 1, "I/O error");
1013        return -1;
1014}
1015
1016static int stv090x_activate_modcod(struct stv090x_state *state)
1017{
1018        if (STV090x_WRITE_DEMOD(state, MODCODLST0, 0xff) < 0)
1019                goto err;
1020        if (STV090x_WRITE_DEMOD(state, MODCODLST1, 0xfc) < 0)
1021                goto err;
1022        if (STV090x_WRITE_DEMOD(state, MODCODLST2, 0xcc) < 0)
1023                goto err;
1024        if (STV090x_WRITE_DEMOD(state, MODCODLST3, 0xcc) < 0)
1025                goto err;
1026        if (STV090x_WRITE_DEMOD(state, MODCODLST4, 0xcc) < 0)
1027                goto err;
1028        if (STV090x_WRITE_DEMOD(state, MODCODLST5, 0xcc) < 0)
1029                goto err;
1030        if (STV090x_WRITE_DEMOD(state, MODCODLST6, 0xcc) < 0)
1031                goto err;
1032        if (STV090x_WRITE_DEMOD(state, MODCODLST7, 0xcc) < 0)
1033                goto err;
1034        if (STV090x_WRITE_DEMOD(state, MODCODLST8, 0xcc) < 0)
1035                goto err;
1036        if (STV090x_WRITE_DEMOD(state, MODCODLST9, 0xcc) < 0)
1037                goto err;
1038        if (STV090x_WRITE_DEMOD(state, MODCODLSTA, 0xcc) < 0)
1039                goto err;
1040        if (STV090x_WRITE_DEMOD(state, MODCODLSTB, 0xcc) < 0)
1041                goto err;
1042        if (STV090x_WRITE_DEMOD(state, MODCODLSTC, 0xcc) < 0)
1043                goto err;
1044        if (STV090x_WRITE_DEMOD(state, MODCODLSTD, 0xcc) < 0)
1045                goto err;
1046        if (STV090x_WRITE_DEMOD(state, MODCODLSTE, 0xcc) < 0)
1047                goto err;
1048        if (STV090x_WRITE_DEMOD(state, MODCODLSTF, 0xcf) < 0)
1049                goto err;
1050
1051        return 0;
1052err:
1053        dprintk(FE_ERROR, 1, "I/O error");
1054        return -1;
1055}
1056
1057static int stv090x_activate_modcod_single(struct stv090x_state *state)
1058{
1059
1060        if (STV090x_WRITE_DEMOD(state, MODCODLST0, 0xff) < 0)
1061                goto err;
1062        if (STV090x_WRITE_DEMOD(state, MODCODLST1, 0xf0) < 0)
1063                goto err;
1064        if (STV090x_WRITE_DEMOD(state, MODCODLST2, 0x00) < 0)
1065                goto err;
1066        if (STV090x_WRITE_DEMOD(state, MODCODLST3, 0x00) < 0)
1067                goto err;
1068        if (STV090x_WRITE_DEMOD(state, MODCODLST4, 0x00) < 0)
1069                goto err;
1070        if (STV090x_WRITE_DEMOD(state, MODCODLST5, 0x00) < 0)
1071                goto err;
1072        if (STV090x_WRITE_DEMOD(state, MODCODLST6, 0x00) < 0)
1073                goto err;
1074        if (STV090x_WRITE_DEMOD(state, MODCODLST7, 0x00) < 0)
1075                goto err;
1076        if (STV090x_WRITE_DEMOD(state, MODCODLST8, 0x00) < 0)
1077                goto err;
1078        if (STV090x_WRITE_DEMOD(state, MODCODLST9, 0x00) < 0)
1079                goto err;
1080        if (STV090x_WRITE_DEMOD(state, MODCODLSTA, 0x00) < 0)
1081                goto err;
1082        if (STV090x_WRITE_DEMOD(state, MODCODLSTB, 0x00) < 0)
1083                goto err;
1084        if (STV090x_WRITE_DEMOD(state, MODCODLSTC, 0x00) < 0)
1085                goto err;
1086        if (STV090x_WRITE_DEMOD(state, MODCODLSTD, 0x00) < 0)
1087                goto err;
1088        if (STV090x_WRITE_DEMOD(state, MODCODLSTE, 0x00) < 0)
1089                goto err;
1090        if (STV090x_WRITE_DEMOD(state, MODCODLSTF, 0x0f) < 0)
1091                goto err;
1092
1093        return 0;
1094
1095err:
1096        dprintk(FE_ERROR, 1, "I/O error");
1097        return -1;
1098}
1099
1100static int stv090x_vitclk_ctl(struct stv090x_state *state, int enable)
1101{
1102        u32 reg;
1103
1104        switch (state->demod) {
1105        case STV090x_DEMODULATOR_0:
1106                mutex_lock(&demod_lock);
1107                reg = stv090x_read_reg(state, STV090x_STOPCLK2);
1108                STV090x_SETFIELD(reg, STOP_CLKVIT1_FIELD, enable);
1109                if (stv090x_write_reg(state, STV090x_STOPCLK2, reg) < 0)
1110                        goto err;
1111                mutex_unlock(&demod_lock);
1112                break;
1113
1114        case STV090x_DEMODULATOR_1:
1115                mutex_lock(&demod_lock);
1116                reg = stv090x_read_reg(state, STV090x_STOPCLK2);
1117                STV090x_SETFIELD(reg, STOP_CLKVIT2_FIELD, enable);
1118                if (stv090x_write_reg(state, STV090x_STOPCLK2, reg) < 0)
1119                        goto err;
1120                mutex_unlock(&demod_lock);
1121                break;
1122
1123        default:
1124                dprintk(FE_ERROR, 1, "Wrong demodulator!");
1125                break;
1126        }
1127        return 0;
1128err:
1129        mutex_unlock(&demod_lock);
1130        dprintk(FE_ERROR, 1, "I/O error");
1131        return -1;
1132}
1133
1134static int stv090x_dvbs_track_crl(struct stv090x_state *state)
1135{
1136        if (state->dev_ver >= 0x30) {
1137                /* Set ACLC BCLC optimised value vs SR */
1138                if (state->srate >= 15000000) {
1139                        if (STV090x_WRITE_DEMOD(state, ACLC, 0x2b) < 0)
1140                                goto err;
1141                        if (STV090x_WRITE_DEMOD(state, BCLC, 0x1a) < 0)
1142                                goto err;
1143                } else if ((state->srate >= 7000000) && (15000000 > state->srate)) {
1144                        if (STV090x_WRITE_DEMOD(state, ACLC, 0x0c) < 0)
1145                                goto err;
1146                        if (STV090x_WRITE_DEMOD(state, BCLC, 0x1b) < 0)
1147                                goto err;
1148                } else if (state->srate < 7000000) {
1149                        if (STV090x_WRITE_DEMOD(state, ACLC, 0x2c) < 0)
1150                                goto err;
1151                        if (STV090x_WRITE_DEMOD(state, BCLC, 0x1c) < 0)
1152                                goto err;
1153                }
1154
1155        } else {
1156                /* Cut 2.0 */
1157                if (STV090x_WRITE_DEMOD(state, ACLC, 0x1a) < 0)
1158                        goto err;
1159                if (STV090x_WRITE_DEMOD(state, BCLC, 0x09) < 0)
1160                        goto err;
1161        }
1162        return 0;
1163err:
1164        dprintk(FE_ERROR, 1, "I/O error");
1165        return -1;
1166}
1167
1168static int stv090x_delivery_search(struct stv090x_state *state)
1169{
1170        u32 reg;
1171
1172        switch (state->search_mode) {
1173        case STV090x_SEARCH_DVBS1:
1174        case STV090x_SEARCH_DSS:
1175                reg = STV090x_READ_DEMOD(state, DMDCFGMD);
1176                STV090x_SETFIELD_Px(reg, DVBS1_ENABLE_FIELD, 1);
1177                STV090x_SETFIELD_Px(reg, DVBS2_ENABLE_FIELD, 0);
1178                if (STV090x_WRITE_DEMOD(state, DMDCFGMD, reg) < 0)
1179                        goto err;
1180
1181                /* Activate Viterbi decoder in legacy search,
1182                 * do not use FRESVIT1, might impact VITERBI2
1183                 */
1184                if (stv090x_vitclk_ctl(state, 0) < 0)
1185                        goto err;
1186
1187                if (stv090x_dvbs_track_crl(state) < 0)
1188                        goto err;
1189
1190                if (STV090x_WRITE_DEMOD(state, CAR2CFG, 0x22) < 0) /* disable DVB-S2 */
1191                        goto err;
1192
1193                if (stv090x_set_vit_thacq(state) < 0)
1194                        goto err;
1195                if (stv090x_set_viterbi(state) < 0)
1196                        goto err;
1197                break;
1198
1199        case STV090x_SEARCH_DVBS2:
1200                reg = STV090x_READ_DEMOD(state, DMDCFGMD);
1201                STV090x_SETFIELD_Px(reg, DVBS1_ENABLE_FIELD, 0);
1202                STV090x_SETFIELD_Px(reg, DVBS2_ENABLE_FIELD, 0);
1203                if (STV090x_WRITE_DEMOD(state, DMDCFGMD, reg) < 0)
1204                        goto err;
1205                STV090x_SETFIELD_Px(reg, DVBS1_ENABLE_FIELD, 1);
1206                STV090x_SETFIELD_Px(reg, DVBS2_ENABLE_FIELD, 1);
1207                if (STV090x_WRITE_DEMOD(state, DMDCFGMD, reg) < 0)
1208                        goto err;
1209
1210                if (stv090x_vitclk_ctl(state, 1) < 0)
1211                        goto err;
1212
1213                if (STV090x_WRITE_DEMOD(state, ACLC, 0x1a) < 0) /* stop DVB-S CR loop */
1214                        goto err;
1215                if (STV090x_WRITE_DEMOD(state, BCLC, 0x09) < 0)
1216                        goto err;
1217
1218                if (state->dev_ver <= 0x20) {
1219                        /* enable S2 carrier loop */
1220                        if (STV090x_WRITE_DEMOD(state, CAR2CFG, 0x26) < 0)
1221                                goto err;
1222                } else {
1223                        /* > Cut 3: Stop carrier 3 */
1224                        if (STV090x_WRITE_DEMOD(state, CAR2CFG, 0x66) < 0)
1225                                goto err;
1226                }
1227
1228                if (state->demod_mode != STV090x_SINGLE) {
1229                        /* Cut 2: enable link during search */
1230                        if (stv090x_activate_modcod(state) < 0)
1231                                goto err;
1232                } else {
1233                        /* Single demodulator
1234                         * Authorize SHORT and LONG frames,
1235                         * QPSK, 8PSK, 16APSK and 32APSK
1236                         */
1237                        if (stv090x_activate_modcod_single(state) < 0)
1238                                goto err;
1239                }
1240
1241                break;
1242
1243        case STV090x_SEARCH_AUTO:
1244        default:
1245                /* enable DVB-S2 and DVB-S2 in Auto MODE */
1246                reg = STV090x_READ_DEMOD(state, DMDCFGMD);
1247                STV090x_SETFIELD_Px(reg, DVBS1_ENABLE_FIELD, 1);
1248                STV090x_SETFIELD_Px(reg, DVBS2_ENABLE_FIELD, 1);
1249                if (STV090x_WRITE_DEMOD(state, DMDCFGMD, reg) < 0)
1250                        goto err;
1251
1252                if (stv090x_vitclk_ctl(state, 0) < 0)
1253                        goto err;
1254
1255                if (stv090x_dvbs_track_crl(state) < 0)
1256                        goto err;
1257
1258                if (state->dev_ver <= 0x20) {
1259                        /* enable S2 carrier loop */
1260                        if (STV090x_WRITE_DEMOD(state, CAR2CFG, 0x26) < 0)
1261                                goto err;
1262                } else {
1263                        /* > Cut 3: Stop carrier 3 */
1264                        if (STV090x_WRITE_DEMOD(state, CAR2CFG, 0x66) < 0)
1265                                goto err;
1266                }
1267
1268                if (state->demod_mode != STV090x_SINGLE) {
1269                        /* Cut 2: enable link during search */
1270                        if (stv090x_activate_modcod(state) < 0)
1271                                goto err;
1272                } else {
1273                        /* Single demodulator
1274                         * Authorize SHORT and LONG frames,
1275                         * QPSK, 8PSK, 16APSK and 32APSK
1276                         */
1277                        if (stv090x_activate_modcod_single(state) < 0)
1278                                goto err;
1279                }
1280
1281                if (state->srate >= 2000000) {
1282                        /* Srate >= 2MSPS, Viterbi threshold to acquire */
1283                        if (stv090x_set_vit_thacq(state) < 0)
1284                                goto err;
1285                } else {
1286                        /* Srate < 2MSPS, Reset Viterbi thresholdto track
1287                         * and then re-acquire
1288                         */
1289                        if (stv090x_set_vit_thtracq(state) < 0)
1290                                goto err;
1291                }
1292
1293                if (stv090x_set_viterbi(state) < 0)
1294                        goto err;
1295                break;
1296        }
1297        return 0;
1298err:
1299        dprintk(FE_ERROR, 1, "I/O error");
1300        return -1;
1301}
1302
1303static int stv090x_start_search(struct stv090x_state *state)
1304{
1305        u32 reg, freq_abs;
1306        s16 freq;
1307
1308        /* Reset demodulator */
1309        reg = STV090x_READ_DEMOD(state, DMDISTATE);
1310        STV090x_SETFIELD_Px(reg, I2C_DEMOD_MODE_FIELD, 0x1f);
1311        if (STV090x_WRITE_DEMOD(state, DMDISTATE, reg) < 0)
1312                goto err;
1313
1314        if (state->dev_ver <= 0x20) {
1315                if (state->srate <= 5000000) {
1316                        if (STV090x_WRITE_DEMOD(state, CARCFG, 0x44) < 0)
1317                                goto err;
1318                        if (STV090x_WRITE_DEMOD(state, CFRUP1, 0x0f) < 0)
1319                                goto err;
1320                        if (STV090x_WRITE_DEMOD(state, CFRUP1, 0xff) < 0)
1321                                goto err;
1322                        if (STV090x_WRITE_DEMOD(state, CFRLOW1, 0xf0) < 0)
1323                                goto err;
1324                        if (STV090x_WRITE_DEMOD(state, CFRLOW0, 0x00) < 0)
1325                                goto err;
1326
1327                        /*enlarge the timing bandwith for Low SR*/
1328                        if (STV090x_WRITE_DEMOD(state, RTCS2, 0x68) < 0)
1329                                goto err;
1330                } else {
1331                        /* If the symbol rate is >5 Msps
1332                        Set The carrier search up and low to auto mode */
1333                        if (STV090x_WRITE_DEMOD(state, CARCFG, 0xc4) < 0)
1334                                goto err;
1335                        /*reduce the timing bandwith for high SR*/
1336                        if (STV090x_WRITE_DEMOD(state, RTCS2, 0x44) < 0)
1337                                goto err;
1338                }
1339        } else {
1340                /* >= Cut 3 */
1341                if (state->srate <= 5000000) {
1342                        /* enlarge the timing bandwith for Low SR */
1343                        STV090x_WRITE_DEMOD(state, RTCS2, 0x68);
1344                } else {
1345                        /* reduce timing bandwith for high SR */
1346                        STV090x_WRITE_DEMOD(state, RTCS2, 0x44);
1347                }
1348
1349                /* Set CFR min and max to manual mode */
1350                STV090x_WRITE_DEMOD(state, CARCFG, 0x46);
1351
1352                if (state->algo == STV090x_WARM_SEARCH) {
1353                        /* WARM Start
1354                         * CFR min = -1MHz,
1355                         * CFR max = +1MHz
1356                         */
1357                        freq_abs  = 1000 << 16;
1358                        freq_abs /= (state->mclk / 1000);
1359                        freq      = (s16) freq_abs;
1360                } else {
1361                        /* COLD Start
1362                         * CFR min =- (SearchRange / 2 + 600KHz)
1363                         * CFR max = +(SearchRange / 2 + 600KHz)
1364                         * (600KHz for the tuner step size)
1365                         */
1366                        freq_abs  = (state->search_range / 2000) + 600;
1367                        freq_abs  = freq_abs << 16;
1368                        freq_abs /= (state->mclk / 1000);
1369                        freq      = (s16) freq_abs;
1370                }
1371
1372                if (STV090x_WRITE_DEMOD(state, CFRUP1, MSB(freq)) < 0)
1373                        goto err;
1374                if (STV090x_WRITE_DEMOD(state, CFRUP1, LSB(freq)) < 0)
1375                        goto err;
1376
1377                freq *= -1;
1378
1379                if (STV090x_WRITE_DEMOD(state, CFRLOW1, MSB(freq)) < 0)
1380                        goto err;
1381                if (STV090x_WRITE_DEMOD(state, CFRLOW0, LSB(freq)) < 0)
1382                        goto err;
1383
1384        }
1385
1386        if (STV090x_WRITE_DEMOD(state, CFRINIT1, 0) < 0)
1387                goto err;
1388        if (STV090x_WRITE_DEMOD(state, CFRINIT0, 0) < 0)
1389                goto err;
1390
1391        if (state->dev_ver >= 0x20) {
1392                if (STV090x_WRITE_DEMOD(state, EQUALCFG, 0x41) < 0)
1393                        goto err;
1394                if (STV090x_WRITE_DEMOD(state, FFECFG, 0x41) < 0)
1395                        goto err;
1396
1397                if ((state->search_mode == STV090x_DVBS1)       ||
1398                        (state->search_mode == STV090x_DSS)     ||
1399                        (state->search_mode == STV090x_SEARCH_AUTO)) {
1400
1401                        if (STV090x_WRITE_DEMOD(state, VITSCALE, 0x82) < 0)
1402                                goto err;
1403                        if (STV090x_WRITE_DEMOD(state, VAVSRVIT, 0x00) < 0)
1404                                goto err;
1405                }
1406        }
1407
1408        if (STV090x_WRITE_DEMOD(state, SFRSTEP, 0x00) < 0)
1409                goto err;
1410        if (STV090x_WRITE_DEMOD(state, TMGTHRISE, 0xe0) < 0)
1411                goto err;
1412        if (STV090x_WRITE_DEMOD(state, TMGTHFALL, 0xc0) < 0)
1413                goto err;
1414
1415        reg = STV090x_READ_DEMOD(state, DMDCFGMD);
1416        STV090x_SETFIELD_Px(reg, SCAN_ENABLE_FIELD, 0);
1417        STV090x_SETFIELD_Px(reg, CFR_AUTOSCAN_FIELD, 0);
1418        if (STV090x_WRITE_DEMOD(state, DMDCFGMD, reg) < 0)
1419                goto err;
1420        reg = STV090x_READ_DEMOD(state, DMDCFG2);
1421        STV090x_SETFIELD_Px(reg, S1S2_SEQUENTIAL_FIELD, 0x0);
1422        if (STV090x_WRITE_DEMOD(state, DMDCFG2, reg) < 0)
1423                goto err;
1424
1425        if (state->dev_ver >= 0x20) {
1426                /*Frequency offset detector setting*/
1427                if (state->srate < 2000000) {
1428                        if (state->dev_ver <= 0x20) {
1429                                /* Cut 2 */
1430                                if (STV090x_WRITE_DEMOD(state, CARFREQ, 0x39) < 0)
1431                                        goto err;
1432                        } else {
1433                                /* Cut 2 */
1434                                if (STV090x_WRITE_DEMOD(state, CARFREQ, 0x89) < 0)
1435                                        goto err;
1436                        }
1437                        if (STV090x_WRITE_DEMOD(state, CARHDR, 0x40) < 0)
1438                                goto err;
1439                }
1440
1441                if (state->srate < 10000000) {
1442                        if (STV090x_WRITE_DEMOD(state, CARFREQ, 0x4c) < 0)
1443                                goto err;
1444                } else {
1445                        if (STV090x_WRITE_DEMOD(state, CARFREQ, 0x4b) < 0)
1446                                goto err;
1447                }
1448        } else {
1449                if (state->srate < 10000000) {
1450                        if (STV090x_WRITE_DEMOD(state, CARFREQ, 0xef) < 0)
1451                                goto err;
1452                } else {
1453                        if (STV090x_WRITE_DEMOD(state, CARFREQ, 0xed) < 0)
1454                                goto err;
1455                }
1456        }
1457
1458        switch (state->algo) {
1459        case STV090x_WARM_SEARCH:
1460                /* The symbol rate and the exact
1461                 * carrier Frequency are known
1462                 */
1463                if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x1f) < 0)
1464                        goto err;
1465                if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x18) < 0)
1466                        goto err;
1467                break;
1468
1469        case STV090x_COLD_SEARCH:
1470                /* The symbol rate is known */
1471                if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x1f) < 0)
1472                        goto err;
1473                if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x15) < 0)
1474                        goto err;
1475                break;
1476
1477        default:
1478                break;
1479        }
1480        return 0;
1481err:
1482        dprintk(FE_ERROR, 1, "I/O error");
1483        return -1;
1484}
1485
1486static int stv090x_get_agc2_min_level(struct stv090x_state *state)
1487{
1488        u32 agc2_min = 0, agc2 = 0, freq_init, freq_step, reg;
1489        s32 i, j, steps, dir;
1490
1491        if (STV090x_WRITE_DEMOD(state, AGC2REF, 0x38) < 0)
1492                goto err;
1493        reg = STV090x_READ_DEMOD(state, DMDCFGMD);
1494        STV090x_SETFIELD_Px(reg, SCAN_ENABLE_FIELD, 1);
1495        STV090x_SETFIELD_Px(reg, CFR_AUTOSCAN_FIELD, 1);
1496        if (STV090x_WRITE_DEMOD(state, DMDCFGMD, reg) < 0)
1497                goto err;
1498
1499        if (STV090x_WRITE_DEMOD(state, SFRUP1, 0x83) < 0) /* SR = 65 Msps Max */
1500                goto err;
1501        if (STV090x_WRITE_DEMOD(state, SFRUP0, 0xc0) < 0)
1502                goto err;
1503        if (STV090x_WRITE_DEMOD(state, SFRLOW1, 0x82) < 0) /* SR= 400 ksps Min */
1504                goto err;
1505        if (STV090x_WRITE_DEMOD(state, SFRLOW0, 0xa0) < 0)
1506                goto err;
1507        if (STV090x_WRITE_DEMOD(state, DMDTOM, 0x00) < 0) /* stop acq @ coarse carrier state */
1508                goto err;
1509        if (stv090x_set_srate(state, 1000000) < 0)
1510                goto err;
1511
1512        steps  = -1 + state->search_range / 1000000;
1513        steps /= 2;
1514        steps  = (2 * steps) + 1;
1515        if (steps < 0)
1516                steps = 1;
1517
1518        dir = 1;
1519        freq_step = (1000000 * 256) / (state->mclk / 256);
1520        freq_init = 0;
1521
1522        for (i = 0; i < steps; i++) {
1523                if (dir > 0)
1524                        freq_init = freq_init + (freq_step * i);
1525                else
1526                        freq_init = freq_init - (freq_step * i);
1527
1528                dir = -1;
1529
1530                if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x5c) < 0) /* Demod RESET */
1531                        goto err;
1532                if (STV090x_WRITE_DEMOD(state, CFRINIT1, (freq_init >> 8) & 0xff) < 0)
1533                        goto err;
1534                if (STV090x_WRITE_DEMOD(state, CFRINIT0, freq_init & 0xff) < 0)
1535                        goto err;
1536                if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x58) < 0) /* Demod RESET */
1537                        goto err;
1538                msleep(10);
1539                for (j = 0; j < 10; j++) {
1540                        agc2 += STV090x_READ_DEMOD(state, AGC2I1) << 8;
1541                        agc2 |= STV090x_READ_DEMOD(state, AGC2I0);
1542                }
1543                agc2 /= 10;
1544                agc2_min = 0xffff;
1545                if (agc2 < 0xffff)
1546                        agc2_min = agc2;
1547        }
1548
1549        return agc2_min;
1550err:
1551        dprintk(FE_ERROR, 1, "I/O error");
1552        return -1;
1553}
1554
1555static u32 stv090x_get_srate(struct stv090x_state *state, u32 clk)
1556{
1557        u8 r3, r2, r1, r0;
1558        s32 srate, int_1, int_2, tmp_1, tmp_2;
1559
1560        r3 = STV090x_READ_DEMOD(state, SFR3);
1561        r2 = STV090x_READ_DEMOD(state, SFR2);
1562        r1 = STV090x_READ_DEMOD(state, SFR1);
1563        r0 = STV090x_READ_DEMOD(state, SFR0);
1564
1565        srate = ((r3 << 24) | (r2 << 16) | (r1 <<  8) | r0);
1566
1567        int_1 = clk >> 16;
1568        int_2 = srate >> 16;
1569
1570        tmp_1 = clk % 0x10000;
1571        tmp_2 = srate % 0x10000;
1572
1573        srate = (int_1 * int_2) +
1574                ((int_1 * tmp_2) >> 16) +
1575                ((int_2 * tmp_1) >> 16);
1576
1577        return srate;
1578}
1579
1580static u32 stv090x_srate_srch_coarse(struct stv090x_state *state)
1581{
1582        struct dvb_frontend *fe = &state->frontend;
1583
1584        int tmg_lock = 0, i;
1585        s32 tmg_cpt = 0, dir = 1, steps, cur_step = 0, freq;
1586        u32 srate_coarse = 0, agc2 = 0, car_step = 1200, reg;
1587
1588        reg = STV090x_READ_DEMOD(state, DMDISTATE);
1589        STV090x_SETFIELD_Px(reg, I2C_DEMOD_MODE_FIELD, 0x1f); /* Demod RESET */
1590        if (STV090x_WRITE_DEMOD(state, DMDISTATE, reg) < 0)
1591                goto err;
1592        if (STV090x_WRITE_DEMOD(state, TMGCFG, 0x12) < 0)
1593                goto err;
1594        if (STV090x_WRITE_DEMOD(state, TMGTHRISE, 0xf0) < 0)
1595                goto err;
1596        if (STV090x_WRITE_DEMOD(state, TMGTHFALL, 0xe0) < 0)
1597                goto err;
1598        reg = STV090x_READ_DEMOD(state, DMDCFGMD);
1599        STV090x_SETFIELD_Px(reg, SCAN_ENABLE_FIELD, 1);
1600        STV090x_SETFIELD_Px(reg, CFR_AUTOSCAN_FIELD, 1);
1601        if (STV090x_WRITE_DEMOD(state, DMDCFGMD, reg) < 0)
1602                goto err;
1603
1604        if (STV090x_WRITE_DEMOD(state, SFRUP1, 0x83) < 0)
1605                goto err;
1606        if (STV090x_WRITE_DEMOD(state, SFRUP0, 0xc0) < 0)
1607                goto err;
1608        if (STV090x_WRITE_DEMOD(state, SFRLOW1, 0x82) < 0)
1609                goto err;
1610        if (STV090x_WRITE_DEMOD(state, SFRLOW0, 0xa0) < 0)
1611                goto err;
1612        if (STV090x_WRITE_DEMOD(state, DMDTOM, 0x00) < 0)
1613                goto err;
1614        if (STV090x_WRITE_DEMOD(state, AGC2REF, 0x60) < 0)
1615                goto err;
1616
1617        if (state->dev_ver >= 0x30) {
1618                if (STV090x_WRITE_DEMOD(state, CARFREQ, 0x99) < 0)
1619                        goto err;
1620                if (STV090x_WRITE_DEMOD(state, SFRSTEP, 0x95) < 0)
1621                        goto err;
1622
1623        } else if (state->dev_ver >= 0x20) {
1624                if (STV090x_WRITE_DEMOD(state, CARFREQ, 0x6a) < 0)
1625                        goto err;
1626                if (STV090x_WRITE_DEMOD(state, SFRSTEP, 0x95) < 0)
1627                        goto err;
1628        }
1629
1630        if (state->srate <= 2000000)
1631                car_step = 1000;
1632        else if (state->srate <= 5000000)
1633                car_step = 2000;
1634        else if (state->srate <= 12000000)
1635                car_step = 3000;
1636        else
1637                car_step = 5000;
1638
1639        steps  = -1 + ((state->search_range / 1000) / car_step);
1640        steps /= 2;
1641        steps  = (2 * steps) + 1;
1642        if (steps < 0)
1643                steps = 1;
1644        else if (steps > 10) {
1645                steps = 11;
1646                car_step = (state->search_range / 1000) / 10;
1647        }
1648        cur_step = 0;
1649        dir = 1;
1650        freq = state->frequency;
1651
1652        while ((!tmg_lock) && (cur_step < steps)) {
1653                if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x5f) < 0) /* Demod RESET */
1654                        goto err;
1655                reg = STV090x_READ_DEMOD(state, DMDISTATE);
1656                STV090x_SETFIELD_Px(reg, I2C_DEMOD_MODE_FIELD, 0x00); /* trigger acquisition */
1657                if (STV090x_WRITE_DEMOD(state, DMDISTATE, reg) < 0)
1658                        goto err;
1659                msleep(50);
1660                for (i = 0; i < 10; i++) {
1661                        reg = STV090x_READ_DEMOD(state, DSTATUS);
1662                        if (STV090x_GETFIELD_Px(reg, TMGLOCK_QUALITY_FIELD) >= 2)
1663                                tmg_cpt++;
1664                        agc2 += STV090x_READ_DEMOD(state, AGC2I1) << 8;
1665                        agc2 |= STV090x_READ_DEMOD(state, AGC2I0);
1666                }
1667                agc2 /= 10;
1668                srate_coarse = stv090x_get_srate(state, state->mclk);
1669                cur_step++;
1670                dir *= -1;
1671                if ((tmg_cpt >= 5) && (agc2 < 0x1f00) && (srate_coarse < 55000000) && (srate_coarse > 850000))
1672                        tmg_lock = 1;
1673                else if (cur_step < steps) {
1674                        if (dir > 0)
1675                                freq += cur_step * car_step;
1676                        else
1677                                freq -= cur_step * car_step;
1678
1679                        /* Setup tuner */
1680                        if (stv090x_i2c_gate_ctrl(fe, 1) < 0)
1681                                goto err;
1682
1683                        if (state->config->tuner_set_frequency) {
1684                                if (state->config->tuner_set_frequency(fe, state->frequency) < 0)
1685                                        goto err;
1686                        }
1687
1688                        if (state->config->tuner_set_bandwidth) {
1689                                if (state->config->tuner_set_bandwidth(fe, state->tuner_bw) < 0)
1690                                        goto err;
1691                        }
1692
1693                        if (stv090x_i2c_gate_ctrl(fe, 0) < 0)
1694                                goto err;
1695
1696                        msleep(50);
1697
1698                        if (stv090x_i2c_gate_ctrl(fe, 1) < 0)
1699                                goto err;
1700
1701                        if (state->config->tuner_get_status) {
1702                                if (state->config->tuner_get_status(fe, &reg) < 0)
1703                                        goto err;
1704                        }
1705
1706                        if (reg)
1707                                dprintk(FE_DEBUG, 1, "Tuner phase locked");
1708                        else
1709                                dprintk(FE_DEBUG, 1, "Tuner unlocked");
1710
1711                        if (stv090x_i2c_gate_ctrl(fe, 0) < 0)
1712                                goto err;
1713
1714                }
1715        }
1716        if (!tmg_lock)
1717                srate_coarse = 0;
1718        else
1719                srate_coarse = stv090x_get_srate(state, state->mclk);
1720
1721        return srate_coarse;
1722err:
1723        dprintk(FE_ERROR, 1, "I/O error");
1724        return -1;
1725}
1726
1727static u32 stv090x_srate_srch_fine(struct stv090x_state *state)
1728{
1729        u32 srate_coarse, freq_coarse, sym, reg;
1730
1731        srate_coarse = stv090x_get_srate(state, state->mclk);
1732        freq_coarse  = STV090x_READ_DEMOD(state, CFR2) << 8;
1733        freq_coarse |= STV090x_READ_DEMOD(state, CFR1);
1734        sym = 13 * (srate_coarse / 10); /* SFRUP = SFR + 30% */
1735
1736        if (sym < state->srate)
1737                srate_coarse = 0;
1738        else {
1739                if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x1f) < 0) /* Demod RESET */
1740                        goto err;
1741                if (STV090x_WRITE_DEMOD(state, TMGCFG2, 0x01) < 0)
1742                        goto err;
1743                if (STV090x_WRITE_DEMOD(state, TMGTHRISE, 0x20) < 0)
1744                        goto err;
1745                if (STV090x_WRITE_DEMOD(state, TMGTHFALL, 0x00) < 0)
1746                        goto err;
1747                if (STV090x_WRITE_DEMOD(state, TMGCFG, 0xd2) < 0)
1748                        goto err;
1749                reg = STV090x_READ_DEMOD(state, DMDCFGMD);
1750                STV090x_SETFIELD_Px(reg, CFR_AUTOSCAN_FIELD, 0x00);
1751                if (STV090x_WRITE_DEMOD(state, DMDCFGMD, reg) < 0)
1752                        goto err;
1753
1754                if (state->dev_ver >= 0x30) {
1755                        if (STV090x_WRITE_DEMOD(state, CARFREQ, 0x79) < 0)
1756                                goto err;
1757                } else if (state->dev_ver >= 0x20) {
1758                        if (STV090x_WRITE_DEMOD(state, CARFREQ, 0x49) < 0)
1759                                goto err;
1760                }
1761
1762                if (srate_coarse > 3000000) {
1763                        sym  = 13 * (srate_coarse / 10); /* SFRUP = SFR + 30% */
1764                        sym  = (sym / 1000) * 65536;
1765                        sym /= (state->mclk / 1000);
1766                        if (STV090x_WRITE_DEMOD(state, SFRUP1, (sym >> 8) & 0x7f) < 0)
1767                                goto err;
1768                        if (STV090x_WRITE_DEMOD(state, SFRUP0, sym & 0xff) < 0)
1769                                goto err;
1770                        sym  = 10 * (srate_coarse / 13); /* SFRLOW = SFR - 30% */
1771                        sym  = (sym / 1000) * 65536;
1772                        sym /= (state->mclk / 1000);
1773                        if (STV090x_WRITE_DEMOD(state, SFRLOW1, (sym >> 8) & 0x7f) < 0)
1774                                goto err;
1775                        if (STV090x_WRITE_DEMOD(state, SFRLOW0, sym & 0xff) < 0)
1776                                goto err;
1777                        sym  = (srate_coarse / 1000) * 65536;
1778                        sym /= (state->mclk / 1000);
1779                        if (STV090x_WRITE_DEMOD(state, SFRINIT1, (sym >> 8) & 0xff) < 0)
1780                                goto err;
1781                        if (STV090x_WRITE_DEMOD(state, SFRINIT0, sym & 0xff) < 0)
1782                                goto err;
1783                } else {
1784                        sym  = 13 * (srate_coarse / 10); /* SFRUP = SFR + 30% */
1785                        sym  = (sym / 100) * 65536;
1786                        sym /= (state->mclk / 100);
1787                        if (STV090x_WRITE_DEMOD(state, SFRUP1, (sym >> 8) & 0x7f) < 0)
1788                                goto err;
1789                        if (STV090x_WRITE_DEMOD(state, SFRUP0, sym & 0xff) < 0)
1790                                goto err;
1791                        sym  = 10 * (srate_coarse / 14); /* SFRLOW = SFR - 30% */
1792                        sym  = (sym / 100) * 65536;
1793                        sym /= (state->mclk / 100);
1794                        if (STV090x_WRITE_DEMOD(state, SFRLOW1, (sym >> 8) & 0x7f) < 0)
1795                                goto err;
1796                        if (STV090x_WRITE_DEMOD(state, SFRLOW0, sym & 0xff) < 0)
1797                                goto err;
1798                        sym  = (srate_coarse / 100) * 65536;
1799                        sym /= (state->mclk / 100);
1800                        if (STV090x_WRITE_DEMOD(state, SFRINIT1, (sym >> 8) & 0xff) < 0)
1801                                goto err;
1802                        if (STV090x_WRITE_DEMOD(state, SFRINIT0, sym & 0xff) < 0)
1803                                goto err;
1804                }
1805                if (STV090x_WRITE_DEMOD(state, DMDTOM, 0x20) < 0)
1806                        goto err;
1807                if (STV090x_WRITE_DEMOD(state, CFRINIT1, (freq_coarse >> 8) & 0xff) < 0)
1808                        goto err;
1809                if (STV090x_WRITE_DEMOD(state, CFRINIT0, freq_coarse & 0xff) < 0)
1810                        goto err;
1811                if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x15) < 0) /* trigger acquisition */
1812                        goto err;
1813        }
1814
1815        return srate_coarse;
1816
1817err:
1818        dprintk(FE_ERROR, 1, "I/O error");
1819        return -1;
1820}
1821
1822static int stv090x_get_dmdlock(struct stv090x_state *state, s32 timeout)
1823{
1824        s32 timer = 0, lock = 0;
1825        u32 reg;
1826        u8 stat;
1827
1828        while ((timer < timeout) && (!lock)) {
1829                reg = STV090x_READ_DEMOD(state, DMDSTATE);
1830                stat = STV090x_GETFIELD_Px(reg, HEADER_MODE_FIELD);
1831
1832                switch (stat) {
1833                case 0: /* searching */
1834                case 1: /* first PLH detected */
1835                default:
1836                        dprintk(FE_DEBUG, 1, "Demodulator searching ..");
1837                        lock = 0;
1838                        break;
1839                case 2: /* DVB-S2 mode */
1840                case 3: /* DVB-S1/legacy mode */
1841                        reg = STV090x_READ_DEMOD(state, DSTATUS);
1842                        lock = STV090x_GETFIELD_Px(reg, LOCK_DEFINITIF_FIELD);
1843                        break;
1844                }
1845
1846                if (!lock)
1847                        msleep(10);
1848                else
1849                        dprintk(FE_DEBUG, 1, "Demodulator acquired LOCK");
1850
1851                timer += 10;
1852        }
1853        return lock;
1854}
1855
1856static int stv090x_blind_search(struct stv090x_state *state)
1857{
1858        u32 agc2, reg, srate_coarse;
1859        s32 timeout_dmd = 500, cpt_fail, agc2_ovflw, i;
1860        u8 k_ref, k_max, k_min;
1861        int coarse_fail, lock;
1862
1863        k_max = 120;
1864        k_min = 30;
1865
1866        agc2 = stv090x_get_agc2_min_level(state);
1867
1868        if (agc2 > STV090x_SEARCH_AGC2_TH(state->dev_ver)) {
1869                lock = 0;
1870        } else {
1871
1872                if (state->dev_ver <= 0x20) {
1873                        if (STV090x_WRITE_DEMOD(state, CARCFG, 0xc4) < 0)
1874                                goto err;
1875                } else {
1876                        /* > Cut 3 */
1877                        if (STV090x_WRITE_DEMOD(state, CARCFG, 0x06) < 0)
1878                                goto err;
1879                }
1880
1881                if (STV090x_WRITE_DEMOD(state, RTCS2, 0x44) < 0)
1882                        goto err;
1883
1884                if (state->dev_ver >= 0x20) {
1885                        if (STV090x_WRITE_DEMOD(state, EQUALCFG, 0x41) < 0)
1886                                goto err;
1887                        if (STV090x_WRITE_DEMOD(state, FFECFG, 0x41) < 0)
1888                                goto err;
1889                        if (STV090x_WRITE_DEMOD(state, VITSCALE, 0x82) < 0)
1890                                goto err;
1891                        if (STV090x_WRITE_DEMOD(state, VAVSRVIT, 0x00) < 0) /* set viterbi hysteresis */
1892                                goto err;
1893                }
1894
1895                k_ref = k_max;
1896                do {
1897                        if (STV090x_WRITE_DEMOD(state, KREFTMG, k_ref) < 0)
1898                                goto err;
1899                        if (stv090x_srate_srch_coarse(state) != 0) {
1900                                srate_coarse = stv090x_srate_srch_fine(state);
1901                                if (srate_coarse != 0) {
1902                                        stv090x_get_lock_tmg(state);
1903                                        lock = stv090x_get_dmdlock(state, timeout_dmd);
1904                                } else {
1905                                        lock = 0;
1906                                }
1907                        } else {
1908                                cpt_fail = 0;
1909                                agc2_ovflw = 0;
1910                                for (i = 0; i < 10; i++) {
1911                                        agc2  = STV090x_READ_DEMOD(state, AGC2I1) << 8;
1912                                        agc2 |= STV090x_READ_DEMOD(state, AGC2I0);
1913                                        if (agc2 >= 0xff00)
1914                                                agc2_ovflw++;
1915                                        reg = STV090x_READ_DEMOD(state, DSTATUS2);
1916                                        if ((STV090x_GETFIELD_Px(reg, CFR_OVERFLOW_FIELD) == 0x01) &&
1917                                            (STV090x_GETFIELD_Px(reg, DEMOD_DELOCK_FIELD) == 0x01))
1918
1919                                                cpt_fail++;
1920                                }
1921                                if ((cpt_fail > 7) || (agc2_ovflw > 7))
1922                                        coarse_fail = 1;
1923
1924                                lock = 0;
1925                        }
1926                        k_ref -= 30;
1927                } while ((k_ref >= k_min) && (!lock) && (!coarse_fail));
1928        }
1929
1930        return lock;
1931
1932err:
1933        dprintk(FE_ERROR, 1, "I/O error");
1934        return -1;
1935}
1936
1937static int stv090x_chk_tmg(struct stv090x_state *state)
1938{
1939        u32 reg;
1940        s32 tmg_cpt = 0, i;
1941        u8 freq, tmg_thh, tmg_thl;
1942        int tmg_lock;
1943
1944        freq = STV090x_READ_DEMOD(state, CARFREQ);
1945        tmg_thh = STV090x_READ_DEMOD(state, TMGTHRISE);
1946        tmg_thl = STV090x_READ_DEMOD(state, TMGTHFALL);
1947        if (STV090x_WRITE_DEMOD(state, TMGTHRISE, 0x20) < 0)
1948                goto err;
1949        if (STV090x_WRITE_DEMOD(state, TMGTHFALL, 0x00) < 0)
1950                goto err;
1951
1952        reg = STV090x_READ_DEMOD(state, DMDCFGMD);
1953        STV090x_SETFIELD_Px(reg, CFR_AUTOSCAN_FIELD, 0x00); /* stop carrier offset search */
1954        if (STV090x_WRITE_DEMOD(state, DMDCFGMD, reg) < 0)
1955                goto err;
1956        if (STV090x_WRITE_DEMOD(state, RTC, 0x80) < 0)
1957                goto err;
1958
1959        if (STV090x_WRITE_DEMOD(state, RTCS2, 0x40) < 0)
1960                goto err;
1961        if (STV090x_WRITE_DEMOD(state, CARFREQ, 0x00) < 0)
1962                goto err;
1963
1964        if (STV090x_WRITE_DEMOD(state, CFRINIT1, 0x00) < 0) /* set car ofset to 0 */
1965                goto err;
1966        if (STV090x_WRITE_DEMOD(state, CFRINIT0, 0x00) < 0)
1967                goto err;
1968        if (STV090x_WRITE_DEMOD(state, AGC2REF, 0x65) < 0)
1969                goto err;
1970
1971        if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x18) < 0) /* trigger acquisition */
1972                goto err;
1973        msleep(10);
1974
1975        for (i = 0; i < 10; i++) {
1976                reg = STV090x_READ_DEMOD(state, DSTATUS);
1977                if (STV090x_GETFIELD_Px(reg, TMGLOCK_QUALITY_FIELD) >= 2)
1978                        tmg_cpt++;
1979                msleep(1);
1980        }
1981        if (tmg_cpt >= 3)
1982                tmg_lock = 1;
1983
1984        if (STV090x_WRITE_DEMOD(state, AGC2REF, 0x38) < 0)
1985                goto err;
1986        if (STV090x_WRITE_DEMOD(state, RTC, 0x88) < 0) /* DVB-S1 timing */
1987                goto err;
1988        if (STV090x_WRITE_DEMOD(state, RTCS2, 0x68) < 0) /* DVB-S2 timing */
1989                goto err;
1990
1991        if (STV090x_WRITE_DEMOD(state, CARFREQ, freq) < 0)
1992                goto err;
1993        if (STV090x_WRITE_DEMOD(state, TMGTHRISE, tmg_thh) < 0)
1994                goto err;
1995        if (STV090x_WRITE_DEMOD(state, TMGTHFALL, tmg_thl) < 0)
1996                goto err;
1997
1998        return  tmg_lock;
1999
2000err:

2001        dprintk(FE_ERROR, 1, "I/O error");
2002        return -1;
2003}
2004
2005static int stv090x_get_coldlock(struct stv090x_state *state, s32 timeout_dmd)
2006{
2007        struct dvb_frontend *fe = &state->frontend;
2008
2009        u32 reg;
2010        s32 car_step, steps, cur_step, dir, freq, timeout_lock;
2011        int lock = 0;
2012
2013        if (state->srate >= 10000000)
2014                timeout_lock = timeout_dmd / 3;
2015        else
2016                timeout_lock = timeout_dmd / 2;
2017
2018        lock = stv090x_get_dmdlock(state, timeout_lock); /* cold start wait */
2019        if (!lock) {
2020                if (state->srate >= 10000000) {
2021                        if (stv090x_chk_tmg(state)) {
2022                                if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x1f) < 0)
2023                                        goto err;
2024                                if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x15) < 0)
2025                                        goto err;
2026                                lock = stv090x_get_dmdlock(state, timeout_dmd);
2027                        } else {
2028                                lock = 0;
2029                        }
2030                } else {
2031                        if (state->srate <= 4000000)
2032                                car_step = 1000;
2033                        else if (state->srate <= 7000000)
2034                                car_step = 2000;
2035                        else if (state->srate <= 10000000)
2036                                car_step = 3000;
2037                        else
2038                                car_step = 5000;
2039
2040                        steps  = (state->search_range / 1000) / car_step;
2041                        steps /= 2;
2042                        steps  = 2 * (steps + 1);
2043                        if (steps < 0)
2044                                steps = 2;
2045                        else if (steps > 12)
2046                                steps = 12;
2047
2048                        cur_step = 1;
2049                        dir = 1;
2050
2051                        if (!lock) {
2052                                freq = state->frequency;
2053                                state->tuner_bw = stv090x_car_width(state->srate, state->rolloff) + state->srate;
2054                                while ((cur_step <= steps) && (!lock)) {
2055                                        if (dir > 0)
2056                                                freq += cur_step * car_step;
2057                                        else
2058                                                freq -= cur_step * car_step;
2059
2060                                        /* Setup tuner */
2061                                        if (stv090x_i2c_gate_ctrl(fe, 1) < 0)
2062                                                goto err;
2063
2064                                        if (state->config->tuner_set_frequency) {
2065                                                if (state->config->tuner_set_frequency(fe, state->frequency) < 0)
2066                                                        goto err;
2067                                        }
2068
2069                                        if (state->config->tuner_set_bandwidth) {
2070                                                if (state->config->tuner_set_bandwidth(fe, state->tuner_bw) < 0)
2071                                                        goto err;
2072                                        }
2073
2074                                        if (stv090x_i2c_gate_ctrl(fe, 0) < 0)
2075                                                goto err;
2076
2077                                        msleep(50);
2078
2079                                        if (stv090x_i2c_gate_ctrl(fe, 1) < 0)
2080                                                goto err;
2081
2082                                        if (state->config->tuner_get_status) {
2083                                                if (state->config->tuner_get_status(fe, &reg) < 0)
2084                                                        goto err;
2085                                        }
2086
2087                                        if (reg)
2088                                                dprintk(FE_DEBUG, 1, "Tuner phase locked");
2089                                        else
2090                                                dprintk(FE_DEBUG, 1, "Tuner unlocked");
2091
2092                                        if (stv090x_i2c_gate_ctrl(fe, 0) < 0)
2093                                                goto err;
2094
2095                                        STV090x_WRITE_DEMOD(state, DMDISTATE, 0x1c);
2096                                        if (state->delsys == STV090x_DVBS2) {
2097                                                reg = STV090x_READ_DEMOD(state, DMDCFGMD);
2098                                                STV090x_SETFIELD_Px(reg, DVBS1_ENABLE_FIELD, 0);
2099                                                STV090x_SETFIELD_Px(reg, DVBS2_ENABLE_FIELD, 0);
2100                                                if (STV090x_WRITE_DEMOD(state, DMDCFGMD, reg) < 0)
2101                                                        goto err;
2102                                                STV090x_SETFIELD_Px(reg, DVBS1_ENABLE_FIELD, 1);
2103                                                STV090x_SETFIELD_Px(reg, DVBS2_ENABLE_FIELD, 1);
2104                                                if (STV090x_WRITE_DEMOD(state, DMDCFGMD, reg) < 0)
2105                                                        goto err;
2106                                        }
2107                                        if (STV090x_WRITE_DEMOD(state, CFRINIT1, 0x00) < 0)
2108                                                goto err;
2109                                        if (STV090x_WRITE_DEMOD(state, CFRINIT0, 0x00) < 0)
2110                                                goto err;
2111                                        if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x1f) < 0)
2112                                                goto err;
2113                                        if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x15) < 0)
2114                                                goto err;
2115                                        lock = stv090x_get_dmdlock(state, (timeout_dmd / 3));
2116
2117                                        dir *= -1;
2118                                        cur_step++;
2119                                }
2120                        }
2121                }
2122        }
2123
2124        return lock;
2125
2126err:
2127        dprintk(FE_ERROR, 1, "I/O error");
2128        return -1;
2129}
2130
2131static int stv090x_get_loop_params(struct stv090x_state *state, s32 *freq_inc, s32 *timeout_sw, s32 *steps)
2132{
2133        s32 timeout, inc, steps_max, srate, car_max;
2134
2135        srate = state->srate;
2136        car_max = state->search_range / 1000;
2137        car_max += car_max / 10;
2138        car_max  = 65536 * (car_max / 2);
2139        car_max /= (state->mclk / 1000);
2140
2141        if (car_max > 0x4000)
2142                car_max = 0x4000 ; /* maxcarrier should be<= +-1/4 Mclk */
2143
2144        inc  = srate;
2145        inc /= state->mclk / 1000;
2146        inc *= 256;
2147        inc *= 256;
2148        inc /= 1000;
2149
2150        switch (state->search_mode) {
2151        case STV090x_SEARCH_DVBS1:
2152        case STV090x_SEARCH_DSS:
2153                inc *= 3; /* freq step = 3% of srate */
2154                timeout = 20;
2155                break;
2156
2157        case STV090x_SEARCH_DVBS2:
2158                inc *= 4;
2159                timeout = 25;
2160                break;
2161
2162        case STV090x_SEARCH_AUTO:
2163        default:
2164                inc *= 3;
2165                timeout = 25;
2166                break;
2167        }
2168        inc /= 100;
2169        if ((inc > car_max) || (inc < 0))
2170                inc = car_max / 2; /* increment <= 1/8 Mclk */
2171
2172        timeout *= 27500; /* 27.5 Msps reference */
2173        if (srate > 0)
2174                timeout /= (srate / 1000);
2175
2176        if ((timeout > 100) || (timeout < 0))
2177                timeout = 100;
2178
2179        steps_max = (car_max / inc) + 1; /* min steps = 3 */
2180        if ((steps_max > 100) || (steps_max < 0)) {
2181                steps_max = 100; /* max steps <= 100 */
2182                inc = car_max / steps_max;
2183        }
2184        *freq_inc = inc;
2185        *timeout_sw = timeout;
2186        *steps = steps_max;
2187
2188        return 0;
2189}
2190
2191static int stv090x_chk_signal(struct stv090x_state *state)
2192{
2193        s32 offst_car, agc2, car_max;
2194        int no_signal;
2195
2196        offst_car  = STV090x_READ_DEMOD(state, CFR2) << 8;
2197        offst_car |= STV090x_READ_DEMOD(state, CFR1);
2198        offst_car = comp2(offst_car, 16);
2199
2200        agc2  = STV090x_READ_DEMOD(state, AGC2I1) << 8;
2201        agc2 |= STV090x_READ_DEMOD(state, AGC2I0);
2202        car_max = state->search_range / 1000;
2203
2204        car_max += (car_max / 10); /* 10% margin */
2205        car_max  = (65536 * car_max / 2);
2206        car_max /= state->mclk / 1000;
2207
2208        if (car_max > 0x4000)
2209                car_max = 0x4000;
2210
2211        if ((agc2 > 0x2000) || (offst_car > 2 * car_max) || (offst_car < -2 * car_max)) {
2212                no_signal = 1;
2213                dprintk(FE_DEBUG, 1, "No Signal");
2214        } else {
2215                no_signal = 0;
2216                dprintk(FE_DEBUG, 1, "Found Signal");
2217        }
2218
2219        return no_signal;
2220}
2221
2222static int stv090x_search_car_loop(struct stv090x_state *state, s32 inc, s32 timeout, int zigzag, s32 steps_max)
2223{
2224        int no_signal, lock = 0;
2225        s32 cpt_step = 0, offst_freq, car_max;
2226        u32 reg;
2227
2228        car_max  = state->search_range / 1000;
2229        car_max += (car_max / 10);
2230        car_max  = (65536 * car_max / 2);
2231        car_max /= (state->mclk / 1000);
2232        if (car_max > 0x4000)
2233                car_max = 0x4000;
2234
2235        if (zigzag)
2236                offst_freq = 0;
2237        else
2238                offst_freq = -car_max + inc;
2239
2240        do {
2241                if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x1c) < 0)
2242                        goto err;
2243                if (STV090x_WRITE_DEMOD(state, CFRINIT1, ((offst_freq / 256) & 0xff)) < 0)
2244                        goto err;
2245                if (STV090x_WRITE_DEMOD(state, CFRINIT0, offst_freq & 0xff) < 0)
2246                        goto err;
2247                if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x18) < 0)
2248                        goto err;
2249
2250                reg = STV090x_READ_DEMOD(state, PDELCTRL1);
2251                STV090x_SETFIELD_Px(reg, ALGOSWRST_FIELD, 0x1); /* stop DVB-S2 packet delin */
2252                if (STV090x_WRITE_DEMOD(state, PDELCTRL1, reg) < 0)
2253                        goto err;
2254
2255                if (zigzag) {
2256                        if (offst_freq >= 0)
2257                                offst_freq = -offst_freq - 2 * inc;
2258                        else
2259                                offst_freq = -offst_freq;
2260                } else {
2261                        offst_freq += 2 * inc;
2262                }
2263
2264                cpt_step++;
2265
2266                lock = stv090x_get_dmdlock(state, timeout);
2267                no_signal = stv090x_chk_signal(state);
2268
2269        } while ((!lock) &&
2270                 (!no_signal) &&
2271                  ((offst_freq - inc) < car_max) &&
2272                  ((offst_freq + inc) > -car_max) &&
2273                  (cpt_step < steps_max));
2274
2275        reg = STV090x_READ_DEMOD(state, PDELCTRL1);
2276        STV090x_SETFIELD_Px(reg, ALGOSWRST_FIELD, 0);
2277        if (STV090x_WRITE_DEMOD(state, PDELCTRL1, reg) < 0)
2278                        goto err;
2279
2280        return lock;
2281err:
2282        dprintk(FE_ERROR, 1, "I/O error");
2283        return -1;
2284}
2285
2286static int stv090x_sw_algo(struct stv090x_state *state)
2287{
2288        int no_signal, zigzag, lock = 0;
2289        u32 reg;
2290
2291        s32 dvbs2_fly_wheel;
2292        s32 inc, timeout_step, trials, steps_max;
2293
2294        /* get params */
2295        stv090x_get_loop_params(state, &inc, &timeout_step, &steps_max);
2296
2297        switch (state->search_mode) {
2298        case STV090x_SEARCH_DVBS1:
2299        case STV090x_SEARCH_DSS:
2300                /* accelerate the frequency detector */
2301                if (state->dev_ver >= 0x20) {
2302                        if (STV090x_WRITE_DEMOD(state, CARFREQ, 0x3B) < 0)
2303                                goto err;
2304                }
2305
2306                if (STV090x_WRITE_DEMOD(state, DMDCFGMD, 0x49) < 0)
2307                        goto err;
2308                zigzag = 0;
2309                break;
2310
2311        case STV090x_SEARCH_DVBS2:
2312                if (state->dev_ver >= 0x20) {
2313                        if (STV090x_WRITE_DEMOD(state, CORRELABS, 0x79) < 0)
2314                                goto err;
2315                }
2316
2317                if (STV090x_WRITE_DEMOD(state, DMDCFGMD, 0x89) < 0)
2318                        goto err;
2319                zigzag = 1;
2320                break;
2321
2322        case STV090x_SEARCH_AUTO:
2323        default:
2324                /* accelerate the frequency detector */
2325                if (state->dev_ver >= 0x20) {
2326                        if (STV090x_WRITE_DEMOD(state, CARFREQ, 0x3b) < 0)
2327                                goto err;
2328                        if (STV090x_WRITE_DEMOD(state, CORRELABS, 0x79) < 0)
2329                                goto err;
2330                }
2331
2332                if (STV090x_WRITE_DEMOD(state, DMDCFGMD, 0xc9) < 0)
2333                        goto err;
2334                zigzag = 0;
2335                break;
2336        }
2337
2338        trials = 0;
2339        do {
2340                lock = stv090x_search_car_loop(state, inc, timeout_step, zigzag, steps_max);
2341                no_signal = stv090x_chk_signal(state);
2342                trials++;
2343
2344                /*run the SW search 2 times maximum*/
2345                if (lock || no_signal || (trials == 2)) {
2346                        /*Check if the demod is not losing lock in DVBS2*/
2347                        if (state->dev_ver >= 0x20) {
2348                                if (STV090x_WRITE_DEMOD(state, CARFREQ, 0x49) < 0)
2349                                        goto err;
2350                                if (STV090x_WRITE_DEMOD(state, CORRELABS, 0x9e) < 0)
2351                                        goto err;
2352                        }
2353
2354                        reg = STV090x_READ_DEMOD(state, DMDSTATE);
2355                        if ((lock) && (STV090x_GETFIELD_Px(reg, HEADER_MODE_FIELD) == STV090x_DVBS2)) {
2356                                /*Check if the demod is not losing lock in DVBS2*/
2357                                msleep(timeout_step);
2358                                reg = STV090x_READ_DEMOD(state, DMDFLYW);
2359                                dvbs2_fly_wheel = STV090x_GETFIELD_Px(reg, FLYWHEEL_CPT_FIELD);
2360                                if (dvbs2_fly_wheel < 0xd) {     /*if correct frames is decrementing */
2361                                        msleep(timeout_step);
2362                                        reg = STV090x_READ_DEMOD(state, DMDFLYW);
2363                                        dvbs2_fly_wheel = STV090x_GETFIELD_Px(reg, FLYWHEEL_CPT_FIELD);
2364                                }
2365                                if (dvbs2_fly_wheel < 0xd) {
2366                                        /*FALSE lock, The demod is loosing lock */
2367                                        lock = 0;
2368                                        if (trials < 2) {
2369                                                if (state->dev_ver >= 0x20) {
2370                                                        if (STV090x_WRITE_DEMOD(state, CORRELABS, 0x79) < 0)
2371                                                                goto err;
2372                                                }
2373
2374                                                if (STV090x_WRITE_DEMOD(state, DMDCFGMD, 0x89) < 0)
2375                                                        goto err;
2376                                        }
2377                                }
2378                        }
2379                }
2380        } while ((!lock) && (trials < 2) && (!no_signal));
2381
2382        return lock;
2383err:
2384        dprintk(FE_ERROR, 1, "I/O error");
2385        return -1;
2386}
2387
2388static enum stv090x_delsys stv090x_get_std(struct stv090x_state *state)
2389{
2390        u32 reg;
2391        enum stv090x_delsys delsys;
2392
2393        reg = STV090x_READ_DEMOD(state, DMDSTATE);
2394        if (STV090x_GETFIELD_Px(reg, HEADER_MODE_FIELD) == 2)
2395                delsys = STV090x_DVBS2;
2396        else if (STV090x_GETFIELD_Px(reg, HEADER_MODE_FIELD) == 3) {
2397                reg = STV090x_READ_DEMOD(state, FECM);
2398                if (STV090x_GETFIELD_Px(reg, DSS_DVB_FIELD) == 1)
2399                        delsys = STV090x_DSS;
2400                else
2401                        delsys = STV090x_DVBS1;
2402        } else {
2403                delsys = STV090x_ERROR;
2404        }
2405
2406        return delsys;
2407}
2408
2409/* in Hz */
2410static s32 stv090x_get_car_freq(struct stv090x_state *state, u32 mclk)
2411{
2412        s32 derot, int_1, int_2, tmp_1, tmp_2;
2413
2414        derot  = STV090x_READ_DEMOD(state, CFR2) << 16;
2415        derot |= STV090x_READ_DEMOD(state, CFR1) <<  8;
2416        derot |= STV090x_READ_DEMOD(state, CFR0);
2417
2418        derot = comp2(derot, 24);
2419        int_1 = state->mclk >> 12;
2420        int_2 = derot >> 12;
2421
2422        /* carrier_frequency = MasterClock * Reg / 2^24 */
2423        tmp_1 = state->mclk % 0x1000;
2424        tmp_2 = derot % 0x1000;
2425
2426        derot = (int_1 * int_2) +
2427                ((int_1 * tmp_2) >> 12) +
2428                ((int_1 * tmp_1) >> 12);
2429
2430        return derot;
2431}
2432
2433static int stv090x_get_viterbi(struct stv090x_state *state)
2434{
2435        u32 reg, rate;
2436
2437        reg = STV090x_READ_DEMOD(state, VITCURPUN);
2438        rate = STV090x_GETFIELD_Px(reg, VIT_CURPUN_FIELD);
2439
2440        switch (rate) {
2441        case 13:
2442                state->fec = STV090x_PR12;
2443                break;
2444
2445        case 18:
2446                state->fec = STV090x_PR23;
2447                break;
2448
2449        case 21:
2450                state->fec = STV090x_PR34;
2451                break;
2452
2453        case 24:
2454                state->fec = STV090x_PR56;
2455                break;
2456
2457        case 25:
2458                state->fec = STV090x_PR67;
2459                break;
2460
2461        case 26:
2462                state->fec = STV090x_PR78;
2463                break;
2464
2465        default:
2466                state->fec = STV090x_PRERR;
2467                break;
2468        }
2469
2470        return 0;
2471}
2472
2473static enum stv090x_signal_state stv090x_get_sig_params(struct stv090x_state *state)
2474{
2475        struct dvb_frontend *fe = &state->frontend;
2476
2477        u8 tmg;
2478        u32 reg;
2479        s32 i = 0, offst_freq;
2480
2481        msleep(5);
2482
2483        if (state->algo == STV090x_BLIND_SEARCH) {
2484                tmg = STV090x_READ_DEMOD(state, TMGREG2);
2485                STV090x_WRITE_DEMOD(state, SFRSTEP, 0x5c);
2486                while ((i <= 50) && (tmg != 0) && (tmg != 0xff)) {
2487                        tmg = STV090x_READ_DEMOD(state, TMGREG2);
2488                        msleep(5);
2489                        i += 5;
2490                }
2491        }
2492        state->delsys = stv090x_get_std(state);
2493
2494        if (stv090x_i2c_gate_ctrl(fe, 1) < 0)
2495                goto err;
2496
2497        if (state->config->tuner_get_frequency) {
2498                if (state->config->tuner_get_frequency(fe, &state->frequency) < 0)
2499                        goto err;
2500        }
2501
2502        if (stv090x_i2c_gate_ctrl(fe, 0) < 0)
2503                goto err;
2504
2505        offst_freq = stv090x_get_car_freq(state, state->mclk) / 1000;
2506        state->frequency += offst_freq;
2507
2508        if (stv090x_get_viterbi(state) < 0)
2509                goto err;
2510
2511        reg = STV090x_READ_DEMOD(state, DMDMODCOD);
2512        state->modcod = STV090x_GETFIELD_Px(reg, DEMOD_MODCOD_FIELD);
2513        state->pilots = STV090x_GETFIELD_Px(reg, DEMOD_TYPE_FIELD) & 0x01;
2514        state->frame_len = STV090x_GETFIELD_Px(reg, DEMOD_TYPE_FIELD) >> 1;
2515        reg = STV090x_READ_DEMOD(state, TMGOBS);
2516        state->rolloff = STV090x_GETFIELD_Px(reg, ROLLOFF_STATUS_FIELD);
2517        reg = STV090x_READ_DEMOD(state, FECM);
2518        state->inversion = STV090x_GETFIELD_Px(reg, IQINV_FIELD);
2519
2520        if ((state->algo == STV090x_BLIND_SEARCH) || (state->srate < 10000000)) {
2521
2522                if (stv090x_i2c_gate_ctrl(fe, 1) < 0)
2523                        goto err;
2524
2525                if (state->config->tuner_get_frequency) {
2526                        if (state->config->tuner_get_frequency(fe, &state->frequency) < 0)
2527                                goto err;
2528                }
2529
2530                if (stv090x_i2c_gate_ctrl(fe, 0) < 0)
2531                        goto err;
2532
2533                if (abs(offst_freq) <= ((state->search_range / 2000) + 500))
2534                        return STV090x_RANGEOK;
2535                else if (abs(offst_freq) <= (stv090x_car_width(state->srate, state->rolloff) / 2000))
2536                        return STV090x_RANGEOK;
2537                else
2538                        return STV090x_OUTOFRANGE; /* Out of Range */
2539        } else {
2540                if (abs(offst_freq) <= ((state->search_range / 2000) + 500))
2541                        return STV090x_RANGEOK;
2542                else
2543                        return STV090x_OUTOFRANGE;
2544        }
2545
2546        return STV090x_OUTOFRANGE;
2547err:
2548        dprintk(FE_ERROR, 1, "I/O error");
2549        return -1;
2550}
2551
2552static u32 stv090x_get_tmgoffst(struct stv090x_state *state, u32 srate)
2553{
2554        s32 offst_tmg;
2555
2556        offst_tmg  = STV090x_READ_DEMOD(state, TMGREG2) << 16;
2557        offst_tmg |= STV090x_READ_DEMOD(state, TMGREG1) <<  8;
2558        offst_tmg |= STV090x_READ_DEMOD(state, TMGREG0);
2559
2560        offst_tmg = comp2(offst_tmg, 24); /* 2's complement */
2561        if (!offst_tmg)
2562                offst_tmg = 1;
2563
2564        offst_tmg  = ((s32) srate * 10) / ((s32) 0x1000000 / offst_tmg);
2565        offst_tmg /= 320;
2566
2567        return offst_tmg;
2568}
2569
2570static u8 stv090x_optimize_carloop(struct stv090x_state *state, enum stv090x_modcod modcod, s32 pilots)
2571{
2572        u8 aclc = 0x29;
2573        s32 i;
2574        struct stv090x_long_frame_crloop *car_loop, *car_loop_qpsk_low, *car_loop_apsk_low;
2575
2576        if (state->dev_ver == 0x20) {
2577                car_loop                = stv090x_s2_crl_cut20;
2578                car_loop_qpsk_low       = stv090x_s2_lowqpsk_crl_cut20;
2579                car_loop_apsk_low       = stv090x_s2_apsk_crl_cut20;
2580        } else {
2581                /* >= Cut 3 */
2582                car_loop                = stv090x_s2_crl_cut30;
2583                car_loop_qpsk_low       = stv090x_s2_lowqpsk_crl_cut30;
2584                car_loop_apsk_low       = stv090x_s2_apsk_crl_cut30;
2585        }
2586
2587        if (modcod < STV090x_QPSK_12) {
2588                i = 0;
2589                while ((i < 3) && (modcod != car_loop_qpsk_low[i].modcod))
2590                        i++;
2591
2592                if (i >= 3)
2593                        i = 2;
2594
2595        } else {
2596                i = 0;
2597                while ((i < 14) && (modcod != car_loop[i].modcod))
2598                        i++;
2599
2600                if (i >= 14) {
2601                        i = 0;
2602                        while ((i < 11) && (modcod != car_loop_apsk_low[i].modcod))
2603                                i++;
2604
2605                        if (i >= 11)
2606                                i = 10;
2607                }
2608        }
2609
2610        if (modcod <= STV090x_QPSK_25) {
2611                if (pilots) {
2612                        if (state->srate <= 3000000)
2613                                aclc = car_loop_qpsk_low[i].crl_pilots_on_2;
2614                        else if (state->srate <= 7000000)
2615                                aclc = car_loop_qpsk_low[i].crl_pilots_on_5;
2616                        else if (state->srate <= 15000000)
2617                                aclc = car_loop_qpsk_low[i].crl_pilots_on_10;
2618                        else if (state->srate <= 25000000)
2619                                aclc = car_loop_qpsk_low[i].crl_pilots_on_20;
2620                        else
2621                                aclc = car_loop_qpsk_low[i].crl_pilots_on_30;
2622                } else {
2623                        if (state->srate <= 3000000)
2624                                aclc = car_loop_qpsk_low[i].crl_pilots_off_2;
2625                        else if (state->srate <= 7000000)
2626                                aclc = car_loop_qpsk_low[i].crl_pilots_off_5;
2627                        else if (state->srate <= 15000000)
2628                                aclc = car_loop_qpsk_low[i].crl_pilots_off_10;
2629                        else if (state->srate <= 25000000)
2630                                aclc = car_loop_qpsk_low[i].crl_pilots_off_20;
2631                        else
2632                                aclc = car_loop_qpsk_low[i].crl_pilots_off_30;
2633                }
2634
2635        } else if (modcod <= STV090x_8PSK_910) {
2636                if (pilots) {
2637                        if (state->srate <= 3000000)
2638                                aclc = car_loop[i].crl_pilots_on_2;
2639                        else if (state->srate <= 7000000)
2640                                aclc = car_loop[i].crl_pilots_on_5;
2641                        else if (state->srate <= 15000000)
2642                                aclc = car_loop[i].crl_pilots_on_10;
2643                        else if (state->srate <= 25000000)
2644                                aclc = car_loop[i].crl_pilots_on_20;
2645                        else
2646                                aclc = car_loop[i].crl_pilots_on_30;
2647                } else {
2648                        if (state->srate <= 3000000)
2649                                aclc = car_loop[i].crl_pilots_off_2;
2650                        else if (state->srate <= 7000000)
2651                                aclc = car_loop[i].crl_pilots_off_5;
2652                        else if (state->srate <= 15000000)
2653                                aclc = car_loop[i].crl_pilots_off_10;
2654                        else if (state->srate <= 25000000)
2655                                aclc = car_loop[i].crl_pilots_off_20;
2656                        else
2657                                aclc = car_loop[i].crl_pilots_off_30;
2658                }
2659        } else { /* 16APSK and 32APSK */
2660                if (state->srate <= 3000000)
2661                        aclc = car_loop_apsk_low[i].crl_pilots_on_2;
2662                else if (state->srate <= 7000000)
2663                        aclc = car_loop_apsk_low[i].crl_pilots_on_5;
2664                else if (state->srate <= 15000000)
2665                        aclc = car_loop_apsk_low[i].crl_pilots_on_10;
2666                else if (state->srate <= 25000000)
2667                        aclc = car_loop_apsk_low[i].crl_pilots_on_20;
2668                else
2669                        aclc = car_loop_apsk_low[i].crl_pilots_on_30;
2670        }
2671
2672        return aclc;
2673}
2674
2675static u8 stv090x_optimize_carloop_short(struct stv090x_state *state)
2676{
2677        struct stv090x_short_frame_crloop *short_crl = NULL;
2678        s32 index = 0;
2679        u8 aclc = 0x0b;
2680
2681        switch (state->modulation) {
2682        case STV090x_QPSK:
2683        default:
2684                index = 0;
2685                break;
2686        case STV090x_8PSK:
2687                index = 1;
2688                break;
2689        case STV090x_16APSK:
2690                index = 2;
2691                break;
2692        case STV090x_32APSK:
2693                index = 3;
2694                break;
2695        }
2696
2697        if (state->dev_ver >= 0x30) {
2698                /* Cut 3.0 and up */
2699                short_crl = stv090x_s2_short_crl_cut30;
2700        } else {
2701                /* Cut 2.0 and up: we don't support cuts older than 2.0 */
2702                short_crl = stv090x_s2_short_crl_cut20;
2703        }
2704
2705        if (state->srate <= 3000000)
2706                aclc = short_crl[index].crl_2;
2707        else if (state->srate <= 7000000)
2708                aclc = short_crl[index].crl_5;
2709        else if (state->srate <= 15000000)
2710                aclc = short_crl[index].crl_10;
2711        else if (state->srate <= 25000000)
2712                aclc = short_crl[index].crl_20;
2713        else
2714                aclc = short_crl[index].crl_30;
2715
2716        return aclc;
2717}
2718
2719static int stv090x_optimize_track(struct stv090x_state *state)
2720{
2721        struct dvb_frontend *fe = &state->frontend;
2722
2723        enum stv090x_rolloff rolloff;
2724        enum stv090x_modcod modcod;
2725
2726        s32 srate, pilots, aclc, f_1, f_0, i = 0, blind_tune = 0;
2727        u32 reg;
2728
2729        srate  = stv090x_get_srate(state, state->mclk);
2730        srate += stv090x_get_tmgoffst(state, srate);
2731
2732        switch (state->delsys) {
2733        case STV090x_DVBS1:
2734        case STV090x_DSS:
2735                if (state->algo == STV090x_SEARCH_AUTO) {
2736                        reg = STV090x_READ_DEMOD(state, DMDCFGMD);
2737                        STV090x_SETFIELD_Px(reg, DVBS1_ENABLE_FIELD, 1);
2738                        STV090x_SETFIELD_Px(reg, DVBS2_ENABLE_FIELD, 0);
2739                        if (STV090x_WRITE_DEMOD(state, DMDCFGMD, reg) < 0)
2740                                goto err;
2741                }
2742                reg = STV090x_READ_DEMOD(state, DEMOD);
2743                STV090x_SETFIELD_Px(reg, ROLLOFF_CONTROL_FIELD, state->rolloff);
2744                STV090x_SETFIELD_Px(reg, MANUAL_SXROLLOFF_FIELD, 0x01);
2745                if (STV090x_WRITE_DEMOD(state, DEMOD, reg) < 0)
2746                        goto err;
2747
2748                if (state->dev_ver >= 0x30) {
2749                        if (stv090x_get_viterbi(state) < 0)
2750                                goto err;
2751
2752                        if (state->fec == STV090x_PR12) {
2753                                if (STV090x_WRITE_DEMOD(state, GAUSSR0, 0x98) < 0)
2754                                        goto err;
2755                                if (STV090x_WRITE_DEMOD(state, CCIR0, 0x18) < 0)
2756                                        goto err;
2757                        } else {
2758                                if (STV090x_WRITE_DEMOD(state, GAUSSR0, 0x18) < 0)
2759                                        goto err;
2760                                if (STV090x_WRITE_DEMOD(state, CCIR0, 0x18) < 0)
2761                                        goto err;
2762                        }
2763                }
2764
2765                if (STV090x_WRITE_DEMOD(state, ERRCTRL1, 0x75) < 0)
2766                        goto err;
2767                break;
2768
2769        case STV090x_DVBS2:
2770                reg = STV090x_READ_DEMOD(state, DMDCFGMD);
2771                STV090x_SETFIELD_Px(reg, DVBS1_ENABLE_FIELD, 0);
2772                STV090x_SETFIELD_Px(reg, DVBS2_ENABLE_FIELD, 1);
2773                if (STV090x_WRITE_DEMOD(state, DMDCFGMD, reg) < 0)
2774                        goto err;
2775                if (STV090x_WRITE_DEMOD(state, ACLC, 0) < 0)
2776                        goto err;
2777                if (STV090x_WRITE_DEMOD(state, BCLC, 0) < 0)
2778                        goto err;
2779                if (state->frame_len == STV090x_LONG_FRAME) {
2780                        reg = STV090x_READ_DEMOD(state, DMDMODCOD);
2781                        modcod = STV090x_GETFIELD_Px(reg, DEMOD_MODCOD_FIELD);
2782                        pilots = STV090x_GETFIELD_Px(reg, DEMOD_TYPE_FIELD) & 0x01;
2783                        aclc = stv090x_optimize_carloop(state, modcod, pilots);
2784                        if (modcod <= STV090x_QPSK_910) {
2785                                STV090x_WRITE_DEMOD(state, ACLC2S2Q, aclc);
2786                        } else if (modcod <= STV090x_8PSK_910) {
2787                                if (STV090x_WRITE_DEMOD(state, ACLC2S2Q, 0x2a) < 0)
2788                                        goto err;
2789                                if (STV090x_WRITE_DEMOD(state, ACLC2S28, aclc) < 0)
2790                                        goto err;
2791                        }
2792                        if ((state->demod_mode == STV090x_SINGLE) && (modcod > STV090x_8PSK_910)) {
2793                                if (modcod <= STV090x_16APSK_910) {
2794                                        if (STV090x_WRITE_DEMOD(state, ACLC2S2Q, 0x2a) < 0)
2795                                                goto err;
2796                                        if (STV090x_WRITE_DEMOD(state, ACLC2S216A, aclc) < 0)
2797                                                goto err;
2798                                } else {
2799                                        if (STV090x_WRITE_DEMOD(state, ACLC2S2Q, 0x2a) < 0)
2800                                                goto err;
2801                                        if (STV090x_WRITE_DEMOD(state, ACLC2S232A, aclc) < 0)
2802                                                goto err;
2803                                }
2804                        }
2805                } else {
2806                        /*Carrier loop setting for short frame*/
2807                        aclc = stv090x_optimize_carloop_short(state);
2808                        if (state->modulation == STV090x_QPSK) {
2809                                if (STV090x_WRITE_DEMOD(state, ACLC2S2Q, aclc) < 0)
2810                                        goto err;
2811                        } else if (state->modulation == STV090x_8PSK) {
2812                                if (STV090x_WRITE_DEMOD(state, ACLC2S2Q, 0x2a) < 0)
2813                                        goto err;
2814                                if (STV090x_WRITE_DEMOD(state, ACLC2S28, aclc) < 0)
2815                                        goto err;
2816                        } else if (state->modulation == STV090x_16APSK) {
2817                                if (STV090x_WRITE_DEMOD(state, ACLC2S2Q, 0x2a) < 0)
2818                                        goto err;
2819                                if (STV090x_WRITE_DEMOD(state, ACLC2S216A, aclc) < 0)
2820                                        goto err;
2821                        } else if (state->modulation == STV090x_32APSK)  {
2822                                if (STV090x_WRITE_DEMOD(state, ACLC2S2Q, 0x2a) < 0)
2823                                        goto err;
2824                                if (STV090x_WRITE_DEMOD(state, ACLC2S232A, aclc) < 0)
2825                                        goto err;
2826                        }
2827                }
2828
2829                STV090x_WRITE_DEMOD(state, ERRCTRL1, 0x67); /* PER */
2830                break;
2831
2832        case STV090x_UNKNOWN:
2833        default:
2834                reg = STV090x_READ_DEMOD(state, DMDCFGMD);
2835                STV090x_SETFIELD_Px(reg, DVBS1_ENABLE_FIELD, 1);
2836                STV090x_SETFIELD_Px(reg, DVBS2_ENABLE_FIELD, 1);
2837                if (STV090x_WRITE_DEMOD(state, DMDCFGMD, reg) < 0)
2838                        goto err;
2839                break;
2840        }
2841
2842        f_1 = STV090x_READ_DEMOD(state, CFR2);
2843        f_0 = STV090x_READ_DEMOD(state, CFR1);
2844        reg = STV090x_READ_DEMOD(state, TMGOBS);
2845        rolloff = STV090x_GETFIELD_Px(reg, ROLLOFF_STATUS_FIELD);
2846
2847        if (state->algo == STV090x_BLIND_SEARCH) {
2848                STV090x_WRITE_DEMOD(state, SFRSTEP, 0x00);
2849                reg = STV090x_READ_DEMOD(state, DMDCFGMD);
2850                STV090x_SETFIELD_Px(reg, SCAN_ENABLE_FIELD, 0x00);
2851                STV090x_SETFIELD_Px(reg, CFR_AUTOSCAN_FIELD, 0x00);
2852                if (STV090x_WRITE_DEMOD(state, DMDCFGMD, reg) < 0)
2853                        goto err;
2854                if (STV090x_WRITE_DEMOD(state, TMGCFG2, 0xc1) < 0)
2855                        goto err;
2856
2857                if (stv090x_set_srate(state, srate) < 0)
2858                        goto err;
2859                blind_tune = 1;
2860        }
2861
2862        if (state->dev_ver >= 0x20) {
2863                if ((state->search_mode == STV090x_SEARCH_DVBS1)        ||
2864                    (state->search_mode == STV090x_SEARCH_DSS)          ||
2865                    (state->search_mode == STV090x_SEARCH_AUTO)) {
2866
2867                        if (STV090x_WRITE_DEMOD(state, VAVSRVIT, 0x0a) < 0)
2868                                goto err;
2869                        if (STV090x_WRITE_DEMOD(state, VITSCALE, 0x00) < 0)
2870                                goto err;
2871                }
2872        }
2873
2874        if (STV090x_WRITE_DEMOD(state, AGC2REF, 0x38) < 0)
2875                goto err;
2876
2877        /* AUTO tracking MODE */
2878        if (STV090x_WRITE_DEMOD(state, SFRUP1, 0x80) < 0)
2879                goto err;
2880        /* AUTO tracking MODE */
2881        if (STV090x_WRITE_DEMOD(state, SFRLOW1, 0x80) < 0)
2882                goto err;
2883
2884        if ((state->dev_ver >= 0x20) || (blind_tune == 1) || (state->srate < 10000000)) {
2885                /* update initial carrier freq with the found freq offset */
2886                if (STV090x_WRITE_DEMOD(state, CFRINIT1, f_1) < 0)
2887                        goto err;
2888                if (STV090x_WRITE_DEMOD(state, CFRINIT0, f_0) < 0)
2889                        goto err;
2890                state->tuner_bw = stv090x_car_width(srate, state->rolloff) + 10000000;
2891
2892                if ((state->dev_ver >= 0x20) || (blind_tune == 1)) {
2893
2894                        if (state->algo != STV090x_WARM_SEARCH) {
2895
2896                                if (stv090x_i2c_gate_ctrl(fe, 1) < 0)
2897                                        goto err;
2898
2899                                if (state->config->tuner_set_bandwidth) {
2900                                        if (state->config->tuner_set_bandwidth(fe, state->tuner_bw) < 0)
2901                                                goto err;
2902                                }
2903
2904                                if (stv090x_i2c_gate_ctrl(fe, 0) < 0)
2905                                        goto err;
2906
2907                        }
2908                }
2909                if ((state->algo == STV090x_BLIND_SEARCH) || (state->srate < 10000000))
2910                        msleep(50); /* blind search: wait 50ms for SR stabilization */
2911                else
2912                        msleep(5);
2913
2914                stv090x_get_lock_tmg(state);
2915
2916                if (!(stv090x_get_dmdlock(state, (state->DemodTimeout / 2)))) {
2917                        if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x1f) < 0)
2918                                goto err;
2919                        if (STV090x_WRITE_DEMOD(state, CFRINIT1, f_1) < 0)
2920                                goto err;
2921                        if (STV090x_WRITE_DEMOD(state, CFRINIT0, f_0) < 0)
2922                                goto err;
2923                        if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x18) < 0)
2924                                goto err;
2925
2926                        i = 0;
2927
2928                        while ((!(stv090x_get_dmdlock(state, (state->DemodTimeout / 2)))) && (i <= 2)) {
2929
2930                                if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x1f) < 0)
2931                                        goto err;
2932                                if (STV090x_WRITE_DEMOD(state, CFRINIT1, f_1) < 0)
2933                                        goto err;
2934                                if (STV090x_WRITE_DEMOD(state, CFRINIT0, f_0) < 0)
2935                                        goto err;
2936                                if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x18) < 0)
2937                                        goto err;
2938                                i++;
2939                        }
2940                }
2941
2942        }
2943
2944        if (state->dev_ver >= 0x20) {
2945                if (STV090x_WRITE_DEMOD(state, CARFREQ, 0x49) < 0)
2946                        goto err;
2947        }
2948
2949        if ((state->delsys == STV090x_DVBS1) || (state->delsys == STV090x_DSS))
2950                stv090x_set_vit_thtracq(state);
2951
2952        return 0;
2953err:
2954        dprintk(FE_ERROR, 1, "I/O error");
2955        return -1;
2956}
2957
2958static int stv090x_get_feclock(struct stv090x_state *state, s32 timeout)
2959{
2960        s32 timer = 0, lock = 0, stat;
2961        u32 reg;
2962
2963        while ((timer < timeout) && (!lock)) {
2964                reg = STV090x_READ_DEMOD(state, DMDSTATE);
2965                stat = STV090x_GETFIELD_Px(reg, HEADER_MODE_FIELD);
2966
2967                switch (stat) {
2968                case 0: /* searching */
2969                case 1: /* first PLH detected */
2970                default:
2971                        lock = 0;
2972                        break;
2973
2974                case 2: /* DVB-S2 mode */
2975                        reg = STV090x_READ_DEMOD(state, PDELSTATUS1);
2976                        lock = STV090x_GETFIELD_Px(reg, PKTDELIN_LOCK_FIELD);
2977                        break;
2978
2979                case 3: /* DVB-S1/legacy mode */
2980                        reg = STV090x_READ_DEMOD(state, VSTATUSVIT);
2981                        lock = STV090x_GETFIELD_Px(reg, LOCKEDVIT_FIELD);
2982                        break;
2983                }
2984                if (!lock) {
2985                        msleep(10);
2986                        timer += 10;
2987                }
2988        }
2989        return lock;
2990}
2991
2992static int stv090x_get_lock(struct stv090x_state *state, s32 timeout_dmd, s32 timeout_fec)
2993{
2994        u32 reg;
2995        s32 timer = 0;
2996        int lock;
2997
2998        lock = stv090x_get_dmdlock(state, timeout_dmd);
2999        if (lock)
3000                lock = stv090x_get_feclock(state, timeout_fec);

3001
3002        if (lock) {
3003                lock = 0;
3004
3005                while ((timer < timeout_fec) && (!lock)) {
3006                        reg = STV090x_READ_DEMOD(state, TSSTATUS);
3007                        lock = STV090x_GETFIELD_Px(reg, TSFIFO_LINEOK_FIELD);
3008                        msleep(1);
3009                        timer++;
3010                }
3011        }
3012
3013        return lock;
3014}
3015
3016static int stv090x_set_s2rolloff(struct stv090x_state *state)
3017{
3018        u32 reg;
3019
3020        if (state->dev_ver <= 0x20) {
3021                /* rolloff to auto mode if DVBS2 */
3022                reg = STV090x_READ_DEMOD(state, DEMOD);
3023                STV090x_SETFIELD_Px(reg, MANUAL_SXROLLOFF_FIELD, 0x00);
3024                if (STV090x_WRITE_DEMOD(state, DEMOD, reg) < 0)
3025                        goto err;
3026        } else {
3027                /* DVB-S2 rolloff to auto mode if DVBS2 */
3028                reg = STV090x_READ_DEMOD(state, DEMOD);
3029                STV090x_SETFIELD_Px(reg, MANUAL_S2ROLLOFF_FIELD, 0x00);
3030                if (STV090x_WRITE_DEMOD(state, DEMOD, reg) < 0)
3031                        goto err;
3032        }
3033        return 0;
3034err:
3035        dprintk(FE_ERROR, 1, "I/O error");
3036        return -1;
3037}
3038
3039
3040static enum stv090x_signal_state stv090x_algo(struct stv090x_state *state)
3041{
3042        struct dvb_frontend *fe = &state->frontend;
3043        enum stv090x_signal_state signal_state = STV090x_NOCARRIER;
3044        u32 reg;
3045        s32 timeout_dmd = 500, timeout_fec = 50, agc1_power, power_iq = 0, i;
3046        int lock = 0, low_sr = 0, no_signal = 0;
3047
3048        reg = STV090x_READ_DEMOD(state, TSCFGH);
3049        STV090x_SETFIELD_Px(reg, RST_HWARE_FIELD, 1); /* Stop path 1 stream merger */
3050        if (STV090x_WRITE_DEMOD(state, TSCFGH, reg) < 0)
3051                goto err;
3052
3053        if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x5c) < 0) /* Demod stop */
3054                goto err;
3055
3056        if (state->dev_ver >= 0x20) {
3057                if (STV090x_WRITE_DEMOD(state, CORRELABS, 0x9e) < 0) /* cut 2.0 */
3058                        goto err;
3059        }
3060
3061        stv090x_get_lock_tmg(state);
3062
3063        if (state->algo == STV090x_BLIND_SEARCH) {
3064                state->tuner_bw = 2 * 36000000; /* wide bw for unknown srate */
3065                if (STV090x_WRITE_DEMOD(state, TMGCFG2, 0xc0) < 0) /* wider srate scan */
3066                        goto err;
3067                if (STV090x_WRITE_DEMOD(state, CORRELMANT, 0x70) < 0)
3068                        goto err;
3069                if (stv090x_set_srate(state, 1000000) < 0) /* inital srate = 1Msps */
3070                        goto err;
3071        } else {
3072                /* known srate */
3073                if (STV090x_WRITE_DEMOD(state, DMDTOM, 0x20) < 0)
3074                        goto err;
3075                if (STV090x_WRITE_DEMOD(state, TMGCFG, 0xd2) < 0)
3076                        goto err;
3077
3078                if (state->srate < 2000000) {
3079                        /* SR < 2MSPS */
3080                        if (STV090x_WRITE_DEMOD(state, CORRELMANT, 0x63) < 0)
3081                                goto err;
3082                } else {
3083                        /* SR >= 2Msps */
3084                        if (STV090x_WRITE_DEMOD(state, CORRELMANT, 0x70) < 0)
3085                                goto err;
3086                }
3087
3088                if (STV090x_WRITE_DEMOD(state, AGC2REF, 0x38) < 0)
3089                        goto err;
3090
3091                if (state->dev_ver >= 0x20) {
3092                        if (STV090x_WRITE_DEMOD(state, KREFTMG, 0x5a) < 0)
3093                                goto err;
3094                        if (state->algo == STV090x_COLD_SEARCH)
3095                                state->tuner_bw = (15 * (stv090x_car_width(state->srate, state->rolloff) + 10000000)) / 10;
3096                        else if (state->algo == STV090x_WARM_SEARCH)
3097                                state->tuner_bw = stv090x_car_width(state->srate, state->rolloff) + 10000000;
3098                }
3099
3100                /* if cold start or warm  (Symbolrate is known)
3101                 * use a Narrow symbol rate scan range
3102                 */
3103                if (STV090x_WRITE_DEMOD(state, TMGCFG2, 0xc1) < 0) /* narrow srate scan */
3104                        goto err;
3105
3106                if (stv090x_set_srate(state, state->srate) < 0)
3107                        goto err;
3108
3109                if (stv090x_set_max_srate(state, state->mclk, state->srate) < 0)
3110                        goto err;
3111                if (stv090x_set_min_srate(state, state->mclk, state->srate) < 0)
3112                        goto err;
3113
3114                if (state->srate >= 10000000)
3115                        low_sr = 0;
3116                else
3117                        low_sr = 1;
3118        }
3119
3120        /* Setup tuner */
3121        if (stv090x_i2c_gate_ctrl(fe, 1) < 0)
3122                goto err;
3123
3124        if (state->config->tuner_set_bbgain) {
3125                if (state->config->tuner_set_bbgain(fe, 10) < 0) /* 10dB */
3126                        goto err;
3127        }
3128
3129        if (state->config->tuner_set_frequency) {
3130                if (state->config->tuner_set_frequency(fe, state->frequency) < 0)
3131                        goto err;
3132        }
3133
3134        if (state->config->tuner_set_bandwidth) {
3135                if (state->config->tuner_set_bandwidth(fe, state->tuner_bw) < 0)
3136                        goto err;
3137        }
3138
3139        if (stv090x_i2c_gate_ctrl(fe, 0) < 0)
3140                goto err;
3141
3142        msleep(50);
3143
3144        if (stv090x_i2c_gate_ctrl(fe, 1) < 0)
3145                goto err;
3146
3147        if (state->config->tuner_get_status) {
3148                if (state->config->tuner_get_status(fe, &reg) < 0)
3149                        goto err;
3150        }
3151
3152        if (reg)
3153                dprintk(FE_DEBUG, 1, "Tuner phase locked");
3154        else
3155                dprintk(FE_DEBUG, 1, "Tuner unlocked");
3156
3157        if (stv090x_i2c_gate_ctrl(fe, 0) < 0)
3158                goto err;
3159
3160        msleep(10);
3161        agc1_power = MAKEWORD16(STV090x_READ_DEMOD(state, AGCIQIN1),
3162                                STV090x_READ_DEMOD(state, AGCIQIN0));
3163
3164        if (agc1_power == 0) {
3165                /* If AGC1 integrator value is 0
3166                 * then read POWERI, POWERQ
3167                 */
3168                for (i = 0; i < 5; i++) {
3169                        power_iq += (STV090x_READ_DEMOD(state, POWERI) +
3170                                     STV090x_READ_DEMOD(state, POWERQ)) >> 1;
3171                }
3172                power_iq /= 5;
3173        }
3174
3175        if ((agc1_power == 0) && (power_iq < STV090x_IQPOWER_THRESHOLD)) {
3176                dprintk(FE_ERROR, 1, "No Signal: POWER_IQ=0x%02x", power_iq);
3177                lock = 0;
3178
3179        } else {
3180                reg = STV090x_READ_DEMOD(state, DEMOD);
3181                STV090x_SETFIELD_Px(reg, SPECINV_CONTROL_FIELD, state->inversion);
3182
3183                if (state->dev_ver <= 0x20) {
3184                        /* rolloff to auto mode if DVBS2 */
3185                        STV090x_SETFIELD_Px(reg, MANUAL_SXROLLOFF_FIELD, 1);
3186                } else {
3187                        /* DVB-S2 rolloff to auto mode if DVBS2 */
3188                        STV090x_SETFIELD_Px(reg, MANUAL_S2ROLLOFF_FIELD, 1);
3189                }
3190                if (STV090x_WRITE_DEMOD(state, DEMOD, reg) < 0)
3191                        goto err;
3192
3193                if (stv090x_delivery_search(state) < 0)
3194                        goto err;
3195
3196                if (state->algo != STV090x_BLIND_SEARCH) {
3197                        if (stv090x_start_search(state) < 0)
3198                                goto err;
3199                }
3200        }
3201
3202        /* need to check for AGC1 state */
3203
3204
3205
3206        if (state->algo == STV090x_BLIND_SEARCH)
3207                lock = stv090x_blind_search(state);
3208
3209        else if (state->algo == STV090x_COLD_SEARCH)
3210                lock = stv090x_get_coldlock(state, timeout_dmd);
3211
3212        else if (state->algo == STV090x_WARM_SEARCH)
3213                lock = stv090x_get_dmdlock(state, timeout_dmd);
3214
3215        if ((!lock) && (state->algo == STV090x_COLD_SEARCH)) {
3216                if (!low_sr) {
3217                        if (stv090x_chk_tmg(state))
3218                                lock = stv090x_sw_algo(state);
3219                }
3220        }
3221
3222        if (lock)
3223                signal_state = stv090x_get_sig_params(state);
3224
3225        if ((lock) && (signal_state == STV090x_RANGEOK)) { /* signal within Range */
3226                stv090x_optimize_track(state);
3227
3228                if (state->dev_ver >= 0x20) {
3229                        /* >= Cut 2.0 :release TS reset after
3230                         * demod lock and optimized Tracking
3231                         */
3232                        reg = STV090x_READ_DEMOD(state, TSCFGH);
3233                        STV090x_SETFIELD_Px(reg, RST_HWARE_FIELD, 0); /* release merger reset */
3234                        if (STV090x_WRITE_DEMOD(state, TSCFGH, reg) < 0)
3235                                goto err;
3236
3237                        msleep(3);
3238
3239                        STV090x_SETFIELD_Px(reg, RST_HWARE_FIELD, 1); /* merger reset */
3240                        if (STV090x_WRITE_DEMOD(state, TSCFGH, reg) < 0)
3241                                goto err;
3242
3243                        STV090x_SETFIELD_Px(reg, RST_HWARE_FIELD, 0); /* release merger reset */
3244                        if (STV090x_WRITE_DEMOD(state, TSCFGH, reg) < 0)
3245                                goto err;
3246                }
3247
3248                if (stv090x_get_lock(state, timeout_fec, timeout_fec)) {
3249                        lock = 1;
3250                        if (state->delsys == STV090x_DVBS2) {
3251                                stv090x_set_s2rolloff(state);
3252
3253                                reg = STV090x_READ_DEMOD(state, PDELCTRL2);
3254                                STV090x_SETFIELD_Px(reg, RESET_UPKO_COUNT, 1);
3255                                if (STV090x_WRITE_DEMOD(state, PDELCTRL2, reg) < 0)
3256                                        goto err;
3257                                /* Reset DVBS2 packet delinator error counter */
3258                                reg = STV090x_READ_DEMOD(state, PDELCTRL2);
3259                                STV090x_SETFIELD_Px(reg, RESET_UPKO_COUNT, 0);
3260                                if (STV090x_WRITE_DEMOD(state, PDELCTRL2, reg) < 0)
3261                                        goto err;
3262
3263                                if (STV090x_WRITE_DEMOD(state, ERRCTRL1, 0x67) < 0) /* PER */
3264                                        goto err;
3265                        } else {
3266                                if (STV090x_WRITE_DEMOD(state, ERRCTRL1, 0x75) < 0)
3267                                        goto err;
3268                        }
3269                        /* Reset the Total packet counter */
3270                        if (STV090x_WRITE_DEMOD(state, FBERCPT4, 0x00) < 0)
3271                                goto err;
3272                        /* Reset the packet Error counter2 */
3273                        if (STV090x_WRITE_DEMOD(state, ERRCTRL2, 0xc1) < 0)
3274                                goto err;
3275                } else {
3276                        lock = 0;
3277                        signal_state = STV090x_NODATA;
3278                        no_signal = stv090x_chk_signal(state);
3279                }
3280        }
3281        return signal_state;
3282
3283err:
3284        dprintk(FE_ERROR, 1, "I/O error");
3285        return -1;
3286}
3287
3288static enum dvbfe_search stv090x_search(struct dvb_frontend *fe, struct dvb_frontend_parameters *p)
3289{
3290        struct stv090x_state *state = fe->demodulator_priv;
3291        struct dtv_frontend_properties *props = &fe->dtv_property_cache;
3292
3293        state->delsys = props->delivery_system;
3294        state->frequency = p->frequency;
3295        state->srate = p->u.qpsk.symbol_rate;
3296        state->search_mode = STV090x_SEARCH_AUTO;
3297        state->algo = STV090x_COLD_SEARCH;
3298        state->fec = STV090x_PRERR;
3299        state->search_range = 2000000;
3300
3301        if (stv090x_algo(state) == STV090x_RANGEOK) {
3302                dprintk(FE_DEBUG, 1, "Search success!");
3303                return DVBFE_ALGO_SEARCH_SUCCESS;
3304        } else {
3305                dprintk(FE_DEBUG, 1, "Search failed!");
3306                return DVBFE_ALGO_SEARCH_FAILED;
3307        }
3308
3309        return DVBFE_ALGO_SEARCH_ERROR;
3310}
3311
3312/* FIXME! */
3313static int stv090x_read_status(struct dvb_frontend *fe, enum fe_status *status)
3314{
3315        struct stv090x_state *state = fe->demodulator_priv;
3316        u32 reg;
3317        u8 search_state;
3318
3319        reg = STV090x_READ_DEMOD(state, DMDSTATE);
3320        search_state = STV090x_GETFIELD_Px(reg, HEADER_MODE_FIELD);
3321
3322        switch (search_state) {
3323        case 0: /* searching */
3324        case 1: /* first PLH detected */
3325        default:
3326                dprintk(FE_DEBUG, 1, "Status: Unlocked (Searching ..)");
3327                *status = 0;
3328                break;
3329
3330        case 2: /* DVB-S2 mode */
3331                dprintk(FE_DEBUG, 1, "Delivery system: DVB-S2");
3332                reg = STV090x_READ_DEMOD(state, DSTATUS);
3333                if (STV090x_GETFIELD_Px(reg, LOCK_DEFINITIF_FIELD)) {
3334                        reg = STV090x_READ_DEMOD(state, TSSTATUS);
3335                        if (STV090x_GETFIELD_Px(reg, TSFIFO_LINEOK_FIELD)) {
3336                                *status = FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK;
3337                        }
3338                }
3339                break;
3340
3341        case 3: /* DVB-S1/legacy mode */
3342                dprintk(FE_DEBUG, 1, "Delivery system: DVB-S");
3343                reg = STV090x_READ_DEMOD(state, DSTATUS);
3344                if (STV090x_GETFIELD_Px(reg, LOCK_DEFINITIF_FIELD)) {
3345                        reg = STV090x_READ_DEMOD(state, VSTATUSVIT);
3346                        if (STV090x_GETFIELD_Px(reg, LOCKEDVIT_FIELD)) {
3347                                reg = STV090x_READ_DEMOD(state, TSSTATUS);
3348                                if (STV090x_GETFIELD_Px(reg, TSFIFO_LINEOK_FIELD)) {
3349                                        *status = FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_SYNC | FE_HAS_LOCK;
3350                                }
3351                        }
3352                }
3353                break;
3354        }
3355
3356        return 0;
3357}
3358
3359static int stv090x_read_per(struct dvb_frontend *fe, u32 *per)
3360{
3361        struct stv090x_state *state = fe->demodulator_priv;
3362
3363        s32 count_4, count_3, count_2, count_1, count_0, count;
3364        u32 reg, h, m, l;
3365        enum fe_status status;
3366
3367        stv090x_read_status(fe, &status);
3368        if (!(status & FE_HAS_LOCK)) {
3369                *per = 1 << 23; /* Max PER */
3370        } else {
3371                /* Counter 2 */
3372                reg = STV090x_READ_DEMOD(state, ERRCNT22);
3373                h = STV090x_GETFIELD_Px(reg, ERR_CNT2_FIELD);
3374
3375                reg = STV090x_READ_DEMOD(state, ERRCNT21);
3376                m = STV090x_GETFIELD_Px(reg, ERR_CNT21_FIELD);
3377
3378                reg = STV090x_READ_DEMOD(state, ERRCNT20);
3379                l = STV090x_GETFIELD_Px(reg, ERR_CNT20_FIELD);
3380
3381                *per = ((h << 16) | (m << 8) | l);
3382
3383                count_4 = STV090x_READ_DEMOD(state, FBERCPT4);
3384                count_3 = STV090x_READ_DEMOD(state, FBERCPT3);
3385                count_2 = STV090x_READ_DEMOD(state, FBERCPT2);
3386                count_1 = STV090x_READ_DEMOD(state, FBERCPT1);
3387                count_0 = STV090x_READ_DEMOD(state, FBERCPT0);
3388
3389                if ((!count_4) && (!count_3)) {
3390                        count  = (count_2 & 0xff) << 16;
3391                        count |= (count_1 & 0xff) <<  8;
3392                        count |=  count_0 & 0xff;
3393                } else {
3394                        count = 1 << 24;
3395                }
3396                if (count == 0)
3397                        *per = 1;
3398        }
3399        if (STV090x_WRITE_DEMOD(state, FBERCPT4, 0) < 0)
3400                goto err;
3401        if (STV090x_WRITE_DEMOD(state, ERRCTRL2, 0xc1) < 0)
3402                goto err;
3403
3404        return 0;
3405err:
3406        dprintk(FE_ERROR, 1, "I/O error");
3407        return -1;
3408}
3409
3410static int stv090x_table_lookup(const struct stv090x_tab *tab, int max, int val)
3411{
3412        int res = 0;
3413        int min = 0, med;
3414
3415        if (val < tab[min].read)
3416                res = tab[min].real;
3417        else if (val >= tab[max].read)
3418                res = tab[max].real;
3419        else {
3420                while ((max - min) > 1) {
3421                        med = (max + min) / 2;
3422                        if (val >= tab[min].read && val < tab[med].read)
3423                                max = med;
3424                        else
3425                                min = med;
3426                }
3427                res = ((val - tab[min].read) *
3428                       (tab[max].real - tab[min].real) /
3429                       (tab[max].read - tab[min].read)) +
3430                        tab[min].real;
3431        }
3432
3433        return res;
3434}
3435
3436static int stv090x_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
3437{
3438        struct stv090x_state *state = fe->demodulator_priv;
3439        u32 reg;
3440        s32 agc;
3441
3442        reg = STV090x_READ_DEMOD(state, AGCIQIN1);
3443        agc = STV090x_GETFIELD_Px(reg, AGCIQ_VALUE_FIELD);
3444
3445        *strength = stv090x_table_lookup(stv090x_rf_tab, ARRAY_SIZE(stv090x_rf_tab) - 1, agc);
3446        if (agc > stv090x_rf_tab[0].read)
3447                *strength = 5;
3448        else if (agc < stv090x_rf_tab[ARRAY_SIZE(stv090x_rf_tab) - 1].read)
3449                *strength = -100;
3450
3451        return 0;
3452}
3453
3454static int stv090x_read_cnr(struct dvb_frontend *fe, u16 *cnr)
3455{
3456        struct stv090x_state *state = fe->demodulator_priv;
3457        u32 reg_0, reg_1, reg, i;
3458        s32 val_0, val_1, val = 0;
3459        u8 lock_f;
3460
3461        switch (state->delsys) {
3462        case STV090x_DVBS2:
3463                reg = STV090x_READ_DEMOD(state, DSTATUS);
3464                lock_f = STV090x_GETFIELD_Px(reg, LOCK_DEFINITIF_FIELD);
3465                if (lock_f) {
3466                        msleep(5);
3467                        for (i = 0; i < 16; i++) {
3468                                reg_1 = STV090x_READ_DEMOD(state, NNOSPLHT1);
3469                                val_1 = STV090x_GETFIELD_Px(reg_1, NOSPLHT_NORMED_FIELD);
3470                                reg_0 = STV090x_READ_DEMOD(state, NNOSPLHT0);
3471                                val_0 = STV090x_GETFIELD_Px(reg_1, NOSPLHT_NORMED_FIELD);
3472                                val  += MAKEWORD16(val_1, val_0);
3473                                msleep(1);
3474                        }
3475                        val /= 16;
3476                        *cnr = stv090x_table_lookup(stv090x_s2cn_tab, ARRAY_SIZE(stv090x_s2cn_tab) - 1, val);
3477                        if (val < stv090x_s2cn_tab[ARRAY_SIZE(stv090x_s2cn_tab) - 1].read)
3478                                *cnr = 1000;
3479                }
3480                break;
3481
3482        case STV090x_DVBS1:
3483        case STV090x_DSS:
3484                reg = STV090x_READ_DEMOD(state, DSTATUS);
3485                lock_f = STV090x_GETFIELD_Px(reg, LOCK_DEFINITIF_FIELD);
3486                if (lock_f) {
3487                        msleep(5);
3488                        for (i = 0; i < 16; i++) {
3489                                reg_1 = STV090x_READ_DEMOD(state, NOSDATAT1);
3490                                val_1 = STV090x_GETFIELD_Px(reg_1, NOSDATAT_UNNORMED_FIELD);
3491                                reg_0 = STV090x_READ_DEMOD(state, NOSDATAT0);
3492                                val_0 = STV090x_GETFIELD_Px(reg_1, NOSDATAT_UNNORMED_FIELD);
3493                                val  += MAKEWORD16(val_1, val_0);
3494                                msleep(1);
3495                        }
3496                        val /= 16;
3497                        *cnr = stv090x_table_lookup(stv090x_s1cn_tab, ARRAY_SIZE(stv090x_s1cn_tab) - 1, val);
3498                        if (val < stv090x_s2cn_tab[ARRAY_SIZE(stv090x_s1cn_tab) - 1].read)
3499                                *cnr = 1000;
3500                }
3501                break;
3502        default:
3503                break;
3504        }
3505
3506        return 0;
3507}
3508
3509static int stv090x_set_tone(struct dvb_frontend *fe, fe_sec_tone_mode_t tone)
3510{
3511        struct stv090x_state *state = fe->demodulator_priv;
3512        u32 reg;
3513
3514        reg = STV090x_READ_DEMOD(state, DISTXCTL);
3515        switch (tone) {
3516        case SEC_TONE_ON:
3517                STV090x_SETFIELD_Px(reg, DISTX_MODE_FIELD, 0);
3518                STV090x_SETFIELD_Px(reg, DISEQC_RESET_FIELD, 1);
3519                if (STV090x_WRITE_DEMOD(state, DISTXCTL, reg) < 0)
3520                        goto err;
3521                STV090x_SETFIELD_Px(reg, DISEQC_RESET_FIELD, 0);
3522                if (STV090x_WRITE_DEMOD(state, DISTXCTL, reg) < 0)
3523                        goto err;
3524                break;
3525
3526        case SEC_TONE_OFF:
3527                STV090x_SETFIELD_Px(reg, DISTX_MODE_FIELD, 0);
3528                STV090x_SETFIELD_Px(reg, DISEQC_RESET_FIELD, 1);
3529                if (STV090x_WRITE_DEMOD(state, DISTXCTL, reg) < 0)
3530                        goto err;
3531                break;
3532        default:
3533                return -EINVAL;
3534        }
3535
3536        return 0;
3537err:
3538        dprintk(FE_ERROR, 1, "I/O error");
3539        return -1;
3540}
3541
3542
3543static enum dvbfe_algo stv090x_frontend_algo(struct dvb_frontend *fe)
3544{
3545        return DVBFE_ALGO_CUSTOM;
3546}
3547
3548static int stv090x_send_diseqc_msg(struct dvb_frontend *fe, struct dvb_diseqc_master_cmd *cmd)
3549{
3550        struct stv090x_state *state = fe->demodulator_priv;
3551        u32 reg, idle = 0, fifo_full = 1;
3552        int i;
3553
3554        reg = STV090x_READ_DEMOD(state, DISTXCTL);
3555
3556        STV090x_SETFIELD_Px(reg, DISTX_MODE_FIELD, 2);
3557        STV090x_SETFIELD_Px(reg, DISEQC_RESET_FIELD, 1);
3558        if (STV090x_WRITE_DEMOD(state, DISTXCTL, reg) < 0)
3559                goto err;
3560        STV090x_SETFIELD_Px(reg, DISEQC_RESET_FIELD, 0);
3561        if (STV090x_WRITE_DEMOD(state, DISTXCTL, reg) < 0)
3562                goto err;
3563
3564        STV090x_SETFIELD_Px(reg, DIS_PRECHARGE_FIELD, 1);
3565        if (STV090x_WRITE_DEMOD(state, DISTXCTL, reg) < 0)
3566                goto err;
3567
3568        for (i = 0; i < cmd->msg_len; i++) {
3569
3570                while (fifo_full) {
3571                        reg = STV090x_READ_DEMOD(state, DISTXSTATUS);
3572                        fifo_full = STV090x_GETFIELD_Px(reg, FIFO_FULL_FIELD);
3573                }
3574
3575                if (STV090x_WRITE_DEMOD(state, DISTXDATA, cmd->msg[i]) < 0)
3576                        goto err;
3577        }
3578        reg = STV090x_READ_DEMOD(state, DISTXCTL);
3579        STV090x_SETFIELD_Px(reg, DIS_PRECHARGE_FIELD, 0);
3580        if (STV090x_WRITE_DEMOD(state, DISTXCTL, reg) < 0)
3581                goto err;
3582
3583        i = 0;
3584
3585        while ((!idle) && (i < 10)) {
3586                reg = STV090x_READ_DEMOD(state, DISTXSTATUS);
3587                idle = STV090x_GETFIELD_Px(reg, TX_IDLE_FIELD);
3588                msleep(10);
3589                i++;
3590        }
3591
3592        return 0;
3593err:
3594        dprintk(FE_ERROR, 1, "I/O error");
3595        return -1;
3596}
3597
3598static int stv090x_send_diseqc_burst(struct dvb_frontend *fe, fe_sec_mini_cmd_t burst)
3599{
3600        struct stv090x_state *state = fe->demodulator_priv;
3601        u32 reg, idle = 0, fifo_full = 1;
3602        u8 mode, value;
3603        int i;
3604
3605        reg = STV090x_READ_DEMOD(state, DISTXCTL);
3606
3607        if (burst == SEC_MINI_A) {
3608                mode = 3;
3609                value = 0x00;
3610        } else {
3611                mode = 2;
3612                value = 0xFF;
3613        }
3614
3615        STV090x_SETFIELD_Px(reg, DISTX_MODE_FIELD, mode);
3616        STV090x_SETFIELD_Px(reg, DISEQC_RESET_FIELD, 1);
3617        if (STV090x_WRITE_DEMOD(state, DISTXCTL, reg) < 0)
3618                goto err;
3619        STV090x_SETFIELD_Px(reg, DISEQC_RESET_FIELD, 0);
3620        if (STV090x_WRITE_DEMOD(state, DISTXCTL, reg) < 0)
3621                goto err;
3622
3623        STV090x_SETFIELD_Px(reg, DIS_PRECHARGE_FIELD, 1);
3624        if (STV090x_WRITE_DEMOD(state, DISTXCTL, reg) < 0)
3625                goto err;
3626
3627        while (fifo_full) {
3628                reg = STV090x_READ_DEMOD(state, DISTXSTATUS);
3629                fifo_full = STV090x_GETFIELD_Px(reg, FIFO_FULL_FIELD);
3630        }
3631
3632        if (STV090x_WRITE_DEMOD(state, DISTXDATA, value) < 0)
3633                goto err;
3634
3635        reg = STV090x_READ_DEMOD(state, DISTXCTL);
3636        STV090x_SETFIELD_Px(reg, DIS_PRECHARGE_FIELD, 0);
3637        if (STV090x_WRITE_DEMOD(state, DISTXCTL, reg) < 0)
3638                goto err;
3639
3640        i = 0;
3641
3642        while ((!idle) && (i < 10)) {
3643                reg = STV090x_READ_DEMOD(state, DISTXSTATUS);
3644                idle = STV090x_GETFIELD_Px(reg, TX_IDLE_FIELD);
3645                msleep(10);
3646                i++;
3647        }
3648
3649        return 0;
3650err:
3651        dprintk(FE_ERROR, 1, "I/O error");
3652        return -1;
3653}
3654
3655static int stv090x_recv_slave_reply(struct dvb_frontend *fe, struct dvb_diseqc_slave_reply *reply)
3656{
3657        struct stv090x_state *state = fe->demodulator_priv;
3658        u32 reg = 0, i = 0, rx_end = 0;
3659
3660        while ((rx_end != 1) && (i < 10)) {
3661                msleep(10);
3662                i++;
3663                reg = STV090x_READ_DEMOD(state, DISRX_ST0);
3664                rx_end = STV090x_GETFIELD_Px(reg, RX_END_FIELD);
3665        }
3666
3667        if (rx_end) {
3668                reply->msg_len = STV090x_GETFIELD_Px(reg, FIFO_BYTENBR_FIELD);
3669                for (i = 0; i < reply->msg_len; i++)
3670                        reply->msg[i] = STV090x_READ_DEMOD(state, DISRXDATA);
3671        }
3672
3673        return 0;
3674}
3675
3676static int stv090x_sleep(struct dvb_frontend *fe)
3677{
3678        struct stv090x_state *state = fe->demodulator_priv;
3679        u32 reg;
3680
3681        dprintk(FE_DEBUG, 1, "Set %s to sleep",
3682                state->device == STV0900 ? "STV0900" : "STV0903");
3683
3684        reg = stv090x_read_reg(state, STV090x_SYNTCTRL);
3685        STV090x_SETFIELD(reg, STANDBY_FIELD, 0x01);
3686        if (stv090x_write_reg(state, STV090x_SYNTCTRL, reg) < 0)
3687                goto err;
3688
3689        reg = stv090x_read_reg(state, STV090x_TSTTNR1);
3690        STV090x_SETFIELD(reg, ADC1_PON_FIELD, 0);
3691        if (stv090x_write_reg(state, STV090x_TSTTNR1, reg) < 0)
3692                goto err;
3693
3694        return 0;
3695err:
3696        dprintk(FE_ERROR, 1, "I/O error");
3697        return -1;
3698}
3699
3700static int stv090x_wakeup(struct dvb_frontend *fe)
3701{
3702        struct stv090x_state *state = fe->demodulator_priv;
3703        u32 reg;
3704
3705        dprintk(FE_DEBUG, 1, "Wake %s from standby",
3706                state->device == STV0900 ? "STV0900" : "STV0903");
3707
3708        reg = stv090x_read_reg(state, STV090x_SYNTCTRL);
3709        STV090x_SETFIELD(reg, STANDBY_FIELD, 0x00);
3710        if (stv090x_write_reg(state, STV090x_SYNTCTRL, reg) < 0)
3711                goto err;
3712
3713        reg = stv090x_read_reg(state, STV090x_TSTTNR1);
3714        STV090x_SETFIELD(reg, ADC1_PON_FIELD, 1);
3715        if (stv090x_write_reg(state, STV090x_TSTTNR1, reg) < 0)
3716                goto err;
3717
3718        return 0;
3719err:
3720        dprintk(FE_ERROR, 1, "I/O error");
3721        return -1;
3722}
3723
3724static void stv090x_release(struct dvb_frontend *fe)
3725{
3726        struct stv090x_state *state = fe->demodulator_priv;
3727
3728        kfree(state);
3729}
3730
3731static int stv090x_ldpc_mode(struct stv090x_state *state, enum stv090x_mode ldpc_mode)
3732{
3733        u32 reg = 0;
3734
3735        switch (ldpc_mode) {
3736        case STV090x_DUAL:
3737        default:
3738                if ((state->demod_mode != STV090x_DUAL) || (STV090x_GETFIELD(reg, DDEMOD_FIELD) != 1)) {
3739                        /* set LDPC to dual mode */
3740                        if (stv090x_write_reg(state, STV090x_GENCFG, 0x1d) < 0)
3741                                goto err;
3742
3743                        state->demod_mode = STV090x_DUAL;
3744
3745                        reg = stv090x_read_reg(state, STV090x_TSTRES0);
3746                        STV090x_SETFIELD(reg, FRESFEC_FIELD, 0x1);
3747                        if (stv090x_write_reg(state, STV090x_TSTRES0, reg) < 0)
3748                                goto err;
3749                        STV090x_SETFIELD(reg, FRESFEC_FIELD, 0x0);
3750                        if (stv090x_write_reg(state, STV090x_TSTRES0, reg) < 0)
3751                                goto err;
3752
3753                        if (STV090x_WRITE_DEMOD(state, MODCODLST0, 0xff) < 0)
3754                                goto err;
3755                        if (STV090x_WRITE_DEMOD(state, MODCODLST1, 0xff) < 0)
3756                                goto err;
3757                        if (STV090x_WRITE_DEMOD(state, MODCODLST2, 0xff) < 0)
3758                                goto err;
3759                        if (STV090x_WRITE_DEMOD(state, MODCODLST3, 0xff) < 0)
3760                                goto err;
3761                        if (STV090x_WRITE_DEMOD(state, MODCODLST4, 0xff) < 0)
3762                                goto err;
3763                        if (STV090x_WRITE_DEMOD(state, MODCODLST5, 0xff) < 0)
3764                                goto err;
3765                        if (STV090x_WRITE_DEMOD(state, MODCODLST6, 0xff) < 0)
3766                                goto err;
3767
3768                        if (STV090x_WRITE_DEMOD(state, MODCODLST7, 0xcc) < 0)
3769                                goto err;
3770                        if (STV090x_WRITE_DEMOD(state, MODCODLST8, 0xcc) < 0)
3771                                goto err;
3772                        if (STV090x_WRITE_DEMOD(state, MODCODLST9, 0xcc) < 0)
3773                                goto err;
3774                        if (STV090x_WRITE_DEMOD(state, MODCODLSTA, 0xcc) < 0)
3775                                goto err;
3776                        if (STV090x_WRITE_DEMOD(state, MODCODLSTB, 0xcc) < 0)
3777                                goto err;
3778                        if (STV090x_WRITE_DEMOD(state, MODCODLSTC, 0xcc) < 0)
3779                                goto err;
3780                        if (STV090x_WRITE_DEMOD(state, MODCODLSTD, 0xcc) < 0)
3781                                goto err;
3782
3783                        if (STV090x_WRITE_DEMOD(state, MODCODLSTE, 0xff) < 0)
3784                                goto err;
3785                        if (STV090x_WRITE_DEMOD(state, MODCODLSTF, 0xcf) < 0)
3786                                goto err;
3787                }
3788                break;
3789
3790        case STV090x_SINGLE:
3791                if (stv090x_stop_modcod(state) < 0)
3792                        goto err;
3793                if (stv090x_activate_modcod_single(state) < 0)
3794                        goto err;
3795
3796                if (state->demod == STV090x_DEMODULATOR_1) {
3797                        if (stv090x_write_reg(state, STV090x_GENCFG, 0x06) < 0) /* path 2 */
3798                                goto err;
3799                } else {
3800                        if (stv090x_write_reg(state, STV090x_GENCFG, 0x04) < 0) /* path 1 */
3801                                goto err;
3802                }
3803
3804                reg = stv090x_read_reg(state, STV090x_TSTRES0);
3805                STV090x_SETFIELD(reg, FRESFEC_FIELD, 0x1);
3806                if (stv090x_write_reg(state, STV090x_TSTRES0, reg) < 0)
3807                        goto err;
3808                STV090x_SETFIELD(reg, FRESFEC_FIELD, 0x0);
3809                if (stv090x_write_reg(state, STV090x_TSTRES0, reg) < 0)
3810                        goto err;
3811
3812                reg = STV090x_READ_DEMOD(state, PDELCTRL1);
3813                STV090x_SETFIELD_Px(reg, ALGOSWRST_FIELD, 0x01);
3814                if (STV090x_WRITE_DEMOD(state, PDELCTRL1, reg) < 0)
3815                        goto err;
3816                STV090x_SETFIELD_Px(reg, ALGOSWRST_FIELD, 0x00);
3817                if (STV090x_WRITE_DEMOD(state, PDELCTRL1, reg) < 0)
3818                        goto err;
3819                break;
3820        }
3821
3822        return 0;
3823err:
3824        dprintk(FE_ERROR, 1, "I/O error");
3825        return -1;
3826}
3827
3828/* return (Hz), clk in Hz*/
3829static u32 stv090x_get_mclk(struct stv090x_state *state)
3830{
3831        const struct stv090x_config *config = state->config;
3832        u32 div, reg;
3833        u8 ratio;
3834
3835        div = stv090x_read_reg(state, STV090x_NCOARSE);
3836        reg = stv090x_read_reg(state, STV090x_SYNTCTRL);
3837        ratio = STV090x_GETFIELD(reg, SELX1RATIO_FIELD) ? 4 : 6;
3838
3839        return (div + 1) * config->xtal / ratio; /* kHz */
3840}
3841
3842static int stv090x_set_mclk(struct stv090x_state *state, u32 mclk, u32 clk)
3843{
3844        const struct stv090x_config *config = state->config;
3845        u32 reg, div, clk_sel;
3846
3847        reg = stv090x_read_reg(state, STV090x_SYNTCTRL);
3848        clk_sel = ((STV090x_GETFIELD(reg, SELX1RATIO_FIELD) == 1) ? 4 : 6);
3849
3850        div = ((clk_sel * mclk) / config->xtal) - 1;
3851
3852        reg = stv090x_read_reg(state, STV090x_NCOARSE);
3853        STV090x_SETFIELD(reg, M_DIV_FIELD, div);
3854        if (stv090x_write_reg(state, STV090x_NCOARSE, reg) < 0)
3855                goto err;
3856
3857        state->mclk = stv090x_get_mclk(state);
3858
3859        /*Set the DiseqC frequency to 22KHz */
3860        div = state->mclk / 704000;
3861        if (STV090x_WRITE_DEMOD(state, F22TX, div) < 0)
3862                goto err;
3863        if (STV090x_WRITE_DEMOD(state, F22RX, div) < 0)
3864                goto err;
3865
3866        return 0;
3867err:
3868        dprintk(FE_ERROR, 1, "I/O error");
3869        return -1;
3870}
3871
3872static int stv090x_set_tspath(struct stv090x_state *state)
3873{
3874        u32 reg;
3875
3876        if (state->dev_ver >= 0x20) {
3877                switch (state->config->ts1_mode) {
3878                case STV090x_TSMODE_PARALLEL_PUNCTURED:
3879                case STV090x_TSMODE_DVBCI:
3880                        switch (state->config->ts2_mode) {
3881                        case STV090x_TSMODE_SERIAL_PUNCTURED:
3882                        case STV090x_TSMODE_SERIAL_CONTINUOUS:
3883                        default:
3884                                stv090x_write_reg(state, STV090x_TSGENERAL, 0x00);
3885                                break;
3886
3887                        case STV090x_TSMODE_PARALLEL_PUNCTURED:
3888                        case STV090x_TSMODE_DVBCI:
3889                                if (stv090x_write_reg(state, STV090x_TSGENERAL, 0x06) < 0) /* Mux'd stream mode */
3890                                        goto err;
3891                                reg = stv090x_read_reg(state, STV090x_P1_TSCFGM);
3892                                STV090x_SETFIELD_Px(reg, TSFIFO_MANSPEED_FIELD, 3);
3893                                if (stv090x_write_reg(state, STV090x_P1_TSCFGM, reg) < 0)
3894                                        goto err;
3895                                reg = stv090x_read_reg(state, STV090x_P2_TSCFGM);
3896                                STV090x_SETFIELD_Px(reg, TSFIFO_MANSPEED_FIELD, 3);
3897                                if (stv090x_write_reg(state, STV090x_P2_TSCFGM, reg) < 0)
3898                                        goto err;
3899                                if (stv090x_write_reg(state, STV090x_P1_TSSPEED, 0x14) < 0)
3900                                        goto err;
3901                                if (stv090x_write_reg(state, STV090x_P2_TSSPEED, 0x28) < 0)
3902                                        goto err;
3903                                break;
3904                        }
3905                        break;
3906
3907                case STV090x_TSMODE_SERIAL_PUNCTURED:
3908                case STV090x_TSMODE_SERIAL_CONTINUOUS:
3909                default:
3910                        switch (state->config->ts2_mode) {
3911                        case STV090x_TSMODE_SERIAL_PUNCTURED:
3912                        case STV090x_TSMODE_SERIAL_CONTINUOUS:
3913                        default:
3914                                if (stv090x_write_reg(state, STV090x_TSGENERAL, 0x0c) < 0)
3915                                        goto err;
3916                                break;
3917
3918                        case STV090x_TSMODE_PARALLEL_PUNCTURED:
3919                        case STV090x_TSMODE_DVBCI:
3920                                if (stv090x_write_reg(state, STV090x_TSGENERAL, 0x0a) < 0)
3921                                        goto err;
3922                                break;
3923                        }
3924                        break;
3925                }
3926        } else {
3927                switch (state->config->ts1_mode) {
3928                case STV090x_TSMODE_PARALLEL_PUNCTURED:
3929                case STV090x_TSMODE_DVBCI:
3930                        switch (state->config->ts2_mode) {
3931                        case STV090x_TSMODE_SERIAL_PUNCTURED:
3932                        case STV090x_TSMODE_SERIAL_CONTINUOUS:
3933                        default:
3934                                stv090x_write_reg(state, STV090x_TSGENERAL1X, 0x10);
3935                                break;
3936
3937                        case STV090x_TSMODE_PARALLEL_PUNCTURED:
3938                        case STV090x_TSMODE_DVBCI:
3939                                stv090x_write_reg(state, STV090x_TSGENERAL1X, 0x16);
3940                                reg = stv090x_read_reg(state, STV090x_P1_TSCFGM);
3941                                STV090x_SETFIELD_Px(reg, TSFIFO_MANSPEED_FIELD, 3);
3942                                if (stv090x_write_reg(state, STV090x_P1_TSCFGM, reg) < 0)
3943                                        goto err;
3944                                reg = stv090x_read_reg(state, STV090x_P1_TSCFGM);
3945                                STV090x_SETFIELD_Px(reg, TSFIFO_MANSPEED_FIELD, 0);
3946                                if (stv090x_write_reg(state, STV090x_P1_TSCFGM, reg) < 0)
3947                                        goto err;
3948                                if (stv090x_write_reg(state, STV090x_P1_TSSPEED, 0x14) < 0)
3949                                        goto err;
3950                                if (stv090x_write_reg(state, STV090x_P2_TSSPEED, 0x28) < 0)
3951                                        goto err;
3952                                break;
3953                        }
3954                        break;
3955
3956                case STV090x_TSMODE_SERIAL_PUNCTURED:
3957                case STV090x_TSMODE_SERIAL_CONTINUOUS:
3958                default:
3959                        switch (state->config->ts2_mode) {
3960                        case STV090x_TSMODE_SERIAL_PUNCTURED:
3961                        case STV090x_TSMODE_SERIAL_CONTINUOUS:
3962                        default:
3963                                stv090x_write_reg(state, STV090x_TSGENERAL1X, 0x14);
3964                                break;
3965
3966                        case STV090x_TSMODE_PARALLEL_PUNCTURED:
3967                        case STV090x_TSMODE_DVBCI:
3968                                stv090x_write_reg(state, STV090x_TSGENERAL1X, 0x12);
3969                                break;
3970                        }
3971                        break;
3972                }
3973        }
3974
3975        switch (state->config->ts1_mode) {
3976        case STV090x_TSMODE_PARALLEL_PUNCTURED:
3977                reg = stv090x_read_reg(state, STV090x_P1_TSCFGH);
3978                STV090x_SETFIELD_Px(reg, TSFIFO_SERIAL_FIELD, 0x00);
3979                STV090x_SETFIELD_Px(reg, TSFIFO_DVBCI_FIELD, 0x00);
3980                if (stv090x_write_reg(state, STV090x_P1_TSCFGH, reg) < 0)
3981                        goto err;
3982                break;
3983
3984        case STV090x_TSMODE_DVBCI:
3985                reg = stv090x_read_reg(state, STV090x_P1_TSCFGH);
3986                STV090x_SETFIELD_Px(reg, TSFIFO_SERIAL_FIELD, 0x00);
3987                STV090x_SETFIELD_Px(reg, TSFIFO_DVBCI_FIELD, 0x01);
3988                if (stv090x_write_reg(state, STV090x_P1_TSCFGH, reg) < 0)
3989                        goto err;
3990                break;
3991
3992        case STV090x_TSMODE_SERIAL_PUNCTURED:
3993                reg = stv090x_read_reg(state, STV090x_P1_TSCFGH);
3994                STV090x_SETFIELD_Px(reg, TSFIFO_SERIAL_FIELD, 0x01);
3995                STV090x_SETFIELD_Px(reg, TSFIFO_DVBCI_FIELD, 0x00);
3996                if (stv090x_write_reg(state, STV090x_P1_TSCFGH, reg) < 0)
3997                        goto err;
3998                break;
3999
4000        case STV090x_TSMODE_SERIAL_CONTINUOUS:

4001                reg = stv090x_read_reg(state, STV090x_P1_TSCFGH);
4002                STV090x_SETFIELD_Px(reg, TSFIFO_SERIAL_FIELD, 0x01);
4003                STV090x_SETFIELD_Px(reg, TSFIFO_DVBCI_FIELD, 0x01);
4004                if (stv090x_write_reg(state, STV090x_P1_TSCFGH, reg) < 0)
4005                        goto err;
4006                break;
4007
4008        default:
4009                break;
4010        }
4011
4012        switch (state->config->ts2_mode) {
4013        case STV090x_TSMODE_PARALLEL_PUNCTURED:
4014                reg = stv090x_read_reg(state, STV090x_P2_TSCFGH);
4015                STV090x_SETFIELD_Px(reg, TSFIFO_SERIAL_FIELD, 0x00);
4016                STV090x_SETFIELD_Px(reg, TSFIFO_DVBCI_FIELD, 0x00);
4017                if (stv090x_write_reg(state, STV090x_P2_TSCFGH, reg) < 0)
4018                        goto err;
4019                break;
4020
4021        case STV090x_TSMODE_DVBCI:
4022                reg = stv090x_read_reg(state, STV090x_P2_TSCFGH);
4023                STV090x_SETFIELD_Px(reg, TSFIFO_SERIAL_FIELD, 0x00);
4024                STV090x_SETFIELD_Px(reg, TSFIFO_DVBCI_FIELD, 0x01);
4025                if (stv090x_write_reg(state, STV090x_P2_TSCFGH, reg) < 0)
4026                        goto err;
4027                break;
4028
4029        case STV090x_TSMODE_SERIAL_PUNCTURED:
4030                reg = stv090x_read_reg(state, STV090x_P2_TSCFGH);
4031                STV090x_SETFIELD_Px(reg, TSFIFO_SERIAL_FIELD, 0x01);
4032                STV090x_SETFIELD_Px(reg, TSFIFO_DVBCI_FIELD, 0x00);
4033                if (stv090x_write_reg(state, STV090x_P2_TSCFGH, reg) < 0)
4034                        goto err;
4035                break;
4036
4037        case STV090x_TSMODE_SERIAL_CONTINUOUS:
4038                reg = stv090x_read_reg(state, STV090x_P2_TSCFGH);
4039                STV090x_SETFIELD_Px(reg, TSFIFO_SERIAL_FIELD, 0x01);
4040                STV090x_SETFIELD_Px(reg, TSFIFO_DVBCI_FIELD, 0x01);
4041                if (stv090x_write_reg(state, STV090x_P2_TSCFGH, reg) < 0)
4042                        goto err;
4043                break;
4044
4045        default:
4046                break;
4047        }
4048        reg = stv090x_read_reg(state, STV090x_P2_TSCFGH);
4049        STV090x_SETFIELD_Px(reg, RST_HWARE_FIELD, 0x01);
4050        if (stv090x_write_reg(state, STV090x_P2_TSCFGH, reg) < 0)
4051                goto err;
4052        STV090x_SETFIELD_Px(reg, RST_HWARE_FIELD, 0x00);
4053        if (stv090x_write_reg(state, STV090x_P2_TSCFGH, reg) < 0)
4054                goto err;
4055
4056        reg = stv090x_read_reg(state, STV090x_P1_TSCFGH);
4057        STV090x_SETFIELD_Px(reg, RST_HWARE_FIELD, 0x01);
4058        if (stv090x_write_reg(state, STV090x_P1_TSCFGH, reg) < 0)
4059                goto err;
4060        STV090x_SETFIELD_Px(reg, RST_HWARE_FIELD, 0x00);
4061        if (stv090x_write_reg(state, STV090x_P1_TSCFGH, reg) < 0)
4062                goto err;
4063
4064        return 0;
4065err:
4066        dprintk(FE_ERROR, 1, "I/O error");
4067        return -1;
4068}
4069
4070static int stv090x_init(struct dvb_frontend *fe)
4071{
4072        struct stv090x_state *state = fe->demodulator_priv;
4073        const struct stv090x_config *config = state->config;
4074        u32 reg;
4075
4076        if (stv090x_wakeup(fe) < 0) {
4077                dprintk(FE_ERROR, 1, "Error waking device");
4078                goto err;
4079        }
4080
4081        if (stv090x_ldpc_mode(state, state->demod_mode) < 0)
4082                goto err;
4083
4084        reg = STV090x_READ_DEMOD(state, TNRCFG2);
4085        STV090x_SETFIELD_Px(reg, TUN_IQSWAP_FIELD, state->inversion);
4086        if (STV090x_WRITE_DEMOD(state, TNRCFG2, reg) < 0)
4087                goto err;
4088        reg = STV090x_READ_DEMOD(state, DEMOD);
4089        STV090x_SETFIELD_Px(reg, ROLLOFF_CONTROL_FIELD, state->rolloff);
4090        if (STV090x_WRITE_DEMOD(state, DEMOD, reg) < 0)
4091                goto err;
4092
4093        if (stv090x_i2c_gate_ctrl(fe, 1) < 0)
4094                goto err;
4095
4096        if (config->tuner_set_mode) {
4097                if (config->tuner_set_mode(fe, TUNER_WAKE) < 0)
4098                        goto err;
4099        }
4100
4101        if (config->tuner_init) {
4102                if (config->tuner_init(fe) < 0)
4103                        goto err;
4104        }
4105
4106        if (stv090x_i2c_gate_ctrl(fe, 0) < 0)
4107                goto err;
4108
4109        if (stv090x_set_tspath(state) < 0)
4110                goto err;
4111
4112        return 0;
4113err:
4114        dprintk(FE_ERROR, 1, "I/O error");
4115        return -1;
4116}
4117
4118static int stv090x_setup(struct dvb_frontend *fe)
4119{
4120        struct stv090x_state *state = fe->demodulator_priv;
4121        const struct stv090x_config *config = state->config;
4122        const struct stv090x_reg *stv090x_initval = NULL;
4123        const struct stv090x_reg *stv090x_cut20_val = NULL;
4124        unsigned long t1_size = 0, t2_size = 0;
4125        u32 reg = 0;
4126
4127        int i;
4128
4129        if (state->device == STV0900) {
4130                dprintk(FE_DEBUG, 1, "Initializing STV0900");
4131                stv090x_initval = stv0900_initval;
4132                t1_size = ARRAY_SIZE(stv0900_initval);
4133                stv090x_cut20_val = stv0900_cut20_val;
4134                t2_size = ARRAY_SIZE(stv0900_cut20_val);
4135        } else if (state->device == STV0903) {
4136                dprintk(FE_DEBUG, 1, "Initializing STV0903");
4137                stv090x_initval = stv0903_initval;
4138                t1_size = ARRAY_SIZE(stv0903_initval);
4139                stv090x_cut20_val = stv0903_cut20_val;
4140                t2_size = ARRAY_SIZE(stv0903_cut20_val);
4141        }
4142
4143        /* STV090x init */
4144        if (STV090x_WRITE_DEMOD(state, DMDISTATE, 0x5c) < 0) /* Stop Demod */
4145                goto err;
4146
4147        msleep(5);
4148
4149        if (STV090x_WRITE_DEMOD(state, TNRCFG, 0x6c) < 0) /* check register ! (No Tuner Mode) */
4150                goto err;
4151
4152        STV090x_SETFIELD_Px(reg, ENARPT_LEVEL_FIELD, config->repeater_level);
4153        if (STV090x_WRITE_DEMOD(state, I2CRPT, reg) < 0) /* repeater OFF */
4154                goto err;
4155
4156        if (stv090x_write_reg(state, STV090x_NCOARSE, 0x13) < 0) /* set PLL divider */
4157                goto err;
4158        msleep(5);
4159        if (stv090x_write_reg(state, STV090x_I2CCFG, 0x08) < 0) /* 1/41 oversampling */
4160                goto err;
4161        if (stv090x_write_reg(state, STV090x_SYNTCTRL, 0x20 | config->clk_mode) < 0) /* enable PLL */
4162                goto err;
4163        msleep(5);
4164
4165        /* write initval */
4166        dprintk(FE_DEBUG, 1, "Setting up initial values");
4167        for (i = 0; i < t1_size; i++) {
4168                if (stv090x_write_reg(state, stv090x_initval[i].addr, stv090x_initval[i].data) < 0)
4169                        goto err;
4170        }
4171
4172        state->dev_ver = stv090x_read_reg(state, STV090x_MID);
4173        if (state->dev_ver >= 0x20) {
4174                if (stv090x_write_reg(state, STV090x_TSGENERAL, 0x0c) < 0)
4175                        goto err;
4176
4177                /* write cut20_val*/
4178                dprintk(FE_DEBUG, 1, "Setting up Cut 2.0 initial values");
4179                for (i = 0; i < t2_size; i++) {
4180                        if (stv090x_write_reg(state, stv090x_cut20_val[i].addr, stv090x_cut20_val[i].data) < 0)
4181                                goto err;
4182                }
4183
4184        } else if (state->dev_ver < 0x20) {
4185                dprintk(FE_ERROR, 1, "ERROR: Unsupported Cut: 0x%02x!",
4186                        state->dev_ver);
4187
4188                goto err;
4189        } else if (state->dev_ver > 0x30) {
4190                /* we shouldn't bail out from here */
4191                dprintk(FE_ERROR, 1, "INFO: Cut: 0x%02x probably incomplete support!",
4192                        state->dev_ver);
4193        }
4194
4195        if (stv090x_write_reg(state, STV090x_TSTRES0, 0x80) < 0)
4196                goto err;
4197        if (stv090x_write_reg(state, STV090x_TSTRES0, 0x00) < 0)
4198                goto err;
4199
4200        stv090x_set_mclk(state, 135000000, config->xtal); /* 135 Mhz */
4201        msleep(5);
4202        if (stv090x_write_reg(state, STV090x_SYNTCTRL, 0x20 | config->clk_mode) < 0)
4203                goto err;
4204        stv090x_get_mclk(state);
4205
4206        return 0;
4207err:
4208        dprintk(FE_ERROR, 1, "I/O error");
4209        return -1;
4210}
4211
4212static struct dvb_frontend_ops stv090x_ops = {
4213
4214        .info = {
4215                .name                   = "STV090x Multistandard",
4216                .type                   = FE_QPSK,
4217                .frequency_min          = 950000,
4218                .frequency_max          = 2150000,
4219                .frequency_stepsize     = 0,
4220                .frequency_tolerance    = 0,
4221                .symbol_rate_min        = 1000000,
4222                .symbol_rate_max        = 45000000,
4223                .caps                   = FE_CAN_INVERSION_AUTO |
4224                                          FE_CAN_FEC_AUTO       |
4225                                          FE_CAN_QPSK           |
4226                                          FE_CAN_2G_MODULATION
4227        },
4228
4229        .release                        = stv090x_release,
4230        .init                           = stv090x_init,
4231
4232        .sleep                          = stv090x_sleep,
4233        .get_frontend_algo              = stv090x_frontend_algo,
4234
4235        .i2c_gate_ctrl                  = stv090x_i2c_gate_ctrl,
4236
4237        .diseqc_send_master_cmd         = stv090x_send_diseqc_msg,
4238        .diseqc_send_burst              = stv090x_send_diseqc_burst,
4239        .diseqc_recv_slave_reply        = stv090x_recv_slave_reply,
4240        .set_tone                       = stv090x_set_tone,
4241
4242        .search                         = stv090x_search,
4243        .read_status                    = stv090x_read_status,
4244        .read_ber                       = stv090x_read_per,
4245        .read_signal_strength           = stv090x_read_signal_strength,
4246        .read_snr                       = stv090x_read_cnr
4247};
4248
4249
4250struct dvb_frontend *stv090x_attach(const struct stv090x_config *config,
4251                                    struct i2c_adapter *i2c,
4252                                    enum stv090x_demodulator demod)
4253{
4254        struct stv090x_state *state = NULL;
4255
4256        state = kzalloc(sizeof (struct stv090x_state), GFP_KERNEL);
4257        if (state == NULL)
4258                goto error;
4259
4260        state->verbose                          = &verbose;
4261        state->config                           = config;
4262        state->i2c                              = i2c;
4263        state->frontend.ops                     = stv090x_ops;
4264        state->frontend.demodulator_priv        = state;
4265        state->demod                            = demod;
4266        state->demod_mode                       = config->demod_mode; /* Single or Dual mode */
4267        state->device                           = config->device;
4268        state->rolloff                          = STV090x_RO_35; /* default */
4269
4270        if (state->demod == STV090x_DEMODULATOR_0)
4271                mutex_init(&demod_lock);
4272
4273        if (stv090x_sleep(&state->frontend) < 0) {
4274                dprintk(FE_ERROR, 1, "Error putting device to sleep");
4275                goto error;
4276        }
4277
4278        if (stv090x_setup(&state->frontend) < 0) {
4279                dprintk(FE_ERROR, 1, "Error setting up device");
4280                goto error;
4281        }
4282        if (stv090x_wakeup(&state->frontend) < 0) {
4283                dprintk(FE_ERROR, 1, "Error waking device");
4284                goto error;
4285        }
4286
4287        dprintk(FE_ERROR, 1, "Attaching %s demodulator(%d) Cut=0x%02x\n",
4288               state->device == STV0900 ? "STV0900" : "STV0903",
4289               demod,
4290               state->dev_ver);
4291
4292        return &state->frontend;
4293
4294error:
4295        kfree(state);
4296        return NULL;
4297}
4298EXPORT_SYMBOL(stv090x_attach);
4299MODULE_PARM_DESC(verbose, "Set Verbosity level");
4300MODULE_AUTHOR("Manu Abraham");
4301MODULE_DESCRIPTION("STV090x Multi-Std Broadcast frontend");
4302MODULE_LICENSE("GPL");
4303