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         temp = (unsigned int)srate / 1000;
 131
 132                 temp = temp * 32768;
 133                 temp = temp / 25;
 134                 temp = temp / 125;
 135                 b[0] = (unsigned char)((temp >> 12) & 0xff);
 136                 b[1] = (unsigned char)((temp >> 4) & 0xff);
 137                 b[2] = (unsigned char)((temp << 4) & 0xf0);
 138                 stv0288_writeregI(state, 0x28, 0x80); /* SFRH */
 139                 stv0288_writeregI(state, 0x29, 0); /* SFRM */
 140                 stv0288_writeregI(state, 0x2a, 0); /* SFRL */
 141
 142                 stv0288_writeregI(state, 0x28, b[0]);
 143                 stv0288_writeregI(state, 0x29, b[1]);
 144                 stv0288_writeregI(state, 0x2a, b[2]);
 145                 dprintk("stv0288: stv0288_set_symbolrate\n");
 146
 147         return 0;
 148 }
 149
 150 static int stv0288_send_diseqc_msg(struct dvb_frontend *fe,
 151                                     struct dvb_diseqc_master_cmd *m)
 152 {
 153         struct stv0288_state *state = fe->demodulator_priv;
 154
 155         int i;
 156
 157         dprintk("%s\n", __func__);
 158
 159         stv0288_writeregI(state, 0x09, 0);
 160         msleep(30);
 161         stv0288_writeregI(state, 0x05, 0x12);/* modulated mode, single shot */
 162
 163         for (i = 0; i < m->msg_len; i++) {
 164                 if (stv0288_writeregI(state, 0x06, m->msg[i]))
 165                         return -EREMOTEIO;
 166         }
 167         msleep(m->msg_len*12);
 168         return 0;
 169 }
 170
 171 static int stv0288_send_diseqc_burst(struct dvb_frontend *fe,
 172                                                 fe_sec_mini_cmd_t burst)
 173 {
 174         struct stv0288_state *state = fe->demodulator_priv;
 175
 176         dprintk("%s\n", __func__);
 177
 178         if (stv0288_writeregI(state, 0x05, 0x03))/* burst mode, single shot */
 179                 return -EREMOTEIO;
 180
 181         if (stv0288_writeregI(state, 0x06, burst == SEC_MINI_A ? 0x00 : 0xff))
 182                 return -EREMOTEIO;
 183
 184         msleep(15);
 185         if (stv0288_writeregI(state, 0x05, 0x12))
 186                 return -EREMOTEIO;
 187
 188         return 0;
 189 }
 190
 191 static int stv0288_set_tone(struct dvb_frontend *fe, fe_sec_tone_mode_t tone)
 192 {
 193         struct stv0288_state *state = fe->demodulator_priv;
 194
 195         switch (tone) {
 196         case SEC_TONE_ON:
 197                 if (stv0288_writeregI(state, 0x05, 0x10))/* cont carrier */
 198                         return -EREMOTEIO;
 199         break;
 200
 201         case SEC_TONE_OFF:
 202                 if (stv0288_writeregI(state, 0x05, 0x12))/* burst mode off*/
 203                         return -EREMOTEIO;
 204         break;
 205
 206         default:
 207                 return -EINVAL;
 208         }
 209         return 0;
 210 }
 211
 212 static u8 stv0288_inittab[] = {
 213         0x01, 0x15,
 214         0x02, 0x20,
 215         0x09, 0x0,
 216         0x0a, 0x4,
 217         0x0b, 0x0,
 218         0x0c, 0x0,
 219         0x0d, 0x0,
 220         0x0e, 0xd4,
 221         0x0f, 0x30,
 222         0x11, 0x80,
 223         0x12, 0x03,
 224         0x13, 0x48,
 225         0x14, 0x84,
 226         0x15, 0x45,
 227         0x16, 0xb7,
 228         0x17, 0x9c,
 229         0x18, 0x0,
 230         0x19, 0xa6,
 231         0x1a, 0x88,
 232         0x1b, 0x8f,
 233         0x1c, 0xf0,
 234         0x20, 0x0b,
 235         0x21, 0x54,
 236         0x22, 0x0,
 237         0x23, 0x0,
 238         0x2b, 0xff,
 239         0x2c, 0xf7,
 240         0x30, 0x0,
 241         0x31, 0x1e,
 242         0x32, 0x14,
 243         0x33, 0x0f,
 244         0x34, 0x09,
 245         0x35, 0x0c,
 246         0x36, 0x05,
 247         0x37, 0x2f,
 248         0x38, 0x16,
 249         0x39, 0xbe,
 250         0x3a, 0x0,
 251         0x3b, 0x13,
 252         0x3c, 0x11,
 253         0x3d, 0x30,
 254         0x40, 0x63,
 255         0x41, 0x04,
 256         0x42, 0x60,
 257         0x43, 0x00,
 258         0x44, 0x00,
 259         0x45, 0x00,
 260         0x46, 0x00,
 261         0x47, 0x00,
 262         0x4a, 0x00,
 263         0x50, 0x10,
 264         0x51, 0x38,
 265         0x52, 0x21,
 266         0x58, 0x54,
 267         0x59, 0x86,
 268         0x5a, 0x0,
 269         0x5b, 0x9b,
 270         0x5c, 0x08,
 271         0x5d, 0x7f,
 272         0x5e, 0x0,
 273         0x5f, 0xff,
 274         0x70, 0x0,
 275         0x71, 0x0,
 276         0x72, 0x0,
 277         0x74, 0x0,
 278         0x75, 0x0,
 279         0x76, 0x0,
 280         0x81, 0x0,
 281         0x82, 0x3f,
 282         0x83, 0x3f,
 283         0x84, 0x0,
 284         0x85, 0x0,
 285         0x88, 0x0,
 286         0x89, 0x0,
 287         0x8a, 0x0,
 288         0x8b, 0x0,
 289         0x8c, 0x0,
 290         0x90, 0x0,
 291         0x91, 0x0,
 292         0x92, 0x0,
 293         0x93, 0x0,
 294         0x94, 0x1c,
 295         0x97, 0x0,
 296         0xa0, 0x48,
 297         0xa1, 0x0,
 298         0xb0, 0xb8,
 299         0xb1, 0x3a,
 300         0xb2, 0x10,
 301         0xb3, 0x82,
 302         0xb4, 0x80,
 303         0xb5, 0x82,
 304         0xb6, 0x82,
 305         0xb7, 0x82,
 306         0xb8, 0x20,
 307         0xb9, 0x0,
 308         0xf0, 0x0,
 309         0xf1, 0x0,
 310         0xf2, 0xc0,
 311         0x51, 0x36,
 312         0x52, 0x09,
 313         0x53, 0x94,
 314         0x54, 0x62,
 315         0x55, 0x29,
 316         0x56, 0x64,
 317         0x57, 0x2b,
 318         0xff, 0xff,
 319 };
 320
 321 static int stv0288_set_voltage(struct dvb_frontend *fe, fe_sec_voltage_t volt)
 322 {
 323         dprintk("%s: %s\n", __func__,
 324                 volt == SEC_VOLTAGE_13 ? "SEC_VOLTAGE_13" :
 325                 volt == SEC_VOLTAGE_18 ? "SEC_VOLTAGE_18" : "??");
 326
 327         return 0;
 328 }
 329
 330 static int stv0288_init(struct dvb_frontend *fe)
 331 {
 332         struct stv0288_state *state = fe->demodulator_priv;
 333         int i;
 334         u8 reg;
 335         u8 val;
 336
 337         dprintk("stv0288: init chip\n");
 338         stv0288_writeregI(state, 0x41, 0x04);
 339         msleep(50);
 340
 341         /* we have default inittab */
 342         if (state->config->inittab == NULL) {
 343                 for (i = 0; !(stv0288_inittab[i] == 0xff &&
 344                                 stv0288_inittab[i + 1] == 0xff); i += 2)
 345                         stv0288_writeregI(state, stv0288_inittab[i],
 346                                         stv0288_inittab[i + 1]);
 347         } else {
 348                 for (i = 0; ; i += 2)  {
 349                         reg = state->config->inittab[i];
 350                         val = state->config->inittab[i+1];
 351                         if (reg == 0xff && val == 0xff)
 352                                 break;
 353                         stv0288_writeregI(state, reg, val);
 354                 }
 355         }
 356         return 0;
 357 }
 358
 359 static int stv0288_read_status(struct dvb_frontend *fe, fe_status_t *status)
 360 {
 361         struct stv0288_state *state = fe->demodulator_priv;
 362
 363         u8 sync = stv0288_readreg(state, 0x24);
 364         if (sync == 255)
 365                 sync = 0;
 366
 367         dprintk("%s : FE_READ_STATUS : VSTATUS: 0x%02x\n", __func__, sync);
 368
 369         *status = 0;
 370         if (sync & 0x80)
 371                 *status |= FE_HAS_CARRIER | FE_HAS_SIGNAL;
 372         if (sync & 0x10)
 373                 *status |= FE_HAS_VITERBI;
 374         if (sync & 0x08) {
 375                 *status |= FE_HAS_LOCK;
 376                 dprintk("stv0288 has locked\n");
 377         }
 378
 379         return 0;
 380 }
 381
 382 static int stv0288_read_ber(struct dvb_frontend *fe, u32 *ber)
 383 {
 384         struct stv0288_state *state = fe->demodulator_priv;
 385
 386         if (state->errmode != STATUS_BER)
 387                 return 0;
 388         *ber = (stv0288_readreg(state, 0x26) << 8) |
 389                                         stv0288_readreg(state, 0x27);
 390         dprintk("stv0288_read_ber %d\n", *ber);
 391
 392         return 0;
 393 }
 394
 395
 396 static int stv0288_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
 397 {
 398         struct stv0288_state *state = fe->demodulator_priv;
 399
 400         s32 signal =  0xffff - ((stv0288_readreg(state, 0x10) << 8));
 401
 402
 403         signal = signal * 5 / 4;
 404         *strength = (signal > 0xffff) ? 0xffff : (signal < 0) ? 0 : signal;
 405         dprintk("stv0288_read_signal_strength %d\n", *strength);
 406
 407         return 0;
 408 }
 409 static int stv0288_sleep(struct dvb_frontend *fe)
 410 {
 411         struct stv0288_state *state = fe->demodulator_priv;
 412
 413         stv0288_writeregI(state, 0x41, 0x84);
 414         state->initialised = 0;
 415
 416         return 0;
 417 }
 418 static int stv0288_read_snr(struct dvb_frontend *fe, u16 *snr)
 419 {
 420         struct stv0288_state *state = fe->demodulator_priv;
 421
 422         s32 xsnr = 0xffff - ((stv0288_readreg(state, 0x2d) << 8)
 423                            | stv0288_readreg(state, 0x2e));
 424         xsnr = 3 * (xsnr - 0xa100);
 425         *snr = (xsnr > 0xffff) ? 0xffff : (xsnr < 0) ? 0 : xsnr;
 426         dprintk("stv0288_read_snr %d\n", *snr);
 427
 428         return 0;
 429 }
 430
 431 static int stv0288_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
 432 {
 433         struct stv0288_state *state = fe->demodulator_priv;
 434
 435         if (state->errmode != STATUS_BER)
 436                 return 0;
 437         *ucblocks = (stv0288_readreg(state, 0x26) << 8) |
 438                                         stv0288_readreg(state, 0x27);
 439         dprintk("stv0288_read_ber %d\n", *ucblocks);
 440
 441         return 0;
 442 }
 443
 444 static int stv0288_set_property(struct dvb_frontend *fe, struct dtv_property *p)
 445 {
 446         dprintk("%s(..)\n", __func__);
 447         return 0;
 448 }
 449
 450 static int stv0288_get_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                                         struct dvb_frontend_parameters *dfp)
 458 {
 459         struct stv0288_state *state = fe->demodulator_priv;
 460         struct dtv_frontend_properties *c = &fe->dtv_property_cache;
 461
 462         char tm;
 463         unsigned char tda[3];
 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         dfp->frequency = c->frequency;
 479         dfp->u.qpsk.symbol_rate = c->symbol_rate;
 480         if (fe->ops.tuner_ops.set_params) {
 481                 fe->ops.tuner_ops.set_params(fe, dfp);
 482                 if (fe->ops.i2c_gate_ctrl)
 483                         fe->ops.i2c_gate_ctrl(fe, 0);
 484         }
 485
 486         udelay(10);
 487         stv0288_set_symbolrate(fe, c->symbol_rate);
 488         /* Carrier lock control register */
 489         stv0288_writeregI(state, 0x15, 0xc5);
 490
 491         tda[0] = 0x2b; /* CFRM */
 492         tda[2] = 0x0; /* CFRL */
 493         for (tm = -6; tm < 7;) {
 494                 /* Viterbi status */
 495                 if (stv0288_readreg(state, 0x24) & 0x8)
 496                         break;
 497
 498                 tda[2] += 40;
 499                 if (tda[2] < 40)
 500                         tm++;
 501                 tda[1] = (unsigned char)tm;
 502                 stv0288_writeregI(state, 0x2b, tda[1]);
 503                 stv0288_writeregI(state, 0x2c, tda[2]);
 504                 udelay(30);
 505         }
 506
 507         state->tuner_frequency = c->frequency;
 508         state->fec_inner = FEC_AUTO;
 509         state->symbol_rate = c->symbol_rate;
 510
 511         return 0;
 512 }
 513
 514 static int stv0288_i2c_gate_ctrl(struct dvb_frontend *fe, int enable)
 515 {
 516         struct stv0288_state *state = fe->demodulator_priv;
 517
 518         if (enable)
 519                 stv0288_writeregI(state, 0x01, 0xb5);
 520         else
 521                 stv0288_writeregI(state, 0x01, 0x35);
 522
 523         udelay(1);
 524
 525         return 0;
 526 }
 527
 528 static void stv0288_release(struct dvb_frontend *fe)
 529 {
 530         struct stv0288_state *state = fe->demodulator_priv;
 531         kfree(state);
 532 }
 533
 534 static struct dvb_frontend_ops stv0288_ops = {
 535
 536         .info = {
 537                 .name                   = "ST STV0288 DVB-S",
 538                 .type                   = FE_QPSK,
 539                 .frequency_min          = 950000,
 540                 .frequency_max          = 2150000,
 541                 .frequency_stepsize     = 1000,  /* kHz for QPSK frontends */
 542                 .frequency_tolerance    = 0,
 543                 .symbol_rate_min        = 1000000,
 544                 .symbol_rate_max        = 45000000,
 545                 .symbol_rate_tolerance  = 500,  /* ppm */
 546                 .caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
 547                       FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 |
 548                       FE_CAN_QPSK |
 549                       FE_CAN_FEC_AUTO
 550         },
 551
 552         .release = stv0288_release,
 553         .init = stv0288_init,
 554         .sleep = stv0288_sleep,
 555         .write = stv0288_write,
 556         .i2c_gate_ctrl = stv0288_i2c_gate_ctrl,
 557         .read_status = stv0288_read_status,
 558         .read_ber = stv0288_read_ber,
 559         .read_signal_strength = stv0288_read_signal_strength,
 560         .read_snr = stv0288_read_snr,
 561         .read_ucblocks = stv0288_read_ucblocks,
 562         .diseqc_send_master_cmd = stv0288_send_diseqc_msg,
 563         .diseqc_send_burst = stv0288_send_diseqc_burst,
 564         .set_tone = stv0288_set_tone,
 565         .set_voltage = stv0288_set_voltage,
 566
 567         .set_property = stv0288_set_property,
 568         .get_property = stv0288_get_property,
 569         .set_frontend = stv0288_set_frontend,
 570 };
 571
 572 struct dvb_frontend *stv0288_attach(const struct stv0288_config *config,
 573                                     struct i2c_adapter *i2c)
 574 {
 575         struct stv0288_state *state = NULL;
 576         int id;
 577
 578         /* allocate memory for the internal state */
 579         state = kzalloc(sizeof(struct stv0288_state), GFP_KERNEL);
 580         if (state == NULL)
 581                 goto error;
 582
 583         /* setup the state */
 584         state->config = config;
 585         state->i2c = i2c;
 586         state->initialised = 0;
 587         state->tuner_frequency = 0;
 588         state->symbol_rate = 0;
 589         state->fec_inner = 0;
 590         state->errmode = STATUS_BER;
 591
 592         stv0288_writeregI(state, 0x41, 0x04);
 593         msleep(200);
 594         id = stv0288_readreg(state, 0x00);
 595         dprintk("stv0288 id %x\n", id);
 596
 597         /* register 0x00 contains 0x11 for STV0288  */
 598         if (id != 0x11)
 599                 goto error;
 600
 601         /* create dvb_frontend */
 602         memcpy(&state->frontend.ops, &stv0288_ops,
 603                         sizeof(struct dvb_frontend_ops));
 604         state->frontend.demodulator_priv = state;
 605         return &state->frontend;
 606
 607 error:
 608         kfree(state);
 609
 610         return NULL;
 611 }
 612 EXPORT_SYMBOL(stv0288_attach);
 613
 614 module_param(debug_legacy_dish_switch, int, 0444);
 615 MODULE_PARM_DESC(debug_legacy_dish_switch,
 616                 "Enable timing analysis for Dish Network legacy switches");
 617
 618 module_param(debug, int, 0644);
 619 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
 620
 621 MODULE_DESCRIPTION("ST STV0288 DVB Demodulator driver");
 622 MODULE_AUTHOR("Georg Acher, Bob Liu, Igor liplianin");
 623 MODULE_LICENSE("GPL");
 624