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