drivers/media/dvb/frontends/drxk_hard.c

   1 /*
   2  * drxk_hard: DRX-K DVB-C/T demodulator driver
   3  *
   4  * Copyright (C) 2010-2011 Digital Devices GmbH
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * version 2 only, as published by the Free Software Foundation.
   9  *
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  20  * 02110-1301, USA
  21  * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
  22  */
  23
  24 #include <linux/kernel.h>
  25 #include <linux/module.h>
  26 #include <linux/moduleparam.h>
  27 #include <linux/init.h>
  28 #include <linux/delay.h>
  29 #include <linux/firmware.h>
  30 #include <linux/i2c.h>
  31 #include <asm/div64.h>
  32
  33 #include "dvb_frontend.h"
  34 #include "drxk.h"
  35 #include "drxk_hard.h"
  36
  37 static int PowerDownDVBT(struct drxk_state *state, bool setPowerMode);
  38 static int PowerDownQAM(struct drxk_state *state);
  39 static int SetDVBTStandard(struct drxk_state *state,
  40                            enum OperationMode oMode);
  41 static int SetQAMStandard(struct drxk_state *state,
  42                           enum OperationMode oMode);
  43 static int SetQAM(struct drxk_state *state, u16 IntermediateFreqkHz,
  44                   s32 tunerFreqOffset);
  45 static int SetDVBTStandard(struct drxk_state *state,
  46                            enum OperationMode oMode);
  47 static int DVBTStart(struct drxk_state *state);
  48 static int SetDVBT(struct drxk_state *state, u16 IntermediateFreqkHz,
  49                    s32 tunerFreqOffset);
  50 static int GetQAMLockStatus(struct drxk_state *state, u32 *pLockStatus);
  51 static int GetDVBTLockStatus(struct drxk_state *state, u32 *pLockStatus);
  52 static int SwitchAntennaToQAM(struct drxk_state *state);
  53 static int SwitchAntennaToDVBT(struct drxk_state *state);
  54
  55 static bool IsDVBT(struct drxk_state *state)
  56 {
  57         return state->m_OperationMode == OM_DVBT;
  58 }
  59
  60 static bool IsQAM(struct drxk_state *state)
  61 {
  62         return state->m_OperationMode == OM_QAM_ITU_A ||
  63             state->m_OperationMode == OM_QAM_ITU_B ||
  64             state->m_OperationMode == OM_QAM_ITU_C;
  65 }
  66
  67 bool IsA1WithPatchCode(struct drxk_state *state)
  68 {
  69         return state->m_DRXK_A1_PATCH_CODE;
  70 }
  71
  72 bool IsA1WithRomCode(struct drxk_state *state)
  73 {
  74         return state->m_DRXK_A1_ROM_CODE;
  75 }
  76
  77 #define NOA1ROM 0
  78
  79 #define DRXDAP_FASI_SHORT_FORMAT(addr) (((addr) & 0xFC30FF80) == 0)
  80 #define DRXDAP_FASI_LONG_FORMAT(addr)  (((addr) & 0xFC30FF80) != 0)
  81
  82 #define DEFAULT_MER_83  165
  83 #define DEFAULT_MER_93  250
  84
  85 #ifndef DRXK_MPEG_SERIAL_OUTPUT_PIN_DRIVE_STRENGTH
  86 #define DRXK_MPEG_SERIAL_OUTPUT_PIN_DRIVE_STRENGTH (0x02)
  87 #endif
  88
  89 #ifndef DRXK_MPEG_PARALLEL_OUTPUT_PIN_DRIVE_STRENGTH
  90 #define DRXK_MPEG_PARALLEL_OUTPUT_PIN_DRIVE_STRENGTH (0x03)
  91 #endif
  92
  93 #ifndef DRXK_MPEG_OUTPUT_CLK_DRIVE_STRENGTH
  94 #define DRXK_MPEG_OUTPUT_CLK_DRIVE_STRENGTH (0x06)
  95 #endif
  96
  97 #define DEFAULT_DRXK_MPEG_LOCK_TIMEOUT 700
  98 #define DEFAULT_DRXK_DEMOD_LOCK_TIMEOUT 500
  99
 100 #ifndef DRXK_KI_RAGC_ATV
 101 #define DRXK_KI_RAGC_ATV   4
 102 #endif
 103 #ifndef DRXK_KI_IAGC_ATV
 104 #define DRXK_KI_IAGC_ATV   6
 105 #endif
 106 #ifndef DRXK_KI_DAGC_ATV
 107 #define DRXK_KI_DAGC_ATV   7
 108 #endif
 109
 110 #ifndef DRXK_KI_RAGC_QAM
 111 #define DRXK_KI_RAGC_QAM   3
 112 #endif
 113 #ifndef DRXK_KI_IAGC_QAM
 114 #define DRXK_KI_IAGC_QAM   4
 115 #endif
 116 #ifndef DRXK_KI_DAGC_QAM
 117 #define DRXK_KI_DAGC_QAM   7
 118 #endif
 119 #ifndef DRXK_KI_RAGC_DVBT
 120 #define DRXK_KI_RAGC_DVBT  (IsA1WithPatchCode(state) ? 3 : 2)
 121 #endif
 122 #ifndef DRXK_KI_IAGC_DVBT
 123 #define DRXK_KI_IAGC_DVBT  (IsA1WithPatchCode(state) ? 4 : 2)
 124 #endif
 125 #ifndef DRXK_KI_DAGC_DVBT
 126 #define DRXK_KI_DAGC_DVBT  (IsA1WithPatchCode(state) ? 10 : 7)
 127 #endif
 128
 129 #ifndef DRXK_AGC_DAC_OFFSET
 130 #define DRXK_AGC_DAC_OFFSET (0x800)
 131 #endif
 132
 133 #ifndef DRXK_BANDWIDTH_8MHZ_IN_HZ
 134 #define DRXK_BANDWIDTH_8MHZ_IN_HZ  (0x8B8249L)
 135 #endif
 136
 137 #ifndef DRXK_BANDWIDTH_7MHZ_IN_HZ
 138 #define DRXK_BANDWIDTH_7MHZ_IN_HZ  (0x7A1200L)
 139 #endif
 140
 141 #ifndef DRXK_BANDWIDTH_6MHZ_IN_HZ
 142 #define DRXK_BANDWIDTH_6MHZ_IN_HZ  (0x68A1B6L)
 143 #endif
 144
 145 #ifndef DRXK_QAM_SYMBOLRATE_MAX
 146 #define DRXK_QAM_SYMBOLRATE_MAX         (7233000)
 147 #endif
 148
 149 #define DRXK_BL_ROM_OFFSET_TAPS_DVBT    56
 150 #define DRXK_BL_ROM_OFFSET_TAPS_ITU_A   64
 151 #define DRXK_BL_ROM_OFFSET_TAPS_ITU_C   0x5FE0
 152 #define DRXK_BL_ROM_OFFSET_TAPS_BG      24
 153 #define DRXK_BL_ROM_OFFSET_TAPS_DKILLP  32
 154 #define DRXK_BL_ROM_OFFSET_TAPS_NTSC    40
 155 #define DRXK_BL_ROM_OFFSET_TAPS_FM      48
 156 #define DRXK_BL_ROM_OFFSET_UCODE        0
 157
 158 #define DRXK_BLC_TIMEOUT                100
 159
 160 #define DRXK_BLCC_NR_ELEMENTS_TAPS      2
 161 #define DRXK_BLCC_NR_ELEMENTS_UCODE     6
 162
 163 #define DRXK_BLDC_NR_ELEMENTS_TAPS      28
 164
 165 #ifndef DRXK_OFDM_NE_NOTCH_WIDTH
 166 #define DRXK_OFDM_NE_NOTCH_WIDTH             (4)
 167 #endif
 168
 169 #define DRXK_QAM_SL_SIG_POWER_QAM16       (40960)
 170 #define DRXK_QAM_SL_SIG_POWER_QAM32       (20480)
 171 #define DRXK_QAM_SL_SIG_POWER_QAM64       (43008)
 172 #define DRXK_QAM_SL_SIG_POWER_QAM128      (20992)
 173 #define DRXK_QAM_SL_SIG_POWER_QAM256      (43520)
 174
 175 static unsigned int debug;
 176 module_param(debug, int, 0644);
 177 MODULE_PARM_DESC(debug, "enable debug messages");
 178
 179 #define dprintk(level, fmt, arg...) do {                        \
 180 if (debug >= level)                                             \
 181         printk(KERN_DEBUG "drxk: %s" fmt, __func__, ## arg);    \
 182 } while (0)
 183
 184
 185 static inline u32 MulDiv32(u32 a, u32 b, u32 c)
 186 {
 187         u64 tmp64;
 188
 189         tmp64 = (u64) a * (u64) b;
 190         do_div(tmp64, c);
 191
 192         return (u32) tmp64;
 193 }
 194
 195 inline u32 Frac28a(u32 a, u32 c)
 196 {
 197         int i = 0;
 198         u32 Q1 = 0;
 199         u32 R0 = 0;
 200
 201         R0 = (a % c) << 4;      /* 32-28 == 4 shifts possible at max */
 202         Q1 = a / c;             /* integer part, only the 4 least significant bits
 203                                    will be visible in the result */
 204
 205         /* division using radix 16, 7 nibbles in the result */
 206         for (i = 0; i < 7; i++) {
 207                 Q1 = (Q1 << 4) | (R0 / c);
 208                 R0 = (R0 % c) << 4;
 209         }
 210         /* rounding */
 211         if ((R0 >> 3) >= c)
 212                 Q1++;
 213
 214         return Q1;
 215 }
 216
 217 static u32 Log10Times100(u32 x)
 218 {
 219         static const u8 scale = 15;
 220         static const u8 indexWidth = 5;
 221         u8 i = 0;
 222         u32 y = 0;
 223         u32 d = 0;
 224         u32 k = 0;
 225         u32 r = 0;
 226         /*
 227            log2lut[n] = (1<<scale) * 200 * log2(1.0 + ((1.0/(1<<INDEXWIDTH)) * n))
 228            0 <= n < ((1<<INDEXWIDTH)+1)
 229          */
 230
 231         static const u32 log2lut[] = {
 232                 0,              /* 0.000000 */
 233                 290941,         /* 290941.300628 */
 234                 573196,         /* 573196.476418 */
 235                 847269,         /* 847269.179851 */
 236                 1113620,        /* 1113620.489452 */
 237                 1372674,        /* 1372673.576986 */
 238                 1624818,        /* 1624817.752104 */
 239                 1870412,        /* 1870411.981536 */
 240                 2109788,        /* 2109787.962654 */
 241                 2343253,        /* 2343252.817465 */
 242                 2571091,        /* 2571091.461923 */
 243                 2793569,        /* 2793568.696416 */
 244                 3010931,        /* 3010931.055901 */
 245                 3223408,        /* 3223408.452106 */
 246                 3431216,        /* 3431215.635215 */
 247                 3634553,        /* 3634553.498355 */
 248                 3833610,        /* 3833610.244726 */
 249                 4028562,        /* 4028562.434393 */
 250                 4219576,        /* 4219575.925308 */
 251                 4406807,        /* 4406806.721144 */
 252                 4590402,        /* 4590401.736809 */
 253                 4770499,        /* 4770499.491025 */
 254                 4947231,        /* 4947230.734179 */
 255                 5120719,        /* 5120719.018555 */
 256                 5291081,        /* 5291081.217197 */
 257                 5458428,        /* 5458427.996830 */
 258                 5622864,        /* 5622864.249668 */
 259                 5784489,        /* 5784489.488298 */
 260                 5943398,        /* 5943398.207380 */
 261                 6099680,        /* 6099680.215452 */
 262                 6253421,        /* 6253420.939751 */
 263                 6404702,        /* 6404701.706649 */
 264                 6553600,        /* 6553600.000000 */
 265         };
 266
 267
 268         if (x == 0)
 269                 return 0;
 270
 271         /* Scale x (normalize) */
 272         /* computing y in log(x/y) = log(x) - log(y) */
 273         if ((x & ((0xffffffff) << (scale + 1))) == 0) {
 274                 for (k = scale; k > 0; k--) {
 275                         if (x & (((u32) 1) << scale))
 276                                 break;
 277                         x <<= 1;
 278                 }
 279         } else {
 280                 for (k = scale; k < 31; k++) {
 281                         if ((x & (((u32) (-1)) << (scale + 1))) == 0)
 282                                 break;
 283                         x >>= 1;
 284                 }
 285         }
 286         /*
 287            Now x has binary point between bit[scale] and bit[scale-1]
 288            and 1.0 <= x < 2.0 */
 289
 290         /* correction for divison: log(x) = log(x/y)+log(y) */
 291         y = k * ((((u32) 1) << scale) * 200);
 292
 293         /* remove integer part */
 294         x &= ((((u32) 1) << scale) - 1);
 295         /* get index */
 296         i = (u8) (x >> (scale - indexWidth));
 297         /* compute delta (x - a) */
 298         d = x & ((((u32) 1) << (scale - indexWidth)) - 1);
 299         /* compute log, multiplication (d* (..)) must be within range ! */
 300         y += log2lut[i] +
 301             ((d * (log2lut[i + 1] - log2lut[i])) >> (scale - indexWidth));
 302         /* Conver to log10() */
 303         y /= 108853;            /* (log2(10) << scale) */
 304         r = (y >> 1);
 305         /* rounding */
 306         if (y & ((u32) 1))
 307                 r++;
 308         return r;
 309 }
 310
 311 /****************************************************************************/
 312 /* I2C **********************************************************************/
 313 /****************************************************************************/
 314
 315 static int i2c_read1(struct i2c_adapter *adapter, u8 adr, u8 *val)
 316 {
 317         struct i2c_msg msgs[1] = { {.addr = adr, .flags = I2C_M_RD,
 318                                     .buf = val, .len = 1}
 319         };
 320
 321         return i2c_transfer(adapter, msgs, 1);
 322 }
 323
 324 static int i2c_write(struct i2c_adapter *adap, u8 adr, u8 *data, int len)
 325 {
 326         int status;
 327         struct i2c_msg msg = {
 328             .addr = adr, .flags = 0, .buf = data, .len = len };
 329
 330         dprintk(3, ":");
 331         if (debug > 2) {
 332                 int i;
 333                 for (i = 0; i < len; i++)
 334                         printk(KERN_CONT " %02x", data[i]);
 335                 printk(KERN_CONT "\n");
 336         }
 337         status = i2c_transfer(adap, &msg, 1);
 338         if (status >= 0 && status != 1)
 339                 status = -EIO;
 340
 341         if (status < 0)
 342                 printk(KERN_ERR "drxk: i2c write error at addr 0x%02x\n", adr);
 343
 344         return status;
 345 }
 346
 347 static int i2c_read(struct i2c_adapter *adap,
 348                     u8 adr, u8 *msg, int len, u8 *answ, int alen)
 349 {
 350         int status;
 351         struct i2c_msg msgs[2] = {
 352                 {.addr = adr, .flags = 0,
 353                                     .buf = msg, .len = len},
 354                 {.addr = adr, .flags = I2C_M_RD,
 355                  .buf = answ, .len = alen}
 356         };
 357
 358         status = i2c_transfer(adap, msgs, 2);
 359         if (status != 2) {
 360                 if (debug > 2)
 361                         printk(KERN_CONT ": ERROR!\n");
 362                 if (status >= 0)
 363                         status = -EIO;
 364
 365                 printk(KERN_ERR "drxk: i2c read error at addr 0x%02x\n", adr);
 366                 return status;
 367         }
 368         if (debug > 2) {
 369                 int i;
 370                 dprintk(2, ": read from");
 371                 for (i = 0; i < len; i++)
 372                         printk(KERN_CONT " %02x", msg[i]);
 373                 printk(KERN_CONT ", value = ");
 374                 for (i = 0; i < alen; i++)
 375                         printk(KERN_CONT " %02x", answ[i]);
 376                 printk(KERN_CONT "\n");
 377         }
 378         return 0;
 379 }
 380
 381 static int read16_flags(struct drxk_state *state, u32 reg, u16 *data, u8 flags)
 382 {
 383         int status;
 384         u8 adr = state->demod_address, mm1[4], mm2[2], len;
 385
 386         if (state->single_master)
 387                 flags |= 0xC0;
 388
 389         if (DRXDAP_FASI_LONG_FORMAT(reg) || (flags != 0)) {
 390                 mm1[0] = (((reg << 1) & 0xFF) | 0x01);
 391                 mm1[1] = ((reg >> 16) & 0xFF);
 392                 mm1[2] = ((reg >> 24) & 0xFF) | flags;
 393                 mm1[3] = ((reg >> 7) & 0xFF);
 394                 len = 4;
 395         } else {
 396                 mm1[0] = ((reg << 1) & 0xFF);
 397                 mm1[1] = (((reg >> 16) & 0x0F) | ((reg >> 18) & 0xF0));
 398                 len = 2;
 399         }
 400         dprintk(2, "(0x%08x, 0x%02x)\n", reg, flags);
 401         status = i2c_read(state->i2c, adr, mm1, len, mm2, 2);
 402         if (status < 0)
 403                 return status;
 404         if (data)
 405                 *data = mm2[0] | (mm2[1] << 8);
 406
 407         return 0;
 408 }
 409
 410 static int read16(struct drxk_state *state, u32 reg, u16 *data)
 411 {
 412         return read16_flags(state, reg, data, 0);
 413 }
 414
 415 static int read32_flags(struct drxk_state *state, u32 reg, u32 *data, u8 flags)
 416 {
 417         int status;
 418         u8 adr = state->demod_address, mm1[4], mm2[4], len;
 419
 420         if (state->single_master)
 421                 flags |= 0xC0;
 422
 423         if (DRXDAP_FASI_LONG_FORMAT(reg) || (flags != 0)) {
 424                 mm1[0] = (((reg << 1) & 0xFF) | 0x01);
 425                 mm1[1] = ((reg >> 16) & 0xFF);
 426                 mm1[2] = ((reg >> 24) & 0xFF) | flags;
 427                 mm1[3] = ((reg >> 7) & 0xFF);
 428                 len = 4;
 429         } else {
 430                 mm1[0] = ((reg << 1) & 0xFF);
 431                 mm1[1] = (((reg >> 16) & 0x0F) | ((reg >> 18) & 0xF0));
 432                 len = 2;
 433         }
 434         dprintk(2, "(0x%08x, 0x%02x)\n", reg, flags);
 435         status = i2c_read(state->i2c, adr, mm1, len, mm2, 4);
 436         if (status < 0)
 437                 return status;
 438         if (data)
 439                 *data = mm2[0] | (mm2[1] << 8) |
 440                     (mm2[2] << 16) | (mm2[3] << 24);
 441
 442         return 0;
 443 }
 444
 445 static int read32(struct drxk_state *state, u32 reg, u32 *data)
 446 {
 447         return read32_flags(state, reg, data, 0);
 448 }
 449
 450 static int write16_flags(struct drxk_state *state, u32 reg, u16 data, u8 flags)
 451 {
 452         u8 adr = state->demod_address, mm[6], len;
 453
 454         if (state->single_master)
 455                 flags |= 0xC0;
 456         if (DRXDAP_FASI_LONG_FORMAT(reg) || (flags != 0)) {
 457                 mm[0] = (((reg << 1) & 0xFF) | 0x01);
 458                 mm[1] = ((reg >> 16) & 0xFF);
 459                 mm[2] = ((reg >> 24) & 0xFF) | flags;
 460                 mm[3] = ((reg >> 7) & 0xFF);
 461                 len = 4;
 462         } else {
 463                 mm[0] = ((reg << 1) & 0xFF);
 464                 mm[1] = (((reg >> 16) & 0x0F) | ((reg >> 18) & 0xF0));
 465                 len = 2;
 466         }
 467         mm[len] = data & 0xff;
 468         mm[len + 1] = (data >> 8) & 0xff;
 469
 470         dprintk(2, "(0x%08x, 0x%04x, 0x%02x)\n", reg, data, flags);
 471         return i2c_write(state->i2c, adr, mm, len + 2);
 472 }
 473
 474 static int write16(struct drxk_state *state, u32 reg, u16 data)
 475 {
 476         return write16_flags(state, reg, data, 0);
 477 }
 478
 479 static int write32_flags(struct drxk_state *state, u32 reg, u32 data, u8 flags)
 480 {
 481         u8 adr = state->demod_address, mm[8], len;
 482
 483         if (state->single_master)
 484                 flags |= 0xC0;
 485         if (DRXDAP_FASI_LONG_FORMAT(reg) || (flags != 0)) {
 486                 mm[0] = (((reg << 1) & 0xFF) | 0x01);
 487                 mm[1] = ((reg >> 16) & 0xFF);
 488                 mm[2] = ((reg >> 24) & 0xFF) | flags;
 489                 mm[3] = ((reg >> 7) & 0xFF);
 490                 len = 4;
 491         } else {
 492                 mm[0] = ((reg << 1) & 0xFF);
 493                 mm[1] = (((reg >> 16) & 0x0F) | ((reg >> 18) & 0xF0));
 494                 len = 2;
 495         }
 496         mm[len] = data & 0xff;
 497         mm[len + 1] = (data >> 8) & 0xff;
 498         mm[len + 2] = (data >> 16) & 0xff;
 499         mm[len + 3] = (data >> 24) & 0xff;
 500         dprintk(2, "(0x%08x, 0x%08x, 0x%02x)\n", reg, data, flags);
 501
 502         return i2c_write(state->i2c, adr, mm, len + 4);
 503 }
 504
 505 static int write32(struct drxk_state *state, u32 reg, u32 data)
 506 {
 507         return write32_flags(state, reg, data, 0);
 508 }
 509
 510 static int write_block(struct drxk_state *state, u32 Address,
 511                       const int BlockSize, const u8 pBlock[])
 512 {
 513         int status = 0, BlkSize = BlockSize;
 514         u8 Flags = 0;
 515
 516         if (state->single_master)
 517                 Flags |= 0xC0;
 518
 519         while (BlkSize > 0) {
 520                 int Chunk = BlkSize > state->m_ChunkSize ?
 521                     state->m_ChunkSize : BlkSize;
 522                 u8 *AdrBuf = &state->Chunk[0];
 523                 u32 AdrLength = 0;
 524
 525                 if (DRXDAP_FASI_LONG_FORMAT(Address) || (Flags != 0)) {
 526                         AdrBuf[0] = (((Address << 1) & 0xFF) | 0x01);
 527                         AdrBuf[1] = ((Address >> 16) & 0xFF);
 528                         AdrBuf[2] = ((Address >> 24) & 0xFF);
 529                         AdrBuf[3] = ((Address >> 7) & 0xFF);
 530                         AdrBuf[2] |= Flags;
 531                         AdrLength = 4;
 532                         if (Chunk == state->m_ChunkSize)
 533                                 Chunk -= 2;
 534                 } else {
 535                         AdrBuf[0] = ((Address << 1) & 0xFF);
 536                         AdrBuf[1] = (((Address >> 16) & 0x0F) |
 537                                      ((Address >> 18) & 0xF0));
 538                         AdrLength = 2;
 539                 }
 540                 memcpy(&state->Chunk[AdrLength], pBlock, Chunk);
 541                 dprintk(2, "(0x%08x, 0x%02x)\n", Address, Flags);
 542                 if (debug > 1) {
 543                         int i;
 544                         if (pBlock)
 545                                 for (i = 0; i < Chunk; i++)
 546                                         printk(KERN_CONT " %02x", pBlock[i]);
 547                         printk(KERN_CONT "\n");
 548                 }
 549                 status = i2c_write(state->i2c, state->demod_address,
 550                                    &state->Chunk[0], Chunk + AdrLength);
 551                 if (status < 0) {
 552                         printk(KERN_ERR "drxk: %s: i2c write error at addr 0x%02x\n",
 553                                __func__, Address);
 554                         break;
 555                 }
 556                 pBlock += Chunk;
 557                 Address += (Chunk >> 1);
 558                 BlkSize -= Chunk;
 559         }
 560         return status;
 561 }
 562
 563 #ifndef DRXK_MAX_RETRIES_POWERUP
 564 #define DRXK_MAX_RETRIES_POWERUP 20
 565 #endif
 566
 567 int PowerUpDevice(struct drxk_state *state)
 568 {
 569         int status;
 570         u8 data = 0;
 571         u16 retryCount = 0;
 572
 573         dprintk(1, "\n");
 574
 575         status = i2c_read1(state->i2c, state->demod_address, &data);
 576         if (status < 0) {
 577                 do {
 578                         data = 0;
 579                         status = i2c_write(state->i2c, state->demod_address,
 580                                            &data, 1);
 581                         msleep(10);
 582                         retryCount++;
 583                         if (status < 0)
 584                                 continue;
 585                         status = i2c_read1(state->i2c, state->demod_address,
 586                                            &data);
 587                 } while (status < 0 &&
 588                          (retryCount < DRXK_MAX_RETRIES_POWERUP));
 589                 if (status < 0 && retryCount >= DRXK_MAX_RETRIES_POWERUP)
 590                         goto error;
 591         }
 592
 593         /* Make sure all clk domains are active */
 594         status = write16(state, SIO_CC_PWD_MODE__A, SIO_CC_PWD_MODE_LEVEL_NONE);
 595         if (status < 0)
 596                 goto error;
 597         status = write16(state, SIO_CC_UPDATE__A, SIO_CC_UPDATE_KEY);
 598         if (status < 0)
 599                 goto error;
 600         /* Enable pll lock tests */
 601         status = write16(state, SIO_CC_PLL_LOCK__A, 1);
 602         if (status < 0)
 603                 goto error;
 604
 605         state->m_currentPowerMode = DRX_POWER_UP;
 606
 607 error:
 608         if (status < 0)
 609                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
 610
 611         return status;
 612 }
 613
 614
 615 static int init_state(struct drxk_state *state)
 616 {
 617         /*
 618          * FIXME: most (all?) of the values bellow should be moved into
 619          * struct drxk_config, as they are probably board-specific
 620          */
 621         u32 ulVSBIfAgcMode = DRXK_AGC_CTRL_AUTO;
 622         u32 ulVSBIfAgcOutputLevel = 0;
 623         u32 ulVSBIfAgcMinLevel = 0;
 624         u32 ulVSBIfAgcMaxLevel = 0x7FFF;
 625         u32 ulVSBIfAgcSpeed = 3;
 626
 627         u32 ulVSBRfAgcMode = DRXK_AGC_CTRL_AUTO;
 628         u32 ulVSBRfAgcOutputLevel = 0;
 629         u32 ulVSBRfAgcMinLevel = 0;
 630         u32 ulVSBRfAgcMaxLevel = 0x7FFF;
 631         u32 ulVSBRfAgcSpeed = 3;
 632         u32 ulVSBRfAgcTop = 9500;
 633         u32 ulVSBRfAgcCutOffCurrent = 4000;
 634
 635         u32 ulATVIfAgcMode = DRXK_AGC_CTRL_AUTO;
 636         u32 ulATVIfAgcOutputLevel = 0;
 637         u32 ulATVIfAgcMinLevel = 0;
 638         u32 ulATVIfAgcMaxLevel = 0;
 639         u32 ulATVIfAgcSpeed = 3;
 640
 641         u32 ulATVRfAgcMode = DRXK_AGC_CTRL_OFF;
 642         u32 ulATVRfAgcOutputLevel = 0;
 643         u32 ulATVRfAgcMinLevel = 0;
 644         u32 ulATVRfAgcMaxLevel = 0;
 645         u32 ulATVRfAgcTop = 9500;
 646         u32 ulATVRfAgcCutOffCurrent = 4000;
 647         u32 ulATVRfAgcSpeed = 3;
 648
 649         u32 ulQual83 = DEFAULT_MER_83;
 650         u32 ulQual93 = DEFAULT_MER_93;
 651
 652         u32 ulDVBTStaticTSClock = 1;
 653         u32 ulDVBCStaticTSClock = 1;
 654
 655         u32 ulMpegLockTimeOut = DEFAULT_DRXK_MPEG_LOCK_TIMEOUT;
 656         u32 ulDemodLockTimeOut = DEFAULT_DRXK_DEMOD_LOCK_TIMEOUT;
 657
 658         /* io_pad_cfg register (8 bit reg.) MSB bit is 1 (default value) */
 659         /* io_pad_cfg_mode output mode is drive always */
 660         /* io_pad_cfg_drive is set to power 2 (23 mA) */
 661         u32 ulGPIOCfg = 0x0113;
 662         u32 ulInvertTSClock = 0;
 663         u32 ulTSDataStrength = DRXK_MPEG_SERIAL_OUTPUT_PIN_DRIVE_STRENGTH;
 664         u32 ulTSClockkStrength = DRXK_MPEG_OUTPUT_CLK_DRIVE_STRENGTH;
 665         u32 ulDVBTBitrate = 50000000;
 666         u32 ulDVBCBitrate = DRXK_QAM_SYMBOLRATE_MAX * 8;
 667
 668         u32 ulInsertRSByte = 0;
 669
 670         u32 ulRfMirror = 1;
 671         u32 ulPowerDown = 0;
 672
 673         dprintk(1, "\n");
 674
 675         state->m_hasLNA = false;
 676         state->m_hasDVBT = false;
 677         state->m_hasDVBC = false;
 678         state->m_hasATV = false;
 679         state->m_hasOOB = false;
 680         state->m_hasAudio = false;
 681
 682         if (!state->m_ChunkSize)
 683                 state->m_ChunkSize = 124;
 684
 685         state->m_oscClockFreq = 0;
 686         state->m_smartAntInverted = false;
 687         state->m_bPDownOpenBridge = false;
 688
 689         /* real system clock frequency in kHz */
 690         state->m_sysClockFreq = 151875;
 691         /* Timing div, 250ns/Psys */
 692         /* Timing div, = (delay (nano seconds) * sysclk (kHz))/ 1000 */
 693         state->m_HICfgTimingDiv = ((state->m_sysClockFreq / 1000) *
 694                                    HI_I2C_DELAY) / 1000;
 695         /* Clipping */
 696         if (state->m_HICfgTimingDiv > SIO_HI_RA_RAM_PAR_2_CFG_DIV__M)
 697                 state->m_HICfgTimingDiv = SIO_HI_RA_RAM_PAR_2_CFG_DIV__M;
 698         state->m_HICfgWakeUpKey = (state->demod_address << 1);
 699         /* port/bridge/power down ctrl */
 700         state->m_HICfgCtrl = SIO_HI_RA_RAM_PAR_5_CFG_SLV0_SLAVE;
 701
 702         state->m_bPowerDown = (ulPowerDown != 0);
 703
 704         state->m_DRXK_A1_PATCH_CODE = false;
 705         state->m_DRXK_A1_ROM_CODE = false;
 706         state->m_DRXK_A2_ROM_CODE = false;
 707         state->m_DRXK_A3_ROM_CODE = false;
 708         state->m_DRXK_A2_PATCH_CODE = false;
 709         state->m_DRXK_A3_PATCH_CODE = false;
 710
 711         /* Init AGC and PGA parameters */
 712         /* VSB IF */
 713         state->m_vsbIfAgcCfg.ctrlMode = (ulVSBIfAgcMode);
 714         state->m_vsbIfAgcCfg.outputLevel = (ulVSBIfAgcOutputLevel);
 715         state->m_vsbIfAgcCfg.minOutputLevel = (ulVSBIfAgcMinLevel);
 716         state->m_vsbIfAgcCfg.maxOutputLevel = (ulVSBIfAgcMaxLevel);
 717         state->m_vsbIfAgcCfg.speed = (ulVSBIfAgcSpeed);
 718         state->m_vsbPgaCfg = 140;
 719
 720         /* VSB RF */
 721         state->m_vsbRfAgcCfg.ctrlMode = (ulVSBRfAgcMode);
 722         state->m_vsbRfAgcCfg.outputLevel = (ulVSBRfAgcOutputLevel);
 723         state->m_vsbRfAgcCfg.minOutputLevel = (ulVSBRfAgcMinLevel);
 724         state->m_vsbRfAgcCfg.maxOutputLevel = (ulVSBRfAgcMaxLevel);
 725         state->m_vsbRfAgcCfg.speed = (ulVSBRfAgcSpeed);
 726         state->m_vsbRfAgcCfg.top = (ulVSBRfAgcTop);
 727         state->m_vsbRfAgcCfg.cutOffCurrent = (ulVSBRfAgcCutOffCurrent);
 728         state->m_vsbPreSawCfg.reference = 0x07;
 729         state->m_vsbPreSawCfg.usePreSaw = true;
 730
 731         state->m_Quality83percent = DEFAULT_MER_83;
 732         state->m_Quality93percent = DEFAULT_MER_93;
 733         if (ulQual93 <= 500 && ulQual83 < ulQual93) {
 734                 state->m_Quality83percent = ulQual83;
 735                 state->m_Quality93percent = ulQual93;
 736         }
 737
 738         /* ATV IF */
 739         state->m_atvIfAgcCfg.ctrlMode = (ulATVIfAgcMode);
 740         state->m_atvIfAgcCfg.outputLevel = (ulATVIfAgcOutputLevel);
 741         state->m_atvIfAgcCfg.minOutputLevel = (ulATVIfAgcMinLevel);
 742         state->m_atvIfAgcCfg.maxOutputLevel = (ulATVIfAgcMaxLevel);
 743         state->m_atvIfAgcCfg.speed = (ulATVIfAgcSpeed);
 744
 745         /* ATV RF */
 746         state->m_atvRfAgcCfg.ctrlMode = (ulATVRfAgcMode);
 747         state->m_atvRfAgcCfg.outputLevel = (ulATVRfAgcOutputLevel);
 748         state->m_atvRfAgcCfg.minOutputLevel = (ulATVRfAgcMinLevel);
 749         state->m_atvRfAgcCfg.maxOutputLevel = (ulATVRfAgcMaxLevel);
 750         state->m_atvRfAgcCfg.speed = (ulATVRfAgcSpeed);
 751         state->m_atvRfAgcCfg.top = (ulATVRfAgcTop);
 752         state->m_atvRfAgcCfg.cutOffCurrent = (ulATVRfAgcCutOffCurrent);
 753         state->m_atvPreSawCfg.reference = 0x04;
 754         state->m_atvPreSawCfg.usePreSaw = true;
 755
 756
 757         /* DVBT RF */
 758         state->m_dvbtRfAgcCfg.ctrlMode = DRXK_AGC_CTRL_OFF;
 759         state->m_dvbtRfAgcCfg.outputLevel = 0;
 760         state->m_dvbtRfAgcCfg.minOutputLevel = 0;
 761         state->m_dvbtRfAgcCfg.maxOutputLevel = 0xFFFF;
 762         state->m_dvbtRfAgcCfg.top = 0x2100;
 763         state->m_dvbtRfAgcCfg.cutOffCurrent = 4000;
 764         state->m_dvbtRfAgcCfg.speed = 1;
 765
 766
 767         /* DVBT IF */
 768         state->m_dvbtIfAgcCfg.ctrlMode = DRXK_AGC_CTRL_AUTO;
 769         state->m_dvbtIfAgcCfg.outputLevel = 0;
 770         state->m_dvbtIfAgcCfg.minOutputLevel = 0;
 771         state->m_dvbtIfAgcCfg.maxOutputLevel = 9000;
 772         state->m_dvbtIfAgcCfg.top = 13424;
 773         state->m_dvbtIfAgcCfg.cutOffCurrent = 0;
 774         state->m_dvbtIfAgcCfg.speed = 3;
 775         state->m_dvbtIfAgcCfg.FastClipCtrlDelay = 30;
 776         state->m_dvbtIfAgcCfg.IngainTgtMax = 30000;
 777         /* state->m_dvbtPgaCfg = 140; */
 778
 779         state->m_dvbtPreSawCfg.reference = 4;
 780         state->m_dvbtPreSawCfg.usePreSaw = false;
 781
 782         /* QAM RF */
 783         state->m_qamRfAgcCfg.ctrlMode = DRXK_AGC_CTRL_OFF;
 784         state->m_qamRfAgcCfg.outputLevel = 0;
 785         state->m_qamRfAgcCfg.minOutputLevel = 6023;
 786         state->m_qamRfAgcCfg.maxOutputLevel = 27000;
 787         state->m_qamRfAgcCfg.top = 0x2380;
 788         state->m_qamRfAgcCfg.cutOffCurrent = 4000;
 789         state->m_qamRfAgcCfg.speed = 3;
 790
 791         /* QAM IF */
 792         state->m_qamIfAgcCfg.ctrlMode = DRXK_AGC_CTRL_AUTO;
 793         state->m_qamIfAgcCfg.outputLevel = 0;
 794         state->m_qamIfAgcCfg.minOutputLevel = 0;
 795         state->m_qamIfAgcCfg.maxOutputLevel = 9000;
 796         state->m_qamIfAgcCfg.top = 0x0511;
 797         state->m_qamIfAgcCfg.cutOffCurrent = 0;
 798         state->m_qamIfAgcCfg.speed = 3;
 799         state->m_qamIfAgcCfg.IngainTgtMax = 5119;
 800         state->m_qamIfAgcCfg.FastClipCtrlDelay = 50;
 801
 802         state->m_qamPgaCfg = 140;
 803         state->m_qamPreSawCfg.reference = 4;
 804         state->m_qamPreSawCfg.usePreSaw = false;
 805
 806         state->m_OperationMode = OM_NONE;
 807         state->m_DrxkState = DRXK_UNINITIALIZED;
 808
 809         /* MPEG output configuration */
 810         state->m_enableMPEGOutput = true;       /* If TRUE; enable MPEG ouput */
 811         state->m_insertRSByte = false;  /* If TRUE; insert RS byte */
 812         state->m_invertDATA = false;    /* If TRUE; invert DATA signals */
 813         state->m_invertERR = false;     /* If TRUE; invert ERR signal */
 814         state->m_invertSTR = false;     /* If TRUE; invert STR signals */
 815         state->m_invertVAL = false;     /* If TRUE; invert VAL signals */
 816         state->m_invertCLK = (ulInvertTSClock != 0);    /* If TRUE; invert CLK signals */
 817         state->m_DVBTStaticCLK = (ulDVBTStaticTSClock != 0);
 818         state->m_DVBCStaticCLK = (ulDVBCStaticTSClock != 0);
 819         /* If TRUE; static MPEG clockrate will be used;
 820            otherwise clockrate will adapt to the bitrate of the TS */
 821
 822         state->m_DVBTBitrate = ulDVBTBitrate;
 823         state->m_DVBCBitrate = ulDVBCBitrate;
 824
 825         state->m_TSDataStrength = (ulTSDataStrength & 0x07);
 826         state->m_TSClockkStrength = (ulTSClockkStrength & 0x07);
 827
 828         /* Maximum bitrate in b/s in case static clockrate is selected */
 829         state->m_mpegTsStaticBitrate = 19392658;
 830         state->m_disableTEIhandling = false;
 831
 832         if (ulInsertRSByte)
 833                 state->m_insertRSByte = true;
 834
 835         state->m_MpegLockTimeOut = DEFAULT_DRXK_MPEG_LOCK_TIMEOUT;
 836         if (ulMpegLockTimeOut < 10000)
 837                 state->m_MpegLockTimeOut = ulMpegLockTimeOut;
 838         state->m_DemodLockTimeOut = DEFAULT_DRXK_DEMOD_LOCK_TIMEOUT;
 839         if (ulDemodLockTimeOut < 10000)
 840                 state->m_DemodLockTimeOut = ulDemodLockTimeOut;
 841
 842         /* QAM defaults */
 843         state->m_Constellation = DRX_CONSTELLATION_AUTO;
 844         state->m_qamInterleaveMode = DRXK_QAM_I12_J17;
 845         state->m_fecRsPlen = 204 * 8;   /* fecRsPlen  annex A */
 846         state->m_fecRsPrescale = 1;
 847
 848         state->m_sqiSpeed = DRXK_DVBT_SQI_SPEED_MEDIUM;
 849         state->m_agcFastClipCtrlDelay = 0;
 850
 851         state->m_GPIOCfg = (ulGPIOCfg);
 852
 853         state->m_bPowerDown = false;
 854         state->m_currentPowerMode = DRX_POWER_DOWN;
 855
 856         state->m_rfmirror = (ulRfMirror == 0);
 857         state->m_IfAgcPol = false;
 858         return 0;
 859 }
 860
 861 static int DRXX_Open(struct drxk_state *state)
 862 {
 863         int status = 0;
 864         u32 jtag = 0;
 865         u16 bid = 0;
 866         u16 key = 0;
 867
 868         dprintk(1, "\n");
 869         /* stop lock indicator process */
 870         status = write16(state, SCU_RAM_GPIO__A, SCU_RAM_GPIO_HW_LOCK_IND_DISABLE);
 871         if (status < 0)
 872                 goto error;
 873         /* Check device id */
 874         status = read16(state, SIO_TOP_COMM_KEY__A, &key);
 875         if (status < 0)
 876                 goto error;
 877         status = write16(state, SIO_TOP_COMM_KEY__A, SIO_TOP_COMM_KEY_KEY);
 878         if (status < 0)
 879                 goto error;
 880         status = read32(state, SIO_TOP_JTAGID_LO__A, &jtag);
 881         if (status < 0)
 882                 goto error;
 883         status = read16(state, SIO_PDR_UIO_IN_HI__A, &bid);
 884         if (status < 0)
 885                 goto error;
 886         status = write16(state, SIO_TOP_COMM_KEY__A, key);
 887 error:
 888         if (status < 0)
 889                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
 890         return status;
 891 }
 892
 893 static int GetDeviceCapabilities(struct drxk_state *state)
 894 {
 895         u16 sioPdrOhwCfg = 0;
 896         u32 sioTopJtagidLo = 0;
 897         int status;
 898         const char *spin = "";
 899
 900         dprintk(1, "\n");
 901
 902         /* driver 0.9.0 */
 903         /* stop lock indicator process */
 904         status = write16(state, SCU_RAM_GPIO__A, SCU_RAM_GPIO_HW_LOCK_IND_DISABLE);
 905         if (status < 0)
 906                 goto error;
 907         status = write16(state, SIO_TOP_COMM_KEY__A, 0xFABA);
 908         if (status < 0)
 909                 goto error;
 910         status = read16(state, SIO_PDR_OHW_CFG__A, &sioPdrOhwCfg);
 911         if (status < 0)
 912                 goto error;
 913         status = write16(state, SIO_TOP_COMM_KEY__A, 0x0000);
 914         if (status < 0)
 915                 goto error;
 916
 917         switch ((sioPdrOhwCfg & SIO_PDR_OHW_CFG_FREF_SEL__M)) {
 918         case 0:
 919                 /* ignore (bypass ?) */
 920                 break;
 921         case 1:
 922                 /* 27 MHz */
 923                 state->m_oscClockFreq = 27000;
 924                 break;
 925         case 2:
 926                 /* 20.25 MHz */
 927                 state->m_oscClockFreq = 20250;
 928                 break;
 929         case 3:
 930                 /* 4 MHz */
 931                 state->m_oscClockFreq = 20250;
 932                 break;
 933         default:
 934                 printk(KERN_ERR "drxk: Clock Frequency is unkonwn\n");
 935                 return -EINVAL;
 936         }
 937         /*
 938                 Determine device capabilities
 939                 Based on pinning v14
 940                 */
 941         status = read32(state, SIO_TOP_JTAGID_LO__A, &sioTopJtagidLo);
 942         if (status < 0)
 943                 goto error;
 944
 945 printk(KERN_ERR "drxk: status = 0x%08x\n", sioTopJtagidLo);
 946
 947         /* driver 0.9.0 */
 948         switch ((sioTopJtagidLo >> 29) & 0xF) {
 949         case 0:
 950                 state->m_deviceSpin = DRXK_SPIN_A1;
 951                 spin = "A1";
 952                 break;
 953         case 2:
 954                 state->m_deviceSpin = DRXK_SPIN_A2;
 955                 spin = "A2";
 956                 break;
 957         case 3:
 958                 state->m_deviceSpin = DRXK_SPIN_A3;
 959                 spin = "A3";
 960                 break;
 961         default:
 962                 state->m_deviceSpin = DRXK_SPIN_UNKNOWN;
 963                 status = -EINVAL;
 964                 printk(KERN_ERR "drxk: Spin %d unknown\n",
 965                        (sioTopJtagidLo >> 29) & 0xF);
 966                 goto error2;
 967         }
 968         switch ((sioTopJtagidLo >> 12) & 0xFF) {
 969         case 0x13:
 970                 /* typeId = DRX3913K_TYPE_ID */
 971                 state->m_hasLNA = false;
 972                 state->m_hasOOB = false;
 973                 state->m_hasATV = false;
 974                 state->m_hasAudio = false;
 975                 state->m_hasDVBT = true;
 976                 state->m_hasDVBC = true;
 977                 state->m_hasSAWSW = true;
 978                 state->m_hasGPIO2 = false;
 979                 state->m_hasGPIO1 = false;
 980                 state->m_hasIRQN = false;
 981                 break;
 982         case 0x15:
 983                 /* typeId = DRX3915K_TYPE_ID */
 984                 state->m_hasLNA = false;
 985                 state->m_hasOOB = false;
 986                 state->m_hasATV = true;
 987                 state->m_hasAudio = false;
 988                 state->m_hasDVBT = true;
 989                 state->m_hasDVBC = false;
 990                 state->m_hasSAWSW = true;
 991                 state->m_hasGPIO2 = true;
 992                 state->m_hasGPIO1 = true;
 993                 state->m_hasIRQN = false;
 994                 break;
 995         case 0x16:
 996                 /* typeId = DRX3916K_TYPE_ID */
 997                 state->m_hasLNA = false;
 998                 state->m_hasOOB = false;
 999                 state->m_hasATV = true;
1000                 state->m_hasAudio = false;
1001                 state->m_hasDVBT = true;
1002                 state->m_hasDVBC = false;
1003                 state->m_hasSAWSW = true;
1004                 state->m_hasGPIO2 = true;
1005                 state->m_hasGPIO1 = true;
1006                 state->m_hasIRQN = false;
1007                 break;
1008         case 0x18:
1009                 /* typeId = DRX3918K_TYPE_ID */
1010                 state->m_hasLNA = false;
1011                 state->m_hasOOB = false;
1012                 state->m_hasATV = true;
1013                 state->m_hasAudio = true;
1014                 state->m_hasDVBT = true;
1015                 state->m_hasDVBC = false;
1016                 state->m_hasSAWSW = true;
1017                 state->m_hasGPIO2 = true;
1018                 state->m_hasGPIO1 = true;
1019                 state->m_hasIRQN = false;
1020                 break;
1021         case 0x21:
1022                 /* typeId = DRX3921K_TYPE_ID */
1023                 state->m_hasLNA = false;
1024                 state->m_hasOOB = false;
1025                 state->m_hasATV = true;
1026                 state->m_hasAudio = true;
1027                 state->m_hasDVBT = true;
1028                 state->m_hasDVBC = true;
1029                 state->m_hasSAWSW = true;
1030                 state->m_hasGPIO2 = true;
1031                 state->m_hasGPIO1 = true;
1032                 state->m_hasIRQN = false;
1033                 break;
1034         case 0x23:
1035                 /* typeId = DRX3923K_TYPE_ID */
1036                 state->m_hasLNA = false;
1037                 state->m_hasOOB = false;
1038                 state->m_hasATV = true;
1039                 state->m_hasAudio = true;
1040                 state->m_hasDVBT = true;
1041                 state->m_hasDVBC = true;
1042                 state->m_hasSAWSW = true;
1043                 state->m_hasGPIO2 = true;
1044                 state->m_hasGPIO1 = true;
1045                 state->m_hasIRQN = false;
1046                 break;
1047         case 0x25:
1048                 /* typeId = DRX3925K_TYPE_ID */
1049                 state->m_hasLNA = false;
1050                 state->m_hasOOB = false;
1051                 state->m_hasATV = true;
1052                 state->m_hasAudio = true;
1053                 state->m_hasDVBT = true;
1054                 state->m_hasDVBC = true;
1055                 state->m_hasSAWSW = true;
1056                 state->m_hasGPIO2 = true;
1057                 state->m_hasGPIO1 = true;
1058                 state->m_hasIRQN = false;
1059                 break;
1060         case 0x26:
1061                 /* typeId = DRX3926K_TYPE_ID */
1062                 state->m_hasLNA = false;
1063                 state->m_hasOOB = false;
1064                 state->m_hasATV = true;
1065                 state->m_hasAudio = false;
1066                 state->m_hasDVBT = true;
1067                 state->m_hasDVBC = true;
1068                 state->m_hasSAWSW = true;
1069                 state->m_hasGPIO2 = true;
1070                 state->m_hasGPIO1 = true;
1071                 state->m_hasIRQN = false;
1072                 break;
1073         default:
1074                 printk(KERN_ERR "drxk: DeviceID 0x%02x not supported\n",
1075                         ((sioTopJtagidLo >> 12) & 0xFF));
1076                 status = -EINVAL;
1077                 goto error2;
1078         }
1079
1080         printk(KERN_INFO
1081                "drxk: detected a drx-39%02xk, spin %s, xtal %d.%03d MHz\n",
1082                ((sioTopJtagidLo >> 12) & 0xFF), spin,
1083                state->m_oscClockFreq / 1000,
1084                state->m_oscClockFreq % 1000);
1085
1086 error:
1087         if (status < 0)
1088                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1089
1090 error2:
1091         return status;
1092 }
1093
1094 static int HI_Command(struct drxk_state *state, u16 cmd, u16 *pResult)
1095 {
1096         int status;
1097         bool powerdown_cmd;
1098
1099         dprintk(1, "\n");
1100
1101         /* Write command */
1102         status = write16(state, SIO_HI_RA_RAM_CMD__A, cmd);
1103         if (status < 0)
1104                 goto error;
1105         if (cmd == SIO_HI_RA_RAM_CMD_RESET)
1106                 msleep(1);
1107
1108         powerdown_cmd =
1109             (bool) ((cmd == SIO_HI_RA_RAM_CMD_CONFIG) &&
1110                     ((state->m_HICfgCtrl) &
1111                      SIO_HI_RA_RAM_PAR_5_CFG_SLEEP__M) ==
1112                     SIO_HI_RA_RAM_PAR_5_CFG_SLEEP_ZZZ);
1113         if (powerdown_cmd == false) {
1114                 /* Wait until command rdy */
1115                 u32 retryCount = 0;
1116                 u16 waitCmd;
1117
1118                 do {
1119                         msleep(1);
1120                         retryCount += 1;
1121                         status = read16(state, SIO_HI_RA_RAM_CMD__A,
1122                                           &waitCmd);
1123                 } while ((status < 0) && (retryCount < DRXK_MAX_RETRIES)
1124                          && (waitCmd != 0));
1125                 if (status < 0)
1126                         goto error;
1127                 status = read16(state, SIO_HI_RA_RAM_RES__A, pResult);
1128         }
1129 error:
1130         if (status < 0)
1131                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1132
1133         return status;
1134 }
1135
1136 static int HI_CfgCommand(struct drxk_state *state)
1137 {
1138         int status;
1139
1140         dprintk(1, "\n");
1141
1142         mutex_lock(&state->mutex);
1143
1144         status = write16(state, SIO_HI_RA_RAM_PAR_6__A, state->m_HICfgTimeout);
1145         if (status < 0)
1146                 goto error;
1147         status = write16(state, SIO_HI_RA_RAM_PAR_5__A, state->m_HICfgCtrl);
1148         if (status < 0)
1149                 goto error;
1150         status = write16(state, SIO_HI_RA_RAM_PAR_4__A, state->m_HICfgWakeUpKey);
1151         if (status < 0)
1152                 goto error;
1153         status = write16(state, SIO_HI_RA_RAM_PAR_3__A, state->m_HICfgBridgeDelay);
1154         if (status < 0)
1155                 goto error;
1156         status = write16(state, SIO_HI_RA_RAM_PAR_2__A, state->m_HICfgTimingDiv);
1157         if (status < 0)
1158                 goto error;
1159         status = write16(state, SIO_HI_RA_RAM_PAR_1__A, SIO_HI_RA_RAM_PAR_1_PAR1_SEC_KEY);
1160         if (status < 0)
1161                 goto error;
1162         status = HI_Command(state, SIO_HI_RA_RAM_CMD_CONFIG, 0);
1163         if (status < 0)
1164                 goto error;
1165
1166         state->m_HICfgCtrl &= ~SIO_HI_RA_RAM_PAR_5_CFG_SLEEP_ZZZ;
1167 error:
1168         mutex_unlock(&state->mutex);
1169         if (status < 0)
1170                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1171         return status;
1172 }
1173
1174 static int InitHI(struct drxk_state *state)
1175 {
1176         dprintk(1, "\n");
1177
1178         state->m_HICfgWakeUpKey = (state->demod_address << 1);
1179         state->m_HICfgTimeout = 0x96FF;
1180         /* port/bridge/power down ctrl */
1181         state->m_HICfgCtrl = SIO_HI_RA_RAM_PAR_5_CFG_SLV0_SLAVE;
1182
1183         return HI_CfgCommand(state);
1184 }
1185
1186 static int MPEGTSConfigurePins(struct drxk_state *state, bool mpegEnable)
1187 {
1188         int status = -1;
1189         u16 sioPdrMclkCfg = 0;
1190         u16 sioPdrMdxCfg = 0;
1191
1192         dprintk(1, ": mpeg %s, %s mode\n",
1193                 mpegEnable ? "enable" : "disable",
1194                 state->m_enableParallel ? "parallel" : "serial");
1195
1196         /* stop lock indicator process */
1197         status = write16(state, SCU_RAM_GPIO__A, SCU_RAM_GPIO_HW_LOCK_IND_DISABLE);
1198         if (status < 0)
1199                 goto error;
1200
1201         /*  MPEG TS pad configuration */
1202         status = write16(state, SIO_TOP_COMM_KEY__A, 0xFABA);
1203         if (status < 0)
1204                 goto error;
1205
1206         if (mpegEnable == false) {
1207                 /*  Set MPEG TS pads to inputmode */
1208                 status = write16(state, SIO_PDR_MSTRT_CFG__A, 0x0000);
1209                 if (status < 0)
1210                         goto error;
1211                 status = write16(state, SIO_PDR_MERR_CFG__A, 0x0000);
1212                 if (status < 0)
1213                         goto error;
1214                 status = write16(state, SIO_PDR_MCLK_CFG__A, 0x0000);
1215                 if (status < 0)
1216                         goto error;
1217                 status = write16(state, SIO_PDR_MVAL_CFG__A, 0x0000);
1218                 if (status < 0)
1219                         goto error;
1220                 status = write16(state, SIO_PDR_MD0_CFG__A, 0x0000);
1221                 if (status < 0)
1222                         goto error;
1223                 status = write16(state, SIO_PDR_MD1_CFG__A, 0x0000);
1224                 if (status < 0)
1225                         goto error;
1226                 status = write16(state, SIO_PDR_MD2_CFG__A, 0x0000);
1227                 if (status < 0)
1228                         goto error;
1229                 status = write16(state, SIO_PDR_MD3_CFG__A, 0x0000);
1230                 if (status < 0)
1231                         goto error;
1232                 status = write16(state, SIO_PDR_MD4_CFG__A, 0x0000);
1233                 if (status < 0)
1234                         goto error;
1235                 status = write16(state, SIO_PDR_MD5_CFG__A, 0x0000);
1236                 if (status < 0)
1237                         goto error;
1238                 status = write16(state, SIO_PDR_MD6_CFG__A, 0x0000);
1239                 if (status < 0)
1240                         goto error;
1241                 status = write16(state, SIO_PDR_MD7_CFG__A, 0x0000);
1242                 if (status < 0)
1243                         goto error;
1244         } else {
1245                 /* Enable MPEG output */
1246                 sioPdrMdxCfg =
1247                         ((state->m_TSDataStrength <<
1248                         SIO_PDR_MD0_CFG_DRIVE__B) | 0x0003);
1249                 sioPdrMclkCfg = ((state->m_TSClockkStrength <<
1250                                         SIO_PDR_MCLK_CFG_DRIVE__B) |
1251                                         0x0003);
1252
1253                 status = write16(state, SIO_PDR_MSTRT_CFG__A, sioPdrMdxCfg);
1254                 if (status < 0)
1255                         goto error;
1256                 status = write16(state, SIO_PDR_MERR_CFG__A, 0x0000);   /* Disable */
1257                 if (status < 0)
1258                         goto error;
1259                 status = write16(state, SIO_PDR_MVAL_CFG__A, 0x0000);   /* Disable */
1260                 if (status < 0)
1261                         goto error;
1262                 if (state->m_enableParallel == true) {
1263                         /* paralel -> enable MD1 to MD7 */
1264                         status = write16(state, SIO_PDR_MD1_CFG__A, sioPdrMdxCfg);
1265                         if (status < 0)
1266                                 goto error;
1267                         status = write16(state, SIO_PDR_MD2_CFG__A, sioPdrMdxCfg);
1268                         if (status < 0)
1269                                 goto error;
1270                         status = write16(state, SIO_PDR_MD3_CFG__A, sioPdrMdxCfg);
1271                         if (status < 0)
1272                                 goto error;
1273                         status = write16(state, SIO_PDR_MD4_CFG__A, sioPdrMdxCfg);
1274                         if (status < 0)
1275                                 goto error;
1276                         status = write16(state, SIO_PDR_MD5_CFG__A, sioPdrMdxCfg);
1277                         if (status < 0)
1278                                 goto error;
1279                         status = write16(state, SIO_PDR_MD6_CFG__A, sioPdrMdxCfg);
1280                         if (status < 0)
1281                                 goto error;
1282                         status = write16(state, SIO_PDR_MD7_CFG__A, sioPdrMdxCfg);
1283                         if (status < 0)
1284                                 goto error;
1285                 } else {
1286                         sioPdrMdxCfg = ((state->m_TSDataStrength <<
1287                                                 SIO_PDR_MD0_CFG_DRIVE__B)
1288                                         | 0x0003);
1289                         /* serial -> disable MD1 to MD7 */
1290                         status = write16(state, SIO_PDR_MD1_CFG__A, 0x0000);
1291                         if (status < 0)
1292                                 goto error;
1293                         status = write16(state, SIO_PDR_MD2_CFG__A, 0x0000);
1294                         if (status < 0)
1295                                 goto error;
1296                         status = write16(state, SIO_PDR_MD3_CFG__A, 0x0000);
1297                         if (status < 0)
1298                                 goto error;
1299                         status = write16(state, SIO_PDR_MD4_CFG__A, 0x0000);
1300                         if (status < 0)
1301                                 goto error;
1302                         status = write16(state, SIO_PDR_MD5_CFG__A, 0x0000);
1303                         if (status < 0)
1304                                 goto error;
1305                         status = write16(state, SIO_PDR_MD6_CFG__A, 0x0000);
1306                         if (status < 0)
1307                                 goto error;
1308                         status = write16(state, SIO_PDR_MD7_CFG__A, 0x0000);
1309                         if (status < 0)
1310                                 goto error;
1311                 }
1312                 status = write16(state, SIO_PDR_MCLK_CFG__A, sioPdrMclkCfg);
1313                 if (status < 0)
1314                         goto error;
1315                 status = write16(state, SIO_PDR_MD0_CFG__A, sioPdrMdxCfg);
1316                 if (status < 0)
1317                         goto error;
1318         }
1319         /*  Enable MB output over MPEG pads and ctl input */
1320         status = write16(state, SIO_PDR_MON_CFG__A, 0x0000);
1321         if (status < 0)
1322                 goto error;
1323         /*  Write nomagic word to enable pdr reg write */
1324         status = write16(state, SIO_TOP_COMM_KEY__A, 0x0000);
1325 error:
1326         if (status < 0)
1327                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1328         return status;
1329 }
1330
1331 static int MPEGTSDisable(struct drxk_state *state)
1332 {
1333         dprintk(1, "\n");
1334
1335         return MPEGTSConfigurePins(state, false);
1336 }
1337
1338 static int BLChainCmd(struct drxk_state *state,
1339                       u16 romOffset, u16 nrOfElements, u32 timeOut)
1340 {
1341         u16 blStatus = 0;
1342         int status;
1343         unsigned long end;
1344
1345         dprintk(1, "\n");
1346         mutex_lock(&state->mutex);
1347         status = write16(state, SIO_BL_MODE__A, SIO_BL_MODE_CHAIN);
1348         if (status < 0)
1349                 goto error;
1350         status = write16(state, SIO_BL_CHAIN_ADDR__A, romOffset);
1351         if (status < 0)
1352                 goto error;
1353         status = write16(state, SIO_BL_CHAIN_LEN__A, nrOfElements);
1354         if (status < 0)
1355                 goto error;
1356         status = write16(state, SIO_BL_ENABLE__A, SIO_BL_ENABLE_ON);
1357         if (status < 0)
1358                 goto error;
1359
1360         end = jiffies + msecs_to_jiffies(timeOut);
1361         do {
1362                 msleep(1);
1363                 status = read16(state, SIO_BL_STATUS__A, &blStatus);
1364                 if (status < 0)
1365                         goto error;
1366         } while ((blStatus == 0x1) &&
1367                         ((time_is_after_jiffies(end))));
1368
1369         if (blStatus == 0x1) {
1370                 printk(KERN_ERR "drxk: SIO not ready\n");
1371                 status = -EINVAL;
1372                 goto error2;
1373         }
1374 error:
1375         if (status < 0)
1376                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1377 error2:
1378         mutex_unlock(&state->mutex);
1379         return status;
1380 }
1381
1382
1383 static int DownloadMicrocode(struct drxk_state *state,
1384                              const u8 pMCImage[], u32 Length)
1385 {
1386         const u8 *pSrc = pMCImage;
1387         u16 Flags;
1388         u16 Drain;
1389         u32 Address;
1390         u16 nBlocks;
1391         u16 BlockSize;
1392         u16 BlockCRC;
1393         u32 offset = 0;
1394         u32 i;
1395         int status = 0;
1396
1397         dprintk(1, "\n");
1398
1399         /* down the drain (we don care about MAGIC_WORD) */
1400         Drain = (pSrc[0] << 8) | pSrc[1];
1401         pSrc += sizeof(u16);
1402         offset += sizeof(u16);
1403         nBlocks = (pSrc[0] << 8) | pSrc[1];
1404         pSrc += sizeof(u16);
1405         offset += sizeof(u16);
1406
1407         for (i = 0; i < nBlocks; i += 1) {
1408                 Address = (pSrc[0] << 24) | (pSrc[1] << 16) |
1409                     (pSrc[2] << 8) | pSrc[3];
1410                 pSrc += sizeof(u32);
1411                 offset += sizeof(u32);
1412
1413                 BlockSize = ((pSrc[0] << 8) | pSrc[1]) * sizeof(u16);
1414                 pSrc += sizeof(u16);
1415                 offset += sizeof(u16);
1416
1417                 Flags = (pSrc[0] << 8) | pSrc[1];
1418                 pSrc += sizeof(u16);
1419                 offset += sizeof(u16);
1420
1421                 BlockCRC = (pSrc[0] << 8) | pSrc[1];
1422                 pSrc += sizeof(u16);
1423                 offset += sizeof(u16);
1424
1425                 if (offset + BlockSize > Length) {
1426                         printk(KERN_ERR "drxk: Firmware is corrupted.\n");
1427                         return -EINVAL;
1428                 }
1429
1430                 status = write_block(state, Address, BlockSize, pSrc);
1431                 if (status < 0) {
1432                         printk(KERN_ERR "drxk: Error %d while loading firmware\n", status);
1433                         break;
1434                 }
1435                 pSrc += BlockSize;
1436                 offset += BlockSize;
1437         }
1438         return status;
1439 }
1440
1441 static int DVBTEnableOFDMTokenRing(struct drxk_state *state, bool enable)
1442 {
1443         int status;
1444         u16 data = 0;
1445         u16 desiredCtrl = SIO_OFDM_SH_OFDM_RING_ENABLE_ON;
1446         u16 desiredStatus = SIO_OFDM_SH_OFDM_RING_STATUS_ENABLED;
1447         unsigned long end;
1448
1449         dprintk(1, "\n");
1450
1451         if (enable == false) {
1452                 desiredCtrl = SIO_OFDM_SH_OFDM_RING_ENABLE_OFF;
1453                 desiredStatus = SIO_OFDM_SH_OFDM_RING_STATUS_DOWN;
1454         }
1455
1456         status = read16(state, SIO_OFDM_SH_OFDM_RING_STATUS__A, &data);
1457         if (status >= 0 && data == desiredStatus) {
1458                 /* tokenring already has correct status */
1459                 return status;
1460         }
1461         /* Disable/enable dvbt tokenring bridge   */
1462         status = write16(state, SIO_OFDM_SH_OFDM_RING_ENABLE__A, desiredCtrl);
1463
1464         end = jiffies + msecs_to_jiffies(DRXK_OFDM_TR_SHUTDOWN_TIMEOUT);
1465         do {
1466                 status = read16(state, SIO_OFDM_SH_OFDM_RING_STATUS__A, &data);
1467                 if ((status >= 0 && data == desiredStatus) || time_is_after_jiffies(end))
1468                         break;
1469                 msleep(1);
1470         } while (1);
1471         if (data != desiredStatus) {
1472                 printk(KERN_ERR "drxk: SIO not ready\n");
1473                 return -EINVAL;
1474         }
1475         return status;
1476 }
1477
1478 static int MPEGTSStop(struct drxk_state *state)
1479 {
1480         int status = 0;
1481         u16 fecOcSncMode = 0;
1482         u16 fecOcIprMode = 0;
1483
1484         dprintk(1, "\n");
1485
1486         /* Gracefull shutdown (byte boundaries) */
1487         status = read16(state, FEC_OC_SNC_MODE__A, &fecOcSncMode);
1488         if (status < 0)
1489                 goto error;
1490         fecOcSncMode |= FEC_OC_SNC_MODE_SHUTDOWN__M;
1491         status = write16(state, FEC_OC_SNC_MODE__A, fecOcSncMode);
1492         if (status < 0)
1493                 goto error;
1494
1495         /* Suppress MCLK during absence of data */
1496         status = read16(state, FEC_OC_IPR_MODE__A, &fecOcIprMode);
1497         if (status < 0)
1498                 goto error;
1499         fecOcIprMode |= FEC_OC_IPR_MODE_MCLK_DIS_DAT_ABS__M;
1500         status = write16(state, FEC_OC_IPR_MODE__A, fecOcIprMode);
1501
1502 error:
1503         if (status < 0)
1504                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1505
1506         return status;
1507 }
1508
1509 static int scu_command(struct drxk_state *state,
1510                        u16 cmd, u8 parameterLen,
1511                        u16 *parameter, u8 resultLen, u16 *result)
1512 {
1513 #if (SCU_RAM_PARAM_0__A - SCU_RAM_PARAM_15__A) != 15
1514 #error DRXK register mapping no longer compatible with this routine!
1515 #endif
1516         u16 curCmd = 0;
1517         int status = -EINVAL;
1518         unsigned long end;
1519         u8 buffer[34];
1520         int cnt = 0, ii;
1521         const char *p;
1522         char errname[30];
1523
1524         dprintk(1, "\n");
1525
1526         if ((cmd == 0) || ((parameterLen > 0) && (parameter == NULL)) ||
1527             ((resultLen > 0) && (result == NULL)))
1528                 goto error;
1529
1530         mutex_lock(&state->mutex);
1531
1532         /* assume that the command register is ready
1533                 since it is checked afterwards */
1534         for (ii = parameterLen - 1; ii >= 0; ii -= 1) {
1535                 buffer[cnt++] = (parameter[ii] & 0xFF);
1536                 buffer[cnt++] = ((parameter[ii] >> 8) & 0xFF);
1537         }
1538         buffer[cnt++] = (cmd & 0xFF);
1539         buffer[cnt++] = ((cmd >> 8) & 0xFF);
1540
1541         write_block(state, SCU_RAM_PARAM_0__A -
1542                         (parameterLen - 1), cnt, buffer);
1543         /* Wait until SCU has processed command */
1544         end = jiffies + msecs_to_jiffies(DRXK_MAX_WAITTIME);
1545         do {
1546                 msleep(1);
1547                 status = read16(state, SCU_RAM_COMMAND__A, &curCmd);
1548                 if (status < 0)
1549                         goto error;
1550         } while (!(curCmd == DRX_SCU_READY) && (time_is_after_jiffies(end)));
1551         if (curCmd != DRX_SCU_READY) {
1552                 printk(KERN_ERR "drxk: SCU not ready\n");
1553                 status = -EIO;
1554                 goto error2;
1555         }
1556         /* read results */
1557         if ((resultLen > 0) && (result != NULL)) {
1558                 s16 err;
1559                 int ii;
1560
1561                 for (ii = resultLen - 1; ii >= 0; ii -= 1) {
1562                         status = read16(state, SCU_RAM_PARAM_0__A - ii, &result[ii]);
1563                         if (status < 0)
1564                                 goto error;
1565                 }
1566
1567                 /* Check if an error was reported by SCU */
1568                 err = (s16)result[0];
1569                 if (err >= 0)
1570                         goto error;
1571
1572                 /* check for the known error codes */
1573                 switch (err) {
1574                 case SCU_RESULT_UNKCMD:
1575                         p = "SCU_RESULT_UNKCMD";
1576                         break;
1577                 case SCU_RESULT_UNKSTD:
1578                         p = "SCU_RESULT_UNKSTD";
1579                         break;
1580                 case SCU_RESULT_SIZE:
1581                         p = "SCU_RESULT_SIZE";
1582                         break;
1583                 case SCU_RESULT_INVPAR:
1584                         p = "SCU_RESULT_INVPAR";
1585                         break;
1586                 default: /* Other negative values are errors */
1587                         sprintf(errname, "ERROR: %d\n", err);
1588                         p = errname;
1589                 }
1590                 printk(KERN_ERR "drxk: %s while sending cmd 0x%04x with params:", p, cmd);
1591                 print_hex_dump_bytes("drxk: ", DUMP_PREFIX_NONE, buffer, cnt);
1592                 status = -EINVAL;
1593                 goto error2;
1594         }
1595
1596 error:
1597         if (status < 0)
1598                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1599 error2:
1600         mutex_unlock(&state->mutex);
1601         return status;
1602 }
1603
1604 static int SetIqmAf(struct drxk_state *state, bool active)
1605 {
1606         u16 data = 0;
1607         int status;
1608
1609         dprintk(1, "\n");
1610
1611         /* Configure IQM */
1612         status = read16(state, IQM_AF_STDBY__A, &data);
1613         if (status < 0)
1614                 goto error;
1615
1616         if (!active) {
1617                 data |= (IQM_AF_STDBY_STDBY_ADC_STANDBY
1618                                 | IQM_AF_STDBY_STDBY_AMP_STANDBY
1619                                 | IQM_AF_STDBY_STDBY_PD_STANDBY
1620                                 | IQM_AF_STDBY_STDBY_TAGC_IF_STANDBY
1621                                 | IQM_AF_STDBY_STDBY_TAGC_RF_STANDBY);
1622         } else {
1623                 data &= ((~IQM_AF_STDBY_STDBY_ADC_STANDBY)
1624                                 & (~IQM_AF_STDBY_STDBY_AMP_STANDBY)
1625                                 & (~IQM_AF_STDBY_STDBY_PD_STANDBY)
1626                                 & (~IQM_AF_STDBY_STDBY_TAGC_IF_STANDBY)
1627                                 & (~IQM_AF_STDBY_STDBY_TAGC_RF_STANDBY)
1628                         );
1629         }
1630         status = write16(state, IQM_AF_STDBY__A, data);
1631
1632 error:
1633         if (status < 0)
1634                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1635         return status;
1636 }
1637
1638 static int CtrlPowerMode(struct drxk_state *state, enum DRXPowerMode *mode)
1639 {
1640         int status = 0;
1641         u16 sioCcPwdMode = 0;
1642
1643         dprintk(1, "\n");
1644
1645         /* Check arguments */
1646         if (mode == NULL)
1647                 return -EINVAL;
1648
1649         switch (*mode) {
1650         case DRX_POWER_UP:
1651                 sioCcPwdMode = SIO_CC_PWD_MODE_LEVEL_NONE;
1652                 break;
1653         case DRXK_POWER_DOWN_OFDM:
1654                 sioCcPwdMode = SIO_CC_PWD_MODE_LEVEL_OFDM;
1655                 break;
1656         case DRXK_POWER_DOWN_CORE:
1657                 sioCcPwdMode = SIO_CC_PWD_MODE_LEVEL_CLOCK;
1658                 break;
1659         case DRXK_POWER_DOWN_PLL:
1660                 sioCcPwdMode = SIO_CC_PWD_MODE_LEVEL_PLL;
1661                 break;
1662         case DRX_POWER_DOWN:
1663                 sioCcPwdMode = SIO_CC_PWD_MODE_LEVEL_OSC;
1664                 break;
1665         default:
1666                 /* Unknow sleep mode */
1667                 return -EINVAL;
1668         }
1669
1670         /* If already in requested power mode, do nothing */
1671         if (state->m_currentPowerMode == *mode)
1672                 return 0;
1673
1674         /* For next steps make sure to start from DRX_POWER_UP mode */
1675         if (state->m_currentPowerMode != DRX_POWER_UP) {
1676                 status = PowerUpDevice(state);
1677                 if (status < 0)
1678                         goto error;
1679                 status = DVBTEnableOFDMTokenRing(state, true);
1680                 if (status < 0)
1681                         goto error;
1682         }
1683
1684         if (*mode == DRX_POWER_UP) {
1685                 /* Restore analog & pin configuartion */
1686         } else {
1687                 /* Power down to requested mode */
1688                 /* Backup some register settings */
1689                 /* Set pins with possible pull-ups connected
1690                    to them in input mode */
1691                 /* Analog power down */
1692                 /* ADC power down */
1693                 /* Power down device */
1694                 /* stop all comm_exec */
1695                 /* Stop and power down previous standard */
1696                 switch (state->m_OperationMode) {
1697                 case OM_DVBT:
1698                         status = MPEGTSStop(state);
1699                         if (status < 0)
1700                                 goto error;
1701                         status = PowerDownDVBT(state, false);
1702                         if (status < 0)
1703                                 goto error;
1704                         break;
1705                 case OM_QAM_ITU_A:
1706                 case OM_QAM_ITU_C:
1707                         status = MPEGTSStop(state);
1708                         if (status < 0)
1709                                 goto error;
1710                         status = PowerDownQAM(state);
1711                         if (status < 0)
1712                                 goto error;
1713                         break;
1714                 default:
1715                         break;
1716                 }
1717                 status = DVBTEnableOFDMTokenRing(state, false);
1718                 if (status < 0)
1719                         goto error;
1720                 status = write16(state, SIO_CC_PWD_MODE__A, sioCcPwdMode);
1721                 if (status < 0)
1722                         goto error;
1723                 status = write16(state, SIO_CC_UPDATE__A, SIO_CC_UPDATE_KEY);
1724                 if (status < 0)
1725                         goto error;
1726
1727                 if (*mode != DRXK_POWER_DOWN_OFDM) {
1728                         state->m_HICfgCtrl |=
1729                                 SIO_HI_RA_RAM_PAR_5_CFG_SLEEP_ZZZ;
1730                         status = HI_CfgCommand(state);
1731                         if (status < 0)
1732                                 goto error;
1733                 }
1734         }
1735         state->m_currentPowerMode = *mode;
1736
1737 error:
1738         if (status < 0)
1739                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1740
1741         return status;
1742 }
1743
1744 static int PowerDownDVBT(struct drxk_state *state, bool setPowerMode)
1745 {
1746         enum DRXPowerMode powerMode = DRXK_POWER_DOWN_OFDM;
1747         u16 cmdResult = 0;
1748         u16 data = 0;
1749         int status;
1750
1751         dprintk(1, "\n");
1752
1753         status = read16(state, SCU_COMM_EXEC__A, &data);
1754         if (status < 0)
1755                 goto error;
1756         if (data == SCU_COMM_EXEC_ACTIVE) {
1757                 /* Send OFDM stop command */
1758                 status = scu_command(state, SCU_RAM_COMMAND_STANDARD_OFDM | SCU_RAM_COMMAND_CMD_DEMOD_STOP, 0, NULL, 1, &cmdResult);
1759                 if (status < 0)
1760                         goto error;
1761                 /* Send OFDM reset command */
1762                 status = scu_command(state, SCU_RAM_COMMAND_STANDARD_OFDM | SCU_RAM_COMMAND_CMD_DEMOD_RESET, 0, NULL, 1, &cmdResult);
1763                 if (status < 0)
1764                         goto error;
1765         }
1766
1767         /* Reset datapath for OFDM, processors first */
1768         status = write16(state, OFDM_SC_COMM_EXEC__A, OFDM_SC_COMM_EXEC_STOP);
1769         if (status < 0)
1770                 goto error;
1771         status = write16(state, OFDM_LC_COMM_EXEC__A, OFDM_LC_COMM_EXEC_STOP);
1772         if (status < 0)
1773                 goto error;
1774         status = write16(state, IQM_COMM_EXEC__A, IQM_COMM_EXEC_B_STOP);
1775         if (status < 0)
1776                 goto error;
1777
1778         /* powerdown AFE                   */
1779         status = SetIqmAf(state, false);
1780         if (status < 0)
1781                 goto error;
1782
1783         /* powerdown to OFDM mode          */
1784         if (setPowerMode) {
1785                 status = CtrlPowerMode(state, &powerMode);
1786                 if (status < 0)
1787                         goto error;
1788         }
1789 error:
1790         if (status < 0)
1791                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1792         return status;
1793 }
1794
1795 static int SetOperationMode(struct drxk_state *state,
1796                             enum OperationMode oMode)
1797 {
1798         int status = 0;
1799
1800         dprintk(1, "\n");
1801         /*
1802            Stop and power down previous standard
1803            TODO investigate total power down instead of partial
1804            power down depending on "previous" standard.
1805          */
1806
1807         /* disable HW lock indicator */
1808         status = write16(state, SCU_RAM_GPIO__A, SCU_RAM_GPIO_HW_LOCK_IND_DISABLE);
1809         if (status < 0)
1810                 goto error;
1811
1812         /* Device is already at the required mode */
1813         if (state->m_OperationMode == oMode)
1814                 return 0;
1815
1816         switch (state->m_OperationMode) {
1817                 /* OM_NONE was added for start up */
1818         case OM_NONE:
1819                 break;
1820         case OM_DVBT:
1821                 status = MPEGTSStop(state);
1822                 if (status < 0)
1823                         goto error;
1824                 status = PowerDownDVBT(state, true);
1825                 if (status < 0)
1826                         goto error;
1827                 state->m_OperationMode = OM_NONE;
1828                 break;
1829         case OM_QAM_ITU_A:      /* fallthrough */
1830         case OM_QAM_ITU_C:
1831                 status = MPEGTSStop(state);
1832                 if (status < 0)
1833                         goto error;
1834                 status = PowerDownQAM(state);
1835                 if (status < 0)
1836                         goto error;
1837                 state->m_OperationMode = OM_NONE;
1838                 break;
1839         case OM_QAM_ITU_B:
1840         default:
1841                 status = -EINVAL;
1842                 goto error;
1843         }
1844
1845         /*
1846                 Power up new standard
1847                 */
1848         switch (oMode) {
1849         case OM_DVBT:
1850                 dprintk(1, ": DVB-T\n");
1851                 state->m_OperationMode = oMode;
1852                 status = SetDVBTStandard(state, oMode);
1853                 if (status < 0)
1854                         goto error;
1855                 break;
1856         case OM_QAM_ITU_A:      /* fallthrough */
1857         case OM_QAM_ITU_C:
1858                 dprintk(1, ": DVB-C Annex %c\n",
1859                         (state->m_OperationMode == OM_QAM_ITU_A) ? 'A' : 'C');
1860                 state->m_OperationMode = oMode;
1861                 status = SetQAMStandard(state, oMode);
1862                 if (status < 0)
1863                         goto error;
1864                 break;
1865         case OM_QAM_ITU_B:
1866         default:
1867                 status = -EINVAL;
1868         }
1869 error:
1870         if (status < 0)
1871                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1872         return status;
1873 }
1874
1875 static int Start(struct drxk_state *state, s32 offsetFreq,
1876                  s32 IntermediateFrequency)
1877 {
1878         int status = -EINVAL;
1879
1880         u16 IFreqkHz;
1881         s32 OffsetkHz = offsetFreq / 1000;
1882
1883         dprintk(1, "\n");
1884         if (state->m_DrxkState != DRXK_STOPPED &&
1885                 state->m_DrxkState != DRXK_DTV_STARTED)
1886                 goto error;
1887
1888         state->m_bMirrorFreqSpect = (state->props.inversion == INVERSION_ON);
1889
1890         if (IntermediateFrequency < 0) {
1891                 state->m_bMirrorFreqSpect = !state->m_bMirrorFreqSpect;
1892                 IntermediateFrequency = -IntermediateFrequency;
1893         }
1894
1895         switch (state->m_OperationMode) {
1896         case OM_QAM_ITU_A:
1897         case OM_QAM_ITU_C:
1898                 IFreqkHz = (IntermediateFrequency / 1000);
1899                 status = SetQAM(state, IFreqkHz, OffsetkHz);
1900                 if (status < 0)
1901                         goto error;
1902                 state->m_DrxkState = DRXK_DTV_STARTED;
1903                 break;
1904         case OM_DVBT:
1905                 IFreqkHz = (IntermediateFrequency / 1000);
1906                 status = MPEGTSStop(state);
1907                 if (status < 0)
1908                         goto error;
1909                 status = SetDVBT(state, IFreqkHz, OffsetkHz);
1910                 if (status < 0)
1911                         goto error;
1912                 status = DVBTStart(state);
1913                 if (status < 0)
1914                         goto error;
1915                 state->m_DrxkState = DRXK_DTV_STARTED;
1916                 break;
1917         default:
1918                 break;
1919         }
1920 error:
1921         if (status < 0)
1922                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1923         return status;
1924 }
1925
1926 static int ShutDown(struct drxk_state *state)
1927 {
1928         dprintk(1, "\n");
1929
1930         MPEGTSStop(state);
1931         return 0;
1932 }
1933
1934 static int GetLockStatus(struct drxk_state *state, u32 *pLockStatus,
1935                          u32 Time)
1936 {
1937         int status = -EINVAL;
1938
1939         dprintk(1, "\n");
1940
1941         if (pLockStatus == NULL)
1942                 goto error;
1943
1944         *pLockStatus = NOT_LOCKED;
1945
1946         /* define the SCU command code */
1947         switch (state->m_OperationMode) {
1948         case OM_QAM_ITU_A:
1949         case OM_QAM_ITU_B:
1950         case OM_QAM_ITU_C:
1951                 status = GetQAMLockStatus(state, pLockStatus);
1952                 break;
1953         case OM_DVBT:
1954                 status = GetDVBTLockStatus(state, pLockStatus);
1955                 break;
1956         default:
1957                 break;
1958         }
1959 error:
1960         if (status < 0)
1961                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1962         return status;
1963 }
1964
1965 static int MPEGTSStart(struct drxk_state *state)
1966 {
1967         int status;
1968
1969         u16 fecOcSncMode = 0;
1970
1971         /* Allow OC to sync again */
1972         status = read16(state, FEC_OC_SNC_MODE__A, &fecOcSncMode);
1973         if (status < 0)
1974                 goto error;
1975         fecOcSncMode &= ~FEC_OC_SNC_MODE_SHUTDOWN__M;
1976         status = write16(state, FEC_OC_SNC_MODE__A, fecOcSncMode);
1977         if (status < 0)
1978                 goto error;
1979         status = write16(state, FEC_OC_SNC_UNLOCK__A, 1);
1980 error:
1981         if (status < 0)
1982                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
1983         return status;
1984 }
1985
1986 static int MPEGTSDtoInit(struct drxk_state *state)
1987 {
1988         int status;
1989
1990         dprintk(1, "\n");
1991
1992         /* Rate integration settings */
1993         status = write16(state, FEC_OC_RCN_CTL_STEP_LO__A, 0x0000);
1994         if (status < 0)
1995                 goto error;
1996         status = write16(state, FEC_OC_RCN_CTL_STEP_HI__A, 0x000C);
1997         if (status < 0)
1998                 goto error;
1999         status = write16(state, FEC_OC_RCN_GAIN__A, 0x000A);
2000         if (status < 0)
2001                 goto error;
2002         status = write16(state, FEC_OC_AVR_PARM_A__A, 0x0008);
2003         if (status < 0)
2004                 goto error;
2005         status = write16(state, FEC_OC_AVR_PARM_B__A, 0x0006);
2006         if (status < 0)
2007                 goto error;
2008         status = write16(state, FEC_OC_TMD_HI_MARGIN__A, 0x0680);
2009         if (status < 0)
2010                 goto error;
2011         status = write16(state, FEC_OC_TMD_LO_MARGIN__A, 0x0080);
2012         if (status < 0)
2013                 goto error;
2014         status = write16(state, FEC_OC_TMD_COUNT__A, 0x03F4);
2015         if (status < 0)
2016                 goto error;
2017
2018         /* Additional configuration */
2019         status = write16(state, FEC_OC_OCR_INVERT__A, 0);
2020         if (status < 0)
2021                 goto error;
2022         status = write16(state, FEC_OC_SNC_LWM__A, 2);
2023         if (status < 0)
2024                 goto error;
2025         status = write16(state, FEC_OC_SNC_HWM__A, 12);
2026 error:
2027         if (status < 0)
2028                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2029
2030         return status;
2031 }
2032
2033 static int MPEGTSDtoSetup(struct drxk_state *state,
2034                           enum OperationMode oMode)
2035 {
2036         int status;
2037
2038         u16 fecOcRegMode = 0;   /* FEC_OC_MODE       register value */
2039         u16 fecOcRegIprMode = 0;        /* FEC_OC_IPR_MODE   register value */
2040         u16 fecOcDtoMode = 0;   /* FEC_OC_IPR_INVERT register value */
2041         u16 fecOcFctMode = 0;   /* FEC_OC_IPR_INVERT register value */
2042         u16 fecOcDtoPeriod = 2; /* FEC_OC_IPR_INVERT register value */
2043         u16 fecOcDtoBurstLen = 188;     /* FEC_OC_IPR_INVERT register value */
2044         u32 fecOcRcnCtlRate = 0;        /* FEC_OC_IPR_INVERT register value */
2045         u16 fecOcTmdMode = 0;
2046         u16 fecOcTmdIntUpdRate = 0;
2047         u32 maxBitRate = 0;
2048         bool staticCLK = false;
2049
2050         dprintk(1, "\n");
2051
2052         /* Check insertion of the Reed-Solomon parity bytes */
2053         status = read16(state, FEC_OC_MODE__A, &fecOcRegMode);
2054         if (status < 0)
2055                 goto error;
2056         status = read16(state, FEC_OC_IPR_MODE__A, &fecOcRegIprMode);
2057         if (status < 0)
2058                 goto error;
2059         fecOcRegMode &= (~FEC_OC_MODE_PARITY__M);
2060         fecOcRegIprMode &= (~FEC_OC_IPR_MODE_MVAL_DIS_PAR__M);
2061         if (state->m_insertRSByte == true) {
2062                 /* enable parity symbol forward */
2063                 fecOcRegMode |= FEC_OC_MODE_PARITY__M;
2064                 /* MVAL disable during parity bytes */
2065                 fecOcRegIprMode |= FEC_OC_IPR_MODE_MVAL_DIS_PAR__M;
2066                 /* TS burst length to 204 */
2067                 fecOcDtoBurstLen = 204;
2068         }
2069
2070         /* Check serial or parrallel output */
2071         fecOcRegIprMode &= (~(FEC_OC_IPR_MODE_SERIAL__M));
2072         if (state->m_enableParallel == false) {
2073                 /* MPEG data output is serial -> set ipr_mode[0] */
2074                 fecOcRegIprMode |= FEC_OC_IPR_MODE_SERIAL__M;
2075         }
2076
2077         switch (oMode) {
2078         case OM_DVBT:
2079                 maxBitRate = state->m_DVBTBitrate;
2080                 fecOcTmdMode = 3;
2081                 fecOcRcnCtlRate = 0xC00000;
2082                 staticCLK = state->m_DVBTStaticCLK;
2083                 break;
2084         case OM_QAM_ITU_A:      /* fallthrough */
2085         case OM_QAM_ITU_C:
2086                 fecOcTmdMode = 0x0004;
2087                 fecOcRcnCtlRate = 0xD2B4EE;     /* good for >63 Mb/s */
2088                 maxBitRate = state->m_DVBCBitrate;
2089                 staticCLK = state->m_DVBCStaticCLK;
2090                 break;
2091         default:
2092                 status = -EINVAL;
2093         }               /* switch (standard) */
2094         if (status < 0)
2095                 goto error;
2096
2097         /* Configure DTO's */
2098         if (staticCLK) {
2099                 u32 bitRate = 0;
2100
2101                 /* Rational DTO for MCLK source (static MCLK rate),
2102                         Dynamic DTO for optimal grouping
2103                         (avoid intra-packet gaps),
2104                         DTO offset enable to sync TS burst with MSTRT */
2105                 fecOcDtoMode = (FEC_OC_DTO_MODE_DYNAMIC__M |
2106                                 FEC_OC_DTO_MODE_OFFSET_ENABLE__M);
2107                 fecOcFctMode = (FEC_OC_FCT_MODE_RAT_ENA__M |
2108                                 FEC_OC_FCT_MODE_VIRT_ENA__M);
2109
2110                 /* Check user defined bitrate */
2111                 bitRate = maxBitRate;
2112                 if (bitRate > 75900000UL) {     /* max is 75.9 Mb/s */
2113                         bitRate = 75900000UL;
2114                 }
2115                 /* Rational DTO period:
2116                         dto_period = (Fsys / bitrate) - 2
2117
2118                         Result should be floored,
2119                         to make sure >= requested bitrate
2120                         */
2121                 fecOcDtoPeriod = (u16) (((state->m_sysClockFreq)
2122                                                 * 1000) / bitRate);
2123                 if (fecOcDtoPeriod <= 2)
2124                         fecOcDtoPeriod = 0;
2125                 else
2126                         fecOcDtoPeriod -= 2;
2127                 fecOcTmdIntUpdRate = 8;
2128         } else {
2129                 /* (commonAttr->staticCLK == false) => dynamic mode */
2130                 fecOcDtoMode = FEC_OC_DTO_MODE_DYNAMIC__M;
2131                 fecOcFctMode = FEC_OC_FCT_MODE__PRE;
2132                 fecOcTmdIntUpdRate = 5;
2133         }
2134
2135         /* Write appropriate registers with requested configuration */
2136         status = write16(state, FEC_OC_DTO_BURST_LEN__A, fecOcDtoBurstLen);
2137         if (status < 0)
2138                 goto error;
2139         status = write16(state, FEC_OC_DTO_PERIOD__A, fecOcDtoPeriod);
2140         if (status < 0)
2141                 goto error;
2142         status = write16(state, FEC_OC_DTO_MODE__A, fecOcDtoMode);
2143         if (status < 0)
2144                 goto error;
2145         status = write16(state, FEC_OC_FCT_MODE__A, fecOcFctMode);
2146         if (status < 0)
2147                 goto error;
2148         status = write16(state, FEC_OC_MODE__A, fecOcRegMode);
2149         if (status < 0)
2150                 goto error;
2151         status = write16(state, FEC_OC_IPR_MODE__A, fecOcRegIprMode);
2152         if (status < 0)
2153                 goto error;
2154
2155         /* Rate integration settings */
2156         status = write32(state, FEC_OC_RCN_CTL_RATE_LO__A, fecOcRcnCtlRate);
2157         if (status < 0)
2158                 goto error;
2159         status = write16(state, FEC_OC_TMD_INT_UPD_RATE__A, fecOcTmdIntUpdRate);
2160         if (status < 0)
2161                 goto error;
2162         status = write16(state, FEC_OC_TMD_MODE__A, fecOcTmdMode);
2163 error:
2164         if (status < 0)
2165                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2166         return status;
2167 }
2168
2169 static int MPEGTSConfigurePolarity(struct drxk_state *state)
2170 {
2171         u16 fecOcRegIprInvert = 0;
2172
2173         /* Data mask for the output data byte */
2174         u16 InvertDataMask =
2175             FEC_OC_IPR_INVERT_MD7__M | FEC_OC_IPR_INVERT_MD6__M |
2176             FEC_OC_IPR_INVERT_MD5__M | FEC_OC_IPR_INVERT_MD4__M |
2177             FEC_OC_IPR_INVERT_MD3__M | FEC_OC_IPR_INVERT_MD2__M |
2178             FEC_OC_IPR_INVERT_MD1__M | FEC_OC_IPR_INVERT_MD0__M;
2179
2180         dprintk(1, "\n");
2181
2182         /* Control selective inversion of output bits */
2183         fecOcRegIprInvert &= (~(InvertDataMask));
2184         if (state->m_invertDATA == true)
2185                 fecOcRegIprInvert |= InvertDataMask;
2186         fecOcRegIprInvert &= (~(FEC_OC_IPR_INVERT_MERR__M));
2187         if (state->m_invertERR == true)
2188                 fecOcRegIprInvert |= FEC_OC_IPR_INVERT_MERR__M;
2189         fecOcRegIprInvert &= (~(FEC_OC_IPR_INVERT_MSTRT__M));
2190         if (state->m_invertSTR == true)
2191                 fecOcRegIprInvert |= FEC_OC_IPR_INVERT_MSTRT__M;
2192         fecOcRegIprInvert &= (~(FEC_OC_IPR_INVERT_MVAL__M));
2193         if (state->m_invertVAL == true)
2194                 fecOcRegIprInvert |= FEC_OC_IPR_INVERT_MVAL__M;
2195         fecOcRegIprInvert &= (~(FEC_OC_IPR_INVERT_MCLK__M));
2196         if (state->m_invertCLK == true)
2197                 fecOcRegIprInvert |= FEC_OC_IPR_INVERT_MCLK__M;
2198
2199         return write16(state, FEC_OC_IPR_INVERT__A, fecOcRegIprInvert);
2200 }
2201
2202 #define   SCU_RAM_AGC_KI_INV_RF_POL__M 0x4000
2203
2204 static int SetAgcRf(struct drxk_state *state,
2205                     struct SCfgAgc *pAgcCfg, bool isDTV)
2206 {
2207         int status = -EINVAL;
2208         u16 data = 0;
2209         struct SCfgAgc *pIfAgcSettings;
2210
2211         dprintk(1, "\n");
2212
2213         if (pAgcCfg == NULL)
2214                 goto error;
2215
2216         switch (pAgcCfg->ctrlMode) {
2217         case DRXK_AGC_CTRL_AUTO:
2218                 /* Enable RF AGC DAC */
2219                 status = read16(state, IQM_AF_STDBY__A, &data);
2220                 if (status < 0)
2221                         goto error;
2222                 data &= ~IQM_AF_STDBY_STDBY_TAGC_RF_STANDBY;
2223                 status = write16(state, IQM_AF_STDBY__A, data);
2224                 if (status < 0)
2225                         goto error;
2226                 status = read16(state, SCU_RAM_AGC_CONFIG__A, &data);
2227                 if (status < 0)
2228                         goto error;
2229
2230                 /* Enable SCU RF AGC loop */
2231                 data &= ~SCU_RAM_AGC_CONFIG_DISABLE_RF_AGC__M;
2232
2233                 /* Polarity */
2234                 if (state->m_RfAgcPol)
2235                         data |= SCU_RAM_AGC_CONFIG_INV_RF_POL__M;
2236                 else
2237                         data &= ~SCU_RAM_AGC_CONFIG_INV_RF_POL__M;
2238                 status = write16(state, SCU_RAM_AGC_CONFIG__A, data);
2239                 if (status < 0)
2240                         goto error;
2241
2242                 /* Set speed (using complementary reduction value) */
2243                 status = read16(state, SCU_RAM_AGC_KI_RED__A, &data);
2244                 if (status < 0)
2245                         goto error;
2246
2247                 data &= ~SCU_RAM_AGC_KI_RED_RAGC_RED__M;
2248                 data |= (~(pAgcCfg->speed <<
2249                                 SCU_RAM_AGC_KI_RED_RAGC_RED__B)
2250                                 & SCU_RAM_AGC_KI_RED_RAGC_RED__M);
2251
2252                 status = write16(state, SCU_RAM_AGC_KI_RED__A, data);
2253                 if (status < 0)
2254                         goto error;
2255
2256                 if (IsDVBT(state))
2257                         pIfAgcSettings = &state->m_dvbtIfAgcCfg;
2258                 else if (IsQAM(state))
2259                         pIfAgcSettings = &state->m_qamIfAgcCfg;
2260                 else
2261                         pIfAgcSettings = &state->m_atvIfAgcCfg;
2262                 if (pIfAgcSettings == NULL) {
2263                         status = -EINVAL;
2264                         goto error;
2265                 }
2266
2267                 /* Set TOP, only if IF-AGC is in AUTO mode */
2268                 if (pIfAgcSettings->ctrlMode == DRXK_AGC_CTRL_AUTO)
2269                         status = write16(state, SCU_RAM_AGC_IF_IACCU_HI_TGT_MAX__A, pAgcCfg->top);
2270                         if (status < 0)
2271                                 goto error;
2272
2273                 /* Cut-Off current */
2274                 status = write16(state, SCU_RAM_AGC_RF_IACCU_HI_CO__A, pAgcCfg->cutOffCurrent);
2275                 if (status < 0)
2276                         goto error;
2277
2278                 /* Max. output level */
2279                 status = write16(state, SCU_RAM_AGC_RF_MAX__A, pAgcCfg->maxOutputLevel);
2280                 if (status < 0)
2281                         goto error;
2282
2283                 break;
2284
2285         case DRXK_AGC_CTRL_USER:
2286                 /* Enable RF AGC DAC */
2287                 status = read16(state, IQM_AF_STDBY__A, &data);
2288                 if (status < 0)
2289                         goto error;
2290                 data &= ~IQM_AF_STDBY_STDBY_TAGC_RF_STANDBY;
2291                 status = write16(state, IQM_AF_STDBY__A, data);
2292                 if (status < 0)
2293                         goto error;
2294
2295                 /* Disable SCU RF AGC loop */
2296                 status = read16(state, SCU_RAM_AGC_CONFIG__A, &data);
2297                 if (status < 0)
2298                         goto error;
2299                 data |= SCU_RAM_AGC_CONFIG_DISABLE_RF_AGC__M;
2300                 if (state->m_RfAgcPol)
2301                         data |= SCU_RAM_AGC_CONFIG_INV_RF_POL__M;
2302                 else
2303                         data &= ~SCU_RAM_AGC_CONFIG_INV_RF_POL__M;
2304                 status = write16(state, SCU_RAM_AGC_CONFIG__A, data);
2305                 if (status < 0)
2306                         goto error;
2307
2308                 /* SCU c.o.c. to 0, enabling full control range */
2309                 status = write16(state, SCU_RAM_AGC_RF_IACCU_HI_CO__A, 0);
2310                 if (status < 0)
2311                         goto error;
2312
2313                 /* Write value to output pin */
2314                 status = write16(state, SCU_RAM_AGC_RF_IACCU_HI__A, pAgcCfg->outputLevel);
2315                 if (status < 0)
2316                         goto error;
2317                 break;
2318
2319         case DRXK_AGC_CTRL_OFF:
2320                 /* Disable RF AGC DAC */
2321                 status = read16(state, IQM_AF_STDBY__A, &data);
2322                 if (status < 0)
2323                         goto error;
2324                 data |= IQM_AF_STDBY_STDBY_TAGC_RF_STANDBY;
2325                 status = write16(state, IQM_AF_STDBY__A, data);
2326                 if (status < 0)
2327                         goto error;
2328
2329                 /* Disable SCU RF AGC loop */
2330                 status = read16(state, SCU_RAM_AGC_CONFIG__A, &data);
2331                 if (status < 0)
2332                         goto error;
2333                 data |= SCU_RAM_AGC_CONFIG_DISABLE_RF_AGC__M;
2334                 status = write16(state, SCU_RAM_AGC_CONFIG__A, data);
2335                 if (status < 0)
2336                         goto error;
2337                 break;
2338
2339         default:
2340                 status = -EINVAL;
2341
2342         }
2343 error:
2344         if (status < 0)
2345                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2346         return status;
2347 }
2348
2349 #define SCU_RAM_AGC_KI_INV_IF_POL__M 0x2000
2350
2351 static int SetAgcIf(struct drxk_state *state,
2352                     struct SCfgAgc *pAgcCfg, bool isDTV)
2353 {
2354         u16 data = 0;
2355         int status = 0;
2356         struct SCfgAgc *pRfAgcSettings;
2357
2358         dprintk(1, "\n");
2359
2360         switch (pAgcCfg->ctrlMode) {
2361         case DRXK_AGC_CTRL_AUTO:
2362
2363                 /* Enable IF AGC DAC */
2364                 status = read16(state, IQM_AF_STDBY__A, &data);
2365                 if (status < 0)
2366                         goto error;
2367                 data &= ~IQM_AF_STDBY_STDBY_TAGC_IF_STANDBY;
2368                 status = write16(state, IQM_AF_STDBY__A, data);
2369                 if (status < 0)
2370                         goto error;
2371
2372                 status = read16(state, SCU_RAM_AGC_CONFIG__A, &data);
2373                 if (status < 0)
2374                         goto error;
2375
2376                 /* Enable SCU IF AGC loop */
2377                 data &= ~SCU_RAM_AGC_CONFIG_DISABLE_IF_AGC__M;
2378
2379                 /* Polarity */
2380                 if (state->m_IfAgcPol)
2381                         data |= SCU_RAM_AGC_CONFIG_INV_IF_POL__M;
2382                 else
2383                         data &= ~SCU_RAM_AGC_CONFIG_INV_IF_POL__M;
2384                 status = write16(state, SCU_RAM_AGC_CONFIG__A, data);
2385                 if (status < 0)
2386                         goto error;
2387
2388                 /* Set speed (using complementary reduction value) */
2389                 status = read16(state, SCU_RAM_AGC_KI_RED__A, &data);
2390                 if (status < 0)
2391                         goto error;
2392                 data &= ~SCU_RAM_AGC_KI_RED_IAGC_RED__M;
2393                 data |= (~(pAgcCfg->speed <<
2394                                 SCU_RAM_AGC_KI_RED_IAGC_RED__B)
2395                                 & SCU_RAM_AGC_KI_RED_IAGC_RED__M);
2396
2397                 status = write16(state, SCU_RAM_AGC_KI_RED__A, data);
2398                 if (status < 0)
2399                         goto error;
2400
2401                 if (IsQAM(state))
2402                         pRfAgcSettings = &state->m_qamRfAgcCfg;
2403                 else
2404                         pRfAgcSettings = &state->m_atvRfAgcCfg;
2405                 if (pRfAgcSettings == NULL)
2406                         return -1;
2407                 /* Restore TOP */
2408                 status = write16(state, SCU_RAM_AGC_IF_IACCU_HI_TGT_MAX__A, pRfAgcSettings->top);
2409                 if (status < 0)
2410                         goto error;
2411                 break;
2412
2413         case DRXK_AGC_CTRL_USER:
2414
2415                 /* Enable IF AGC DAC */
2416                 status = read16(state, IQM_AF_STDBY__A, &data);
2417                 if (status < 0)
2418                         goto error;
2419                 data &= ~IQM_AF_STDBY_STDBY_TAGC_IF_STANDBY;
2420                 status = write16(state, IQM_AF_STDBY__A, data);
2421                 if (status < 0)
2422                         goto error;
2423
2424                 status = read16(state, SCU_RAM_AGC_CONFIG__A, &data);
2425                 if (status < 0)
2426                         goto error;
2427
2428                 /* Disable SCU IF AGC loop */
2429                 data |= SCU_RAM_AGC_CONFIG_DISABLE_IF_AGC__M;
2430
2431                 /* Polarity */
2432                 if (state->m_IfAgcPol)
2433                         data |= SCU_RAM_AGC_CONFIG_INV_IF_POL__M;
2434                 else
2435                         data &= ~SCU_RAM_AGC_CONFIG_INV_IF_POL__M;
2436                 status = write16(state, SCU_RAM_AGC_CONFIG__A, data);
2437                 if (status < 0)
2438                         goto error;
2439
2440                 /* Write value to output pin */
2441                 status = write16(state, SCU_RAM_AGC_IF_IACCU_HI_TGT_MAX__A, pAgcCfg->outputLevel);
2442                 if (status < 0)
2443                         goto error;
2444                 break;
2445
2446         case DRXK_AGC_CTRL_OFF:
2447
2448                 /* Disable If AGC DAC */
2449                 status = read16(state, IQM_AF_STDBY__A, &data);
2450                 if (status < 0)
2451                         goto error;
2452                 data |= IQM_AF_STDBY_STDBY_TAGC_IF_STANDBY;
2453                 status = write16(state, IQM_AF_STDBY__A, data);
2454                 if (status < 0)
2455                         goto error;
2456
2457                 /* Disable SCU IF AGC loop */
2458                 status = read16(state, SCU_RAM_AGC_CONFIG__A, &data);
2459                 if (status < 0)
2460                         goto error;
2461                 data |= SCU_RAM_AGC_CONFIG_DISABLE_IF_AGC__M;
2462                 status = write16(state, SCU_RAM_AGC_CONFIG__A, data);
2463                 if (status < 0)
2464                         goto error;
2465                 break;
2466         }               /* switch (agcSettingsIf->ctrlMode) */
2467
2468         /* always set the top to support
2469                 configurations without if-loop */
2470         status = write16(state, SCU_RAM_AGC_INGAIN_TGT_MIN__A, pAgcCfg->top);
2471 error:
2472         if (status < 0)
2473                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2474         return status;
2475 }
2476
2477 static int ReadIFAgc(struct drxk_state *state, u32 *pValue)
2478 {
2479         u16 agcDacLvl;
2480         int status;
2481         u16 Level = 0;
2482
2483         dprintk(1, "\n");
2484
2485         status = read16(state, IQM_AF_AGC_IF__A, &agcDacLvl);
2486         if (status < 0) {
2487                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2488                 return status;
2489         }
2490
2491         *pValue = 0;
2492
2493         if (agcDacLvl > DRXK_AGC_DAC_OFFSET)
2494                 Level = agcDacLvl - DRXK_AGC_DAC_OFFSET;
2495         if (Level < 14000)
2496                 *pValue = (14000 - Level) / 4;
2497         else
2498                 *pValue = 0;
2499
2500         return status;
2501 }
2502
2503 static int GetQAMSignalToNoise(struct drxk_state *state,
2504                                s32 *pSignalToNoise)
2505 {
2506         int status = 0;
2507         u16 qamSlErrPower = 0;  /* accum. error between
2508                                         raw and sliced symbols */
2509         u32 qamSlSigPower = 0;  /* used for MER, depends of
2510                                         QAM modulation */
2511         u32 qamSlMer = 0;       /* QAM MER */
2512
2513         dprintk(1, "\n");
2514
2515         /* MER calculation */
2516
2517         /* get the register value needed for MER */
2518         status = read16(state, QAM_SL_ERR_POWER__A, &qamSlErrPower);
2519         if (status < 0) {
2520                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2521                 return -EINVAL;
2522         }
2523
2524         switch (state->props.modulation) {
2525         case QAM_16:
2526                 qamSlSigPower = DRXK_QAM_SL_SIG_POWER_QAM16 << 2;
2527                 break;
2528         case QAM_32:
2529                 qamSlSigPower = DRXK_QAM_SL_SIG_POWER_QAM32 << 2;
2530                 break;
2531         case QAM_64:
2532                 qamSlSigPower = DRXK_QAM_SL_SIG_POWER_QAM64 << 2;
2533                 break;
2534         case QAM_128:
2535                 qamSlSigPower = DRXK_QAM_SL_SIG_POWER_QAM128 << 2;
2536                 break;
2537         default:
2538         case QAM_256:
2539                 qamSlSigPower = DRXK_QAM_SL_SIG_POWER_QAM256 << 2;
2540                 break;
2541         }
2542
2543         if (qamSlErrPower > 0) {
2544                 qamSlMer = Log10Times100(qamSlSigPower) -
2545                         Log10Times100((u32) qamSlErrPower);
2546         }
2547         *pSignalToNoise = qamSlMer;
2548
2549         return status;
2550 }
2551
2552 static int GetDVBTSignalToNoise(struct drxk_state *state,
2553                                 s32 *pSignalToNoise)
2554 {
2555         int status;
2556         u16 regData = 0;
2557         u32 EqRegTdSqrErrI = 0;
2558         u32 EqRegTdSqrErrQ = 0;
2559         u16 EqRegTdSqrErrExp = 0;
2560         u16 EqRegTdTpsPwrOfs = 0;
2561         u16 EqRegTdReqSmbCnt = 0;
2562         u32 tpsCnt = 0;
2563         u32 SqrErrIQ = 0;
2564         u32 a = 0;
2565         u32 b = 0;
2566         u32 c = 0;
2567         u32 iMER = 0;
2568         u16 transmissionParams = 0;
2569
2570         dprintk(1, "\n");
2571
2572         status = read16(state, OFDM_EQ_TOP_TD_TPS_PWR_OFS__A, &EqRegTdTpsPwrOfs);
2573         if (status < 0)
2574                 goto error;
2575         status = read16(state, OFDM_EQ_TOP_TD_REQ_SMB_CNT__A, &EqRegTdReqSmbCnt);
2576         if (status < 0)
2577                 goto error;
2578         status = read16(state, OFDM_EQ_TOP_TD_SQR_ERR_EXP__A, &EqRegTdSqrErrExp);
2579         if (status < 0)
2580                 goto error;
2581         status = read16(state, OFDM_EQ_TOP_TD_SQR_ERR_I__A, &regData);
2582         if (status < 0)
2583                 goto error;
2584         /* Extend SQR_ERR_I operational range */
2585         EqRegTdSqrErrI = (u32) regData;
2586         if ((EqRegTdSqrErrExp > 11) &&
2587                 (EqRegTdSqrErrI < 0x00000FFFUL)) {
2588                 EqRegTdSqrErrI += 0x00010000UL;
2589         }
2590         status = read16(state, OFDM_EQ_TOP_TD_SQR_ERR_Q__A, &regData);
2591         if (status < 0)
2592                 goto error;
2593         /* Extend SQR_ERR_Q operational range */
2594         EqRegTdSqrErrQ = (u32) regData;
2595         if ((EqRegTdSqrErrExp > 11) &&
2596                 (EqRegTdSqrErrQ < 0x00000FFFUL))
2597                 EqRegTdSqrErrQ += 0x00010000UL;
2598
2599         status = read16(state, OFDM_SC_RA_RAM_OP_PARAM__A, &transmissionParams);
2600         if (status < 0)
2601                 goto error;
2602
2603         /* Check input data for MER */
2604
2605         /* MER calculation (in 0.1 dB) without math.h */
2606         if ((EqRegTdTpsPwrOfs == 0) || (EqRegTdReqSmbCnt == 0))
2607                 iMER = 0;
2608         else if ((EqRegTdSqrErrI + EqRegTdSqrErrQ) == 0) {
2609                 /* No error at all, this must be the HW reset value
2610                         * Apparently no first measurement yet
2611                         * Set MER to 0.0 */
2612                 iMER = 0;
2613         } else {
2614                 SqrErrIQ = (EqRegTdSqrErrI + EqRegTdSqrErrQ) <<
2615                         EqRegTdSqrErrExp;
2616                 if ((transmissionParams &
2617                         OFDM_SC_RA_RAM_OP_PARAM_MODE__M)
2618                         == OFDM_SC_RA_RAM_OP_PARAM_MODE_2K)
2619                         tpsCnt = 17;
2620                 else
2621                         tpsCnt = 68;
2622
2623                 /* IMER = 100 * log10 (x)
2624                         where x = (EqRegTdTpsPwrOfs^2 *
2625                         EqRegTdReqSmbCnt * tpsCnt)/SqrErrIQ
2626
2627                         => IMER = a + b -c
2628                         where a = 100 * log10 (EqRegTdTpsPwrOfs^2)
2629                         b = 100 * log10 (EqRegTdReqSmbCnt * tpsCnt)
2630                         c = 100 * log10 (SqrErrIQ)
2631                         */
2632
2633                 /* log(x) x = 9bits * 9bits->18 bits  */
2634                 a = Log10Times100(EqRegTdTpsPwrOfs *
2635                                         EqRegTdTpsPwrOfs);
2636                 /* log(x) x = 16bits * 7bits->23 bits  */
2637                 b = Log10Times100(EqRegTdReqSmbCnt * tpsCnt);
2638                 /* log(x) x = (16bits + 16bits) << 15 ->32 bits  */
2639                 c = Log10Times100(SqrErrIQ);
2640
2641                 iMER = a + b;
2642                 /* No negative MER, clip to zero */
2643                 if (iMER > c)
2644                         iMER -= c;
2645                 else
2646                         iMER = 0;
2647         }
2648         *pSignalToNoise = iMER;
2649
2650 error:
2651         if (status < 0)
2652                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2653         return status;
2654 }
2655
2656 static int GetSignalToNoise(struct drxk_state *state, s32 *pSignalToNoise)
2657 {
2658         dprintk(1, "\n");
2659
2660         *pSignalToNoise = 0;
2661         switch (state->m_OperationMode) {
2662         case OM_DVBT:
2663                 return GetDVBTSignalToNoise(state, pSignalToNoise);
2664         case OM_QAM_ITU_A:
2665         case OM_QAM_ITU_C:
2666                 return GetQAMSignalToNoise(state, pSignalToNoise);
2667         default:
2668                 break;
2669         }
2670         return 0;
2671 }
2672
2673 #if 0
2674 static int GetDVBTQuality(struct drxk_state *state, s32 *pQuality)
2675 {
2676         /* SNR Values for quasi errorfree reception rom Nordig 2.2 */
2677         int status = 0;
2678
2679         dprintk(1, "\n");
2680
2681         static s32 QE_SN[] = {
2682                 51,             /* QPSK 1/2 */
2683                 69,             /* QPSK 2/3 */
2684                 79,             /* QPSK 3/4 */
2685                 89,             /* QPSK 5/6 */
2686                 97,             /* QPSK 7/8 */
2687                 108,            /* 16-QAM 1/2 */
2688                 131,            /* 16-QAM 2/3 */
2689                 146,            /* 16-QAM 3/4 */
2690                 156,            /* 16-QAM 5/6 */
2691                 160,            /* 16-QAM 7/8 */
2692                 165,            /* 64-QAM 1/2 */
2693                 187,            /* 64-QAM 2/3 */
2694                 202,            /* 64-QAM 3/4 */
2695                 216,            /* 64-QAM 5/6 */
2696                 225,            /* 64-QAM 7/8 */
2697         };
2698
2699         *pQuality = 0;
2700
2701         do {
2702                 s32 SignalToNoise = 0;
2703                 u16 Constellation = 0;
2704                 u16 CodeRate = 0;
2705                 u32 SignalToNoiseRel;
2706                 u32 BERQuality;
2707
2708                 status = GetDVBTSignalToNoise(state, &SignalToNoise);
2709                 if (status < 0)
2710                         break;
2711                 status = read16(state, OFDM_EQ_TOP_TD_TPS_CONST__A, &Constellation);
2712                 if (status < 0)
2713                         break;
2714                 Constellation &= OFDM_EQ_TOP_TD_TPS_CONST__M;
2715
2716                 status = read16(state, OFDM_EQ_TOP_TD_TPS_CODE_HP__A, &CodeRate);
2717                 if (status < 0)
2718                         break;
2719                 CodeRate &= OFDM_EQ_TOP_TD_TPS_CODE_HP__M;
2720
2721                 if (Constellation > OFDM_EQ_TOP_TD_TPS_CONST_64QAM ||
2722                     CodeRate > OFDM_EQ_TOP_TD_TPS_CODE_LP_7_8)
2723                         break;
2724                 SignalToNoiseRel = SignalToNoise -
2725                     QE_SN[Constellation * 5 + CodeRate];
2726                 BERQuality = 100;
2727
2728                 if (SignalToNoiseRel < -70)
2729                         *pQuality = 0;
2730                 else if (SignalToNoiseRel < 30)
2731                         *pQuality = ((SignalToNoiseRel + 70) *
2732                                      BERQuality) / 100;
2733                 else
2734                         *pQuality = BERQuality;
2735         } while (0);
2736         return 0;
2737 };
2738
2739 static int GetDVBCQuality(struct drxk_state *state, s32 *pQuality)
2740 {
2741         int status = 0;
2742         *pQuality = 0;
2743
2744         dprintk(1, "\n");
2745
2746         do {
2747                 u32 SignalToNoise = 0;
2748                 u32 BERQuality = 100;
2749                 u32 SignalToNoiseRel = 0;
2750
2751                 status = GetQAMSignalToNoise(state, &SignalToNoise);
2752                 if (status < 0)
2753                         break;
2754
2755                 switch (state->props.modulation) {
2756                 case QAM_16:
2757                         SignalToNoiseRel = SignalToNoise - 200;
2758                         break;
2759                 case QAM_32:
2760                         SignalToNoiseRel = SignalToNoise - 230;
2761                         break;  /* Not in NorDig */
2762                 case QAM_64:
2763                         SignalToNoiseRel = SignalToNoise - 260;
2764                         break;
2765                 case QAM_128:
2766                         SignalToNoiseRel = SignalToNoise - 290;
2767                         break;
2768                 default:
2769                 case QAM_256:
2770                         SignalToNoiseRel = SignalToNoise - 320;
2771                         break;
2772                 }
2773
2774                 if (SignalToNoiseRel < -70)
2775                         *pQuality = 0;
2776                 else if (SignalToNoiseRel < 30)
2777                         *pQuality = ((SignalToNoiseRel + 70) *
2778                                      BERQuality) / 100;
2779                 else
2780                         *pQuality = BERQuality;
2781         } while (0);
2782
2783         return status;
2784 }
2785
2786 static int GetQuality(struct drxk_state *state, s32 *pQuality)
2787 {
2788         dprintk(1, "\n");
2789
2790         switch (state->m_OperationMode) {
2791         case OM_DVBT:
2792                 return GetDVBTQuality(state, pQuality);
2793         case OM_QAM_ITU_A:
2794                 return GetDVBCQuality(state, pQuality);
2795         default:
2796                 break;
2797         }
2798
2799         return 0;
2800 }
2801 #endif
2802
2803 /* Free data ram in SIO HI */
2804 #define SIO_HI_RA_RAM_USR_BEGIN__A 0x420040
2805 #define SIO_HI_RA_RAM_USR_END__A   0x420060
2806
2807 #define DRXK_HI_ATOMIC_BUF_START (SIO_HI_RA_RAM_USR_BEGIN__A)
2808 #define DRXK_HI_ATOMIC_BUF_END   (SIO_HI_RA_RAM_USR_BEGIN__A + 7)
2809 #define DRXK_HI_ATOMIC_READ      SIO_HI_RA_RAM_PAR_3_ACP_RW_READ
2810 #define DRXK_HI_ATOMIC_WRITE     SIO_HI_RA_RAM_PAR_3_ACP_RW_WRITE
2811
2812 #define DRXDAP_FASI_ADDR2BLOCK(addr)  (((addr) >> 22) & 0x3F)
2813 #define DRXDAP_FASI_ADDR2BANK(addr)   (((addr) >> 16) & 0x3F)
2814 #define DRXDAP_FASI_ADDR2OFFSET(addr) ((addr) & 0x7FFF)
2815
2816 static int ConfigureI2CBridge(struct drxk_state *state, bool bEnableBridge)
2817 {
2818         int status = -EINVAL;
2819
2820         dprintk(1, "\n");
2821
2822         if (state->m_DrxkState == DRXK_UNINITIALIZED)
2823                 goto error;
2824         if (state->m_DrxkState == DRXK_POWERED_DOWN)
2825                 goto error;
2826
2827         if (state->no_i2c_bridge)
2828                 return 0;
2829
2830         status = write16(state, SIO_HI_RA_RAM_PAR_1__A, SIO_HI_RA_RAM_PAR_1_PAR1_SEC_KEY);
2831         if (status < 0)
2832                 goto error;
2833         if (bEnableBridge) {
2834                 status = write16(state, SIO_HI_RA_RAM_PAR_2__A, SIO_HI_RA_RAM_PAR_2_BRD_CFG_CLOSED);
2835                 if (status < 0)
2836                         goto error;
2837         } else {
2838                 status = write16(state, SIO_HI_RA_RAM_PAR_2__A, SIO_HI_RA_RAM_PAR_2_BRD_CFG_OPEN);
2839                 if (status < 0)
2840                         goto error;
2841         }
2842
2843         status = HI_Command(state, SIO_HI_RA_RAM_CMD_BRDCTRL, 0);
2844
2845 error:
2846         if (status < 0)
2847                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2848         return status;
2849 }
2850
2851 static int SetPreSaw(struct drxk_state *state,
2852                      struct SCfgPreSaw *pPreSawCfg)
2853 {
2854         int status = -EINVAL;
2855
2856         dprintk(1, "\n");
2857
2858         if ((pPreSawCfg == NULL)
2859             || (pPreSawCfg->reference > IQM_AF_PDREF__M))
2860                 goto error;
2861
2862         status = write16(state, IQM_AF_PDREF__A, pPreSawCfg->reference);
2863 error:
2864         if (status < 0)
2865                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2866         return status;
2867 }
2868
2869 static int BLDirectCmd(struct drxk_state *state, u32 targetAddr,
2870                        u16 romOffset, u16 nrOfElements, u32 timeOut)
2871 {
2872         u16 blStatus = 0;
2873         u16 offset = (u16) ((targetAddr >> 0) & 0x00FFFF);
2874         u16 blockbank = (u16) ((targetAddr >> 16) & 0x000FFF);
2875         int status;
2876         unsigned long end;
2877
2878         dprintk(1, "\n");
2879
2880         mutex_lock(&state->mutex);
2881         status = write16(state, SIO_BL_MODE__A, SIO_BL_MODE_DIRECT);
2882         if (status < 0)
2883                 goto error;
2884         status = write16(state, SIO_BL_TGT_HDR__A, blockbank);
2885         if (status < 0)
2886                 goto error;
2887         status = write16(state, SIO_BL_TGT_ADDR__A, offset);
2888         if (status < 0)
2889                 goto error;
2890         status = write16(state, SIO_BL_SRC_ADDR__A, romOffset);
2891         if (status < 0)
2892                 goto error;
2893         status = write16(state, SIO_BL_SRC_LEN__A, nrOfElements);
2894         if (status < 0)
2895                 goto error;
2896         status = write16(state, SIO_BL_ENABLE__A, SIO_BL_ENABLE_ON);
2897         if (status < 0)
2898                 goto error;
2899
2900         end = jiffies + msecs_to_jiffies(timeOut);
2901         do {
2902                 status = read16(state, SIO_BL_STATUS__A, &blStatus);
2903                 if (status < 0)
2904                         goto error;
2905         } while ((blStatus == 0x1) && time_is_after_jiffies(end));
2906         if (blStatus == 0x1) {
2907                 printk(KERN_ERR "drxk: SIO not ready\n");
2908                 status = -EINVAL;
2909                 goto error2;
2910         }
2911 error:
2912         if (status < 0)
2913                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2914 error2:
2915         mutex_unlock(&state->mutex);
2916         return status;
2917
2918 }
2919
2920 static int ADCSyncMeasurement(struct drxk_state *state, u16 *count)
2921 {
2922         u16 data = 0;
2923         int status;
2924
2925         dprintk(1, "\n");
2926
2927         /* Start measurement */
2928         status = write16(state, IQM_AF_COMM_EXEC__A, IQM_AF_COMM_EXEC_ACTIVE);
2929         if (status < 0)
2930                 goto error;
2931         status = write16(state, IQM_AF_START_LOCK__A, 1);
2932         if (status < 0)
2933                 goto error;
2934
2935         *count = 0;
2936         status = read16(state, IQM_AF_PHASE0__A, &data);
2937         if (status < 0)
2938                 goto error;
2939         if (data == 127)
2940                 *count = *count + 1;
2941         status = read16(state, IQM_AF_PHASE1__A, &data);
2942         if (status < 0)
2943                 goto error;
2944         if (data == 127)
2945                 *count = *count + 1;
2946         status = read16(state, IQM_AF_PHASE2__A, &data);
2947         if (status < 0)
2948                 goto error;
2949         if (data == 127)
2950                 *count = *count + 1;
2951
2952 error:
2953         if (status < 0)
2954                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2955         return status;
2956 }
2957
2958 static int ADCSynchronization(struct drxk_state *state)
2959 {
2960         u16 count = 0;
2961         int status;
2962
2963         dprintk(1, "\n");
2964
2965         status = ADCSyncMeasurement(state, &count);
2966         if (status < 0)
2967                 goto error;
2968
2969         if (count == 1) {
2970                 /* Try sampling on a diffrent edge */
2971                 u16 clkNeg = 0;
2972
2973                 status = read16(state, IQM_AF_CLKNEG__A, &clkNeg);
2974                 if (status < 0)
2975                         goto error;
2976                 if ((clkNeg | IQM_AF_CLKNEG_CLKNEGDATA__M) ==
2977                         IQM_AF_CLKNEG_CLKNEGDATA_CLK_ADC_DATA_POS) {
2978                         clkNeg &= (~(IQM_AF_CLKNEG_CLKNEGDATA__M));
2979                         clkNeg |=
2980                                 IQM_AF_CLKNEG_CLKNEGDATA_CLK_ADC_DATA_NEG;
2981                 } else {
2982                         clkNeg &= (~(IQM_AF_CLKNEG_CLKNEGDATA__M));
2983                         clkNeg |=
2984                                 IQM_AF_CLKNEG_CLKNEGDATA_CLK_ADC_DATA_POS;
2985                 }
2986                 status = write16(state, IQM_AF_CLKNEG__A, clkNeg);
2987                 if (status < 0)
2988                         goto error;
2989                 status = ADCSyncMeasurement(state, &count);
2990                 if (status < 0)
2991                         goto error;
2992         }
2993
2994         if (count < 2)
2995                 status = -EINVAL;
2996 error:
2997         if (status < 0)
2998                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
2999         return status;
3000 }
3001
3002 static int SetFrequencyShifter(struct drxk_state *state,
3003                                u16 intermediateFreqkHz,
3004                                s32 tunerFreqOffset, bool isDTV)
3005 {
3006         bool selectPosImage = false;
3007         u32 rfFreqResidual = tunerFreqOffset;
3008         u32 fmFrequencyShift = 0;
3009         bool tunerMirror = !state->m_bMirrorFreqSpect;
3010         u32 adcFreq;
3011         bool adcFlip;
3012         int status;
3013         u32 ifFreqActual;
3014         u32 samplingFrequency = (u32) (state->m_sysClockFreq / 3);
3015         u32 frequencyShift;
3016         bool imageToSelect;
3017
3018         dprintk(1, "\n");
3019
3020         /*
3021            Program frequency shifter
3022            No need to account for mirroring on RF
3023          */
3024         if (isDTV) {
3025                 if ((state->m_OperationMode == OM_QAM_ITU_A) ||
3026                     (state->m_OperationMode == OM_QAM_ITU_C) ||
3027                     (state->m_OperationMode == OM_DVBT))
3028                         selectPosImage = true;
3029                 else
3030                         selectPosImage = false;
3031         }
3032         if (tunerMirror)
3033                 /* tuner doesn't mirror */
3034                 ifFreqActual = intermediateFreqkHz +
3035                     rfFreqResidual + fmFrequencyShift;
3036         else
3037                 /* tuner mirrors */
3038                 ifFreqActual = intermediateFreqkHz -
3039                     rfFreqResidual - fmFrequencyShift;
3040         if (ifFreqActual > samplingFrequency / 2) {
3041                 /* adc mirrors */
3042                 adcFreq = samplingFrequency - ifFreqActual;
3043                 adcFlip = true;
3044         } else {
3045                 /* adc doesn't mirror */
3046                 adcFreq = ifFreqActual;
3047                 adcFlip = false;
3048         }
3049
3050         frequencyShift = adcFreq;
3051         imageToSelect = state->m_rfmirror ^ tunerMirror ^
3052             adcFlip ^ selectPosImage;
3053         state->m_IqmFsRateOfs =
3054             Frac28a((frequencyShift), samplingFrequency);
3055
3056         if (imageToSelect)
3057                 state->m_IqmFsRateOfs = ~state->m_IqmFsRateOfs + 1;
3058
3059         /* Program frequency shifter with tuner offset compensation */
3060         /* frequencyShift += tunerFreqOffset; TODO */
3061         status = write32(state, IQM_FS_RATE_OFS_LO__A,
3062                          state->m_IqmFsRateOfs);
3063         if (status < 0)
3064                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3065         return status;
3066 }
3067
3068 static int InitAGC(struct drxk_state *state, bool isDTV)
3069 {
3070         u16 ingainTgt = 0;
3071         u16 ingainTgtMin = 0;
3072         u16 ingainTgtMax = 0;
3073         u16 clpCyclen = 0;
3074         u16 clpSumMin = 0;
3075         u16 clpDirTo = 0;
3076         u16 snsSumMin = 0;
3077         u16 snsSumMax = 0;
3078         u16 clpSumMax = 0;
3079         u16 snsDirTo = 0;
3080         u16 kiInnergainMin = 0;
3081         u16 ifIaccuHiTgt = 0;
3082         u16 ifIaccuHiTgtMin = 0;
3083         u16 ifIaccuHiTgtMax = 0;
3084         u16 data = 0;
3085         u16 fastClpCtrlDelay = 0;
3086         u16 clpCtrlMode = 0;
3087         int status = 0;
3088
3089         dprintk(1, "\n");
3090
3091         /* Common settings */
3092         snsSumMax = 1023;
3093         ifIaccuHiTgtMin = 2047;
3094         clpCyclen = 500;
3095         clpSumMax = 1023;
3096
3097         /* AGCInit() not available for DVBT; init done in microcode */
3098         if (!IsQAM(state)) {
3099                 printk(KERN_ERR "drxk: %s: mode %d is not DVB-C\n", __func__, state->m_OperationMode);
3100                 return -EINVAL;
3101         }
3102
3103         /* FIXME: Analog TV AGC require different settings */
3104
3105         /* Standard specific settings */
3106         clpSumMin = 8;
3107         clpDirTo = (u16) -9;
3108         clpCtrlMode = 0;
3109         snsSumMin = 8;
3110         snsDirTo = (u16) -9;
3111         kiInnergainMin = (u16) -1030;
3112         ifIaccuHiTgtMax = 0x2380;
3113         ifIaccuHiTgt = 0x2380;
3114         ingainTgtMin = 0x0511;
3115         ingainTgt = 0x0511;
3116         ingainTgtMax = 5119;
3117         fastClpCtrlDelay = state->m_qamIfAgcCfg.FastClipCtrlDelay;
3118
3119         status = write16(state, SCU_RAM_AGC_FAST_CLP_CTRL_DELAY__A, fastClpCtrlDelay);
3120         if (status < 0)
3121                 goto error;
3122
3123         status = write16(state, SCU_RAM_AGC_CLP_CTRL_MODE__A, clpCtrlMode);
3124         if (status < 0)
3125                 goto error;
3126         status = write16(state, SCU_RAM_AGC_INGAIN_TGT__A, ingainTgt);
3127         if (status < 0)
3128                 goto error;
3129         status = write16(state, SCU_RAM_AGC_INGAIN_TGT_MIN__A, ingainTgtMin);
3130         if (status < 0)
3131                 goto error;
3132         status = write16(state, SCU_RAM_AGC_INGAIN_TGT_MAX__A, ingainTgtMax);
3133         if (status < 0)
3134                 goto error;
3135         status = write16(state, SCU_RAM_AGC_IF_IACCU_HI_TGT_MIN__A, ifIaccuHiTgtMin);
3136         if (status < 0)
3137                 goto error;
3138         status = write16(state, SCU_RAM_AGC_IF_IACCU_HI_TGT_MAX__A, ifIaccuHiTgtMax);
3139         if (status < 0)
3140                 goto error;
3141         status = write16(state, SCU_RAM_AGC_IF_IACCU_HI__A, 0);
3142         if (status < 0)
3143                 goto error;
3144         status = write16(state, SCU_RAM_AGC_IF_IACCU_LO__A, 0);
3145         if (status < 0)
3146                 goto error;
3147         status = write16(state, SCU_RAM_AGC_RF_IACCU_HI__A, 0);
3148         if (status < 0)
3149                 goto error;
3150         status = write16(state, SCU_RAM_AGC_RF_IACCU_LO__A, 0);
3151         if (status < 0)
3152                 goto error;
3153         status = write16(state, SCU_RAM_AGC_CLP_SUM_MAX__A, clpSumMax);
3154         if (status < 0)
3155                 goto error;
3156         status = write16(state, SCU_RAM_AGC_SNS_SUM_MAX__A, snsSumMax);
3157         if (status < 0)
3158                 goto error;
3159
3160         status = write16(state, SCU_RAM_AGC_KI_INNERGAIN_MIN__A, kiInnergainMin);
3161         if (status < 0)
3162                 goto error;
3163         status = write16(state, SCU_RAM_AGC_IF_IACCU_HI_TGT__A, ifIaccuHiTgt);
3164         if (status < 0)
3165                 goto error;
3166         status = write16(state, SCU_RAM_AGC_CLP_CYCLEN__A, clpCyclen);
3167         if (status < 0)
3168                 goto error;
3169
3170         status = write16(state, SCU_RAM_AGC_RF_SNS_DEV_MAX__A, 1023);
3171         if (status < 0)
3172                 goto error;
3173         status = write16(state, SCU_RAM_AGC_RF_SNS_DEV_MIN__A, (u16) -1023);
3174         if (status < 0)
3175                 goto error;
3176         status = write16(state, SCU_RAM_AGC_FAST_SNS_CTRL_DELAY__A, 50);
3177         if (status < 0)
3178                 goto error;
3179
3180         status = write16(state, SCU_RAM_AGC_KI_MAXMINGAIN_TH__A, 20);
3181         if (status < 0)
3182                 goto error;
3183         status = write16(state, SCU_RAM_AGC_CLP_SUM_MIN__A, clpSumMin);
3184         if (status < 0)
3185                 goto error;
3186         status = write16(state, SCU_RAM_AGC_SNS_SUM_MIN__A, snsSumMin);
3187         if (status < 0)
3188                 goto error;
3189         status = write16(state, SCU_RAM_AGC_CLP_DIR_TO__A, clpDirTo);
3190         if (status < 0)
3191                 goto error;
3192         status = write16(state, SCU_RAM_AGC_SNS_DIR_TO__A, snsDirTo);
3193         if (status < 0)
3194                 goto error;
3195         status = write16(state, SCU_RAM_AGC_KI_MINGAIN__A, 0x7fff);
3196         if (status < 0)
3197                 goto error;
3198         status = write16(state, SCU_RAM_AGC_KI_MAXGAIN__A, 0x0);
3199         if (status < 0)
3200                 goto error;
3201         status = write16(state, SCU_RAM_AGC_KI_MIN__A, 0x0117);
3202         if (status < 0)
3203                 goto error;
3204         status = write16(state, SCU_RAM_AGC_KI_MAX__A, 0x0657);
3205         if (status < 0)
3206                 goto error;
3207         status = write16(state, SCU_RAM_AGC_CLP_SUM__A, 0);
3208         if (status < 0)
3209                 goto error;
3210         status = write16(state, SCU_RAM_AGC_CLP_CYCCNT__A, 0);
3211         if (status < 0)
3212                 goto error;
3213         status = write16(state, SCU_RAM_AGC_CLP_DIR_WD__A, 0);
3214         if (status < 0)
3215                 goto error;
3216         status = write16(state, SCU_RAM_AGC_CLP_DIR_STP__A, 1);
3217         if (status < 0)
3218                 goto error;
3219         status = write16(state, SCU_RAM_AGC_SNS_SUM__A, 0);
3220         if (status < 0)
3221                 goto error;
3222         status = write16(state, SCU_RAM_AGC_SNS_CYCCNT__A, 0);
3223         if (status < 0)
3224                 goto error;
3225         status = write16(state, SCU_RAM_AGC_SNS_DIR_WD__A, 0);
3226         if (status < 0)
3227                 goto error;
3228         status = write16(state, SCU_RAM_AGC_SNS_DIR_STP__A, 1);
3229         if (status < 0)
3230                 goto error;
3231         status = write16(state, SCU_RAM_AGC_SNS_CYCLEN__A, 500);
3232         if (status < 0)
3233                 goto error;
3234         status = write16(state, SCU_RAM_AGC_KI_CYCLEN__A, 500);
3235         if (status < 0)
3236                 goto error;
3237
3238         /* Initialize inner-loop KI gain factors */
3239         status = read16(state, SCU_RAM_AGC_KI__A, &data);
3240         if (status < 0)
3241                 goto error;
3242
3243         data = 0x0657;
3244         data &= ~SCU_RAM_AGC_KI_RF__M;
3245         data |= (DRXK_KI_RAGC_QAM << SCU_RAM_AGC_KI_RF__B);
3246         data &= ~SCU_RAM_AGC_KI_IF__M;
3247         data |= (DRXK_KI_IAGC_QAM << SCU_RAM_AGC_KI_IF__B);
3248
3249         status = write16(state, SCU_RAM_AGC_KI__A, data);
3250 error:
3251         if (status < 0)
3252                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3253         return status;
3254 }
3255
3256 static int DVBTQAMGetAccPktErr(struct drxk_state *state, u16 *packetErr)
3257 {
3258         int status;
3259
3260         dprintk(1, "\n");
3261         if (packetErr == NULL)
3262                 status = write16(state, SCU_RAM_FEC_ACCUM_PKT_FAILURES__A, 0);
3263         else
3264                 status = read16(state, SCU_RAM_FEC_ACCUM_PKT_FAILURES__A, packetErr);
3265         if (status < 0)
3266                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3267         return status;
3268 }
3269
3270 static int DVBTScCommand(struct drxk_state *state,
3271                          u16 cmd, u16 subcmd,
3272                          u16 param0, u16 param1, u16 param2,
3273                          u16 param3, u16 param4)
3274 {
3275         u16 curCmd = 0;
3276         u16 errCode = 0;
3277         u16 retryCnt = 0;
3278         u16 scExec = 0;
3279         int status;
3280
3281         dprintk(1, "\n");
3282         status = read16(state, OFDM_SC_COMM_EXEC__A, &scExec);
3283         if (scExec != 1) {
3284                 /* SC is not running */
3285                 status = -EINVAL;
3286         }
3287         if (status < 0)
3288                 goto error;
3289
3290         /* Wait until sc is ready to receive command */
3291         retryCnt = 0;
3292         do {
3293                 msleep(1);
3294                 status = read16(state, OFDM_SC_RA_RAM_CMD__A, &curCmd);
3295                 retryCnt++;
3296         } while ((curCmd != 0) && (retryCnt < DRXK_MAX_RETRIES));
3297         if (retryCnt >= DRXK_MAX_RETRIES && (status < 0))
3298                 goto error;
3299
3300         /* Write sub-command */
3301         switch (cmd) {
3302                 /* All commands using sub-cmd */
3303         case OFDM_SC_RA_RAM_CMD_PROC_START:
3304         case OFDM_SC_RA_RAM_CMD_SET_PREF_PARAM:
3305         case OFDM_SC_RA_RAM_CMD_PROGRAM_PARAM:
3306                 status = write16(state, OFDM_SC_RA_RAM_CMD_ADDR__A, subcmd);
3307                 if (status < 0)
3308                         goto error;
3309                 break;
3310         default:
3311                 /* Do nothing */
3312                 break;
3313         }
3314
3315         /* Write needed parameters and the command */
3316         switch (cmd) {
3317                 /* All commands using 5 parameters */
3318                 /* All commands using 4 parameters */
3319                 /* All commands using 3 parameters */
3320                 /* All commands using 2 parameters */
3321         case OFDM_SC_RA_RAM_CMD_PROC_START:
3322         case OFDM_SC_RA_RAM_CMD_SET_PREF_PARAM:
3323         case OFDM_SC_RA_RAM_CMD_PROGRAM_PARAM:
3324                 status = write16(state, OFDM_SC_RA_RAM_PARAM1__A, param1);
3325                 /* All commands using 1 parameters */
3326         case OFDM_SC_RA_RAM_CMD_SET_ECHO_TIMING:
3327         case OFDM_SC_RA_RAM_CMD_USER_IO:
3328                 status = write16(state, OFDM_SC_RA_RAM_PARAM0__A, param0);
3329                 /* All commands using 0 parameters */
3330         case OFDM_SC_RA_RAM_CMD_GET_OP_PARAM:
3331         case OFDM_SC_RA_RAM_CMD_NULL:
3332                 /* Write command */
3333                 status = write16(state, OFDM_SC_RA_RAM_CMD__A, cmd);
3334                 break;
3335         default:
3336                 /* Unknown command */
3337                 status = -EINVAL;
3338         }
3339         if (status < 0)
3340                 goto error;
3341
3342         /* Wait until sc is ready processing command */
3343         retryCnt = 0;
3344         do {
3345                 msleep(1);
3346                 status = read16(state, OFDM_SC_RA_RAM_CMD__A, &curCmd);
3347                 retryCnt++;
3348         } while ((curCmd != 0) && (retryCnt < DRXK_MAX_RETRIES));
3349         if (retryCnt >= DRXK_MAX_RETRIES && (status < 0))
3350                 goto error;
3351
3352         /* Check for illegal cmd */
3353         status = read16(state, OFDM_SC_RA_RAM_CMD_ADDR__A, &errCode);
3354         if (errCode == 0xFFFF) {
3355                 /* illegal command */
3356                 status = -EINVAL;
3357         }
3358         if (status < 0)
3359                 goto error;
3360
3361         /* Retreive results parameters from SC */
3362         switch (cmd) {
3363                 /* All commands yielding 5 results */
3364                 /* All commands yielding 4 results */
3365                 /* All commands yielding 3 results */
3366                 /* All commands yielding 2 results */
3367                 /* All commands yielding 1 result */
3368         case OFDM_SC_RA_RAM_CMD_USER_IO:
3369         case OFDM_SC_RA_RAM_CMD_GET_OP_PARAM:
3370                 status = read16(state, OFDM_SC_RA_RAM_PARAM0__A, &(param0));
3371                 /* All commands yielding 0 results */
3372         case OFDM_SC_RA_RAM_CMD_SET_ECHO_TIMING:
3373         case OFDM_SC_RA_RAM_CMD_SET_TIMER:
3374         case OFDM_SC_RA_RAM_CMD_PROC_START:
3375         case OFDM_SC_RA_RAM_CMD_SET_PREF_PARAM:
3376         case OFDM_SC_RA_RAM_CMD_PROGRAM_PARAM:
3377         case OFDM_SC_RA_RAM_CMD_NULL:
3378                 break;
3379         default:
3380                 /* Unknown command */
3381                 status = -EINVAL;
3382                 break;
3383         }                       /* switch (cmd->cmd) */
3384 error:
3385         if (status < 0)
3386                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3387         return status;
3388 }
3389
3390 static int PowerUpDVBT(struct drxk_state *state)
3391 {
3392         enum DRXPowerMode powerMode = DRX_POWER_UP;
3393         int status;
3394
3395         dprintk(1, "\n");
3396         status = CtrlPowerMode(state, &powerMode);
3397         if (status < 0)
3398                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3399         return status;
3400 }
3401
3402 static int DVBTCtrlSetIncEnable(struct drxk_state *state, bool *enabled)
3403 {
3404         int status;
3405
3406         dprintk(1, "\n");
3407         if (*enabled == true)
3408                 status = write16(state, IQM_CF_BYPASSDET__A, 0);
3409         else
3410                 status = write16(state, IQM_CF_BYPASSDET__A, 1);
3411         if (status < 0)
3412                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3413         return status;
3414 }
3415
3416 #define DEFAULT_FR_THRES_8K     4000
3417 static int DVBTCtrlSetFrEnable(struct drxk_state *state, bool *enabled)
3418 {
3419
3420         int status;
3421
3422         dprintk(1, "\n");
3423         if (*enabled == true) {
3424                 /* write mask to 1 */
3425                 status = write16(state, OFDM_SC_RA_RAM_FR_THRES_8K__A,
3426                                    DEFAULT_FR_THRES_8K);
3427         } else {
3428                 /* write mask to 0 */
3429                 status = write16(state, OFDM_SC_RA_RAM_FR_THRES_8K__A, 0);
3430         }
3431         if (status < 0)
3432                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3433
3434         return status;
3435 }
3436
3437 static int DVBTCtrlSetEchoThreshold(struct drxk_state *state,
3438                                     struct DRXKCfgDvbtEchoThres_t *echoThres)
3439 {
3440         u16 data = 0;
3441         int status;
3442
3443         dprintk(1, "\n");
3444         status = read16(state, OFDM_SC_RA_RAM_ECHO_THRES__A, &data);
3445         if (status < 0)
3446                 goto error;
3447
3448         switch (echoThres->fftMode) {
3449         case DRX_FFTMODE_2K:
3450                 data &= ~OFDM_SC_RA_RAM_ECHO_THRES_2K__M;
3451                 data |= ((echoThres->threshold <<
3452                         OFDM_SC_RA_RAM_ECHO_THRES_2K__B)
3453                         & (OFDM_SC_RA_RAM_ECHO_THRES_2K__M));
3454                 break;
3455         case DRX_FFTMODE_8K:
3456                 data &= ~OFDM_SC_RA_RAM_ECHO_THRES_8K__M;
3457                 data |= ((echoThres->threshold <<
3458                         OFDM_SC_RA_RAM_ECHO_THRES_8K__B)
3459                         & (OFDM_SC_RA_RAM_ECHO_THRES_8K__M));
3460                 break;
3461         default:
3462                 return -EINVAL;
3463         }
3464
3465         status = write16(state, OFDM_SC_RA_RAM_ECHO_THRES__A, data);
3466 error:
3467         if (status < 0)
3468                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3469         return status;
3470 }
3471
3472 static int DVBTCtrlSetSqiSpeed(struct drxk_state *state,
3473                                enum DRXKCfgDvbtSqiSpeed *speed)
3474 {
3475         int status = -EINVAL;
3476
3477         dprintk(1, "\n");
3478
3479         switch (*speed) {
3480         case DRXK_DVBT_SQI_SPEED_FAST:
3481         case DRXK_DVBT_SQI_SPEED_MEDIUM:
3482         case DRXK_DVBT_SQI_SPEED_SLOW:
3483                 break;
3484         default:
3485                 goto error;
3486         }
3487         status = write16(state, SCU_RAM_FEC_PRE_RS_BER_FILTER_SH__A,
3488                            (u16) *speed);
3489 error:
3490         if (status < 0)
3491                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3492         return status;
3493 }
3494
3495 /*============================================================================*/
3496
3497 /**
3498 * \brief Activate DVBT specific presets
3499 * \param demod instance of demodulator.
3500 * \return DRXStatus_t.
3501 *
3502 * Called in DVBTSetStandard
3503 *
3504 */
3505 static int DVBTActivatePresets(struct drxk_state *state)
3506 {
3507         int status;
3508         bool setincenable = false;
3509         bool setfrenable = true;
3510
3511         struct DRXKCfgDvbtEchoThres_t echoThres2k = { 0, DRX_FFTMODE_2K };
3512         struct DRXKCfgDvbtEchoThres_t echoThres8k = { 0, DRX_FFTMODE_8K };
3513
3514         dprintk(1, "\n");
3515         status = DVBTCtrlSetIncEnable(state, &setincenable);
3516         if (status < 0)
3517                 goto error;
3518         status = DVBTCtrlSetFrEnable(state, &setfrenable);
3519         if (status < 0)
3520                 goto error;
3521         status = DVBTCtrlSetEchoThreshold(state, &echoThres2k);
3522         if (status < 0)
3523                 goto error;
3524         status = DVBTCtrlSetEchoThreshold(state, &echoThres8k);
3525         if (status < 0)
3526                 goto error;
3527         status = write16(state, SCU_RAM_AGC_INGAIN_TGT_MAX__A, state->m_dvbtIfAgcCfg.IngainTgtMax);
3528 error:
3529         if (status < 0)
3530                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3531         return status;
3532 }
3533
3534 /*============================================================================*/
3535
3536 /**
3537 * \brief Initialize channelswitch-independent settings for DVBT.
3538 * \param demod instance of demodulator.
3539 * \return DRXStatus_t.
3540 *
3541 * For ROM code channel filter taps are loaded from the bootloader. For microcode
3542 * the DVB-T taps from the drxk_filters.h are used.
3543 */
3544 static int SetDVBTStandard(struct drxk_state *state,
3545                            enum OperationMode oMode)
3546 {
3547         u16 cmdResult = 0;
3548         u16 data = 0;
3549         int status;
3550
3551         dprintk(1, "\n");
3552
3553         PowerUpDVBT(state);
3554         /* added antenna switch */
3555         SwitchAntennaToDVBT(state);
3556         /* send OFDM reset command */
3557         status = scu_command(state, SCU_RAM_COMMAND_STANDARD_OFDM | SCU_RAM_COMMAND_CMD_DEMOD_RESET, 0, NULL, 1, &cmdResult);
3558         if (status < 0)
3559                 goto error;
3560
3561         /* send OFDM setenv command */
3562         status = scu_command(state, SCU_RAM_COMMAND_STANDARD_OFDM | SCU_RAM_COMMAND_CMD_DEMOD_SET_ENV, 0, NULL, 1, &cmdResult);
3563         if (status < 0)
3564                 goto error;
3565
3566         /* reset datapath for OFDM, processors first */
3567         status = write16(state, OFDM_SC_COMM_EXEC__A, OFDM_SC_COMM_EXEC_STOP);
3568         if (status < 0)
3569                 goto error;
3570         status = write16(state, OFDM_LC_COMM_EXEC__A, OFDM_LC_COMM_EXEC_STOP);
3571         if (status < 0)
3572                 goto error;
3573         status = write16(state, IQM_COMM_EXEC__A, IQM_COMM_EXEC_B_STOP);
3574         if (status < 0)
3575                 goto error;
3576
3577         /* IQM setup */
3578         /* synchronize on ofdstate->m_festart */
3579         status = write16(state, IQM_AF_UPD_SEL__A, 1);
3580         if (status < 0)
3581                 goto error;
3582         /* window size for clipping ADC detection */
3583         status = write16(state, IQM_AF_CLP_LEN__A, 0);
3584         if (status < 0)
3585                 goto error;
3586         /* window size for for sense pre-SAW detection */
3587         status = write16(state, IQM_AF_SNS_LEN__A, 0);
3588         if (status < 0)
3589                 goto error;
3590         /* sense threshold for sense pre-SAW detection */
3591         status = write16(state, IQM_AF_AMUX__A, IQM_AF_AMUX_SIGNAL2ADC);
3592         if (status < 0)
3593                 goto error;
3594         status = SetIqmAf(state, true);
3595         if (status < 0)
3596                 goto error;
3597
3598         status = write16(state, IQM_AF_AGC_RF__A, 0);
3599         if (status < 0)
3600                 goto error;
3601
3602         /* Impulse noise cruncher setup */
3603         status = write16(state, IQM_AF_INC_LCT__A, 0);  /* crunch in IQM_CF */
3604         if (status < 0)
3605                 goto error;
3606         status = write16(state, IQM_CF_DET_LCT__A, 0);  /* detect in IQM_CF */
3607         if (status < 0)
3608                 goto error;
3609         status = write16(state, IQM_CF_WND_LEN__A, 3);  /* peak detector window length */
3610         if (status < 0)
3611                 goto error;
3612
3613         status = write16(state, IQM_RC_STRETCH__A, 16);
3614         if (status < 0)
3615                 goto error;
3616         status = write16(state, IQM_CF_OUT_ENA__A, 0x4);        /* enable output 2 */
3617         if (status < 0)
3618                 goto error;
3619         status = write16(state, IQM_CF_DS_ENA__A, 0x4); /* decimate output 2 */
3620         if (status < 0)
3621                 goto error;
3622         status = write16(state, IQM_CF_SCALE__A, 1600);
3623         if (status < 0)
3624                 goto error;
3625         status = write16(state, IQM_CF_SCALE_SH__A, 0);
3626         if (status < 0)
3627                 goto error;
3628
3629         /* virtual clipping threshold for clipping ADC detection */
3630         status = write16(state, IQM_AF_CLP_TH__A, 448);
3631         if (status < 0)
3632                 goto error;
3633         status = write16(state, IQM_CF_DATATH__A, 495); /* crunching threshold */
3634         if (status < 0)
3635                 goto error;
3636
3637         status = BLChainCmd(state, DRXK_BL_ROM_OFFSET_TAPS_DVBT, DRXK_BLCC_NR_ELEMENTS_TAPS, DRXK_BLC_TIMEOUT);
3638         if (status < 0)
3639                 goto error;
3640
3641         status = write16(state, IQM_CF_PKDTH__A, 2);    /* peak detector threshold */
3642         if (status < 0)
3643                 goto error;
3644         status = write16(state, IQM_CF_POW_MEAS_LEN__A, 2);
3645         if (status < 0)
3646                 goto error;
3647         /* enable power measurement interrupt */
3648         status = write16(state, IQM_CF_COMM_INT_MSK__A, 1);
3649         if (status < 0)
3650                 goto error;
3651         status = write16(state, IQM_COMM_EXEC__A, IQM_COMM_EXEC_B_ACTIVE);
3652         if (status < 0)
3653                 goto error;
3654
3655         /* IQM will not be reset from here, sync ADC and update/init AGC */
3656         status = ADCSynchronization(state);
3657         if (status < 0)
3658                 goto error;
3659         status = SetPreSaw(state, &state->m_dvbtPreSawCfg);
3660         if (status < 0)
3661                 goto error;
3662
3663         /* Halt SCU to enable safe non-atomic accesses */
3664         status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_HOLD);
3665         if (status < 0)
3666                 goto error;
3667
3668         status = SetAgcRf(state, &state->m_dvbtRfAgcCfg, true);
3669         if (status < 0)
3670                 goto error;
3671         status = SetAgcIf(state, &state->m_dvbtIfAgcCfg, true);
3672         if (status < 0)
3673                 goto error;
3674
3675         /* Set Noise Estimation notch width and enable DC fix */
3676         status = read16(state, OFDM_SC_RA_RAM_CONFIG__A, &data);
3677         if (status < 0)
3678                 goto error;
3679         data |= OFDM_SC_RA_RAM_CONFIG_NE_FIX_ENABLE__M;
3680         status = write16(state, OFDM_SC_RA_RAM_CONFIG__A, data);
3681         if (status < 0)
3682                 goto error;
3683
3684         /* Activate SCU to enable SCU commands */
3685         status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_ACTIVE);
3686         if (status < 0)
3687                 goto error;
3688
3689         if (!state->m_DRXK_A3_ROM_CODE) {
3690                 /* AGCInit() is not done for DVBT, so set agcFastClipCtrlDelay  */
3691                 status = write16(state, SCU_RAM_AGC_FAST_CLP_CTRL_DELAY__A, state->m_dvbtIfAgcCfg.FastClipCtrlDelay);
3692                 if (status < 0)
3693                         goto error;
3694         }
3695
3696         /* OFDM_SC setup */
3697 #ifdef COMPILE_FOR_NONRT
3698         status = write16(state, OFDM_SC_RA_RAM_BE_OPT_DELAY__A, 1);
3699         if (status < 0)
3700                 goto error;
3701         status = write16(state, OFDM_SC_RA_RAM_BE_OPT_INIT_DELAY__A, 2);
3702         if (status < 0)
3703                 goto error;
3704 #endif
3705
3706         /* FEC setup */
3707         status = write16(state, FEC_DI_INPUT_CTL__A, 1);        /* OFDM input */
3708         if (status < 0)
3709                 goto error;
3710
3711
3712 #ifdef COMPILE_FOR_NONRT
3713         status = write16(state, FEC_RS_MEASUREMENT_PERIOD__A, 0x400);
3714         if (status < 0)
3715                 goto error;
3716 #else
3717         status = write16(state, FEC_RS_MEASUREMENT_PERIOD__A, 0x1000);
3718         if (status < 0)
3719                 goto error;
3720 #endif
3721         status = write16(state, FEC_RS_MEASUREMENT_PRESCALE__A, 0x0001);
3722         if (status < 0)
3723                 goto error;
3724
3725         /* Setup MPEG bus */
3726         status = MPEGTSDtoSetup(state, OM_DVBT);
3727         if (status < 0)
3728                 goto error;
3729         /* Set DVBT Presets */
3730         status = DVBTActivatePresets(state);
3731         if (status < 0)
3732                 goto error;
3733
3734 error:
3735         if (status < 0)
3736                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3737         return status;
3738 }
3739
3740 /*============================================================================*/
3741 /**
3742 * \brief Start dvbt demodulating for channel.
3743 * \param demod instance of demodulator.
3744 * \return DRXStatus_t.
3745 */
3746 static int DVBTStart(struct drxk_state *state)
3747 {
3748         u16 param1;
3749         int status;
3750         /* DRXKOfdmScCmd_t scCmd; */
3751
3752         dprintk(1, "\n");
3753         /* Start correct processes to get in lock */
3754         /* DRXK: OFDM_SC_RA_RAM_PROC_LOCKTRACK is no longer in mapfile! */
3755         param1 = OFDM_SC_RA_RAM_LOCKTRACK_MIN;
3756         status = DVBTScCommand(state, OFDM_SC_RA_RAM_CMD_PROC_START, 0, OFDM_SC_RA_RAM_SW_EVENT_RUN_NMASK__M, param1, 0, 0, 0);
3757         if (status < 0)
3758                 goto error;
3759         /* Start FEC OC */
3760         status = MPEGTSStart(state);
3761         if (status < 0)
3762                 goto error;
3763         status = write16(state, FEC_COMM_EXEC__A, FEC_COMM_EXEC_ACTIVE);
3764         if (status < 0)
3765                 goto error;
3766 error:
3767         if (status < 0)
3768                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
3769         return status;
3770 }
3771
3772
3773 /*============================================================================*/
3774
3775 /**
3776 * \brief Set up dvbt demodulator for channel.
3777 * \param demod instance of demodulator.
3778 * \return DRXStatus_t.
3779 * // original DVBTSetChannel()
3780 */
3781 static int SetDVBT(struct drxk_state *state, u16 IntermediateFreqkHz,
3782                    s32 tunerFreqOffset)
3783 {
3784         u16 cmdResult = 0;
3785         u16 transmissionParams = 0;
3786         u16 operationMode = 0;
3787         u32 iqmRcRateOfs = 0;
3788         u32 bandwidth = 0;
3789         u16 param1;
3790         int status;
3791
3792         dprintk(1, "IF =%d, TFO = %d\n", IntermediateFreqkHz, tunerFreqOffset);
3793
3794         status = scu_command(state, SCU_RAM_COMMAND_STANDARD_OFDM | SCU_RAM_COMMAND_CMD_DEMOD_STOP, 0, NULL, 1, &cmdResult);
3795         if (status < 0)
3796                 goto error;
3797
3798         /* Halt SCU to enable safe non-atomic accesses */
3799         status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_HOLD);
3800         if (status < 0)
3801                 goto error;
3802
3803         /* Stop processors */
3804         status = write16(state, OFDM_SC_COMM_EXEC__A, OFDM_SC_COMM_EXEC_STOP);
3805         if (status < 0)
3806                 goto error;
3807         status = write16(state, OFDM_LC_COMM_EXEC__A, OFDM_LC_COMM_EXEC_STOP);
3808         if (status < 0)
3809                 goto error;
3810
3811         /* Mandatory fix, always stop CP, required to set spl offset back to
3812                 hardware default (is set to 0 by ucode during pilot detection */
3813         status = write16(state, OFDM_CP_COMM_EXEC__A, OFDM_CP_COMM_EXEC_STOP);
3814         if (status < 0)
3815                 goto error;
3816
3817         /*== Write channel settings to device =====================================*/
3818
3819         /* mode */
3820         switch (state->props.transmission_mode) {
3821         case TRANSMISSION_MODE_AUTO:
3822         default:
3823                 operationMode |= OFDM_SC_RA_RAM_OP_AUTO_MODE__M;
3824                 /* fall through , try first guess DRX_FFTMODE_8K */
3825         case TRANSMISSION_MODE_8K:
3826                 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_MODE_8K;
3827                 break;
3828         case TRANSMISSION_MODE_2K:
3829                 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_MODE_2K;
3830                 break;
3831         }
3832
3833         /* guard */
3834         switch (state->props.guard_interval) {
3835         default:
3836         case GUARD_INTERVAL_AUTO:
3837                 operationMode |= OFDM_SC_RA_RAM_OP_AUTO_GUARD__M;
3838                 /* fall through , try first guess DRX_GUARD_1DIV4 */
3839         case GUARD_INTERVAL_1_4:
3840                 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_GUARD_4;
3841                 break;
3842         case GUARD_INTERVAL_1_32:
3843                 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_GUARD_32;
3844                 break;
3845         case GUARD_INTERVAL_1_16:
3846                 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_GUARD_16;
3847                 break;
3848         case GUARD_INTERVAL_1_8:
3849                 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_GUARD_8;
3850                 break;
3851         }
3852
3853         /* hierarchy */
3854         switch (state->props.hierarchy) {
3855         case HIERARCHY_AUTO:
3856         case HIERARCHY_NONE:
3857         default:
3858                 operationMode |= OFDM_SC_RA_RAM_OP_AUTO_HIER__M;
3859                 /* fall through , try first guess SC_RA_RAM_OP_PARAM_HIER_NO */
3860                 /* transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_HIER_NO; */
3861                 /* break; */
3862         case HIERARCHY_1:
3863                 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_HIER_A1;
3864                 break;
3865         case HIERARCHY_2:
3866                 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_HIER_A2;
3867                 break;
3868         case HIERARCHY_4:
3869                 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_HIER_A4;
3870                 break;
3871         }
3872
3873
3874         /* modulation */
3875         switch (state->props.modulation) {
3876         case QAM_AUTO:
3877         default:
3878                 operationMode |= OFDM_SC_RA_RAM_OP_AUTO_CONST__M;
3879                 /* fall through , try first guess DRX_CONSTELLATION_QAM64 */
3880         case QAM_64:
3881                 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_CONST_QAM64;
3882                 break;
3883         case QPSK:
3884                 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_CONST_QPSK;
3885                 break;
3886         case QAM_16:
3887                 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_CONST_QAM16;
3888                 break;
3889         }
3890 #if 0
3891         /* No hierachical channels support in BDA */
3892         /* Priority (only for hierarchical channels) */
3893         switch (channel->priority) {
3894         case DRX_PRIORITY_LOW:
3895                 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_PRIO_LO;
3896                 WR16(devAddr, OFDM_EC_SB_PRIOR__A,
3897                         OFDM_EC_SB_PRIOR_LO);
3898                 break;
3899         case DRX_PRIORITY_HIGH:
3900                 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_PRIO_HI;
3901                 WR16(devAddr, OFDM_EC_SB_PRIOR__A,
3902                         OFDM_EC_SB_PRIOR_HI));
3903                 break;
3904         case DRX_PRIORITY_UNKNOWN:      /* fall through */
3905         default:
3906                 status = -EINVAL;
3907                 goto error;
3908         }
3909 #else
3910         /* Set Priorty high */
3911         transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_PRIO_HI;
3912         status = write16(state, OFDM_EC_SB_PRIOR__A, OFDM_EC_SB_PRIOR_HI);
3913         if (status < 0)
3914                 goto error;
3915 #endif
3916
3917         /* coderate */
3918         switch (state->props.code_rate_HP) {
3919         case FEC_AUTO:
3920         default:
3921                 operationMode |= OFDM_SC_RA_RAM_OP_AUTO_RATE__M;
3922                 /* fall through , try first guess DRX_CODERATE_2DIV3 */
3923         case FEC_2_3:
3924                 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_RATE_2_3;
3925                 break;
3926         case FEC_1_2:
3927                 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_RATE_1_2;
3928                 break;
3929         case FEC_3_4:
3930                 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_RATE_3_4;
3931                 break;
3932         case FEC_5_6:
3933                 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_RATE_5_6;
3934                 break;
3935         case FEC_7_8:
3936                 transmissionParams |= OFDM_SC_RA_RAM_OP_PARAM_RATE_7_8;
3937                 break;
3938         }
3939
3940         /* SAW filter selection: normaly not necesarry, but if wanted
3941                 the application can select a SAW filter via the driver by using UIOs */
3942         /* First determine real bandwidth (Hz) */
3943         /* Also set delay for impulse noise cruncher */
3944         /* Also set parameters for EC_OC fix, note EC_OC_REG_TMD_HIL_MAR is changed
3945                 by SC for fix for some 8K,1/8 guard but is restored by InitEC and ResetEC
3946                 functions */
3947         switch (state->props.bandwidth_hz) {
3948         case 0:
3949                 state->props.bandwidth_hz = 8000000;
3950                 /* fall though */
3951         case 8000000:
3952                 bandwidth = DRXK_BANDWIDTH_8MHZ_IN_HZ;
3953                 status = write16(state, OFDM_SC_RA_RAM_SRMM_FIX_FACT_8K__A, 3052);
3954                 if (status < 0)
3955                         goto error;
3956                 /* cochannel protection for PAL 8 MHz */
3957                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_8K_PER_LEFT__A, 7);
3958                 if (status < 0)
3959                         goto error;
3960                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_8K_PER_RIGHT__A, 7);
3961                 if (status < 0)
3962                         goto error;
3963                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_2K_PER_LEFT__A, 7);
3964                 if (status < 0)
3965                         goto error;
3966                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_2K_PER_RIGHT__A, 1);
3967                 if (status < 0)
3968                         goto error;
3969                 break;
3970         case 7000000:
3971                 bandwidth = DRXK_BANDWIDTH_7MHZ_IN_HZ;
3972                 status = write16(state, OFDM_SC_RA_RAM_SRMM_FIX_FACT_8K__A, 3491);
3973                 if (status < 0)
3974                         goto error;
3975                 /* cochannel protection for PAL 7 MHz */
3976                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_8K_PER_LEFT__A, 8);
3977                 if (status < 0)
3978                         goto error;
3979                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_8K_PER_RIGHT__A, 8);
3980                 if (status < 0)
3981                         goto error;
3982                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_2K_PER_LEFT__A, 4);
3983                 if (status < 0)
3984                         goto error;
3985                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_2K_PER_RIGHT__A, 1);
3986                 if (status < 0)
3987                         goto error;
3988                 break;
3989         case 6000000:
3990                 bandwidth = DRXK_BANDWIDTH_6MHZ_IN_HZ;
3991                 status = write16(state, OFDM_SC_RA_RAM_SRMM_FIX_FACT_8K__A, 4073);
3992                 if (status < 0)
3993                         goto error;
3994                 /* cochannel protection for NTSC 6 MHz */
3995                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_8K_PER_LEFT__A, 19);
3996                 if (status < 0)
3997                         goto error;
3998                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_8K_PER_RIGHT__A, 19);
3999                 if (status < 0)
4000                         goto error;
4001                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_2K_PER_LEFT__A, 14);
4002                 if (status < 0)
4003                         goto error;
4004                 status = write16(state, OFDM_SC_RA_RAM_NI_INIT_2K_PER_RIGHT__A, 1);
4005                 if (status < 0)
4006                         goto error;
4007                 break;
4008         default:
4009                 status = -EINVAL;
4010                 goto error;
4011         }
4012
4013         if (iqmRcRateOfs == 0) {
4014                 /* Now compute IQM_RC_RATE_OFS
4015                         (((SysFreq/BandWidth)/2)/2) -1) * 2^23)
4016                         =>
4017                         ((SysFreq / BandWidth) * (2^21)) - (2^23)
4018                         */
4019                 /* (SysFreq / BandWidth) * (2^28)  */
4020                 /* assert (MAX(sysClk)/MIN(bandwidth) < 16)
4021                         => assert(MAX(sysClk) < 16*MIN(bandwidth))
4022                         => assert(109714272 > 48000000) = true so Frac 28 can be used  */
4023                 iqmRcRateOfs = Frac28a((u32)
4024                                         ((state->m_sysClockFreq *
4025                                                 1000) / 3), bandwidth);
4026                 /* (SysFreq / BandWidth) * (2^21), rounding before truncating  */
4027                 if ((iqmRcRateOfs & 0x7fL) >= 0x40)
4028                         iqmRcRateOfs += 0x80L;
4029                 iqmRcRateOfs = iqmRcRateOfs >> 7;
4030                 /* ((SysFreq / BandWidth) * (2^21)) - (2^23)  */
4031                 iqmRcRateOfs = iqmRcRateOfs - (1 << 23);
4032         }
4033
4034         iqmRcRateOfs &=
4035                 ((((u32) IQM_RC_RATE_OFS_HI__M) <<
4036                 IQM_RC_RATE_OFS_LO__W) | IQM_RC_RATE_OFS_LO__M);
4037         status = write32(state, IQM_RC_RATE_OFS_LO__A, iqmRcRateOfs);
4038         if (status < 0)
4039                 goto error;
4040
4041         /* Bandwidth setting done */
4042
4043 #if 0
4044         status = DVBTSetFrequencyShift(demod, channel, tunerOffset);
4045         if (status < 0)
4046                 goto error;
4047 #endif
4048         status = SetFrequencyShifter(state, IntermediateFreqkHz, tunerFreqOffset, true);
4049         if (status < 0)
4050                 goto error;
4051
4052         /*== Start SC, write channel settings to SC ===============================*/
4053
4054         /* Activate SCU to enable SCU commands */
4055         status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_ACTIVE);
4056         if (status < 0)
4057                 goto error;
4058
4059         /* Enable SC after setting all other parameters */
4060         status = write16(state, OFDM_SC_COMM_STATE__A, 0);
4061         if (status < 0)
4062                 goto error;
4063         status = write16(state, OFDM_SC_COMM_EXEC__A, 1);
4064         if (status < 0)
4065                 goto error;
4066
4067
4068         status = scu_command(state, SCU_RAM_COMMAND_STANDARD_OFDM | SCU_RAM_COMMAND_CMD_DEMOD_START, 0, NULL, 1, &cmdResult);
4069         if (status < 0)
4070                 goto error;
4071
4072         /* Write SC parameter registers, set all AUTO flags in operation mode */
4073         param1 = (OFDM_SC_RA_RAM_OP_AUTO_MODE__M |
4074                         OFDM_SC_RA_RAM_OP_AUTO_GUARD__M |
4075                         OFDM_SC_RA_RAM_OP_AUTO_CONST__M |
4076                         OFDM_SC_RA_RAM_OP_AUTO_HIER__M |
4077                         OFDM_SC_RA_RAM_OP_AUTO_RATE__M);
4078         status = DVBTScCommand(state, OFDM_SC_RA_RAM_CMD_SET_PREF_PARAM,
4079                                 0, transmissionParams, param1, 0, 0, 0);
4080         if (status < 0)
4081                 goto error;
4082
4083         if (!state->m_DRXK_A3_ROM_CODE)
4084                 status = DVBTCtrlSetSqiSpeed(state, &state->m_sqiSpeed);
4085 error:
4086         if (status < 0)
4087                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4088
4089         return status;
4090 }
4091
4092
4093 /*============================================================================*/
4094
4095 /**
4096 * \brief Retreive lock status .
4097 * \param demod    Pointer to demodulator instance.
4098 * \param lockStat Pointer to lock status structure.
4099 * \return DRXStatus_t.
4100 *
4101 */
4102 static int GetDVBTLockStatus(struct drxk_state *state, u32 *pLockStatus)
4103 {
4104         int status;
4105         const u16 mpeg_lock_mask = (OFDM_SC_RA_RAM_LOCK_MPEG__M |
4106                                     OFDM_SC_RA_RAM_LOCK_FEC__M);
4107         const u16 fec_lock_mask = (OFDM_SC_RA_RAM_LOCK_FEC__M);
4108         const u16 demod_lock_mask = OFDM_SC_RA_RAM_LOCK_DEMOD__M;
4109
4110         u16 ScRaRamLock = 0;
4111         u16 ScCommExec = 0;
4112
4113         dprintk(1, "\n");
4114
4115         *pLockStatus = NOT_LOCKED;
4116         /* driver 0.9.0 */
4117         /* Check if SC is running */
4118         status = read16(state, OFDM_SC_COMM_EXEC__A, &ScCommExec);
4119         if (status < 0)
4120                 goto end;
4121         if (ScCommExec == OFDM_SC_COMM_EXEC_STOP)
4122                 goto end;
4123
4124         status = read16(state, OFDM_SC_RA_RAM_LOCK__A, &ScRaRamLock);
4125         if (status < 0)
4126                 goto end;
4127
4128         if ((ScRaRamLock & mpeg_lock_mask) == mpeg_lock_mask)
4129                 *pLockStatus = MPEG_LOCK;
4130         else if ((ScRaRamLock & fec_lock_mask) == fec_lock_mask)
4131                 *pLockStatus = FEC_LOCK;
4132         else if ((ScRaRamLock & demod_lock_mask) == demod_lock_mask)
4133                 *pLockStatus = DEMOD_LOCK;
4134         else if (ScRaRamLock & OFDM_SC_RA_RAM_LOCK_NODVBT__M)
4135                 *pLockStatus = NEVER_LOCK;
4136 end:
4137         if (status < 0)
4138                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4139
4140         return status;
4141 }
4142
4143 static int PowerUpQAM(struct drxk_state *state)
4144 {
4145         enum DRXPowerMode powerMode = DRXK_POWER_DOWN_OFDM;
4146         int status;
4147
4148         dprintk(1, "\n");
4149         status = CtrlPowerMode(state, &powerMode);
4150         if (status < 0)
4151                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4152
4153         return status;
4154 }
4155
4156
4157 /** Power Down QAM */
4158 static int PowerDownQAM(struct drxk_state *state)
4159 {
4160         u16 data = 0;
4161         u16 cmdResult;
4162         int status = 0;
4163
4164         dprintk(1, "\n");
4165         status = read16(state, SCU_COMM_EXEC__A, &data);
4166         if (status < 0)
4167                 goto error;
4168         if (data == SCU_COMM_EXEC_ACTIVE) {
4169                 /*
4170                         STOP demodulator
4171                         QAM and HW blocks
4172                         */
4173                 /* stop all comstate->m_exec */
4174                 status = write16(state, QAM_COMM_EXEC__A, QAM_COMM_EXEC_STOP);
4175                 if (status < 0)
4176                         goto error;
4177                 status = scu_command(state, SCU_RAM_COMMAND_STANDARD_QAM | SCU_RAM_COMMAND_CMD_DEMOD_STOP, 0, NULL, 1, &cmdResult);
4178                 if (status < 0)
4179                         goto error;
4180         }
4181         /* powerdown AFE                   */
4182         status = SetIqmAf(state, false);
4183
4184 error:
4185         if (status < 0)
4186                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4187
4188         return status;
4189 }
4190
4191 /*============================================================================*/
4192
4193 /**
4194 * \brief Setup of the QAM Measurement intervals for signal quality
4195 * \param demod instance of demod.
4196 * \param modulation current modulation.
4197 * \return DRXStatus_t.
4198 *
4199 *  NOTE:
4200 *  Take into account that for certain settings the errorcounters can overflow.
4201 *  The implementation does not check this.
4202 *
4203 */
4204 static int SetQAMMeasurement(struct drxk_state *state,
4205                              enum EDrxkConstellation modulation,
4206                              u32 symbolRate)
4207 {
4208         u32 fecBitsDesired = 0; /* BER accounting period */
4209         u32 fecRsPeriodTotal = 0;       /* Total period */
4210         u16 fecRsPrescale = 0;  /* ReedSolomon Measurement Prescale */
4211         u16 fecRsPeriod = 0;    /* Value for corresponding I2C register */
4212         int status = 0;
4213
4214         dprintk(1, "\n");
4215
4216         fecRsPrescale = 1;
4217         /* fecBitsDesired = symbolRate [kHz] *
4218                 FrameLenght [ms] *
4219                 (modulation + 1) *
4220                 SyncLoss (== 1) *
4221                 ViterbiLoss (==1)
4222                 */
4223         switch (modulation) {
4224         case DRX_CONSTELLATION_QAM16:
4225                 fecBitsDesired = 4 * symbolRate;
4226                 break;
4227         case DRX_CONSTELLATION_QAM32:
4228                 fecBitsDesired = 5 * symbolRate;
4229                 break;
4230         case DRX_CONSTELLATION_QAM64:
4231                 fecBitsDesired = 6 * symbolRate;
4232                 break;
4233         case DRX_CONSTELLATION_QAM128:
4234                 fecBitsDesired = 7 * symbolRate;
4235                 break;
4236         case DRX_CONSTELLATION_QAM256:
4237                 fecBitsDesired = 8 * symbolRate;
4238                 break;
4239         default:
4240                 status = -EINVAL;
4241         }
4242         if (status < 0)
4243                 goto error;
4244
4245         fecBitsDesired /= 1000; /* symbolRate [Hz] -> symbolRate [kHz]  */
4246         fecBitsDesired *= 500;  /* meas. period [ms] */
4247
4248         /* Annex A/C: bits/RsPeriod = 204 * 8 = 1632 */
4249         /* fecRsPeriodTotal = fecBitsDesired / 1632 */
4250         fecRsPeriodTotal = (fecBitsDesired / 1632UL) + 1;       /* roughly ceil */
4251
4252         /* fecRsPeriodTotal =  fecRsPrescale * fecRsPeriod  */
4253         fecRsPrescale = 1 + (u16) (fecRsPeriodTotal >> 16);
4254         if (fecRsPrescale == 0) {
4255                 /* Divide by zero (though impossible) */
4256                 status = -EINVAL;
4257                 if (status < 0)
4258                         goto error;
4259         }
4260         fecRsPeriod =
4261                 ((u16) fecRsPeriodTotal +
4262                 (fecRsPrescale >> 1)) / fecRsPrescale;
4263
4264         /* write corresponding registers */
4265         status = write16(state, FEC_RS_MEASUREMENT_PERIOD__A, fecRsPeriod);
4266         if (status < 0)
4267                 goto error;
4268         status = write16(state, FEC_RS_MEASUREMENT_PRESCALE__A, fecRsPrescale);
4269         if (status < 0)
4270                 goto error;
4271         status = write16(state, FEC_OC_SNC_FAIL_PERIOD__A, fecRsPeriod);
4272 error:
4273         if (status < 0)
4274                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4275         return status;
4276 }
4277
4278 static int SetQAM16(struct drxk_state *state)
4279 {
4280         int status = 0;
4281
4282         dprintk(1, "\n");
4283         /* QAM Equalizer Setup */
4284         /* Equalizer */
4285         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD0__A, 13517);
4286         if (status < 0)
4287                 goto error;
4288         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD1__A, 13517);
4289         if (status < 0)
4290                 goto error;
4291         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD2__A, 13517);
4292         if (status < 0)
4293                 goto error;
4294         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD3__A, 13517);
4295         if (status < 0)
4296                 goto error;
4297         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD4__A, 13517);
4298         if (status < 0)
4299                 goto error;
4300         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD5__A, 13517);
4301         if (status < 0)
4302                 goto error;
4303         /* Decision Feedback Equalizer */
4304         status = write16(state, QAM_DQ_QUAL_FUN0__A, 2);
4305         if (status < 0)
4306                 goto error;
4307         status = write16(state, QAM_DQ_QUAL_FUN1__A, 2);
4308         if (status < 0)
4309                 goto error;
4310         status = write16(state, QAM_DQ_QUAL_FUN2__A, 2);
4311         if (status < 0)
4312                 goto error;
4313         status = write16(state, QAM_DQ_QUAL_FUN3__A, 2);
4314         if (status < 0)
4315                 goto error;
4316         status = write16(state, QAM_DQ_QUAL_FUN4__A, 2);
4317         if (status < 0)
4318                 goto error;
4319         status = write16(state, QAM_DQ_QUAL_FUN5__A, 0);
4320         if (status < 0)
4321                 goto error;
4322
4323         status = write16(state, QAM_SY_SYNC_HWM__A, 5);
4324         if (status < 0)
4325                 goto error;
4326         status = write16(state, QAM_SY_SYNC_AWM__A, 4);
4327         if (status < 0)
4328                 goto error;
4329         status = write16(state, QAM_SY_SYNC_LWM__A, 3);
4330         if (status < 0)
4331                 goto error;
4332
4333         /* QAM Slicer Settings */
4334         status = write16(state, SCU_RAM_QAM_SL_SIG_POWER__A, DRXK_QAM_SL_SIG_POWER_QAM16);
4335         if (status < 0)
4336                 goto error;
4337
4338         /* QAM Loop Controller Coeficients */
4339         status = write16(state, SCU_RAM_QAM_LC_CA_FINE__A, 15);
4340         if (status < 0)
4341                 goto error;
4342         status = write16(state, SCU_RAM_QAM_LC_CA_COARSE__A, 40);
4343         if (status < 0)
4344                 goto error;
4345         status = write16(state, SCU_RAM_QAM_LC_EP_FINE__A, 12);
4346         if (status < 0)
4347                 goto error;
4348         status = write16(state, SCU_RAM_QAM_LC_EP_MEDIUM__A, 24);
4349         if (status < 0)
4350                 goto error;
4351         status = write16(state, SCU_RAM_QAM_LC_EP_COARSE__A, 24);
4352         if (status < 0)
4353                 goto error;
4354         status = write16(state, SCU_RAM_QAM_LC_EI_FINE__A, 12);
4355         if (status < 0)
4356                 goto error;
4357         status = write16(state, SCU_RAM_QAM_LC_EI_MEDIUM__A, 16);
4358         if (status < 0)
4359                 goto error;
4360         status = write16(state, SCU_RAM_QAM_LC_EI_COARSE__A, 16);
4361         if (status < 0)
4362                 goto error;
4363
4364         status = write16(state, SCU_RAM_QAM_LC_CP_FINE__A, 5);
4365         if (status < 0)
4366                 goto error;
4367         status = write16(state, SCU_RAM_QAM_LC_CP_MEDIUM__A, 20);
4368         if (status < 0)
4369                 goto error;
4370         status = write16(state, SCU_RAM_QAM_LC_CP_COARSE__A, 80);
4371         if (status < 0)
4372                 goto error;
4373         status = write16(state, SCU_RAM_QAM_LC_CI_FINE__A, 5);
4374         if (status < 0)
4375                 goto error;
4376         status = write16(state, SCU_RAM_QAM_LC_CI_MEDIUM__A, 20);
4377         if (status < 0)
4378                 goto error;
4379         status = write16(state, SCU_RAM_QAM_LC_CI_COARSE__A, 50);
4380         if (status < 0)
4381                 goto error;
4382         status = write16(state, SCU_RAM_QAM_LC_CF_FINE__A, 16);
4383         if (status < 0)
4384                 goto error;
4385         status = write16(state, SCU_RAM_QAM_LC_CF_MEDIUM__A, 16);
4386         if (status < 0)
4387                 goto error;
4388         status = write16(state, SCU_RAM_QAM_LC_CF_COARSE__A, 32);
4389         if (status < 0)
4390                 goto error;
4391         status = write16(state, SCU_RAM_QAM_LC_CF1_FINE__A, 5);
4392         if (status < 0)
4393                 goto error;
4394         status = write16(state, SCU_RAM_QAM_LC_CF1_MEDIUM__A, 10);
4395         if (status < 0)
4396                 goto error;
4397         status = write16(state, SCU_RAM_QAM_LC_CF1_COARSE__A, 10);
4398         if (status < 0)
4399                 goto error;
4400
4401
4402         /* QAM State Machine (FSM) Thresholds */
4403
4404         status = write16(state, SCU_RAM_QAM_FSM_RTH__A, 140);
4405         if (status < 0)
4406                 goto error;
4407         status = write16(state, SCU_RAM_QAM_FSM_FTH__A, 50);
4408         if (status < 0)
4409                 goto error;
4410         status = write16(state, SCU_RAM_QAM_FSM_CTH__A, 95);
4411         if (status < 0)
4412                 goto error;
4413         status = write16(state, SCU_RAM_QAM_FSM_PTH__A, 120);
4414         if (status < 0)
4415                 goto error;
4416         status = write16(state, SCU_RAM_QAM_FSM_QTH__A, 230);
4417         if (status < 0)
4418                 goto error;
4419         status = write16(state, SCU_RAM_QAM_FSM_MTH__A, 105);
4420         if (status < 0)
4421                 goto error;
4422
4423         status = write16(state, SCU_RAM_QAM_FSM_RATE_LIM__A, 40);
4424         if (status < 0)
4425                 goto error;
4426         status = write16(state, SCU_RAM_QAM_FSM_COUNT_LIM__A, 4);
4427         if (status < 0)
4428                 goto error;
4429         status = write16(state, SCU_RAM_QAM_FSM_FREQ_LIM__A, 24);
4430         if (status < 0)
4431                 goto error;
4432
4433
4434         /* QAM FSM Tracking Parameters */
4435
4436         status = write16(state, SCU_RAM_QAM_FSM_MEDIAN_AV_MULT__A, (u16) 16);
4437         if (status < 0)
4438                 goto error;
4439         status = write16(state, SCU_RAM_QAM_FSM_RADIUS_AV_LIMIT__A, (u16) 220);
4440         if (status < 0)
4441                 goto error;
4442         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET1__A, (u16) 25);
4443         if (status < 0)
4444                 goto error;
4445         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET2__A, (u16) 6);
4446         if (status < 0)
4447                 goto error;
4448         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET3__A, (u16) -24);
4449         if (status < 0)
4450                 goto error;
4451         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET4__A, (u16) -65);
4452         if (status < 0)
4453                 goto error;
4454         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16) -127);
4455         if (status < 0)
4456                 goto error;
4457
4458 error:
4459         if (status < 0)
4460                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4461         return status;
4462 }
4463
4464 /*============================================================================*/
4465
4466 /**
4467 * \brief QAM32 specific setup
4468 * \param demod instance of demod.
4469 * \return DRXStatus_t.
4470 */
4471 static int SetQAM32(struct drxk_state *state)
4472 {
4473         int status = 0;
4474
4475         dprintk(1, "\n");
4476
4477         /* QAM Equalizer Setup */
4478         /* Equalizer */
4479         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD0__A, 6707);
4480         if (status < 0)
4481                 goto error;
4482         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD1__A, 6707);
4483         if (status < 0)
4484                 goto error;
4485         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD2__A, 6707);
4486         if (status < 0)
4487                 goto error;
4488         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD3__A, 6707);
4489         if (status < 0)
4490                 goto error;
4491         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD4__A, 6707);
4492         if (status < 0)
4493                 goto error;
4494         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD5__A, 6707);
4495         if (status < 0)
4496                 goto error;
4497
4498         /* Decision Feedback Equalizer */
4499         status = write16(state, QAM_DQ_QUAL_FUN0__A, 3);
4500         if (status < 0)
4501                 goto error;
4502         status = write16(state, QAM_DQ_QUAL_FUN1__A, 3);
4503         if (status < 0)
4504                 goto error;
4505         status = write16(state, QAM_DQ_QUAL_FUN2__A, 3);
4506         if (status < 0)
4507                 goto error;
4508         status = write16(state, QAM_DQ_QUAL_FUN3__A, 3);
4509         if (status < 0)
4510                 goto error;
4511         status = write16(state, QAM_DQ_QUAL_FUN4__A, 3);
4512         if (status < 0)
4513                 goto error;
4514         status = write16(state, QAM_DQ_QUAL_FUN5__A, 0);
4515         if (status < 0)
4516                 goto error;
4517
4518         status = write16(state, QAM_SY_SYNC_HWM__A, 6);
4519         if (status < 0)
4520                 goto error;
4521         status = write16(state, QAM_SY_SYNC_AWM__A, 5);
4522         if (status < 0)
4523                 goto error;
4524         status = write16(state, QAM_SY_SYNC_LWM__A, 3);
4525         if (status < 0)
4526                 goto error;
4527
4528         /* QAM Slicer Settings */
4529
4530         status = write16(state, SCU_RAM_QAM_SL_SIG_POWER__A, DRXK_QAM_SL_SIG_POWER_QAM32);
4531         if (status < 0)
4532                 goto error;
4533
4534
4535         /* QAM Loop Controller Coeficients */
4536
4537         status = write16(state, SCU_RAM_QAM_LC_CA_FINE__A, 15);
4538         if (status < 0)
4539                 goto error;
4540         status = write16(state, SCU_RAM_QAM_LC_CA_COARSE__A, 40);
4541         if (status < 0)
4542                 goto error;
4543         status = write16(state, SCU_RAM_QAM_LC_EP_FINE__A, 12);
4544         if (status < 0)
4545                 goto error;
4546         status = write16(state, SCU_RAM_QAM_LC_EP_MEDIUM__A, 24);
4547         if (status < 0)
4548                 goto error;
4549         status = write16(state, SCU_RAM_QAM_LC_EP_COARSE__A, 24);
4550         if (status < 0)
4551                 goto error;
4552         status = write16(state, SCU_RAM_QAM_LC_EI_FINE__A, 12);
4553         if (status < 0)
4554                 goto error;
4555         status = write16(state, SCU_RAM_QAM_LC_EI_MEDIUM__A, 16);
4556         if (status < 0)
4557                 goto error;
4558         status = write16(state, SCU_RAM_QAM_LC_EI_COARSE__A, 16);
4559         if (status < 0)
4560                 goto error;
4561
4562         status = write16(state, SCU_RAM_QAM_LC_CP_FINE__A, 5);
4563         if (status < 0)
4564                 goto error;
4565         status = write16(state, SCU_RAM_QAM_LC_CP_MEDIUM__A, 20);
4566         if (status < 0)
4567                 goto error;
4568         status = write16(state, SCU_RAM_QAM_LC_CP_COARSE__A, 80);
4569         if (status < 0)
4570                 goto error;
4571         status = write16(state, SCU_RAM_QAM_LC_CI_FINE__A, 5);
4572         if (status < 0)
4573                 goto error;
4574         status = write16(state, SCU_RAM_QAM_LC_CI_MEDIUM__A, 20);
4575         if (status < 0)
4576                 goto error;
4577         status = write16(state, SCU_RAM_QAM_LC_CI_COARSE__A, 50);
4578         if (status < 0)
4579                 goto error;
4580         status = write16(state, SCU_RAM_QAM_LC_CF_FINE__A, 16);
4581         if (status < 0)
4582                 goto error;
4583         status = write16(state, SCU_RAM_QAM_LC_CF_MEDIUM__A, 16);
4584         if (status < 0)
4585                 goto error;
4586         status = write16(state, SCU_RAM_QAM_LC_CF_COARSE__A, 16);
4587         if (status < 0)
4588                 goto error;
4589         status = write16(state, SCU_RAM_QAM_LC_CF1_FINE__A, 5);
4590         if (status < 0)
4591                 goto error;
4592         status = write16(state, SCU_RAM_QAM_LC_CF1_MEDIUM__A, 10);
4593         if (status < 0)
4594                 goto error;
4595         status = write16(state, SCU_RAM_QAM_LC_CF1_COARSE__A, 0);
4596         if (status < 0)
4597                 goto error;
4598
4599
4600         /* QAM State Machine (FSM) Thresholds */
4601
4602         status = write16(state, SCU_RAM_QAM_FSM_RTH__A, 90);
4603         if (status < 0)
4604                 goto error;
4605         status = write16(state, SCU_RAM_QAM_FSM_FTH__A, 50);
4606         if (status < 0)
4607                 goto error;
4608         status = write16(state, SCU_RAM_QAM_FSM_CTH__A, 80);
4609         if (status < 0)
4610                 goto error;
4611         status = write16(state, SCU_RAM_QAM_FSM_PTH__A, 100);
4612         if (status < 0)
4613                 goto error;
4614         status = write16(state, SCU_RAM_QAM_FSM_QTH__A, 170);
4615         if (status < 0)
4616                 goto error;
4617         status = write16(state, SCU_RAM_QAM_FSM_MTH__A, 100);
4618         if (status < 0)
4619                 goto error;
4620
4621         status = write16(state, SCU_RAM_QAM_FSM_RATE_LIM__A, 40);
4622         if (status < 0)
4623                 goto error;
4624         status = write16(state, SCU_RAM_QAM_FSM_COUNT_LIM__A, 4);
4625         if (status < 0)
4626                 goto error;
4627         status = write16(state, SCU_RAM_QAM_FSM_FREQ_LIM__A, 10);
4628         if (status < 0)
4629                 goto error;
4630
4631
4632         /* QAM FSM Tracking Parameters */
4633
4634         status = write16(state, SCU_RAM_QAM_FSM_MEDIAN_AV_MULT__A, (u16) 12);
4635         if (status < 0)
4636                 goto error;
4637         status = write16(state, SCU_RAM_QAM_FSM_RADIUS_AV_LIMIT__A, (u16) 140);
4638         if (status < 0)
4639                 goto error;
4640         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET1__A, (u16) -8);
4641         if (status < 0)
4642                 goto error;
4643         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET2__A, (u16) -16);
4644         if (status < 0)
4645                 goto error;
4646         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET3__A, (u16) -26);
4647         if (status < 0)
4648                 goto error;
4649         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET4__A, (u16) -56);
4650         if (status < 0)
4651                 goto error;
4652         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16) -86);
4653 error:
4654         if (status < 0)
4655                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4656         return status;
4657 }
4658
4659 /*============================================================================*/
4660
4661 /**
4662 * \brief QAM64 specific setup
4663 * \param demod instance of demod.
4664 * \return DRXStatus_t.
4665 */
4666 static int SetQAM64(struct drxk_state *state)
4667 {
4668         int status = 0;
4669
4670         dprintk(1, "\n");
4671         /* QAM Equalizer Setup */
4672         /* Equalizer */
4673         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD0__A, 13336);
4674         if (status < 0)
4675                 goto error;
4676         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD1__A, 12618);
4677         if (status < 0)
4678                 goto error;
4679         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD2__A, 11988);
4680         if (status < 0)
4681                 goto error;
4682         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD3__A, 13809);
4683         if (status < 0)
4684                 goto error;
4685         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD4__A, 13809);
4686         if (status < 0)
4687                 goto error;
4688         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD5__A, 15609);
4689         if (status < 0)
4690                 goto error;
4691
4692         /* Decision Feedback Equalizer */
4693         status = write16(state, QAM_DQ_QUAL_FUN0__A, 4);
4694         if (status < 0)
4695                 goto error;
4696         status = write16(state, QAM_DQ_QUAL_FUN1__A, 4);
4697         if (status < 0)
4698                 goto error;
4699         status = write16(state, QAM_DQ_QUAL_FUN2__A, 4);
4700         if (status < 0)
4701                 goto error;
4702         status = write16(state, QAM_DQ_QUAL_FUN3__A, 4);
4703         if (status < 0)
4704                 goto error;
4705         status = write16(state, QAM_DQ_QUAL_FUN4__A, 3);
4706         if (status < 0)
4707                 goto error;
4708         status = write16(state, QAM_DQ_QUAL_FUN5__A, 0);
4709         if (status < 0)
4710                 goto error;
4711
4712         status = write16(state, QAM_SY_SYNC_HWM__A, 5);
4713         if (status < 0)
4714                 goto error;
4715         status = write16(state, QAM_SY_SYNC_AWM__A, 4);
4716         if (status < 0)
4717                 goto error;
4718         status = write16(state, QAM_SY_SYNC_LWM__A, 3);
4719         if (status < 0)
4720                 goto error;
4721
4722         /* QAM Slicer Settings */
4723         status = write16(state, SCU_RAM_QAM_SL_SIG_POWER__A, DRXK_QAM_SL_SIG_POWER_QAM64);
4724         if (status < 0)
4725                 goto error;
4726
4727
4728         /* QAM Loop Controller Coeficients */
4729
4730         status = write16(state, SCU_RAM_QAM_LC_CA_FINE__A, 15);
4731         if (status < 0)
4732                 goto error;
4733         status = write16(state, SCU_RAM_QAM_LC_CA_COARSE__A, 40);
4734         if (status < 0)
4735                 goto error;
4736         status = write16(state, SCU_RAM_QAM_LC_EP_FINE__A, 12);
4737         if (status < 0)
4738                 goto error;
4739         status = write16(state, SCU_RAM_QAM_LC_EP_MEDIUM__A, 24);
4740         if (status < 0)
4741                 goto error;
4742         status = write16(state, SCU_RAM_QAM_LC_EP_COARSE__A, 24);
4743         if (status < 0)
4744                 goto error;
4745         status = write16(state, SCU_RAM_QAM_LC_EI_FINE__A, 12);
4746         if (status < 0)
4747                 goto error;
4748         status = write16(state, SCU_RAM_QAM_LC_EI_MEDIUM__A, 16);
4749         if (status < 0)
4750                 goto error;
4751         status = write16(state, SCU_RAM_QAM_LC_EI_COARSE__A, 16);
4752         if (status < 0)
4753                 goto error;
4754
4755         status = write16(state, SCU_RAM_QAM_LC_CP_FINE__A, 5);
4756         if (status < 0)
4757                 goto error;
4758         status = write16(state, SCU_RAM_QAM_LC_CP_MEDIUM__A, 30);
4759         if (status < 0)
4760                 goto error;
4761         status = write16(state, SCU_RAM_QAM_LC_CP_COARSE__A, 100);
4762         if (status < 0)
4763                 goto error;
4764         status = write16(state, SCU_RAM_QAM_LC_CI_FINE__A, 5);
4765         if (status < 0)
4766                 goto error;
4767         status = write16(state, SCU_RAM_QAM_LC_CI_MEDIUM__A, 30);
4768         if (status < 0)
4769                 goto error;
4770         status = write16(state, SCU_RAM_QAM_LC_CI_COARSE__A, 50);
4771         if (status < 0)
4772                 goto error;
4773         status = write16(state, SCU_RAM_QAM_LC_CF_FINE__A, 16);
4774         if (status < 0)
4775                 goto error;
4776         status = write16(state, SCU_RAM_QAM_LC_CF_MEDIUM__A, 25);
4777         if (status < 0)
4778                 goto error;
4779         status = write16(state, SCU_RAM_QAM_LC_CF_COARSE__A, 48);
4780         if (status < 0)
4781                 goto error;
4782         status = write16(state, SCU_RAM_QAM_LC_CF1_FINE__A, 5);
4783         if (status < 0)
4784                 goto error;
4785         status = write16(state, SCU_RAM_QAM_LC_CF1_MEDIUM__A, 10);
4786         if (status < 0)
4787                 goto error;
4788         status = write16(state, SCU_RAM_QAM_LC_CF1_COARSE__A, 10);
4789         if (status < 0)
4790                 goto error;
4791
4792
4793         /* QAM State Machine (FSM) Thresholds */
4794
4795         status = write16(state, SCU_RAM_QAM_FSM_RTH__A, 100);
4796         if (status < 0)
4797                 goto error;
4798         status = write16(state, SCU_RAM_QAM_FSM_FTH__A, 60);
4799         if (status < 0)
4800                 goto error;
4801         status = write16(state, SCU_RAM_QAM_FSM_CTH__A, 80);
4802         if (status < 0)
4803                 goto error;
4804         status = write16(state, SCU_RAM_QAM_FSM_PTH__A, 110);
4805         if (status < 0)
4806                 goto error;
4807         status = write16(state, SCU_RAM_QAM_FSM_QTH__A, 200);
4808         if (status < 0)
4809                 goto error;
4810         status = write16(state, SCU_RAM_QAM_FSM_MTH__A, 95);
4811         if (status < 0)
4812                 goto error;
4813
4814         status = write16(state, SCU_RAM_QAM_FSM_RATE_LIM__A, 40);
4815         if (status < 0)
4816                 goto error;
4817         status = write16(state, SCU_RAM_QAM_FSM_COUNT_LIM__A, 4);
4818         if (status < 0)
4819                 goto error;
4820         status = write16(state, SCU_RAM_QAM_FSM_FREQ_LIM__A, 15);
4821         if (status < 0)
4822                 goto error;
4823
4824
4825         /* QAM FSM Tracking Parameters */
4826
4827         status = write16(state, SCU_RAM_QAM_FSM_MEDIAN_AV_MULT__A, (u16) 12);
4828         if (status < 0)
4829                 goto error;
4830         status = write16(state, SCU_RAM_QAM_FSM_RADIUS_AV_LIMIT__A, (u16) 141);
4831         if (status < 0)
4832                 goto error;
4833         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET1__A, (u16) 7);
4834         if (status < 0)
4835                 goto error;
4836         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET2__A, (u16) 0);
4837         if (status < 0)
4838                 goto error;
4839         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET3__A, (u16) -15);
4840         if (status < 0)
4841                 goto error;
4842         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET4__A, (u16) -45);
4843         if (status < 0)
4844                 goto error;
4845         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16) -80);
4846 error:
4847         if (status < 0)
4848                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
4849
4850         return status;
4851 }
4852
4853 /*============================================================================*/
4854
4855 /**
4856 * \brief QAM128 specific setup
4857 * \param demod: instance of demod.
4858 * \return DRXStatus_t.
4859 */
4860 static int SetQAM128(struct drxk_state *state)
4861 {
4862         int status = 0;
4863
4864         dprintk(1, "\n");
4865         /* QAM Equalizer Setup */
4866         /* Equalizer */
4867         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD0__A, 6564);
4868         if (status < 0)
4869                 goto error;
4870         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD1__A, 6598);
4871         if (status < 0)
4872                 goto error;
4873         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD2__A, 6394);
4874         if (status < 0)
4875                 goto error;
4876         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD3__A, 6409);
4877         if (status < 0)
4878                 goto error;
4879         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD4__A, 6656);
4880         if (status < 0)
4881                 goto error;
4882         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD5__A, 7238);
4883         if (status < 0)
4884                 goto error;
4885
4886         /* Decision Feedback Equalizer */
4887         status = write16(state, QAM_DQ_QUAL_FUN0__A, 6);
4888         if (status < 0)
4889                 goto error;
4890         status = write16(state, QAM_DQ_QUAL_FUN1__A, 6);
4891         if (status < 0)
4892                 goto error;
4893         status = write16(state, QAM_DQ_QUAL_FUN2__A, 6);
4894         if (status < 0)
4895                 goto error;
4896         status = write16(state, QAM_DQ_QUAL_FUN3__A, 6);
4897         if (status < 0)
4898                 goto error;
4899         status = write16(state, QAM_DQ_QUAL_FUN4__A, 5);
4900         if (status < 0)
4901                 goto error;
4902         status = write16(state, QAM_DQ_QUAL_FUN5__A, 0);
4903         if (status < 0)
4904                 goto error;
4905
4906         status = write16(state, QAM_SY_SYNC_HWM__A, 6);
4907         if (status < 0)
4908                 goto error;
4909         status = write16(state, QAM_SY_SYNC_AWM__A, 5);
4910         if (status < 0)
4911                 goto error;
4912         status = write16(state, QAM_SY_SYNC_LWM__A, 3);
4913         if (status < 0)
4914                 goto error;
4915
4916
4917         /* QAM Slicer Settings */
4918
4919         status = write16(state, SCU_RAM_QAM_SL_SIG_POWER__A, DRXK_QAM_SL_SIG_POWER_QAM128);
4920         if (status < 0)
4921                 goto error;
4922
4923
4924         /* QAM Loop Controller Coeficients */
4925
4926         status = write16(state, SCU_RAM_QAM_LC_CA_FINE__A, 15);
4927         if (status < 0)
4928                 goto error;
4929         status = write16(state, SCU_RAM_QAM_LC_CA_COARSE__A, 40);
4930         if (status < 0)
4931                 goto error;
4932         status = write16(state, SCU_RAM_QAM_LC_EP_FINE__A, 12);
4933         if (status < 0)
4934                 goto error;
4935         status = write16(state, SCU_RAM_QAM_LC_EP_MEDIUM__A, 24);
4936         if (status < 0)
4937                 goto error;
4938         status = write16(state, SCU_RAM_QAM_LC_EP_COARSE__A, 24);
4939         if (status < 0)
4940                 goto error;
4941         status = write16(state, SCU_RAM_QAM_LC_EI_FINE__A, 12);
4942         if (status < 0)
4943                 goto error;
4944         status = write16(state, SCU_RAM_QAM_LC_EI_MEDIUM__A, 16);
4945         if (status < 0)
4946                 goto error;
4947         status = write16(state, SCU_RAM_QAM_LC_EI_COARSE__A, 16);
4948         if (status < 0)
4949                 goto error;
4950
4951         status = write16(state, SCU_RAM_QAM_LC_CP_FINE__A, 5);
4952         if (status < 0)
4953                 goto error;
4954         status = write16(state, SCU_RAM_QAM_LC_CP_MEDIUM__A, 40);
4955         if (status < 0)
4956                 goto error;
4957         status = write16(state, SCU_RAM_QAM_LC_CP_COARSE__A, 120);
4958         if (status < 0)
4959                 goto error;
4960         status = write16(state, SCU_RAM_QAM_LC_CI_FINE__A, 5);
4961         if (status < 0)
4962                 goto error;
4963         status = write16(state, SCU_RAM_QAM_LC_CI_MEDIUM__A, 40);
4964         if (status < 0)
4965                 goto error;
4966         status = write16(state, SCU_RAM_QAM_LC_CI_COARSE__A, 60);
4967         if (status < 0)
4968                 goto error;
4969         status = write16(state, SCU_RAM_QAM_LC_CF_FINE__A, 16);
4970         if (status < 0)
4971                 goto error;
4972         status = write16(state, SCU_RAM_QAM_LC_CF_MEDIUM__A, 25);
4973         if (status < 0)
4974                 goto error;
4975         status = write16(state, SCU_RAM_QAM_LC_CF_COARSE__A, 64);
4976         if (status < 0)
4977                 goto error;
4978         status = write16(state, SCU_RAM_QAM_LC_CF1_FINE__A, 5);
4979         if (status < 0)
4980                 goto error;
4981         status = write16(state, SCU_RAM_QAM_LC_CF1_MEDIUM__A, 10);
4982         if (status < 0)
4983                 goto error;
4984         status = write16(state, SCU_RAM_QAM_LC_CF1_COARSE__A, 0);
4985         if (status < 0)
4986                 goto error;
4987
4988
4989         /* QAM State Machine (FSM) Thresholds */
4990
4991         status = write16(state, SCU_RAM_QAM_FSM_RTH__A, 50);
4992         if (status < 0)
4993                 goto error;
4994         status = write16(state, SCU_RAM_QAM_FSM_FTH__A, 60);
4995         if (status < 0)
4996                 goto error;
4997         status = write16(state, SCU_RAM_QAM_FSM_CTH__A, 80);
4998         if (status < 0)
4999                 goto error;
5000         status = write16(state, SCU_RAM_QAM_FSM_PTH__A, 100);
5001         if (status < 0)
5002                 goto error;
5003         status = write16(state, SCU_RAM_QAM_FSM_QTH__A, 140);
5004         if (status < 0)
5005                 goto error;
5006         status = write16(state, SCU_RAM_QAM_FSM_MTH__A, 100);
5007         if (status < 0)
5008                 goto error;
5009
5010         status = write16(state, SCU_RAM_QAM_FSM_RATE_LIM__A, 40);
5011         if (status < 0)
5012                 goto error;
5013         status = write16(state, SCU_RAM_QAM_FSM_COUNT_LIM__A, 5);
5014         if (status < 0)
5015                 goto error;
5016
5017         status = write16(state, SCU_RAM_QAM_FSM_FREQ_LIM__A, 12);
5018         if (status < 0)
5019                 goto error;
5020
5021         /* QAM FSM Tracking Parameters */
5022
5023         status = write16(state, SCU_RAM_QAM_FSM_MEDIAN_AV_MULT__A, (u16) 8);
5024         if (status < 0)
5025                 goto error;
5026         status = write16(state, SCU_RAM_QAM_FSM_RADIUS_AV_LIMIT__A, (u16) 65);
5027         if (status < 0)
5028                 goto error;
5029         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET1__A, (u16) 5);
5030         if (status < 0)
5031                 goto error;
5032         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET2__A, (u16) 3);
5033         if (status < 0)
5034                 goto error;
5035         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET3__A, (u16) -1);
5036         if (status < 0)
5037                 goto error;
5038         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET4__A, (u16) -12);
5039         if (status < 0)
5040                 goto error;
5041         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16) -23);
5042 error:
5043         if (status < 0)
5044                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5045
5046         return status;
5047 }
5048
5049 /*============================================================================*/
5050
5051 /**
5052 * \brief QAM256 specific setup
5053 * \param demod: instance of demod.
5054 * \return DRXStatus_t.
5055 */
5056 static int SetQAM256(struct drxk_state *state)
5057 {
5058         int status = 0;
5059
5060         dprintk(1, "\n");
5061         /* QAM Equalizer Setup */
5062         /* Equalizer */
5063         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD0__A, 11502);
5064         if (status < 0)
5065                 goto error;
5066         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD1__A, 12084);
5067         if (status < 0)
5068                 goto error;
5069         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD2__A, 12543);
5070         if (status < 0)
5071                 goto error;
5072         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD3__A, 12931);
5073         if (status < 0)
5074                 goto error;
5075         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD4__A, 13629);
5076         if (status < 0)
5077                 goto error;
5078         status = write16(state, SCU_RAM_QAM_EQ_CMA_RAD5__A, 15385);
5079         if (status < 0)
5080                 goto error;
5081
5082         /* Decision Feedback Equalizer */
5083         status = write16(state, QAM_DQ_QUAL_FUN0__A, 8);
5084         if (status < 0)
5085                 goto error;
5086         status = write16(state, QAM_DQ_QUAL_FUN1__A, 8);
5087         if (status < 0)
5088                 goto error;
5089         status = write16(state, QAM_DQ_QUAL_FUN2__A, 8);
5090         if (status < 0)
5091                 goto error;
5092         status = write16(state, QAM_DQ_QUAL_FUN3__A, 8);
5093         if (status < 0)
5094                 goto error;
5095         status = write16(state, QAM_DQ_QUAL_FUN4__A, 6);
5096         if (status < 0)
5097                 goto error;
5098         status = write16(state, QAM_DQ_QUAL_FUN5__A, 0);
5099         if (status < 0)
5100                 goto error;
5101
5102         status = write16(state, QAM_SY_SYNC_HWM__A, 5);
5103         if (status < 0)
5104                 goto error;
5105         status = write16(state, QAM_SY_SYNC_AWM__A, 4);
5106         if (status < 0)
5107                 goto error;
5108         status = write16(state, QAM_SY_SYNC_LWM__A, 3);
5109         if (status < 0)
5110                 goto error;
5111
5112         /* QAM Slicer Settings */
5113
5114         status = write16(state, SCU_RAM_QAM_SL_SIG_POWER__A, DRXK_QAM_SL_SIG_POWER_QAM256);
5115         if (status < 0)
5116                 goto error;
5117
5118
5119         /* QAM Loop Controller Coeficients */
5120
5121         status = write16(state, SCU_RAM_QAM_LC_CA_FINE__A, 15);
5122         if (status < 0)
5123                 goto error;
5124         status = write16(state, SCU_RAM_QAM_LC_CA_COARSE__A, 40);
5125         if (status < 0)
5126                 goto error;
5127         status = write16(state, SCU_RAM_QAM_LC_EP_FINE__A, 12);
5128         if (status < 0)
5129                 goto error;
5130         status = write16(state, SCU_RAM_QAM_LC_EP_MEDIUM__A, 24);
5131         if (status < 0)
5132                 goto error;
5133         status = write16(state, SCU_RAM_QAM_LC_EP_COARSE__A, 24);
5134         if (status < 0)
5135                 goto error;
5136         status = write16(state, SCU_RAM_QAM_LC_EI_FINE__A, 12);
5137         if (status < 0)
5138                 goto error;
5139         status = write16(state, SCU_RAM_QAM_LC_EI_MEDIUM__A, 16);
5140         if (status < 0)
5141                 goto error;
5142         status = write16(state, SCU_RAM_QAM_LC_EI_COARSE__A, 16);
5143         if (status < 0)
5144                 goto error;
5145
5146         status = write16(state, SCU_RAM_QAM_LC_CP_FINE__A, 5);
5147         if (status < 0)
5148                 goto error;
5149         status = write16(state, SCU_RAM_QAM_LC_CP_MEDIUM__A, 50);
5150         if (status < 0)
5151                 goto error;
5152         status = write16(state, SCU_RAM_QAM_LC_CP_COARSE__A, 250);
5153         if (status < 0)
5154                 goto error;
5155         status = write16(state, SCU_RAM_QAM_LC_CI_FINE__A, 5);
5156         if (status < 0)
5157                 goto error;
5158         status = write16(state, SCU_RAM_QAM_LC_CI_MEDIUM__A, 50);
5159         if (status < 0)
5160                 goto error;
5161         status = write16(state, SCU_RAM_QAM_LC_CI_COARSE__A, 125);
5162         if (status < 0)
5163                 goto error;
5164         status = write16(state, SCU_RAM_QAM_LC_CF_FINE__A, 16);
5165         if (status < 0)
5166                 goto error;
5167         status = write16(state, SCU_RAM_QAM_LC_CF_MEDIUM__A, 25);
5168         if (status < 0)
5169                 goto error;
5170         status = write16(state, SCU_RAM_QAM_LC_CF_COARSE__A, 48);
5171         if (status < 0)
5172                 goto error;
5173         status = write16(state, SCU_RAM_QAM_LC_CF1_FINE__A, 5);
5174         if (status < 0)
5175                 goto error;
5176         status = write16(state, SCU_RAM_QAM_LC_CF1_MEDIUM__A, 10);
5177         if (status < 0)
5178                 goto error;
5179         status = write16(state, SCU_RAM_QAM_LC_CF1_COARSE__A, 10);
5180         if (status < 0)
5181                 goto error;
5182
5183
5184         /* QAM State Machine (FSM) Thresholds */
5185
5186         status = write16(state, SCU_RAM_QAM_FSM_RTH__A, 50);
5187         if (status < 0)
5188                 goto error;
5189         status = write16(state, SCU_RAM_QAM_FSM_FTH__A, 60);
5190         if (status < 0)
5191                 goto error;
5192         status = write16(state, SCU_RAM_QAM_FSM_CTH__A, 80);
5193         if (status < 0)
5194                 goto error;
5195         status = write16(state, SCU_RAM_QAM_FSM_PTH__A, 100);
5196         if (status < 0)
5197                 goto error;
5198         status = write16(state, SCU_RAM_QAM_FSM_QTH__A, 150);
5199         if (status < 0)
5200                 goto error;
5201         status = write16(state, SCU_RAM_QAM_FSM_MTH__A, 110);
5202         if (status < 0)
5203                 goto error;
5204
5205         status = write16(state, SCU_RAM_QAM_FSM_RATE_LIM__A, 40);
5206         if (status < 0)
5207                 goto error;
5208         status = write16(state, SCU_RAM_QAM_FSM_COUNT_LIM__A, 4);
5209         if (status < 0)
5210                 goto error;
5211         status = write16(state, SCU_RAM_QAM_FSM_FREQ_LIM__A, 12);
5212         if (status < 0)
5213                 goto error;
5214
5215
5216         /* QAM FSM Tracking Parameters */
5217
5218         status = write16(state, SCU_RAM_QAM_FSM_MEDIAN_AV_MULT__A, (u16) 8);
5219         if (status < 0)
5220                 goto error;
5221         status = write16(state, SCU_RAM_QAM_FSM_RADIUS_AV_LIMIT__A, (u16) 74);
5222         if (status < 0)
5223                 goto error;
5224         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET1__A, (u16) 18);
5225         if (status < 0)
5226                 goto error;
5227         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET2__A, (u16) 13);
5228         if (status < 0)
5229                 goto error;
5230         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET3__A, (u16) 7);
5231         if (status < 0)
5232                 goto error;
5233         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET4__A, (u16) 0);
5234         if (status < 0)
5235                 goto error;
5236         status = write16(state, SCU_RAM_QAM_FSM_LCAVG_OFFSET5__A, (u16) -8);
5237 error:
5238         if (status < 0)
5239                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5240         return status;
5241 }
5242
5243
5244 /*============================================================================*/
5245 /**
5246 * \brief Reset QAM block.
5247 * \param demod:   instance of demod.
5248 * \param channel: pointer to channel data.
5249 * \return DRXStatus_t.
5250 */
5251 static int QAMResetQAM(struct drxk_state *state)
5252 {
5253         int status;
5254         u16 cmdResult;
5255
5256         dprintk(1, "\n");
5257         /* Stop QAM comstate->m_exec */
5258         status = write16(state, QAM_COMM_EXEC__A, QAM_COMM_EXEC_STOP);
5259         if (status < 0)
5260                 goto error;
5261
5262         status = scu_command(state, SCU_RAM_COMMAND_STANDARD_QAM | SCU_RAM_COMMAND_CMD_DEMOD_RESET, 0, NULL, 1, &cmdResult);
5263 error:
5264         if (status < 0)
5265                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5266         return status;
5267 }
5268
5269 /*============================================================================*/
5270
5271 /**
5272 * \brief Set QAM symbolrate.
5273 * \param demod:   instance of demod.
5274 * \param channel: pointer to channel data.
5275 * \return DRXStatus_t.
5276 */
5277 static int QAMSetSymbolrate(struct drxk_state *state)
5278 {
5279         u32 adcFrequency = 0;
5280         u32 symbFreq = 0;
5281         u32 iqmRcRate = 0;
5282         u16 ratesel = 0;
5283         u32 lcSymbRate = 0;
5284         int status;
5285
5286         dprintk(1, "\n");
5287         /* Select & calculate correct IQM rate */
5288         adcFrequency = (state->m_sysClockFreq * 1000) / 3;
5289         ratesel = 0;
5290         /* printk(KERN_DEBUG "drxk: SR %d\n", state->props.symbol_rate); */
5291         if (state->props.symbol_rate <= 1188750)
5292                 ratesel = 3;
5293         else if (state->props.symbol_rate <= 2377500)
5294                 ratesel = 2;
5295         else if (state->props.symbol_rate <= 4755000)
5296                 ratesel = 1;
5297         status = write16(state, IQM_FD_RATESEL__A, ratesel);
5298         if (status < 0)
5299                 goto error;
5300
5301         /*
5302                 IqmRcRate = ((Fadc / (symbolrate * (4<<ratesel))) - 1) * (1<<23)
5303                 */
5304         symbFreq = state->props.symbol_rate * (1 << ratesel);
5305         if (symbFreq == 0) {
5306                 /* Divide by zero */
5307                 status = -EINVAL;
5308                 goto error;
5309         }
5310         iqmRcRate = (adcFrequency / symbFreq) * (1 << 21) +
5311                 (Frac28a((adcFrequency % symbFreq), symbFreq) >> 7) -
5312                 (1 << 23);
5313         status = write32(state, IQM_RC_RATE_OFS_LO__A, iqmRcRate);
5314         if (status < 0)
5315                 goto error;
5316         state->m_iqmRcRate = iqmRcRate;
5317         /*
5318                 LcSymbFreq = round (.125 *  symbolrate / adcFreq * (1<<15))
5319                 */
5320         symbFreq = state->props.symbol_rate;
5321         if (adcFrequency == 0) {
5322                 /* Divide by zero */
5323                 status = -EINVAL;
5324                 goto error;
5325         }
5326         lcSymbRate = (symbFreq / adcFrequency) * (1 << 12) +
5327                 (Frac28a((symbFreq % adcFrequency), adcFrequency) >>
5328                 16);
5329         if (lcSymbRate > 511)
5330                 lcSymbRate = 511;
5331         status = write16(state, QAM_LC_SYMBOL_FREQ__A, (u16) lcSymbRate);
5332
5333 error:
5334         if (status < 0)
5335                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5336         return status;
5337 }
5338
5339 /*============================================================================*/
5340
5341 /**
5342 * \brief Get QAM lock status.
5343 * \param demod:   instance of demod.
5344 * \param channel: pointer to channel data.
5345 * \return DRXStatus_t.
5346 */
5347
5348 static int GetQAMLockStatus(struct drxk_state *state, u32 *pLockStatus)
5349 {
5350         int status;
5351         u16 Result[2] = { 0, 0 };
5352
5353         dprintk(1, "\n");
5354         *pLockStatus = NOT_LOCKED;
5355         status = scu_command(state,
5356                         SCU_RAM_COMMAND_STANDARD_QAM |
5357                         SCU_RAM_COMMAND_CMD_DEMOD_GET_LOCK, 0, NULL, 2,
5358                         Result);
5359         if (status < 0)
5360                 printk(KERN_ERR "drxk: %s status = %08x\n", __func__, status);
5361
5362         if (Result[1] < SCU_RAM_QAM_LOCKED_LOCKED_DEMOD_LOCKED) {
5363                 /* 0x0000 NOT LOCKED */
5364         } else if (Result[1] < SCU_RAM_QAM_LOCKED_LOCKED_LOCKED) {
5365                 /* 0x4000 DEMOD LOCKED */
5366                 *pLockStatus = DEMOD_LOCK;
5367         } else if (Result[1] < SCU_RAM_QAM_LOCKED_LOCKED_NEVER_LOCK) {
5368                 /* 0x8000 DEMOD + FEC LOCKED (system lock) */
5369                 *pLockStatus = MPEG_LOCK;
5370         } else {
5371                 /* 0xC000 NEVER LOCKED */
5372                 /* (system will never be able to lock to the signal) */
5373                 /* TODO: check this, intermediate & standard specific lock states are not
5374                    taken into account here */
5375                 *pLockStatus = NEVER_LOCK;
5376         }
5377         return status;
5378 }
5379
5380 #define QAM_MIRROR__M         0x03
5381 #define QAM_MIRROR_NORMAL     0x00
5382 #define QAM_MIRRORED          0x01
5383 #define QAM_MIRROR_AUTO_ON    0x02
5384 #define QAM_LOCKRANGE__M      0x10
5385 #define QAM_LOCKRANGE_NORMAL  0x10
5386
5387 static int SetQAM(struct drxk_state *state, u16 IntermediateFreqkHz,
5388                   s32 tunerFreqOffset)
5389 {
5390         int status;
5391         u16 setParamParameters[4] = { 0, 0, 0, 0 };
5392         u16 cmdResult;
5393
5394         dprintk(1, "\n");
5395         /*
5396          * STEP 1: reset demodulator
5397          *      resets FEC DI and FEC RS
5398          *      resets QAM block
5399          *      resets SCU variables
5400          */
5401         status = write16(state, FEC_DI_COMM_EXEC__A, FEC_DI_COMM_EXEC_STOP);
5402         if (status < 0)
5403                 goto error;
5404         status = write16(state, FEC_RS_COMM_EXEC__A, FEC_RS_COMM_EXEC_STOP);
5405         if (status < 0)
5406                 goto error;
5407         status = QAMResetQAM(state);
5408         if (status < 0)
5409                 goto error;
5410
5411         /*
5412          * STEP 2: configure demodulator
5413          *      -set params; resets IQM,QAM,FEC HW; initializes some
5414          *       SCU variables
5415          */
5416         status = QAMSetSymbolrate(state);
5417         if (status < 0)
5418                 goto error;
5419
5420         /* Set params */
5421         switch (state->props.modulation) {
5422         case QAM_256:
5423                 state->m_Constellation = DRX_CONSTELLATION_QAM256;
5424                 break;
5425         case QAM_AUTO:
5426         case QAM_64:
5427                 state->m_Constellation = DRX_CONSTELLATION_QAM64;
5428                 break;
5429         case QAM_16:
5430                 state->m_Constellation = DRX_CONSTELLATION_QAM16;
5431                 break;
5432         case QAM_32:
5433                 state->m_Constellation = DRX_CONSTELLATION_QAM32;
5434                 break;
5435         case QAM_128:
5436                 state->m_Constellation = DRX_CONSTELLATION_QAM128;
5437                 break;
5438         default:
5439                 status = -EINVAL;
5440                 break;
5441         }
5442         if (status < 0)
5443                 goto error;
5444         setParamParameters[0] = state->m_Constellation; /* modulation     */
5445         setParamParameters[1] = DRXK_QAM_I12_J17;       /* interleave mode   */
5446         if (state->m_OperationMode == OM_QAM_ITU_C)
5447                 setParamParameters[2] = QAM_TOP_ANNEX_C;
5448         else
5449                 setParamParameters[2] = QAM_TOP_ANNEX_A;
5450         setParamParameters[3] |= (QAM_MIRROR_AUTO_ON);
5451         /* Env parameters */
5452         /* check for LOCKRANGE Extented */
5453         /* setParamParameters[3] |= QAM_LOCKRANGE_NORMAL; */
5454
5455         status = scu_command(state, SCU_RAM_COMMAND_STANDARD_QAM | SCU_RAM_COMMAND_CMD_DEMOD_SET_PARAM, 4, setParamParameters, 1, &cmdResult);
5456         if (status < 0) {
5457                 /* Fall-back to the simpler call */
5458                 if (state->m_OperationMode == OM_QAM_ITU_C)
5459                         setParamParameters[0] = QAM_TOP_ANNEX_C;
5460                 else
5461                         setParamParameters[0] = QAM_TOP_ANNEX_A;
5462                 status = scu_command(state, SCU_RAM_COMMAND_STANDARD_QAM | SCU_RAM_COMMAND_CMD_DEMOD_SET_ENV, 1, setParamParameters, 1, &cmdResult);
5463                 if (status < 0)
5464                         goto error;
5465
5466                 setParamParameters[0] = state->m_Constellation; /* modulation     */
5467                 setParamParameters[1] = DRXK_QAM_I12_J17;       /* interleave mode   */
5468                 status = scu_command(state, SCU_RAM_COMMAND_STANDARD_QAM | SCU_RAM_COMMAND_CMD_DEMOD_SET_PARAM, 2, setParamParameters, 1, &cmdResult);
5469         }
5470         if (status < 0)
5471                 goto error;
5472
5473         /*
5474          * STEP 3: enable the system in a mode where the ADC provides valid
5475          * signal setup modulation independent registers
5476          */
5477 #if 0
5478         status = SetFrequency(channel, tunerFreqOffset));
5479         if (status < 0)
5480                 goto error;
5481 #endif
5482         status = SetFrequencyShifter(state, IntermediateFreqkHz, tunerFreqOffset, true);
5483         if (status < 0)
5484                 goto error;
5485
5486         /* Setup BER measurement */
5487         status = SetQAMMeasurement(state, state->m_Constellation, state->props.symbol_rate);
5488         if (status < 0)
5489                 goto error;
5490
5491         /* Reset default values */
5492         status = write16(state, IQM_CF_SCALE_SH__A, IQM_CF_SCALE_SH__PRE);
5493         if (status < 0)
5494                 goto error;
5495         status = write16(state, QAM_SY_TIMEOUT__A, QAM_SY_TIMEOUT__PRE);
5496         if (status < 0)
5497                 goto error;
5498
5499         /* Reset default LC values */
5500         status = write16(state, QAM_LC_RATE_LIMIT__A, 3);
5501         if (status < 0)
5502                 goto error;
5503         status = write16(state, QAM_LC_LPF_FACTORP__A, 4);
5504         if (status < 0)
5505                 goto error;
5506         status = write16(state, QAM_LC_LPF_FACTORI__A, 4);
5507         if (status < 0)
5508                 goto error;
5509         status = write16(state, QAM_LC_MODE__A, 7);
5510         if (status < 0)
5511                 goto error;
5512
5513         status = write16(state, QAM_LC_QUAL_TAB0__A, 1);
5514         if (status < 0)
5515                 goto error;
5516         status = write16(state, QAM_LC_QUAL_TAB1__A, 1);
5517         if (status < 0)
5518                 goto error;
5519         status = write16(state, QAM_LC_QUAL_TAB2__A, 1);
5520         if (status < 0)
5521                 goto error;
5522         status = write16(state, QAM_LC_QUAL_TAB3__A, 1);
5523         if (status < 0)
5524                 goto error;
5525         status = write16(state, QAM_LC_QUAL_TAB4__A, 2);
5526         if (status < 0)
5527                 goto error;
5528         status = write16(state, QAM_LC_QUAL_TAB5__A, 2);
5529         if (status < 0)
5530                 goto error;
5531         status = write16(state, QAM_LC_QUAL_TAB6__A, 2);
5532         if (status < 0)
5533                 goto error;
5534         status = write16(state, QAM_LC_QUAL_TAB8__A, 2);
5535         if (status < 0)
5536                 goto error;
5537         status = write16(state, QAM_LC_QUAL_TAB9__A, 2);
5538         if (status < 0)
5539                 goto error;
5540         status = write16(state, QAM_LC_QUAL_TAB10__A, 2);
5541         if (status < 0)
5542                 goto error;
5543         status = write16(state, QAM_LC_QUAL_TAB12__A, 2);
5544         if (status < 0)
5545                 goto error;
5546         status = write16(state, QAM_LC_QUAL_TAB15__A, 3);
5547         if (status < 0)
5548                 goto error;
5549         status = write16(state, QAM_LC_QUAL_TAB16__A, 3);
5550         if (status < 0)
5551                 goto error;
5552         status = write16(state, QAM_LC_QUAL_TAB20__A, 4);
5553         if (status < 0)
5554                 goto error;
5555         status = write16(state, QAM_LC_QUAL_TAB25__A, 4);
5556         if (status < 0)
5557                 goto error;
5558
5559         /* Mirroring, QAM-block starting point not inverted */
5560         status = write16(state, QAM_SY_SP_INV__A, QAM_SY_SP_INV_SPECTRUM_INV_DIS);
5561         if (status < 0)
5562                 goto error;
5563
5564         /* Halt SCU to enable safe non-atomic accesses */
5565         status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_HOLD);
5566         if (status < 0)
5567                 goto error;
5568
5569         /* STEP 4: modulation specific setup */
5570         switch (state->props.modulation) {
5571         case QAM_16:
5572                 status = SetQAM16(state);
5573                 break;
5574         case QAM_32:
5575                 status = SetQAM32(state);
5576                 break;
5577         case QAM_AUTO:
5578         case QAM_64:
5579                 status = SetQAM64(state);
5580                 break;
5581         case QAM_128:
5582                 status = SetQAM128(state);
5583                 break;
5584         case QAM_256:
5585                 status = SetQAM256(state);
5586                 break;
5587         default:
5588                 status = -EINVAL;
5589                 break;
5590         }
5591         if (status < 0)
5592                 goto error;
5593
5594         /* Activate SCU to enable SCU commands */
5595         status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_ACTIVE);
5596         if (status < 0)
5597                 goto error;
5598
5599         /* Re-configure MPEG output, requires knowledge of channel bitrate */
5600         /* extAttr->currentChannel.modulation = channel->modulation; */
5601         /* extAttr->currentChannel.symbolrate    = channel->symbolrate; */
5602         status = MPEGTSDtoSetup(state, state->m_OperationMode);
5603         if (status < 0)
5604                 goto error;
5605
5606         /* Start processes */
5607         status = MPEGTSStart(state);
5608         if (status < 0)
5609                 goto error;
5610         status = write16(state, FEC_COMM_EXEC__A, FEC_COMM_EXEC_ACTIVE);
5611         if (status < 0)
5612                 goto error;
5613         status = write16(state, QAM_COMM_EXEC__A, QAM_COMM_EXEC_ACTIVE);
5614         if (status < 0)
5615                 goto error;
5616         status = write16(state, IQM_COMM_EXEC__A, IQM_COMM_EXEC_B_ACTIVE);
5617         if (status < 0)
5618                 goto error;
5619
5620         /* STEP 5: start QAM demodulator (starts FEC, QAM and IQM HW) */
5621         status = scu_command(state, SCU_RAM_COMMAND_STANDARD_QAM | SCU_RAM_COMMAND_CMD_DEMOD_START, 0, NULL, 1, &cmdResult);
5622         if (status < 0)
5623                 goto error;
5624
5625         /* update global DRXK data container */
5626 /*?     extAttr->qamInterleaveMode = DRXK_QAM_I12_J17; */
5627
5628 error:
5629         if (status < 0)
5630                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5631         return status;
5632 }
5633
5634 static int SetQAMStandard(struct drxk_state *state,
5635                           enum OperationMode oMode)
5636 {
5637         int status;
5638 #ifdef DRXK_QAM_TAPS
5639 #define DRXK_QAMA_TAPS_SELECT
5640 #include "drxk_filters.h"
5641 #undef DRXK_QAMA_TAPS_SELECT
5642 #endif
5643
5644         dprintk(1, "\n");
5645
5646         /* added antenna switch */
5647         SwitchAntennaToQAM(state);
5648
5649         /* Ensure correct power-up mode */
5650         status = PowerUpQAM(state);
5651         if (status < 0)
5652                 goto error;
5653         /* Reset QAM block */
5654         status = QAMResetQAM(state);
5655         if (status < 0)
5656                 goto error;
5657
5658         /* Setup IQM */
5659
5660         status = write16(state, IQM_COMM_EXEC__A, IQM_COMM_EXEC_B_STOP);
5661         if (status < 0)
5662                 goto error;
5663         status = write16(state, IQM_AF_AMUX__A, IQM_AF_AMUX_SIGNAL2ADC);
5664         if (status < 0)
5665                 goto error;
5666
5667         /* Upload IQM Channel Filter settings by
5668                 boot loader from ROM table */
5669         switch (oMode) {
5670         case OM_QAM_ITU_A:
5671                 status = BLChainCmd(state, DRXK_BL_ROM_OFFSET_TAPS_ITU_A, DRXK_BLCC_NR_ELEMENTS_TAPS, DRXK_BLC_TIMEOUT);
5672                 break;
5673         case OM_QAM_ITU_C:
5674                 status = BLDirectCmd(state, IQM_CF_TAP_RE0__A, DRXK_BL_ROM_OFFSET_TAPS_ITU_C, DRXK_BLDC_NR_ELEMENTS_TAPS, DRXK_BLC_TIMEOUT);
5675                 if (status < 0)
5676                         goto error;
5677                 status = BLDirectCmd(state, IQM_CF_TAP_IM0__A, DRXK_BL_ROM_OFFSET_TAPS_ITU_C, DRXK_BLDC_NR_ELEMENTS_TAPS, DRXK_BLC_TIMEOUT);
5678                 break;
5679         default:
5680                 status = -EINVAL;
5681         }
5682         if (status < 0)
5683                 goto error;
5684
5685         status = write16(state, IQM_CF_OUT_ENA__A, (1 << IQM_CF_OUT_ENA_QAM__B));
5686         if (status < 0)
5687                 goto error;
5688         status = write16(state, IQM_CF_SYMMETRIC__A, 0);
5689         if (status < 0)
5690                 goto error;
5691         status = write16(state, IQM_CF_MIDTAP__A, ((1 << IQM_CF_MIDTAP_RE__B) | (1 << IQM_CF_MIDTAP_IM__B)));
5692         if (status < 0)
5693                 goto error;
5694
5695         status = write16(state, IQM_RC_STRETCH__A, 21);
5696         if (status < 0)
5697                 goto error;
5698         status = write16(state, IQM_AF_CLP_LEN__A, 0);
5699         if (status < 0)
5700                 goto error;
5701         status = write16(state, IQM_AF_CLP_TH__A, 448);
5702         if (status < 0)
5703                 goto error;
5704         status = write16(state, IQM_AF_SNS_LEN__A, 0);
5705         if (status < 0)
5706                 goto error;
5707         status = write16(state, IQM_CF_POW_MEAS_LEN__A, 0);
5708         if (status < 0)
5709                 goto error;
5710
5711         status = write16(state, IQM_FS_ADJ_SEL__A, 1);
5712         if (status < 0)
5713                 goto error;
5714         status = write16(state, IQM_RC_ADJ_SEL__A, 1);
5715         if (status < 0)
5716                 goto error;
5717         status = write16(state, IQM_CF_ADJ_SEL__A, 1);
5718         if (status < 0)
5719                 goto error;
5720         status = write16(state, IQM_AF_UPD_SEL__A, 0);
5721         if (status < 0)
5722                 goto error;
5723
5724         /* IQM Impulse Noise Processing Unit */
5725         status = write16(state, IQM_CF_CLP_VAL__A, 500);
5726         if (status < 0)
5727                 goto error;
5728         status = write16(state, IQM_CF_DATATH__A, 1000);
5729         if (status < 0)
5730                 goto error;
5731         status = write16(state, IQM_CF_BYPASSDET__A, 1);
5732         if (status < 0)
5733                 goto error;
5734         status = write16(state, IQM_CF_DET_LCT__A, 0);
5735         if (status < 0)
5736                 goto error;
5737         status = write16(state, IQM_CF_WND_LEN__A, 1);
5738         if (status < 0)
5739                 goto error;
5740         status = write16(state, IQM_CF_PKDTH__A, 1);
5741         if (status < 0)
5742                 goto error;
5743         status = write16(state, IQM_AF_INC_BYPASS__A, 1);
5744         if (status < 0)
5745                 goto error;
5746
5747         /* turn on IQMAF. Must be done before setAgc**() */
5748         status = SetIqmAf(state, true);
5749         if (status < 0)
5750                 goto error;
5751         status = write16(state, IQM_AF_START_LOCK__A, 0x01);
5752         if (status < 0)
5753                 goto error;
5754
5755         /* IQM will not be reset from here, sync ADC and update/init AGC */
5756         status = ADCSynchronization(state);
5757         if (status < 0)
5758                 goto error;
5759
5760         /* Set the FSM step period */
5761         status = write16(state, SCU_RAM_QAM_FSM_STEP_PERIOD__A, 2000);
5762         if (status < 0)
5763                 goto error;
5764
5765         /* Halt SCU to enable safe non-atomic accesses */
5766         status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_HOLD);
5767         if (status < 0)
5768                 goto error;
5769
5770         /* No more resets of the IQM, current standard correctly set =>
5771                 now AGCs can be configured. */
5772
5773         status = InitAGC(state, true);
5774         if (status < 0)
5775                 goto error;
5776         status = SetPreSaw(state, &(state->m_qamPreSawCfg));
5777         if (status < 0)
5778                 goto error;
5779
5780         /* Configure AGC's */
5781         status = SetAgcRf(state, &(state->m_qamRfAgcCfg), true);
5782         if (status < 0)
5783                 goto error;
5784         status = SetAgcIf(state, &(state->m_qamIfAgcCfg), true);
5785         if (status < 0)
5786                 goto error;
5787
5788         /* Activate SCU to enable SCU commands */
5789         status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_ACTIVE);
5790 error:
5791         if (status < 0)
5792                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5793         return status;
5794 }
5795
5796 static int WriteGPIO(struct drxk_state *state)
5797 {
5798         int status;
5799         u16 value = 0;
5800
5801         dprintk(1, "\n");
5802         /* stop lock indicator process */
5803         status = write16(state, SCU_RAM_GPIO__A, SCU_RAM_GPIO_HW_LOCK_IND_DISABLE);
5804         if (status < 0)
5805                 goto error;
5806
5807         /*  Write magic word to enable pdr reg write               */
5808         status = write16(state, SIO_TOP_COMM_KEY__A, SIO_TOP_COMM_KEY_KEY);
5809         if (status < 0)
5810                 goto error;
5811
5812         if (state->m_hasSAWSW) {
5813                 if (state->UIO_mask & 0x0001) { /* UIO-1 */
5814                         /* write to io pad configuration register - output mode */
5815                         status = write16(state, SIO_PDR_SMA_TX_CFG__A, state->m_GPIOCfg);
5816                         if (status < 0)
5817                                 goto error;
5818
5819                         /* use corresponding bit in io data output registar */
5820                         status = read16(state, SIO_PDR_UIO_OUT_LO__A, &value);
5821                         if (status < 0)
5822                                 goto error;
5823                         if ((state->m_GPIO & 0x0001) == 0)
5824                                 value &= 0x7FFF;        /* write zero to 15th bit - 1st UIO */
5825                         else
5826                                 value |= 0x8000;        /* write one to 15th bit - 1st UIO */
5827                         /* write back to io data output register */
5828                         status = write16(state, SIO_PDR_UIO_OUT_LO__A, value);
5829                         if (status < 0)
5830                                 goto error;
5831                 }
5832                 if (state->UIO_mask & 0x0002) { /* UIO-2 */
5833                         /* write to io pad configuration register - output mode */
5834                         status = write16(state, SIO_PDR_SMA_TX_CFG__A, state->m_GPIOCfg);
5835                         if (status < 0)
5836                                 goto error;
5837
5838                         /* use corresponding bit in io data output registar */
5839                         status = read16(state, SIO_PDR_UIO_OUT_LO__A, &value);
5840                         if (status < 0)
5841                                 goto error;
5842                         if ((state->m_GPIO & 0x0002) == 0)
5843                                 value &= 0xBFFF;        /* write zero to 14th bit - 2st UIO */
5844                         else
5845                                 value |= 0x4000;        /* write one to 14th bit - 2st UIO */
5846                         /* write back to io data output register */
5847                         status = write16(state, SIO_PDR_UIO_OUT_LO__A, value);
5848                         if (status < 0)
5849                                 goto error;
5850                 }
5851                 if (state->UIO_mask & 0x0004) { /* UIO-3 */
5852                         /* write to io pad configuration register - output mode */
5853                         status = write16(state, SIO_PDR_SMA_TX_CFG__A, state->m_GPIOCfg);
5854                         if (status < 0)
5855                                 goto error;
5856
5857                         /* use corresponding bit in io data output registar */
5858                         status = read16(state, SIO_PDR_UIO_OUT_LO__A, &value);
5859                         if (status < 0)
5860                                 goto error;
5861                         if ((state->m_GPIO & 0x0004) == 0)
5862                                 value &= 0xFFFB;            /* write zero to 2nd bit - 3rd UIO */
5863                         else
5864                                 value |= 0x0004;            /* write one to 2nd bit - 3rd UIO */
5865                         /* write back to io data output register */
5866                         status = write16(state, SIO_PDR_UIO_OUT_LO__A, value);
5867                         if (status < 0)
5868                                 goto error;
5869                 }
5870         }
5871         /*  Write magic word to disable pdr reg write               */
5872         status = write16(state, SIO_TOP_COMM_KEY__A, 0x0000);
5873 error:
5874         if (status < 0)
5875                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5876         return status;
5877 }
5878
5879 static int SwitchAntennaToQAM(struct drxk_state *state)
5880 {
5881         int status = 0;
5882         bool gpio_state;
5883
5884         dprintk(1, "\n");
5885
5886         if (!state->antenna_gpio)
5887                 return 0;
5888
5889         gpio_state = state->m_GPIO & state->antenna_gpio;
5890
5891         if (state->antenna_dvbt ^ gpio_state) {
5892                 /* Antenna is on DVB-T mode. Switch */
5893                 if (state->antenna_dvbt)
5894                         state->m_GPIO &= ~state->antenna_gpio;
5895                 else
5896                         state->m_GPIO |= state->antenna_gpio;
5897                 status = WriteGPIO(state);
5898         }
5899         if (status < 0)
5900                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5901         return status;
5902 }
5903
5904 static int SwitchAntennaToDVBT(struct drxk_state *state)
5905 {
5906         int status = 0;
5907         bool gpio_state;
5908
5909         dprintk(1, "\n");
5910
5911         if (!state->antenna_gpio)
5912                 return 0;
5913
5914         gpio_state = state->m_GPIO & state->antenna_gpio;
5915
5916         if (!(state->antenna_dvbt ^ gpio_state)) {
5917                 /* Antenna is on DVB-C mode. Switch */
5918                 if (state->antenna_dvbt)
5919                         state->m_GPIO |= state->antenna_gpio;
5920                 else
5921                         state->m_GPIO &= ~state->antenna_gpio;
5922                 status = WriteGPIO(state);
5923         }
5924         if (status < 0)
5925                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5926         return status;
5927 }
5928
5929
5930 static int PowerDownDevice(struct drxk_state *state)
5931 {
5932         /* Power down to requested mode */
5933         /* Backup some register settings */
5934         /* Set pins with possible pull-ups connected to them in input mode */
5935         /* Analog power down */
5936         /* ADC power down */
5937         /* Power down device */
5938         int status;
5939
5940         dprintk(1, "\n");
5941         if (state->m_bPDownOpenBridge) {
5942                 /* Open I2C bridge before power down of DRXK */
5943                 status = ConfigureI2CBridge(state, true);
5944                 if (status < 0)
5945                         goto error;
5946         }
5947         /* driver 0.9.0 */
5948         status = DVBTEnableOFDMTokenRing(state, false);
5949         if (status < 0)
5950                 goto error;
5951
5952         status = write16(state, SIO_CC_PWD_MODE__A, SIO_CC_PWD_MODE_LEVEL_CLOCK);
5953         if (status < 0)
5954                 goto error;
5955         status = write16(state, SIO_CC_UPDATE__A, SIO_CC_UPDATE_KEY);
5956         if (status < 0)
5957                 goto error;
5958         state->m_HICfgCtrl |= SIO_HI_RA_RAM_PAR_5_CFG_SLEEP_ZZZ;
5959         status = HI_CfgCommand(state);
5960 error:
5961         if (status < 0)
5962                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
5963
5964         return status;
5965 }
5966
5967 static int load_microcode(struct drxk_state *state, const char *mc_name)
5968 {
5969         const struct firmware *fw = NULL;
5970         int err = 0;
5971
5972         dprintk(1, "\n");
5973
5974         err = request_firmware(&fw, mc_name, state->i2c->dev.parent);
5975         if (err < 0) {
5976                 printk(KERN_ERR
5977                        "drxk: Could not load firmware file %s.\n", mc_name);
5978                 printk(KERN_INFO
5979                        "drxk: Copy %s to your hotplug directory!\n", mc_name);
5980                 return err;
5981         }
5982         err = DownloadMicrocode(state, fw->data, fw->size);
5983         release_firmware(fw);
5984         return err;
5985 }
5986
5987 static int init_drxk(struct drxk_state *state)
5988 {
5989         int status = 0;
5990         enum DRXPowerMode powerMode = DRXK_POWER_DOWN_OFDM;
5991         u16 driverVersion;
5992
5993         dprintk(1, "\n");
5994         if ((state->m_DrxkState == DRXK_UNINITIALIZED)) {
5995                 status = PowerUpDevice(state);
5996                 if (status < 0)
5997                         goto error;
5998                 status = DRXX_Open(state);
5999                 if (status < 0)
6000                         goto error;
6001                 /* Soft reset of OFDM-, sys- and osc-clockdomain */
6002                 status = write16(state, SIO_CC_SOFT_RST__A, SIO_CC_SOFT_RST_OFDM__M | SIO_CC_SOFT_RST_SYS__M | SIO_CC_SOFT_RST_OSC__M);
6003                 if (status < 0)
6004                         goto error;
6005                 status = write16(state, SIO_CC_UPDATE__A, SIO_CC_UPDATE_KEY);
6006                 if (status < 0)
6007                         goto error;
6008                 /* TODO is this needed, if yes how much delay in worst case scenario */
6009                 msleep(1);
6010                 state->m_DRXK_A3_PATCH_CODE = true;
6011                 status = GetDeviceCapabilities(state);
6012                 if (status < 0)
6013                         goto error;
6014
6015                 /* Bridge delay, uses oscilator clock */
6016                 /* Delay = (delay (nano seconds) * oscclk (kHz))/ 1000 */
6017                 /* SDA brdige delay */
6018                 state->m_HICfgBridgeDelay =
6019                         (u16) ((state->m_oscClockFreq / 1000) *
6020                                 HI_I2C_BRIDGE_DELAY) / 1000;
6021                 /* Clipping */
6022                 if (state->m_HICfgBridgeDelay >
6023                         SIO_HI_RA_RAM_PAR_3_CFG_DBL_SDA__M) {
6024                         state->m_HICfgBridgeDelay =
6025                                 SIO_HI_RA_RAM_PAR_3_CFG_DBL_SDA__M;
6026                 }
6027                 /* SCL bridge delay, same as SDA for now */
6028                 state->m_HICfgBridgeDelay +=
6029                         state->m_HICfgBridgeDelay <<
6030                         SIO_HI_RA_RAM_PAR_3_CFG_DBL_SCL__B;
6031
6032                 status = InitHI(state);
6033                 if (status < 0)
6034                         goto error;
6035                 /* disable various processes */
6036 #if NOA1ROM
6037                 if (!(state->m_DRXK_A1_ROM_CODE)
6038                         && !(state->m_DRXK_A2_ROM_CODE))
6039 #endif
6040                 {
6041                         status = write16(state, SCU_RAM_GPIO__A, SCU_RAM_GPIO_HW_LOCK_IND_DISABLE);
6042                         if (status < 0)
6043                                 goto error;
6044                 }
6045
6046                 /* disable MPEG port */
6047                 status = MPEGTSDisable(state);
6048                 if (status < 0)
6049                         goto error;
6050
6051                 /* Stop AUD and SCU */
6052                 status = write16(state, AUD_COMM_EXEC__A, AUD_COMM_EXEC_STOP);
6053                 if (status < 0)
6054                         goto error;
6055                 status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_STOP);
6056                 if (status < 0)
6057                         goto error;
6058
6059                 /* enable token-ring bus through OFDM block for possible ucode upload */
6060                 status = write16(state, SIO_OFDM_SH_OFDM_RING_ENABLE__A, SIO_OFDM_SH_OFDM_RING_ENABLE_ON);
6061                 if (status < 0)
6062                         goto error;
6063
6064                 /* include boot loader section */
6065                 status = write16(state, SIO_BL_COMM_EXEC__A, SIO_BL_COMM_EXEC_ACTIVE);
6066                 if (status < 0)
6067                         goto error;
6068                 status = BLChainCmd(state, 0, 6, 100);
6069                 if (status < 0)
6070                         goto error;
6071
6072                 if (!state->microcode_name)
6073                         load_microcode(state, "drxk_a3.mc");
6074                 else
6075                         load_microcode(state, state->microcode_name);
6076
6077                 /* disable token-ring bus through OFDM block for possible ucode upload */
6078                 status = write16(state, SIO_OFDM_SH_OFDM_RING_ENABLE__A, SIO_OFDM_SH_OFDM_RING_ENABLE_OFF);
6079                 if (status < 0)
6080                         goto error;
6081
6082                 /* Run SCU for a little while to initialize microcode version numbers */
6083                 status = write16(state, SCU_COMM_EXEC__A, SCU_COMM_EXEC_ACTIVE);
6084                 if (status < 0)
6085                         goto error;
6086                 status = DRXX_Open(state);
6087                 if (status < 0)
6088                         goto error;
6089                 /* added for test */
6090                 msleep(30);
6091
6092                 powerMode = DRXK_POWER_DOWN_OFDM;
6093                 status = CtrlPowerMode(state, &powerMode);
6094                 if (status < 0)
6095                         goto error;
6096
6097                 /* Stamp driver version number in SCU data RAM in BCD code
6098                         Done to enable field application engineers to retreive drxdriver version
6099                         via I2C from SCU RAM.
6100                         Not using SCU command interface for SCU register access since no
6101                         microcode may be present.
6102                         */
6103                 driverVersion =
6104                         (((DRXK_VERSION_MAJOR / 100) % 10) << 12) +
6105                         (((DRXK_VERSION_MAJOR / 10) % 10) << 8) +
6106                         ((DRXK_VERSION_MAJOR % 10) << 4) +
6107                         (DRXK_VERSION_MINOR % 10);
6108                 status = write16(state, SCU_RAM_DRIVER_VER_HI__A, driverVersion);
6109                 if (status < 0)
6110                         goto error;
6111                 driverVersion =
6112                         (((DRXK_VERSION_PATCH / 1000) % 10) << 12) +
6113                         (((DRXK_VERSION_PATCH / 100) % 10) << 8) +
6114                         (((DRXK_VERSION_PATCH / 10) % 10) << 4) +
6115                         (DRXK_VERSION_PATCH % 10);
6116                 status = write16(state, SCU_RAM_DRIVER_VER_LO__A, driverVersion);
6117                 if (status < 0)
6118                         goto error;
6119
6120                 printk(KERN_INFO "DRXK driver version %d.%d.%d\n",
6121                         DRXK_VERSION_MAJOR, DRXK_VERSION_MINOR,
6122                         DRXK_VERSION_PATCH);
6123
6124                 /* Dirty fix of default values for ROM/PATCH microcode
6125                         Dirty because this fix makes it impossible to setup suitable values
6126                         before calling DRX_Open. This solution requires changes to RF AGC speed
6127                         to be done via the CTRL function after calling DRX_Open */
6128
6129                 /* m_dvbtRfAgcCfg.speed = 3; */
6130
6131                 /* Reset driver debug flags to 0 */
6132                 status = write16(state, SCU_RAM_DRIVER_DEBUG__A, 0);
6133                 if (status < 0)
6134                         goto error;
6135                 /* driver 0.9.0 */
6136                 /* Setup FEC OC:
6137                         NOTE: No more full FEC resets allowed afterwards!! */
6138                 status = write16(state, FEC_COMM_EXEC__A, FEC_COMM_EXEC_STOP);
6139                 if (status < 0)
6140                         goto error;
6141                 /* MPEGTS functions are still the same */
6142                 status = MPEGTSDtoInit(state);
6143                 if (status < 0)
6144                         goto error;
6145                 status = MPEGTSStop(state);
6146                 if (status < 0)
6147                         goto error;
6148                 status = MPEGTSConfigurePolarity(state);
6149                 if (status < 0)
6150                         goto error;
6151                 status = MPEGTSConfigurePins(state, state->m_enableMPEGOutput);
6152                 if (status < 0)
6153                         goto error;
6154                 /* added: configure GPIO */
6155                 status = WriteGPIO(state);
6156                 if (status < 0)
6157                         goto error;
6158
6159                 state->m_DrxkState = DRXK_STOPPED;
6160
6161                 if (state->m_bPowerDown) {
6162                         status = PowerDownDevice(state);
6163                         if (status < 0)
6164                                 goto error;
6165                         state->m_DrxkState = DRXK_POWERED_DOWN;
6166                 } else
6167                         state->m_DrxkState = DRXK_STOPPED;
6168         }
6169 error:
6170         if (status < 0)
6171                 printk(KERN_ERR "drxk: Error %d on %s\n", status, __func__);
6172
6173         return status;
6174 }
6175
6176 static void drxk_release(struct dvb_frontend *fe)
6177 {
6178         struct drxk_state *state = fe->demodulator_priv;
6179
6180         dprintk(1, "\n");
6181         kfree(state);
6182 }
6183
6184 static int drxk_sleep(struct dvb_frontend *fe)
6185 {
6186         struct drxk_state *state = fe->demodulator_priv;
6187
6188         dprintk(1, "\n");
6189         ShutDown(state);
6190         return 0;
6191 }
6192
6193 static int drxk_gate_ctrl(struct dvb_frontend *fe, int enable)
6194 {
6195         struct drxk_state *state = fe->demodulator_priv;
6196
6197         dprintk(1, "%s\n", enable ? "enable" : "disable");
6198         return ConfigureI2CBridge(state, enable ? true : false);
6199 }
6200
6201 static int drxk_set_parameters(struct dvb_frontend *fe)
6202 {
6203         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
6204         u32 delsys  = p->delivery_system, old_delsys;
6205         struct drxk_state *state = fe->demodulator_priv;
6206         u32 IF;
6207
6208         dprintk(1, "\n");
6209
6210         if (!fe->ops.tuner_ops.get_if_frequency) {
6211                 printk(KERN_ERR
6212                        "drxk: Error: get_if_frequency() not defined at tuner. Can't work without it!\n");
6213                 return -EINVAL;
6214         }
6215
6216         if (fe->ops.i2c_gate_ctrl)
6217                 fe->ops.i2c_gate_ctrl(fe, 1);
6218         if (fe->ops.tuner_ops.set_params)
6219                 fe->ops.tuner_ops.set_params(fe);
6220         if (fe->ops.i2c_gate_ctrl)
6221                 fe->ops.i2c_gate_ctrl(fe, 0);
6222
6223         old_delsys = state->props.delivery_system;
6224         state->props = *p;
6225
6226         if (old_delsys != delsys) {
6227                 ShutDown(state);
6228                 switch (delsys) {
6229                 case SYS_DVBC_ANNEX_A:
6230                 case SYS_DVBC_ANNEX_C:
6231                         if (!state->m_hasDVBC)
6232                                 return -EINVAL;
6233                         state->m_itut_annex_c = (delsys == SYS_DVBC_ANNEX_C) ? true : false;
6234                         if (state->m_itut_annex_c)
6235                                 SetOperationMode(state, OM_QAM_ITU_C);
6236                         else
6237                                 SetOperationMode(state, OM_QAM_ITU_A);
6238                         break;
6239                 case SYS_DVBT:
6240                         if (!state->m_hasDVBT)
6241                                 return -EINVAL;
6242                         SetOperationMode(state, OM_DVBT);
6243                         break;
6244                 default:
6245                         return -EINVAL;
6246                 }
6247         }
6248
6249         fe->ops.tuner_ops.get_if_frequency(fe, &IF);
6250         Start(state, 0, IF);
6251
6252         /* printk(KERN_DEBUG "drxk: %s IF=%d done\n", __func__, IF); */
6253
6254         return 0;
6255 }
6256
6257 static int drxk_read_status(struct dvb_frontend *fe, fe_status_t *status)
6258 {
6259         struct drxk_state *state = fe->demodulator_priv;
6260         u32 stat;
6261
6262         dprintk(1, "\n");
6263         *status = 0;
6264         GetLockStatus(state, &stat, 0);
6265         if (stat == MPEG_LOCK)
6266                 *status |= 0x1f;
6267         if (stat == FEC_LOCK)
6268                 *status |= 0x0f;
6269         if (stat == DEMOD_LOCK)
6270                 *status |= 0x07;
6271         return 0;
6272 }
6273
6274 static int drxk_read_ber(struct dvb_frontend *fe, u32 *ber)
6275 {
6276         dprintk(1, "\n");
6277
6278         *ber = 0;
6279         return 0;
6280 }
6281
6282 static int drxk_read_signal_strength(struct dvb_frontend *fe,
6283                                      u16 *strength)
6284 {
6285         struct drxk_state *state = fe->demodulator_priv;
6286         u32 val = 0;
6287
6288         dprintk(1, "\n");
6289         ReadIFAgc(state, &val);
6290         *strength = val & 0xffff;
6291         return 0;
6292 }
6293
6294 static int drxk_read_snr(struct dvb_frontend *fe, u16 *snr)
6295 {
6296         struct drxk_state *state = fe->demodulator_priv;
6297         s32 snr2;
6298
6299         dprintk(1, "\n");
6300         GetSignalToNoise(state, &snr2);
6301         *snr = snr2 & 0xffff;
6302         return 0;
6303 }
6304
6305 static int drxk_read_ucblocks(struct dvb_frontend *fe, u32 *ucblocks)
6306 {
6307         struct drxk_state *state = fe->demodulator_priv;
6308         u16 err;
6309
6310         dprintk(1, "\n");
6311         DVBTQAMGetAccPktErr(state, &err);
6312         *ucblocks = (u32) err;
6313         return 0;
6314 }
6315
6316 static int drxk_get_tune_settings(struct dvb_frontend *fe, struct dvb_frontend_tune_settings
6317                                     *sets)
6318 {
6319         struct dtv_frontend_properties *p = &fe->dtv_property_cache;
6320
6321         dprintk(1, "\n");
6322         switch (p->delivery_system) {
6323         case SYS_DVBC_ANNEX_A:
6324         case SYS_DVBC_ANNEX_C:
6325                 sets->min_delay_ms = 3000;
6326                 sets->max_drift = 0;
6327                 sets->step_size = 0;
6328                 return 0;
6329         default:
6330                 /*
6331                  * For DVB-T, let it use the default DVB core way, that is:
6332                  *      fepriv->step_size = fe->ops.info.frequency_stepsize * 2
6333                  */
6334                 return -EINVAL;
6335         }
6336 }
6337
6338 static struct dvb_frontend_ops drxk_ops = {
6339         /* .delsys will be filled dynamically */
6340         .info = {
6341                 .name = "DRXK",
6342                 .frequency_min = 47000000,
6343                 .frequency_max = 865000000,
6344                  /* For DVB-C */
6345                 .symbol_rate_min = 870000,
6346                 .symbol_rate_max = 11700000,
6347                 /* For DVB-T */
6348                 .frequency_stepsize = 166667,
6349
6350                 .caps = FE_CAN_QAM_16 | FE_CAN_QAM_32 | FE_CAN_QAM_64 |
6351                         FE_CAN_QAM_128 | FE_CAN_QAM_256 | FE_CAN_FEC_AUTO |
6352                         FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
6353                         FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 | FE_CAN_MUTE_TS |
6354                         FE_CAN_TRANSMISSION_MODE_AUTO | FE_CAN_RECOVER |
6355                         FE_CAN_GUARD_INTERVAL_AUTO | FE_CAN_HIERARCHY_AUTO
6356         },
6357
6358         .release = drxk_release,
6359         .sleep = drxk_sleep,
6360         .i2c_gate_ctrl = drxk_gate_ctrl,
6361
6362         .set_frontend = drxk_set_parameters,
6363         .get_tune_settings = drxk_get_tune_settings,
6364
6365         .read_status = drxk_read_status,
6366         .read_ber = drxk_read_ber,
6367         .read_signal_strength = drxk_read_signal_strength,
6368         .read_snr = drxk_read_snr,
6369         .read_ucblocks = drxk_read_ucblocks,
6370 };
6371
6372 struct dvb_frontend *drxk_attach(const struct drxk_config *config,
6373                                  struct i2c_adapter *i2c)
6374 {
6375         int n;
6376
6377         struct drxk_state *state = NULL;
6378         u8 adr = config->adr;
6379
6380         dprintk(1, "\n");
6381         state = kzalloc(sizeof(struct drxk_state), GFP_KERNEL);
6382         if (!state)
6383                 return NULL;
6384
6385         state->i2c = i2c;
6386         state->demod_address = adr;
6387         state->single_master = config->single_master;
6388         state->microcode_name = config->microcode_name;
6389         state->no_i2c_bridge = config->no_i2c_bridge;
6390         state->antenna_gpio = config->antenna_gpio;
6391         state->antenna_dvbt = config->antenna_dvbt;
6392         state->m_ChunkSize = config->chunk_size;
6393
6394         if (config->parallel_ts)
6395                 state->m_enableParallel = true;
6396         else
6397                 state->m_enableParallel = false;
6398
6399         /* NOTE: as more UIO bits will be used, add them to the mask */
6400         state->UIO_mask = config->antenna_gpio;
6401
6402         /* Default gpio to DVB-C */
6403         if (!state->antenna_dvbt && state->antenna_gpio)
6404                 state->m_GPIO |= state->antenna_gpio;
6405         else
6406                 state->m_GPIO &= ~state->antenna_gpio;
6407
6408         mutex_init(&state->mutex);
6409
6410         memcpy(&state->frontend.ops, &drxk_ops, sizeof(drxk_ops));
6411         state->frontend.demodulator_priv = state;
6412
6413         init_state(state);
6414         if (init_drxk(state) < 0)
6415                 goto error;
6416
6417         /* Initialize the supported delivery systems */
6418         n = 0;
6419         if (state->m_hasDVBC) {
6420                 state->frontend.ops.delsys[n++] = SYS_DVBC_ANNEX_A;
6421                 state->frontend.ops.delsys[n++] = SYS_DVBC_ANNEX_C;
6422                 strlcat(state->frontend.ops.info.name, " DVB-C",
6423                         sizeof(state->frontend.ops.info.name));
6424         }
6425         if (state->m_hasDVBT) {
6426                 state->frontend.ops.delsys[n++] = SYS_DVBT;
6427                 strlcat(state->frontend.ops.info.name, " DVB-T",
6428                         sizeof(state->frontend.ops.info.name));
6429         }
6430
6431         printk(KERN_INFO "drxk: frontend initialized.\n");
6432         return &state->frontend;
6433
6434 error:
6435         printk(KERN_ERR "drxk: not found\n");
6436         kfree(state);
6437         return NULL;
6438 }
6439 EXPORT_SYMBOL(drxk_attach);
6440
6441 MODULE_DESCRIPTION("DRX-K driver");
6442 MODULE_AUTHOR("Ralph Metzler");
6443 MODULE_LICENSE("GPL");