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         fe_code_rate_t 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                                                 fe_sec_mini_cmd_t 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, fe_sec_tone_mode_t 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, fe_sec_voltage_t volt)
 327 {
 328         dprintk("%s: %s\n", __func__,
 329                 volt == SEC_VOLTAGE_13 ? "SEC_VOLTAGE_13" :
 330                 volt == SEC_VOLTAGE_18 ? "SEC_VOLTAGE_18" : "??");
 331
 332         return 0;
 333 }
 334
 335 static int stv0288_init(struct dvb_frontend *fe)
 336 {
 337         struct stv0288_state *state = fe->demodulator_priv;
 338         int i;
 339         u8 reg;
 340         u8 val;
 341
 342         dprintk("stv0288: init chip\n");
 343         stv0288_writeregI(state, 0x41, 0x04);
 344         msleep(50);
 345
 346         /* we have default inittab */
 347         if (state->config->inittab == NULL) {
 348                 for (i = 0; !(stv0288_inittab[i] == 0xff &&
 349                                 stv0288_inittab[i + 1] == 0xff); i += 2)
 350                         stv0288_writeregI(state, stv0288_inittab[i],
 351                                         stv0288_inittab[i + 1]);
 352         } else {
 353                 for (i = 0; ; i += 2)  {
 354                         reg = state->config->inittab[i];
 355                         val = state->config->inittab[i+1];
 356                         if (reg == 0xff && val == 0xff)
 357                                 break;
 358                         stv0288_writeregI(state, reg, val);
 359                 }
 360         }
 361         return 0;
 362 }
 363
 364 static int stv0288_read_status(struct dvb_frontend *fe, fe_status_t *status)
 365 {
 366         struct stv0288_state *state = fe->demodulator_priv;
 367
 368         u8 sync = stv0288_readreg(state, 0x24);
 369         if (sync == 255)
 370                 sync = 0;
 371
 372         dprintk("%s : FE_READ_STATUS : VSTATUS: 0x%02x\n", __func__, sync);
 373
 374         *status = 0;
 375         if (sync & 0x80)
 376                 *status |= FE_HAS_CARRIER | FE_HAS_SIGNAL;
 377         if (sync & 0x10)
 378                 *status |= FE_HAS_VITERBI;
 379         if (sync & 0x08) {
 380                 *status |= FE_HAS_LOCK;
 381                 dprintk("stv0288 has locked\n");
 382         }
 383
 384         return 0;
 385 }
 386
 387 static int stv0288_read_ber(struct dvb_frontend *fe, u32 *ber)
 388 {
 389         struct stv0288_state *state = fe->demodulator_priv;
 390
 391         if (state->errmode != STATUS_BER)
 392                 return 0;
 393         *ber = (stv0288_readreg(state, 0x26) << 8) |
 394                                         stv0288_readreg(state, 0x27);
 395         dprintk("stv0288_read_ber %d\n", *ber);
 396
 397         return 0;
 398 }
 399
 400
 401 static int stv0288_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
 402 {
 403         struct stv0288_state *state = fe->demodulator_priv;
 404
 405         s32 signal =  0xffff - ((stv0288_readreg(state, 0x10) << 8));
 406
 407
 408         signal = signal * 5 / 4;
 409         *strength = (signal > 0xffff) ? 0xffff : (signal < 0) ? 0 : signal;
 410         dprintk("stv0288_read_signal_strength %d\n", *strength);
 411
 412         return 0;
 413 }
 414 static int stv0288_sleep(struct dvb_frontend *fe)
 415 {
 416         struct stv0288_state *state = fe->demodulator_priv;
 417
 418         stv0288_writeregI(state, 0x41, 0x84);
 419         state->initialised = 0;
 420
 421         return 0;
 422 }
 423 static int stv0288_read_snr(struct dvb_frontend *fe, u16 *snr)
 424 {
 425         struct stv0288_state *state = fe->demodulator_priv;
 426
 427         s32 xsnr = 0xffff - ((stv0288_readreg(state, 0x2d) << 8)
 428                            | stv0288_readreg(state, 0x2e));
 429         xsnr = 3 * (xsnr - 0xa100);
 430         *snr = (xsnr > 0xffff) ? 0xffff : (xsnr < 0) ? 0 : xsnr;
 431         dprintk("stv0288_read_snr %d\n", *snr);
 432
 433         return 0;
 434 }
 435
 436 static int stv0288_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
 437 {
 438         struct stv0288_state *state = fe->demodulator_priv;
 439
 440         if (state->errmode != STATUS_BER)
 441                 return 0;
 442         *ucblocks = (stv0288_readreg(state, 0x26) << 8) |
 443                                         stv0288_readreg(state, 0x27);
 444         dprintk("stv0288_read_ber %d\n", *ucblocks);
 445
 446         return 0;
 447 }
 448
 449 static int stv0288_set_property(struct dvb_frontend *fe, struct dtv_property *p)
 450 {
 451         dprintk("%s(..)\n", __func__);
 452         return 0;
 453 }
 454
 455 static int stv0288_set_frontend(struct dvb_frontend *fe)
 456 {
 457         struct stv0288_state *state = fe->demodulator_priv;
 458         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 459
 460         char tm;
 461         unsigned char tda[3];
 462         u8 reg, time_out = 0;
 463
 464         dprintk("%s : FE_SET_FRONTEND\n", __func__);
 465
 466         if (c->delivery_system != SYS_DVBS) {
 467                         dprintk("%s: unsupported delivery "
 468                                 "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 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