drivers/media/dvb-frontends/sp8870.c

   1 /*
   2     Driver for Spase SP8870 demodulator
   3
   4     Copyright (C) 1999 Juergen Peitz
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14
  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 /*(DEBLOBBED)*/
  23
  24 #include <linux/init.h>
  25 #include <linux/module.h>
  26 #include <linux/device.h>
  27 #include <linux/firmware.h>
  28 #include <linux/delay.h>
  29 #include <linux/string.h>
  30 #include <linux/slab.h>
  31
  32 #include "dvb_frontend.h"
  33 #include "sp8870.h"
  34
  35
  36 struct sp8870_state {
  37
  38         struct i2c_adapter* i2c;
  39
  40         const struct sp8870_config* config;
  41
  42         struct dvb_frontend frontend;
  43
  44         /* demodulator private data */
  45         u8 initialised:1;
  46 };
  47
  48 static int debug;
  49 #define dprintk(args...) \
  50         do { \
  51                 if (debug) printk(KERN_DEBUG "sp8870: " args); \
  52         } while (0)
  53
  54 /* firmware size for sp8870 */
  55 #define SP8870_FIRMWARE_SIZE 16382
  56
  57 /* starting point for firmware in file 'Sc_main.mc' */
  58 #define SP8870_FIRMWARE_OFFSET 0x0A
  59
  60 static int sp8870_writereg (struct sp8870_state* state, u16 reg, u16 data)
  61 {
  62         u8 buf [] = { reg >> 8, reg & 0xff, data >> 8, data & 0xff };
  63         struct i2c_msg msg = { .addr = state->config->demod_address, .flags = 0, .buf = buf, .len = 4 };
  64         int err;
  65
  66         if ((err = i2c_transfer (state->i2c, &msg, 1)) != 1) {
  67                 dprintk ("%s: writereg error (err == %i, reg == 0x%02x, data == 0x%02x)\n", __func__, err, reg, data);
  68                 return -EREMOTEIO;
  69         }
  70
  71         return 0;
  72 }
  73
  74 static int sp8870_readreg (struct sp8870_state* state, u16 reg)
  75 {
  76         int ret;
  77         u8 b0 [] = { reg >> 8 , reg & 0xff };
  78         u8 b1 [] = { 0, 0 };
  79         struct i2c_msg msg [] = { { .addr = state->config->demod_address, .flags = 0, .buf = b0, .len = 2 },
  80                            { .addr = state->config->demod_address, .flags = I2C_M_RD, .buf = b1, .len = 2 } };
  81
  82         ret = i2c_transfer (state->i2c, msg, 2);
  83
  84         if (ret != 2) {
  85                 dprintk("%s: readreg error (ret == %i)\n", __func__, ret);
  86                 return -1;
  87         }
  88
  89         return (b1[0] << 8 | b1[1]);
  90 }
  91
  92 static int sp8870_firmware_upload (struct sp8870_state* state, const struct firmware *fw)
  93 {
  94         struct i2c_msg msg;
  95         const char *fw_buf = fw->data;
  96         int fw_pos;
  97         u8 tx_buf[255];
  98         int tx_len;
  99         int err = 0;
 100
 101         dprintk ("%s: ...\n", __func__);
 102
 103         if (fw->size < SP8870_FIRMWARE_SIZE + SP8870_FIRMWARE_OFFSET)
 104                 return -EINVAL;
 105
 106         // system controller stop
 107         sp8870_writereg(state, 0x0F00, 0x0000);
 108
 109         // instruction RAM register hiword
 110         sp8870_writereg(state, 0x8F08, ((SP8870_FIRMWARE_SIZE / 2) & 0xFFFF));
 111
 112         // instruction RAM MWR
 113         sp8870_writereg(state, 0x8F0A, ((SP8870_FIRMWARE_SIZE / 2) >> 16));
 114
 115         // do firmware upload
 116         fw_pos = SP8870_FIRMWARE_OFFSET;
 117         while (fw_pos < SP8870_FIRMWARE_SIZE + SP8870_FIRMWARE_OFFSET){
 118                 tx_len = (fw_pos <= SP8870_FIRMWARE_SIZE + SP8870_FIRMWARE_OFFSET - 252) ? 252 : SP8870_FIRMWARE_SIZE + SP8870_FIRMWARE_OFFSET - fw_pos;
 119                 // write register 0xCF0A
 120                 tx_buf[0] = 0xCF;
 121                 tx_buf[1] = 0x0A;
 122                 memcpy(&tx_buf[2], fw_buf + fw_pos, tx_len);
 123                 msg.addr = state->config->demod_address;
 124                 msg.flags = 0;
 125                 msg.buf = tx_buf;
 126                 msg.len = tx_len + 2;
 127                 if ((err = i2c_transfer (state->i2c, &msg, 1)) != 1) {
 128                         printk("%s: firmware upload failed!\n", __func__);
 129                         printk ("%s: i2c error (err == %i)\n", __func__, err);
 130                         return err;
 131                 }
 132                 fw_pos += tx_len;
 133         }
 134
 135         dprintk ("%s: done!\n", __func__);
 136         return 0;
 137 };
 138
 139 static void sp8870_microcontroller_stop (struct sp8870_state* state)
 140 {
 141         sp8870_writereg(state, 0x0F08, 0x000);
 142         sp8870_writereg(state, 0x0F09, 0x000);
 143
 144         // microcontroller STOP
 145         sp8870_writereg(state, 0x0F00, 0x000);
 146 }
 147
 148 static void sp8870_microcontroller_start (struct sp8870_state* state)
 149 {
 150         sp8870_writereg(state, 0x0F08, 0x000);
 151         sp8870_writereg(state, 0x0F09, 0x000);
 152
 153         // microcontroller START
 154         sp8870_writereg(state, 0x0F00, 0x001);
 155         // not documented but if we don't read 0x0D01 out here
 156         // we don't get a correct data valid signal
 157         sp8870_readreg(state, 0x0D01);
 158 }
 159
 160 static int sp8870_read_data_valid_signal(struct sp8870_state* state)
 161 {
 162         return (sp8870_readreg(state, 0x0D02) > 0);
 163 }
 164
 165 static int configure_reg0xc05 (struct dtv_frontend_properties *p, u16 *reg0xc05)
 166 {
 167         int known_parameters = 1;
 168
 169         *reg0xc05 = 0x000;
 170
 171         switch (p->modulation) {
 172         case QPSK:
 173                 break;
 174         case QAM_16:
 175                 *reg0xc05 |= (1 << 10);
 176                 break;
 177         case QAM_64:
 178                 *reg0xc05 |= (2 << 10);
 179                 break;
 180         case QAM_AUTO:
 181                 known_parameters = 0;
 182                 break;
 183         default:
 184                 return -EINVAL;
 185         }
 186
 187         switch (p->hierarchy) {
 188         case HIERARCHY_NONE:
 189                 break;
 190         case HIERARCHY_1:
 191                 *reg0xc05 |= (1 << 7);
 192                 break;
 193         case HIERARCHY_2:
 194                 *reg0xc05 |= (2 << 7);
 195                 break;
 196         case HIERARCHY_4:
 197                 *reg0xc05 |= (3 << 7);
 198                 break;
 199         case HIERARCHY_AUTO:
 200                 known_parameters = 0;
 201                 break;
 202         default:
 203                 return -EINVAL;
 204         }
 205
 206         switch (p->code_rate_HP) {
 207         case FEC_1_2:
 208                 break;
 209         case FEC_2_3:
 210                 *reg0xc05 |= (1 << 3);
 211                 break;
 212         case FEC_3_4:
 213                 *reg0xc05 |= (2 << 3);
 214                 break;
 215         case FEC_5_6:
 216                 *reg0xc05 |= (3 << 3);
 217                 break;
 218         case FEC_7_8:
 219                 *reg0xc05 |= (4 << 3);
 220                 break;
 221         case FEC_AUTO:
 222                 known_parameters = 0;
 223                 break;
 224         default:
 225                 return -EINVAL;
 226         }
 227
 228         if (known_parameters)
 229                 *reg0xc05 |= (2 << 1);  /* use specified parameters */
 230         else
 231                 *reg0xc05 |= (1 << 1);  /* enable autoprobing */
 232
 233         return 0;
 234 }
 235
 236 static int sp8870_wake_up(struct sp8870_state* state)
 237 {
 238         // enable TS output and interface pins
 239         return sp8870_writereg(state, 0xC18, 0x00D);
 240 }
 241
 242 static int sp8870_set_frontend_parameters(struct dvb_frontend *fe)
 243 {
 244         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
 245         struct sp8870_state* state = fe->demodulator_priv;
 246         int  err;
 247         u16 reg0xc05;
 248
 249         if ((err = configure_reg0xc05(p, &reg0xc05)))
 250                 return err;
 251
 252         // system controller stop
 253         sp8870_microcontroller_stop(state);
 254
 255         // set tuner parameters
 256         if (fe->ops.tuner_ops.set_params) {
 257                 fe->ops.tuner_ops.set_params(fe);
 258                 if (fe->ops.i2c_gate_ctrl) fe->ops.i2c_gate_ctrl(fe, 0);
 259         }
 260
 261         // sample rate correction bit [23..17]
 262         sp8870_writereg(state, 0x0319, 0x000A);
 263
 264         // sample rate correction bit [16..0]
 265         sp8870_writereg(state, 0x031A, 0x0AAB);
 266
 267         // integer carrier offset
 268         sp8870_writereg(state, 0x0309, 0x0400);
 269
 270         // fractional carrier offset
 271         sp8870_writereg(state, 0x030A, 0x0000);
 272
 273         // filter for 6/7/8 Mhz channel
 274         if (p->bandwidth_hz == 6000000)
 275                 sp8870_writereg(state, 0x0311, 0x0002);
 276         else if (p->bandwidth_hz == 7000000)
 277                 sp8870_writereg(state, 0x0311, 0x0001);
 278         else
 279                 sp8870_writereg(state, 0x0311, 0x0000);
 280
 281         // scan order: 2k first = 0x0000, 8k first = 0x0001
 282         if (p->transmission_mode == TRANSMISSION_MODE_2K)
 283                 sp8870_writereg(state, 0x0338, 0x0000);
 284         else
 285                 sp8870_writereg(state, 0x0338, 0x0001);
 286
 287         sp8870_writereg(state, 0xc05, reg0xc05);
 288
 289         // read status reg in order to clear pending irqs
 290         err = sp8870_readreg(state, 0x200);
 291         if (err < 0)
 292                 return err;
 293
 294         // system controller start
 295         sp8870_microcontroller_start(state);
 296
 297         return 0;
 298 }
 299
 300 static int sp8870_init (struct dvb_frontend* fe)
 301 {
 302         struct sp8870_state* state = fe->demodulator_priv;
 303         const struct firmware *fw = NULL;
 304
 305         sp8870_wake_up(state);
 306         if (state->initialised) return 0;
 307         state->initialised = 1;
 308
 309         dprintk ("%s\n", __func__);
 310
 311
 312         /* request the firmware, this will block until someone uploads it */
 313         printk("sp8870: waiting for firmware upload (%s)...\n", "/*(DEBLOBBED)*/");
 314         if (state->config->request_firmware(fe, &fw, "/*(DEBLOBBED)*/")) {
 315                 printk("sp8870: no firmware upload (timeout or file not found?)\n");
 316                 return -EIO;
 317         }
 318
 319         if (sp8870_firmware_upload(state, fw)) {
 320                 printk("sp8870: writing firmware to device failed\n");
 321                 release_firmware(fw);
 322                 return -EIO;
 323         }
 324         release_firmware(fw);
 325         printk("sp8870: firmware upload complete\n");
 326
 327         /* enable TS output and interface pins */
 328         sp8870_writereg(state, 0xc18, 0x00d);
 329
 330         // system controller stop
 331         sp8870_microcontroller_stop(state);
 332
 333         // ADC mode
 334         sp8870_writereg(state, 0x0301, 0x0003);
 335
 336         // Reed Solomon parity bytes passed to output
 337         sp8870_writereg(state, 0x0C13, 0x0001);
 338
 339         // MPEG clock is suppressed if no valid data
 340         sp8870_writereg(state, 0x0C14, 0x0001);
 341
 342         /* bit 0x010: enable data valid signal */
 343         sp8870_writereg(state, 0x0D00, 0x010);
 344         sp8870_writereg(state, 0x0D01, 0x000);
 345
 346         return 0;
 347 }
 348
 349 static int sp8870_read_status(struct dvb_frontend *fe,
 350                               enum fe_status *fe_status)
 351 {
 352         struct sp8870_state* state = fe->demodulator_priv;
 353         int status;
 354         int signal;
 355
 356         *fe_status = 0;
 357
 358         status = sp8870_readreg (state, 0x0200);
 359         if (status < 0)
 360                 return -EIO;
 361
 362         signal = sp8870_readreg (state, 0x0303);
 363         if (signal < 0)
 364                 return -EIO;
 365
 366         if (signal > 0x0F)
 367                 *fe_status |= FE_HAS_SIGNAL;
 368         if (status & 0x08)
 369                 *fe_status |= FE_HAS_SYNC;
 370         if (status & 0x04)
 371                 *fe_status |= FE_HAS_LOCK | FE_HAS_CARRIER | FE_HAS_VITERBI;
 372
 373         return 0;
 374 }
 375
 376 static int sp8870_read_ber (struct dvb_frontend* fe, u32 * ber)
 377 {
 378         struct sp8870_state* state = fe->demodulator_priv;
 379         int ret;
 380         u32 tmp;
 381
 382         *ber = 0;
 383
 384         ret = sp8870_readreg(state, 0xC08);
 385         if (ret < 0)
 386                 return -EIO;
 387
 388         tmp = ret & 0x3F;
 389
 390         ret = sp8870_readreg(state, 0xC07);
 391         if (ret < 0)
 392                 return -EIO;
 393
 394         tmp = ret << 6;
 395         if (tmp >= 0x3FFF0)
 396                 tmp = ~0;
 397
 398         *ber = tmp;
 399
 400         return 0;
 401 }
 402
 403 static int sp8870_read_signal_strength(struct dvb_frontend* fe,  u16 * signal)
 404 {
 405         struct sp8870_state* state = fe->demodulator_priv;
 406         int ret;
 407         u16 tmp;
 408
 409         *signal = 0;
 410
 411         ret = sp8870_readreg (state, 0x306);
 412         if (ret < 0)
 413                 return -EIO;
 414
 415         tmp = ret << 8;
 416
 417         ret = sp8870_readreg (state, 0x303);
 418         if (ret < 0)
 419                 return -EIO;
 420
 421         tmp |= ret;
 422
 423         if (tmp)
 424                 *signal = 0xFFFF - tmp;
 425
 426         return 0;
 427 }
 428
 429 static int sp8870_read_uncorrected_blocks (struct dvb_frontend* fe, u32* ublocks)
 430 {
 431         struct sp8870_state* state = fe->demodulator_priv;
 432         int ret;
 433
 434         *ublocks = 0;
 435
 436         ret = sp8870_readreg(state, 0xC0C);
 437         if (ret < 0)
 438                 return -EIO;
 439
 440         if (ret == 0xFFFF)
 441                 ret = ~0;
 442
 443         *ublocks = ret;
 444
 445         return 0;
 446 }
 447
 448 /* number of trials to recover from lockup */
 449 #define MAXTRIALS 5
 450 /* maximum checks for data valid signal */
 451 #define MAXCHECKS 100
 452
 453 /* only for debugging: counter for detected lockups */
 454 static int lockups;
 455 /* only for debugging: counter for channel switches */
 456 static int switches;
 457
 458 static int sp8870_set_frontend(struct dvb_frontend *fe)
 459 {
 460         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
 461         struct sp8870_state* state = fe->demodulator_priv;
 462
 463         /*
 464             The firmware of the sp8870 sometimes locks up after setting frontend parameters.
 465             We try to detect this by checking the data valid signal.
 466             If it is not set after MAXCHECKS we try to recover the lockup by setting
 467             the frontend parameters again.
 468         */
 469
 470         int err = 0;
 471         int valid = 0;
 472         int trials = 0;
 473         int check_count = 0;
 474
 475         dprintk("%s: frequency = %i\n", __func__, p->frequency);
 476
 477         for (trials = 1; trials <= MAXTRIALS; trials++) {
 478
 479                 err = sp8870_set_frontend_parameters(fe);
 480                 if (err)
 481                         return err;
 482
 483                 for (check_count = 0; check_count < MAXCHECKS; check_count++) {
 484 //                      valid = ((sp8870_readreg(i2c, 0x0200) & 4) == 0);
 485                         valid = sp8870_read_data_valid_signal(state);
 486                         if (valid) {
 487                                 dprintk("%s: delay = %i usec\n",
 488                                         __func__, check_count * 10);
 489                                 break;
 490                         }
 491                         udelay(10);
 492                 }
 493                 if (valid)
 494                         break;
 495         }
 496
 497         if (!valid) {
 498                 printk("%s: firmware crash!!!!!!\n", __func__);
 499                 return -EIO;
 500         }
 501
 502         if (debug) {
 503                 if (valid) {
 504                         if (trials > 1) {
 505                                 printk("%s: firmware lockup!!!\n", __func__);
 506                                 printk("%s: recovered after %i trial(s))\n",  __func__, trials - 1);
 507                                 lockups++;
 508                         }
 509                 }
 510                 switches++;
 511                 printk("%s: switches = %i lockups = %i\n", __func__, switches, lockups);
 512         }
 513
 514         return 0;
 515 }
 516
 517 static int sp8870_sleep(struct dvb_frontend* fe)
 518 {
 519         struct sp8870_state* state = fe->demodulator_priv;
 520
 521         // tristate TS output and disable interface pins
 522         return sp8870_writereg(state, 0xC18, 0x000);
 523 }
 524
 525 static int sp8870_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings* fesettings)
 526 {
 527         fesettings->min_delay_ms = 350;
 528         fesettings->step_size = 0;
 529         fesettings->max_drift = 0;
 530         return 0;
 531 }
 532
 533 static int sp8870_i2c_gate_ctrl(struct dvb_frontend* fe, int enable)
 534 {
 535         struct sp8870_state* state = fe->demodulator_priv;
 536
 537         if (enable) {
 538                 return sp8870_writereg(state, 0x206, 0x001);
 539         } else {
 540                 return sp8870_writereg(state, 0x206, 0x000);
 541         }
 542 }
 543
 544 static void sp8870_release(struct dvb_frontend* fe)
 545 {
 546         struct sp8870_state* state = fe->demodulator_priv;
 547         kfree(state);
 548 }
 549
 550 static const struct dvb_frontend_ops sp8870_ops;
 551
 552 struct dvb_frontend* sp8870_attach(const struct sp8870_config* config,
 553                                    struct i2c_adapter* i2c)
 554 {
 555         struct sp8870_state* state = NULL;
 556
 557         /* allocate memory for the internal state */
 558         state = kzalloc(sizeof(struct sp8870_state), GFP_KERNEL);
 559         if (state == NULL) goto error;
 560
 561         /* setup the state */
 562         state->config = config;
 563         state->i2c = i2c;
 564         state->initialised = 0;
 565
 566         /* check if the demod is there */
 567         if (sp8870_readreg(state, 0x0200) < 0) goto error;
 568
 569         /* create dvb_frontend */
 570         memcpy(&state->frontend.ops, &sp8870_ops, sizeof(struct dvb_frontend_ops));
 571         state->frontend.demodulator_priv = state;
 572         return &state->frontend;
 573
 574 error:
 575         kfree(state);
 576         return NULL;
 577 }
 578
 579 static const struct dvb_frontend_ops sp8870_ops = {
 580         .delsys = { SYS_DVBT },
 581         .info = {
 582                 .name                   = "Spase SP8870 DVB-T",
 583                 .frequency_min          = 470000000,
 584                 .frequency_max          = 860000000,
 585                 .frequency_stepsize     = 166666,
 586                 .caps                   = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 |
 587                                           FE_CAN_FEC_3_4 | FE_CAN_FEC_5_6 |
 588                                           FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
 589                                           FE_CAN_QPSK | FE_CAN_QAM_16 |
 590                                           FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
 591                                           FE_CAN_HIERARCHY_AUTO |  FE_CAN_RECOVER
 592         },
 593
 594         .release = sp8870_release,
 595
 596         .init = sp8870_init,
 597         .sleep = sp8870_sleep,
 598         .i2c_gate_ctrl = sp8870_i2c_gate_ctrl,
 599
 600         .set_frontend = sp8870_set_frontend,
 601         .get_tune_settings = sp8870_get_tune_settings,
 602
 603         .read_status = sp8870_read_status,
 604         .read_ber = sp8870_read_ber,
 605         .read_signal_strength = sp8870_read_signal_strength,
 606         .read_ucblocks = sp8870_read_uncorrected_blocks,
 607 };
 608
 609 module_param(debug, int, 0644);
 610 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
 611
 612 MODULE_DESCRIPTION("Spase SP8870 DVB-T Demodulator driver");
 613 MODULE_AUTHOR("Juergen Peitz");
 614 MODULE_LICENSE("GPL");
 615
 616 EXPORT_SYMBOL(sp8870_attach);