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>/scripts/get_dvb_firmware alps_tdlb7" to
  25  * download/extract it, and then copy it to /usr/lib/hotplug/firmware
  26  * or /lib/firmware (depending on configuration of firmware hotplug).
  27  */
  28 #define SP8870_DEFAULT_FIRMWARE "dvb-fe-sp8870.fw"
  29
  30 #include <linux/init.h>
  31 #include <linux/module.h>
  32 #include <linux/device.h>
  33 #include <linux/firmware.h>
  34 #include <linux/delay.h>
  35 #include <linux/string.h>
  36 #include <linux/slab.h>
  37
  38 #include <media/dvb_frontend.h>
  39 #include "sp8870.h"
  40
  41
  42 struct sp8870_state {
  43
  44         struct i2c_adapter* i2c;
  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", __func__, 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", __func__, 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         const 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", __func__);
 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", __func__);
 135                         printk ("%s: i2c error (err == %i)\n", __func__, err);
 136                         return err;
 137                 }
 138                 fw_pos += tx_len;
 139         }
 140
 141         dprintk ("%s: done!\n", __func__);
 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 dtv_frontend_properties *p, u16 *reg0xc05)
 172 {
 173         int known_parameters = 1;
 174
 175         *reg0xc05 = 0x000;
 176
 177         switch (p->modulation) {
 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->hierarchy) {
 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->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 {
 250         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
 251         struct sp8870_state* 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         if (fe->ops.tuner_ops.set_params) {
 263                 fe->ops.tuner_ops.set_params(fe);
 264                 if (fe->ops.i2c_gate_ctrl) fe->ops.i2c_gate_ctrl(fe, 0);
 265         }
 266
 267         // sample rate correction bit [23..17]
 268         sp8870_writereg(state, 0x0319, 0x000A);
 269
 270         // sample rate correction bit [16..0]
 271         sp8870_writereg(state, 0x031A, 0x0AAB);
 272
 273         // integer carrier offset
 274         sp8870_writereg(state, 0x0309, 0x0400);
 275
 276         // fractional carrier offset
 277         sp8870_writereg(state, 0x030A, 0x0000);
 278
 279         // filter for 6/7/8 Mhz channel
 280         if (p->bandwidth_hz == 6000000)
 281                 sp8870_writereg(state, 0x0311, 0x0002);
 282         else if (p->bandwidth_hz == 7000000)
 283                 sp8870_writereg(state, 0x0311, 0x0001);
 284         else
 285                 sp8870_writereg(state, 0x0311, 0x0000);
 286
 287         // scan order: 2k first = 0x0000, 8k first = 0x0001
 288         if (p->transmission_mode == TRANSMISSION_MODE_2K)
 289                 sp8870_writereg(state, 0x0338, 0x0000);
 290         else
 291                 sp8870_writereg(state, 0x0338, 0x0001);
 292
 293         sp8870_writereg(state, 0xc05, reg0xc05);
 294
 295         // read status reg in order to clear pending irqs
 296         err = sp8870_readreg(state, 0x200);
 297         if (err)
 298                 return err;
 299
 300         // system controller start
 301         sp8870_microcontroller_start(state);
 302
 303         return 0;
 304 }
 305
 306 static int sp8870_init (struct dvb_frontend* fe)
 307 {
 308         struct sp8870_state* state = fe->demodulator_priv;
 309         const struct firmware *fw = NULL;
 310
 311         sp8870_wake_up(state);
 312         if (state->initialised) return 0;
 313         state->initialised = 1;
 314
 315         dprintk ("%s\n", __func__);
 316
 317
 318         /* request the firmware, this will block until someone uploads it */
 319         printk("sp8870: waiting for firmware upload (%s)...\n", SP8870_DEFAULT_FIRMWARE);
 320         if (state->config->request_firmware(fe, &fw, SP8870_DEFAULT_FIRMWARE)) {
 321                 printk("sp8870: no firmware upload (timeout or file not found?)\n");
 322                 return -EIO;
 323         }
 324
 325         if (sp8870_firmware_upload(state, fw)) {
 326                 printk("sp8870: writing firmware to device failed\n");
 327                 release_firmware(fw);
 328                 return -EIO;
 329         }
 330         release_firmware(fw);
 331         printk("sp8870: firmware upload complete\n");
 332
 333         /* enable TS output and interface pins */
 334         sp8870_writereg(state, 0xc18, 0x00d);
 335
 336         // system controller stop
 337         sp8870_microcontroller_stop(state);
 338
 339         // ADC mode
 340         sp8870_writereg(state, 0x0301, 0x0003);
 341
 342         // Reed Solomon parity bytes passed to output
 343         sp8870_writereg(state, 0x0C13, 0x0001);
 344
 345         // MPEG clock is suppressed if no valid data
 346         sp8870_writereg(state, 0x0C14, 0x0001);
 347
 348         /* bit 0x010: enable data valid signal */
 349         sp8870_writereg(state, 0x0D00, 0x010);
 350         sp8870_writereg(state, 0x0D01, 0x000);
 351
 352         return 0;
 353 }
 354
 355 static int sp8870_read_status(struct dvb_frontend *fe,
 356                               enum fe_status *fe_status)
 357 {
 358         struct sp8870_state* state = fe->demodulator_priv;
 359         int status;
 360         int signal;
 361
 362         *fe_status = 0;
 363
 364         status = sp8870_readreg (state, 0x0200);
 365         if (status < 0)
 366                 return -EIO;
 367
 368         signal = sp8870_readreg (state, 0x0303);
 369         if (signal < 0)
 370                 return -EIO;
 371
 372         if (signal > 0x0F)
 373                 *fe_status |= FE_HAS_SIGNAL;
 374         if (status & 0x08)
 375                 *fe_status |= FE_HAS_SYNC;
 376         if (status & 0x04)
 377                 *fe_status |= FE_HAS_LOCK | FE_HAS_CARRIER | FE_HAS_VITERBI;
 378
 379         return 0;
 380 }
 381
 382 static int sp8870_read_ber (struct dvb_frontend* fe, u32 * ber)
 383 {
 384         struct sp8870_state* state = fe->demodulator_priv;
 385         int ret;
 386         u32 tmp;
 387
 388         *ber = 0;
 389
 390         ret = sp8870_readreg(state, 0xC08);
 391         if (ret < 0)
 392                 return -EIO;
 393
 394         tmp = ret & 0x3F;
 395
 396         ret = sp8870_readreg(state, 0xC07);
 397         if (ret < 0)
 398                 return -EIO;
 399
 400         tmp = ret << 6;
 401         if (tmp >= 0x3FFF0)
 402                 tmp = ~0;
 403
 404         *ber = tmp;
 405
 406         return 0;
 407 }
 408
 409 static int sp8870_read_signal_strength(struct dvb_frontend* fe,  u16 * signal)
 410 {
 411         struct sp8870_state* state = fe->demodulator_priv;
 412         int ret;
 413         u16 tmp;
 414
 415         *signal = 0;
 416
 417         ret = sp8870_readreg (state, 0x306);
 418         if (ret < 0)
 419                 return -EIO;
 420
 421         tmp = ret << 8;
 422
 423         ret = sp8870_readreg (state, 0x303);
 424         if (ret < 0)
 425                 return -EIO;
 426
 427         tmp |= ret;
 428
 429         if (tmp)
 430                 *signal = 0xFFFF - tmp;
 431
 432         return 0;
 433 }
 434
 435 static int sp8870_read_uncorrected_blocks (struct dvb_frontend* fe, u32* ublocks)
 436 {
 437         struct sp8870_state* state = fe->demodulator_priv;
 438         int ret;
 439
 440         *ublocks = 0;
 441
 442         ret = sp8870_readreg(state, 0xC0C);
 443         if (ret < 0)
 444                 return -EIO;
 445
 446         if (ret == 0xFFFF)
 447                 ret = ~0;
 448
 449         *ublocks = ret;
 450
 451         return 0;
 452 }
 453
 454 /* number of trials to recover from lockup */
 455 #define MAXTRIALS 5
 456 /* maximum checks for data valid signal */
 457 #define MAXCHECKS 100
 458
 459 /* only for debugging: counter for detected lockups */
 460 static int lockups;
 461 /* only for debugging: counter for channel switches */
 462 static int switches;
 463
 464 static int sp8870_set_frontend(struct dvb_frontend *fe)
 465 {
 466         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
 467         struct sp8870_state* state = fe->demodulator_priv;
 468
 469         /*
 470             The firmware of the sp8870 sometimes locks up after setting frontend parameters.
 471             We try to detect this by checking the data valid signal.
 472             If it is not set after MAXCHECKS we try to recover the lockup by setting
 473             the frontend parameters again.
 474         */
 475
 476         int err = 0;
 477         int valid = 0;
 478         int trials = 0;
 479         int check_count = 0;
 480
 481         dprintk("%s: frequency = %i\n", __func__, p->frequency);
 482
 483         for (trials = 1; trials <= MAXTRIALS; trials++) {
 484
 485                 err = sp8870_set_frontend_parameters(fe);
 486                 if (err)
 487                         return err;
 488
 489                 for (check_count = 0; check_count < MAXCHECKS; check_count++) {
 490 //                      valid = ((sp8870_readreg(i2c, 0x0200) & 4) == 0);
 491                         valid = sp8870_read_data_valid_signal(state);
 492                         if (valid) {
 493                                 dprintk("%s: delay = %i usec\n",
 494                                         __func__, check_count * 10);
 495                                 break;
 496                         }
 497                         udelay(10);
 498                 }
 499                 if (valid)
 500                         break;
 501         }
 502
 503         if (!valid) {
 504                 printk("%s: firmware crash!!!!!!\n", __func__);
 505                 return -EIO;
 506         }
 507
 508         if (debug) {
 509                 if (valid) {
 510                         if (trials > 1) {
 511                                 printk("%s: firmware lockup!!!\n", __func__);
 512                                 printk("%s: recovered after %i trial(s))\n",  __func__, trials - 1);
 513                                 lockups++;
 514                         }
 515                 }
 516                 switches++;
 517                 printk("%s: switches = %i lockups = %i\n", __func__, switches, lockups);
 518         }
 519
 520         return 0;
 521 }
 522
 523 static int sp8870_sleep(struct dvb_frontend* fe)
 524 {
 525         struct sp8870_state* state = fe->demodulator_priv;
 526
 527         // tristate TS output and disable interface pins
 528         return sp8870_writereg(state, 0xC18, 0x000);
 529 }
 530
 531 static int sp8870_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings* fesettings)
 532 {
 533         fesettings->min_delay_ms = 350;
 534         fesettings->step_size = 0;
 535         fesettings->max_drift = 0;
 536         return 0;
 537 }
 538
 539 static int sp8870_i2c_gate_ctrl(struct dvb_frontend* fe, int enable)
 540 {
 541         struct sp8870_state* state = fe->demodulator_priv;
 542
 543         if (enable) {
 544                 return sp8870_writereg(state, 0x206, 0x001);
 545         } else {
 546                 return sp8870_writereg(state, 0x206, 0x000);
 547         }
 548 }
 549
 550 static void sp8870_release(struct dvb_frontend* fe)
 551 {
 552         struct sp8870_state* state = fe->demodulator_priv;
 553         kfree(state);
 554 }
 555
 556 static const struct dvb_frontend_ops sp8870_ops;
 557
 558 struct dvb_frontend* sp8870_attach(const struct sp8870_config* config,
 559                                    struct i2c_adapter* i2c)
 560 {
 561         struct sp8870_state* state = NULL;
 562
 563         /* allocate memory for the internal state */
 564         state = kzalloc(sizeof(struct sp8870_state), GFP_KERNEL);
 565         if (state == NULL) goto error;
 566
 567         /* setup the state */
 568         state->config = config;
 569         state->i2c = i2c;
 570         state->initialised = 0;
 571
 572         /* check if the demod is there */
 573         if (sp8870_readreg(state, 0x0200) < 0) goto error;
 574
 575         /* create dvb_frontend */
 576         memcpy(&state->frontend.ops, &sp8870_ops, sizeof(struct dvb_frontend_ops));
 577         state->frontend.demodulator_priv = state;
 578         return &state->frontend;
 579
 580 error:
 581         kfree(state);
 582         return NULL;
 583 }
 584
 585 static const struct dvb_frontend_ops sp8870_ops = {
 586         .delsys = { SYS_DVBT },
 587         .info = {
 588                 .name                   = "Spase SP8870 DVB-T",
 589                 .frequency_min_hz       = 470 * MHz,
 590                 .frequency_max_hz       = 860 * MHz,
 591                 .frequency_stepsize_hz  = 166666,
 592                 .caps                   = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 |
 593                                           FE_CAN_FEC_3_4 | FE_CAN_FEC_5_6 |
 594                                           FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
 595                                           FE_CAN_QPSK | FE_CAN_QAM_16 |
 596                                           FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
 597                                           FE_CAN_HIERARCHY_AUTO |  FE_CAN_RECOVER
 598         },
 599
 600         .release = sp8870_release,
 601
 602         .init = sp8870_init,
 603         .sleep = sp8870_sleep,
 604         .i2c_gate_ctrl = sp8870_i2c_gate_ctrl,
 605
 606         .set_frontend = sp8870_set_frontend,
 607         .get_tune_settings = sp8870_get_tune_settings,
 608
 609         .read_status = sp8870_read_status,
 610         .read_ber = sp8870_read_ber,
 611         .read_signal_strength = sp8870_read_signal_strength,
 612         .read_ucblocks = sp8870_read_uncorrected_blocks,
 613 };
 614
 615 module_param(debug, int, 0644);
 616 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
 617
 618 MODULE_DESCRIPTION("Spase SP8870 DVB-T Demodulator driver");
 619 MODULE_AUTHOR("Juergen Peitz");
 620 MODULE_LICENSE("GPL");
 621
 622 EXPORT_SYMBOL(sp8870_attach);