drivers/media/dvb/frontends/stv0297.c

   1 /*
   2     Driver for STV0297 demodulator
   3
   4     Copyright (C) 2004 Andrew de Quincey <adq_dvb@lidskialf.net>
   5     Copyright (C) 2003-2004 Dennis Noermann <dennis.noermann@noernet.de>
   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/delay.h>
  27
  28 #include "dvb_frontend.h"
  29 #include "stv0297.h"
  30
  31 struct stv0297_state {
  32
  33         struct i2c_adapter* i2c;
  34
  35         struct dvb_frontend_ops ops;
  36
  37         const struct stv0297_config* config;
  38
  39         struct dvb_frontend frontend;
  40
  41         unsigned long base_freq;
  42         u8 pwm;
  43 };
  44
  45 #if 1
  46 #define dprintk(x...) printk(x)
  47 #else
  48 #define dprintk(x...)
  49 #endif
  50
  51 #define STV0297_CLOCK_KHZ   28900
  52
  53 static u8 init_tab [] = {
  54   0x00, 0x09,
  55   0x01, 0x69,
  56   0x03, 0x00,
  57   0x04, 0x00,
  58   0x07, 0x00,
  59   0x08, 0x00,
  60   0x20, 0x00,
  61   0x21, 0x40,
  62   0x22, 0x00,
  63   0x23, 0x00,
  64   0x24, 0x40,
  65   0x25, 0x88,
  66   0x30, 0xff,
  67   0x31, 0x00,
  68   0x32, 0xff,
  69   0x33, 0x00,
  70   0x34, 0x50,
  71   0x35, 0x7f,
  72   0x36, 0x00,
  73   0x37, 0x20,
  74   0x38, 0x00,
  75   0x40, 0x1c,
  76   0x41, 0xff,
  77   0x42, 0x29,
  78         0x43, 0x00,
  79   0x44, 0xff,
  80   0x45, 0x00,
  81   0x46, 0x00,
  82   0x49, 0x04,
  83   0x4a, 0xff,
  84   0x4b, 0x7f,
  85   0x52, 0x30,
  86   0x55, 0xae,
  87   0x56, 0x47,
  88   0x57, 0xe1,
  89   0x58, 0x3a,
  90   0x5a, 0x1e,
  91   0x5b, 0x34,
  92   0x60, 0x00,
  93   0x63, 0x00,
  94   0x64, 0x00,
  95   0x65, 0x00,
  96   0x66, 0x00,
  97   0x67, 0x00,
  98   0x68, 0x00,
  99   0x69, 0x00,
 100   0x6a, 0x02,
 101   0x6b, 0x00,
 102   0x70, 0xff,
 103   0x71, 0x00,
 104   0x72, 0x00,
 105   0x73, 0x00,
 106   0x74, 0x0c,
 107   0x80, 0x00,
 108   0x81, 0x00,
 109   0x82, 0x00,
 110   0x83, 0x00,
 111   0x84, 0x04,
 112   0x85, 0x80,
 113   0x86, 0x24,
 114   0x87, 0x78,
 115   0x88, 0x00,
 116   0x89, 0x00,
 117   0x90, 0x01,
 118   0x91, 0x01,
 119   0xa0, 0x00,
 120   0xa1, 0x00,
 121   0xa2, 0x00,
 122   0xb0, 0x91,
 123   0xb1, 0x0b,
 124   0xc0, 0x53,
 125   0xc1, 0x70,
 126   0xc2, 0x12,
 127   0xd0, 0x00,
 128   0xd1, 0x00,
 129   0xd2, 0x00,
 130   0xd3, 0x00,
 131   0xd4, 0x00,
 132   0xd5, 0x00,
 133   0xde, 0x00,
 134   0xdf, 0x00,
 135   0x61, 0x49,
 136   0x62, 0x0b,
 137   0x53, 0x08,
 138   0x59, 0x08,
 139 };
 140
 141
 142 static int stv0297_writereg (struct stv0297_state* state, u8 reg, u8 data)
 143 {
 144         int ret;
 145         u8 buf [] = { reg, data };
 146         struct i2c_msg msg = { .addr = state->config->demod_address, .flags = 0, .buf = buf, .len = 2 };
 147
 148         ret = i2c_transfer (state->i2c, &msg, 1);
 149
 150         if (ret != 1)
 151                 dprintk("%s: writereg error (reg == 0x%02x, val == 0x%02x, "
 152                   "ret == %i)\n", __FUNCTION__, reg, data, ret);
 153
 154         return (ret != 1) ? -1 : 0;
 155 }
 156
 157 static int stv0297_readreg (struct stv0297_state* state, u8 reg)
 158 {
 159         int ret;
 160         u8 b0[] = { reg };
 161         u8 b1[] = { 0 };
 162         struct i2c_msg msg[] = { {.addr = state->config->demod_address,.flags = 0,.buf = b0,.len =
 163                                   1},
 164         {.addr = state->config->demod_address,.flags = I2C_M_RD,.buf = b1,.len = 1}
 165         };
 166
 167         // this device needs a STOP between the register and data
 168         if ((ret = i2c_transfer (state->i2c, &msg[0], 1)) != 1) {
 169                 dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n", __FUNCTION__, reg, ret);
 170                 return -1;
 171         }
 172         if ((ret = i2c_transfer (state->i2c, &msg[1], 1)) != 1) {
 173                 dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n", __FUNCTION__, reg, ret);
 174                 return -1;
 175         }
 176
 177         return b1[0];
 178 }
 179
 180 static int stv0297_writereg_mask (struct stv0297_state* state, u8 reg, u8 mask, u8 data)
 181 {
 182         int val;
 183
 184         val = stv0297_readreg(state, reg);
 185         val &= ~mask;
 186         val |= (data & mask);
 187         stv0297_writereg(state, reg, val);
 188
 189         return 0;
 190 }
 191
 192 static int stv0297_readregs (struct stv0297_state* state, u8 reg1, u8 *b, u8 len)
 193 {
 194         int ret;
 195         struct i2c_msg msg[] = { {.addr = state->config->demod_address,.flags = 0,.buf =
 196                                   &reg1,.len = 1},
 197         {.addr = state->config->demod_address,.flags = I2C_M_RD,.buf = b,.len = len}
 198         };
 199
 200         // this device needs a STOP between the register and data
 201         if ((ret = i2c_transfer (state->i2c, &msg[0], 1)) != 1) {
 202                 dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n", __FUNCTION__, reg1, ret);
 203                 return -1;
 204         }
 205         if ((ret = i2c_transfer (state->i2c, &msg[1], 1)) != 1) {
 206                 dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n", __FUNCTION__, reg1, ret);
 207                 return -1;
 208         }
 209
 210         return 0;
 211 }
 212
 213 static u32 stv0297_get_symbolrate(struct stv0297_state *state)
 214 {
 215         u64 tmp;
 216
 217         tmp = stv0297_readreg(state, 0x55);
 218         tmp |= stv0297_readreg(state, 0x56) << 8;
 219         tmp |= stv0297_readreg(state, 0x57) << 16;
 220         tmp |= stv0297_readreg(state, 0x58) << 24;
 221
 222         tmp *= STV0297_CLOCK_KHZ;
 223         tmp >>= 32;
 224
 225         return (u32) tmp;
 226 }
 227
 228 static void stv0297_set_symbolrate(struct stv0297_state *state, u32 srate)
 229 {
 230         long tmp;
 231
 232         tmp = 131072L * srate;  /* 131072 = 2^17  */
 233         tmp = tmp / (STV0297_CLOCK_KHZ / 4);    /* 1/4 = 2^-2 */
 234         tmp = tmp * 8192L;      /* 8192 = 2^13 */
 235
 236         stv0297_writereg (state, 0x55,(unsigned char)(tmp & 0xFF));
 237         stv0297_writereg (state, 0x56,(unsigned char)(tmp>> 8));
 238         stv0297_writereg (state, 0x57,(unsigned char)(tmp>>16));
 239         stv0297_writereg (state, 0x58,(unsigned char)(tmp>>24));
 240 }
 241
 242 static void stv0297_set_sweeprate(struct stv0297_state *state, short fshift, long symrate)
 243 {
 244         long tmp;
 245
 246         tmp = (long) fshift *262144L;   /* 262144 = 2*18 */
 247         tmp /= symrate;
 248         tmp *= 1024;            /* 1024 = 2*10   */
 249
 250         // adjust
 251         if (tmp >= 0) {
 252                 tmp += 500000;
 253         } else {
 254                 tmp -= 500000;
 255         }
 256         tmp /= 1000000;
 257
 258         stv0297_writereg(state, 0x60, tmp & 0xFF);
 259         stv0297_writereg_mask(state, 0x69, 0xF0, (tmp >> 4) & 0xf0);
 260 }
 261
 262 static void stv0297_set_carrieroffset(struct stv0297_state* state, long offset)
 263 {
 264         long tmp;
 265
 266         /* symrate is hardcoded to 10000 */
 267         tmp = offset * 26844L;  /* (2**28)/10000 */
 268         if (tmp < 0)
 269                 tmp += 0x10000000;
 270         tmp &= 0x0FFFFFFF;
 271
 272         stv0297_writereg(state, 0x66, (unsigned char) (tmp & 0xFF));
 273         stv0297_writereg(state, 0x67, (unsigned char) (tmp >> 8));
 274         stv0297_writereg(state, 0x68, (unsigned char) (tmp >> 16));
 275         stv0297_writereg_mask(state, 0x69, 0x0F, (tmp >> 24) & 0x0f);
 276 }
 277
 278 /*
 279 static long stv0297_get_carrieroffset(struct stv0297_state* state)
 280 {
 281         s64 tmp;
 282
 283         stv0297_writereg(state,0x6B, 0x00);
 284
 285         tmp = stv0297_readreg(state, 0x66);
 286         tmp |= (stv0297_readreg(state, 0x67) << 8);
 287         tmp |= (stv0297_readreg(state, 0x68) << 16);
 288         tmp |= (stv0297_readreg(state, 0x69) & 0x0F) << 24;
 289
 290         tmp *= stv0297_get_symbolrate(state);
 291         tmp >>= 28;
 292
 293         return (s32) tmp;
 294 }
 295 */
 296
 297 static void stv0297_set_initialdemodfreq(struct stv0297_state* state, long freq)
 298 {
 299         s32 tmp;
 300
 301         if (freq > 10000)
 302                 freq -= STV0297_CLOCK_KHZ;
 303
 304         tmp = (STV0297_CLOCK_KHZ * 1000) / (1 << 16);
 305         tmp = (freq * 1000) / tmp;
 306         if (tmp > 0xffff)
 307                 tmp = 0xffff;
 308
 309         stv0297_writereg_mask(state, 0x25, 0x80, 0x80);
 310         stv0297_writereg(state, 0x21, tmp >> 8);
 311         stv0297_writereg(state, 0x20, tmp);
 312 }
 313
 314 static int stv0297_set_qam(struct stv0297_state* state, fe_modulation_t modulation)
 315 {
 316         int val = 0;
 317
 318         switch(modulation) {
 319         case QAM_16:
 320                 val = 0;
 321                 break;
 322
 323         case QAM_32:
 324                 val = 1;
 325                 break;
 326
 327         case QAM_64:
 328                 val = 4;
 329                 break;
 330
 331         case QAM_128:
 332                 val = 2;
 333                 break;
 334
 335         case QAM_256:
 336                 val = 3;
 337                 break;
 338
 339         default:
 340                 return -EINVAL;
 341         }
 342
 343         stv0297_writereg_mask(state, 0x00, 0x70, val << 4);
 344
 345         return 0;
 346 }
 347
 348 static int stv0297_set_inversion(struct stv0297_state* state, fe_spectral_inversion_t inversion)
 349 {
 350         int val = 0;
 351
 352         switch(inversion) {
 353         case INVERSION_OFF:
 354                 val = 0;
 355                 break;
 356
 357         case INVERSION_ON:
 358                 val = 1;
 359                 break;
 360
 361         default:
 362                 return -EINVAL;
 363         }
 364
 365         stv0297_writereg_mask(state, 0x83, 0x08, val << 3);
 366
 367         return 0;
 368 }
 369
 370
 371
 372
 373
 374
 375
 376
 377
 378
 379
 380
 381
 382 int stv0297_enable_plli2c(struct dvb_frontend* fe)
 383 {
 384         struct stv0297_state* state = (struct stv0297_state*) fe->demodulator_priv;
 385
 386         stv0297_writereg(state, 0x87, 0x78);
 387         stv0297_writereg(state, 0x86, 0xc8);
 388
 389         return 0;
 390 }
 391
 392 static int stv0297_init (struct dvb_frontend* fe)
 393 {
 394         struct stv0297_state* state = (struct stv0297_state*) fe->demodulator_priv;
 395         int i;
 396
 397         /* soft reset */
 398         stv0297_writereg_mask(state, 0x80, 1, 1);
 399         stv0297_writereg_mask(state, 0x80, 1, 0);
 400
 401         /* reset deinterleaver */
 402         stv0297_writereg_mask(state, 0x81, 1, 1);
 403         stv0297_writereg_mask(state, 0x81, 1, 0);
 404
 405         /* load init table */
 406         for (i=0; i<sizeof(init_tab); i+=2) {
 407                 stv0297_writereg (state, init_tab[i], init_tab[i+1]);
 408         }
 409
 410         /* set a dummy symbol rate */
 411         stv0297_set_symbolrate(state, 6900);
 412
 413         /* invert AGC1 polarity */
 414         stv0297_writereg_mask(state, 0x88, 0x10, 0x10);
 415
 416         /* setup bit error counting */
 417         stv0297_writereg_mask(state, 0xA0, 0x80, 0x00);
 418         stv0297_writereg_mask(state, 0xA0, 0x10, 0x00);
 419         stv0297_writereg_mask(state, 0xA0, 0x08, 0x00);
 420         stv0297_writereg_mask(state, 0xA0, 0x07, 0x04);
 421
 422         /* min + max PWM */
 423         stv0297_writereg(state, 0x4a, 0x00);
 424         stv0297_writereg(state, 0x4b, state->pwm);
 425         msleep(200);
 426
 427         if (state->config->pll_init)
 428                 state->config->pll_init(fe);
 429
 430         return 0;
 431 }
 432
 433 static int stv0297_sleep(struct dvb_frontend *fe)
 434 {
 435         struct stv0297_state *state = (struct stv0297_state *) fe->demodulator_priv;
 436
 437         stv0297_writereg_mask(state, 0x80, 1, 1);
 438
 439         return 0;
 440 }
 441
 442 static int stv0297_read_status(struct dvb_frontend* fe, fe_status_t* status)
 443 {
 444         struct stv0297_state* state = (struct stv0297_state*) fe->demodulator_priv;
 445
 446         u8 sync = stv0297_readreg (state, 0xDF);
 447
 448         *status = 0;
 449         if (sync & 0x80)
 450                 *status |=
 451                         FE_HAS_SYNC | FE_HAS_SIGNAL | FE_HAS_CARRIER | FE_HAS_VITERBI | FE_HAS_LOCK;
 452         return 0;
 453 }
 454
 455 static int stv0297_read_ber(struct dvb_frontend* fe, u32* ber)
 456 {
 457         struct stv0297_state* state = (struct stv0297_state*) fe->demodulator_priv;
 458         u8 BER[3];
 459
 460         stv0297_writereg (state, 0xA0, 0x80);   // Start Counting bit errors for 4096 Bytes
 461         mdelay(25);                             // Hopefully got 4096 Bytes
 462         stv0297_readregs (state, 0xA0, BER, 3);
 463         mdelay(25);
 464         *ber = (BER[2] << 8 | BER[1]) / ( 8 * 4096);
 465
 466         return 0;
 467 }
 468
 469
 470 static int stv0297_read_signal_strength(struct dvb_frontend* fe, u16* strength)
 471 {
 472         struct stv0297_state* state = (struct stv0297_state*) fe->demodulator_priv;
 473         u8 STRENGTH[2];
 474
 475         stv0297_readregs (state, 0x41, STRENGTH, 2);
 476         *strength = (STRENGTH[1] & 0x03) << 8 | STRENGTH[0];
 477
 478         return 0;
 479 }
 480
 481 static int stv0297_read_snr(struct dvb_frontend* fe, u16* snr)
 482 {
 483         struct stv0297_state* state = (struct stv0297_state*) fe->demodulator_priv;
 484         u8 SNR[2];
 485
 486         stv0297_readregs (state, 0x07, SNR, 2);
 487         *snr = SNR[1] << 8 | SNR[0];
 488
 489         return 0;
 490 }
 491
 492 static int stv0297_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
 493 {
 494         struct stv0297_state* state = (struct stv0297_state*) fe->demodulator_priv;
 495
 496         *ucblocks = (stv0297_readreg (state, 0xD5) << 8)
 497                    | stv0297_readreg (state, 0xD4);
 498
 499         return 0;
 500 }
 501
 502 static int stv0297_set_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters * p)
 503 {
 504         struct stv0297_state* state = (struct stv0297_state*) fe->demodulator_priv;
 505         int u_threshold;
 506         int initial_u;
 507         int blind_u;
 508         int delay;
 509         int sweeprate;
 510         int carrieroffset;
 511         unsigned long starttime;
 512         unsigned long timeout;
 513         fe_spectral_inversion_t inversion;
 514
 515         switch(p->u.qam.modulation) {
 516         case QAM_16:
 517         case QAM_32:
 518         case QAM_64:
 519           delay = 100;
 520           sweeprate = 1500;
 521           break;
 522
 523         case QAM_128:
 524           delay = 150;
 525           sweeprate = 1000;
 526           break;
 527
 528         case QAM_256:
 529           delay = 200;
 530           sweeprate = 500;
 531           break;
 532
 533         default:
 534           return -EINVAL;
 535         }
 536
 537         // determine inversion dependant parameters
 538         inversion = p->inversion;
 539         if (state->config->invert)
 540                 inversion = (inversion == INVERSION_ON) ? INVERSION_OFF : INVERSION_ON;
 541         carrieroffset = -330;
 542         switch (inversion) {
 543         case INVERSION_OFF:
 544           break;
 545
 546         case INVERSION_ON:
 547           sweeprate = -sweeprate;
 548           carrieroffset = -carrieroffset;
 549           break;
 550
 551         default:
 552           return -EINVAL;
 553         }
 554
 555         stv0297_init(fe);
 556         state->config->pll_set(fe, p);
 557
 558         /* clear software interrupts */
 559         stv0297_writereg(state, 0x82, 0x0);
 560
 561         /* set initial demodulation frequency */
 562         stv0297_set_initialdemodfreq(state, 7250);
 563
 564         /* setup AGC */
 565         stv0297_writereg_mask(state, 0x43, 0x10, 0x00);
 566         stv0297_writereg(state, 0x41, 0x00);
 567         stv0297_writereg_mask(state, 0x42, 0x03, 0x01);
 568         stv0297_writereg_mask(state, 0x36, 0x60, 0x00);
 569         stv0297_writereg_mask(state, 0x36, 0x18, 0x00);
 570         stv0297_writereg_mask(state, 0x71, 0x80, 0x80);
 571         stv0297_writereg(state, 0x72, 0x00);
 572         stv0297_writereg(state, 0x73, 0x00);
 573         stv0297_writereg_mask(state, 0x74, 0x0F, 0x00);
 574         stv0297_writereg_mask(state, 0x43, 0x08, 0x00);
 575         stv0297_writereg_mask(state, 0x71, 0x80, 0x00);
 576
 577         /* setup STL */
 578         stv0297_writereg_mask(state, 0x5a, 0x20, 0x20);
 579         stv0297_writereg_mask(state, 0x5b, 0x02, 0x02);
 580         stv0297_writereg_mask(state, 0x5b, 0x02, 0x00);
 581         stv0297_writereg_mask(state, 0x5b, 0x01, 0x00);
 582         stv0297_writereg_mask(state, 0x5a, 0x40, 0x40);
 583
 584         /* disable frequency sweep */
 585         stv0297_writereg_mask(state, 0x6a, 0x01, 0x00);
 586
 587         /* reset deinterleaver */
 588         stv0297_writereg_mask(state, 0x81, 0x01, 0x01);
 589         stv0297_writereg_mask(state, 0x81, 0x01, 0x00);
 590
 591         /* ??? */
 592         stv0297_writereg_mask(state, 0x83, 0x20, 0x20);
 593         stv0297_writereg_mask(state, 0x83, 0x20, 0x00);
 594
 595         /* reset equaliser */
 596         u_threshold = stv0297_readreg(state, 0x00) & 0xf;
 597         initial_u = stv0297_readreg(state, 0x01) >> 4;
 598         blind_u = stv0297_readreg(state, 0x01) & 0xf;
 599         stv0297_writereg_mask(state, 0x84, 0x01, 0x01);
 600         stv0297_writereg_mask(state, 0x84, 0x01, 0x00);
 601         stv0297_writereg_mask(state, 0x00, 0x0f, u_threshold);
 602         stv0297_writereg_mask(state, 0x01, 0xf0, initial_u << 4);
 603         stv0297_writereg_mask(state, 0x01, 0x0f, blind_u);
 604
 605         /* data comes from internal A/D */
 606         stv0297_writereg_mask(state, 0x87, 0x80, 0x00);
 607
 608         /* clear phase registers */
 609         stv0297_writereg(state, 0x63, 0x00);
 610         stv0297_writereg(state, 0x64, 0x00);
 611         stv0297_writereg(state, 0x65, 0x00);
 612         stv0297_writereg(state, 0x66, 0x00);
 613         stv0297_writereg(state, 0x67, 0x00);
 614         stv0297_writereg(state, 0x68, 0x00);
 615         stv0297_writereg_mask(state, 0x69, 0x0f, 0x00);
 616
 617         /* set parameters */
 618         stv0297_set_qam(state, p->u.qam.modulation);
 619         stv0297_set_symbolrate(state, p->u.qam.symbol_rate/1000);
 620         stv0297_set_sweeprate(state, sweeprate, p->u.qam.symbol_rate / 1000);
 621         stv0297_set_carrieroffset(state, carrieroffset);
 622         stv0297_set_inversion(state, inversion);
 623
 624         /* kick off lock */
 625         stv0297_writereg_mask(state, 0x88, 0x08, 0x08);
 626         stv0297_writereg_mask(state, 0x5a, 0x20, 0x00);
 627         stv0297_writereg_mask(state, 0x6a, 0x01, 0x01);
 628         stv0297_writereg_mask(state, 0x43, 0x40, 0x40);
 629         stv0297_writereg_mask(state, 0x5b, 0x30, 0x00);
 630         stv0297_writereg_mask(state, 0x03, 0x0c, 0x0c);
 631         stv0297_writereg_mask(state, 0x03, 0x03, 0x03);
 632         stv0297_writereg_mask(state, 0x43, 0x10, 0x10);
 633
 634         /* wait for WGAGC lock */
 635         starttime = jiffies;
 636         timeout = jiffies + (200*HZ)/1000;
 637         while(time_before(jiffies, timeout)) {
 638                 msleep(10);
 639                 if (stv0297_readreg(state, 0x43) & 0x08)
 640                         break;
 641         }
 642         if (time_after(jiffies, timeout)) {
 643                 goto timeout;
 644         }
 645         msleep(20);
 646
 647         /* wait for equaliser partial convergence */
 648         timeout = jiffies + (50*HZ)/1000;
 649         while(time_before(jiffies, timeout)) {
 650                 msleep(10);
 651
 652                 if (stv0297_readreg(state, 0x82) & 0x04) {
 653                         break;
 654                 }
 655         }
 656         if (time_after(jiffies, timeout)) {
 657                 goto timeout;
 658         }
 659
 660         /* wait for equaliser full convergence */
 661         timeout = jiffies + (delay*HZ)/1000;
 662         while(time_before(jiffies, timeout)) {
 663                 msleep(10);
 664
 665                 if (stv0297_readreg(state, 0x82) & 0x08) {
 666                         break;
 667                 }
 668         }
 669         if (time_after(jiffies, timeout)) {
 670                 goto timeout;
 671         }
 672
 673         /* disable sweep */
 674         stv0297_writereg_mask(state, 0x6a, 1, 0);
 675         stv0297_writereg_mask(state, 0x88, 8, 0);
 676
 677         /* wait for main lock */
 678         timeout = jiffies + (20*HZ)/1000;
 679         while(time_before(jiffies, timeout)) {
 680                 msleep(10);
 681
 682                 if (stv0297_readreg(state, 0xDF) & 0x80) {
 683                         break;
 684                 }
 685         }
 686         if (time_after(jiffies, timeout)) {
 687                 goto timeout;
 688         }
 689         msleep(100);
 690
 691         /* is it still locked after that delay? */
 692         if (!(stv0297_readreg(state, 0xDF) & 0x80)) {
 693                 goto timeout;
 694         }
 695
 696         /* success!! */
 697         stv0297_writereg_mask(state, 0x5a, 0x40, 0x00);
 698         state->base_freq = p->frequency;
 699         return 0;
 700
 701 timeout:
 702         stv0297_writereg_mask(state, 0x6a, 0x01, 0x00);
 703         return 0;
 704 }
 705
 706 static int stv0297_get_frontend(struct dvb_frontend* fe, struct dvb_frontend_parameters * p)
 707 {
 708         struct stv0297_state* state = (struct stv0297_state*) fe->demodulator_priv;
 709         int reg_00, reg_83;
 710
 711         reg_00 = stv0297_readreg(state, 0x00);
 712         reg_83 = stv0297_readreg(state, 0x83);
 713
 714         p->frequency = state->base_freq;
 715         p->inversion = (reg_83 & 0x08) ? INVERSION_ON : INVERSION_OFF;
 716         if (state->config->invert)
 717                 p->inversion = (p->inversion == INVERSION_ON) ? INVERSION_OFF : INVERSION_ON;
 718         p->u.qam.symbol_rate = stv0297_get_symbolrate(state) * 1000;
 719         p->u.qam.fec_inner = FEC_NONE;
 720
 721         switch((reg_00 >> 4) & 0x7) {
 722         case 0:
 723                 p->u.qam.modulation = QAM_16;
 724                 break;
 725         case 1:
 726                 p->u.qam.modulation = QAM_32;
 727                 break;
 728         case 2:
 729                 p->u.qam.modulation = QAM_128;
 730                 break;
 731         case 3:
 732                 p->u.qam.modulation = QAM_256;
 733                 break;
 734         case 4:
 735                 p->u.qam.modulation = QAM_64;
 736                 break;
 737         }
 738
 739         return 0;
 740 }
 741
 742 static void stv0297_release(struct dvb_frontend* fe)
 743 {
 744         struct stv0297_state* state = (struct stv0297_state*) fe->demodulator_priv;
 745         kfree(state);
 746 }
 747
 748 static struct dvb_frontend_ops stv0297_ops;
 749
 750 struct dvb_frontend* stv0297_attach(const struct stv0297_config* config,
 751                                     struct i2c_adapter *i2c, int pwm)
 752 {
 753         struct stv0297_state* state = NULL;
 754
 755         /* allocate memory for the internal state */
 756         state = (struct stv0297_state*) kmalloc(sizeof(struct stv0297_state), GFP_KERNEL);
 757         if (state == NULL)
 758                 goto error;
 759
 760         /* setup the state */
 761         state->config = config;
 762         state->i2c = i2c;
 763         memcpy(&state->ops, &stv0297_ops, sizeof(struct dvb_frontend_ops));
 764         state->base_freq = 0;
 765         state->pwm = pwm;
 766
 767         /* check if the demod is there */
 768         if ((stv0297_readreg(state, 0x80) & 0x70) != 0x20)
 769                 goto error;
 770
 771         /* create dvb_frontend */
 772         state->frontend.ops = &state->ops;
 773         state->frontend.demodulator_priv = state;
 774         return &state->frontend;
 775
 776 error:
 777         if (state)
 778                 kfree(state);
 779         return NULL;
 780 }
 781
 782 static struct dvb_frontend_ops stv0297_ops = {
 783
 784         .info = {
 785                 .name                   = "ST STV0297 DVB-C",
 786                 .type                   = FE_QAM,
 787                 .frequency_min          = 64000000,
 788                 .frequency_max          = 1300000000,
 789                 .frequency_stepsize     = 62500,
 790                 .symbol_rate_min        = 870000,
 791                 .symbol_rate_max        = 11700000,
 792                 .caps = FE_CAN_QAM_16 | FE_CAN_QAM_32 | FE_CAN_QAM_64 |
 793                  FE_CAN_QAM_128 | FE_CAN_QAM_256 | FE_CAN_FEC_AUTO},
 794
 795         .release = stv0297_release,
 796
 797         .init = stv0297_init,
 798         .sleep = stv0297_sleep,
 799
 800         .set_frontend = stv0297_set_frontend,
 801         .get_frontend = stv0297_get_frontend,
 802
 803         .read_status = stv0297_read_status,
 804         .read_ber = stv0297_read_ber,
 805         .read_signal_strength = stv0297_read_signal_strength,
 806         .read_snr = stv0297_read_snr,
 807         .read_ucblocks = stv0297_read_ucblocks,
 808 };
 809
 810 MODULE_DESCRIPTION("ST STV0297 DVB-C Demodulator driver");
 811 MODULE_AUTHOR("Dennis Noermann and Andrew de Quincey");
 812 MODULE_LICENSE("GPL");
 813
 814 EXPORT_SYMBOL(stv0297_attach);
 815 EXPORT_SYMBOL(stv0297_enable_plli2c);