src/tuner_e4k.c

   1 /*
   2  * Elonics E4000 tuner driver
   3  *
   4  * (C) 2011-2012 by Harald Welte <laforge@gnumonks.org>
   5  * (C) 2012 by Sylvain Munaut <tnt@246tNt.com>
   6  * (C) 2012 by Hoernchen <la@tfc-server.de>
   7  *
   8  * All Rights Reserved
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  22  */
  23
  24 #include <limits.h>
  25 #include <stdint.h>
  26 #include <errno.h>
  27 #include <string.h>
  28 #include <stdio.h>
  29
  30 #include <reg_field.h>
  31 #include <tuner_e4k.h>
  32
  33 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
  34
  35 /* If this is defined, the limits are somewhat relaxed compared to what the
  36  * vendor claims is possible */
  37 #define OUT_OF_SPEC
  38
  39 #define MHZ(x)  ((x)*1000*1000)
  40 #define KHZ(x)  ((x)*1000)
  41
  42 uint32_t unsigned_delta(uint32_t a, uint32_t b)
  43 {
  44         if (a > b)
  45                 return a - b;
  46         else
  47                 return b - a;
  48 }
  49
  50 /* look-up table bit-width -> mask */
  51 static const uint8_t width2mask[] = {
  52         0, 1, 3, 7, 0xf, 0x1f, 0x3f, 0x7f, 0xff
  53 };
  54
  55 /***********************************************************************
  56  * Register Access */
  57
  58 #if 0
  59 /*! \brief Write a register of the tuner chip
  60  *  \param[in] e4k reference to the tuner
  61  *  \param[in] reg number of the register
  62  *  \param[in] val value to be written
  63  *  \returns 0 on success, negative in case of error
  64  */
  65 int e4k_reg_write(struct e4k_state *e4k, uint8_t reg, uint8_t val)
  66 {
  67         /* FIXME */
  68         return 0;
  69 }
  70
  71 /*! \brief Read a register of the tuner chip
  72  *  \param[in] e4k reference to the tuner
  73  *  \param[in] reg number of the register
  74  *  \returns positive 8bit register contents on success, negative in case of error
  75  */
  76 int e4k_reg_read(struct e4k_state *e4k, uint8_t reg)
  77 {
  78         /* FIXME */
  79         return 0;
  80 }
  81 #endif
  82
  83 /*! \brief Set or clear some (masked) bits inside a register
  84  *  \param[in] e4k reference to the tuner
  85  *  \param[in] reg number of the register
  86  *  \param[in] mask bit-mask of the value
  87  *  \param[in] val data value to be written to register
  88  *  \returns 0 on success, negative in case of error
  89  */
  90 static int e4k_reg_set_mask(struct e4k_state *e4k, uint8_t reg,
  91                      uint8_t mask, uint8_t val)
  92 {
  93         uint8_t tmp = e4k_reg_read(e4k, reg);
  94
  95         if ((tmp & mask) == val)
  96                 return 0;
  97
  98         return e4k_reg_write(e4k, reg, (tmp & ~mask) | (val & mask));
  99 }
 100
 101 /*! \brief Write a given field inside a register
 102  *  \param[in] e4k reference to the tuner
 103  *  \param[in] field structure describing the field
 104  *  \param[in] val value to be written
 105  *  \returns 0 on success, negative in case of error
 106  */
 107 static int e4k_field_write(struct e4k_state *e4k, const struct reg_field *field, uint8_t val)
 108 {
 109         int rc;
 110         uint8_t mask;
 111
 112         rc = e4k_reg_read(e4k, field->reg);
 113         if (rc < 0)
 114                 return rc;
 115
 116         mask = width2mask[field->width] << field->shift;
 117
 118         return e4k_reg_set_mask(e4k, field->reg, mask, val << field->shift);
 119 }
 120
 121 /*! \brief Read a given field inside a register
 122  *  \param[in] e4k reference to the tuner
 123  *  \param[in] field structure describing the field
 124  *  \returns positive value of the field, negative in case of error
 125  */
 126 static int e4k_field_read(struct e4k_state *e4k, const struct reg_field *field)
 127 {
 128         int rc;
 129
 130         rc = e4k_reg_read(e4k, field->reg);
 131         if (rc < 0)
 132                 return rc;
 133
 134         rc = (rc >> field->shift) & width2mask[field->width];
 135
 136         return rc;
 137 }
 138
 139 /***********************************************************************
 140  * Filter Control */
 141
 142 static const uint32_t rf_filt_center_uhf[] = {
 143         MHZ(360), MHZ(380), MHZ(405), MHZ(425),
 144         MHZ(450), MHZ(475), MHZ(505), MHZ(540),
 145         MHZ(575), MHZ(615), MHZ(670), MHZ(720),
 146         MHZ(760), MHZ(840), MHZ(890), MHZ(970)
 147 };
 148
 149 static const uint32_t rf_filt_center_l[] = {
 150         MHZ(1300), MHZ(1320), MHZ(1360), MHZ(1410),
 151         MHZ(1445), MHZ(1460), MHZ(1490), MHZ(1530),
 152         MHZ(1560), MHZ(1590), MHZ(1640), MHZ(1660),
 153         MHZ(1680), MHZ(1700), MHZ(1720), MHZ(1750)
 154 };
 155
 156 static int closest_arr_idx(const uint32_t *arr, unsigned int arr_size, uint32_t freq)
 157 {
 158         unsigned int i, bi = 0;
 159         uint32_t best_delta = 0xffffffff;
 160
 161         /* iterate over the array containing a list of the center
 162          * frequencies, selecting the closest one */
 163         for (i = 0; i < arr_size; i++) {
 164                 uint32_t delta = unsigned_delta(freq, arr[i]);
 165                 if (delta < best_delta) {
 166                         best_delta = delta;
 167                         bi = i;
 168                 }
 169         }
 170
 171         return bi;
 172 }
 173
 174 /* return 4-bit index as to which RF filter to select */
 175 static int choose_rf_filter(enum e4k_band band, uint32_t freq)
 176 {
 177         int rc;
 178
 179         switch (band) {
 180                 case E4K_BAND_VHF2:
 181                 case E4K_BAND_VHF3:
 182                         rc = 0;
 183                         break;
 184                 case E4K_BAND_UHF:
 185                         rc = closest_arr_idx(rf_filt_center_uhf,
 186                                                  ARRAY_SIZE(rf_filt_center_uhf),
 187                                                  freq);
 188                         break;
 189                 case E4K_BAND_L:
 190                         rc = closest_arr_idx(rf_filt_center_l,
 191                                                  ARRAY_SIZE(rf_filt_center_l),
 192                                                  freq);
 193                         break;
 194                 default:
 195                         rc = -EINVAL;
 196                         break;
 197         }
 198
 199         return rc;
 200 }
 201
 202 /* \brief Automatically select apropriate RF filter based on e4k state */
 203 int e4k_rf_filter_set(struct e4k_state *e4k)
 204 {
 205         int rc;
 206
 207         rc = choose_rf_filter(e4k->band, e4k->vco.flo);
 208         if (rc < 0)
 209                 return rc;
 210
 211         return e4k_reg_set_mask(e4k, E4K_REG_FILT1, 0xF, rc);
 212 }
 213
 214 /* Mixer Filter */
 215 static const uint32_t mix_filter_bw[] = {
 216         KHZ(27000), KHZ(27000), KHZ(27000), KHZ(27000),
 217         KHZ(27000), KHZ(27000), KHZ(27000), KHZ(27000),
 218         KHZ(4600), KHZ(4200), KHZ(3800), KHZ(3400),
 219         KHZ(3300), KHZ(2700), KHZ(2300), KHZ(1900)
 220 };
 221
 222 /* IF RC Filter */
 223 static const uint32_t ifrc_filter_bw[] = {
 224         KHZ(21400), KHZ(21000), KHZ(17600), KHZ(14700),
 225         KHZ(12400), KHZ(10600), KHZ(9000), KHZ(7700),
 226         KHZ(6400), KHZ(5300), KHZ(4400), KHZ(3400),
 227         KHZ(2600), KHZ(1800), KHZ(1200), KHZ(1000)
 228 };
 229
 230 /* IF Channel Filter */
 231 static const uint32_t ifch_filter_bw[] = {
 232         KHZ(5500), KHZ(5300), KHZ(5000), KHZ(4800),
 233         KHZ(4600), KHZ(4400), KHZ(4300), KHZ(4100),
 234         KHZ(3900), KHZ(3800), KHZ(3700), KHZ(3600),
 235         KHZ(3400), KHZ(3300), KHZ(3200), KHZ(3100),
 236         KHZ(3000), KHZ(2950), KHZ(2900), KHZ(2800),
 237         KHZ(2750), KHZ(2700), KHZ(2600), KHZ(2550),
 238         KHZ(2500), KHZ(2450), KHZ(2400), KHZ(2300),
 239         KHZ(2280), KHZ(2240), KHZ(2200), KHZ(2150)
 240 };
 241
 242 static const uint32_t *if_filter_bw[] = {
 243         mix_filter_bw,
 244         ifch_filter_bw,
 245         ifrc_filter_bw,
 246 };
 247
 248 static const uint32_t if_filter_bw_len[] = {
 249         ARRAY_SIZE(mix_filter_bw),
 250         ARRAY_SIZE(ifch_filter_bw),
 251         ARRAY_SIZE(ifrc_filter_bw),
 252 };
 253
 254 static const struct reg_field if_filter_fields[] = {
 255         {
 256                 E4K_REG_FILT2, 4, 4,
 257         },
 258         {
 259                 E4K_REG_FILT3, 0, 5,
 260         },
 261         {
 262                 E4K_REG_FILT2, 0, 4,
 263         }
 264 };
 265
 266 static int find_if_bw(enum e4k_if_filter filter, uint32_t bw)
 267 {
 268         if (filter >= ARRAY_SIZE(if_filter_bw))
 269                 return -EINVAL;
 270
 271         return closest_arr_idx(if_filter_bw[filter],
 272                                if_filter_bw_len[filter], bw);
 273 }
 274
 275 /*! \brief Set the filter band-width of any of the IF filters
 276  *  \param[in] e4k reference to the tuner chip
 277  *  \param[in] filter filter to be configured
 278  *  \param[in] bandwidth bandwidth to be configured
 279  *  \returns positive actual filter band-width, negative in case of error
 280  */
 281 int e4k_if_filter_bw_set(struct e4k_state *e4k, enum e4k_if_filter filter,
 282                          uint32_t bandwidth)
 283 {
 284         int bw_idx;
 285         const struct reg_field *field;
 286
 287         if (filter >= ARRAY_SIZE(if_filter_bw))
 288                 return -EINVAL;
 289
 290         bw_idx = find_if_bw(filter, bandwidth);
 291
 292         field = &if_filter_fields[filter];
 293
 294         return e4k_field_write(e4k, field, bw_idx);
 295 }
 296
 297 /*! \brief Enables / Disables the channel filter
 298  *  \param[in] e4k reference to the tuner chip
 299  *  \param[in] on 1=filter enabled, 0=filter disabled
 300  *  \returns 0 success, negative errors
 301  */
 302 int e4k_if_filter_chan_enable(struct e4k_state *e4k, int on)
 303 {
 304         return e4k_reg_set_mask(e4k, E4K_REG_FILT3, E4K_FILT3_DISABLE,
 305                                 on ? 0 : E4K_FILT3_DISABLE);
 306 }
 307
 308 int e4k_if_filter_bw_get(struct e4k_state *e4k, enum e4k_if_filter filter)
 309 {
 310         const uint32_t *arr;
 311         int rc;
 312         const struct reg_field *field;
 313
 314         if (filter >= ARRAY_SIZE(if_filter_bw))
 315                 return -EINVAL;
 316
 317         field = &if_filter_fields[filter];
 318
 319         rc = e4k_field_read(e4k, field);
 320         if (rc < 0)
 321                 return rc;
 322
 323         arr = if_filter_bw[filter];
 324
 325         return arr[rc];
 326 }
 327
 328
 329 /***********************************************************************
 330  * Frequency Control */
 331
 332 #define E4K_FVCO_MIN_KHZ        2600000 /* 2.6 GHz */
 333 #define E4K_FVCO_MAX_KHZ        3900000 /* 3.9 GHz */
 334 #define E4K_PLL_Y               65536
 335
 336 #ifdef OUT_OF_SPEC
 337 #define E4K_FLO_MIN_MHZ         50
 338 #define E4K_FLO_MAX_MHZ         2200UL
 339 #else
 340 #define E4K_FLO_MIN_MHZ         64
 341 #define E4K_FLO_MAX_MHZ         1700
 342 #endif
 343
 344 struct pll_settings {
 345         uint32_t freq;
 346         uint8_t reg_synth7;
 347         uint8_t mult;
 348 };
 349
 350 static const struct pll_settings pll_vars[] = {
 351         {KHZ(72400),    (1 << 3) | 7,   48},
 352         {KHZ(81200),    (1 << 3) | 6,   40},
 353         {KHZ(108300),   (1 << 3) | 5,   32},
 354         {KHZ(162500),   (1 << 3) | 4,   24},
 355         {KHZ(216600),   (1 << 3) | 3,   16},
 356         {KHZ(325000),   (1 << 3) | 2,   12},
 357         {KHZ(350000),   (1 << 3) | 1,   8},
 358         {KHZ(432000),   (0 << 3) | 3,   8},
 359         {KHZ(667000),   (0 << 3) | 2,   6},
 360         {KHZ(1200000),  (0 << 3) | 1,   4}
 361 };
 362
 363 static int is_fvco_valid(uint32_t fvco_z)
 364 {
 365         /* check if the resulting fosc is valid */
 366         if (fvco_z/1000 < E4K_FVCO_MIN_KHZ ||
 367             fvco_z/1000 > E4K_FVCO_MAX_KHZ) {
 368                 fprintf(stderr, "[E4K] Fvco %u invalid\n", fvco_z);
 369                 return 0;
 370         }
 371
 372         return 1;
 373 }
 374
 375 static int is_fosc_valid(uint32_t fosc)
 376 {
 377         if (fosc < MHZ(16) || fosc > MHZ(30)) {
 378                 fprintf(stderr, "[E4K] Fosc %u invalid\n", fosc);
 379                 return 0;
 380         }
 381
 382         return 1;
 383 }
 384
 385 static int is_z_valid(uint32_t z)
 386 {
 387         if (z > 255) {
 388                 fprintf(stderr, "[E4K] Z %u invalid\n", z);
 389                 return 0;
 390         }
 391
 392         return 1;
 393 }
 394
 395 /*! \brief Determine if 3-phase mixing shall be used or not */
 396 static int use_3ph_mixing(uint32_t flo)
 397 {
 398         /* this is a magic number somewhre between VHF and UHF */
 399         if (flo < MHZ(350))
 400                 return 1;
 401
 402         return 0;
 403 }
 404
 405 /* \brief compute Fvco based on Fosc, Z and X
 406  * \returns positive value (Fvco in Hz), 0 in case of error */
 407 static uint64_t compute_fvco(uint32_t f_osc, uint8_t z, uint16_t x)
 408 {
 409         uint64_t fvco_z, fvco_x, fvco;
 410
 411         /* We use the following transformation in order to
 412          * handle the fractional part with integer arithmetic:
 413          *  Fvco = Fosc * (Z + X/Y) <=> Fvco = Fosc * Z + (Fosc * X)/Y
 414          * This avoids X/Y = 0.  However, then we would overflow a 32bit
 415          * integer, as we cannot hold e.g. 26 MHz * 65536 either.
 416          */
 417         fvco_z = (uint64_t)f_osc * z;
 418
 419 #if 0
 420         if (!is_fvco_valid(fvco_z))
 421                 return 0;
 422 #endif
 423
 424         fvco_x = ((uint64_t)f_osc * x) / E4K_PLL_Y;
 425
 426         fvco = fvco_z + fvco_x;
 427
 428         return fvco;
 429 }
 430
 431 static uint32_t compute_flo(uint32_t f_osc, uint8_t z, uint16_t x, uint8_t r)
 432 {
 433         uint64_t fvco = compute_fvco(f_osc, z, x);
 434         if (fvco == 0)
 435                 return -EINVAL;
 436
 437         return fvco / r;
 438 }
 439
 440 static int e4k_band_set(struct e4k_state *e4k, enum e4k_band band)
 441 {
 442         int rc;
 443
 444         switch (band) {
 445         case E4K_BAND_VHF2:
 446         case E4K_BAND_VHF3:
 447         case E4K_BAND_UHF:
 448                 e4k_reg_write(e4k, E4K_REG_BIAS, 3);
 449                 break;
 450         case E4K_BAND_L:
 451                 e4k_reg_write(e4k, E4K_REG_BIAS, 0);
 452                 break;
 453         }
 454
 455         /* workaround: if we don't reset this register before writing to it,
 456          * we get a gap between 325-350 MHz */
 457         rc = e4k_reg_set_mask(e4k, E4K_REG_SYNTH1, 0x06, 0);
 458         rc = e4k_reg_set_mask(e4k, E4K_REG_SYNTH1, 0x06, band << 1);
 459         if (rc >= 0)
 460                 e4k->band = band;
 461
 462         return rc;
 463 }
 464
 465 /*! \brief Compute PLL parameters for givent target frequency
 466  *  \param[out] oscp Oscillator parameters, if computation successful
 467  *  \param[in] fosc Clock input frequency applied to the chip (Hz)
 468  *  \param[in] intended_flo target tuning frequency (Hz)
 469  *  \returns actual PLL frequency, as close as possible to intended_flo,
 470  *           0 in case of error
 471  */
 472 uint32_t e4k_compute_pll_params(struct e4k_pll_params *oscp, uint32_t fosc, uint32_t intended_flo)
 473 {
 474         uint32_t i;
 475         uint8_t r = 2;
 476         uint64_t intended_fvco, remainder;
 477         uint64_t z = 0;
 478         uint32_t x;
 479         int flo;
 480         int three_phase_mixing = 0;
 481         oscp->r_idx = 0;
 482
 483         if (!is_fosc_valid(fosc))
 484                 return 0;
 485
 486         for(i = 0; i < ARRAY_SIZE(pll_vars); ++i) {
 487                 if(intended_flo < pll_vars[i].freq) {
 488                         three_phase_mixing = (pll_vars[i].reg_synth7 & 0x08) ? 1 : 0;
 489                         oscp->r_idx = pll_vars[i].reg_synth7;
 490                         r = pll_vars[i].mult;
 491                         break;
 492                 }
 493         }
 494
 495         //fprintf(stderr, "[E4K] Fint=%u, R=%u\n", intended_flo, r);
 496
 497         /* flo(max) = 1700MHz, R(max) = 48, we need 64bit! */
 498         intended_fvco = (uint64_t)intended_flo * r;
 499
 500         /* compute integral component of multiplier */
 501         z = intended_fvco / fosc;
 502
 503         /* compute fractional part.  this will not overflow,
 504         * as fosc(max) = 30MHz and z(max) = 255 */
 505         remainder = intended_fvco - (fosc * z);
 506         /* remainder(max) = 30MHz, E4K_PLL_Y = 65536 -> 64bit! */
 507         x = (remainder * E4K_PLL_Y) / fosc;
 508         /* x(max) as result of this computation is 65536 */
 509
 510         flo = compute_flo(fosc, z, x, r);
 511
 512         oscp->fosc = fosc;
 513         oscp->flo = flo;
 514         oscp->intended_flo = intended_flo;
 515         oscp->r = r;
 516 //      oscp->r_idx = pll_vars[i].reg_synth7 & 0x0;
 517         oscp->threephase = three_phase_mixing;
 518         oscp->x = x;
 519         oscp->z = z;
 520
 521         return flo;
 522 }
 523
 524 int e4k_tune_params(struct e4k_state *e4k, struct e4k_pll_params *p)
 525 {
 526         uint8_t val;
 527
 528         /* program R + 3phase/2phase */
 529         e4k_reg_write(e4k, E4K_REG_SYNTH7, p->r_idx);
 530         /* program Z */
 531         e4k_reg_write(e4k, E4K_REG_SYNTH3, p->z);
 532         /* program X */
 533         e4k_reg_write(e4k, E4K_REG_SYNTH4, p->x & 0xff);
 534         e4k_reg_write(e4k, E4K_REG_SYNTH5, p->x >> 8);
 535
 536         /* we're in auto calibration mode, so there's no need to trigger it */
 537
 538         memcpy(&e4k->vco, p, sizeof(e4k->vco));
 539
 540         /* set the band */
 541         if (e4k->vco.flo < MHZ(140))
 542                 e4k_band_set(e4k, E4K_BAND_VHF2);
 543         else if (e4k->vco.flo < MHZ(350))
 544                 e4k_band_set(e4k, E4K_BAND_VHF3);
 545         else if (e4k->vco.flo < MHZ(1135))
 546                 e4k_band_set(e4k, E4K_BAND_UHF);
 547         else
 548                 e4k_band_set(e4k, E4K_BAND_L);
 549
 550         /* select and set proper RF filter */
 551         e4k_rf_filter_set(e4k);
 552
 553         return e4k->vco.flo;
 554 }
 555
 556 /*! \brief High-level tuning API, just specify frquency
 557  *
 558  *  This function will compute matching PLL parameters, program them into the
 559  *  hardware and set the band as well as RF filter.
 560  *
 561  *  \param[in] e4k reference to tuner
 562  *  \param[in] freq frequency in Hz
 563  *  \returns actual tuned frequency, negative in case of error
 564  */
 565 int e4k_tune_freq(struct e4k_state *e4k, uint32_t freq)
 566 {
 567         uint32_t rc;
 568         struct e4k_pll_params p;
 569
 570         /* determine PLL parameters */
 571         rc = e4k_compute_pll_params(&p, e4k->vco.fosc, freq);
 572         if (!rc)
 573                 return -EINVAL;
 574
 575         /* actually tune to those parameters */
 576         rc = e4k_tune_params(e4k, &p);
 577
 578         /* check PLL lock */
 579         rc = e4k_reg_read(e4k, E4K_REG_SYNTH1);
 580         if (!(rc & 0x01)) {
 581                 fprintf(stderr, "[E4K] PLL not locked for %u Hz!\n", freq);
 582                 return -1;
 583         }
 584
 585         return 0;
 586 }
 587
 588 /***********************************************************************
 589  * Gain Control */
 590
 591 static const int8_t if_stage1_gain[] = {
 592         -3, 6
 593 };
 594
 595 static const int8_t if_stage23_gain[] = {
 596         0, 3, 6, 9
 597 };
 598
 599 static const int8_t if_stage4_gain[] = {
 600         0, 1, 2, 2
 601 };
 602
 603 static const int8_t if_stage56_gain[] = {
 604         3, 6, 9, 12, 15, 15, 15, 15
 605 };
 606
 607 static const int8_t *if_stage_gain[] = {
 608         0,
 609         if_stage1_gain,
 610         if_stage23_gain,
 611         if_stage23_gain,
 612         if_stage4_gain,
 613         if_stage56_gain,
 614         if_stage56_gain
 615 };
 616
 617 static const uint8_t if_stage_gain_len[] = {
 618         0,
 619         ARRAY_SIZE(if_stage1_gain),
 620         ARRAY_SIZE(if_stage23_gain),
 621         ARRAY_SIZE(if_stage23_gain),
 622         ARRAY_SIZE(if_stage4_gain),
 623         ARRAY_SIZE(if_stage56_gain),
 624         ARRAY_SIZE(if_stage56_gain)
 625 };
 626
 627 static const struct reg_field if_stage_gain_regs[] = {
 628         { 0, 0, 0 },
 629         { E4K_REG_GAIN3, 0, 1 },
 630         { E4K_REG_GAIN3, 1, 2 },
 631         { E4K_REG_GAIN3, 3, 2 },
 632         { E4K_REG_GAIN3, 5, 2 },
 633         { E4K_REG_GAIN4, 0, 3 },
 634         { E4K_REG_GAIN4, 3, 3 }
 635 };
 636
 637 static const int32_t lnagain[] = {
 638         -50,    0,
 639         -25,    1,
 640         0,      4,
 641         25,     5,
 642         50,     6,
 643         75,     7,
 644         100,    8,
 645         125,    9,
 646         150,    10,
 647         175,    11,
 648         200,    12,
 649         250,    13,
 650         300,    14,
 651 };
 652
 653 static const int32_t enhgain[] = {
 654         10, 30, 50, 70
 655 };
 656
 657 int e4k_set_lna_gain(struct e4k_state *e4k, int32_t gain)
 658 {
 659         uint32_t i;
 660         for(i = 0; i < ARRAY_SIZE(lnagain)/2; ++i) {
 661                 if(lnagain[i*2] == gain) {
 662                         e4k_reg_set_mask(e4k, E4K_REG_GAIN1, 0xf, lnagain[i*2+1]);
 663                         return gain;
 664                 }
 665         }
 666         return -EINVAL;
 667 }
 668
 669 int e4k_set_enh_gain(struct e4k_state *e4k, int32_t gain)
 670 {
 671         uint32_t i;
 672         for(i = 0; i < ARRAY_SIZE(enhgain); ++i) {
 673                 if(enhgain[i] == gain) {
 674                         e4k_reg_set_mask(e4k, E4K_REG_AGC11, 0x7, E4K_AGC11_LNA_GAIN_ENH | (i << 1));
 675                         return gain;
 676                 }
 677         }
 678         e4k_reg_set_mask(e4k, E4K_REG_AGC11, 0x7, 0);
 679
 680         /* special case: 0 = off*/
 681         if(0 == gain)
 682                 return 0;
 683         else
 684                 return -EINVAL;
 685 }
 686
 687 int e4k_enable_manual_gain(struct e4k_state *e4k, uint8_t manual)
 688 {
 689         if (manual) {
 690                 /* Set LNA mode to manual */
 691                 e4k_reg_set_mask(e4k, E4K_REG_AGC1, E4K_AGC1_MOD_MASK, E4K_AGC_MOD_SERIAL);
 692
 693                 /* Set Mixer Gain Control to manual */
 694                 e4k_reg_set_mask(e4k, E4K_REG_AGC7, E4K_AGC7_MIX_GAIN_AUTO, 0);
 695         } else {
 696                 /* Set LNA mode to auto */
 697                 e4k_reg_set_mask(e4k, E4K_REG_AGC1, E4K_AGC1_MOD_MASK, E4K_AGC_MOD_IF_SERIAL_LNA_AUTON);
 698                 /* Set Mixer Gain Control to auto */
 699                 e4k_reg_set_mask(e4k, E4K_REG_AGC7, E4K_AGC7_MIX_GAIN_AUTO, 1);
 700
 701                 e4k_reg_set_mask(e4k, E4K_REG_AGC11, 0x7, 0);
 702         }
 703
 704         return 0;
 705 }
 706
 707 static int find_stage_gain(uint8_t stage, int8_t val)
 708 {
 709         const int8_t *arr;
 710         int i;
 711
 712         if (stage >= ARRAY_SIZE(if_stage_gain))
 713                 return -EINVAL;
 714
 715         arr = if_stage_gain[stage];
 716
 717         for (i = 0; i < if_stage_gain_len[stage]; i++) {
 718                 if (arr[i] == val)
 719                         return i;
 720         }
 721         return -EINVAL;
 722 }
 723
 724 /*! \brief Set the gain of one of the IF gain stages
 725  *  \param [e4k] handle to the tuner chip
 726  *  \param [stage] number of the stage (1..6)
 727  *  \param [value] gain value in dB
 728  *  \returns 0 on success, negative in case of error
 729  */
 730 int e4k_if_gain_set(struct e4k_state *e4k, uint8_t stage, int8_t value)
 731 {
 732         int rc;
 733         uint8_t mask;
 734         const struct reg_field *field;
 735
 736         rc = find_stage_gain(stage, value);
 737         if (rc < 0)
 738                 return rc;
 739
 740         /* compute the bit-mask for the given gain field */
 741         field = &if_stage_gain_regs[stage];
 742         mask = width2mask[field->width] << field->shift;
 743
 744         return e4k_reg_set_mask(e4k, field->reg, mask, rc << field->shift);
 745 }
 746
 747 int e4k_mixer_gain_set(struct e4k_state *e4k, int8_t value)
 748 {
 749         uint8_t bit;
 750
 751         switch (value) {
 752         case 4:
 753                 bit = 0;
 754                 break;
 755         case 12:
 756                 bit = 1;
 757                 break;
 758         default:
 759                 return -EINVAL;
 760         }
 761
 762         return e4k_reg_set_mask(e4k, E4K_REG_GAIN2, 1, bit);
 763 }
 764
 765 int e4k_commonmode_set(struct e4k_state *e4k, int8_t value)
 766 {
 767         if(value < 0)
 768                 return -EINVAL;
 769         else if(value > 7)
 770                 return -EINVAL;
 771
 772         return e4k_reg_set_mask(e4k, E4K_REG_DC7, 7, value);
 773 }
 774
 775 /***********************************************************************
 776  * DC Offset */
 777
 778 int e4k_manual_dc_offset(struct e4k_state *e4k, int8_t iofs, int8_t irange, int8_t qofs, int8_t qrange)
 779 {
 780         int res;
 781
 782         if((iofs < 0x00) || (iofs > 0x3f))
 783                 return -EINVAL;
 784         if((irange < 0x00) || (irange > 0x03))
 785                 return -EINVAL;
 786         if((qofs < 0x00) || (qofs > 0x3f))
 787                 return -EINVAL;
 788         if((qrange < 0x00) || (qrange > 0x03))
 789                 return -EINVAL;
 790
 791         res = e4k_reg_set_mask(e4k, E4K_REG_DC2, 0x3f, iofs);
 792         if(res < 0)
 793                 return res;
 794
 795         res = e4k_reg_set_mask(e4k, E4K_REG_DC3, 0x3f, qofs);
 796         if(res < 0)
 797                 return res;
 798
 799         res = e4k_reg_set_mask(e4k, E4K_REG_DC4, 0x33, (qrange << 4) | irange);
 800         return res;
 801 }
 802
 803 /*! \brief Perform a DC offset calibration right now
 804  *  \param [e4k] handle to the tuner chip
 805  */
 806 int e4k_dc_offset_calibrate(struct e4k_state *e4k)
 807 {
 808         /* make sure the DC range detector is enabled */
 809         e4k_reg_set_mask(e4k, E4K_REG_DC5, E4K_DC5_RANGE_DET_EN, E4K_DC5_RANGE_DET_EN);
 810
 811         return e4k_reg_write(e4k, E4K_REG_DC1, 0x01);
 812 }
 813
 814
 815 static const int8_t if_gains_max[] = {
 816         0, 6, 9, 9, 2, 15, 15
 817 };
 818
 819 struct gain_comb {
 820         int8_t mixer_gain;
 821         int8_t if1_gain;
 822         uint8_t reg;
 823 };
 824
 825 static const struct gain_comb dc_gain_comb[] = {
 826         { 4,  -3, 0x50 },
 827         { 4,   6, 0x51 },
 828         { 12, -3, 0x52 },
 829         { 12,  6, 0x53 },
 830 };
 831
 832 #define TO_LUT(offset, range)   (offset | (range << 6))
 833
 834 int e4k_dc_offset_gen_table(struct e4k_state *e4k)
 835 {
 836         uint32_t i;
 837
 838         /* FIXME: read ont current gain values and write them back
 839          * before returning to the caller */
 840
 841         /* disable auto mixer gain */
 842         e4k_reg_set_mask(e4k, E4K_REG_AGC7, E4K_AGC7_MIX_GAIN_AUTO, 0);
 843
 844         /* set LNA/IF gain to full manual */
 845         e4k_reg_set_mask(e4k, E4K_REG_AGC1, E4K_AGC1_MOD_MASK,
 846                          E4K_AGC_MOD_SERIAL);
 847
 848         /* set all 'other' gains to maximum */
 849         for (i = 2; i <= 6; i++)
 850                 e4k_if_gain_set(e4k, i, if_gains_max[i]);
 851
 852         /* iterate over all mixer + if_stage_1 gain combinations */
 853         for (i = 0; i < ARRAY_SIZE(dc_gain_comb); i++) {
 854                 uint8_t offs_i, offs_q, range, range_i, range_q;
 855
 856                 /* set the combination of mixer / if1 gain */
 857                 e4k_mixer_gain_set(e4k, dc_gain_comb[i].mixer_gain);
 858                 e4k_if_gain_set(e4k, 1, dc_gain_comb[i].if1_gain);
 859
 860                 /* perform actual calibration */
 861                 e4k_dc_offset_calibrate(e4k);
 862
 863                 /* extract I/Q offset and range values */
 864                 offs_i = e4k_reg_read(e4k, E4K_REG_DC2) & 0x3f;
 865                 offs_q = e4k_reg_read(e4k, E4K_REG_DC3) & 0x3f;
 866                 range  = e4k_reg_read(e4k, E4K_REG_DC4);
 867                 range_i = range & 0x3;
 868                 range_q = (range >> 4) & 0x3;
 869
 870                 fprintf(stderr, "[E4K] Table %u I=%u/%u, Q=%u/%u\n",
 871                         i, range_i, offs_i, range_q, offs_q);
 872
 873                 /* write into the table */
 874                 e4k_reg_write(e4k, dc_gain_comb[i].reg,
 875                               TO_LUT(offs_q, range_q));
 876                 e4k_reg_write(e4k, dc_gain_comb[i].reg + 0x10,
 877                               TO_LUT(offs_i, range_i));
 878         }
 879
 880         return 0;
 881 }
 882
 883 /***********************************************************************
 884  * Initialization */
 885
 886 static int magic_init(struct e4k_state *e4k)
 887 {
 888         e4k_reg_write(e4k, 0x7e, 0x01);
 889         e4k_reg_write(e4k, 0x7f, 0xfe);
 890         e4k_reg_write(e4k, 0x82, 0x00);
 891         e4k_reg_write(e4k, 0x86, 0x50); /* polarity A */
 892         e4k_reg_write(e4k, 0x87, 0x20);
 893         e4k_reg_write(e4k, 0x88, 0x01);
 894         e4k_reg_write(e4k, 0x9f, 0x7f);
 895         e4k_reg_write(e4k, 0xa0, 0x07);
 896
 897         return 0;
 898 }
 899
 900 /*! \brief Initialize the E4K tuner
 901  */
 902 int e4k_init(struct e4k_state *e4k)
 903 {
 904         /* make a dummy i2c read or write command, will not be ACKed! */
 905         e4k_reg_read(e4k, 0);
 906
 907         /* Make sure we reset everything and clear POR indicator */
 908         e4k_reg_write(e4k, E4K_REG_MASTER1,
 909                 E4K_MASTER1_RESET |
 910                 E4K_MASTER1_NORM_STBY |
 911                 E4K_MASTER1_POR_DET
 912         );
 913
 914         /* Configure clock input */
 915         e4k_reg_write(e4k, E4K_REG_CLK_INP, 0x00);
 916
 917         /* Disable clock output */
 918         e4k_reg_write(e4k, E4K_REG_REF_CLK, 0x00);
 919         e4k_reg_write(e4k, E4K_REG_CLKOUT_PWDN, 0x96);
 920
 921         /* Write some magic values into registers */
 922         magic_init(e4k);
 923 #if 0
 924         /* Set common mode voltage a bit higher for more margin 850 mv */
 925         e4k_commonmode_set(e4k, 4);
 926
 927         /* Initialize DC offset lookup tables */
 928         e4k_dc_offset_gen_table(e4k);
 929
 930         /* Enable time variant DC correction */
 931         e4k_reg_write(e4k, E4K_REG_DCTIME1, 0x01);
 932         e4k_reg_write(e4k, E4K_REG_DCTIME2, 0x01);
 933 #endif
 934
 935         /* Set LNA mode to manual */
 936         e4k_reg_write(e4k, E4K_REG_AGC4, 0x10); /* High threshold */
 937         e4k_reg_write(e4k, E4K_REG_AGC5, 0x04); /* Low threshold */
 938         e4k_reg_write(e4k, E4K_REG_AGC6, 0x1a); /* LNA calib + loop rate */
 939
 940         e4k_reg_set_mask(e4k, E4K_REG_AGC1, E4K_AGC1_MOD_MASK,
 941                 E4K_AGC_MOD_SERIAL);
 942
 943         /* Set Mixer Gain Control to manual */
 944         e4k_reg_set_mask(e4k, E4K_REG_AGC7, E4K_AGC7_MIX_GAIN_AUTO, 0);
 945
 946 #if 0
 947         /* Enable LNA Gain enhancement */
 948         e4k_reg_set_mask(e4k, E4K_REG_AGC11, 0x7,
 949                          E4K_AGC11_LNA_GAIN_ENH | (2 << 1));
 950
 951         /* Enable automatic IF gain mode switching */
 952         e4k_reg_set_mask(e4k, E4K_REG_AGC8, 0x1, E4K_AGC8_SENS_LIN_AUTO);
 953 #endif
 954
 955         /* Use auto-gain as default */
 956         e4k_enable_manual_gain(e4k, 0);
 957
 958         /* Select moderate gain levels */
 959         e4k_if_gain_set(e4k, 1, 6);
 960         e4k_if_gain_set(e4k, 2, 0);
 961         e4k_if_gain_set(e4k, 3, 0);
 962         e4k_if_gain_set(e4k, 4, 0);
 963         e4k_if_gain_set(e4k, 5, 9);
 964         e4k_if_gain_set(e4k, 6, 9);
 965
 966         /* Set the most narrow filter we can possibly use */
 967         e4k_if_filter_bw_set(e4k, E4K_IF_FILTER_MIX, KHZ(1900));
 968         e4k_if_filter_bw_set(e4k, E4K_IF_FILTER_RC, KHZ(1000));
 969         e4k_if_filter_bw_set(e4k, E4K_IF_FILTER_CHAN, KHZ(2150));
 970         e4k_if_filter_chan_enable(e4k, 1);
 971
 972         /* Disable time variant DC correction and LUT */
 973         e4k_reg_set_mask(e4k, E4K_REG_DC5, 0x03, 0);
 974         e4k_reg_set_mask(e4k, E4K_REG_DCTIME1, 0x03, 0);
 975         e4k_reg_set_mask(e4k, E4K_REG_DCTIME2, 0x03, 0);
 976
 977         return 0;
 978 }