drivers/media/dvb-frontends/dib3000mc.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Driver for DiBcom DiB3000MC/P-demodulator.
   4  *
   5  * Copyright (C) 2004-7 DiBcom (http://www.dibcom.fr/)
   6  * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@posteo.de)
   7  *
   8  * This code is partially based on the previous dib3000mc.c .
   9  */
  10
  11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  12
  13 #include <linux/kernel.h>
  14 #include <linux/slab.h>
  15 #include <linux/i2c.h>
  16
  17 #include <media/dvb_frontend.h>
  18
  19 #include "dib3000mc.h"
  20
  21 static int debug;
  22 module_param(debug, int, 0644);
  23 MODULE_PARM_DESC(debug, "turn on debugging (default: 0)");
  24
  25 static int buggy_sfn_workaround;
  26 module_param(buggy_sfn_workaround, int, 0644);
  27 MODULE_PARM_DESC(buggy_sfn_workaround, "Enable work-around for buggy SFNs (default: 0)");
  28
  29 #define dprintk(fmt, arg...) do {                                       \
  30         if (debug)                                                      \
  31                 printk(KERN_DEBUG pr_fmt("%s: " fmt),                   \
  32                        __func__, ##arg);                                \
  33 } while (0)
  34
  35 struct dib3000mc_state {
  36         struct dvb_frontend demod;
  37         struct dib3000mc_config *cfg;
  38
  39         u8 i2c_addr;
  40         struct i2c_adapter *i2c_adap;
  41
  42         struct dibx000_i2c_master i2c_master;
  43
  44         u32 timf;
  45
  46         u32 current_bandwidth;
  47
  48         u16 dev_id;
  49
  50         u8 sfn_workaround_active :1;
  51 };
  52
  53 static u16 dib3000mc_read_word(struct dib3000mc_state *state, u16 reg)
  54 {
  55         struct i2c_msg msg[2] = {
  56                 { .addr = state->i2c_addr >> 1, .flags = 0,        .len = 2 },
  57                 { .addr = state->i2c_addr >> 1, .flags = I2C_M_RD, .len = 2 },
  58         };
  59         u16 word;
  60         u8 *b;
  61
  62         b = kmalloc(4, GFP_KERNEL);
  63         if (!b)
  64                 return 0;
  65
  66         b[0] = (reg >> 8) | 0x80;
  67         b[1] = reg;
  68         b[2] = 0;
  69         b[3] = 0;
  70
  71         msg[0].buf = b;
  72         msg[1].buf = b + 2;
  73
  74         if (i2c_transfer(state->i2c_adap, msg, 2) != 2)
  75                 dprintk("i2c read error on %d\n",reg);
  76
  77         word = (b[2] << 8) | b[3];
  78         kfree(b);
  79
  80         return word;
  81 }
  82
  83 static int dib3000mc_write_word(struct dib3000mc_state *state, u16 reg, u16 val)
  84 {
  85         struct i2c_msg msg = {
  86                 .addr = state->i2c_addr >> 1, .flags = 0, .len = 4
  87         };
  88         int rc;
  89         u8 *b;
  90
  91         b = kmalloc(4, GFP_KERNEL);
  92         if (!b)
  93                 return -ENOMEM;
  94
  95         b[0] = reg >> 8;
  96         b[1] = reg;
  97         b[2] = val >> 8;
  98         b[3] = val;
  99
 100         msg.buf = b;
 101
 102         rc = i2c_transfer(state->i2c_adap, &msg, 1) != 1 ? -EREMOTEIO : 0;
 103         kfree(b);
 104
 105         return rc;
 106 }
 107
 108 static int dib3000mc_identify(struct dib3000mc_state *state)
 109 {
 110         u16 value;
 111         if ((value = dib3000mc_read_word(state, 1025)) != 0x01b3) {
 112                 dprintk("-E-  DiB3000MC/P: wrong Vendor ID (read=0x%x)\n",value);
 113                 return -EREMOTEIO;
 114         }
 115
 116         value = dib3000mc_read_word(state, 1026);
 117         if (value != 0x3001 && value != 0x3002) {
 118                 dprintk("-E-  DiB3000MC/P: wrong Device ID (%x)\n",value);
 119                 return -EREMOTEIO;
 120         }
 121         state->dev_id = value;
 122
 123         dprintk("-I-  found DiB3000MC/P: %x\n",state->dev_id);
 124
 125         return 0;
 126 }
 127
 128 static int dib3000mc_set_timing(struct dib3000mc_state *state, s16 nfft, u32 bw, u8 update_offset)
 129 {
 130         u32 timf;
 131
 132         if (state->timf == 0) {
 133                 timf = 1384402; // default value for 8MHz
 134                 if (update_offset)
 135                         msleep(200); // first time we do an update
 136         } else
 137                 timf = state->timf;
 138
 139         timf *= (bw / 1000);
 140
 141         if (update_offset) {
 142                 s16 tim_offs = dib3000mc_read_word(state, 416);
 143
 144                 if (tim_offs &  0x2000)
 145                         tim_offs -= 0x4000;
 146
 147                 if (nfft == TRANSMISSION_MODE_2K)
 148                         tim_offs *= 4;
 149
 150                 timf += tim_offs;
 151                 state->timf = timf / (bw / 1000);
 152         }
 153
 154         dprintk("timf: %d\n", timf);
 155
 156         dib3000mc_write_word(state, 23, (u16) (timf >> 16));
 157         dib3000mc_write_word(state, 24, (u16) (timf      ) & 0xffff);
 158
 159         return 0;
 160 }
 161
 162 static int dib3000mc_setup_pwm_state(struct dib3000mc_state *state)
 163 {
 164         u16 reg_51, reg_52 = state->cfg->agc->setup & 0xfefb;
 165         if (state->cfg->pwm3_inversion) {
 166                 reg_51 =  (2 << 14) | (0 << 10) | (7 << 6) | (2 << 2) | (2 << 0);
 167                 reg_52 |= (1 << 2);
 168         } else {
 169                 reg_51 = (2 << 14) | (4 << 10) | (7 << 6) | (2 << 2) | (2 << 0);
 170                 reg_52 |= (1 << 8);
 171         }
 172         dib3000mc_write_word(state, 51, reg_51);
 173         dib3000mc_write_word(state, 52, reg_52);
 174
 175         if (state->cfg->use_pwm3)
 176                 dib3000mc_write_word(state, 245, (1 << 3) | (1 << 0));
 177         else
 178                 dib3000mc_write_word(state, 245, 0);
 179
 180         dib3000mc_write_word(state, 1040, 0x3);
 181         return 0;
 182 }
 183
 184 static int dib3000mc_set_output_mode(struct dib3000mc_state *state, int mode)
 185 {
 186         int    ret = 0;
 187         u16 fifo_threshold = 1792;
 188         u16 outreg = 0;
 189         u16 outmode = 0;
 190         u16 elecout = 1;
 191         u16 smo_reg = dib3000mc_read_word(state, 206) & 0x0010; /* keep the pid_parse bit */
 192
 193         dprintk("-I-  Setting output mode for demod %p to %d\n",
 194                         &state->demod, mode);
 195
 196         switch (mode) {
 197                 case OUTMODE_HIGH_Z:  // disable
 198                         elecout = 0;
 199                         break;
 200                 case OUTMODE_MPEG2_PAR_GATED_CLK:   // STBs with parallel gated clock
 201                         outmode = 0;
 202                         break;
 203                 case OUTMODE_MPEG2_PAR_CONT_CLK:    // STBs with parallel continues clock
 204                         outmode = 1;
 205                         break;
 206                 case OUTMODE_MPEG2_SERIAL:          // STBs with serial input
 207                         outmode = 2;
 208                         break;
 209                 case OUTMODE_MPEG2_FIFO:            // e.g. USB feeding
 210                         elecout = 3;
 211                         /*ADDR @ 206 :
 212                         P_smo_error_discard  [1;6:6] = 0
 213                         P_smo_rs_discard     [1;5:5] = 0
 214                         P_smo_pid_parse      [1;4:4] = 0
 215                         P_smo_fifo_flush     [1;3:3] = 0
 216                         P_smo_mode           [2;2:1] = 11
 217                         P_smo_ovf_prot       [1;0:0] = 0
 218                         */
 219                         smo_reg |= 3 << 1;
 220                         fifo_threshold = 512;
 221                         outmode = 5;
 222                         break;
 223                 case OUTMODE_DIVERSITY:
 224                         outmode = 4;
 225                         elecout = 1;
 226                         break;
 227                 default:
 228                         dprintk("Unhandled output_mode passed to be set for demod %p\n",&state->demod);
 229                         outmode = 0;
 230                         break;
 231         }
 232
 233         if ((state->cfg->output_mpeg2_in_188_bytes))
 234                 smo_reg |= (1 << 5); // P_smo_rs_discard     [1;5:5] = 1
 235
 236         outreg = dib3000mc_read_word(state, 244) & 0x07FF;
 237         outreg |= (outmode << 11);
 238         ret |= dib3000mc_write_word(state,  244, outreg);
 239         ret |= dib3000mc_write_word(state,  206, smo_reg);   /*smo_ mode*/
 240         ret |= dib3000mc_write_word(state,  207, fifo_threshold); /* synchronous fread */
 241         ret |= dib3000mc_write_word(state, 1040, elecout);         /* P_out_cfg */
 242         return ret;
 243 }
 244
 245 static int dib3000mc_set_bandwidth(struct dib3000mc_state *state, u32 bw)
 246 {
 247         u16 bw_cfg[6] = { 0 };
 248         u16 imp_bw_cfg[3] = { 0 };
 249         u16 reg;
 250
 251 /* settings here are for 27.7MHz */
 252         switch (bw) {
 253                 case 8000:
 254                         bw_cfg[0] = 0x0019; bw_cfg[1] = 0x5c30; bw_cfg[2] = 0x0054; bw_cfg[3] = 0x88a0; bw_cfg[4] = 0x01a6; bw_cfg[5] = 0xab20;
 255                         imp_bw_cfg[0] = 0x04db; imp_bw_cfg[1] = 0x00db; imp_bw_cfg[2] = 0x00b7;
 256                         break;
 257
 258                 case 7000:
 259                         bw_cfg[0] = 0x001c; bw_cfg[1] = 0xfba5; bw_cfg[2] = 0x0060; bw_cfg[3] = 0x9c25; bw_cfg[4] = 0x01e3; bw_cfg[5] = 0x0cb7;
 260                         imp_bw_cfg[0] = 0x04c0; imp_bw_cfg[1] = 0x00c0; imp_bw_cfg[2] = 0x00a0;
 261                         break;
 262
 263                 case 6000:
 264                         bw_cfg[0] = 0x0021; bw_cfg[1] = 0xd040; bw_cfg[2] = 0x0070; bw_cfg[3] = 0xb62b; bw_cfg[4] = 0x0233; bw_cfg[5] = 0x8ed5;
 265                         imp_bw_cfg[0] = 0x04a5; imp_bw_cfg[1] = 0x00a5; imp_bw_cfg[2] = 0x0089;
 266                         break;
 267
 268                 case 5000:
 269                         bw_cfg[0] = 0x0028; bw_cfg[1] = 0x9380; bw_cfg[2] = 0x0087; bw_cfg[3] = 0x4100; bw_cfg[4] = 0x02a4; bw_cfg[5] = 0x4500;
 270                         imp_bw_cfg[0] = 0x0489; imp_bw_cfg[1] = 0x0089; imp_bw_cfg[2] = 0x0072;
 271                         break;
 272
 273                 default: return -EINVAL;
 274         }
 275
 276         for (reg = 6; reg < 12; reg++)
 277                 dib3000mc_write_word(state, reg, bw_cfg[reg - 6]);
 278         dib3000mc_write_word(state, 12, 0x0000);
 279         dib3000mc_write_word(state, 13, 0x03e8);
 280         dib3000mc_write_word(state, 14, 0x0000);
 281         dib3000mc_write_word(state, 15, 0x03f2);
 282         dib3000mc_write_word(state, 16, 0x0001);
 283         dib3000mc_write_word(state, 17, 0xb0d0);
 284         // P_sec_len
 285         dib3000mc_write_word(state, 18, 0x0393);
 286         dib3000mc_write_word(state, 19, 0x8700);
 287
 288         for (reg = 55; reg < 58; reg++)
 289                 dib3000mc_write_word(state, reg, imp_bw_cfg[reg - 55]);
 290
 291         // Timing configuration
 292         dib3000mc_set_timing(state, TRANSMISSION_MODE_2K, bw, 0);
 293
 294         return 0;
 295 }
 296
 297 static u16 impulse_noise_val[29] =
 298
 299 {
 300         0x38, 0x6d9, 0x3f28, 0x7a7, 0x3a74, 0x196, 0x32a, 0x48c, 0x3ffe, 0x7f3,
 301         0x2d94, 0x76, 0x53d, 0x3ff8, 0x7e3, 0x3320, 0x76, 0x5b3, 0x3feb, 0x7d2,
 302         0x365e, 0x76, 0x48c, 0x3ffe, 0x5b3, 0x3feb, 0x76, 0x0000, 0xd
 303 };
 304
 305 static void dib3000mc_set_impulse_noise(struct dib3000mc_state *state, u8 mode, s16 nfft)
 306 {
 307         u16 i;
 308         for (i = 58; i < 87; i++)
 309                 dib3000mc_write_word(state, i, impulse_noise_val[i-58]);
 310
 311         if (nfft == TRANSMISSION_MODE_8K) {
 312                 dib3000mc_write_word(state, 58, 0x3b);
 313                 dib3000mc_write_word(state, 84, 0x00);
 314                 dib3000mc_write_word(state, 85, 0x8200);
 315         }
 316
 317         dib3000mc_write_word(state, 34, 0x1294);
 318         dib3000mc_write_word(state, 35, 0x1ff8);
 319         if (mode == 1)
 320                 dib3000mc_write_word(state, 55, dib3000mc_read_word(state, 55) | (1 << 10));
 321 }
 322
 323 static int dib3000mc_init(struct dvb_frontend *demod)
 324 {
 325         struct dib3000mc_state *state = demod->demodulator_priv;
 326         struct dibx000_agc_config *agc = state->cfg->agc;
 327
 328         // Restart Configuration
 329         dib3000mc_write_word(state, 1027, 0x8000);
 330         dib3000mc_write_word(state, 1027, 0x0000);
 331
 332         // power up the demod + mobility configuration
 333         dib3000mc_write_word(state, 140, 0x0000);
 334         dib3000mc_write_word(state, 1031, 0);
 335
 336         if (state->cfg->mobile_mode) {
 337                 dib3000mc_write_word(state, 139,  0x0000);
 338                 dib3000mc_write_word(state, 141,  0x0000);
 339                 dib3000mc_write_word(state, 175,  0x0002);
 340                 dib3000mc_write_word(state, 1032, 0x0000);
 341         } else {
 342                 dib3000mc_write_word(state, 139,  0x0001);
 343                 dib3000mc_write_word(state, 141,  0x0000);
 344                 dib3000mc_write_word(state, 175,  0x0000);
 345                 dib3000mc_write_word(state, 1032, 0x012C);
 346         }
 347         dib3000mc_write_word(state, 1033, 0x0000);
 348
 349         // P_clk_cfg
 350         dib3000mc_write_word(state, 1037, 0x3130);
 351
 352         // other configurations
 353
 354         // P_ctrl_sfreq
 355         dib3000mc_write_word(state, 33, (5 << 0));
 356         dib3000mc_write_word(state, 88, (1 << 10) | (0x10 << 0));
 357
 358         // Phase noise control
 359         // P_fft_phacor_inh, P_fft_phacor_cpe, P_fft_powrange
 360         dib3000mc_write_word(state, 99, (1 << 9) | (0x20 << 0));
 361
 362         if (state->cfg->phase_noise_mode == 0)
 363                 dib3000mc_write_word(state, 111, 0x00);
 364         else
 365                 dib3000mc_write_word(state, 111, 0x02);
 366
 367         // P_agc_global
 368         dib3000mc_write_word(state, 50, 0x8000);
 369
 370         // agc setup misc
 371         dib3000mc_setup_pwm_state(state);
 372
 373         // P_agc_counter_lock
 374         dib3000mc_write_word(state, 53, 0x87);
 375         // P_agc_counter_unlock
 376         dib3000mc_write_word(state, 54, 0x87);
 377
 378         /* agc */
 379         dib3000mc_write_word(state, 36, state->cfg->max_time);
 380         dib3000mc_write_word(state, 37, (state->cfg->agc_command1 << 13) | (state->cfg->agc_command2 << 12) | (0x1d << 0));
 381         dib3000mc_write_word(state, 38, state->cfg->pwm3_value);
 382         dib3000mc_write_word(state, 39, state->cfg->ln_adc_level);
 383
 384         // set_agc_loop_Bw
 385         dib3000mc_write_word(state, 40, 0x0179);
 386         dib3000mc_write_word(state, 41, 0x03f0);
 387
 388         dib3000mc_write_word(state, 42, agc->agc1_max);
 389         dib3000mc_write_word(state, 43, agc->agc1_min);
 390         dib3000mc_write_word(state, 44, agc->agc2_max);
 391         dib3000mc_write_word(state, 45, agc->agc2_min);
 392         dib3000mc_write_word(state, 46, (agc->agc1_pt1 << 8) | agc->agc1_pt2);
 393         dib3000mc_write_word(state, 47, (agc->agc1_slope1 << 8) | agc->agc1_slope2);
 394         dib3000mc_write_word(state, 48, (agc->agc2_pt1 << 8) | agc->agc2_pt2);
 395         dib3000mc_write_word(state, 49, (agc->agc2_slope1 << 8) | agc->agc2_slope2);
 396
 397 // Begin: TimeOut registers
 398         // P_pha3_thres
 399         dib3000mc_write_word(state, 110, 3277);
 400         // P_timf_alpha = 6, P_corm_alpha = 6, P_corm_thres = 0x80
 401         dib3000mc_write_word(state,  26, 0x6680);
 402         // lock_mask0
 403         dib3000mc_write_word(state, 1, 4);
 404         // lock_mask1
 405         dib3000mc_write_word(state, 2, 4);
 406         // lock_mask2
 407         dib3000mc_write_word(state, 3, 0x1000);
 408         // P_search_maxtrial=1
 409         dib3000mc_write_word(state, 5, 1);
 410
 411         dib3000mc_set_bandwidth(state, 8000);
 412
 413         // div_lock_mask
 414         dib3000mc_write_word(state,  4, 0x814);
 415
 416         dib3000mc_write_word(state, 21, (1 << 9) | 0x164);
 417         dib3000mc_write_word(state, 22, 0x463d);
 418
 419         // Spurious rm cfg
 420         // P_cspu_regul, P_cspu_win_cut
 421         dib3000mc_write_word(state, 120, 0x200f);
 422         // P_adp_selec_monit
 423         dib3000mc_write_word(state, 134, 0);
 424
 425         // Fec cfg
 426         dib3000mc_write_word(state, 195, 0x10);
 427
 428         // diversity register: P_dvsy_sync_wait..
 429         dib3000mc_write_word(state, 180, 0x2FF0);
 430
 431         // Impulse noise configuration
 432         dib3000mc_set_impulse_noise(state, 0, TRANSMISSION_MODE_8K);
 433
 434         // output mode set-up
 435         dib3000mc_set_output_mode(state, OUTMODE_HIGH_Z);
 436
 437         /* close the i2c-gate */
 438         dib3000mc_write_word(state, 769, (1 << 7) );
 439
 440         return 0;
 441 }
 442
 443 static int dib3000mc_sleep(struct dvb_frontend *demod)
 444 {
 445         struct dib3000mc_state *state = demod->demodulator_priv;
 446
 447         dib3000mc_write_word(state, 1031, 0xFFFF);
 448         dib3000mc_write_word(state, 1032, 0xFFFF);
 449         dib3000mc_write_word(state, 1033, 0xFFF0);
 450
 451         return 0;
 452 }
 453
 454 static void dib3000mc_set_adp_cfg(struct dib3000mc_state *state, s16 qam)
 455 {
 456         u16 cfg[4] = { 0 },reg;
 457         switch (qam) {
 458                 case QPSK:
 459                         cfg[0] = 0x099a; cfg[1] = 0x7fae; cfg[2] = 0x0333; cfg[3] = 0x7ff0;
 460                         break;
 461                 case QAM_16:
 462                         cfg[0] = 0x023d; cfg[1] = 0x7fdf; cfg[2] = 0x00a4; cfg[3] = 0x7ff0;
 463                         break;
 464                 case QAM_64:
 465                         cfg[0] = 0x0148; cfg[1] = 0x7ff0; cfg[2] = 0x00a4; cfg[3] = 0x7ff8;
 466                         break;
 467         }
 468         for (reg = 129; reg < 133; reg++)
 469                 dib3000mc_write_word(state, reg, cfg[reg - 129]);
 470 }
 471
 472 static void dib3000mc_set_channel_cfg(struct dib3000mc_state *state,
 473                                       struct dtv_frontend_properties *ch, u16 seq)
 474 {
 475         u16 value;
 476         u32 bw = BANDWIDTH_TO_KHZ(ch->bandwidth_hz);
 477
 478         dib3000mc_set_bandwidth(state, bw);
 479         dib3000mc_set_timing(state, ch->transmission_mode, bw, 0);
 480
 481 #if 1
 482         dib3000mc_write_word(state, 100, (16 << 6) + 9);
 483 #else
 484         if (boost)
 485                 dib3000mc_write_word(state, 100, (11 << 6) + 6);
 486         else
 487                 dib3000mc_write_word(state, 100, (16 << 6) + 9);
 488 #endif
 489
 490         dib3000mc_write_word(state, 1027, 0x0800);
 491         dib3000mc_write_word(state, 1027, 0x0000);
 492
 493         //Default cfg isi offset adp
 494         dib3000mc_write_word(state, 26,  0x6680);
 495         dib3000mc_write_word(state, 29,  0x1273);
 496         dib3000mc_write_word(state, 33,       5);
 497         dib3000mc_set_adp_cfg(state, QAM_16);
 498         dib3000mc_write_word(state, 133,  15564);
 499
 500         dib3000mc_write_word(state, 12 , 0x0);
 501         dib3000mc_write_word(state, 13 , 0x3e8);
 502         dib3000mc_write_word(state, 14 , 0x0);
 503         dib3000mc_write_word(state, 15 , 0x3f2);
 504
 505         dib3000mc_write_word(state, 93,0);
 506         dib3000mc_write_word(state, 94,0);
 507         dib3000mc_write_word(state, 95,0);
 508         dib3000mc_write_word(state, 96,0);
 509         dib3000mc_write_word(state, 97,0);
 510         dib3000mc_write_word(state, 98,0);
 511
 512         dib3000mc_set_impulse_noise(state, 0, ch->transmission_mode);
 513
 514         value = 0;
 515         switch (ch->transmission_mode) {
 516                 case TRANSMISSION_MODE_2K: value |= (0 << 7); break;
 517                 default:
 518                 case TRANSMISSION_MODE_8K: value |= (1 << 7); break;
 519         }
 520         switch (ch->guard_interval) {
 521                 case GUARD_INTERVAL_1_32: value |= (0 << 5); break;
 522                 case GUARD_INTERVAL_1_16: value |= (1 << 5); break;
 523                 case GUARD_INTERVAL_1_4:  value |= (3 << 5); break;
 524                 default:
 525                 case GUARD_INTERVAL_1_8:  value |= (2 << 5); break;
 526         }
 527         switch (ch->modulation) {
 528                 case QPSK:  value |= (0 << 3); break;
 529                 case QAM_16: value |= (1 << 3); break;
 530                 default:
 531                 case QAM_64: value |= (2 << 3); break;
 532         }
 533         switch (HIERARCHY_1) {
 534                 case HIERARCHY_2: value |= 2; break;
 535                 case HIERARCHY_4: value |= 4; break;
 536                 default:
 537                 case HIERARCHY_1: value |= 1; break;
 538         }
 539         dib3000mc_write_word(state, 0, value);
 540         dib3000mc_write_word(state, 5, (1 << 8) | ((seq & 0xf) << 4));
 541
 542         value = 0;
 543         if (ch->hierarchy == 1)
 544                 value |= (1 << 4);
 545         if (1 == 1)
 546                 value |= 1;
 547         switch ((ch->hierarchy == 0 || 1 == 1) ? ch->code_rate_HP : ch->code_rate_LP) {
 548                 case FEC_2_3: value |= (2 << 1); break;
 549                 case FEC_3_4: value |= (3 << 1); break;
 550                 case FEC_5_6: value |= (5 << 1); break;
 551                 case FEC_7_8: value |= (7 << 1); break;
 552                 default:
 553                 case FEC_1_2: value |= (1 << 1); break;
 554         }
 555         dib3000mc_write_word(state, 181, value);
 556
 557         // diversity synchro delay add 50% SFN margin
 558         switch (ch->transmission_mode) {
 559                 case TRANSMISSION_MODE_8K: value = 256; break;
 560                 case TRANSMISSION_MODE_2K:
 561                 default: value = 64; break;
 562         }
 563         switch (ch->guard_interval) {
 564                 case GUARD_INTERVAL_1_16: value *= 2; break;
 565                 case GUARD_INTERVAL_1_8:  value *= 4; break;
 566                 case GUARD_INTERVAL_1_4:  value *= 8; break;
 567                 default:
 568                 case GUARD_INTERVAL_1_32: value *= 1; break;
 569         }
 570         value <<= 4;
 571         value |= dib3000mc_read_word(state, 180) & 0x000f;
 572         dib3000mc_write_word(state, 180, value);
 573
 574         // restart demod
 575         value = dib3000mc_read_word(state, 0);
 576         dib3000mc_write_word(state, 0, value | (1 << 9));
 577         dib3000mc_write_word(state, 0, value);
 578
 579         msleep(30);
 580
 581         dib3000mc_set_impulse_noise(state, state->cfg->impulse_noise_mode, ch->transmission_mode);
 582 }
 583
 584 static int dib3000mc_autosearch_start(struct dvb_frontend *demod)
 585 {
 586         struct dtv_frontend_properties *chan = &demod->dtv_property_cache;
 587         struct dib3000mc_state *state = demod->demodulator_priv;
 588         u16 reg;
 589 //      u32 val;
 590         struct dtv_frontend_properties schan;
 591
 592         schan = *chan;
 593
 594         /* TODO what is that ? */
 595
 596         /* a channel for autosearch */
 597         schan.transmission_mode = TRANSMISSION_MODE_8K;
 598         schan.guard_interval = GUARD_INTERVAL_1_32;
 599         schan.modulation = QAM_64;
 600         schan.code_rate_HP = FEC_2_3;
 601         schan.code_rate_LP = FEC_2_3;
 602         schan.hierarchy = 0;
 603
 604         dib3000mc_set_channel_cfg(state, &schan, 11);
 605
 606         reg = dib3000mc_read_word(state, 0);
 607         dib3000mc_write_word(state, 0, reg | (1 << 8));
 608         dib3000mc_read_word(state, 511);
 609         dib3000mc_write_word(state, 0, reg);
 610
 611         return 0;
 612 }
 613
 614 static int dib3000mc_autosearch_is_irq(struct dvb_frontend *demod)
 615 {
 616         struct dib3000mc_state *state = demod->demodulator_priv;
 617         u16 irq_pending = dib3000mc_read_word(state, 511);
 618
 619         if (irq_pending & 0x1) // failed
 620                 return 1;
 621
 622         if (irq_pending & 0x2) // succeeded
 623                 return 2;
 624
 625         return 0; // still pending
 626 }
 627
 628 static int dib3000mc_tune(struct dvb_frontend *demod)
 629 {
 630         struct dtv_frontend_properties *ch = &demod->dtv_property_cache;
 631         struct dib3000mc_state *state = demod->demodulator_priv;
 632
 633         // ** configure demod **
 634         dib3000mc_set_channel_cfg(state, ch, 0);
 635
 636         // activates isi
 637         if (state->sfn_workaround_active) {
 638                 dprintk("SFN workaround is active\n");
 639                 dib3000mc_write_word(state, 29, 0x1273);
 640                 dib3000mc_write_word(state, 108, 0x4000); // P_pha3_force_pha_shift
 641         } else {
 642                 dib3000mc_write_word(state, 29, 0x1073);
 643                 dib3000mc_write_word(state, 108, 0x0000); // P_pha3_force_pha_shift
 644         }
 645
 646         dib3000mc_set_adp_cfg(state, (u8)ch->modulation);
 647         if (ch->transmission_mode == TRANSMISSION_MODE_8K) {
 648                 dib3000mc_write_word(state, 26, 38528);
 649                 dib3000mc_write_word(state, 33, 8);
 650         } else {
 651                 dib3000mc_write_word(state, 26, 30336);
 652                 dib3000mc_write_word(state, 33, 6);
 653         }
 654
 655         if (dib3000mc_read_word(state, 509) & 0x80)
 656                 dib3000mc_set_timing(state, ch->transmission_mode,
 657                                      BANDWIDTH_TO_KHZ(ch->bandwidth_hz), 1);
 658
 659         return 0;
 660 }
 661
 662 struct i2c_adapter * dib3000mc_get_tuner_i2c_master(struct dvb_frontend *demod, int gating)
 663 {
 664         struct dib3000mc_state *st = demod->demodulator_priv;
 665         return dibx000_get_i2c_adapter(&st->i2c_master, DIBX000_I2C_INTERFACE_TUNER, gating);
 666 }
 667
 668 EXPORT_SYMBOL(dib3000mc_get_tuner_i2c_master);
 669
 670 static int dib3000mc_get_frontend(struct dvb_frontend* fe,
 671                                   struct dtv_frontend_properties *fep)
 672 {
 673         struct dib3000mc_state *state = fe->demodulator_priv;
 674         u16 tps = dib3000mc_read_word(state,458);
 675
 676         fep->inversion = INVERSION_AUTO;
 677
 678         fep->bandwidth_hz = state->current_bandwidth;
 679
 680         switch ((tps >> 8) & 0x1) {
 681                 case 0: fep->transmission_mode = TRANSMISSION_MODE_2K; break;
 682                 case 1: fep->transmission_mode = TRANSMISSION_MODE_8K; break;
 683         }
 684
 685         switch (tps & 0x3) {
 686                 case 0: fep->guard_interval = GUARD_INTERVAL_1_32; break;
 687                 case 1: fep->guard_interval = GUARD_INTERVAL_1_16; break;
 688                 case 2: fep->guard_interval = GUARD_INTERVAL_1_8; break;
 689                 case 3: fep->guard_interval = GUARD_INTERVAL_1_4; break;
 690         }
 691
 692         switch ((tps >> 13) & 0x3) {
 693                 case 0: fep->modulation = QPSK; break;
 694                 case 1: fep->modulation = QAM_16; break;
 695                 case 2:
 696                 default: fep->modulation = QAM_64; break;
 697         }
 698
 699         /* as long as the frontend_param structure is fixed for hierarchical transmission I refuse to use it */
 700         /* (tps >> 12) & 0x1 == hrch is used, (tps >> 9) & 0x7 == alpha */
 701
 702         fep->hierarchy = HIERARCHY_NONE;
 703         switch ((tps >> 5) & 0x7) {
 704                 case 1: fep->code_rate_HP = FEC_1_2; break;
 705                 case 2: fep->code_rate_HP = FEC_2_3; break;
 706                 case 3: fep->code_rate_HP = FEC_3_4; break;
 707                 case 5: fep->code_rate_HP = FEC_5_6; break;
 708                 case 7:
 709                 default: fep->code_rate_HP = FEC_7_8; break;
 710
 711         }
 712
 713         switch ((tps >> 2) & 0x7) {
 714                 case 1: fep->code_rate_LP = FEC_1_2; break;
 715                 case 2: fep->code_rate_LP = FEC_2_3; break;
 716                 case 3: fep->code_rate_LP = FEC_3_4; break;
 717                 case 5: fep->code_rate_LP = FEC_5_6; break;
 718                 case 7:
 719                 default: fep->code_rate_LP = FEC_7_8; break;
 720         }
 721
 722         return 0;
 723 }
 724
 725 static int dib3000mc_set_frontend(struct dvb_frontend *fe)
 726 {
 727         struct dtv_frontend_properties *fep = &fe->dtv_property_cache;
 728         struct dib3000mc_state *state = fe->demodulator_priv;
 729         int ret;
 730
 731         dib3000mc_set_output_mode(state, OUTMODE_HIGH_Z);
 732
 733         state->current_bandwidth = fep->bandwidth_hz;
 734         dib3000mc_set_bandwidth(state, BANDWIDTH_TO_KHZ(fep->bandwidth_hz));
 735
 736         /* maybe the parameter has been changed */
 737         state->sfn_workaround_active = buggy_sfn_workaround;
 738
 739         if (fe->ops.tuner_ops.set_params) {
 740                 fe->ops.tuner_ops.set_params(fe);
 741                 msleep(100);
 742         }
 743
 744         if (fep->transmission_mode  == TRANSMISSION_MODE_AUTO ||
 745             fep->guard_interval == GUARD_INTERVAL_AUTO ||
 746             fep->modulation     == QAM_AUTO ||
 747             fep->code_rate_HP   == FEC_AUTO) {
 748                 int i = 1000, found;
 749
 750                 dib3000mc_autosearch_start(fe);
 751                 do {
 752                         msleep(1);
 753                         found = dib3000mc_autosearch_is_irq(fe);
 754                 } while (found == 0 && i--);
 755
 756                 dprintk("autosearch returns: %d\n",found);
 757                 if (found == 0 || found == 1)
 758                         return 0; // no channel found
 759
 760                 dib3000mc_get_frontend(fe, fep);
 761         }
 762
 763         ret = dib3000mc_tune(fe);
 764
 765         /* make this a config parameter */
 766         dib3000mc_set_output_mode(state, OUTMODE_MPEG2_FIFO);
 767         return ret;
 768 }
 769
 770 static int dib3000mc_read_status(struct dvb_frontend *fe, enum fe_status *stat)
 771 {
 772         struct dib3000mc_state *state = fe->demodulator_priv;
 773         u16 lock = dib3000mc_read_word(state, 509);
 774
 775         *stat = 0;
 776
 777         if (lock & 0x8000)
 778                 *stat |= FE_HAS_SIGNAL;
 779         if (lock & 0x3000)
 780                 *stat |= FE_HAS_CARRIER;
 781         if (lock & 0x0100)
 782                 *stat |= FE_HAS_VITERBI;
 783         if (lock & 0x0010)
 784                 *stat |= FE_HAS_SYNC;
 785         if (lock & 0x0008)
 786                 *stat |= FE_HAS_LOCK;
 787
 788         return 0;
 789 }
 790
 791 static int dib3000mc_read_ber(struct dvb_frontend *fe, u32 *ber)
 792 {
 793         struct dib3000mc_state *state = fe->demodulator_priv;
 794         *ber = (dib3000mc_read_word(state, 500) << 16) | dib3000mc_read_word(state, 501);
 795         return 0;
 796 }
 797
 798 static int dib3000mc_read_unc_blocks(struct dvb_frontend *fe, u32 *unc)
 799 {
 800         struct dib3000mc_state *state = fe->demodulator_priv;
 801         *unc = dib3000mc_read_word(state, 508);
 802         return 0;
 803 }
 804
 805 static int dib3000mc_read_signal_strength(struct dvb_frontend *fe, u16 *strength)
 806 {
 807         struct dib3000mc_state *state = fe->demodulator_priv;
 808         u16 val = dib3000mc_read_word(state, 392);
 809         *strength = 65535 - val;
 810         return 0;
 811 }
 812
 813 static int dib3000mc_read_snr(struct dvb_frontend* fe, u16 *snr)
 814 {
 815         *snr = 0x0000;
 816         return 0;
 817 }
 818
 819 static int dib3000mc_fe_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings *tune)
 820 {
 821         tune->min_delay_ms = 1000;
 822         return 0;
 823 }
 824
 825 static void dib3000mc_release(struct dvb_frontend *fe)
 826 {
 827         struct dib3000mc_state *state = fe->demodulator_priv;
 828         dibx000_exit_i2c_master(&state->i2c_master);
 829         kfree(state);
 830 }
 831
 832 int dib3000mc_pid_control(struct dvb_frontend *fe, int index, int pid,int onoff)
 833 {
 834         struct dib3000mc_state *state = fe->demodulator_priv;
 835         dib3000mc_write_word(state, 212 + index,  onoff ? (1 << 13) | pid : 0);
 836         return 0;
 837 }
 838 EXPORT_SYMBOL(dib3000mc_pid_control);
 839
 840 int dib3000mc_pid_parse(struct dvb_frontend *fe, int onoff)
 841 {
 842         struct dib3000mc_state *state = fe->demodulator_priv;
 843         u16 tmp = dib3000mc_read_word(state, 206) & ~(1 << 4);
 844         tmp |= (onoff << 4);
 845         return dib3000mc_write_word(state, 206, tmp);
 846 }
 847 EXPORT_SYMBOL(dib3000mc_pid_parse);
 848
 849 void dib3000mc_set_config(struct dvb_frontend *fe, struct dib3000mc_config *cfg)
 850 {
 851         struct dib3000mc_state *state = fe->demodulator_priv;
 852         state->cfg = cfg;
 853 }
 854 EXPORT_SYMBOL(dib3000mc_set_config);
 855
 856 int dib3000mc_i2c_enumeration(struct i2c_adapter *i2c, int no_of_demods, u8 default_addr, struct dib3000mc_config cfg[])
 857 {
 858         struct dib3000mc_state *dmcst;
 859         int k;
 860         u8 new_addr;
 861
 862         static u8 DIB3000MC_I2C_ADDRESS[] = {20,22,24,26};
 863
 864         dmcst = kzalloc(sizeof(struct dib3000mc_state), GFP_KERNEL);
 865         if (dmcst == NULL)
 866                 return -ENOMEM;
 867
 868         dmcst->i2c_adap = i2c;
 869
 870         for (k = no_of_demods-1; k >= 0; k--) {
 871                 dmcst->cfg = &cfg[k];
 872
 873                 /* designated i2c address */
 874                 new_addr          = DIB3000MC_I2C_ADDRESS[k];
 875                 dmcst->i2c_addr = new_addr;
 876                 if (dib3000mc_identify(dmcst) != 0) {
 877                         dmcst->i2c_addr = default_addr;
 878                         if (dib3000mc_identify(dmcst) != 0) {
 879                                 dprintk("-E-  DiB3000P/MC #%d: not identified\n", k);
 880                                 kfree(dmcst);
 881                                 return -ENODEV;
 882                         }
 883                 }
 884
 885                 dib3000mc_set_output_mode(dmcst, OUTMODE_MPEG2_PAR_CONT_CLK);
 886
 887                 // set new i2c address and force divstr (Bit 1) to value 0 (Bit 0)
 888                 dib3000mc_write_word(dmcst, 1024, (new_addr << 3) | 0x1);
 889                 dmcst->i2c_addr = new_addr;
 890         }
 891
 892         for (k = 0; k < no_of_demods; k++) {
 893                 dmcst->cfg = &cfg[k];
 894                 dmcst->i2c_addr = DIB3000MC_I2C_ADDRESS[k];
 895
 896                 dib3000mc_write_word(dmcst, 1024, dmcst->i2c_addr << 3);
 897
 898                 /* turn off data output */
 899                 dib3000mc_set_output_mode(dmcst, OUTMODE_HIGH_Z);
 900         }
 901
 902         kfree(dmcst);
 903         return 0;
 904 }
 905 EXPORT_SYMBOL(dib3000mc_i2c_enumeration);
 906
 907 static const struct dvb_frontend_ops dib3000mc_ops;
 908
 909 struct dvb_frontend * dib3000mc_attach(struct i2c_adapter *i2c_adap, u8 i2c_addr, struct dib3000mc_config *cfg)
 910 {
 911         struct dvb_frontend *demod;
 912         struct dib3000mc_state *st;
 913         st = kzalloc(sizeof(struct dib3000mc_state), GFP_KERNEL);
 914         if (st == NULL)
 915                 return NULL;
 916
 917         st->cfg = cfg;
 918         st->i2c_adap = i2c_adap;
 919         st->i2c_addr = i2c_addr;
 920
 921         demod                   = &st->demod;
 922         demod->demodulator_priv = st;
 923         memcpy(&st->demod.ops, &dib3000mc_ops, sizeof(struct dvb_frontend_ops));
 924
 925         if (dib3000mc_identify(st) != 0)
 926                 goto error;
 927
 928         dibx000_init_i2c_master(&st->i2c_master, DIB3000MC, st->i2c_adap, st->i2c_addr);
 929
 930         dib3000mc_write_word(st, 1037, 0x3130);
 931
 932         return demod;
 933
 934 error:
 935         kfree(st);
 936         return NULL;
 937 }
 938 EXPORT_SYMBOL(dib3000mc_attach);
 939
 940 static const struct dvb_frontend_ops dib3000mc_ops = {
 941         .delsys = { SYS_DVBT },
 942         .info = {
 943                 .name = "DiBcom 3000MC/P",
 944                 .frequency_min_hz      =  44250 * kHz,
 945                 .frequency_max_hz      = 867250 * kHz,
 946                 .frequency_stepsize_hz = 62500,
 947                 .caps = FE_CAN_INVERSION_AUTO |
 948                         FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
 949                         FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_FEC_AUTO |
 950                         FE_CAN_QPSK | FE_CAN_QAM_16 | FE_CAN_QAM_64 | FE_CAN_QAM_AUTO |
 951                         FE_CAN_TRANSMISSION_MODE_AUTO |
 952                         FE_CAN_GUARD_INTERVAL_AUTO |
 953                         FE_CAN_RECOVER |
 954                         FE_CAN_HIERARCHY_AUTO,
 955         },
 956
 957         .release              = dib3000mc_release,
 958
 959         .init                 = dib3000mc_init,
 960         .sleep                = dib3000mc_sleep,
 961
 962         .set_frontend         = dib3000mc_set_frontend,
 963         .get_tune_settings    = dib3000mc_fe_get_tune_settings,
 964         .get_frontend         = dib3000mc_get_frontend,
 965
 966         .read_status          = dib3000mc_read_status,
 967         .read_ber             = dib3000mc_read_ber,
 968         .read_signal_strength = dib3000mc_read_signal_strength,
 969         .read_snr             = dib3000mc_read_snr,
 970         .read_ucblocks        = dib3000mc_read_unc_blocks,
 971 };
 972
 973 MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
 974 MODULE_DESCRIPTION("Driver for the DiBcom 3000MC/P COFDM demodulator");
 975 MODULE_LICENSE("GPL");