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