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