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         sp8870_readreg(state, 0x200);
 291
 292         // system controller start
 293         sp8870_microcontroller_start(state);
 294
 295         return 0;
 296 }
 297
 298 static int sp8870_init (struct dvb_frontend* fe)
 299 {
 300         struct sp8870_state* state = fe->demodulator_priv;
 301         const struct firmware *fw = NULL;
 302
 303         sp8870_wake_up(state);
 304         if (state->initialised) return 0;
 305         state->initialised = 1;
 306
 307         dprintk ("%s\n", __func__);
 308
 309
 310         /* request the firmware, this will block until someone uploads it */
 311         printk("sp8870: waiting for firmware upload (%s)...\n", "/*(DEBLOBBED)*/");
 312         if (state->config->reject_firmware(fe, &fw, "/*(DEBLOBBED)*/")) {
 313                 printk("sp8870: no firmware upload (timeout or file not found?)\n");
 314                 return -EIO;
 315         }
 316
 317         if (sp8870_firmware_upload(state, fw)) {
 318                 printk("sp8870: writing firmware to device failed\n");
 319                 release_firmware(fw);
 320                 return -EIO;
 321         }
 322         release_firmware(fw);
 323         printk("sp8870: firmware upload complete\n");
 324
 325         /* enable TS output and interface pins */
 326         sp8870_writereg(state, 0xc18, 0x00d);
 327
 328         // system controller stop
 329         sp8870_microcontroller_stop(state);
 330
 331         // ADC mode
 332         sp8870_writereg(state, 0x0301, 0x0003);
 333
 334         // Reed Solomon parity bytes passed to output
 335         sp8870_writereg(state, 0x0C13, 0x0001);
 336
 337         // MPEG clock is suppressed if no valid data
 338         sp8870_writereg(state, 0x0C14, 0x0001);
 339
 340         /* bit 0x010: enable data valid signal */
 341         sp8870_writereg(state, 0x0D00, 0x010);
 342         sp8870_writereg(state, 0x0D01, 0x000);
 343
 344         return 0;
 345 }
 346
 347 static int sp8870_read_status (struct dvb_frontend* fe, fe_status_t * fe_status)
 348 {
 349         struct sp8870_state* state = fe->demodulator_priv;
 350         int status;
 351         int signal;
 352
 353         *fe_status = 0;
 354
 355         status = sp8870_readreg (state, 0x0200);
 356         if (status < 0)
 357                 return -EIO;
 358
 359         signal = sp8870_readreg (state, 0x0303);
 360         if (signal < 0)
 361                 return -EIO;
 362
 363         if (signal > 0x0F)
 364                 *fe_status |= FE_HAS_SIGNAL;
 365         if (status & 0x08)
 366                 *fe_status |= FE_HAS_SYNC;
 367         if (status & 0x04)
 368                 *fe_status |= FE_HAS_LOCK | FE_HAS_CARRIER | FE_HAS_VITERBI;
 369
 370         return 0;
 371 }
 372
 373 static int sp8870_read_ber (struct dvb_frontend* fe, u32 * ber)
 374 {
 375         struct sp8870_state* state = fe->demodulator_priv;
 376         int ret;
 377         u32 tmp;
 378
 379         *ber = 0;
 380
 381         ret = sp8870_readreg(state, 0xC08);
 382         if (ret < 0)
 383                 return -EIO;
 384
 385         tmp = ret & 0x3F;
 386
 387         ret = sp8870_readreg(state, 0xC07);
 388         if (ret < 0)
 389                 return -EIO;
 390
 391          tmp = ret << 6;
 392
 393         if (tmp >= 0x3FFF0)
 394                 tmp = ~0;
 395
 396         *ber = tmp;
 397
 398         return 0;
 399 }
 400
 401 static int sp8870_read_signal_strength(struct dvb_frontend* fe,  u16 * signal)
 402 {
 403         struct sp8870_state* state = fe->demodulator_priv;
 404         int ret;
 405         u16 tmp;
 406
 407         *signal = 0;
 408
 409         ret = sp8870_readreg (state, 0x306);
 410         if (ret < 0)
 411                 return -EIO;
 412
 413         tmp = ret << 8;
 414
 415         ret = sp8870_readreg (state, 0x303);
 416         if (ret < 0)
 417                 return -EIO;
 418
 419         tmp |= ret;
 420
 421         if (tmp)
 422                 *signal = 0xFFFF - tmp;
 423
 424         return 0;
 425 }
 426
 427 static int sp8870_read_uncorrected_blocks (struct dvb_frontend* fe, u32* ublocks)
 428 {
 429         struct sp8870_state* state = fe->demodulator_priv;
 430         int ret;
 431
 432         *ublocks = 0;
 433
 434         ret = sp8870_readreg(state, 0xC0C);
 435         if (ret < 0)
 436                 return -EIO;
 437
 438         if (ret == 0xFFFF)
 439                 ret = ~0;
 440
 441         *ublocks = ret;
 442
 443         return 0;
 444 }
 445
 446 /* number of trials to recover from lockup */
 447 #define MAXTRIALS 5
 448 /* maximum checks for data valid signal */
 449 #define MAXCHECKS 100
 450
 451 /* only for debugging: counter for detected lockups */
 452 static int lockups;
 453 /* only for debugging: counter for channel switches */
 454 static int switches;
 455
 456 static int sp8870_set_frontend(struct dvb_frontend *fe)
 457 {
 458         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
 459         struct sp8870_state* state = fe->demodulator_priv;
 460
 461         /*
 462             The firmware of the sp8870 sometimes locks up after setting frontend parameters.
 463             We try to detect this by checking the data valid signal.
 464             If it is not set after MAXCHECKS we try to recover the lockup by setting
 465             the frontend parameters again.
 466         */
 467
 468         int err = 0;
 469         int valid = 0;
 470         int trials = 0;
 471         int check_count = 0;
 472
 473         dprintk("%s: frequency = %i\n", __func__, p->frequency);
 474
 475         for (trials = 1; trials <= MAXTRIALS; trials++) {
 476
 477                 err = sp8870_set_frontend_parameters(fe);
 478                 if (err)
 479                         return err;
 480
 481                 for (check_count = 0; check_count < MAXCHECKS; check_count++) {
 482 //                      valid = ((sp8870_readreg(i2c, 0x0200) & 4) == 0);
 483                         valid = sp8870_read_data_valid_signal(state);
 484                         if (valid) {
 485                                 dprintk("%s: delay = %i usec\n",
 486                                         __func__, check_count * 10);
 487                                 break;
 488                         }
 489                         udelay(10);
 490                 }
 491                 if (valid)
 492                         break;
 493         }
 494
 495         if (!valid) {
 496                 printk("%s: firmware crash!!!!!!\n", __func__);
 497                 return -EIO;
 498         }
 499
 500         if (debug) {
 501                 if (valid) {
 502                         if (trials > 1) {
 503                                 printk("%s: firmware lockup!!!\n", __func__);
 504                                 printk("%s: recovered after %i trial(s))\n",  __func__, trials - 1);
 505                                 lockups++;
 506                         }
 507                 }
 508                 switches++;
 509                 printk("%s: switches = %i lockups = %i\n", __func__, switches, lockups);
 510         }
 511
 512         return 0;
 513 }
 514
 515 static int sp8870_sleep(struct dvb_frontend* fe)
 516 {
 517         struct sp8870_state* state = fe->demodulator_priv;
 518
 519         // tristate TS output and disable interface pins
 520         return sp8870_writereg(state, 0xC18, 0x000);
 521 }
 522
 523 static int sp8870_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings* fesettings)
 524 {
 525         fesettings->min_delay_ms = 350;
 526         fesettings->step_size = 0;
 527         fesettings->max_drift = 0;
 528         return 0;
 529 }
 530
 531 static int sp8870_i2c_gate_ctrl(struct dvb_frontend* fe, int enable)
 532 {
 533         struct sp8870_state* state = fe->demodulator_priv;
 534
 535         if (enable) {
 536                 return sp8870_writereg(state, 0x206, 0x001);
 537         } else {
 538                 return sp8870_writereg(state, 0x206, 0x000);
 539         }
 540 }
 541
 542 static void sp8870_release(struct dvb_frontend* fe)
 543 {
 544         struct sp8870_state* state = fe->demodulator_priv;
 545         kfree(state);
 546 }
 547
 548 static struct dvb_frontend_ops sp8870_ops;
 549
 550 struct dvb_frontend* sp8870_attach(const struct sp8870_config* config,
 551                                    struct i2c_adapter* i2c)
 552 {
 553         struct sp8870_state* state = NULL;
 554
 555         /* allocate memory for the internal state */
 556         state = kzalloc(sizeof(struct sp8870_state), GFP_KERNEL);
 557         if (state == NULL) goto error;
 558
 559         /* setup the state */
 560         state->config = config;
 561         state->i2c = i2c;
 562         state->initialised = 0;
 563
 564         /* check if the demod is there */
 565         if (sp8870_readreg(state, 0x0200) < 0) goto error;
 566
 567         /* create dvb_frontend */
 568         memcpy(&state->frontend.ops, &sp8870_ops, sizeof(struct dvb_frontend_ops));
 569         state->frontend.demodulator_priv = state;
 570         return &state->frontend;
 571
 572 error:
 573         kfree(state);
 574         return NULL;
 575 }
 576
 577 static struct dvb_frontend_ops sp8870_ops = {
 578         .delsys = { SYS_DVBT },
 579         .info = {
 580                 .name                   = "Spase SP8870 DVB-T",
 581                 .frequency_min          = 470000000,
 582                 .frequency_max          = 860000000,
 583                 .frequency_stepsize     = 166666,
 584                 .caps                   = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 |
 585                                           FE_CAN_FEC_3_4 | FE_CAN_FEC_5_6 |
 586                                           FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
 587                                           FE_CAN_QPSK | FE_CAN_QAM_16 |
 588                                           FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
 589                                           FE_CAN_HIERARCHY_AUTO |  FE_CAN_RECOVER
 590         },
 591
 592         .release = sp8870_release,
 593
 594         .init = sp8870_init,
 595         .sleep = sp8870_sleep,
 596         .i2c_gate_ctrl = sp8870_i2c_gate_ctrl,
 597
 598         .set_frontend = sp8870_set_frontend,
 599         .get_tune_settings = sp8870_get_tune_settings,
 600
 601         .read_status = sp8870_read_status,
 602         .read_ber = sp8870_read_ber,
 603         .read_signal_strength = sp8870_read_signal_strength,
 604         .read_ucblocks = sp8870_read_uncorrected_blocks,
 605 };
 606
 607 module_param(debug, int, 0644);
 608 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
 609
 610 MODULE_DESCRIPTION("Spase SP8870 DVB-T Demodulator driver");
 611 MODULE_AUTHOR("Juergen Peitz");
 612 MODULE_LICENSE("GPL");
 613
 614 EXPORT_SYMBOL(sp8870_attach);