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, ret == %i)\n",
  78                         __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 system selected (%d)\n",
 469                         __func__, c->delivery_system);
 470                 return -EOPNOTSUPP;
 471         }
 472
 473         if (state->config->set_ts_params)
 474                 state->config->set_ts_params(fe, 0);
 475
 476         /* only frequency & symbol_rate are used for tuner*/
 477         if (fe->ops.tuner_ops.set_params) {
 478                 fe->ops.tuner_ops.set_params(fe);
 479                 if (fe->ops.i2c_gate_ctrl)
 480                         fe->ops.i2c_gate_ctrl(fe, 0);
 481         }
 482
 483         udelay(10);
 484         stv0288_set_symbolrate(fe, c->symbol_rate);
 485         /* Carrier lock control register */
 486         stv0288_writeregI(state, 0x15, 0xc5);
 487
 488         tda[2] = 0x0; /* CFRL */
 489         for (tm = -9; tm < 7;) {
 490                 /* Viterbi status */
 491                 reg = stv0288_readreg(state, 0x24);
 492                 if (reg & 0x8)
 493                                 break;
 494                 if (reg & 0x80) {
 495                         time_out++;
 496                         if (time_out > 10)
 497                                 break;
 498                         tda[2] += 40;
 499                         if (tda[2] < 40)
 500                                 tm++;
 501                 } else {
 502                         tm++;
 503                         tda[2] = 0;
 504                         time_out = 0;
 505                 }
 506                 tda[1] = (unsigned char)tm;
 507                 stv0288_writeregI(state, 0x2b, tda[1]);
 508                 stv0288_writeregI(state, 0x2c, tda[2]);
 509                 msleep(30);
 510         }
 511         state->tuner_frequency = c->frequency;
 512         state->fec_inner = FEC_AUTO;
 513         state->symbol_rate = c->symbol_rate;
 514
 515         return 0;
 516 }
 517
 518 static int stv0288_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
 519 {
 520         struct stv0288_state *state = fe->demodulator_priv;
 521
 522         if (enable)
 523                 stv0288_writeregI(state, 0x01, 0xb5);
 524         else
 525                 stv0288_writeregI(state, 0x01, 0x35);
 526
 527         udelay(1);
 528
 529         return 0;
 530 }
 531
 532 static void stv0288_release(struct dvb_frontend *fe)
 533 {
 534         struct stv0288_state *state = fe->demodulator_priv;
 535         kfree(state);
 536 }
 537
 538 static const struct dvb_frontend_ops stv0288_ops = {
 539         .delsys = { SYS_DVBS },
 540         .info = {
 541                 .name                   = "ST STV0288 DVB-S",
 542                 .frequency_min          = 950000,
 543                 .frequency_max          = 2150000,
 544                 .frequency_stepsize     = 1000,  /* kHz for QPSK frontends */
 545                 .frequency_tolerance    = 0,
 546                 .symbol_rate_min        = 1000000,
 547                 .symbol_rate_max        = 45000000,
 548                 .symbol_rate_tolerance  = 500,  /* ppm */
 549                 .caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
 550                       FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 |
 551                       FE_CAN_QPSK |
 552                       FE_CAN_FEC_AUTO
 553         },
 554
 555         .release = stv0288_release,
 556         .init = stv0288_init,
 557         .sleep = stv0288_sleep,
 558         .write = stv0288_write,
 559         .i2c_gate_ctrl = stv0288_i2c_gate_ctrl,
 560         .read_status = stv0288_read_status,
 561         .read_ber = stv0288_read_ber,
 562         .read_signal_strength = stv0288_read_signal_strength,
 563         .read_snr = stv0288_read_snr,
 564         .read_ucblocks = stv0288_read_ucblocks,
 565         .diseqc_send_master_cmd = stv0288_send_diseqc_msg,
 566         .diseqc_send_burst = stv0288_send_diseqc_burst,
 567         .set_tone = stv0288_set_tone,
 568         .set_voltage = stv0288_set_voltage,
 569
 570         .set_property = stv0288_set_property,
 571         .set_frontend = stv0288_set_frontend,
 572 };
 573
 574 struct dvb_frontend *stv0288_attach(const struct stv0288_config *config,
 575                                     struct i2c_adapter *i2c)
 576 {
 577         struct stv0288_state *state = NULL;
 578         int id;
 579
 580         /* allocate memory for the internal state */
 581         state = kzalloc(sizeof(struct stv0288_state), GFP_KERNEL);
 582         if (state == NULL)
 583                 goto error;
 584
 585         /* setup the state */
 586         state->config = config;
 587         state->i2c = i2c;
 588         state->initialised = 0;
 589         state->tuner_frequency = 0;
 590         state->symbol_rate = 0;
 591         state->fec_inner = 0;
 592         state->errmode = STATUS_BER;
 593
 594         stv0288_writeregI(state, 0x41, 0x04);
 595         msleep(200);
 596         id = stv0288_readreg(state, 0x00);
 597         dprintk("stv0288 id %x\n", id);
 598
 599         /* register 0x00 contains 0x11 for STV0288  */
 600         if (id != 0x11)
 601                 goto error;
 602
 603         /* create dvb_frontend */
 604         memcpy(&state->frontend.ops, &stv0288_ops,
 605                         sizeof(struct dvb_frontend_ops));
 606         state->frontend.demodulator_priv = state;
 607         return &state->frontend;
 608
 609 error:
 610         kfree(state);
 611
 612         return NULL;
 613 }
 614 EXPORT_SYMBOL(stv0288_attach);
 615
 616 module_param(debug_legacy_dish_switch, int, 0444);
 617 MODULE_PARM_DESC(debug_legacy_dish_switch,
 618                 "Enable timing analysis for Dish Network legacy switches");
 619
 620 module_param(debug, int, 0644);
 621 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
 622
 623 MODULE_DESCRIPTION("ST STV0288 DVB Demodulator driver");
 624 MODULE_AUTHOR("Georg Acher, Bob Liu, Igor liplianin");
 625 MODULE_LICENSE("GPL");
 626