drivers/media/dvb-frontends/l64781.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3     driver for LSI L64781 COFDM demodulator
   4
   5     Copyright (C) 2001 Holger Waechtler for Convergence Integrated Media GmbH
   6                        Marko Kohtala <marko.kohtala@luukku.com>
   7
   8
   9 */
  10
  11 #include <linux/init.h>
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/string.h>
  15 #include <linux/slab.h>
  16 #include <media/dvb_frontend.h>
  17 #include "l64781.h"
  18
  19
  20 struct l64781_state {
  21         struct i2c_adapter* i2c;
  22         const struct l64781_config* config;
  23         struct dvb_frontend frontend;
  24
  25         /* private demodulator data */
  26         unsigned int first:1;
  27 };
  28
  29 #define dprintk(args...) \
  30         do { \
  31                 if (debug) printk(KERN_DEBUG "l64781: " args); \
  32         } while (0)
  33
  34 static int debug;
  35
  36 module_param(debug, int, 0644);
  37 MODULE_PARM_DESC(debug, "Turn on/off frontend debugging (default:off).");
  38
  39
  40 static int l64781_writereg (struct l64781_state* state, u8 reg, u8 data)
  41 {
  42         int ret;
  43         u8 buf [] = { reg, data };
  44         struct i2c_msg msg = { .addr = state->config->demod_address, .flags = 0, .buf = buf, .len = 2 };
  45
  46         if ((ret = i2c_transfer(state->i2c, &msg, 1)) != 1)
  47                 dprintk ("%s: write_reg error (reg == %02x) = %02x!\n",
  48                          __func__, reg, ret);
  49
  50         return (ret != 1) ? -1 : 0;
  51 }
  52
  53 static int l64781_readreg (struct l64781_state* state, u8 reg)
  54 {
  55         int ret;
  56         u8 b0 [] = { reg };
  57         u8 b1 [] = { 0 };
  58         struct i2c_msg msg [] = { { .addr = state->config->demod_address, .flags = 0, .buf = b0, .len = 1 },
  59                            { .addr = state->config->demod_address, .flags = I2C_M_RD, .buf = b1, .len = 1 } };
  60
  61         ret = i2c_transfer(state->i2c, msg, 2);
  62
  63         if (ret != 2) return ret;
  64
  65         return b1[0];
  66 }
  67
  68 static void apply_tps (struct l64781_state* state)
  69 {
  70         l64781_writereg (state, 0x2a, 0x00);
  71         l64781_writereg (state, 0x2a, 0x01);
  72
  73         /* This here is a little bit questionable because it enables
  74            the automatic update of TPS registers. I think we'd need to
  75            handle the IRQ from FE to update some other registers as
  76            well, or at least implement some magic to tuning to correct
  77            to the TPS received from transmission. */
  78         l64781_writereg (state, 0x2a, 0x02);
  79 }
  80
  81
  82 static void reset_afc (struct l64781_state* state)
  83 {
  84         /* Set AFC stall for the AFC_INIT_FRQ setting, TIM_STALL for
  85            timing offset */
  86         l64781_writereg (state, 0x07, 0x9e); /* stall AFC */
  87         l64781_writereg (state, 0x08, 0);    /* AFC INIT FREQ */
  88         l64781_writereg (state, 0x09, 0);
  89         l64781_writereg (state, 0x0a, 0);
  90         l64781_writereg (state, 0x07, 0x8e);
  91         l64781_writereg (state, 0x0e, 0);    /* AGC gain to zero in beginning */
  92         l64781_writereg (state, 0x11, 0x80); /* stall TIM */
  93         l64781_writereg (state, 0x10, 0);    /* TIM_OFFSET_LSB */
  94         l64781_writereg (state, 0x12, 0);
  95         l64781_writereg (state, 0x13, 0);
  96         l64781_writereg (state, 0x11, 0x00);
  97 }
  98
  99 static int reset_and_configure (struct l64781_state* state)
 100 {
 101         u8 buf [] = { 0x06 };
 102         struct i2c_msg msg = { .addr = 0x00, .flags = 0, .buf = buf, .len = 1 };
 103         // NOTE: this is correct in writing to address 0x00
 104
 105         return (i2c_transfer(state->i2c, &msg, 1) == 1) ? 0 : -ENODEV;
 106 }
 107
 108 static int apply_frontend_param(struct dvb_frontend *fe)
 109 {
 110         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
 111         struct l64781_state* state = fe->demodulator_priv;
 112         /* The coderates for FEC_NONE, FEC_4_5 and FEC_FEC_6_7 are arbitrary */
 113         static const u8 fec_tab[] = { 7, 0, 1, 2, 9, 3, 10, 4 };
 114         /* QPSK, QAM_16, QAM_64 */
 115         static const u8 qam_tab [] = { 2, 4, 0, 6 };
 116         static const u8 guard_tab [] = { 1, 2, 4, 8 };
 117         /* The Grundig 29504-401.04 Tuner comes with 18.432MHz crystal. */
 118         static const u32 ppm = 8000;
 119         u32 ddfs_offset_fixed;
 120 /*      u32 ddfs_offset_variable = 0x6000-((1000000UL+ppm)/ */
 121 /*                      bw_tab[p->bandWidth]<<10)/15625; */
 122         u32 init_freq;
 123         u32 spi_bias;
 124         u8 val0x04;
 125         u8 val0x05;
 126         u8 val0x06;
 127         int bw;
 128
 129         switch (p->bandwidth_hz) {
 130         case 8000000:
 131                 bw = 8;
 132                 break;
 133         case 7000000:
 134                 bw = 7;
 135                 break;
 136         case 6000000:
 137                 bw = 6;
 138                 break;
 139         default:
 140                 return -EINVAL;
 141         }
 142
 143         if (fe->ops.tuner_ops.set_params) {
 144                 fe->ops.tuner_ops.set_params(fe);
 145                 if (fe->ops.i2c_gate_ctrl) fe->ops.i2c_gate_ctrl(fe, 0);
 146         }
 147
 148         if (p->inversion != INVERSION_ON &&
 149             p->inversion != INVERSION_OFF)
 150                 return -EINVAL;
 151
 152         if (p->code_rate_HP != FEC_1_2 && p->code_rate_HP != FEC_2_3 &&
 153             p->code_rate_HP != FEC_3_4 && p->code_rate_HP != FEC_5_6 &&
 154             p->code_rate_HP != FEC_7_8)
 155                 return -EINVAL;
 156
 157         if (p->hierarchy != HIERARCHY_NONE &&
 158             (p->code_rate_LP != FEC_1_2 && p->code_rate_LP != FEC_2_3 &&
 159              p->code_rate_LP != FEC_3_4 && p->code_rate_LP != FEC_5_6 &&
 160              p->code_rate_LP != FEC_7_8))
 161                 return -EINVAL;
 162
 163         if (p->modulation != QPSK && p->modulation != QAM_16 &&
 164             p->modulation != QAM_64)
 165                 return -EINVAL;
 166
 167         if (p->transmission_mode != TRANSMISSION_MODE_2K &&
 168             p->transmission_mode != TRANSMISSION_MODE_8K)
 169                 return -EINVAL;
 170
 171         if ((int)p->guard_interval < GUARD_INTERVAL_1_32 ||
 172             p->guard_interval > GUARD_INTERVAL_1_4)
 173                 return -EINVAL;
 174
 175         if ((int)p->hierarchy < HIERARCHY_NONE ||
 176             p->hierarchy > HIERARCHY_4)
 177                 return -EINVAL;
 178
 179         ddfs_offset_fixed = 0x4000-(ppm<<16)/bw/1000000;
 180
 181         /* This works up to 20000 ppm, it overflows if too large ppm! */
 182         init_freq = (((8UL<<25) + (8UL<<19) / 25*ppm / (15625/25)) /
 183                         bw & 0xFFFFFF);
 184
 185         /* SPI bias calculation is slightly modified to fit in 32bit */
 186         /* will work for high ppm only... */
 187         spi_bias = 378 * (1 << 10);
 188         spi_bias *= 16;
 189         spi_bias *= bw;
 190         spi_bias *= qam_tab[p->modulation];
 191         spi_bias /= p->code_rate_HP + 1;
 192         spi_bias /= (guard_tab[p->guard_interval] + 32);
 193         spi_bias *= 1000;
 194         spi_bias /= 1000 + ppm/1000;
 195         spi_bias *= p->code_rate_HP;
 196
 197         val0x04 = (p->transmission_mode << 2) | p->guard_interval;
 198         val0x05 = fec_tab[p->code_rate_HP];
 199
 200         if (p->hierarchy != HIERARCHY_NONE)
 201                 val0x05 |= (p->code_rate_LP - FEC_1_2) << 3;
 202
 203         val0x06 = (p->hierarchy << 2) | p->modulation;
 204
 205         l64781_writereg (state, 0x04, val0x04);
 206         l64781_writereg (state, 0x05, val0x05);
 207         l64781_writereg (state, 0x06, val0x06);
 208
 209         reset_afc (state);
 210
 211         /* Technical manual section 2.6.1, TIM_IIR_GAIN optimal values */
 212         l64781_writereg (state, 0x15,
 213                          p->transmission_mode == TRANSMISSION_MODE_2K ? 1 : 3);
 214         l64781_writereg (state, 0x16, init_freq & 0xff);
 215         l64781_writereg (state, 0x17, (init_freq >> 8) & 0xff);
 216         l64781_writereg (state, 0x18, (init_freq >> 16) & 0xff);
 217
 218         l64781_writereg (state, 0x1b, spi_bias & 0xff);
 219         l64781_writereg (state, 0x1c, (spi_bias >> 8) & 0xff);
 220         l64781_writereg (state, 0x1d, ((spi_bias >> 16) & 0x7f) |
 221                 (p->inversion == INVERSION_ON ? 0x80 : 0x00));
 222
 223         l64781_writereg (state, 0x22, ddfs_offset_fixed & 0xff);
 224         l64781_writereg (state, 0x23, (ddfs_offset_fixed >> 8) & 0x3f);
 225
 226         l64781_readreg (state, 0x00);  /*  clear interrupt registers... */
 227         l64781_readreg (state, 0x01);  /*  dto. */
 228
 229         apply_tps (state);
 230
 231         return 0;
 232 }
 233
 234 static int get_frontend(struct dvb_frontend *fe,
 235                         struct dtv_frontend_properties *p)
 236 {
 237         struct l64781_state* state = fe->demodulator_priv;
 238         int tmp;
 239
 240
 241         tmp = l64781_readreg(state, 0x04);
 242         switch(tmp & 3) {
 243         case 0:
 244                 p->guard_interval = GUARD_INTERVAL_1_32;
 245                 break;
 246         case 1:
 247                 p->guard_interval = GUARD_INTERVAL_1_16;
 248                 break;
 249         case 2:
 250                 p->guard_interval = GUARD_INTERVAL_1_8;
 251                 break;
 252         case 3:
 253                 p->guard_interval = GUARD_INTERVAL_1_4;
 254                 break;
 255         }
 256         switch((tmp >> 2) & 3) {
 257         case 0:
 258                 p->transmission_mode = TRANSMISSION_MODE_2K;
 259                 break;
 260         case 1:
 261                 p->transmission_mode = TRANSMISSION_MODE_8K;
 262                 break;
 263         default:
 264                 printk(KERN_WARNING "Unexpected value for transmission_mode\n");
 265         }
 266
 267         tmp = l64781_readreg(state, 0x05);
 268         switch(tmp & 7) {
 269         case 0:
 270                 p->code_rate_HP = FEC_1_2;
 271                 break;
 272         case 1:
 273                 p->code_rate_HP = FEC_2_3;
 274                 break;
 275         case 2:
 276                 p->code_rate_HP = FEC_3_4;
 277                 break;
 278         case 3:
 279                 p->code_rate_HP = FEC_5_6;
 280                 break;
 281         case 4:
 282                 p->code_rate_HP = FEC_7_8;
 283                 break;
 284         default:
 285                 printk("Unexpected value for code_rate_HP\n");
 286         }
 287         switch((tmp >> 3) & 7) {
 288         case 0:
 289                 p->code_rate_LP = FEC_1_2;
 290                 break;
 291         case 1:
 292                 p->code_rate_LP = FEC_2_3;
 293                 break;
 294         case 2:
 295                 p->code_rate_LP = FEC_3_4;
 296                 break;
 297         case 3:
 298                 p->code_rate_LP = FEC_5_6;
 299                 break;
 300         case 4:
 301                 p->code_rate_LP = FEC_7_8;
 302                 break;
 303         default:
 304                 printk("Unexpected value for code_rate_LP\n");
 305         }
 306
 307         tmp = l64781_readreg(state, 0x06);
 308         switch(tmp & 3) {
 309         case 0:
 310                 p->modulation = QPSK;
 311                 break;
 312         case 1:
 313                 p->modulation = QAM_16;
 314                 break;
 315         case 2:
 316                 p->modulation = QAM_64;
 317                 break;
 318         default:
 319                 printk(KERN_WARNING "Unexpected value for modulation\n");
 320         }
 321         switch((tmp >> 2) & 7) {
 322         case 0:
 323                 p->hierarchy = HIERARCHY_NONE;
 324                 break;
 325         case 1:
 326                 p->hierarchy = HIERARCHY_1;
 327                 break;
 328         case 2:
 329                 p->hierarchy = HIERARCHY_2;
 330                 break;
 331         case 3:
 332                 p->hierarchy = HIERARCHY_4;
 333                 break;
 334         default:
 335                 printk("Unexpected value for hierarchy\n");
 336         }
 337
 338
 339         tmp = l64781_readreg (state, 0x1d);
 340         p->inversion = (tmp & 0x80) ? INVERSION_ON : INVERSION_OFF;
 341
 342         tmp = (int) (l64781_readreg (state, 0x08) |
 343                      (l64781_readreg (state, 0x09) << 8) |
 344                      (l64781_readreg (state, 0x0a) << 16));
 345         p->frequency += tmp;
 346
 347         return 0;
 348 }
 349
 350 static int l64781_read_status(struct dvb_frontend *fe, enum fe_status *status)
 351 {
 352         struct l64781_state* state = fe->demodulator_priv;
 353         int sync = l64781_readreg (state, 0x32);
 354         int gain = l64781_readreg (state, 0x0e);
 355
 356         l64781_readreg (state, 0x00);  /*  clear interrupt registers... */
 357         l64781_readreg (state, 0x01);  /*  dto. */
 358
 359         *status = 0;
 360
 361         if (gain > 5)
 362                 *status |= FE_HAS_SIGNAL;
 363
 364         if (sync & 0x02) /* VCXO locked, this criteria should be ok */
 365                 *status |= FE_HAS_CARRIER;
 366
 367         if (sync & 0x20)
 368                 *status |= FE_HAS_VITERBI;
 369
 370         if (sync & 0x40)
 371                 *status |= FE_HAS_SYNC;
 372
 373         if (sync == 0x7f)
 374                 *status |= FE_HAS_LOCK;
 375
 376         return 0;
 377 }
 378
 379 static int l64781_read_ber(struct dvb_frontend* fe, u32* ber)
 380 {
 381         struct l64781_state* state = fe->demodulator_priv;
 382
 383         /*   XXX FIXME: set up counting period (reg 0x26...0x28)
 384          */
 385         *ber = l64781_readreg (state, 0x39)
 386             | (l64781_readreg (state, 0x3a) << 8);
 387
 388         return 0;
 389 }
 390
 391 static int l64781_read_signal_strength(struct dvb_frontend* fe, u16* signal_strength)
 392 {
 393         struct l64781_state* state = fe->demodulator_priv;
 394
 395         u8 gain = l64781_readreg (state, 0x0e);
 396         *signal_strength = (gain << 8) | gain;
 397
 398         return 0;
 399 }
 400
 401 static int l64781_read_snr(struct dvb_frontend* fe, u16* snr)
 402 {
 403         struct l64781_state* state = fe->demodulator_priv;
 404
 405         u8 avg_quality = 0xff - l64781_readreg (state, 0x33);
 406         *snr = (avg_quality << 8) | avg_quality; /* not exact, but...*/
 407
 408         return 0;
 409 }
 410
 411 static int l64781_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
 412 {
 413         struct l64781_state* state = fe->demodulator_priv;
 414
 415         *ucblocks = l64781_readreg (state, 0x37)
 416            | (l64781_readreg (state, 0x38) << 8);
 417
 418         return 0;
 419 }
 420
 421 static int l64781_sleep(struct dvb_frontend* fe)
 422 {
 423         struct l64781_state* state = fe->demodulator_priv;
 424
 425         /* Power down */
 426         return l64781_writereg (state, 0x3e, 0x5a);
 427 }
 428
 429 static int l64781_init(struct dvb_frontend* fe)
 430 {
 431         struct l64781_state* state = fe->demodulator_priv;
 432
 433         reset_and_configure (state);
 434
 435         /* Power up */
 436         l64781_writereg (state, 0x3e, 0xa5);
 437
 438         /* Reset hard */
 439         l64781_writereg (state, 0x2a, 0x04);
 440         l64781_writereg (state, 0x2a, 0x00);
 441
 442         /* Set tuner specific things */
 443         /* AFC_POL, set also in reset_afc */
 444         l64781_writereg (state, 0x07, 0x8e);
 445
 446         /* Use internal ADC */
 447         l64781_writereg (state, 0x0b, 0x81);
 448
 449         /* AGC loop gain, and polarity is positive */
 450         l64781_writereg (state, 0x0c, 0x84);
 451
 452         /* Internal ADC outputs two's complement */
 453         l64781_writereg (state, 0x0d, 0x8c);
 454
 455         /* With ppm=8000, it seems the DTR_SENSITIVITY will result in
 456            value of 2 with all possible bandwidths and guard
 457            intervals, which is the initial value anyway. */
 458         /*l64781_writereg (state, 0x19, 0x92);*/
 459
 460         /* Everything is two's complement, soft bit and CSI_OUT too */
 461         l64781_writereg (state, 0x1e, 0x09);
 462
 463         /* delay a bit after first init attempt */
 464         if (state->first) {
 465                 state->first = 0;
 466                 msleep(200);
 467         }
 468
 469         return 0;
 470 }
 471
 472 static int l64781_get_tune_settings(struct dvb_frontend* fe,
 473                                     struct dvb_frontend_tune_settings* fesettings)
 474 {
 475         fesettings->min_delay_ms = 4000;
 476         fesettings->step_size = 0;
 477         fesettings->max_drift = 0;
 478         return 0;
 479 }
 480
 481 static void l64781_release(struct dvb_frontend* fe)
 482 {
 483         struct l64781_state* state = fe->demodulator_priv;
 484         kfree(state);
 485 }
 486
 487 static const struct dvb_frontend_ops l64781_ops;
 488
 489 struct dvb_frontend* l64781_attach(const struct l64781_config* config,
 490                                    struct i2c_adapter* i2c)
 491 {
 492         struct l64781_state* state = NULL;
 493         int reg0x3e = -1;
 494         u8 b0 [] = { 0x1a };
 495         u8 b1 [] = { 0x00 };
 496         struct i2c_msg msg [] = { { .addr = config->demod_address, .flags = 0, .buf = b0, .len = 1 },
 497                            { .addr = config->demod_address, .flags = I2C_M_RD, .buf = b1, .len = 1 } };
 498
 499         /* allocate memory for the internal state */
 500         state = kzalloc(sizeof(struct l64781_state), GFP_KERNEL);
 501         if (state == NULL) goto error;
 502
 503         /* setup the state */
 504         state->config = config;
 505         state->i2c = i2c;
 506         state->first = 1;
 507
 508         /*
 509          *  the L64781 won't show up before we send the reset_and_configure()
 510          *  broadcast. If nothing responds there is no L64781 on the bus...
 511          */
 512         if (reset_and_configure(state) < 0) {
 513                 dprintk("No response to reset and configure broadcast...\n");
 514                 goto error;
 515         }
 516
 517         /* The chip always responds to reads */
 518         if (i2c_transfer(state->i2c, msg, 2) != 2) {
 519                 dprintk("No response to read on I2C bus\n");
 520                 goto error;
 521         }
 522
 523         /* Save current register contents for bailout */
 524         reg0x3e = l64781_readreg(state, 0x3e);
 525
 526         /* Reading the POWER_DOWN register always returns 0 */
 527         if (reg0x3e != 0) {
 528                 dprintk("Device doesn't look like L64781\n");
 529                 goto error;
 530         }
 531
 532         /* Turn the chip off */
 533         l64781_writereg (state, 0x3e, 0x5a);
 534
 535         /* Responds to all reads with 0 */
 536         if (l64781_readreg(state, 0x1a) != 0) {
 537                 dprintk("Read 1 returned unexpected value\n");
 538                 goto error;
 539         }
 540
 541         /* Turn the chip on */
 542         l64781_writereg (state, 0x3e, 0xa5);
 543
 544         /* Responds with register default value */
 545         if (l64781_readreg(state, 0x1a) != 0xa1) {
 546                 dprintk("Read 2 returned unexpected value\n");
 547                 goto error;
 548         }
 549
 550         /* create dvb_frontend */
 551         memcpy(&state->frontend.ops, &l64781_ops, sizeof(struct dvb_frontend_ops));
 552         state->frontend.demodulator_priv = state;
 553         return &state->frontend;
 554
 555 error:
 556         if (reg0x3e >= 0)
 557                 l64781_writereg (state, 0x3e, reg0x3e);  /* restore reg 0x3e */
 558         kfree(state);
 559         return NULL;
 560 }
 561
 562 static const struct dvb_frontend_ops l64781_ops = {
 563         .delsys = { SYS_DVBT },
 564         .info = {
 565                 .name = "LSI L64781 DVB-T",
 566         /*      .frequency_min_hz = ???,*/
 567         /*      .frequency_max_hz = ???,*/
 568                 .frequency_stepsize_hz = 166666,
 569         /*      .symbol_rate_tolerance = ???,*/
 570                 .caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
 571                       FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 |
 572                       FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 |
 573                       FE_CAN_MUTE_TS
 574         },
 575
 576         .release = l64781_release,
 577
 578         .init = l64781_init,
 579         .sleep = l64781_sleep,
 580
 581         .set_frontend = apply_frontend_param,
 582         .get_frontend = get_frontend,
 583         .get_tune_settings = l64781_get_tune_settings,
 584
 585         .read_status = l64781_read_status,
 586         .read_ber = l64781_read_ber,
 587         .read_signal_strength = l64781_read_signal_strength,
 588         .read_snr = l64781_read_snr,
 589         .read_ucblocks = l64781_read_ucblocks,
 590 };
 591
 592 MODULE_DESCRIPTION("LSI L64781 DVB-T Demodulator driver");
 593 MODULE_AUTHOR("Holger Waechtler, Marko Kohtala");
 594 MODULE_LICENSE("GPL");
 595
 596 EXPORT_SYMBOL(l64781_attach);