drivers/media/dvb-frontends/stv0288.c

   1 /*
   2         Driver for ST STV0288 demodulator
   3         Copyright (C) 2006 Georg Acher, BayCom GmbH, acher (at) baycom (dot) de
   4                 for Reel Multimedia
   5         Copyright (C) 2008 TurboSight.com, Bob Liu <bob@turbosight.com>
   6         Copyright (C) 2008 Igor M. Liplianin <liplianin@me.by>
   7                 Removed stb6000 specific tuner code and revised some
   8                 procedures.
   9         2010-09-01 Josef Pavlik <josef@pavlik.it>
  10                 Fixed diseqc_msg, diseqc_burst and set_tone problems
  11
  12         This program is free software; you can redistribute it and/or modify
  13         it under the terms of the GNU General Public License as published by
  14         the Free Software Foundation; either version 2 of the License, or
  15         (at your option) any later version.
  16
  17         This program is distributed in the hope that it will be useful,
  18         but WITHOUT ANY WARRANTY; without even the implied warranty of
  19         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20         GNU General Public License for more details.
  21
  22         You should have received a copy of the GNU General Public License
  23         along with this program; if not, write to the Free Software
  24         Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  25
  26 */
  27
  28 #include <linux/init.h>
  29 #include <linux/kernel.h>
  30 #include <linux/module.h>
  31 #include <linux/string.h>
  32 #include <linux/slab.h>
  33 #include <linux/jiffies.h>
  34 #include <asm/div64.h>
  35
  36 #include "dvb_frontend.h"
  37 #include "stv0288.h"
  38
  39 struct stv0288_state {
  40         struct i2c_adapter *i2c;
  41         const struct stv0288_config *config;
  42         struct dvb_frontend frontend;
  43
  44         u8 initialised:1;
  45         u32 tuner_frequency;
  46         u32 symbol_rate;
  47         enum fe_code_rate fec_inner;
  48         int errmode;
  49 };
  50
  51 #define STATUS_BER 0
  52 #define STATUS_UCBLOCKS 1
  53
  54 static int debug;
  55 static int debug_legacy_dish_switch;
  56 #define dprintk(args...) \
  57         do { \
  58                 if (debug) \
  59                         printk(KERN_DEBUG "stv0288: " args); \
  60         } while (0)
  61
  62
  63 static int stv0288_writeregI(struct stv0288_state *state, u8 reg, u8 data)
  64 {
  65         int ret;
  66         u8 buf[] = { reg, data };
  67         struct i2c_msg msg = {
  68                 .addr = state->config->demod_address,
  69                 .flags = 0,
  70                 .buf = buf,
  71                 .len = 2
  72         };
  73
  74         ret = i2c_transfer(state->i2c, &msg, 1);
  75
  76         if (ret != 1)
  77                 dprintk("%s: writereg error (reg == 0x%02x, val == 0x%02x, "
  78                         "ret == %i)\n", __func__, reg, data, ret);
  79
  80         return (ret != 1) ? -EREMOTEIO : 0;
  81 }
  82
  83 static int stv0288_write(struct dvb_frontend *fe, const u8 buf[], int len)
  84 {
  85         struct stv0288_state *state = fe->demodulator_priv;
  86
  87         if (len != 2)
  88                 return -EINVAL;
  89
  90         return stv0288_writeregI(state, buf[0], buf[1]);
  91 }
  92
  93 static u8 stv0288_readreg(struct stv0288_state *state, u8 reg)
  94 {
  95         int ret;
  96         u8 b0[] = { reg };
  97         u8 b1[] = { 0 };
  98         struct i2c_msg msg[] = {
  99                 {
 100                         .addr = state->config->demod_address,
 101                         .flags = 0,
 102                         .buf = b0,
 103                         .len = 1
 104                 }, {
 105                         .addr = state->config->demod_address,
 106                         .flags = I2C_M_RD,
 107                         .buf = b1,
 108                         .len = 1
 109                 }
 110         };
 111
 112         ret = i2c_transfer(state->i2c, msg, 2);
 113
 114         if (ret != 2)
 115                 dprintk("%s: readreg error (reg == 0x%02x, ret == %i)\n",
 116                                 __func__, reg, ret);
 117
 118         return b1[0];
 119 }
 120
 121 static int stv0288_set_symbolrate(struct dvb_frontend *fe, u32 srate)
 122 {
 123         struct stv0288_state *state = fe->demodulator_priv;
 124         unsigned int temp;
 125         unsigned char b[3];
 126
 127         if ((srate < 1000000) || (srate > 45000000))
 128                 return -EINVAL;
 129
 130         stv0288_writeregI(state, 0x22, 0);
 131         stv0288_writeregI(state, 0x23, 0);
 132         stv0288_writeregI(state, 0x2b, 0xff);
 133         stv0288_writeregI(state, 0x2c, 0xf7);
 134
 135         temp = (unsigned int)srate / 1000;
 136
 137         temp = temp * 32768;
 138         temp = temp / 25;
 139         temp = temp / 125;
 140         b[0] = (unsigned char)((temp >> 12) & 0xff);
 141         b[1] = (unsigned char)((temp >> 4) & 0xff);
 142         b[2] = (unsigned char)((temp << 4) & 0xf0);
 143         stv0288_writeregI(state, 0x28, 0x80); /* SFRH */
 144         stv0288_writeregI(state, 0x29, 0); /* SFRM */
 145         stv0288_writeregI(state, 0x2a, 0); /* SFRL */
 146
 147         stv0288_writeregI(state, 0x28, b[0]);
 148         stv0288_writeregI(state, 0x29, b[1]);
 149         stv0288_writeregI(state, 0x2a, b[2]);
 150         dprintk("stv0288: stv0288_set_symbolrate\n");
 151
 152         return 0;
 153 }
 154
 155 static int stv0288_send_diseqc_msg(struct dvb_frontend *fe,
 156                                     struct dvb_diseqc_master_cmd *m)
 157 {
 158         struct stv0288_state *state = fe->demodulator_priv;
 159
 160         int i;
 161
 162         dprintk("%s\n", __func__);
 163
 164         stv0288_writeregI(state, 0x09, 0);
 165         msleep(30);
 166         stv0288_writeregI(state, 0x05, 0x12);/* modulated mode, single shot */
 167
 168         for (i = 0; i < m->msg_len; i++) {
 169                 if (stv0288_writeregI(state, 0x06, m->msg[i]))
 170                         return -EREMOTEIO;
 171         }
 172         msleep(m->msg_len*12);
 173         return 0;
 174 }
 175
 176 static int stv0288_send_diseqc_burst(struct dvb_frontend *fe,
 177                                      enum fe_sec_mini_cmd burst)
 178 {
 179         struct stv0288_state *state = fe->demodulator_priv;
 180
 181         dprintk("%s\n", __func__);
 182
 183         if (stv0288_writeregI(state, 0x05, 0x03))/* burst mode, single shot */
 184                 return -EREMOTEIO;
 185
 186         if (stv0288_writeregI(state, 0x06, burst == SEC_MINI_A ? 0x00 : 0xff))
 187                 return -EREMOTEIO;
 188
 189         msleep(15);
 190         if (stv0288_writeregI(state, 0x05, 0x12))
 191                 return -EREMOTEIO;
 192
 193         return 0;
 194 }
 195
 196 static int stv0288_set_tone(struct dvb_frontend *fe, enum fe_sec_tone_mode tone)
 197 {
 198         struct stv0288_state *state = fe->demodulator_priv;
 199
 200         switch (tone) {
 201         case SEC_TONE_ON:
 202                 if (stv0288_writeregI(state, 0x05, 0x10))/* cont carrier */
 203                         return -EREMOTEIO;
 204         break;
 205
 206         case SEC_TONE_OFF:
 207                 if (stv0288_writeregI(state, 0x05, 0x12))/* burst mode off*/
 208                         return -EREMOTEIO;
 209         break;
 210
 211         default:
 212                 return -EINVAL;
 213         }
 214         return 0;
 215 }
 216
 217 static u8 stv0288_inittab[] = {
 218         0x01, 0x15,
 219         0x02, 0x20,
 220         0x09, 0x0,
 221         0x0a, 0x4,
 222         0x0b, 0x0,
 223         0x0c, 0x0,
 224         0x0d, 0x0,
 225         0x0e, 0xd4,
 226         0x0f, 0x30,
 227         0x11, 0x80,
 228         0x12, 0x03,
 229         0x13, 0x48,
 230         0x14, 0x84,
 231         0x15, 0x45,
 232         0x16, 0xb7,
 233         0x17, 0x9c,
 234         0x18, 0x0,
 235         0x19, 0xa6,
 236         0x1a, 0x88,
 237         0x1b, 0x8f,
 238         0x1c, 0xf0,
 239         0x20, 0x0b,
 240         0x21, 0x54,
 241         0x22, 0x0,
 242         0x23, 0x0,
 243         0x2b, 0xff,
 244         0x2c, 0xf7,
 245         0x30, 0x0,
 246         0x31, 0x1e,
 247         0x32, 0x14,
 248         0x33, 0x0f,
 249         0x34, 0x09,
 250         0x35, 0x0c,
 251         0x36, 0x05,
 252         0x37, 0x2f,
 253         0x38, 0x16,
 254         0x39, 0xbe,
 255         0x3a, 0x0,
 256         0x3b, 0x13,
 257         0x3c, 0x11,
 258         0x3d, 0x30,
 259         0x40, 0x63,
 260         0x41, 0x04,
 261         0x42, 0x20,
 262         0x43, 0x00,
 263         0x44, 0x00,
 264         0x45, 0x00,
 265         0x46, 0x00,
 266         0x47, 0x00,
 267         0x4a, 0x00,
 268         0x50, 0x10,
 269         0x51, 0x38,
 270         0x52, 0x21,
 271         0x58, 0x54,
 272         0x59, 0x86,
 273         0x5a, 0x0,
 274         0x5b, 0x9b,
 275         0x5c, 0x08,
 276         0x5d, 0x7f,
 277         0x5e, 0x0,
 278         0x5f, 0xff,
 279         0x70, 0x0,
 280         0x71, 0x0,
 281         0x72, 0x0,
 282         0x74, 0x0,
 283         0x75, 0x0,
 284         0x76, 0x0,
 285         0x81, 0x0,
 286         0x82, 0x3f,
 287         0x83, 0x3f,
 288         0x84, 0x0,
 289         0x85, 0x0,
 290         0x88, 0x0,
 291         0x89, 0x0,
 292         0x8a, 0x0,
 293         0x8b, 0x0,
 294         0x8c, 0x0,
 295         0x90, 0x0,
 296         0x91, 0x0,
 297         0x92, 0x0,
 298         0x93, 0x0,
 299         0x94, 0x1c,
 300         0x97, 0x0,
 301         0xa0, 0x48,
 302         0xa1, 0x0,
 303         0xb0, 0xb8,
 304         0xb1, 0x3a,
 305         0xb2, 0x10,
 306         0xb3, 0x82,
 307         0xb4, 0x80,
 308         0xb5, 0x82,
 309         0xb6, 0x82,
 310         0xb7, 0x82,
 311         0xb8, 0x20,
 312         0xb9, 0x0,
 313         0xf0, 0x0,
 314         0xf1, 0x0,
 315         0xf2, 0xc0,
 316         0x51, 0x36,
 317         0x52, 0x09,
 318         0x53, 0x94,
 319         0x54, 0x62,
 320         0x55, 0x29,
 321         0x56, 0x64,
 322         0x57, 0x2b,
 323         0xff, 0xff,
 324 };
 325
 326 static int stv0288_set_voltage(struct dvb_frontend *fe,
 327                                enum fe_sec_voltage volt)
 328 {
 329         dprintk("%s: %s\n", __func__,
 330                 volt == SEC_VOLTAGE_13 ? "SEC_VOLTAGE_13" :
 331                 volt == SEC_VOLTAGE_18 ? "SEC_VOLTAGE_18" : "??");
 332
 333         return 0;
 334 }
 335
 336 static int stv0288_init(struct dvb_frontend *fe)
 337 {
 338         struct stv0288_state *state = fe->demodulator_priv;
 339         int i;
 340         u8 reg;
 341         u8 val;
 342
 343         dprintk("stv0288: init chip\n");
 344         stv0288_writeregI(state, 0x41, 0x04);
 345         msleep(50);
 346
 347         /* we have default inittab */
 348         if (state->config->inittab == NULL) {
 349                 for (i = 0; !(stv0288_inittab[i] == 0xff &&
 350                                 stv0288_inittab[i + 1] == 0xff); i += 2)
 351                         stv0288_writeregI(state, stv0288_inittab[i],
 352                                         stv0288_inittab[i + 1]);
 353         } else {
 354                 for (i = 0; ; i += 2)  {
 355                         reg = state->config->inittab[i];
 356                         val = state->config->inittab[i+1];
 357                         if (reg == 0xff && val == 0xff)
 358                                 break;
 359                         stv0288_writeregI(state, reg, val);
 360                 }
 361         }
 362         return 0;
 363 }
 364
 365 static int stv0288_read_status(struct dvb_frontend *fe, enum fe_status *status)
 366 {
 367         struct stv0288_state *state = fe->demodulator_priv;
 368
 369         u8 sync = stv0288_readreg(state, 0x24);
 370         if (sync == 255)
 371                 sync = 0;
 372
 373         dprintk("%s : FE_READ_STATUS : VSTATUS: 0x%02x\n", __func__, sync);
 374
 375         *status = 0;
 376         if (sync & 0x80)
 377                 *status |= FE_HAS_CARRIER | FE_HAS_SIGNAL;
 378         if (sync & 0x10)
 379                 *status |= FE_HAS_VITERBI;
 380         if (sync & 0x08) {
 381                 *status |= FE_HAS_LOCK;
 382                 dprintk("stv0288 has locked\n");
 383         }
 384
 385         return 0;
 386 }
 387
 388 static int stv0288_read_ber(struct dvb_frontend *fe, u32 *ber)
 389 {
 390         struct stv0288_state *state = fe->demodulator_priv;
 391
 392         if (state->errmode != STATUS_BER)
 393                 return 0;
 394         *ber = (stv0288_readreg(state, 0x26) << 8) |
 395                                         stv0288_readreg(state, 0x27);
 396         dprintk("stv0288_read_ber %d\n", *ber);
 397
 398         return 0;
 399 }
 400
 401
 402 static int stv0288_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
 403 {
 404         struct stv0288_state *state = fe->demodulator_priv;
 405
 406         s32 signal =  0xffff - ((stv0288_readreg(state, 0x10) << 8));
 407
 408
 409         signal = signal * 5 / 4;
 410         *strength = (signal > 0xffff) ? 0xffff : (signal < 0) ? 0 : signal;
 411         dprintk("stv0288_read_signal_strength %d\n", *strength);
 412
 413         return 0;
 414 }
 415 static int stv0288_sleep(struct dvb_frontend *fe)
 416 {
 417         struct stv0288_state *state = fe->demodulator_priv;
 418
 419         stv0288_writeregI(state, 0x41, 0x84);
 420         state->initialised = 0;
 421
 422         return 0;
 423 }
 424 static int stv0288_read_snr(struct dvb_frontend *fe, u16 *snr)
 425 {
 426         struct stv0288_state *state = fe->demodulator_priv;
 427
 428         s32 xsnr = 0xffff - ((stv0288_readreg(state, 0x2d) << 8)
 429                            | stv0288_readreg(state, 0x2e));
 430         xsnr = 3 * (xsnr - 0xa100);
 431         *snr = (xsnr > 0xffff) ? 0xffff : (xsnr < 0) ? 0 : xsnr;
 432         dprintk("stv0288_read_snr %d\n", *snr);
 433
 434         return 0;
 435 }
 436
 437 static int stv0288_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
 438 {
 439         struct stv0288_state *state = fe->demodulator_priv;
 440
 441         if (state->errmode != STATUS_BER)
 442                 return 0;
 443         *ucblocks = (stv0288_readreg(state, 0x26) << 8) |
 444                                         stv0288_readreg(state, 0x27);
 445         dprintk("stv0288_read_ber %d\n", *ucblocks);
 446
 447         return 0;
 448 }
 449
 450 static int stv0288_set_property(struct dvb_frontend *fe, struct dtv_property *p)
 451 {
 452         dprintk("%s(..)\n", __func__);
 453         return 0;
 454 }
 455
 456 static int stv0288_set_frontend(struct dvb_frontend *fe)
 457 {
 458         struct stv0288_state *state = fe->demodulator_priv;
 459         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 460
 461         char tm;
 462         unsigned char tda[3];
 463         u8 reg, time_out = 0;
 464
 465         dprintk("%s : FE_SET_FRONTEND\n", __func__);
 466
 467         if (c->delivery_system != SYS_DVBS) {
 468                         dprintk("%s: unsupported delivery "
 469                                 "system selected (%d)\n",
 470                                 __func__, c->delivery_system);
 471                         return -EOPNOTSUPP;
 472         }
 473
 474         if (state->config->set_ts_params)
 475                 state->config->set_ts_params(fe, 0);
 476
 477         /* only frequency & symbol_rate are used for tuner*/
 478         if (fe->ops.tuner_ops.set_params) {
 479                 fe->ops.tuner_ops.set_params(fe);
 480                 if (fe->ops.i2c_gate_ctrl)
 481                         fe->ops.i2c_gate_ctrl(fe, 0);
 482         }
 483
 484         udelay(10);
 485         stv0288_set_symbolrate(fe, c->symbol_rate);
 486         /* Carrier lock control register */
 487         stv0288_writeregI(state, 0x15, 0xc5);
 488
 489         tda[2] = 0x0; /* CFRL */
 490         for (tm = -9; tm < 7;) {
 491                 /* Viterbi status */
 492                 reg = stv0288_readreg(state, 0x24);
 493                 if (reg & 0x8)
 494                                 break;
 495                 if (reg & 0x80) {
 496                         time_out++;
 497                         if (time_out > 10)
 498                                 break;
 499                         tda[2] += 40;
 500                         if (tda[2] < 40)
 501                                 tm++;
 502                 } else {
 503                         tm++;
 504                         tda[2] = 0;
 505                         time_out = 0;
 506                 }
 507                 tda[1] = (unsigned char)tm;
 508                 stv0288_writeregI(state, 0x2b, tda[1]);
 509                 stv0288_writeregI(state, 0x2c, tda[2]);
 510                 msleep(30);
 511         }
 512         state->tuner_frequency = c->frequency;
 513         state->fec_inner = FEC_AUTO;
 514         state->symbol_rate = c->symbol_rate;
 515
 516         return 0;
 517 }
 518
 519 static int stv0288_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
 520 {
 521         struct stv0288_state *state = fe->demodulator_priv;
 522
 523         if (enable)
 524                 stv0288_writeregI(state, 0x01, 0xb5);
 525         else
 526                 stv0288_writeregI(state, 0x01, 0x35);
 527
 528         udelay(1);
 529
 530         return 0;
 531 }
 532
 533 static void stv0288_release(struct dvb_frontend *fe)
 534 {
 535         struct stv0288_state *state = fe->demodulator_priv;
 536         kfree(state);
 537 }
 538
 539 static struct dvb_frontend_ops stv0288_ops = {
 540         .delsys = { SYS_DVBS },
 541         .info = {
 542                 .name                   = "ST STV0288 DVB-S",
 543                 .frequency_min          = 950000,
 544                 .frequency_max          = 2150000,
 545                 .frequency_stepsize     = 1000,  /* kHz for QPSK frontends */
 546                 .frequency_tolerance    = 0,
 547                 .symbol_rate_min        = 1000000,
 548                 .symbol_rate_max        = 45000000,
 549                 .symbol_rate_tolerance  = 500,  /* ppm */
 550                 .caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
 551                       FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 |
 552                       FE_CAN_QPSK |
 553                       FE_CAN_FEC_AUTO
 554         },
 555
 556         .release = stv0288_release,
 557         .init = stv0288_init,
 558         .sleep = stv0288_sleep,
 559         .write = stv0288_write,
 560         .i2c_gate_ctrl = stv0288_i2c_gate_ctrl,
 561         .read_status = stv0288_read_status,
 562         .read_ber = stv0288_read_ber,
 563         .read_signal_strength = stv0288_read_signal_strength,
 564         .read_snr = stv0288_read_snr,
 565         .read_ucblocks = stv0288_read_ucblocks,
 566         .diseqc_send_master_cmd = stv0288_send_diseqc_msg,
 567         .diseqc_send_burst = stv0288_send_diseqc_burst,
 568         .set_tone = stv0288_set_tone,
 569         .set_voltage = stv0288_set_voltage,
 570
 571         .set_property = stv0288_set_property,
 572         .set_frontend = stv0288_set_frontend,
 573 };
 574
 575 struct dvb_frontend *stv0288_attach(const struct stv0288_config *config,
 576                                     struct i2c_adapter *i2c)
 577 {
 578         struct stv0288_state *state = NULL;
 579         int id;
 580
 581         /* allocate memory for the internal state */
 582         state = kzalloc(sizeof(struct stv0288_state), GFP_KERNEL);
 583         if (state == NULL)
 584                 goto error;
 585
 586         /* setup the state */
 587         state->config = config;
 588         state->i2c = i2c;
 589         state->initialised = 0;
 590         state->tuner_frequency = 0;
 591         state->symbol_rate = 0;
 592         state->fec_inner = 0;
 593         state->errmode = STATUS_BER;
 594
 595         stv0288_writeregI(state, 0x41, 0x04);
 596         msleep(200);
 597         id = stv0288_readreg(state, 0x00);
 598         dprintk("stv0288 id %x\n", id);
 599
 600         /* register 0x00 contains 0x11 for STV0288  */
 601         if (id != 0x11)
 602                 goto error;
 603
 604         /* create dvb_frontend */
 605         memcpy(&state->frontend.ops, &stv0288_ops,
 606                         sizeof(struct dvb_frontend_ops));
 607         state->frontend.demodulator_priv = state;
 608         return &state->frontend;
 609
 610 error:
 611         kfree(state);
 612
 613         return NULL;
 614 }
 615 EXPORT_SYMBOL(stv0288_attach);
 616
 617 module_param(debug_legacy_dish_switch, int, 0444);
 618 MODULE_PARM_DESC(debug_legacy_dish_switch,
 619                 "Enable timing analysis for Dish Network legacy switches");
 620
 621 module_param(debug, int, 0644);
 622 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
 623
 624 MODULE_DESCRIPTION("ST STV0288 DVB Demodulator driver");
 625 MODULE_AUTHOR("Georg Acher, Bob Liu, Igor liplianin");
 626 MODULE_LICENSE("GPL");
 627